@@ -28,7 +28,7 @@ import (

 	pkgprogress "github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/reference"

 	"github.com/moby/buildkit/cache"

-	gw "github.com/moby/buildkit/frontend/gateway/client"

+	"github.com/moby/buildkit/client/llb"

 	"github.com/moby/buildkit/session"

 	"github.com/moby/buildkit/session/auth"

 	"github.com/moby/buildkit/source"

@@ -150,7 +150,7 @@ func (is *imageSource) resolveRemote(ctx context.Context, ref string, platform *

 	return typed.dgst, typed.dt, nil

 }

-func (is *imageSource) ResolveImageConfig(ctx context.Context, ref string, opt gw.ResolveImageConfigOpt, sm *session.Manager) (digest.Digest, []byte, error) {

+func (is *imageSource) ResolveImageConfig(ctx context.Context, ref string, opt llb.ResolveImageConfigOpt, sm *session.Manager) (digest.Digest, []byte, error) {

 	resolveMode, err := source.ParseImageResolveMode(opt.ResolveMode)

 	if err != nil {

 		return "", nil, err

@@ -304,7 +304,7 @@ func (p *puller) resolve(ctx context.Context) error {

 				_ = resolveProgressDone(err)

 				return

 			}

-			_, dt, err := p.is.ResolveImageConfig(ctx, ref.String(), gw.ResolveImageConfigOpt{Platform: &p.platform, ResolveMode: resolveModeToString(p.src.ResolveMode)}, p.sm)

+			_, dt, err := p.is.ResolveImageConfig(ctx, ref.String(), llb.ResolveImageConfigOpt{Platform: &p.platform, ResolveMode: resolveModeToString(p.src.ResolveMode)}, p.sm)

 			if err != nil {

 				p.resolveErr = err

 				_ = resolveProgressDone(err)

@@ -23,12 +23,12 @@ import (

 	"github.com/moby/buildkit/cache"

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

 	"github.com/moby/buildkit/client"

+	"github.com/moby/buildkit/client/llb"

 	"github.com/moby/buildkit/executor"

 	"github.com/moby/buildkit/exporter"

 	localexporter "github.com/moby/buildkit/exporter/local"

 	tarexporter "github.com/moby/buildkit/exporter/tar"

 	"github.com/moby/buildkit/frontend"

-	gw "github.com/moby/buildkit/frontend/gateway/client"

 	"github.com/moby/buildkit/session"

 	"github.com/moby/buildkit/snapshot"

 	"github.com/moby/buildkit/solver"

@@ -183,7 +183,7 @@ func (w *Worker) ResolveOp(v solver.Vertex, s frontend.FrontendLLBBridge, sm *se

 }

 // ResolveImageConfig returns image config for an image

-func (w *Worker) ResolveImageConfig(ctx context.Context, ref string, opt gw.ResolveImageConfigOpt, sm *session.Manager) (digest.Digest, []byte, error) {

+func (w *Worker) ResolveImageConfig(ctx context.Context, ref string, opt llb.ResolveImageConfigOpt, sm *session.Manager) (digest.Digest, []byte, error) {

 	// ImageSource is typically source/containerimage

 	resolveImageConfig, ok := w.ImageSource.(resolveImageConfig)

 	if !ok {

@@ -477,7 +477,7 @@ func oneOffProgress(ctx context.Context, id string) func(err error) error {

 }

 type resolveImageConfig interface {

-	ResolveImageConfig(ctx context.Context, ref string, opt gw.ResolveImageConfigOpt, sm *session.Manager) (digest.Digest, []byte, error)

+	ResolveImageConfig(ctx context.Context, ref string, opt llb.ResolveImageConfigOpt, sm *session.Manager) (digest.Digest, []byte, error)

 }

 type emptyProvider struct {

@@ -26,8 +26,8 @@ github.com/imdario/mergo                            1afb36080aec31e0d1528973ebe6

 golang.org/x/sync                                   e225da77a7e68af35c70ccbf71af2b83e6acac3c

 # buildkit

-github.com/moby/buildkit                            4f4e03067523b2fc5ca2f17514a5e75ad63e02fb

-github.com/tonistiigi/fsutil                        0f039a052ca1da01626278199624b62aed9b3729

+github.com/moby/buildkit                            d75ed2b682485d4e4a35e46531230111424f8a65

+github.com/tonistiigi/fsutil                        6c909ab392c173a4264ae1bfcbc0450b9aac0c7d

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

 github.com/opentracing/opentracing-go               1361b9cd60be79c4c3a7fa9841b3c132e40066a7

 github.com/google/shlex                             e7afc7fbc51079733e9468cdfd1efcd7d196cd1d

@@ -45,7 +45,7 @@ You don't need to read this document unless you want to use the full-featured st

     - [Building a Dockerfile using external frontend:](#building-a-dockerfile-using-external-frontend)

     - [Building a Dockerfile with experimental features like `RUN --mount=type=(bind|cache|tmpfs|secret|ssh)`](#building-a-dockerfile-with-experimental-features-like-run---mounttypebindcachetmpfssecretssh)

   - [Output](#output)

-    - [Registry](#registry)

+    - [Image/Registry](#imageregistry)

     - [Local directory](#local-directory)

     - [Docker tarball](#docker-tarball)

     - [OCI tarball](#oci-tarball)

@@ -85,6 +85,7 @@ BuildKit is used by the following projects:

 -   [Rio](https://github.com/rancher/rio)

 -   [PouchContainer](https://github.com/alibaba/pouch)

 -   [Docker buildx](https://github.com/docker/buildx)

+-   [Okteto Cloud](https://okteto.com/)

 ## Quick start

@@ -94,7 +95,7 @@ BuildKit is composed of the `buildkitd` daemon and the `buildctl` client.

 While the `buildctl` client is available for Linux, macOS, and Windows, the `buildkitd` daemon is only available for Linux currently.

 The `buildkitd` daemon requires the following components to be installed:

--   [runc](https://github.com/opencontainers/runc)

+-   [runc](https://github.com/opencontainers/runc) or [crun](https://github.com/containers/crun)

 -   [containerd](https://github.com/containerd/containerd) (if you want to use containerd worker)

 The latest binaries of BuildKit are available [here](https://github.com/moby/buildkit/releases) for Linux, macOS, and Windows.

@@ -125,6 +126,11 @@ We are open to adding more backends.

 The buildkitd daemon listens gRPC API on `/run/buildkit/buildkitd.sock` by default, but you can also use TCP sockets.

 See [Expose BuildKit as a TCP service](#expose-buildkit-as-a-tcp-service).

+:information_source: Notice to Fedora 31 users:

+

+* As runc still does not work on cgroup v2 environment like Fedora 31, you need to substitute runc with crun. Run `rm -f $(which buildkit-runc) && ln -s $(which crun) /usr/local/bin/buildkit-runc` .

+* If you want to use runc, you need to configure the system to use cgroup v1. Run `sudo grubby --update-kernel=ALL --args="systemd.unified_cgroup_hierarchy=0"` and reboot.

+

 ### Exploring LLB

 BuildKit builds are based on a binary intermediate format called LLB that is used for defining the dependency graph for processes running part of your build. tl;dr: LLB is to Dockerfile what LLVM IR is to C.

@@ -193,7 +199,7 @@ See [`frontend/dockerfile/docs/experimental.md`](frontend/dockerfile/docs/experi

 By default, the build result and intermediate cache will only remain internally in BuildKit. An output needs to be specified to retrieve the result.

-#### Registry

+#### Image/Registry

 ```bash

 buildctl build ... --output type=image,name=docker.io/username/image,push=true

@@ -209,6 +215,18 @@ buildctl build ...\

   --import-cache type=registry,ref=docker.io/username/image

 ```

+Keys supported by image output:

+* `name=[value]`: image name

+* `push=true`: push after creating the image

+* `push-by-digest=true`: push unnamed image

+* `registry.insecure=true`: push to insecure HTTP registry

+* `oci-mediatypes=true`: use OCI mediatypes in configuration JSON instead of Docker's

+* `unpack=true`: unpack image after creation (for use with containerd)

+* `dangling-name-prefix=[value]`: name image with `prefix@<digest>` , used for anonymous images

+* `name-canonical=true`: add additional canonical name `name@<digest>`

+* `compression=[uncompressed,gzip]`: choose compression type for layer, gzip is default value

+

+

 If credentials are required, `buildctl` will attempt to read Docker configuration file `$DOCKER_CONFIG/config.json`.

 `$DOCKER_CONFIG` defaults to `~/.docker`.

@@ -322,14 +340,11 @@ buildctl build ... \

 ```bash

 buildctl build ... --export-cache type=local,dest=path/to/output-dir

-buildctl build ... --import-cache type=local,src=path/to/input-dir,digest=sha256:deadbeef

+buildctl build ... --import-cache type=local,src=path/to/input-dir

 ```

 The directory layout conforms to OCI Image Spec v1.0.

-Currently, you need to specify the `digest` of the manifest list to import for `local` cache importer. 

-This is planned to default to the digest of "latest" tag in `index.json` in future.

-

 #### `--export-cache` options

 -   `type`: `inline`, `registry`, or `local`

 -   `mode=min` (default): only export layers for the resulting image

@@ -341,7 +356,8 @@ This is planned to default to the digest of "latest" tag in `index.json` in futu

 -   `type`: `registry` or `local`. Use `registry` to import `inline` cache.

 -   `ref=docker.io/user/image:tag`: reference for `registry` cache importer

 -   `src=path/to/input-dir`: directory for `local` cache importer

--   `digest=sha256:deadbeef`: digest of the manifest list to import for `local` cache importer. 

+-   `digest=sha256:deadbeef`: digest of the manifest list to import for `local` cache importer.

+    Defaults to the digest of "latest" tag in `index.json`

 ### Consistent hashing

@@ -50,7 +50,7 @@ func (m *PruneRequest) Reset()         { *m = PruneRequest{} }

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

 func (*PruneRequest) ProtoMessage()    {}

 func (*PruneRequest) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{0}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{0}

 }

 func (m *PruneRequest) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -118,7 +118,7 @@ func (m *DiskUsageRequest) Reset()         { *m = DiskUsageRequest{} }

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

 func (*DiskUsageRequest) ProtoMessage()    {}

 func (*DiskUsageRequest) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{1}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{1}

 }

 func (m *DiskUsageRequest) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -165,7 +165,7 @@ func (m *DiskUsageResponse) Reset()         { *m = DiskUsageResponse{} }

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

 func (*DiskUsageResponse) ProtoMessage()    {}

 func (*DiskUsageResponse) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{2}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{2}

 }

 func (m *DiskUsageResponse) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -222,7 +222,7 @@ func (m *UsageRecord) Reset()         { *m = UsageRecord{} }

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

 func (*UsageRecord) ProtoMessage()    {}

 func (*UsageRecord) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{3}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{3}

 }

 func (m *UsageRecord) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -338,6 +338,7 @@ type SolveRequest struct {

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

 	Cache                CacheOptions                                             `protobuf:"bytes,8,opt,name=Cache,proto3" json:"Cache"`

 	Entitlements         []github_com_moby_buildkit_util_entitlements.Entitlement `protobuf:"bytes,9,rep,name=Entitlements,proto3,customtype=github.com/moby/buildkit/util/entitlements.Entitlement" json:"Entitlements,omitempty"`

+	FrontendInputs       map[string]*pb.Definition                                `protobuf:"bytes,10,rep,name=FrontendInputs,proto3" json:"FrontendInputs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`

 	XXX_NoUnkeyedLiteral struct{}                                                 `json:"-"`

 	XXX_unrecognized     []byte                                                   `json:"-"`

 	XXX_sizecache        int32                                                    `json:"-"`

@@ -347,7 +348,7 @@ func (m *SolveRequest) Reset()         { *m = SolveRequest{} }

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

 func (*SolveRequest) ProtoMessage()    {}

 func (*SolveRequest) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{4}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{4}

 }

 func (m *SolveRequest) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -432,6 +433,13 @@ func (m *SolveRequest) GetCache() CacheOptions {

 	return CacheOptions{}

 }

+func (m *SolveRequest) GetFrontendInputs() map[string]*pb.Definition {

+	if m != nil {

+		return m.FrontendInputs

+	}

+	return nil

+}

+

 type CacheOptions struct {

 	// ExportRefDeprecated is deprecated in favor or the new Exports since BuildKit v0.4.0.

 	// When ExportRefDeprecated is set, the solver appends

@@ -459,7 +467,7 @@ func (m *CacheOptions) Reset()         { *m = CacheOptions{} }

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

 func (*CacheOptions) ProtoMessage()    {}

 func (*CacheOptions) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{5}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{5}

 }

 func (m *CacheOptions) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -538,7 +546,7 @@ func (m *CacheOptionsEntry) Reset()         { *m = CacheOptionsEntry{} }

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

 func (*CacheOptionsEntry) ProtoMessage()    {}

 func (*CacheOptionsEntry) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{6}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{6}

 }

 func (m *CacheOptionsEntry) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -592,7 +600,7 @@ func (m *SolveResponse) Reset()         { *m = SolveResponse{} }

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

 func (*SolveResponse) ProtoMessage()    {}

 func (*SolveResponse) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{7}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{7}

 }

 func (m *SolveResponse) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -639,7 +647,7 @@ func (m *StatusRequest) Reset()         { *m = StatusRequest{} }

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

 func (*StatusRequest) ProtoMessage()    {}

 func (*StatusRequest) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{8}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{8}

 }

 func (m *StatusRequest) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -688,7 +696,7 @@ func (m *StatusResponse) Reset()         { *m = StatusResponse{} }

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

 func (*StatusResponse) ProtoMessage()    {}

 func (*StatusResponse) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{9}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{9}

 }

 func (m *StatusResponse) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -755,7 +763,7 @@ func (m *Vertex) Reset()         { *m = Vertex{} }

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

 func (*Vertex) ProtoMessage()    {}

 func (*Vertex) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{10}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{10}

 }

 func (m *Vertex) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -838,7 +846,7 @@ func (m *VertexStatus) Reset()         { *m = VertexStatus{} }

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

 func (*VertexStatus) ProtoMessage()    {}

 func (*VertexStatus) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{11}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{11}

 }

 func (m *VertexStatus) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -930,7 +938,7 @@ func (m *VertexLog) Reset()         { *m = VertexLog{} }

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

 func (*VertexLog) ProtoMessage()    {}

 func (*VertexLog) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{12}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{12}

 }

 func (m *VertexLog) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -991,7 +999,7 @@ func (m *BytesMessage) Reset()         { *m = BytesMessage{} }

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

 func (*BytesMessage) ProtoMessage()    {}

 func (*BytesMessage) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{13}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{13}

 }

 func (m *BytesMessage) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -1038,7 +1046,7 @@ func (m *ListWorkersRequest) Reset()         { *m = ListWorkersRequest{} }

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

 func (*ListWorkersRequest) ProtoMessage()    {}

 func (*ListWorkersRequest) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{14}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{14}

 }

 func (m *ListWorkersRequest) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -1085,7 +1093,7 @@ func (m *ListWorkersResponse) Reset()         { *m = ListWorkersResponse{} }

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

 func (*ListWorkersResponse) ProtoMessage()    {}

 func (*ListWorkersResponse) Descriptor() ([]byte, []int) {

-	return fileDescriptor_control_86d7f5d7b8f10de2, []int{15}

+	return fileDescriptor_control_7e741c2ad6bf4a8a, []int{15}

 }

 func (m *ListWorkersResponse) XXX_Unmarshal(b []byte) error {

 	return m.Unmarshal(b)

@@ -1129,6 +1137,7 @@ func init() {

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

 	proto.RegisterMapType((map[string]string)(nil), "moby.buildkit.v1.SolveRequest.ExporterAttrsEntry")

 	proto.RegisterMapType((map[string]string)(nil), "moby.buildkit.v1.SolveRequest.FrontendAttrsEntry")

+	proto.RegisterMapType((map[string]*pb.Definition)(nil), "moby.buildkit.v1.SolveRequest.FrontendInputsEntry")

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

 	proto.RegisterMapType((map[string]string)(nil), "moby.buildkit.v1.CacheOptions.ExportAttrsDeprecatedEntry")

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

@@ -1803,6 +1812,34 @@ func (m *SolveRequest) MarshalTo(dAtA []byte) (int, error) {

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

 		}

 	}

+	if len(m.FrontendInputs) > 0 {

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

+			dAtA[i] = 0x52

+			i++

+			v := m.FrontendInputs[k]

+			msgSize := 0

+			if v != nil {

+				msgSize = v.Size()

+				msgSize += 1 + sovControl(uint64(msgSize))

+			}

+			mapSize := 1 + len(k) + sovControl(uint64(len(k))) + msgSize

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

+			dAtA[i] = 0xa

+			i++

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

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

+			if v != nil {

+				dAtA[i] = 0x12

+				i++

+				i = encodeVarintControl(dAtA, i, uint64(v.Size()))

+				n5, err := v.MarshalTo(dAtA[i:])

+				if err != nil {

+					return 0, err

+				}

+				i += n5

+			}

+		}

+	}

 	if m.XXX_unrecognized != nil {

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

 	}

@@ -2114,21 +2151,21 @@ func (m *Vertex) MarshalTo(dAtA []byte) (int, error) {

 		dAtA[i] = 0x2a

 		i++

 		i = encodeVarintControl(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.Started)))

-		n5, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Started, dAtA[i:])

+		n6, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Started, dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n5

+		i += n6

 	}

 	if m.Completed != nil {

 		dAtA[i] = 0x32

 		i++

 		i = encodeVarintControl(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.Completed)))

-		n6, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Completed, dAtA[i:])

+		n7, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Completed, dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n6

+		i += n7

 	}

 	if len(m.Error) > 0 {

 		dAtA[i] = 0x3a

@@ -2188,30 +2225,30 @@ func (m *VertexStatus) MarshalTo(dAtA []byte) (int, error) {

 	dAtA[i] = 0x32

 	i++

 	i = encodeVarintControl(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)))

-	n7, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i:])

+	n8, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n7

+	i += n8

 	if m.Started != nil {

 		dAtA[i] = 0x3a

 		i++

 		i = encodeVarintControl(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.Started)))

-		n8, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Started, dAtA[i:])

+		n9, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Started, dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n8

+		i += n9

 	}

 	if m.Completed != nil {

 		dAtA[i] = 0x42

 		i++

 		i = encodeVarintControl(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.Completed)))

-		n9, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Completed, dAtA[i:])

+		n10, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Completed, dAtA[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n9

+		i += n10

 	}

 	if m.XXX_unrecognized != nil {

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

@@ -2243,11 +2280,11 @@ func (m *VertexLog) MarshalTo(dAtA []byte) (int, error) {

 	dAtA[i] = 0x12

 	i++

 	i = encodeVarintControl(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)))

-	n10, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i:])

+	n11, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n10

+	i += n11

 	if m.Stream != 0 {

 		dAtA[i] = 0x18

 		i++

@@ -2532,6 +2569,19 @@ func (m *SolveRequest) Size() (n int) {

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

 		}

 	}

+	if len(m.FrontendInputs) > 0 {

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

+			_ = k

+			_ = v

+			l = 0

+			if v != nil {

+				l = v.Size()

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

+			}

+			mapEntrySize := 1 + len(k) + sovControl(uint64(len(k))) + l

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

+		}

+	}

 	if m.XXX_unrecognized != nil {

 		n += len(m.XXX_unrecognized)

 	}

@@ -3942,6 +3992,129 @@ func (m *SolveRequest) Unmarshal(dAtA []byte) error {

 			}

 			m.Entitlements = append(m.Entitlements, github_com_moby_buildkit_util_entitlements.Entitlement(dAtA[iNdEx:postIndex]))

 			iNdEx = postIndex

+		case 10:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field FrontendInputs", 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.FrontendInputs == nil {

+				m.FrontendInputs = make(map[string]*pb.Definition)

+			}

+			var mapkey string

+			var mapvalue *pb.Definition

+			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 mapmsglen int

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

+						if shift >= 64 {

+							return ErrIntOverflowControl

+						}

+						if iNdEx >= l {

+							return io.ErrUnexpectedEOF

+						}

+						b := dAtA[iNdEx]

+						iNdEx++

+						mapmsglen |= (int(b) & 0x7F) << shift

+						if b < 0x80 {

+							break

+						}

+					}

+					if mapmsglen < 0 {

+						return ErrInvalidLengthControl

+					}

+					postmsgIndex := iNdEx + mapmsglen

+					if mapmsglen < 0 {

+						return ErrInvalidLengthControl

+					}

+					if postmsgIndex > l {

+						return io.ErrUnexpectedEOF

+					}

+					mapvalue = &pb.Definition{}

+					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {

+						return err

+					}

+					iNdEx = postmsgIndex

+				} 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.FrontendInputs[mapkey] = mapvalue

+			iNdEx = postIndex

 		default:

 			iNdEx = preIndex

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

@@ -5878,93 +6051,96 @@ var (

 	ErrIntOverflowControl   = fmt.Errorf("proto: integer overflow")

 )

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

-

-var fileDescriptor_control_86d7f5d7b8f10de2 = []byte{

-	// 1359 bytes of a gzipped FileDescriptorProto

-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4b, 0x6f, 0x1b, 0xb7,

-	0x16, 0xce, 0x48, 0xd6, 0xeb, 0x48, 0x0e, 0x1c, 0x26, 0x37, 0x18, 0xcc, 0xc5, 0xb5, 0x75, 0x27,

-	0x2d, 0x20, 0x04, 0xc9, 0xc8, 0x71, 0x9b, 0x22, 0x35, 0xda, 0x22, 0x91, 0x95, 0x22, 0x0e, 0x62,

-	0x34, 0xa0, 0x93, 0x06, 0xe8, 0xa2, 0xc0, 0x48, 0xa2, 0x95, 0x81, 0x47, 0xc3, 0x29, 0xc9, 0x71,

-	0xa3, 0xfe, 0x80, 0xae, 0xfb, 0x2f, 0xba, 0xea, 0xaa, 0x8b, 0xfe, 0x82, 0x02, 0x59, 0x76, 0x9d,

-	0x85, 0x5b, 0x64, 0xdf, 0xae, 0xba, 0xe9, 0xae, 0xe0, 0x63, 0x64, 0xca, 0x92, 0xfc, 0xca, 0x6a,

-	0x78, 0x38, 0xe7, 0xfb, 0x78, 0x5e, 0x24, 0x0f, 0x61, 0xb9, 0x4f, 0x13, 0xc1, 0x68, 0x1c, 0xa4,

-	0x8c, 0x0a, 0x8a, 0x56, 0x46, 0xb4, 0x37, 0x0e, 0x7a, 0x59, 0x14, 0x0f, 0xf6, 0x23, 0x11, 0x1c,

-	0xdc, 0xf1, 0x6e, 0x0f, 0x23, 0xf1, 0x32, 0xeb, 0x05, 0x7d, 0x3a, 0x6a, 0x0f, 0xe9, 0x90, 0xb6,

-	0x95, 0x62, 0x2f, 0xdb, 0x53, 0x92, 0x12, 0xd4, 0x48, 0x13, 0x78, 0x6b, 0x43, 0x4a, 0x87, 0x31,

-	0x39, 0xd2, 0x12, 0xd1, 0x88, 0x70, 0x11, 0x8e, 0x52, 0xa3, 0x70, 0xcb, 0xe2, 0x93, 0x8b, 0xb5,

-	0xf3, 0xc5, 0xda, 0x9c, 0xc6, 0x07, 0x84, 0xb5, 0xd3, 0x5e, 0x9b, 0xa6, 0xdc, 0x68, 0xb7, 0x17,

-	0x6a, 0x87, 0x69, 0xd4, 0x16, 0xe3, 0x94, 0xf0, 0xf6, 0xb7, 0x94, 0xed, 0x13, 0xa6, 0x01, 0xfe,

-	0xf7, 0x0e, 0x34, 0x9e, 0xb2, 0x2c, 0x21, 0x98, 0x7c, 0x93, 0x11, 0x2e, 0xd0, 0x75, 0x28, 0xef,

-	0x45, 0xb1, 0x20, 0xcc, 0x75, 0x9a, 0xc5, 0x56, 0x0d, 0x1b, 0x09, 0xad, 0x40, 0x31, 0x8c, 0x63,

-	0xb7, 0xd0, 0x74, 0x5a, 0x55, 0x2c, 0x87, 0xa8, 0x05, 0x8d, 0x7d, 0x42, 0xd2, 0x6e, 0xc6, 0x42,

-	0x11, 0xd1, 0xc4, 0x2d, 0x36, 0x9d, 0x56, 0xb1, 0xb3, 0xf4, 0xfa, 0x70, 0xcd, 0xc1, 0x53, 0x7f,

-	0x90, 0x0f, 0x35, 0x29, 0x77, 0xc6, 0x82, 0x70, 0x77, 0xc9, 0x52, 0x3b, 0x9a, 0xf6, 0x6f, 0xc2,

-	0x4a, 0x37, 0xe2, 0xfb, 0xcf, 0x79, 0x38, 0x3c, 0xcd, 0x16, 0xff, 0x31, 0x5c, 0xb1, 0x74, 0x79,

-	0x4a, 0x13, 0x4e, 0xd0, 0x5d, 0x28, 0x33, 0xd2, 0xa7, 0x6c, 0xa0, 0x94, 0xeb, 0x1b, 0xff, 0x0b,

-	0x8e, 0xe7, 0x26, 0x30, 0x00, 0xa9, 0x84, 0x8d, 0xb2, 0xff, 0x4f, 0x01, 0xea, 0xd6, 0x3c, 0xba,

-	0x0c, 0x85, 0xed, 0xae, 0xeb, 0x34, 0x9d, 0x56, 0x0d, 0x17, 0xb6, 0xbb, 0xc8, 0x85, 0xca, 0x4e,

-	0x26, 0xc2, 0x5e, 0x4c, 0x8c, 0xef, 0xb9, 0x88, 0xae, 0x41, 0x69, 0x3b, 0x79, 0xce, 0x89, 0x72,

-	0xbc, 0x8a, 0xb5, 0x80, 0x10, 0x2c, 0xed, 0x46, 0xdf, 0x11, 0xed, 0x26, 0x56, 0x63, 0xe9, 0xc7,

-	0xd3, 0x90, 0x91, 0x44, 0xb8, 0x25, 0xc5, 0x6b, 0x24, 0xd4, 0x81, 0xda, 0x16, 0x23, 0xa1, 0x20,

-	0x83, 0x07, 0xc2, 0x2d, 0x37, 0x9d, 0x56, 0x7d, 0xc3, 0x0b, 0x74, 0x41, 0x04, 0x79, 0x41, 0x04,

-	0xcf, 0xf2, 0x82, 0xe8, 0x54, 0x5f, 0x1f, 0xae, 0x5d, 0xfa, 0xe1, 0x77, 0x19, 0xb7, 0x09, 0x0c,

-	0xdd, 0x07, 0x78, 0x12, 0x72, 0xf1, 0x9c, 0x2b, 0x92, 0xca, 0xa9, 0x24, 0x4b, 0x8a, 0xc0, 0xc2,

-	0xa0, 0x55, 0x00, 0x15, 0x80, 0x2d, 0x9a, 0x25, 0xc2, 0xad, 0x2a, 0xbb, 0xad, 0x19, 0xd4, 0x84,

-	0x7a, 0x97, 0xf0, 0x3e, 0x8b, 0x52, 0x95, 0xe6, 0x9a, 0x72, 0xc1, 0x9e, 0x92, 0x0c, 0x3a, 0x7a,

-	0xcf, 0xc6, 0x29, 0x71, 0x41, 0x29, 0x58, 0x33, 0xd2, 0xff, 0xdd, 0x97, 0x21, 0x23, 0x03, 0xb7,

-	0xae, 0x42, 0x65, 0x24, 0xff, 0xef, 0x25, 0x68, 0xec, 0xca, 0x2a, 0xce, 0x13, 0xbe, 0x02, 0x45,

-	0x4c, 0xf6, 0x4c, 0xf4, 0xe5, 0x10, 0x05, 0x00, 0x5d, 0xb2, 0x17, 0x25, 0x91, 0x5a, 0xbb, 0xa0,

-	0xdc, 0xbb, 0x1c, 0xa4, 0xbd, 0xe0, 0x68, 0x16, 0x5b, 0x1a, 0xc8, 0x83, 0xea, 0xc3, 0x57, 0x29,

-	0x65, 0xb2, 0x68, 0x8a, 0x8a, 0x66, 0x22, 0xa3, 0x17, 0xb0, 0x9c, 0x8f, 0x1f, 0x08, 0xc1, 0x64,

-	0x29, 0xca, 0x42, 0xb9, 0x33, 0x5b, 0x28, 0xb6, 0x51, 0xc1, 0x14, 0xe6, 0x61, 0x22, 0xd8, 0x18,

-	0x4f, 0xf3, 0xc8, 0x1a, 0xd9, 0x25, 0x9c, 0x4b, 0x0b, 0x75, 0x82, 0x73, 0x51, 0x9a, 0xf3, 0x39,

-	0xa3, 0x89, 0x20, 0xc9, 0x40, 0x25, 0xb8, 0x86, 0x27, 0xb2, 0x34, 0x27, 0x1f, 0x6b, 0x73, 0x2a,

-	0x67, 0x32, 0x67, 0x0a, 0x63, 0xcc, 0x99, 0x9a, 0x43, 0x9b, 0x50, 0xda, 0x0a, 0xfb, 0x2f, 0x89,

-	0xca, 0x65, 0x7d, 0x63, 0x75, 0x96, 0x50, 0xfd, 0xfe, 0x42, 0x25, 0x8f, 0xab, 0xad, 0x78, 0x09,

-	0x6b, 0x08, 0xfa, 0x1a, 0x1a, 0x0f, 0x13, 0x11, 0x89, 0x98, 0x8c, 0x48, 0x22, 0xb8, 0x5b, 0x93,

-	0x1b, 0xaf, 0xb3, 0xf9, 0xe6, 0x70, 0xed, 0xa3, 0x85, 0x47, 0x4b, 0x26, 0xa2, 0xb8, 0x4d, 0x2c,

-	0x54, 0x60, 0x51, 0xe0, 0x29, 0x3e, 0xef, 0x3e, 0xa0, 0xd9, 0x78, 0xca, 0xbc, 0xef, 0x93, 0x71,

-	0x9e, 0xf7, 0x7d, 0x32, 0x96, 0x9b, 0xeb, 0x20, 0x8c, 0x33, 0xbd, 0xe9, 0x6a, 0x58, 0x0b, 0x9b,

-	0x85, 0x7b, 0x8e, 0x64, 0x98, 0x0d, 0xc1, 0x79, 0x18, 0xfc, 0x9f, 0x8a, 0xd0, 0xb0, 0x23, 0x80,

-	0xd6, 0xe1, 0xaa, 0x36, 0x0a, 0x93, 0xbd, 0x2e, 0x49, 0x19, 0xe9, 0xcb, 0xcd, 0x65, 0xc8, 0xe6,

-	0xfd, 0x42, 0x1b, 0x70, 0x6d, 0x7b, 0x64, 0xa6, 0xb9, 0x05, 0x29, 0xa8, 0x73, 0x6a, 0xee, 0x3f,

-	0x44, 0xe1, 0x3f, 0x9a, 0x4a, 0x99, 0x6d, 0x81, 0x8a, 0x2a, 0xef, 0x1f, 0x9f, 0x9c, 0xa6, 0x60,

-	0x2e, 0x56, 0xe7, 0x7f, 0x3e, 0x2f, 0xfa, 0x14, 0x2a, 0xfa, 0x47, 0x5e, 0xe9, 0x37, 0x4e, 0x5e,

-	0x42, 0x93, 0xe5, 0x18, 0x09, 0xd7, 0x7e, 0x70, 0xb7, 0x74, 0x0e, 0xb8, 0xc1, 0x78, 0x8f, 0xc0,

-	0x5b, 0x6c, 0xf2, 0xb9, 0xf2, 0xf5, 0xa3, 0x03, 0x57, 0x66, 0x16, 0x92, 0x07, 0xad, 0x3a, 0x6e,

-	0x34, 0x85, 0x1a, 0xa3, 0x2e, 0x94, 0xf4, 0x56, 0x2a, 0x28, 0x83, 0x83, 0x33, 0x18, 0x1c, 0x58,

-	0xfb, 0x48, 0x83, 0xbd, 0x7b, 0x00, 0x17, 0xac, 0xac, 0x5f, 0x1c, 0x58, 0x36, 0x9b, 0xd5, 0xdc,

-	0x4a, 0x21, 0xac, 0xe4, 0xf5, 0x9e, 0xcf, 0x99, 0xfb, 0xe9, 0xee, 0xc2, 0x7d, 0xae, 0xd5, 0x82,

-	0xe3, 0x38, 0x6d, 0xe3, 0x0c, 0x9d, 0xb7, 0x95, 0xd7, 0xd5, 0x31, 0xd5, 0x73, 0x59, 0xfe, 0x7f,

-	0x58, 0xde, 0x15, 0xa1, 0xc8, 0xf8, 0xc2, 0xa3, 0xd8, 0xff, 0xd9, 0x81, 0xcb, 0xb9, 0x8e, 0xf1,

-	0xee, 0x43, 0xa8, 0x1e, 0x10, 0x26, 0xc8, 0x2b, 0xc2, 0x8d, 0x57, 0xee, 0xac, 0x57, 0x5f, 0x2a,

-	0x0d, 0x3c, 0xd1, 0x44, 0x9b, 0x50, 0xe5, 0x8a, 0x87, 0xe4, 0x89, 0x5a, 0x5d, 0x84, 0x32, 0xeb,

-	0x4d, 0xf4, 0x51, 0x1b, 0x96, 0x62, 0x3a, 0xe4, 0x66, 0xcf, 0xfc, 0x77, 0x11, 0xee, 0x09, 0x1d,

-	0x62, 0xa5, 0xe8, 0x1f, 0x16, 0xa0, 0xac, 0xe7, 0xd0, 0x63, 0x28, 0x0f, 0xa2, 0x21, 0xe1, 0x42,

-	0x7b, 0xd5, 0xd9, 0x90, 0x07, 0xdf, 0x9b, 0xc3, 0xb5, 0x9b, 0xd6, 0xc9, 0x46, 0x53, 0x92, 0xc8,

-	0x16, 0x2f, 0x8c, 0x12, 0xc2, 0x78, 0x7b, 0x48, 0x6f, 0x6b, 0x48, 0xd0, 0x55, 0x1f, 0x6c, 0x18,

-	0x24, 0x57, 0x94, 0xa4, 0x99, 0xd0, 0x1e, 0x5c, 0x90, 0x4b, 0x33, 0xc8, 0x4a, 0x4e, 0xc2, 0x11,

-	0x31, 0xf7, 0x95, 0x1a, 0xcb, 0x2b, 0xb3, 0x2f, 0x4b, 0x75, 0xa0, 0x1a, 0x89, 0x2a, 0x36, 0x12,

-	0xda, 0x84, 0x0a, 0x17, 0x21, 0x93, 0xc7, 0x46, 0xe9, 0x8c, 0x77, 0x7d, 0x0e, 0x40, 0x9f, 0x41,

-	0xad, 0x4f, 0x47, 0x69, 0x4c, 0x24, 0xba, 0x7c, 0x46, 0xf4, 0x11, 0x44, 0x56, 0x0f, 0x61, 0x8c,

-	0x32, 0xd5, 0x65, 0xd4, 0xb0, 0x16, 0xfc, 0xbf, 0x0a, 0xd0, 0xb0, 0x93, 0x35, 0xd3, 0x41, 0x3d,

-	0x86, 0xb2, 0x4e, 0xbd, 0xae, 0xba, 0x8b, 0x85, 0x4a, 0x33, 0xcc, 0x0d, 0x95, 0x0b, 0x95, 0x7e,

-	0xc6, 0x54, 0x7b, 0xa5, 0x9b, 0xae, 0x5c, 0x94, 0x06, 0x0b, 0x2a, 0xc2, 0x58, 0x85, 0xaa, 0x88,

-	0xb5, 0x20, 0xbb, 0xae, 0x49, 0x93, 0x7d, 0xbe, 0xae, 0x6b, 0x02, 0xb3, 0xd3, 0x50, 0x79, 0xa7,

-	0x34, 0x54, 0xcf, 0x9d, 0x06, 0xff, 0x57, 0x07, 0x6a, 0x93, 0x2a, 0xb7, 0xa2, 0xeb, 0xbc, 0x73,

-	0x74, 0xa7, 0x22, 0x53, 0xb8, 0x58, 0x64, 0xae, 0x43, 0x99, 0x0b, 0x46, 0xc2, 0x91, 0x7e, 0x0f,

-	0x60, 0x23, 0xc9, 0xf3, 0x64, 0xc4, 0x87, 0x2a, 0x43, 0x0d, 0x2c, 0x87, 0xbe, 0x0f, 0x0d, 0xd5,

-	0xfa, 0xef, 0x10, 0x2e, 0x9b, 0x4d, 0x99, 0xdb, 0x41, 0x28, 0x42, 0xe5, 0x47, 0x03, 0xab, 0xb1,

-	0x7f, 0x0b, 0xd0, 0x93, 0x88, 0x8b, 0x17, 0xea, 0xc9, 0xc2, 0x4f, 0x7b, 0x17, 0xec, 0xc2, 0xd5,

-	0x29, 0x6d, 0x73, 0x4a, 0x7d, 0x72, 0xec, 0x65, 0xf0, 0xde, 0xec, 0xa9, 0xa1, 0x5e, 0x46, 0x81,

-	0x06, 0x4e, 0x3f, 0x10, 0x36, 0xfe, 0x2c, 0x42, 0x65, 0x4b, 0x3f, 0xfa, 0xd0, 0x33, 0xa8, 0x4d,

-	0x1e, 0x1e, 0xc8, 0x9f, 0xa5, 0x39, 0xfe, 0x82, 0xf1, 0x6e, 0x9c, 0xa8, 0x63, 0xec, 0x7b, 0x04,

-	0x25, 0xf5, 0x04, 0x43, 0x73, 0x8e, 0x41, 0xfb, 0x6d, 0xe6, 0x9d, 0xfc, 0xa4, 0x59, 0x77, 0x24,

-	0x93, 0xba, 0x43, 0xe6, 0x31, 0xd9, 0x4d, 0xa4, 0xb7, 0x76, 0xca, 0xe5, 0x83, 0x76, 0xa0, 0x6c,

-	0xb6, 0xf3, 0x3c, 0x55, 0xfb, 0xa6, 0xf0, 0x9a, 0x8b, 0x15, 0x34, 0xd9, 0xba, 0x83, 0x76, 0x26,

-	0x1d, 0xf2, 0x3c, 0xd3, 0xec, 0x32, 0xf0, 0x4e, 0xf9, 0xdf, 0x72, 0xd6, 0x1d, 0xf4, 0x15, 0xd4,

-	0xad, 0x44, 0xa3, 0x39, 0x09, 0x9d, 0xad, 0x1a, 0xef, 0xfd, 0x53, 0xb4, 0xb4, 0xb1, 0x9d, 0xc6,

-	0xeb, 0xb7, 0xab, 0xce, 0x6f, 0x6f, 0x57, 0x9d, 0x3f, 0xde, 0xae, 0x3a, 0xbd, 0xb2, 0xaa, 0xfb,

-	0x0f, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xd3, 0x7a, 0xbe, 0x54, 0xf8, 0x0f, 0x00, 0x00,

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

+

+var fileDescriptor_control_7e741c2ad6bf4a8a = []byte{

+	// 1397 bytes of a gzipped FileDescriptorProto

+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4d, 0x6f, 0x1b, 0xc5,

+	0x1b, 0xef, 0xda, 0xf1, 0xdb, 0x63, 0x27, 0x4a, 0xa7, 0xfd, 0x57, 0xab, 0xfd, 0x8b, 0xc4, 0x6c,

+	0x8b, 0x64, 0x55, 0xed, 0x3a, 0x35, 0x14, 0x95, 0x08, 0x50, 0xeb, 0xb8, 0xa8, 0xa9, 0x1a, 0x51,

+	0x36, 0x2d, 0x95, 0x7a, 0x40, 0x5a, 0xdb, 0x13, 0x77, 0x95, 0xf5, 0xce, 0x32, 0x33, 0x1b, 0x6a,

+	0x3e, 0x00, 0x67, 0xbe, 0x03, 0x07, 0x4e, 0x9c, 0x38, 0xf0, 0x09, 0x90, 0x7a, 0xe4, 0xdc, 0x43,

+	0x40, 0xb9, 0xc3, 0x9d, 0x1b, 0x9a, 0x97, 0x75, 0xc6, 0xb1, 0x9d, 0xc4, 0xe9, 0xc9, 0xf3, 0x8c,

+	0x9f, 0xdf, 0x6f, 0x9f, 0xd7, 0x99, 0x79, 0x60, 0xb9, 0x47, 0x62, 0x4e, 0x49, 0xe4, 0x25, 0x94,

+	0x70, 0x82, 0x56, 0x87, 0xa4, 0x3b, 0xf2, 0xba, 0x69, 0x18, 0xf5, 0xf7, 0x43, 0xee, 0x1d, 0xdc,

+	0x71, 0x6e, 0x0f, 0x42, 0xfe, 0x2a, 0xed, 0x7a, 0x3d, 0x32, 0x6c, 0x0e, 0xc8, 0x80, 0x34, 0xa5,

+	0x62, 0x37, 0xdd, 0x93, 0x92, 0x14, 0xe4, 0x4a, 0x11, 0x38, 0xeb, 0x03, 0x42, 0x06, 0x11, 0x3e,

+	0xd6, 0xe2, 0xe1, 0x10, 0x33, 0x1e, 0x0c, 0x13, 0xad, 0x70, 0xcb, 0xe0, 0x13, 0x1f, 0x6b, 0x66,

+	0x1f, 0x6b, 0x32, 0x12, 0x1d, 0x60, 0xda, 0x4c, 0xba, 0x4d, 0x92, 0x30, 0xad, 0xdd, 0x9c, 0xab,

+	0x1d, 0x24, 0x61, 0x93, 0x8f, 0x12, 0xcc, 0x9a, 0xdf, 0x11, 0xba, 0x8f, 0xa9, 0x02, 0xb8, 0x3f,

+	0x58, 0x50, 0x7b, 0x4a, 0xd3, 0x18, 0xfb, 0xf8, 0xdb, 0x14, 0x33, 0x8e, 0xae, 0x41, 0x71, 0x2f,

+	0x8c, 0x38, 0xa6, 0xb6, 0x55, 0xcf, 0x37, 0x2a, 0xbe, 0x96, 0xd0, 0x2a, 0xe4, 0x83, 0x28, 0xb2,

+	0x73, 0x75, 0xab, 0x51, 0xf6, 0xc5, 0x12, 0x35, 0xa0, 0xb6, 0x8f, 0x71, 0xd2, 0x49, 0x69, 0xc0,

+	0x43, 0x12, 0xdb, 0xf9, 0xba, 0xd5, 0xc8, 0xb7, 0x97, 0xde, 0x1c, 0xae, 0x5b, 0xfe, 0xc4, 0x3f,

+	0xc8, 0x85, 0x8a, 0x90, 0xdb, 0x23, 0x8e, 0x99, 0xbd, 0x64, 0xa8, 0x1d, 0x6f, 0xbb, 0x37, 0x61,

+	0xb5, 0x13, 0xb2, 0xfd, 0xe7, 0x2c, 0x18, 0x9c, 0x65, 0x8b, 0xfb, 0x18, 0x2e, 0x1b, 0xba, 0x2c,

+	0x21, 0x31, 0xc3, 0xe8, 0x2e, 0x14, 0x29, 0xee, 0x11, 0xda, 0x97, 0xca, 0xd5, 0xd6, 0x7b, 0xde,

+	0xc9, 0xdc, 0x78, 0x1a, 0x20, 0x94, 0x7c, 0xad, 0xec, 0xfe, 0x9b, 0x83, 0xaa, 0xb1, 0x8f, 0x56,

+	0x20, 0xb7, 0xdd, 0xb1, 0xad, 0xba, 0xd5, 0xa8, 0xf8, 0xb9, 0xed, 0x0e, 0xb2, 0xa1, 0xb4, 0x93,

+	0xf2, 0xa0, 0x1b, 0x61, 0xed, 0x7b, 0x26, 0xa2, 0xab, 0x50, 0xd8, 0x8e, 0x9f, 0x33, 0x2c, 0x1d,

+	0x2f, 0xfb, 0x4a, 0x40, 0x08, 0x96, 0x76, 0xc3, 0xef, 0xb1, 0x72, 0xd3, 0x97, 0x6b, 0xe1, 0xc7,

+	0xd3, 0x80, 0xe2, 0x98, 0xdb, 0x05, 0xc9, 0xab, 0x25, 0xd4, 0x86, 0xca, 0x16, 0xc5, 0x01, 0xc7,

+	0xfd, 0x07, 0xdc, 0x2e, 0xd6, 0xad, 0x46, 0xb5, 0xe5, 0x78, 0xaa, 0x20, 0xbc, 0xac, 0x20, 0xbc,

+	0x67, 0x59, 0x41, 0xb4, 0xcb, 0x6f, 0x0e, 0xd7, 0x2f, 0xfd, 0xf8, 0xa7, 0x88, 0xdb, 0x18, 0x86,

+	0xee, 0x03, 0x3c, 0x09, 0x18, 0x7f, 0xce, 0x24, 0x49, 0xe9, 0x4c, 0x92, 0x25, 0x49, 0x60, 0x60,

+	0xd0, 0x1a, 0x80, 0x0c, 0xc0, 0x16, 0x49, 0x63, 0x6e, 0x97, 0xa5, 0xdd, 0xc6, 0x0e, 0xaa, 0x43,

+	0xb5, 0x83, 0x59, 0x8f, 0x86, 0x89, 0x4c, 0x73, 0x45, 0xba, 0x60, 0x6e, 0x09, 0x06, 0x15, 0xbd,

+	0x67, 0xa3, 0x04, 0xdb, 0x20, 0x15, 0x8c, 0x1d, 0xe1, 0xff, 0xee, 0xab, 0x80, 0xe2, 0xbe, 0x5d,

+	0x95, 0xa1, 0xd2, 0x92, 0xfb, 0x53, 0x11, 0x6a, 0xbb, 0xa2, 0x8a, 0xb3, 0x84, 0xaf, 0x42, 0xde,

+	0xc7, 0x7b, 0x3a, 0xfa, 0x62, 0x89, 0x3c, 0x80, 0x0e, 0xde, 0x0b, 0xe3, 0x50, 0x7e, 0x3b, 0x27,

+	0xdd, 0x5b, 0xf1, 0x92, 0xae, 0x77, 0xbc, 0xeb, 0x1b, 0x1a, 0xc8, 0x81, 0xf2, 0xc3, 0xd7, 0x09,

+	0xa1, 0xa2, 0x68, 0xf2, 0x92, 0x66, 0x2c, 0xa3, 0x17, 0xb0, 0x9c, 0xad, 0x1f, 0x70, 0x4e, 0x45,

+	0x29, 0x8a, 0x42, 0xb9, 0x33, 0x5d, 0x28, 0xa6, 0x51, 0xde, 0x04, 0xe6, 0x61, 0xcc, 0xe9, 0xc8,

+	0x9f, 0xe4, 0x11, 0x35, 0xb2, 0x8b, 0x19, 0x13, 0x16, 0xaa, 0x04, 0x67, 0xa2, 0x30, 0xe7, 0x0b,

+	0x4a, 0x62, 0x8e, 0xe3, 0xbe, 0x4c, 0x70, 0xc5, 0x1f, 0xcb, 0xc2, 0x9c, 0x6c, 0xad, 0xcc, 0x29,

+	0x9d, 0xcb, 0x9c, 0x09, 0x8c, 0x36, 0x67, 0x62, 0x0f, 0x6d, 0x42, 0x61, 0x2b, 0xe8, 0xbd, 0xc2,

+	0x32, 0x97, 0xd5, 0xd6, 0xda, 0x34, 0xa1, 0xfc, 0xfb, 0x4b, 0x99, 0x3c, 0x26, 0x5b, 0xf1, 0x92,

+	0xaf, 0x20, 0xe8, 0x1b, 0xa8, 0x3d, 0x8c, 0x79, 0xc8, 0x23, 0x3c, 0xc4, 0x31, 0x67, 0x76, 0x45,

+	0x34, 0x5e, 0x7b, 0xf3, 0xed, 0xe1, 0xfa, 0xc7, 0x73, 0x8f, 0x96, 0x94, 0x87, 0x51, 0x13, 0x1b,

+	0x28, 0xcf, 0xa0, 0xf0, 0x27, 0xf8, 0xd0, 0x4b, 0x58, 0xc9, 0x8c, 0xdd, 0x8e, 0x93, 0x94, 0x33,

+	0x1b, 0xa4, 0xd7, 0xad, 0x73, 0x7a, 0xad, 0x40, 0xca, 0xed, 0x13, 0x4c, 0xce, 0x7d, 0x40, 0xd3,

+	0xb9, 0x12, 0x35, 0xb5, 0x8f, 0x47, 0x59, 0x4d, 0xed, 0xe3, 0x91, 0x68, 0xdc, 0x83, 0x20, 0x4a,

+	0x55, 0x43, 0x57, 0x7c, 0x25, 0x6c, 0xe6, 0xee, 0x59, 0x82, 0x61, 0x3a, 0xbc, 0x0b, 0x31, 0x7c,

+	0x05, 0x57, 0x66, 0x98, 0x3a, 0x83, 0xe2, 0x86, 0x49, 0x31, 0x5d, 0xd3, 0xc7, 0x94, 0xee, 0x2f,

+	0x79, 0xa8, 0x99, 0x09, 0x43, 0x1b, 0x70, 0x45, 0xf9, 0xe9, 0xe3, 0xbd, 0x0e, 0x4e, 0x28, 0xee,

+	0x89, 0xb3, 0x40, 0x93, 0xcf, 0xfa, 0x0b, 0xb5, 0xe0, 0xea, 0xf6, 0x50, 0x6f, 0x33, 0x03, 0x92,

+	0x93, 0xc7, 0xea, 0xcc, 0xff, 0x10, 0x81, 0xff, 0x29, 0x2a, 0x19, 0x09, 0x03, 0x94, 0x97, 0x09,

+	0xfb, 0xe4, 0xf4, 0xaa, 0xf2, 0x66, 0x62, 0x55, 0xde, 0x66, 0xf3, 0xa2, 0xcf, 0xa0, 0xa4, 0xfe,

+	0xc8, 0x1a, 0xf3, 0xfa, 0xe9, 0x9f, 0x50, 0x64, 0x19, 0x46, 0xc0, 0x95, 0x1f, 0xcc, 0x2e, 0x2c,

+	0x00, 0xd7, 0x18, 0xe7, 0x11, 0x38, 0xf3, 0x4d, 0x5e, 0xa4, 0x04, 0xdc, 0x9f, 0x2d, 0xb8, 0x3c,

+	0xf5, 0x21, 0x71, 0x2f, 0xc8, 0xd3, 0x51, 0x51, 0xc8, 0x35, 0xea, 0x40, 0x41, 0x75, 0x7e, 0x4e,

+	0x1a, 0xec, 0x9d, 0xc3, 0x60, 0xcf, 0x68, 0x7b, 0x05, 0x76, 0xee, 0x01, 0x5c, 0xac, 0x58, 0xdd,

+	0xdf, 0x2c, 0x58, 0xd6, 0x5d, 0xa6, 0x2f, 0xd1, 0x00, 0x56, 0xb3, 0x16, 0xca, 0xf6, 0xf4, 0x75,

+	0x7a, 0x77, 0x6e, 0x83, 0x2a, 0x35, 0xef, 0x24, 0x4e, 0xd9, 0x38, 0x45, 0xe7, 0x6c, 0x65, 0x75,

+	0x75, 0x42, 0x75, 0x21, 0xcb, 0xdf, 0x87, 0xe5, 0x5d, 0x1e, 0xf0, 0x94, 0xcd, 0xbd, 0x39, 0xdc,

+	0x5f, 0x2d, 0x58, 0xc9, 0x74, 0xb4, 0x77, 0x1f, 0x41, 0xf9, 0x00, 0x53, 0x8e, 0x5f, 0x63, 0xa6,

+	0xbd, 0xb2, 0xa7, 0xbd, 0xfa, 0x5a, 0x6a, 0xf8, 0x63, 0x4d, 0xb4, 0x09, 0x65, 0x26, 0x79, 0x70,

+	0x96, 0xa8, 0xb5, 0x79, 0x28, 0xfd, 0xbd, 0xb1, 0x3e, 0x6a, 0xc2, 0x52, 0x44, 0x06, 0x4c, 0xf7,

+	0xcc, 0xff, 0xe7, 0xe1, 0x9e, 0x90, 0x81, 0x2f, 0x15, 0xdd, 0xc3, 0x1c, 0x14, 0xd5, 0x1e, 0x7a,

+	0x0c, 0xc5, 0x7e, 0x38, 0xc0, 0x8c, 0x2b, 0xaf, 0xda, 0x2d, 0x71, 0x4e, 0xbf, 0x3d, 0x5c, 0xbf,

+	0x69, 0x1c, 0xc4, 0x24, 0xc1, 0xb1, 0x78, 0x91, 0x06, 0x61, 0x8c, 0x29, 0x6b, 0x0e, 0xc8, 0x6d,

+	0x05, 0xf1, 0x3a, 0xf2, 0xc7, 0xd7, 0x0c, 0x82, 0x2b, 0x54, 0xc7, 0xad, 0x6c, 0xf9, 0x8b, 0x71,

+	0x29, 0x06, 0x51, 0xc9, 0x71, 0x30, 0xc4, 0xfa, 0x7a, 0x95, 0x6b, 0x71, 0xc3, 0xf7, 0x44, 0xa9,

+	0xf6, 0xe5, 0xbb, 0xa7, 0xec, 0x6b, 0x09, 0x6d, 0x42, 0x89, 0xf1, 0x80, 0x8a, 0x63, 0xa3, 0x70,

+	0xce, 0xa7, 0x49, 0x06, 0x40, 0x9f, 0x43, 0xa5, 0x47, 0x86, 0x49, 0x84, 0x05, 0xba, 0x78, 0x4e,

+	0xf4, 0x31, 0x44, 0x54, 0x0f, 0xa6, 0x94, 0x50, 0xf9, 0x28, 0xaa, 0xf8, 0x4a, 0x70, 0xff, 0xc9,

+	0x41, 0xcd, 0x4c, 0xd6, 0xd4, 0x83, 0xef, 0x31, 0x14, 0x55, 0xea, 0x55, 0xd5, 0x5d, 0x2c, 0x54,

+	0x8a, 0x61, 0x66, 0xa8, 0x6c, 0x28, 0xf5, 0x52, 0x2a, 0x5f, 0x83, 0xea, 0x8d, 0x98, 0x89, 0xc2,

+	0x60, 0x4e, 0x78, 0x10, 0xc9, 0x50, 0xe5, 0x7d, 0x25, 0x88, 0x47, 0xe2, 0x78, 0x26, 0x58, 0xec,

+	0x91, 0x38, 0x86, 0x99, 0x69, 0x28, 0xbd, 0x53, 0x1a, 0xca, 0x0b, 0xa7, 0xc1, 0xfd, 0xdd, 0x82,

+	0xca, 0xb8, 0xca, 0x8d, 0xe8, 0x5a, 0xef, 0x1c, 0xdd, 0x89, 0xc8, 0xe4, 0x2e, 0x16, 0x99, 0x6b,

+	0x50, 0x64, 0x9c, 0xe2, 0x60, 0xa8, 0xc6, 0x17, 0x5f, 0x4b, 0xe2, 0x3c, 0x19, 0xb2, 0x81, 0xcc,

+	0x50, 0xcd, 0x17, 0x4b, 0xd7, 0x85, 0x9a, 0x9c, 0x54, 0x76, 0x30, 0x13, 0x6f, 0x63, 0x91, 0xdb,

+	0x7e, 0xc0, 0x03, 0xe9, 0x47, 0xcd, 0x97, 0x6b, 0xf7, 0x16, 0xa0, 0x27, 0x21, 0xe3, 0x2f, 0xe4,

+	0x84, 0xc5, 0xce, 0x1a, 0x63, 0x76, 0xe1, 0xca, 0x84, 0xb6, 0x3e, 0xa5, 0x3e, 0x3d, 0x31, 0xc8,

+	0xdc, 0x98, 0x3e, 0x35, 0xe4, 0x20, 0xe7, 0x29, 0xe0, 0xe4, 0x3c, 0xd3, 0xfa, 0x3b, 0x0f, 0xa5,

+	0x2d, 0x35, 0xa3, 0xa2, 0x67, 0x50, 0x19, 0xcf, 0x49, 0xc8, 0x9d, 0xa6, 0x39, 0x39, 0x70, 0x39,

+	0xd7, 0x4f, 0xd5, 0xd1, 0xf6, 0x3d, 0x82, 0x82, 0x9c, 0x18, 0xd1, 0x8c, 0x63, 0xd0, 0x1c, 0x25,

+	0x9d, 0xd3, 0x27, 0xb0, 0x0d, 0x4b, 0x30, 0xc9, 0x3b, 0x64, 0x16, 0x93, 0xf9, 0xfa, 0x73, 0xd6,

+	0xcf, 0xb8, 0x7c, 0xd0, 0x0e, 0x14, 0x75, 0x3b, 0xcf, 0x52, 0x35, 0x6f, 0x0a, 0xa7, 0x3e, 0x5f,

+	0x41, 0x91, 0x6d, 0x58, 0x68, 0x67, 0xfc, 0xa0, 0x9f, 0x65, 0x9a, 0x59, 0x06, 0xce, 0x19, 0xff,

+	0x37, 0xac, 0x0d, 0x0b, 0xbd, 0x84, 0xaa, 0x91, 0x68, 0x34, 0x23, 0xa1, 0xd3, 0x55, 0xe3, 0x7c,

+	0x70, 0x86, 0x96, 0x32, 0xb6, 0x5d, 0x7b, 0x73, 0xb4, 0x66, 0xfd, 0x71, 0xb4, 0x66, 0xfd, 0x75,

+	0xb4, 0x66, 0x75, 0x8b, 0xb2, 0xee, 0x3f, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x65, 0x7c,

+	0xd6, 0xa7, 0x10, 0x00, 0x00,

 }

@@ -63,6 +63,7 @@ message SolveRequest {

 	map<string, string> FrontendAttrs = 7;

 	CacheOptions Cache = 8 [(gogoproto.nullable) = false];

 	repeated string Entitlements = 9 [(gogoproto.customtype) = "github.com/moby/buildkit/util/entitlements.Entitlement" ];

+	map<string, pb.Definition> FrontendInputs = 10;

 }

 message CacheOptions {

@@ -111,7 +111,7 @@ func (cm *cacheManager) GetByBlob(ctx context.Context, desc ocispec.Descriptor,

 	if parent != nil {

 		pInfo := parent.Info()

 		if pInfo.ChainID == "" || pInfo.BlobChainID == "" {

-			return nil, errors.Errorf("failed to get ref by blob on non-adressable parent")

+			return nil, errors.Errorf("failed to get ref by blob on non-addressable parent")

 		}

 		chainID = imagespecidentity.ChainID([]digest.Digest{pInfo.ChainID, chainID})

 		blobChainID = imagespecidentity.ChainID([]digest.Digest{pInfo.BlobChainID, blobChainID})

@@ -254,7 +254,10 @@ func (cr *cacheRecord) Mount(ctx context.Context, readonly bool) (snapshot.Mount

 func (cr *cacheRecord) remove(ctx context.Context, removeSnapshot bool) error {

 	delete(cr.cm.records, cr.ID())

 	if cr.parent != nil {

-		if err := cr.parent.release(ctx); err != nil {

+		cr.parent.mu.Lock()

+		err := cr.parent.release(ctx)

+		cr.parent.mu.Unlock()

+		if err != nil {

 			return err

 		}

 	}

@@ -103,3 +103,8 @@ func (g *gatewayClientForBuild) Return(ctx context.Context, in *gatewayapi.Retur

 	ctx = buildid.AppendToOutgoingContext(ctx, g.buildID)

 	return g.gateway.Return(ctx, in, opts...)

 }

+

+func (g *gatewayClientForBuild) Inputs(ctx context.Context, in *gatewayapi.InputsRequest, opts ...grpc.CallOption) (*gatewayapi.InputsResponse, error) {

+	ctx = buildid.AppendToOutgoingContext(ctx, g.buildID)

+	return g.gateway.Inputs(ctx, in, opts...)

+}

new file mode 100644

@@ -0,0 +1,161 @@

+package llb

+

+import (

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

+	digest "github.com/opencontainers/go-digest"

+	specs "github.com/opencontainers/image-spec/specs-go/v1"

+	"github.com/pkg/errors"

+)

+

+// DefinitionOp implements llb.Vertex using a marshalled definition.

+//

+// For example, after marshalling a LLB state and sending over the wire, the

+// LLB state can be reconstructed from the definition.

+type DefinitionOp struct {

+	MarshalCache

+	ops       map[digest.Digest]*pb.Op

+	defs      map[digest.Digest][]byte

+	metas     map[digest.Digest]pb.OpMetadata

+	platforms map[digest.Digest]*specs.Platform

+	dgst      digest.Digest

+	index     pb.OutputIndex

+}

+

+// NewDefinitionOp returns a new operation from a marshalled definition.

+func NewDefinitionOp(def *pb.Definition) (*DefinitionOp, error) {

+	ops := make(map[digest.Digest]*pb.Op)

+	defs := make(map[digest.Digest][]byte)

+

+	var dgst digest.Digest

+	for _, dt := range def.Def {

+		var op pb.Op

+		if err := (&op).Unmarshal(dt); err != nil {

+			return nil, errors.Wrap(err, "failed to parse llb proto op")

+		}

+		dgst = digest.FromBytes(dt)

+		ops[dgst] = &op

+		defs[dgst] = dt

+	}

+

+	var index pb.OutputIndex