diff --git a/src/sed/fast_io.rs b/src/sed/fast_io.rs
index 5ea8bf3d..838965e4 100644
--- a/src/sed/fast_io.rs
+++ b/src/sed/fast_io.rs
@@ -678,6 +678,15 @@ impl OutputBuffer {
         )))
     }
 
+    /// Schedule the specified text for output unchanged, after any
+    /// deferred newline.
+    pub fn write_raw(&mut self, bytes: &[u8]) -> io::Result<()> {
+        self.flush_pending_newline()?;
+        #[cfg(unix)]
+        self.flush_mmap(WriteRange::Complete)?;
+        self.out.write_all(bytes)
+    }
+
     /// Copy the specified file to the output.
     pub fn copy_file(&mut self, path: &PathBuf) -> io::Result<()> {
         // Flush mmap writes, if any.
diff --git a/src/sed/processor.rs b/src/sed/processor.rs
index 298a974e..cb08d253 100644
--- a/src/sed/processor.rs
+++ b/src/sed/processor.rs
@@ -464,10 +464,15 @@ fn transliterate(
 
 /// Output any data queued for output at the end of the cycle.
 fn flush_appends(output: &mut OutputBuffer, context: &mut ProcessingContext) -> UResult<()> {
+    if !context.append_elements.is_empty() {
+        // As in GNU sed, end a line that lacks its newline before the queued
+        // output, even when an `r` file is empty or unreadable.
+        output.flush_pending_newline()?;
+    }
     for elem in &context.append_elements {
         match elem {
             AppendElement::Text(text) => {
-                output.write_bytes(text.as_ref())?;
+                output.write_raw(text.as_ref())?;
             }
             AppendElement::Path(path) => {
                 output.copy_file(path)?;
@@ -567,9 +572,7 @@ fn list(
 ) -> UResult<()> {
     // Special case for an empty pattern space
     if line.is_empty() {
-        if line.is_newline_terminated() {
-            output.write_str("$\n")?;
-        }
+        output.write_str("$\n")?;
         return Ok(());
     }
 
@@ -738,7 +741,7 @@ fn process_file(
                     }
                     CommandData::Text(cmd_bytes) => {
                         let shell_out = shell_stdout(cmd_bytes.to_vec(), &command, context)?;
-                        output.write_bytes(&shell_out)?;
+                        output.write_raw(&shell_out)?;
                     }
                     _ => panic!("invalid 'e' command data"),
                 },
@@ -830,6 +833,8 @@ fn process_file(
                     );
                     context.stop_processing = true;
                     context.quiet = true;
+                    // Like GNU sed, discard text queued by `a`, `r` and `R`.
+                    context.append_elements.clear();
                     break;
                 }
                 'R' => {
diff --git a/tests/by-util/test_sed.rs b/tests/by-util/test_sed.rs
index 5597d2fe..c1bd48f6 100644
--- a/tests/by-util/test_sed.rs
+++ b/tests/by-util/test_sed.rs
@@ -3132,3 +3132,129 @@ fn test_posix_reject_flags() {
         .code_is(1)
         .stderr_is("sed: <script argument 1>:1:7: error: unknown option to 's'\n");
 }
+
+/// `r` first writes a newline that the line lacks, even when the file is
+/// missing, and then copies the file unchanged, as GNU sed does.
+#[test]
+fn read_file_after_line_without_newline() -> std::io::Result<()> {
+    let dir = tempfile::tempdir()?;
+    let (one, two, text) = (
+        dir.path().join("1"),
+        dir.path().join("2"),
+        dir.path().join("text"),
+    );
+    fs::write(&one, "a")?;
+    fs::write(&two, "b\n")?;
+    fs::write(&text, "X\nY")?;
+    new_ucmd!()
+        .arg(format!("1r {}", text.display()))
+        .arg(&one)
+        .arg(&two)
+        .succeeds()
+        .stdout_is("a\nX\nYb\n");
+
+    let missing = dir.path().join("missing");
+    new_ucmd!()
+        .arg(format!("r {}", missing.display()))
+        .pipe_in("x")
+        .succeeds()
+        .stdout_is("x\n");
+    // `n` reads the next line without starting a new cycle, so `r` is not
+    // applied to it.
+    new_ucmd!()
+        .args(&["-e", &format!("r {}", missing.display()), "-e", "n"])
+        .pipe_in("x\ny")
+        .succeeds()
+        .stdout_is("x\ny");
+
+    // Text queued by `R` that lacks a newline is not ended before `r`.
+    let unterminated = dir.path().join("unterminated");
+    fs::write(&unterminated, "R")?;
+    new_ucmd!()
+        .args(&["-e", &format!("R {}", unterminated.display())])
+        .args(&["-e", &format!("r {}", text.display())])
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_is("x\nRX\nYy\nX\nY");
+    new_ucmd!()
+        .args(&["-n", "-e", &format!("R {}", unterminated.display())])
+        .args(&["-e", &format!("r {}", text.display())])
+        .pipe_in("x\ny\n")
+        .succeeds()
+        .stdout_is("RX\nYX\nY");
+    Ok(())
+}
+
+/// `Q` discards text queued by `a`, `r` and `R`, as GNU sed does.
+#[test]
+fn quit_silently_discards_appended_text() -> std::io::Result<()> {
+    new_ucmd!()
+        .args(&["-e", "a A", "-e", "Q"])
+        .pipe_in("x\n")
+        .succeeds()
+        .stdout_is("");
+
+    let dir = tempfile::tempdir()?;
+    let (one, two, text) = (
+        dir.path().join("1"),
+        dir.path().join("2"),
+        dir.path().join("text"),
+    );
+    fs::write(&one, "a")?;
+    fs::write(&two, "b\n")?;
+    fs::write(&text, "X\n")?;
+    new_ucmd!()
+        .args(&["-e", &format!("R {}", text.display()), "-e", "Q"])
+        .pipe_in("x\n")
+        .succeeds()
+        .stdout_is("");
+    new_ucmd!()
+        .args(&["-e", &format!("2r {}", text.display()), "-e", "2Q"])
+        .arg(&one)
+        .arg(&two)
+        .succeeds()
+        .stdout_is("a");
+    Ok(())
+}
+
+/// `R` copies a line lacking a newline unchanged, as GNU sed does.
+#[test]
+fn read_one_line_without_newline_is_copied_unchanged() -> std::io::Result<()> {
+    let temp = NamedTempFile::new()?;
+    fs::write(temp.path(), "x")?;
+    new_ucmd!()
+        .arg(format!("R {}", temp.path().display()))
+        .pipe_in("a\nb\n")
+        .succeeds()
+        .stdout_is("a\nxb\n");
+    Ok(())
+}
+
+/// The output of the `e` command is copied unchanged, as GNU sed does.
+#[cfg(unix)]
+#[test]
+fn execute_command_output_is_copied_unchanged() {
+    new_ucmd!()
+        .arg("1e printf hi")
+        .pipe_in("a\nb\n")
+        .succeeds()
+        .stdout_is("hia\nb\n");
+    // A line that lacks its newline is ended before the output, even when
+    // there is none.
+    new_ucmd!()
+        .args(&["-n", "p;e true"])
+        .pipe_in("a")
+        .succeeds()
+        .stdout_is("a\n");
+}
+
+/// `l` shows an empty pattern space as `$`, even when the line lacked a
+/// newline, as GNU sed does.
+#[test]
+fn list_empty_line_without_newline() {
+    new_ucmd!()
+        .args(&["-n", "s/a//;l"])
+        .pipe_in("a")
+        .succeeds()
+        .stdout_is("$\n");
+}