diff --git a/slog/attr.go b/slog/attr.go
index 29431cb..cd3bacc 100644
--- a/slog/attr.go
+++ b/slog/attr.go
@@ -82,3 +82,9 @@
 func (a Attr) String() string {
 	return fmt.Sprintf("%s=%s", a.Key, a.Value)
 }
+
+// isEmpty reports whether a has an empty key and a nil value.
+// That can be written as Attr{} or Any("", nil).
+func (a Attr) isEmpty() bool {
+	return a.Key == "" && a.Value.num == 0 && a.Value.any == nil
+}
diff --git a/slog/benchmarks/handlers.go b/slog/benchmarks/handlers.go
index 6bacee0..90c7aed 100644
--- a/slog/benchmarks/handlers.go
+++ b/slog/benchmarks/handlers.go
@@ -48,11 +48,12 @@
 	buf.WriteByte(' ')
 	buf.WriteString("msg=")
 	buf.WriteString(r.Message)
-	r.Attrs(func(a slog.Attr) {
+	r.Attrs(func(a slog.Attr) bool {
 		buf.WriteByte(' ')
 		buf.WriteString(a.Key)
 		buf.WriteByte('=')
 		h.appendValue(buf, a.Value)
+		return true
 	})
 	buf.WriteByte('\n')
 	_, err := h.w.Write(*buf)
diff --git a/slog/benchmarks/handlers_test.go b/slog/benchmarks/handlers_test.go
index f29eae9..9847f67 100644
--- a/slog/benchmarks/handlers_test.go
+++ b/slog/benchmarks/handlers_test.go
@@ -38,6 +38,6 @@
 
 func attrSlice(r slog.Record) []slog.Attr {
 	var as []slog.Attr
-	r.Attrs(func(a slog.Attr) { as = append(as, a) })
+	r.Attrs(func(a slog.Attr) bool { as = append(as, a); return true })
 	return as
 }
diff --git a/slog/example_depth_test.go b/slog/example_wrap_test.go
similarity index 73%
rename from slog/example_depth_test.go
rename to slog/example_wrap_test.go
index 599cf16..c7bfbb7 100644
--- a/slog/example_depth_test.go
+++ b/slog/example_wrap_test.go
@@ -17,24 +17,21 @@
 
 // Infof is an example of a user-defined logging function that wraps slog.
 // The log record contains the source position of the caller of Infof.
-func Infof(format string, args ...any) {
-	l := slog.Default()
-	if !l.Enabled(context.Background(), slog.LevelInfo) {
+func Infof(logger *slog.Logger, format string, args ...any) {
+	if !logger.Enabled(context.Background(), slog.LevelInfo) {
 		return
 	}
 	var pcs [1]uintptr
 	runtime.Callers(2, pcs[:]) // skip [Callers, Infof]
 	r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf(format, args...), pcs[0])
-	_ = l.Handler().Handle(context.Background(), r)
+	_ = logger.Handler().Handle(context.Background(), r)
 }
 
 func Example_wrapping() {
-	defer func(l *slog.Logger) { slog.SetDefault(l) }(slog.Default())
-
 	replace := func(groups []string, a slog.Attr) slog.Attr {
 		// Remove time.
 		if a.Key == slog.TimeKey && len(groups) == 0 {
-			a.Key = ""
+			return slog.Attr{}
 		}
 		// Remove the directory from the source's filename.
 		if a.Key == slog.SourceKey {
@@ -43,9 +40,8 @@
 		return a
 	}
 	logger := slog.New(slog.HandlerOptions{AddSource: true, ReplaceAttr: replace}.NewTextHandler(os.Stdout))
-	slog.SetDefault(logger)
-	Infof("message, %s", "formatted")
+	Infof(logger, "message, %s", "formatted")
 
 	// Output:
-	// level=INFO source=example_depth_test.go:47 msg="message, formatted"
+	// level=INFO source=example_wrap_test.go:43 msg="message, formatted"
 }
diff --git a/slog/handler.go b/slog/handler.go
index c1b9037..862fb3a 100644
--- a/slog/handler.go
+++ b/slog/handler.go
@@ -51,8 +51,9 @@
 	// Handle methods that produce output should observe the following rules:
 	//   - If r.Time is the zero time, ignore the time.
 	//   - If r.PC is zero, ignore it.
-	//   - If an Attr's key is the empty string and the value is not a group,
-	//     ignore the Attr.
+	//   - Attr's values should be resolved.
+	//   - If an Attr's key and value are both the zero value, ignore the Attr.
+	//     This can be tested with attr.Equal(Attr{}).
 	//   - If a group's key is empty, inline the group's Attrs.
 	//   - If a group has no Attrs (even if it has a non-empty key),
 	//     ignore it.
@@ -61,7 +62,6 @@
 	// WithAttrs returns a new Handler whose attributes consist of
 	// both the receiver's attributes and the arguments.
 	// The Handler owns the slice: it may retain, modify or discard it.
-	// [Logger.With] will resolve the Attrs.
 	WithAttrs(attrs []Attr) Handler
 
 	// WithGroup returns a new Handler with the given group appended to
@@ -333,8 +333,9 @@
 	defer s.prefix.Free()
 	s.prefix.WriteString(s.h.groupPrefix)
 	s.openGroups()
-	r.Attrs(func(a Attr) {
+	r.Attrs(func(a Attr) bool {
 		s.appendAttr(a)
+		return true
 	})
 	if s.h.json {
 		// Close all open groups.
@@ -440,26 +441,22 @@
 // It handles replacement and checking for an empty key.
 // after replacement).
 func (s *handleState) appendAttr(a Attr) {
-	v := a.Value
-	// Elide a non-group with an empty key.
-	if a.Key == "" && v.Kind() != KindGroup {
-		return
-	}
-	if rep := s.h.opts.ReplaceAttr; rep != nil && v.Kind() != KindGroup {
+	if rep := s.h.opts.ReplaceAttr; rep != nil && a.Value.Kind() != KindGroup {
 		var gs []string
 		if s.groups != nil {
 			gs = *s.groups
 		}
-		a = rep(gs, Attr{a.Key, v})
-		if a.Key == "" {
-			return
-		}
-		// Although all attributes in the Record are already resolved,
-		// This one came from the user, so it may not have been.
-		v = a.Value.Resolve()
+		// Resolve before calling ReplaceAttr, so the user doesn't have to.
+		a.Value = a.Value.Resolve()
+		a = rep(gs, a)
 	}
-	if v.Kind() == KindGroup {
-		attrs := v.Group()
+	a.Value = a.Value.Resolve()
+	// Elide empty Attrs.
+	if a.isEmpty() {
+		return
+	}
+	if a.Value.Kind() == KindGroup {
+		attrs := a.Value.Group()
 		// Output only non-empty groups.
 		if len(attrs) > 0 {
 			// Inline a group with an empty key.
@@ -475,7 +472,7 @@
 		}
 	} else {
 		s.appendKey(a.Key)
-		s.appendValue(v)
+		s.appendValue(a.Value)
 	}
 }
 
diff --git a/slog/handler_test.go b/slog/handler_test.go
index 8b1b669..6c39025 100644
--- a/slog/handler_test.go
+++ b/slog/handler_test.go
@@ -109,12 +109,10 @@
 func TestJSONAndTextHandlers(t *testing.T) {
 	ctx := context.Background()
 
-	// ReplaceAttr functions
-
 	// remove all Attrs
 	removeAll := func(_ []string, a Attr) Attr { return Attr{} }
 
-	attrs := []Attr{String("a", "one"), Int("b", 2), Any("", "ignore me")}
+	attrs := []Attr{String("a", "one"), Int("b", 2), Any("", nil)}
 	preAttrs := []Attr{Int("pre", 3), String("x", "y")}
 
 	for _, test := range []struct {
@@ -133,6 +131,12 @@
 			wantJSON: `{"time":"2000-01-02T03:04:05Z","level":"INFO","msg":"message","a":"one","b":2}`,
 		},
 		{
+			name:     "empty key",
+			attrs:    append(slices.Clip(attrs), Any("", "v")),
+			wantText: `time=2000-01-02T03:04:05.000Z level=INFO msg=message a=one b=2 ""=v`,
+			wantJSON: `{"time":"2000-01-02T03:04:05Z","level":"INFO","msg":"message","a":"one","b":2,"":"v"}`,
+		},
+		{
 			name:     "cap keys",
 			replace:  upperCaseKey,
 			attrs:    attrs,
@@ -232,6 +236,16 @@
 			wantJSON: `{"msg":"message","a":1,"name":{"first":"Ren","last":"Hoek"},"b":2}`,
 		},
 		{
+			// Test resolution when there is no ReplaceAttr function.
+			name: "resolve",
+			attrs: []Attr{
+				Any("", &replace{Value{}}), // should be elided
+				Any("name", logValueName{"Ren", "Hoek"}),
+			},
+			wantText: "time=2000-01-02T03:04:05.000Z level=INFO msg=message name.first=Ren name.last=Hoek",
+			wantJSON: `{"time":"2000-01-02T03:04:05Z","level":"INFO","msg":"message","name":{"first":"Ren","last":"Hoek"}}`,
+		},
+		{
 			name:     "with-group",
 			replace:  removeKeys(TimeKey, LevelKey),
 			with:     func(h Handler) Handler { return h.WithAttrs(preAttrs).WithGroup("s") },
@@ -297,7 +311,7 @@
 			wantJSON: `{"msg":"message","a":1,"b":2,"c":3,"d":4}`,
 		},
 	} {
-		r := NewRecord(testTime, LevelInfo, "message", 1)
+		r := NewRecord(testTime, LevelInfo, "message", 0)
 		r.AddAttrs(test.attrs...)
 		var buf bytes.Buffer
 		opts := HandlerOptions{ReplaceAttr: test.replace}
diff --git a/slog/internal/testutil/testutil.go b/slog/internal/testutil/testutil.go
index 4f59d0a..540fefb 100644
--- a/slog/internal/testutil/testutil.go
+++ b/slog/internal/testutil/testutil.go
@@ -12,7 +12,7 @@
 // to make example output deterministic.
 func RemoveTime(groups []string, a slog.Attr) slog.Attr {
 	if a.Key == slog.TimeKey && len(groups) == 0 {
-		a.Key = ""
+		return slog.Attr{}
 	}
 	return a
 }
diff --git a/slog/json_handler.go b/slog/json_handler.go
index 1cd1f59..047cb74 100644
--- a/slog/json_handler.go
+++ b/slog/json_handler.go
@@ -80,7 +80,7 @@
 // Values are formatted as with encoding/json.Marshal, with the following
 // exceptions:
 //   - Floating-point NaNs and infinities are formatted as one of the strings
-//     "NaN", "+Inf" or "-Inf".
+//     "NaN", "Infinity" or "-Infinity".
 //   - Levels are formatted as with Level.String.
 //   - HTML characters are not escaped.
 //
@@ -114,9 +114,9 @@
 		// json.Marshal fails on special floats, so handle them here.
 		switch {
 		case math.IsInf(f, 1):
-			s.buf.WriteString(`"+Inf"`)
+			s.buf.WriteString(`"Infinity"`)
 		case math.IsInf(f, -1):
-			s.buf.WriteString(`"-Inf"`)
+			s.buf.WriteString(`"-Infinity"`)
 		case math.IsNaN(f):
 			s.buf.WriteString(`"NaN"`)
 		default:
@@ -136,13 +136,14 @@
 		s.appendTime(v.Time())
 	case KindAny:
 		a := v.Any()
-		if err, ok := a.(error); ok {
+		_, jm := a.(json.Marshaler)
+		if err, ok := a.(error); ok && !jm {
 			s.appendString(err.Error())
 		} else {
 			return appendJSONMarshal(s.buf, a)
 		}
 	default:
-		panic(fmt.Sprintf("bad kind: %d", v.Kind()))
+		panic(fmt.Sprintf("bad kind: %s", v.Kind()))
 	}
 	return nil
 }
diff --git a/slog/json_handler_test.go b/slog/json_handler_test.go
index 64b3b4d..fb93713 100644
--- a/slog/json_handler_test.go
+++ b/slog/json_handler_test.go
@@ -13,6 +13,7 @@
 	"io"
 	"math"
 	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -67,6 +68,12 @@
 	return []byte(fmt.Sprintf(`[%q]`, j.s)), nil
 }
 
+type jsonMarshalerError struct {
+	jsonMarshaler
+}
+
+func (jsonMarshalerError) Error() string { return "oops" }
+
 func TestAppendJSONValue(t *testing.T) {
 	// On most values, jsonAppendAttrValue should agree with json.Marshal.
 	for _, value := range []any{
@@ -82,6 +89,7 @@
 		time.Minute,
 		testTime,
 		jsonMarshaler{"xyz"},
+		jsonMarshalerError{jsonMarshaler{"pqr"}},
 	} {
 		got := jsonValueString(t, AnyValue(value))
 		want, err := marshalJSON(value)
@@ -111,8 +119,8 @@
 		want  string
 	}{
 		{math.NaN(), `"NaN"`},
-		{math.Inf(+1), `"+Inf"`},
-		{math.Inf(-1), `"-Inf"`},
+		{math.Inf(+1), `"Infinity"`},
+		{math.Inf(-1), `"-Infinity"`},
 		{LevelWarn, `"WARN"`},
 	} {
 		got := jsonValueString(t, AnyValue(test.value))
@@ -202,7 +210,7 @@
 		}),
 	}
 
-	outFile, err := os.Create("/tmp/bench.log")
+	outFile, err := os.Create(filepath.Join(b.TempDir(), "bench.log"))
 	if err != nil {
 		b.Fatal(err)
 	}
diff --git a/slog/logger.go b/slog/logger.go
index 8f021e6..173b34f 100644
--- a/slog/logger.go
+++ b/slog/logger.go
@@ -89,7 +89,7 @@
 func (l *Logger) Handler() Handler { return l.handler }
 
 // With returns a new Logger that includes the given arguments, converted to
-// Attrs as in [Logger.Log] and resolved.
+// Attrs as in [Logger.Log].
 // The Attrs will be added to each output from the Logger.
 // The new Logger shares the old Logger's context.
 // The new Logger's handler is the result of calling WithAttrs on the receiver's
@@ -110,6 +110,8 @@
 
 // WithGroup returns a new Logger that starts a group. The keys of all
 // attributes added to the Logger will be qualified by the given name.
+// (How that qualification happens depends on the [Handler.WithGroup]
+// method of the Logger's Handler.)
 // The new Logger shares the old Logger's context.
 //
 // The new Logger's handler is the result of calling WithGroup on the receiver's
diff --git a/slog/logger_test.go b/slog/logger_test.go
index 2f04540..9694b54 100644
--- a/slog/logger_test.go
+++ b/slog/logger_test.go
@@ -13,6 +13,7 @@
 	"regexp"
 	"runtime"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -398,12 +399,15 @@
 }
 
 type captureHandler struct {
+	mu     sync.Mutex
 	r      Record
 	attrs  []Attr
 	groups []string
 }
 
 func (h *captureHandler) Handle(ctx context.Context, r Record) error {
+	h.mu.Lock()
+	defer h.mu.Unlock()
 	h.r = r
 	return nil
 }
@@ -411,14 +415,22 @@
 func (*captureHandler) Enabled(context.Context, Level) bool { return true }
 
 func (c *captureHandler) WithAttrs(as []Attr) Handler {
-	c2 := *c
-	c2.attrs = concat(c2.attrs, as)
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	var c2 captureHandler
+	c2.r = c.r
+	c2.groups = c.groups
+	c2.attrs = concat(c.attrs, as)
 	return &c2
 }
 
 func (c *captureHandler) WithGroup(name string) Handler {
-	c2 := *c
-	c2.groups = append(slices.Clip(c2.groups), name)
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	var c2 captureHandler
+	c2.r = c.r
+	c2.attrs = c.attrs
+	c2.groups = append(slices.Clip(c.groups), name)
 	return &c2
 }
 
diff --git a/slog/record.go b/slog/record.go
index 6911c6c..e791b2e 100644
--- a/slog/record.go
+++ b/slog/record.go
@@ -87,27 +87,29 @@
 }
 
 // Attrs calls f on each Attr in the Record.
-// The Attrs are already resolved.
-func (r Record) Attrs(f func(Attr)) {
+// Iteration stops if f returns false.
+func (r Record) Attrs(f func(Attr) bool) {
 	for i := 0; i < r.nFront; i++ {
-		f(r.front[i])
+		if !f(r.front[i]) {
+			return
+		}
 	}
 	for _, a := range r.back {
-		f(a)
+		if !f(a) {
+			return
+		}
 	}
 }
 
 // AddAttrs appends the given Attrs to the Record's list of Attrs.
-// It resolves the Attrs before doing so.
 func (r *Record) AddAttrs(attrs ...Attr) {
-	resolveAttrs(attrs)
 	n := copy(r.front[r.nFront:], attrs)
 	r.nFront += n
 	// Check if a copy was modified by slicing past the end
 	// and seeing if the Attr there is non-zero.
 	if cap(r.back) > len(r.back) {
 		end := r.back[:len(r.back)+1][len(r.back)]
-		if end != (Attr{}) {
+		if !end.isEmpty() {
 			panic("copies of a slog.Record were both modified")
 		}
 	}
@@ -116,7 +118,6 @@
 
 // Add converts the args to Attrs as described in [Logger.Log],
 // then appends the Attrs to the Record's list of Attrs.
-// It resolves the Attrs before doing so.
 func (r *Record) Add(args ...any) {
 	var a Attr
 	for len(args) > 0 {
@@ -150,7 +151,7 @@
 
 // argsToAttr turns a prefix of the nonempty args slice into an Attr
 // and returns the unconsumed portion of the slice.
-// If args[0] is an Attr, it returns it, resolved.
+// If args[0] is an Attr, it returns it.
 // If args[0] is a string, it treats the first two elements as
 // a key-value pair.
 // Otherwise, it treats args[0] as a value with a missing key.
@@ -160,12 +161,9 @@
 		if len(args) == 1 {
 			return String(badKey, x), nil
 		}
-		a := Any(x, args[1])
-		a.Value = a.Value.Resolve()
-		return a, args[2:]
+		return Any(x, args[1]), args[2:]
 
 	case Attr:
-		x.Value = x.Value.Resolve()
 		return x, args[1:]
 
 	default:
diff --git a/slog/record_test.go b/slog/record_test.go
index 4727a08..fa907f3 100644
--- a/slog/record_test.go
+++ b/slog/record_test.go
@@ -24,6 +24,17 @@
 	if got := attrsSlice(r); !attrsEqual(got, as) {
 		t.Errorf("got %v, want %v", got, as)
 	}
+
+	// Early return.
+	var got []Attr
+	r.Attrs(func(a Attr) bool {
+		got = append(got, a)
+		return len(got) < 2
+	})
+	want := as[:2]
+	if !attrsEqual(got, want) {
+		t.Errorf("got %v, want %v", got, want)
+	}
 }
 
 func TestRecordSourceLine(t *testing.T) {
@@ -103,7 +114,7 @@
 
 func attrsSlice(r Record) []Attr {
 	s := make([]Attr, 0, r.NumAttrs())
-	r.Attrs(func(a Attr) { s = append(s, a) })
+	r.Attrs(func(a Attr) bool { s = append(s, a); return true })
 	return s
 }
 
@@ -158,7 +169,7 @@
 		for j := 0; j < nAttrs; j++ {
 			r.AddAttrs(Int("k", j))
 		}
-		r.Attrs(func(b Attr) { a = b })
+		r.Attrs(func(b Attr) bool { a = b; return true })
 	}
 	_ = a
 }
diff --git a/slog/slogtest/slogtest.go b/slog/slogtest/slogtest.go
index 442a6c7..610575a 100644
--- a/slog/slogtest/slogtest.go
+++ b/slog/slogtest/slogtest.go
@@ -67,9 +67,9 @@
 			},
 		},
 		{
-			explanation: withSource("a Handler should ignore an Attr with an empty key"),
+			explanation: withSource("a Handler should ignore an empty Attr"),
 			f: func(l *slog.Logger) {
-				l.Info("msg", "a", "b", "", "ignore", "c", "d")
+				l.Info("msg", "a", "b", "", nil, "c", "d")
 			},
 			checks: []check{
 				hasAttr("a", "b"),
diff --git a/slog/text_handler.go b/slog/text_handler.go
index 0faa367..4981eb6 100644
--- a/slog/text_handler.go
+++ b/slog/text_handler.go
@@ -68,7 +68,7 @@
 // If the AddSource option is set and source information is available,
 // the key is "source" and the value is output as FILE:LINE.
 //
-// The message's key "msg".
+// The message's key is "msg".
 //
 // To modify these or other attributes, or remove them from the output, use
 // [HandlerOptions.ReplaceAttr].
@@ -80,9 +80,13 @@
 // characters, non-printing characters, '"' or '='.
 //
 // Keys inside groups consist of components (keys or group names) separated by
-// dots. No further escaping is performed. If it is necessary to reconstruct the
-// group structure of a key even in the presence of dots inside components, use
-// [HandlerOptions.ReplaceAttr] to escape the keys.
+// dots. No further escaping is performed.
+// Thus there is no way to determine from the key "a.b.c" whether there
+// are two groups "a" and "b" and a key "c", or a single group "a.b" and a key "c",
+// or single group "a" and a key "b.c".
+// If it is necessary to reconstruct the group structure of a key
+// even in the presence of dots inside components, use
+// [HandlerOptions.ReplaceAttr] to encode that information in the key.
 //
 // Each call to Handle results in a single serialized call to
 // io.Writer.Write.
@@ -134,10 +138,15 @@
 }
 
 func needsQuoting(s string) bool {
+	if len(s) == 0 {
+		return true
+	}
 	for i := 0; i < len(s); {
 		b := s[i]
 		if b < utf8.RuneSelf {
-			if needsQuotingSet[b] {
+			// Quote anything except a backslash that would need quoting in a
+			// JSON string, as well as space and '='
+			if b != '\\' && (b == ' ' || b == '=' || !safeSet[b]) {
 				return true
 			}
 			i++
@@ -151,17 +160,3 @@
 	}
 	return false
 }
-
-var needsQuotingSet = [utf8.RuneSelf]bool{
-	'"': true,
-	'=': true,
-}
-
-func init() {
-	for i := 0; i < utf8.RuneSelf; i++ {
-		r := rune(i)
-		if unicode.IsSpace(r) || !unicode.IsPrint(r) {
-			needsQuotingSet[i] = true
-		}
-	}
-}
diff --git a/slog/text_handler_test.go b/slog/text_handler_test.go
index 71f637a..6dbe402 100644
--- a/slog/text_handler_test.go
+++ b/slog/text_handler_test.go
@@ -183,7 +183,7 @@
 		in   string
 		want bool
 	}{
-		{"", false},
+		{"", true},
 		{"ab", false},
 		{"a=b", true},
 		{`"ab"`, true},
diff --git a/slog/value.go b/slog/value.go
index f331945..5719976 100644
--- a/slog/value.go
+++ b/slog/value.go
@@ -7,7 +7,9 @@
 import (
 	"fmt"
 	"math"
+	"runtime"
 	"strconv"
+	"strings"
 	"time"
 
 	"golang.org/x/exp/slices"
@@ -346,8 +348,10 @@
 		return append(dst, v.duration().String()...)
 	case KindTime:
 		return append(dst, v.time().String()...)
-	case KindAny, KindGroup, KindLogValuer:
-		return append(dst, fmt.Sprint(v.any)...)
+	case KindGroup:
+		return fmt.Append(dst, v.group())
+	case KindAny, KindLogValuer:
+		return fmt.Append(dst, v.any)
 	default:
 		panic(fmt.Sprintf("bad kind: %s", v.Kind()))
 	}
@@ -365,20 +369,19 @@
 
 // Resolve repeatedly calls LogValue on v while it implements LogValuer,
 // and returns the result.
-// If v resolves to a group, the group's attributes' values are also resolved.
+// If v resolves to a group, the group's attributes' values are not recursively
+// resolved.
 // If the number of LogValue calls exceeds a threshold, a Value containing an
 // error is returned.
 // Resolve's return value is guaranteed not to be of Kind KindLogValuer.
-func (v Value) Resolve() Value {
-	v = v.resolve()
-	if v.Kind() == KindGroup {
-		resolveAttrs(v.Group())
-	}
-	return v
-}
-
-func (v Value) resolve() Value {
+func (v Value) Resolve() (rv Value) {
 	orig := v
+	defer func() {
+		if r := recover(); r != nil {
+			rv = AnyValue(fmt.Errorf("LogValue panicked\n%s", stack(3, 5)))
+		}
+	}()
+
 	for i := 0; i < maxLogValues; i++ {
 		if v.Kind() != KindLogValuer {
 			return v
@@ -389,10 +392,26 @@
 	return AnyValue(err)
 }
 
-// resolveAttrs replaces the values of the given Attrs with their
-// resolutions.
-func resolveAttrs(as []Attr) {
-	for i, a := range as {
-		as[i].Value = a.Value.Resolve()
+func stack(skip, nFrames int) string {
+	pcs := make([]uintptr, nFrames+1)
+	n := runtime.Callers(skip+1, pcs)
+	if n == 0 {
+		return "(no stack)"
 	}
+	frames := runtime.CallersFrames(pcs[:n])
+	var b strings.Builder
+	i := 0
+	for {
+		frame, more := frames.Next()
+		fmt.Fprintf(&b, "called from %s (%s:%d)\n", frame.Function, frame.File, frame.Line)
+		if !more {
+			break
+		}
+		i++
+		if i >= nFrames {
+			fmt.Fprintf(&b, "(rest of stack elided)\n")
+			break
+		}
+	}
+	return b.String()
 }
diff --git a/slog/value_test.go b/slog/value_test.go
index e3c087c..1196e75 100644
--- a/slog/value_test.go
+++ b/slog/value_test.go
@@ -7,6 +7,7 @@
 import (
 	"fmt"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 	"unsafe"
@@ -59,6 +60,7 @@
 		{StringValue("foo"), "foo"},
 		{TimeValue(testTime), "2000-01-02 03:04:05 +0000 UTC"},
 		{AnyValue(time.Duration(3 * time.Second)), "3s"},
+		{GroupValue(Int("a", 1), Bool("b", true)), "[a=1 b=true]"},
 	} {
 		if got := test.v.String(); got != test.want {
 			t.Errorf("%#v:\ngot  %q\nwant %q", test.v, got, test.want)
@@ -173,18 +175,27 @@
 		t.Errorf("expected error, got %T", got)
 	}
 
-	// Test Resolve group.
-	r = &replace{GroupValue(
-		Int("a", 1),
-		Group("b", Any("c", &replace{StringValue("d")})),
-	)}
-	v = AnyValue(r)
+	// Groups are not recursively resolved.
+	c := Any("c", &replace{StringValue("d")})
+	v = AnyValue(&replace{GroupValue(Int("a", 1), Group("b", c))})
 	got2 := v.Resolve().Any().([]Attr)
-	want2 := []Attr{Int("a", 1), Group("b", String("c", "d"))}
+	want2 := []Attr{Int("a", 1), Group("b", c)}
 	if !attrsEqual(got2, want2) {
 		t.Errorf("got %v, want %v", got2, want2)
 	}
 
+	// Verify that panics in Resolve are caught and turn into errors.
+	v = AnyValue(panickingLogValue{})
+	got = v.Resolve().Any()
+	gotErr, ok := got.(error)
+	if !ok {
+		t.Errorf("expected error, got %T", got)
+	}
+	// The error should provide some context information.
+	// We'll just check that this function name appears in it.
+	if got, want := gotErr.Error(), "TestLogValue"; !strings.Contains(got, want) {
+		t.Errorf("got %q, want substring %q", got, want)
+	}
 }
 
 func TestZeroTime(t *testing.T) {
@@ -201,6 +212,10 @@
 
 func (r *replace) LogValue() Value { return r.v }
 
+type panickingLogValue struct{}
+
+func (panickingLogValue) LogValue() Value { panic("bad") }
+
 // A Value with "unsafe" strings is significantly faster:
 // safe:  1785 ns/op, 0 allocs
 // unsafe: 690 ns/op, 0 allocs