turbo 2.11.8 → 2.11.9

package/bin/turbo

@@ -386,7 +386,9 @@ function shouldOwnWindowsCtrlC() {
     return false;
   }
 
-  if (usesTui(process.argv.slice(2))) {
+  const args = process.argv.slice(2);
+  // Exec's command reads the console directly, like the TUI does.
+  if (usesTui(args) || selectsExec(args)) {
     return false;
   }
 
@@ -410,6 +412,62 @@ function usesTui(args) {
   return false;
 }
 
+// Global flags that take the next word as their value. Keep in step with the
+// global options in crates/turborepo-cli/src/cli/args.rs.
+const GLOBAL_VALUE_FLAGS = new Set([
+  "--api",
+  "--cwd",
+  "--heap",
+  "--login",
+  "--remote-cache-timeout",
+  "--root-turbo-json",
+  "--team",
+  "--token",
+  "--trace",
+  "--ui",
+  "--verbosity",
+  "--experimental-otel-endpoint",
+  "--experimental-otel-header",
+  "--experimental-otel-interval-ms",
+  "--experimental-otel-protocol",
+  "--experimental-otel-resource",
+  "--experimental-otel-timeout-ms",
+]);
+
+// Global flags whose value is optional. Like turbo, take the next word as
+// the value unless it is a flag.
+const GLOBAL_OPTIONAL_VALUE_FLAGS = new Set([
+  "--experimental-otel-enabled",
+  "--experimental-otel-metrics-run-summary",
+  "--experimental-otel-metrics-task-details",
+  "--experimental-otel-use-remote-cache-token",
+]);
+
+// The command is the first word that is not a flag or a flag's value, so a
+// task or argument named `exec` does not select it.
+function selectsExec(args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      return false;
+    }
+    if (arg.startsWith("-")) {
+      const next = args[i + 1];
+      if (
+        GLOBAL_VALUE_FLAGS.has(arg) ||
+        (GLOBAL_OPTIONAL_VALUE_FLAGS.has(arg) &&
+          next !== undefined &&
+          !next.startsWith("-"))
+      ) {
+        i++;
+      }
+      continue;
+    }
+    return arg === "exec";
+  }
+  return false;
+}
+
 function runTurbo() {
   if (shouldOwnWindowsCtrlC()) {
     return runTurboChild(

package/docs/guides/multi-language.mdx

@@ -1,9 +1,9 @@
 ---
 title: Multi-language support
-description: Combine package-manager and native language workspaces.
+description: Run other language toolchains alongside JavaScript packages.
 product: turborepo
 type: guide
-summary: Run JavaScript packages and experimental native Go modules in one task graph.
+summary: Use package scripts to build JavaScript and .NET projects in one task graph.
 prerequisites:
   - /docs/crafting-your-repository/structuring-a-repository
   - /docs/crafting-your-repository/configuring-tasks
@@ -14,35 +14,41 @@ related:
   - /docs/guides/migrating-from-nx
 ---
 
-Turborepo can combine package-manager workspaces with enabled native workspaces. Each workspace contributes its own package identities, dependency relationships, and tasks to the same Package Graph and Task Graph.
+Turborepo can run other language toolchains through scripts in `package.json`. Add a package for each independently cacheable project and declare its dependencies so Turborepo can order tasks and invalidate cached results.
 
-This example combines a JavaScript application with two Go modules:
+For experimental native workspace support, see the [Rust](/docs/guides/tools/rust), [Python](/docs/guides/tools/python), and [Go](/docs/guides/tools/go) guides. Those integrations discover projects and dependencies from their native workspace files.
+
+This example combines a JavaScript package with a .NET console application and a C# library. Start with [Turborepo installed](/docs/getting-started/installation) in your repository, and install the [.NET 10 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/10.0) so `dotnet` is available on `PATH`.
 
 ```text
 .
 ├── apps/api/
-│   ├── go.mod
-│   └── main.go
+│   ├── Api.csproj
+│   ├── Program.cs
+│   └── package.json
 ├── packages/
 │   ├── lib/
-│   │   ├── go.mod
-│   │   └── lib.go
+│   │   ├── Lib.csproj
+│   │   ├── Message.cs
+│   │   └── package.json
 │   └── web/
 │       └── package.json
-├── go.work
+├── .gitignore
+├── global.json
 ├── package.json
 └── turbo.json
 ```
 
-## Add the JavaScript workspace
+## Add the package-manager workspaces
 
-Include `packages/web` in the package-manager workspace:
+Include both the application and library directories. Their `package.json` files make the .NET projects visible to Turborepo:
 
 <PackageManagerTabs>
   <Tab value="pnpm">
 
 ```yaml title="./pnpm-workspace.yaml"
 packages:
+  - "apps/*"
   - "packages/*"
 ```
 
@@ -54,7 +60,8 @@ packages:
 
 ```json title="./package.json"
 {
-  "workspaces": ["packages/*"]
+  "private": true,
+  "workspaces": ["apps/*", "packages/*"]
 }
 ```
 
@@ -66,7 +73,8 @@ packages:
 
 ```json title="./package.json"
 {
-  "workspaces": ["packages/*"]
+  "private": true,
+  "workspaces": ["apps/*", "packages/*"]
 }
 ```
 
@@ -78,7 +86,8 @@ packages:
 
 ```json title="./package.json"
 {
-  "workspaces": ["packages/*"]
+  "private": true,
+  "workspaces": ["apps/*", "packages/*"]
 }
 ```
 
@@ -87,7 +96,7 @@ packages:
   </Tab>
 </PackageManagerTabs>
 
-The JavaScript application has a normal package name and script:
+The JavaScript package has a normal package name and script:
 
 ```json title="./packages/web/package.json"
 {
@@ -100,92 +109,136 @@ The JavaScript application has a normal package name and script:
 }
 ```
 
-## Add the Go workspace
+## Add the .NET projects
 
-At the repository root, create a `go.work` that lists each Go module:
+Pin the .NET SDK at the repository root so machines sharing cached builds use the same compiler. Install the version specified here:
 
-```text title="./go.work"
-go 1.22
-
-use (
-  ./apps/api
-  ./packages/lib
-)
+```json title="./global.json"
+{
+  "sdk": {
+    "version": "10.0.401",
+    "rollForward": "disable"
+  }
+}
 ```
 
-Declare the full Go module paths in `go.mod`. Turborepo derives the package names `lib` and `api` from these paths:
+`rollForward: "disable"` requires the exact SDK version. This prevents a compiler upgrade from reusing cached outputs without a corresponding change to `global.json`.
 
-```text title="./packages/lib/go.mod"
-module example.com/acme/lib
+Create the library project and its source file:
 
-go 1.22
+```xml title="./packages/lib/Lib.csproj"
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <DefaultItemExcludes>$(DefaultItemExcludes);node_modules/**</DefaultItemExcludes>
+  </PropertyGroup>
+</Project>
 ```
 
-```text title="./apps/api/go.mod"
-module example.com/acme/api
+```csharp title="./packages/lib/Message.cs"
+namespace Acme.Lib;
 
-go 1.22
+public static class Message
+{
+    public static string Text() => "API ready";
+}
+```
+
+The application uses a `ProjectReference` to resolve the library in .NET:
+
+```xml title="./apps/api/Api.csproj"
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <DefaultItemExcludes>$(DefaultItemExcludes);node_modules/**</DefaultItemExcludes>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../packages/lib/Lib.csproj" />
+  </ItemGroup>
+</Project>
+```
 
-require example.com/acme/lib v0.0.0
+```csharp title="./apps/api/Program.cs"
+System.Console.WriteLine(Acme.Lib.Message.Text());
 ```
 
-For example, the API can import and call the library:
+## Connect the projects to Turborepo
+
+Add a `package.json` beside each `.csproj` with a script that invokes the [.NET CLI](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-build):
 
-```go title="./packages/lib/lib.go"
-package lib
+```json title="./packages/lib/package.json"
+{
+  "name": "lib",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "dotnet build Lib.csproj --configuration Release"
+  }
+}
+```
 
-func Message() string {
-	return "API ready"
+```json title="./apps/api/package.json"
+{
+  "name": "api",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "dotnet build Api.csproj --configuration Release"
+  },
+  "dependencies": {
+    "lib": "workspace:*"
+  }
 }
 ```
 
-```go title="./apps/api/main.go"
-package main
+For npm, use `"lib": "*"` instead of `"workspace:*"`. Run your package manager's install command from the repository root to link the workspaces and update its lockfile.
 
-import (
-	"fmt"
+Keep the `package.json` dependency in sync with the `ProjectReference`. .NET uses the project reference to compile the application, while Turborepo uses the package dependency to build `lib` before `api` and invalidate `api`'s cache when the library changes. Turborepo does not read `.csproj` references or manage NuGet dependencies. Review both declarations whenever you add or remove a project reference.
 
-	"example.com/acme/lib"
-)
+The `DefaultItemExcludes` entries keep .NET from compiling source files reached through workspace links in `node_modules`.
 
-func main() {
-	fmt.Println(lib.Message())
-}
-```
+## Configure tasks and caching
+
+Ignore `bin/` and `obj/` to keep generated files out of the default input hash. The `outputs` setting below still lets Turborepo cache and restore `bin/`:
 
-## Enable native Go tasks
+```text title="./.gitignore"
+node_modules/
+.turbo/
+bin/
+obj/
+```
 
-Enable native Go workspace support in the root `turbo.json`:
+Configure the build task and cache the binaries produced by each .NET project:
 
 ```json title="./turbo.json"
 {
   "$schema": "https://turborepo.dev/schema.json",
-  "futureFlags": {
-    "experimentalGoWorkspaces": true
-  },
+  "globalDependencies": ["global.json"],
   "tasks": {
     "build": {
-      "dependsOn": ["^build"]
+      "dependsOn": ["^build"],
+      "outputs": ["bin/**"]
     },
-    "test": {},
-    "lint": {}
+    "web#build": {
+      "outputs": []
+    }
   }
 }
 ```
 
-Turborepo now discovers `web` from the package-manager workspace and `api` and `lib` from `go.work`. The Go modules do not need `package.json` files. A repository that contains only enabled native workspaces can also omit the root `package.json`; this mixed repository keeps one for its JavaScript workspace.
+Output paths are relative to each package. The .NET builds write to `bin/Release/net10.0`; the JavaScript script only prints a message and has no files to cache. `obj/` contains intermediate and restore state and is not cached here. A build that needs it can recreate it through `dotnet build`'s implicit restore.
 
-Go package names use the last module-path component and preserve a trailing major-version suffix: `example.com/api` becomes `api`, while `example.com/api/v2` becomes `api/v2`. Names must be unique across the entire Package Graph: another Go module ending in `/api`, or a JavaScript package named `api`, would collide with this API. Full paths are not aliases, and package-name overrides are not supported. See [Go package names](/docs/guides/tools/go#package-names) for collision handling.
+Adding `global.json` to [`globalDependencies`](/docs/reference/configuration#globaldependencies) makes SDK version changes in that file invalidate cached tasks. Update the pinned version when upgrading the SDK; Turborepo does not detect the installed .NET SDK version automatically. If you add shared files such as `Directory.Build.props`, `Directory.Build.targets`, or `NuGet.Config`, include those in your task inputs or global dependencies too. Keep the build environment consistent between machines that share cached outputs.
 
-Run JavaScript scripts and built-in native Go tasks together, or select a Go package by its derived name:
+Run all builds, or select the .NET application:
 
 ```bash title="Terminal"
 turbo run build
-turbo run test --filter=api
-turbo run api#test
-turbo run lint
+turbo run build --filter=api
+dotnet apps/api/bin/Release/net10.0/Api.dll
 ```
 
-The API's `require example.com/acme/lib` declaration resolves the dependency on the package named `lib`, so `dependsOn: ["^build"]` orders their Go builds. Keep the full module paths in `go.mod` and Go imports; those paths remain dependency-resolution metadata rather than Turborepo graph identities. The synthetic `go-workspace` package depends on every Go member but does not provide built-in `test`, `lint`, or `format` tasks. Run those tasks without a filter to execute them in each member module. See the [Go guide](/docs/guides/tools/go) for the complete native task and caching behavior.
+The application prints `API ready`. A second unchanged `turbo run build` restores the cached results. Editing `packages/lib/Message.cs` causes both `lib` and its dependent `api` to rebuild, while `web` can still use its cache.
 
-For a language without native workspace support, add a `package.json` beside each independently cacheable project and invoke its toolchain from package scripts. Turborepo then uses the package-manager relationships rather than interpreting that language's dependency graph.
+.NET still checks project references during the application's build and normally skips recompilation when they are up to date. The package dependency lets Turborepo schedule and cache each project independently; it does not replace .NET's dependency resolution.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbo",
-  "version": "2.11.8",
+  "version": "2.11.9",
   "description": "Turborepo is the build system for coding agents.",
   "homepage": "https://turborepo.dev",
   "bugs": "https://github.com/vercel/turborepo/issues",
@@ -19,12 +19,12 @@
   ],
   "main": "./bin/turbo",
   "optionalDependencies": {
-    "@turbo/darwin-64": "2.11.8",
-    "@turbo/darwin-arm64": "2.11.8",
-    "@turbo/linux-64": "2.11.8",
-    "@turbo/linux-arm64": "2.11.8",
-    "@turbo/windows-64": "2.11.8",
-    "@turbo/windows-arm64": "2.11.8"
+    "@turbo/darwin-64": "2.11.9",
+    "@turbo/darwin-arm64": "2.11.9",
+    "@turbo/linux-64": "2.11.9",
+    "@turbo/linux-arm64": "2.11.9",
+    "@turbo/windows-64": "2.11.9",
+    "@turbo/windows-arm64": "2.11.9"
   },
   "scripts": {
     "postversion": "node bump-version.js"

package/schema.json

@@ -190,6 +190,17 @@
         }
       ]
     },
+    "setup": {
+      "description": "Repository policy for `turbo setup`. Only allowed in the root turbo.json and requires `futureFlags.experimentalSetup`.",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/SetupPolicy"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "tags": {
       "description": "Arbitrary string labels for this package. In the root configuration, these labels apply to the root package.",
       "anyOf": [
@@ -223,12 +234,89 @@
   "allowComments": true,
   "allowTrailingCommas": true,
   "definitions": {
+    "AdditionalTool": {
+      "description": "A tool that `turbo setup` downloads, verifies, and installs from explicit artifacts. The full installation tree is kept; no tool-provided scripts run.",
+      "type": "object",
+      "required": ["artifacts", "version"],
+      "properties": {
+        "artifacts": {
+          "description": "Artifacts keyed by platform, such as `linux-x64-gnu` or `macos-arm64`. Platforms without an artifact are unsupported for this tool.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/Map_of_AdditionalToolArtifact"
+            }
+          ]
+        },
+        "version": {
+          "description": "The exact version of the tool. Ranges and channels are not allowed.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/String"
+            }
+          ]
+        }
+      }
+    },
+    "AdditionalToolArtifact": {
+      "description": "One platform's artifact for an additional tool.",
+      "type": "object",
+      "required": ["executables", "format", "sha256", "url"],
+      "properties": {
+        "executables": {
+          "description": "Executable names mapped to paths relative to `rootPrefix`, or to the archive's top level without one. A binary has exactly one entry, which names where the file is installed.",
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/String"
+          }
+        },
+        "format": {
+          "description": "`binary` for a single executable file, or the archive format.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/ArtifactFormat"
+            }
+          ]
+        },
+        "rootPrefix": {
+          "description": "The single top-level directory that contains every archive entry. Omit it for an archive whose entries sit at its top level. Not allowed for binaries.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/String"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "sha256": {
+          "description": "Lowercase hex SHA-256 digest of the downloaded bytes. A digest pins the expected bytes; it does not establish that the publisher is trustworthy.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/String"
+            }
+          ]
+        },
+        "url": {
+          "description": "HTTPS download URL without credentials, a query, or a fragment.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/String"
+            }
+          ]
+        }
+      }
+    },
     "Array_of_String": {
       "type": "array",
       "items": {
         "$ref": "#/definitions/String"
       }
     },
+    "ArtifactFormat": {
+      "description": "How an artifact is packaged. `binary` is a single executable file.",
+      "type": "string",
+      "enum": ["binary", "tar", "tar-gz", "zip"]
+    },
     "Boolean": {
       "type": "boolean"
     },
@@ -282,6 +370,11 @@
         }
       }
     },
+    "DependencyPolicy": {
+      "description": "How `turbo setup` prepares a toolchain's dependencies. `locked` installs them from the committed ecosystem lockfile without changing it. `skip` does not install them.",
+      "type": "string",
+      "enum": ["locked", "skip"]
+    },
     "EnvMode": {
       "description": "Turborepo's Environment Modes allow you to control which environment variables are available to a task at runtime.\n\n- `strict`: Filter environment variables to only those that are specified in the `env` and `globalEnv` keys in `turbo.json`. - `loose`: Allow all environment variables for the process to be available.\n\nDocumentation: https://turborepo.dev/docs/reference/configuration#envmode",
       "oneOf": [
@@ -510,6 +603,12 @@
         }
       }
     },
+    "Map_of_AdditionalToolArtifact": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/AdditionalToolArtifact"
+      }
+    },
     "Map_of_TagRules": {
       "type": "object",
       "additionalProperties": {
@@ -804,6 +903,179 @@
         }
       }
     },
+    "SetupMirrors": {
+      "description": "Credential-free HTTPS mirrors for `turbo setup` downloads. Each value is a base URL that serves the same paths as the official source.",
+      "type": "object",
+      "properties": {
+        "bun": {
+          "description": "Replaces the `https://github.com` origin for Bun release checksums and archives, keeping their official paths.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/String"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "go": {
+          "description": "Replaces both the `https://go.dev` and `https://dl.google.com` origins for Go's release index and archives. The mirror serves both official paths, `/dl/?mode=json&include=all` and `/go/<archive>`, beneath its base.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/String"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "node": {
+          "description": "Replaces `https://nodejs.org/dist` for Node.js release metadata and archives.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/String"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "npmRegistry": {
+          "description": "Replaces `https://registry.npmjs.org` for npm, pnpm, and Yarn package metadata and tarballs.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/String"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "python": {
+          "description": "Replaces the `https://releases.astral.sh` origin for CPython build checksums and archives, keeping their official paths.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/String"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "rust": {
+          "description": "Replaces the `https://static.rust-lang.org` origin for rustup and Rust toolchain downloads, keeping their official paths, like `RUSTUP_DIST_SERVER`.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/String"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "uv": {
+          "description": "Replaces the `https://releases.astral.sh` origin for uv's version index and release archives, keeping their official paths.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/String"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
+    "SetupPolicy": {
+      "description": "Repository policy for `turbo setup`. Only allowed in the root turbo.json and requires `futureFlags.experimentalSetup`.\n\nOptional: without it, `turbo setup` infers what to prepare from native declaration files, and detected tools are managed. Root `tools` and `dependencies` apply to every toolchain. A toolchain key overrides them for that toolchain.",
+      "type": "object",
+      "properties": {
+        "additionalTools": {
+          "description": "Tools that no built-in adapter manages, keyed by tool ID. Each declares an exact version and explicit per-platform artifacts. `turbo setup` locks, verifies, and installs them without running tool-provided scripts.",
+          "type": ["object", "null"],
+          "additionalProperties": {
+            "$ref": "#/definitions/AdditionalTool"
+          }
+        },
+        "dependencies": {
+          "description": "How `turbo setup` prepares dependencies for every toolchain.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/DependencyPolicy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "go": {
+          "description": "Setup policy for the Go toolchain. Requires `futureFlags.experimentalGoWorkspaces`.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/ToolchainSetupPolicy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "javascript": {
+          "description": "Setup policy for the JavaScript toolchain.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/ToolchainSetupPolicy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "mirrors": {
+          "description": "Credential-free HTTPS mirrors for setup downloads. `turbo.lock` keeps the official URLs, and environment variables override these values.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/SetupMirrors"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "python": {
+          "description": "Setup policy for the Python toolchain. Requires `futureFlags.experimentalPythonWorkspaces`.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/ToolchainSetupPolicy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "rust": {
+          "description": "Setup policy for the Rust toolchain. Requires `futureFlags.experimentalCargoWorkspaces`.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/ToolchainSetupPolicy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "tools": {
+          "description": "How `turbo setup` prepares tools for every toolchain.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/ToolPolicy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
     "String": {
       "type": "string"
     },
@@ -882,6 +1154,39 @@
         }
       ]
     },
+    "ToolPolicy": {
+      "description": "How `turbo setup` prepares a toolchain's tools. `managed` provisions the locked version for this repository. `verify-system` uses an installed tool after verifying that it matches the locked version. `skip` neither provisions nor verifies the tool, which also skips the toolchain's dependencies.",
+      "type": "string",
+      "enum": ["managed", "verify-system", "skip"]
+    },
+    "ToolchainSetupPolicy": {
+      "description": "Setup policy for one toolchain. Omitted values use the root `setup` values, then the inferred default.",
+      "type": "object",
+      "properties": {
+        "dependencies": {
+          "description": "How `turbo setup` prepares this toolchain's dependencies.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/DependencyPolicy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "tools": {
+          "description": "How `turbo setup` prepares this toolchain's tools.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/ToolPolicy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
     "UI": {
       "description": "Enable use of the UI for `turbo`.\n\nDocumentation: https://turborepo.dev/docs/reference/configuration#ui",
       "oneOf": [