diff --git a/go/src/examples/advertiser/advertiser.go b/go/src/examples/advertiser/advertiser.go
index bd05870..0d04f68 100644
--- a/go/src/examples/advertiser/advertiser.go
+++ b/go/src/examples/advertiser/advertiser.go
@@ -4,8 +4,8 @@
 	"log"
 
 	"mojo/public/go/application"
-	"mojo/public/go/system"
 	"mojo/public/go/bindings"
+	"mojo/public/go/system"
 
 	"mojom/vanadium/discovery"
 )
@@ -14,21 +14,21 @@
 import "C"
 
 type advDelegate struct {
-	id int32
-	proxy *discovery.Discoverer_Proxy
+	id    int32
+	proxy *discovery.Advertiser_Proxy
 }
 
 func (a *advDelegate) Initialize(ctx application.Context) {
-	req, ptr := discovery.CreateMessagePipeForDiscoverer()
+	req, ptr := discovery.CreateMessagePipeForAdvertiser()
 	ctx.ConnectToApplication("https://mojo.v.io/discovery.mojo").ConnectToService(&req)
-	a.proxy = discovery.NewDiscovererProxy(ptr, bindings.GetAsyncWaiter())
+	a.proxy = discovery.NewAdvertiserProxy(ptr, bindings.GetAsyncWaiter())
 	s := discovery.Service{
 		InterfaceName: "v.io/discovery.T",
-		Addrs: []string{"localhost:1000", "localhost:2000"},
-		Attrs: map[string]string{ "foo" : "bar"},
+		Addrs:         []string{"localhost:1000", "localhost:2000"},
+		Attrs:         map[string]string{"foo": "bar"},
 	}
 	id, e1, e2 := a.proxy.Advertise(s, nil)
-	if e1 != nil  || e2 != nil{
+	if e1 != nil || e2 != nil {
 		log.Println("Error occurred", e1, e2)
 		return
 	}
@@ -36,7 +36,6 @@
 	a.id = id
 }
 
-
 func (*advDelegate) AcceptConnection(connection *application.Connection) {
 	connection.Close()
 }
@@ -45,7 +44,6 @@
 	s.proxy.StopAdvertising(s.id)
 }
 
-
 //export MojoMain
 func MojoMain(handle C.MojoHandle) C.MojoResult {
 	application.Run(&advDelegate{}, system.MojoHandle(handle))
diff --git a/go/src/examples/scanner/scanner.go b/go/src/examples/scanner/scanner.go
index 6c749fe..60ed6d9 100644
--- a/go/src/examples/scanner/scanner.go
+++ b/go/src/examples/scanner/scanner.go
@@ -4,8 +4,8 @@
 	"log"
 
 	"mojo/public/go/application"
-	"mojo/public/go/system"
 	"mojo/public/go/bindings"
+	"mojo/public/go/system"
 
 	"mojom/vanadium/discovery"
 )
@@ -13,7 +13,7 @@
 //#include "mojo/public/c/system/types.h"
 import "C"
 
-type handler struct {}
+type handler struct{}
 
 func (*handler) Found(s discovery.Service) error {
 	log.Println("Found a new service", s)
@@ -26,19 +26,19 @@
 }
 
 type scannerDelegate struct {
-	id int32
-	proxy *discovery.Discoverer_Proxy
-	stub *bindings.Stub
+	id    int32
+	proxy *discovery.Scanner_Proxy
+	stub  *bindings.Stub
 }
 
 func (s *scannerDelegate) Initialize(ctx application.Context) {
-	req, ptr := discovery.CreateMessagePipeForDiscoverer()
+	req, ptr := discovery.CreateMessagePipeForScanner()
 	ctx.ConnectToApplication("https://mojo.v.io/discovery.mojo").ConnectToService(&req)
-	s.proxy = discovery.NewDiscovererProxy(ptr, bindings.GetAsyncWaiter())
+	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.io/discovery.T", scanPtr)
-	if e1 != nil  || e2 != nil{
+	if e1 != nil || e2 != nil {
 		log.Println("Error occurred", e1, e2)
 		return
 	}
@@ -57,7 +57,6 @@
 	}()
 }
 
-
 func (*scannerDelegate) AcceptConnection(connection *application.Connection) {
 	connection.Close()
 }
@@ -67,7 +66,6 @@
 	s.stub.Close()
 }
 
-
 //export MojoMain
 func MojoMain(handle C.MojoHandle) C.MojoResult {
 	application.Run(&scannerDelegate{}, system.MojoHandle(handle))
diff --git a/go/src/mojom/vanadium/discovery/discovery.mojom.go b/go/src/mojom/vanadium/discovery/discovery.mojom.go
index 3caf89c..458c651 100644
--- a/go/src/mojom/vanadium/discovery/discovery.mojom.go
+++ b/go/src/mojom/vanadium/discovery/discovery.mojom.go
@@ -17,78 +17,74 @@
 	"sort"
 )
 
-type Discoverer interface {
+type Advertiser interface {
 	Advertise(inS Service, inPattern []string) (outHandle int32, outErr *Error, err error)
 	StopAdvertising(inH int32) (err error)
-	Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle int32, outErr *Error, err error)
-	StopScan(inH int32) (err error)
 }
 
-var discoverer_Name = "discovery::Discoverer"
+var advertiser_Name = "discovery::Advertiser"
 
-type Discoverer_Request bindings.InterfaceRequest
+type Advertiser_Request bindings.InterfaceRequest
 
-func (r *Discoverer_Request) Name() string {
-	return discoverer_Name
+func (r *Advertiser_Request) Name() string {
+	return advertiser_Name
 }
 
-type Discoverer_Pointer bindings.InterfacePointer
+type Advertiser_Pointer bindings.InterfacePointer
 
-func (p *Discoverer_Pointer) Name() string {
-	return discoverer_Name
+func (p *Advertiser_Pointer) Name() string {
+	return advertiser_Name
 }
 
-type Discoverer_ServiceFactory struct {
-	Delegate Discoverer_Factory
+type Advertiser_ServiceFactory struct {
+	Delegate Advertiser_Factory
 }
 
-type Discoverer_Factory interface {
-	Create(request Discoverer_Request)
+type Advertiser_Factory interface {
+	Create(request Advertiser_Request)
 }
 
-func (f *Discoverer_ServiceFactory) Name() string {
-	return discoverer_Name
+func (f *Advertiser_ServiceFactory) Name() string {
+	return advertiser_Name
 }
 
-func (f *Discoverer_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
-	request := Discoverer_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
+func (f *Advertiser_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
+	request := Advertiser_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
 	f.Delegate.Create(request)
 }
 
-// CreateMessagePipeForDiscoverer creates a message pipe for use with the
-// Discoverer interface with a Discoverer_Request on one end and a Discoverer_Pointer on the other.
-func CreateMessagePipeForDiscoverer() (Discoverer_Request, Discoverer_Pointer) {
+// 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) {
 	r, p := bindings.CreateMessagePipeForMojoInterface()
-	return Discoverer_Request(r), Discoverer_Pointer(p)
+	return Advertiser_Request(r), Advertiser_Pointer(p)
 }
 
-const discoverer_Advertise_Name uint32 = 0
-const discoverer_StopAdvertising_Name uint32 = 1
-const discoverer_Scan_Name uint32 = 2
-const discoverer_StopScan_Name uint32 = 3
+const advertiser_Advertise_Name uint32 = 0
+const advertiser_StopAdvertising_Name uint32 = 1
 
-type Discoverer_Proxy struct {
+type Advertiser_Proxy struct {
 	router *bindings.Router
 	ids    bindings.Counter
 }
 
-func NewDiscovererProxy(p Discoverer_Pointer, waiter bindings.AsyncWaiter) *Discoverer_Proxy {
-	return &Discoverer_Proxy{
+func NewAdvertiserProxy(p Advertiser_Pointer, waiter bindings.AsyncWaiter) *Advertiser_Proxy {
+	return &Advertiser_Proxy{
 		bindings.NewRouter(p.PassMessagePipe(), waiter),
 		bindings.NewCounter(),
 	}
 }
 
-func (p *Discoverer_Proxy) Close_Proxy() {
+func (p *Advertiser_Proxy) Close_Proxy() {
 	p.router.Close()
 }
 
-type discoverer_Advertise_Params struct {
+type advertiser_Advertise_Params struct {
 	inS       Service
 	inPattern []string
 }
 
-func (s *discoverer_Advertise_Params) Encode(encoder *bindings.Encoder) error {
+func (s *advertiser_Advertise_Params) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(16, 0)
 	if err := encoder.WritePointer(); err != nil {
 		return err
@@ -117,23 +113,23 @@
 	return nil
 }
 
-var discoverer_Advertise_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var advertiser_Advertise_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{24, 0},
 }
 
-func (s *discoverer_Advertise_Params) Decode(decoder *bindings.Decoder) error {
+func (s *advertiser_Advertise_Params) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(discoverer_Advertise_Params_Versions), func(i int) bool {
-		return discoverer_Advertise_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(advertiser_Advertise_Params_Versions), func(i int) bool {
+		return advertiser_Advertise_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(discoverer_Advertise_Params_Versions) {
-		if discoverer_Advertise_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(advertiser_Advertise_Params_Versions) {
+		if advertiser_Advertise_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := discoverer_Advertise_Params_Versions[index].Size
+		expectedSize := advertiser_Advertise_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),
@@ -192,12 +188,12 @@
 	return nil
 }
 
-type discoverer_Advertise_ResponseParams struct {
+type advertiser_Advertise_ResponseParams struct {
 	outHandle int32
 	outErr    *Error
 }
 
-func (s *discoverer_Advertise_ResponseParams) Encode(encoder *bindings.Encoder) error {
+func (s *advertiser_Advertise_ResponseParams) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(16, 0)
 	if err := encoder.WriteInt32(s.outHandle); err != nil {
 		return err
@@ -218,23 +214,23 @@
 	return nil
 }
 
-var discoverer_Advertise_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+var advertiser_Advertise_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{24, 0},
 }
 
-func (s *discoverer_Advertise_ResponseParams) Decode(decoder *bindings.Decoder) error {
+func (s *advertiser_Advertise_ResponseParams) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(discoverer_Advertise_ResponseParams_Versions), func(i int) bool {
-		return discoverer_Advertise_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(advertiser_Advertise_ResponseParams_Versions), func(i int) bool {
+		return advertiser_Advertise_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(discoverer_Advertise_ResponseParams_Versions) {
-		if discoverer_Advertise_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(advertiser_Advertise_ResponseParams_Versions) {
+		if advertiser_Advertise_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := discoverer_Advertise_ResponseParams_Versions[index].Size
+		expectedSize := advertiser_Advertise_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),
@@ -268,13 +264,13 @@
 	return nil
 }
 
-func (p *Discoverer_Proxy) Advertise(inS Service, inPattern []string) (outHandle int32, outErr *Error, err error) {
-	payload := &discoverer_Advertise_Params{
+func (p *Advertiser_Proxy) Advertise(inS Service, inPattern []string) (outHandle int32, outErr *Error, err error) {
+	payload := &advertiser_Advertise_Params{
 		inS,
 		inPattern,
 	}
 	header := bindings.MessageHeader{
-		Type:      discoverer_Advertise_Name,
+		Type:      advertiser_Advertise_Name,
 		Flags:     bindings.MessageExpectsResponseFlag,
 		RequestId: p.ids.Count(),
 	}
@@ -295,13 +291,13 @@
 		}
 		return
 	}
-	if got, want := readResult.Message.Header.Type, discoverer_Advertise_Name; got != want {
+	if got, want := readResult.Message.Header.Type, advertiser_Advertise_Name; got != want {
 		err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
 			fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
 		}
 		return
 	}
-	var response discoverer_Advertise_ResponseParams
+	var response advertiser_Advertise_ResponseParams
 	if err = readResult.Message.DecodePayload(&response); err != nil {
 		p.Close_Proxy()
 		return
@@ -311,11 +307,11 @@
 	return
 }
 
-type discoverer_StopAdvertising_Params struct {
+type advertiser_StopAdvertising_Params struct {
 	inH int32
 }
 
-func (s *discoverer_StopAdvertising_Params) Encode(encoder *bindings.Encoder) error {
+func (s *advertiser_StopAdvertising_Params) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(8, 0)
 	if err := encoder.WriteInt32(s.inH); err != nil {
 		return err
@@ -326,23 +322,23 @@
 	return nil
 }
 
-var discoverer_StopAdvertising_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var advertiser_StopAdvertising_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{16, 0},
 }
 
-func (s *discoverer_StopAdvertising_Params) Decode(decoder *bindings.Decoder) error {
+func (s *advertiser_StopAdvertising_Params) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(discoverer_StopAdvertising_Params_Versions), func(i int) bool {
-		return discoverer_StopAdvertising_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(advertiser_StopAdvertising_Params_Versions), func(i int) bool {
+		return advertiser_StopAdvertising_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(discoverer_StopAdvertising_Params_Versions) {
-		if discoverer_StopAdvertising_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(advertiser_StopAdvertising_Params_Versions) {
+		if advertiser_StopAdvertising_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := discoverer_StopAdvertising_Params_Versions[index].Size
+		expectedSize := advertiser_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),
@@ -362,12 +358,12 @@
 	return nil
 }
 
-func (p *Discoverer_Proxy) StopAdvertising(inH int32) (err error) {
-	payload := &discoverer_StopAdvertising_Params{
+func (p *Advertiser_Proxy) StopAdvertising(inH int32) (err error) {
+	payload := &advertiser_StopAdvertising_Params{
 		inH,
 	}
 	header := bindings.MessageHeader{
-		Type:  discoverer_StopAdvertising_Name,
+		Type:  advertiser_StopAdvertising_Name,
 		Flags: bindings.MessageNoFlag,
 	}
 	var message *bindings.Message
@@ -383,12 +379,134 @@
 	return
 }
 
-type discoverer_Scan_Params struct {
+type advertiser_Stub struct {
+	connector *bindings.Connector
+	impl      Advertiser
+}
+
+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 (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.outErr, err = s.impl.Advertise(request.inS, request.inPattern)
+		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_StopAdvertising_Name:
+		if message.Header.Flags != bindings.MessageNoFlag {
+			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
+			}
+		}
+		var request advertiser_StopAdvertising_Params
+		if err := message.DecodePayload(&request); err != nil {
+			return err
+		}
+		err = s.impl.StopAdvertising(request.inH)
+		if err != nil {
+			return
+		}
+	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 int32, outErr *Error, err error)
+	StopScan(inH int32) (err error)
+}
+
+var scanner_Name = "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) 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_StopScan_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 *discoverer_Scan_Params) Encode(encoder *bindings.Encoder) error {
+func (s *scanner_Scan_Params) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(16, 0)
 	if err := encoder.WritePointer(); err != nil {
 		return err
@@ -405,23 +523,23 @@
 	return nil
 }
 
-var discoverer_Scan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var scanner_Scan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{24, 0},
 }
 
-func (s *discoverer_Scan_Params) Decode(decoder *bindings.Decoder) error {
+func (s *scanner_Scan_Params) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(discoverer_Scan_Params_Versions), func(i int) bool {
-		return discoverer_Scan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(scanner_Scan_Params_Versions), func(i int) bool {
+		return scanner_Scan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(discoverer_Scan_Params_Versions) {
-		if discoverer_Scan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(scanner_Scan_Params_Versions) {
+		if scanner_Scan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := discoverer_Scan_Params_Versions[index].Size
+		expectedSize := scanner_Scan_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),
@@ -461,12 +579,12 @@
 	return nil
 }
 
-type discoverer_Scan_ResponseParams struct {
+type scanner_Scan_ResponseParams struct {
 	outHandle int32
 	outErr    *Error
 }
 
-func (s *discoverer_Scan_ResponseParams) Encode(encoder *bindings.Encoder) error {
+func (s *scanner_Scan_ResponseParams) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(16, 0)
 	if err := encoder.WriteInt32(s.outHandle); err != nil {
 		return err
@@ -487,23 +605,23 @@
 	return nil
 }
 
-var discoverer_Scan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
+var scanner_Scan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{24, 0},
 }
 
-func (s *discoverer_Scan_ResponseParams) Decode(decoder *bindings.Decoder) error {
+func (s *scanner_Scan_ResponseParams) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(discoverer_Scan_ResponseParams_Versions), func(i int) bool {
-		return discoverer_Scan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(scanner_Scan_ResponseParams_Versions), func(i int) bool {
+		return scanner_Scan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(discoverer_Scan_ResponseParams_Versions) {
-		if discoverer_Scan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(scanner_Scan_ResponseParams_Versions) {
+		if scanner_Scan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := discoverer_Scan_ResponseParams_Versions[index].Size
+		expectedSize := scanner_Scan_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),
@@ -537,13 +655,13 @@
 	return nil
 }
 
-func (p *Discoverer_Proxy) Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle int32, outErr *Error, err error) {
-	payload := &discoverer_Scan_Params{
+func (p *Scanner_Proxy) Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle int32, outErr *Error, err error) {
+	payload := &scanner_Scan_Params{
 		inQuery,
 		inScanHandler,
 	}
 	header := bindings.MessageHeader{
-		Type:      discoverer_Scan_Name,
+		Type:      scanner_Scan_Name,
 		Flags:     bindings.MessageExpectsResponseFlag,
 		RequestId: p.ids.Count(),
 	}
@@ -564,13 +682,13 @@
 		}
 		return
 	}
-	if got, want := readResult.Message.Header.Type, discoverer_Scan_Name; got != want {
+	if got, want := readResult.Message.Header.Type, scanner_Scan_Name; got != want {
 		err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
 			fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
 		}
 		return
 	}
-	var response discoverer_Scan_ResponseParams
+	var response scanner_Scan_ResponseParams
 	if err = readResult.Message.DecodePayload(&response); err != nil {
 		p.Close_Proxy()
 		return
@@ -580,11 +698,11 @@
 	return
 }
 
-type discoverer_StopScan_Params struct {
+type scanner_StopScan_Params struct {
 	inH int32
 }
 
-func (s *discoverer_StopScan_Params) Encode(encoder *bindings.Encoder) error {
+func (s *scanner_StopScan_Params) Encode(encoder *bindings.Encoder) error {
 	encoder.StartStruct(8, 0)
 	if err := encoder.WriteInt32(s.inH); err != nil {
 		return err
@@ -595,23 +713,23 @@
 	return nil
 }
 
-var discoverer_StopScan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
+var scanner_StopScan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
 	bindings.DataHeader{16, 0},
 }
 
-func (s *discoverer_StopScan_Params) Decode(decoder *bindings.Decoder) error {
+func (s *scanner_StopScan_Params) Decode(decoder *bindings.Decoder) error {
 	header, err := decoder.StartStruct()
 	if err != nil {
 		return err
 	}
-	index := sort.Search(len(discoverer_StopScan_Params_Versions), func(i int) bool {
-		return discoverer_StopScan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
+	index := sort.Search(len(scanner_StopScan_Params_Versions), func(i int) bool {
+		return scanner_StopScan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
 	})
-	if index < len(discoverer_StopScan_Params_Versions) {
-		if discoverer_StopScan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
+	if index < len(scanner_StopScan_Params_Versions) {
+		if scanner_StopScan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
 			index--
 		}
-		expectedSize := discoverer_StopScan_Params_Versions[index].Size
+		expectedSize := scanner_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),
@@ -631,12 +749,12 @@
 	return nil
 }
 
-func (p *Discoverer_Proxy) StopScan(inH int32) (err error) {
-	payload := &discoverer_StopScan_Params{
+func (p *Scanner_Proxy) StopScan(inH int32) (err error) {
+	payload := &scanner_StopScan_Params{
 		inH,
 	}
 	header := bindings.MessageHeader{
-		Type:  discoverer_StopScan_Name,
+		Type:  scanner_StopScan_Name,
 		Flags: bindings.MessageNoFlag,
 	}
 	var message *bindings.Message
@@ -652,74 +770,35 @@
 	return
 }
 
-type discoverer_Stub struct {
+type scanner_Stub struct {
 	connector *bindings.Connector
-	impl      Discoverer
+	impl      Scanner
 }
 
-func NewDiscovererStub(r Discoverer_Request, impl Discoverer, waiter bindings.AsyncWaiter) *bindings.Stub {
+func NewScannerStub(r Scanner_Request, impl Scanner, waiter bindings.AsyncWaiter) *bindings.Stub {
 	connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
-	return bindings.NewStub(connector, &discoverer_Stub{connector, impl})
+	return bindings.NewStub(connector, &scanner_Stub{connector, impl})
 }
 
-func (s *discoverer_Stub) Accept(message *bindings.Message) (err error) {
+func (s *scanner_Stub) Accept(message *bindings.Message) (err error) {
 	switch message.Header.Type {
-	case discoverer_Advertise_Name:
+	case scanner_Scan_Name:
 		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
 			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
 				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
 			}
 		}
-		var request discoverer_Advertise_Params
+		var request scanner_Scan_Params
 		if err := message.DecodePayload(&request); err != nil {
 			return err
 		}
-		var response discoverer_Advertise_ResponseParams
-		response.outHandle, response.outErr, err = s.impl.Advertise(request.inS, request.inPattern)
-		if err != nil {
-			return
-		}
-		header := bindings.MessageHeader{
-			Type:      discoverer_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 discoverer_StopAdvertising_Name:
-		if message.Header.Flags != bindings.MessageNoFlag {
-			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
-				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
-			}
-		}
-		var request discoverer_StopAdvertising_Params
-		if err := message.DecodePayload(&request); err != nil {
-			return err
-		}
-		err = s.impl.StopAdvertising(request.inH)
-		if err != nil {
-			return
-		}
-	case discoverer_Scan_Name:
-		if message.Header.Flags != bindings.MessageExpectsResponseFlag {
-			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
-				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
-			}
-		}
-		var request discoverer_Scan_Params
-		if err := message.DecodePayload(&request); err != nil {
-			return err
-		}
-		var response discoverer_Scan_ResponseParams
+		var response scanner_Scan_ResponseParams
 		response.outHandle, response.outErr, err = s.impl.Scan(request.inQuery, request.inScanHandler)
 		if err != nil {
 			return
 		}
 		header := bindings.MessageHeader{
-			Type:      discoverer_Scan_Name,
+			Type:      scanner_Scan_Name,
 			Flags:     bindings.MessageIsResponseFlag,
 			RequestId: message.Header.RequestId,
 		}
@@ -728,13 +807,13 @@
 			return err
 		}
 		return s.connector.WriteMessage(message)
-	case discoverer_StopScan_Name:
+	case scanner_StopScan_Name:
 		if message.Header.Flags != bindings.MessageNoFlag {
 			return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
 				fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
 			}
 		}
-		var request discoverer_StopScan_Params
+		var request scanner_StopScan_Params
 		if err := message.DecodePayload(&request); err != nil {
 			return err
 		}
diff --git a/go/src/vanadium/discovery/discovery.go b/go/src/vanadium/discovery/discovery.go
index 7c4a2d2..f15ce4d 100644
--- a/go/src/vanadium/discovery/discovery.go
+++ b/go/src/vanadium/discovery/discovery.go
@@ -1,8 +1,6 @@
 package main
 
 import (
-	"log"
-
 	"v.io/v23"
 	idiscovery "v.io/x/ref/lib/discovery"
 	"v.io/x/ref/lib/discovery/plugins/ble"
@@ -16,44 +14,58 @@
 	"mojo/public/go/application"
 	"mojo/public/go/bindings"
 	"mojo/public/go/system"
+	"v.io/v23/context"
 )
 
 //#include "mojo/public/c/system/types.h"
 import "C"
 
 type discoveryDelegate struct {
+	ctx      *context.T
 	stubs    []*bindings.Stub
 	impl     *internal.DiscoveryService
 	shutdown v23.Shutdown
 }
 
 func (d *discoveryDelegate) Initialize(c application.Context) {
+	// TODO(bjornick): Caling 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.
 	ctx, shutdown := v23.Init()
 	host := c.Args()[1]
-	log.Println("Starting discovery with name", host)
+	ctx.Info("Starting discovery with name", host)
 	mplugin, err := mdns.New(host)
+	pluginList := []idiscovery.Plugin{}
 	if err != nil {
-		log.Println("Failed to start mplugin", err)
+		ctx.Error("Failed to start MDNS plugin", err)
+	} else {
+		pluginList = append(pluginList, mplugin)
 	}
 
 	bplugin, err := ble.NewPlugin(host)
 	if err != nil {
-		log.Println("Failed to start bplugin", err)
+		ctx.Error("Failed to start BLE plugin", err)
+	} else {
+		pluginList = append(pluginList, bplugin)
 	}
 
-	d.impl = internal.NewDiscoveryService(ctx, idiscovery.New([]idiscovery.Plugin{mplugin, bplugin}))
+	if len(pluginList) == 0 {
+		c.Close()
+		return
+	}
+	d.impl = internal.NewDiscoveryService(ctx, idiscovery.New(pluginList))
 	d.shutdown = shutdown
 }
 
-func (d *discoveryDelegate) Create(request mojom.Discoverer_Request) {
-	stub := mojom.NewDiscovererStub(request, d.impl, bindings.GetAsyncWaiter())
+func (d *discoveryDelegate) addAndServeStub(stub *bindings.Stub) {
 	d.stubs = append(d.stubs, stub)
 	go func() {
 		for {
 			if err := stub.ServeRequest(); err != nil {
 				connectionErr, ok := err.(*bindings.ConnectionError)
 				if !ok || !connectionErr.Closed() {
-					log.Println(err)
+					d.ctx.Error(err)
 				}
 				break
 			}
@@ -61,8 +73,28 @@
 	}()
 }
 
+type advertiseFactory struct {
+	d *discoveryDelegate
+}
+
+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) {
-	connection.ProvideServices(&mojom.Discoverer_ServiceFactory{d})
+	advFactory := &advertiseFactory{d: d}
+	scanFactory := scannerFactory{d: d}
+	connection.ProvideServices(&mojom.Advertiser_ServiceFactory{advFactory}, &mojom.ScanHandler_ServiceFactory{scanFactory})
 }
 
 func (d *discoveryDelegate) Quit() {
diff --git a/go/src/vanadium/discovery/internal/discovery.go b/go/src/vanadium/discovery/internal/discovery.go
index 9b4cd17..fe50d66 100644
--- a/go/src/vanadium/discovery/internal/discovery.go
+++ b/go/src/vanadium/discovery/internal/discovery.go
@@ -6,7 +6,6 @@
 	"v.io/v23/context"
 	"v.io/v23/discovery"
 	"v.io/v23/verror"
-	idiscovery "v.io/x/ref/lib/discovery"
 
 	"mojo/public/go/bindings"
 	mojom "mojom/vanadium/discovery"
@@ -15,35 +14,28 @@
 // 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
-	s            discovery.T
-	trigger      *idiscovery.Trigger
+	ctx     *context.T
+	s       discovery.T
 
 	// mu protects pending* and next*
-	mu           sync.Mutex
+	mu sync.Mutex
 
 	// The id to assign the next advertisement.
-	nextAdv      int32
-	// A map of advertisement ids to the cancellation channel.  When StopAdvertisement is
-	// called, the channel will be closed.
-	pendingAdvs  map[int32]chan struct{}
+	nextAdv int32
+	// A map of advertisement ids to the cancellation function.
+	activeAdvs map[int32]func()
 	// The id to assign to the next scan.
-	nextScan     int32
-	// A map of scan id to the cancellataion channel.  When StopScan is called, the channel
-	// for that id will be closed.
-	pendingScans map[int32]chan struct{}
+	nextScan int32
+	// A map of scan id to the cancellataion func()
+	activeScans map[int32]func()
 }
 
-func convertToErrorStruct(err error) *mojom.Error {
-	outErr := &mojom.Error{
-		Id:  "v.io/verror/Unknown",
+func v2mError(err error) *mojom.Error {
+	return &mojom.Error{
+		Id:  string(verror.ErrorID(err)),
+		Action: int32(verror.Action(err)),
 		Msg: err.Error(),
 	}
-	if e, ok := err.(verror.E); ok {
-		outErr.Id = string(e.ID)
-		outErr.Action = int32(e.Action)
-	}
-	return outErr
 }
 
 // NewDiscoveryService returns a new DiscoveryService bound to the context and the Vanadium
@@ -52,9 +44,8 @@
 	return &DiscoveryService{
 		ctx:          ctx,
 		s:            vDiscovery,
-		trigger:      idiscovery.NewTrigger(),
-		pendingAdvs:  map[int32]chan struct{}{},
-		pendingScans: map[int32]chan struct{}{},
+		activeAdvs:  map[int32]func(){},
+		activeScans: map[int32]func(){},
 	}
 }
 
@@ -68,35 +59,34 @@
 		Addrs:         s.Addrs,
 	}
 
-	ctx, c := context.WithCancel(d.ctx)
+	ctx, cancel := context.WithCancel(d.ctx)
 
 	err := d.s.Advertise(ctx, vService, nil)
 	if err != nil {
-		return 0, convertToErrorStruct(err), nil
+		cancel()
+		return 0, v2mError(err), nil
 	}
-	ch := make(chan struct{})
 	d.mu.Lock()
 	id := d.nextAdv
-	d.pendingAdvs[id] = ch
+	d.activeAdvs[id] = cancel
 	d.nextAdv++
 	d.mu.Unlock()
-	d.trigger.Add(c, ch)
 	return id, nil, nil
 }
 
 // StopAdvertising stops advertising for the given advertising id.
 func (d *DiscoveryService) StopAdvertising(handle int32) error {
 	d.mu.Lock()
-	ch := d.pendingAdvs[handle]
-	delete(d.pendingAdvs, handle)
+	cancel := d.activeAdvs[handle]
+	delete(d.activeAdvs, handle)
 	d.mu.Unlock()
-	if ch != nil {
-		close(ch)
+	if cancel != nil {
+		cancel()
 	}
 	return nil
 }
 
-func vServiceTomService(s discovery.Service) mojom.Service {
+func v2mService(s discovery.Service) mojom.Service {
 	return mojom.Service{
 		InstanceUuid:  s.InstanceUuid,
 		InterfaceName: s.InterfaceName,
@@ -108,28 +98,26 @@
 // Scan scans for all services that match the query string passed in and calls scanHandler with updates.
 // Returns the handle to this Scan.
 func (d *DiscoveryService) Scan(query string, scanHandler mojom.ScanHandler_Pointer) (int32, *mojom.Error, error) {
-	ctx, c := context.WithCancel(d.ctx)
+	ctx, cancel := context.WithCancel(d.ctx)
 	proxy := mojom.NewScanHandlerProxy(scanHandler, bindings.GetAsyncWaiter())
 	scanCh, err := d.s.Scan(ctx, query)
 	if err != nil {
-		return 0, convertToErrorStruct(err), nil
+		cancel()
+		return 0, v2mError(err), nil
 	}
-	ch := make(chan struct{})
 	d.mu.Lock()
 	id := d.nextScan
-	d.pendingScans[id] = ch
+	d.activeScans[id] = cancel
 	d.nextScan++
 	d.mu.Unlock()
 
-	d.trigger.Add(c, ch)
 	go func() {
 		for v := range scanCh {
 			switch value := v.(type) {
 			case discovery.UpdateFound:
-				proxy.Found(vServiceTomService(value.Value.Service))
+				proxy.Found(v2mService(value.Value.Service))
 			case discovery.UpdateLost:
-				proxy.Lost(vServiceTomService(value.Value.Service))
-			default:
+				proxy.Lost(v2mService(value.Value.Service))
 			}
 		}
 	}()
@@ -139,11 +127,11 @@
 // SopScan Stops the scan.
 func (d *DiscoveryService) StopScan(handle int32) error {
 	d.mu.Lock()
-	ch := d.pendingScans[handle]
-	delete(d.pendingScans, handle)
+	cancel := d.activeScans[handle]
+	delete(d.activeScans, handle)
 	d.mu.Unlock()
-	if ch != nil {
-		close(ch)
+	if cancel != nil {
+		cancel()
 	}
 	return nil
 }
@@ -151,12 +139,12 @@
 // Stop Stops all scans and advertisements.
 func (d *DiscoveryService) Stop() {
 	d.mu.Lock()
-	for _, ch := range d.pendingScans {
-		close(ch)
+	for _, cancel := range d.activeScans {
+		cancel()
 	}
 
-	for _, ch := range d.pendingAdvs {
-		close(ch)
+	for _, cancel := range d.activeAdvs {
+		cancel()
 	}
 	d.mu.Unlock()
 }
diff --git a/go/src/vanadium/discovery/internal/discovery_test.go b/go/src/vanadium/discovery/internal/discovery_test.go
index dea5351..6c35745 100644
--- a/go/src/vanadium/discovery/internal/discovery_test.go
+++ b/go/src/vanadium/discovery/internal/discovery_test.go
@@ -1,11 +1,12 @@
 package internal
+
 import (
 	"reflect"
 	"testing"
 
+	"v.io/v23/context"
 	"v.io/v23/discovery"
 	"v.io/v23/security/access"
-	"v.io/v23/context"
 	idiscovery "v.io/x/ref/lib/discovery"
 	vtest "v.io/x/ref/test"
 
@@ -14,21 +15,19 @@
 	mojom "mojom/vanadium/discovery"
 )
 
-
 type mockAdv struct {
 	s discovery.Service
 }
 
 type discoveryMock struct {
-	trigger *idiscovery.Trigger
-	id int64
+	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 *discoveryMock) Advertise(ctx *context.T,s discovery.Service, perms access.Permissions) error {
+func (d *discoveryMock) Advertise(ctx *context.T, s discovery.Service, perms access.Permissions) error {
 	currId := d.id
 	d.services[currId] = s
 	d.id++
@@ -44,17 +43,10 @@
 	return nil, nil
 }
 
-func compare(t *testing.T, vService discovery.Service, mService mojom.Service) {
-	if !reflect.DeepEqual(vService.Addrs, mService.Addrs) {
-		t.Errorf("addrs not the same: %v, %v", vService.Addrs, mService.Addrs)
-	}
-
-	if vService.InterfaceName != mService.InterfaceName {
-		t.Errorf("interface name not the same: %v, %v", vService.InterfaceName, mService.InterfaceName)
-	}
-
-	if !reflect.DeepEqual(map[string]string(vService.Attrs), mService.Attrs) {
-		t.Errorf("attributes not the same: %v, %v", vService.Attrs, mService.Attrs)
+func compare(t *testing.T, want discovery.Service, got mojom.Service) {
+	mwant := v2mService(want)
+	if !reflect.DeepEqual(mwant, got) {
+		t.Errorf("Got %#v want %#v", got, want)
 	}
 }
 
@@ -62,18 +54,18 @@
 	ctx, shutdown := vtest.V23Init()
 	defer shutdown()
 	mock := &discoveryMock{
-		trigger: idiscovery.NewTrigger(),
+		trigger:  idiscovery.NewTrigger(),
 		services: map[int64]discovery.Service{},
 		deleteCh: make(chan struct{}),
 	}
 	s := NewDiscoveryService(ctx, mock)
-	testService := mojom.Service {
+	testService := mojom.Service{
 		InterfaceName: "v.io/v23/discovery.T",
 		Attrs: map[string]string{
 			"key1": "value1",
 			"key2": "value2",
 		},
-		Addrs: []string{ "addr1", "addr2"},
+		Addrs: []string{"addr1", "addr2"},
 	}
 	id, e1, e2 := s.Advertise(testService, nil)
 
@@ -88,14 +80,13 @@
 		compare(t, service, testService)
 	}
 
-	testService2 := mojom.Service {
+	testService2 := mojom.Service{
 		InterfaceName: "v.io/v23/naming.T",
 		Attrs: map[string]string{
 			"key1": "value1",
 			"key2": "value2",
 		},
-		Addrs: []string{ "addr1", "addr2"},
-
+		Addrs: []string{"addr1", "addr2"},
 	}
 
 	_, e1, e2 = s.Advertise(testService2, nil)
@@ -120,6 +111,3 @@
 		t.Errorf("service should have been removed")
 	}
 }
-
-
-
diff --git a/mojom/vanadium/discovery.mojom b/mojom/vanadium/discovery.mojom
index 996c3a6..ca741e0 100644
--- a/mojom/vanadium/discovery.mojom
+++ b/mojom/vanadium/discovery.mojom
@@ -22,18 +22,32 @@
    string msg;
 };
 
-interface Discoverer {
+// Advertiser provides methods to do Vanadium Advertising.
+interface Advertiser {
+	// Advertises the given Service to all blessings that match pattern.  Returns
+	// a handle to the active advertisement that can be used to stop the advertisement.
 	Advertise(Service s, array<string> pattern) => (int32 Handle, Error? Err);
 
+	// StopAdvertising Stops the advertisement associated with the given handle.
 	StopAdvertising(int32 h);
+};
 
+// Scanner provides methods to scan for Vanadium advertisements.
+interface Scanner {
+	// Scan scans for services matching the query passed nad calls ScanHandler with updates.
+	// Returns a handle to the active scanner that can be used to stop the scanning.
 	Scan(string query, ScanHandler scanHandler) => (int32 Handle, Error? Err);
 
+	// StopScan stops the scanner associated weith the given handle.
 	StopScan(int32 h);
 };
 
+// ScanHandler is used to pass updates about Services that are found/lost during the
+// scan.
 interface ScanHandler {
+	// Found will be called when a Service is found.
 	Found(Service s);
 
+	// Lost will be called when a service is lost.
 	Lost(Service s);
 };
\ No newline at end of file