diff --git a/Makefile b/Makefile
index 010712f..88d5cd9 100644
--- a/Makefile
+++ b/Makefile
@@ -121,12 +121,10 @@
 
 # Examples.
 run-advertiser: $(DISCOVERY_BUILD_DIR)/advertiser.mojo $(DISCOVERY_BUILD_DIR)/discovery.mojo
-	$(MOJO_DEVTOOLS)/mojo_run --config-file $(CURDIR)/mojoconfig $(MOJO_SHELL_FLAGS) $(MOJO_ANDROID_FLAGS) https://mojo.v.io/advertiser.mojo \
-	--args-for="https://mojo.v.io/discovery.mojo"
+	$(call MOJO_RUN,"https://mojo.v.io/advertiser.mojo")
 
 run-scanner: $(DISCOVERY_BUILD_DIR)/scanner.mojo $(DISCOVERY_BUILD_DIR)/discovery.mojo
-	$(MOJO_DEVTOOLS)/mojo_run --config-file $(CURDIR)/mojoconfig $(MOJO_SHELL_FLAGS) $(MOJO_ANDROID_FLAGS) https://mojo.v.io/scanner.mojo \
-	--args-for="https://mojo.v.io/discovery.mojo"
+	$(call MOJO_RUN,"https://mojo.v.io/scanner.mojo")
 
 $(DISCOVERY_BUILD_DIR)/advertiser.mojo: $(V23_GO_FILES) go/src/mojom/vanadium/discovery/discovery.mojom.go | mojo-env-check
 	$(call MOGO_BUILD,examples/advertiser,$@)
diff --git a/go/src/examples/advertiser/advertiser.go b/go/src/examples/advertiser/advertiser.go
index 7226b6e..0d41e53 100644
--- a/go/src/examples/advertiser/advertiser.go
+++ b/go/src/examples/advertiser/advertiser.go
@@ -17,42 +17,46 @@
 //#include "mojo/public/c/system/types.h"
 import "C"
 
-type advDelegate struct {
-	id    uint32
-	proxy *discovery.Advertiser_Proxy
+type delegate struct {
+	stop func()
 }
 
-func (a *advDelegate) Initialize(ctx application.Context) {
-	req, ptr := discovery.CreateMessagePipeForAdvertiser()
+func (d *delegate) Initialize(ctx application.Context) {
+	req, ptr := discovery.CreateMessagePipeForDiscovery()
 	ctx.ConnectToApplication("https://mojo.v.io/discovery.mojo").ConnectToService(&req)
-	a.proxy = discovery.NewAdvertiserProxy(ptr, bindings.GetAsyncWaiter())
-	s := discovery.Service{
+
+	service := discovery.Service{
 		InterfaceName: "v.io/discovery.T",
 		Addrs:         []string{"localhost:1000", "localhost:2000"},
 		Attrs:         &map[string]string{"foo": "bar"},
 	}
-	id, _, e1, e2 := a.proxy.Advertise(s, nil)
+	proxy := discovery.NewDiscoveryProxy(ptr, bindings.GetAsyncWaiter())
+	instanceId, e1, e2 := proxy.StartAdvertising(service, nil)
 	if e1 != nil || e2 != nil {
 		log.Println("Error occurred", e1, e2)
 		return
 	}
 
-	a.id = id
+	d.stop = func() {
+		proxy.StopAdvertising(instanceId)
+		proxy.Close_Proxy()
+	}
 }
 
-func (*advDelegate) AcceptConnection(connection *application.Connection) {
+func (*delegate) AcceptConnection(connection *application.Connection) {
 	connection.Close()
 }
 
-func (s *advDelegate) Quit() {
-	s.proxy.Stop(s.id)
+func (d *delegate) Quit() {
+	if d.stop != nil {
+		d.stop()
+	}
 }
 
 //export MojoMain
 func MojoMain(handle C.MojoHandle) C.MojoResult {
-	application.Run(&advDelegate{}, system.MojoHandle(handle))
+	application.Run(&delegate{}, system.MojoHandle(handle))
 	return C.MOJO_RESULT_OK
 }
 
-func main() {
-}
+func main() {}
diff --git a/go/src/examples/scanner/scanner.go b/go/src/examples/scanner/scanner.go
index 9a78238..2ad52a1 100644
--- a/go/src/examples/scanner/scanner.go
+++ b/go/src/examples/scanner/scanner.go
@@ -17,42 +17,50 @@
 //#include "mojo/public/c/system/types.h"
 import "C"
 
-type handler struct{}
+type scanHandler struct{}
 
-func (*handler) Found(s discovery.Service) error {
-	log.Println("Found a new service", s)
+func (*scanHandler) Update(update discovery.Update) error {
+	var tag string
+	switch update.UpdateType {
+	case discovery.UpdateType_Found:
+		tag = "Found"
+	case discovery.UpdateType_Lost:
+		tag = "Lost"
+	}
+	log.Printf("%s service: %v", tag, update.Service)
 	return nil
 }
 
-func (*handler) Lost(s []uint8) error {
-	log.Println("Lost a new service", s)
-	return nil
+type delegate struct {
+	stop func()
 }
 
-type scannerDelegate struct {
-	id    uint32
-	proxy *discovery.Scanner_Proxy
-	stub  *bindings.Stub
-}
-
-func (s *scannerDelegate) Initialize(ctx application.Context) {
-	req, ptr := discovery.CreateMessagePipeForScanner()
+func (d *delegate) Initialize(ctx application.Context) {
+	req, ptr := discovery.CreateMessagePipeForDiscovery()
 	ctx.ConnectToApplication("https://mojo.v.io/discovery.mojo").ConnectToService(&req)
-	s.proxy = discovery.NewScannerProxy(ptr, bindings.GetAsyncWaiter())
-	scanReq, scanPtr := discovery.CreateMessagePipeForScanHandler()
-	s.stub = discovery.NewScanHandlerStub(scanReq, &handler{}, bindings.GetAsyncWaiter())
-	id, e1, e2 := s.proxy.Scan(`v.InterfaceName="v.io/discovery.T"`, scanPtr)
+
+	scanHandlerReq, scanHandlerPtr := discovery.CreateMessagePipeForScanHandler()
+	scanHandlerStub := discovery.NewScanHandlerStub(scanHandlerReq, &scanHandler{}, bindings.GetAsyncWaiter())
+
+	proxy := discovery.NewDiscoveryProxy(ptr, bindings.GetAsyncWaiter())
+	scanId, e1, e2 := proxy.StartScan(`v.InterfaceName="v.io/discovery.T"`, scanHandlerPtr)
 	if e1 != nil || e2 != nil {
 		log.Println("Error occurred", e1, e2)
+		scanHandlerStub.Close()
 		return
 	}
 
-	s.id = id
+	d.stop = func() {
+		proxy.StopScan(scanId)
+		scanHandlerStub.Close()
+		proxy.Close_Proxy()
+	}
+
 	go func() {
 		for {
-			if err := s.stub.ServeRequest(); err != nil {
-				connectionError, ok := err.(*bindings.ConnectionError)
-				if !ok || !connectionError.Closed() {
+			if err := scanHandlerStub.ServeRequest(); err != nil {
+				connErr, ok := err.(*bindings.ConnectionError)
+				if !ok || !connErr.Closed() {
 					log.Println(err)
 				}
 				break
@@ -61,20 +69,18 @@
 	}()
 }
 
-func (*scannerDelegate) AcceptConnection(connection *application.Connection) {
+func (*delegate) AcceptConnection(connection *application.Connection) {
 	connection.Close()
 }
 
-func (s *scannerDelegate) Quit() {
-	s.proxy.Stop(s.id)
-	s.stub.Close()
+func (d *delegate) Quit() {
+	d.stop()
 }
 
 //export MojoMain
 func MojoMain(handle C.MojoHandle) C.MojoResult {
-	application.Run(&scannerDelegate{}, system.MojoHandle(handle))
+	application.Run(&delegate{}, system.MojoHandle(handle))
 	return C.MOJO_RESULT_OK
 }
 
-func main() {
-}
+func main() {}
diff --git a/go/src/mojom/vanadium/discovery/discovery.mojom.go b/go/src/mojom/vanadium/discovery/discovery.mojom.go
index 44df270..f8e7461 100644
--- a/go/src/mojom/vanadium/discovery/discovery.mojom.go
+++ b/go/src/mojom/vanadium/discovery/discovery.mojom.go
@@ -19,6 +19,81 @@
 	sort "sort"
 )
 
+// These IDs are the Mojom Identifiers / Type Keys.
+// Mojom libraries importing this one will use these identifiers when building
+// TypeReference objects.
+var ID_discovery_UpdateType__ string = "discovery_UpdateType__"
+var ID_discovery_Service__ string = "discovery_Service__"
+var ID_discovery_Update__ string = "discovery_Update__"
+var ID_discovery_Error__ string = "discovery_Error__"
+var ID_discovery_Discovery__ string = "discovery_Discovery__"
+var ID_discovery_ScanHandler__ string = "discovery_ScanHandler__"
+
+var discoveryDesc__ = make(map[string]mojom_types.UserDefinedType)
+
+func init() {
+	discoveryDesc__["discovery_UpdateType__"] = &mojom_types.UserDefinedTypeEnumType{
+		Value: discovery_UpdateType__(),
+	}
+	discoveryDesc__["discovery_Service__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Service__(),
+	}
+
+	discoveryDesc__["discovery_Update__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Update__(),
+	}
+
+	discoveryDesc__["discovery_Error__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Error__(),
+	}
+
+	discoveryDesc__["discovery_Discovery__"] = &mojom_types.UserDefinedTypeInterfaceType{
+		Value: discovery_Discovery__(),
+	}
+	discoveryDesc__["discovery_Discovery_StartAdvertising_Params__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Discovery_StartAdvertising_Params__(),
+	}
+
+	discoveryDesc__["discovery_Discovery_StartAdvertising_ResponseParams__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Discovery_StartAdvertising_ResponseParams__(),
+	}
+
+	discoveryDesc__["discovery_Discovery_StopAdvertising_Params__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Discovery_StopAdvertising_Params__(),
+	}
+
+	discoveryDesc__["discovery_Discovery_StopAdvertising_ResponseParams__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Discovery_StopAdvertising_ResponseParams__(),
+	}
+
+	discoveryDesc__["discovery_Discovery_StartScan_Params__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Discovery_StartScan_Params__(),
+	}
+
+	discoveryDesc__["discovery_ScanHandler__"] = &mojom_types.UserDefinedTypeInterfaceType{
+		Value: discovery_ScanHandler__(),
+	}
+	discoveryDesc__["discovery_ScanHandler_Update_Params__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_ScanHandler_Update_Params__(),
+	}
+
+	discoveryDesc__["discovery_Discovery_StartScan_ResponseParams__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Discovery_StartScan_ResponseParams__(),
+	}
+
+	discoveryDesc__["discovery_Discovery_StopScan_Params__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Discovery_StopScan_Params__(),
+	}
+
+	discoveryDesc__["discovery_Discovery_StopScan_ResponseParams__"] = &mojom_types.UserDefinedTypeStructType{
+		Value: discovery_Discovery_StopScan_ResponseParams__(),
+	}
+
+}
+func GetAllMojomTypeDefinitions() map[string]mojom_types.UserDefinedType {
+	return discoveryDesc__
+}
+
 type UpdateType int32
 
 const (
@@ -26,78 +101,112 @@
 	UpdateType_Lost  = UpdateType_Found + 1
 )
 
-type Advertiser interface {
-	Advertise(inService Service, inVisibility *[]string) (outHandle uint32, outInstanceId string, outErr *Error, err error)
-	Stop(inH uint32) (outErr *Error, err error)
+// String names and labels used by the MojomEnum types.
+var (
+	enumName_UpdateType            = "UpdateType"
+	enumFullIdentifier_UpdateType  = "discovery.UpdateType"
+	enumFieldName_UpdateType_Found = "Found"
+	enumFieldName_UpdateType_Lost  = "Lost"
+)
+
+func discovery_UpdateType__() mojom_types.MojomEnum {
+	return mojom_types.MojomEnum{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &enumName_UpdateType,
+			FullIdentifier: &enumFullIdentifier_UpdateType,
+		},
+		Values: []mojom_types.EnumValue{mojom_types.EnumValue{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &enumFieldName_UpdateType_Found,
+			},
+			EnumTypeKey: ID_discovery_UpdateType__,
+			IntValue:    int32(1),
+		}, mojom_types.EnumValue{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &enumFieldName_UpdateType_Lost,
+			},
+			EnumTypeKey: ID_discovery_UpdateType__,
+			IntValue:    int32(2),
+		}},
+	}
 }
 
-var advertiser_Name = "v23::discovery::Advertiser"
-
-type Advertiser_Request bindings.InterfaceRequest
-
-func (r *Advertiser_Request) Name() string {
-	return advertiser_Name
+type Discovery interface {
+	StartAdvertising(inService Service, inVisibility *[]string) (outInstanceId string, outErr *Error, err error)
+	StopAdvertising(inInstanceId string) (outErr *Error, err error)
+	StartScan(inQuery string, inHandler ScanHandler_Pointer) (outScanId uint32, outErr *Error, err error)
+	StopScan(inScanId uint32) (outErr *Error, err error)
 }
 
-type Advertiser_Pointer bindings.InterfacePointer
+var discovery_Name = "v23::discovery::Discovery"
 
-func (p *Advertiser_Pointer) Name() string {
-	return advertiser_Name
+type Discovery_Request bindings.InterfaceRequest
+
+func (r *Discovery_Request) Name() string {
+	return discovery_Name
 }
 
-type Advertiser_ServiceFactory struct {
-	Delegate Advertiser_Factory
+type Discovery_Pointer bindings.InterfacePointer
+
+func (p *Discovery_Pointer) Name() string {
+	return discovery_Name
 }
 
-type Advertiser_Factory interface {
-	Create(request Advertiser_Request)
+type Discovery_ServiceFactory struct {
+	Delegate Discovery_Factory
 }
 
-func (f *Advertiser_ServiceFactory) Name() string {
-	return advertiser_Name
+type Discovery_Factory interface {
+	Create(request Discovery_Request)
 }
 
-func (f *Advertiser_ServiceFactory) ServiceDescription() service_describer.ServiceDescription {
-	return &Advertiser_ServiceDescription{}
+func (f *Discovery_ServiceFactory) Name() string {
+	return discovery_Name
 }
 
-func (f *Advertiser_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
-	request := Advertiser_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+func (f *Discovery_ServiceFactory) ServiceDescription() service_describer.ServiceDescription {
+	return &Discovery_ServiceDescription{}
+}
+
+func (f *Discovery_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+	request := Discovery_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
 	f.Delegate.Create(request)
 }
 
-// CreateMessagePipeForAdvertiser creates a message pipe for use with the
-// Advertiser interface with a Advertiser_Request on one end and a Advertiser_Pointer on the other.
-func CreateMessagePipeForAdvertiser() (Advertiser_Request, Advertiser_Pointer) {
+// CreateMessagePipeForDiscovery creates a message pipe for use with the
+// Discovery interface with a Discovery_Request on one end and a Discovery_Pointer on the other.
+func CreateMessagePipeForDiscovery() (Discovery_Request, Discovery_Pointer) {
 	r, p := bindings.CreateMessagePipeForMojoInterface()
-	return Advertiser_Request(r), Advertiser_Pointer(p)
+	return Discovery_Request(r), Discovery_Pointer(p)
 }
 
-const advertiser_Advertise_Name uint32 = 0
-const advertiser_Stop_Name uint32 = 1
+const discovery_StartAdvertising_Name uint32 = 0
+const discovery_StopAdvertising_Name uint32 = 1
+const discovery_StartScan_Name uint32 = 2
+const discovery_StopScan_Name uint32 = 3
 
-type Advertiser_Proxy struct {
+type Discovery_Proxy struct {
 	router *bindings.Router
 	ids    bindings.Counter
 }
 
-func NewAdvertiserProxy(p Advertiser_Pointer, waiter bindings.AsyncWaiter) *Advertiser_Proxy {
-	return &Advertiser_Proxy{
+func NewDiscoveryProxy(p Discovery_Pointer, waiter bindings.AsyncWaiter) *Discovery_Proxy {
+	return &Discovery_Proxy{
 		bindings.NewRouter(p.PassMessagePipe(), waiter),
 		bindings.NewCounter(),
 	}
 }
 
-func (p *Advertiser_Proxy) Close_Proxy() {
+func (p *Discovery_Proxy) Close_Proxy() {
 	p.router.Close()
 }
 
-type advertiser_Advertise_Params struct {
+type discovery_StartAdvertising_Params struct {
 	inService    Service
 	inVisibility *[]string
 }
 
-func (s *advertiser_Advertise_Params) Encode(encoder *bindings.Encoder) error {
+func (s *discovery_StartAdvertising_Params) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(16, 0)
 	if err := encoder.WritePointer(); err != nil {
 		return err
@@ -130,23 +239,23 @@
 	return nil
 }
 
-var advertiser_Advertise_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var discovery_StartAdvertising_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{24, 0},
 }
 
-func (s *advertiser_Advertise_Params) Decode(decoder *bindings.Decoder) error {
+func (s *discovery_StartAdvertising_Params) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(advertiser_Advertise_Params_Versions), func(i int) bool {
-		return advertiser_Advertise_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(discovery_StartAdvertising_Params_Versions), func(i int) bool {
+		return discovery_StartAdvertising_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(advertiser_Advertise_Params_Versions) {
-		if advertiser_Advertise_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(discovery_StartAdvertising_Params_Versions) {
+		if discovery_StartAdvertising_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := advertiser_Advertise_Params_Versions[index].Size
+		expectedSize := discovery_StartAdvertising_Params_Versions[index].Size
 		if expectedSize != header.Size {
 			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
 				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -206,17 +315,45 @@
 	return nil
 }
 
-type advertiser_Advertise_ResponseParams struct {
-	outHandle     uint32
+// String names and labels used by the MojomStruct types.
+var (
+	structName_DiscoveryStartAdvertisingParams                   = "DiscoveryStartAdvertisingParams"
+	structFullIdentifier_DiscoveryStartAdvertisingParams         = "discovery.DiscoveryStartAdvertisingParams"
+	structFieldName_DiscoveryStartAdvertisingParams_InService    = "InService"
+	structFieldName_DiscoveryStartAdvertisingParams_InVisibility = "InVisibility"
+)
+
+func discovery_Discovery_StartAdvertising_Params__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_DiscoveryStartAdvertisingParams,
+			FullIdentifier: &structFullIdentifier_DiscoveryStartAdvertisingParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStartAdvertisingParams_InService,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Identifier: &ID_discovery_Service__,
+					TypeKey: &ID_discovery_Service__},
+			},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStartAdvertisingParams_InVisibility,
+			},
+			Type: &mojom_types.TypeArrayType{
+				Value: mojom_types.ArrayType{Nullable: true, ElementType: &mojom_types.TypeStringType{mojom_types.StringType{false}}},
+			},
+		}},
+	}
+}
+
+type discovery_StartAdvertising_ResponseParams struct {
 	outInstanceId string
 	outErr        *Error
 }
 
-func (s *advertiser_Advertise_ResponseParams) Encode(encoder *bindings.Encoder) error {
-	encoder.StartStruct(24, 0)
-	if err := encoder.WriteUint32(s.outHandle); err != nil {
-		return err
-	}
+func (s *discovery_StartAdvertising_ResponseParams) Encode(encoder *bindings.Encoder) error {
+	encoder.StartStruct(16, 0)
 	if err := encoder.WritePointer(); err != nil {
 		return err
 	}
@@ -239,23 +376,23 @@
 	return nil
 }
 
-var advertiser_Advertise_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
-	bindings.DataHeader{32, 0},
+var discovery_StartAdvertising_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+	bindings.DataHeader{24, 0},
 }
 
-func (s *advertiser_Advertise_ResponseParams) Decode(decoder *bindings.Decoder) error {
+func (s *discovery_StartAdvertising_ResponseParams) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(advertiser_Advertise_ResponseParams_Versions), func(i int) bool {
-		return advertiser_Advertise_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(discovery_StartAdvertising_ResponseParams_Versions), func(i int) bool {
+		return discovery_StartAdvertising_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(advertiser_Advertise_ResponseParams_Versions) {
-		if advertiser_Advertise_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(discovery_StartAdvertising_ResponseParams_Versions) {
+		if discovery_StartAdvertising_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := advertiser_Advertise_ResponseParams_Versions[index].Size
+		expectedSize := discovery_StartAdvertising_ResponseParams_Versions[index].Size
 		if expectedSize != header.Size {
 			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
 				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -263,13 +400,6 @@
 		}
 	}
 	if header.ElementsOrVersion >= 0 {
-		value0, err := decoder.ReadUint32()
-		if err != nil {
-			return err
-		}
-		s.outHandle = value0
-	}
-	if header.ElementsOrVersion >= 0 {
 		pointer0, err := decoder.ReadPointer()
 		if err != nil {
 			return err
@@ -304,13 +434,43 @@
 	return nil
 }
 
-func (p *Advertiser_Proxy) Advertise(inService Service, inVisibility *[]string) (outHandle uint32, outInstanceId string, outErr *Error, err error) {
-	payload := &advertiser_Advertise_Params{
+// String names and labels used by the MojomStruct types.
+var (
+	structName_DiscoveryStartAdvertisingResponseParams                    = "DiscoveryStartAdvertisingResponseParams"
+	structFullIdentifier_DiscoveryStartAdvertisingResponseParams          = "discovery.DiscoveryStartAdvertisingResponseParams"
+	structFieldName_DiscoveryStartAdvertisingResponseParams_OutInstanceId = "OutInstanceId"
+	structFieldName_DiscoveryStartAdvertisingResponseParams_OutErr        = "OutErr"
+)
+
+func discovery_Discovery_StartAdvertising_ResponseParams__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_DiscoveryStartAdvertisingResponseParams,
+			FullIdentifier: &structFullIdentifier_DiscoveryStartAdvertisingResponseParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStartAdvertisingResponseParams_OutInstanceId,
+			},
+			Type: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStartAdvertisingResponseParams_OutErr,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Nullable: true, Identifier: &ID_discovery_Error__,
+					TypeKey: &ID_discovery_Error__},
+			},
+		}},
+	}
+}
+
+func (p *Discovery_Proxy) StartAdvertising(inService Service, inVisibility *[]string) (outInstanceId string, outErr *Error, err error) {
+	payload := &discovery_StartAdvertising_Params{
 		inService,
 		inVisibility,
 	}
 	header := bindings.MessageHeader{
-		Type:      advertiser_Advertise_Name,
+		Type:      discovery_StartAdvertising_Name,
 		Flags:     bindings.MessageExpectsResponseFlag,
 		RequestId: p.ids.Count(),
 	}
@@ -331,30 +491,32 @@
 		}
 		return
 	}
-	if got, want := readResult.Message.Header.Type, advertiser_Advertise_Name; got != want {
+	if got, want := readResult.Message.Header.Type, discovery_StartAdvertising_Name; got != want {
 		err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
 			fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
 		}
 		return
 	}
-	var response advertiser_Advertise_ResponseParams
+	var response discovery_StartAdvertising_ResponseParams
 	if err = readResult.Message.DecodePayload(&response); err != nil {
 		p.Close_Proxy()
 		return
 	}
-	outHandle = response.outHandle
 	outInstanceId = response.outInstanceId
 	outErr = response.outErr
 	return
 }
 
-type advertiser_Stop_Params struct {
-	inH uint32
+type discovery_StopAdvertising_Params struct {
+	inInstanceId string
 }
 
-func (s *advertiser_Stop_Params) Encode(encoder *bindings.Encoder) error {
+func (s *discovery_StopAdvertising_Params) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(8, 0)
-	if err := encoder.WriteUint32(s.inH); err != nil {
+	if err := encoder.WritePointer(); err != nil {
+		return err
+	}
+	if err := encoder.WriteString(s.inInstanceId); err != nil {
 		return err
 	}
 	if err := encoder.Finish(); err != nil {
@@ -363,23 +525,23 @@
 	return nil
 }
 
-var advertiser_Stop_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var discovery_StopAdvertising_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{16, 0},
 }
 
-func (s *advertiser_Stop_Params) Decode(decoder *bindings.Decoder) error {
+func (s *discovery_StopAdvertising_Params) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(advertiser_Stop_Params_Versions), func(i int) bool {
-		return advertiser_Stop_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(discovery_StopAdvertising_Params_Versions), func(i int) bool {
+		return discovery_StopAdvertising_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(advertiser_Stop_Params_Versions) {
-		if advertiser_Stop_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(discovery_StopAdvertising_Params_Versions) {
+		if discovery_StopAdvertising_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := advertiser_Stop_Params_Versions[index].Size
+		expectedSize := discovery_StopAdvertising_Params_Versions[index].Size
 		if expectedSize != header.Size {
 			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
 				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -387,11 +549,19 @@
 		}
 	}
 	if header.ElementsOrVersion >= 0 {
-		value0, err := decoder.ReadUint32()
+		pointer0, err := decoder.ReadPointer()
 		if err != nil {
 			return err
 		}
-		s.inH = value0
+		if pointer0 == 0 {
+			return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+		} else {
+			value0, err := decoder.ReadString()
+			if err != nil {
+				return err
+			}
+			s.inInstanceId = value0
+		}
 	}
 	if err := decoder.Finish(); err != nil {
 		return err
@@ -399,11 +569,32 @@
 	return nil
 }
 
-type advertiser_Stop_ResponseParams struct {
+// String names and labels used by the MojomStruct types.
+var (
+	structName_DiscoveryStopAdvertisingParams                   = "DiscoveryStopAdvertisingParams"
+	structFullIdentifier_DiscoveryStopAdvertisingParams         = "discovery.DiscoveryStopAdvertisingParams"
+	structFieldName_DiscoveryStopAdvertisingParams_InInstanceId = "InInstanceId"
+)
+
+func discovery_Discovery_StopAdvertising_Params__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_DiscoveryStopAdvertisingParams,
+			FullIdentifier: &structFullIdentifier_DiscoveryStopAdvertisingParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStopAdvertisingParams_InInstanceId,
+			},
+			Type: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+		}},
+	}
+}
+
+type discovery_StopAdvertising_ResponseParams struct {
 	outErr *Error
 }
 
-func (s *advertiser_Stop_ResponseParams) Encode(encoder *bindings.Encoder) error {
+func (s *discovery_StopAdvertising_ResponseParams) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(8, 0)
 	if s.outErr == nil {
 		encoder.WriteNullPointer()
@@ -421,23 +612,23 @@
 	return nil
 }
 
-var advertiser_Stop_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+var discovery_StopAdvertising_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{16, 0},
 }
 
-func (s *advertiser_Stop_ResponseParams) Decode(decoder *bindings.Decoder) error {
+func (s *discovery_StopAdvertising_ResponseParams) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(advertiser_Stop_ResponseParams_Versions), func(i int) bool {
-		return advertiser_Stop_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(discovery_StopAdvertising_ResponseParams_Versions), func(i int) bool {
+		return discovery_StopAdvertising_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(advertiser_Stop_ResponseParams_Versions) {
-		if advertiser_Stop_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(discovery_StopAdvertising_ResponseParams_Versions) {
+		if discovery_StopAdvertising_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := advertiser_Stop_ResponseParams_Versions[index].Size
+		expectedSize := discovery_StopAdvertising_ResponseParams_Versions[index].Size
 		if expectedSize != header.Size {
 			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
 				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -464,12 +655,36 @@
 	return nil
 }
 
-func (p *Advertiser_Proxy) Stop(inH uint32) (outErr *Error, err error) {
-	payload := &advertiser_Stop_Params{
-		inH,
+// String names and labels used by the MojomStruct types.
+var (
+	structName_DiscoveryStopAdvertisingResponseParams             = "DiscoveryStopAdvertisingResponseParams"
+	structFullIdentifier_DiscoveryStopAdvertisingResponseParams   = "discovery.DiscoveryStopAdvertisingResponseParams"
+	structFieldName_DiscoveryStopAdvertisingResponseParams_OutErr = "OutErr"
+)
+
+func discovery_Discovery_StopAdvertising_ResponseParams__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_DiscoveryStopAdvertisingResponseParams,
+			FullIdentifier: &structFullIdentifier_DiscoveryStopAdvertisingResponseParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStopAdvertisingResponseParams_OutErr,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Nullable: true, Identifier: &ID_discovery_Error__,
+					TypeKey: &ID_discovery_Error__},
+			},
+		}},
+	}
+}
+
+func (p *Discovery_Proxy) StopAdvertising(inInstanceId string) (outErr *Error, err error) {
+	payload := &discovery_StopAdvertising_Params{
+		inInstanceId,
 	}
 	header := bindings.MessageHeader{
-		Type:      advertiser_Stop_Name,
+		Type:      discovery_StopAdvertising_Name,
 		Flags:     bindings.MessageExpectsResponseFlag,
 		RequestId: p.ids.Count(),
 	}
@@ -490,13 +705,13 @@
 		}
 		return
 	}
-	if got, want := readResult.Message.Header.Type, advertiser_Stop_Name; got != want {
+	if got, want := readResult.Message.Header.Type, discovery_StopAdvertising_Name; got != want {
 		err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
 			fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
 		}
 		return
 	}
-	var response advertiser_Stop_ResponseParams
+	var response discovery_StopAdvertising_ResponseParams
 	if err = readResult.Message.DecodePayload(&response); err != nil {
 		p.Close_Proxy()
 		return
@@ -505,172 +720,12 @@
 	return
 }
 
-type advertiser_Stub struct {
-	connector *bindings.Connector
-	impl      Advertiser
+type discovery_StartScan_Params struct {
+	inQuery   string
+	inHandler ScanHandler_Pointer
 }
 
-func NewAdvertiserStub(r Advertiser_Request, impl Advertiser, waiter bindings.AsyncWaiter) *bindings.Stub {
-	connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
-	return bindings.NewStub(connector, &advertiser_Stub{connector, impl})
-}
-
-func (f *Advertiser_Request) ServiceDescription() service_describer.ServiceDescription {
-	return &Advertiser_ServiceDescription{}
-}
-
-type Advertiser_ServiceDescription struct{}
-
-func (sd *Advertiser_ServiceDescription) GetTopLevelInterface() (outMojomInterface mojom_types.MojomInterface, err error) {
-	err = fmt.Errorf("GetTopLevelInterface not implemented")
-	return
-}
-
-func (sd *Advertiser_ServiceDescription) GetTypeDefinition(inTypeKey string) (outType mojom_types.UserDefinedType, err error) {
-	err = fmt.Errorf("GetTypeDefinition not implemented")
-	return
-}
-
-func (sd *Advertiser_ServiceDescription) GetAllTypeDefinitions() (outDefinitions *map[string]mojom_types.UserDefinedType, err error) {
-	err = fmt.Errorf("GetAllTypeDefinitions not implemented")
-	return
-}
-
-var _ service_describer.ServiceDescription = (*Advertiser_ServiceDescription)(nil)
-
-func (s *advertiser_Stub) Accept(message *bindings.Message) (err error) {
-	switch message.Header.Type {
-	case advertiser_Advertise_Name:
-		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
-			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
-				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
-			}
-		}
-		var request advertiser_Advertise_Params
-		if err := message.DecodePayload(&request); err != nil {
-			return err
-		}
-		var response advertiser_Advertise_ResponseParams
-		response.outHandle, response.outInstanceId, response.outErr, err = s.impl.Advertise(request.inService, request.inVisibility)
-		if err != nil {
-			return
-		}
-		header := bindings.MessageHeader{
-			Type:      advertiser_Advertise_Name,
-			Flags:     bindings.MessageIsResponseFlag,
-			RequestId: message.Header.RequestId,
-		}
-		message, err = bindings.EncodeMessage(header, &response)
-		if err != nil {
-			return err
-		}
-		return s.connector.WriteMessage(message)
-	case advertiser_Stop_Name:
-		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
-			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
-				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
-			}
-		}
-		var request advertiser_Stop_Params
-		if err := message.DecodePayload(&request); err != nil {
-			return err
-		}
-		var response advertiser_Stop_ResponseParams
-		response.outErr, err = s.impl.Stop(request.inH)
-		if err != nil {
-			return
-		}
-		header := bindings.MessageHeader{
-			Type:      advertiser_Stop_Name,
-			Flags:     bindings.MessageIsResponseFlag,
-			RequestId: message.Header.RequestId,
-		}
-		message, err = bindings.EncodeMessage(header, &response)
-		if err != nil {
-			return err
-		}
-		return s.connector.WriteMessage(message)
-	default:
-		return &bindings.ValidationError{
-			bindings.MessageHeaderUnknownMethod,
-			fmt.Sprintf("unknown method %v", message.Header.Type),
-		}
-	}
-	return
-}
-
-type Scanner interface {
-	Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle uint32, outErr *Error, err error)
-	Stop(inH uint32) (outErr *Error, err error)
-}
-
-var scanner_Name = "v23::discovery::Scanner"
-
-type Scanner_Request bindings.InterfaceRequest
-
-func (r *Scanner_Request) Name() string {
-	return scanner_Name
-}
-
-type Scanner_Pointer bindings.InterfacePointer
-
-func (p *Scanner_Pointer) Name() string {
-	return scanner_Name
-}
-
-type Scanner_ServiceFactory struct {
-	Delegate Scanner_Factory
-}
-
-type Scanner_Factory interface {
-	Create(request Scanner_Request)
-}
-
-func (f *Scanner_ServiceFactory) Name() string {
-	return scanner_Name
-}
-
-func (f *Scanner_ServiceFactory) ServiceDescription() service_describer.ServiceDescription {
-	return &Scanner_ServiceDescription{}
-}
-
-func (f *Scanner_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
-	request := Scanner_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
-	f.Delegate.Create(request)
-}
-
-// CreateMessagePipeForScanner creates a message pipe for use with the
-// Scanner interface with a Scanner_Request on one end and a Scanner_Pointer on the other.
-func CreateMessagePipeForScanner() (Scanner_Request, Scanner_Pointer) {
-	r, p := bindings.CreateMessagePipeForMojoInterface()
-	return Scanner_Request(r), Scanner_Pointer(p)
-}
-
-const scanner_Scan_Name uint32 = 0
-const scanner_Stop_Name uint32 = 1
-
-type Scanner_Proxy struct {
-	router *bindings.Router
-	ids    bindings.Counter
-}
-
-func NewScannerProxy(p Scanner_Pointer, waiter bindings.AsyncWaiter) *Scanner_Proxy {
-	return &Scanner_Proxy{
-		bindings.NewRouter(p.PassMessagePipe(), waiter),
-		bindings.NewCounter(),
-	}
-}
-
-func (p *Scanner_Proxy) Close_Proxy() {
-	p.router.Close()
-}
-
-type scanner_Scan_Params struct {
-	inQuery       string
-	inScanHandler ScanHandler_Pointer
-}
-
-func (s *scanner_Scan_Params) Encode(encoder *bindings.Encoder) error {
+func (s *discovery_StartScan_Params) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(16, 0)
 	if err := encoder.WritePointer(); err != nil {
 		return err
@@ -678,7 +733,7 @@
 	if err := encoder.WriteString(s.inQuery); err != nil {
 		return err
 	}
-	if err := encoder.WriteInterface(s.inScanHandler.PassMessagePipe()); err != nil {
+	if err := encoder.WriteInterface(s.inHandler.PassMessagePipe()); err != nil {
 		return err
 	}
 	if err := encoder.Finish(); err != nil {
@@ -687,23 +742,23 @@
 	return nil
 }
 
-var scanner_Scan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var discovery_StartScan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{24, 0},
 }
 
-func (s *scanner_Scan_Params) Decode(decoder *bindings.Decoder) error {
+func (s *discovery_StartScan_Params) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(scanner_Scan_Params_Versions), func(i int) bool {
-		return scanner_Scan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(discovery_StartScan_Params_Versions), func(i int) bool {
+		return discovery_StartScan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(scanner_Scan_Params_Versions) {
-		if scanner_Scan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(discovery_StartScan_Params_Versions) {
+		if discovery_StartScan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := scanner_Scan_Params_Versions[index].Size
+		expectedSize := discovery_StartScan_Params_Versions[index].Size
 		if expectedSize != header.Size {
 			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
 				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -732,7 +787,7 @@
 		}
 		if handle0.IsValid() {
 			handleOwner := bindings.NewMessagePipeHandleOwner(handle0)
-			s.inScanHandler = ScanHandler_Pointer{handleOwner}
+			s.inHandler = ScanHandler_Pointer{handleOwner}
 		} else {
 			return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unexpected invalid handle"}
 		}
@@ -743,14 +798,44 @@
 	return nil
 }
 
-type scanner_Scan_ResponseParams struct {
-	outHandle uint32
+// String names and labels used by the MojomStruct types.
+var (
+	structName_DiscoveryStartScanParams                = "DiscoveryStartScanParams"
+	structFullIdentifier_DiscoveryStartScanParams      = "discovery.DiscoveryStartScanParams"
+	structFieldName_DiscoveryStartScanParams_InQuery   = "InQuery"
+	structFieldName_DiscoveryStartScanParams_InHandler = "InHandler"
+)
+
+func discovery_Discovery_StartScan_Params__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_DiscoveryStartScanParams,
+			FullIdentifier: &structFullIdentifier_DiscoveryStartScanParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStartScanParams_InQuery,
+			},
+			Type: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStartScanParams_InHandler,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Identifier: &ID_discovery_ScanHandler__,
+					TypeKey: &ID_discovery_ScanHandler__},
+			},
+		}},
+	}
+}
+
+type discovery_StartScan_ResponseParams struct {
+	outScanId uint32
 	outErr    *Error
 }
 
-func (s *scanner_Scan_ResponseParams) Encode(encoder *bindings.Encoder) error {
+func (s *discovery_StartScan_ResponseParams) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(16, 0)
-	if err := encoder.WriteUint32(s.outHandle); err != nil {
+	if err := encoder.WriteUint32(s.outScanId); err != nil {
 		return err
 	}
 	if s.outErr == nil {
@@ -769,23 +854,23 @@
 	return nil
 }
 
-var scanner_Scan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+var discovery_StartScan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{24, 0},
 }
 
-func (s *scanner_Scan_ResponseParams) Decode(decoder *bindings.Decoder) error {
+func (s *discovery_StartScan_ResponseParams) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(scanner_Scan_ResponseParams_Versions), func(i int) bool {
-		return scanner_Scan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(discovery_StartScan_ResponseParams_Versions), func(i int) bool {
+		return discovery_StartScan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(scanner_Scan_ResponseParams_Versions) {
-		if scanner_Scan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(discovery_StartScan_ResponseParams_Versions) {
+		if discovery_StartScan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := scanner_Scan_ResponseParams_Versions[index].Size
+		expectedSize := discovery_StartScan_ResponseParams_Versions[index].Size
 		if expectedSize != header.Size {
 			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
 				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -797,7 +882,7 @@
 		if err != nil {
 			return err
 		}
-		s.outHandle = value0
+		s.outScanId = value0
 	}
 	if header.ElementsOrVersion >= 0 {
 		pointer0, err := decoder.ReadPointer()
@@ -819,13 +904,43 @@
 	return nil
 }
 
-func (p *Scanner_Proxy) Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle uint32, outErr *Error, err error) {
-	payload := &scanner_Scan_Params{
+// String names and labels used by the MojomStruct types.
+var (
+	structName_DiscoveryStartScanResponseParams                = "DiscoveryStartScanResponseParams"
+	structFullIdentifier_DiscoveryStartScanResponseParams      = "discovery.DiscoveryStartScanResponseParams"
+	structFieldName_DiscoveryStartScanResponseParams_OutScanId = "OutScanId"
+	structFieldName_DiscoveryStartScanResponseParams_OutErr    = "OutErr"
+)
+
+func discovery_Discovery_StartScan_ResponseParams__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_DiscoveryStartScanResponseParams,
+			FullIdentifier: &structFullIdentifier_DiscoveryStartScanResponseParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStartScanResponseParams_OutScanId,
+			},
+			Type: &mojom_types.TypeSimpleType{mojom_types.SimpleType_UinT32},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStartScanResponseParams_OutErr,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Nullable: true, Identifier: &ID_discovery_Error__,
+					TypeKey: &ID_discovery_Error__},
+			},
+		}},
+	}
+}
+
+func (p *Discovery_Proxy) StartScan(inQuery string, inHandler ScanHandler_Pointer) (outScanId uint32, outErr *Error, err error) {
+	payload := &discovery_StartScan_Params{
 		inQuery,
-		inScanHandler,
+		inHandler,
 	}
 	header := bindings.MessageHeader{
-		Type:      scanner_Scan_Name,
+		Type:      discovery_StartScan_Name,
 		Flags:     bindings.MessageExpectsResponseFlag,
 		RequestId: p.ids.Count(),
 	}
@@ -846,29 +961,29 @@
 		}
 		return
 	}
-	if got, want := readResult.Message.Header.Type, scanner_Scan_Name; got != want {
+	if got, want := readResult.Message.Header.Type, discovery_StartScan_Name; got != want {
 		err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
 			fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
 		}
 		return
 	}
-	var response scanner_Scan_ResponseParams
+	var response discovery_StartScan_ResponseParams
 	if err = readResult.Message.DecodePayload(&response); err != nil {
 		p.Close_Proxy()
 		return
 	}
-	outHandle = response.outHandle
+	outScanId = response.outScanId
 	outErr = response.outErr
 	return
 }
 
-type scanner_Stop_Params struct {
-	inH uint32
+type discovery_StopScan_Params struct {
+	inScanId uint32
 }
 
-func (s *scanner_Stop_Params) Encode(encoder *bindings.Encoder) error {
+func (s *discovery_StopScan_Params) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(8, 0)
-	if err := encoder.WriteUint32(s.inH); err != nil {
+	if err := encoder.WriteUint32(s.inScanId); err != nil {
 		return err
 	}
 	if err := encoder.Finish(); err != nil {
@@ -877,23 +992,23 @@
 	return nil
 }
 
-var scanner_Stop_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var discovery_StopScan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{16, 0},
 }
 
-func (s *scanner_Stop_Params) Decode(decoder *bindings.Decoder) error {
+func (s *discovery_StopScan_Params) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(scanner_Stop_Params_Versions), func(i int) bool {
-		return scanner_Stop_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(discovery_StopScan_Params_Versions), func(i int) bool {
+		return discovery_StopScan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(scanner_Stop_Params_Versions) {
-		if scanner_Stop_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(discovery_StopScan_Params_Versions) {
+		if discovery_StopScan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := scanner_Stop_Params_Versions[index].Size
+		expectedSize := discovery_StopScan_Params_Versions[index].Size
 		if expectedSize != header.Size {
 			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
 				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -905,7 +1020,7 @@
 		if err != nil {
 			return err
 		}
-		s.inH = value0
+		s.inScanId = value0
 	}
 	if err := decoder.Finish(); err != nil {
 		return err
@@ -913,11 +1028,32 @@
 	return nil
 }
 
-type scanner_Stop_ResponseParams struct {
+// String names and labels used by the MojomStruct types.
+var (
+	structName_DiscoveryStopScanParams               = "DiscoveryStopScanParams"
+	structFullIdentifier_DiscoveryStopScanParams     = "discovery.DiscoveryStopScanParams"
+	structFieldName_DiscoveryStopScanParams_InScanId = "InScanId"
+)
+
+func discovery_Discovery_StopScan_Params__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_DiscoveryStopScanParams,
+			FullIdentifier: &structFullIdentifier_DiscoveryStopScanParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStopScanParams_InScanId,
+			},
+			Type: &mojom_types.TypeSimpleType{mojom_types.SimpleType_UinT32},
+		}},
+	}
+}
+
+type discovery_StopScan_ResponseParams struct {
 	outErr *Error
 }
 
-func (s *scanner_Stop_ResponseParams) Encode(encoder *bindings.Encoder) error {
+func (s *discovery_StopScan_ResponseParams) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(8, 0)
 	if s.outErr == nil {
 		encoder.WriteNullPointer()
@@ -935,23 +1071,23 @@
 	return nil
 }
 
-var scanner_Stop_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+var discovery_StopScan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{16, 0},
 }
 
-func (s *scanner_Stop_ResponseParams) Decode(decoder *bindings.Decoder) error {
+func (s *discovery_StopScan_ResponseParams) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(scanner_Stop_ResponseParams_Versions), func(i int) bool {
-		return scanner_Stop_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(discovery_StopScan_ResponseParams_Versions), func(i int) bool {
+		return discovery_StopScan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(scanner_Stop_ResponseParams_Versions) {
-		if scanner_Stop_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(discovery_StopScan_ResponseParams_Versions) {
+		if discovery_StopScan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := scanner_Stop_ResponseParams_Versions[index].Size
+		expectedSize := discovery_StopScan_ResponseParams_Versions[index].Size
 		if expectedSize != header.Size {
 			return &bindings.ValidationError{bindings.UnexpectedStructHeader,
 				fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size),
@@ -978,12 +1114,36 @@
 	return nil
 }
 
-func (p *Scanner_Proxy) Stop(inH uint32) (outErr *Error, err error) {
-	payload := &scanner_Stop_Params{
-		inH,
+// String names and labels used by the MojomStruct types.
+var (
+	structName_DiscoveryStopScanResponseParams             = "DiscoveryStopScanResponseParams"
+	structFullIdentifier_DiscoveryStopScanResponseParams   = "discovery.DiscoveryStopScanResponseParams"
+	structFieldName_DiscoveryStopScanResponseParams_OutErr = "OutErr"
+)
+
+func discovery_Discovery_StopScan_ResponseParams__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_DiscoveryStopScanResponseParams,
+			FullIdentifier: &structFullIdentifier_DiscoveryStopScanResponseParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_DiscoveryStopScanResponseParams_OutErr,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Nullable: true, Identifier: &ID_discovery_Error__,
+					TypeKey: &ID_discovery_Error__},
+			},
+		}},
+	}
+}
+
+func (p *Discovery_Proxy) StopScan(inScanId uint32) (outErr *Error, err error) {
+	payload := &discovery_StopScan_Params{
+		inScanId,
 	}
 	header := bindings.MessageHeader{
-		Type:      scanner_Stop_Name,
+		Type:      discovery_StopScan_Name,
 		Flags:     bindings.MessageExpectsResponseFlag,
 		RequestId: p.ids.Count(),
 	}
@@ -1004,13 +1164,13 @@
 		}
 		return
 	}
-	if got, want := readResult.Message.Header.Type, scanner_Stop_Name; got != want {
+	if got, want := readResult.Message.Header.Type, discovery_StopScan_Name; got != want {
 		err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
 			fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
 		}
 		return
 	}
-	var response scanner_Stop_ResponseParams
+	var response discovery_StopScan_ResponseParams
 	if err = readResult.Message.DecodePayload(&response); err != nil {
 		p.Close_Proxy()
 		return
@@ -1019,58 +1179,112 @@
 	return
 }
 
-type scanner_Stub struct {
+type discovery_Stub struct {
 	connector *bindings.Connector
-	impl      Scanner
+	impl      Discovery
 }
 
-func NewScannerStub(r Scanner_Request, impl Scanner, waiter bindings.AsyncWaiter) *bindings.Stub {
+func NewDiscoveryStub(r Discovery_Request, impl Discovery, waiter bindings.AsyncWaiter) *bindings.Stub {
 	connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
-	return bindings.NewStub(connector, &scanner_Stub{connector, impl})
+	return bindings.NewStub(connector, &discovery_Stub{connector, impl})
 }
 
-func (f *Scanner_Request) ServiceDescription() service_describer.ServiceDescription {
-	return &Scanner_ServiceDescription{}
+var (
+	interfaceName_Discovery                        = "Discovery"
+	interfaceFullIdentifier_Discovery              = "discovery.Discovery"
+	interfaceMethodName_Discovery_StartAdvertising = "StartAdvertising"
+	interfaceMethodName_Discovery_StopAdvertising  = "StopAdvertising"
+	interfaceMethodName_Discovery_StartScan        = "StartScan"
+	interfaceMethodName_Discovery_StopScan         = "StopScan"
+)
+
+func discovery_Discovery__() mojom_types.MojomInterface {
+	responseParamsMap := make(map[string]*mojom_types.MojomStruct)
+	_ = responseParamsMap // To avoid the declared but unused compiler error
+	mstruct_StartAdvertising := discovery_Discovery_StartAdvertising_ResponseParams__()
+	responseParamsMap[interfaceMethodName_Discovery_StartAdvertising] = &mstruct_StartAdvertising
+	mstruct_StopAdvertising := discovery_Discovery_StopAdvertising_ResponseParams__()
+	responseParamsMap[interfaceMethodName_Discovery_StopAdvertising] = &mstruct_StopAdvertising
+	mstruct_StartScan := discovery_Discovery_StartScan_ResponseParams__()
+	responseParamsMap[interfaceMethodName_Discovery_StartScan] = &mstruct_StartScan
+	mstruct_StopScan := discovery_Discovery_StopScan_ResponseParams__()
+	responseParamsMap[interfaceMethodName_Discovery_StopScan] = &mstruct_StopScan
+	return mojom_types.MojomInterface{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &interfaceName_Discovery,
+			FullIdentifier: &interfaceFullIdentifier_Discovery,
+		},
+		Methods: map[uint32]mojom_types.MojomMethod{discovery_StartAdvertising_Name: mojom_types.MojomMethod{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &interfaceMethodName_Discovery_StartAdvertising,
+			},
+			Parameters:     discovery_Discovery_StartAdvertising_Params__(),
+			ResponseParams: responseParamsMap[interfaceMethodName_Discovery_StartAdvertising],
+		}, discovery_StopAdvertising_Name: mojom_types.MojomMethod{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &interfaceMethodName_Discovery_StopAdvertising,
+			},
+			Parameters:     discovery_Discovery_StopAdvertising_Params__(),
+			ResponseParams: responseParamsMap[interfaceMethodName_Discovery_StopAdvertising],
+		}, discovery_StartScan_Name: mojom_types.MojomMethod{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &interfaceMethodName_Discovery_StartScan,
+			},
+			Parameters:     discovery_Discovery_StartScan_Params__(),
+			ResponseParams: responseParamsMap[interfaceMethodName_Discovery_StartScan],
+		}, discovery_StopScan_Name: mojom_types.MojomMethod{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &interfaceMethodName_Discovery_StopScan,
+			},
+			Parameters:     discovery_Discovery_StopScan_Params__(),
+			ResponseParams: responseParamsMap[interfaceMethodName_Discovery_StopScan],
+		}},
+	}
 }
 
-type Scanner_ServiceDescription struct{}
-
-func (sd *Scanner_ServiceDescription) GetTopLevelInterface() (outMojomInterface mojom_types.MojomInterface, err error) {
-	err = fmt.Errorf("GetTopLevelInterface not implemented")
-	return
+func (f *Discovery_Request) ServiceDescription() service_describer.ServiceDescription {
+	return &Discovery_ServiceDescription{}
 }
 
-func (sd *Scanner_ServiceDescription) GetTypeDefinition(inTypeKey string) (outType mojom_types.UserDefinedType, err error) {
-	err = fmt.Errorf("GetTypeDefinition not implemented")
-	return
+type Discovery_ServiceDescription struct{}
+
+func (sd *Discovery_ServiceDescription) GetTopLevelInterface() (outMojomInterface mojom_types.MojomInterface, err error) {
+	return discovery_Discovery__(), nil
 }
 
-func (sd *Scanner_ServiceDescription) GetAllTypeDefinitions() (outDefinitions *map[string]mojom_types.UserDefinedType, err error) {
-	err = fmt.Errorf("GetAllTypeDefinitions not implemented")
-	return
+func (sd *Discovery_ServiceDescription) GetTypeDefinition(inTypeKey string) (outType mojom_types.UserDefinedType, err error) {
+	if udt, ok := GetAllMojomTypeDefinitions()[inTypeKey]; ok {
+		return udt, nil
+	}
+	return nil, fmt.Errorf("%s_ServiceDescription does not recognize %s", "Discovery", inTypeKey)
 }
 
-var _ service_describer.ServiceDescription = (*Scanner_ServiceDescription)(nil)
+func (sd *Discovery_ServiceDescription) GetAllTypeDefinitions() (outDefinitions *map[string]mojom_types.UserDefinedType, err error) {
+	o := GetAllMojomTypeDefinitions()
+	return &o, nil
+}
 
-func (s *scanner_Stub) Accept(message *bindings.Message) (err error) {
+var _ service_describer.ServiceDescription = (*Discovery_ServiceDescription)(nil)
+
+func (s *discovery_Stub) Accept(message *bindings.Message) (err error) {
 	switch message.Header.Type {
-	case scanner_Scan_Name:
+	case discovery_StartAdvertising_Name:
 		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
 			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
 				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
 			}
 		}
-		var request scanner_Scan_Params
+		var request discovery_StartAdvertising_Params
 		if err := message.DecodePayload(&request); err != nil {
 			return err
 		}
-		var response scanner_Scan_ResponseParams
-		response.outHandle, response.outErr, err = s.impl.Scan(request.inQuery, request.inScanHandler)
+		var response discovery_StartAdvertising_ResponseParams
+		response.outInstanceId, response.outErr, err = s.impl.StartAdvertising(request.inService, request.inVisibility)
 		if err != nil {
 			return
 		}
 		header := bindings.MessageHeader{
-			Type:      scanner_Scan_Name,
+			Type:      discovery_StartAdvertising_Name,
 			Flags:     bindings.MessageIsResponseFlag,
 			RequestId: message.Header.RequestId,
 		}
@@ -1079,23 +1293,73 @@
 			return err
 		}
 		return s.connector.WriteMessage(message)
-	case scanner_Stop_Name:
+	case discovery_StopAdvertising_Name:
 		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
 			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
 				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
 			}
 		}
-		var request scanner_Stop_Params
+		var request discovery_StopAdvertising_Params
 		if err := message.DecodePayload(&request); err != nil {
 			return err
 		}
-		var response scanner_Stop_ResponseParams
-		response.outErr, err = s.impl.Stop(request.inH)
+		var response discovery_StopAdvertising_ResponseParams
+		response.outErr, err = s.impl.StopAdvertising(request.inInstanceId)
 		if err != nil {
 			return
 		}
 		header := bindings.MessageHeader{
-			Type:      scanner_Stop_Name,
+			Type:      discovery_StopAdvertising_Name,
+			Flags:     bindings.MessageIsResponseFlag,
+			RequestId: message.Header.RequestId,
+		}
+		message, err = bindings.EncodeMessage(header, &response)
+		if err != nil {
+			return err
+		}
+		return s.connector.WriteMessage(message)
+	case discovery_StartScan_Name:
+		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
+			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+			}
+		}
+		var request discovery_StartScan_Params
+		if err := message.DecodePayload(&request); err != nil {
+			return err
+		}
+		var response discovery_StartScan_ResponseParams
+		response.outScanId, response.outErr, err = s.impl.StartScan(request.inQuery, request.inHandler)
+		if err != nil {
+			return
+		}
+		header := bindings.MessageHeader{
+			Type:      discovery_StartScan_Name,
+			Flags:     bindings.MessageIsResponseFlag,
+			RequestId: message.Header.RequestId,
+		}
+		message, err = bindings.EncodeMessage(header, &response)
+		if err != nil {
+			return err
+		}
+		return s.connector.WriteMessage(message)
+	case discovery_StopScan_Name:
+		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
+			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+			}
+		}
+		var request discovery_StopScan_Params
+		if err := message.DecodePayload(&request); err != nil {
+			return err
+		}
+		var response discovery_StopScan_ResponseParams
+		response.outErr, err = s.impl.StopScan(request.inScanId)
+		if err != nil {
+			return
+		}
+		header := bindings.MessageHeader{
+			Type:      discovery_StopScan_Name,
 			Flags:     bindings.MessageIsResponseFlag,
 			RequestId: message.Header.RequestId,
 		}
@@ -1237,6 +1501,30 @@
 	return nil
 }
 
+// String names and labels used by the MojomStruct types.
+var (
+	structName_ScanHandlerUpdateParams               = "ScanHandlerUpdateParams"
+	structFullIdentifier_ScanHandlerUpdateParams     = "discovery.ScanHandlerUpdateParams"
+	structFieldName_ScanHandlerUpdateParams_InUpdate = "InUpdate"
+)
+
+func discovery_ScanHandler_Update_Params__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_ScanHandlerUpdateParams,
+			FullIdentifier: &structFullIdentifier_ScanHandlerUpdateParams,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_ScanHandlerUpdateParams_InUpdate,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Identifier: &ID_discovery_Update__,
+					TypeKey: &ID_discovery_Update__},
+			},
+		}},
+	}
+}
+
 func (p *ScanHandler_Proxy) Update(inUpdate Update) (err error) {
 	payload := &scanHandler_Update_Params{
 		inUpdate,
@@ -1268,6 +1556,30 @@
 	return bindings.NewStub(connector, &scanHandler_Stub{connector, impl})
 }
 
+var (
+	interfaceName_ScanHandler              = "ScanHandler"
+	interfaceFullIdentifier_ScanHandler    = "discovery.ScanHandler"
+	interfaceMethodName_ScanHandler_Update = "Update"
+)
+
+func discovery_ScanHandler__() mojom_types.MojomInterface {
+	responseParamsMap := make(map[string]*mojom_types.MojomStruct)
+	_ = responseParamsMap // To avoid the declared but unused compiler error
+	return mojom_types.MojomInterface{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &interfaceName_ScanHandler,
+			FullIdentifier: &interfaceFullIdentifier_ScanHandler,
+		},
+		Methods: map[uint32]mojom_types.MojomMethod{scanHandler_Update_Name: mojom_types.MojomMethod{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &interfaceMethodName_ScanHandler_Update,
+			},
+			Parameters:     discovery_ScanHandler_Update_Params__(),
+			ResponseParams: responseParamsMap[interfaceMethodName_ScanHandler_Update],
+		}},
+	}
+}
+
 func (f *ScanHandler_Request) ServiceDescription() service_describer.ServiceDescription {
 	return &ScanHandler_ServiceDescription{}
 }
@@ -1275,18 +1587,19 @@
 type ScanHandler_ServiceDescription struct{}
 
 func (sd *ScanHandler_ServiceDescription) GetTopLevelInterface() (outMojomInterface mojom_types.MojomInterface, err error) {
-	err = fmt.Errorf("GetTopLevelInterface not implemented")
-	return
+	return discovery_ScanHandler__(), nil
 }
 
 func (sd *ScanHandler_ServiceDescription) GetTypeDefinition(inTypeKey string) (outType mojom_types.UserDefinedType, err error) {
-	err = fmt.Errorf("GetTypeDefinition not implemented")
-	return
+	if udt, ok := GetAllMojomTypeDefinitions()[inTypeKey]; ok {
+		return udt, nil
+	}
+	return nil, fmt.Errorf("%s_ServiceDescription does not recognize %s", "ScanHandler", inTypeKey)
 }
 
 func (sd *ScanHandler_ServiceDescription) GetAllTypeDefinitions() (outDefinitions *map[string]mojom_types.UserDefinedType, err error) {
-	err = fmt.Errorf("GetAllTypeDefinitions not implemented")
-	return
+	o := GetAllMojomTypeDefinitions()
+	return &o, nil
 }
 
 var _ service_describer.ServiceDescription = (*ScanHandler_ServiceDescription)(nil)
@@ -1322,10 +1635,11 @@
 	InterfaceName string
 	Attrs         *map[string]string
 	Addrs         []string
+	Attachments   *map[string][]uint8
 }
 
 func (s *Service) Encode(encoder *bindings.Encoder) error {
-	encoder.StartStruct(40, 0)
+	encoder.StartStruct(48, 0)
 	if s.InstanceId == nil {
 		encoder.WriteNullPointer()
 	} else {
@@ -1416,6 +1730,61 @@
 	if err := encoder.Finish(); err != nil {
 		return err
 	}
+	if s.Attachments == nil {
+		encoder.WriteNullPointer()
+	} else {
+		if err := encoder.WritePointer(); err != nil {
+			return err
+		}
+		encoder.StartMap()
+		{
+			var keys0 []string
+			var values0 [][]uint8
+			for key0, value0 := range *s.Attachments {
+				keys0 = append(keys0, key0)
+				values0 = append(values0, value0)
+			}
+			if err := encoder.WritePointer(); err != nil {
+				return err
+			}
+			encoder.StartArray(uint32(len(keys0)), 64)
+			for _, elem1 := range keys0 {
+				if err := encoder.WritePointer(); err != nil {
+					return err
+				}
+				if err := encoder.WriteString(elem1); err != nil {
+					return err
+				}
+			}
+			if err := encoder.Finish(); err != nil {
+				return err
+			}
+			if err := encoder.WritePointer(); err != nil {
+				return err
+			}
+			encoder.StartArray(uint32(len(values0)), 64)
+			for _, elem1 := range values0 {
+				if err := encoder.WritePointer(); err != nil {
+					return err
+				}
+				encoder.StartArray(uint32(len(elem1)), 8)
+				for _, elem2 := range elem1 {
+					if err := encoder.WriteUint8(elem2); err != nil {
+						return err
+					}
+				}
+				if err := encoder.Finish(); err != nil {
+					return err
+				}
+			}
+			if err := encoder.Finish(); err != nil {
+				return err
+			}
+		}
+		if err := encoder.Finish(); err != nil {
+			return err
+		}
+	}
 	if err := encoder.Finish(); err != nil {
 		return err
 	}
@@ -1423,7 +1792,7 @@
 }
 
 var service_Versions []bindings.DataHeader = []bindings.DataHeader{
-	bindings.DataHeader{48, 0},
+	bindings.DataHeader{56, 0},
 }
 
 func (s *Service) Decode(decoder *bindings.Decoder) error {
@@ -1621,12 +1990,181 @@
 			}
 		}
 	}
+	if header.ElementsOrVersion >= 0 {
+		pointer0, err := decoder.ReadPointer()
+		if err != nil {
+			return err
+		}
+		if pointer0 == 0 {
+			s.Attachments = nil
+		} else {
+			s.Attachments = new(map[string][]uint8)
+			if err := decoder.StartMap(); err != nil {
+				return err
+			}
+			var keys0 []string
+			{
+				pointer1, err := decoder.ReadPointer()
+				if err != nil {
+					return err
+				}
+				if pointer1 == 0 {
+					return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+				} else {
+					len1, err := decoder.StartArray(64)
+					if err != nil {
+						return err
+					}
+					keys0 = make([]string, len1)
+					for i1 := uint32(0); i1 < len1; i1++ {
+						pointer2, err := decoder.ReadPointer()
+						if err != nil {
+							return err
+						}
+						if pointer2 == 0 {
+							return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+						} else {
+							value2, err := decoder.ReadString()
+							if err != nil {
+								return err
+							}
+							keys0[i1] = value2
+						}
+					}
+					if err := decoder.Finish(); err != nil {
+						return err
+					}
+				}
+			}
+			var values0 [][]uint8
+			{
+				pointer1, err := decoder.ReadPointer()
+				if err != nil {
+					return err
+				}
+				if pointer1 == 0 {
+					return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+				} else {
+					len1, err := decoder.StartArray(64)
+					if err != nil {
+						return err
+					}
+					values0 = make([][]uint8, len1)
+					for i1 := uint32(0); i1 < len1; i1++ {
+						pointer2, err := decoder.ReadPointer()
+						if err != nil {
+							return err
+						}
+						if pointer2 == 0 {
+							return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"}
+						} else {
+							len2, err := decoder.StartArray(8)
+							if err != nil {
+								return err
+							}
+							values0[i1] = make([]uint8, len2)
+							for i2 := uint32(0); i2 < len2; i2++ {
+								value3, err := decoder.ReadUint8()
+								if err != nil {
+									return err
+								}
+								values0[i1][i2] = value3
+							}
+							if err := decoder.Finish(); err != nil {
+								return err
+							}
+						}
+					}
+					if err := decoder.Finish(); err != nil {
+						return err
+					}
+				}
+			}
+			if len(keys0) != len(values0) {
+				return &bindings.ValidationError{bindings.DifferentSizedArraysInMap,
+					fmt.Sprintf("Number of keys %d is different from number of values %d", len(keys0), len(values0)),
+				}
+			}
+			if err := decoder.Finish(); err != nil {
+				return err
+			}
+			len0 := len(keys0)
+			map0 := make(map[string][]uint8)
+			for i0 := 0; i0 < len0; i0++ {
+				map0[keys0[i0]] = values0[i0]
+			}
+			(*s.Attachments) = map0
+		}
+	}
 	if err := decoder.Finish(); err != nil {
 		return err
 	}
 	return nil
 }
 
+// String names and labels used by the MojomStruct types.
+var (
+	structName_Service                    = "Service"
+	structFullIdentifier_Service          = "discovery.Service"
+	structFieldName_Service_InstanceId    = "InstanceId"
+	structFieldName_Service_InstanceName  = "InstanceName"
+	structFieldName_Service_InterfaceName = "InterfaceName"
+	structFieldName_Service_Attrs         = "Attrs"
+	structFieldName_Service_Addrs         = "Addrs"
+	structFieldName_Service_Attachments   = "Attachments"
+)
+
+func discovery_Service__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_Service,
+			FullIdentifier: &structFullIdentifier_Service,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Service_InstanceId,
+			},
+			Type: &mojom_types.TypeStringType{mojom_types.StringType{true}},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Service_InstanceName,
+			},
+			Type: &mojom_types.TypeStringType{mojom_types.StringType{true}},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Service_InterfaceName,
+			},
+			Type: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Service_Attrs,
+			},
+			Type: &mojom_types.TypeMapType{
+				Value: mojom_types.MapType{Nullable: true, KeyType: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+					ValueType: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+				},
+			},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Service_Addrs,
+			},
+			Type: &mojom_types.TypeArrayType{
+				Value: mojom_types.ArrayType{ElementType: &mojom_types.TypeStringType{mojom_types.StringType{false}}},
+			},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Service_Attachments,
+			},
+			Type: &mojom_types.TypeMapType{
+				Value: mojom_types.MapType{Nullable: true, KeyType: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+					ValueType: &mojom_types.TypeArrayType{
+						Value: mojom_types.ArrayType{ElementType: &mojom_types.TypeSimpleType{mojom_types.SimpleType_UinT8}},
+					},
+				},
+			},
+		}},
+	}
+}
+
 type Update struct {
 	Service    Service
 	UpdateType UpdateType
@@ -1698,6 +2236,39 @@
 	return nil
 }
 
+// String names and labels used by the MojomStruct types.
+var (
+	structName_Update                 = "Update"
+	structFullIdentifier_Update       = "discovery.Update"
+	structFieldName_Update_Service    = "Service"
+	structFieldName_Update_UpdateType = "UpdateType"
+)
+
+func discovery_Update__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_Update,
+			FullIdentifier: &structFullIdentifier_Update,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Update_Service,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Identifier: &ID_discovery_Service__,
+					TypeKey: &ID_discovery_Service__},
+			},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Update_UpdateType,
+			},
+			Type: &mojom_types.TypeTypeReference{
+				Value: mojom_types.TypeReference{Identifier: &ID_discovery_UpdateType__,
+					TypeKey: &ID_discovery_UpdateType__},
+			},
+		}},
+	}
+}
+
 type Error struct {
 	Id     string
 	Action int32
@@ -1792,3 +2363,36 @@
 	}
 	return nil
 }
+
+// String names and labels used by the MojomStruct types.
+var (
+	structName_Error             = "Error"
+	structFullIdentifier_Error   = "discovery.Error"
+	structFieldName_Error_Id     = "Id"
+	structFieldName_Error_Action = "Action"
+	structFieldName_Error_Msg    = "Msg"
+)
+
+func discovery_Error__() mojom_types.MojomStruct {
+	return mojom_types.MojomStruct{
+		DeclData: &mojom_types.DeclarationData{
+			ShortName:      &structName_Error,
+			FullIdentifier: &structFullIdentifier_Error,
+		}, Fields: []mojom_types.StructField{mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Error_Id,
+			},
+			Type: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Error_Action,
+			},
+			Type: &mojom_types.TypeSimpleType{mojom_types.SimpleType_InT32},
+		}, mojom_types.StructField{
+			DeclData: &mojom_types.DeclarationData{
+				ShortName: &structFieldName_Error_Msg,
+			},
+			Type: &mojom_types.TypeStringType{mojom_types.StringType{false}},
+		}},
+	}
+}
diff --git a/go/src/vanadium/discovery/discovery.go b/go/src/vanadium/discovery/discovery.go
index 56932d0..229dd68 100644
--- a/go/src/vanadium/discovery/discovery.go
+++ b/go/src/vanadium/discovery/discovery.go
@@ -23,88 +23,65 @@
 //#include "mojo/public/c/system/types.h"
 import "C"
 
-type discoveryDelegate struct {
-	// mu protects stubs.  All calls to methods on the delegate by
-	// mojo will be done in the same goroutine.  We need mu so
-	// we can clean up stubs that fail because of pipe errors because
-	// each stub serves all its requests in its own goroutine.
-	mu    sync.Mutex
-	stubs map[*bindings.Stub]struct{}
-
-	ctx *context.T
-
+type delegate struct {
+	ctx      *context.T
 	shutdown v23.Shutdown
-	impl     *internal.DiscoveryService
+
+	mu    sync.Mutex
+	stubs map[*bindings.Stub]struct{} // GUARDED_BY(mu)
 }
 
-func (d *discoveryDelegate) Initialize(mctx application.Context) {
+func (d *delegate) Initialize(mctx application.Context) {
 	// TODO(bjornick): Calling init multiple times in the same process
 	// will be bad.  For now, this is ok because this is the only
 	// vanadium service that will be used in the demos and each go library
 	// will be in its own process.
 	d.ctx, d.shutdown = v23.Init(mctx)
-	d.impl = internal.NewDiscoveryService(d.ctx)
 }
 
-func (d *discoveryDelegate) addAndServeStub(stub *bindings.Stub) {
+func (d *delegate) Create(request mojom.Discovery_Request) {
+	discovery := internal.NewDiscovery(d.ctx)
+	stub := mojom.NewDiscoveryStub(request, discovery, bindings.GetAsyncWaiter())
 	d.mu.Lock()
 	d.stubs[stub] = struct{}{}
 	d.mu.Unlock()
+
 	go func() {
+		defer discovery.Close()
+
 		for {
 			if err := stub.ServeRequest(); err != nil {
-				connectionErr, ok := err.(*bindings.ConnectionError)
-				if !ok || !connectionErr.Closed() {
+				connErr, ok := err.(*bindings.ConnectionError)
+				if !ok || !connErr.Closed() {
 					d.ctx.Error(err)
 				}
 				break
 			}
 		}
+
 		d.mu.Lock()
 		delete(d.stubs, stub)
 		d.mu.Unlock()
 	}()
 }
 
-type advertiseFactory struct {
-	d *discoveryDelegate
+func (d *delegate) AcceptConnection(connection *application.Connection) {
+	connection.ProvideServices(&mojom.Discovery_ServiceFactory{d})
 }
 
-func (a *advertiseFactory) Create(request mojom.Advertiser_Request) {
-	stub := mojom.NewAdvertiserStub(request, a.d.impl, bindings.GetAsyncWaiter())
-	a.d.addAndServeStub(stub)
-}
-
-type scannerFactory struct {
-	d *discoveryDelegate
-}
-
-func (s *scannerFactory) Create(request mojom.Scanner_Request) {
-	stub := mojom.NewScannerStub(request, s.d.impl, bindings.GetAsyncWaiter())
-	s.d.addAndServeStub(stub)
-}
-
-func (d *discoveryDelegate) AcceptConnection(connection *application.Connection) {
-	advFactory := &advertiseFactory{d: d}
-	scanFactory := &scannerFactory{d: d}
-	connection.ProvideServices(&mojom.Advertiser_ServiceFactory{advFactory}, &mojom.Scanner_ServiceFactory{scanFactory})
-}
-
-func (d *discoveryDelegate) Quit() {
-	d.impl.StopAll()
-	d.shutdown()
+func (d *delegate) Quit() {
 	d.mu.Lock()
 	for stub := range d.stubs {
 		stub.Close()
 	}
 	d.mu.Unlock()
+	d.shutdown()
 }
 
 //export MojoMain
 func MojoMain(handle C.MojoHandle) C.MojoResult {
-	application.Run(&discoveryDelegate{stubs: map[*bindings.Stub]struct{}{}}, system.MojoHandle(handle))
+	application.Run(&delegate{stubs: map[*bindings.Stub]struct{}{}}, system.MojoHandle(handle))
 	return C.MOJO_RESULT_OK
 }
 
-func main() {
-}
+func main() {}
diff --git a/go/src/vanadium/discovery/internal/discovery.go b/go/src/vanadium/discovery/internal/discovery.go
index 5d28a81..2b582bb 100644
--- a/go/src/vanadium/discovery/internal/discovery.go
+++ b/go/src/vanadium/discovery/internal/discovery.go
@@ -8,6 +8,7 @@
 	"sync"
 
 	"mojo/public/go/bindings"
+
 	mojom "mojom/vanadium/discovery"
 
 	"v.io/v23"
@@ -20,28 +21,26 @@
 const pkgPath = "mojo/vanadium/discovery/vanadium/discovery"
 
 var (
-	errInvalidHandle = verror.Register(pkgPath+".errInvalidHandle", verror.NoRetry, "{1:}{2:} handle not valid")
+	errInvalidInstanceId = verror.Register(pkgPath+".errInvalidInstanceId", verror.NoRetry, "{1:}{2:} instance id not valid")
+	errInvalidScanId     = verror.Register(pkgPath+".errInvalidScanId", verror.NoRetry, "{1:}{2:} scan id not valid")
 )
 
-type handleT uint32
+type DiscoveryCloser interface {
+	mojom.Discovery
 
-// DiscoveryService implements the mojom interface mojom/vanadium/discovery.DiscoveryService.  It
-// is basically a thin wrapper around the Vanadium Discovery API.
-type DiscoveryService struct {
-	ctx       *context.T
-	discovery discovery.T
+	// Close closes all active tasks.
+	Close()
+}
 
-	// mu protects pending* and next*
-	mu sync.Mutex
+// mdiscovery is basically a thin wrapper around the Vanadium discovery API.
+type mdiscovery struct {
+	ctx *context.T
+	d   discovery.T
 
-	// The id to assign the next advertisement.
-	nextAdv handleT
-	// A map of advertisement ids to the cancellation function.
-	activeAdvs map[handleT]func()
-	// The id to assign to the next scan.
-	nextScan handleT
-	// A map of scan id to the cancellataion func()
-	activeScans map[handleT]func()
+	mu          sync.Mutex
+	activeAdvs  map[string]func() // GUARDED_BY(mu)
+	activeScans map[uint32]func() // GUARDED_BY(mu)
+	nextScanId  uint32            // GUARDED_BY(mu)
 }
 
 func v2mError(err error) *mojom.Error {
@@ -52,70 +51,6 @@
 	}
 }
 
-// NewDiscoveryService returns a new DiscoveryService bound to the context and the Vanadium
-// Discovery implementation passed in.
-func NewDiscoveryService(ctx *context.T) *DiscoveryService {
-	return &DiscoveryService{
-		ctx:         ctx,
-		discovery:   v23.GetDiscovery(ctx),
-		nextAdv:     1,
-		activeAdvs:  map[handleT]func(){},
-		activeScans: map[handleT]func(){},
-	}
-}
-
-func (d *DiscoveryService) Advertise(service mojom.Service, visibility *[]string) (uint32, string, *mojom.Error, error) {
-	vService := discovery.Service{
-		InterfaceName: service.InterfaceName,
-		Addrs:         service.Addrs,
-	}
-	if service.InstanceId != nil {
-		vService.InstanceId = *service.InstanceId
-	}
-	if service.InstanceName != nil {
-		vService.InstanceName = *service.InstanceName
-	}
-	if service.Attrs != nil {
-		vService.Attrs = *service.Attrs
-	}
-	var vVisibility []security.BlessingPattern
-	if visibility != nil {
-		vVisibility := make([]security.BlessingPattern, len(*visibility))
-		for i, p := range *visibility {
-			vVisibility[i] = security.BlessingPattern(p)
-		}
-	}
-
-	ctx, cancel := context.WithCancel(d.ctx)
-	done, err := d.discovery.Advertise(ctx, &vService, vVisibility)
-	if err != nil {
-		cancel()
-		return 0, "", v2mError(err), nil
-	}
-	d.mu.Lock()
-	currId := d.nextAdv
-	d.activeAdvs[currId] = func() {
-		cancel()
-		<-done
-	}
-	d.nextAdv += 2
-	d.mu.Unlock()
-	return uint32(currId), vService.InstanceId, nil, nil
-}
-
-func (d *DiscoveryService) stopAdvertising(handle uint32) (*mojom.Error, error) {
-	d.mu.Lock()
-	stop := d.activeAdvs[handleT(handle)]
-	if stop == nil {
-		d.mu.Unlock()
-		return v2mError(verror.New(errInvalidHandle, d.ctx)), nil
-	}
-	delete(d.activeAdvs, handleT(handle))
-	d.mu.Unlock()
-	stop()
-	return nil, nil
-}
-
 func v2mService(s discovery.Service) mojom.Service {
 	mService := mojom.Service{
 		InterfaceName: s.InterfaceName,
@@ -128,78 +63,171 @@
 		mService.InstanceName = &s.InstanceName
 	}
 	if len(s.Attrs) > 0 {
-		attr := map[string]string(s.Attrs)
-		mService.Attrs = &attr
+		attrs := map[string]string(s.Attrs)
+		mService.Attrs = &attrs
+	}
+	if len(s.Attachments) > 0 {
+		attachments := map[string][]byte(s.Attachments)
+		mService.Attachments = &attachments
 	}
 	return mService
 }
 
-func (d *DiscoveryService) Scan(query string, scanHandler mojom.ScanHandler_Pointer) (uint32, *mojom.Error, error) {
+func (d *mdiscovery) StartAdvertising(service mojom.Service, visibility *[]string) (string, *mojom.Error, error) {
+	vService := discovery.Service{
+		InterfaceName: service.InterfaceName,
+		Addrs:         service.Addrs,
+	}
+	if service.InstanceId != nil {
+		vService.InstanceId = *service.InstanceId
+	}
+	if service.InstanceName != nil {
+		vService.InstanceName = *service.InstanceName
+	}
+	if service.Attrs != nil {
+		vService.Attrs = *service.Attrs
+	}
+	if service.Attachments != nil {
+		vService.Attachments = *service.Attachments
+	}
+	var vVisibility []security.BlessingPattern
+	if visibility != nil {
+		vVisibility := make([]security.BlessingPattern, len(*visibility))
+		for i, p := range *visibility {
+			vVisibility[i] = security.BlessingPattern(p)
+		}
+	}
+
 	ctx, cancel := context.WithCancel(d.ctx)
-	scanCh, err := d.discovery.Scan(ctx, query)
+	done, err := d.d.Advertise(ctx, &vService, vVisibility)
 	if err != nil {
 		cancel()
-		return 0, v2mError(err), nil
+		return "", v2mError(err), nil
 	}
-	d.mu.Lock()
-	currId := d.nextScan
-	d.activeScans[currId] = cancel
-	d.nextScan += 2
-	d.mu.Unlock()
+	stop := func() {
+		cancel()
+		<-done
+	}
 
-	go func() {
-		proxy := mojom.NewScanHandlerProxy(scanHandler, bindings.GetAsyncWaiter())
-		for v := range scanCh {
-			switch value := v.(type) {
-			case discovery.UpdateFound:
-				update := mojom.Update{
-					Service:    v2mService(value.Value.Service),
-					UpdateType: mojom.UpdateType_Found,
-				}
-				proxy.Update(update)
-			case discovery.UpdateLost:
-				update := mojom.Update{
-					Service:    v2mService(value.Value.Service),
-					UpdateType: mojom.UpdateType_Lost,
-				}
-				proxy.Update(update)
-			}
-		}
-	}()
-	return uint32(currId), nil, nil
+	d.mu.Lock()
+	d.activeAdvs[vService.InstanceId] = stop
+	d.mu.Unlock()
+	return vService.InstanceId, nil, nil
 }
 
-// Stop stops the scan.
-func (d *DiscoveryService) Stop(handle uint32) (*mojom.Error, error) {
-	if handle%2 == 0 {
-		return d.stopScan(handle)
-	}
-	return d.stopAdvertising(handle)
-}
-
-func (d *DiscoveryService) stopScan(handle uint32) (*mojom.Error, error) {
+func (d *mdiscovery) StopAdvertising(instanceId string) (*mojom.Error, error) {
 	d.mu.Lock()
-	cancel := d.activeScans[handleT(handle)]
-	if cancel == nil {
-		d.mu.Unlock()
-		return v2mError(verror.New(errInvalidHandle, d.ctx)), nil
-	}
-	delete(d.activeScans, handleT(handle))
+	stop := d.activeAdvs[instanceId]
+	delete(d.activeAdvs, instanceId)
 	d.mu.Unlock()
-	cancel()
+	if stop == nil {
+		return v2mError(verror.New(errInvalidInstanceId, d.ctx)), nil
+	}
+	stop()
 	return nil, nil
 }
 
-// Stop Stops all scans and advertisements.
-func (d *DiscoveryService) StopAll() {
-	d.mu.Lock()
-	for _, cancel := range d.activeScans {
+func (d *mdiscovery) StartScan(query string, handlerPtr mojom.ScanHandler_Pointer) (uint32, *mojom.Error, error) {
+	// There is no way to mock _Pointer or _Request types. So we put StartScan()
+	// logic into a separate function startScan() for unit testing.
+	proxy := mojom.NewScanHandlerProxy(handlerPtr, bindings.GetAsyncWaiter())
+	return d.startScan(query, proxy)
+}
+
+type scanHandlerProxy interface {
+	mojom.ScanHandler
+	Close_Proxy()
+}
+
+func (d *mdiscovery) startScan(query string, proxy scanHandlerProxy) (uint32, *mojom.Error, error) {
+	ctx, cancel := context.WithCancel(d.ctx)
+	scanCh, err := d.d.Scan(ctx, query)
+	if err != nil {
 		cancel()
+		proxy.Close_Proxy()
+		return 0, v2mError(err), nil
 	}
 
-	for _, cancel := range d.activeAdvs {
-		cancel()
-	}
-	d.discovery.Close()
+	d.mu.Lock()
+	scanId := d.nextScanId
+	d.activeScans[scanId] = cancel
+	d.nextScanId++
 	d.mu.Unlock()
+
+	go func() {
+		defer proxy.Close_Proxy()
+
+		for update := range scanCh {
+			var mupdate mojom.Update
+			switch u := update.(type) {
+			case discovery.UpdateFound:
+				mupdate = mojom.Update{
+					Service:    v2mService(u.Value.Service),
+					UpdateType: mojom.UpdateType_Found,
+				}
+			case discovery.UpdateLost:
+				mupdate = mojom.Update{
+					Service:    v2mService(u.Value.Service),
+					UpdateType: mojom.UpdateType_Lost,
+				}
+			}
+			if err := proxy.Update(mupdate); err != nil {
+				return
+			}
+		}
+	}()
+
+	return scanId, nil, nil
+}
+
+func (d *mdiscovery) StopScan(scanId uint32) (*mojom.Error, error) {
+	d.mu.Lock()
+	stop := d.activeScans[scanId]
+	delete(d.activeScans, scanId)
+	d.mu.Unlock()
+	if stop == nil {
+		return v2mError(verror.New(errInvalidScanId, d.ctx)), nil
+	}
+	stop()
+	return nil, nil
+}
+
+func (d *mdiscovery) Close() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	for _, stop := range d.activeAdvs {
+		stop()
+	}
+	for _, stop := range d.activeScans {
+		stop()
+	}
+}
+
+// ediscovery always returns the given error.
+type ediscovery struct{ err error }
+
+func (d *ediscovery) StartAdvertising(mojom.Service, *[]string) (string, *mojom.Error, error) {
+	return "", v2mError(d.err), nil
+}
+func (d *ediscovery) StopAdvertising(string) (*mojom.Error, error) { return v2mError(d.err), nil }
+func (d *ediscovery) StartScan(string, mojom.ScanHandler_Pointer) (uint32, *mojom.Error, error) {
+	return 0, v2mError(d.err), nil
+}
+func (d *ediscovery) StopScan(uint32) (*mojom.Error, error) { return v2mError(d.err), nil }
+func (d *ediscovery) Close()                                {}
+
+// NewDiscovery returns a new Vanadium discovery instance.
+func NewDiscovery(ctx *context.T) DiscoveryCloser {
+	d, err := v23.NewDiscovery(ctx)
+	if err != nil {
+		return &ediscovery{err}
+	}
+
+	return &mdiscovery{
+		ctx:         ctx,
+		d:           d,
+		activeAdvs:  make(map[string]func()),
+		activeScans: make(map[uint32]func()),
+	}
 }
diff --git a/go/src/vanadium/discovery/internal/discovery_test.go b/go/src/vanadium/discovery/internal/discovery_test.go
index 2c64631..85829b3 100644
--- a/go/src/vanadium/discovery/internal/discovery_test.go
+++ b/go/src/vanadium/discovery/internal/discovery_test.go
@@ -5,136 +5,214 @@
 package internal
 
 import (
+	"errors"
 	"fmt"
-	"math/rand"
 	"reflect"
-	"strconv"
-	"sync"
+	"runtime"
 	"testing"
+	"time"
 
 	mojom "mojom/vanadium/discovery"
 
-	"v.io/v23/context"
 	"v.io/v23/discovery"
-	"v.io/v23/security"
 
 	idiscovery "v.io/x/ref/lib/discovery"
 	dfactory "v.io/x/ref/lib/discovery/factory"
+	"v.io/x/ref/lib/discovery/plugins/mock"
 	_ "v.io/x/ref/runtime/factories/generic"
-	vtest "v.io/x/ref/test"
+	"v.io/x/ref/test"
 )
 
-type mockDiscovery struct {
-	mu       sync.Mutex
-	trigger  *idiscovery.Trigger
-	id       int64
-	services map[int64]discovery.Service
-	// An item will be put in deleteCh when something has been deleted.
-	deleteCh chan struct{}
-}
-
-func (d *mockDiscovery) Advertise(ctx *context.T, s *discovery.Service, perms []security.BlessingPattern) (<-chan struct{}, error) {
-	if len(s.InstanceId) == 0 {
-		s.InstanceId = strconv.Itoa(rand.Int())
-	}
-	d.mu.Lock()
-	currId := d.id
-	d.services[currId] = *s
-	d.id++
-	d.mu.Unlock()
-	done := make(chan struct{})
-	stop := func() {
-		d.mu.Lock()
-		delete(d.services, currId)
-		d.mu.Unlock()
-		close(done)
-
-		go func() { d.deleteCh <- struct{}{} }()
-	}
-	d.trigger.Add(stop, ctx.Done())
-	return done, nil
-}
-
-func (*mockDiscovery) Scan(ctx *context.T, query string) (<-chan discovery.Update, error) {
-	return nil, nil
-}
-
-func (*mockDiscovery) Close() {}
-
-func compare(want discovery.Service, got mojom.Service) error {
-	mwant := v2mService(want)
-	if !reflect.DeepEqual(mwant, got) {
-		return fmt.Errorf("Got %#v want %#v", got, want)
-	}
-	return nil
-}
-
-func mkMojomService(instanceId, interfaceName string, attrs map[string]string, addrs []string) mojom.Service {
-	return mojom.Service{
-		InstanceId:    &instanceId,
-		InterfaceName: interfaceName,
-		Attrs:         &attrs,
-		Addrs:         addrs,
-	}
-}
-
-func TestAdvertising(t *testing.T) {
-	mock := &mockDiscovery{
-		trigger:  idiscovery.NewTrigger(),
-		services: map[int64]discovery.Service{},
-		deleteCh: make(chan struct{}),
-	}
-	dfactory.InjectDiscovery(mock)
-
-	ctx, shutdown := vtest.V23Init()
+func TestBasic(t *testing.T) {
+	ctx, shutdown := test.V23Init()
 	defer shutdown()
 
-	ds := NewDiscoveryService(ctx)
+	df, _ := idiscovery.NewFactory(ctx, mock.New())
+	dfactory.InjectFactory(df)
 
-	s1 := mkMojomService("s1", "v.io/discovery", map[string]string{"k1": "v1", "k2": "v2"}, []string{"addr1", "addr2"})
-	h1, id1, e1, e2 := ds.Advertise(s1, nil)
-	if e1 != nil || e2 != nil {
-		t.Fatalf("failed to start service: %v, %v", e1, e2)
-	}
-	if got, want := id1, "s1"; got != want {
-		t.Errorf("got instance id %s, but want %s", got, want)
-	}
-	if len(mock.services) != 1 {
-		t.Errorf("service missing in mock")
+	services := []discovery.Service{
+		{
+			InstanceId:    "123",
+			InterfaceName: "v.io/v23/a",
+			Attrs:         discovery.Attributes{"a1": "v1"},
+			Addrs:         []string{"/h1:123/x"},
+		},
+		{
+			InterfaceName: "v.io/v23/b",
+			Attrs:         discovery.Attributes{"b1": "v1"},
+			Addrs:         []string{"/h1:123/y"},
+		},
 	}
 
-	for _, service := range mock.services {
-		if err := compare(service, s1); err != nil {
-			t.Error(err)
+	d1 := NewDiscovery(ctx)
+
+	for i, service := range services {
+		instanceId, merr, err := d1.StartAdvertising(mkMojomService(service), nil)
+		if merr != nil || err != nil {
+			t.Fatalf("failed to advertise service: %v, %v", merr, err)
+		}
+		if len(instanceId) == 0 {
+			t.Errorf("service[%d]: got empty instance id", i)
+		}
+
+		if len(service.InstanceId) == 0 {
+			services[i].InstanceId = instanceId
+		} else if instanceId != service.InstanceId {
+			t.Errorf("service[%d]: got instance id %v, but wanted %v", i, instanceId, service.InstanceId)
 		}
 	}
 
-	s2 := mkMojomService("", "v.io/naming", map[string]string{"k1": "v1", "k2": "v2"}, []string{"addr3", "addr4"})
-	_, id2, e1, e2 := ds.Advertise(s2, nil)
-	if e1 != nil || e2 != nil {
-		t.Fatalf("failed to start service: %v, %v", e1, e2)
-	}
-	if len(id2) == 0 {
-		t.Error("empty instance id returned")
-	}
-	s2.InstanceId = &id2
-
-	ds.Stop(h1)
-	// Wait for the deletion to finish.
-	<-mock.deleteCh
-	if len(mock.services) != 1 {
-		t.Errorf("service should have been removed")
+	// Make sure none of advertisements are discoverable by the same discovery instance.
+	if err := scanAndMatch(d1, ""); err != nil {
+		t.Error(err)
 	}
 
-	for _, service := range mock.services {
-		if err := compare(service, s2); err != nil {
-			t.Error(err)
+	// Create a new discovery instance. All advertisements should be discovered with that.
+	d2 := NewDiscovery(ctx)
+
+	if err := scanAndMatch(d2, `v.InterfaceName="v.io/v23/a"`, services[0]); err != nil {
+		t.Error(err)
+	}
+	if err := scanAndMatch(d2, `v.InterfaceName="v.io/v23/b"`, services[1]); err != nil {
+		t.Error(err)
+	}
+	if err := scanAndMatch(d2, "", services...); err != nil {
+		t.Error(err)
+	}
+
+	// Open a new scan channel and consume expected advertisements first.
+	scanCh, scanStop, err := startScan(d2, `v.InterfaceName="v.io/v23/a"`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer scanStop()
+	update := <-scanCh
+	if !matchFound([]mojom.Update{update}, services[0]) {
+		t.Errorf("unexpected scan: %v", update)
+	}
+
+	// Make sure scan returns the lost advertisement when advertising is stopped.
+	d1.StopAdvertising(services[0].InstanceId)
+
+	update = <-scanCh
+	if !matchLost([]mojom.Update{update}, services[0]) {
+		t.Errorf("unexpected scan: %v", update)
+	}
+
+	// Also it shouldn't affect the other.
+	if err := scanAndMatch(d2, `v.InterfaceName="v.io/v23/b"`, services[1]); err != nil {
+		t.Error(err)
+	}
+
+	// Stop advertising the remaining one; Shouldn't discover any service.
+	d1.StopAdvertising(services[1].InstanceId)
+	if err := scanAndMatch(d2, ""); err != nil {
+		t.Error(err)
+	}
+}
+
+type mockScanHandler struct {
+	ch chan mojom.Update
+}
+
+func (m *mockScanHandler) Update(u mojom.Update) error {
+	m.ch <- u
+	return nil
+}
+func (m *mockScanHandler) Close_Proxy() { close(m.ch) }
+
+func startScan(d mojom.Discovery, query string) (<-chan mojom.Update, func(), error) {
+	ch := make(chan mojom.Update)
+	scanId, merr, err := d.(*mdiscovery).startScan(query, &mockScanHandler{ch})
+	if merr != nil {
+		return nil, nil, errors.New(merr.Msg)
+	}
+	if err != nil {
+		return nil, nil, err
+	}
+
+	stop := func() { d.StopScan(scanId) }
+	return ch, stop, nil
+}
+
+func scan(d mojom.Discovery, query string) ([]mojom.Update, error) {
+	ch, stop, err := startScan(d, query)
+	if err != nil {
+		return nil, err
+	}
+	defer stop()
+
+	var updates []mojom.Update
+	for {
+		select {
+		case update := <-ch:
+			updates = append(updates, update)
+		case <-time.After(5 * time.Millisecond):
+			return updates, nil
 		}
 	}
+}
 
-	ds.StopAll()
-	<-mock.deleteCh
-	if len(mock.services) != 0 {
-		t.Errorf("service should have been removed")
+func scanAndMatch(d mojom.Discovery, query string, wants ...discovery.Service) error {
+	const timeout = 3 * time.Second
+
+	var updates []mojom.Update
+	for now := time.Now(); time.Since(now) < timeout; {
+		runtime.Gosched()
+
+		var err error
+		updates, err = scan(d, query)
+		if err != nil {
+			return err
+		}
+		if matchFound(updates, wants...) {
+			return nil
+		}
 	}
+	return fmt.Errorf("Match failed; got %v, but wanted %v", updates, wants)
+}
+
+func match(updates []mojom.Update, updateType mojom.UpdateType, wants ...discovery.Service) bool {
+	for _, want := range wants {
+		matched := false
+		for i, update := range updates {
+			if update.UpdateType == updateType && reflect.DeepEqual(update.Service, mkMojomService(want)) {
+				updates = append(updates[:i], updates[i+1:]...)
+				matched = true
+				break
+			}
+		}
+		if !matched {
+			return false
+		}
+	}
+	return len(updates) == 0
+}
+
+func matchFound(updates []mojom.Update, wants ...discovery.Service) bool {
+	return match(updates, mojom.UpdateType_Found, wants...)
+}
+
+func matchLost(updates []mojom.Update, wants ...discovery.Service) bool {
+	return match(updates, mojom.UpdateType_Lost, wants...)
+}
+
+func mkMojomService(service discovery.Service) mojom.Service {
+	mservice := mojom.Service{
+		InstanceId:    &service.InstanceId,
+		InterfaceName: service.InterfaceName,
+		Addrs:         service.Addrs,
+	}
+	if len(service.InstanceName) > 0 {
+		mservice.InstanceName = &service.InstanceName
+	}
+	if len(service.Attrs) > 0 {
+		attrs := map[string]string(service.Attrs)
+		mservice.Attrs = &attrs
+	}
+	if len(service.Attachments) > 0 {
+		attachments := map[string][]byte(service.Attachments)
+		mservice.Attachments = &attachments
+	}
+	return mservice
 }
diff --git a/mojom/vanadium/discovery.mojom b/mojom/vanadium/discovery.mojom
index d638974..f9c5443 100644
--- a/mojom/vanadium/discovery.mojom
+++ b/mojom/vanadium/discovery.mojom
@@ -21,11 +21,14 @@
   // The addresses that the service is served on.
   // E.g., '/host:port/a/b/c'.
   array<string> Addrs;
+  // The service attachments.
+  // E.g., {'thumbnail': binary_data }.
+  map<string, array<uint8>>? Attachments;
 };
 
 enum UpdateType {
-	  found = 1,
-	  lost,
+  found = 1,
+  lost,
 };
 
 struct Update {
@@ -39,25 +42,21 @@
   string msg;
 };
 
-// Advertiser provides methods to do Vanadium Advertising.
-[ServiceName="v23::discovery::Advertiser"]
-interface Advertiser {
-  // Advertise advertises the service to be discovered by "Scanner" implementations.
-  // visibility is used to limit the principals that can see the advertisement. An
-  // empty set means that there are no restrictions on visibility (i.e, equivalent
-  // to []security.BlessingPattern{security.AllPrincipals}).
+// Discovery provides Vanadium discovery operations.
+[ServiceName="v23::discovery::Discovery"]
+interface Discovery {
+  // StartAdvertising advertises the service to be discovered by "Scanner"
+  // implementations. visibility is used to limit the principals that can see
+  // the advertisement. An empty set means that there are no restrictions on
+  // visibility (i.e, equivalent to []security.BlessingPattern{security.AllPrincipals}).
   //
   // It is an error to have simultaneously active advertisements for two identical
   // instances (service.InstanceUuid).
-  Advertise(Service service, array<string>? visibility) => (uint32 Handle, string instanceId, Error? Err);
+  StartAdvertising(Service service, array<string>? visibility) => (string instance_id, Error? err);
 
-  // Stop Stops the advertisement associated with the given handle.
-  Stop(uint32 h) => (Error? Err);
-};
+  // StopAdvertising stops the advertisement associated with the given instance id.
+  StopAdvertising(string instance_id) => (Error? Err);
 
-// Scanner provides methods to scan for Vanadium advertisements.
-[ServiceName="v23::discovery::Scanner"]
-interface Scanner {
   // Scan scans for services matching the query passed and calls ScanHandler with updates.
   //
   // The query is a WHERE expression of syncQL query against scanned services, where
@@ -71,14 +70,13 @@
   //
   // SyncQL tutorial at:
   //    https://github.com/vanadium/docs/blob/master/tutorials/syncql-tutorial.md
-  Scan(string query, ScanHandler scanHandler) => (uint32 Handle, Error? Err);
+  StartScan(string query, ScanHandler handler) => (uint32 scan_id, Error? err);
 
-  // StopScan stops the scanner associated weith the given handle.
-  Stop(uint32 h) => (Error? Err);
+  // StopScan stops the scanning associated with the given scan id.
+  StopScan(uint32 scan_id) => (Error? err);
 };
 
-// ScanHandler is used to pass updates about Services that are found/lost during
-// the scan.
+// ScanHandler is used to pass updates about services that are found/lost during the scan.
 [ServiceName="v23::discovery::ScanHandler"]
 interface ScanHandler {
   // Update will be called when a Service is found or lost.