# A txtar test version of evaluation phase of the process behind our
# CI workflow generation.
#
# Note: all the non-golden files below are updated automatically by
# the internal/ci updateTxtarTests CUE command (with the exception
# of the cue.mod/module.cue file).

-- workflows.cue --
package ci

import (
	"github.com/SchemaStore/schemastore/src/schemas/json"
	encjson "encoding/json"
)

workflowsDir:        *"./" | string @tag(workflowsDir)
_#masterBranch:      "master"
_#releaseTagPattern: "v*"
workflows:           [...{
	file:   string
	schema: json.#Workflow
}] & [{
	file:   "test.yml"
	schema: test
}, {
	file:   "repository_dispatch.yml"
	schema: repository_dispatch
}, {
	file:   "release.yml"
	schema: release
}, {
	file:   "rebuild_tip_cuelang_org.yml"
	schema: rebuild_tip_cuelang_org
}]
test: _#bashWorkflow & {
	name: "Test"
	on: push: {
		branches: ["**"]
		"tags-ignore": [_#releaseTagPattern]
	}
	jobs: {
		start: {
			"runs-on": _#linuxMachine
			steps:     [..._ & {
				if: "${{ \(_#isCLCITestBranch) }}"
			}] & [_#writeCookiesFile, _#startCLBuild]
		}
		test: {
			needs:     "start"
			strategy:  _#testStrategy
			"runs-on": "${{ matrix.os }}"
			steps: [_#writeCookiesFile, _#installGo, _#checkoutCode, _#cacheGoModules, _#goGenerate, _#goTest, _#goTestRace & {
				if: "${{ \(_#isMaster) || \(_#isCLCITestBranch) && matrix.go-version == '\(_#latestStableGo)' && matrix.os == '\(_#linuxMachine)' }}"
			}, _#goReleaseCheck, _#checkGitClean, _#pullThroughProxy, _#failCLBuild]
		}
		mark_ci_success: {
			"runs-on": _#linuxMachine
			if:        "${{ \(_#isCLCITestBranch) }}"
			needs:     "test"
			steps: [_#writeCookiesFile, _#passCLBuild]
		}
		delete_build_branch: {
			"runs-on": _#linuxMachine
			if:        "${{ \(_#isCLCITestBranch) && always() }}"
			needs:     "test"
			steps: [_#step & {
				run: """
							\(_#tempCueckooGitDir)
							git push https://github.com/cuelang/cue :${GITHUB_REF#\(_#branchRefPrefix)}
							"""
			}]
		}
	}

	// _#isCLCITestBranch is an expression that evaluates to true
	// if the job is running as a result of a CL triggered CI build
	_#isCLCITestBranch: "startsWith(github.ref, '\(_#branchRefPrefix)ci/')"

	// _#isMaster is an expression that evaluates to true if the
	// job is running as a result of a master commit push
	_#isMaster:         "github.ref == '\(_#branchRefPrefix+_#masterBranch)'"
	_#pullThroughProxy: _#step & {
		name: "Pull this commit through the proxy on \(_#masterBranch)"
		run: """
			v=$(git rev-parse HEAD)
			cd $(mktemp -d)
			go mod init mod.com
			GOPROXY=https://proxy.golang.org go get -d cuelang.org/go@$v
			"""
		if: "${{ \(_#isMaster) }}"
	}
	_#startCLBuild: _#step & {
		name: "Update Gerrit CL message with starting message"
		run:  (_#gerrit._#setCodeReview & {
			#args: {
				message: "Started the build... see progress at ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}"
			}
		}).res
	}
	_#failCLBuild: _#step & {
		if:   "${{ \(_#isCLCITestBranch) && failure() }}"
		name: "Post any failures for this matrix entry"
		run:  (_#gerrit._#setCodeReview & {
			#args: {
				message: "Build failed for ${{ runner.os }}-${{ matrix.go-version }}; see ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }} for more details"
				labels: "Code-Review": -1
			}
		}).res
	}
	_#passCLBuild: _#step & {
		name: "Update Gerrit CL message with success message"
		run:  (_#gerrit._#setCodeReview & {
			#args: {
				message: "Build succeeded for ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}"
				labels: "Code-Review": 1
			}
		}).res
	}
	_#gerrit: {
		// _#setCodeReview assumes that it is invoked from a job where
		// _#isCLCITestBranch is true
		_#setCodeReview: {
			#args: {
				message: string
				labels?: "Code-Review": int
			}
			res: "curl -f -s -H \"Content-Type: application/json\" --request POST --data '\(encjson.Marshal(#args))' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review"
		}
	}
}
repository_dispatch: _#bashWorkflow & {
	name: "Repository Dispatch"
	on: ["repository_dispatch"]
	jobs: start: {
		if:        "${{ startsWith(github.event.action, 'Build for refs/changes/') }}"
		"runs-on": _#linuxMachine
		steps: [_#step & {
			name: "Checkout ref"
			run:  """
							\(_#tempCueckooGitDir)
							git fetch https://cue-review.googlesource.com/cue ${{ github.event.client_payload.ref }}
							git checkout -b ci/${{ github.event.client_payload.changeID }}/${{ github.event.client_payload.commit }} FETCH_HEAD
							git push https://github.com/cuelang/cue ci/${{ github.event.client_payload.changeID }}/${{ github.event.client_payload.commit }}
							"""
		}]
	}
}
release: _#bashWorkflow & {
	name: "Release"
	on: push: tags: [_#releaseTagPattern]
	jobs: {
		goreleaser: {
			"runs-on": _#linuxMachine
			steps: [{
				name: "Checkout code"
				uses: "actions/checkout@v2"
			}, {
				name: "Unshallow"
				run:  "git fetch --prune --unshallow"
			}, {
				name: "Run GoReleaser"
				env: GITHUB_TOKEN: "${{ secrets.ACTIONS_GITHUB_TOKEN }}"
				uses: "docker://goreleaser/goreleaser:v0.110.0"
				with: args: "release --rm-dist"
			}]
		}
		docker: {
			name:      "docker"
			"runs-on": _#linuxMachine
			steps: [{
				name: "Check out the repo"
				uses: "actions/checkout@v2"
			}, {
				name: "Set version environment"
				run: """
					CUE_VERSION=$(echo ${GITHUB_REF##refs/tags/v})
					echo \"CUE_VERSION=$CUE_VERSION\"
					echo \"CUE_VERSION=$(echo $CUE_VERSION)\" >> $GITHUB_ENV
					"""
			}, {
				name: "Push to Docker Hub"
				env: {
					DOCKER_BUILDKIT: 1
					GOLANG_VERSION:  1.14
					CUE_VERSION:     "${{ env.CUE_VERSION }}"
				}
				uses: "docker/build-push-action@v1"
				with: {
					tags:           "${{ env.CUE_VERSION }},latest"
					repository:     "cuelang/cue"
					username:       "${{ secrets.DOCKER_USERNAME }}"
					password:       "${{ secrets.DOCKER_PASSWORD }}"
					tag_with_ref:   false
					tag_with_sha:   false
					target:         "cue"
					always_pull:    true
					build_args:     "GOLANG_VERSION=${{ env.GOLANG_VERSION }},CUE_VERSION=v${{ env.CUE_VERSION }}"
					add_git_labels: true
				}
			}]
		}
	}
}
rebuild_tip_cuelang_org: _#bashWorkflow & {
	name: "Push to tip"
	on: push: branches: [_#masterBranch]
	jobs: push: {
		"runs-on": _#linuxMachine
		steps: [{
			name: "Rebuild tip.cuelang.org"
			run:  "curl -f -X POST -d {} https://api.netlify.com/build_hooks/${{ secrets.CuelangOrgTipRebuildHook }}"
		}]
	}
}
_#bashWorkflow: json.#Workflow & {
	jobs: [string]: defaults: run: shell: "bash"
}

// TODO: drop when cuelang.org/issue/390 is fixed.
// Declare definitions for sub-schemas
_#job: ((json.#Workflow & {}).jobs & {
	x: _
}).x
_#step: ((_#job & {
	steps: _
}).steps & [_])[0]

// We need at least go1.14 for code generation
_#codeGenGo:      "1.14.14"
_#latestStableGo: "1.15.x"
_#linuxMachine:   "ubuntu-18.04"
_#macosMachine:   "macos-10.15"
_#windowsMachine: "windows-2019"
_#testStrategy: {
	"fail-fast": false
	matrix: {
		// Use a stable version of 1.14.x for go generate
		"go-version": [_#codeGenGo, _#latestStableGo, "1.16.0-rc1"]
		os: [_#linuxMachine, _#macosMachine, _#windowsMachine]
	}
}
_#installGo: _#step & {
	name: "Install Go"
	uses: "actions/setup-go@v2"
	with: {
		"go-version": "${{ matrix.go-version }}"
		stable:       false
	}
}
_#checkoutCode: _#step & {
	name: "Checkout code"
	uses: "actions/checkout@v2"
}
_#cacheGoModules: _#step & {
	name: "Cache Go modules"
	uses: "actions/cache@v1"
	with: {
		path: "~/go/pkg/mod"
		key:  "${{ runner.os }}-${{ matrix.go-version }}-go-${{ hashFiles('**/go.sum') }}"
		"restore-keys": """
			${{ runner.os }}-${{ matrix.go-version }}-go-
			"""
	}
}
_#goGenerate: _#step & {
	name: "Generate"
	run:  "go generate ./..."
	// The Go version corresponds to the precise version specified in
	// the matrix. Skip windows for now until we work out why re-gen is flaky
	if: "matrix.go-version == '\(_#codeGenGo)' && matrix.os != '\(_#windowsMachine)'"
}
_#goTest: _#step & {
	name: "Test"
	run:  "go test ./..."
}
_#goTestRace: _#step & {
	name: "Test with -race"
	run:  "go test -race ./..."
}
_#goReleaseCheck: _#step & {
	name: "gorelease check"
	run:  "go run golang.org/x/exp/cmd/gorelease"
}
_#checkGitClean: _#step & {
	name: "Check that git is clean post generate and tests"
	run:  "test -z \"$(git status --porcelain)\" || (git status; git diff; false)"
}
_#writeCookiesFile: _#step & {
	name: "Write the gitcookies file"
	run:  "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies"
}
_#branchRefPrefix: "refs/heads/"
_#tempCueckooGitDir: """
	mkdir tmpgit
	cd tmpgit
	git init
	git config user.name cueckoo
	git config user.email cueckoo@gmail.com
	git config http.https://github.com/.extraheader "AUTHORIZATION: basic $(echo -n cueckoo:${{ secrets.CUECKOO_GITHUB_PAT }} | base64)"
	"""
-- cue.mod/module.cue --
module: "mod.com"

-- cue.mod/pkg/github.com/SchemaStore/schemastore/src/schemas/json/github-workflow.cue --
package json

import "strings"

#Workflow: {
	@jsonschema(schema="http://json-schema.org/draft-07/schema")
	null | bool | number | string | [...] | {
		// The name of your workflow. GitHub displays the names of your
		// workflows on your repository's actions page. If you omit this
		// field, GitHub sets the name to the workflow's filename.
		name?: string

		// The name of the GitHub event that triggers the workflow. You
		// can provide a single event string, array of events, array of
		// event types, or an event configuration map that schedules a
		// workflow or restricts the execution of a workflow to specific
		// files, tags, or branch changes. For a list of available
		// events, see
		// https://help.github.com/en/github/automating-your-workflow-with-github-actions/events-that-trigger-workflows.
		on: #event | [...#event] & [_, ...] | {
			// Runs your workflow anytime the check_run event occurs. More
			// than one activity type triggers this event. For information
			// about the REST API, see
			// https://developer.github.com/v3/checks/runs.
			check_run?: #eventObject & {
				types?: #types & [..."created" | "rerequested" | "completed" | "requested_action"] | *["created", "rerequested", "completed", "requested_action"]
				...
			}

			// Runs your workflow anytime the check_suite event occurs. More
			// than one activity type triggers this event. For information
			// about the REST API, see
			// https://developer.github.com/v3/checks/suites/.
			check_suite?: #eventObject & {
				types?: #types & [..."completed" | "requested" | "rerequested"] | *["completed", "requested", "rerequested"]
				...
			}

			// Runs your workflow anytime someone creates a branch or tag,
			// which triggers the create event. For information about the
			// REST API, see
			// https://developer.github.com/v3/git/refs/#create-a-reference.
			create?: #eventObject

			// Runs your workflow anytime someone deletes a branch or tag,
			// which triggers the delete event. For information about the
			// REST API, see
			// https://developer.github.com/v3/git/refs/#delete-a-reference.
			delete?: #eventObject

			// Runs your workflow anytime someone creates a deployment, which
			// triggers the deployment event. Deployments created with a
			// commit SHA may not have a Git ref. For information about the
			// REST API, see
			// https://developer.github.com/v3/repos/deployments/.
			deployment?: #eventObject

			// Runs your workflow anytime a third party provides a deployment
			// status, which triggers the deployment_status event.
			// Deployments created with a commit SHA may not have a Git ref.
			// For information about the REST API, see
			// https://developer.github.com/v3/repos/deployments/#create-a-deployment-status.
			deployment_status?: #eventObject

			// Runs your workflow anytime when someone forks a repository,
			// which triggers the fork event. For information about the REST
			// API, see
			// https://developer.github.com/v3/repos/forks/#create-a-fork.
			fork?: #eventObject

			// Runs your workflow when someone creates or updates a Wiki page,
			// which triggers the gollum event.
			gollum?: #eventObject

			// Runs your workflow anytime the issue_comment event occurs. More
			// than one activity type triggers this event. For information
			// about the REST API, see
			// https://developer.github.com/v3/issues/comments/.
			issue_comment?: #eventObject & {
				types?: #types & [..."created" | "edited" | "deleted"] | *["created", "edited", "deleted"]
				...
			}

			// Runs your workflow anytime the issues event occurs. More than
			// one activity type triggers this event. For information about
			// the REST API, see https://developer.github.com/v3/issues.
			issues?: #eventObject & {
				types?: #types & [..."opened" | "edited" | "deleted" | "transferred" | "pinned" | "unpinned" | "closed" | "reopened" | "assigned" | "unassigned" | "labeled" | "unlabeled" | "locked" | "unlocked" | "milestoned" | "demilestoned"] | *["opened", "edited", "deleted", "transferred", "pinned", "unpinned", "closed", "reopened", "assigned", "unassigned", "labeled", "unlabeled", "locked", "unlocked", "milestoned", "demilestoned"]
				...
			}

			// Runs your workflow anytime the label event occurs. More than
			// one activity type triggers this event. For information about
			// the REST API, see
			// https://developer.github.com/v3/issues/labels/.
			label?: #eventObject & {
				types?: #types & [..."created" | "edited" | "deleted"] | *["created", "edited", "deleted"]
				...
			}

			// Runs your workflow anytime the member event occurs. More than
			// one activity type triggers this event. For information about
			// the REST API, see
			// https://developer.github.com/v3/repos/collaborators/.
			member?: #eventObject & {
				types?: #types & [..."added" | "edited" | "deleted"] | *["added", "edited", "deleted"]
				...
			}

			// Runs your workflow anytime the milestone event occurs. More
			// than one activity type triggers this event. For information
			// about the REST API, see
			// https://developer.github.com/v3/issues/milestones/.
			milestone?: #eventObject & {
				types?: #types & [..."created" | "closed" | "opened" | "edited" | "deleted"] | *["created", "closed", "opened", "edited", "deleted"]
				...
			}

			// Runs your workflow anytime someone pushes to a GitHub
			// Pages-enabled branch, which triggers the page_build event. For
			// information about the REST API, see
			// https://developer.github.com/v3/repos/pages/.
			page_build?: #eventObject

			// Runs your workflow anytime the project event occurs. More than
			// one activity type triggers this event. For information about
			// the REST API, see https://developer.github.com/v3/projects/.
			project?: #eventObject & {
				types?: #types & [..."created" | "updated" | "closed" | "reopened" | "edited" | "deleted"] | *["created", "updated", "closed", "reopened", "edited", "deleted"]
				...
			}

			// Runs your workflow anytime the project_card event occurs. More
			// than one activity type triggers this event. For information
			// about the REST API, see
			// https://developer.github.com/v3/projects/cards.
			project_card?: #eventObject & {
				types?: #types & [..."created" | "moved" | "converted" | "edited" | "deleted"] | *["created", "moved", "converted", "edited", "deleted"]
				...
			}

			// Runs your workflow anytime the project_column event occurs.
			// More than one activity type triggers this event. For
			// information about the REST API, see
			// https://developer.github.com/v3/projects/columns.
			project_column?: #eventObject & {
				types?: #types & [..."created" | "updated" | "moved" | "deleted"] | *["created", "updated", "moved", "deleted"]
				...
			}

			// Runs your workflow anytime someone makes a private repository
			// public, which triggers the public event. For information about
			// the REST API, see https://developer.github.com/v3/repos/#edit.
			public?: #eventObject

			// Runs your workflow anytime the pull_request event occurs. More
			// than one activity type triggers this event. For information
			// about the REST API, see https://developer.github.com/v3/pulls.
			// Note: Workflows do not run on private base repositories when
			// you open a pull request from a forked repository.
			// When you create a pull request from a forked repository to the
			// base repository, GitHub sends the pull_request event to the
			// base repository and no pull request events occur on the forked
			// repository.
			// Workflows don't run on forked repositories by default. You must
			// enable GitHub Actions in the Actions tab of the forked
			// repository.
			// The permissions for the GITHUB_TOKEN in forked repositories is
			// read-only. For more information about the GITHUB_TOKEN, see
			// https://help.github.com/en/articles/virtual-environments-for-github-actions.
			pull_request?: #ref & {
				types?: #types & [..."assigned" | "unassigned" | "labeled" | "unlabeled" | "opened" | "edited" | "closed" | "reopened" | "synchronize" | "ready_for_review" | "locked" | "unlocked" | "review_requested" | "review_request_removed"] | *["opened", "synchronize", "reopened"]

				{[=~"^(branche|tag|path)s(-ignore)?$" & !~"^(types)$"]: _}
			}

			// Runs your workflow anytime the pull_request_review event
			// occurs. More than one activity type triggers this event. For
			// information about the REST API, see
			// https://developer.github.com/v3/pulls/reviews.
			// Note: Workflows do not run on private base repositories when
			// you open a pull request from a forked repository.
			// When you create a pull request from a forked repository to the
			// base repository, GitHub sends the pull_request event to the
			// base repository and no pull request events occur on the forked
			// repository.
			// Workflows don't run on forked repositories by default. You must
			// enable GitHub Actions in the Actions tab of the forked
			// repository.
			// The permissions for the GITHUB_TOKEN in forked repositories is
			// read-only. For more information about the GITHUB_TOKEN, see
			// https://help.github.com/en/articles/virtual-environments-for-github-actions.
			pull_request_review?: #eventObject & {
				types?: #types & [..."submitted" | "edited" | "dismissed"] | *["submitted", "edited", "dismissed"]
				...
			}

			// Runs your workflow anytime a comment on a pull request's
			// unified diff is modified, which triggers the
			// pull_request_review_comment event. More than one activity type
			// triggers this event. For information about the REST API, see
			// https://developer.github.com/v3/pulls/comments.
			// Note: Workflows do not run on private base repositories when
			// you open a pull request from a forked repository.
			// When you create a pull request from a forked repository to the
			// base repository, GitHub sends the pull_request event to the
			// base repository and no pull request events occur on the forked
			// repository.
			// Workflows don't run on forked repositories by default. You must
			// enable GitHub Actions in the Actions tab of the forked
			// repository.
			// The permissions for the GITHUB_TOKEN in forked repositories is
			// read-only. For more information about the GITHUB_TOKEN, see
			// https://help.github.com/en/articles/virtual-environments-for-github-actions.
			pull_request_review_comment?: #eventObject & {
				types?: #types & [..."created" | "edited" | "deleted"] | *["created", "edited", "deleted"]
				...
			}

			// This event is similar to pull_request, except that it runs in
			// the context of the base repository of the pull request, rather
			// than in the merge commit. This means that you can more safely
			// make your secrets available to the workflows triggered by the
			// pull request, because only workflows defined in the commit on
			// the base repository are run. For example, this event allows
			// you to create workflows that label and comment on pull
			// requests, based on the contents of the event payload.
			pull_request_target?: #ref & {
				types?: #types & [..."assigned" | "unassigned" | "labeled" | "unlabeled" | "opened" | "edited" | "closed" | "reopened" | "synchronize" | "ready_for_review" | "locked" | "unlocked" | "review_requested" | "review_request_removed"] | *["opened", "synchronize", "reopened"]

				{[=~"^(branche|tag|path)s(-ignore)?$" & !~"^(types)$"]: _}
			}

			// Runs your workflow when someone pushes to a repository branch,
			// which triggers the push event.
			// Note: The webhook payload available to GitHub Actions does not
			// include the added, removed, and modified attributes in the
			// commit object. You can retrieve the full commit object using
			// the REST API. For more information, see
			// https://developer.github.com/v3/repos/commits/#get-a-single-commit.
			push?: #ref & {
				{[=~"^(branche|tag|path)s(-ignore)?$" & !~"^()$"]: _}
			}

			// Runs your workflow anytime a package is published or updated.
			// For more information, see
			// https://help.github.com/en/github/managing-packages-with-github-packages.
			registry_package?: #eventObject & {
				types?: #types & [..."published" | "updated"] | *["published", "updated"]
				...
			}

			// Runs your workflow anytime the release event occurs. More than
			// one activity type triggers this event. For information about
			// the REST API, see
			// https://developer.github.com/v3/repos/releases/ in the GitHub
			// Developer documentation.
			release?: #eventObject & {
				types?: #types & [..."published" | "unpublished" | "created" | "edited" | "deleted" | "prereleased" | "released"] | *["published", "unpublished", "created", "edited", "deleted", "prereleased", "released"]
				...
			}

			// Runs your workflow anytime the status of a Git commit changes,
			// which triggers the status event. For information about the
			// REST API, see https://developer.github.com/v3/repos/statuses/.
			status?: #eventObject

			// Runs your workflow anytime the watch event occurs. More than
			// one activity type triggers this event. For information about
			// the REST API, see
			// https://developer.github.com/v3/activity/starring/.
			watch?: #eventObject

			// You can now create workflows that are manually triggered with
			// the new workflow_dispatch event. You will then see a 'Run
			// workflow' button on the Actions tab, enabling you to easily
			// trigger a run.
			workflow_dispatch?: null | bool | number | string | [...] | {
				// Input parameters allow you to specify data that the action
				// expects to use during runtime. GitHub stores input parameters
				// as environment variables. Input ids with uppercase letters are
				// converted to lowercase during runtime. We recommended using
				// lowercase input ids.
				inputs?: {
					{[=~"^[_a-zA-Z][a-zA-Z0-9_-]*$" & !~"^()$"]: {
						// A string description of the input parameter.
						description: string

						// A string shown to users using the deprecated input.
						deprecationMessage?: string

						// A boolean to indicate whether the action requires the input
						// parameter. Set to true when the parameter is required.
						required: bool

						// A string representing the default value. The default value is
						// used when an input parameter isn't specified in a workflow
						// file.
						default?: string
					}}
				}
				...
			}

			// This event occurs when a workflow run is requested or
			// completed, and allows you to execute a workflow based on the
			// finished result of another workflow. For example, if your
			// pull_request workflow generates build artifacts, you can
			// create a new workflow that uses workflow_run to analyze the
			// results and add a comment to the original pull request.
			workflow_run?: #eventObject & {
				types?:     #types & [..."requested" | "completed"] | *["requested", "completed"]
				workflows?: [...string] & [_, ...]

				{[=~"^branches(-ignore)?$" & !~"^(types|workflows)$"]: _}
				...
			}

			// You can use the GitHub API to trigger a webhook event called
			// repository_dispatch when you want to trigger a workflow for
			// activity that happens outside of GitHub. For more information,
			// see
			// https://developer.github.com/v3/repos/#create-a-repository-dispatch-event.
			// To trigger the custom repository_dispatch webhook event, you
			// must send a POST request to a GitHub API endpoint and provide
			// an event_type name to describe the activity type. To trigger a
			// workflow run, you must also configure your workflow to use the
			// repository_dispatch event.
			repository_dispatch?: #eventObject

			// You can schedule a workflow to run at specific UTC times using
			// POSIX cron syntax
			// (https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html#tag_20_25_07).
			// Scheduled workflows run on the latest commit on the default or
			// base branch. The shortest interval you can run scheduled
			// workflows is once every 5 minutes.
			// Note: GitHub Actions does not support the non-standard syntax
			// @yearly, @monthly, @weekly, @daily, @hourly, and @reboot.
			// You can use crontab guru (https://crontab.guru/). to help
			// generate your cron syntax and confirm what time it will run.
			// To help you get started, there is also a list of crontab guru
			// examples (https://crontab.guru/examples.html).
			schedule?: [...null | bool | number | string | [...] | {
				cron?: =~"^(((\\d+,)+\\d+|((\\d+|\\*)\\/\\d+|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|(\\d+-\\d+)|\\d+|\\*|MON|TUE|WED|THU|FRI|SAT|SUN) ?){5,7}$"
			}] & [_, ...]
		}

		// A map of environment variables that are available to all jobs
		// and steps in the workflow.
		env?: #env

		// A map of default settings that will apply to all jobs in the
		// workflow.
		defaults?: #defaults

		// A workflow run is made up of one or more jobs. Jobs run in
		// parallel by default. To run jobs sequentially, you can define
		// dependencies on other jobs using the jobs.<job_id>.needs
		// keyword.
		// Each job runs in a fresh instance of the virtual environment
		// specified by runs-on.
		// You can run an unlimited number of jobs as long as you are
		// within the workflow usage limits. For more information, see
		// https://help.github.com/en/github/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#usage-limits.
		jobs: {
			{[=~"^[_a-zA-Z][a-zA-Z0-9_-]*$" & !~"^()$"]: {
				// The name of the job displayed on GitHub.
				name?: string

				// Identifies any jobs that must complete successfully before this
				// job will run. It can be a string or array of strings. If a job
				// fails, all jobs that need it are skipped unless the jobs use a
				// conditional statement that causes the job to continue.
				needs?: [...#name] & [_, ...] | #name

				// The type of machine to run the job on. The machine can be
				// either a GitHub-hosted runner, or a self-hosted runner.
				"runs-on": "macos-10.15" | "macos-11.0" | "macos-latest" | "self-hosted" | "ubuntu-16.04" | "ubuntu-18.04" | "ubuntu-20.04" | "ubuntu-latest" | "windows-2016" | "windows-2019" | "windows-latest" | (["self-hosted"] | ["self-hosted", #machine] | ["self-hosted", #architecture] | ["self-hosted", #machine, #architecture] | ["self-hosted", #architecture, #machine]) & [...] | #expressionSyntax

				// The environment that the job references.
				environment?: string | #environment

				// A map of outputs for a job. Job outputs are available to all
				// downstream jobs that depend on this job.
				outputs?: {
					[string]: string
				}

				// A map of environment variables that are available to all steps
				// in the job.
				env?: #env

				// A map of default settings that will apply to all steps in the
				// job.
				defaults?: #defaults

				// You can use the if conditional to prevent a job from running
				// unless a condition is met. You can use any supported context
				// and expression to create a conditional.
				// Expressions in an if conditional do not require the ${{ }}
				// syntax. For more information, see
				// https://help.github.com/en/articles/contexts-and-expression-syntax-for-github-actions.
				if?: string

				// A job contains a sequence of tasks called steps. Steps can run
				// commands, run setup tasks, or run an action in your
				// repository, a public repository, or an action published in a
				// Docker registry. Not all steps run actions, but all actions
				// run as a step. Each step runs in its own process in the
				// virtual environment and has access to the workspace and
				// filesystem. Because steps run in their own process, changes to
				// environment variables are not preserved between steps. GitHub
				// provides built-in steps to set up and complete a job.
				steps?: [...{
					// A unique identifier for the step. You can use the id to
					// reference the step in contexts. For more information, see
					// https://help.github.com/en/articles/contexts-and-expression-syntax-for-github-actions.
					id?: string

					// You can use the if conditional to prevent a step from running
					// unless a condition is met. You can use any supported context
					// and expression to create a conditional.
					// Expressions in an if conditional do not require the ${{ }}
					// syntax. For more information, see
					// https://help.github.com/en/articles/contexts-and-expression-syntax-for-github-actions.
					if?: string

					// A name for your step to display on GitHub.
					name?: string

					// Selects an action to run as part of a step in your job. An
					// action is a reusable unit of code. You can use an action
					// defined in the same repository as the workflow, a public
					// repository, or in a published Docker container image
					// (https://hub.docker.com/).
					// We strongly recommend that you include the version of the
					// action you are using by specifying a Git ref, SHA, or Docker
					// tag number. If you don't specify a version, it could break
					// your workflows or cause unexpected behavior when the action
					// owner publishes an update.
					// - Using the commit SHA of a released action version is the
					// safest for stability and security.
					// - Using the specific major action version allows you to receive
					// critical fixes and security patches while still maintaining
					// compatibility. It also assures that your workflow should still
					// work.
					// - Using the master branch of an action may be convenient, but
					// if someone releases a new major version with a breaking
					// change, your workflow could break.
					// Some actions require inputs that you must set using the with
					// keyword. Review the action's README file to determine the
					// inputs required.
					// Actions are either JavaScript files or Docker containers. If
					// the action you're using is a Docker container you must run the
					// job in a Linux virtual environment. For more details, see
					// https://help.github.com/en/articles/virtual-environments-for-github-actions.
					uses?: string

					// Runs command-line programs using the operating system's shell.
					// If you do not provide a name, the step name will default to
					// the text specified in the run command.
					// Commands run using non-login shells by default. You can choose
					// a different shell and customize the shell used to run
					// commands. For more information, see
					// https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#using-a-specific-shell.
					// Each run keyword represents a new process and shell in the
					// virtual environment. When you provide multi-line commands,
					// each line runs in the same shell.
					run?: string, "working-directory"?: #["working-directory"], shell?: #shell

					// A map of the input parameters defined by the action. Each input
					// parameter is a key/value pair. Input parameters are set as
					// environment variables. The variable is prefixed with INPUT_
					// and converted to upper case.
					with?: #env & {
						args?: string, entrypoint?: string, ...
					}

					// Sets environment variables for steps to use in the virtual
					// environment. You can also set environment variables for the
					// entire workflow or a job.
					env?: #env

					// Prevents a job from failing when a step fails. Set to true to
					// allow a job to pass when this step fails.
					"continue-on-error"?: bool | #expressionSyntax | *false

					// The maximum number of minutes to run the step before killing
					// the process.
					"timeout-minutes"?: number
				}] & [_, ...]

				// The maximum number of minutes to let a workflow run before
				// GitHub automatically cancels it. Default: 360
				"timeout-minutes"?: number | *360

				// A strategy creates a build matrix for your jobs. You can define
				// different variations of an environment to run each job in.
				strategy?: {
					// A build matrix is a set of different configurations of the
					// virtual environment. For example you might run a job against
					// more than one supported version of a language, operating
					// system, or tool. Each configuration is a copy of the job that
					// runs and reports a status.
					// You can specify a matrix by supplying an array for the
					// configuration options. For example, if the GitHub virtual
					// environment supports Node.js versions 6, 8, and 10 you could
					// specify an array of those versions in the matrix.
					// When you define a matrix of operating systems, you must set the
					// required runs-on keyword to the operating system of the
					// current job, rather than hard-coding the operating system
					// name. To access the operating system name, you can use the
					// matrix.os context parameter to set runs-on. For more
					// information, see
					// https://help.github.com/en/articles/contexts-and-expression-syntax-for-github-actions.
					matrix: ({
						...
					} | #expressionSyntax) & {
						{[=~"^(in|ex)clude$" & !~"^()$"]: [...{
											[string]: #configuration
						}] & [_, ...]}
						{[!~"^(in|ex)clude$" & !~"^()$"]: [...#configuration] & [_, ...]}
					}

					// When set to true, GitHub cancels all in-progress jobs if any
					// matrix job fails. Default: true
					"fail-fast"?: bool | *true

					// The maximum number of jobs that can run simultaneously when
					// using a matrix job strategy. By default, GitHub will maximize
					// the number of jobs run in parallel depending on the available
					// runners on GitHub-hosted virtual machines.
					"max-parallel"?: number
				}

				// Prevents a workflow run from failing when a job fails. Set to
				// true to allow a workflow run to pass when this job fails.
				"continue-on-error"?: bool | #expressionSyntax

				// A container to run any steps in a job that don't already
				// specify a container. If you have steps that use both script
				// and container actions, the container actions will run as
				// sibling containers on the same network with the same volume
				// mounts.
				// If you do not set a container, all steps will run directly on
				// the host specified by runs-on unless a step refers to an
				// action configured to run in a container.
				container?: string | #container

				// Additional containers to host services for a job in a workflow.
				// These are useful for creating databases or cache services like
				// redis. The runner on the virtual machine will automatically
				// create a network and manage the life cycle of the service
				// containers.
				// When you use a service container for a job or your step uses
				// container actions, you don't need to set port information to
				// access the service. Docker automatically exposes all ports
				// between containers on the same network.
				// When both the job and the action run in a container, you can
				// directly reference the container by its hostname. The hostname
				// is automatically mapped to the service name.
				// When a step does not use a container action, you must access
				// the service using localhost and bind the ports.
				services?: {
					[string]: #container
				}
			}}
		}
	}

	#architecture: "ARM32" | "x64" | "x86"

	#branch: #globs

	#configuration: string | number | bool | {
		[string]: #configuration
	} | [...#configuration]

	#container: {
		// The Docker image to use as the container to run the action. The
		// value can be the Docker Hub image name or a registry name.
		image: string

		// If the image's container registry requires authentication to
		// pull the image, you can use credentials to set a map of the
		// username and password. The credentials are the same values
		// that you would provide to the `docker login` command.
		credentials?: {
			username?: string
			password?: string
			...
		}

		// Sets an array of environment variables in the container.
		env?: #env

		// Sets an array of ports to expose on the container.
		ports?: [...number | string] & [_, ...]

		// Sets an array of volumes for the container to use. You can use
		// volumes to share data between services or other steps in a
		// job. You can specify named Docker volumes, anonymous Docker
		// volumes, or bind mounts on the host.
		// To specify a volume, you specify the source and destination
		// path: <source>:<destinationPath>
		// The <source> is a volume name or an absolute path on the host
		// machine, and <destinationPath> is an absolute path in the
		// container.
		volumes?: [...=~"^[^:]+:[^:]+$"] & [_, ...]

		// Additional Docker container resource options. For a list of
		// options, see
		// https://docs.docker.com/engine/reference/commandline/create/#options.
		options?: string
	}

	#defaults: run?: {
		shell?:               #shell
		"working-directory"?: #["working-directory"]
	}

	#env: [string]: bool | number | string

	#environment: {
		// The name of the environment configured in the repo.
		name: string

		// A deployment URL
		url?: string
	}

	#event: "check_run" | "check_suite" | "create" | "delete" | "deployment" | "deployment_status" | "fork" | "gollum" | "issue_comment" | "issues" | "label" | "member" | "milestone" | "page_build" | "project" | "project_card" | "project_column" | "public" | "pull_request" | "pull_request_review" | "pull_request_review_comment" | "pull_request_target" | "push" | "registry_package" | "release" | "status" | "watch" | "workflow_dispatch" | "workflow_run" | "repository_dispatch"

	#eventObject: null

	#expressionSyntax: =~"^\\$\\{\\{.*\\}\\}$"

	#globs: [...strings.MinRunes(1)] & [_, ...]

	#machine: "linux" | "macos" | "windows"

	#name: =~"^[_a-zA-Z][a-zA-Z0-9_-]*$"

	#path: #globs

	#ref: null | {
		branches?:          #branch
		"branches-ignore"?: #branch
		tags?:              #branch
		"tags-ignore"?:     #branch
		paths?:             #path
		"paths-ignore"?:    #path
		...
	}

	#shell: (string | ("bash" | "pwsh" | "python" | "sh" | "cmd" | "powershell")) & string

	#types: [_, ...]

	#: "working-directory": string
}
-- out/eval --
(struct){
  workflowsDir: (string){ |(*(string){ "./" }, (string){ string }) }
  workflows: (#list){
    0: (struct){
      file: (string){ "test.yml" }
      schema: (#struct){
        #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
        #branch: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
          }, (list){
          }) }
        #container: (#struct){
          image: (string){ string }
        }
        #defaults: (#struct){
        }
        #env: (#struct){
        }
        #environment: (#struct){
          name: (string){ string }
        }
        #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
        #eventObject: (null){ null }
        #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
        #globs: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
        #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
        #path: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #ref: ((null|struct)){ |((null){ null }, (#struct){
          }) }
        #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
        #types: (list){
          0: (_){ _ }
        }
        #: (#struct){
          "working-directory": (string){ string }
        }
        jobs: (#struct){
          test: (#struct){
            strategy: (#struct){
              "fail-fast": (bool){ false }
              matrix: (#struct){
                "go-version": (#list){
                  0: (string){ "1.13.x" }
                  1: (string){ "1.14.9" }
                  2: (string){ "1.15.x" }
                }
                os: (#list){
                  0: (string){ "ubuntu-18.04" }
                  1: (string){ "macos-10.15" }
                  2: (string){ "windows-2019" }
                }
              }
            }
            "runs-on": (string){ "${{ matrix.os }}" }
            steps: (#list){
              0: (#struct){
                name: (string){ "Write the gitcookies file" }
                run: (string){ "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies" }
              }
              1: (#struct){
                name: (string){ "Install Go" }
                uses: (string){ "actions/setup-go@v2" }
                with: (#struct){
                  "go-version": (string){ "${{ matrix.go-version }}" }
                }
              }
              2: (#struct){
                name: (string){ "Checkout code" }
                uses: (string){ "actions/checkout@v2" }
              }
              3: (#struct){
                name: (string){ "Cache Go modules" }
                uses: (string){ "actions/cache@v1" }
                with: (#struct){
                  path: (string){ "~/go/pkg/mod" }
                  key: (string){ "${{ runner.os }}-${{ matrix.go-version }}-go-${{ hashFiles('**/go.sum') }}" }
                  "restore-keys": (string){ "${{ runner.os }}-${{ matrix.go-version }}-go-" }
                }
              }
              4: (#struct){
                name: (string){ "Generate" }
                run: (string){ "go generate ./..." }
                if: (string){ "matrix.go-version == '1.14.9' && matrix.os != 'windows-2019'" }
              }
              5: (#struct){
                name: (string){ "Test" }
                run: (string){ "go test ./..." }
              }
              6: (#struct){
                name: (string){ "Test with -race" }
                run: (string){ "go test -race ./..." }
              }
              7: (#struct){
                name: (string){ "gorelease check" }
                run: (string){ "go run golang.org/x/exp/cmd/gorelease" }
              }
              8: (#struct){
                name: (string){ "Check that git is clean post generate and tests" }
                run: (string){ "test -z \"$(git status --porcelain)\" || (git status; git diff; false)" }
              }
              9: (#struct){
                name: (string){ "Pull this commit through the proxy on master" }
                run: (string){ "v=$(git rev-parse HEAD)\ncd $(mktemp -d)\ngo mod init mod.com\nGOPROXY=https://proxy.golang.org go get -d cuelang.org/go@$v" }
                if: (string){ "${{ github.ref == 'refs/heads/master' }}" }
              }
              10: (#struct){
                if: (string){ "${{ startsWith(github.ref, 'refs/heads/ci/') && failure() }}" }
                name: (string){ "Post any failures for this matrix entry" }
                run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Build failed for ${{ runner.os }}-${{ matrix.go-version }}; see ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }} for more details\",\"labels\":{\"Code-Review\":-1}}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review" }
              }
            }
            defaults: (#struct){
              run: (#struct){
                shell: (string){ "bash" }
              }
            }
          }
          mark_ci_success: (#struct){
            "runs-on": (string){ "ubuntu-18.04" }
            if: (string){ "${{ startsWith(github.ref, 'refs/heads/ci/') }}" }
            needs: (string){ "test" }
            steps: (#list){
              0: (#struct){
                name: (string){ "Write the gitcookies file" }
                run: (string){ "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies" }
              }
              1: (#struct){
                name: (string){ "Update Gerrit CL message with success message" }
                run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Build succeeded for ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}\",\"labels\":{\"Code-Review\":1}}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review" }
              }
            }
            defaults: (#struct){
              run: (#struct){
                shell: (string){ "bash" }
              }
            }
          }
          delete_build_branch: (#struct){
            "runs-on": (string){ "ubuntu-18.04" }
            if: (string){ "${{ startsWith(github.ref, 'refs/heads/ci/') && always() }}" }
            needs: (string){ "test" }
            steps: (#list){
              0: (#struct){
                run: (string){ "mkdir tmpgit\ncd tmpgit\ngit init\ngit config user.name cueckoo\ngit config user.email cueckoo@gmail.com\ngit config http.https://github.com/.extraheader \"AUTHORIZATION: basic $(echo -n cueckoo:${{ secrets.CUECKOO_GITHUB_PAT }} | base64)\"\ngit push https://github.com/cuelang/cue :${GITHUB_REF#refs/heads/}" }
              }
            }
            defaults: (#struct){
              run: (#struct){
                shell: (string){ "bash" }
              }
            }
          }
        }
        name: (string){ "Test" }
        on: (#struct){
          push: (#struct){
            branches: (#list){
              0: (string){ "**" }
            }
            "tags-ignore": (#list){
              0: (string){ "v*" }
            }
          }
        }
        _#isCLCITestBranch(:ci): (string){ "startsWith(github.ref, 'refs/heads/ci/')" }
        _#isMaster(:ci): (string){ "github.ref == 'refs/heads/master'" }
        _#pullThroughProxy(:ci): (#struct){
          name: (string){ "Pull this commit through the proxy on master" }
          run: (string){ "v=$(git rev-parse HEAD)\ncd $(mktemp -d)\ngo mod init mod.com\nGOPROXY=https://proxy.golang.org go get -d cuelang.org/go@$v" }
          if: (string){ "${{ github.ref == 'refs/heads/master' }}" }
        }
        _#failCLBuild(:ci): (#struct){
          if: (string){ "${{ startsWith(github.ref, 'refs/heads/ci/') && failure() }}" }
          name: (string){ "Post any failures for this matrix entry" }
          run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Build failed for ${{ runner.os }}-${{ matrix.go-version }}; see ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }} for more details\",\"labels\":{\"Code-Review\":-1}}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review" }
        }
        _#passCLBuild(:ci): (#struct){
          name: (string){ "Update Gerrit CL message with success message" }
          run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Build succeeded for ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}\",\"labels\":{\"Code-Review\":1}}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review" }
        }
        _#gerrit(:ci): (#struct){
          _#setCodeReview(:ci): (#struct){
            #args: (#struct){
              message: (string){ string }
            }
            res: (_|_){
              // [incomplete] invalid interpolation: cannot convert incomplete value "string" to JSON:
              //     ./workflows.cue:136:9
            }
          }
        }
      }
    }
    1: (struct){
      file: (string){ "test_dispatch.yml" }
      schema: (#struct){
        #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
        #branch: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
          }, (list){
          }) }
        #container: (#struct){
          image: (string){ string }
        }
        #defaults: (#struct){
        }
        #env: (#struct){
        }
        #environment: (#struct){
          name: (string){ string }
        }
        #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
        #eventObject: (null){ null }
        #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
        #globs: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
        #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
        #path: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #ref: ((null|struct)){ |((null){ null }, (#struct){
          }) }
        #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
        #types: (list){
          0: (_){ _ }
        }
        #: (#struct){
          "working-directory": (string){ string }
        }
        jobs: (#struct){
          start: (#struct){
            if: (string){ "${{ startsWith(github.event.action, 'Build for refs/changes/') }}" }
            "runs-on": (string){ "ubuntu-18.04" }
            steps: (#list){
              0: (#struct){
                name: (string){ "Write the gitcookies file" }
                run: (string){ "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies" }
              }
              1: (#struct){
                name: (string){ "Update Gerrit CL message with starting message" }
                run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Started the build... see progress at ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}\"}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/${{ github.event.client_payload.changeID }}/revisions/${{ github.event.client_payload.commit }}/review" }
              }
              2: (#struct){
                name: (string){ "Checkout ref" }
                run: (string){ "mkdir tmpgit\ncd tmpgit\ngit init\ngit config user.name cueckoo\ngit config user.email cueckoo@gmail.com\ngit config http.https://github.com/.extraheader \"AUTHORIZATION: basic $(echo -n cueckoo:${{ secrets.CUECKOO_GITHUB_PAT }} | base64)\"\ngit fetch https://cue-review.googlesource.com/cue ${{ github.event.client_payload.ref }}\ngit checkout -b ci/${{ github.event.client_payload.changeID }}/${{ github.event.client_payload.commit }} FETCH_HEAD\ngit push https://github.com/cuelang/cue ci/${{ github.event.client_payload.changeID }}/${{ github.event.client_payload.commit }}" }
              }
            }
            defaults: (#struct){
              run: (#struct){
                shell: (string){ "bash" }
              }
            }
          }
        }
        name: (string){ "Test Dispatch" }
        on: (#list){
          0: (string){ "repository_dispatch" }
        }
        _#gerrit(:ci): (#struct){
          _#setCodeReview(:ci): (#struct){
            #args: (#struct){
              message: (string){ string }
            }
            res: (_|_){
              // [incomplete] invalid interpolation: cannot convert incomplete value "string" to JSON:
              //     ./workflows.cue:180:9
            }
          }
        }
      }
    }
    2: (struct){
      file: (string){ "release.yml" }
      schema: (#struct){
        #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
        #branch: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
          }, (list){
          }) }
        #container: (#struct){
          image: (string){ string }
        }
        #defaults: (#struct){
        }
        #env: (#struct){
        }
        #environment: (#struct){
          name: (string){ string }
        }
        #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
        #eventObject: (null){ null }
        #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
        #globs: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
        #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
        #path: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #ref: ((null|struct)){ |((null){ null }, (#struct){
          }) }
        #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
        #types: (list){
          0: (_){ _ }
        }
        #: (#struct){
          "working-directory": (string){ string }
        }
        jobs: (#struct){
          goreleaser: (#struct){
            "runs-on": (string){ "ubuntu-18.04" }
            steps: (#list){
              0: (#struct){
                name: (string){ "Checkout code" }
                uses: (string){ "actions/checkout@v2" }
              }
              1: (#struct){
                name: (string){ "Unshallow" }
                run: (string){ "git fetch --prune --unshallow" }
              }
              2: (#struct){
                name: (string){ "Run GoReleaser" }
                env: (#struct){
                  GITHUB_TOKEN: (string){ "${{ secrets.ACTIONS_GITHUB_TOKEN }}" }
                }
                uses: (string){ "docker://goreleaser/goreleaser:latest" }
                with: (#struct){
                  args: (string){ "release --rm-dist" }
                }
              }
            }
            defaults: (#struct){
              run: (#struct){
                shell: (string){ "bash" }
              }
            }
          }
          docker: (#struct){
            name: (string){ "docker" }
            "runs-on": (string){ "ubuntu-18.04" }
            steps: (#list){
              0: (#struct){
                name: (string){ "Check out the repo" }
                uses: (string){ "actions/checkout@v2" }
              }
              1: (#struct){
                name: (string){ "Set version environment" }
                run: (string){ "CUE_VERSION=$(echo ${GITHUB_REF##refs/tags/v})\necho \"CUE_VERSION=$CUE_VERSION\"\necho \"CUE_VERSION=$(echo $CUE_VERSION)\" >> $GITHUB_ENV" }
              }
              2: (#struct){
                name: (string){ "Push to Docker Hub" }
                env: (#struct){
                  DOCKER_BUILDKIT: (int){ 1 }
                  GOLANG_VERSION: (float){ 1.14 }
                  CUE_VERSION: (string){ "${{ env.CUE_VERSION }}" }
                }
                uses: (string){ "docker/build-push-action@v1" }
                with: (#struct){
                  tags: (string){ "${{ env.CUE_VERSION }},latest" }
                  repository: (string){ "cuelang/cue" }
                  username: (string){ "${{ secrets.DOCKER_USERNAME }}" }
                  password: (string){ "${{ secrets.DOCKER_PASSWORD }}" }
                  tag_with_ref: (bool){ false }
                  tag_with_sha: (bool){ false }
                  target: (string){ "cue" }
                  always_pull: (bool){ true }
                  build_args: (string){ "GOLANG_VERSION=${{ env.GOLANG_VERSION }},CUE_VERSION=v${{ env.CUE_VERSION }}" }
                  add_git_labels: (bool){ true }
                }
              }
            }
            defaults: (#struct){
              run: (#struct){
                shell: (string){ "bash" }
              }
            }
          }
        }
        name: (string){ "Release" }
        on: (#struct){
          push: (#struct){
            tags: (#list){
              0: (string){ "v*" }
            }
          }
        }
      }
    }
    3: (struct){
      file: (string){ "rebuild_tip_cuelang_org.yml" }
      schema: (#struct){
        #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
        #branch: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
          }, (list){
          }) }
        #container: (#struct){
          image: (string){ string }
        }
        #defaults: (#struct){
        }
        #env: (#struct){
        }
        #environment: (#struct){
          name: (string){ string }
        }
        #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
        #eventObject: (null){ null }
        #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
        #globs: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
        #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
        #path: (list){
          0: (string){ strings.MinRunes(1) }
        }
        #ref: ((null|struct)){ |((null){ null }, (#struct){
          }) }
        #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
        #types: (list){
          0: (_){ _ }
        }
        #: (#struct){
          "working-directory": (string){ string }
        }
        jobs: (#struct){
          push: (#struct){
            "runs-on": (string){ "ubuntu-18.04" }
            steps: (#list){
              0: (#struct){
                name: (string){ "Rebuild tip.cuelang.org" }
                run: (string){ "curl -f -X POST -d {} https://api.netlify.com/build_hooks/${{ secrets.CuelangOrgTipRebuildHook }}" }
              }
            }
            defaults: (#struct){
              run: (#struct){
                shell: (string){ "bash" }
              }
            }
          }
        }
        name: (string){ "Push to tip" }
        on: (#struct){
          push: (#struct){
            branches: (#list){
              0: (string){ "master" }
            }
          }
        }
      }
    }
  }
  test: (#struct){
    #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
    #branch: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
      }, (list){
      }) }
    #container: (#struct){
      image: (string){ string }
    }
    #defaults: (#struct){
    }
    #env: (#struct){
    }
    #environment: (#struct){
      name: (string){ string }
    }
    #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
    #eventObject: (null){ null }
    #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
    #globs: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
    #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
    #path: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #ref: ((null|struct)){ |((null){ null }, (#struct){
      }) }
    #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
    #types: (list){
      0: (_){ _ }
    }
    #: (#struct){
      "working-directory": (string){ string }
    }
    jobs: (#struct){
      test: (#struct){
        strategy: (#struct){
          "fail-fast": (bool){ false }
          matrix: (#struct){
            "go-version": (#list){
              0: (string){ "1.13.x" }
              1: (string){ "1.14.9" }
              2: (string){ "1.15.x" }
            }
            os: (#list){
              0: (string){ "ubuntu-18.04" }
              1: (string){ "macos-10.15" }
              2: (string){ "windows-2019" }
            }
          }
        }
        "runs-on": (string){ "${{ matrix.os }}" }
        steps: (#list){
          0: (#struct){
            name: (string){ "Write the gitcookies file" }
            run: (string){ "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies" }
          }
          1: (#struct){
            name: (string){ "Install Go" }
            uses: (string){ "actions/setup-go@v2" }
            with: (#struct){
              "go-version": (string){ "${{ matrix.go-version }}" }
            }
          }
          2: (#struct){
            name: (string){ "Checkout code" }
            uses: (string){ "actions/checkout@v2" }
          }
          3: (#struct){
            name: (string){ "Cache Go modules" }
            uses: (string){ "actions/cache@v1" }
            with: (#struct){
              path: (string){ "~/go/pkg/mod" }
              key: (string){ "${{ runner.os }}-${{ matrix.go-version }}-go-${{ hashFiles('**/go.sum') }}" }
              "restore-keys": (string){ "${{ runner.os }}-${{ matrix.go-version }}-go-" }
            }
          }
          4: (#struct){
            name: (string){ "Generate" }
            run: (string){ "go generate ./..." }
            if: (string){ "matrix.go-version == '1.14.9' && matrix.os != 'windows-2019'" }
          }
          5: (#struct){
            name: (string){ "Test" }
            run: (string){ "go test ./..." }
          }
          6: (#struct){
            name: (string){ "Test with -race" }
            run: (string){ "go test -race ./..." }
          }
          7: (#struct){
            name: (string){ "gorelease check" }
            run: (string){ "go run golang.org/x/exp/cmd/gorelease" }
          }
          8: (#struct){
            name: (string){ "Check that git is clean post generate and tests" }
            run: (string){ "test -z \"$(git status --porcelain)\" || (git status; git diff; false)" }
          }
          9: (#struct){
            name: (string){ "Pull this commit through the proxy on master" }
            run: (string){ "v=$(git rev-parse HEAD)\ncd $(mktemp -d)\ngo mod init mod.com\nGOPROXY=https://proxy.golang.org go get -d cuelang.org/go@$v" }
            if: (string){ "${{ github.ref == 'refs/heads/master' }}" }
          }
          10: (#struct){
            if: (string){ "${{ startsWith(github.ref, 'refs/heads/ci/') && failure() }}" }
            name: (string){ "Post any failures for this matrix entry" }
            run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Build failed for ${{ runner.os }}-${{ matrix.go-version }}; see ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }} for more details\",\"labels\":{\"Code-Review\":-1}}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review" }
          }
        }
        defaults: (#struct){
          run: (#struct){
            shell: (string){ "bash" }
          }
        }
      }
      mark_ci_success: (#struct){
        "runs-on": (string){ "ubuntu-18.04" }
        if: (string){ "${{ startsWith(github.ref, 'refs/heads/ci/') }}" }
        needs: (string){ "test" }
        steps: (#list){
          0: (#struct){
            name: (string){ "Write the gitcookies file" }
            run: (string){ "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies" }
          }
          1: (#struct){
            name: (string){ "Update Gerrit CL message with success message" }
            run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Build succeeded for ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}\",\"labels\":{\"Code-Review\":1}}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review" }
          }
        }
        defaults: (#struct){
          run: (#struct){
            shell: (string){ "bash" }
          }
        }
      }
      delete_build_branch: (#struct){
        "runs-on": (string){ "ubuntu-18.04" }
        if: (string){ "${{ startsWith(github.ref, 'refs/heads/ci/') && always() }}" }
        needs: (string){ "test" }
        steps: (#list){
          0: (#struct){
            run: (string){ "mkdir tmpgit\ncd tmpgit\ngit init\ngit config user.name cueckoo\ngit config user.email cueckoo@gmail.com\ngit config http.https://github.com/.extraheader \"AUTHORIZATION: basic $(echo -n cueckoo:${{ secrets.CUECKOO_GITHUB_PAT }} | base64)\"\ngit push https://github.com/cuelang/cue :${GITHUB_REF#refs/heads/}" }
          }
        }
        defaults: (#struct){
          run: (#struct){
            shell: (string){ "bash" }
          }
        }
      }
    }
    name: (string){ "Test" }
    on: (#struct){
      push: (#struct){
        branches: (#list){
          0: (string){ "**" }
        }
        "tags-ignore": (#list){
          0: (string){ "v*" }
        }
      }
    }
    _#isCLCITestBranch(:ci): (string){ "startsWith(github.ref, 'refs/heads/ci/')" }
    _#isMaster(:ci): (string){ "github.ref == 'refs/heads/master'" }
    _#pullThroughProxy(:ci): (#struct){
      name: (string){ "Pull this commit through the proxy on master" }
      run: (string){ "v=$(git rev-parse HEAD)\ncd $(mktemp -d)\ngo mod init mod.com\nGOPROXY=https://proxy.golang.org go get -d cuelang.org/go@$v" }
      if: (string){ "${{ github.ref == 'refs/heads/master' }}" }
    }
    _#failCLBuild(:ci): (#struct){
      if: (string){ "${{ startsWith(github.ref, 'refs/heads/ci/') && failure() }}" }
      name: (string){ "Post any failures for this matrix entry" }
      run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Build failed for ${{ runner.os }}-${{ matrix.go-version }}; see ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }} for more details\",\"labels\":{\"Code-Review\":-1}}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review" }
    }
    _#passCLBuild(:ci): (#struct){
      name: (string){ "Update Gerrit CL message with success message" }
      run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Build succeeded for ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}\",\"labels\":{\"Code-Review\":1}}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review" }
    }
    _#gerrit(:ci): (#struct){
      _#setCodeReview(:ci): (#struct){
        #args: (#struct){
          message: (string){ string }
        }
        res: (_|_){
          // [incomplete] invalid interpolation: cannot convert incomplete value "string" to JSON:
          //     ./workflows.cue:136:9
        }
      }
    }
  }
  test_dispatch: (#struct){
    #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
    #branch: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
      }, (list){
      }) }
    #container: (#struct){
      image: (string){ string }
    }
    #defaults: (#struct){
    }
    #env: (#struct){
    }
    #environment: (#struct){
      name: (string){ string }
    }
    #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
    #eventObject: (null){ null }
    #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
    #globs: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
    #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
    #path: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #ref: ((null|struct)){ |((null){ null }, (#struct){
      }) }
    #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
    #types: (list){
      0: (_){ _ }
    }
    #: (#struct){
      "working-directory": (string){ string }
    }
    jobs: (#struct){
      start: (#struct){
        if: (string){ "${{ startsWith(github.event.action, 'Build for refs/changes/') }}" }
        "runs-on": (string){ "ubuntu-18.04" }
        steps: (#list){
          0: (#struct){
            name: (string){ "Write the gitcookies file" }
            run: (string){ "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies" }
          }
          1: (#struct){
            name: (string){ "Update Gerrit CL message with starting message" }
            run: (string){ "curl -f -s -H \"Content-Type: application/json\" --request POST --data '{\"message\":\"Started the build... see progress at ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}\"}' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/${{ github.event.client_payload.changeID }}/revisions/${{ github.event.client_payload.commit }}/review" }
          }
          2: (#struct){
            name: (string){ "Checkout ref" }
            run: (string){ "mkdir tmpgit\ncd tmpgit\ngit init\ngit config user.name cueckoo\ngit config user.email cueckoo@gmail.com\ngit config http.https://github.com/.extraheader \"AUTHORIZATION: basic $(echo -n cueckoo:${{ secrets.CUECKOO_GITHUB_PAT }} | base64)\"\ngit fetch https://cue-review.googlesource.com/cue ${{ github.event.client_payload.ref }}\ngit checkout -b ci/${{ github.event.client_payload.changeID }}/${{ github.event.client_payload.commit }} FETCH_HEAD\ngit push https://github.com/cuelang/cue ci/${{ github.event.client_payload.changeID }}/${{ github.event.client_payload.commit }}" }
          }
        }
        defaults: (#struct){
          run: (#struct){
            shell: (string){ "bash" }
          }
        }
      }
    }
    name: (string){ "Test Dispatch" }
    on: (#list){
      0: (string){ "repository_dispatch" }
    }
    _#gerrit(:ci): (#struct){
      _#setCodeReview(:ci): (#struct){
        #args: (#struct){
          message: (string){ string }
        }
        res: (_|_){
          // [incomplete] invalid interpolation: cannot convert incomplete value "string" to JSON:
          //     ./workflows.cue:180:9
        }
      }
    }
  }
  release: (#struct){
    #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
    #branch: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
      }, (list){
      }) }
    #container: (#struct){
      image: (string){ string }
    }
    #defaults: (#struct){
    }
    #env: (#struct){
    }
    #environment: (#struct){
      name: (string){ string }
    }
    #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
    #eventObject: (null){ null }
    #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
    #globs: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
    #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
    #path: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #ref: ((null|struct)){ |((null){ null }, (#struct){
      }) }
    #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
    #types: (list){
      0: (_){ _ }
    }
    #: (#struct){
      "working-directory": (string){ string }
    }
    jobs: (#struct){
      goreleaser: (#struct){
        "runs-on": (string){ "ubuntu-18.04" }
        steps: (#list){
          0: (#struct){
            name: (string){ "Checkout code" }
            uses: (string){ "actions/checkout@v2" }
          }
          1: (#struct){
            name: (string){ "Unshallow" }
            run: (string){ "git fetch --prune --unshallow" }
          }
          2: (#struct){
            name: (string){ "Run GoReleaser" }
            env: (#struct){
              GITHUB_TOKEN: (string){ "${{ secrets.ACTIONS_GITHUB_TOKEN }}" }
            }
            uses: (string){ "docker://goreleaser/goreleaser:latest" }
            with: (#struct){
              args: (string){ "release --rm-dist" }
            }
          }
        }
        defaults: (#struct){
          run: (#struct){
            shell: (string){ "bash" }
          }
        }
      }
      docker: (#struct){
        name: (string){ "docker" }
        "runs-on": (string){ "ubuntu-18.04" }
        steps: (#list){
          0: (#struct){
            name: (string){ "Check out the repo" }
            uses: (string){ "actions/checkout@v2" }
          }
          1: (#struct){
            name: (string){ "Set version environment" }
            run: (string){ "CUE_VERSION=$(echo ${GITHUB_REF##refs/tags/v})\necho \"CUE_VERSION=$CUE_VERSION\"\necho \"CUE_VERSION=$(echo $CUE_VERSION)\" >> $GITHUB_ENV" }
          }
          2: (#struct){
            name: (string){ "Push to Docker Hub" }
            env: (#struct){
              DOCKER_BUILDKIT: (int){ 1 }
              GOLANG_VERSION: (float){ 1.14 }
              CUE_VERSION: (string){ "${{ env.CUE_VERSION }}" }
            }
            uses: (string){ "docker/build-push-action@v1" }
            with: (#struct){
              tags: (string){ "${{ env.CUE_VERSION }},latest" }
              repository: (string){ "cuelang/cue" }
              username: (string){ "${{ secrets.DOCKER_USERNAME }}" }
              password: (string){ "${{ secrets.DOCKER_PASSWORD }}" }
              tag_with_ref: (bool){ false }
              tag_with_sha: (bool){ false }
              target: (string){ "cue" }
              always_pull: (bool){ true }
              build_args: (string){ "GOLANG_VERSION=${{ env.GOLANG_VERSION }},CUE_VERSION=v${{ env.CUE_VERSION }}" }
              add_git_labels: (bool){ true }
            }
          }
        }
        defaults: (#struct){
          run: (#struct){
            shell: (string){ "bash" }
          }
        }
      }
    }
    name: (string){ "Release" }
    on: (#struct){
      push: (#struct){
        tags: (#list){
          0: (string){ "v*" }
        }
      }
    }
  }
  rebuild_tip_cuelang_org: (#struct){
    #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
    #branch: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
      }, (list){
      }) }
    #container: (#struct){
      image: (string){ string }
    }
    #defaults: (#struct){
    }
    #env: (#struct){
    }
    #environment: (#struct){
      name: (string){ string }
    }
    #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
    #eventObject: (null){ null }
    #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
    #globs: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
    #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
    #path: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #ref: ((null|struct)){ |((null){ null }, (#struct){
      }) }
    #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
    #types: (list){
      0: (_){ _ }
    }
    #: (#struct){
      "working-directory": (string){ string }
    }
    jobs: (#struct){
      push: (#struct){
        "runs-on": (string){ "ubuntu-18.04" }
        steps: (#list){
          0: (#struct){
            name: (string){ "Rebuild tip.cuelang.org" }
            run: (string){ "curl -f -X POST -d {} https://api.netlify.com/build_hooks/${{ secrets.CuelangOrgTipRebuildHook }}" }
          }
        }
        defaults: (#struct){
          run: (#struct){
            shell: (string){ "bash" }
          }
        }
      }
    }
    name: (string){ "Push to tip" }
    on: (#struct){
      push: (#struct){
        branches: (#list){
          0: (string){ "master" }
        }
      }
    }
  }
  _#bashWorkflow(:ci): (#struct){
    #architecture: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
    #branch: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #configuration: ((bool|string|list|struct|number)){ |((string){ string }, (number){ number }, (bool){ bool }, (#struct){
      }, (list){
      }) }
    #container: (#struct){
      image: (string){ string }
    }
    #defaults: (#struct){
    }
    #env: (#struct){
    }
    #environment: (#struct){
      name: (string){ string }
    }
    #event: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
    #eventObject: (null){ null }
    #expressionSyntax: (string){ =~"^\\$\\{\\{.*\\}\\}$" }
    #globs: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #machine: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
    #name: (string){ =~"^[_a-zA-Z][a-zA-Z0-9_-]*$" }
    #path: (list){
      0: (string){ strings.MinRunes(1) }
    }
    #ref: ((null|struct)){ |((null){ null }, (#struct){
      }) }
    #shell: (string){ |((string){ string }, (string){ "bash" }, (string){ "pwsh" }, (string){ "python" }, (string){ "sh" }, (string){ "cmd" }, (string){ "powershell" }) }
    #types: (list){
      0: (_){ _ }
    }
    #: (#struct){
      "working-directory": (string){ string }
    }
    jobs: (#struct){
    }
    on: ((string|list|struct)){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }, (list){
        0: (string){ |((string){ "check_run" }, (string){ "check_suite" }, (string){ "create" }, (string){ "delete" }, (string){ "deployment" }, (string){ "deployment_status" }, (string){ "fork" }, (string){ "gollum" }, (string){ "issue_comment" }, (string){ "issues" }, (string){ "label" }, (string){ "member" }, (string){ "milestone" }, (string){ "page_build" }, (string){ "project" }, (string){ "project_card" }, (string){ "project_column" }, (string){ "public" }, (string){ "pull_request" }, (string){ "pull_request_review" }, (string){ "pull_request_review_comment" }, (string){ "pull_request_target" }, (string){ "push" }, (string){ "registry_package" }, (string){ "release" }, (string){ "status" }, (string){ "watch" }, (string){ "workflow_dispatch" }, (string){ "workflow_run" }, (string){ "repository_dispatch" }) }
      }, (#struct){
      }) }
  }
  _#job(:ci): (#struct){
    "runs-on": ((string|list)){ |((string){ "macos-10.15" }, (string){ "macos-11.0" }, (string){ "macos-latest" }, (string){ "self-hosted" }, (string){ "ubuntu-16.04" }, (string){ "ubuntu-18.04" }, (string){ "ubuntu-20.04" }, (string){ "ubuntu-latest" }, (string){ "windows-2016" }, (string){ "windows-2019" }, (string){ "windows-latest" }, (#list){
        0: (string){ "self-hosted" }
      }, (#list){
        0: (string){ "self-hosted" }
        1: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
      }, (#list){
        0: (string){ "self-hosted" }
        1: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
      }, (#list){
        0: (string){ "self-hosted" }
        1: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
        2: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
      }, (#list){
        0: (string){ "self-hosted" }
        1: (string){ |((string){ "ARM32" }, (string){ "x64" }, (string){ "x86" }) }
        2: (string){ |((string){ "linux" }, (string){ "macos" }, (string){ "windows" }) }
      }, (string){ =~"^\\$\\{\\{.*\\}\\}$" }) }
  }
  _#step(:ci): (#struct){
  }
  _#codeGenGo(:ci): (string){ "1.14.9" }
  _#linuxMachine(:ci): (string){ "ubuntu-18.04" }
  _#macosMachine(:ci): (string){ "macos-10.15" }
  _#windowsMachine(:ci): (string){ "windows-2019" }
  _#testStrategy(:ci): (#struct){
    "fail-fast": (bool){ false }
    matrix: (#struct){
      "go-version": (#list){
        0: (string){ "1.13.x" }
        1: (string){ "1.14.9" }
        2: (string){ "1.15.x" }
      }
      os: (#list){
        0: (string){ "ubuntu-18.04" }
        1: (string){ "macos-10.15" }
        2: (string){ "windows-2019" }
      }
    }
  }
  _#installGo(:ci): (#struct){
    name: (string){ "Install Go" }
    uses: (string){ "actions/setup-go@v2" }
    with: (#struct){
      "go-version": (string){ "${{ matrix.go-version }}" }
    }
  }
  _#checkoutCode(:ci): (#struct){
    name: (string){ "Checkout code" }
    uses: (string){ "actions/checkout@v2" }
  }
  _#cacheGoModules(:ci): (#struct){
    name: (string){ "Cache Go modules" }
    uses: (string){ "actions/cache@v1" }
    with: (#struct){
      path: (string){ "~/go/pkg/mod" }
      key: (string){ "${{ runner.os }}-${{ matrix.go-version }}-go-${{ hashFiles('**/go.sum') }}" }
      "restore-keys": (string){ "${{ runner.os }}-${{ matrix.go-version }}-go-" }
    }
  }
  _#goGenerate(:ci): (#struct){
    name: (string){ "Generate" }
    run: (string){ "go generate ./..." }
    if: (string){ "matrix.go-version == '1.14.9' && matrix.os != 'windows-2019'" }
  }
  _#goTest(:ci): (#struct){
    name: (string){ "Test" }
    run: (string){ "go test ./..." }
  }
  _#goTestRace(:ci): (#struct){
    name: (string){ "Test with -race" }
    run: (string){ "go test -race ./..." }
  }
  _#goReleaseCheck(:ci): (#struct){
    name: (string){ "gorelease check" }
    run: (string){ "go run golang.org/x/exp/cmd/gorelease" }
  }
  _#checkGitClean(:ci): (#struct){
    name: (string){ "Check that git is clean post generate and tests" }
    run: (string){ "test -z \"$(git status --porcelain)\" || (git status; git diff; false)" }
  }
  _#writeCookiesFile(:ci): (#struct){
    name: (string){ "Write the gitcookies file" }
    run: (string){ "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies" }
  }
  _#branchRefPrefix(:ci): (string){ "refs/heads/" }
  _#tempCueckooGitDir(:ci): (string){ "mkdir tmpgit\ncd tmpgit\ngit init\ngit config user.name cueckoo\ngit config user.email cueckoo@gmail.com\ngit config http.https://github.com/.extraheader \"AUTHORIZATION: basic $(echo -n cueckoo:${{ secrets.CUECKOO_GITHUB_PAT }} | base64)\"" }
}
-- out/compile --
--- workflows.cue
{
  workflowsDir: (*"./"|string)
  _#masterBranch: "master"
  _#releaseTagPattern: "v*"
  workflows: ([
    ...{
      file: string
      schema: 〈import;"github.com/SchemaStore/schemastore/src/schemas/json"〉.#Workflow
    },
  ] & [
    {
      file: "test.yml"
      schema: 〈1;test〉
    },
    {
      file: "repository_dispatch.yml"
      schema: 〈1;repository_dispatch〉
    },
    {
      file: "release.yml"
      schema: 〈1;release〉
    },
    {
      file: "rebuild_tip_cuelang_org.yml"
      schema: 〈1;rebuild_tip_cuelang_org〉
    },
  ])
  test: (〈0;_#bashWorkflow〉 & {
    name: "Test"
    on: {
      push: {
        branches: [
          "**",
        ]
        "tags-ignore": [
          〈3;_#releaseTagPattern〉,
        ]
      }
    }
    jobs: {
      start: {
        "runs-on": 〈3;_#linuxMachine〉
        steps: ([
          ...(_ & {
            if: "${{ \(〈3;_#isCLCITestBranch〉) }}"
          }),
        ] & [
          〈3;_#writeCookiesFile〉,
          〈2;_#startCLBuild〉,
        ])
      }
      test: {
        needs: "start"
        strategy: 〈3;_#testStrategy〉
        "runs-on": "${{ matrix.os }}"
        steps: [
          〈3;_#writeCookiesFile〉,
          〈3;_#installGo〉,
          〈3;_#checkoutCode〉,
          〈3;_#cacheGoModules〉,
          〈3;_#goGenerate〉,
          〈3;_#goTest〉,
          (〈3;_#goTestRace〉 & {
            if: "${{ \(〈3;_#isMaster〉) || \(〈3;_#isCLCITestBranch〉) && matrix.go-version == '\(〈4;_#latestStableGo〉)' && matrix.os == '\(〈4;_#linuxMachine〉)' }}"
          }),
          〈3;_#goReleaseCheck〉,
          〈3;_#checkGitClean〉,
          〈2;_#pullThroughProxy〉,
          〈2;_#failCLBuild〉,
        ]
      }
      mark_ci_success: {
        "runs-on": 〈3;_#linuxMachine〉
        if: "${{ \(〈2;_#isCLCITestBranch〉) }}"
        needs: "test"
        steps: [
          〈3;_#writeCookiesFile〉,
          〈2;_#passCLBuild〉,
        ]
      }
      delete_build_branch: {
        "runs-on": 〈3;_#linuxMachine〉
        if: "${{ \(〈2;_#isCLCITestBranch〉) && always() }}"
        needs: "test"
        steps: [
          (〈3;_#step〉 & {
            run: "\(〈4;_#tempCueckooGitDir〉)
            git push https://github.com/cuelang/cue :${GITHUB_REF#\(〈4;_#branchRefPrefix〉)}"
          }),
        ]
      }
    }
    _#isCLCITestBranch: "startsWith(github.ref, '\(〈1;_#branchRefPrefix〉)ci/')"
    _#isMaster: "github.ref == '\((〈1;_#branchRefPrefix〉 + 〈1;_#masterBranch〉))'"
    _#pullThroughProxy: (〈1;_#step〉 & {
      name: "Pull this commit through the proxy on \(〈2;_#masterBranch〉)"
      run: "v=$(git rev-parse HEAD)\ncd $(mktemp -d)\ngo mod init mod.com\nGOPROXY=https://proxy.golang.org go get -d cuelang.org/go@$v"
      if: "${{ \(〈1;_#isMaster〉) }}"
    })
    _#startCLBuild: (〈1;_#step〉 & {
      name: "Update Gerrit CL message with starting message"
      run: (〈1;_#gerrit〉._#setCodeReview & {
        #args: {
          message: "Started the build... see progress at ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}"
        }
      }).res
    })
    _#failCLBuild: (〈1;_#step〉 & {
      if: "${{ \(〈1;_#isCLCITestBranch〉) && failure() }}"
      name: "Post any failures for this matrix entry"
      run: (〈1;_#gerrit〉._#setCodeReview & {
        #args: {
          message: "Build failed for ${{ runner.os }}-${{ matrix.go-version }}; see ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }} for more details"
          labels: {
            "Code-Review": -1
          }
        }
      }).res
    })
    _#passCLBuild: (〈1;_#step〉 & {
      name: "Update Gerrit CL message with success message"
      run: (〈1;_#gerrit〉._#setCodeReview & {
        #args: {
          message: "Build succeeded for ${{ github.event.repository.html_url }}/actions/runs/${{ github.run_id }}"
          labels: {
            "Code-Review": 1
          }
        }
      }).res
    })
    _#gerrit: {
      _#setCodeReview: {
        #args: {
          message: string
          labels?: {
            "Code-Review": int
          }
        }
        res: "curl -f -s -H "Content-Type: application/json" --request POST --data '\(〈import;"encoding/json"〉.Marshal(〈0;#args〉))' -b ~/.gitcookies https://cue-review.googlesource.com/a/changes/$(basename $(dirname $GITHUB_REF))/revisions/$(basename $GITHUB_REF)/review"
      }
    }
  })
  repository_dispatch: (〈0;_#bashWorkflow〉 & {
    name: "Repository Dispatch"
    on: [
      "repository_dispatch",
    ]
    jobs: {
      start: {
        if: "${{ startsWith(github.event.action, 'Build for refs/changes/') }}"
        "runs-on": 〈3;_#linuxMachine〉
        steps: [
          (〈3;_#step〉 & {
            name: "Checkout ref"
            run: "\(〈4;_#tempCueckooGitDir〉)
            git fetch https://cue-review.googlesource.com/cue ${{ github.event.client_payload.ref }}
            git checkout -b ci/${{ github.event.client_payload.changeID }}/${{ github.event.client_payload.commit }} FETCH_HEAD
            git push https://github.com/cuelang/cue ci/${{ github.event.client_payload.changeID }}/${{ github.event.client_payload.commit }}"
          }),
        ]
      }
    }
  })
  release: (〈0;_#bashWorkflow〉 & {
    name: "Release"
    on: {
      push: {
        tags: [
          〈3;_#releaseTagPattern〉,
        ]
      }
    }
    jobs: {
      goreleaser: {
        "runs-on": 〈3;_#linuxMachine〉
        steps: [
          {
            name: "Checkout code"
            uses: "actions/checkout@v2"
          },
          {
            name: "Unshallow"
            run: "git fetch --prune --unshallow"
          },
          {
            name: "Run GoReleaser"
            env: {
              GITHUB_TOKEN: "${{ secrets.ACTIONS_GITHUB_TOKEN }}"
            }
            uses: "docker://goreleaser/goreleaser:v0.110.0"
            with: {
              args: "release --rm-dist"
            }
          },
        ]
      }
      docker: {
        name: "docker"
        "runs-on": 〈3;_#linuxMachine〉
        steps: [
          {
            name: "Check out the repo"
            uses: "actions/checkout@v2"
          },
          {
            name: "Set version environment"
            run: "CUE_VERSION=$(echo ${GITHUB_REF##refs/tags/v})\necho \"CUE_VERSION=$CUE_VERSION\"\necho \"CUE_VERSION=$(echo $CUE_VERSION)\" >> $GITHUB_ENV"
          },
          {
            name: "Push to Docker Hub"
            env: {
              DOCKER_BUILDKIT: 1
              GOLANG_VERSION: 1.14
              CUE_VERSION: "${{ env.CUE_VERSION }}"
            }
            uses: "docker/build-push-action@v1"
            with: {
              tags: "${{ env.CUE_VERSION }},latest"
              repository: "cuelang/cue"
              username: "${{ secrets.DOCKER_USERNAME }}"
              password: "${{ secrets.DOCKER_PASSWORD }}"
              tag_with_ref: false
              tag_with_sha: false
              target: "cue"
              always_pull: true
              build_args: "GOLANG_VERSION=${{ env.GOLANG_VERSION }},CUE_VERSION=v${{ env.CUE_VERSION }}"
              add_git_labels: true
            }
          },
        ]
      }
    }
  })
  rebuild_tip_cuelang_org: (〈0;_#bashWorkflow〉 & {
    name: "Push to tip"
    on: {
      push: {
        branches: [
          〈3;_#masterBranch〉,
        ]
      }
    }
    jobs: {
      push: {
        "runs-on": 〈3;_#linuxMachine〉
        steps: [
          {
            name: "Rebuild tip.cuelang.org"
            run: "curl -f -X POST -d {} https://api.netlify.com/build_hooks/${{ secrets.CuelangOrgTipRebuildHook }}"
          },
        ]
      }
    }
  })
  _#bashWorkflow: (〈import;"github.com/SchemaStore/schemastore/src/schemas/json"〉.#Workflow & {
    jobs: {
      [string]: {
        defaults: {
          run: {
            shell: "bash"
          }
        }
      }
    }
  })
  _#job: ((〈import;"github.com/SchemaStore/schemastore/src/schemas/json"〉.#Workflow & {}).jobs & {
    x: _
  }).x
  _#step: ((〈0;_#job〉 & {
    steps: _
  }).steps & [
    _,
  ])[0]
  _#codeGenGo: "1.14.14"
  _#latestStableGo: "1.15.x"
  _#linuxMachine: "ubuntu-18.04"
  _#macosMachine: "macos-10.15"
  _#windowsMachine: "windows-2019"
  _#testStrategy: {
    "fail-fast": false
    matrix: {
      "go-version": [
        〈2;_#codeGenGo〉,
        〈2;_#latestStableGo〉,
        "1.16.0-rc1",
      ]
      os: [
        〈2;_#linuxMachine〉,
        〈2;_#macosMachine〉,
        〈2;_#windowsMachine〉,
      ]
    }
  }
  _#installGo: (〈0;_#step〉 & {
    name: "Install Go"
    uses: "actions/setup-go@v2"
    with: {
      "go-version": "${{ matrix.go-version }}"
      stable: false
    }
  })
  _#checkoutCode: (〈0;_#step〉 & {
    name: "Checkout code"
    uses: "actions/checkout@v2"
  })
  _#cacheGoModules: (〈0;_#step〉 & {
    name: "Cache Go modules"
    uses: "actions/cache@v1"
    with: {
      path: "~/go/pkg/mod"
      key: "${{ runner.os }}-${{ matrix.go-version }}-go-${{ hashFiles('**/go.sum') }}"
      "restore-keys": "${{ runner.os }}-${{ matrix.go-version }}-go-"
    }
  })
  _#goGenerate: (〈0;_#step〉 & {
    name: "Generate"
    run: "go generate ./..."
    if: "matrix.go-version == '\(〈1;_#codeGenGo〉)' && matrix.os != '\(〈1;_#windowsMachine〉)'"
  })
  _#goTest: (〈0;_#step〉 & {
    name: "Test"
    run: "go test ./..."
  })
  _#goTestRace: (〈0;_#step〉 & {
    name: "Test with -race"
    run: "go test -race ./..."
  })
  _#goReleaseCheck: (〈0;_#step〉 & {
    name: "gorelease check"
    run: "go run golang.org/x/exp/cmd/gorelease"
  })
  _#checkGitClean: (〈0;_#step〉 & {
    name: "Check that git is clean post generate and tests"
    run: "test -z \"$(git status --porcelain)\" || (git status; git diff; false)"
  })
  _#writeCookiesFile: (〈0;_#step〉 & {
    name: "Write the gitcookies file"
    run: "echo \"${{ secrets.gerritCookie }}\" > ~/.gitcookies"
  })
  _#branchRefPrefix: "refs/heads/"
  _#tempCueckooGitDir: "mkdir tmpgit\ncd tmpgit\ngit init\ngit config user.name cueckoo\ngit config user.email cueckoo@gmail.com\ngit config http.https://github.com/.extraheader \"AUTHORIZATION: basic $(echo -n cueckoo:${{ secrets.CUECKOO_GITHUB_PAT }} | base64)\""
}