diff --git a/vdl/pipe.go b/vdl/pipe.go
index 8f4df48..cebaa18 100644
--- a/vdl/pipe.go
+++ b/vdl/pipe.go
@@ -296,7 +296,7 @@
 	d.Enc.Mu.Lock()
 	defer d.Enc.Mu.Unlock()
 	if d.Enc.DecStarted && d.Enc.State != pipeStateDecoder {
-		return d.Close(errInvalidPipeState)
+		return d.Enc.closeLocked(errInvalidPipeState)
 	}
 	if d.IgnoringNextStartValue {
 		d.IgnoringNextStartValue = false
@@ -310,10 +310,10 @@
 	}
 	top := d.decTop()
 	if top == nil {
-		return d.Close(errEmptyPipeStack)
+		return d.Enc.closeLocked(errEmptyPipeStack)
 	}
 	if top.NextOp != pipeStartDec {
-		return d.Close(fmt.Errorf("vdl: pipe expected state %v, but got %v", pipeStartDec, top.NextOp))
+		return d.Enc.closeLocked(fmt.Errorf("vdl: pipe expected state %v, but got %v", pipeStartDec, top.NextOp))
 	}
 	top.NextOp = top.NextOp.Next()
 	return d.Enc.Err
@@ -653,7 +653,7 @@
 	case numberFloat:
 		x := d.Enc.ArgFloat
 		if bitlen <= 32 && (x < -math.MaxFloat32 || x > math.MaxFloat32) {
-			return 0, d.Close(fmt.Errorf(errFmt, "float", bitlen, x))
+			return 0, d.Enc.closeLocked(fmt.Errorf(errFmt, "float", bitlen, x))
 		}
 		return x, d.Enc.Err
 	}
@@ -672,10 +672,13 @@
 
 func (d *pipeDecoder) DecodeBytes(fixedLen int, b *[]byte) error {
 	if !d.Enc.IsBytes {
-		return d.Close(bytesVDLRead(fixedLen, b, d))
+		if err := bytesVDLRead(fixedLen, b, d); err != nil {
+			return d.Enc.closeLocked(err)
+		}
+		return nil
 	}
 	if fixedLen >= 0 && fixedLen != len(d.Enc.ArgBytes) {
-		return d.Close(fmt.Errorf("invalid byte len: got %v, want %v", len(d.Enc.ArgBytes), fixedLen))
+		return d.Enc.closeLocked(fmt.Errorf("invalid byte len: got %v, want %v", len(d.Enc.ArgBytes), fixedLen))
 	}
 	if len(*b) < len(d.Enc.ArgBytes) {
 		*b = make([]byte, len(d.Enc.ArgBytes))
diff --git a/vdl/target.go b/vdl/target.go
index 4e0acef..517ebb3 100644
--- a/vdl/target.go
+++ b/vdl/target.go
@@ -167,6 +167,10 @@
 		}
 		return result, nil
 	}
+	if !rv.IsValid() {
+		// TODO(bprosnitz) Is this the behavior we want?
+		return ZeroValue(AnyType), nil
+	}
 	var result *Value
 	err := convertPipe(&result, rv.Interface())
 	return result, err
diff --git a/vom/.api b/vom/.api
index e22048f..d8bff51 100644
--- a/vom/.api
+++ b/vom/.api
@@ -65,6 +65,8 @@
 pkg vom, func RawBytesOf(interface{}) *RawBytes
 pkg vom, func VDLReadPrimitive(vdl.Decoder, *Primitive) error
 pkg vom, func VersionedEncode(Version, interface{}) ([]byte, error)
+pkg vom, func VersionedXEncode(Version, interface{}) ([]byte, error)
+pkg vom, func XDecode([]byte, interface{}) error
 pkg vom, method (*ControlKind) FillVDLTarget(vdl.Target, *vdl.Type) error
 pkg vom, method (*ControlKind) MakeVDLTarget() vdl.Target
 pkg vom, method (*ControlKind) Set(string) error
diff --git a/vom/new_decoder_test.go b/vom/new_decoder_test.go
index 89e6e28..8fb1e2f 100644
--- a/vom/new_decoder_test.go
+++ b/vom/new_decoder_test.go
@@ -7,7 +7,9 @@
 package vom
 
 import (
+	"fmt"
 	"reflect"
+	"strings"
 	"testing"
 
 	"v.io/v23/vdl"
@@ -31,23 +33,141 @@
 
 		vdlValue := vdl.ValueOf(test.Value)
 		name := test.Name + " [vdl.Value]"
-		testDecodeVDL(t, name, binversion+bintype+binvalue, vdlValue)
+		testDecodeVDLNew(t, name, binversion+bintype+binvalue, vdlValue)
 		name = test.Name + " [vdl.Value] (with TypeDecoder)"
-		testDecodeVDLWithTypeDecoder(t, name, binversion, bintype, binvalue, vdlValue)
+		testDecodeVDLWithTypeDecoderNew(t, name, binversion, bintype, binvalue, vdlValue)
 		name = test.Name + " [vdl.Any]"
-		testDecodeVDL(t, name, binversion+bintype+binvalue, vdl.AnyValue(vdlValue))
+		testDecodeVDLNew(t, name, binversion+bintype+binvalue, vdl.AnyValue(vdlValue))
 		name = test.Name + " [vdl.Any] (with TypeDecoder)"
-		testDecodeVDLWithTypeDecoder(t, name, binversion, bintype, binvalue, vdl.AnyValue(vdlValue))
+		testDecodeVDLWithTypeDecoderNew(t, name, binversion, bintype, binvalue, vdl.AnyValue(vdlValue))
 
 		// Convert in
 		name = test.Name + " [go value]"
-		testDecodeGo(t, name, binversion+bintype+binvalue, reflect.TypeOf(test.Value), test.Value)
+		testDecodeGoNew(t, name, binversion+bintype+binvalue, reflect.TypeOf(test.Value), test.Value)
 		name = test.Name + " [go value] (with TypeDecoder)"
-		testDecodeGoWithTypeDecoder(t, name, binversion, bintype, binvalue, reflect.TypeOf(test.Value), test.Value)
+		testDecodeGoWithTypeDecoderNew(t, name, binversion, bintype, binvalue, reflect.TypeOf(test.Value), test.Value)
 
 		name = test.Name + " [go interface]"
-		testDecodeGo(t, name, binversion+bintype+binvalue, reflect.TypeOf((*interface{})(nil)).Elem(), test.Value)
+		testDecodeGoNew(t, name, binversion+bintype+binvalue, reflect.TypeOf((*interface{})(nil)).Elem(), test.Value)
 		name = test.Name + " [go interface] (with TypeDecoder)"
-		testDecodeGoWithTypeDecoder(t, name, binversion, bintype, binvalue, reflect.TypeOf((*interface{})(nil)).Elem(), test.Value)
+		testDecodeGoWithTypeDecoderNew(t, name, binversion, bintype, binvalue, reflect.TypeOf((*interface{})(nil)).Elem(), test.Value)
+	}
+}
+
+func testDecodeVDLNew(t *testing.T, name, bin string, value *vdl.Value) {
+	for _, mode := range allReadModes {
+		head := fmt.Sprintf("%s (%s)", name, mode)
+		decoder := NewXDecoder(mode.testReader(strings.NewReader(bin)))
+		if value == nil {
+			value = vdl.ZeroValue(vdl.AnyType)
+		}
+		got := vdl.ZeroValue(value.Type())
+		if err := decoder.Decode(got); err != nil {
+			t.Errorf("%s: Decode failed: %v", head, err)
+			return
+		}
+		if want := value; !vdl.EqualValue(got, want) {
+			t.Errorf("%s: Decode mismatch\nGOT  %v\nWANT %v", head, got, want)
+			return
+		}
+	}
+	// Test single-shot vom.Decode twice, to ensure we test the cache hit case.
+	testDecodeVDLSingleShotNew(t, name, bin, value)
+	testDecodeVDLSingleShotNew(t, name, bin, value)
+}
+
+func testDecodeVDLSingleShotNew(t *testing.T, name, bin string, value *vdl.Value) {
+	// Test the single-shot vom.Decode.
+	head := fmt.Sprintf("%s (single-shot)", name)
+	got := vdl.ZeroValue(value.Type())
+	if err := XDecode([]byte(bin), got); err != nil {
+		t.Errorf("%s: Decode failed: %v", head, err)
+		return
+	}
+	if want := value; !vdl.EqualValue(got, want) {
+		t.Errorf("%s: Decode mismatch\nGOT  %v\nWANT %v", head, got, want)
+		return
+	}
+}
+
+func testDecodeVDLWithTypeDecoderNew(t *testing.T, name, binversion, bintype, binvalue string, value *vdl.Value) {
+	for _, mode := range allReadModes {
+		head := fmt.Sprintf("%s (%s)", name, mode)
+		typedec := NewTypeDecoder(mode.testReader(strings.NewReader(binversion + bintype)))
+		typedec.Start()
+		decoder := NewXDecoderWithTypeDecoder(mode.testReader(strings.NewReader(binversion+binvalue)), typedec)
+		if value == nil {
+			value = vdl.ZeroValue(vdl.AnyType)
+		}
+		got := vdl.ZeroValue(value.Type())
+		if err := decoder.Decode(got); err != nil {
+			t.Errorf("%s: Decode failed: %v", head, err)
+			return
+		}
+		if want := value; !vdl.EqualValue(got, want) {
+			t.Errorf("%s: Decode mismatch\nGOT  %v\nWANT %v", head, got, want)
+			return
+		}
+		typedec.Stop()
+	}
+}
+
+func testDecodeGoNew(t *testing.T, name, bin string, rt reflect.Type, want interface{}) {
+	for _, mode := range allReadModes {
+		head := fmt.Sprintf("%s (%s)", name, mode)
+		decoder := NewXDecoder(mode.testReader(strings.NewReader(bin)))
+		var got interface{}
+		if rt != nil {
+			got = reflect.New(rt).Elem().Interface()
+		}
+		if err := decoder.Decode(&got); err != nil {
+			t.Errorf("%s: Decode failed: %v", head, err)
+			return
+		}
+		if !vdl.DeepEqual(got, want) {
+			t.Errorf("%s: Decode mismatch\nGOT  %T %+v\nWANT %T %+v", head, got, got, want, want)
+			return
+		}
+	}
+	// Test single-shot vom.Decode twice, to ensure we test the cache hit case.
+	testDecodeGoSingleShotNew(t, name, bin, rt, want)
+	testDecodeGoSingleShotNew(t, name, bin, rt, want)
+}
+
+func testDecodeGoSingleShotNew(t *testing.T, name, bin string, rt reflect.Type, want interface{}) {
+	head := fmt.Sprintf("%s (single-shot)", name)
+	var got interface{}
+	if rt != nil {
+		got = reflect.New(rt).Elem().Interface()
+	}
+	if err := XDecode([]byte(bin), &got); err != nil {
+		t.Errorf("%s: Decode failed: %v", head, err)
+		return
+	}
+	if !vdl.DeepEqual(got, want) {
+		t.Errorf("%s: Decode mismatch\nGOT  %T %+v\nWANT %T %+v", head, got, got, want, want)
+		return
+	}
+}
+
+func testDecodeGoWithTypeDecoderNew(t *testing.T, name, binversion, bintype, binvalue string, rt reflect.Type, want interface{}) {
+	for _, mode := range allReadModes {
+		head := fmt.Sprintf("%s (%s)", name, mode)
+		typedec := NewTypeDecoder(mode.testReader(strings.NewReader(binversion + bintype)))
+		typedec.Start()
+		decoder := NewXDecoderWithTypeDecoder(mode.testReader(strings.NewReader(binversion+binvalue)), typedec)
+		var got interface{}
+		if rt != nil {
+			got = reflect.New(rt).Elem().Interface()
+		}
+		if err := decoder.Decode(&got); err != nil {
+			t.Errorf("%s: Decode failed: %v", head, err)
+			return
+		}
+		if !vdl.DeepEqual(got, want) {
+			t.Errorf("%s: Decode mismatch\nGOT  %T %+v\nWANT %T %+v", head, got, got, want, want)
+			return
+		}
+		typedec.Stop()
 	}
 }
diff --git a/vom/new_encoder_test.go b/vom/new_encoder_test.go
deleted file mode 100644
index 5e95227..0000000
--- a/vom/new_encoder_test.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2015 The Vanadium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build newvdltests
-
-package vom
-
-import (
-	"fmt"
-	"testing"
-	"v.io/v23/vdl"
-	"v.io/v23/vom/vomtest"
-)
-
-func TestEncoderNew(t *testing.T) {
-	for _, test := range vomtest.Data() {
-		version := Version(test.Version)
-		hexVersion := fmt.Sprintf("%x", test.Version)
-		vdlValue := vdl.ValueOf(test.Value)
-		name := test.Name + " [vdl.Value]"
-		testEncode(t, version, name, vdlValue, hexVersion+test.HexType+test.HexValue)
-		name = test.Name + " [vdl.Value] (with TypeEncoder)"
-		testEncodeWithTypeEncoder(t, version, name, vdlValue, hexVersion, test.HexType, test.HexValue)
-
-		name = test.Name + " [go value]"
-		testEncode(t, version, name, test.Value, hexVersion+test.HexType+test.HexValue)
-		name = test.Name + " [go value] (with TypeEncoder)"
-		testEncodeWithTypeEncoder(t, version, name, test.Value, hexVersion, test.HexType, test.HexValue)
-	}
-}
diff --git a/vom/single_shot.go b/vom/single_shot.go
index f3a1a08..090b960 100644
--- a/vom/single_shot.go
+++ b/vom/single_shot.go
@@ -30,6 +30,14 @@
 	return buf.Bytes(), nil
 }
 
+func VersionedXEncode(version Version, v interface{}) ([]byte, error) {
+	var buf bytes.Buffer
+	if err := NewVersionedXEncoder(version, &buf).Encode(v); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
 // Decode reads the value from the given data, and stores it in value v.  The
 // semantics of value decoding are described by Decoder.Decode.
 //
@@ -76,6 +84,51 @@
 	return nil
 }
 
+func XDecode(data []byte, v interface{}) error {
+	// The implementation below corresponds (logically) to the following:
+	//   return NewDecoder(bytes.NewReader(data)).Decode(valptr)
+	//
+	// However decoding type messages is expensive, so we cache typeDecoders to
+	// skip the decoding in the common case.
+	key, err := computeTypeDecoderCacheKey(data)
+	if err != nil {
+		return err
+	}
+	var buf *decbuf
+	typeDec := singleShotTypeDecoderCache.lookup(key)
+	cacheMiss := false
+	if typeDec == nil {
+		// Cache miss; start decoding at the beginning of all type messages with a
+		// new TypeDecoder.
+		cacheMiss = true
+		buf = newDecbufFromBytes(data)
+		typeDec = newTypeDecoderInternal(buf)
+	} else {
+		version := Version(data[0])
+		data = data[len(key):] // skip the already-read types
+		buf = newDecbufFromBytes(data)
+		buf.version = version
+		typeDec = newDerivedTypeDecoderInternal(buf, typeDec)
+	}
+	// Decode the value message.
+	decoder := &XDecoder{
+		xDecoder{
+			old: &Decoder{
+				buf:     buf,
+				typeDec: typeDec,
+			},
+		},
+	}
+	if err := decoder.Decode(v); err != nil {
+		return err
+	}
+	// Populate the typeDecoder cache for future re-use.
+	if cacheMiss {
+		singleShotTypeDecoderCache.insert(key, typeDec)
+	}
+	return nil
+}
+
 // singleShotTypeDecoderCache is a global cache of TypeDecoders keyed by the
 // bytes of the sequence of type messages before the value message.  A sequence
 // of type messages that is byte-equal doesn't guarantee the same types in the
diff --git a/vom/xencoder.go b/vom/xencoder.go
index f3a6b86..c936132 100644
--- a/vom/xencoder.go
+++ b/vom/xencoder.go
@@ -144,7 +144,7 @@
 
 	nextValueIsAny := e.top().nextValueIsAny()
 	var anyRef anyStartRef
-	if nextValueIsAny {
+	if nextValueIsAny && tt.Kind() == vdl.Optional {
 		tid, err := e.typeEnc.encode(tt)
 		if err != nil {
 			return err
@@ -154,7 +154,7 @@
 		binaryEncodeUint(e.buf, uint64(anyRef.index))
 	}
 	binaryEncodeControl(e.buf, WireCtrlNil)
-	if nextValueIsAny {
+	if nextValueIsAny && tt.Kind() == vdl.Optional {
 		e.anyLens.FinishAny(anyRef, e.buf.Len())
 	}
 
diff --git a/vom/xencoder_test.go b/vom/xencoder_test.go
new file mode 100644
index 0000000..a1a721f
--- /dev/null
+++ b/vom/xencoder_test.go
@@ -0,0 +1,90 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build newvdltests
+
+package vom
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+
+	"v.io/v23/vdl"
+	"v.io/v23/vom/vomtest"
+)
+
+func TestXEncoder(t *testing.T) {
+	for _, test := range vomtest.Data() {
+		version := Version(test.Version)
+		hexVersion := fmt.Sprintf("%x", test.Version)
+		vdlValue := vdl.ValueOf(test.Value)
+		name := test.Name + " [vdl.Value]"
+		testXEncode(t, version, name, vdlValue, hexVersion+test.HexType+test.HexValue)
+		name = test.Name + " [vdl.Value] (with TypeEncoder)"
+		testXEncodeWithTypeEncoder(t, version, name, vdlValue, hexVersion, test.HexType, test.HexValue)
+
+		name = test.Name + " [go value]"
+		testXEncode(t, version, name, test.Value, hexVersion+test.HexType+test.HexValue)
+		name = test.Name + " [go value] (with TypeEncoder)"
+		testXEncodeWithTypeEncoder(t, version, name, test.Value, hexVersion, test.HexType, test.HexValue)
+	}
+}
+
+func testXEncode(t *testing.T, version Version, name string, value interface{}, hex string) {
+	for _, singleShot := range []bool{false, true} {
+		var bin []byte
+		if !singleShot {
+			var buf bytes.Buffer
+			encoder := NewVersionedXEncoder(version, &buf)
+			if err := encoder.Encode(value); err != nil {
+				t.Errorf("%s: Encode(%#v) failed: %v", name, value, err)
+				return
+			}
+			bin = buf.Bytes()
+		} else {
+			name += " (single-shot)"
+			var err error
+			bin, err = VersionedXEncode(version, value)
+			if err != nil {
+				t.Errorf("%s: Encode(%#v) failed: %v", name, value, err)
+				return
+			}
+		}
+		got, want := fmt.Sprintf("%x", bin), hex
+		match, err := matchHexPat(got, want)
+		if err != nil {
+			t.Error(err)
+		}
+		if !match {
+			t.Errorf("%s: Encode(%#v)\n GOT %s\nWANT %s", name, value, got, want)
+		}
+	}
+}
+
+func testXEncodeWithTypeEncoder(t *testing.T, version Version, name string, value interface{}, hexversion, hextype, hexvalue string) {
+	var buf, typebuf bytes.Buffer
+	typeenc := NewVersionedTypeEncoder(version, &typebuf)
+	encoder := NewVersionedXEncoderWithTypeEncoder(version, &buf, typeenc)
+	if err := encoder.Encode(value); err != nil {
+		t.Errorf("%s: Encode(%#v) failed: %v", name, value, err)
+		return
+	}
+	got, want := fmt.Sprintf("%x", typebuf.Bytes()), hexversion+hextype
+	match, err := matchHexPat(got, want)
+	if err != nil {
+		t.Error(err)
+	}
+	if !match && len(hextype) > 0 {
+		t.Errorf("%s: EncodeType(%#v)\nGOT %s\nWANT %s", name, value, got, want)
+	}
+	got, want = fmt.Sprintf("%x", buf.Bytes()), hexversion+hexvalue
+	match, err = matchHexPat(got, want)
+	if err != nil {
+		t.Error(err)
+	}
+	if !match {
+		t.Errorf("%s: Encode(%#v)\nGOT %s\nWANT %s", name, value, got, want)
+	}
+}