diff --git a/textutil/.api b/textutil/.api
index 278023d..fbf83f1 100644
--- a/textutil/.api
+++ b/textutil/.api
@@ -5,6 +5,7 @@
 pkg textutil, func FlushRuneChunk(RuneChunkDecoder, func(rune) error) error
 pkg textutil, func NewLineWriter(io.Writer, int, RuneChunkDecoder, RuneEncoder) *LineWriter
 pkg textutil, func NewUTF8LineWriter(io.Writer, int) *LineWriter
+pkg textutil, func PrefixLineWriter(io.Writer, string) WriteFlushCloser
 pkg textutil, func PrefixWriter(io.Writer, string) io.Writer
 pkg textutil, func TerminalSize() (int, int, error)
 pkg textutil, func WriteRuneChunk(RuneChunkDecoder, func(rune) error, []byte) (int, error)
@@ -26,3 +27,10 @@
 pkg textutil, type RuneEncoder interface, Encode(rune, *bytes.Buffer)
 pkg textutil, type UTF8ChunkDecoder struct
 pkg textutil, type UTF8Encoder struct
+pkg textutil, type WriteFlushCloser interface { Close, Flush, Write }
+pkg textutil, type WriteFlushCloser interface, Close() error
+pkg textutil, type WriteFlushCloser interface, Flush() error
+pkg textutil, type WriteFlushCloser interface, Write([]byte) (int, error)
+pkg textutil, type WriteFlusher interface { Flush, Write }
+pkg textutil, type WriteFlusher interface, Flush() error
+pkg textutil, type WriteFlusher interface, Write([]byte) (int, error)
diff --git a/textutil/writer.go b/textutil/writer.go
index 9bbec00..8b7e930 100644
--- a/textutil/writer.go
+++ b/textutil/writer.go
@@ -7,8 +7,29 @@
 import (
 	"bytes"
 	"io"
+	"unicode/utf8"
 )
 
+// WriteFlusher is the interface that groups the basic Write and Flush methods.
+//
+// Flush is typically provided when Write calls perform buffering; Flush
+// immediately outputs the buffered data.  Flush must be called after the last
+// call to Write, and may be called an arbitrary number of times before the last
+// Write.
+//
+// If the type is also a Closer, Close implies a Flush call.
+type WriteFlusher interface {
+	io.Writer
+	Flush() error
+}
+
+// WriteFlushCloser is the interface that groups the basic Write, Flush and
+// Close methods.
+type WriteFlushCloser interface {
+	WriteFlusher
+	io.Closer
+}
+
 // PrefixWriter returns an io.Writer that wraps w, where the prefix is written
 // out immediately before the first non-empty Write call.
 func PrefixWriter(w io.Writer, prefix string) io.Writer {
@@ -28,6 +49,77 @@
 	return w.w.Write(data)
 }
 
+// PrefixLineWriter returns a WriteFlushCloser that wraps w.  Any occurrence of
+// EOL (\f, \n, \r, \v, LineSeparator or ParagraphSeparator) causes the
+// preceeding line to be written to w, with the given prefix.  Data without EOL
+// is buffered until the next EOL, or Flush or Close call.  A single Write call
+// may result in zero or more Write calls on the underlying writer.
+func PrefixLineWriter(w io.Writer, prefix string) WriteFlushCloser {
+	return &prefixLineWriter{w, []byte(prefix), nil}
+}
+
+type prefixLineWriter struct {
+	w      io.Writer
+	prefix []byte
+	buf    []byte
+}
+
+const eolRunesAsString = "\f\n\r\v" + string(LineSeparator) + string(ParagraphSeparator)
+
+func (w *prefixLineWriter) Write(data []byte) (int, error) {
+	totalLen := len(data)
+	for len(data) > 0 {
+		index := bytes.IndexAny(data, eolRunesAsString)
+		if index == -1 {
+			// No EOL: buffer remaining data.
+			// TODO(toddw): Flush at a max size, to avoid unbounded growth?
+			w.buf = append(w.buf, data...)
+			return totalLen, nil
+		}
+		// Saw EOL: write prefix, buffer, and data including EOL.
+		if _, err := w.w.Write(w.prefix); err != nil {
+			return totalLen - len(data), err
+		}
+		if _, err := w.w.Write(w.buf); err != nil {
+			return totalLen - len(data), err
+		}
+		w.buf = w.buf[:0]
+		_, eolSize := utf8.DecodeRune(data[index:])
+		n, err := w.w.Write(data[:index+eolSize])
+		data = data[n:]
+		if err != nil {
+			return totalLen - len(data), err
+		}
+	}
+	return totalLen, nil
+}
+
+func (w *prefixLineWriter) Flush() error {
+	if len(w.buf) > 0 {
+		if _, err := w.w.Write(w.prefix); err != nil {
+			return err
+		}
+		if _, err := w.w.Write(w.buf); err != nil {
+			return err
+		}
+		w.buf = w.buf[:0]
+	}
+	if f, ok := w.w.(WriteFlusher); ok {
+		return f.Flush()
+	}
+	return nil
+}
+
+func (w *prefixLineWriter) Close() error {
+	firstErr := w.Flush()
+	if c, ok := w.w.(io.Closer); ok {
+		if err := c.Close(); firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}
+
 // ByteReplaceWriter returns an io.Writer that wraps w, where all occurrences of
 // the old byte are replaced with the new string on Write calls.
 func ByteReplaceWriter(w io.Writer, old byte, new string) io.Writer {
diff --git a/textutil/writer_test.go b/textutil/writer_test.go
index 3db70e9..cb8f705 100644
--- a/textutil/writer_test.go
+++ b/textutil/writer_test.go
@@ -7,6 +7,7 @@
 import (
 	"bytes"
 	"fmt"
+	"strings"
 	"testing"
 )
 
@@ -22,18 +23,39 @@
 		{"", []string{"a", ""}, "a"},
 		{"", []string{"", "a"}, "a"},
 		{"", []string{"a", "b"}, "ab"},
+		{"", []string{"ab"}, "ab"},
+		{"", []string{"\n"}, "\n"},
+		{"", []string{"\n", ""}, "\n"},
+		{"", []string{"", "\n"}, "\n"},
+		{"", []string{"a", "\n"}, "a\n"},
+		{"", []string{"a\n"}, "a\n"},
+		{"", []string{"\n", "a"}, "\na"},
+		{"", []string{"\na"}, "\na"},
+		{"", []string{"a\nb\nc"}, "a\nb\nc"},
 		{"PRE", nil, ""},
 		{"PRE", []string{""}, ""},
 		{"PRE", []string{"a"}, "PREa"},
 		{"PRE", []string{"a", ""}, "PREa"},
 		{"PRE", []string{"", "a"}, "PREa"},
 		{"PRE", []string{"a", "b"}, "PREab"},
+		{"PRE", []string{"ab"}, "PREab"},
+		{"PRE", []string{"\n"}, "PRE\n"},
+		{"PRE", []string{"\n", ""}, "PRE\n"},
+		{"PRE", []string{"", "\n"}, "PRE\n"},
+		{"PRE", []string{"a", "\n"}, "PREa\n"},
+		{"PRE", []string{"a\n"}, "PREa\n"},
+		{"PRE", []string{"\n", "a"}, "PRE\na"},
+		{"PRE", []string{"\na"}, "PRE\na"},
+		{"PRE", []string{"a", "\n", "b", "\n", "c"}, "PREa\nb\nc"},
+		{"PRE", []string{"a\nb\nc"}, "PREa\nb\nc"},
+		{"PRE", []string{"a\nb\nc\n"}, "PREa\nb\nc\n"},
 	}
 	for _, test := range tests {
 		var buf bytes.Buffer
 		w := PrefixWriter(&buf, test.Prefix)
+		name := fmt.Sprintf("(%q, %q)", test.Want, test.Writes)
 		for _, write := range test.Writes {
-			name := fmt.Sprintf("(%v, %v)", test.Want, write)
+			name := name + fmt.Sprintf("(%q)", write)
 			n, err := w.Write([]byte(write))
 			if got, want := n, len(write); got != want {
 				t.Errorf("%s got len %d, want %d", name, got, want)
@@ -43,11 +65,99 @@
 			}
 		}
 		if got, want := buf.String(), test.Want; got != want {
-			t.Errorf("got %v, want %v", got, want)
+			t.Errorf("%s got %q, want %q", name, got, want)
 		}
 	}
 }
 
+func TestPrefixLineWriter(t *testing.T) {
+	tests := []struct {
+		Prefix string
+		Writes []string
+		Want   string
+	}{
+		{"", nil, ""},
+		{"", []string{""}, ""},
+		{"", []string{"a"}, "a"},
+		{"", []string{"a", ""}, "a"},
+		{"", []string{"", "a"}, "a"},
+		{"", []string{"a", "b"}, "ab"},
+		{"", []string{"ab"}, "ab"},
+		{"", []string{"\n"}, "\n"},
+		{"", []string{"\n", ""}, "\n"},
+		{"", []string{"", "\n"}, "\n"},
+		{"", []string{"a", "\n"}, "a\n"},
+		{"", []string{"a\n"}, "a\n"},
+		{"", []string{"\n", "a"}, "\na"},
+		{"", []string{"\na"}, "\na"},
+		{"", []string{"a\nb\nc"}, "a\nb\nc"},
+		{"PRE", nil, ""},
+		{"PRE", []string{""}, ""},
+		{"PRE", []string{"a"}, "PREa"},
+		{"PRE", []string{"a", ""}, "PREa"},
+		{"PRE", []string{"", "a"}, "PREa"},
+		{"PRE", []string{"a", "b"}, "PREab"},
+		{"PRE", []string{"ab"}, "PREab"},
+		{"PRE", []string{"\n"}, "PRE\n"},
+		{"PRE", []string{"\n", ""}, "PRE\n"},
+		{"PRE", []string{"", "\n"}, "PRE\n"},
+		{"PRE", []string{"a", "\n"}, "PREa\n"},
+		{"PRE", []string{"a\n"}, "PREa\n"},
+		{"PRE", []string{"\n", "a"}, "PRE\nPREa"},
+		{"PRE", []string{"\na"}, "PRE\nPREa"},
+		{"PRE", []string{"a", "\n", "b", "\n", "c"}, "PREa\nPREb\nPREc"},
+		{"PRE", []string{"a\nb\nc"}, "PREa\nPREb\nPREc"},
+		{"PRE", []string{"a\nb\nc\n"}, "PREa\nPREb\nPREc\n"},
+	}
+	for _, test := range tests {
+		for _, eol := range eolRunesAsString {
+			// Replace \n in Want and Writes with the test eol rune.
+			want := strings.Replace(test.Want, "\n", string(eol), -1)
+			var writes []string
+			for _, write := range test.Writes {
+				writes = append(writes, strings.Replace(write, "\n", string(eol), -1))
+			}
+			// Run the actual tests.
+			var buf bytes.Buffer
+			w := PrefixLineWriter(&buf, test.Prefix)
+			name := fmt.Sprintf("(%q, %q)", want, writes)
+			for _, write := range writes {
+				name := name + fmt.Sprintf("(%q)", write)
+				n, err := w.Write([]byte(write))
+				if got, want := n, len(write); got != want {
+					t.Errorf("%s got len %d, want %d", name, got, want)
+				}
+				if err != nil {
+					t.Errorf("%s got error: %v", name, err)
+				}
+			}
+			if err := w.Flush(); err != nil {
+				t.Errorf("%s Flush got error: %v", name, err)
+			}
+			if got, want := buf.String(), want; got != want {
+				t.Errorf("%s got %q, want %q", name, got, want)
+			}
+		}
+	}
+}
+
+type fakeWriteFlushCloser struct{ flushed, closed bool }
+
+func (f *fakeWriteFlushCloser) Write(p []byte) (int, error) { return len(p), nil }
+func (f *fakeWriteFlushCloser) Flush() error                { f.flushed = true; return nil }
+func (f *fakeWriteFlushCloser) Close() error                { f.closed = true; return nil }
+
+func TestPrefixLineWriterCloseFlush(t *testing.T) {
+	var fake fakeWriteFlushCloser
+	w := PrefixLineWriter(&fake, "")
+	if w.Flush(); !fake.flushed {
+		t.Errorf("Flush not propagated")
+	}
+	if w.Close(); !fake.closed {
+		t.Errorf("Close not propagated")
+	}
+}
+
 func TestByteReplaceWriter(t *testing.T) {
 	tests := []struct {
 		Old    byte
@@ -77,8 +187,9 @@
 	for _, test := range tests {
 		var buf bytes.Buffer
 		w := ByteReplaceWriter(&buf, test.Old, test.New)
+		name := fmt.Sprintf("(%q, %q, %q, %q)", test.Old, test.New, test.Want, test.Writes)
 		for _, write := range test.Writes {
-			name := fmt.Sprintf("(%v, %v, %v, %v)", test.Old, test.New, test.Want, write)
+			name := name + fmt.Sprintf("(%q)", write)
 			n, err := w.Write([]byte(write))
 			if got, want := n, len(write); got != want {
 				t.Errorf("%s got len %d, want %d", name, got, want)
@@ -88,7 +199,7 @@
 			}
 		}
 		if got, want := buf.String(), test.Want; got != want {
-			t.Errorf("got %v, want %v", got, want)
+			t.Errorf("%s got %q, want %q", name, got, want)
 		}
 	}
 }