diff --git a/src/uu/sed/src/command.rs b/src/uu/sed/src/command.rs
index acaca06b..35e8ad19 100644
--- a/src/uu/sed/src/command.rs
+++ b/src/uu/sed/src/command.rs
@@ -8,15 +8,18 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::error_handling::{ScriptLocation, runtime_error};
 use crate::fast_regex::{Captures, Match, Regex};
 use crate::named_writer::NamedWriter;
+use crate::script_char_provider::ScriptCharProvider;
+use crate::script_line_provider::ScriptLineProvider;
 
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::path::PathBuf; // For file descriptors and equivalent
 use std::rc::Rc;
-use uucore::error::{UResult, USimpleError};
+use uucore::error::UResult;
 
 #[derive(Debug, Default, Clone)]
 /// Compilation and processing options provided mostly through the
@@ -38,6 +41,8 @@ pub struct ProcessingContext {
     pub null_data: bool,
 
     // Other context
+    /// Currently processed input file name (not script) in quoted form
+    pub input_name: String,
     /// Current input line number
     pub line_number: usize,
     /// True if this is the last address of a range
@@ -80,13 +85,6 @@ pub struct StringSpace {
     pub has_newline: bool, // True if \n-terminated
 }
 
-#[derive(Debug, PartialEq)]
-/// The specification of a script: through a string or a file
-pub enum ScriptValue {
-    StringVal(String),
-    PathVal(PathBuf),
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 /// Types of address specifications that precede commands
 pub enum AddressType {
@@ -152,21 +150,21 @@ impl ReplacementTemplate {
     /// Apply the template to the given RE captures.
     /// Example:
     /// let result = regex.replace_all(input, |caps: &Captures| {
-    ///    template.apply_captures(caps) });
+    ///    template.apply_captures(&command, caps) });
     /// Returns an error if a backreference in the template was not matched by the RE.
-    pub fn apply_captures(&self, caps: &Captures) -> UResult<String> {
+    pub fn apply_captures(&self, command: &Command, caps: &Captures) -> UResult<String> {
         let mut result = String::new();
 
         // Invalid group numbers may end here through (unkown at compile time)
         // reused REs.
         if self.max_group_number > caps.len() - 1 {
-            return Err(USimpleError::new(
-                2,
+            return runtime_error(
+                &command.location,
                 format!(
-                    "invalid reference \\{} on `s' command's RHS",
+                    "invalid reference \\{} on command's RHS",
                     self.max_group_number
                 ),
-            ));
+            );
         }
 
         for part in &self.parts {
@@ -285,6 +283,7 @@ pub struct Command {
     pub start_line: Option<usize>,          // Start line number (or None)
     pub data: CommandData,                  // Command-specific data
     pub next: Option<Rc<RefCell<Command>>>, // Pointer to next command
+    pub location: ScriptLocation,           // Command's definition location
 }
 
 impl Default for Command {
@@ -297,6 +296,17 @@ impl Default for Command {
             start_line: None,
             data: CommandData::None,
             next: None,
+            location: ScriptLocation::default(),
+        }
+    }
+}
+
+impl Command {
+    /// Construct with position information from the given providers.
+    pub fn at_position(lines: &ScriptLineProvider, line: &ScriptCharProvider) -> Self {
+        Command {
+            location: ScriptLocation::at_position(lines, line),
+            ..Default::default()
         }
     }
 }
@@ -306,15 +316,14 @@ impl Default for Command {
 /// After parsing, t, b Label elements are converted into BranchTarget ones.
 pub enum CommandData {
     None,
-    Block(Option<Rc<RefCell<Command>>>), // Commands for '{'
-    BranchTarget(Option<Rc<RefCell<Command>>>), // Commands for 'b', 't'
-    Label(Option<String>),               // Label name for 'b', 't', ':'
-    Path(PathBuf),                       // File path for 'r'
-    NamedWriter(Rc<RefCell<NamedWriter>>), // File output for 'w'
-    Number(usize),                       // Number for 'l', 'q', 'Q' (GNU)
-    Substitution(Box<Substitution>),     // Substitute command 's'
-    Text(Cow<'static, str>),             // Text for 'a', 'c', 'i'
-    Transliteration(Box<Transliteration>), // Transliteration command 'y'
+    BranchTarget(Option<Rc<RefCell<Command>>>), // Commands for 'b', 't', '{'
+    Label(Option<String>),                      // Label name for 'b', 't', ':'
+    Path(PathBuf),                              // File path for 'r'
+    NamedWriter(Rc<RefCell<NamedWriter>>),      // File output for 'w'
+    Number(usize),                              // Number for 'l', 'q', 'Q' (GNU)
+    Substitution(Box<Substitution>),            // Substitute command 's'
+    Text(Cow<'static, str>),                    // Text for 'a', 'c', 'i'
+    Transliteration(Box<Transliteration>),      // Transliteration command 'y'
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -353,8 +362,9 @@ mod tests {
         let template = ReplacementTemplate::default();
         let input = &mut IOChunk::from_str("foo");
         let caps = caps_for("foo", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "");
     }
 
@@ -364,8 +374,9 @@ mod tests {
         let template = ReplacementTemplate::new(vec![ReplacementPart::Literal("hello".into())]);
         let input = &mut IOChunk::from_str("abc");
         let caps = caps_for("abc", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "hello");
     }
 
@@ -378,8 +389,9 @@ mod tests {
         ]);
         let input = &mut IOChunk::from_str("foo42");
         let caps = caps_for(r"foo\d+", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "got: foo42");
     }
 
@@ -392,8 +404,9 @@ mod tests {
         ]);
         let input = &mut IOChunk::from_str("foo42");
         let caps = caps_for(r"foo(\d+)", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "number: 42");
     }
 
@@ -408,8 +421,9 @@ mod tests {
         ]);
         let input = &mut IOChunk::from_str("x:123");
         let caps = caps_for(r"(\w+):(\d+)", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps).unwrap();
+        let result = template.apply_captures(&cmd, &caps).unwrap();
         assert_eq!(result, "key: x, value: 123");
     }
 
@@ -424,8 +438,9 @@ mod tests {
         ]);
         let input = &mut IOChunk::from_str("x:123");
         let caps = caps_for(r"(\w+):(\d+)", input);
+        let cmd = Command::default();
 
-        let result = template.apply_captures(&caps);
+        let result = template.apply_captures(&cmd, &caps);
         assert!(result.is_err());
 
         let msg = result.unwrap_err().to_string();
diff --git a/src/uu/sed/src/compiler.rs b/src/uu/sed/src/compiler.rs
index 9246a49d..0574ecf1 100644
--- a/src/uu/sed/src/compiler.rs
+++ b/src/uu/sed/src/compiler.rs
@@ -10,15 +10,14 @@
 
 use crate::command::{
     Address, AddressType, AddressValue, Command, CommandData, ProcessingContext, ReplacementPart,
-    ReplacementTemplate, ScriptValue, Substitution, Transliteration,
-};
-use crate::delimited_parser::{
-    compilation_error, parse_char_escape, parse_regex, parse_transliteration,
+    ReplacementTemplate, Substitution, Transliteration,
 };
+use crate::delimited_parser::{parse_char_escape, parse_regex, parse_transliteration};
+use crate::error_handling::{ScriptLocation, compilation_error, semantic_error};
 use crate::fast_regex::Regex;
 use crate::named_writer::NamedWriter;
 use crate::script_char_provider::ScriptCharProvider;
-use crate::script_line_provider::ScriptLineProvider;
+use crate::script_line_provider::{ScriptLineProvider, ScriptValue};
 
 use std::borrow::Cow;
 use std::cell::RefCell;
@@ -238,9 +237,9 @@ pub fn compile(
 }
 
 /// For every Command in the top-level `head` chain, look for
-/// `CommandData::Block(Some(sub_head))`.  Recursively patch
-/// the sub-chain, then splice its tail back to the original
-/// “next” pointer of the *parent* (falling back to its own
+/// `CommandData::BranchTarget(Some(sub_head))` '{' commands.
+/// Recursively patch the sub-chain, then splice its tail back to the
+/// original “next” pointer of the *parent* (falling back to its own
 /// parent_next if its own next was `None`).
 fn patch_block_endings(head: Option<Rc<RefCell<Command>>>) {
     fn patch_block_endings_to_parent(
@@ -258,22 +257,24 @@ fn patch_block_endings(head: Option<Rc<RefCell<Command>>>) {
             let splice_target = own_next.clone().or(parent_next.clone());
 
             // If it has a sub-block, recurse and then patch its tail
-            if let CommandData::Block(Some(ref sub_head)) = cmd.data {
-                // 1) recurse into the sub-chain, passing along splice_target
-                patch_block_endings_to_parent(Some(sub_head.clone()), splice_target.clone());
-
-                // 2) find the tail of that sub-chain
-                let mut tail = sub_head.clone();
-                loop {
-                    let next_in_sub = tail.borrow().next.clone();
-                    match next_in_sub {
-                        Some(n) => tail = n,
-                        None => break,
+            if let CommandData::BranchTarget(Some(ref sub_head)) = cmd.data {
+                if cmd.code == '{' {
+                    // 1) recurse into the sub-chain, passing splice_target
+                    patch_block_endings_to_parent(Some(sub_head.clone()), splice_target.clone());
+
+                    // 2) find the tail of that sub-chain
+                    let mut tail = sub_head.clone();
+                    loop {
+                        let next_in_sub = tail.borrow().next.clone();
+                        match next_in_sub {
+                            Some(n) => tail = n,
+                            None => break,
+                        }
                     }
-                }
 
-                // 3) splice the tail’s `.next` to splice_target
-                tail.borrow_mut().next = splice_target.clone();
+                    // 3) splice the tail’s `.next` to splice_target
+                    tail.borrow_mut().next = splice_target.clone();
+                }
             }
 
             // drop the borrow before moving on
@@ -299,7 +300,7 @@ fn populate_label_map(
 
         // Extract any label to insert after borrow ends
         let maybe_label = match &cmd.data {
-            CommandData::Block(Some(sub_head)) => {
+            CommandData::BranchTarget(Some(sub_head)) => {
                 populate_label_map(Some(sub_head.clone()), context)?;
                 None
             }
@@ -310,7 +311,7 @@ fn populate_label_map(
         if let Some(label) = maybe_label {
             if cmd.code == ':' {
                 if context.label_to_command_map.contains_key(&label) {
-                    return Err(USimpleError::new(2, format!("duplicate label `{label}'")));
+                    return semantic_error(&cmd.location, format!("duplicate label `{label}'"));
                 }
                 context.label_to_command_map.insert(label, rc_cmd.clone());
             }
@@ -332,7 +333,7 @@ fn resolve_branch_targets(
         let mut cmd = rc_cmd.borrow_mut();
 
         // Recurse into blocks
-        if let CommandData::Block(Some(sub_head)) = &cmd.data {
+        if let CommandData::BranchTarget(Some(sub_head)) = &cmd.data {
             resolve_branch_targets(Some(sub_head.clone()), context)?;
         }
 
@@ -349,7 +350,11 @@ fn resolve_branch_targets(
                         .get(&label)
                         .cloned()
                         .ok_or_else(|| {
-                            USimpleError::new(2, format!("undefined label `{label}'"))
+                            semantic_error::<()>(
+                                &cmd.location,
+                                format!("undefined label `{label}'"),
+                            )
+                            .unwrap_err()
                         })?;
                     CommandData::BranchTarget(Some(target))
                 }
@@ -394,7 +399,7 @@ fn compile_sequence(
             continue;
         }
 
-        let mut cmd = Rc::new(RefCell::new(Command::default()));
+        let mut cmd = Rc::new(RefCell::new(Command::at_position(lines, line)));
         let n_addr = compile_address_range(lines, line, &mut cmd, context)?;
         line.eat_spaces();
         let mut cmd_spec = get_cmd_spec(lines, line, n_addr)?;
@@ -990,8 +995,9 @@ pub fn compile_subst_flags(
             }
 
             'w' => {
+                let location = ScriptLocation::at_position(lines, line);
                 let path = read_file_path(lines, line)?;
-                subst.write_file = Some(NamedWriter::new(path)?);
+                subst.write_file = Some(NamedWriter::new(path, location)?);
                 return Ok(()); // 'w' is the last flag allowed
             }
 
@@ -1154,7 +1160,7 @@ fn compile_command(
             line.advance(); // move past '{'
             context.parsed_block_nesting += 1;
             let block_body = compile_sequence(lines, line, context)?;
-            cmd.data = CommandData::Block(block_body);
+            cmd.data = CommandData::BranchTarget(block_body);
         }
         CommandArgs::EndGroup => { // }
             // Implemented at a higher level.
@@ -1193,8 +1199,9 @@ fn compile_command(
         }
         CommandArgs::WriteFile => {
             // w
+            let location = ScriptLocation::at_position(lines, line);
             let path = read_file_path(lines, line)?;
-            cmd.data = CommandData::NamedWriter(NamedWriter::new(path)?);
+            cmd.data = CommandData::NamedWriter(NamedWriter::new(path, location)?);
         }
     }
 
@@ -1368,7 +1375,7 @@ mod tests {
         let err = result.unwrap_err();
         let msg = err.to_string();
 
-        assert!(msg.contains("test.sed:42:4: error: unexpected token"));
+        assert!(msg.contains("test.sed:42:5: error: unexpected token"));
     }
 
     #[test]
@@ -1385,7 +1392,7 @@ mod tests {
         let err = result.unwrap_err();
         let msg = err.to_string();
 
-        assert_eq!(msg, "input.txt:3:0: error: invalid command 'x'");
+        assert_eq!(msg, "input.txt:3:1: error: invalid command 'x'");
     }
 
     // get_cmd_spec
@@ -1397,7 +1404,7 @@ mod tests {
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
-        assert!(msg.contains("test.sed:1:0: error: command expected"));
+        assert!(msg.contains("test.sed:1:1: error: command expected"));
     }
 
     #[test]
@@ -1408,7 +1415,7 @@ mod tests {
 
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
-        assert!(msg.contains("script.sed:2:0: error: invalid command code `@'"));
+        assert!(msg.contains("script.sed:2:1: error: invalid command code `@'"));
     }
 
     #[test]
@@ -1420,7 +1427,7 @@ mod tests {
         assert!(result.is_err());
         let msg = result.unwrap_err().to_string();
         assert!(
-            msg.contains("input.sed:3:0: error: command q expects up to 1 address(es), found 2")
+            msg.contains("input.sed:3:1: error: command q expects up to 1 address(es), found 2")
         );
     }
 
@@ -1854,9 +1861,37 @@ mod tests {
         };
         assert_eq!(line, 1);
 
+        assert_eq!(cmd.location.line_number, 1);
+        assert_eq!(cmd.location.column_number, 1);
+        assert_eq!(cmd.location.input_name.as_ref(), "<script argument 1>");
+
         assert!(cmd.next.is_none());
     }
 
+    #[test]
+    fn test_compile_two_commands() {
+        let scripts = vec![ScriptValue::StringVal("l;q".to_string())];
+        let mut opts = ProcessingContext::default();
+
+        let result = compile(scripts, &mut opts).unwrap();
+        let binding = result.unwrap();
+        let cmd = binding.borrow();
+
+        assert_eq!(cmd.code, 'l');
+        assert_eq!(cmd.location.line_number, 1);
+        assert_eq!(cmd.location.column_number, 1);
+        assert_eq!(cmd.location.input_name.as_ref(), "<script argument 1>");
+
+        let binding2 = cmd.next.clone().unwrap();
+        let cmd2 = binding2.borrow();
+        assert_eq!(cmd2.code, 'q');
+        assert_eq!(cmd2.location.line_number, 1);
+        assert_eq!(cmd2.location.column_number, 3);
+        assert_eq!(cmd2.location.input_name.as_ref(), "<script argument 1>");
+
+        assert!(cmd2.next.is_none());
+    }
+
     // compile_replacement
     #[test]
     fn test_compile_replacement_literal() {
@@ -2215,7 +2250,7 @@ mod tests {
 
         let head = link_commands(vec![a.clone(), block.clone(), b.clone()]);
         let sub_head = link_commands(vec![x.clone(), y.clone()]);
-        block.borrow_mut().data = CommandData::Block(sub_head.clone());
+        block.borrow_mut().data = CommandData::BranchTarget(sub_head.clone());
 
         patch_block_endings(head.clone());
 
@@ -2228,7 +2263,7 @@ mod tests {
     #[test]
     fn test_empty_block_no_panic() {
         let a = command_with_code('a');
-        a.borrow_mut().data = CommandData::Block(None);
+        a.borrow_mut().data = CommandData::BranchTarget(None);
 
         patch_block_endings(Some(a.clone()));
 
@@ -2259,8 +2294,8 @@ mod tests {
         let head = link_commands(vec![a.clone(), outer_block.clone(), b.clone()]);
         let outer = link_commands(vec![m.clone(), inner_block.clone(), n.clone()]);
         let inner = link_commands(vec![x.clone(), y.clone()]);
-        outer_block.borrow_mut().data = CommandData::Block(outer.clone());
-        inner_block.borrow_mut().data = CommandData::Block(inner.clone());
+        outer_block.borrow_mut().data = CommandData::BranchTarget(outer.clone());
+        inner_block.borrow_mut().data = CommandData::BranchTarget(inner.clone());
 
         patch_block_endings(head.clone());
 
@@ -2287,8 +2322,8 @@ mod tests {
         let head = link_commands(vec![a.clone(), outer_block.clone(), b.clone()]);
         let outer = link_commands(vec![inner_block.clone()]);
         let inner = link_commands(vec![x.clone()]);
-        outer_block.borrow_mut().data = CommandData::Block(outer.clone());
-        inner_block.borrow_mut().data = CommandData::Block(inner.clone());
+        outer_block.borrow_mut().data = CommandData::BranchTarget(outer.clone());
+        inner_block.borrow_mut().data = CommandData::BranchTarget(inner.clone());
 
         patch_block_endings(head.clone());
 
@@ -2363,7 +2398,7 @@ mod tests {
     fn test_label_inside_block() {
         let nested = command_with_data(CommandData::Label(Some("inside".to_string())));
         nested.borrow_mut().code = ':';
-        let block = command_with_data(CommandData::Block(Some(nested.clone())));
+        let block = command_with_data(CommandData::BranchTarget(Some(nested.clone())));
         let mut context = ProcessingContext::default();
 
         populate_label_map(Some(block.clone()), &mut context).unwrap();
@@ -2505,7 +2540,7 @@ mod tests {
         let branch = command_with_data(CommandData::Label(Some("inner".to_string())));
         branch.borrow_mut().code = 't';
 
-        let block = command_with_data(CommandData::Block(Some(label.clone())));
+        let block = command_with_data(CommandData::BranchTarget(Some(label.clone())));
         let head = link_commands(vec![branch.clone(), block]);
 
         let mut context = ProcessingContext::default();
diff --git a/src/uu/sed/src/delimited_parser.rs b/src/uu/sed/src/delimited_parser.rs
index e96e4b04..59fc16a9 100644
--- a/src/uu/sed/src/delimited_parser.rs
+++ b/src/uu/sed/src/delimited_parser.rs
@@ -8,28 +8,12 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::error_handling::compilation_error;
 use crate::script_char_provider::ScriptCharProvider;
 use crate::script_line_provider::ScriptLineProvider;
-use std::char;
-use uucore::error::{UResult, USimpleError};
 
-// Fail with msg as a compile error at the current location
-pub fn compilation_error<T>(
-    lines: &ScriptLineProvider,
-    line: &ScriptCharProvider,
-    msg: impl ToString,
-) -> UResult<T> {
-    Err(USimpleError::new(
-        1,
-        format!(
-            "{}:{}:{}: error: {}",
-            lines.get_input_name(),
-            lines.get_line_number(),
-            line.get_pos(),
-            msg.to_string()
-        ),
-    ))
-}
+use std::char;
+use uucore::error::UResult;
 
 /// Return true if c is a valid octal digit
 fn is_ascii_octal_digit(c: char) -> bool {
diff --git a/src/uu/sed/src/error_handling.rs b/src/uu/sed/src/error_handling.rs
new file mode 100644
index 00000000..e8d83b01
--- /dev/null
+++ b/src/uu/sed/src/error_handling.rs
@@ -0,0 +1,116 @@
+// Parse delimited character sequences
+//
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 Diomidis Spinellis
+//
+// This file is part of the uutils sed package.
+// It is licensed under the MIT License.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use crate::command::ProcessingContext;
+use crate::script_char_provider::ScriptCharProvider;
+use crate::script_line_provider::ScriptLineProvider;
+
+use std::rc::Rc;
+
+use uucore::error::{UResult, USimpleError};
+
+#[derive(Clone, Debug)]
+/// The location in a script where a command is defined
+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
+}
+
+impl Default for ScriptLocation {
+    fn default() -> Self {
+        ScriptLocation {
+            input_name: Rc::from("<unknown>"),
+            line_number: 1,
+            column_number: 1,
+        }
+    }
+}
+
+impl ScriptLocation {
+    /// Construct with position information from the given providers.
+    pub fn at_position(lines: &ScriptLineProvider, line: &ScriptCharProvider) -> Self {
+        ScriptLocation {
+            line_number: lines.get_line_number(),
+            column_number: line.get_pos() + 1,
+            input_name: Rc::from(lines.get_input_name()),
+        }
+    }
+}
+
+/// 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>(
+    lines: &ScriptLineProvider,
+    line: &ScriptCharProvider,
+    msg: impl ToString,
+) -> UResult<T> {
+    Err(USimpleError::new(
+        1,
+        format!(
+            "{}:{}:{}: error: {}",
+            lines.get_input_name(),
+            lines.get_line_number(),
+            line.get_pos() + 1,
+            msg.to_string()
+        ),
+    ))
+}
+
+/// 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> {
+    Err(USimpleError::new(
+        exit_code,
+        format!(
+            "{}:{}:{}: error: {}",
+            location.input_name,
+            location.line_number,
+            location.column_number,
+            msg.to_string()
+        ),
+    ))
+}
+
+/// Fail with msg as a compilation error at the command's location.
+/// The error's exit code is 1 (compilation phase).
+pub fn semantic_error<T>(location: &ScriptLocation, msg: impl ToString) -> UResult<T> {
+    location_error(location, msg, 1)
+}
+
+/// Fail with msg as a runtime error at the command's location.
+/// The error's exit code is 2 (processing phase).
+pub fn runtime_error<T>(location: &ScriptLocation, msg: impl ToString) -> UResult<T> {
+    location_error(location, msg, 2)
+}
+
+/// Fail with msg as a runtime error at the command's and input's location.
+/// This is to be used in cases where the error depends on both, for example,
+/// a fancy regular expression applied on invalid UTF-8 input.
+/// (A fixed string match will not err in this case.)
+/// The error's exit code is 2 (processing phase).
+pub fn input_runtime_error<T>(
+    location: &ScriptLocation,
+    context: &ProcessingContext,
+    msg: impl ToString,
+) -> UResult<T> {
+    Err(USimpleError::new(
+        2,
+        format!(
+            "{}:{}:{}: {}:{} error: {}",
+            location.input_name,
+            location.line_number,
+            location.column_number,
+            context.input_name,
+            context.line_number,
+            msg.to_string()
+        ),
+    ))
+}
diff --git a/src/uu/sed/src/fast_io.rs b/src/uu/sed/src/fast_io.rs
index c101163d..6b08d1d1 100644
--- a/src/uu/sed/src/fast_io.rs
+++ b/src/uu/sed/src/fast_io.rs
@@ -263,7 +263,7 @@ impl<'a> IOChunk<'a> {
                         self.utf8_verified.set(true);
                         Ok(())
                     }
-                    Err(e) => Err(USimpleError::new(1, e.to_string())),
+                    Err(e) => Err(USimpleError::new(2, e.to_string())),
                 }
             }
         }
diff --git a/src/uu/sed/src/named_writer.rs b/src/uu/sed/src/named_writer.rs
index 003c4a05..fcee964e 100644
--- a/src/uu/sed/src/named_writer.rs
+++ b/src/uu/sed/src/named_writer.rs
@@ -8,6 +8,8 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::error_handling::{ScriptLocation, runtime_error};
+
 use std::cell::RefCell;
 use std::fs::{File, OpenOptions};
 use std::io::{BufWriter, Write};
@@ -15,7 +17,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult};
+use uucore::error::UResult;
 
 thread_local! {
     /// Global list of all writers that should be flushed at shutdown
@@ -26,22 +28,27 @@ thread_local! {
 /// Writer that tracks its file name for better error messages
 pub struct NamedWriter {
     pub path: PathBuf,
-    pub writer: BufWriter<File>,
+    writer: BufWriter<File>,
+    location: ScriptLocation,
 }
 
 impl NamedWriter {
     /// Create a new writer, truncate the file, and register it for flushing.
-    pub fn new(path: PathBuf) -> UResult<Rc<RefCell<Self>>> {
+    pub fn new(path: PathBuf, location: ScriptLocation) -> UResult<Rc<RefCell<Self>>> {
         let file = OpenOptions::new()
             .create(true)
             .write(true)
             .truncate(true)
             .open(&path)
-            .map_err_context(|| format!("error opening output file {}", path.quote()))?;
+            .map_err(|e| {
+                runtime_error::<()>(&location, format!("creating file {}: {}", path.quote(), e))
+                    .unwrap_err()
+            })?;
 
         let writer = Rc::new(RefCell::new(NamedWriter {
             path,
             writer: BufWriter::new(file),
+            location,
         }));
 
         FLUSH_LIST.with(|list| list.borrow_mut().push(Rc::clone(&writer)));
@@ -50,15 +57,24 @@ impl NamedWriter {
 
     /// Write a line to the file with a newline, returning descriptive errors.
     pub fn write_line(&mut self, line: &str) -> UResult<()> {
-        writeln!(self.writer, "{line}")
-            .map_err_context(|| format!("error writing to file {}", self.path.quote()))
+        writeln!(self.writer, "{line}").map_err(|e| {
+            runtime_error::<()>(
+                &self.location,
+                format!("writing to file {}: {e}", self.path.quote()),
+            )
+            .unwrap_err()
+        })
     }
 
     /// Flush the writer, returning a descriptive error.
     pub fn flush(&mut self) -> UResult<()> {
-        self.writer
-            .flush()
-            .map_err_context(|| format!("error writing to file {}", self.path.quote()))
+        self.writer.flush().map_err(|e| {
+            runtime_error::<()>(
+                &self.location,
+                format!("writing to file {}: {}", self.path.quote(), e),
+            )
+            .unwrap_err()
+        })
     }
 }
 
diff --git a/src/uu/sed/src/processor.rs b/src/uu/sed/src/processor.rs
index e1f01764..d79f10ae 100644
--- a/src/uu/sed/src/processor.rs
+++ b/src/uu/sed/src/processor.rs
@@ -10,8 +10,9 @@
 
 use crate::command::{
     Address, AddressType, AddressValue, AppendElement, Command, CommandData, InputAction,
-    ProcessingContext, Substitution, Transliteration,
+    ProcessingContext, Transliteration,
 };
+use crate::error_handling::{ScriptLocation, input_runtime_error};
 use crate::fast_io::{IOChunk, LineReader, OutputBuffer};
 use crate::fast_regex::Regex;
 use crate::in_place::InPlace;
@@ -23,19 +24,34 @@ use std::io::{self, IsTerminal};
 use std::path::PathBuf;
 use std::rc::Rc;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError, set_exit_code};
+use uucore::error::{FromIo, UResult, set_exit_code};
+
+/// Return the specified command variant or panic.
+// Example: let path = extract_variant!(command, Path);
+macro_rules! extract_variant {
+    ($cmd:expr, $variant:ident) => {
+        match &$cmd.data {
+            CommandData::$variant(inner) => inner,
+            _ => panic!(concat!("Expected ", stringify!($variant), " command data")),
+        }
+    };
+}
 
 /// Return true if the passed address matches the current I/O context.
 fn match_address(
     addr: &Address,
     pattern: &mut IOChunk,
     context: &mut ProcessingContext,
+    location: &ScriptLocation,
 ) -> UResult<bool> {
     match addr.atype {
         AddressType::Re => {
             if let AddressValue::Regex(ref re) = addr.value {
-                let regex = re_or_saved_re(re, context)?;
-                regex.is_match(pattern)
+                let regex = re_or_saved_re(re, context, location)?;
+                match regex.is_match(pattern) {
+                    Ok(result) => Ok(result),
+                    Err(e) => input_runtime_error(location, context, e.to_string()),
+                }
             } else {
                 Ok(false)
             }
@@ -88,7 +104,7 @@ fn applies(
                     }
                 }
                 _ => {
-                    if match_address(addr2, pattern, context)? {
+                    if match_address(addr2, pattern, context, &command.location)? {
                         command.start_line = None;
                         context.last_address = true;
                         Ok(true)
@@ -109,7 +125,7 @@ fn applies(
                 }
             }
         } else if let Some(addr1) = &command.addr1 {
-            if match_address(addr1, pattern, context)? {
+            if match_address(addr1, pattern, context, &command.location)? {
                 match addr2.atype {
                     AddressType::Line => {
                         if let AddressValue::LineNumber(n) = addr2.value {
@@ -139,7 +155,7 @@ fn applies(
             Ok(false)
         }
     } else if let Some(addr1) = &command.addr1 {
-        Ok(match_address(addr1, pattern, context)?)
+        Ok(match_address(addr1, pattern, context, &command.location)?)
     } else {
         Ok(false)
     };
@@ -171,6 +187,7 @@ fn write_chunk(
 fn re_or_saved_re<'a>(
     regex: &Option<Regex>,
     context: &'a mut ProcessingContext,
+    location: &ScriptLocation,
 ) -> UResult<&'a Regex> {
     if let Some(re) = regex {
         // First time we see this regex: clone it *once* into the context.
@@ -181,17 +198,19 @@ fn re_or_saved_re<'a>(
         // We already have one: just borrow it.
         Ok(saved_re)
     } else {
-        Err(USimpleError::new(2, "no previous regular expression"))
+        input_runtime_error(location, context, "no previous regular expression")
     }
 }
 
 /// Perform the specified RE replacement in the provided pattern space.
 fn substitute(
     pattern: &mut IOChunk,
-    sub: &mut Substitution,
+    command: &Command,
     context: &mut ProcessingContext,
     output: &mut OutputBuffer,
 ) -> UResult<()> {
+    let sub = extract_variant!(command, Substitution);
+
     let mut count = 0;
     let mut last_end = 0;
     let mut result = String::new();
@@ -199,71 +218,93 @@ fn substitute(
 
     let mut text: Option<&str> = None;
 
-    let regex = re_or_saved_re(&sub.regex, context)?;
+    let regex = re_or_saved_re(&sub.regex, context, &command.location)?;
 
-    match (sub.occurrence, sub.replacement.max_group_number) {
+    // The following let block allows a common input_runtime_error to be
+    // called once in all cases, and most importantly, to finish the regex
+    // mutable borrowing of context, so as to reuse context in the error call.
+    let subst_result = match (sub.occurrence, sub.replacement.max_group_number) {
         (1, 0) => {
             // Example: s/foo/bar/: find() is enough.
-            let m = regex.find(pattern)?;
-            if let Some(m) = m {
-                text = Some(pattern.as_str()?);
-                result.push_str(&text.unwrap()[last_end..m.start()]);
-
-                let replacement = sub.replacement.apply_match(&m);
-                result.push_str(&replacement);
-                replaced = true;
-                last_end = m.end();
+            match regex.find(pattern) {
+                Err(e) => Err(e),
+                Ok(Some(m)) => {
+                    text = Some(pattern.as_str()?);
+                    result.push_str(&text.unwrap()[last_end..m.start()]);
+
+                    let replacement = sub.replacement.apply_match(&m);
+                    result.push_str(&replacement);
+                    replaced = true;
+                    last_end = m.end();
+                    Ok(())
+                }
+                Ok(None) => Ok(()), // No match
             }
         }
 
         (1, _) => {
             // Example: s/\(.\)\(.\)/\2\1/: captures() is enough.
-            let caps = regex.captures(pattern)?;
-            if let Some(caps) = caps {
-                let m = caps.get(0)?.unwrap();
-                text = Some(pattern.as_str()?);
-                result.push_str(&text.unwrap()[last_end..m.start()]);
-
-                let replacement = sub.replacement.apply_captures(&caps)?;
-                result.push_str(&replacement);
-                replaced = true;
-                last_end = m.end();
+            match regex.captures(pattern) {
+                Err(e) => Err(e),
+                Ok(Some(caps)) => {
+                    let m = caps.get(0)?.unwrap();
+                    text = Some(pattern.as_str()?);
+                    result.push_str(&text.unwrap()[last_end..m.start()]);
+
+                    let replacement = sub.replacement.apply_captures(command, &caps)?;
+                    result.push_str(&replacement);
+                    replaced = true;
+                    last_end = m.end();
+                    Ok(())
+                }
+                Ok(None) => Ok(()), // No match
             }
         }
 
         (_, _) => {
             // Example: s/(.)(.)/\2\1/3: captures_iter() is needed.
             // Iterate over multiple captures of the RE in the pattern.
-            for caps in regex.captures_iter(pattern)? {
-                count += 1;
-                let caps = caps?;
+            'captures: {
+                for caps_result in regex.captures_iter(pattern)? {
+                    let caps = match caps_result {
+                        Ok(caps) => caps,
+                        Err(e) => break 'captures Err(e),
+                    };
+                    count += 1;
 
-                let m = caps.get(0)?.unwrap();
+                    let m = caps.get(0)?.unwrap();
 
-                // Always write the unmatched text before this match.
-                if text.is_none() {
-                    text = Some(pattern.as_str()?);
-                }
-                result.push_str(&text.unwrap()[last_end..m.start()]);
+                    // Always write the unmatched text before this match.
+                    if text.is_none() {
+                        text = Some(pattern.as_str()?);
+                    }
+                    result.push_str(&text.unwrap()[last_end..m.start()]);
 
-                if sub.occurrence == 0 || count == sub.occurrence {
-                    let replacement = sub.replacement.apply_captures(&caps)?;
-                    result.push_str(&replacement);
-                    replaced = true;
-                } else {
-                    // Not the target match — leave the match unchanged.
-                    result.push_str(m.as_str());
-                }
+                    if sub.occurrence == 0 || count == sub.occurrence {
+                        let replacement = sub.replacement.apply_captures(command, &caps)?;
+                        result.push_str(&replacement);
+                        replaced = true;
+                    } else {
+                        // Not the target match — leave the match unchanged.
+                        result.push_str(m.as_str());
+                    }
 
-                last_end = m.end();
+                    last_end = m.end();
 
-                // Early exit if only a specific occurrence,
-                // (likely 1) needed replacing.
-                if count == sub.occurrence {
-                    break;
+                    // Early exit if only a specific occurrence,
+                    // (likely 1) needed replacing.
+                    if count == sub.occurrence {
+                        break 'captures Ok(());
+                    }
                 }
+                break 'captures Ok(());
             }
         }
+    };
+
+    // Handle errors.
+    if let Err(e) = subst_result {
+        return input_runtime_error(&command.location, context, e.to_string());
     }
 
     // Handle substitution success.
@@ -325,17 +366,6 @@ fn flush_appends(output: &mut OutputBuffer, context: &mut ProcessingContext) ->
     Ok(())
 }
 
-/// Return the specified command variant or panic.
-// Example: let path = extract_variant!(command, Path);
-macro_rules! extract_variant {
-    ($cmd:expr, $variant:ident) => {
-        match &$cmd.data {
-            CommandData::$variant(inner) => inner,
-            _ => panic!(concat!("Expected ", stringify!($variant), " command data")),
-        }
-    };
-}
-
 /// List the passed pattern space in unambiguous form.
 fn list(output: &mut OutputBuffer, line: &IOChunk, max_width: usize) -> UResult<()> {
     // Special case for an empty pattern space
@@ -434,7 +464,7 @@ fn process_file(
             match command.code {
                 '{' => {
                     // Block begin; start processing the enclosed ones.
-                    let body = extract_variant!(command, Block);
+                    let body = extract_variant!(command, BranchTarget);
                     current = body.clone();
                     continue;
                 }
@@ -572,11 +602,7 @@ fn process_file(
                         .push(AppendElement::Path(path.clone()));
                 }
                 's' => {
-                    let subst = match &mut command.data {
-                        CommandData::Substitution(subst) => subst,
-                        _ => panic!("Expected Substitution command data"),
-                    };
-                    substitute(&mut pattern, &mut *subst, context, output)?;
+                    substitute(&mut pattern, &command, context, output)?;
                 }
                 't' if !context.substitution_made => { /* Do nothing. */ }
                 't' => {
@@ -668,6 +694,7 @@ pub fn process_all_files(
         if context.separate {
             context.line_number = 0;
         }
+        context.input_name = path.quote().to_string();
         process_file(&commands, &mut reader, output, context)?;
 
         // Handle any N command remains.
diff --git a/src/uu/sed/src/script_line_provider.rs b/src/uu/sed/src/script_line_provider.rs
index d75eb9b9..dff5fe9b 100644
--- a/src/uu/sed/src/script_line_provider.rs
+++ b/src/uu/sed/src/script_line_provider.rs
@@ -8,13 +8,21 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use crate::command::ScriptValue;
 use std::fmt;
 use std::fs::File;
 use std::io::{self, BufRead, BufReader};
+use std::path::PathBuf;
+
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
 
+#[derive(Debug, PartialEq)]
+/// The specification of a script: through a string or a file
+pub enum ScriptValue {
+    StringVal(String),
+    PathVal(PathBuf),
+}
+
 #[derive(Debug)]
 /// The provider of script lines across all specified scripts
 /// Scripts can be specified to sed as files or as strings.
@@ -104,22 +112,13 @@ impl ScriptLineProvider {
             return Ok(());
         }
 
-        fn truncate_with_ellipsis(input: &str) -> String {
-            const MAX_LEN: usize = 20;
-            if input.chars().count() <= MAX_LEN {
-                input.to_string()
-            } else {
-                input.chars().take(MAX_LEN).collect::<String>() + "..."
-            }
-        }
-
         match &self.sources[next_index] {
             ScriptValue::StringVal(s) => {
                 let cursor = std::io::Cursor::new(s.clone());
                 self.state = State::Active {
                     index: next_index,
                     reader: Box::new(BufReader::new(cursor)),
-                    input_name: truncate_with_ellipsis(s),
+                    input_name: format!("<script argument {}>", next_index + 1),
                     line_number: 0,
                 };
             }
@@ -254,7 +253,7 @@ mod tests {
         if let Some(line) = provider.next_line().unwrap() {
             assert_eq!(line.trim(), "l1");
             assert_eq!(provider.get_line_number(), 1);
-            assert_eq!(provider.get_input_name(), "l1\nl2\n");
+            assert_eq!(provider.get_input_name(), "<script argument 1>");
         } else {
             panic!("Expected a line");
         }
@@ -262,7 +261,7 @@ mod tests {
         if let Some(line) = provider.next_line().unwrap() {
             assert_eq!(line.trim(), "l2");
             assert_eq!(provider.get_line_number(), 2);
-            assert_eq!(provider.get_input_name(), "l1\nl2\n");
+            assert_eq!(provider.get_input_name(), "<script argument 1>");
         } else {
             panic!("Expected a line");
         }
@@ -270,7 +269,7 @@ mod tests {
         if let Some(line) = provider.next_line().unwrap() {
             assert_eq!(line.trim(), "l3");
             assert_eq!(provider.get_line_number(), 1);
-            assert_eq!(provider.get_input_name(), "l3");
+            assert_eq!(provider.get_input_name(), "<script argument 2>");
         } else {
             panic!("Expected a line");
         }
diff --git a/src/uu/sed/src/sed.rs b/src/uu/sed/src/sed.rs
index fa34a512..c7147127 100644
--- a/src/uu/sed/src/sed.rs
+++ b/src/uu/sed/src/sed.rs
@@ -11,6 +11,7 @@
 pub mod command;
 pub mod compiler;
 pub mod delimited_parser;
+pub mod error_handling;
 pub mod fast_io;
 pub mod fast_regex;
 pub mod in_place;
@@ -19,9 +20,10 @@ pub mod processor;
 pub mod script_char_provider;
 pub mod script_line_provider;
 
-use crate::command::{ProcessingContext, ScriptValue, StringSpace};
+use crate::command::{ProcessingContext, StringSpace};
 use crate::compiler::compile;
 use crate::processor::process_all_files;
+use crate::script_line_provider::ScriptValue;
 use clap::{Arg, ArgMatches, Command, arg};
 use std::collections::HashMap;
 use std::path::PathBuf;
@@ -197,6 +199,7 @@ fn build_context(matches: &ArgMatches) -> ProcessingContext {
         null_data: matches.get_flag("null-data"),
 
         // Other context
+        input_name: "<stdin>".to_string(),
         line_number: 0,
         last_address: false,
         last_line: false,
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index e623b65c..cfe26c51 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -897,3 +897,97 @@ check_output!(pi, ["-f", "script/math.sed", "input/pi"]);
 
 // Solve the Towers of Hanoi puzzle
 check_output!(hanoi, ["-f", "script/hanoi.sed", "input/hanoi"]);
+
+////////////////////////////////////////////////////////////
+// Error handling
+#[test]
+fn test_invalid_backreference() {
+    new_ucmd!()
+        .args(&["-n", "-e", r"s/./X/;s//\1/", LINES1])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:8: error: invalid reference \\1 on command's RHS\n");
+}
+
+#[test]
+fn test_duplicate_label() {
+    new_ucmd!()
+        .args(&[":foo;:foo"])
+        .fails()
+        .code_is(1)
+        .stderr_is("sed: <script argument 1>:1:6: error: duplicate label `foo'\n");
+}
+
+#[test]
+fn test_undefined_label() {
+    new_ucmd!()
+        .args(&["b foo"])
+        .fails()
+        .code_is(1)
+        .stderr_is("sed: <script argument 1>:1:1: error: undefined label `foo'\n");
+}
+
+// The following test diverse ways in which regexes are matched.
+// Search for 'regex\.' to find them in the code.
+#[test]
+fn test_fancy_regex_is_match_error() {
+    new_ucmd!()
+        .args(&["-E", r"/(\.+)+\1b$/p", "input/dots-4k.txt"])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:1: 'input/dots-4k.txt':1 error: Error executing regex: Max limit for backtracking count exceeded\n");
+}
+
+#[test]
+fn test_fancy_regex_find_error() {
+    new_ucmd!()
+        .args(&["-E", r"p;s/(\.+)+\1b$/X/", "input/dots-4k.txt"])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:3: 'input/dots-4k.txt':1 error: Error executing regex: Max limit for backtracking count exceeded\n");
+}
+
+#[test]
+fn test_fancy_regex_captures_error() {
+    new_ucmd!()
+        .args(&["-E", r"p;s/(\.+)+\1b$/\1/", "input/dots-4k.txt"])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:3: 'input/dots-4k.txt':1 error: Error executing regex: Max limit for backtracking count exceeded\n");
+}
+
+#[test]
+fn test_fancy_regex_captures_iter_error() {
+    new_ucmd!()
+        .args(&["-E", r"p;s/(\.+)+\1b$/\1/3", "input/dots-4k.txt"])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:3: 'input/dots-4k.txt':1 error: error retrieving RE captures: Error executing regex: Max limit for backtracking count exceeded\n");
+}
+
+#[test]
+fn test_write_file_failure() {
+    new_ucmd!()
+        .args(&["w /xyzzy/xyzy", LINES1])
+        .fails()
+        .code_is(2)
+        .stderr_contains("sed: <script argument 1>:1:1: error: creating file '/xyzzy/xyzy':");
+}
+
+#[test]
+fn test_missing_substitute_re() {
+    new_ucmd!()
+        .args(&["l;s//foo/", LINES1])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:1:3: 'input/lines1':1 error: no previous regular expression\n");
+}
+
+#[test]
+fn test_missing_address_re() {
+    new_ucmd!()
+        .args(&["l\np;//s/foo/bar/", LINES1])
+        .fails()
+        .code_is(2)
+        .stderr_is("sed: <script argument 1>:2:3: 'input/lines1':1 error: no previous regular expression\n");
+}