diff --git a/slog/handler.go b/slog/handler.go
index 5ab9fbf..2661ac1 100644
--- a/slog/handler.go
+++ b/slog/handler.go
@@ -93,9 +93,9 @@
 }
 
 type commonHandler struct {
-	newAppender       func(*buffer.Buffer) appender
 	opts              HandlerOptions
-	attrs             []Attr
+	app               appender
+	attrSep           byte // char separating attrs from each other
 	preformattedAttrs []byte
 	mu                sync.Mutex
 	w                 io.Writer
@@ -109,132 +109,162 @@
 
 func (h *commonHandler) with(as []Attr) *commonHandler {
 	h2 := &commonHandler{
-		newAppender:       h.newAppender,
+		app:               h.app,
+		attrSep:           h.attrSep,
 		opts:              h.opts,
-		attrs:             concat(h.attrs, as),
 		preformattedAttrs: h.preformattedAttrs,
 		w:                 h.w,
 	}
-	if h.opts.ReplaceAttr != nil {
-		for i, p := range h2.attrs[len(h.attrs):] {
-			h2.attrs[i] = h.opts.ReplaceAttr(p)
-		}
-	}
-
 	// Pre-format the attributes as an optimization.
-	app := h2.newAppender((*buffer.Buffer)(&h2.preformattedAttrs))
-	for _, p := range h2.attrs[len(h.attrs):] {
-		appendAttr(app, p)
+	state := handleState{
+		h2,
+		(*buffer.Buffer)(&h2.preformattedAttrs),
+		false,
+	}
+	for _, a := range as {
+		state.appendAttr(a)
 	}
 	return h2
 }
 
 func (h *commonHandler) handle(r Record) error {
-	buf := buffer.New()
-	defer buf.Free()
-	app := h.newAppender(buf)
 	rep := h.opts.ReplaceAttr
-	replace := func(a Attr) {
-		a = rep(a)
-		if a.Key() != "" {
-			app.appendKey(a.Key())
-			if err := app.appendAttrValue(a); err != nil {
-				app.appendString(fmt.Sprintf("!ERROR:%v", err))
-			}
-		}
-	}
-
-	app.appendStart()
+	state := handleState{h, buffer.New(), false}
+	defer state.buf.Free()
+	h.app.appendStart(state.buf)
+	// time
 	if !r.Time().IsZero() {
 		key := "time"
 		val := r.Time().Round(0) // strip monotonic to match Attr behavior
 		if rep == nil {
-			app.appendKey(key)
-			if err := app.appendTime(val); err != nil {
-				return err
-			}
+			state.appendKey(key)
+			state.appendTime(val)
 		} else {
-			replace(Time(key, val))
+			state.appendAttr(Time(key, val))
 		}
-		app.appendSep()
 	}
+	// level
 	if r.Level() != 0 {
 		key := "level"
 		val := r.Level()
 		if rep == nil {
-			app.appendKey(key)
-			app.appendString(val.String())
+			state.appendKey(key)
+			state.appendString(val.String())
 		} else {
-			replace(Any(key, val))
+			state.appendAttr(Any(key, val))
 		}
-		app.appendSep()
 	}
+	// source
 	if h.opts.AddSource {
 		file, line := r.SourceLine()
 		if file != "" {
 			key := "source"
 			if rep == nil {
-				app.appendKey(key)
-				app.appendSource(file, line)
+				state.appendKey(key)
+				h.app.appendSource(state.buf, file, line)
 			} else {
 				buf := buffer.New()
-				buf.WriteString(file)
+				buf.WriteString(file) // TODO: escape?
 				buf.WriteByte(':')
 				itoa((*[]byte)(buf), line, -1)
 				s := buf.String()
 				buf.Free()
-				replace(String(key, s))
+				state.appendAttr(String(key, s))
 			}
-			app.appendSep()
 		}
 	}
+	// message
 	key := "msg"
 	val := r.Message()
 	if rep == nil {
-		app.appendKey(key)
-		app.appendString(val)
+		state.appendKey(key)
+		state.appendString(val)
 	} else {
-		replace(String(key, val))
+		state.appendAttr(String(key, val))
 	}
-	*buf = append(*buf, h.preformattedAttrs...)
+	// preformatted Attrs
+	if len(h.preformattedAttrs) > 0 {
+		state.appendSep()
+		state.buf.Write(h.preformattedAttrs)
+	}
+	// Attrs in Record
 	r.Attrs(func(a Attr) {
-		if rep != nil {
-			a = rep(a)
-		}
-		appendAttr(app, a)
+		state.appendAttr(a)
 	})
-	app.appendEnd()
-	buf.WriteByte('\n')
+	h.app.appendEnd(state.buf)
+	state.buf.WriteByte('\n')
 
 	h.mu.Lock()
 	defer h.mu.Unlock()
-	_, err := h.w.Write(*buf)
+	_, err := h.w.Write(*state.buf)
 	return err
 }
 
-func appendAttr(app appender, a Attr) {
-	if a.Key() != "" {
-		app.appendSep()
-		app.appendKey(a.Key())
-		if err := app.appendAttrValue(a); err != nil {
-			app.appendString(fmt.Sprintf("!ERROR:%v", err))
-		}
+// handleState holds state for a single call to commonHandler.handle.
+// The initial value of sep determines whether to emit a separator
+// before the next key, after which it stays true.
+type handleState struct {
+	h   *commonHandler
+	buf *buffer.Buffer
+	sep bool // Append separator before next Attr?
+}
+
+// appendAttr appends the Attr's key and value using app.
+// If sep is true, it also prepends a separator.
+// It handles replacement and checking for an empty key.
+// It sets sep to true if it actually did the append (if the key was non-empty
+// after replacement).
+func (s *handleState) appendAttr(a Attr) {
+	if rep := s.h.opts.ReplaceAttr; rep != nil {
+		a = rep(a)
+	}
+	if a.Key() == "" {
+		return
+	}
+	s.appendKey(a.Key())
+	s.appendAttrValue(a)
+}
+
+func (s *handleState) appendError(err error) {
+	s.appendString(fmt.Sprintf("!ERROR:%v", err))
+}
+
+type appender interface {
+	appendStart(*buffer.Buffer)                 // start of output
+	appendEnd(*buffer.Buffer)                   // end of output
+	appendKey(*buffer.Buffer, string)           // append key and key-value separator
+	appendString(*buffer.Buffer, string)        // append a string
+	appendSource(*buffer.Buffer, string, int)   // append a filename and line
+	appendTime(*buffer.Buffer, time.Time) error // append a time
+	appendAttrValue(*buffer.Buffer, Attr) error // append Attr's value (but not key)
+}
+
+func (s *handleState) appendSep() {
+	if s.sep {
+		s.buf.WriteByte(s.h.attrSep)
 	}
 }
 
-// An appender appends keys and values to a buffer.
-// TextHandler and JSONHandler both implement it.
-// It factors out the format-specific parts of the job.
-// Other than growing the buffer, none of the methods should allocate.
-type appender interface {
-	appendStart()                       // start a sequence of Attrs
-	appendEnd()                         // end a sequence of Attrs
-	appendSep()                         // separate one Attr from the next
-	appendKey(key string)               // append a key
-	appendString(string)                // append a string that may need to be escaped
-	appendTime(time.Time) error         // append a time
-	appendSource(file string, line int) // append file:line
-	appendAttrValue(a Attr) error       // append the Attr's value (but not its key)
+func (s *handleState) appendKey(key string) {
+	s.appendSep()
+	s.h.app.appendKey(s.buf, key)
+	s.sep = true
+}
+
+func (s *handleState) appendString(str string) {
+	s.h.app.appendString(s.buf, str)
+}
+
+func (s *handleState) appendAttrValue(a Attr) {
+	if err := s.h.app.appendAttrValue(s.buf, a); err != nil {
+		s.appendError(err)
+	}
+}
+
+func (s *handleState) appendTime(t time.Time) {
+	if err := s.h.app.appendTime(s.buf, t); err != nil {
+		s.appendError(err)
+	}
 }
 
 // This takes half the time of Time.AppendFormat.
diff --git a/slog/handler_test.go b/slog/handler_test.go
index 9800ef7..f1ed37f 100644
--- a/slog/handler_test.go
+++ b/slog/handler_test.go
@@ -8,12 +8,9 @@
 
 import (
 	"bytes"
-	"fmt"
 	"strings"
 	"testing"
 	"time"
-
-	"golang.org/x/exp/slog/internal/buffer"
 )
 
 func TestDefaultWith(t *testing.T) {
@@ -33,11 +30,22 @@
 	}
 }
 
+// NOTE TO REVIEWER: Ignore this test. The next CL revamps it.
 func TestCommonHandle(t *testing.T) {
 	tm := time.Date(2022, 9, 18, 8, 26, 33, 0, time.UTC)
 	r := NewRecord(tm, InfoLevel, "message", 1)
 	r.AddAttrs(String("a", "one"), Int("b", 2), Any("", "ignore me"))
 
+	newHandler := func(replace func(Attr) Attr) *commonHandler {
+		return &commonHandler{
+			app:     textAppender{},
+			attrSep: ' ',
+			opts:    HandlerOptions{ReplaceAttr: replace},
+		}
+	}
+
+	removeAttr := func(a Attr) Attr { return Attr{} }
+
 	for _, test := range []struct {
 		name string
 		h    *commonHandler
@@ -45,33 +53,38 @@
 	}{
 		{
 			name: "basic",
-			h:    &commonHandler{},
-			want: "(time=2022-09-18T08:26:33.000Z;level=INFO;msg=message;a=one;b=2)",
+			h:    newHandler(nil),
+			want: "time=2022-09-18T08:26:33.000Z level=INFO msg=message a=one b=2",
 		},
 		{
 			name: "cap keys",
-			h: &commonHandler{
-				opts: HandlerOptions{ReplaceAttr: upperCaseKey},
-			},
-			want: "(TIME=2022-09-18T08:26:33.000Z;LEVEL=INFO;MSG=message;A=one;B=2)",
+			h:    newHandler(upperCaseKey),
+			want: "TIME=2022-09-18T08:26:33.000Z LEVEL=INFO MSG=message A=one B=2",
 		},
 		{
 			name: "remove all",
-			h: &commonHandler{
-				opts: HandlerOptions{
-					ReplaceAttr: func(a Attr) Attr { return Attr{} },
-				},
-			},
-			// TODO: fix this. The correct result is "()".
-			want: "(;;)",
+			h:    newHandler(removeAttr),
+			want: "",
+		},
+		{
+			name: "preformatted",
+			h:    newHandler(nil).with([]Attr{Int("pre", 3), String("x", "y")}),
+			want: "time=2022-09-18T08:26:33.000Z level=INFO msg=message pre=3 x=y a=one b=2",
+		},
+		{
+			name: "preformatted cap keys",
+			h:    newHandler(upperCaseKey).with([]Attr{Int("pre", 3), String("x", "y")}),
+			want: "TIME=2022-09-18T08:26:33.000Z LEVEL=INFO MSG=message PRE=3 X=y A=one B=2",
+		},
+		{
+			name: "preformatted remove all",
+			h:    newHandler(removeAttr).with([]Attr{Int("pre", 3), String("x", "y")}),
+			want: "",
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			var buf bytes.Buffer
 			test.h.w = &buf
-			test.h.newAppender = func(buf *buffer.Buffer) appender {
-				return &testAppender{buf}
-			}
 			if err := test.h.handle(r); err != nil {
 				t.Fatal(err)
 			}
@@ -87,41 +100,6 @@
 	return a.WithKey(strings.ToUpper(a.Key()))
 }
 
-type testAppender struct {
-	buf *buffer.Buffer
-}
-
-func (a *testAppender) appendStart() { a.buf.WriteByte('(') }
-func (a *testAppender) appendSep()   { a.buf.WriteByte(';') }
-func (a *testAppender) appendEnd()   { a.buf.WriteByte(')') }
-
-func (a *testAppender) appendKey(key string) {
-	a.appendString(key)
-	a.buf.WriteByte('=')
-}
-func (a *testAppender) appendString(s string) { a.buf.WriteString(s) }
-
-func (a *testAppender) appendTime(t time.Time) error {
-	*a.buf = appendTimeRFC3339Millis(*a.buf, t)
-	return nil
-}
-
-func (a *testAppender) appendSource(file string, line int) {
-	a.appendString(fmt.Sprintf("%s:%d", file, line))
-}
-
-func (a *testAppender) appendAttrValue(at Attr) error {
-	switch at.Kind() {
-	case StringKind:
-		a.appendString(at.str())
-	case TimeKind:
-		a.appendTime(at.Time())
-	default:
-		*a.buf = at.appendValue(*a.buf)
-	}
-	return nil
-}
-
 const rfc3339Millis = "2006-01-02T15:04:05.000Z07:00"
 
 func TestAppendTimeRFC3339(t *testing.T) {
diff --git a/slog/json_handler.go b/slog/json_handler.go
index b473011..844b6a3 100644
--- a/slog/json_handler.go
+++ b/slog/json_handler.go
@@ -32,17 +32,14 @@
 func (opts HandlerOptions) NewJSONHandler(w io.Writer) *JSONHandler {
 	return &JSONHandler{
 		&commonHandler{
-			newAppender: newJSONAppender,
-			w:           w,
-			opts:        opts,
+			app:     jsonAppender{},
+			attrSep: ',',
+			w:       w,
+			opts:    opts,
 		},
 	}
 }
 
-func newJSONAppender(buf *buffer.Buffer) appender {
-	return (*jsonAppender)(buf)
-}
-
 // With returns a new JSONHandler whose attributes consists
 // of h's attributes followed by attrs.
 func (h *JSONHandler) With(attrs []Attr) Handler {
@@ -53,7 +50,7 @@
 //
 // If the Record's time is zero, the time is omitted.
 // Otherwise, the key is "time"
-// and the value is output in RFC3339 format with millisecond precision.
+// and the value is output as with json.Marshal.
 //
 // If the Record's level is zero, the level is omitted.
 // Otherwise, the key is "level"
@@ -79,77 +76,74 @@
 	return h.commonHandler.handle(r)
 }
 
-type jsonAppender buffer.Buffer
+type jsonAppender struct{}
 
-func (a *jsonAppender) buf() *buffer.Buffer { return (*buffer.Buffer)(a) }
+func (jsonAppender) appendStart(buf *buffer.Buffer) { buf.WriteByte('{') }
+func (jsonAppender) appendEnd(buf *buffer.Buffer)   { buf.WriteByte('}') }
 
-func (a *jsonAppender) appendKey(key string) {
-	a.appendString(key)
-	a.buf().WriteByte(':')
+func (a jsonAppender) appendKey(buf *buffer.Buffer, key string) {
+	a.appendString(buf, key)
+	buf.WriteByte(':')
 }
 
-func (a *jsonAppender) appendString(s string) {
-	*a.buf() = appendQuotedJSONString(*a.buf(), s)
+func (jsonAppender) appendString(buf *buffer.Buffer, s string) {
+	*buf = appendQuotedJSONString(*buf, s)
 }
 
-func (a *jsonAppender) appendStart() { a.buf().WriteByte('{') }
-func (a *jsonAppender) appendEnd()   { a.buf().WriteByte('}') }
-func (a *jsonAppender) appendSep()   { a.buf().WriteByte(',') }
+func (jsonAppender) appendSource(buf *buffer.Buffer, file string, line int) {
+	buf.WriteByte('"')
+	*buf = appendJSONString(*buf, file)
+	buf.WriteByte(':')
+	itoa((*[]byte)(buf), line, -1)
+	buf.WriteByte('"')
+}
 
-func (a *jsonAppender) appendTime(t time.Time) error {
+func (jsonAppender) appendTime(buf *buffer.Buffer, t time.Time) error {
 	b, err := t.MarshalJSON()
 	if err != nil {
 		return err
 	}
-	a.buf().Write(b)
+	buf.Write(b)
 	return nil
 }
 
-func (a *jsonAppender) appendSource(file string, line int) {
-	a.buf().WriteByte('"')
-	*a.buf() = appendJSONString(*a.buf(), file)
-	a.buf().WriteByte(':')
-	itoa((*[]byte)(a), line, -1)
-	a.buf().WriteByte('"')
-}
-
-func (ap *jsonAppender) appendAttrValue(a Attr) error {
+func (app jsonAppender) appendAttrValue(buf *buffer.Buffer, a Attr) error {
 	switch a.Kind() {
 	case StringKind:
-		ap.appendString(a.str())
+		app.appendString(buf, a.str())
 	case Int64Kind:
-		*ap.buf() = strconv.AppendInt(*ap.buf(), a.Int64(), 10)
+		*buf = strconv.AppendInt(*buf, a.Int64(), 10)
 	case Uint64Kind:
-		*ap.buf() = strconv.AppendUint(*ap.buf(), a.Uint64(), 10)
+		*buf = strconv.AppendUint(*buf, a.Uint64(), 10)
 	case Float64Kind:
 		f := a.Float64()
 		// json.Marshal fails on special floats, so handle them here.
 		switch {
 		case math.IsInf(f, 1):
-			ap.buf().WriteString(`"+Inf"`)
+			buf.WriteString(`"+Inf"`)
 		case math.IsInf(f, -1):
-			ap.buf().WriteString(`"-Inf"`)
+			buf.WriteString(`"-Inf"`)
 		case math.IsNaN(f):
-			ap.buf().WriteString(`"NaN"`)
+			buf.WriteString(`"NaN"`)
 		default:
 			// json.Marshal is funny about floats; it doesn't
 			// always match strconv.AppendFloat. So just call it.
 			// That's expensive, but floats are rare.
-			if err := ap.appendJSONMarshal(f); err != nil {
+			if err := appendJSONMarshal(buf, f); err != nil {
 				return err
 			}
 		}
 	case BoolKind:
-		*ap.buf() = strconv.AppendBool(*ap.buf(), a.Bool())
+		*buf = strconv.AppendBool(*buf, a.Bool())
 	case DurationKind:
 		// Do what json.Marshal does.
-		*ap.buf() = strconv.AppendInt(*ap.buf(), int64(a.Duration()), 10)
+		*buf = strconv.AppendInt(*buf, int64(a.Duration()), 10)
 	case TimeKind:
-		if err := ap.appendTime(a.Time()); err != nil {
+		if err := app.appendTime(buf, a.Time()); err != nil {
 			return err
 		}
 	case AnyKind:
-		if err := ap.appendJSONMarshal(a.Value()); err != nil {
+		if err := appendJSONMarshal(buf, a.Value()); err != nil {
 			return err
 		}
 	default:
@@ -158,12 +152,12 @@
 	return nil
 }
 
-func (a *jsonAppender) appendJSONMarshal(v any) error {
+func appendJSONMarshal(buf *buffer.Buffer, v any) error {
 	b, err := json.Marshal(v)
 	if err != nil {
 		return err
 	}
-	a.buf().Write(b)
+	buf.Write(b)
 	return nil
 }
 
diff --git a/slog/json_handler_test.go b/slog/json_handler_test.go
index 2d47b66..5785d86 100644
--- a/slog/json_handler_test.go
+++ b/slog/json_handler_test.go
@@ -54,8 +54,7 @@
 
 func TestJSONAppendSource(t *testing.T) {
 	var buf []byte
-	app := newJSONAppender((*buffer.Buffer)(&buf))
-	app.appendSource("file.go", 23)
+	(jsonAppender{}).appendSource((*buffer.Buffer)(&buf), "file.go", 23)
 	got := string(buf)
 	want := `"file.go:23"`
 	if got != want {
@@ -78,9 +77,7 @@
 }
 
 func TestJSONAppendAttrValue(t *testing.T) {
-	var buf []byte
-	app := newJSONAppender((*buffer.Buffer)(&buf))
-	// On most values, appendAttrValue should agree with json.Marshal.
+	// On most values, jsonAppendAttrValue should agree with json.Marshal.
 	for _, value := range []any{
 		"hello",
 		`"[{escape}]"`,
@@ -95,12 +92,12 @@
 		testTime,
 		jsonMarshaler{"xyz"},
 	} {
+		var buf []byte
 		attr := Any("", value)
-		if err := app.appendAttrValue(attr); err != nil {
+		if err := (jsonAppender{}).appendAttrValue((*buffer.Buffer)(&buf), attr); err != nil {
 			t.Fatal(err)
 		}
 		got := string(buf)
-		buf = nil
 		b, err := json.Marshal(value)
 		if err != nil {
 			t.Fatal(err)
@@ -114,8 +111,6 @@
 
 func TestJSONAppendAttrValueSpecial(t *testing.T) {
 	// Attr values that render differently from json.Marshal.
-	var buf []byte
-	app := newJSONAppender((*buffer.Buffer)(&buf))
 	for _, test := range []struct {
 		value any
 		want  string
@@ -125,12 +120,13 @@
 		{math.Inf(-1), `"-Inf"`},
 		{WarnLevel, `"WARN"`},
 	} {
+		var buf []byte
+
 		attr := Any("", test.value)
-		if err := app.appendAttrValue(attr); err != nil {
+		if err := (jsonAppender{}).appendAttrValue((*buffer.Buffer)(&buf), attr); err != nil {
 			t.Fatal(err)
 		}
 		got := string(buf)
-		buf = nil
 		if got != test.want {
 			t.Errorf("%v: got %s, want %s", test.value, got, test.want)
 		}
diff --git a/slog/text_handler.go b/slog/text_handler.go
index b67a650..de18fec 100644
--- a/slog/text_handler.go
+++ b/slog/text_handler.go
@@ -32,11 +32,10 @@
 func (opts HandlerOptions) NewTextHandler(w io.Writer) *TextHandler {
 	return &TextHandler{
 		&commonHandler{
-			newAppender: func(buf *buffer.Buffer) appender {
-				return (*textAppender)(buf)
-			},
-			w:    w,
-			opts: opts,
+			app:     textAppender{},
+			attrSep: ' ',
+			w:       w,
+			opts:    opts,
 		},
 	}
 }
@@ -78,65 +77,59 @@
 	return h.commonHandler.handle(r)
 }
 
-type textAppender buffer.Buffer
+type textAppender struct{}
 
-func (a *textAppender) buf() *buffer.Buffer { return (*buffer.Buffer)(a) }
+func (textAppender) appendStart(*buffer.Buffer) {}
 
-func (a *textAppender) appendKey(key string) {
-	a.appendString(key)
-	a.buf().WriteByte('=')
+func (textAppender) appendEnd(*buffer.Buffer) {}
+
+func (a textAppender) appendKey(buf *buffer.Buffer, key string) {
+	a.appendString(buf, key)
+	buf.WriteByte('=')
 }
 
-func (a *textAppender) appendString(s string) {
+func (textAppender) appendString(buf *buffer.Buffer, s string) {
 	if needsQuoting(s) {
-		*a.buf() = strconv.AppendQuote(*a.buf(), s)
+		*buf = strconv.AppendQuote(*buf, s)
 	} else {
-		a.buf().WriteString(s)
+		buf.WriteString(s)
 	}
 }
 
-func (a *textAppender) appendStart() {}
-func (a *textAppender) appendEnd()   {}
-func (a *textAppender) appendSep()   { a.buf().WriteByte(' ') }
-
-func (a *textAppender) appendTime(t time.Time) error {
-	*a.buf() = appendTimeRFC3339Millis(*a.buf(), t)
+func (textAppender) appendTime(buf *buffer.Buffer, t time.Time) error {
+	*buf = appendTimeRFC3339Millis(*buf, t)
 	return nil
 }
 
-func (a *textAppender) appendSource(file string, line int) {
+func (a textAppender) appendSource(buf *buffer.Buffer, file string, line int) {
 	if needsQuoting(file) {
-		a.appendString(file + ":" + strconv.Itoa(line))
+		a.appendString(buf, file+":"+strconv.Itoa(line))
 	} else {
 		// common case: no quoting needed.
-		a.appendString(file)
-		a.buf().WriteByte(':')
-		itoa((*[]byte)(a.buf()), line, -1)
+		a.appendString(buf, file)
+		buf.WriteByte(':')
+		itoa((*[]byte)(buf), line, -1)
 	}
 }
-
-func (ap *textAppender) appendAttrValue(a Attr) error {
+func (app textAppender) appendAttrValue(buf *buffer.Buffer, a Attr) error {
 	switch a.Kind() {
 	case StringKind:
-		ap.appendString(a.str())
+		app.appendString(buf, a.str())
 	case TimeKind:
-		if err := ap.appendTime(a.Time()); err != nil {
-			return err
-		}
+		_ = app.appendTime(buf, a.Time())
 	case AnyKind:
 		if tm, ok := a.any.(encoding.TextMarshaler); ok {
 			data, err := tm.MarshalText()
 			if err != nil {
-				ap.appendString("!ERROR:" + err.Error())
-			} else {
-				// TODO: avoid the conversion to string.
-				ap.appendString(string(data))
+				return err
 			}
+			// TODO: avoid the conversion to string.
+			app.appendString(buf, string(data))
 			return nil
 		}
-		ap.appendString(fmt.Sprint(a.Value()))
+		app.appendString(buf, fmt.Sprint(a.Value()))
 	default:
-		*ap.buf() = a.appendValue(*ap.buf())
+		*buf = a.appendValue(*buf)
 	}
 	return nil
 }
diff --git a/slog/text_handler_test.go b/slog/text_handler_test.go
index f9f4f30..7836393 100644
--- a/slog/text_handler_test.go
+++ b/slog/text_handler_test.go
@@ -114,8 +114,6 @@
 }
 
 func TestTextAppendSource(t *testing.T) {
-	var buf []byte
-	app := (*textAppender)((*buffer.Buffer)(&buf))
 	for _, test := range []struct {
 		file string
 		want string
@@ -124,12 +122,13 @@
 		{"a b.go", `"a b.go:1"`},
 		{`C:\windows\b.go`, `C:\windows\b.go:1`},
 	} {
-		app.appendSource(test.file, 1)
+		var buf []byte
+		(textAppender{}).appendSource((*buffer.Buffer)(&buf), test.file, 1)
 		got := string(buf)
 		if got != test.want {
 			t.Errorf("%s:\ngot  %s\nwant %s", test.file, got, test.want)
 		}
-		buf = buf[:0]
+
 	}
 }