refactor: VeryFastCompile for Task list

* feat: warn when enabling inactive experiments

* feat: TASK_ environment prefix

* feat: calculate experiment enabled/active instead of storing

* refactor: rename GetTaskVar to GetTaskEnv

* feat: experiments tests

.editorconfig

@@ -8,6 +8,6 @@ charset = utf-8
 trim_trailing_whitespace = true
 indent_style = tab
 
-[*.{md,mdx,yml,yaml,json,toml,htm,html,js,css,svg,sh,bash,fish}]
+[*.{md,mdx,yml,yaml,json,toml,htm,html,js,ts,css,svg,sh,bash,fish}]
 indent_style = space
 indent_size = 2

.github/CODE_OF_CONDUCT.md

@@ -34,7 +34,7 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at andrey@nering.com.br. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at task@taskfile.dev. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,20 +0,0 @@
----
-name: Bug Report
-about: Use this to report bugs and issues
----
-
-<!--
-
-Thanks for your bug report!
-
-Before submitting this issue, please make sure the same problem was not
-already reported by someone else.
-
-Please describe the bug you're facing. Consider pasting example Taskfiles
-showing how to reproduce the problem.
-
--->
-
-- Task version:
-- Operating system:
-- Experiments enabled:

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,69 @@
+name: '🐞 Bug Report'
+description: Report a bug in Task.
+labels: ['state: needs-triage']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your bug report!
+
+        Before submitting, please check the list of [existing issues](https://github.com/go-task/task/issues) and make sure the same bug was not already reported by someone else.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Describe the bug you're seeing.
+      placeholder: |
+        - What did you do?
+        - What did you expect to happen?
+        - What happened instead?
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: Version
+      description: What version(s) of Task is the issue occurring on?
+    validations:
+      required: true
+
+  - type: input
+    id: os
+    attributes:
+      label: Operating system
+      description: What operating system(s) is the issue occurring on?
+    validations:
+      required: true
+
+  - type: dropdown
+    id: experiments
+    attributes:
+      label: Experiments Enabled
+      description: Do you have any experiments enabled? You can check by running `task --experiments`.
+      multiple: true
+      options:
+        - Env Precedence
+        - Gentle Force
+        - Map Variables (1)
+        - Map Variables (2)
+        - Remote Taskfiles
+    validations:
+      required: false
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Example Taskfile
+      description: |
+        If you have a Taskfile that reproduces the issue, please paste it here.
+        This will be automatically formatted into code, so no need for backticks.
+      render: YAML
+      placeholder: |
+        version: '3'
+
+        tasks:
+          default:
+            cmds:
+              - 'echo "This Taskfile is buggy :("'

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +1,11 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Extension for Visual Studio Code
+  - name: '🔌 Task for Visual Studio Code'
     url: https://github.com/go-task/vscode-task
-    about: Issues related to the Visual Studio Code extension should be opened here.
-  - name: Help forum on Discord
-    url: https://discord.gg/6TY36E39UK
-    about: 'The Discord #help channel is the best way to get help from the community.'
-  - name: Questions, Ideas and General Discussions
+    about: 'Issues related to the Visual Studio Code extension should be opened here.'
+  - name: '💬 Help forum on Discord'
+    url: https://discord.com/channels/974121106208354339/1025054680289660989
+    about: 'The #help channel on our Discord is the best way to get help from the community.'
+  - name: '❓ Questions, Ideas and General Discussions'
     url: https://github.com/go-task/task/discussions
-    about: Ask questions and discuss general ideas with the community.
+    about: 'Ask questions and discuss general ideas with the community.'

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,15 +0,0 @@
----
-name: Feature Request
-about: Use this to make feature requests
----
-
-<!--
-
-Describe in detail what feature do you want to see in Task.
-Give examples if possible.
-
-Please, search if this wasn't proposed before, and if this is more like an idea
-than a strong feature request, consider opening a
-[discussion](https://github.com/go-task/task/discussions) instead.
-
--->

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,23 @@
+name: '✨ Feature Request'
+description: Suggest a new feature or enhancement for Task.
+labels: ['state: needs-triage']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your feature request!
+
+        Before submitting, please check the list of [existing issues](https://github.com/go-task/task/issues) and make sure the same change was not already requested by someone else.
+        If your request is more of an idea than a feature request, consider opening a [discussion](https://github.com/go-task/task/discussions) instead.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Describe the feature/enhancement you want to see in Task.
+      placeholder: |
+        - Give a general overview of the feature/enhancement.
+        - Explain problem is the change trying to solve.
+        - Give examples of how you would use the feature.
+    validations:
+      required: true

.github/dependabot.yml

@@ -1,24 +0,0 @@
-version: 2
-
-updates:
-  - package-ecosystem: gomod
-    directory: /
-    schedule:
-      interval: weekly
-      day: saturday
-      time: '08:00'
-      timezone: America/Sao_Paulo
-    labels:
-      - "area: dependencies"
-      - "lang: go"
-
-  - package-ecosystem: npm
-    directory: /
-    schedule:
-      interval: weekly
-      day: saturday
-      time: '08:00'
-      timezone: America/Sao_Paulo
-    labels:
-      - "area: dependencies"
-      - "lang: javascript"

.github/renovate.json

@@ -3,46 +3,23 @@
   "extends": [
     "config:recommended",
     "group:allNonMajor",
-    "schedule:monthly"
+    "schedule:weekly",
+    ":semanticCommitTypeAll(chore)"
   ],
   "mode": "full",
-  "reviewers": ["team:developer"],
+  "addLabels":["area: dependencies"],
   "packageRules": [
     {
       "matchManagers": ["github-actions"],
-      "groupName": "Github Action",
-      "labels": ["area: github actions", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "addLabels": ["area: github actions"]
     },
     {
-      "matchManagers": ["npm", "nvm"],
-      "groupName": "Website",
-      "labels": ["lang: javascript", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "matchCategories": ["js", "node"],
+      "addLabels": ["lang: javascript"]
     },
     {
-      "matchManagers": ["gomod"],
-      "groupName": "golang",
-      "labels": ["lang: go", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "matchCategories": ["golang"],
+      "addLabels": ["lang: go"]
     }
   ]
 }

.golangci.yml

@@ -10,6 +10,11 @@ linters:
     - gofmt
     - gofumpt
     - misspell
+    - noctx
+    - paralleltest
+    - tenv
+    - thelper
+    - tparallel
 
 linters-settings:
   depguard:

.goreleaser.yml

@@ -57,7 +57,7 @@ checksum:
 nfpms:
   - vendor: Task
     homepage: https://taskfile.dev
-    maintainer: Andrey Nering <andrey@nering.com.br>
+    maintainer: The Task authors <task@taskfile.dev>
     description: Simple task runner written in Go
     license: MIT
     conflicts:

.nvmrc

@@ -1 +1 @@
-18.20.4
+22.13.1

CHANGELOG.md

@@ -1,11 +1,53 @@
 # Changelog
 
+## Unreleased
+
+- Made `--init` less verbose by default and respect `--silent` and `--verbose`
+  flags (#2009, #2011 by @HeCorr).
+- Fix a bug where an HTTP node's location was being mutated incorrectly (#2007
+  by @jeongukjae).
+- Fixed a bug where allowed values didn't work with dynamic var (#2032, #2033 by
+  @vmaerten).
+- Use only the relevant checker (timestamp or checksum) to improve performance
+  (#2029, #2031 by @vmaerten).
+- Print warnings when attempting to enable an inactive experiment or an active
+  experiment with an invalid value (#1979, #2049 by @pd93).
+- Refactored the experiments package and added tests (#2049 by @pd93).
+
+## v3.41.0 - 2025-01-18
+
+- Fixed an issue where dynamic variables were not properly logged in verbose
+  mode (#1920, #1921 by @mgbowman).
+- Support `silent` for defer statements (#1877, #1879 by @danilobuerger).
+- Added an option to exclude some tasks from being included (#1859 by
+  @vmaerten).
+- Fixed an issue where a required variable was incorrectly handled in a template
+  function (#1950, #1962 by @vmaerten).
+- Expose a new `TASK_DIR` special variable, which will contain the absolute path
+  of task directory. (#1959, #1961 by @vmaerten).
+- Fixed fatal bugs that caused concurrent map writes (#1605, #1972, #1974 by
+  @pd93, @GrahamDennis and @trim21).
+- Refactored internal ordered map implementation to use
+  [github.com/elliotchance/orderedmap](https://github.com/elliotchance/orderedmap)
+  (#1797 by @pd93).
+- Fixed a bug where variables defined at the task level were being ignored in
+  the `requires` section. (#1960, #1955, #1768 by @vmaerten and @mokeko)
+- The `CHECKSUM` and `TIMESTAMP` variables are now accessible within `cmds`
+  (#1872 by @niklasr22).
+- Updated [installation docs](https://taskfile.dev/installation) and added pip
+  installation method (#935, #1989 by @pd93).
+- Fixed a bug where dynamic variables could not access environment variables
+  (#630, #1869 by @rohm1 and @pd93).
+- Disable version check for use as an external library (#1938 by @leaanthony).
+
 ## v3.40.1 - 2024-12-06
 
-- Fixed a security issue in `git-urls` by switching to the maintained fork `chainguard-dev/git-urls` (#1917 by
-  @AlekSi).
-- Added missing `platforms` property to `cmds` that use `for` (#1915 by @dkarter).
-- Added misspell linter to check for misspelled English words (#1883 by @christiandins).
+- Fixed a security issue in `git-urls` by switching to the maintained fork
+  `chainguard-dev/git-urls` (#1917 by @AlekSi).
+- Added missing `platforms` property to `cmds` that use `for` (#1915 by
+  @dkarter).
+- Added misspell linter to check for misspelled English words (#1883 by
+  @christiandins).
 
 ## v3.40.0 - 2024-11-05
 
@@ -299,8 +341,8 @@
 - Added the
   [Remote Taskfiles experiment](https://taskfile.dev/experiments/remote-taskfiles)
   as a draft (#1152, #1317 by @pd93).
-- Improve performance of content checksumming on `sources:` by replacing md5 with
-  [XXH3](https://xxhash.com/) which is much faster. This is a soft breaking
+- Improve performance of content checksumming on `sources:` by replacing md5
+  with [XXH3](https://xxhash.com/) which is much faster. This is a soft breaking
   change because checksums will be invalidated when upgrading to this release
   (#1325 by @ReillyBrogan).
 
@@ -447,8 +489,8 @@ it a go and let us know what you think via a
 - Fixed a bug where tasks were sometimes incorrectly marked as internal (#1007
   by @pd93).
 - Update to Go 1.20 (bump minimum version to 1.19) (#1010 by @pd93)
-- Added environment variable `FORCE_COLOR` support to force color output.
-  Useful for environments without TTY (#1003 by @automation-stack)
+- Added environment variable `FORCE_COLOR` support to force color output. Useful
+  for environments without TTY (#1003 by @automation-stack)
 
 ## v3.20.0 - 2023-01-14
 

README.md

@@ -10,6 +10,18 @@
   </p>
 
   <p>
-    <a href="https://taskfile.dev/installation/">Installation</a> | <a href="https://taskfile.dev/usage/">Documentation</a> | <a href="https://twitter.com/taskfiledev">Twitter</a> | <a href="https://fosstodon.org/@task">Mastodon</a> | <a href="https://discord.gg/6TY36E39UK">Discord</a>
+    <a href="https://taskfile.dev/installation/">Installation</a> | <a href="https://taskfile.dev/usage/">Documentation</a> | <a href="https://twitter.com/taskfiledev">Twitter</a> | <a href="https://bsky.app/profile/taskfile.dev">Bluesky</a> | <a href="https://fosstodon.org/@task">Mastodon</a> | <a href="https://discord.gg/6TY36E39UK">Discord</a>
   </p>
+
+  <h1>Gold Sponsors</h1>
+
+  <table>
+    <tr>
+      <td align="center" valign="middle">
+        <a target="_blank" href="https://devowl.io">
+          <img src="/website/static/img/devowl.io.svg" height="100px" title="devowl.io" />
+        </a>
+      </td>
+    </tr>
+  </table>
 </div>

Taskfile.yml

@@ -98,21 +98,17 @@ tasks:
   test:
     desc: Runs test suite
     aliases: [t]
-    deps: [install]
+    sources:
+      - "**/*.go"
+      - "testdata/**/*"
     cmds:
-      - go test {{catLines .GO_PACKAGES}}
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
+      - go test ./...
 
   test:all:
     desc: Runs test suite with signals and watch tests included
-    deps: [install, sleepit:build]
+    deps: [sleepit:build]
     cmds:
-      - go test {{catLines .GO_PACKAGES}} -tags 'signals watch'
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
+      - go test -tags 'signals watch' ./...
 
   goreleaser:test:
     desc: Tests release process without publishing
@@ -176,11 +172,3 @@ tasks:
     desc: Publish release to npm
     cmds:
       - npm publish --access=public
-
-  packages:
-    cmds:
-      - echo '{{.GO_PACKAGES}}'
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
-    silent: true

args/args.go

@@ -9,7 +9,7 @@ import (
 // Parse parses command line argument: tasks and global variables
 func Parse(args ...string) ([]*ast.Call, *ast.Vars) {
 	calls := []*ast.Call{}
-	globals := &ast.Vars{}
+	globals := ast.NewVars()
 
 	for _, arg := range args {
 		if !strings.Contains(arg, "=") {

args/args_test.go

@@ -7,11 +7,12 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/go-task/task/v3/args"
-	"github.com/go-task/task/v3/internal/omap"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestArgs(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		Args            []string
 		ExpectedCalls   []*ast.Call
@@ -32,30 +33,40 @@ func TestArgs(t *testing.T) {
 				{Task: "task-b"},
 				{Task: "task-c"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
-						"BAR": {Value: "baz"},
-						"BAZ": {Value: "foo"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO", "BAR", "BAZ"},
-				),
-			},
+				},
+				&ast.VarElement{
+					Key: "BAR",
+					Value: ast.Var{
+						Value: "baz",
+					},
+				},
+				&ast.VarElement{
+					Key: "BAZ",
+					Value: ast.Var{
+						Value: "foo",
+					},
+				},
+			),
 		},
 		{
 			Args: []string{"task-a", "CONTENT=with some spaces"},
 			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"CONTENT": {Value: "with some spaces"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "CONTENT",
+					Value: ast.Var{
+						Value: "with some spaces",
 					},
-					[]string{"CONTENT"},
-				),
-			},
+				},
+			),
 		},
 		{
 			Args: []string{"FOO=bar", "task-a", "task-b"},
@@ -63,14 +74,14 @@ func TestArgs(t *testing.T) {
 				{Task: "task-a"},
 				{Task: "task-b"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO"},
-				),
-			},
+				},
+			),
 		},
 		{
 			Args:          nil,
@@ -83,25 +94,32 @@ func TestArgs(t *testing.T) {
 		{
 			Args:          []string{"FOO=bar", "BAR=baz"},
 			ExpectedCalls: []*ast.Call{},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
-						"BAR": {Value: "baz"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO", "BAR"},
-				),
-			},
+				},
+				&ast.VarElement{
+					Key: "BAR",
+					Value: ast.Var{
+						Value: "baz",
+					},
+				},
+			),
 		},
 	}
 
 	for i, test := range tests {
 		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
+			t.Parallel()
+
 			calls, globals := args.Parse(test.Args...)
 			assert.Equal(t, test.ExpectedCalls, calls)
 			if test.ExpectedGlobals.Len() > 0 || globals.Len() > 0 {
-				assert.Equal(t, test.ExpectedGlobals.Keys(), globals.Keys())
-				assert.Equal(t, test.ExpectedGlobals.Values(), globals.Values())
+				assert.Equal(t, test.ExpectedGlobals, globals)
+				assert.Equal(t, test.ExpectedGlobals, globals)
 			}
 		})
 	}

cmd/task/task.go

@@ -44,7 +44,7 @@ func main() {
 }
 
 func run() error {
-	logger := &logger.Logger{
+	log := &logger.Logger{
 		Stdout:  os.Stdout,
 		Stderr:  os.Stderr,
 		Verbose: flags.Verbose,
@@ -69,7 +69,7 @@ func run() error {
 	}
 
 	if flags.Experiments {
-		return experiments.List(logger)
+		return log.PrintExperiments()
 	}
 
 	if flags.Init {
@@ -77,9 +77,18 @@ func run() error {
 		if err != nil {
 			return err
 		}
+
 		if err := task.InitTaskfile(os.Stdout, wd); err != nil {
 			return err
 		}
+
+		if !flags.Silent {
+			if flags.Verbose {
+				log.Outf(logger.Default, "%s\n", task.DefaultTaskfile)
+			}
+			log.Outf(logger.Green, "%s created in the current directory\n", task.DefaultTaskFilename)
+		}
+
 		return nil
 	}
 
@@ -100,6 +109,10 @@ func run() error {
 		dir = home
 	}
 
+	if err := experiments.Validate(); err != nil {
+		log.Warnf("%s\n", err.Error())
+	}
+
 	var taskSorter sort.TaskSorter
 	switch flags.TaskSort {
 	case "none":
@@ -132,8 +145,9 @@ func run() error {
 		Stdout: os.Stdout,
 		Stderr: os.Stderr,
 
-		OutputStyle: flags.Output,
-		TaskSorter:  taskSorter,
+		OutputStyle:        flags.Output,
+		TaskSorter:         taskSorter,
+		EnableVersionCheck: true,
 	}
 	listOptions := task.NewListOptions(flags.List, flags.ListAll, flags.ListJson, flags.NoStatus)
 	if err := listOptions.Validate(); err != nil {
@@ -144,9 +158,6 @@ func run() error {
 	if err != nil {
 		return err
 	}
-	if experiments.AnyVariables.Enabled {
-		logger.Warnf("The 'Any Variables' experiment flag is no longer required to use non-map variable types. If you wish to use map variables, please use 'TASK_X_MAP_VARIABLES' instead. See https://github.com/go-task/task/issues/1585\n")
-	}
 
 	// If the download flag is specified, we should stop execution as soon as
 	// taskfile is downloaded

go.mod

@@ -5,26 +5,27 @@ go 1.22.0
 require (
 	github.com/Ladicle/tabwriter v1.0.0
 	github.com/Masterminds/semver/v3 v3.3.1
-	github.com/alecthomas/chroma/v2 v2.14.0
+	github.com/alecthomas/chroma/v2 v2.15.0
 	github.com/chainguard-dev/git-urls v1.0.2
 	github.com/davecgh/go-spew v1.1.1
 	github.com/dominikbraun/graph v0.23.0
+	github.com/elliotchance/orderedmap/v2 v2.7.0
 	github.com/fatih/color v1.18.0
-	github.com/go-git/go-billy/v5 v5.6.0
-	github.com/go-git/go-git/v5 v5.12.0
+	github.com/go-git/go-billy/v5 v5.6.2
+	github.com/go-git/go-git/v5 v5.13.2
 	github.com/go-task/slim-sprig/v3 v3.0.0
 	github.com/go-task/template v0.1.0
 	github.com/joho/godotenv v1.5.1
 	github.com/mattn/go-zglob v0.0.6
 	github.com/mitchellh/hashstructure/v2 v2.0.2
-	github.com/otiai10/copy v1.14.0
+	github.com/otiai10/copy v1.14.1
 	github.com/radovskyb/watcher v1.0.7
 	github.com/sajari/fuzzy v1.0.0
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.10.0
 	github.com/zeebo/xxh3 v1.0.2
-	golang.org/x/sync v0.9.0
-	golang.org/x/term v0.26.0
+	golang.org/x/sync v0.10.0
+	golang.org/x/term v0.28.0
 	gopkg.in/yaml.v3 v3.0.1
 	mvdan.cc/sh/v3 v3.10.0
 )
@@ -32,10 +33,10 @@ require (
 require (
 	dario.cat/mergo v1.0.0 // indirect
 	github.com/Microsoft/go-winio v0.6.1 // indirect
-	github.com/ProtonMail/go-crypto v1.0.0 // indirect
+	github.com/ProtonMail/go-crypto v1.1.5 // indirect
 	github.com/cloudflare/circl v1.3.7 // indirect
-	github.com/cyphar/filepath-securejoin v0.2.5 // indirect
-	github.com/dlclark/regexp2 v1.11.0 // indirect
+	github.com/cyphar/filepath-securejoin v0.3.6 // indirect
+	github.com/dlclark/regexp2 v1.11.4 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
@@ -45,16 +46,17 @@ require (
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/pjbgf/sha1cd v0.3.0 // indirect
+	github.com/otiai10/mint v1.6.3 // indirect
+	github.com/pjbgf/sha1cd v0.3.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
-	github.com/skeema/knownhosts v1.2.2 // indirect
+	github.com/skeema/knownhosts v1.3.0 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
-	golang.org/x/crypto v0.25.0 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
 	golang.org/x/mod v0.18.0 // indirect
-	golang.org/x/net v0.27.0 // indirect
-	golang.org/x/sys v0.27.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
+	golang.org/x/sys v0.29.0 // indirect
 	golang.org/x/tools v0.22.0 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 )

go.sum

@@ -7,51 +7,61 @@ github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lpr
 github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
 github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
 github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
-github.com/ProtonMail/go-crypto v1.0.0 h1:LRuvITjQWX+WIfr930YHG2HNfjR1uOfyf5vE0kC2U78=
-github.com/ProtonMail/go-crypto v1.0.0/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0=
+github.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk=
+github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
+github.com/ProtonMail/go-crypto v1.1.5 h1:eoAQfK2dwL+tFSFpr7TbOaPNUbPiJj4fLYwwGE1FQO4=
+github.com/ProtonMail/go-crypto v1.1.5/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
 github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
 github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
 github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
 github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
+github.com/alecthomas/chroma/v2 v2.15.0 h1:LxXTQHFoYrstG2nnV9y2X5O94sOBzf0CIUpSTbpxvMc=
+github.com/alecthomas/chroma/v2 v2.15.0/go.mod h1:gUhVLrPDXPtp/f+L1jo9xepo9gL4eLwRuGAunSZMkio=
 github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
 github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
-github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
 github.com/chainguard-dev/git-urls v1.0.2 h1:pSpT7ifrpc5X55n4aTTm7FFUE+ZQHKiqpiwNkJrVcKQ=
 github.com/chainguard-dev/git-urls v1.0.2/go.mod h1:rbGgj10OS7UgZlbzdUQIQpT0k/D4+An04HJY7Ol+Y/o=
-github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
 github.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU=
 github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA=
 github.com/creack/pty v1.1.23 h1:4M6+isWdcStXEf15G/RbrMPOQj1dZ7HPZCGwE4kOeP0=
 github.com/creack/pty v1.1.23/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
-github.com/cyphar/filepath-securejoin v0.2.5 h1:6iR5tXJ/e6tJZzzdMc1km3Sa7RRIVBKAK32O2s7AYfo=
-github.com/cyphar/filepath-securejoin v0.2.5/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=
+github.com/cyphar/filepath-securejoin v0.3.6 h1:4d9N5ykBnSp5Xn2JkhocYDkOpURL/18CYMpo6xB9uWM=
+github.com/cyphar/filepath-securejoin v0.3.6/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
 github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
+github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dominikbraun/graph v0.23.0 h1:TdZB4pPqCLFxYhdyMFb1TBdFxp8XLcJfTTBQucVPgCo=
 github.com/dominikbraun/graph v0.23.0/go.mod h1:yOjYyogZLY1LSG9E33JWZJiq5k83Qy2C6POAuiViluc=
-github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a h1:mATvB/9r/3gvcejNsXKSkQ6lcIaNec2nyfOdlTBR2lU=
-github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a/go.mod h1:Ro8st/ElPeALwNFlcTpWmkr6IoMFfkjXAvTHpevnDsM=
+github.com/elazarl/goproxy v1.2.3 h1:xwIyKHbaP5yfT6O9KIeYJR5549MXRQkoQMRXGztz8YQ=
+github.com/elazarl/goproxy v1.2.3/go.mod h1:YfEbZtqP4AetfO6d40vWchF3znWX7C7Vd6ZMfdL8z64=
+github.com/elliotchance/orderedmap/v2 v2.7.0 h1:WHuf0DRo63uLnldCPp9ojm3gskYwEdIIfAUVG5KhoOc=
+github.com/elliotchance/orderedmap/v2 v2.7.0/go.mod h1:85lZyVbpGaGvHvnKa7Qhx7zncAdBIBq6u56Hb1PRU5Q=
 github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
 github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/gliderlabs/ssh v0.3.7 h1:iV3Bqi942d9huXnzEF2Mt+CY9gLu8DNM4Obd+8bODRE=
-github.com/gliderlabs/ssh v0.3.7/go.mod h1:zpHEXBstFnQYtGnB8k8kQLol82umzn/2/snG7alWVD8=
+github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
+github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
-github.com/go-git/go-billy/v5 v5.6.0 h1:w2hPNtoehvJIxR00Vb4xX94qHQi/ApZfX+nBE2Cjio8=
-github.com/go-git/go-billy/v5 v5.6.0/go.mod h1:sFDq7xD3fn3E0GOwUSZqHo9lrkmx8xJhA0ZrfvjBRGM=
+github.com/go-git/go-billy/v5 v5.6.1 h1:u+dcrgaguSSkbjzHwelEjc0Yj300NUevrrPphk/SoRA=
+github.com/go-git/go-billy/v5 v5.6.1/go.mod h1:0AsLr1z2+Uksi4NlElmMblP5rPcDZNRCD8ujZCRR2BE=
+github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
+github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
 github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
 github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
-github.com/go-git/go-git/v5 v5.12.0 h1:7Md+ndsjrzZxbddRDZjF14qK+NN56sy6wkqaVrjZtys=
-github.com/go-git/go-git/v5 v5.12.0/go.mod h1:FTM9VKtnI2m65hNI/TenDDDnUf2Q9FHnXYjuz9i5OEY=
+github.com/go-git/go-git/v5 v5.13.1 h1:DAQ9APonnlvSWpvolXWIuV6Q6zXy2wHbN4cVlNR5Q+M=
+github.com/go-git/go-git/v5 v5.13.1/go.mod h1:qryJB4cSBoq3FRoBRf5A77joojuBcmPJ0qu3XXXVixc=
+github.com/go-git/go-git/v5 v5.13.2 h1:7O7xvsK7K+rZPKW6AQR1YyNhfywkv7B8/FsP3ki6Zv0=
+github.com/go-git/go-git/v5 v5.13.2/go.mod h1:hWdW5P4YZRjmpGHwRH2v3zkWcNl6HeXaXQEMGb3NJ9A=
 github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
 github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
 github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
@@ -94,10 +104,16 @@ github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
 github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
 github.com/otiai10/copy v1.14.0 h1:dCI/t1iTdYGtkvCuBG2BgR6KZa83PTclw4U5n2wAllU=
 github.com/otiai10/copy v1.14.0/go.mod h1:ECfuL02W+/FkTWZWgQqXPWZgW9oeKCSQ5qVfSc4qc4w=
+github.com/otiai10/copy v1.14.1 h1:5/7E6qsUMBaH5AnQ0sSLzzTg1oTECmcCmT6lvF45Na8=
+github.com/otiai10/copy v1.14.1/go.mod h1:oQwrEDDOci3IM8dJF0d8+jnbfPDllW6vUjNc3DoZm9I=
 github.com/otiai10/mint v1.5.1 h1:XaPLeE+9vGbuyEHem1JNk3bYc7KKqyI/na0/mLd/Kks=
 github.com/otiai10/mint v1.5.1/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
+github.com/otiai10/mint v1.6.3 h1:87qsV/aw1F5as1eH1zS/yqHY85ANKVMgkDrf9rcxbQs=
+github.com/otiai10/mint v1.6.3/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
 github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=
 github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=
+github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
+github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -111,8 +127,8 @@ github.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/skeema/knownhosts v1.2.2 h1:Iug2P4fLmDw9f41PB6thxUkNUkJzB5i+1/exaj40L3A=
-github.com/skeema/knownhosts v1.2.2/go.mod h1:xYbVRSPxqBZFrdmDyMmsOs+uX1UZC3nTN3ThzgDxUwo=
+github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY=
+github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@@ -124,77 +140,50 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
 github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
 github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
 github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
 github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
-golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
-golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
-golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
 golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
-golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
-golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
-golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
-golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
-golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU=
-golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
+golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
 golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=

init.go

@@ -1,7 +1,6 @@
 package task
 
 import (
-	"fmt"
 	"io"
 	"os"
 
@@ -9,7 +8,7 @@ import (
 	"github.com/go-task/task/v3/internal/filepathext"
 )
 
-const defaultTaskfile = `# https://taskfile.dev
+const DefaultTaskfile = `# https://taskfile.dev
 
 version: '3'
 
@@ -23,19 +22,19 @@ tasks:
     silent: true
 `
 
-const defaultTaskfileName = "Taskfile.yml"
+const DefaultTaskFilename = "Taskfile.yml"
 
-// InitTaskfile Taskfile creates a new Taskfile
+// InitTaskfile creates a new Taskfile
 func InitTaskfile(w io.Writer, dir string) error {
-	f := filepathext.SmartJoin(dir, defaultTaskfileName)
+	f := filepathext.SmartJoin(dir, DefaultTaskFilename)
 
 	if _, err := os.Stat(f); err == nil {
 		return errors.TaskfileAlreadyExistsError{}
 	}
 
-	if err := os.WriteFile(f, []byte(defaultTaskfile), 0o644); err != nil {
+	if err := os.WriteFile(f, []byte(DefaultTaskfile), 0o644); err != nil {
 		return err
 	}
-	fmt.Fprintf(w, "%s created in the current directory\n", defaultTaskfile)
+
 	return nil
 }

init_test.go

@@ -0,0 +1,31 @@
+package task_test
+
+import (
+	"io"
+	"os"
+	"testing"
+
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/internal/filepathext"
+)
+
+func TestInit(t *testing.T) {
+	t.Parallel()
+
+	const dir = "testdata/init"
+	file := filepathext.SmartJoin(dir, "Taskfile.yml")
+
+	_ = os.Remove(file)
+	if _, err := os.Stat(file); err == nil {
+		t.Errorf("Taskfile.yml should not exist")
+	}
+
+	if err := task.InitTaskfile(io.Discard, dir); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := os.Stat(file); err != nil {
+		t.Errorf("Taskfile.yml should exist")
+	}
+	_ = os.Remove(file)
+}

internal/compiler/compiler.go

@@ -4,12 +4,12 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"maps"
 	"os"
 	"path/filepath"
 	"strings"
 	"sync"
 
+	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/logger"
@@ -80,7 +80,7 @@ func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool
 				return nil
 			}
 			// If the variable is dynamic, we need to resolve it first
-			static, err := c.HandleDynamicVar(newVar, dir)
+			static, err := c.HandleDynamicVar(newVar, dir, env.GetFromVars(result))
 			if err != nil {
 				return err
 			}
@@ -132,7 +132,7 @@ func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool
 	return result, nil
 }
 
-func (c *Compiler) HandleDynamicVar(v ast.Var, dir string) (string, error) {
+func (c *Compiler) HandleDynamicVar(v ast.Var, dir string, e []string) (string, error) {
 	c.muDynamicCache.Lock()
 	defer c.muDynamicCache.Unlock()
 
@@ -159,6 +159,7 @@ func (c *Compiler) HandleDynamicVar(v ast.Var, dir string) (string, error) {
 		Dir:     dir,
 		Stdout:  &stdout,
 		Stderr:  c.Logger.Stderr,
+		Env:     e,
 	}
 	if err := execext.RunCommand(context.Background(), opts); err != nil {
 		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
@@ -170,7 +171,7 @@ func (c *Compiler) HandleDynamicVar(v ast.Var, dir string) (string, error) {
 	result = strings.TrimSuffix(result, "\n")
 
 	c.dynamicCache[*v.Sh] = result
-	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", v.Sh, result)
+	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", *v.Sh, result)
 
 	return result, nil
 }
@@ -192,10 +193,14 @@ func (c *Compiler) getSpecialVars(t *ast.Task, call *ast.Call) (map[string]strin
 		"TASK_VERSION":     version.GetVersion(),
 	}
 	if t != nil {
-		maps.Copy(allVars, map[string]string{"TASK": t.Task, "TASKFILE": t.Location.Taskfile, "TASKFILE_DIR": filepath.Dir(t.Location.Taskfile)})
+		allVars["TASK"] = t.Task
+		allVars["TASK_DIR"] = filepathext.SmartJoin(c.Dir, t.Dir)
+		allVars["TASKFILE"] = t.Location.Taskfile
+		allVars["TASKFILE_DIR"] = filepath.Dir(t.Location.Taskfile)
 	}
 	if call != nil {
-		maps.Copy(allVars, map[string]string{"ALIAS": call.Task})
+		allVars["ALIAS"] = call.Task
 	}
+
 	return allVars, nil
 }

internal/compiler/env.go

@@ -10,7 +10,7 @@ import (
 // GetEnviron the all return all environment variables encapsulated on a
 // ast.Vars
 func GetEnviron() *ast.Vars {
-	m := &ast.Vars{}
+	m := ast.NewVars()
 	for _, e := range os.Environ() {
 		keyVal := strings.SplitN(e, "=", 2)
 		key, val := keyVal[0], keyVal[1]

internal/deepcopy/deepcopy.go

@@ -2,6 +2,8 @@ package deepcopy
 
 import (
 	"reflect"
+
+	"github.com/elliotchance/orderedmap/v2"
 )
 
 type Copier[T any] interface {
@@ -38,6 +40,21 @@ func Map[K comparable, V any](orig map[K]V) map[K]V {
 	return c
 }
 
+func OrderedMap[K comparable, V any](orig *orderedmap.OrderedMap[K, V]) *orderedmap.OrderedMap[K, V] {
+	if orig.Len() == 0 {
+		return orderedmap.NewOrderedMap[K, V]()
+	}
+	c := orderedmap.NewOrderedMap[K, V]()
+	for pair := orig.Front(); pair != nil; pair = pair.Next() {
+		if copyable, ok := any(pair.Value).(Copier[V]); ok {
+			c.Set(pair.Key, copyable.DeepCopy())
+		} else {
+			c.Set(pair.Key, pair.Value)
+		}
+	}
+	return c
+}
+
 // TraverseStringsFunc runs the given function on every string in the given
 // value by traversing it recursively. If the given value is a string, the
 // function will run on a copy of the string and return it. If the value is a

internal/env/env.go

@@ -8,16 +8,24 @@ import (
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
+const taskVarPrefix = "TASK_"
+
 func Get(t *ast.Task) []string {
 	if t.Env == nil {
 		return nil
 	}
+
+	return GetFromVars(t.Env)
+}
+
+func GetFromVars(env *ast.Vars) []string {
 	environ := os.Environ()
-	for k, v := range t.Env.ToCacheMap() {
+
+	for k, v := range env.ToCacheMap() {
 		if !isTypeAllowed(v) {
 			continue
 		}
-		if !experiments.EnvPrecedence.Enabled {
+		if !experiments.EnvPrecedence.Enabled() {
 			if _, alreadySet := os.LookupEnv(k); alreadySet {
 				continue
 			}
@@ -36,3 +44,7 @@ func isTypeAllowed(v any) bool {
 		return false
 	}
 }
+
+func GetTaskEnv(key string) string {
+	return os.Getenv(taskVarPrefix + key)
+}

internal/experiments/errors.go

@@ -0,0 +1,32 @@
+package experiments
+
+import (
+	"fmt"
+	"strings"
+)
+
+type InvalidValueError struct {
+	Name          string
+	AllowedValues []string
+	Value         string
+}
+
+func (err InvalidValueError) Error() string {
+	return fmt.Sprintf(
+		"task: Experiment %q has an invalid value %q (allowed values: %s)",
+		err.Name,
+		err.Value,
+		strings.Join(err.AllowedValues, ", "),
+	)
+}
+
+type InactiveError struct {
+	Name string
+}
+
+func (err InactiveError) Error() string {
+	return fmt.Sprintf(
+		"task: Experiment %q is inactive and cannot be enabled",
+		err.Name,
+	)
+}

internal/experiments/experiment.go

@@ -0,0 +1,56 @@
+package experiments
+
+import (
+	"fmt"
+	"slices"
+)
+
+type Experiment struct {
+	Name          string   // The name of the experiment.
+	AllowedValues []string // The values that can enable this experiment.
+	Value         string   // The version of the experiment that is enabled.
+}
+
+// New creates a new experiment with the given name and sets the values that can
+// enable it.
+func New(xName string, allowedValues ...string) Experiment {
+	value := getEnv(xName)
+	x := Experiment{
+		Name:          xName,
+		AllowedValues: allowedValues,
+		Value:         value,
+	}
+	xList = append(xList, x)
+	return x
+}
+
+func (x *Experiment) Enabled() bool {
+	return slices.Contains(x.AllowedValues, x.Value)
+}
+
+func (x *Experiment) Active() bool {
+	return len(x.AllowedValues) > 0
+}
+
+func (x Experiment) Valid() error {
+	if !x.Active() && x.Value != "" {
+		return &InactiveError{
+			Name: x.Name,
+		}
+	}
+	if !x.Enabled() && x.Value != "" {
+		return &InvalidValueError{
+			Name:          x.Name,
+			AllowedValues: x.AllowedValues,
+			Value:         x.Value,
+		}
+	}
+	return nil
+}
+
+func (x Experiment) String() string {
+	if x.Enabled() {
+		return fmt.Sprintf("on (%s)", x.Value)
+	}
+	return "off"
+}

internal/experiments/experiment_test.go

@@ -0,0 +1,74 @@
+package experiments_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/go-task/task/v3/internal/experiments"
+)
+
+func TestNew(t *testing.T) {
+	const (
+		exampleExperiment    = "EXAMPLE"
+		exampleExperimentEnv = "TASK_X_EXAMPLE"
+	)
+	tests := []struct {
+		name          string
+		allowedValues []string
+		value         string
+		wantEnabled   bool
+		wantActive    bool
+		wantValid     error
+	}{
+		{
+			name:        `[] allowed, value=""`,
+			wantEnabled: false,
+			wantActive:  false,
+		},
+		{
+			name:        `[] allowed, value="1"`,
+			value:       "1",
+			wantEnabled: false,
+			wantActive:  false,
+			wantValid: &experiments.InactiveError{
+				Name: exampleExperiment,
+			},
+		},
+		{
+			name:          `[1] allowed, value=""`,
+			allowedValues: []string{"1"},
+			wantEnabled:   false,
+			wantActive:    true,
+		},
+		{
+			name:          `[1] allowed, value="1"`,
+			allowedValues: []string{"1"},
+			value:         "1",
+			wantEnabled:   true,
+			wantActive:    true,
+		},
+		{
+			name:          `[1] allowed, value="2"`,
+			allowedValues: []string{"1"},
+			value:         "2",
+			wantEnabled:   false,
+			wantActive:    true,
+			wantValid: &experiments.InvalidValueError{
+				Name:          exampleExperiment,
+				AllowedValues: []string{"1"},
+				Value:         "2",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv(exampleExperimentEnv, tt.value)
+			x := experiments.New(exampleExperiment, tt.allowedValues...)
+			assert.Equal(t, exampleExperiment, x.Name)
+			assert.Equal(t, tt.wantEnabled, x.Enabled())
+			assert.Equal(t, tt.wantActive, x.Active())
+			assert.Equal(t, tt.wantValid, x.Valid())
+		})
+	}
+}

internal/experiments/experiments.go

@@ -2,28 +2,17 @@ package experiments
 
 import (
 	"fmt"
-	"io"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 
-	"github.com/Ladicle/tabwriter"
 	"github.com/joho/godotenv"
 	"github.com/spf13/pflag"
-
-	"github.com/go-task/task/v3/internal/logger"
 )
 
 const envPrefix = "TASK_X_"
 
-type Experiment struct {
-	Name    string
-	Enabled bool
-	Value   string
-}
-
-// A list of experiments.
+// A set of experiments that can be enabled or disabled.
 var (
 	GentleForce     Experiment
 	RemoteTaskfiles Experiment
@@ -32,32 +21,31 @@ var (
 	EnvPrecedence   Experiment
 )
 
+// An internal list of all the initialized experiments used for iterating.
+var xList []Experiment
+
 func init() {
 	readDotEnv()
-	GentleForce = New("GENTLE_FORCE")
-	RemoteTaskfiles = New("REMOTE_TASKFILES")
-	AnyVariables = New("ANY_VARIABLES", "1", "2")
+	GentleForce = New("GENTLE_FORCE", "1")
+	RemoteTaskfiles = New("REMOTE_TASKFILES", "1")
+	AnyVariables = New("ANY_VARIABLES")
 	MapVariables = New("MAP_VARIABLES", "1", "2")
-	EnvPrecedence = New("ENV_PRECEDENCE")
+	EnvPrecedence = New("ENV_PRECEDENCE", "1")
 }
 
-func New(xName string, enabledValues ...string) Experiment {
-	if len(enabledValues) == 0 {
-		enabledValues = []string{"1"}
-	}
-	value := getEnv(xName)
-	return Experiment{
-		Name:    xName,
-		Enabled: slices.Contains(enabledValues, value),
-		Value:   value,
+// Validate checks if any experiments have been enabled while being inactive.
+// If one is found, the function returns an error.
+func Validate() error {
+	for _, x := range List() {
+		if err := x.Valid(); err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
-func (x Experiment) String() string {
-	if x.Enabled {
-		return fmt.Sprintf("on (%s)", x.Value)
-	}
-	return "off"
+func List() []Experiment {
+	return xList
 }
 
 func getEnv(xName string) string {
@@ -95,18 +83,3 @@ func readDotEnv() {
 		}
 	}
 }
-
-func printExperiment(w io.Writer, l *logger.Logger, x Experiment) {
-	l.FOutf(w, logger.Yellow, "* ")
-	l.FOutf(w, logger.Green, x.Name)
-	l.FOutf(w, logger.Default, ": \t%s\n", x.String())
-}
-
-func List(l *logger.Logger) error {
-	w := tabwriter.NewWriter(os.Stdout, 0, 8, 0, ' ', 0)
-	printExperiment(w, l, GentleForce)
-	printExperiment(w, l, RemoteTaskfiles)
-	printExperiment(w, l, MapVariables)
-	printExperiment(w, l, EnvPrecedence)
-	return w.Flush()
-}

internal/fingerprint/sources_checksum_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestNormalizeFilename(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		In, Out string
 	}{

internal/fingerprint/task_test.go

@@ -26,6 +26,8 @@ import (
 // | false             | true               | false              |
 // | false             | false              | false              |
 func TestIsTaskUpToDate(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		name                    string
 		task                    *ast.Task
@@ -150,6 +152,8 @@ func TestIsTaskUpToDate(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
 			mockStatusChecker := mocks.NewStatusCheckable(t)
 			if tt.setupMockStatusChecker != nil {
 				tt.setupMockStatusChecker(mockStatusChecker)

internal/flags/flags.go

@@ -10,6 +10,7 @@ import (
 	"github.com/spf13/pflag"
 
 	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/experiments"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
@@ -79,7 +80,7 @@ func init() {
 		log.Print(usage)
 		pflag.PrintDefaults()
 	}
-	offline, err := strconv.ParseBool(cmp.Or(os.Getenv("TASK_OFFLINE"), "false"))
+	offline, err := strconv.ParseBool(cmp.Or(env.GetTaskEnv("OFFLINE"), "false"))
 	if err != nil {
 		offline = false
 	}
@@ -115,7 +116,7 @@ func init() {
 	pflag.BoolVar(&Experiments, "experiments", false, "Lists all the available experiments and whether or not they are enabled.")
 
 	// Gentle force experiment will override the force flag and add a new force-all flag
-	if experiments.GentleForce.Enabled {
+	if experiments.GentleForce.Enabled() {
 		pflag.BoolVarP(&Force, "force", "f", false, "Forces execution of the directly called task.")
 		pflag.BoolVar(&ForceAll, "force-all", false, "Forces execution of the called task and all its dependant tasks.")
 	} else {
@@ -123,7 +124,7 @@ func init() {
 	}
 
 	// Remote Taskfiles experiment will adds the "download" and "offline" flags
-	if experiments.RemoteTaskfiles.Enabled {
+	if experiments.RemoteTaskfiles.Enabled() {
 		pflag.BoolVar(&Download, "download", false, "Downloads a cached version of a remote Taskfile.")
 		pflag.BoolVar(&Offline, "offline", offline, "Forces Task to only use local or cached Taskfiles.")
 		pflag.DurationVar(&Timeout, "timeout", time.Second*10, "Timeout for downloading remote Taskfiles.")

internal/logger/logger.go

@@ -8,9 +8,12 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/Ladicle/tabwriter"
 	"github.com/fatih/color"
 
 	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/env"
+	"github.com/go-task/task/v3/internal/experiments"
 	"github.com/go-task/task/v3/internal/term"
 )
 
@@ -19,70 +22,86 @@ var (
 	ErrNoTerminal      = errors.New("no terminal")
 )
 
+var (
+	attrsReset       = envColor("COLOR_RESET", color.Reset)
+	attrsFgBlue      = envColor("COLOR_BLUE", color.FgBlue)
+	attrsFgGreen     = envColor("COLOR_GREEN", color.FgGreen)
+	attrsFgCyan      = envColor("COLOR_CYAN", color.FgCyan)
+	attrsFgYellow    = envColor("COLOR_YELLOW", color.FgYellow)
+	attrsFgMagenta   = envColor("COLOR_MAGENTA", color.FgMagenta)
+	attrsFgRed       = envColor("COLOR_RED", color.FgRed)
+	attrsFgHiBlue    = envColor("COLOR_BRIGHT_BLUE", color.FgHiBlue)
+	attrsFgHiGreen   = envColor("COLOR_BRIGHT_GREEN", color.FgHiGreen)
+	attrsFgHiCyan    = envColor("COLOR_BRIGHT_CYAN", color.FgHiCyan)
+	attrsFgHiYellow  = envColor("COLOR_BRIGHT_YELLOW", color.FgHiYellow)
+	attrsFgHiMagenta = envColor("COLOR_BRIGHT_MAGENTA", color.FgHiMagenta)
+	attrsFgHiRed     = envColor("COLOR_BRIGHT_RED", color.FgHiRed)
+)
+
 type (
 	Color     func() PrintFunc
 	PrintFunc func(io.Writer, string, ...any)
 )
 
 func Default() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RESET", color.Reset)...).FprintfFunc()
+	return color.New(attrsReset...).FprintfFunc()
 }
 
 func Blue() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)...).FprintfFunc()
+	return color.New(attrsFgBlue...).FprintfFunc()
 }
 
 func Green() PrintFunc {
-	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)...).FprintfFunc()
+	return color.New(attrsFgGreen...).FprintfFunc()
 }
 
 func Cyan() PrintFunc {
-	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)...).FprintfFunc()
+	return color.New(attrsFgCyan...).FprintfFunc()
 }
 
 func Yellow() PrintFunc {
-	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)...).FprintfFunc()
+	return color.New(attrsFgYellow...).FprintfFunc()
 }
 
 func Magenta() PrintFunc {
-	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)...).FprintfFunc()
+	return color.New(attrsFgMagenta...).FprintfFunc()
 }
 
 func Red() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RED", color.FgRed)...).FprintfFunc()
+	return color.New(attrsFgRed...).FprintfFunc()
 }
 
 func BrightBlue() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_BLUE", color.FgHiBlue)...).FprintfFunc()
+	return color.New(attrsFgHiBlue...).FprintfFunc()
 }
 
 func BrightGreen() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_GREEN", color.FgHiGreen)...).FprintfFunc()
+	return color.New(attrsFgHiGreen...).FprintfFunc()
 }
 
 func BrightCyan() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_CYAN", color.FgHiCyan)...).FprintfFunc()
+	return color.New(attrsFgHiCyan...).FprintfFunc()
 }
 
 func BrightYellow() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_YELLOW", color.FgHiYellow)...).FprintfFunc()
+	return color.New(attrsFgHiYellow...).FprintfFunc()
 }
 
 func BrightMagenta() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_MAGENTA", color.FgHiMagenta)...).FprintfFunc()
+	return color.New(attrsFgHiMagenta...).FprintfFunc()
 }
 
 func BrightRed() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_RED", color.FgHiRed)...).FprintfFunc()
+	return color.New(attrsFgHiRed...).FprintfFunc()
 }
 
-func envColor(env string, defaultColor color.Attribute) []color.Attribute {
+func envColor(name string, defaultColor color.Attribute) []color.Attribute {
 	if os.Getenv("FORCE_COLOR") != "" {
 		color.NoColor = false
 	}
 
 	// Fetch the environment variable
-	override := os.Getenv(env)
+	override := env.GetTaskEnv(name)
 
 	// First, try splitting the string by commas (RGB shortcut syntax) and if it
 	// matches, then prepend the 256-color foreground escape sequence.
@@ -195,3 +214,16 @@ func (l *Logger) Prompt(color Color, prompt string, defaultValue string, continu
 
 	return nil
 }
+
+func (l *Logger) PrintExperiments() error {
+	w := tabwriter.NewWriter(l.Stdout, 0, 8, 0, ' ', 0)
+	for _, x := range experiments.List() {
+		if !x.Active() {
+			continue
+		}
+		l.FOutf(w, Yellow, "* ")
+		l.FOutf(w, Green, x.Name)
+		l.FOutf(w, Default, ": \t%s\n", x.String())
+	}
+	return w.Flush()
+}

internal/omap/orderedmap.go

@@ -1,164 +0,0 @@
-package omap
-
-import (
-	"cmp"
-	"fmt"
-	"slices"
-
-	"gopkg.in/yaml.v3"
-
-	"github.com/go-task/task/v3/internal/deepcopy"
-	"github.com/go-task/task/v3/internal/exp"
-)
-
-// An OrderedMap is a wrapper around a regular map that maintains an ordered
-// list of the map's keys. This allows you to run deterministic and ordered
-// operations on the map such as printing/serializing/iterating.
-type OrderedMap[K cmp.Ordered, V any] struct {
-	s []K
-	m map[K]V
-}
-
-// New will create a new OrderedMap of the given type and return it.
-func New[K cmp.Ordered, V any]() OrderedMap[K, V] {
-	return OrderedMap[K, V]{
-		s: make([]K, 0),
-		m: make(map[K]V),
-	}
-}
-
-// FromMap will create a new OrderedMap from the given map. Since Golang maps
-// are unordered, the order of the created OrderedMap will be random.
-func FromMap[K cmp.Ordered, V any](m map[K]V) OrderedMap[K, V] {
-	om := New[K, V]()
-	om.m = m
-	om.s = exp.Keys(m)
-	return om
-}
-
-func FromMapWithOrder[K cmp.Ordered, V any](m map[K]V, order []K) OrderedMap[K, V] {
-	om := New[K, V]()
-	if len(m) != len(order) {
-		panic("length of map and order must be equal")
-	}
-	om.m = m
-	om.s = order
-	for key := range om.m {
-		if !slices.Contains(om.s, key) {
-			panic("order keys must match map keys")
-		}
-	}
-	return om
-}
-
-// Len will return the number of items in the map.
-func (om *OrderedMap[K, V]) Len() int {
-	return len(om.s)
-}
-
-// Set will set the value for a given key.
-func (om *OrderedMap[K, V]) Set(key K, value V) {
-	if om.m == nil {
-		om.m = make(map[K]V)
-	}
-	if _, ok := om.m[key]; !ok {
-		om.s = append(om.s, key)
-	}
-	om.m[key] = value
-}
-
-// Get will return the value for a given key.
-// If the key does not exist, it will return the zero value of the value type.
-func (om *OrderedMap[K, V]) Get(key K) V {
-	value, ok := om.m[key]
-	if !ok {
-		var zero V
-		return zero
-	}
-	return value
-}
-
-// Exists will return whether or not the given key exists.
-func (om *OrderedMap[K, V]) Exists(key K) bool {
-	_, ok := om.m[key]
-	return ok
-}
-
-// Sort will sort the map.
-func (om *OrderedMap[K, V]) Sort() {
-	slices.Sort(om.s)
-}
-
-// SortFunc will sort the map using the given function.
-func (om *OrderedMap[K, V]) SortFunc(less func(i, j K) int) {
-	slices.SortFunc(om.s, less)
-}
-
-// Keys will return a slice of the map's keys in order.
-func (om *OrderedMap[K, V]) Keys() []K {
-	return om.s
-}
-
-// Values will return a slice of the map's values in order.
-func (om *OrderedMap[K, V]) Values() []V {
-	var values []V
-	for _, key := range om.s {
-		values = append(values, om.m[key])
-	}
-	return values
-}
-
-// Range will iterate over the map and call the given function for each key/value.
-func (om *OrderedMap[K, V]) Range(fn func(key K, value V) error) error {
-	for _, key := range om.s {
-		if err := fn(key, om.m[key]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Merge merges the given Vars into the caller one
-func (om *OrderedMap[K, V]) Merge(other OrderedMap[K, V]) {
-	// nolint: errcheck
-	other.Range(func(key K, value V) error {
-		om.Set(key, value)
-		return nil
-	})
-}
-
-func (om *OrderedMap[K, V]) DeepCopy() OrderedMap[K, V] {
-	return OrderedMap[K, V]{
-		s: deepcopy.Slice(om.s),
-		m: deepcopy.Map(om.m),
-	}
-}
-
-func (om *OrderedMap[K, V]) UnmarshalYAML(node *yaml.Node) error {
-	switch node.Kind {
-	// Even numbers contain the keys
-	// Odd numbers contain the values
-	case yaml.MappingNode:
-		for i := 0; i < len(node.Content); i += 2 {
-			// Decode the key
-			keyNode := node.Content[i]
-			var k K
-			if err := keyNode.Decode(&k); err != nil {
-				return err
-			}
-
-			// Decode the value
-			valueNode := node.Content[i+1]
-			var v V
-			if err := valueNode.Decode(&v); err != nil {
-				return err
-			}
-
-			// Set the key and value
-			om.Set(k, v)
-		}
-		return nil
-	}
-
-	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into variables", node.Line, node.ShortTag())
-}

internal/omap/orderedmap_test.go

@@ -1,121 +0,0 @@
-package omap
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"gopkg.in/yaml.v3"
-)
-
-func TestFromMap(t *testing.T) {
-	m := map[int]string{3: "three", 1: "one", 2: "two"}
-	om := FromMap(m)
-	assert.Len(t, om.m, 3)
-	assert.Len(t, om.s, 3)
-	assert.ElementsMatch(t, []int{1, 2, 3}, om.s)
-	for key, value := range m {
-		assert.Equal(t, om.Get(key), value)
-	}
-}
-
-func TestSetGetExists(t *testing.T) {
-	om := New[int, string]()
-	assert.False(t, om.Exists(1))
-	assert.Equal(t, "", om.Get(1))
-	om.Set(1, "one")
-	assert.True(t, om.Exists(1))
-	assert.Equal(t, "one", om.Get(1))
-}
-
-func TestSort(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	om.Sort()
-	assert.Equal(t, []int{1, 2, 3}, om.s)
-}
-
-func TestSortFunc(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	om.SortFunc(func(a, b int) int {
-		return b - a
-	})
-	assert.Equal(t, []int{3, 2, 1}, om.s)
-}
-
-func TestKeysValues(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	assert.Equal(t, []int{3, 1, 2}, om.Keys())
-	assert.Equal(t, []string{"three", "one", "two"}, om.Values())
-}
-
-func Range(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-
-	expectedKeys := []int{3, 1, 2}
-	expectedValues := []string{"three", "one", "two"}
-
-	keys := make([]int, 0, len(expectedKeys))
-	values := make([]string, 0, len(expectedValues))
-
-	err := om.Range(func(key int, value string) error {
-		keys = append(keys, key)
-		values = append(values, value)
-		return nil
-	})
-
-	assert.NoError(t, err)
-	assert.ElementsMatch(t, expectedKeys, keys)
-	assert.ElementsMatch(t, expectedValues, values)
-}
-
-func TestOrderedMapMerge(t *testing.T) {
-	om1 := New[string, int]()
-	om1.Set("a", 1)
-	om1.Set("b", 2)
-
-	om2 := New[string, int]()
-	om2.Set("b", 3)
-	om2.Set("c", 4)
-
-	om1.Merge(om2)
-
-	expectedKeys := []string{"a", "b", "c"}
-	expectedValues := []int{1, 3, 4}
-
-	assert.Equal(t, len(expectedKeys), len(om1.s))
-	assert.Equal(t, len(expectedKeys), len(om1.m))
-
-	for i, key := range expectedKeys {
-		assert.True(t, om1.Exists(key))
-		assert.Equal(t, expectedValues[i], om1.Get(key))
-	}
-}
-
-func TestUnmarshalYAML(t *testing.T) {
-	yamlString := `
-3: three
-1: one
-2: two
-`
-	var om OrderedMap[int, string]
-	err := yaml.Unmarshal([]byte(yamlString), &om)
-	require.NoError(t, err)
-
-	expectedKeys := []int{3, 1, 2}
-	expectedValues := []string{"three", "one", "two"}
-
-	assert.Equal(t, expectedKeys, om.Keys())
-	assert.Equal(t, expectedValues, om.Values())
-}

internal/output/output_test.go

@@ -12,13 +12,14 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/omap"
 	"github.com/go-task/task/v3/internal/output"
 	"github.com/go-task/task/v3/internal/templater"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestInterleaved(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Interleaved{}
 	w, _, _ := o.WrapWriter(&b, io.Discard, "", nil)
@@ -30,6 +31,8 @@ func TestInterleaved(t *testing.T) {
 }
 
 func TestGroup(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{}
 	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
@@ -48,12 +51,15 @@ func TestGroup(t *testing.T) {
 }
 
 func TestGroupWithBeginEnd(t *testing.T) {
+	t.Parallel()
+
 	tmpl := templater.Cache{
-		Vars: &ast.Vars{
-			OrderedMap: omap.FromMap(map[string]ast.Var{
-				"VAR1": {Value: "example-value"},
-			}),
-		},
+		Vars: ast.NewVars(
+			&ast.VarElement{
+				Key:   "VAR1",
+				Value: ast.Var{Value: "example-value"},
+			},
+		),
 	}
 
 	var o output.Output = output.Group{
@@ -61,6 +67,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 		End:   "::endgroup::",
 	}
 	t.Run("simple", func(t *testing.T) {
+		t.Parallel()
+
 		var b bytes.Buffer
 		w, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
 
@@ -72,6 +80,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 		assert.Equal(t, "::group::example-value\nfoo\nbar\nbaz\n::endgroup::\n", b.String())
 	})
 	t.Run("no output", func(t *testing.T) {
+		t.Parallel()
+
 		var b bytes.Buffer
 		_, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
 		require.NoError(t, cleanup(nil))
@@ -80,6 +90,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 }
 
 func TestGroupErrorOnlySwallowsOutputOnNoError(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{
 		ErrorOnly: true,
@@ -94,6 +106,8 @@ func TestGroupErrorOnlySwallowsOutputOnNoError(t *testing.T) {
 }
 
 func TestGroupErrorOnlyShowsOutputOnError(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{
 		ErrorOnly: true,
@@ -107,7 +121,7 @@ func TestGroupErrorOnlyShowsOutputOnError(t *testing.T) {
 	assert.Equal(t, "std-out\nstd-err\n", b.String())
 }
 
-func TestPrefixed(t *testing.T) {
+func TestPrefixed(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 	var b bytes.Buffer
 	l := &logger.Logger{
 		Color: false,
@@ -116,7 +130,7 @@ func TestPrefixed(t *testing.T) {
 	var o output.Output = output.NewPrefixed(l)
 	w, _, cleanup := o.WrapWriter(&b, io.Discard, "prefix", nil)
 
-	t.Run("simple use cases", func(t *testing.T) {
+	t.Run("simple use cases", func(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 		b.Reset()
 
 		fmt.Fprintln(w, "foo\nbar")
@@ -126,7 +140,7 @@ func TestPrefixed(t *testing.T) {
 		require.NoError(t, cleanup(nil))
 	})
 
-	t.Run("multiple writes for a single line", func(t *testing.T) {
+	t.Run("multiple writes for a single line", func(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 		b.Reset()
 
 		for _, char := range []string{"T", "e", "s", "t", "!"} {
@@ -140,6 +154,8 @@ func TestPrefixed(t *testing.T) {
 }
 
 func TestPrefixedWithColor(t *testing.T) {
+	t.Parallel()
+
 	color.NoColor = false
 
 	var b bytes.Buffer
@@ -155,6 +171,8 @@ func TestPrefixedWithColor(t *testing.T) {
 	}
 
 	t.Run("colors should loop", func(t *testing.T) {
+		t.Parallel()
+
 		for i, w := range writers {
 			b.Reset()
 
@@ -164,7 +182,11 @@ func TestPrefixedWithColor(t *testing.T) {
 			l.FOutf(&prefix, color, fmt.Sprintf("prefix-%d", i))
 
 			fmt.Fprintln(w, "foo\nbar")
-			assert.Equal(t, fmt.Sprintf("[%s] foo\n[%s] bar\n", prefix.String(), prefix.String()), b.String())
+			assert.Equal(
+				t,
+				fmt.Sprintf("[%s] foo\n[%s] bar\n", prefix.String(), prefix.String()),
+				b.String(),
+			)
 		}
 	})
 }

internal/output/prefixed.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"sync"
 
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/templater"
@@ -14,20 +15,21 @@ type Prefixed struct {
 	logger  *logger.Logger
 	seen    map[string]uint
 	counter *uint
+	mutex   sync.Mutex
 }
 
-func NewPrefixed(logger *logger.Logger) Prefixed {
+func NewPrefixed(logger *logger.Logger) *Prefixed {
 	var counter uint
 
-	return Prefixed{
+	return &Prefixed{
 		seen:    make(map[string]uint),
 		counter: &counter,
 		logger:  logger,
 	}
 }
 
-func (p Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
-	pw := &prefixWriter{writer: stdOut, prefix: prefix, prefixed: &p}
+func (p *Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
+	pw := &prefixWriter{writer: stdOut, prefix: prefix, prefixed: p}
 	return pw, pw, func(error) error { return pw.close() }
 }
 
@@ -85,6 +87,9 @@ func (pw *prefixWriter) writeLine(line string) error {
 		line += "\n"
 	}
 
+	defer pw.prefixed.mutex.Unlock()
+	pw.prefixed.mutex.Lock()
+
 	idx, ok := pw.prefixed.seen[pw.prefix]
 
 	if !ok {

internal/sort/sorter_test.go

@@ -9,6 +9,8 @@ import (
 )
 
 func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
+	t.Parallel()
+
 	task1 := &ast.Task{Task: "task1"}
 	task2 := &ast.Task{Task: "task2"}
 	task3 := &ast.Task{Task: "ns1:task3"}
@@ -40,6 +42,8 @@ func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
 			s := &AlphaNumericWithRootTasksFirst{}
 			s.Sort(tt.tasks)
 			assert.Equal(t, tt.want, tt.tasks)
@@ -48,6 +52,8 @@ func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
 }
 
 func TestAlphaNumeric_Sort(t *testing.T) {
+	t.Parallel()
+
 	task1 := &ast.Task{Task: "task1"}
 	task2 := &ast.Task{Task: "task2"}
 	task3 := &ast.Task{Task: "ns1:task3"}
@@ -69,6 +75,8 @@ func TestAlphaNumeric_Sort(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
 			s := &AlphaNumeric{}
 			s.Sort(tt.tasks)
 			assert.Equal(t, tt.tasks, tt.want)

internal/summary/summary.go

@@ -10,7 +10,9 @@ import (
 func PrintTasks(l *logger.Logger, t *ast.Taskfile, c []*ast.Call) {
 	for i, call := range c {
 		PrintSpaceBetweenSummaries(l, i)
-		PrintTask(l, t.Tasks.Get(call.Task))
+		if task, ok := t.Tasks.Get(call.Task); ok {
+			PrintTask(l, task)
+		}
 	}
 }
 

internal/summary/summary_test.go

@@ -13,6 +13,8 @@ import (
 )
 
 func TestPrintsDependenciesIfPresent(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Deps: []*ast.Dep{
@@ -38,6 +40,8 @@ func createDummyLogger() (*bytes.Buffer, logger.Logger) {
 }
 
 func TestDoesNotPrintDependenciesIfMissing(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Deps: []*ast.Dep{},
@@ -49,6 +53,8 @@ func TestDoesNotPrintDependenciesIfMissing(t *testing.T) {
 }
 
 func TestPrintTaskName(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Task: "my-task-name",
@@ -60,6 +66,8 @@ func TestPrintTaskName(t *testing.T) {
 }
 
 func TestPrintTaskCommandsIfPresent(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Cmds: []*ast.Cmd{
@@ -78,6 +86,8 @@ func TestPrintTaskCommandsIfPresent(t *testing.T) {
 }
 
 func TestDoesNotPrintCommandIfMissing(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Cmds: []*ast.Cmd{},
@@ -89,6 +99,8 @@ func TestDoesNotPrintCommandIfMissing(t *testing.T) {
 }
 
 func TestLayout(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Task:    "sample-task",
@@ -123,6 +135,8 @@ commands:
 }
 
 func TestPrintDescriptionAsFallback(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	taskWithoutSummary := &ast.Task{
 		Desc: "description",
@@ -150,13 +164,15 @@ func TestPrintDescriptionAsFallback(t *testing.T) {
 }
 
 func TestPrintAllWithSpaces(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 
 	t1 := &ast.Task{Task: "t1"}
 	t2 := &ast.Task{Task: "t2"}
 	t3 := &ast.Task{Task: "t3"}
 
-	tasks := ast.Tasks{}
+	tasks := ast.NewTasks()
 	tasks.Set("t1", t1)
 	tasks.Set("t2", t2)
 	tasks.Set("t3", t3)

internal/templater/templater.go

@@ -140,11 +140,11 @@ func ReplaceVarsWithExtra(vars *ast.Vars, cache *Cache, extra map[string]any) *a
 		return nil
 	}
 
-	var newVars ast.Vars
+	newVars := ast.NewVars()
 	_ = vars.Range(func(k string, v ast.Var) error {
 		newVars.Set(k, ReplaceVarWithExtra(v, cache, extra))
 		return nil
 	})
 
-	return &newVars
+	return newVars
 }

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-task/cli",
-  "version": "3.40.1",
+  "version": "3.41.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-task/cli",
-  "version": "3.40.1",
+  "version": "3.41.0",
   "description": "A task runner / simpler Make alternative written in Go",
   "scripts": {
     "postinstall": "go-npm install",
@@ -22,7 +22,7 @@
     "build-tool",
     "task-runner"
   ],
-  "author": "Andrey Nering",
+  "author": "The Task authors",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/go-task/task/issues"

requires.go

@@ -7,30 +7,16 @@ import (
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-func (e *Executor) areTaskRequiredVarsSet(t *ast.Task, call *ast.Call) error {
+func (e *Executor) areTaskRequiredVarsSet(t *ast.Task) error {
 	if t.Requires == nil || len(t.Requires.Vars) == 0 {
 		return nil
 	}
 
-	vars, err := e.Compiler.GetVariables(t, call)
-	if err != nil {
-		return err
-	}
-
 	var missingVars []string
-	var notAllowedValuesVars []errors.NotAllowedVar
 	for _, requiredVar := range t.Requires.Vars {
-		value, isString := vars.Get(requiredVar.Name).Value.(string)
-		if !vars.Exists(requiredVar.Name) {
+		_, ok := t.Vars.Get(requiredVar.Name)
+		if !ok {
 			missingVars = append(missingVars, requiredVar.Name)
-		} else {
-			if isString && requiredVar.Enum != nil && !slices.Contains(requiredVar.Enum, value) {
-				notAllowedValuesVars = append(notAllowedValuesVars, errors.NotAllowedVar{
-					Value: value,
-					Enum:  requiredVar.Enum,
-					Name:  requiredVar.Name,
-				})
-			}
 		}
 	}
 
@@ -41,6 +27,29 @@ func (e *Executor) areTaskRequiredVarsSet(t *ast.Task, call *ast.Call) error {
 		}
 	}
 
+	return nil
+}
+
+func (e *Executor) areTaskRequiredVarsAllowedValuesSet(t *ast.Task) error {
+	if t.Requires == nil || len(t.Requires.Vars) == 0 {
+		return nil
+	}
+
+	var notAllowedValuesVars []errors.NotAllowedVar
+	for _, requiredVar := range t.Requires.Vars {
+		varValue, _ := t.Vars.Get(requiredVar.Name)
+
+		value, isString := varValue.Value.(string)
+		if isString && requiredVar.Enum != nil && !slices.Contains(requiredVar.Enum, value) {
+			notAllowedValuesVars = append(notAllowedValuesVars, errors.NotAllowedVar{
+				Value: value,
+				Enum:  requiredVar.Enum,
+				Name:  requiredVar.Name,
+			})
+		}
+
+	}
+
 	if len(notAllowedValuesVars) > 0 {
 		return &errors.TaskNotAllowedVars{
 			TaskName:       t.Name(),

setup.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/compiler"
+	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/logger"
@@ -109,13 +110,14 @@ func (e *Executor) setupTempDir() error {
 		return nil
 	}
 
-	if os.Getenv("TASK_TEMP_DIR") == "" {
+	tempDir := env.GetTaskEnv("TEMP_DIR")
+	if tempDir == "" {
 		e.TempDir = TempDir{
 			Remote:      filepathext.SmartJoin(e.Dir, ".task"),
 			Fingerprint: filepathext.SmartJoin(e.Dir, ".task"),
 		}
-	} else if filepath.IsAbs(os.Getenv("TASK_TEMP_DIR")) || strings.HasPrefix(os.Getenv("TASK_TEMP_DIR"), "~") {
-		tempDir, err := execext.Expand(os.Getenv("TASK_TEMP_DIR"))
+	} else if filepath.IsAbs(tempDir) || strings.HasPrefix(tempDir, "~") {
+		tempDir, err := execext.Expand(tempDir)
 		if err != nil {
 			return err
 		}
@@ -128,14 +130,15 @@ func (e *Executor) setupTempDir() error {
 
 	} else {
 		e.TempDir = TempDir{
-			Remote:      filepathext.SmartJoin(e.Dir, os.Getenv("TASK_TEMP_DIR")),
-			Fingerprint: filepathext.SmartJoin(e.Dir, os.Getenv("TASK_TEMP_DIR")),
+			Remote:      filepathext.SmartJoin(e.Dir, tempDir),
+			Fingerprint: filepathext.SmartJoin(e.Dir, tempDir),
 		}
 	}
 
-	if os.Getenv("TASK_REMOTE_DIR") != "" {
-		if filepath.IsAbs(os.Getenv("TASK_REMOTE_DIR")) || strings.HasPrefix(os.Getenv("TASK_REMOTE_DIR"), "~") {
-			remoteTempDir, err := execext.Expand(os.Getenv("TASK_REMOTE_DIR"))
+	remoteDir := env.GetTaskEnv("REMOTE_DIR")
+	if remoteDir != "" {
+		if filepath.IsAbs(remoteDir) || strings.HasPrefix(remoteDir, "~") {
+			remoteTempDir, err := execext.Expand(remoteDir)
 			if err != nil {
 				return err
 			}
@@ -213,7 +216,7 @@ func (e *Executor) readDotEnvFiles() error {
 	}
 
 	err = env.Range(func(key string, value ast.Var) error {
-		if ok := e.Taskfile.Env.Exists(key); !ok {
+		if _, ok := e.Taskfile.Env.Get(key); !ok {
 			e.Taskfile.Env.Set(key, value)
 		}
 		return nil
@@ -246,6 +249,9 @@ func (e *Executor) setupConcurrencyState() {
 }
 
 func (e *Executor) doVersionChecks() error {
+	if !e.EnableVersionCheck {
+		return nil
+	}
 	// Copy the version to avoid modifying the original
 	schemaVersion := &semver.Version{}
 	*schemaVersion = *e.Taskfile.Version

signals.go

@@ -8,20 +8,20 @@ import (
 	"github.com/go-task/task/v3/internal/logger"
 )
 
-const interruptSignalsCount = 3
+const maxInterruptSignals = 3
 
 // NOTE(@andreynering): This function intercepts SIGINT and SIGTERM signals
 // so the Task process is not killed immediately and processes running have
 // time to do cleanup work.
 func (e *Executor) InterceptInterruptSignals() {
-	ch := make(chan os.Signal, interruptSignalsCount)
+	ch := make(chan os.Signal, maxInterruptSignals)
 	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
 
 	go func() {
-		for i := range interruptSignalsCount {
+		for i := range maxInterruptSignals {
 			sig := <-ch
 
-			if i+1 >= interruptSignalsCount {
+			if i+1 >= maxInterruptSignals {
 				e.Logger.Errf(logger.Red, "task: Signal received for the third time: %q. Forcing shutdown\n", sig)
 				os.Exit(1)
 			}

task.go

@@ -70,12 +70,13 @@ type Executor struct {
 	Stdout io.Writer
 	Stderr io.Writer
 
-	Logger         *logger.Logger
-	Compiler       *compiler.Compiler
-	Output         output.Output
-	OutputStyle    ast.Output
-	TaskSorter     sort.TaskSorter
-	UserWorkingDir string
+	Logger             *logger.Logger
+	Compiler           *compiler.Compiler
+	Output             output.Output
+	OutputStyle        ast.Output
+	TaskSorter         sort.TaskSorter
+	UserWorkingDir     string
+	EnableVersionCheck bool
 
 	fuzzyModel *fuzzy.Model
 
@@ -176,10 +177,19 @@ func (e *Executor) RunTask(ctx context.Context, call *ast.Call) error {
 		return nil
 	}
 
+	if err := e.areTaskRequiredVarsSet(t); err != nil {
+		return err
+	}
+
 	t, err = e.CompiledTask(call)
 	if err != nil {
 		return err
 	}
+
+	if err := e.areTaskRequiredVarsAllowedValuesSet(t); err != nil {
+		return err
+	}
+
 	if !e.Watch && atomic.AddInt32(e.taskCallCount[t.Task], 1) >= MaximumTaskCall {
 		return &errors.TaskCalledTooManyTimesError{
 			TaskName:        t.Task,
@@ -202,10 +212,6 @@ func (e *Executor) RunTask(ctx context.Context, call *ast.Call) error {
 				return err
 			}
 
-			if err := e.areTaskRequiredVarsSet(t, call); err != nil {
-				return err
-			}
-
 			preCondMet, err := e.areTaskPreconditionsMet(ctx, t)
 			if err != nil {
 				return err
@@ -383,7 +389,7 @@ func (e *Executor) runCommand(ctx context.Context, t *ast.Task, call *ast.Call,
 		if err != nil {
 			return fmt.Errorf("task: failed to get variables: %w", err)
 		}
-		stdOut, stdErr, close := outputWrapper.WrapWriter(e.Stdout, e.Stderr, t.Prefix, outputTemplater)
+		stdOut, stdErr, closer := outputWrapper.WrapWriter(e.Stdout, e.Stderr, t.Prefix, outputTemplater)
 
 		err = execext.RunCommand(ctx, &execext.RunCommandOptions{
 			Command:   cmd.Cmd,
@@ -395,7 +401,7 @@ func (e *Executor) runCommand(ctx context.Context, t *ast.Task, call *ast.Call,
 			Stdout:    stdOut,
 			Stderr:    stdErr,
 		})
-		if closeErr := close(err); closeErr != nil {
+		if closeErr := closer(err); closeErr != nil {
 			e.Logger.Errf(logger.Red, "task: unable to close writer: %v\n", closeErr)
 		}
 		if _, isExitError := interp.IsExitStatus(err); isExitError && cmd.IgnoreError {
@@ -451,7 +457,7 @@ func (e *Executor) GetTask(call *ast.Call) (*ast.Task, error) {
 	case 0: // Carry on
 	case 1:
 		if call.Vars == nil {
-			call.Vars = &ast.Vars{}
+			call.Vars = ast.NewVars()
 		}
 		call.Vars.Set("MATCH", ast.Var{Value: matchingTasks[0].Wildcards})
 		return matchingTasks[0].Task, nil
@@ -521,7 +527,7 @@ func (e *Executor) GetTaskList(filters ...FilterFunc) ([]*ast.Task, error) {
 	// Compile the list of tasks
 	for i := range tasks {
 		g.Go(func() error {
-			compiledTask, err := e.FastCompiledTask(&ast.Call{Task: tasks[i].Task})
+			compiledTask, err := e.CompiledTaskForTaskList(&ast.Call{Task: tasks[i].Task})
 			if err != nil {
 				return err
 			}

taskfile/ast/cmd.go

@@ -75,11 +75,13 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 
 		// A deferred command
 		var deferredCmd struct {
-			Defer string
+			Defer  string
+			Silent bool
 		}
 		if err := node.Decode(&deferredCmd); err == nil && deferredCmd.Defer != "" {
 			c.Defer = true
 			c.Cmd = deferredCmd.Defer
+			c.Silent = deferredCmd.Silent
 			return nil
 		}
 
@@ -91,6 +93,7 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 			c.Defer = true
 			c.Task = deferredCall.Defer.Task
 			c.Vars = deferredCall.Defer.Vars
+			c.Silent = deferredCall.Defer.Silent
 			return nil
 		}
 

taskfile/ast/for.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
-	"github.com/go-task/task/v3/internal/omap"
 )
 
 type For struct {
 	From   string
 	List   []any
-	Matrix omap.OrderedMap[string, []any]
+	Matrix *Matrix
 	Var    string
 	Split  string
 	As     string
@@ -38,7 +37,7 @@ func (f *For) UnmarshalYAML(node *yaml.Node) error {
 
 	case yaml.MappingNode:
 		var forStruct struct {
-			Matrix omap.OrderedMap[string, []any]
+			Matrix *Matrix
 			Var    string
 			Split  string
 			As     string

taskfile/ast/include.go

@@ -1,46 +1,128 @@
 package ast
 
 import (
+	"sync"
+
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
-	omap "github.com/go-task/task/v3/internal/omap"
+	"github.com/go-task/task/v3/internal/deepcopy"
 )
 
-// Include represents information about included taskfiles
-type Include struct {
-	Namespace      string
-	Taskfile       string
-	Dir            string
-	Optional       bool
-	Internal       bool
-	Aliases        []string
-	AdvancedImport bool
-	Vars           *Vars
-	Flatten        bool
+type (
+	// Include represents information about included taskfiles
+	Include struct {
+		Namespace      string
+		Taskfile       string
+		Dir            string
+		Optional       bool
+		Internal       bool
+		Aliases        []string
+		Excludes       []string
+		AdvancedImport bool
+		Vars           *Vars
+		Flatten        bool
+	}
+	// Includes is an ordered map of namespaces to includes.
+	Includes struct {
+		om    *orderedmap.OrderedMap[string, *Include]
+		mutex sync.RWMutex
+	}
+	// An IncludeElement is a key-value pair that is used for initializing an
+	// Includes structure.
+	IncludeElement orderedmap.Element[string, *Include]
+)
+
+// NewIncludes creates a new instance of Includes and initializes it with the
+// provided set of elements, if any. The elements are added in the order they
+// are passed.
+func NewIncludes(els ...*IncludeElement) *Includes {
+	includes := &Includes{
+		om: orderedmap.NewOrderedMap[string, *Include](),
+	}
+	for _, el := range els {
+		includes.Set(el.Key, el.Value)
+	}
+	return includes
 }
 
-// Includes represents information about included tasksfiles
-type Includes struct {
-	omap.OrderedMap[string, *Include]
+// Len returns the number of includes in the Includes map.
+func (includes *Includes) Len() int {
+	if includes == nil || includes.om == nil {
+		return 0
+	}
+	defer includes.mutex.RUnlock()
+	includes.mutex.RLock()
+	return includes.om.Len()
+}
+
+// Get returns the value the the include with the provided key and a boolean
+// that indicates if the value was found or not. If the value is not found, the
+// returned include is a zero value and the bool is false.
+func (includes *Includes) Get(key string) (*Include, bool) {
+	if includes == nil || includes.om == nil {
+		return &Include{}, false
+	}
+	defer includes.mutex.RUnlock()
+	includes.mutex.RLock()
+	return includes.om.Get(key)
+}
+
+// Set sets the value of the include with the provided key to the provided
+// value. If the include already exists, its value is updated. If the include
+// does not exist, it is created.
+func (includes *Includes) Set(key string, value *Include) bool {
+	if includes == nil {
+		includes = NewIncludes()
+	}
+	if includes.om == nil {
+		includes.om = orderedmap.NewOrderedMap[string, *Include]()
+	}
+	defer includes.mutex.Unlock()
+	includes.mutex.Lock()
+	return includes.om.Set(key, value)
+}
+
+// Range calls the provided function for each include in the map. The function
+// receives the include's key and value as arguments. If the function returns
+// an error, the iteration stops and the error is returned.
+func (includes *Includes) Range(f func(k string, v *Include) error) error {
+	if includes == nil || includes.om == nil {
+		return nil
+	}
+	for pair := includes.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 // UnmarshalYAML implements the yaml.Unmarshaler interface.
 func (includes *Includes) UnmarshalYAML(node *yaml.Node) error {
+	if includes == nil || includes.om == nil {
+		*includes = *NewIncludes()
+	}
 	switch node.Kind {
 	case yaml.MappingNode:
-		// NOTE(@andreynering): on this style of custom unmarshalling,
-		// even number contains the keys, while odd numbers contains
-		// the values.
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
 		for i := 0; i < len(node.Content); i += 2 {
 			keyNode := node.Content[i]
 			valueNode := node.Content[i+1]
 
+			// Decode the value node into an Include struct
 			var v Include
 			if err := valueNode.Decode(&v); err != nil {
 				return errors.NewTaskfileDecodeError(err, node)
 			}
+
+			// Set the include namespace
 			v.Namespace = keyNode.Value
+
+			// Add the include to the ordered map
 			includes.Set(keyNode.Value, &v)
 		}
 		return nil
@@ -49,22 +131,6 @@ func (includes *Includes) UnmarshalYAML(node *yaml.Node) error {
 	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("includes")
 }
 
-// Len returns the length of the map
-func (includes *Includes) Len() int {
-	if includes == nil {
-		return 0
-	}
-	return includes.OrderedMap.Len()
-}
-
-// Wrapper around OrderedMap.Set to ensure we don't get nil pointer errors
-func (includes *Includes) Range(f func(k string, v *Include) error) error {
-	if includes == nil {
-		return nil
-	}
-	return includes.OrderedMap.Range(f)
-}
-
 func (include *Include) UnmarshalYAML(node *yaml.Node) error {
 	switch node.Kind {
 
@@ -84,6 +150,7 @@ func (include *Include) UnmarshalYAML(node *yaml.Node) error {
 			Internal bool
 			Flatten  bool
 			Aliases  []string
+			Excludes []string
 			Vars     *Vars
 		}
 		if err := node.Decode(&includedTaskfile); err != nil {
@@ -94,6 +161,7 @@ func (include *Include) UnmarshalYAML(node *yaml.Node) error {
 		include.Optional = includedTaskfile.Optional
 		include.Internal = includedTaskfile.Internal
 		include.Aliases = includedTaskfile.Aliases
+		include.Excludes = includedTaskfile.Excludes
 		include.AdvancedImport = true
 		include.Vars = includedTaskfile.Vars
 		include.Flatten = includedTaskfile.Flatten
@@ -115,6 +183,7 @@ func (include *Include) DeepCopy() *Include {
 		Dir:            include.Dir,
 		Optional:       include.Optional,
 		Internal:       include.Internal,
+		Excludes:       deepcopy.Slice(include.Excludes),
 		AdvancedImport: include.AdvancedImport,
 		Vars:           include.Vars.DeepCopy(),
 		Flatten:        include.Flatten,

taskfile/ast/matrix.go

@@ -0,0 +1,95 @@
+package ast
+
+import (
+	"github.com/elliotchance/orderedmap/v2"
+	"gopkg.in/yaml.v3"
+
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/deepcopy"
+)
+
+type Matrix struct {
+	om *orderedmap.OrderedMap[string, []any]
+}
+
+type MatrixElement orderedmap.Element[string, []any]
+
+func NewMatrix(els ...*MatrixElement) *Matrix {
+	matrix := &Matrix{
+		om: orderedmap.NewOrderedMap[string, []any](),
+	}
+	for _, el := range els {
+		matrix.Set(el.Key, el.Value)
+	}
+	return matrix
+}
+
+func (matrix *Matrix) Len() int {
+	if matrix == nil || matrix.om == nil {
+		return 0
+	}
+	return matrix.om.Len()
+}
+
+func (matrix *Matrix) Get(key string) ([]any, bool) {
+	if matrix == nil || matrix.om == nil {
+		return nil, false
+	}
+	return matrix.om.Get(key)
+}
+
+func (matrix *Matrix) Set(key string, value []any) bool {
+	if matrix == nil {
+		matrix = NewMatrix()
+	}
+	if matrix.om == nil {
+		matrix.om = orderedmap.NewOrderedMap[string, []any]()
+	}
+	return matrix.om.Set(key, value)
+}
+
+func (matrix *Matrix) Range(f func(k string, v []any) error) error {
+	if matrix == nil || matrix.om == nil {
+		return nil
+	}
+	for pair := matrix.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (matrix *Matrix) DeepCopy() *Matrix {
+	if matrix == nil {
+		return nil
+	}
+	return &Matrix{
+		om: deepcopy.OrderedMap(matrix.om),
+	}
+}
+
+func (matrix *Matrix) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+	case yaml.MappingNode:
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
+
+			// Decode the value node into a Matrix struct
+			var v []any
+			if err := valueNode.Decode(&v); err != nil {
+				return errors.NewTaskfileDecodeError(err, node)
+			}
+
+			// Add the task to the ordered map
+			matrix.Set(keyNode.Value, v)
+		}
+		return nil
+	}
+
+	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("matrix")
+}

taskfile/ast/platforms_test.go

@@ -8,6 +8,8 @@ import (
 )
 
 func TestPlatformParsing(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		Input        string
 		ExpectedOS   string
@@ -34,6 +36,8 @@ func TestPlatformParsing(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.Input, func(t *testing.T) {
+			t.Parallel()
+
 			var p Platform
 			err := p.parsePlatform(test.Input)
 

taskfile/ast/precondition_test.go

@@ -11,6 +11,8 @@ import (
 )
 
 func TestPreconditionParse(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		content  string
 		v        any

taskfile/ast/taskfile.go

@@ -29,7 +29,7 @@ type Taskfile struct {
 	Shopt    []string
 	Vars     *Vars
 	Env      *Vars
-	Tasks    Tasks
+	Tasks    *Tasks
 	Silent   bool
 	Dotenv   []string
 	Run      string
@@ -47,11 +47,17 @@ func (t1 *Taskfile) Merge(t2 *Taskfile, include *Include) error {
 	if t2.Output.IsSet() {
 		t1.Output = t2.Output
 	}
+	if t1.Includes == nil {
+		t1.Includes = NewIncludes()
+	}
 	if t1.Vars == nil {
-		t1.Vars = &Vars{}
+		t1.Vars = NewVars()
 	}
 	if t1.Env == nil {
-		t1.Env = &Vars{}
+		t1.Env = NewVars()
+	}
+	if t1.Tasks == nil {
+		t1.Tasks = NewTasks()
 	}
 	t1.Vars.Merge(t2.Vars, include)
 	t1.Env.Merge(t2.Env, include)
@@ -70,7 +76,7 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 			Shopt    []string
 			Vars     *Vars
 			Env      *Vars
-			Tasks    Tasks
+			Tasks    *Tasks
 			Silent   bool
 			Dotenv   []string
 			Run      string
@@ -92,11 +98,17 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 		tf.Dotenv = taskfile.Dotenv
 		tf.Run = taskfile.Run
 		tf.Interval = taskfile.Interval
+		if tf.Includes == nil {
+			tf.Includes = NewIncludes()
+		}
 		if tf.Vars == nil {
-			tf.Vars = &Vars{}
+			tf.Vars = NewVars()
 		}
 		if tf.Env == nil {
-			tf.Env = &Vars{}
+			tf.Env = NewVars()
+		}
+		if tf.Tasks == nil {
+			tf.Tasks = NewTasks()
 		}
 		return nil
 	}

taskfile/ast/taskfile_test.go

@@ -7,11 +7,12 @@ import (
 	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 
-	"github.com/go-task/task/v3/internal/omap"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestCmdParse(t *testing.T) {
+	t.Parallel()
+
 	const (
 		yamlCmd      = `echo "a string command"`
 		yamlDep      = `"task-name"`
@@ -38,15 +39,21 @@ vars:
 			yamlTaskCall,
 			&ast.Cmd{},
 			&ast.Cmd{
-				Task: "another-task", Vars: &ast.Vars{
-					OrderedMap: omap.FromMapWithOrder(
-						map[string]ast.Var{
-							"PARAM1": {Value: "VALUE1"},
-							"PARAM2": {Value: "VALUE2"},
+				Task: "another-task",
+				Vars: ast.NewVars(
+					&ast.VarElement{
+						Key: "PARAM1",
+						Value: ast.Var{
+							Value: "VALUE1",
 						},
-						[]string{"PARAM1", "PARAM2"},
-					),
-				},
+					},
+					&ast.VarElement{
+						Key: "PARAM2",
+						Value: ast.Var{
+							Value: "VALUE2",
+						},
+					},
+				),
 			},
 		},
 		{
@@ -58,14 +65,15 @@ vars:
 			yamlDeferredCall,
 			&ast.Cmd{},
 			&ast.Cmd{
-				Task: "some_task", Vars: &ast.Vars{
-					OrderedMap: omap.FromMapWithOrder(
-						map[string]ast.Var{
-							"PARAM1": {Value: "var"},
+				Task: "some_task",
+				Vars: ast.NewVars(
+					&ast.VarElement{
+						Key: "PARAM1",
+						Value: ast.Var{
+							Value: "var",
 						},
-						[]string{"PARAM1"},
-					),
-				},
+					},
+				),
 				Defer: true,
 			},
 		},
@@ -78,15 +86,21 @@ vars:
 			yamlTaskCall,
 			&ast.Dep{},
 			&ast.Dep{
-				Task: "another-task", Vars: &ast.Vars{
-					OrderedMap: omap.FromMapWithOrder(
-						map[string]ast.Var{
-							"PARAM1": {Value: "VALUE1"},
-							"PARAM2": {Value: "VALUE2"},
+				Task: "another-task",
+				Vars: ast.NewVars(
+					&ast.VarElement{
+						Key: "PARAM1",
+						Value: ast.Var{
+							Value: "VALUE1",
 						},
-						[]string{"PARAM1", "PARAM2"},
-					),
-				},
+					},
+					&ast.VarElement{
+						Key: "PARAM2",
+						Value: ast.Var{
+							Value: "VALUE2",
+						},
+					},
+				),
 			},
 		},
 	}

taskfile/ast/tasks.go

@@ -4,32 +4,135 @@ import (
 	"fmt"
 	"slices"
 	"strings"
+	"sync"
 
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/internal/omap"
 )
 
-// Tasks represents a group of tasks
-type Tasks struct {
-	omap.OrderedMap[string, *Task]
+type (
+	// Tasks is an ordered map of task names to Tasks.
+	Tasks struct {
+		om    *orderedmap.OrderedMap[string, *Task]
+		mutex sync.RWMutex
+	}
+	// A TaskElement is a key-value pair that is used for initializing a Tasks
+	// structure.
+	TaskElement orderedmap.Element[string, *Task]
+	// MatchingTask represents a task that matches a given call. It includes the
+	// task itself and a list of wildcards that were matched.
+	MatchingTask struct {
+		Task      *Task
+		Wildcards []string
+	}
+)
+
+// NewTasks creates a new instance of Tasks and initializes it with the provided
+// set of elements, if any. The elements are added in the order they are passed.
+func NewTasks(els ...*TaskElement) *Tasks {
+	tasks := &Tasks{
+		om: orderedmap.NewOrderedMap[string, *Task](),
+	}
+	for _, el := range els {
+		tasks.Set(el.Key, el.Value)
+	}
+	return tasks
 }
 
-type MatchingTask struct {
-	Task      *Task
-	Wildcards []string
+// Len returns the number of variables in the Tasks map.
+func (tasks *Tasks) Len() int {
+	if tasks == nil || tasks.om == nil {
+		return 0
+	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	return tasks.om.Len()
 }
 
+// Get returns the value the the task with the provided key and a boolean that
+// indicates if the value was found or not. If the value is not found, the
+// returned task is a zero value and the bool is false.
+func (tasks *Tasks) Get(key string) (*Task, bool) {
+	if tasks == nil || tasks.om == nil {
+		return &Task{}, false
+	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	return tasks.om.Get(key)
+}
+
+// Set sets the value of the task with the provided key to the provided value.
+// If the task already exists, its value is updated. If the task does not exist,
+// it is created.
+func (tasks *Tasks) Set(key string, value *Task) bool {
+	if tasks == nil {
+		tasks = NewTasks()
+	}
+	if tasks.om == nil {
+		tasks.om = orderedmap.NewOrderedMap[string, *Task]()
+	}
+	defer tasks.mutex.Unlock()
+	tasks.mutex.Lock()
+	return tasks.om.Set(key, value)
+}
+
+// Range calls the provided function for each task in the map. The function
+// receives the task's key and value as arguments. If the function returns an
+// error, the iteration stops and the error is returned.
+func (tasks *Tasks) Range(f func(k string, v *Task) error) error {
+	if tasks == nil || tasks.om == nil {
+		return nil
+	}
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Keys returns a slice of all the keys in the Tasks map.
+func (tasks *Tasks) Keys() []string {
+	if tasks == nil {
+		return nil
+	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	var keys []string
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		keys = append(keys, pair.Key)
+	}
+	return keys
+}
+
+// Values returns a slice of all the values in the Tasks map.
+func (tasks *Tasks) Values() []*Task {
+	if tasks == nil {
+		return nil
+	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	var values []*Task
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		values = append(values, pair.Value)
+	}
+	return values
+}
+
+// FindMatchingTasks returns a list of tasks that match the given call. A task
+// matches a call if its name is equal to the call's task name or if it matches
+// a wildcard pattern. The function returns a list of MatchingTask structs, each
+// containing a task and a list of wildcards that were matched.
 func (t *Tasks) FindMatchingTasks(call *Call) []*MatchingTask {
 	if call == nil {
 		return nil
 	}
-	var task *Task
 	var matchingTasks []*MatchingTask
 	// If there is a direct match, return it
-	if task = t.OrderedMap.Get(call.Task); task != nil {
+	if task, ok := t.Get(call.Task); ok {
 		matchingTasks = append(matchingTasks, &MatchingTask{Task: task, Wildcards: nil})
 		return matchingTasks
 	}
@@ -47,7 +150,9 @@ func (t *Tasks) FindMatchingTasks(call *Call) []*MatchingTask {
 	return matchingTasks
 }
 
-func (t1 *Tasks) Merge(t2 Tasks, include *Include, includedTaskfileVars *Vars) error {
+func (t1 *Tasks) Merge(t2 *Tasks, include *Include, includedTaskfileVars *Vars) error {
+	defer t2.mutex.RUnlock()
+	t2.mutex.RLock()
 	err := t2.Range(func(name string, v *Task) error {
 		// We do a deep copy of the task struct here to ensure that no data can
 		// be changed elsewhere once the taskfile is merged.
@@ -56,6 +161,12 @@ func (t1 *Tasks) Merge(t2 Tasks, include *Include, includedTaskfileVars *Vars) e
 		// taskfile are marked as internal
 		task.Internal = task.Internal || (include != nil && include.Internal)
 		taskName := name
+
+		// if the task is in the exclude list, don't add it to the merged taskfile and early return
+		if slices.Contains(include.Excludes, name) {
+			return nil
+		}
+
 		if !include.Flatten {
 			// Add namespaces to task dependencies
 			for _, dep := range task.Deps {
@@ -94,13 +205,13 @@ func (t1 *Tasks) Merge(t2 Tasks, include *Include, includedTaskfileVars *Vars) e
 		if include.AdvancedImport {
 			task.Dir = filepathext.SmartJoin(include.Dir, task.Dir)
 			if task.IncludeVars == nil {
-				task.IncludeVars = &Vars{}
+				task.IncludeVars = NewVars()
 			}
 			task.IncludeVars.Merge(include.Vars, nil)
 			task.IncludedTaskfileVars = includedTaskfileVars.DeepCopy()
 		}
 
-		if t1.Get(taskName) != nil {
+		if _, ok := t1.Get(taskName); ok {
 			return &errors.TaskNameFlattenConflictError{
 				TaskName: taskName,
 				Include:  include.Namespace,
@@ -112,52 +223,53 @@ func (t1 *Tasks) Merge(t2 Tasks, include *Include, includedTaskfileVars *Vars) e
 		return nil
 	})
 
-	// If the included Taskfile has a default task, being not flattened and the parent namespace has
-	// no task with a matching name, we can add an alias so that the user can
-	// run the included Taskfile's default task without specifying its full
-	// name. If the parent namespace has aliases, we add another alias for each
-	// of them.
-	if t2.Get("default") != nil && t1.Get(include.Namespace) == nil && !include.Flatten {
+	// If the included Taskfile has a default task, is not flattened and the
+	// parent namespace has no task with a matching name, we can add an alias so
+	// that the user can run the included Taskfile's default task without
+	// specifying its full name. If the parent namespace has aliases, we add
+	// another alias for each of them.
+	_, t2DefaultExists := t2.Get("default")
+	_, t1NamespaceExists := t1.Get(include.Namespace)
+	if t2DefaultExists && !t1NamespaceExists && !include.Flatten {
 		defaultTaskName := fmt.Sprintf("%s:default", include.Namespace)
-		t1.Get(defaultTaskName).Aliases = append(t1.Get(defaultTaskName).Aliases, include.Namespace)
-		t1.Get(defaultTaskName).Aliases = slices.Concat(t1.Get(defaultTaskName).Aliases, include.Aliases)
+		t1DefaultTask, ok := t1.Get(defaultTaskName)
+		if ok {
+			t1DefaultTask.Aliases = append(t1DefaultTask.Aliases, include.Namespace)
+			t1DefaultTask.Aliases = slices.Concat(t1DefaultTask.Aliases, include.Aliases)
+		}
 	}
+
 	return err
 }
 
 func (t *Tasks) UnmarshalYAML(node *yaml.Node) error {
+	if t == nil || t.om == nil {
+		*t = *NewTasks()
+	}
 	switch node.Kind {
 	case yaml.MappingNode:
-		tasks := omap.New[string, *Task]()
-		if err := node.Decode(&tasks); err != nil {
-			return errors.NewTaskfileDecodeError(err, node)
-		}
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
 
-		// nolint: errcheck
-		tasks.Range(func(name string, task *Task) error {
-			// Set the task's name
-			if task == nil {
-				task = &Task{
-					Task: name,
-				}
+			// Decode the value node into a Task struct
+			var v Task
+			if err := valueNode.Decode(&v); err != nil {
+				return errors.NewTaskfileDecodeError(err, node)
 			}
-			task.Task = name
 
-			// Set the task's location
-			for _, keys := range node.Content {
-				if keys.Value == name {
-					task.Location = &Location{
-						Line:   keys.Line,
-						Column: keys.Column,
-					}
-				}
+			// Set the task name and location
+			v.Task = keyNode.Value
+			v.Location = &Location{
+				Line:   keyNode.Line,
+				Column: keyNode.Column,
 			}
-			tasks.Set(name, task)
-			return nil
-		})
 
-		*t = Tasks{
-			OrderedMap: tasks,
+			// Add the task to the ordered map
+			t.Set(keyNode.Value, &v)
 		}
 		return nil
 	}

taskfile/ast/var.go

@@ -2,81 +2,169 @@ package ast
 
 import (
 	"strings"
+	"sync"
 
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/deepcopy"
 	"github.com/go-task/task/v3/internal/experiments"
-	"github.com/go-task/task/v3/internal/omap"
 )
 
-// Vars is a string[string] variables map.
-type Vars struct {
-	omap.OrderedMap[string, Var]
+type (
+	// Vars is an ordered map of variable names to values.
+	Vars struct {
+		om    *orderedmap.OrderedMap[string, Var]
+		mutex sync.RWMutex
+	}
+	// A VarElement is a key-value pair that is used for initializing a Vars
+	// structure.
+	VarElement orderedmap.Element[string, Var]
+)
+
+// NewVars creates a new instance of Vars and initializes it with the provided
+// set of elements, if any. The elements are added in the order they are passed.
+func NewVars(els ...*VarElement) *Vars {
+	vars := &Vars{
+		om: orderedmap.NewOrderedMap[string, Var](),
+	}
+	for _, el := range els {
+		vars.Set(el.Key, el.Value)
+	}
+	return vars
 }
 
-// ToCacheMap converts Vars to a map containing only the static
+// Len returns the number of variables in the Vars map.
+func (vars *Vars) Len() int {
+	if vars == nil || vars.om == nil {
+		return 0
+	}
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	return vars.om.Len()
+}
+
+// Get returns the value the the variable with the provided key and a boolean
+// that indicates if the value was found or not. If the value is not found, the
+// returned variable is a zero value and the bool is false.
+func (vars *Vars) Get(key string) (Var, bool) {
+	if vars == nil || vars.om == nil {
+		return Var{}, false
+	}
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	return vars.om.Get(key)
+}
+
+// Set sets the value of the variable with the provided key to the provided
+// value. If the variable already exists, its value is updated. If the variable
+// does not exist, it is created.
+func (vars *Vars) Set(key string, value Var) bool {
+	if vars == nil {
+		vars = NewVars()
+	}
+	if vars.om == nil {
+		vars.om = orderedmap.NewOrderedMap[string, Var]()
+	}
+	defer vars.mutex.Unlock()
+	vars.mutex.Lock()
+	return vars.om.Set(key, value)
+}
+
+// Range calls the provided function for each variable in the map. The function
+// receives the variable's key and value as arguments. If the function returns
+// an error, the iteration stops and the error is returned.
+func (vars *Vars) Range(f func(k string, v Var) error) error {
+	if vars == nil || vars.om == nil {
+		return nil
+	}
+	for pair := vars.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ToCacheMap converts Vars to an unordered map containing only the static
 // variables
-func (vs *Vars) ToCacheMap() (m map[string]any) {
-	m = make(map[string]any, vs.Len())
-	_ = vs.Range(func(k string, v Var) error {
-		if v.Sh != nil && *v.Sh != "" {
+func (vars *Vars) ToCacheMap() (m map[string]any) {
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	m = make(map[string]any, vars.Len())
+	for pair := vars.om.Front(); pair != nil; pair = pair.Next() {
+		if pair.Value.Sh != nil && *pair.Value.Sh != "" {
 			// Dynamic variable is not yet resolved; trigger
 			// <no value> to be used in templates.
 			return nil
 		}
-
-		if v.Live != nil {
-			m[k] = v.Live
+		if pair.Value.Live != nil {
+			m[pair.Key] = pair.Value.Live
 		} else {
-			m[k] = v.Value
+			m[pair.Key] = pair.Value.Value
 		}
-		return nil
-	})
+	}
 	return
 }
 
-// Wrapper around OrderedMap.Set to ensure we don't get nil pointer errors
-func (vs *Vars) Range(f func(k string, v Var) error) error {
-	if vs == nil {
-		return nil
-	}
-	return vs.OrderedMap.Range(f)
-}
-
-// Wrapper around OrderedMap.Merge to ensure we don't get nil pointer errors
-func (vs *Vars) Merge(other *Vars, include *Include) {
-	if vs == nil || other == nil {
+// Merge loops over other and merges it values with the variables in vars. If
+// the include parameter is not nil and its it is an advanced import, the
+// directory is set set to the value of the include parameter.
+func (vars *Vars) Merge(other *Vars, include *Include) {
+	if vars == nil || vars.om == nil || other == nil {
 		return
 	}
-	_ = other.Range(func(key string, value Var) error {
+	defer other.mutex.RUnlock()
+	other.mutex.RLock()
+	for pair := other.om.Front(); pair != nil; pair = pair.Next() {
 		if include != nil && include.AdvancedImport {
-			value.Dir = include.Dir
+			pair.Value.Dir = include.Dir
 		}
-		vs.Set(key, value)
-		return nil
-	})
-}
-
-// Wrapper around OrderedMap.Len to ensure we don't get nil pointer errors
-func (vs *Vars) Len() int {
-	if vs == nil {
-		return 0
+		vars.om.Set(pair.Key, pair.Value)
 	}
-	return vs.OrderedMap.Len()
 }
 
-// DeepCopy creates a new instance of Vars and copies
-// data by value from the source struct.
 func (vs *Vars) DeepCopy() *Vars {
 	if vs == nil {
 		return nil
 	}
+	defer vs.mutex.RUnlock()
+	vs.mutex.RLock()
 	return &Vars{
-		OrderedMap: vs.OrderedMap.DeepCopy(),
+		om: deepcopy.OrderedMap(vs.om),
 	}
 }
 
+func (vs *Vars) UnmarshalYAML(node *yaml.Node) error {
+	if vs == nil || vs.om == nil {
+		*vs = *NewVars()
+	}
+	vs.om = orderedmap.NewOrderedMap[string, Var]()
+	switch node.Kind {
+	case yaml.MappingNode:
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
+
+			// Decode the value node into a Task struct
+			var v Var
+			if err := valueNode.Decode(&v); err != nil {
+				return errors.NewTaskfileDecodeError(err, node)
+			}
+
+			// Add the task to the ordered map
+			vs.Set(keyNode.Value, v)
+		}
+		return nil
+	}
+
+	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("vars")
+}
+
 // Var represents either a static or dynamic variable.
 type Var struct {
 	Value any
@@ -87,7 +175,7 @@ type Var struct {
 }
 
 func (v *Var) UnmarshalYAML(node *yaml.Node) error {
-	if experiments.MapVariables.Enabled {
+	if experiments.MapVariables.Enabled() {
 
 		// This implementation is not backwards-compatible and replaces the 'sh' key with map variables
 		if experiments.MapVariables.Value == "1" {

taskfile/dotenv.go

@@ -22,7 +22,7 @@ func Dotenv(c *compiler.Compiler, tf *ast.Taskfile, dir string) (*ast.Vars, erro
 		return nil, err
 	}
 
-	env := &ast.Vars{}
+	env := ast.NewVars()
 	cache := &templater.Cache{Vars: vars}
 
 	for _, dotEnvPath := range tf.Dotenv {
@@ -41,7 +41,7 @@ func Dotenv(c *compiler.Compiler, tf *ast.Taskfile, dir string) (*ast.Vars, erro
 			return nil, fmt.Errorf("error reading env file %s: %w", dotEnvPath, err)
 		}
 		for key, value := range envs {
-			if ok := env.Exists(key); !ok {
+			if _, ok := env.Get(key); !ok {
 				env.Set(key, ast.Var{Value: value})
 			}
 		}

taskfile/node.go

@@ -64,7 +64,7 @@ func NewNode(
 
 	}
 
-	if node.Remote() && !experiments.RemoteTaskfiles.Enabled {
+	if node.Remote() && !experiments.RemoteTaskfiles.Enabled() {
 		return nil, errors.New("task: Remote taskfiles are not enabled. You can read more about this experiment and how to enable it at https://taskfile.dev/experiments/remote-taskfiles")
 	}
 	return node, err

taskfile/node_git_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestGitNode_ssh(t *testing.T) {
+	t.Parallel()
+
 	node, err := NewGitNode("git@github.com:foo/bar.git//Taskfile.yml?ref=main", "", false)
 	assert.NoError(t, err)
 	assert.Equal(t, "main", node.ref)
@@ -19,6 +21,8 @@ func TestGitNode_ssh(t *testing.T) {
 }
 
 func TestGitNode_sshWithDir(t *testing.T) {
+	t.Parallel()
+
 	node, err := NewGitNode("git@github.com:foo/bar.git//directory/Taskfile.yml?ref=main", "", false)
 	assert.NoError(t, err)
 	assert.Equal(t, "main", node.ref)
@@ -31,6 +35,8 @@ func TestGitNode_sshWithDir(t *testing.T) {
 }
 
 func TestGitNode_https(t *testing.T) {
+	t.Parallel()
+
 	node, err := NewGitNode("https://github.com/foo/bar.git//Taskfile.yml?ref=main", "", false)
 	assert.NoError(t, err)
 	assert.Equal(t, "main", node.ref)
@@ -43,6 +49,8 @@ func TestGitNode_https(t *testing.T) {
 }
 
 func TestGitNode_httpsWithDir(t *testing.T) {
+	t.Parallel()
+
 	node, err := NewGitNode("https://github.com/foo/bar.git//directory/Taskfile.yml?ref=main", "", false)
 	assert.NoError(t, err)
 	assert.Equal(t, "main", node.ref)
@@ -55,6 +63,8 @@ func TestGitNode_httpsWithDir(t *testing.T) {
 }
 
 func TestGitNode_FilenameAndDir(t *testing.T) {
+	t.Parallel()
+
 	node, err := NewGitNode("https://github.com/foo/bar.git//directory/Taskfile.yml?ref=main", "", false)
 	assert.NoError(t, err)
 	filename, dir := node.FilenameAndLastDir()

taskfile/node_http.go

@@ -17,9 +17,10 @@ import (
 // An HTTPNode is a node that reads a Taskfile from a remote location via HTTP.
 type HTTPNode struct {
 	*BaseNode
-	URL     *url.URL
-	logger  *logger.Logger
-	timeout time.Duration
+	URL        *url.URL // stores url pointing actual remote file. (e.g. with Taskfile.yml)
+	entrypoint string   // stores entrypoint url. used for building graph vertices.
+	logger     *logger.Logger
+	timeout    time.Duration
 }
 
 func NewHTTPNode(
@@ -40,15 +41,16 @@ func NewHTTPNode(
 	}
 
 	return &HTTPNode{
-		BaseNode: base,
-		URL:      url,
-		timeout:  timeout,
-		logger:   l,
+		BaseNode:   base,
+		URL:        url,
+		entrypoint: entrypoint,
+		timeout:    timeout,
+		logger:     l,
 	}, nil
 }
 
 func (node *HTTPNode) Location() string {
-	return node.URL.String()
+	return node.entrypoint
 }
 
 func (node *HTTPNode) Remote() bool {
@@ -119,6 +121,6 @@ func (node *HTTPNode) ResolveDir(dir string) (string, error) {
 }
 
 func (node *HTTPNode) FilenameAndLastDir() (string, string) {
-	dir, filename := filepath.Split(node.URL.Path)
+	dir, filename := filepath.Split(node.entrypoint)
 	return filepath.Base(dir), filename
 }

taskfile/node_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestScheme(t *testing.T) {
+	t.Parallel()
+
 	scheme, err := getScheme("https://github.com/foo/bar.git")
 	assert.NoError(t, err)
 	assert.Equal(t, "git", scheme)

taskfile/reader.go

@@ -115,6 +115,7 @@ func (r *Reader) include(node Node) error {
 				Flatten:        include.Flatten,
 				Aliases:        include.Aliases,
 				AdvancedImport: include.AdvancedImport,
+				Excludes:       include.Excludes,
 				Vars:           include.Vars,
 			}
 			if err := cache.Err(); err != nil {

taskfile/taskfile.go

@@ -43,13 +43,13 @@ var (
 // found, an error will be returned.
 func RemoteExists(ctx context.Context, l *logger.Logger, u *url.URL, timeout time.Duration) (*url.URL, error) {
 	// Create a new HEAD request for the given URL to check if the resource exists
-	req, err := http.NewRequest("HEAD", u.String(), nil)
+	req, err := http.NewRequestWithContext(ctx, "HEAD", u.String(), nil)
 	if err != nil {
 		return nil, errors.TaskfileFetchFailedError{URI: u.String()}
 	}
 
 	// Request the given URL
-	resp, err := http.DefaultClient.Do(req.WithContext(ctx))
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		if errors.Is(ctx.Err(), context.DeadlineExceeded) {
 			return nil, &errors.TaskfileNetworkTimeoutError{URI: u.String(), Timeout: timeout}

testdata/cmds_vars/Taskfile.yml

@@ -0,0 +1,16 @@
+version: '3'
+
+tasks:
+  build-checksum:
+    sources:
+      - ./source.txt
+    cmds:
+      - echo "{{.CHECKSUM}}"
+
+  build-ts:
+    method: timestamp
+    sources:
+      - ./source.txt
+    cmds:
+      - echo '{{.TIMESTAMP.Unix}}'
+      - echo '{{.TIMESTAMP}}'

testdata/cmds_vars/source.txt

@@ -0,0 +1 @@
+Hello, World!

testdata/deferred/Taskfile.yml

@@ -1,12 +1,14 @@
-version: "3"
+version: '3'
 
 tasks:
   task-1:
     - echo 'task-1 ran {{.PARAM}}'
 
   task-2:
-    - defer: { task: "task-1", vars: { PARAM: "successfully" } }
+    - defer: { task: 'task-1', vars: { PARAM: 'successfully' } }
+    - defer: { task: 'task-1', vars: { PARAM: 'successfully' }, silent: true }
     - defer: echo 'echo ran'
+      silent: true
     - defer: echo 'failing' && exit 2
     - echo 'cmd ran'
     - exit 1

testdata/env/Taskfile.yml

@@ -17,6 +17,7 @@ tasks:
       - task: global
       - task: not-overridden
       - task: multiple_type
+      - task: dynamic
 
   local:
     vars:
@@ -50,3 +51,11 @@ tasks:
   overridden:
     cmds:
       - echo "QUX='$QUX'" > overridden.txt
+
+  dynamic:
+    silent: true
+    vars:
+      DYNAMIC_FOO:
+        sh: echo $FOO
+    cmds:
+      - echo "{{ .DYNAMIC_FOO }}" > dynamic.txt

testdata/includes_with_excludes/Taskfile.yml

@@ -0,0 +1,17 @@
+version: '3'
+
+includes:
+  included:
+    taskfile: ./included/Taskfile.yml
+    excludes:
+        - foo
+  included_flatten:
+    taskfile: ./included/Taskfile.yml
+    flatten: true
+    excludes:
+      - bar
+
+tasks:
+  default:
+    cmds:
+      - echo "called_dep" > called_dep.txt

testdata/includes_with_excludes/included/Taskfile.yml

@@ -0,0 +1,5 @@
+version: '3'
+
+tasks:
+  foo: echo foo
+  bar: echo bar

testdata/requires/Taskfile.yml

@@ -7,12 +7,40 @@ tasks:
   missing-var:
     requires:
       vars:
-        - foo
+        - FOO
     cmd: echo "{{.foo}}"
 
+  var-defined-in-task:
+    vars:
+      FOO: bar
+    requires:
+      vars:
+        - FOO
+    cmd: echo "{{.FOO}}"
+
+
+  validation-var-dynamic:
+    vars:
+      FOO:
+        sh: echo "one"
+
+    requires:
+      vars:
+        - name: FOO
+          enum: ['one', 'two']
+
 
   validation-var:
     requires:
       vars:
-        - name: foo
+        - name: FOO
           enum: ['one', 'two']
+
+
+  require-before-compile:
+    requires:
+      vars: [ MY_VAR ]
+    cmd: |
+      {{range .MY_VAR | splitList " " }}
+        echo {{.}}
+      {{end}}

testdata/special_vars/Taskfile.yml

@@ -19,3 +19,6 @@ tasks:
     cmds:
       - echo "{{.ALIAS}}"
   print-task-alias-default: echo "{{.ALIAS}}"
+  print-task-dir:
+    dir: 'foo'
+    cmd: echo {{.TASK_DIR}}

testdata/status_vars/Taskfile.yml

@@ -1,10 +1,16 @@
 version: '3'
 
 tasks:
-  build:
+  build-checksum:
     sources:
       - ./source.txt
     status:
       - echo "{{.CHECKSUM}}"
+
+  build-ts:
+    method: timestamp
+    sources:
+      - ./source.txt
+    status:
       - echo '{{.TIMESTAMP.Unix}}'
       - echo '{{.TIMESTAMP}}'

testdata/var_inheritance/v3/entrypoint-global-dotenv/Taskfile.yml

@@ -0,0 +1,11 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+
+tasks:
+  default:
+    cmds:
+      - 'echo "{{.VAR}}"'
+      - 'echo "$ENV"'

testdata/var_inheritance/v3/entrypoint-global-dotenv/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv

testdata/var_inheritance/v3/entrypoint-global-vars/Taskfile.yml

@@ -0,0 +1,15 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+vars:
+  VAR: entrypoint-global-vars
+env:
+  ENV: entrypoint-global-vars
+
+tasks:
+  default:
+    cmds:
+      - 'echo "{{.VAR}}"'
+      - 'echo "$ENV"'

testdata/var_inheritance/v3/entrypoint-global-vars/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv

testdata/var_inheritance/v3/entrypoint-task-call-dotenv/Taskfile.yml

@@ -0,0 +1,25 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+vars:
+  VAR: entrypoint-global-vars
+env:
+  ENV: entrypoint-global-vars
+
+tasks:
+  default:
+    dotenv:
+      - 'task.env'
+    cmds:
+      - task: called-task
+        vars:
+          VAR: entrypoint-task-call-vars
+
+  called-task:
+    dotenv:
+      - 'called-task.env'
+    cmds:
+      - 'echo "{{.VAR}}"'
+      - 'echo "$ENV"'

testdata/var_inheritance/v3/entrypoint-task-call-dotenv/called-task.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-task-call-dotenv
+ENV=entrypoint-task-call-dotenv

testdata/var_inheritance/v3/entrypoint-task-call-dotenv/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv

testdata/var_inheritance/v3/entrypoint-task-call-dotenv/task.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-task-dotenv
+ENV=entrypoint-task-dotenv

testdata/var_inheritance/v3/entrypoint-task-call-task-vars/Taskfile.yml

@@ -0,0 +1,27 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+vars:
+  VAR: entrypoint-global-vars
+env:
+  ENV: entrypoint-global-vars
+
+tasks:
+  default:
+    dotenv:
+      - 'task.env'
+    cmds:
+      - task: called-task
+        vars:
+          VAR: entrypoint-task-call-vars
+
+  called-task:
+    vars:
+      VAR: entrypoint-task-call-task-vars
+    env:
+      ENV: entrypoint-task-call-task-vars
+    cmds:
+      - 'echo "{{.VAR}}"'
+      - 'echo "$ENV"'

testdata/var_inheritance/v3/entrypoint-task-call-task-vars/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv

testdata/var_inheritance/v3/entrypoint-task-call-task-vars/task.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-task-dotenv
+ENV=entrypoint-task-dotenv

testdata/var_inheritance/v3/entrypoint-task-call-vars/Taskfile.yml

@@ -0,0 +1,23 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+vars:
+  VAR: entrypoint-global-vars
+env:
+  ENV: entrypoint-global-vars
+
+tasks:
+  default:
+    dotenv:
+      - 'task.env'
+    cmds:
+      - task: called-task
+        vars:
+          VAR: entrypoint-task-call-vars
+
+  called-task:
+    cmds:
+      - 'echo "{{.VAR}}"'
+      - 'echo "$ENV"'

testdata/var_inheritance/v3/entrypoint-task-call-vars/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv

testdata/var_inheritance/v3/entrypoint-task-call-vars/task.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-task-dotenv
+ENV=entrypoint-task-dotenv

testdata/var_inheritance/v3/entrypoint-task-dotenv/Taskfile.yml

@@ -0,0 +1,17 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+vars:
+  VAR: entrypoint-global-vars
+env:
+  ENV: entrypoint-global-vars
+
+tasks:
+  default:
+    dotenv:
+      - 'task.env'
+    cmds:
+      - 'echo "{{.VAR}}"'
+      - 'echo "$ENV"'

testdata/var_inheritance/v3/entrypoint-task-dotenv/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv

testdata/var_inheritance/v3/entrypoint-task-dotenv/task.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-task-dotenv
+ENV=entrypoint-task-dotenv

testdata/var_inheritance/v3/entrypoint-task-vars/Taskfile.yml

@@ -0,0 +1,21 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+vars:
+  VAR: entrypoint-global-vars
+env:
+  ENV: entrypoint-global-vars
+
+tasks:
+  default:
+    dotenv:
+      - 'task.env'
+    vars:
+      VAR: entrypoint-task-vars
+    env:
+      ENV: entrypoint-task-vars
+    cmds:
+      - 'echo "{{.VAR}}"'
+      - 'echo "$ENV"'

testdata/var_inheritance/v3/entrypoint-task-vars/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv

testdata/var_inheritance/v3/entrypoint-task-vars/task.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-task-dotenv
+ENV=entrypoint-task-dotenv

testdata/var_inheritance/v3/included-global-vars/Taskfile.yml

@@ -0,0 +1,12 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+vars:
+  VAR: entrypoint-global-vars
+env:
+  ENV: entrypoint-global-vars
+
+includes:
+  included: included.yml

testdata/var_inheritance/v3/included-global-vars/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv

testdata/var_inheritance/v3/included-global-vars/included.yml

@@ -0,0 +1,13 @@
+version: '3'
+
+silent: true
+vars:
+  VAR: included-global-vars
+env:
+  ENV: included-global-vars
+
+tasks:
+  default:
+    cmds:
+      - 'echo "{{.VAR}}"'
+      - 'echo "$ENV"'

testdata/var_inheritance/v3/included-task-call-dotenv/Taskfile.yml

@@ -0,0 +1,12 @@
+version: '3'
+
+silent: true
+dotenv:
+  - 'global.env'
+vars:
+  VAR: entrypoint-global-vars
+env:
+  ENV: entrypoint-global-vars
+
+includes:
+  included: included.yml

testdata/var_inheritance/v3/included-task-call-dotenv/global.env

@@ -0,0 +1,2 @@
+VAR=entrypoint-global-dotenv
+ENV=entrypoint-global-dotenv