diff --git a/Cargo.lock b/Cargo.lock
index ed343578..d81b381e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -85,6 +85,16 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "ariadne"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8454c8a44ce2cb9cc7e7fae67fc6128465b343b92c6631e94beca3c8d1524ea5"
+dependencies = [
+ "unicode-width",
+ "yansi",
+]
+
 [[package]]
 name = "assert_fs"
 version = "1.1.4"
@@ -1105,6 +1115,7 @@ dependencies = [
 name = "sed"
 version = "0.2.0"
 dependencies = [
+ "ariadne",
  "assert_fs",
  "chrono",
  "clap",
@@ -1453,6 +1464,7 @@ version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f24a5910ebbf2c0baf486a9125705f8e026a8f7741a3ea8cf5eca3c9257c9bdf"
 dependencies = [
+ "ariadne",
  "clap",
  "dns-lookup",
  "fluent",
diff --git a/Cargo.toml b/Cargo.toml
index 67c255c3..49fc6172 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,6 +40,7 @@ feat_common_core = ["sed"]
 sed = []
 
 [workspace.dependencies]
+ariadne = "0.6.0"
 assert_fs = "1.1.3"
 chrono = { version = "0.4.37", default-features = false, features = [
   "clock",
@@ -62,12 +63,13 @@ sha2 = { version = "0.11.0", default-features = false, features = ["alloc"] }
 tempfile = "3.10.1"
 terminal_size = "0.4.2"
 textwrap = { version = "0.16.1", features = ["terminal_size"] }
-uucore = { version = "0.12.0", features = ["libc"] }
+uucore = { version = "0.12.0", features = ["diagnostics", "libc"] }
 rustix = "1.1.4"
 xattr = "1.3.1"
 
 
 [dependencies]
+ariadne = { workspace = true }
 clap = { workspace = true }
 clap_complete = { workspace = true }
 clap_mangen = { workspace = true }
diff --git a/README.md b/README.md
index ce60d17e..40ca9b83 100644
--- a/README.md
+++ b/README.md
@@ -88,73 +88,8 @@ cargo test
 ```
 
 ## Extensions and incompatibilities
-### Supported GNU extensions
-* Command-line arguments can be specified in long (`--`) form.
-* Spaces can precede a regular expression modifier.
-* `I` can be used in as a synonym for the `i` (case insensitive) substitution
-  flag.
-* `M` and `m` substitution flags allow multi-line matching.
-* In addition to `\n`, other escape sequences (octal, hex, C) are supported
-  in the strings of the `y` command.
-  Under POSIX these yield undefined behavior.
-* The `a`, `c`, and `i` commands do not require an initial backslash,
-  allow text to appear on the same line, and support escape sequences
-  in the specified text.
-* The `a`, `i`, `=`, `l`, `q` and `r` commands support address range as an extension to POSIX.
-* The substitution command replacement group `\0` is a synonym for &.
-* An `F` command outputs the name of the file currently being processed.
-* A `Q` command (optionally followed by an exit code) quits immediately.
-* The `q` command can be optionally followed by an exit code.
-* A `W` command writes to a file the pattern's first line.
-* An `R` command reads one line at a time from a file.
-* The `l` command can be optionally followed by the output width.
-* The `--follow-symlinks` option for in-place editing.
-* The `--sandbox` option that limits potentially destructive commands.
-* Address 0 can be used to specify an address range that is already
-  active on line 1 and can finish with the specified regular expression.
-* Address steps can be specified in the form of start~step and start,~step
-  ranges.
-* Address 0 can be used in the `r` command to prepend a file.
-
-### Supported BSD and GNU extensions
-* The second address in a range can be specified as a relative address with +N.
-* In-place editing of file with the `-i` flag.
-
-### New extensions
-* Unicode characters can be specified in regular expression pattern, replacement
-  and transliteration sequences using `\uXXXX` or `\UXXXXXXXX` sequences.
-
-### Incompatible extensions
-The `-U` or `--uutil-extensions` option enables useful extensions or bug fixes
-that aren't compatible with GNU sed or POSIX.
-
-* The `l` command lists Unicode characters using the `\uXXXX` and `\UXXXXXXXX`
-  escapes rather than as octal UTF-8 byte sequences.
-
-### Incompatibilities
-* Similarly to GNU _sed_, input is processed as raw bytes or as valid UTF-8
-  (this includes 7-bit ASCII) based on the locale as specified by the
-  `LC_ALL`, `LC_CTYPE`, and `LANG` environment variables,
-  with the default being byte processing.
-  However, in contrast with GNU _sed_, other locales (e.g. ISO-8859-1)
-  are not supported. If the input is in another code page or encoding
-  and requires locale-specific processing (e.g. ignore/map case,
-  character classes), consider converting it through UTF-8 to ensure
-  the correct handling of locale-specific regular expressions.
-  This _sed_ program can also handle arbitrary byte sequences
-  if no part of the input requires treating it as a Rust String.
-* Back-references aren't supported when input is processed as bytes
-  (`LC_ALL=C`).
-* The command will report an error and fail if duplicate labels are found
-  in the script.
-  This matches the BSD behavior. The GNU version accepts duplicate labels.
-* The last line (`$`) address is interpreted as the last non-empty line of
-  the last file.  If files specified in subsequent arguments until the last
-  one are empty, then the last line condition will never be triggered.
-  This behavior is consistent with the
-  [original implementation](https://github.com/dspinellis/unix-history-repo/blob/Research-V7/usr/src/cmd/sed/sed1.c#L665).
-* Labels are parsed for alphanumeric characters. The BSD version parses them
-  until the end of the line, preventing ; to be used as a separator.
+The GNU, BSD and new extensions _sed_ supports, and where it differs from GNU
+_sed_, are listed in [docs/src/extensions.md](docs/src/extensions.md).
 
 ## GNU test suite compatibility
 
diff --git a/docs/.gitignore b/docs/.gitignore
new file mode 100644
index 00000000..7585238e
--- /dev/null
+++ b/docs/.gitignore
@@ -0,0 +1 @@
+book
diff --git a/docs/book.toml b/docs/book.toml
new file mode 100644
index 00000000..1e203748
--- /dev/null
+++ b/docs/book.toml
@@ -0,0 +1,8 @@
+[book]
+language = "en"
+multilingual = false
+src = "src"
+title = "uutils sed Documentation"
+
+[output.html]
+git-repository-url = "https://github.com/uutils/sed/tree/main/docs/src"
diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
new file mode 100644
index 00000000..21ccb4b9
--- /dev/null
+++ b/docs/src/SUMMARY.md
@@ -0,0 +1,5 @@
+# Summary
+
+[Introduction](index.md)
+
+* [Extensions and incompatibilities](extensions.md)
diff --git a/docs/src/extensions.md b/docs/src/extensions.md
new file mode 100644
index 00000000..9d68c971
--- /dev/null
+++ b/docs/src/extensions.md
@@ -0,0 +1,150 @@
+# Extensions and incompatibilities
+
+The main goal of the project is compatibility with GNU _sed_, but _sed_ also
+supports features that GNU _sed_ does not, and differs from it in a few places.
+Below is a list of these extensions and incompatibilities.
+
+## Supported GNU extensions
+* Command-line arguments can be specified in long (`--`) form.
+* Spaces can precede a regular expression modifier.
+* `I` can be used in as a synonym for the `i` (case insensitive) substitution
+  flag.
+* `M` and `m` substitution flags allow multi-line matching.
+* In addition to `\n`, other escape sequences (octal, hex, C) are supported
+  in the strings of the `y` command.
+  Under POSIX these yield undefined behavior.
+* The `a`, `c`, and `i` commands do not require an initial backslash,
+  allow text to appear on the same line, and support escape sequences
+  in the specified text.
+* The `a`, `i`, `=`, `l`, `q` and `r` commands support address range as an extension to POSIX.
+* The substitution command replacement group `\0` is a synonym for &.
+* An `F` command outputs the name of the file currently being processed.
+* A `Q` command (optionally followed by an exit code) quits immediately.
+* The `q` command can be optionally followed by an exit code.
+* A `W` command writes to a file the pattern's first line.
+* An `R` command reads one line at a time from a file.
+* The `l` command can be optionally followed by the output width.
+* The `--follow-symlinks` option for in-place editing.
+* The `--sandbox` option that limits potentially destructive commands.
+* Address 0 can be used to specify an address range that is already
+  active on line 1 and can finish with the specified regular expression.
+* Address steps can be specified in the form of start~step and start,~step
+  ranges.
+* Address 0 can be used in the `r` command to prepend a file.
+
+## Supported BSD and GNU extensions
+* The second address in a range can be specified as a relative address with +N.
+* In-place editing of file with the `-i` flag.
+
+## New extensions
+* Unicode characters can be specified in regular expression pattern, replacement
+  and transliteration sequences using `\uXXXX` or `\UXXXXXXXX` sequences.
+* Script errors are reported with the offending line quoted back and the
+  character at fault underlined, whenever standard error is a terminal. See
+  [Script error diagnostics](#script-error-diagnostics).
+
+## Script error diagnostics
+When standard error is a terminal, a script error is followed by the script
+line it was found on, with the character at fault underlined. The usual
+one-line message always comes first and is unchanged, and when standard error
+is a pipe or a file it is the whole of the output, so nothing that parses
+_sed_'s output is affected.
+
+The `UUTILS_DIAG` environment variable overrides the terminal check, as it does
+for the other uutils: `never` always gives the single-line message, and
+`always` gives the report even when redirected. Colors follow `NO_COLOR`.
+
+Positions are `input:line:column`, where input is the script file name or
+`<script argument N>`, and the column counts bytes, as in GNU _sed_.
+
+An invalid substitute flag:
+```
+$ sed 's/a/b/q'
+sed: <script argument 1>:1:7: error: invalid substitute flag: 'q'
+   ╭─[ <script argument 1>:1:7 ]
+   │
+ 1 │ s/a/b/q
+   │       ┬
+   │       ╰── here
+───╯
+```
+
+An error at the end of the line points just past the last character:
+```
+$ sed '/adrift'
+sed: <script argument 1>:1:8: error: unterminated regular expression
+   ╭─[ <script argument 1>:1:8 ]
+   │
+ 1 │ /adrift
+   │        ┬
+   │        ╰── here
+───╯
+```
+
+In a script file, the file name and line number are shown:
+```
+$ cat edit.sed
+s/foo/bar/
+/start/,/end/{
+  s/x/y/g
+  y/abc/de/
+}
+$ sed -f edit.sed
+sed: edit.sed:4:11: error: transliteration strings are not the same length
+   ╭─[ edit.sed:4:11 ]
+   │
+ 4 │   y/abc/de/
+   │           ┬
+   │           ╰── here
+───╯
+```
+
+Errors found only once the whole script is compiled, such as a branch to an
+undefined label, still quote the line they came from:
+```
+$ sed -e p -e 'b nowhere'
+sed: <script argument 2>:1:1: error: undefined label `nowhere'
+   ╭─[ <script argument 2>:1:1 ]
+   │
+ 1 │ b nowhere
+   │ ┬
+   │ ╰── here
+───╯
+```
+
+Other errors reported this way include an unknown command (`sed k`), an
+unexpected `}` (`sed 'p}'`), a repeated `!` (`sed '/x/!!p'`), a missing label
+or file name (`sed ':'`, `sed r`), a missing `a` text (`sed 'a'`) and an invalid
+regular expression (`sed 's/\(a/b/'`).
+
+## Incompatible extensions
+The `-U` or `--uutil-extensions` option enables useful extensions or bug fixes
+that aren't compatible with GNU sed or POSIX.
+
+* The `l` command lists Unicode characters using the `\uXXXX` and `\UXXXXXXXX`
+  escapes rather than as octal UTF-8 byte sequences.
+
+## Incompatibilities
+* Similarly to GNU _sed_, input is processed as raw bytes or as valid UTF-8
+  (this includes 7-bit ASCII) based on the locale as specified by the
+  `LC_ALL`, `LC_CTYPE`, and `LANG` environment variables,
+  with the default being byte processing.
+  However, in contrast with GNU _sed_, other locales (e.g. ISO-8859-1)
+  are not supported. If the input is in another code page or encoding
+  and requires locale-specific processing (e.g. ignore/map case,
+  character classes), consider converting it through UTF-8 to ensure
+  the correct handling of locale-specific regular expressions.
+  This _sed_ program can also handle arbitrary byte sequences
+  if no part of the input requires treating it as a Rust String.
+* Back-references aren't supported when input is processed as bytes
+  (`LC_ALL=C`).
+* The command will report an error and fail if duplicate labels are found
+  in the script.
+  This matches the BSD behavior. The GNU version accepts duplicate labels.
+* The last line (`$`) address is interpreted as the last non-empty line of
+  the last file.  If files specified in subsequent arguments until the last
+  one are empty, then the last line condition will never be triggered.
+  This behavior is consistent with the
+  [original implementation](https://github.com/dspinellis/unix-history-repo/blob/Research-V7/usr/src/cmd/sed/sed1.c#L665).
+* Labels are parsed for alphanumeric characters. The BSD version parses them
+  until the end of the line, preventing ; to be used as a separator.
diff --git a/docs/src/index.md b/docs/src/index.md
new file mode 100644
index 00000000..12622f2c
--- /dev/null
+++ b/docs/src/index.md
@@ -0,0 +1,10 @@
+# uutils sed
+
+_sed_ is a Rust reimplementation of the
+[sed utility](https://pubs.opengroup.org/onlinepubs/9799919799/utilities/sed.html)
+with some [GNU sed](https://www.gnu.org/software/sed/manual/sed.html),
+[FreeBSD sed](https://man.freebsd.org/cgi/man.cgi?sed(1)),
+and other extensions.
+
+It is part of the [uutils](https://uutils.github.io/) project. The source code
+is on [GitHub](https://github.com/uutils/sed).
diff --git a/src/sed/error_handling.rs b/src/sed/error_handling.rs
index 8f2bb250..2f0c529b 100644
--- a/src/sed/error_handling.rs
+++ b/src/sed/error_handling.rs
@@ -12,8 +12,13 @@ use crate::sed::command::ProcessingContext;
 use crate::sed::script_char_provider::ScriptCharProvider;
 use crate::sed::script_line_provider::ScriptLineProvider;
 
+use std::env;
+use std::io::{IsTerminal, stderr};
+use std::ops::Range;
 use std::rc::Rc;
 
+use ariadne::{CharSet, Color, Config, IndexType, Label, Report, ReportKind, Source};
+use uucore::diagnostics::enabled;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
 
@@ -23,6 +28,11 @@ pub struct ScriptLocation {
     pub input_name: Rc<str>,  // Shared input name
     pub line_number: usize,   // 1-based line number
     pub column_number: usize, // 1-based column number
+    /// The script line itself, kept so that an error raised long after the
+    /// line was consumed can still underline it. `None` when diagnostics are
+    /// off -- down a pipe, say -- since the line provider streams and every
+    /// compiled command would otherwise pay for a copy nobody reads.
+    pub line_text: Option<Rc<str>>,
 }
 
 impl Default for ScriptLocation {
@@ -31,6 +41,7 @@ impl Default for ScriptLocation {
             input_name: Rc::from("<unknown>"),
             line_number: 1,
             column_number: 1,
+            line_text: None,
         }
     }
 }
@@ -42,10 +53,122 @@ impl ScriptLocation {
             line_number: lines.get_line_number(),
             column_number: line.get_pos() + 1,
             input_name: Rc::from(lines.get_input_name()),
+            line_text: if enabled() { line.line_text() } else { None },
         }
     }
 }
 
+/// Append an underlined view of the offending script line to `message`, when
+/// the error is going to a terminal (or `UUTILS_DIAG` insists).
+///
+/// The first line of the result is always the message the caller built, so
+/// existing output is only ever added to -- and down a pipe, where anything
+/// parsing sed's output lives, it is the whole of it. Anything that cannot be
+/// drawn -- a script that is not valid UTF-8, an empty line, a location with no
+/// line recorded, an error hit once the whole script has been read -- yields the message unchanged.
+fn with_snippet(
+    message: String,
+    input_name: &str,
+    line_number: usize,
+    column_number: usize,
+    line_text: Option<&str>,
+) -> String {
+    // Line 0 means the script ran out before the error was noticed: the
+    // message names no line, so there is none to point at.
+    if !enabled() || line_number == 0 {
+        return message;
+    }
+    let Some(text) = line_text else {
+        return message;
+    };
+    if text.is_empty() {
+        return message;
+    }
+
+    // Errors that run off the end of the line -- an unterminated regular
+    // expression, a missing argument -- report the column just past the last
+    // character. Give the caret a space to sit on there, so that the column
+    // drawn is the one the message names rather than one short of it.
+    let text = if column_number > text.len() {
+        format!("{text} ")
+    } else {
+        text.to_string()
+    };
+    // `column_number` is a 1-based *byte* column, and anything further out than
+    // the space just added is not a position in this line at all.
+    let start = column_number - 1;
+    let Some(offending) = text.get(start..).and_then(|rest| rest.chars().next()) else {
+        return message;
+    };
+
+    // Only the offending line is still in hand -- the provider streams and
+    // keeps no history -- but the report should show the line number the
+    // message quotes. Pad with the missing newlines so that the line lands
+    // where it belongs, and move the span along with it. (ariadne's
+    // display_line_offset renumbers the header but not the gutter.)
+    let padding = "\n".repeat(line_number - 1);
+    let start = start + padding.len();
+    let source = padding + &text;
+
+    let span = start..start + offending.len_utf8();
+    match render_snippet(input_name, &source, span, line_number, column_number) {
+        Some(drawn) => format!("{message}\n{drawn}"),
+        None => message,
+    }
+}
+
+/// Draw `source` with the bytes in `span` underlined, headed by the same
+/// `input_name:line_number:column_number` the message names.
+///
+/// Returns `None` when ariadne cannot draw it, so that the caller keeps the
+/// plain message.
+fn render_snippet(
+    input_name: &str,
+    source: &str,
+    span: Range<usize>,
+    line_number: usize,
+    column_number: usize,
+) -> Option<String> {
+    let color = env::var_os("NO_COLOR").is_none() && stderr().is_terminal();
+    let config = Config::default()
+        // Columns are byte columns, as in the message; ariadne would count
+        // characters otherwise and drift on multi-byte scripts.
+        .with_index_type(IndexType::Byte)
+        .with_color(color)
+        .with_char_set(CharSet::Unicode);
+    let label = Label::new((input_name, span.clone()))
+        .with_color(Color::Red)
+        .with_message("here");
+
+    let mut rendered = Vec::new();
+    Report::build(ReportKind::Error, (input_name, span))
+        .with_config(config)
+        .with_label(label)
+        .finish()
+        .write((input_name, Source::from(source)), &mut rendered)
+        .ok()?;
+
+    // ariadne heads every report with its own, untranslated "Error:" line; the
+    // message sed already printed takes its place.
+    let rendered = String::from_utf8_lossy(&rendered);
+    let (_, body) = rendered.split_once('\n')?;
+    let (header, body) = body.split_once('\n')?;
+
+    // ariadne's header counts characters even when told to index bytes, while
+    // sed's message counts bytes, as GNU sed does. Swap in the message's own
+    // position, so that the two agree on a multi-byte line.
+    let prefix = format!("{input_name}:");
+    let from = header.find(&prefix)?;
+    let position = from + prefix.len();
+    let to = position + header[position..].find(' ')?;
+    Some(format!(
+        "{}{prefix}{line_number}:{column_number}{}\n{}",
+        &header[..from],
+        &header[to..],
+        body.trim_end_matches('\n')
+    ))
+}
+
 /// Fail with msg as a compile error at the provider location.
 /// The error's exit code is 1 (compilation phase).
 pub fn compilation_error<T>(
@@ -53,14 +176,24 @@ pub fn compilation_error<T>(
     line: &ScriptCharProvider,
     msg: impl ToString,
 ) -> UResult<T> {
+    let input_name = lines.get_input_name();
+    let line_number = lines.get_line_number();
+    let column_number = line.get_pos() + 1;
+    let message = format!(
+        "{}:{}:{}: error: {}",
+        input_name,
+        line_number,
+        column_number,
+        msg.to_string()
+    );
     Err(USimpleError::new(
         1,
-        format!(
-            "{}:{}:{}: error: {}",
-            lines.get_input_name(),
-            lines.get_line_number(),
-            line.get_pos() + 1,
-            msg.to_string()
+        with_snippet(
+            message,
+            input_name,
+            line_number,
+            column_number,
+            str::from_utf8(line.get_line()).ok(),
         ),
     ))
 }
@@ -68,14 +201,21 @@ pub fn compilation_error<T>(
 /// Fail with msg as a compilation error at the command's location.
 /// The error's exit code is as specified.
 fn location_error<T>(location: &ScriptLocation, msg: impl ToString, exit_code: i32) -> UResult<T> {
+    let message = format!(
+        "{}:{}:{}: error: {}",
+        location.input_name,
+        location.line_number,
+        location.column_number,
+        msg.to_string()
+    );
     Err(USimpleError::new(
         exit_code,
-        format!(
-            "{}:{}:{}: error: {}",
-            location.input_name,
+        with_snippet(
+            message,
+            &location.input_name,
             location.line_number,
             location.column_number,
-            msg.to_string()
+            location.line_text.as_deref(),
         ),
     ))
 }
diff --git a/src/sed/script_char_provider.rs b/src/sed/script_char_provider.rs
index 5c697e7c..14dfe684 100644
--- a/src/sed/script_char_provider.rs
+++ b/src/sed/script_char_provider.rs
@@ -8,10 +8,16 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use std::cell::OnceCell;
+use std::rc::Rc;
+
 #[derive(Debug)]
 pub struct ScriptCharProvider {
     line: Vec<u8>,
     pos: usize,
+    /// The line as text, made on first request and shared by every command
+    /// compiled from it, so that a long line of many commands is copied once.
+    text: OnceCell<Option<Rc<str>>>,
 }
 
 impl ScriptCharProvider {
@@ -20,6 +26,7 @@ impl ScriptCharProvider {
         Self {
             line: line.as_ref().to_vec(),
             pos: 0,
+            text: OnceCell::new(),
         }
     }
 
@@ -66,6 +73,19 @@ impl ScriptCharProvider {
     pub fn get_pos(&self) -> usize {
         self.pos
     }
+
+    /// Return the whole line being scanned, so that an error can quote it.
+    pub fn get_line(&self) -> &[u8] {
+        &self.line
+    }
+
+    /// Return the whole line as shared text, or `None` if it is not valid
+    /// UTF-8, so that a command can keep it for a later error.
+    pub fn line_text(&self) -> Option<Rc<str>> {
+        self.text
+            .get_or_init(|| str::from_utf8(&self.line).ok().map(Rc::from))
+            .clone()
+    }
 }
 
 #[cfg(test)]
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index 3027b7e9..c91a06cc 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -1183,6 +1183,162 @@ fn pattern_clear_with_z_is_non_posix() {
 }
 check_output!(trans_newline, ["-e", r"1N;2y/\n/X/", LINES1]);
 
+////////////////////////////////////////////////////////////
+// Rich diagnostics, drawn for a terminal and controlled by UUTILS_DIAG
+#[test]
+fn diagnostics_stay_out_of_the_way_of_scripts() {
+    // A test harness captures stderr, so it is never a terminal and always
+    // gets the bare message -- which is exactly the guarantee anything parsing
+    // sed's output relies on. `never` holds even if a terminal shows up, and
+    // an empty value leaves the terminal check in charge.
+    for value in [None, Some(""), Some("never")] {
+        let mut command = new_ucmd!();
+        if let Some(value) = value {
+            command.env("UUTILS_DIAG", value);
+        }
+        command
+            .args(&["--posix", "z"])
+            .fails()
+            .code_is(1)
+            .stderr_is("sed: <script argument 1>:1:1: error: invalid command code `z'\n");
+    }
+}
+
+#[test]
+fn diagnostics_underline_the_offending_character() {
+    let result = new_ucmd!()
+        .env("UUTILS_DIAG", "always")
+        .args(&["s/a/b/q"])
+        .fails();
+    result.code_is(1);
+    let output = result.stderr_str().to_string();
+
+    // Whatever is added, the first line is the one sed has always printed.
+    let mut lines = output.lines();
+    assert_eq!(
+        lines.next(),
+        Some("sed: <script argument 1>:1:7: error: invalid substitute flag: 'q'")
+    );
+    assert!(
+        output.contains("s/a/b/q"),
+        "script not quoted back: {output}"
+    );
+
+    // The underline sits under column 7, the offending flag.
+    let underline = output
+        .lines()
+        .find(|line| line.contains('┬'))
+        .expect("nothing underlined");
+    let script = output
+        .lines()
+        .find(|line| line.contains("s/a/b/q"))
+        .expect("script line missing");
+    assert_eq!(
+        underline.chars().position(|c| c == '┬'),
+        script
+            .find("s/a/b/q")
+            .map(|at| script[..at].chars().count() + 6)
+    );
+
+    // stderr is a pipe here, so nothing should be colored.
+    assert!(!output.contains('\u{1b}'), "escape sequences on a pipe");
+}
+
+#[test]
+fn diagnostics_can_point_past_the_end_of_the_line() {
+    // An error that runs off the end of the line reports the column just after
+    // the last character. The drawn column has to agree with the one the
+    // message names, rather than falling back a character.
+    let result = new_ucmd!()
+        .env("UUTILS_DIAG", "always")
+        .args(&["/adrift"])
+        .fails();
+    result.code_is(1);
+    let output = result.stderr_str().to_string();
+
+    assert!(
+        output
+            .starts_with("sed: <script argument 1>:1:8: error: unterminated regular expression\n"),
+        "unexpected first line: {output}"
+    );
+    assert!(
+        output.contains("<script argument 1>:1:8 ]"),
+        "drawn column disagrees with the message: {output}"
+    );
+    let underline = output
+        .lines()
+        .find(|line| line.contains('┬'))
+        .expect("nothing underlined");
+    let script = output
+        .lines()
+        .find(|line| line.contains("/adrift"))
+        .expect("script line missing");
+    assert_eq!(
+        underline.chars().position(|c| c == '┬'),
+        script
+            .find("/adrift")
+            .map(|at| script[..at].chars().count() + 7)
+    );
+}
+
+#[test]
+fn diagnostics_count_columns_in_bytes_like_the_message() {
+    // `é` is two bytes: the message names byte column 8, and the frame header
+    // has to name the same column rather than ariadne's character count, 7.
+    let result = new_ucmd!()
+        .env("UUTILS_DIAG", "always")
+        .args(&["s/é/e/z"])
+        .fails();
+    result.code_is(1);
+    let output = result.stderr_str().to_string();
+
+    assert!(
+        output.starts_with("sed: <script argument 1>:1:8: error: invalid substitute flag: 'z'\n"),
+        "unexpected first line: {output}"
+    );
+    assert!(
+        output.contains("[ <script argument 1>:1:8 ]"),
+        "drawn column disagrees with the message: {output}"
+    );
+}
+
+#[test]
+fn diagnostics_reach_errors_raised_after_the_line_was_read() {
+    // An undefined label is only detected once the whole script is compiled,
+    // by which point the line has been consumed -- the location has to have
+    // carried the text along with it. The script spans two lines, so this also
+    // pins the line number shown in the gutter.
+    let result = new_ucmd!()
+        .env("UUTILS_DIAG", "always")
+        .args(&["-e", "p\nb nowhere"])
+        .fails();
+    result.code_is(1);
+    let output = result.stderr_str().to_string();
+
+    assert!(
+        output.starts_with("sed: <script argument 1>:2:1: error: undefined label `nowhere'\n"),
+        "unexpected first line: {output}"
+    );
+    let quoted = output
+        .lines()
+        .find(|line| line.contains("b nowhere"))
+        .expect("offending line not quoted back");
+    assert!(quoted.contains(" 2 "), "wrong line number: {quoted}");
+    assert!(!output.contains(" 1 "), "unrelated line quoted: {output}");
+}
+
+#[test]
+fn diagnostics_leave_errors_at_the_end_of_the_script_alone() {
+    // A trailing backslash asks for another line; once there is none, the
+    // message names line 0 and no script, so there is no line to point at.
+    new_ucmd!()
+        .env("UUTILS_DIAG", "always")
+        .args(&["s/a/b\\"])
+        .fails()
+        .code_is(1)
+        .stderr_is("sed: :0:7: error: unterminated substitute replacement (unexpected EOF)\n");
+}
+
 ////////////////////////////////////////////////////////////
 // Pattern space manipulation: D, d, H, h, N, n, P, p, q, x
 check_output!(pattern_print_to_newline, ["-n", r"1{;N;P;P;p;}", LINES1]);