gen

type ActiveVM struct {
	VmId        string  `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"`
	TenantId    string  `protobuf:"bytes,2,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	ImageDigest string  `protobuf:"bytes,3,opt,name=image_digest,json=imageDigest,proto3" json:"image_digest,omitempty"`
	State       VMState `protobuf:"varint,4,opt,name=state,proto3,enum=protocol.VMState" json:"state,omitempty"`
	// contains filtered or unexported fields
}

type AuditRecord struct {
	TenantId     string   `protobuf:"bytes,1,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	SchedulerId  string   `protobuf:"bytes,2,opt,name=scheduler_id,json=schedulerId,proto3" json:"scheduler_id,omitempty"`
	WorkerId     string   `protobuf:"bytes,3,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
	VmId         string   `protobuf:"bytes,4,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"`
	ImageDigest  string   `protobuf:"bytes,5,opt,name=image_digest,json=imageDigest,proto3" json:"image_digest,omitempty"`
	SourceDigest []byte   `protobuf:"bytes,6,opt,name=source_digest,json=sourceDigest,proto3" json:"source_digest,omitempty"`
	OutputDigest []byte   `protobuf:"bytes,7,opt,name=output_digest,json=outputDigest,proto3" json:"output_digest,omitempty"`
	CacheKey     string   `protobuf:"bytes,8,opt,name=cache_key,json=cacheKey,proto3" json:"cache_key,omitempty"`
	Flags        []string `protobuf:"bytes,9,rep,name=flags,proto3" json:"flags,omitempty"`
	ExitCode     int32    `protobuf:"varint,10,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	DurationMs   int64    `protobuf:"varint,11,opt,name=duration_ms,json=durationMs,proto3" json:"duration_ms,omitempty"`
	Timestamp    int64    `protobuf:"varint,12,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// contains filtered or unexported fields
}

type AuthRequest struct {

	// tenant_id selects which tenant's IdP the scheduler validates the
	// JWT against. Required for jwt_token; ignored for static_token
	// (workers are tenant-agnostic at the auth layer). Carried in the
	// request rather than as a JWT claim so that an IdP configured for
	// tenant A is never asked to validate a token labeled as tenant B —
	// see docs/plan/multi-tenant.md "Threat model".
	TenantId string `protobuf:"bytes,3,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	// Types that are valid to be assigned to Token:
	//
	//	*AuthRequest_JwtToken
	//	*AuthRequest_StaticToken
	Token isAuthRequest_Token `protobuf_oneof:"token"`
	// contains filtered or unexported fields
}

type AuthRequest_JwtToken struct {
	JwtToken string `protobuf:"bytes,1,opt,name=jwt_token,json=jwtToken,proto3,oneof"`
}

type AuthRequest_StaticToken struct {
	StaticToken string `protobuf:"bytes,2,opt,name=static_token,json=staticToken,proto3,oneof"`
}

type AuthResponse struct {
	Success          bool   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	SessionToken     string `protobuf:"bytes,2,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`                     // pass as "session-token" gRPC metadata on subsequent calls
	SigningPublicKey []byte `protobuf:"bytes,3,opt,name=signing_public_key,json=signingPublicKey,proto3,oneof" json:"signing_public_key,omitempty"` // scheduler's public key for verifying task JWTs (workers only)
	// contains filtered or unexported fields
}

type BlobChunk struct {

	// First message in a per-blob run carries the header; subsequent
	// messages carry data only. The worker tracks the active blob via
	// stream state, opens a BLAKE3 hasher on header, and finalises on
	// the next header (or stream close).
	//
	// Types that are valid to be assigned to Body:
	//
	//	*BlobChunk_Header
	//	*BlobChunk_Data
	Body isBlobChunk_Body `protobuf_oneof:"body"`
	// contains filtered or unexported fields
}

type BlobChunk_Data struct {
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3,oneof"`
}

type BlobChunk_Header struct {
	Header *BlobDigest `protobuf:"bytes,1,opt,name=header,proto3,oneof"` // digest the client claims; worker recomputes and verifies
}

type BlobDigest struct {
	Digest []byte `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	Size   uint64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	// tenant_id scopes the source-store namespace this blob lives in,
	// and is cross-checked against scheduler_token's tenant claim by
	// the worker. Required on every header.
	TenantId string `protobuf:"bytes,3,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	// scheduler_token is the short-lived per-route JWT the scheduler
	// issued when the client called Route. Worker verifies it against
	// the scheduler pubkey (already hydrated at RegisterWorker) and
	// refuses the stream if tenant_id, image_digest, or worker_id
	// don't match. Required on every header — repeated rather than
	// stream-init because gRPC bidi streams have no first-message
	// contract enforced by the runtime. See docs/plan/multi-tenant.md
	// "Worker enforcement".
	SchedulerToken string `protobuf:"bytes,4,opt,name=scheduler_token,json=schedulerToken,proto3" json:"scheduler_token,omitempty"`
	// contains filtered or unexported fields
}

type BlobRef struct {
	Digest []byte `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"` // BLAKE3-256 of the file's bytes
	Path   string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`     // materialization path inside the source root (validated for traversal at apply time)
	Size   uint64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`    // size in bytes; advisory, worker re-checks on fetch
	// contains filtered or unexported fields
}

type CasDescriptor struct {
	ManifestDigest []byte     `protobuf:"bytes,1,opt,name=manifest_digest,json=manifestDigest,proto3" json:"manifest_digest,omitempty"` // BLAKE3-256 of the path-sorted (path, blob.digest) list
	Blobs          []*BlobRef `protobuf:"bytes,2,rep,name=blobs,proto3" json:"blobs,omitempty"`
	EntryPath      string     `protobuf:"bytes,3,opt,name=entry_path,json=entryPath,proto3" json:"entry_path,omitempty"` // which blob is the translation-unit root
	// contains filtered or unexported fields
}

type CompileProbe struct {
	ManifestDigest []byte   `protobuf:"bytes,1,opt,name=manifest_digest,json=manifestDigest,proto3" json:"manifest_digest,omitempty"`
	Args           []string `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"` // worker derives flag-key from these
	TenantId       string   `protobuf:"bytes,3,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	ImageDigest    string   `protobuf:"bytes,4,opt,name=image_digest,json=imageDigest,proto3" json:"image_digest,omitempty"`
	SchedulerToken string   `protobuf:"bytes,5,opt,name=scheduler_token,json=schedulerToken,proto3" json:"scheduler_token,omitempty"`
	// contains filtered or unexported fields
}

type CompileRequest struct {
	Cwd  string   `protobuf:"bytes,1,opt,name=cwd,proto3" json:"cwd,omitempty"`
	Args []string `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
	// For remote compilation only
	Descriptor_ *RemoteDescriptor `protobuf:"bytes,3,opt,name=descriptor,proto3,oneof" json:"descriptor,omitempty"`
	// contains filtered or unexported fields
}

type CompileResponse struct {
	ExitCode int32  `protobuf:"varint,1,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	Stdout   []byte `protobuf:"bytes,2,opt,name=stdout,proto3" json:"stdout,omitempty"`
	Stderr   []byte `protobuf:"bytes,3,opt,name=stderr,proto3" json:"stderr,omitempty"`
	// For remote compilation only
	OutputArtifact []byte       `protobuf:"bytes,4,opt,name=output_artifact,json=outputArtifact,proto3,oneof" json:"output_artifact,omitempty"`
	CacheKey       *string      `protobuf:"bytes,5,opt,name=cache_key,json=cacheKey,proto3,oneof" json:"cache_key,omitempty"`
	Audit          *AuditRecord `protobuf:"bytes,6,opt,name=audit,proto3,oneof" json:"audit,omitempty"`
	// Side-effect output files the compile produced besides the primary
	// `-o` artifact — typically `.d` files written by `-Wp,-MMD,<path>`
	// / `-MF <path>` for the Make-style dep tracking the kernel build
	// depends on for incremental builds. Keys are paths relative to
	// the per-RPC output staging dir (`/out` in-container); the client
	// writes each back to the corresponding path under its `inv.Cwd`.
	//
	// Populated for CAS-mode dispatches whether the response was a
	// fresh compile or a cache hit — the CompileCache stores extras
	// alongside the primary artifact (as a single `extras` blob,
	// JSON-encoded) so warm hits replay the same .d files cold
	// compiles produced. Without that, deleting a .d on disk would
	// leave `make` re-firing the compile rule forever on cache-hit
	// responses that returned the .o but no .d.
	ExtraOutputs map[string][]byte `` /* 171-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GetTenantIdPRequest struct {
	TenantId string `protobuf:"bytes,1,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	// contains filtered or unexported fields
}

type GetTenantIdPResponse struct {
	Issuer   string `protobuf:"bytes,1,opt,name=issuer,proto3" json:"issuer,omitempty"`
	TokenUrl string `protobuf:"bytes,2,opt,name=token_url,json=tokenUrl,proto3" json:"token_url,omitempty"`
	Audience string `protobuf:"bytes,3,opt,name=audience,proto3" json:"audience,omitempty"`
	// OAuth client_id + scope for this tenant. Both live on the
	// scheduler so ops can rotate them without re-flashing every
	// client. Empty fields are omitted from the password-grant POST.
	ClientId string `protobuf:"bytes,4,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	Scope    string `protobuf:"bytes,5,opt,name=scope,proto3" json:"scope,omitempty"`
	// contains filtered or unexported fields
}

type HeartbeatResponse struct {
	// contains filtered or unexported fields
}

type PreprocessedDescriptor struct {
	PreprocessedSource []byte `protobuf:"bytes,1,opt,name=preprocessed_source,json=preprocessedSource,proto3" json:"preprocessed_source,omitempty"`
	// contains filtered or unexported fields
}

type ProbeMiss struct {
	// contains filtered or unexported fields
}

type ProbeResponse struct {

	// Types that are valid to be assigned to Result:
	//
	//	*ProbeResponse_Hit
	//	*ProbeResponse_Miss
	Result isProbeResponse_Result `protobuf_oneof:"result"`
	// contains filtered or unexported fields
}

type ProbeResponse_Hit struct {
	Hit *CompileResponse `protobuf:"bytes,1,opt,name=hit,proto3,oneof"` // cache hit: full result, client is done
}

type ProbeResponse_Miss struct {
	Miss *ProbeMiss `protobuf:"bytes,2,opt,name=miss,proto3,oneof"` // cache miss: client proceeds to upload dance
}

type RegisterWorkerRequest struct {
	SessionToken    string      `protobuf:"bytes,1,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
	WorkerId        string      `protobuf:"bytes,2,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
	PublicAddr      string      `protobuf:"bytes,3,opt,name=public_addr,json=publicAddr,proto3" json:"public_addr,omitempty"`
	ImageDigests    []string    `protobuf:"bytes,4,rep,name=image_digests,json=imageDigests,proto3" json:"image_digests,omitempty"`
	AvailableVcpus  int32       `protobuf:"varint,5,opt,name=available_vcpus,json=availableVcpus,proto3" json:"available_vcpus,omitempty"`
	CurrentLoad     int32       `protobuf:"varint,6,opt,name=current_load,json=currentLoad,proto3" json:"current_load,omitempty"`
	Runtime         RuntimeType `protobuf:"varint,7,opt,name=runtime,proto3,enum=protocol.RuntimeType" json:"runtime,omitempty"`
	CertFingerprint []byte      `protobuf:"bytes,8,opt,name=cert_fingerprint,json=certFingerprint,proto3" json:"cert_fingerprint,omitempty"`
	// contains filtered or unexported fields
}

type RegisterWorkerResponse struct {
	Success   bool   `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	ErrorCode uint32 `protobuf:"varint,2,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"`
	// contains filtered or unexported fields
}

type RemoteDescriptor struct {
	TenantId       string     `protobuf:"bytes,1,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	ImageDigest    string     `protobuf:"bytes,2,opt,name=image_digest,json=imageDigest,proto3" json:"image_digest,omitempty"`
	SchedulerToken string     `protobuf:"bytes,3,opt,name=scheduler_token,json=schedulerToken,proto3" json:"scheduler_token,omitempty"`
	SourceMode     SourceMode `protobuf:"varint,4,opt,name=source_mode,json=sourceMode,proto3,enum=protocol.SourceMode" json:"source_mode,omitempty"`
	// Types that are valid to be assigned to SourceSettings:
	//
	//	*RemoteDescriptor_Preprocessed
	//	*RemoteDescriptor_Cas
	SourceSettings isRemoteDescriptor_SourceSettings `protobuf_oneof:"source_settings"`
	// Full OCI image reference, e.g. "ghcr.io/foo/toolchain@sha256:abc..."
	// or "registry.example.com/team/toolchain:v1.2.3". Used by the worker
	// to pull the image if it's not already in the local snapshotter.
	// image_digest remains the canonical identity for routing, cache keys,
	// and audit; image_ref is the pullable address.
	ImageRef string `protobuf:"bytes,8,opt,name=image_ref,json=imageRef,proto3" json:"image_ref,omitempty"`
	// contains filtered or unexported fields
}

type RemoteDescriptor_Cas struct {
	Cas *CasDescriptor `protobuf:"bytes,7,opt,name=cas,proto3,oneof"`
}

type RemoteDescriptor_Preprocessed struct {
	Preprocessed *PreprocessedDescriptor `protobuf:"bytes,6,opt,name=preprocessed,proto3,oneof"`
}

type RouteRequest struct {
	SessionToken string `protobuf:"bytes,1,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
	TenantId     string `protobuf:"bytes,2,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
	ImageDigest  string `protobuf:"bytes,3,opt,name=image_digest,json=imageDigest,proto3" json:"image_digest,omitempty"`
	// contains filtered or unexported fields
}

type RouteResponse struct {
	WorkerAddress   string `protobuf:"bytes,1,opt,name=worker_address,json=workerAddress,proto3" json:"worker_address,omitempty"`
	Token           string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`                                            // JWT signed by scheduler; worker verifies signature
	CertFingerprint []byte `protobuf:"bytes,3,opt,name=cert_fingerprint,json=certFingerprint,proto3" json:"cert_fingerprint,omitempty"` // SHA-256 of worker's TLS cert, for client-side pinning
	// contains filtered or unexported fields
}

type RuntimeType int32

type SchedulerServiceClient interface {
	// GetTenantIdP is unauthenticated by design: the client only knows
	// its tenant_id + scheduler URL from local config, and needs to
	// discover where to OAuth before it can produce a JWT. See
	// docs/plan/multi-tenant.md "Identity discovery (client side)".
	GetTenantIdP(ctx context.Context, in *GetTenantIdPRequest, opts ...grpc.CallOption) (*GetTenantIdPResponse, error)
	Authenticate(ctx context.Context, in *AuthRequest, opts ...grpc.CallOption) (*AuthResponse, error)
	Route(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteResponse, error)
	RegisterWorker(ctx context.Context, in *RegisterWorkerRequest, opts ...grpc.CallOption) (*RegisterWorkerResponse, error)
	Heartbeat(ctx context.Context, in *WorkerHeartbeat, opts ...grpc.CallOption) (*HeartbeatResponse, error)
}

type SchedulerServiceServer interface {
	// GetTenantIdP is unauthenticated by design: the client only knows
	// its tenant_id + scheduler URL from local config, and needs to
	// discover where to OAuth before it can produce a JWT. See
	// docs/plan/multi-tenant.md "Identity discovery (client side)".
	GetTenantIdP(context.Context, *GetTenantIdPRequest) (*GetTenantIdPResponse, error)
	Authenticate(context.Context, *AuthRequest) (*AuthResponse, error)
	Route(context.Context, *RouteRequest) (*RouteResponse, error)
	RegisterWorker(context.Context, *RegisterWorkerRequest) (*RegisterWorkerResponse, error)
	Heartbeat(context.Context, *WorkerHeartbeat) (*HeartbeatResponse, error)
	// contains filtered or unexported methods
}

type SourceMode int32

type UnimplementedSchedulerServiceServer struct{}

type UnimplementedWorkerServiceServer struct{}

type UnsafeSchedulerServiceServer interface {
	// contains filtered or unexported methods
}

type UnsafeWorkerServiceServer interface {
	// contains filtered or unexported methods
}

type UploadResult struct {
	BlobsReceived uint64 `protobuf:"varint,1,opt,name=blobs_received,json=blobsReceived,proto3" json:"blobs_received,omitempty"`
	BytesReceived uint64 `protobuf:"varint,2,opt,name=bytes_received,json=bytesReceived,proto3" json:"bytes_received,omitempty"`
	// Digests the worker refused to commit — hash mismatch, quota
	// overrun, etc. The client treats these as the upload-failed set
	// and either retries or falls back to local compile. Reasons are
	// intentionally not carried on the wire; logs on the worker
	// capture them.
	RejectedDigests [][]byte `protobuf:"bytes,3,rep,name=rejected_digests,json=rejectedDigests,proto3" json:"rejected_digests,omitempty"`
	// contains filtered or unexported fields
}

type VMState int32

type WorkerHeartbeat struct {
	SessionToken   string      `protobuf:"bytes,1,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
	WorkerId       string      `protobuf:"bytes,2,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
	AvailableVcpus int32       `protobuf:"varint,3,opt,name=available_vcpus,json=availableVcpus,proto3" json:"available_vcpus,omitempty"`
	CurrentLoad    int32       `protobuf:"varint,4,opt,name=current_load,json=currentLoad,proto3" json:"current_load,omitempty"`
	ActiveVms      []*ActiveVM `protobuf:"bytes,5,rep,name=active_vms,json=activeVms,proto3" json:"active_vms,omitempty"`
	// contains filtered or unexported fields
}

type WorkerServiceClient interface {
	Compile(ctx context.Context, in *CompileRequest, opts ...grpc.CallOption) (*CompileResponse, error)
	// ProbeCompileCache is the cache short-circuit for CAS mode. Client
	// sends just the manifest digest + args + image; worker computes
	// the compile cache key and checks the compile cache (local +
	// S3-backed). On hit, the client gets the artifact back and skips
	// FindMissingBlobs / UploadBlobs entirely — typical for incremental
	// builds where most TUs are cached. On miss, client proceeds with
	// the upload dance. Mirrors Bazel's ActionCache.GetActionResult.
	ProbeCompileCache(ctx context.Context, in *CompileProbe, opts ...grpc.CallOption) (*ProbeResponse, error)
	// FindMissingBlobs is the client's "what do I need to upload?"
	// probe in CAS mode. Client streams the digests it intends to
	// ship; worker streams back the subset it isn't already storing
	// locally. Single-layer lookup (sourceStore.Has) — source blobs
	// are worker-local-ephemeral, so there's nothing else to probe.
	// Bidi-streaming so the client can pipeline upload decisions
	// without waiting for the full probe set.
	FindMissingBlobs(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[BlobDigest, BlobDigest], error)
	// UploadBlobs streams missing blobs to the worker. The worker
	// opens a BLAKE3 hasher per blob, tees incoming bytes to a temp
	// file in the local source store, and on header-boundary verifies
	// the recomputed digest matches the client-claimed one. Match →
	// atomic-rename into the local store keyed by recomputed digest.
	// Mismatch / quota / bad path → reject and report in
	// UploadResult.rejected_digests. Source blobs are worker-local-
	// ephemeral (no S3 write-through); the client is the source of
	// truth and re-uploads on cache miss.
	UploadBlobs(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[BlobChunk, UploadResult], error)
}

type WorkerServiceServer interface {
	Compile(context.Context, *CompileRequest) (*CompileResponse, error)
	// ProbeCompileCache is the cache short-circuit for CAS mode. Client
	// sends just the manifest digest + args + image; worker computes
	// the compile cache key and checks the compile cache (local +
	// S3-backed). On hit, the client gets the artifact back and skips
	// FindMissingBlobs / UploadBlobs entirely — typical for incremental
	// builds where most TUs are cached. On miss, client proceeds with
	// the upload dance. Mirrors Bazel's ActionCache.GetActionResult.
	ProbeCompileCache(context.Context, *CompileProbe) (*ProbeResponse, error)
	// FindMissingBlobs is the client's "what do I need to upload?"
	// probe in CAS mode. Client streams the digests it intends to
	// ship; worker streams back the subset it isn't already storing
	// locally. Single-layer lookup (sourceStore.Has) — source blobs
	// are worker-local-ephemeral, so there's nothing else to probe.
	// Bidi-streaming so the client can pipeline upload decisions
	// without waiting for the full probe set.
	FindMissingBlobs(grpc.BidiStreamingServer[BlobDigest, BlobDigest]) error
	// UploadBlobs streams missing blobs to the worker. The worker
	// opens a BLAKE3 hasher per blob, tees incoming bytes to a temp
	// file in the local source store, and on header-boundary verifies
	// the recomputed digest matches the client-claimed one. Match →
	// atomic-rename into the local store keyed by recomputed digest.
	// Mismatch / quota / bad path → reject and report in
	// UploadResult.rejected_digests. Source blobs are worker-local-
	// ephemeral (no S3 write-through); the client is the source of
	// truth and re-uploads on cache miss.
	UploadBlobs(grpc.ClientStreamingServer[BlobChunk, UploadResult]) error
	// contains filtered or unexported methods
}

type WorkerService_FindMissingBlobsClient = grpc.BidiStreamingClient[BlobDigest, BlobDigest]

type WorkerService_FindMissingBlobsServer = grpc.BidiStreamingServer[BlobDigest, BlobDigest]

type WorkerService_UploadBlobsClient = grpc.ClientStreamingClient[BlobChunk, UploadResult]

type WorkerService_UploadBlobsServer = grpc.ClientStreamingServer[BlobChunk, UploadResult]