diff --git a/go/src/v.io/x/js.core/stress/stress.vdl.go b/go/src/v.io/x/js.core/stress/stress.vdl.go
index 2f8e8cb..6a6c3b5 100644
--- a/go/src/v.io/x/js.core/stress/stress.vdl.go
+++ b/go/src/v.io/x/js.core/stress/stress.vdl.go
@@ -31,10 +31,87 @@
 }) {
 }
 
+func (m *StressResults) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+
+	if __VDLType_stress_v_io_x_js_core_stress_StressResults == nil || __VDLTypestress0 == nil {
+		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
+	}
+	fieldsTarget1, err := t.StartFields(tt)
+	if err != nil {
+		return err
+	}
+
+	var2 := (m.Iterations == int64(0))
+	if !var2 {
+		keyTarget3, fieldTarget4, err := fieldsTarget1.StartField("Iterations")
+		if err != vdl.ErrFieldNoExist && err != nil {
+			return err
+		}
+		if err != vdl.ErrFieldNoExist {
+			if err := fieldTarget4.FromInt(int64(m.Iterations), vdl.Int64Type); err != nil {
+				return err
+			}
+			if err := fieldsTarget1.FinishField(keyTarget3, fieldTarget4); err != nil {
+				return err
+			}
+		}
+	}
+	var5 := (m.Qps == float64(0))
+	if !var5 {
+		keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Qps")
+		if err != vdl.ErrFieldNoExist && err != nil {
+			return err
+		}
+		if err != vdl.ErrFieldNoExist {
+			if err := fieldTarget7.FromFloat(float64(m.Qps), vdl.Float64Type); err != nil {
+				return err
+			}
+			if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+				return err
+			}
+		}
+	}
+	var8 := (m.MsecsPerRpc == float64(0))
+	if !var8 {
+		keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("MsecsPerRpc")
+		if err != vdl.ErrFieldNoExist && err != nil {
+			return err
+		}
+		if err != vdl.ErrFieldNoExist {
+			if err := fieldTarget10.FromFloat(float64(m.MsecsPerRpc), vdl.Float64Type); err != nil {
+				return err
+			}
+			if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+				return err
+			}
+		}
+	}
+	if err := t.FinishFields(fieldsTarget1); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m *StressResults) MakeVDLTarget() vdl.Target {
+	return nil
+}
+
+func (m *StressResults) IsZero() bool {
+
+	var1 := (*m == StressResults{})
+	return var1
+}
+
 func init() {
 	vdl.Register((*StressResults)(nil))
 }
 
+var __VDLTypestress0 *vdl.Type = vdl.TypeOf((*StressResults)(nil))
+var __VDLType_stress_v_io_x_js_core_stress_StressResults *vdl.Type = vdl.TypeOf(StressResults{})
+
+func __VDLEnsureNativeBuilt_stress() {
+}
+
 // StressClientMethods is the client interface
 // containing Stress methods.
 type StressClientMethods interface {
diff --git a/go/src/v.io/x/js.core/test_service/cache.vdl.go b/go/src/v.io/x/js.core/test_service/cache.vdl.go
index 37d84cb..95292ce 100644
--- a/go/src/v.io/x/js.core/test_service/cache.vdl.go
+++ b/go/src/v.io/x/js.core/test_service/cache.vdl.go
@@ -25,6 +25,40 @@
 }) {
 }
 
+func (m KeyPageResult) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+
+	listTarget1, err := t.StartList(__VDLType_cache_v_io_x_js_core_test_service_KeyPageResult, 10)
+	if err != nil {
+		return err
+	}
+	for i, elem3 := range m {
+		elemTarget2, err := listTarget1.StartElem(i)
+		if err != nil {
+			return err
+		}
+		if err := elemTarget2.FromString(string(elem3), vdl.StringType); err != nil {
+			return err
+		}
+		if err := listTarget1.FinishElem(elemTarget2); err != nil {
+			return err
+		}
+	}
+	if err := t.FinishList(listTarget1); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m KeyPageResult) MakeVDLTarget() vdl.Target {
+	return nil
+}
+
+func (m KeyPageResult) IsZero() bool {
+
+	var1 := (m == KeyPageResult{})
+	return var1
+}
+
 // KeyValuePair is a representation of a cached key and value pair.
 type KeyValuePair struct {
 	Key   string
@@ -36,11 +70,81 @@
 }) {
 }
 
+func (m *KeyValuePair) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+
+	if __VDLType_cache_v_io_x_js_core_test_service_KeyValuePair == nil || __VDLTypecache0 == nil {
+		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
+	}
+	fieldsTarget1, err := t.StartFields(tt)
+	if err != nil {
+		return err
+	}
+
+	var2 := (m.Key == "")
+	if !var2 {
+		keyTarget3, fieldTarget4, err := fieldsTarget1.StartField("Key")
+		if err != vdl.ErrFieldNoExist && err != nil {
+			return err
+		}
+		if err != vdl.ErrFieldNoExist {
+			if err := fieldTarget4.FromString(string(m.Key), vdl.StringType); err != nil {
+				return err
+			}
+			if err := fieldsTarget1.FinishField(keyTarget3, fieldTarget4); err != nil {
+				return err
+			}
+		}
+	}
+	var5 := (m.Value == (*vom.RawBytes)(nil))
+	if !var5 {
+		keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Value")
+		if err != vdl.ErrFieldNoExist && err != nil {
+			return err
+		}
+		if err != vdl.ErrFieldNoExist {
+
+			if m.Value == nil {
+				if err := fieldTarget7.FromNil(vdl.AnyType); err != nil {
+					return err
+				}
+			} else {
+				if err := m.Value.FillVDLTarget(fieldTarget7, vdl.AnyType); err != nil {
+					return err
+				}
+			}
+			if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+				return err
+			}
+		}
+	}
+	if err := t.FinishFields(fieldsTarget1); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m *KeyValuePair) MakeVDLTarget() vdl.Target {
+	return nil
+}
+
+func (m *KeyValuePair) IsZero() bool {
+
+	var1 := (*m == KeyValuePair{})
+	return var1
+}
+
 func init() {
 	vdl.Register((*KeyPageResult)(nil))
 	vdl.Register((*KeyValuePair)(nil))
 }
 
+var __VDLTypecache0 *vdl.Type = vdl.TypeOf((*KeyValuePair)(nil))
+var __VDLType_cache_v_io_x_js_core_test_service_KeyPageResult *vdl.Type = vdl.TypeOf(KeyPageResult{})
+var __VDLType_cache_v_io_x_js_core_test_service_KeyValuePair *vdl.Type = vdl.TypeOf(KeyValuePair{})
+
+func __VDLEnsureNativeBuilt_cache() {
+}
+
 // CacheClientMethods is the client interface
 // containing Cache methods.
 //
diff --git a/go/src/v.io/x/js.core/test_service/cancel_collector.vdl.go b/go/src/v.io/x/js.core/test_service/cancel_collector.vdl.go
index 76230e4..8301317 100644
--- a/go/src/v.io/x/js.core/test_service/cancel_collector.vdl.go
+++ b/go/src/v.io/x/js.core/test_service/cancel_collector.vdl.go
@@ -14,6 +14,9 @@
 	"v.io/v23/rpc"
 )
 
+func __VDLEnsureNativeBuilt_cancel_collector() {
+}
+
 // CancelCollectorClientMethods is the client interface
 // containing CancelCollector methods.
 //
diff --git a/go/src/v.io/x/js.core/test_service/error_thrower.vdl.go b/go/src/v.io/x/js.core/test_service/error_thrower.vdl.go
index 75d39fc..224c0eb 100644
--- a/go/src/v.io/x/js.core/test_service/error_thrower.vdl.go
+++ b/go/src/v.io/x/js.core/test_service/error_thrower.vdl.go
@@ -14,6 +14,9 @@
 	"v.io/v23/rpc"
 )
 
+func __VDLEnsureNativeBuilt_error_thrower() {
+}
+
 // ErrorThrowerClientMethods is the client interface
 // containing ErrorThrower methods.
 //
diff --git a/go/src/v.io/x/js.core/test_service/invoke_method_caveat_id.vdl.go b/go/src/v.io/x/js.core/test_service/invoke_method_caveat_id.vdl.go
index ac8fd09..9ce4033 100644
--- a/go/src/v.io/x/js.core/test_service/invoke_method_caveat_id.vdl.go
+++ b/go/src/v.io/x/js.core/test_service/invoke_method_caveat_id.vdl.go
@@ -30,10 +30,79 @@
 }) {
 }
 
+func (m *TestCaveatData) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+
+	if __VDLType_invoke_method_caveat_id_v_io_x_js_core_test_service_TestCaveatData == nil || __VDLTypeinvoke_method_caveat_id0 == nil {
+		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
+	}
+	fieldsTarget1, err := t.StartFields(tt)
+	if err != nil {
+		return err
+	}
+
+	var2 := (m.A == "")
+	if !var2 {
+		keyTarget3, fieldTarget4, err := fieldsTarget1.StartField("A")
+		if err != vdl.ErrFieldNoExist && err != nil {
+			return err
+		}
+		if err != vdl.ErrFieldNoExist {
+			if err := fieldTarget4.FromString(string(m.A), vdl.StringType); err != nil {
+				return err
+			}
+			if err := fieldsTarget1.FinishField(keyTarget3, fieldTarget4); err != nil {
+				return err
+			}
+		}
+	}
+	var5 := (m.B == (*vom.RawBytes)(nil))
+	if !var5 {
+		keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("B")
+		if err != vdl.ErrFieldNoExist && err != nil {
+			return err
+		}
+		if err != vdl.ErrFieldNoExist {
+
+			if m.B == nil {
+				if err := fieldTarget7.FromNil(vdl.AnyType); err != nil {
+					return err
+				}
+			} else {
+				if err := m.B.FillVDLTarget(fieldTarget7, vdl.AnyType); err != nil {
+					return err
+				}
+			}
+			if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+				return err
+			}
+		}
+	}
+	if err := t.FinishFields(fieldsTarget1); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m *TestCaveatData) MakeVDLTarget() vdl.Target {
+	return nil
+}
+
+func (m *TestCaveatData) IsZero() bool {
+
+	var1 := (*m == TestCaveatData{})
+	return var1
+}
+
 func init() {
 	vdl.Register((*TestCaveatData)(nil))
 }
 
+var __VDLTypeinvoke_method_caveat_id0 *vdl.Type = vdl.TypeOf((*TestCaveatData)(nil))
+var __VDLType_invoke_method_caveat_id_v_io_x_js_core_test_service_TestCaveatData *vdl.Type = vdl.TypeOf(TestCaveatData{})
+
+func __VDLEnsureNativeBuilt_invoke_method_caveat_id() {
+}
+
 var ConditionallyValidatingTestCaveat = security.CaveatDescriptor{
 	Id: uniqueid.Id{
 		0,
diff --git a/go/src/v.io/x/js.core/test_service/native.vdl.go b/go/src/v.io/x/js.core/test_service/native.vdl.go
index 4080377..c6f7a21 100644
--- a/go/src/v.io/x/js.core/test_service/native.vdl.go
+++ b/go/src/v.io/x/js.core/test_service/native.vdl.go
@@ -18,6 +18,9 @@
 	_ "v.io/v23/vdlroot/time"
 )
 
+func __VDLEnsureNativeBuilt_native() {
+}
+
 // NativeTestClientMethods is the client interface
 // containing NativeTest methods.
 type NativeTestClientMethods interface {