@@ -13,12 +13,13 @@ import (

 	"github.com/docker/docker/daemon/graphdriver"

 	"github.com/moby/buildkit/cache"

 	"github.com/moby/buildkit/cache/metadata"

-	"github.com/moby/buildkit/cache/remotecache"

+	registryremotecache "github.com/moby/buildkit/cache/remotecache/registry"

 	"github.com/moby/buildkit/control"

 	"github.com/moby/buildkit/exporter"

 	"github.com/moby/buildkit/frontend"

-	"github.com/moby/buildkit/frontend/dockerfile"

+	dockerfile "github.com/moby/buildkit/frontend/dockerfile/builder"

 	"github.com/moby/buildkit/frontend/gateway"

+	"github.com/moby/buildkit/frontend/gateway/forwarder"

 	"github.com/moby/buildkit/snapshot/blobmapping"

 	"github.com/moby/buildkit/solver/boltdbcachestorage"

 	"github.com/moby/buildkit/worker"

@@ -113,10 +114,6 @@ func newController(rt http.RoundTripper, opt Opt) (*control.Controller, error) {

 		return nil, err

 	}

-	frontends := map[string]frontend.Frontend{}

-	frontends["dockerfile.v0"] = dockerfile.NewDockerfileFrontend()

-	frontends["gateway.v0"] = gateway.NewGatewayFrontend()

-

 	wopt := mobyworker.Opt{

 		ID:                "moby",

 		SessionManager:    opt.SessionManager,

@@ -141,17 +138,17 @@ func newController(rt http.RoundTripper, opt Opt) (*control.Controller, error) {

 	}

 	wc.Add(w)

-	ci := remotecache.NewCacheImporter(remotecache.ImportOpt{

-		Worker:         w,

-		SessionManager: opt.SessionManager,

-	})

+	frontends := map[string]frontend.Frontend{

+		"dockerfile.v0": forwarder.NewGatewayForwarder(wc, dockerfile.Build),

+		"gateway.v0":    gateway.NewGatewayFrontend(wc),

+	}

 	return control.NewController(control.Opt{

-		SessionManager:   opt.SessionManager,

-		WorkerController: wc,

-		Frontends:        frontends,

-		CacheKeyStorage:  cacheStorage,

-		// CacheExporter:    ce,

-		CacheImporter: ci,

+		SessionManager:           opt.SessionManager,

+		WorkerController:         wc,

+		Frontends:                frontends,

+		CacheKeyStorage:          cacheStorage,

+		ResolveCacheImporterFunc: registryremotecache.ResolveCacheImporterFunc(opt.SessionManager),

+		// TODO: set ResolveCacheExporterFunc for exporting cache

 	})

 }

@@ -83,7 +83,7 @@ func (e *imageExporterInstance) Export(ctx context.Context, ref cache.ImmutableR

 	if ref != nil {

 		layersDone := oneOffProgress(ctx, "exporting layers")

-		if err := ref.Finalize(ctx); err != nil {

+		if err := ref.Finalize(ctx, true); err != nil {

 			return nil, err

 		}

@@ -26,7 +26,7 @@ github.com/imdario/mergo v0.3.5

 golang.org/x/sync fd80eb99c8f653c847d294a001bdf2a3a6f768f5

 # buildkit

-github.com/moby/buildkit 9acf51e49185b348608e0096b2903dd72907adcb

+github.com/moby/buildkit 98f1604134f945d48538ffca0e18662337b4a850

 github.com/tonistiigi/fsutil 8abad97ee3969cdf5e9c367f46adba2c212b3ddb

 github.com/grpc-ecosystem/grpc-opentracing 8e809c8a86450a29b90dcc9efbf062d0fe6d9746

 github.com/opentracing/opentracing-go 1361b9cd60be79c4c3a7fa9841b3c132e40066a7

@@ -256,7 +256,7 @@ make test TESTPKGS=./client

 make test TESTPKGS=./client TESTFLAGS="--run /TestCallDiskUsage -v" 

 # run all integration tests with a specific worker

-# supported workers are oci and containerd

+# supported workers: oci, oci-rootless, containerd, containerd-1.0

 make test TESTPKGS=./client TESTFLAGS="--run //worker=containerd -v" 

 ```

@@ -23,7 +23,6 @@

 		BytesMessage

 		ListWorkersRequest

 		ListWorkersResponse

-		WorkerRecord

 */

 package moby_buildkit_v1

@@ -33,6 +32,7 @@ import math "math"

 import _ "github.com/gogo/protobuf/gogoproto"

 import _ "github.com/golang/protobuf/ptypes/timestamp"

 import pb "github.com/moby/buildkit/solver/pb"

+import moby_buildkit_v1_types "github.com/moby/buildkit/api/types"

 import time "time"

 import github_com_opencontainers_go_digest "github.com/opencontainers/go-digest"

@@ -526,7 +526,7 @@ func (m *ListWorkersRequest) GetFilter() []string {

 }

 type ListWorkersResponse struct {

-	Record []*WorkerRecord `protobuf:"bytes,1,rep,name=record" json:"record,omitempty"`

+	Record []*moby_buildkit_v1_types.WorkerRecord `protobuf:"bytes,1,rep,name=record" json:"record,omitempty"`

 }

 func (m *ListWorkersResponse) Reset()                    { *m = ListWorkersResponse{} }

@@ -534,45 +534,13 @@ func (m *ListWorkersResponse) String() string            { return proto.CompactT

 func (*ListWorkersResponse) ProtoMessage()               {}

 func (*ListWorkersResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{14} }

-func (m *ListWorkersResponse) GetRecord() []*WorkerRecord {

+func (m *ListWorkersResponse) GetRecord() []*moby_buildkit_v1_types.WorkerRecord {

 	if m != nil {

 		return m.Record

 	}

 	return nil

 }

-type WorkerRecord struct {

-	ID        string            `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`

-	Labels    map[string]string `protobuf:"bytes,2,rep,name=Labels" json:"Labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`

-	Platforms []pb.Platform     `protobuf:"bytes,3,rep,name=platforms" json:"platforms"`

-}

-

-func (m *WorkerRecord) Reset()                    { *m = WorkerRecord{} }

-func (m *WorkerRecord) String() string            { return proto.CompactTextString(m) }

-func (*WorkerRecord) ProtoMessage()               {}

-func (*WorkerRecord) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{15} }

-

-func (m *WorkerRecord) GetID() string {

-	if m != nil {

-		return m.ID

-	}

-	return ""

-}

-

-func (m *WorkerRecord) GetLabels() map[string]string {

-	if m != nil {

-		return m.Labels

-	}

-	return nil

-}

-

-func (m *WorkerRecord) GetPlatforms() []pb.Platform {

-	if m != nil {

-		return m.Platforms

-	}

-	return nil

-}

-

 func init() {

 	proto.RegisterType((*PruneRequest)(nil), "moby.buildkit.v1.PruneRequest")

 	proto.RegisterType((*DiskUsageRequest)(nil), "moby.buildkit.v1.DiskUsageRequest")

@@ -589,7 +557,6 @@ func init() {

 	proto.RegisterType((*BytesMessage)(nil), "moby.buildkit.v1.BytesMessage")

 	proto.RegisterType((*ListWorkersRequest)(nil), "moby.buildkit.v1.ListWorkersRequest")

 	proto.RegisterType((*ListWorkersResponse)(nil), "moby.buildkit.v1.ListWorkersResponse")

-	proto.RegisterType((*WorkerRecord)(nil), "moby.buildkit.v1.WorkerRecord")

 }

 // Reference imports to suppress errors if they are not otherwise used.

@@ -1620,59 +1587,6 @@ func (m *ListWorkersResponse) MarshalTo(dAtA []byte) (int, error) {

 	return i, nil

 }

-func (m *WorkerRecord) Marshal() (dAtA []byte, err error) {

-	size := m.Size()

-	dAtA = make([]byte, size)

-	n, err := m.MarshalTo(dAtA)

-	if err != nil {

-		return nil, err

-	}

-	return dAtA[:n], nil

-}

-

-func (m *WorkerRecord) MarshalTo(dAtA []byte) (int, error) {

-	var i int

-	_ = i

-	var l int

-	_ = l

-	if len(m.ID) > 0 {

-		dAtA[i] = 0xa

-		i++

-		i = encodeVarintControl(dAtA, i, uint64(len(m.ID)))

-		i += copy(dAtA[i:], m.ID)

-	}

-	if len(m.Labels) > 0 {

-		for k, _ := range m.Labels {

-			dAtA[i] = 0x12

-			i++

-			v := m.Labels[k]

-			mapSize := 1 + len(k) + sovControl(uint64(len(k))) + 1 + len(v) + sovControl(uint64(len(v)))

-			i = encodeVarintControl(dAtA, i, uint64(mapSize))

-			dAtA[i] = 0xa

-			i++

-			i = encodeVarintControl(dAtA, i, uint64(len(k)))

-			i += copy(dAtA[i:], k)

-			dAtA[i] = 0x12

-			i++

-			i = encodeVarintControl(dAtA, i, uint64(len(v)))

-			i += copy(dAtA[i:], v)

-		}

-	}

-	if len(m.Platforms) > 0 {

-		for _, msg := range m.Platforms {

-			dAtA[i] = 0x1a

-			i++

-			i = encodeVarintControl(dAtA, i, uint64(msg.Size()))

-			n, err := msg.MarshalTo(dAtA[i:])

-			if err != nil {

-				return 0, err

-			}

-			i += n

-		}

-	}

-	return i, nil

-}

-

 func encodeVarintControl(dAtA []byte, offset int, v uint64) int {

 	for v >= 1<<7 {

 		dAtA[offset] = uint8(v&0x7f | 0x80)

@@ -1984,30 +1898,6 @@ func (m *ListWorkersResponse) Size() (n int) {

 	return n

 }

-func (m *WorkerRecord) Size() (n int) {

-	var l int

-	_ = l

-	l = len(m.ID)

-	if l > 0 {

-		n += 1 + l + sovControl(uint64(l))

-	}

-	if len(m.Labels) > 0 {

-		for k, v := range m.Labels {

-			_ = k

-			_ = v

-			mapEntrySize := 1 + len(k) + sovControl(uint64(len(k))) + 1 + len(v) + sovControl(uint64(len(v)))

-			n += mapEntrySize + 1 + sovControl(uint64(mapEntrySize))

-		}

-	}

-	if len(m.Platforms) > 0 {

-		for _, e := range m.Platforms {

-			l = e.Size()

-			n += 1 + l + sovControl(uint64(l))

-		}

-	}

-	return n

-}

-

 func sovControl(x uint64) (n int) {

 	for {

 		n++

@@ -4487,7 +4377,7 @@ func (m *ListWorkersResponse) Unmarshal(dAtA []byte) error {

 			if postIndex > l {

 				return io.ErrUnexpectedEOF

 			}

-			m.Record = append(m.Record, &WorkerRecord{})

+			m.Record = append(m.Record, &moby_buildkit_v1_types.WorkerRecord{})

 			if err := m.Record[len(m.Record)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {

 				return err

 			}

@@ -4513,234 +4403,6 @@ func (m *ListWorkersResponse) Unmarshal(dAtA []byte) error {

 	}

 	return nil

 }

-func (m *WorkerRecord) Unmarshal(dAtA []byte) error {

-	l := len(dAtA)

-	iNdEx := 0

-	for iNdEx < l {

-		preIndex := iNdEx

-		var wire uint64

-		for shift := uint(0); ; shift += 7 {

-			if shift >= 64 {

-				return ErrIntOverflowControl

-			}

-			if iNdEx >= l {

-				return io.ErrUnexpectedEOF

-			}

-			b := dAtA[iNdEx]

-			iNdEx++

-			wire |= (uint64(b) & 0x7F) << shift

-			if b < 0x80 {

-				break

-			}

-		}

-		fieldNum := int32(wire >> 3)

-		wireType := int(wire & 0x7)

-		if wireType == 4 {

-			return fmt.Errorf("proto: WorkerRecord: wiretype end group for non-group")

-		}

-		if fieldNum <= 0 {

-			return fmt.Errorf("proto: WorkerRecord: illegal tag %d (wire type %d)", fieldNum, wire)

-		}

-		switch fieldNum {

-		case 1:

-			if wireType != 2 {

-				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)

-			}

-			var stringLen uint64

-			for shift := uint(0); ; shift += 7 {

-				if shift >= 64 {

-					return ErrIntOverflowControl

-				}

-				if iNdEx >= l {

-					return io.ErrUnexpectedEOF

-				}

-				b := dAtA[iNdEx]

-				iNdEx++

-				stringLen |= (uint64(b) & 0x7F) << shift

-				if b < 0x80 {

-					break

-				}

-			}

-			intStringLen := int(stringLen)

-			if intStringLen < 0 {

-				return ErrInvalidLengthControl

-			}

-			postIndex := iNdEx + intStringLen

-			if postIndex > l {

-				return io.ErrUnexpectedEOF

-			}

-			m.ID = string(dAtA[iNdEx:postIndex])

-			iNdEx = postIndex

-		case 2:

-			if wireType != 2 {

-				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)

-			}

-			var msglen int

-			for shift := uint(0); ; shift += 7 {

-				if shift >= 64 {

-					return ErrIntOverflowControl

-				}

-				if iNdEx >= l {

-					return io.ErrUnexpectedEOF

-				}

-				b := dAtA[iNdEx]

-				iNdEx++

-				msglen |= (int(b) & 0x7F) << shift

-				if b < 0x80 {

-					break

-				}

-			}

-			if msglen < 0 {

-				return ErrInvalidLengthControl

-			}

-			postIndex := iNdEx + msglen

-			if postIndex > l {

-				return io.ErrUnexpectedEOF

-			}

-			if m.Labels == nil {

-				m.Labels = make(map[string]string)

-			}

-			var mapkey string

-			var mapvalue string

-			for iNdEx < postIndex {

-				entryPreIndex := iNdEx

-				var wire uint64

-				for shift := uint(0); ; shift += 7 {

-					if shift >= 64 {

-						return ErrIntOverflowControl

-					}

-					if iNdEx >= l {

-						return io.ErrUnexpectedEOF

-					}

-					b := dAtA[iNdEx]

-					iNdEx++

-					wire |= (uint64(b) & 0x7F) << shift

-					if b < 0x80 {

-						break

-					}

-				}

-				fieldNum := int32(wire >> 3)

-				if fieldNum == 1 {

-					var stringLenmapkey uint64

-					for shift := uint(0); ; shift += 7 {

-						if shift >= 64 {

-							return ErrIntOverflowControl

-						}

-						if iNdEx >= l {

-							return io.ErrUnexpectedEOF

-						}

-						b := dAtA[iNdEx]

-						iNdEx++

-						stringLenmapkey |= (uint64(b) & 0x7F) << shift

-						if b < 0x80 {

-							break

-						}

-					}

-					intStringLenmapkey := int(stringLenmapkey)

-					if intStringLenmapkey < 0 {

-						return ErrInvalidLengthControl

-					}

-					postStringIndexmapkey := iNdEx + intStringLenmapkey

-					if postStringIndexmapkey > l {

-						return io.ErrUnexpectedEOF

-					}

-					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])

-					iNdEx = postStringIndexmapkey

-				} else if fieldNum == 2 {

-					var stringLenmapvalue uint64

-					for shift := uint(0); ; shift += 7 {

-						if shift >= 64 {

-							return ErrIntOverflowControl

-						}

-						if iNdEx >= l {

-							return io.ErrUnexpectedEOF

-						}

-						b := dAtA[iNdEx]

-						iNdEx++

-						stringLenmapvalue |= (uint64(b) & 0x7F) << shift

-						if b < 0x80 {

-							break

-						}

-					}

-					intStringLenmapvalue := int(stringLenmapvalue)

-					if intStringLenmapvalue < 0 {

-						return ErrInvalidLengthControl

-					}

-					postStringIndexmapvalue := iNdEx + intStringLenmapvalue

-					if postStringIndexmapvalue > l {

-						return io.ErrUnexpectedEOF

-					}

-					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])

-					iNdEx = postStringIndexmapvalue

-				} else {

-					iNdEx = entryPreIndex

-					skippy, err := skipControl(dAtA[iNdEx:])

-					if err != nil {

-						return err

-					}

-					if skippy < 0 {

-						return ErrInvalidLengthControl

-					}

-					if (iNdEx + skippy) > postIndex {

-						return io.ErrUnexpectedEOF

-					}

-					iNdEx += skippy

-				}

-			}

-			m.Labels[mapkey] = mapvalue

-			iNdEx = postIndex

-		case 3:

-			if wireType != 2 {

-				return fmt.Errorf("proto: wrong wireType = %d for field Platforms", wireType)

-			}

-			var msglen int

-			for shift := uint(0); ; shift += 7 {

-				if shift >= 64 {

-					return ErrIntOverflowControl

-				}

-				if iNdEx >= l {

-					return io.ErrUnexpectedEOF

-				}

-				b := dAtA[iNdEx]

-				iNdEx++

-				msglen |= (int(b) & 0x7F) << shift

-				if b < 0x80 {

-					break

-				}

-			}

-			if msglen < 0 {

-				return ErrInvalidLengthControl

-			}

-			postIndex := iNdEx + msglen

-			if postIndex > l {

-				return io.ErrUnexpectedEOF

-			}

-			m.Platforms = append(m.Platforms, pb.Platform{})

-			if err := m.Platforms[len(m.Platforms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {

-				return err

-			}

-			iNdEx = postIndex

-		default:

-			iNdEx = preIndex

-			skippy, err := skipControl(dAtA[iNdEx:])

-			if err != nil {

-				return err

-			}

-			if skippy < 0 {

-				return ErrInvalidLengthControl

-			}

-			if (iNdEx + skippy) > l {

-				return io.ErrUnexpectedEOF

-			}

-			iNdEx += skippy

-		}

-	}

-

-	if iNdEx > l {

-		return io.ErrUnexpectedEOF

-	}

-	return nil

-}

 func skipControl(dAtA []byte) (n int, err error) {

 	l := len(dAtA)

 	iNdEx := 0

@@ -4849,81 +4511,79 @@ var (

 func init() { proto.RegisterFile("control.proto", fileDescriptorControl) }

 var fileDescriptorControl = []byte{

-	// 1214 bytes of a gzipped FileDescriptorProto

-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4f, 0x6f, 0x1b, 0x55,

-	0x10, 0x67, 0x6d, 0xc7, 0xf6, 0x8e, 0x9d, 0x28, 0x3c, 0xa0, 0x5a, 0x2d, 0x90, 0x98, 0x05, 0x24,

-	0xab, 0x6a, 0xd7, 0x69, 0xa0, 0x08, 0x72, 0xa8, 0x5a, 0xc7, 0x45, 0x24, 0x4a, 0x44, 0xd8, 0x34,

-	0x54, 0xe2, 0xb6, 0xb6, 0x5f, 0xdc, 0x55, 0xd6, 0xfb, 0x96, 0xf7, 0x9e, 0xa3, 0x86, 0x4f, 0xc1,

-	0x81, 0x6f, 0xc2, 0x81, 0x33, 0x07, 0xa4, 0xde, 0xe0, 0xcc, 0x21, 0x45, 0xb9, 0xc3, 0x67, 0x40,

-	0xef, 0xcf, 0xda, 0xcf, 0x5e, 0xe7, 0x8f, 0xd3, 0x93, 0xdf, 0xcc, 0xfe, 0xe6, 0xb7, 0xf3, 0x66,

-	0x66, 0x67, 0xc6, 0xb0, 0xdc, 0x23, 0x09, 0xa7, 0x24, 0xf6, 0x53, 0x4a, 0x38, 0x41, 0xab, 0x43,

-	0xd2, 0x3d, 0xf3, 0xbb, 0xa3, 0x28, 0xee, 0x9f, 0x44, 0xdc, 0x3f, 0x7d, 0xe0, 0xde, 0x1f, 0x44,

-	0xfc, 0xc5, 0xa8, 0xeb, 0xf7, 0xc8, 0xb0, 0x35, 0x20, 0x03, 0xd2, 0x92, 0xc0, 0xee, 0xe8, 0x58,

-	0x4a, 0x52, 0x90, 0x27, 0x45, 0xe0, 0xae, 0x0f, 0x08, 0x19, 0xc4, 0x78, 0x82, 0xe2, 0xd1, 0x10,

-	0x33, 0x1e, 0x0e, 0x53, 0x0d, 0xb8, 0x67, 0xf0, 0x89, 0x97, 0xb5, 0xb2, 0x97, 0xb5, 0x18, 0x89,

-	0x4f, 0x31, 0x6d, 0xa5, 0xdd, 0x16, 0x49, 0x99, 0x42, 0x7b, 0x2b, 0x50, 0x3f, 0xa0, 0xa3, 0x04,

-	0x07, 0xf8, 0xc7, 0x11, 0x66, 0xdc, 0xbb, 0x0b, 0xab, 0x9d, 0x88, 0x9d, 0x1c, 0xb1, 0x70, 0x90,

-	0xe9, 0xd0, 0x1d, 0x28, 0x1f, 0x47, 0x31, 0xc7, 0xd4, 0xb1, 0x1a, 0x56, 0xd3, 0x0e, 0xb4, 0xe4,

-	0xed, 0xc2, 0xdb, 0x06, 0x96, 0xa5, 0x24, 0x61, 0x18, 0x3d, 0x84, 0x32, 0xc5, 0x3d, 0x42, 0xfb,

-	0x8e, 0xd5, 0x28, 0x36, 0x6b, 0x9b, 0x1f, 0xfa, 0xb3, 0x37, 0xf6, 0xb5, 0x81, 0x00, 0x05, 0x1a,

-	0xec, 0xfd, 0x5e, 0x80, 0x9a, 0xa1, 0x47, 0x2b, 0x50, 0xd8, 0xe9, 0xe8, 0xf7, 0x15, 0x76, 0x3a,

-	0xc8, 0x81, 0xca, 0xfe, 0x88, 0x87, 0xdd, 0x18, 0x3b, 0x85, 0x86, 0xd5, 0xac, 0x06, 0x99, 0x88,

-	0xde, 0x85, 0xa5, 0x9d, 0xe4, 0x88, 0x61, 0xa7, 0x28, 0xf5, 0x4a, 0x40, 0x08, 0x4a, 0x87, 0xd1,

-	0x4f, 0xd8, 0x29, 0x35, 0xac, 0x66, 0x31, 0x90, 0x67, 0x71, 0x8f, 0x83, 0x90, 0xe2, 0x84, 0x3b,

-	0x4b, 0xea, 0x1e, 0x4a, 0x42, 0x6d, 0xb0, 0xb7, 0x29, 0x0e, 0x39, 0xee, 0x3f, 0xe1, 0x4e, 0xb9,

-	0x61, 0x35, 0x6b, 0x9b, 0xae, 0xaf, 0xc2, 0xec, 0x67, 0x61, 0xf6, 0x9f, 0x65, 0x61, 0x6e, 0x57,

-	0x5f, 0x9d, 0xaf, 0xbf, 0xf5, 0xf3, 0xeb, 0x75, 0x2b, 0x98, 0x98, 0xa1, 0xc7, 0x00, 0x7b, 0x21,

-	0xe3, 0x47, 0x4c, 0x92, 0x54, 0xae, 0x25, 0x29, 0x49, 0x02, 0xc3, 0x06, 0xad, 0x01, 0xc8, 0x00,

-	0x6c, 0x93, 0x51, 0xc2, 0x9d, 0xaa, 0xf4, 0xdb, 0xd0, 0xa0, 0x06, 0xd4, 0x3a, 0x98, 0xf5, 0x68,

-	0x94, 0xf2, 0x88, 0x24, 0x8e, 0x2d, 0xaf, 0x60, 0xaa, 0xbc, 0x5f, 0x4a, 0x50, 0x3f, 0x14, 0x39,

-	0xce, 0x12, 0xb7, 0x0a, 0xc5, 0x00, 0x1f, 0xeb, 0x28, 0x8a, 0x23, 0xf2, 0x01, 0x3a, 0xf8, 0x38,

-	0x4a, 0x22, 0xc9, 0x51, 0x90, 0x6e, 0xae, 0xf8, 0x69, 0xd7, 0x9f, 0x68, 0x03, 0x03, 0x81, 0x5c,

-	0xa8, 0x3e, 0x7d, 0x99, 0x12, 0x2a, 0x92, 0x5f, 0x94, 0x34, 0x63, 0x19, 0x3d, 0x87, 0xe5, 0xec,

-	0xfc, 0x84, 0x73, 0xca, 0x9c, 0x92, 0x4c, 0xf8, 0x83, 0x7c, 0xc2, 0x4d, 0xa7, 0xfc, 0x29, 0x9b,

-	0xa7, 0x09, 0xa7, 0x67, 0xc1, 0x34, 0x8f, 0xc8, 0xf5, 0x21, 0x66, 0x4c, 0x78, 0xa8, 0x12, 0x95,

-	0x89, 0xc2, 0x9d, 0xaf, 0x29, 0x49, 0x38, 0x4e, 0xfa, 0x32, 0x51, 0x76, 0x30, 0x96, 0x85, 0x3b,

-	0xd9, 0x59, 0xb9, 0x53, 0xb9, 0x91, 0x3b, 0x53, 0x36, 0xda, 0x9d, 0x29, 0x1d, 0xda, 0x82, 0xa5,

-	0xed, 0xb0, 0xf7, 0x02, 0xcb, 0x9c, 0xd4, 0x36, 0xd7, 0xf2, 0x84, 0xf2, 0xf1, 0xb7, 0x32, 0x09,

-	0xac, 0x5d, 0x12, 0xe5, 0x11, 0x28, 0x13, 0xf7, 0x31, 0xa0, 0xfc, 0x7d, 0x45, 0x5e, 0x4e, 0xf0,

-	0x59, 0x96, 0x97, 0x13, 0x7c, 0x26, 0x8a, 0xf8, 0x34, 0x8c, 0x47, 0xaa, 0xb8, 0xed, 0x40, 0x09,

-	0x5b, 0x85, 0x2f, 0x2d, 0xc1, 0x90, 0x77, 0x71, 0x11, 0x06, 0xef, 0xb5, 0x05, 0x75, 0xd3, 0x43,

-	0xf4, 0x01, 0xd8, 0xca, 0xa9, 0x49, 0x71, 0x4c, 0x14, 0xa2, 0x0e, 0x77, 0x86, 0x5a, 0x60, 0x4e,

-	0xa1, 0x51, 0x6c, 0xda, 0x81, 0xa1, 0x41, 0xdf, 0x41, 0x4d, 0x81, 0x55, 0x94, 0x8b, 0x32, 0xca,

-	0xad, 0xab, 0x83, 0xe2, 0x1b, 0x16, 0x2a, 0xc6, 0x26, 0x87, 0xfb, 0x08, 0x56, 0x67, 0x01, 0x0b,

-	0xdd, 0xf0, 0x37, 0x0b, 0x96, 0x75, 0x52, 0x75, 0x17, 0x0a, 0x33, 0x46, 0x4c, 0x33, 0x9d, 0xee,

-	0x47, 0x0f, 0x2f, 0xad, 0x07, 0x05, 0xf3, 0x67, 0xed, 0x94, 0xbf, 0x39, 0x3a, 0x77, 0x1b, 0xde,

-	0x9b, 0x0b, 0x5d, 0xc8, 0xf3, 0x8f, 0x60, 0xf9, 0x90, 0x87, 0x7c, 0xc4, 0x2e, 0xfd, 0x64, 0xbd,

-	0x5f, 0x2d, 0x58, 0xc9, 0x30, 0xfa, 0x76, 0x9f, 0x43, 0xf5, 0x14, 0x53, 0x8e, 0x5f, 0x62, 0xa6,

-	0x6f, 0xe5, 0xe4, 0x6f, 0xf5, 0xbd, 0x44, 0x04, 0x63, 0x24, 0xda, 0x82, 0x2a, 0x93, 0x3c, 0x58,

-	0xa5, 0x75, 0x6e, 0x29, 0x2b, 0x2b, 0xfd, 0xbe, 0x31, 0x1e, 0xb5, 0xa0, 0x14, 0x93, 0x41, 0x96,

-	0xed, 0xf7, 0x2f, 0xb3, 0xdb, 0x23, 0x83, 0x40, 0x02, 0xbd, 0xf3, 0x02, 0x94, 0x95, 0x0e, 0xed,

-	0x42, 0xb9, 0x1f, 0x0d, 0x30, 0xe3, 0xea, 0x56, 0xed, 0x4d, 0xf1, 0x81, 0xfc, 0x7d, 0xbe, 0x7e,

-	0xd7, 0x18, 0x54, 0x24, 0xc5, 0x89, 0x18, 0x94, 0x61, 0x94, 0x60, 0xca, 0x5a, 0x03, 0x72, 0x5f,

-	0x99, 0xf8, 0x1d, 0xf9, 0x13, 0x68, 0x06, 0xc1, 0x15, 0x25, 0xe9, 0x88, 0xeb, 0xc2, 0xbc, 0x1d,

-	0x97, 0x62, 0x10, 0x23, 0x22, 0x09, 0x87, 0x58, 0xf7, 0x35, 0x79, 0x16, 0x23, 0xa2, 0x27, 0xea,

-	0xb6, 0x2f, 0x07, 0x47, 0x35, 0xd0, 0x12, 0xda, 0x82, 0x0a, 0xe3, 0x21, 0xe5, 0xb8, 0x2f, 0x5b,

-	0xd2, 0x4d, 0x7a, 0x7b, 0x66, 0x80, 0x1e, 0x81, 0xdd, 0x23, 0xc3, 0x34, 0xc6, 0xc2, 0xba, 0x7c,

-	0x43, 0xeb, 0x89, 0x89, 0xa8, 0x1e, 0x4c, 0x29, 0xa1, 0x72, 0xaa, 0xd8, 0x81, 0x12, 0xbc, 0xff,

-	0x0a, 0x50, 0x37, 0x93, 0x95, 0x9b, 0x98, 0xbb, 0x50, 0x56, 0xa9, 0x57, 0x55, 0x77, 0xbb, 0x50,

-	0x29, 0x86, 0xb9, 0xa1, 0x72, 0xa0, 0xd2, 0x1b, 0x51, 0x39, 0x4e, 0xd5, 0x90, 0xcd, 0x44, 0xe1,

-	0x30, 0x27, 0x3c, 0x8c, 0x65, 0xa8, 0x8a, 0x81, 0x12, 0xc4, 0x94, 0x1d, 0xaf, 0x2a, 0x8b, 0x4d,

-	0xd9, 0xb1, 0x99, 0x99, 0x86, 0xca, 0x1b, 0xa5, 0xa1, 0xba, 0x70, 0x1a, 0xbc, 0x3f, 0x2c, 0xb0,

-	0xc7, 0x55, 0x6e, 0x44, 0xd7, 0x7a, 0xe3, 0xe8, 0x4e, 0x45, 0xa6, 0x70, 0xbb, 0xc8, 0xdc, 0x81,

-	0x32, 0xe3, 0x14, 0x87, 0x43, 0x99, 0xa3, 0x62, 0xa0, 0x25, 0xd1, 0x4f, 0x86, 0x6c, 0x20, 0x33,

-	0x54, 0x0f, 0xc4, 0xd1, 0xf3, 0xa0, 0xde, 0x3e, 0xe3, 0x98, 0xed, 0x63, 0x26, 0x96, 0x0b, 0x91,

-	0xdb, 0x7e, 0xc8, 0x43, 0x79, 0x8f, 0x7a, 0x20, 0xcf, 0xde, 0x3d, 0x40, 0x7b, 0x11, 0xe3, 0xcf,

-	0x09, 0x3d, 0xc1, 0x94, 0xcd, 0xdb, 0x03, 0x8b, 0xc6, 0x1e, 0xb8, 0x0f, 0xef, 0x4c, 0xa1, 0x75,

-	0x97, 0xfa, 0x62, 0x66, 0x13, 0x9c, 0xd3, 0x6d, 0x94, 0xc9, 0xcc, 0x2a, 0xf8, 0xa7, 0x05, 0x75,

-	0xf3, 0x41, 0xae, 0xb2, 0xdb, 0x50, 0xde, 0x0b, 0xbb, 0x38, 0xce, 0xda, 0xd8, 0xdd, 0xab, 0x89,

-	0x7d, 0x05, 0x56, 0x7d, 0x5c, 0x5b, 0xa2, 0x0d, 0xb0, 0xd3, 0x38, 0xe4, 0xc7, 0x84, 0x0e, 0xb3,

-	0xae, 0x56, 0x17, 0x7b, 0xd0, 0x81, 0x56, 0xea, 0x31, 0x3e, 0x01, 0xb9, 0x5f, 0x41, 0xcd, 0x20,

-	0x5a, 0xa4, 0xcb, 0x6f, 0xfe, 0x5b, 0x84, 0xca, 0xb6, 0xfa, 0x1b, 0x80, 0x9e, 0x81, 0x3d, 0x5e,

-	0x9a, 0x91, 0x97, 0xf7, 0x7c, 0x76, 0xfb, 0x76, 0x3f, 0xbe, 0x12, 0xa3, 0x63, 0xfd, 0x0d, 0x2c,

-	0xc9, 0x35, 0x1e, 0xcd, 0x09, 0xb2, 0xb9, 0xdf, 0xbb, 0x57, 0xaf, 0xe3, 0x1b, 0x96, 0x60, 0x92,

-	0xf3, 0x70, 0x1e, 0x93, 0xb9, 0x38, 0xb9, 0xeb, 0xd7, 0x0c, 0x52, 0xb4, 0x0f, 0x65, 0xdd, 0x9a,

-	0xe6, 0x41, 0xcd, 0xa9, 0xe7, 0x36, 0x2e, 0x07, 0x28, 0xb2, 0x0d, 0x0b, 0xed, 0x8f, 0xb7, 0xc2,

-	0x79, 0xae, 0x99, 0x25, 0xed, 0x5e, 0xf3, 0xbc, 0x69, 0x6d, 0x58, 0xe8, 0x07, 0xa8, 0x19, 0x45,

-	0x8b, 0x3e, 0xc9, 0x9b, 0xe4, 0xbf, 0x00, 0xf7, 0xd3, 0x6b, 0x50, 0xca, 0xd9, 0x76, 0xfd, 0xd5,

-	0xc5, 0x9a, 0xf5, 0xd7, 0xc5, 0x9a, 0xf5, 0xcf, 0xc5, 0x9a, 0xd5, 0x2d, 0xcb, 0x6f, 0xf8, 0xb3,

-	0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x86, 0xd4, 0x0f, 0xa1, 0x0a, 0x0e, 0x00, 0x00,

+	// 1176 bytes of a gzipped FileDescriptorProto

+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4d, 0x6f, 0x23, 0x45,

+	0x13, 0x7e, 0xc7, 0x76, 0xfc, 0x51, 0x76, 0xa2, 0xbc, 0x0d, 0xac, 0x46, 0x03, 0x24, 0x66, 0x00,

+	0xc9, 0x5a, 0xed, 0xce, 0x64, 0x03, 0x2b, 0xa1, 0x08, 0xad, 0x76, 0x1d, 0x2f, 0x22, 0x51, 0x22,

+	0x96, 0xce, 0x86, 0x95, 0xb8, 0x8d, 0xed, 0x8e, 0x77, 0x14, 0x7b, 0x7a, 0xe8, 0xee, 0x09, 0x6b,

+	0x7e, 0x05, 0x07, 0xfe, 0x09, 0x07, 0xce, 0x1c, 0x90, 0xf6, 0xc8, 0x99, 0x43, 0x16, 0xe5, 0x0e,

+	0xbf, 0x01, 0xf5, 0xc7, 0xd8, 0xed, 0xd8, 0xf9, 0xdc, 0x53, 0xba, 0x2a, 0x4f, 0x3d, 0x53, 0x5d,

+	0x4f, 0xb9, 0xab, 0x60, 0xb9, 0x47, 0x13, 0xc1, 0xe8, 0x30, 0x48, 0x19, 0x15, 0x14, 0xad, 0x8e,

+	0x68, 0x77, 0x1c, 0x74, 0xb3, 0x78, 0xd8, 0x3f, 0x8e, 0x45, 0x70, 0xf2, 0xc0, 0xbb, 0x3f, 0x88,

+	0xc5, 0xcb, 0xac, 0x1b, 0xf4, 0xe8, 0x28, 0x1c, 0xd0, 0x01, 0x0d, 0x15, 0xb0, 0x9b, 0x1d, 0x29,

+	0x4b, 0x19, 0xea, 0xa4, 0x09, 0xbc, 0xf5, 0x01, 0xa5, 0x83, 0x21, 0x99, 0xa2, 0x44, 0x3c, 0x22,

+	0x5c, 0x44, 0xa3, 0xd4, 0x00, 0xee, 0x59, 0x7c, 0xf2, 0x63, 0x61, 0xfe, 0xb1, 0x90, 0xd3, 0xe1,

+	0x09, 0x61, 0x61, 0xda, 0x0d, 0x69, 0xca, 0x0d, 0x3a, 0xbc, 0x10, 0x1d, 0xa5, 0x71, 0x28, 0xc6,

+	0x29, 0xe1, 0xe1, 0x8f, 0x94, 0x1d, 0x13, 0xa6, 0x03, 0xfc, 0x15, 0x68, 0x3c, 0x63, 0x59, 0x42,

+	0x30, 0xf9, 0x21, 0x23, 0x5c, 0xf8, 0x77, 0x61, 0xb5, 0x13, 0xf3, 0xe3, 0x43, 0x1e, 0x0d, 0x72,

+	0x1f, 0xba, 0x03, 0xe5, 0xa3, 0x78, 0x28, 0x08, 0x73, 0x9d, 0xa6, 0xd3, 0xaa, 0x61, 0x63, 0xf9,

+	0xbb, 0xf0, 0x7f, 0x0b, 0xcb, 0x53, 0x9a, 0x70, 0x82, 0x1e, 0x42, 0x99, 0x91, 0x1e, 0x65, 0x7d,

+	0xd7, 0x69, 0x16, 0x5b, 0xf5, 0xcd, 0x0f, 0x83, 0xf3, 0x25, 0x0a, 0x4c, 0x80, 0x04, 0x61, 0x03,

+	0xf6, 0x7f, 0x2f, 0x40, 0xdd, 0xf2, 0xa3, 0x15, 0x28, 0xec, 0x74, 0xcc, 0xf7, 0x0a, 0x3b, 0x1d,

+	0xe4, 0x42, 0x65, 0x3f, 0x13, 0x51, 0x77, 0x48, 0xdc, 0x42, 0xd3, 0x69, 0x55, 0x71, 0x6e, 0xa2,

+	0x77, 0x61, 0x69, 0x27, 0x39, 0xe4, 0xc4, 0x2d, 0x2a, 0xbf, 0x36, 0x10, 0x82, 0xd2, 0x41, 0xfc,

+	0x13, 0x71, 0x4b, 0x4d, 0xa7, 0x55, 0xc4, 0xea, 0x2c, 0xef, 0xf1, 0x2c, 0x62, 0x24, 0x11, 0xee,

+	0x92, 0xbe, 0x87, 0xb6, 0x50, 0x1b, 0x6a, 0xdb, 0x8c, 0x44, 0x82, 0xf4, 0x9f, 0x08, 0xb7, 0xdc,

+	0x74, 0x5a, 0xf5, 0x4d, 0x2f, 0xd0, 0xba, 0x04, 0xb9, 0x2e, 0xc1, 0xf3, 0x5c, 0x97, 0x76, 0xf5,

+	0xf5, 0xe9, 0xfa, 0xff, 0x7e, 0x7e, 0xb3, 0xee, 0xe0, 0x69, 0x18, 0x7a, 0x0c, 0xb0, 0x17, 0x71,

+	0x71, 0xc8, 0x15, 0x49, 0xe5, 0x4a, 0x92, 0x92, 0x22, 0xb0, 0x62, 0xd0, 0x1a, 0x80, 0x2a, 0xc0,

+	0x36, 0xcd, 0x12, 0xe1, 0x56, 0x55, 0xde, 0x96, 0x07, 0x35, 0xa1, 0xde, 0x21, 0xbc, 0xc7, 0xe2,

+	0x54, 0xc4, 0x34, 0x71, 0x6b, 0xea, 0x0a, 0xb6, 0xcb, 0xff, 0xa5, 0x04, 0x8d, 0x03, 0xd9, 0x14,

+	0xb9, 0x70, 0xab, 0x50, 0xc4, 0xe4, 0xc8, 0x54, 0x51, 0x1e, 0x51, 0x00, 0xd0, 0x21, 0x47, 0x71,

+	0x12, 0x2b, 0x8e, 0x82, 0x4a, 0x73, 0x25, 0x48, 0xbb, 0xc1, 0xd4, 0x8b, 0x2d, 0x04, 0xf2, 0xa0,

+	0xfa, 0xf4, 0x55, 0x4a, 0x99, 0x14, 0xbf, 0xa8, 0x68, 0x26, 0x36, 0x7a, 0x01, 0xcb, 0xf9, 0xf9,

+	0x89, 0x10, 0x8c, 0xbb, 0x25, 0x25, 0xf8, 0x83, 0x79, 0xc1, 0xed, 0xa4, 0x82, 0x99, 0x98, 0xa7,

+	0x89, 0x60, 0x63, 0x3c, 0xcb, 0x23, 0xb5, 0x3e, 0x20, 0x9c, 0xcb, 0x0c, 0xb5, 0x50, 0xb9, 0x29,

+	0xd3, 0xf9, 0x8a, 0xd1, 0x44, 0x90, 0xa4, 0xaf, 0x84, 0xaa, 0xe1, 0x89, 0x2d, 0xd3, 0xc9, 0xcf,

+	0x3a, 0x9d, 0xca, 0xb5, 0xd2, 0x99, 0x89, 0x31, 0xe9, 0xcc, 0xf8, 0xd0, 0x16, 0x2c, 0x6d, 0x47,

+	0xbd, 0x97, 0x44, 0x69, 0x52, 0xdf, 0x5c, 0x9b, 0x27, 0x54, 0xff, 0xfe, 0x46, 0x89, 0xc0, 0xdb,

+	0x25, 0xd9, 0x1e, 0x58, 0x87, 0x78, 0x8f, 0x01, 0xcd, 0xdf, 0x57, 0xea, 0x72, 0x4c, 0xc6, 0xb9,

+	0x2e, 0xc7, 0x64, 0x2c, 0x9b, 0xf8, 0x24, 0x1a, 0x66, 0xba, 0xb9, 0x6b, 0x58, 0x1b, 0x5b, 0x85,

+	0x2f, 0x1c, 0xc9, 0x30, 0x9f, 0xe2, 0x4d, 0x18, 0xfc, 0x37, 0x0e, 0x34, 0xec, 0x0c, 0xd1, 0x07,

+	0x50, 0xd3, 0x49, 0x4d, 0x9b, 0x63, 0xea, 0x90, 0x7d, 0xb8, 0x33, 0x32, 0x06, 0x77, 0x0b, 0xcd,

+	0x62, 0xab, 0x86, 0x2d, 0x0f, 0xfa, 0x16, 0xea, 0x1a, 0xac, 0xab, 0x5c, 0x54, 0x55, 0x0e, 0x2f,

+	0x2f, 0x4a, 0x60, 0x45, 0xe8, 0x1a, 0xdb, 0x1c, 0xde, 0x23, 0x58, 0x3d, 0x0f, 0xb8, 0xd1, 0x0d,

+	0x7f, 0x73, 0x60, 0xd9, 0x88, 0x6a, 0x5e, 0xa1, 0x28, 0x67, 0x24, 0x2c, 0xf7, 0x99, 0xf7, 0xe8,

+	0xe1, 0x85, 0xfd, 0xa0, 0x61, 0xc1, 0xf9, 0x38, 0x9d, 0xef, 0x1c, 0x9d, 0xb7, 0x0d, 0xef, 0x2d,

+	0x84, 0xde, 0x28, 0xf3, 0x8f, 0x60, 0xf9, 0x40, 0x44, 0x22, 0xe3, 0x17, 0xfe, 0x64, 0xfd, 0x5f,

+	0x1d, 0x58, 0xc9, 0x31, 0xe6, 0x76, 0x9f, 0x43, 0xf5, 0x84, 0x30, 0x41, 0x5e, 0x11, 0x6e, 0x6e,

+	0xe5, 0xce, 0xdf, 0xea, 0x3b, 0x85, 0xc0, 0x13, 0x24, 0xda, 0x82, 0x2a, 0x57, 0x3c, 0x44, 0xcb,

+	0xba, 0xb0, 0x95, 0x75, 0x94, 0xf9, 0xde, 0x04, 0x8f, 0x42, 0x28, 0x0d, 0xe9, 0x20, 0x57, 0xfb,

+	0xfd, 0x8b, 0xe2, 0xf6, 0xe8, 0x00, 0x2b, 0xa0, 0x7f, 0x5a, 0x80, 0xb2, 0xf6, 0xa1, 0x5d, 0x28,

+	0xf7, 0xe3, 0x01, 0xe1, 0x42, 0xdf, 0xaa, 0xbd, 0x29, 0x7f, 0x20, 0x7f, 0x9d, 0xae, 0xdf, 0xb5,

+	0x66, 0x15, 0x4d, 0x49, 0x22, 0x27, 0x6b, 0x14, 0x27, 0x84, 0xf1, 0x70, 0x40, 0xef, 0xeb, 0x90,

+	0xa0, 0xa3, 0xfe, 0x60, 0xc3, 0x20, 0xb9, 0xe2, 0x24, 0xcd, 0x84, 0x69, 0xcc, 0xdb, 0x71, 0x69,

+	0x06, 0x39, 0x22, 0x92, 0x68, 0x44, 0xcc, 0xbb, 0xa6, 0xce, 0x72, 0x44, 0xf4, 0x64, 0xdf, 0xf6,

+	0xd5, 0xe0, 0xa8, 0x62, 0x63, 0xa1, 0x2d, 0xa8, 0x70, 0x11, 0x31, 0x41, 0xfa, 0xea, 0x49, 0xba,

+	0xce, 0xdb, 0x9e, 0x07, 0xa0, 0x47, 0x50, 0xeb, 0xd1, 0x51, 0x3a, 0x24, 0x32, 0xba, 0x7c, 0xcd,

+	0xe8, 0x69, 0x88, 0xec, 0x1e, 0xc2, 0x18, 0x65, 0x6a, 0xaa, 0xd4, 0xb0, 0x36, 0xfc, 0x7f, 0x0b,

+	0xd0, 0xb0, 0xc5, 0x9a, 0x9b, 0x98, 0xbb, 0x50, 0xd6, 0xd2, 0xeb, 0xae, 0xbb, 0x5d, 0xa9, 0x34,

+	0xc3, 0xc2, 0x52, 0xb9, 0x50, 0xe9, 0x65, 0x4c, 0x8d, 0x53, 0x3d, 0x64, 0x73, 0x53, 0x26, 0x2c,

+	0xa8, 0x88, 0x86, 0xaa, 0x54, 0x45, 0xac, 0x0d, 0x39, 0x65, 0x27, 0xbb, 0xcd, 0xcd, 0xa6, 0xec,

+	0x24, 0xcc, 0x96, 0xa1, 0xf2, 0x56, 0x32, 0x54, 0x6f, 0x2c, 0x83, 0xff, 0x87, 0x03, 0xb5, 0x49,

+	0x97, 0x5b, 0xd5, 0x75, 0xde, 0xba, 0xba, 0x33, 0x95, 0x29, 0xdc, 0xae, 0x32, 0x77, 0xa0, 0xcc,

+	0x05, 0x23, 0xd1, 0x48, 0x69, 0x54, 0xc4, 0xc6, 0x92, 0xef, 0xc9, 0x88, 0x0f, 0x94, 0x42, 0x0d,

+	0x2c, 0x8f, 0xbe, 0x0f, 0x8d, 0xf6, 0x58, 0x10, 0xbe, 0x4f, 0xb8, 0x5c, 0x2e, 0xa4, 0xb6, 0xfd,

+	0x48, 0x44, 0xea, 0x1e, 0x0d, 0xac, 0xce, 0xfe, 0x3d, 0x40, 0x7b, 0x31, 0x17, 0x2f, 0xd4, 0xa6,

+	0xc8, 0x17, 0xed, 0x81, 0x45, 0x6b, 0x0f, 0x3c, 0x80, 0x77, 0x66, 0xd0, 0xe6, 0x95, 0xfa, 0xf2,

+	0xdc, 0x26, 0xf8, 0xc9, 0xfc, 0xab, 0xa1, 0x16, 0xd2, 0x40, 0x07, 0xce, 0x2e, 0x84, 0x9b, 0xff,

+	0x14, 0xa1, 0xb2, 0xad, 0x77, 0x6d, 0xf4, 0x1c, 0x6a, 0x93, 0x45, 0x13, 0xf9, 0xf3, 0x34, 0xe7,

+	0x37, 0x56, 0xef, 0xe3, 0x4b, 0x31, 0x26, 0xbf, 0xaf, 0x61, 0x49, 0xad, 0xbe, 0x68, 0xc1, 0x33,

+	0x68, 0xef, 0xc4, 0xde, 0xe5, 0x2b, 0xec, 0x86, 0x23, 0x99, 0xd4, 0x0c, 0x59, 0xc4, 0x64, 0x2f,

+	0x1b, 0xde, 0xfa, 0x15, 0xc3, 0x07, 0xed, 0x43, 0xd9, 0xfc, 0x9c, 0x17, 0x41, 0xed, 0x49, 0xe1,

+	0x35, 0x2f, 0x06, 0x68, 0xb2, 0x0d, 0x07, 0xed, 0x4f, 0x36, 0xa9, 0x45, 0xa9, 0xd9, 0x6d, 0xe0,

+	0x5d, 0xf1, 0xff, 0x96, 0xb3, 0xe1, 0xa0, 0xef, 0xa1, 0x6e, 0x09, 0x8d, 0x16, 0x08, 0x3a, 0xdf,

+	0x35, 0xde, 0xa7, 0x57, 0xa0, 0x74, 0xb2, 0xed, 0xc6, 0xeb, 0xb3, 0x35, 0xe7, 0xcf, 0xb3, 0x35,

+	0xe7, 0xef, 0xb3, 0x35, 0xa7, 0x5b, 0x56, 0x7d, 0xff, 0xd9, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff,

+	0xe1, 0xef, 0xcc, 0xf5, 0x6f, 0x0d, 0x00, 0x00,

 }

@@ -2,9 +2,13 @@ syntax = "proto3";

 package moby.buildkit.v1;

+// The control API is currently considered experimental and may break in a backwards

+// incompatible way.

+

 import "github.com/gogo/protobuf/gogoproto/gogo.proto";

 import "google/protobuf/timestamp.proto";

 import "github.com/moby/buildkit/solver/pb/ops.proto";

+import "github.com/moby/buildkit/api/types/worker.proto";

 option (gogoproto.sizer_all) = true;

 option (gogoproto.marshaler_all) = true;

@@ -17,6 +21,7 @@ service Control {

 	rpc Status(StatusRequest) returns (stream StatusResponse);

 	rpc Session(stream BytesMessage) returns (stream BytesMessage);

 	rpc ListWorkers(ListWorkersRequest) returns (ListWorkersResponse);

+	// rpc Info(InfoRequest) returns (InfoResponse);

 }

 message PruneRequest {

@@ -112,11 +117,5 @@ message ListWorkersRequest {

 }

 message ListWorkersResponse {

-	repeated WorkerRecord record = 1;

-}

-

-message WorkerRecord {

-	string ID = 1;

-	map<string, string> Labels = 2;

-	repeated pb.Platform platforms = 3 [(gogoproto.nullable) = false];

-}

+	repeated moby.buildkit.v1.types.WorkerRecord record = 1;

+}

\ No newline at end of file

new file mode 100644

@@ -0,0 +1,3 @@

+package moby_buildkit_v1_types

+

+//go:generate protoc -I=. -I=../../vendor/ -I=../../../../../ --gogo_out=plugins=grpc:. worker.proto

new file mode 100644

@@ -0,0 +1,523 @@

+// Code generated by protoc-gen-gogo. DO NOT EDIT.

+// source: worker.proto

+

+/*

+	Package moby_buildkit_v1_types is a generated protocol buffer package.

+

+	It is generated from these files:

+		worker.proto

+

+	It has these top-level messages:

+		WorkerRecord

+*/

+package moby_buildkit_v1_types

+

+import proto "github.com/gogo/protobuf/proto"

+import fmt "fmt"

+import math "math"

+import _ "github.com/gogo/protobuf/gogoproto"

+import pb "github.com/moby/buildkit/solver/pb"

+

+import io "io"

+

+// Reference imports to suppress errors if they are not otherwise used.

+var _ = proto.Marshal

+var _ = fmt.Errorf

+var _ = math.Inf

+

+// This is a compile-time assertion to ensure that this generated file

+// is compatible with the proto package it is being compiled against.

+// A compilation error at this line likely means your copy of the

+// proto package needs to be updated.

+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

+

+type WorkerRecord struct {

+	ID        string            `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`

+	Labels    map[string]string `protobuf:"bytes,2,rep,name=Labels" json:"Labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`

+	Platforms []pb.Platform     `protobuf:"bytes,3,rep,name=platforms" json:"platforms"`

+}

+

+func (m *WorkerRecord) Reset()                    { *m = WorkerRecord{} }

+func (m *WorkerRecord) String() string            { return proto.CompactTextString(m) }

+func (*WorkerRecord) ProtoMessage()               {}

+func (*WorkerRecord) Descriptor() ([]byte, []int) { return fileDescriptorWorker, []int{0} }

+

+func (m *WorkerRecord) GetID() string {

+	if m != nil {

+		return m.ID

+	}

+	return ""

+}

+

+func (m *WorkerRecord) GetLabels() map[string]string {

+	if m != nil {

+		return m.Labels

+	}

+	return nil

+}

+

+func (m *WorkerRecord) GetPlatforms() []pb.Platform {

+	if m != nil {

+		return m.Platforms

+	}

+	return nil

+}

+

+func init() {

+	proto.RegisterType((*WorkerRecord)(nil), "moby.buildkit.v1.types.WorkerRecord")

+}

+func (m *WorkerRecord) Marshal() (dAtA []byte, err error) {

+	size := m.Size()

+	dAtA = make([]byte, size)

+	n, err := m.MarshalTo(dAtA)

+	if err != nil {

+		return nil, err

+	}

+	return dAtA[:n], nil

+}

+

+func (m *WorkerRecord) MarshalTo(dAtA []byte) (int, error) {

+	var i int

+	_ = i

+	var l int

+	_ = l

+	if len(m.ID) > 0 {

+		dAtA[i] = 0xa

+		i++

+		i = encodeVarintWorker(dAtA, i, uint64(len(m.ID)))

+		i += copy(dAtA[i:], m.ID)

+	}

+	if len(m.Labels) > 0 {

+		for k, _ := range m.Labels {

+			dAtA[i] = 0x12

+			i++

+			v := m.Labels[k]

+			mapSize := 1 + len(k) + sovWorker(uint64(len(k))) + 1 + len(v) + sovWorker(uint64(len(v)))

+			i = encodeVarintWorker(dAtA, i, uint64(mapSize))

+			dAtA[i] = 0xa

+			i++

+			i = encodeVarintWorker(dAtA, i, uint64(len(k)))

+			i += copy(dAtA[i:], k)

+			dAtA[i] = 0x12

+			i++

+			i = encodeVarintWorker(dAtA, i, uint64(len(v)))

+			i += copy(dAtA[i:], v)

+		}

+	}

+	if len(m.Platforms) > 0 {

+		for _, msg := range m.Platforms {

+			dAtA[i] = 0x1a

+			i++

+			i = encodeVarintWorker(dAtA, i, uint64(msg.Size()))

+			n, err := msg.MarshalTo(dAtA[i:])

+			if err != nil {

+				return 0, err

+			}

+			i += n

+		}

+	}

+	return i, nil

+}

+

+func encodeVarintWorker(dAtA []byte, offset int, v uint64) int {

+	for v >= 1<<7 {

+		dAtA[offset] = uint8(v&0x7f | 0x80)

+		v >>= 7

+		offset++

+	}

+	dAtA[offset] = uint8(v)

+	return offset + 1

+}

+func (m *WorkerRecord) Size() (n int) {

+	var l int

+	_ = l

+	l = len(m.ID)

+	if l > 0 {

+		n += 1 + l + sovWorker(uint64(l))

+	}

+	if len(m.Labels) > 0 {

+		for k, v := range m.Labels {

+			_ = k

+			_ = v

+			mapEntrySize := 1 + len(k) + sovWorker(uint64(len(k))) + 1 + len(v) + sovWorker(uint64(len(v)))

+			n += mapEntrySize + 1 + sovWorker(uint64(mapEntrySize))

+		}

+	}

+	if len(m.Platforms) > 0 {

+		for _, e := range m.Platforms {

+			l = e.Size()

+			n += 1 + l + sovWorker(uint64(l))

+		}

+	}

+	return n

+}

+

+func sovWorker(x uint64) (n int) {

+	for {

+		n++

+		x >>= 7

+		if x == 0 {