diff --git a/examples/lib.rs b/examples/lib.rs
index 14cfa647..7923782c 100644
--- a/examples/lib.rs
+++ b/examples/lib.rs
@@ -1,4 +1,4 @@
-fn main() -> Result<(), String> {
+fn main() -> Result<(), markdown::message::Message> {
     // Turn on debugging.
     // You can show it with `RUST_LOG=debug cargo run --features log --example lib`
     env_logger::init();
diff --git a/generate/src/main.rs b/generate/src/main.rs
index 3635afbe..fc4e0fb0 100644
--- a/generate/src/main.rs
+++ b/generate/src/main.rs
@@ -72,12 +72,12 @@ async fn commonmark() {
 // > 👉 **Important**: this module is generated by `generate/src/main.rs`.
 // > It is generate from the latest CommonMark website.
 
-use markdown::{{to_html_with_options, CompileOptions, Options}};
+use markdown::{{message, to_html_with_options, CompileOptions, Options}};
 use pretty_assertions::assert_eq;
 
 #[rustfmt::skip]
 #[test]
-fn commonmark() -> Result<(), String> {{
+fn commonmark() -> Result<(), message::Message> {{
     let danger = Options {{
         compile: CompileOptions {{
             allow_dangerous_html: true,
diff --git a/readme.md b/readme.md
index b1a4be74..ceb32940 100644
--- a/readme.md
+++ b/readme.md
@@ -107,7 +107,7 @@ Yields:
 Extensions (in this case GFM):
 
 ```rs
-fn main() -> Result<(), String> {
+fn main() -> Result<(), markdown::message::Message> {
     println!(
         "{}",
         markdown::to_html_with_options(
@@ -135,7 +135,7 @@ Yields:
 Syntax tree ([mdast][]):
 
 ```rs
-fn main() -> Result<(), String> {
+fn main() -> Result<(), markdown::message::Message> {
     println!(
         "{:?}",
         markdown::to_mdast("# Hey, *you*!", &markdown::ParseOptions::default())?
@@ -294,8 +294,8 @@ user-provided markdown opens you up to XSS attacks.
 An aspect related to XSS for security is syntax errors: markdown itself has no
 syntax errors.
 Some syntax extensions (specifically, only MDX) do include syntax errors.
-For that reason, `to_html_with_options` returns `Result<String, String>`, of
-which the error is a simple string indicating where the problem happened, what
+For that reason, `to_html_with_options` returns `Result<String, Message>`, of
+which the error is a struct indicating where the problem happened, what
 occurred, and what was expected instead.
 Make sure to handle your errors when using MDX.
 
diff --git a/src/configuration.rs b/src/configuration.rs
index f080e229..811e556a 100644
--- a/src/configuration.rs
+++ b/src/configuration.rs
@@ -482,7 +482,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html, to_html_with_options, CompileOptions, Options};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `markdown-rs` is safe by default:
     /// assert_eq!(
@@ -526,7 +526,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html, to_html_with_options, CompileOptions, Options};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `markdown-rs` is safe by default:
     /// assert_eq!(
@@ -570,7 +570,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html, to_html_with_options, CompileOptions, LineEnding, Options};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `markdown-rs` uses `\n` by default:
     /// assert_eq!(
@@ -612,7 +612,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, CompileOptions, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `"Footnotes"` is used by default:
     /// assert_eq!(
@@ -657,7 +657,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, CompileOptions, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `"h2"` is used by default:
     /// assert_eq!(
@@ -705,7 +705,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, CompileOptions, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `"class=\"sr-only\""` is used by default:
     /// assert_eq!(
@@ -748,7 +748,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, CompileOptions, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `"Back to content"` is used by default:
     /// assert_eq!(
@@ -804,7 +804,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, CompileOptions, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `"user-content-"` is used by default:
     /// assert_eq!(
@@ -843,7 +843,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, CompileOptions, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // With `gfm_task_list_item_checkable`, generated `<input type="checkbox" />`
     /// // tags do not contain the attribute `disabled=""` and are thus toggleable by
@@ -880,7 +880,7 @@ pub struct CompileOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, CompileOptions, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // With `allow_dangerous_html`, `markdown-rs` passes HTML through untouched:
     /// assert_eq!(
@@ -975,7 +975,7 @@ pub struct ParseOptions {
     ///
     /// ```
     /// use markdown::{to_html, to_html_with_options, Constructs, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `markdown-rs` follows CommonMark by default:
     /// assert_eq!(
@@ -1020,7 +1020,7 @@ pub struct ParseOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, Constructs, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `markdown-rs` supports single tildes by default:
     /// assert_eq!(
@@ -1075,7 +1075,7 @@ pub struct ParseOptions {
     ///
     /// ```
     /// use markdown::{to_html_with_options, Constructs, Options, ParseOptions};
-    /// # fn main() -> Result<(), String> {
+    /// # fn main() -> Result<(), markdown::message::Message> {
     ///
     /// // `markdown-rs` supports single dollars by default:
     /// assert_eq!(
diff --git a/src/construct/content.rs b/src/construct/content.rs
index e29dac9b..2c5d6e54 100644
--- a/src/construct/content.rs
+++ b/src/construct/content.rs
@@ -24,11 +24,12 @@
 //! [paragraph]: crate::construct::paragraph
 
 use crate::event::{Content, Kind, Link, Name};
+use crate::message;
 use crate::resolve::Name as ResolveName;
 use crate::state::{Name as StateName, State};
 use crate::subtokenize::{subtokenize, Subresult};
 use crate::tokenizer::Tokenizer;
-use alloc::{string::String, vec};
+use alloc::vec;
 
 /// Before a content chunk.
 ///
@@ -110,7 +111,7 @@ pub fn definition_after(tokenizer: &mut Tokenizer) -> State {
 
 /// Merge `Content` chunks, which currently span a single line, into actual
 /// `Content`s that span multiple lines.
-pub fn resolve(tokenizer: &mut Tokenizer) -> Result<Option<Subresult>, String> {
+pub fn resolve(tokenizer: &mut Tokenizer) -> Result<Option<Subresult>, message::Message> {
     let mut index = 0;
 
     while index < tokenizer.events.len() {
diff --git a/src/construct/document.rs b/src/construct/document.rs
index 5591b125..204e9347 100644
--- a/src/construct/document.rs
+++ b/src/construct/document.rs
@@ -10,11 +10,12 @@
 //! *   [GFM: Footnote definition][crate::construct::gfm_footnote_definition]
 
 use crate::event::{Content, Event, Kind, Link, Name};
+use crate::message;
 use crate::state::{Name as StateName, State};
 use crate::subtokenize::divide_events;
 use crate::tokenizer::{Container, ContainerState, Tokenizer};
 use crate::util::skip;
-use alloc::{boxed::Box, string::String, vec::Vec};
+use alloc::{boxed::Box, vec::Vec};
 
 /// Phases where we can exit containers.
 #[derive(Debug, PartialEq)]
@@ -470,7 +471,7 @@ pub fn flow_end(tokenizer: &mut Tokenizer) -> State {
 }
 
 /// Close containers (and flow if needed).
-fn exit_containers(tokenizer: &mut Tokenizer, phase: &Phase) -> Result<(), String> {
+fn exit_containers(tokenizer: &mut Tokenizer, phase: &Phase) -> Result<(), message::Message> {
     let mut stack_close = tokenizer
         .tokenize_state
         .document_container_stack
diff --git a/src/construct/mdx_esm.rs b/src/construct/mdx_esm.rs
index 13d7991f..277eecb1 100644
--- a/src/construct/mdx_esm.rs
+++ b/src/construct/mdx_esm.rs
@@ -30,11 +30,12 @@
 //! [parse_options]: crate::ParseOptions
 
 use crate::event::Name;
+use crate::message;
 use crate::state::{Name as StateName, State};
 use crate::tokenizer::Tokenizer;
 use crate::util::{mdx_collect::collect, slice::Slice};
 use crate::MdxSignal;
-use alloc::format;
+use alloc::boxed::Box;
 
 /// Start of MDX ESM.
 ///
@@ -205,7 +206,7 @@ fn parse_esm(tokenizer: &mut Tokenizer) -> State {
     // Parse and handle what was signaled back.
     match parse(&result.value) {
         MdxSignal::Ok => State::Ok,
-        MdxSignal::Error(message, relative) => {
+        MdxSignal::Error(message, relative, source, rule_id) => {
             let point = tokenizer
                 .parse_state
                 .location
@@ -213,16 +214,23 @@ fn parse_esm(tokenizer: &mut Tokenizer) -> State {
                 .expect("expected location index if aware mdx is on")
                 .relative_to_point(&result.stops, relative)
                 .expect("expected non-empty string");
-            State::Error(format!("{}:{}: {}", point.line, point.column, message))
+            State::Error(message::Message {
+                place: Some(Box::new(message::Place::Point(point))),
+                reason: message,
+                source,
+                rule_id,
+            })
         }
-        MdxSignal::Eof(message) => {
+        MdxSignal::Eof(message, source, rule_id) => {
             if tokenizer.current.is_none() {
-                State::Error(format!(
-                    "{}:{}: {}",
-                    tokenizer.point.line, tokenizer.point.column, message
-                ))
+                State::Error(message::Message {
+                    place: Some(Box::new(message::Place::Point(tokenizer.point.to_unist()))),
+                    reason: message,
+                    source,
+                    rule_id,
+                })
             } else {
-                tokenizer.tokenize_state.mdx_last_parse_error = Some(message);
+                tokenizer.tokenize_state.mdx_last_parse_error = Some((message, *source, *rule_id));
                 State::Retry(StateName::MdxEsmContinuationStart)
             }
         }
diff --git a/src/construct/partial_mdx_expression.rs b/src/construct/partial_mdx_expression.rs
index f5d1c503..22d0eb5b 100644
--- a/src/construct/partial_mdx_expression.rs
+++ b/src/construct/partial_mdx_expression.rs
@@ -58,11 +58,12 @@
 
 use crate::construct::partial_space_or_tab::space_or_tab_min_max;
 use crate::event::Name;
+use crate::message;
 use crate::state::{Name as StateName, State};
 use crate::tokenizer::Tokenizer;
 use crate::util::{constant::TAB_SIZE, mdx_collect::collect};
 use crate::{MdxExpressionKind, MdxExpressionParse, MdxSignal};
-use alloc::format;
+use alloc::boxed::Box;
 
 /// Start of an MDX expression.
 ///
@@ -89,12 +90,15 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
 pub fn before(tokenizer: &mut Tokenizer) -> State {
     match tokenizer.current {
         None => {
-            State::Error(format!(
-                "{}:{}: {}",
-                tokenizer.point.line, tokenizer.point.column,
-                tokenizer.tokenize_state.mdx_last_parse_error.take()
-                    .unwrap_or_else(|| "Unexpected end of file in expression, expected a corresponding closing brace for `{`".into())
-            ))
+            let problem = tokenizer.tokenize_state.mdx_last_parse_error.take()
+                        .unwrap_or_else(|| ("Unexpected end of file in expression, expected a corresponding closing brace for `{`".into(), "markdown-rs".into(), "unexpected-eof".into()));
+
+            State::Error(message::Message {
+                place: Some(Box::new(message::Place::Point(tokenizer.point.to_unist()))),
+                reason: problem.0,
+                rule_id: Box::new(problem.2),
+                source: Box::new(problem.1),
+            })
         }
         Some(b'\n') => {
             tokenizer.enter(Name::LineEnding);
@@ -167,10 +171,14 @@ pub fn eol_after(tokenizer: &mut Tokenizer) -> State {
         || tokenizer.tokenize_state.token_2 == Name::MdxJsxFlowTag)
         && tokenizer.lazy
     {
-        State::Error(format!(
-            "{}:{}: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
-            tokenizer.point.line, tokenizer.point.column
-        ))
+        State::Error(
+            message::Message {
+                place: Some(Box::new(message::Place::Point(tokenizer.point.to_unist()))),
+                reason: "Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc".into(),
+                source: Box::new("markdown-rs".into()),
+                rule_id: Box::new("unexpected-lazy".into()),
+            }
+        )
     } else if matches!(tokenizer.current, Some(b'\t' | b' ')) {
         tokenizer.attempt(State::Next(StateName::MdxExpressionBefore), State::Nok);
         // Idea: investigate if we’d need to use more complex stripping.
@@ -220,21 +228,24 @@ fn parse_expression(tokenizer: &mut Tokenizer, parse: &MdxExpressionParse) -> St
     // Parse and handle what was signaled back.
     match parse(&result.value, &kind) {
         MdxSignal::Ok => State::Ok,
-        MdxSignal::Error(message, relative) => {
+        MdxSignal::Error(reason, relative, source, rule_id) => {
             let point = tokenizer
                 .parse_state
                 .location
                 .as_ref()
                 .expect("expected location index if aware mdx is on")
                 .relative_to_point(&result.stops, relative)
-                .map_or((tokenizer.point.line, tokenizer.point.column), |d| {
-                    (d.line, d.column)
-                });
+                .unwrap_or_else(|| tokenizer.point.to_unist());
 
-            State::Error(format!("{}:{}: {}", point.0, point.1, message))
+            State::Error(message::Message {
+                place: Some(Box::new(message::Place::Point(point))),
+                reason,
+                rule_id,
+                source,
+            })
         }
-        MdxSignal::Eof(message) => {
-            tokenizer.tokenize_state.mdx_last_parse_error = Some(message);
+        MdxSignal::Eof(reason, source, rule_id) => {
+            tokenizer.tokenize_state.mdx_last_parse_error = Some((reason, *source, *rule_id));
             tokenizer.enter(Name::MdxExpressionData);
             tokenizer.consume();
             State::Next(StateName::MdxExpressionInside)
diff --git a/src/construct/partial_mdx_jsx.rs b/src/construct/partial_mdx_jsx.rs
index 8bf0742f..87c266ae 100644
--- a/src/construct/partial_mdx_jsx.rs
+++ b/src/construct/partial_mdx_jsx.rs
@@ -162,6 +162,7 @@
 //! [interleaving]: https://mdxjs.com/docs/what-is-mdx/#interleaving
 
 use crate::event::Name;
+use crate::message;
 use crate::state::{Name as StateName, State};
 use crate::tokenizer::Tokenizer;
 use crate::util::{
@@ -171,7 +172,7 @@ use crate::util::{
     },
     identifier::{id_cont, id_start},
 };
-use alloc::format;
+use alloc::{boxed::Box, format};
 use core::str;
 
 /// Start of MDX: JSX.
@@ -1092,10 +1093,14 @@ pub fn es_whitespace_inside(tokenizer: &mut Tokenizer) -> State {
 pub fn es_whitespace_eol_after(tokenizer: &mut Tokenizer) -> State {
     // Lazy continuation in a flow tag is a syntax error.
     if tokenizer.tokenize_state.token_1 == Name::MdxJsxFlowTag && tokenizer.lazy {
-        State::Error(format!(
-            "{}:{}: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
-            tokenizer.point.line, tokenizer.point.column
-        ))
+        State::Error(
+            message::Message {
+                place: Some(Box::new(message::Place::Point(tokenizer.point.to_unist()))),
+                reason: "Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc".into(),
+                rule_id: Box::new("unexpected-lazy".into()),
+                source: Box::new("markdown-rs".into()),
+            }
+        )
     } else {
         State::Retry(StateName::MdxJsxEsWhitespaceStart)
     }
@@ -1114,16 +1119,26 @@ fn id_cont_opt(code: Option<char>) -> bool {
 /// Crash because something happened `at`, with info on what was `expect`ed
 /// instead.
 fn crash(tokenizer: &Tokenizer, at: &str, expect: &str) -> State {
-    State::Error(format!(
-        "{}:{}: Unexpected {} {}, expected {}",
-        tokenizer.point.line,
-        tokenizer.point.column,
-        format_char_opt(if tokenizer.current.is_none() {
-            None
-        } else {
-            char_after_index(tokenizer.parse_state.bytes, tokenizer.point.index)
-        }),
-        at,
-        expect
-    ))
+    State::Error(message::Message {
+        place: Some(Box::new(message::Place::Point(tokenizer.point.to_unist()))),
+        reason: format!(
+            "Unexpected {} {}, expected {}",
+            format_char_opt(if tokenizer.current.is_none() {
+                None
+            } else {
+                char_after_index(tokenizer.parse_state.bytes, tokenizer.point.index)
+            }),
+            at,
+            expect
+        ),
+        rule_id: Box::new(format!(
+            "unexpected-{}",
+            if tokenizer.current.is_none() {
+                "eof"
+            } else {
+                "character"
+            }
+        )),
+        source: Box::new("markdown-rs".into()),
+    })
 }
diff --git a/src/event.rs b/src/event.rs
index 3f4363d5..dacb2c09 100644
--- a/src/event.rs
+++ b/src/event.rs
@@ -1,5 +1,6 @@
 //! Semantic labels of things happening.
 
+use crate::unist;
 use crate::util::constant::TAB_SIZE;
 
 /// Semantic label of a span.
@@ -3505,8 +3506,17 @@ pub struct Point {
 }
 
 impl Point {
+    /// Create a unist point.
+    pub fn to_unist(&self) -> unist::Point {
+        unist::Point {
+            line: self.line,
+            column: self.column,
+            offset: self.index,
+        }
+    }
+
     /// Create a new point, that is shifted from the close earlier current
-    /// point, to `index.`
+    /// point, to `index`.
     pub fn shift_to(&self, bytes: &[u8], index: usize) -> Point {
         let mut next = self.clone();
         debug_assert!(index > next.index, "expected to shift forward");
diff --git a/src/lib.rs b/src/lib.rs
index 584861ef..f1266e81 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,6 +28,7 @@
 #![allow(clippy::missing_panics_doc)]
 #![allow(clippy::must_use_candidate)]
 #![allow(clippy::too_many_lines)]
+#![allow(clippy::result_large_err)]
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/wooorm/markdown-rs/8924580/media/logo-monochromatic.svg?sanitize=true"
 )]
@@ -46,6 +47,7 @@ mod tokenizer;
 mod util;
 
 pub mod mdast; // To do: externalize?
+pub mod message; // To do: externalize.
 pub mod unist; // To do: externalize.
 
 #[doc(hidden)]
@@ -99,7 +101,7 @@ pub fn to_html(value: &str) -> String {
 ///
 /// ```
 /// use markdown::{to_html_with_options, CompileOptions, Options};
-/// # fn main() -> Result<(), String> {
+/// # fn main() -> Result<(), markdown::message::Message> {
 ///
 /// // Use GFM:
 /// let result = to_html_with_options("~hi~hello!", &Options::gfm())?;
@@ -120,7 +122,7 @@ pub fn to_html(value: &str) -> String {
 /// # Ok(())
 /// # }
 /// ```
-pub fn to_html_with_options(value: &str, options: &Options) -> Result<String, String> {
+pub fn to_html_with_options(value: &str, options: &Options) -> Result<String, message::Message> {
     let (events, parse_state) = parser::parse(value, &options.parse)?;
     Ok(to_html::compile(
         &events,
@@ -143,7 +145,7 @@ pub fn to_html_with_options(value: &str, options: &Options) -> Result<String, St
 ///
 /// ```
 /// use markdown::{to_mdast, ParseOptions};
-/// # fn main() -> Result<(), String> {
+/// # fn main() -> Result<(), markdown::message::Message> {
 ///
 /// let tree = to_mdast("# Hey, *you*!", &ParseOptions::default())?;
 ///
@@ -152,7 +154,7 @@ pub fn to_html_with_options(value: &str, options: &Options) -> Result<String, St
 /// # Ok(())
 /// # }
 /// ```
-pub fn to_mdast(value: &str, options: &ParseOptions) -> Result<mdast::Node, String> {
+pub fn to_mdast(value: &str, options: &ParseOptions) -> Result<mdast::Node, message::Message> {
     let (events, parse_state) = parser::parse(value, options)?;
     let node = to_mdast::compile(&events, parse_state.bytes)?;
     Ok(node)
diff --git a/src/message.rs b/src/message.rs
new file mode 100644
index 00000000..4b6e8221
--- /dev/null
+++ b/src/message.rs
@@ -0,0 +1,46 @@
+use crate::unist::{Point, Position};
+use alloc::{boxed::Box, fmt, string::String};
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Message {
+    /// Place of message.
+    pub place: Option<Box<Place>>,
+    /// Reason for message (should use markdown).
+    pub reason: String,
+    /// Category of message.
+    pub rule_id: Box<String>,
+    /// Namespace of message.
+    pub source: Box<String>,
+}
+
+impl fmt::Display for Message {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(ref place) = self.place {
+            write!(f, "{}: ", place)?;
+        };
+
+        write!(f, "{} ({}:{})", self.reason, self.source, self.rule_id)
+    }
+}
+
+/// Somewhere.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Place {
+    /// Between two points.
+    Position(Position),
+    /// At a point.
+    Point(Point),
+}
+
+impl fmt::Display for Place {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Place::Position(position) => write!(
+                f,
+                "{}:{}-{}:{}",
+                position.start.line, position.start.column, position.end.line, position.end.column
+            ),
+            Place::Point(point) => write!(f, "{}:{}", point.line, point.column),
+        }
+    }
+}
diff --git a/src/parser.rs b/src/parser.rs
index e40aa5a3..9bcfa0ac 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1,6 +1,7 @@
 //! Turn bytes of markdown into events.
 
 use crate::event::{Event, Point};
+use crate::message;
 use crate::state::{Name as StateName, State};
 use crate::subtokenize::subtokenize;
 use crate::tokenizer::Tokenizer;
@@ -32,7 +33,7 @@ pub struct ParseState<'a> {
 pub fn parse<'a>(
     value: &'a str,
     options: &'a ParseOptions,
-) -> Result<(Vec<Event>, ParseState<'a>), String> {
+) -> Result<(Vec<Event>, ParseState<'a>), message::Message> {
     let bytes = value.as_bytes();
 
     let mut parse_state = ParseState {
diff --git a/src/resolve.rs b/src/resolve.rs
index 813ce523..297a2ef3 100644
--- a/src/resolve.rs
+++ b/src/resolve.rs
@@ -1,9 +1,9 @@
 //! Resolve events.
 
 use crate::construct;
+use crate::message;
 use crate::subtokenize::Subresult;
 use crate::tokenizer::Tokenizer;
-use alloc::string::String;
 
 /// Names of resolvers.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -63,7 +63,7 @@ pub enum Name {
 }
 
 /// Call the corresponding resolver.
-pub fn call(tokenizer: &mut Tokenizer, name: Name) -> Result<Option<Subresult>, String> {
+pub fn call(tokenizer: &mut Tokenizer, name: Name) -> Result<Option<Subresult>, message::Message> {
     let result = match name {
         Name::Label => construct::label_end::resolve(tokenizer),
         Name::Attention => construct::attention::resolve(tokenizer),
diff --git a/src/state.rs b/src/state.rs
index e7387e62..84c963b5 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -1,16 +1,16 @@
 //! States of the state machine.
 
 use crate::construct;
+use crate::message;
 use crate::tokenizer::Tokenizer;
-use alloc::string::String;
 
 /// Result of a state.
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum State {
     /// Syntax error.
     ///
     /// Only used by MDX.
-    Error(String),
+    Error(message::Message),
     /// Move to [`Name`][] next.
     Next(Name),
     /// Retry in [`Name`][].
@@ -28,13 +28,13 @@ impl State {
     /// or on an attempt ([`State::Nok`]).
     ///
     /// But it turns the final result into an error if crashed.
-    pub fn to_result(&self) -> Result<(), String> {
+    pub fn to_result(&self) -> Result<(), message::Message> {
         match self {
             State::Nok | State::Next(_) | State::Retry(_) => {
                 unreachable!("cannot turn intermediate state into result")
             }
             State::Ok => Ok(()),
-            State::Error(x) => Err(x.into()),
+            State::Error(x) => Err(x.clone()),
         }
     }
 }
diff --git a/src/subtokenize.rs b/src/subtokenize.rs
index 348224fd..467ca463 100644
--- a/src/subtokenize.rs
+++ b/src/subtokenize.rs
@@ -18,6 +18,7 @@
 //! any level that can include references can be parsed.
 
 use crate::event::{Content, Event, Kind, Name, VOID_EVENTS};
+use crate::message;
 use crate::parser::ParseState;
 use crate::state::{Name as StateName, State};
 use crate::tokenizer::Tokenizer;
@@ -78,7 +79,7 @@ pub fn subtokenize(
     events: &mut Vec<Event>,
     parse_state: &ParseState,
     filter: &Option<Content>,
-) -> Result<Subresult, String> {
+) -> Result<Subresult, message::Message> {
     let mut map = EditMap::new();
     let mut index = 0;
     let mut value = Subresult {
diff --git a/src/to_mdast.rs b/src/to_mdast.rs
index 99a0c2ac..7f297567 100644
--- a/src/to_mdast.rs
+++ b/src/to_mdast.rs
@@ -1,6 +1,6 @@
 //! Turn events into a syntax tree.
 
-use crate::event::{Event, Kind, Name, Point as EventPoint};
+use crate::event::{Event, Kind, Name};
 use crate::mdast::{
     AttributeContent, AttributeValue, AttributeValueExpression, BlockQuote, Break, Code,
     Definition, Delete, Emphasis, FootnoteDefinition, FootnoteReference, Heading, Html, Image,
@@ -9,6 +9,7 @@ use crate::mdast::{
     MdxjsEsm, Node, Paragraph, ReferenceKind, Root, Strong, Table, TableCell, TableRow, Text,
     ThematicBreak, Toml, Yaml,
 };
+use crate::message;
 use crate::unist::{Point, Position};
 use crate::util::{
     character_reference::{
@@ -20,6 +21,7 @@ use crate::util::{
     slice::{Position as SlicePosition, Slice},
 };
 use alloc::{
+    boxed::Box,
     format,
     string::{String, ToString},
     vec,
@@ -114,12 +116,12 @@ impl<'a> CompileContext<'a> {
                 start: if events.is_empty() {
                     Point::new(1, 1, 0)
                 } else {
-                    point_from_event(&events[0])
+                    events[0].point.to_unist()
                 },
                 end: if events.is_empty() {
                     Point::new(1, 1, 0)
                 } else {
-                    point_from_event(&events[events.len() - 1])
+                    events[events.len() - 1].point.to_unist()
                 },
             }),
         });
@@ -203,9 +205,9 @@ impl<'a> CompileContext<'a> {
         event_stack.push(self.index);
     }
 
-    fn tail_pop(&mut self) -> Result<(), String> {
+    fn tail_pop(&mut self) -> Result<(), message::Message> {
         let ev = &self.events[self.index];
-        let end = point_from_event(ev);
+        let end = ev.point.to_unist();
         let (tree, stack, event_stack) = self.trees.last_mut().expect("Cannot get tail w/o tree");
         let node = delve_mut(tree, stack);
         let pos = node.position_mut().expect("Cannot pop manually added node");
@@ -223,7 +225,7 @@ impl<'a> CompileContext<'a> {
 }
 
 /// Turn events and bytes into a syntax tree.
-pub fn compile(events: &[Event], bytes: &[u8]) -> Result<Node, String> {
+pub fn compile(events: &[Event], bytes: &[u8]) -> Result<Node, message::Message> {
     let mut context = CompileContext::new(events, bytes);
 
     let mut index = 0;
@@ -244,7 +246,7 @@ pub fn compile(events: &[Event], bytes: &[u8]) -> Result<Node, String> {
 }
 
 /// Handle the event at `index`.
-fn handle(context: &mut CompileContext, index: usize) -> Result<(), String> {
+fn handle(context: &mut CompileContext, index: usize) -> Result<(), message::Message> {
     context.index = index;
 
     if context.events[index].kind == Kind::Enter {
@@ -257,7 +259,7 @@ fn handle(context: &mut CompileContext, index: usize) -> Result<(), String> {
 }
 
 /// Handle [`Enter`][Kind::Enter].
-fn enter(context: &mut CompileContext) -> Result<(), String> {
+fn enter(context: &mut CompileContext) -> Result<(), message::Message> {
     match context.events[context.index].name {
         Name::AutolinkEmail
         | Name::AutolinkProtocol
@@ -335,7 +337,7 @@ fn enter(context: &mut CompileContext) -> Result<(), String> {
 }
 
 /// Handle [`Exit`][Kind::Exit].
-fn exit(context: &mut CompileContext) -> Result<(), String> {
+fn exit(context: &mut CompileContext) -> Result<(), message::Message> {
     match context.events[context.index].name {
         Name::Autolink
         | Name::BlockQuote
@@ -775,7 +777,7 @@ fn on_enter_math_flow(context: &mut CompileContext) {
 
 /// Handle [`Enter`][Kind::Enter]:{[`MdxJsxFlowTag`][Name::MdxJsxFlowTag],[`MdxJsxTextTag`][Name::MdxJsxTextTag]}.
 fn on_enter_mdx_jsx_tag(context: &mut CompileContext) {
-    let point = point_from_event(&context.events[context.index]);
+    let point = context.events[context.index].point.to_unist();
     context.jsx_tag = Some(JsxTag {
         name: None,
         attributes: vec![],
@@ -788,35 +790,41 @@ fn on_enter_mdx_jsx_tag(context: &mut CompileContext) {
 }
 
 /// Handle [`Enter`][Kind::Enter]:[`MdxJsxTagClosingMarker`][Name::MdxJsxTagClosingMarker].
-fn on_enter_mdx_jsx_tag_closing_marker(context: &mut CompileContext) -> Result<(), String> {
+fn on_enter_mdx_jsx_tag_closing_marker(
+    context: &mut CompileContext,
+) -> Result<(), message::Message> {
     if context.jsx_tag_stack.is_empty() {
         let event = &context.events[context.index];
-        Err(format!(
-            "{}:{}: Unexpected closing slash `/` in tag, expected an open tag first (mdx-jsx:unexpected-closing-slash)",
-            event.point.line,
-            event.point.column,
-        ))
+        Err(message::Message {
+            place: Some(Box::new(message::Place::Point(event.point.to_unist()))),
+            reason: "Unexpected closing slash `/` in tag, expected an open tag first".into(),
+            rule_id: Box::new("unexpected-closing-slash".into()),
+            source: Box::new("markdown-rs".into()),
+        })
     } else {
         Ok(())
     }
 }
 
 /// Handle [`Enter`][Kind::Enter]:{[`MdxJsxTagAttribute`][Name::MdxJsxTagAttribute],[`MdxJsxTagAttributeExpression`][Name::MdxJsxTagAttributeExpression]}.
-fn on_enter_mdx_jsx_tag_any_attribute(context: &mut CompileContext) -> Result<(), String> {
+fn on_enter_mdx_jsx_tag_any_attribute(
+    context: &mut CompileContext,
+) -> Result<(), message::Message> {
     if context.jsx_tag.as_ref().expect("expected tag").close {
         let event = &context.events[context.index];
-        Err(format!(
-            "{}:{}: Unexpected attribute in closing tag, expected the end of the tag (mdx-jsx:unexpected-attribute)",
-            event.point.line,
-            event.point.column,
-        ))
+        Err(message::Message {
+            place: Some(Box::new(message::Place::Point(event.point.to_unist()))),
+            reason: "Unexpected attribute in closing tag, expected the end of the tag".into(),
+            rule_id: Box::new("unexpected-attribute".into()),
+            source: Box::new("markdown-rs".into()),
+        })
     } else {
         Ok(())
     }
 }
 
 /// Handle [`Enter`][Kind::Enter]:[`MdxJsxTagAttribute`][Name::MdxJsxTagAttribute].
-fn on_enter_mdx_jsx_tag_attribute(context: &mut CompileContext) -> Result<(), String> {
+fn on_enter_mdx_jsx_tag_attribute(context: &mut CompileContext) -> Result<(), message::Message> {
     on_enter_mdx_jsx_tag_any_attribute(context)?;
 
     context
@@ -833,7 +841,9 @@ fn on_enter_mdx_jsx_tag_attribute(context: &mut CompileContext) -> Result<(), St
 }
 
 /// Handle [`Enter`][Kind::Enter]:[`MdxJsxTagAttributeExpression`][Name::MdxJsxTagAttributeExpression].
-fn on_enter_mdx_jsx_tag_attribute_expression(context: &mut CompileContext) -> Result<(), String> {
+fn on_enter_mdx_jsx_tag_attribute_expression(
+    context: &mut CompileContext,
+) -> Result<(), message::Message> {
     on_enter_mdx_jsx_tag_any_attribute(context)?;
 
     let CollectResult { value, stops } = collect(
@@ -884,15 +894,19 @@ fn on_enter_mdx_jsx_tag_attribute_value_expression(context: &mut CompileContext)
 }
 
 /// Handle [`Enter`][Kind::Enter]:[`MdxJsxTagSelfClosingMarker`][Name::MdxJsxTagSelfClosingMarker].
-fn on_enter_mdx_jsx_tag_self_closing_marker(context: &mut CompileContext) -> Result<(), String> {
+fn on_enter_mdx_jsx_tag_self_closing_marker(
+    context: &mut CompileContext,
+) -> Result<(), message::Message> {
     let tag = context.jsx_tag.as_ref().expect("expected tag");
     if tag.close {
         let event = &context.events[context.index];
-        Err(format!(
-            "{}:{}: Unexpected self-closing slash `/` in closing tag, expected the end of the tag (mdx-jsx:unexpected-self-closing-slash)",
-            event.point.line,
-            event.point.column,
-        ))
+        Err(message::Message {
+            place: Some(Box::new(message::Place::Point(event.point.to_unist()))),
+            reason: "Unexpected self-closing slash `/` in closing tag, expected the end of the tag"
+                .into(),
+            rule_id: Box::new("unexpected-self-closing-slash".into()),
+            source: Box::new("markdown-rs".into()),
+        })
     } else {
         Ok(())
     }
@@ -907,13 +921,13 @@ fn on_enter_paragraph(context: &mut CompileContext) {
 }
 
 /// Handle [`Exit`][Kind::Exit]:`*`.
-fn on_exit(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit(context: &mut CompileContext) -> Result<(), message::Message> {
     context.tail_pop()?;
     Ok(())
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`AutolinkProtocol`][Name::AutolinkProtocol].
-fn on_exit_autolink_protocol(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_autolink_protocol(context: &mut CompileContext) -> Result<(), message::Message> {
     on_exit_data(context)?;
     let value = Slice::from_position(
         context.bytes,
@@ -928,7 +942,7 @@ fn on_exit_autolink_protocol(context: &mut CompileContext) -> Result<(), String>
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`AutolinkEmail`][Name::AutolinkEmail].
-fn on_exit_autolink_email(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_autolink_email(context: &mut CompileContext) -> Result<(), message::Message> {
     on_exit_data(context)?;
     let value = Slice::from_position(
         context.bytes,
@@ -1010,7 +1024,7 @@ fn on_exit_raw_flow_fence(context: &mut CompileContext) {
 }
 
 /// Handle [`Exit`][Kind::Exit]:{[`CodeFenced`][Name::CodeFenced],[`MathFlow`][Name::MathFlow]}.
-fn on_exit_raw_flow(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_raw_flow(context: &mut CompileContext) -> Result<(), message::Message> {
     let value = trim_eol(context.resume().to_string(), true, true);
 
     match context.tail_mut() {
@@ -1025,7 +1039,7 @@ fn on_exit_raw_flow(context: &mut CompileContext) -> Result<(), String> {
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`CodeIndented`][Name::CodeIndented].
-fn on_exit_code_indented(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_code_indented(context: &mut CompileContext) -> Result<(), message::Message> {
     let value = context.resume().to_string();
 
     if let Node::Code(node) = context.tail_mut() {
@@ -1039,7 +1053,7 @@ fn on_exit_code_indented(context: &mut CompileContext) -> Result<(), String> {
 }
 
 /// Handle [`Exit`][Kind::Exit]:{[`CodeText`][Name::CodeText],[`MathText`][Name::MathText]}.
-fn on_exit_raw_text(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_raw_text(context: &mut CompileContext) -> Result<(), message::Message> {
     let mut value = context.resume().to_string();
 
     // To do: share with `to_html`.
@@ -1077,7 +1091,7 @@ fn on_exit_raw_text(context: &mut CompileContext) -> Result<(), String> {
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`Data`][Name::Data] (and many text things).
-fn on_exit_data(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_data(context: &mut CompileContext) -> Result<(), message::Message> {
     let value = Slice::from_position(
         context.bytes,
         &SlicePosition::from_exit_event(context.events, context.index),
@@ -1139,7 +1153,7 @@ fn on_exit_drop(context: &mut CompileContext) {
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`Frontmatter`][Name::Frontmatter].
-fn on_exit_frontmatter(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_frontmatter(context: &mut CompileContext) -> Result<(), message::Message> {
     let value = trim_eol(context.resume().to_string(), true, true);
 
     match context.tail_mut() {
@@ -1153,7 +1167,7 @@ fn on_exit_frontmatter(context: &mut CompileContext) -> Result<(), String> {
 }
 
 /// Handle [`Exit`][Kind::Exit]:{[`GfmAutolinkLiteralEmail`][Name::GfmAutolinkLiteralEmail],[`GfmAutolinkLiteralMailto`][Name::GfmAutolinkLiteralMailto],[`GfmAutolinkLiteralProtocol`][Name::GfmAutolinkLiteralProtocol],[`GfmAutolinkLiteralWww`][Name::GfmAutolinkLiteralWww],[`GfmAutolinkLiteralXmpp`][Name::GfmAutolinkLiteralXmpp]}.
-fn on_exit_gfm_autolink_literal(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_gfm_autolink_literal(context: &mut CompileContext) -> Result<(), message::Message> {
     on_exit_data(context)?;
 
     let value = Slice::from_position(
@@ -1183,7 +1197,7 @@ fn on_exit_gfm_autolink_literal(context: &mut CompileContext) -> Result<(), Stri
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`GfmTable`][Name::GfmTable].
-fn on_exit_gfm_table(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_gfm_table(context: &mut CompileContext) -> Result<(), message::Message> {
     on_exit(context)?;
     context.gfm_table_inside = false;
     Ok(())
@@ -1202,7 +1216,7 @@ fn on_exit_gfm_task_list_item_value(context: &mut CompileContext) {
 }
 
 /// Handle [`Exit`][Kind::Exit]:{[`HardBreakEscape`][Name::HardBreakEscape],[`HardBreakTrailing`][Name::HardBreakTrailing]}.
-fn on_exit_hard_break(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_hard_break(context: &mut CompileContext) -> Result<(), message::Message> {
     on_exit(context)?;
     context.hard_break_after = true;
     Ok(())
@@ -1227,7 +1241,7 @@ fn on_exit_heading_atx_sequence(context: &mut CompileContext) {
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`HeadingSetext`][Name::HeadingSetext].
-fn on_exit_heading_setext(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_heading_setext(context: &mut CompileContext) -> Result<(), message::Message> {
     context.heading_setext_text_after = false;
     on_exit(context)?;
     Ok(())
@@ -1278,13 +1292,13 @@ fn on_exit_label_text(context: &mut CompileContext) {
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`LineEnding`][Name::LineEnding].
-fn on_exit_line_ending(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_line_ending(context: &mut CompileContext) -> Result<(), message::Message> {
     if context.heading_setext_text_after {
         // Ignore.
     }
     // Line ending position after hard break is part of it.
     else if context.hard_break_after {
-        let end = point_from_event(&context.events[context.index]);
+        let end = context.events[context.index].point.to_unist();
         let node = context.tail_mut();
         let tail = node
             .children_mut()
@@ -1313,7 +1327,7 @@ fn on_exit_line_ending(context: &mut CompileContext) -> Result<(), String> {
 }
 
 /// Handle [`Exit`][Kind::Exit]:{[`HtmlFlow`][Name::HtmlFlow],[`HtmlText`][Name::HtmlText]}.
-fn on_exit_html(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_html(context: &mut CompileContext) -> Result<(), message::Message> {
     let value = context.resume().to_string();
 
     match context.tail_mut() {
@@ -1326,7 +1340,7 @@ fn on_exit_html(context: &mut CompileContext) -> Result<(), String> {
 }
 
 /// Handle [`Exit`][Kind::Exit]:{[`GfmFootnoteCall`][Name::GfmFootnoteCall],[`Image`][Name::Image],[`Link`][Name::Link]}.
-fn on_exit_media(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_media(context: &mut CompileContext) -> Result<(), message::Message> {
     let reference = context
         .media_reference_stack
         .pop()
@@ -1379,7 +1393,7 @@ fn on_exit_media(context: &mut CompileContext) -> Result<(), String> {
 }
 
 /// Handle [`Exit`][Kind::Exit]:[`ListItem`][Name::ListItem].
-fn on_exit_list_item(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_list_item(context: &mut CompileContext) -> Result<(), message::Message> {
     if let Node::ListItem(item) = context.tail_mut() {
         if item.checked.is_some() {
             if let Some(Node::Paragraph(paragraph)) = item.children.first_mut() {
@@ -1444,13 +1458,13 @@ fn on_exit_list_item_value(context: &mut CompileContext) {
 }
 
 /// Handle [`Exit`][Kind::Exit]:{[`MdxJsxFlowTag`][Name::MdxJsxFlowTag],[`MdxJsxTextTag`][Name::MdxJsxTextTag]}.
-fn on_exit_mdx_jsx_tag(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_mdx_jsx_tag(context: &mut CompileContext) -> Result<(), message::Message> {
     let mut tag = context.jsx_tag.as_ref().expect("expected tag").clone();
 
     // End of a tag, so drop the buffer.
     context.resume();
     // Set end point.
-    tag.end = point_from_event(&context.events[context.index]);
+    tag.end = context.events[context.index].point.to_unist();
 
     let stack = &context.jsx_tag_stack;
     let tail = stack.last();
@@ -1460,15 +1474,24 @@ fn on_exit_mdx_jsx_tag(context: &mut CompileContext) -> Result<(), String> {
         let tail = tail.unwrap();
 
         if tail.name != tag.name {
-            return Err(format!(
-                "{}:{}: Unexpected closing tag `{}`, expected corresponding closing tag for `{}` ({}:{}) (mdx-jsx:end-tag-mismatch)",
-                tag.start.line,
-                tag.start.column,
-                serialize_abbreviated_tag(&tag),
-                serialize_abbreviated_tag(tail),
-                tail.start.line,
-                tail.start.column,
-            ));
+            let label = serialize_abbreviated_tag(&tag);
+            return Err(
+                message::Message {
+                    place: Some(Box::new(message::Place::Position(Position {
+                        start: tag.start,
+                        end: tag.end,
+                    }))),
+                    reason: format!(
+                        "Unexpected closing tag `{}`, expected corresponding closing tag for `{}` ({}:{})",
+                        label,
+                        serialize_abbreviated_tag(tail),
+                        tail.start.line,
+                        tail.start.column,
+                    ),
+                    rule_id: Box::new("end-tag-mismatch".into()),
+                    source: Box::new("markdown-rs".into()),
+                },
+            );
         }
 
         // Remove from our custom stack.
@@ -1559,7 +1582,7 @@ fn on_exit_mdx_jsx_tag_name_local(context: &mut CompileContext) {
 }
 
 /// Handle [`Exit`][Kind::Exit]:{[`MdxEsm`][Name::MdxEsm],[`MdxFlowExpression`][Name::MdxFlowExpression],[`MdxTextExpression`][Name::MdxTextExpression]}.
-fn on_exit_mdx_esm_or_expression(context: &mut CompileContext) -> Result<(), String> {
+fn on_exit_mdx_esm_or_expression(context: &mut CompileContext) -> Result<(), message::Message> {
     on_exit_drop(context);
     context.tail_pop()?;
     Ok(())
@@ -1669,16 +1692,6 @@ fn on_exit_resource_title_string(context: &mut CompileContext) {
     }
 }
 
-/// Create a point from an event.
-fn point_from_event_point(point: &EventPoint) -> Point {
-    Point::new(point.line, point.column, point.index)
-}
-
-/// Create a point from an event.
-fn point_from_event(event: &Event) -> Point {
-    point_from_event_point(&event.point)
-}
-
 /// Create a position from an event.
 fn position_from_event(event: &Event) -> Position {
     let end = Point::new(event.point.line, event.point.column, event.point.index);
@@ -1741,7 +1754,7 @@ fn on_mismatch_error(
     context: &mut CompileContext,
     left: Option<&Event>,
     right: &Event,
-) -> Result<(), String> {
+) -> Result<(), message::Message> {
     if right.name == Name::MdxJsxFlowTag || right.name == Name::MdxJsxTextTag {
         let stack = &context.jsx_tag_stack;
         let tag = stack.last().unwrap();
@@ -1751,34 +1764,42 @@ fn on_mismatch_error(
             &context.events[context.events.len() - 1].point
         };
 
-        return Err(format!(
-            "{}:{}: Expected a closing tag for `{}` ({}:{}){} (mdx-jsx:end-tag-mismatch)",
-            point.line,
-            point.column,
-            serialize_abbreviated_tag(tag),
-            tag.start.line,
-            tag.start.column,
-            if let Some(left) = left {
-                format!(" before the end of `{:?}`", left.name)
-            } else {
-                String::new()
-            }
-        ));
+        return Err(message::Message {
+            place: Some(Box::new(message::Place::Point(point.to_unist()))),
+            reason: format!(
+                "Expected a closing tag for `{}` ({}:{}){}",
+                serialize_abbreviated_tag(tag),
+                tag.start.line,
+                tag.start.column,
+                if let Some(left) = left {
+                    format!(" before the end of `{:?}`", left.name)
+                } else {
+                    String::new()
+                }
+            ),
+            rule_id: Box::new("end-tag-mismatch".into()),
+            source: Box::new("markdown-rs".into()),
+        });
     }
 
     if let Some(left) = left {
         if left.name == Name::MdxJsxFlowTag || left.name == Name::MdxJsxTextTag {
             let tag = context.jsx_tag.as_ref().unwrap();
 
-            return Err(format!(
-                "{}:{}: Expected the closing tag `{}` either before the start of `{:?}` ({}:{}), or another opening tag after that start (mdx-jsx:end-tag-mismatch)",
-                tag.start.line,
-                tag.start.column,
-                serialize_abbreviated_tag(tag),
-                &right.name,
-                &right.point.line,
-                &right.point.column,
-            ));
+            return Err(
+                message::Message {
+                    place: Some(Box::new(message::Place::Point(tag.start.clone()))),
+                    reason: format!(
+                        "Expected the closing tag `{}` either before the start of `{:?}` ({}:{}), or another opening tag after that start",
+                        serialize_abbreviated_tag(tag),
+                        &right.name,
+                        &right.point.line,
+                        &right.point.column,
+                    ),
+                    rule_id: Box::new("end-tag-mismatch".into()),
+                    source: Box::new("markdown-rs".into()),
+                }
+            );
         }
         unreachable!("mismatched (non-jsx): {:?} / {:?}", left.name, right.name);
     } else {
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
index 67ac411a..ef95c9a2 100644
--- a/src/tokenizer.rs
+++ b/src/tokenizer.rs
@@ -9,6 +9,7 @@
 //! [`attempt`]: Tokenizer::attempt
 
 use crate::event::{Content, Event, Kind, Link, Name, Point, VOID_EVENTS};
+use crate::message;
 use crate::parser::ParseState;
 use crate::resolve::{call as call_resolve, Name as ResolveName};
 use crate::state::{call, State};
@@ -232,7 +233,7 @@ pub struct TokenizeState<'a> {
     pub gfm_footnote_definitions: Vec<String>,
 
     // Last error message provided at an EOF of an expression.
-    pub mdx_last_parse_error: Option<String>,
+    pub mdx_last_parse_error: Option<(String, String, String)>,
 
     /// Whether to connect events.
     pub connect: bool,
@@ -625,7 +626,7 @@ impl<'a> Tokenizer<'a> {
     }
 
     /// Flush.
-    pub fn flush(&mut self, state: State, resolve: bool) -> Result<Subresult, String> {
+    pub fn flush(&mut self, state: State, resolve: bool) -> Result<Subresult, message::Message> {
         let to = (self.point.index, self.point.vs);
         let state = push_impl(self, to, to, state, true);
 
diff --git a/src/util/location.rs b/src/util/location.rs
index 87d2ad8e..bc97a2fd 100644
--- a/src/util/location.rs
+++ b/src/util/location.rs
@@ -71,11 +71,7 @@ impl Location {
                 } else {
                     0
                 };
-                return Some(Point {
-                    line: index + 1,
-                    column: offset + 1 - previous,
-                    offset,
-                });
+                return Some(Point::new(index + 1, offset + 1 - previous, offset));
             }
         }
 
diff --git a/src/util/mdx.rs b/src/util/mdx.rs
index ce5c9d49..0ed6a713 100644
--- a/src/util/mdx.rs
+++ b/src/util/mdx.rs
@@ -1,4 +1,4 @@
-use alloc::string::String;
+use alloc::{boxed::Box, string::String};
 
 /// Signal used as feedback when parsing MDX ESM/expressions.
 #[derive(Clone, Debug)]
@@ -14,7 +14,7 @@ pub enum Signal {
     /// ```rust ignore
     /// Signal::Error("Unexpected `\"`, expected identifier".into(), 1)
     /// ```
-    Error(String, usize),
+    Error(String, usize, Box<String>, Box<String>),
     /// An error at the end of the (partial?) expression.
     ///
     /// `markdown-rs` will either crash with error message `String` if it
@@ -26,7 +26,7 @@ pub enum Signal {
     /// ```rust ignore
     /// Signal::Eof("Unexpected end of file in string literal".into())
     /// ```
-    Eof(String),
+    Eof(String, Box<String>, Box<String>),
     /// Done, successfully.
     ///
     /// `markdown-rs` knows that this is the end of a valid expression/esm and
diff --git a/tests/attention.rs b/tests/attention.rs
index 61d038a4..5f071e56 100644
--- a/tests/attention.rs
+++ b/tests/attention.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Emphasis, Node, Paragraph, Root, Strong, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn attention() -> Result<(), String> {
+fn attention() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/autolink.rs b/tests/autolink.rs
index 1f4fab5a..e06d9b0c 100644
--- a/tests/autolink.rs
+++ b/tests/autolink.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Link, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn autolink() -> Result<(), String> {
+fn autolink() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/block_quote.rs b/tests/block_quote.rs
index b6fcf6a8..800cbfb2 100644
--- a/tests/block_quote.rs
+++ b/tests/block_quote.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{BlockQuote, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn block_quote() -> Result<(), String> {
+fn block_quote() -> Result<(), message::Message> {
     assert_eq!(
         to_html("> # a\n> b\n> c"),
         "<blockquote>\n<h1>a</h1>\n<p>b\nc</p>\n</blockquote>",
diff --git a/tests/character_escape.rs b/tests/character_escape.rs
index e062f28b..522aa524 100644
--- a/tests/character_escape.rs
+++ b/tests/character_escape.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn character_escape() -> Result<(), String> {
+fn character_escape() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/character_reference.rs b/tests/character_reference.rs
index 03282a1c..41b67e3a 100644
--- a/tests/character_reference.rs
+++ b/tests/character_reference.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn character_reference() -> Result<(), String> {
+fn character_reference() -> Result<(), message::Message> {
     assert_eq!(
         to_html(
             "&nbsp; &amp; &copy; &AElig; &Dcaron;\n&frac34; &HilbertSpace; &DifferentialD;\n&ClockwiseContourIntegral; &ngE;"
diff --git a/tests/code_fenced.rs b/tests/code_fenced.rs
index 403a8932..86574ca0 100644
--- a/tests/code_fenced.rs
+++ b/tests/code_fenced.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Code, Node, Root},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn code_fenced() -> Result<(), String> {
+fn code_fenced() -> Result<(), message::Message> {
     assert_eq!(
         to_html("```\n<\n >\n```"),
         "<pre><code>&lt;\n &gt;\n</code></pre>",
diff --git a/tests/code_indented.rs b/tests/code_indented.rs
index 1bd5726d..b393deec 100644
--- a/tests/code_indented.rs
+++ b/tests/code_indented.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Code, Node, Root},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn code_indented() -> Result<(), String> {
+fn code_indented() -> Result<(), message::Message> {
     assert_eq!(
         to_html("    a simple\n      indented code block"),
         "<pre><code>a simple\n  indented code block\n</code></pre>",
diff --git a/tests/code_text.rs b/tests/code_text.rs
index 47d8b197..d4a0e70b 100644
--- a/tests/code_text.rs
+++ b/tests/code_text.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{InlineCode, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn code_text() -> Result<(), String> {
+fn code_text() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/commonmark.rs b/tests/commonmark.rs
index 532cb373..7d4f5746 100644
--- a/tests/commonmark.rs
+++ b/tests/commonmark.rs
@@ -3,12 +3,12 @@
 // > 👉 **Important**: this module is generated by `generate/src/main.rs`.
 // > It is generate from the latest CommonMark website.
 
-use markdown::{to_html_with_options, CompileOptions, Options};
+use markdown::{message, to_html_with_options, CompileOptions, Options};
 use pretty_assertions::assert_eq;
 
 #[rustfmt::skip]
 #[test]
-fn commonmark() -> Result<(), String> {
+fn commonmark() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/definition.rs b/tests/definition.rs
index 0279d4d1..271beaaf 100644
--- a/tests/definition.rs
+++ b/tests/definition.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Definition, Node, Root},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn definition() -> Result<(), String> {
+fn definition() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/frontmatter.rs b/tests/frontmatter.rs
index 82a928a2..68efd485 100644
--- a/tests/frontmatter.rs
+++ b/tests/frontmatter.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Node, Root, Toml, Yaml},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn frontmatter() -> Result<(), String> {
+fn frontmatter() -> Result<(), message::Message> {
     let frontmatter = Options {
         parse: ParseOptions {
             constructs: Constructs {
diff --git a/tests/fuzz.rs b/tests/fuzz.rs
index 4778cbb8..98a3f219 100644
--- a/tests/fuzz.rs
+++ b/tests/fuzz.rs
@@ -1,8 +1,8 @@
-use markdown::{mdast, to_html, to_html_with_options, to_mdast, Options};
+use markdown::{mdast, message, to_html, to_html_with_options, to_mdast, Options};
 use pretty_assertions::assert_eq;
 
 #[test]
-fn fuzz() -> Result<(), String> {
+fn fuzz() -> Result<(), message::Message> {
     assert_eq!(
         to_html("[\n~\na\n-\n\n"),
         "<h2>[\n~\na</h2>\n",
diff --git a/tests/gfm_autolink_literal.rs b/tests/gfm_autolink_literal.rs
index 3470d6dc..29869f8d 100644
--- a/tests/gfm_autolink_literal.rs
+++ b/tests/gfm_autolink_literal.rs
@@ -5,14 +5,14 @@
 
 use markdown::{
     mdast::{Link, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn gfm_autolink_literal() -> Result<(), String> {
+fn gfm_autolink_literal() -> Result<(), message::Message> {
     assert_eq!(
         to_html("https://example.com"),
         "<p>https://example.com</p>",
diff --git a/tests/gfm_footnote.rs b/tests/gfm_footnote.rs
index 92562aa8..7c16d92c 100644
--- a/tests/gfm_footnote.rs
+++ b/tests/gfm_footnote.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{FootnoteDefinition, FootnoteReference, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn gfm_footnote() -> Result<(), String> {
+fn gfm_footnote() -> Result<(), message::Message> {
     assert_eq!(
         to_html("A call.[^a]\n\n[^a]: whatevs"),
         "<p>A call.<a href=\"whatevs\">^a</a></p>\n",
diff --git a/tests/gfm_strikethrough.rs b/tests/gfm_strikethrough.rs
index 120f6c1f..55b31e4a 100644
--- a/tests/gfm_strikethrough.rs
+++ b/tests/gfm_strikethrough.rs
@@ -5,14 +5,14 @@
 
 use markdown::{
     mdast::{Delete, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn gfm_strikethrough() -> Result<(), String> {
+fn gfm_strikethrough() -> Result<(), message::Message> {
     assert_eq!(
         to_html("a ~b~ c"),
         "<p>a ~b~ c</p>",
diff --git a/tests/gfm_table.rs b/tests/gfm_table.rs
index 887f3d06..ea46cbef 100644
--- a/tests/gfm_table.rs
+++ b/tests/gfm_table.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{AlignKind, InlineCode, Node, Root, Table, TableCell, TableRow, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn gfm_table() -> Result<(), String> {
+fn gfm_table() -> Result<(), message::Message> {
     assert_eq!(
         to_html("| a |\n| - |\n| b |"),
         "<p>| a |\n| - |\n| b |</p>",
diff --git a/tests/gfm_tagfilter.rs b/tests/gfm_tagfilter.rs
index 70e8e2f9..430c4400 100644
--- a/tests/gfm_tagfilter.rs
+++ b/tests/gfm_tagfilter.rs
@@ -3,11 +3,11 @@
 // To do: clippy introduced this in 1.72 but breaks when it fixes it.
 // Remove when solved.
 
-use markdown::{to_html_with_options, CompileOptions, Options};
+use markdown::{message, to_html_with_options, CompileOptions, Options};
 use pretty_assertions::assert_eq;
 
 #[test]
-fn gfm_tagfilter() -> Result<(), String> {
+fn gfm_tagfilter() -> Result<(), message::Message> {
     assert_eq!(
         to_html_with_options(
             "<iframe>",
diff --git a/tests/gfm_task_list_item.rs b/tests/gfm_task_list_item.rs
index 5d451345..0bfafe5c 100644
--- a/tests/gfm_task_list_item.rs
+++ b/tests/gfm_task_list_item.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Emphasis, List, ListItem, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn gfm_task_list_item() -> Result<(), String> {
+fn gfm_task_list_item() -> Result<(), message::Message> {
     assert_eq!(
         to_html("* [x] y."),
         "<ul>\n<li>[x] y.</li>\n</ul>",
diff --git a/tests/hard_break_escape.rs b/tests/hard_break_escape.rs
index 3a023894..189c11ec 100644
--- a/tests/hard_break_escape.rs
+++ b/tests/hard_break_escape.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Break, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn hard_break_escape() -> Result<(), String> {
+fn hard_break_escape() -> Result<(), message::Message> {
     assert_eq!(
         to_html("foo\\\nbaz"),
         "<p>foo<br />\nbaz</p>",
diff --git a/tests/hard_break_trailing.rs b/tests/hard_break_trailing.rs
index 6cdbfc83..b209065e 100644
--- a/tests/hard_break_trailing.rs
+++ b/tests/hard_break_trailing.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Break, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn hard_break_trailing() -> Result<(), String> {
+fn hard_break_trailing() -> Result<(), message::Message> {
     assert_eq!(
         to_html("foo  \nbaz"),
         "<p>foo<br />\nbaz</p>",
diff --git a/tests/heading_atx.rs b/tests/heading_atx.rs
index 944bfc5e..0eaf2e7d 100644
--- a/tests/heading_atx.rs
+++ b/tests/heading_atx.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Heading, Node, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn heading_atx() -> Result<(), String> {
+fn heading_atx() -> Result<(), message::Message> {
     assert_eq!(
         to_html("# foo"),
         "<h1>foo</h1>",
diff --git a/tests/heading_setext.rs b/tests/heading_setext.rs
index 3bc1eef9..31303273 100644
--- a/tests/heading_setext.rs
+++ b/tests/heading_setext.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Heading, Node, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn heading_setext() -> Result<(), String> {
+fn heading_setext() -> Result<(), message::Message> {
     assert_eq!(
         to_html("Foo *bar*\n========="),
         "<h1>Foo <em>bar</em></h1>",
diff --git a/tests/html_flow.rs b/tests/html_flow.rs
index 53a3436d..52ee3348 100644
--- a/tests/html_flow.rs
+++ b/tests/html_flow.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Html, Node, Root},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn html_flow() -> Result<(), String> {
+fn html_flow() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
@@ -63,7 +63,7 @@ fn html_flow() -> Result<(), String> {
 }
 
 #[test]
-fn html_flow_1_raw() -> Result<(), String> {
+fn html_flow_1_raw() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
@@ -235,7 +235,7 @@ p {color:blue;}
 }
 
 #[test]
-fn html_flow_2_comment() -> Result<(), String> {
+fn html_flow_2_comment() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
@@ -344,7 +344,7 @@ fn html_flow_2_comment() -> Result<(), String> {
 }
 
 #[test]
-fn html_flow_3_instruction() -> Result<(), String> {
+fn html_flow_3_instruction() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
@@ -401,7 +401,7 @@ fn html_flow_3_instruction() -> Result<(), String> {
 }
 
 #[test]
-fn html_flow_4_declaration() -> Result<(), String> {
+fn html_flow_4_declaration() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
@@ -466,7 +466,7 @@ fn html_flow_4_declaration() -> Result<(), String> {
 }
 
 #[test]
-fn html_flow_5_cdata() -> Result<(), String> {
+fn html_flow_5_cdata() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
@@ -540,7 +540,7 @@ fn html_flow_5_cdata() -> Result<(), String> {
 }
 
 #[test]
-fn html_flow_6_basic() -> Result<(), String> {
+fn html_flow_6_basic() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
@@ -827,7 +827,7 @@ okay.",
 }
 
 #[test]
-fn html_flow_7_complete() -> Result<(), String> {
+fn html_flow_7_complete() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/html_text.rs b/tests/html_text.rs
index e3fcd137..fb8aabb1 100644
--- a/tests/html_text.rs
+++ b/tests/html_text.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Html, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn html_text() -> Result<(), String> {
+fn html_text() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/image.rs b/tests/image.rs
index 055ac62f..19144d29 100644
--- a/tests/image.rs
+++ b/tests/image.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Definition, Image, ImageReference, Node, Paragraph, ReferenceKind, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn image() -> Result<(), String> {
+fn image() -> Result<(), message::Message> {
     assert_eq!(
         to_html("[link](/uri \"title\")"),
         "<p><a href=\"/uri\" title=\"title\">link</a></p>",
diff --git a/tests/link_reference.rs b/tests/link_reference.rs
index 40ecb1b4..a6f51759 100644
--- a/tests/link_reference.rs
+++ b/tests/link_reference.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Definition, LinkReference, Node, Paragraph, ReferenceKind, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn link_reference() -> Result<(), String> {
+fn link_reference() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/link_resource.rs b/tests/link_resource.rs
index a93eb8d6..8e8671f6 100644
--- a/tests/link_resource.rs
+++ b/tests/link_resource.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Image, Link, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Options,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn link_resource() -> Result<(), String> {
+fn link_resource() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/list.rs b/tests/list.rs
index 0c2992e6..64c91070 100644
--- a/tests/list.rs
+++ b/tests/list.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{List, ListItem, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn list() -> Result<(), String> {
+fn list() -> Result<(), message::Message> {
     let danger = Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/math_flow.rs b/tests/math_flow.rs
index 04b7fb57..0137cd1e 100644
--- a/tests/math_flow.rs
+++ b/tests/math_flow.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Math, Node, Root},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn math_flow() -> Result<(), String> {
+fn math_flow() -> Result<(), message::Message> {
     let math = Options {
         parse: ParseOptions {
             constructs: Constructs {
diff --git a/tests/math_text.rs b/tests/math_text.rs
index 598853c1..ca8c0702 100644
--- a/tests/math_text.rs
+++ b/tests/math_text.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{InlineMath, Node, Paragraph, Root, Text},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     CompileOptions, Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn math_text() -> Result<(), String> {
+fn math_text() -> Result<(), message::Message> {
     let math = Options {
         parse: ParseOptions {
             constructs: Constructs {
diff --git a/tests/mdx_esm.rs b/tests/mdx_esm.rs
index 7f766632..f7f4dff2 100644
--- a/tests/mdx_esm.rs
+++ b/tests/mdx_esm.rs
@@ -1,7 +1,7 @@
 mod test_utils;
 use markdown::{
     mdast::{MdxjsEsm, Node, Root},
-    to_html_with_options, to_mdast,
+    message, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
@@ -9,7 +9,7 @@ use pretty_assertions::assert_eq;
 use test_utils::swc::{parse_esm, parse_expression};
 
 #[test]
-fn mdx_esm() -> Result<(), String> {
+fn mdx_esm() -> Result<(), message::Message> {
     let swc = Options {
         parse: ParseOptions {
             constructs: Constructs::mdx(),
@@ -93,14 +93,20 @@ fn mdx_esm() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("import a", &swc).err().unwrap(),
-        "1:9: Could not parse esm with swc: Expected ',', got '<eof>'",
+        to_html_with_options("import a", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:9: Could not parse esm with swc: Expected ',', got '<eof>' (mdx:swc)",
         "should crash on invalid import/exports (1)"
     );
 
     assert_eq!(
-        to_html_with_options("import 1/1", &swc).err().unwrap(),
-        "1:8: Could not parse esm with swc: Expected 'from', got 'numeric literal (1, 1)'",
+        to_html_with_options("import 1/1", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:8: Could not parse esm with swc: Expected 'from', got 'numeric literal (1, 1)' (mdx:swc)",
         "should crash on invalid import/exports (2)"
     );
 
@@ -119,8 +125,9 @@ fn mdx_esm() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("import a from 'b'\n*md*?", &swc)
             .err()
-            .unwrap(),
-        "2:6: Could not parse esm with swc: Expression expected",
+            .unwrap()
+            .to_string(),
+        "2:6: Could not parse esm with swc: Expression expected (mdx:swc)",
         "should crash on markdown after import/export w/o blank line"
     );
 
@@ -133,16 +140,18 @@ fn mdx_esm() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("export var a = 1\nvar b\n\nc", &swc)
             .err()
-            .unwrap(),
-        "2:1: Unexpected statement in code: only import/exports are supported",
+            .unwrap()
+            .to_string(),
+        "2:1: Unexpected statement in code: only import/exports are supported (mdx:swc)",
         "should crash on other statements in “blocks”"
     );
 
     assert_eq!(
         to_html_with_options("import ('a')\n\nb", &swc)
             .err()
-            .unwrap(),
-        "1:1: Unexpected statement in code: only import/exports are supported",
+            .unwrap()
+            .to_string(),
+        "1:1: Unexpected statement in code: only import/exports are supported (mdx:swc)",
         "should crash on import-as-a-function with a space `import (x)`"
     );
 
diff --git a/tests/mdx_expression_flow.rs b/tests/mdx_expression_flow.rs
index 7bf39c4a..49c89b97 100644
--- a/tests/mdx_expression_flow.rs
+++ b/tests/mdx_expression_flow.rs
@@ -1,7 +1,7 @@
 mod test_utils;
 use markdown::{
     mdast::{MdxFlowExpression, Node, Root},
-    to_html_with_options, to_mdast,
+    message, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
@@ -9,7 +9,7 @@ use pretty_assertions::assert_eq;
 use test_utils::swc::{parse_esm, parse_expression};
 
 #[test]
-fn mdx_expression_flow_agnostic() -> Result<(), String> {
+fn mdx_expression_flow_agnostic() -> Result<(), message::Message> {
     let mdx = Options {
         parse: ParseOptions::mdx(),
         ..Default::default()
@@ -65,14 +65,17 @@ fn mdx_expression_flow_agnostic() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("{a", &mdx).err().unwrap(),
-        "1:3: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        to_html_with_options("{a", &mdx).err().unwrap().to_string(),
+        "1:3: Unexpected end of file in expression, expected a corresponding closing brace for `{` (markdown-rs:unexpected-eof)",
         "should crash if no closing brace is found (1)"
     );
 
     assert_eq!(
-        to_html_with_options("{b { c }", &mdx).err().unwrap(),
-        "1:9: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        to_html_with_options("{b { c }", &mdx)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:9: Unexpected end of file in expression, expected a corresponding closing brace for `{` (markdown-rs:unexpected-eof)",
         "should crash if no closing brace is found (2)"
     );
 
@@ -103,8 +106,8 @@ fn mdx_expression_flow_agnostic() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("> {a\nb}", &mdx)
             .err()
-            .unwrap(),
-        "2:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+            .unwrap().to_string(),
+        "2:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazyness (1)"
     );
 
@@ -123,8 +126,8 @@ fn mdx_expression_flow_agnostic() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("> {\n> a\nb}", &mdx)
             .err()
-            .unwrap(),
-        "3:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+            .unwrap().to_string(),
+        "3:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazyness (4)"
     );
 
@@ -145,7 +148,7 @@ fn mdx_expression_flow_agnostic() -> Result<(), String> {
 }
 
 #[test]
-fn mdx_expression_flow_gnostic() -> Result<(), String> {
+fn mdx_expression_flow_gnostic() -> Result<(), message::Message> {
     let swc = Options {
         parse: ParseOptions {
             constructs: Constructs::mdx(),
@@ -169,14 +172,17 @@ fn mdx_expression_flow_gnostic() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("{a", &swc).err().unwrap(),
-        "1:3: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        to_html_with_options("{a", &swc).err().unwrap().to_string(),
+        "1:3: Unexpected end of file in expression, expected a corresponding closing brace for `{` (markdown-rs:unexpected-eof)",
         "should crash if no closing brace is found (1)"
     );
 
     assert_eq!(
-        to_html_with_options("{b { c }", &swc).err().unwrap(),
-        "1:9: Could not parse expression with swc: Unexpected content after expression",
+        to_html_with_options("{b { c }", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:9: Could not parse expression with swc: Unexpected content after expression (mdx:swc)",
         "should crash if no closing brace is found (2)"
     );
 
@@ -220,7 +226,7 @@ fn mdx_expression_flow_gnostic() -> Result<(), String> {
 }
 
 #[test]
-fn mdx_expression_spread() -> Result<(), String> {
+fn mdx_expression_spread() -> Result<(), message::Message> {
     let swc = Options {
         parse: ParseOptions {
             constructs: Constructs::mdx(),
@@ -238,38 +244,44 @@ fn mdx_expression_spread() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("<a {b} />", &swc).err().unwrap(),
-        "1:5: Unexpected prop in spread (such as `{x}`): only a spread is supported (such as `{...x}`)",
+        to_html_with_options("<a {b} />", &swc).err().unwrap().to_string(),
+        "1:5: Unexpected prop in spread (such as `{x}`): only a spread is supported (such as `{...x}`) (mdx:swc)",
         "should crash if not a spread"
     );
 
     assert_eq!(
-        to_html_with_options("<a {...?} />", &swc).err().unwrap(),
-        "1:13: Could not parse expression with swc: Expression expected",
+        to_html_with_options("<a {...?} />", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:13: Could not parse expression with swc: Expression expected (mdx:swc)",
         "should crash on an incorrect spread"
     );
 
     assert_eq!(
-        to_html_with_options("<a {...b,c} d>", &swc).err().unwrap(),
-        "1:5: Unexpected extra content in spread (such as `{...x,y}`): only a single spread is supported (such as `{...x}`)",
+        to_html_with_options("<a {...b,c} d>", &swc).err().unwrap().to_string(),
+        "1:5: Unexpected extra content in spread (such as `{...x,y}`): only a single spread is supported (such as `{...x}`) (mdx:swc)",
         "should crash if a spread and other things"
     );
 
     assert_eq!(
-        to_html_with_options("<a {} />", &swc).err().unwrap(),
-        "1:9: Unexpected prop in spread (such as `{x}`): only a spread is supported (such as `{...x}`)",
+        to_html_with_options("<a {} />", &swc).err().unwrap().to_string(),
+        "1:9: Unexpected prop in spread (such as `{x}`): only a spread is supported (such as `{...x}`) (mdx:swc)",
         "should crash on an empty spread"
     );
 
     assert_eq!(
-        to_html_with_options("<a {a=b} />", &swc).err().unwrap(),
-        "1:12: Could not parse expression with swc: assignment property is invalid syntax",
+        to_html_with_options("<a {a=b} />", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:12: Could not parse expression with swc: assignment property is invalid syntax (mdx:swc)",
         "should crash if not an identifier"
     );
 
     assert_eq!(
-        to_html_with_options("<a {/* b */} />", &swc).err().unwrap(),
-        "1:5: Unexpected prop in spread (such as `{x}`): only a spread is supported (such as `{...x}`)",
+        to_html_with_options("<a {/* b */} />", &swc).err().unwrap().to_string(),
+        "1:5: Unexpected prop in spread (such as `{x}`): only a spread is supported (such as `{...x}`) (mdx:swc)",
         "should crash on a comment spread"
     );
 
diff --git a/tests/mdx_expression_text.rs b/tests/mdx_expression_text.rs
index 169aca3e..2590c2d8 100644
--- a/tests/mdx_expression_text.rs
+++ b/tests/mdx_expression_text.rs
@@ -1,7 +1,7 @@
 mod test_utils;
 use markdown::{
     mdast::{MdxTextExpression, Node, Paragraph, Root, Text},
-    to_html_with_options, to_mdast,
+    message, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
@@ -9,7 +9,7 @@ use pretty_assertions::assert_eq;
 use test_utils::swc::{parse_esm, parse_expression};
 
 #[test]
-fn mdx_expression_text_gnostic_core() -> Result<(), String> {
+fn mdx_expression_text_gnostic_core() -> Result<(), message::Message> {
     let swc = Options {
         parse: ParseOptions {
             constructs: Constructs::mdx(),
@@ -63,14 +63,20 @@ fn mdx_expression_text_gnostic_core() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("a {//} b", &swc).err().unwrap(),
-        "1:4: Could not parse expression with swc: Unexpected eof",
+        to_html_with_options("a {//} b", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:4: Could not parse expression with swc: Unexpected eof (mdx:swc)",
         "should crash on an incorrect line comment (1)"
     );
 
     assert_eq!(
-        to_html_with_options("a { // b } c", &swc).err().unwrap(),
-        "1:4: Could not parse expression with swc: Unexpected eof",
+        to_html_with_options("a { // b } c", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:4: Could not parse expression with swc: Unexpected eof (mdx:swc)",
         "should crash on an incorrect line comment (2)"
     );
 
@@ -119,8 +125,9 @@ fn mdx_expression_text_gnostic_core() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a {var b = \"c\"} d", &swc)
             .err()
-            .unwrap(),
-        "1:4: Could not parse expression with swc: Expression expected",
+            .unwrap()
+            .to_string(),
+        "1:4: Could not parse expression with swc: Expression expected (mdx:swc)",
         "should crash on non-expressions"
     );
 
@@ -131,16 +138,20 @@ fn mdx_expression_text_gnostic_core() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("> a {\n> b<} c", &swc).err().unwrap(),
-        "2:8: Could not parse expression with swc: Unexpected eof",
+        to_html_with_options("> a {\n> b<} c", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "2:8: Could not parse expression with swc: Unexpected eof (mdx:swc)",
         "should crash on incorrect expressions in containers (1)"
     );
 
     assert_eq!(
         to_html_with_options("> a {\n> b\n> c} d", &swc)
             .err()
-            .unwrap(),
-        "3:7: Could not parse expression with swc: Unexpected content after expression",
+            .unwrap()
+            .to_string(),
+        "3:7: Could not parse expression with swc: Unexpected content after expression (mdx:swc)",
         "should crash on incorrect expressions in containers (2)"
     );
 
@@ -148,7 +159,7 @@ fn mdx_expression_text_gnostic_core() -> Result<(), String> {
 }
 
 #[test]
-fn mdx_expression_text_agnostic() -> Result<(), String> {
+fn mdx_expression_text_agnostic() -> Result<(), message::Message> {
     let mdx = Options {
         parse: ParseOptions::mdx(),
         ..Default::default()
@@ -167,16 +178,19 @@ fn mdx_expression_text_agnostic() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("a {b c", &mdx).err().unwrap(),
-        "1:7: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        to_html_with_options("a {b c", &mdx)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:7: Unexpected end of file in expression, expected a corresponding closing brace for `{` (markdown-rs:unexpected-eof)",
         "should crash if no closing brace is found (1)"
     );
 
     assert_eq!(
         to_html_with_options("a {b { c } d", &mdx)
             .err()
-            .unwrap(),
-        "1:13: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+            .unwrap().to_string(),
+        "1:13: Unexpected end of file in expression, expected a corresponding closing brace for `{` (markdown-rs:unexpected-eof)",
         "should crash if no closing brace is found (2)"
     );
 
@@ -228,7 +242,7 @@ fn mdx_expression_text_agnostic() -> Result<(), String> {
 }
 
 #[test]
-fn mdx_expression_text_gnostic() -> Result<(), String> {
+fn mdx_expression_text_gnostic() -> Result<(), message::Message> {
     let swc = Options {
         parse: ParseOptions {
             constructs: Constructs::mdx(),
@@ -246,8 +260,11 @@ fn mdx_expression_text_gnostic() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("a {??} b", &swc).err().unwrap(),
-        "1:9: Could not parse expression with swc: Unexpected eof",
+        to_html_with_options("a {??} b", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:9: Could not parse expression with swc: Unexpected eof (mdx:swc)",
         "should crash on an incorrect expression"
     );
 
@@ -258,14 +275,20 @@ fn mdx_expression_text_gnostic() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("a {b c", &swc).err().unwrap(),
-        "1:7: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        to_html_with_options("a {b c", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:7: Unexpected end of file in expression, expected a corresponding closing brace for `{` (markdown-rs:unexpected-eof)",
         "should crash if no closing brace is found (1)"
     );
 
     assert_eq!(
-        to_html_with_options("a {b { c } d", &swc).err().unwrap(),
-        "1:13: Could not parse expression with swc: Unexpected content after expression",
+        to_html_with_options("a {b { c } d", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:13: Could not parse expression with swc: Unexpected content after expression (mdx:swc)",
         "should crash if no closing brace is found (2)"
     );
 
diff --git a/tests/mdx_jsx_flow.rs b/tests/mdx_jsx_flow.rs
index 5adf41b9..9039832b 100644
--- a/tests/mdx_jsx_flow.rs
+++ b/tests/mdx_jsx_flow.rs
@@ -1,7 +1,7 @@
 mod test_utils;
 use markdown::{
     mdast::{List, ListItem, MdxJsxFlowElement, Node, Paragraph, Root, Text},
-    to_html_with_options, to_mdast,
+    message, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
@@ -9,7 +9,7 @@ use pretty_assertions::assert_eq;
 use test_utils::swc::{parse_esm, parse_expression};
 
 #[test]
-fn mdx_jsx_flow_agnostic() -> Result<(), String> {
+fn mdx_jsx_flow_agnostic() -> Result<(), message::Message> {
     let mdx = Options {
         parse: ParseOptions::mdx(),
         ..Default::default()
@@ -90,7 +90,7 @@ fn mdx_jsx_flow_agnostic() -> Result<(), String> {
 // Flow is mostly the same as `text`, so we only test the relevant
 // differences.
 #[test]
-fn mdx_jsx_flow_essence() -> Result<(), String> {
+fn mdx_jsx_flow_essence() -> Result<(), message::Message> {
     let mdx = Options {
         parse: ParseOptions::mdx(),
         ..Default::default()
@@ -130,62 +130,62 @@ fn mdx_jsx_flow_essence() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("* <!a>\n1. b", &mdx)
             .err()
-            .unwrap(),
-        "1:4: Unexpected character `!` (U+0021) before name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a comment in MDX, use `{/* text */}`)",
+            .unwrap().to_string(),
+        "1:4: Unexpected character `!` (U+0021) before name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a comment in MDX, use `{/* text */}`) (markdown-rs:unexpected-character)",
         "should handle crash in containers gracefully"
     );
 
     assert_eq!(
-        to_html_with_options("> <X\n/>", &mdx).err().unwrap(),
-        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+         to_html_with_options("> <X\n/>", &mdx).err().unwrap().to_string(),
+        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazy flow (1)"
     );
 
     assert_eq!(
         to_html_with_options("> a\n> <X\n/>", &mdx)
             .err()
-            .unwrap(),
-        "3:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+            .unwrap().to_string(),
+        "3:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazy flow (2)"
     );
 
     assert_eq!(
         to_html_with_options("> <a b='\nc'/>", &mdx)
             .err()
-            .unwrap(),
-        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+            .unwrap().to_string(),
+        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazy flow (3)"
     );
 
     assert_eq!(
         to_html_with_options("> <a b='c\n'/>", &mdx)
             .err()
-            .unwrap(),
-        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+            .unwrap().to_string(),
+        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazy flow (4)"
     );
 
     assert_eq!(
         to_html_with_options("> <a b='c\nd'/>", &mdx)
             .err()
-            .unwrap(),
-        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+            .unwrap().to_string(),
+        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazy flow (5)"
     );
 
     assert_eq!(
         to_html_with_options("> <a b={c\nd}/>", &mdx)
             .err()
-            .unwrap(),
-        "2:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+            .unwrap().to_string(),
+        "2:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazy flow (6)"
     );
 
     assert_eq!(
         to_html_with_options("> <a {b\nc}/>", &mdx)
             .err()
-            .unwrap(),
-        "2:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+            .unwrap().to_string(),
+        "2:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc (markdown-rs:unexpected-lazy)",
         "should not support lazy flow (7)"
     );
 
@@ -232,7 +232,7 @@ fn mdx_jsx_flow_essence() -> Result<(), String> {
 // Flow is mostly the same as `text`, so we only test the relevant
 // differences.
 #[test]
-fn mdx_jsx_flow_interleaving_with_expressions() -> Result<(), String> {
+fn mdx_jsx_flow_interleaving_with_expressions() -> Result<(), message::Message> {
     let mdx = Options {
         parse: ParseOptions::mdx(),
         ..Default::default()
diff --git a/tests/mdx_jsx_text.rs b/tests/mdx_jsx_text.rs
index afd259c3..c05bd5b9 100644
--- a/tests/mdx_jsx_text.rs
+++ b/tests/mdx_jsx_text.rs
@@ -4,7 +4,7 @@ use markdown::{
         AttributeContent, AttributeValue, AttributeValueExpression, Emphasis, MdxJsxAttribute,
         MdxJsxTextElement, Node, Paragraph, Root, Text,
     },
-    to_html_with_options, to_mdast,
+    message, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
@@ -12,7 +12,7 @@ use pretty_assertions::assert_eq;
 use test_utils::swc::{parse_esm, parse_expression};
 
 #[test]
-fn mdx_jsx_text_core() -> Result<(), String> {
+fn mdx_jsx_text_core() -> Result<(), message::Message> {
     let mdx = Options {
         parse: ParseOptions::mdx(),
         ..Default::default()
@@ -419,73 +419,79 @@ fn mdx_jsx_text_core() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_mdast("a </b> c", &mdx.parse)
-            .err()
-            .unwrap(),
-        "1:4: Unexpected closing slash `/` in tag, expected an open tag first (mdx-jsx:unexpected-closing-slash)",
+        to_mdast("a </b> c", &mdx.parse).err().unwrap().to_string(),
+        "1:4: Unexpected closing slash `/` in tag, expected an open tag first (markdown-rs:unexpected-closing-slash)",
         "should crash when building the ast on a closing tag if none is open"
     );
 
     assert_eq!(
         to_mdast("a <b> c </b/> d", &mdx.parse)
             .err()
-            .unwrap(),
-        "1:12: Unexpected self-closing slash `/` in closing tag, expected the end of the tag (mdx-jsx:unexpected-self-closing-slash)",
+            .unwrap()
+            .to_string(),
+        "1:12: Unexpected self-closing slash `/` in closing tag, expected the end of the tag (markdown-rs:unexpected-self-closing-slash)",
         "should crash when building the ast on a closing tag with a self-closing slash"
     );
 
     assert_eq!(
         to_mdast("a <b> c </b d> e", &mdx.parse)
             .err()
-            .unwrap(),
-        "1:13: Unexpected attribute in closing tag, expected the end of the tag (mdx-jsx:unexpected-attribute)",
+            .unwrap()
+            .to_string(),
+        "1:13: Unexpected attribute in closing tag, expected the end of the tag (markdown-rs:unexpected-attribute)",
         "should crash when building the ast on a closing tag with an attribute"
     );
 
     assert_eq!(
         to_mdast("a <>b</c> d", &mdx.parse)
             .err()
-            .unwrap(),
-        "1:6: Unexpected closing tag `</c>`, expected corresponding closing tag for `<>` (1:3) (mdx-jsx:end-tag-mismatch)",
+            .unwrap().to_string(),
+        "1:6-1:10: Unexpected closing tag `</c>`, expected corresponding closing tag for `<>` (1:3) (markdown-rs:end-tag-mismatch)",
         "should crash when building the ast on mismatched tags (1)"
     );
 
     assert_eq!(
         to_mdast("a <b>c</> d", &mdx.parse)
             .err()
-            .unwrap(),
-        "1:7: Unexpected closing tag `</>`, expected corresponding closing tag for `<b>` (1:3) (mdx-jsx:end-tag-mismatch)",
+            .unwrap().to_string(),
+        "1:7-1:10: Unexpected closing tag `</>`, expected corresponding closing tag for `<b>` (1:3) (markdown-rs:end-tag-mismatch)",
         "should crash when building the ast on mismatched tags (2)"
     );
 
     assert_eq!(
-        to_mdast("*a <b>c* d</b>.", &mdx.parse).err().unwrap(),
-        "1:9: Expected a closing tag for `<b>` (1:4) before the end of `Emphasis` (mdx-jsx:end-tag-mismatch)",
+        to_mdast("*a <b>c* d</b>.", &mdx.parse)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:9: Expected a closing tag for `<b>` (1:4) before the end of `Emphasis` (markdown-rs:end-tag-mismatch)",
         "should crash when building the ast on mismatched interleaving (1)"
     );
 
     assert_eq!(
-        to_mdast("<a>b *c</a> d*.", &mdx.parse).err().unwrap(),
-        "1:8: Expected the closing tag `</a>` either before the start of `Emphasis` (1:6), or another opening tag after that start (mdx-jsx:end-tag-mismatch)",
+        to_mdast("<a>b *c</a> d*.", &mdx.parse).err().unwrap().to_string(),
+        "1:8: Expected the closing tag `</a>` either before the start of `Emphasis` (1:6), or another opening tag after that start (markdown-rs:end-tag-mismatch)",
         "should crash when building the ast on mismatched interleaving (2)"
     );
 
     assert_eq!(
-        to_mdast("a <b>.", &mdx.parse).err().unwrap(),
-        "1:7: Expected a closing tag for `<b>` (1:3) before the end of `Paragraph` (mdx-jsx:end-tag-mismatch)",
+        to_mdast("a <b>.", &mdx.parse).err().unwrap().to_string(),
+        "1:7: Expected a closing tag for `<b>` (1:3) before the end of `Paragraph` (markdown-rs:end-tag-mismatch)",
         "should crash when building the ast on mismatched interleaving (3)"
     );
 
     // Note: this is flow, not text.
     assert_eq!(
-        to_mdast("<a>", &mdx.parse).err().unwrap(),
-        "1:4: Expected a closing tag for `<a>` (1:1) (mdx-jsx:end-tag-mismatch)",
+        to_mdast("<a>", &mdx.parse).err().unwrap().to_string(),
+        "1:4: Expected a closing tag for `<a>` (1:1) (markdown-rs:end-tag-mismatch)",
         "should crash when building the ast on mismatched interleaving (4)"
     );
 
     assert_eq!(
-        to_mdast("<a><b></b>", &mdx.parse).err().unwrap(),
-        "1:11: Expected a closing tag for `<a>` (1:1) (mdx-jsx:end-tag-mismatch)",
+        to_mdast("<a><b></b>", &mdx.parse)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:11: Expected a closing tag for `<a>` (1:1) (markdown-rs:end-tag-mismatch)",
         "should crash on unclosed jsx after closed jsx"
     );
 
@@ -493,7 +499,7 @@ fn mdx_jsx_text_core() -> Result<(), String> {
 }
 
 #[test]
-fn mdx_jsx_text_agnosic() -> Result<(), String> {
+fn mdx_jsx_text_agnosic() -> Result<(), message::Message> {
     let mdx = Options {
         parse: ParseOptions::mdx(),
         ..Default::default()
@@ -533,7 +539,7 @@ fn mdx_jsx_text_agnosic() -> Result<(), String> {
 }
 
 #[test]
-fn mdx_jsx_text_gnostic() -> Result<(), String> {
+fn mdx_jsx_text_gnostic() -> Result<(), message::Message> {
     let swc = Options {
         parse: ParseOptions {
             constructs: Constructs::mdx(),
@@ -587,38 +593,45 @@ fn mdx_jsx_text_gnostic() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("a <b c={} /> d", &swc).err().unwrap(),
-        "1:15: Could not parse expression with swc: Unexpected eof",
+        to_html_with_options("a <b c={} /> d", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:15: Could not parse expression with swc: Unexpected eof (mdx:swc)",
         "should crash on an empty attribute value expression"
     );
 
     assert_eq!(
         to_html_with_options("a <b {1 + 1} /> c", &swc)
             .err()
-            .unwrap(),
-        "1:18: Could not parse expression with swc: Expected ',', got '}'",
+            .unwrap()
+            .to_string(),
+        "1:18: Could not parse expression with swc: Expected ',', got '}' (mdx:swc)",
         "should crash on a non-spread attribute expression"
     );
 
     assert_eq!(
-        to_html_with_options("a <b c={?} /> d", &swc).err().unwrap(),
-        "1:16: Could not parse expression with swc: Expression expected",
+        to_html_with_options("a <b c={?} /> d", &swc)
+            .err()
+            .unwrap()
+            .to_string(),
+        "1:16: Could not parse expression with swc: Expression expected (mdx:swc)",
         "should crash on invalid JS in an attribute value expression"
     );
 
     assert_eq!(
         to_html_with_options("a <b {?} /> c", &swc)
             .err()
-            .unwrap(),
-        "1:14: Could not parse expression with swc: Unexpected token `?`. Expected identifier, string literal, numeric literal or [ for the computed key",
+            .unwrap().to_string(),
+        "1:14: Could not parse expression with swc: Unexpected token `?`. Expected identifier, string literal, numeric literal or [ for the computed key (mdx:swc)",
         "should crash on invalid JS in an attribute expression"
     );
 
     assert_eq!(
         to_html_with_options("a <b{c=d}={}/> f", &swc)
             .err()
-            .unwrap(),
-        "1:6: Unexpected prop in spread (such as `{x}`): only a spread is supported (such as `{...x}`)",
+            .unwrap().to_string(),
+        "1:6: Unexpected prop in spread (such as `{x}`): only a spread is supported (such as `{...x}`) (mdx:swc)",
         "should crash on invalid JS in an attribute expression (2)"
     );
 
@@ -632,7 +645,7 @@ fn mdx_jsx_text_gnostic() -> Result<(), String> {
 }
 
 #[test]
-fn mdx_jsx_text_complete() -> Result<(), String> {
+fn mdx_jsx_text_complete() -> Result<(), message::Message> {
     let mdx = Options {
         parse: ParseOptions::mdx(),
         ..Default::default()
@@ -665,16 +678,16 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <!> b", &mdx)
             .err()
-            .unwrap(),
-        "1:4: Unexpected character `!` (U+0021) before name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a comment in MDX, use `{/* text */}`)",
+            .unwrap().to_string(),
+        "1:4: Unexpected character `!` (U+0021) before name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a comment in MDX, use `{/* text */}`) (markdown-rs:unexpected-character)",
         "should crash on a nonconforming start identifier"
     );
 
     assert_eq!(
         to_html_with_options("a </(> b.", &mdx)
             .err()
-            .unwrap(),
-        "1:5: Unexpected character `(` (U+0028) before name, expected a character that can start a name, such as a letter, `$`, or `_`",
+            .unwrap().to_string(),
+        "1:5: Unexpected character `(` (U+0028) before name, expected a character that can start a name, such as a letter, `$`, or `_` (markdown-rs:unexpected-character)",
         "should crash on a nonconforming start identifier in a closing tag"
     );
 
@@ -687,48 +700,48 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <© /> b.", &mdx)
             .err()
-            .unwrap(),
-        "1:4: Unexpected character U+00A9 before name, expected a character that can start a name, such as a letter, `$`, or `_`",
+            .unwrap().to_string(),
+        "1:4: Unexpected character U+00A9 before name, expected a character that can start a name, such as a letter, `$`, or `_` (markdown-rs:unexpected-character)",
         "should crash on non-conforming non-ascii identifier start characters"
     );
 
     assert_eq!(
         to_html_with_options("a <!--b-->", &mdx)
             .err()
-            .unwrap(),
-        "1:4: Unexpected character `!` (U+0021) before name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a comment in MDX, use `{/* text */}`)",
+            .unwrap().to_string(),
+        "1:4: Unexpected character `!` (U+0021) before name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a comment in MDX, use `{/* text */}`) (markdown-rs:unexpected-character)",
         "should crash nicely on what might be a comment"
     );
 
     assert_eq!(
         to_html_with_options("a <// b\nc/>", &mdx)
             .err()
-            .unwrap(),
-        "1:5: Unexpected character `/` (U+002F) before name, expected a character that can start a name, such as a letter, `$`, or `_` (note: JS comments in JSX tags are not supported in MDX)",
+            .unwrap().to_string(),
+        "1:5: Unexpected character `/` (U+002F) before name, expected a character that can start a name, such as a letter, `$`, or `_` (note: JS comments in JSX tags are not supported in MDX) (markdown-rs:unexpected-character)",
         "should crash nicely on JS line comments inside tags (1)"
     );
 
     assert_eq!(
         to_html_with_options("a <b// c\nd/>", &mdx)
             .err()
-            .unwrap(),
-        "1:6: Unexpected character `/` (U+002F) after self-closing slash, expected `>` to end the tag (note: JS comments in JSX tags are not supported in MDX)",
+            .unwrap().to_string(),
+        "1:6: Unexpected character `/` (U+002F) after self-closing slash, expected `>` to end the tag (note: JS comments in JSX tags are not supported in MDX) (markdown-rs:unexpected-character)",
         "should crash nicely JS line comments inside tags (2)"
     );
 
     assert_eq!(
         to_html_with_options("a </*b*/c>", &mdx)
             .err()
-            .unwrap(),
-        "1:5: Unexpected character `*` (U+002A) before name, expected a character that can start a name, such as a letter, `$`, or `_`",
+            .unwrap().to_string(),
+        "1:5: Unexpected character `*` (U+002A) before name, expected a character that can start a name, such as a letter, `$`, or `_` (markdown-rs:unexpected-character)",
         "should crash nicely JS multiline comments inside tags (1)"
     );
 
     assert_eq!(
         to_html_with_options("a <b/*c*/>", &mdx)
             .err()
-            .unwrap(),
-        "1:6: Unexpected character `*` (U+002A) after self-closing slash, expected `>` to end the tag",
+            .unwrap().to_string(),
+        "1:6: Unexpected character `*` (U+002A) after self-closing slash, expected `>` to end the tag (markdown-rs:unexpected-character)",
         "should crash nicely JS multiline comments inside tags (2)"
     );
 
@@ -741,16 +754,16 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <a¬ /> b.", &mdx)
             .err()
-            .unwrap(),
-        "1:5: Unexpected character U+00AC in name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:5: Unexpected character U+00AC in name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on non-conforming non-ascii identifier continuation characters"
     );
 
     assert_eq!(
         to_html_with_options("a <b@c.d>", &mdx)
             .err()
-            .unwrap(),
-        "1:5: Unexpected character `@` (U+0040) in name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag (note: to create a link in MDX, use `[text](url)`)",
+            .unwrap().to_string(),
+        "1:5: Unexpected character `@` (U+0040) in name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag (note: to create a link in MDX, use `[text](url)`) (markdown-rs:unexpected-character)",
         "should crash nicely on what might be an email link"
     );
 
@@ -763,8 +776,8 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <a?> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:5: Unexpected character `?` (U+003F) in name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:5: Unexpected character `?` (U+003F) in name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on nonconforming identifier continuation characters"
     );
 
@@ -775,10 +788,10 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     );
 
     assert_eq!(
-        to_html_with_options("a <b.c@d.e>", &mdx)
+         to_html_with_options("a <b.c@d.e>", &mdx)
             .err()
-            .unwrap(),
-        "1:7: Unexpected character `@` (U+0040) in member name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag (note: to create a link in MDX, use `[text](url)`)",
+            .unwrap().to_string(),
+        "1:7: Unexpected character `@` (U+0040) in member name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag (note: to create a link in MDX, use `[text](url)`) (markdown-rs:unexpected-character)",
         "should crash nicely on what might be an email link in member names"
     );
 
@@ -791,72 +804,72 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <a:+> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:6: Unexpected character `+` (U+002B) before local name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a link in MDX, use `[text](url)`)",
+            .unwrap().to_string(),
+        "1:6: Unexpected character `+` (U+002B) before local name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a link in MDX, use `[text](url)`) (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character to start a local name"
     );
 
     assert_eq!(
         to_html_with_options("a <http://example.com>", &mdx)
             .err()
-            .unwrap(),
-        "1:9: Unexpected character `/` (U+002F) before local name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a link in MDX, use `[text](url)`)",
+            .unwrap().to_string(),
+        "1:9: Unexpected character `/` (U+002F) before local name, expected a character that can start a name, such as a letter, `$`, or `_` (note: to create a link in MDX, use `[text](url)`) (markdown-rs:unexpected-character)",
         "should crash nicely on what might be a protocol in local names"
     );
 
     assert_eq!(
         to_html_with_options("a <http: >", &mdx)
             .err()
-            .unwrap(),
-        "1:10: Unexpected character `>` (U+003E) before local name, expected a character that can start a name, such as a letter, `$`, or `_`",
+            .unwrap().to_string(),
+        "1:10: Unexpected character `>` (U+003E) before local name, expected a character that can start a name, such as a letter, `$`, or `_` (markdown-rs:unexpected-character)",
         "should crash nicely on what might be a protocol in local names"
     );
 
     assert_eq!(
         to_html_with_options("a <a:b|> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:7: Unexpected character `|` (U+007C) in local name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:7: Unexpected character `|` (U+007C) in local name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character in a local name"
     );
 
     assert_eq!(
         to_html_with_options("a <a..> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:6: Unexpected character `.` (U+002E) before member name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:6: Unexpected character `.` (U+002E) before member name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character to start a member name"
     );
 
     assert_eq!(
         to_html_with_options("a <a.b,> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:7: Unexpected character `,` (U+002C) in member name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:7: Unexpected character `,` (U+002C) in member name, expected a name character such as letters, digits, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character in a member name"
     );
 
     assert_eq!(
         to_html_with_options("a <a:b .> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:8: Unexpected character `.` (U+002E) after local name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:8: Unexpected character `.` (U+002E) after local name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character after a local name"
     );
 
     assert_eq!(
         to_html_with_options("a <a.b :> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:8: Unexpected character `:` (U+003A) after member name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:8: Unexpected character `:` (U+003A) after member name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character after a member name"
     );
 
     assert_eq!(
         to_html_with_options("a <a => c.", &mdx)
             .err()
-            .unwrap(),
-        "1:6: Unexpected character `=` (U+003D) after name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:6: Unexpected character `=` (U+003D) after name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character after name"
     );
 
@@ -917,24 +930,24 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <b {...p}~>c</b>.", &mdx)
             .err()
-            .unwrap(),
-        "1:12: Unexpected character `~` (U+007E) before attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:12: Unexpected character `~` (U+007E) before attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character before an attribute name"
     );
 
     assert_eq!(
         to_html_with_options("a <b {...", &mdx)
             .err()
-            .unwrap(),
-        "1:10: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+            .unwrap().to_string(),
+        "1:10: Unexpected end of file in expression, expected a corresponding closing brace for `{` (markdown-rs:unexpected-eof)",
         "should crash on a missing closing brace in attribute expression"
     );
 
     assert_eq!(
         to_html_with_options("a <a b@> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:7: Unexpected character `@` (U+0040) in attribute name, expected an attribute name character such as letters, digits, `$`, or `_`; `=` to initialize a value; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:7: Unexpected character `@` (U+0040) in attribute name, expected an attribute name character such as letters, digits, `$`, or `_`; `=` to initialize a value; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character in attribute name"
     );
 
@@ -953,32 +966,32 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <a b 1> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:8: Unexpected character `1` (U+0031) after attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag",
+            .unwrap().to_string(),
+        "1:8: Unexpected character `1` (U+0031) after attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character after an attribute name"
     );
 
     assert_eq!(
         to_html_with_options("a <a b:#> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:8: Unexpected character `#` (U+0023) before local attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag",
+            .unwrap().to_string(),
+        "1:8: Unexpected character `#` (U+0023) before local attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character to start a local attribute name"
     );
 
     assert_eq!(
         to_html_with_options("a <a b:c%> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:9: Unexpected character `%` (U+0025) in local attribute name, expected an attribute name character such as letters, digits, `$`, or `_`; `=` to initialize a value; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:9: Unexpected character `%` (U+0025) in local attribute name, expected an attribute name character such as letters, digits, `$`, or `_`; `=` to initialize a value; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character in a local attribute name"
     );
 
     assert_eq!(
         to_html_with_options("a <a b:c ^> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:10: Unexpected character `^` (U+005E) after local attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag",
+            .unwrap().to_string(),
+        "1:10: Unexpected character `^` (U+005E) after local attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; `=` to initialize a value; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character after a local attribute name"
     );
 
@@ -997,48 +1010,48 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <a b=``> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:8: Unexpected character `` ` `` (U+0060) before attribute value, expected a character that can start an attribute value, such as `\"`, `'`, or `{`",
+            .unwrap().to_string(),
+        "1:8: Unexpected character `` ` `` (U+0060) before attribute value, expected a character that can start an attribute value, such as `\"`, `'`, or `{` (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character before an attribute value"
     );
 
     assert_eq!(
         to_html_with_options("a <a b=<c />> d.", &mdx)
             .err()
-            .unwrap(),
-        "1:8: Unexpected character `<` (U+003C) before attribute value, expected a character that can start an attribute value, such as `\"`, `'`, or `{` (note: to use an element or fragment as a prop value in MDX, use `{<element />}`)",
+            .unwrap().to_string(),
+        "1:8: Unexpected character `<` (U+003C) before attribute value, expected a character that can start an attribute value, such as `\"`, `'`, or `{` (note: to use an element or fragment as a prop value in MDX, use `{<element />}`) (markdown-rs:unexpected-character)",
         "should crash nicely on what might be a fragment, element as prop value"
     );
 
     assert_eq!(
         to_html_with_options("a <a b=\"> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:13: Unexpected end of file in attribute value, expected a corresponding closing quote `\"` (U+0022)",
+            .unwrap().to_string(),
+        "1:13: Unexpected end of file in attribute value, expected a corresponding closing quote `\"` (U+0022) (markdown-rs:unexpected-eof)",
         "should crash on a missing closing quote in double quoted attribute value"
     );
 
     assert_eq!(
         to_html_with_options("a <a b=\"> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:13: Unexpected end of file in attribute value, expected a corresponding closing quote `\"` (U+0022)",
+            .unwrap().to_string(),
+        "1:13: Unexpected end of file in attribute value, expected a corresponding closing quote `\"` (U+0022) (markdown-rs:unexpected-eof)",
         "should crash on a missing closing quote in single quoted attribute value"
     );
 
     assert_eq!(
         to_html_with_options("a <a b={> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:13: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+            .unwrap().to_string(),
+        "1:13: Unexpected end of file in expression, expected a corresponding closing brace for `{` (markdown-rs:unexpected-eof)",
         "should crash on a missing closing brace in an attribute value expression"
     );
 
     assert_eq!(
         to_html_with_options("a <a b=\"\"*> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:10: Unexpected character `*` (U+002A) before attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag",
+            .unwrap().to_string(),
+        "1:10: Unexpected character `*` (U+002A) before attribute name, expected a character that can start an attribute name, such as a letter, `$`, or `_`; whitespace before attributes; or the end of the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character after an attribute value"
     );
 
@@ -1057,8 +1070,8 @@ fn mdx_jsx_text_complete() -> Result<(), String> {
     assert_eq!(
         to_html_with_options("a <a/b> c.", &mdx)
             .err()
-            .unwrap(),
-        "1:6: Unexpected character `b` (U+0062) after self-closing slash, expected `>` to end the tag",
+            .unwrap().to_string(),
+        "1:6: Unexpected character `b` (U+0062) after self-closing slash, expected `>` to end the tag (markdown-rs:unexpected-character)",
         "should crash on a nonconforming character after a self-closing slash"
     );
 
diff --git a/tests/mdx_swc.rs b/tests/mdx_swc.rs
index 831e64fa..8a33456a 100644
--- a/tests/mdx_swc.rs
+++ b/tests/mdx_swc.rs
@@ -1,10 +1,10 @@
 mod test_utils;
-use markdown::{to_html_with_options, Constructs, Options, ParseOptions};
+use markdown::{message, to_html_with_options, Constructs, Options, ParseOptions};
 use pretty_assertions::assert_eq;
 use test_utils::swc::{parse_esm, parse_expression};
 
 #[test]
-fn mdx_swc() -> Result<(), String> {
+fn mdx_swc() -> Result<(), message::Message> {
     let swc = Options {
         parse: ParseOptions {
             constructs: Constructs::mdx(),
diff --git a/tests/misc_dangerous_html.rs b/tests/misc_dangerous_html.rs
index 516da654..66769364 100644
--- a/tests/misc_dangerous_html.rs
+++ b/tests/misc_dangerous_html.rs
@@ -1,8 +1,8 @@
-use markdown::{to_html, to_html_with_options, CompileOptions, Options};
+use markdown::{message, to_html, to_html_with_options, CompileOptions, Options};
 use pretty_assertions::assert_eq;
 
 #[test]
-fn dangerous_html() -> Result<(), String> {
+fn dangerous_html() -> Result<(), message::Message> {
     let danger = &Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/misc_default_line_ending.rs b/tests/misc_default_line_ending.rs
index 10a82939..1873b6c2 100644
--- a/tests/misc_default_line_ending.rs
+++ b/tests/misc_default_line_ending.rs
@@ -1,8 +1,8 @@
-use markdown::{to_html, to_html_with_options, CompileOptions, LineEnding, Options};
+use markdown::{message, to_html, to_html_with_options, CompileOptions, LineEnding, Options};
 use pretty_assertions::assert_eq;
 
 #[test]
-fn default_line_ending() -> Result<(), String> {
+fn default_line_ending() -> Result<(), message::Message> {
     assert_eq!(
         to_html("> a"),
         "<blockquote>\n<p>a</p>\n</blockquote>",
diff --git a/tests/misc_line_ending.rs b/tests/misc_line_ending.rs
index 355c8d4f..46c12e2d 100644
--- a/tests/misc_line_ending.rs
+++ b/tests/misc_line_ending.rs
@@ -1,8 +1,8 @@
-use markdown::{to_html, to_html_with_options, CompileOptions, Options};
+use markdown::{message, to_html, to_html_with_options, CompileOptions, Options};
 use pretty_assertions::assert_eq;
 
 #[test]
-fn line_ending() -> Result<(), String> {
+fn line_ending() -> Result<(), message::Message> {
     let danger = &Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/misc_tabs.rs b/tests/misc_tabs.rs
index 1ad51278..7d5612f4 100644
--- a/tests/misc_tabs.rs
+++ b/tests/misc_tabs.rs
@@ -1,8 +1,8 @@
-use markdown::{to_html, to_html_with_options, CompileOptions, Options};
+use markdown::{message, to_html, to_html_with_options, CompileOptions, Options};
 use pretty_assertions::assert_eq;
 
 #[test]
-fn tabs_flow() -> Result<(), String> {
+fn tabs_flow() -> Result<(), message::Message> {
     let danger = &Options {
         compile: CompileOptions {
             allow_dangerous_html: true,
diff --git a/tests/misc_zero.rs b/tests/misc_zero.rs
index ed9f1bcb..d4613968 100644
--- a/tests/misc_zero.rs
+++ b/tests/misc_zero.rs
@@ -1,12 +1,12 @@
 use markdown::{
     mdast::{Node, Root},
-    to_html, to_mdast,
+    message, to_html, to_mdast,
     unist::Position,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn zero() -> Result<(), String> {
+fn zero() -> Result<(), message::Message> {
     assert_eq!(to_html(""), "", "should support no markdown");
 
     assert_eq!(
diff --git a/tests/test_utils/swc.rs b/tests/test_utils/swc.rs
index e7ec6817..fb4b71e8 100644
--- a/tests/test_utils/swc.rs
+++ b/tests/test_utils/swc.rs
@@ -180,12 +180,14 @@ pub fn flat_comments(single_threaded_comments: SingleThreadedComments) -> Vec<Co
 /// * If the error happens at `value_len`, yields `MdxSignal::Eof`
 /// * Else, yields `MdxSignal::Error`.
 fn swc_error_to_signal(span: Span, reason: &str, value_len: usize) -> MdxSignal {
+    let source = Box::new("mdx".into());
+    let rule_id = Box::new("swc".into());
     let error_end = span.hi.to_usize();
 
     if error_end >= value_len {
-        MdxSignal::Eof(reason.into())
+        MdxSignal::Eof(reason.into(), source, rule_id)
     } else {
-        MdxSignal::Error(reason.into(), span.lo.to_usize())
+        MdxSignal::Error(reason.into(), span.lo.to_usize(), source, rule_id)
     }
 }
 
diff --git a/tests/thematic_break.rs b/tests/thematic_break.rs
index 4721d49f..8ef1ee47 100644
--- a/tests/thematic_break.rs
+++ b/tests/thematic_break.rs
@@ -1,13 +1,13 @@
 use markdown::{
     mdast::{Node, Root, ThematicBreak},
-    to_html, to_html_with_options, to_mdast,
+    message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
 use pretty_assertions::assert_eq;
 
 #[test]
-fn thematic_break() -> Result<(), String> {
+fn thematic_break() -> Result<(), message::Message> {
     assert_eq!(
         to_html("***\n---\n___"),
         "<hr />\n<hr />\n<hr />",