diff --git a/play.go b/play.go
index fd56676..e160220 100644
--- a/play.go
+++ b/play.go
@@ -35,41 +35,27 @@
 // 	4 bytes: big-endian int32, length of the next write
 //
 type Recorder struct {
-	mu     sync.Mutex
-	writes []recorderWrite
+	stdout, stderr recorderWriter
 }
 
-type recorderWrite struct {
-	b    []byte
-	kind string
-}
-
-func (r *Recorder) Stdout() io.Writer { return recorderWriter{r, "stdout"} }
-func (r *Recorder) Stderr() io.Writer { return recorderWriter{r, "stderr"} }
+func (r *Recorder) Stdout() io.Writer { return &r.stdout }
+func (r *Recorder) Stderr() io.Writer { return &r.stderr }
 
 type recorderWriter struct {
-	r    *Recorder
-	kind string
+	mu     sync.Mutex
+	writes []byte
 }
 
-func (w recorderWriter) Write(b []byte) (n int, err error) {
-	w.r.mu.Lock()
-	defer w.r.mu.Unlock()
+func (w *recorderWriter) bytes() []byte {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	return w.writes[0:len(w.writes):len(w.writes)]
+}
 
-	// Append this write to the previous one if it has the same kind.
-	if len(w.r.writes) > 0 {
-		prev := &w.r.writes[len(w.r.writes)-1]
-		if prev.kind == w.kind {
-			prev.b = append(prev.b, b...)
-			return len(b), nil
-		}
-	}
-
-	// Otherwise, append a new write.
-	w.r.writes = append(w.r.writes, recorderWrite{
-		append([]byte(nil), b...), w.kind,
-	})
-
+func (w *recorderWriter) Write(b []byte) (n int, err error) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.writes = append(w.writes, b...)
 	return len(b), nil
 }
 
@@ -80,31 +66,36 @@
 }
 
 func (r *Recorder) Events() ([]Event, error) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
+	stdout, stderr := r.stdout.bytes(), r.stderr.bytes()
+
+	evOut, err := decode("stdout", stdout)
+	if err != nil {
+		return nil, err
+	}
+	evErr, err := decode("stderr", stderr)
+	if err != nil {
+		return nil, err
+	}
+
+	events := sortedMerge(evOut, evErr)
 
 	var (
 		out []Event
 		now = epoch
 	)
-	for _, w := range r.writes {
-		events, err := decode(w.kind, w.b)
-		if err != nil {
-			return nil, err
+
+	for _, e := range events {
+		delay := e.time.Sub(now)
+		if delay < 0 {
+			delay = 0
 		}
-		for _, e := range events {
-			delay := e.time.Sub(now)
-			if delay < 0 {
-				delay = 0
-			}
-			out = append(out, Event{
-				Message: string(sanitize(e.msg)),
-				Kind:    e.kind,
-				Delay:   delay,
-			})
-			if delay > 0 {
-				now = e.time
-			}
+		out = append(out, Event{
+			Message: string(sanitize(e.msg)),
+			Kind:    e.kind,
+			Delay:   delay,
+		})
+		if delay > 0 {
+			now = e.time
 		}
 	}
 	return out, nil
@@ -184,6 +175,31 @@
 	return events, nil
 }
 
+// Sorted merge of two slices of events into one slice.
+func sortedMerge(a, b []event) []event {
+	if len(a) == 0 {
+		return b
+	}
+	if len(b) == 0 {
+		return a
+	}
+
+	sorted := make([]event, 0, len(a)+len(b))
+	i, j := 0, 0
+	for i < len(a) && j < len(b) {
+		if a[i].time.Before(b[j].time) {
+			sorted = append(sorted, a[i])
+			i++
+		} else {
+			sorted = append(sorted, b[j])
+			j++
+		}
+	}
+	sorted = append(sorted, a[i:]...)
+	sorted = append(sorted, b[j:]...)
+	return sorted
+}
+
 // sanitize scans b for invalid utf8 code points. If found, it reconstructs
 // the slice replacing the invalid codes with \uFFFD, properly encoded.
 func sanitize(b []byte) []byte {
diff --git a/play_test.go b/play_test.go
index 69f9dd4..bf02993 100644
--- a/play_test.go
+++ b/play_test.go
@@ -19,22 +19,22 @@
 	stdout.Write([]byte("head"))
 	stdout.Write(pbWrite(0, "one"))
 	stdout.Write(pbWrite(0, "two"))
+
 	stderr.Write(pbWrite(1*time.Second, "three"))
-	stdout.Write(pbWrite(2*time.Second, "four"))
-	stderr.Write(pbWrite(3*time.Second, "five"))
+	stderr.Write(pbWrite(2*time.Second, "five"))
+	stdout.Write(pbWrite(2*time.Second-time.Nanosecond, "four"))
+	stderr.Write(pbWrite(2*time.Second, "six"))
+
 	stdout.Write([]byte("middle"))
-	stderr.Write(pbWrite(4*time.Second, "six"))
-	stdout.Write(pbWrite(4*time.Second, "seven"))
+	stdout.Write(pbWrite(3*time.Second, "seven"))
 	stdout.Write([]byte("tail"))
 
 	want := []Event{
 		{"headonetwo", "stdout", 0},
 		{"three", "stderr", time.Second},
-		{"four", "stdout", time.Second},
-		{"five", "stderr", time.Second},
-		{"middle", "stdout", 0},
-		{"six", "stderr", time.Second},
-		{"seventail", "stdout", 0},
+		{"fourmiddle", "stdout", time.Second - time.Nanosecond},
+		{"fivesix", "stderr", time.Nanosecond},
+		{"seventail", "stdout", time.Second},
 	}
 
 	got, err := r.Events()
@@ -42,7 +42,7 @@
 		t.Fatalf("Decode: %v", err)
 	}
 	if !reflect.DeepEqual(got, want) {
-		t.Errorf("got %v, want %v", got, want)
+		t.Errorf("got: \n%v,\nwant \n%v", got, want)
 	}
 }