vercel/turborepo

Turborepo is a high-performance build system and task runner designed for monorepos, orchestrating tasks across JavaScript, TypeScript, Rust, Go, and Python workspaces. It provides intelligent caching, dependency graph analysis, and file watching to accelerate development workflows. The system also includes an AI-driven maintenance agent and a comprehensive CLI for managing complex repository structures.

106 changes.

This period focused on rewriting core Turborepo infrastructure in Rust, including lockfile parsing, caching, and file watching, while migrating examples to the Next.js App Router and ESLint flat config. The work also expanded support for diverse package managers and languages, such as Bun, Go, and Cargo, and introduced new tooling for code generation and migration.

71 changes.

This period focused on extracting core Turborepo subsystems into standalone crates, including the task execution engine, hashing, scope resolution, and configuration parsing, to improve modularity and maintainability. Concurrently, significant developer experience enhancements were introduced, such as a new standalone LSP server, a VS Code extension, an interactive TUI, and real-time devtools for graph visualization. The work also expanded framework support with new examples for Angular, Solid, and Vite, while establishing robust integration test infrastructure in Rust.

67 changes.

This period focused on decomposing the monolithic Turborepo codebase into specialized crates for task execution, run orchestration, and query handling, while introducing a new structured logging system. Significant features included OpenTelemetry integration for metrics, a GraphQL API for affected task detection, and a new pluggable task executor supporting multiple toolchains. The work also expanded test coverage for watch mode, lockfile pruning, and various language ecosystems, alongside the introduction of an AI-driven maintenance platform.

The \turborepo-ai-agents\ crate now includes logic to detect when \turbo\ is invoked by an AI coding agent (such as Cursor, Claude Code, Codex, Gemini, Devin, etc.) by inspecting specific environment variables and filesystem markers. This detection aligns with the heuristics used by \@vercel/detect-agent\, allowing Turborepo to identify and potentially adjust behavior for AI-driven workflows.

crates/turborepo-ai-agents · high confidence

The \examples/with-angular\ project now includes a dedicated ESLint configuration package (\@turbo/eslint-config\) that provides two preset configurations: \angular.js\ for application code (enforcing \app\ prefixed component and directive selectors) and \library.js\ for library code (enforcing \lib\ prefixed selectors). These configurations integrate TypeScript ESLint, Angular ESLint rules for templates and accessibility, and Prettier, ensuring consistent linting standards across the Angular example.

examples/with-angular/packages/eslint-config · high confidence

The \with-angular\ example now includes a standalone Angular web application and a shared UI library. The web app (\apps/web\) is configured with Angular CLI 17.3.7, pnpm, ESLint, and VS Code launch tasks, and it imports the \MyCounterButtonComponent\ from the \ui\ package. The UI library (\packages/ui\) is set up with ng-packagr to build and publish a standalone \MyCounterButtonComponent\ that tracks and displays click counts.

examples/with-angular/apps/web, examples/with-angular/packages/ui · high confidence

The \with-yarn\ example now includes a dedicated \eslint-config\ package that provides three distinct ESLint configuration presets: \library.js\ for general library code, \next.js\ for Next.js applications (extending the Vercel style guide), and \react-internal.js\ for internal React libraries. These configurations standardize linting rules, TypeScript resolution, and environment settings across the example project.

examples/with-berry/packages/eslint-config, examples/with-yarn/packages/eslint-config · high confidence

The \with-nestjs\ example now includes a dedicated ESLint configuration package (\examples/with-nestjs/packages/eslint-config\) that uses the ESLint flat config format. This package provides a shared base configuration and specific profiles for Nest.js, Next.js, React libraries, and Node.js libraries, enabling consistent linting rules across the example's different application types.

examples/with-nestjs/packages/eslint-config · high confidence

The \with-nestjs\ example now includes a fully configured NestJS API application. This update introduces a new API service that uses SWC for faster compilation and testing, replacing previous tooling. The example features a \LinksService\ that now sanitizes user input using \escape-html\ to prevent XSS vulnerabilities in link titles. It also includes unit and end-to-end tests for the application controllers and services, along with configuration files for ESLint, Prettier, and Jest tailored for the NestJS framework.

examples/with-nestjs/apps/api · high confidence

This change introduces the \with-nestjs\ example, providing a complete starter project that combines a NestJS backend API with a React UI layer. The API package includes a \Link\ entity, corresponding Data Transfer Objects (DTOs) for creating and updating links, and is configured with ESLint flat config and Prettier. The UI package provides reusable React components (\Button\, \Card\, \Code\) and is set up with its own TypeScript and linting configuration. Additionally, a shared Jest configuration package is added to support testing for both NestJS (using SWC) and Next.js applications within the example.

examples/with-nestjs/packages/api · high confidence

Introduces a new full-stack starter template in the \examples/with-nextjs-elysia/apps/web\ directory, combining a Next.js frontend with an Elysia backend. The frontend is configured with Tailwind CSS, the React Compiler, and standalone output mode, while the layout imports the Geist font family from the \geist\ npm package. The application integrates with the Elysia server via \@elysiajs/eden\ and includes a \QueryProvider\ that implements global error handling for API requests using \sonner\ for toast notifications.

examples/with-nextjs-elysia/apps/web, examples/with-nextjs-elysia/packages/contract, examples/with-nextjs-elysia/packages/ui · high confidence

The \examples/with-typeorm/apps/web\ directory now includes a complete Next.js application that demonstrates how to integrate TypeORM within a Turborepo monorepo. This example provides a functional web interface and API routes (\/api/todo\) that use a shared \@repo/typeorm-service\ package to perform CRUD operations on todo items. The setup includes standard Next.js configuration files, TypeScript configuration extending the repo's base config, ESLint rules for Next.js, and UI components from the shared \@repo/ui\ package, serving as a reference implementation for developers building full-stack applications with TypeORM in this environment.

examples/with-typeorm/apps/web · high confidence

The \examples/with-react-native-web/apps/web\ directory now contains a fully configured Next.js application that serves as the web target for the React Native Web example. This includes the App Router structure (\app/layout.tsx\, \app/page.tsx\), a \next.config.js\ that maps \react-native\ imports to \react-native-web\ for both Webpack and Turbopack, and standard project scaffolding (ESLint, TypeScript, CSS). Users can now run the web portion of this example using standard Next.js commands.

examples/with-nestjs/apps/web, examples/with-react-native-web/apps/web · high confidence

The kitchen-sink example now includes a new \blog\ application built with Remix and Vite. This addition provides a reference implementation for deploying a Remix site to Vercel, featuring an edge-runtime route, Vercel Analytics integration, and shared UI components from the monorepo's \@repo/ui\ package.

examples/kitchen-sink/apps/blog · high confidence

Added a new community-maintained example demonstrating a Turborepo monorepo setup using Rsbuild for building a React application. This includes a \web\ app configured with Rsbuild and React, a shared \@repo/ui\ component library, and tooling for TypeScript, Rslint, and Prettier.

examples/with-rsbuild, examples/with-rsbuild/apps/web · high confidence

Added a new Turborepo example demonstrating Module Federation with Rsbuild, featuring a host app, a remote app, and a shared UI component library. The example uses specific versions of @module-federation/rsbuild-plugin (2.9.1), @rsbuild/core (2.2.8), and @rsbuild/plugin-react (2.1.0) to enable runtime composition between the React applications.

examples/with-rsbuild-module-federation, examples/with-rsbuild-module-federation/host, examples/with-rsbuild-module-federation/remote · high confidence

This change introduces a new example demonstrating Rsbuild integration, including a shared UI package (\shared-ui\) that exports a \SharedBadge\ component, a reusable UI library (\packages/ui\) providing \Header\ and \Counter\ components, and a dedicated RSLint configuration (\rslint-config\) for enforcing recommended JavaScript, TypeScript, and React rules.

examples/with-rsbuild-module-federation/shared-ui, examples/with-rsbuild/packages/rslint-config, examples/with-rsbuild/packages/ui · high confidence

The \examples/with-solid/packages/ui\ directory now contains a reusable UI package for the SolidStart example. This includes a \Button\ component that supports composition via the \asChild\ prop and class merging using \clsx\ and \tailwind-merge\. The package also provides TypeScript primitives for button, div, and span elements, along with standard configuration files for ESLint, TypeScript, and Git.

examples/with-solid/packages/ui · high confidence

This change introduces a new \with-solid\ example application built with SolidStart, including the web app source code (routes, components, entry points) and supporting configuration packages for ESLint and Tailwind CSS. The web app demonstrates a basic SolidStart setup with file-based routing, server-side rendering, and Tailwind styling, while the shared packages provide reusable linting rules and design tokens for the example workspace.

examples/with-solid/apps/web, examples/with-solid/packages/eslint-config, examples/with-solid/packages/tailwind-config · high confidence

The \typeorm-service\ package now provides a complete example of a TypeORM-based application structured with a domain layer (entity, repository, and service classes) and a custom dependency injection helper. It uses SQL.js as an in-memory database and includes unit tests for the \TodoService\ (verifying CRUD operations via mocked repositories) and integration tests for TypeORM itself, all configured with Vitest and SWC.

examples/with-typeorm/packages/typeorm-service · high confidence

The microfrontends example now includes a shared \@repo/ui\ package containing reusable React components (Button, Card, Code) and a dedicated ESLint configuration (\eslint.config.mjs\) that extends the new \@repo/eslint-config/react-internal\ rules. This change standardizes linting for React-based packages within the monorepo and provides a concrete UI component library for the example application to consume.

examples/with-microfrontends/packages/ui · high confidence

The \examples/with-typeorm/packages/ui\ package now includes a shared React UI library containing \Button\, \Card\, and \Code\ components, along with the necessary TypeScript and ESLint configuration to support them. Additionally, a Turborepo generator is provided to scaffold new React components into this library, automatically handling file creation and package exports.

examples/with-typeorm/packages/ui · high confidence

The \with-react-native-web\ example now includes a dedicated \packages/ui\ directory containing a reusable Button component. This package exports a styled Pressable button with text, configured via a custom tsup build setup to output CommonJS and ESM formats, and uses a shared TypeScript configuration. This provides a concrete UI primitive for the example application.

examples/with-react-native-web/packages/ui, examples/with-vite/packages/ui · high confidence

The Gatsby example now includes a dedicated UI package containing a basic Button component, along with the necessary TypeScript and ESLint configuration files to support it.

examples/with-gatsby/packages/ui · high confidence

The design-system example now includes a new \ui\ package containing a \Button\ component and its associated build configuration (tsup) and TypeScript settings. To support this, shared ESLint configurations for React, library, and Storybook contexts have been added to the \eslint-config\ package, and the \ui\ package is configured to extend the React ESLint rules.

examples/design-system/packages/ui · high confidence

The \examples/with-berry/packages/ui\ directory now includes a configured UI package. This adds a \tsconfig.json\ extending the shared React library configuration with strict null checks, an \.eslintrc.js\ file applying the internal React ESLint rules, and initial React components (\Button\ and \Header\) to demonstrate the setup.

examples/with-berry/packages/ui · high confidence

The \with-ultracite\ example now includes a Next.js web application (\apps/web\) and a shared UI component library (\packages/ui\). The web app provides a complete starter structure with layout, global styles, and a home page that demonstrates dark mode support and imports a reusable \Button\ component. The shared UI package exposes this \Button\ component, along with \Card\ and \Code\ components, allowing the web app to use a centralized design system.

examples/with-ultracite/apps/web, examples/with-ultracite/packages/ui · high confidence

A new mock server implementation for a subset of the Vercel API has been added to support testing. This includes endpoints for user information, team details, caching status, artifact queries, and artifact storage, along with utilities for requesting ephemeral ports to facilitate isolated test environments.

crates/turborepo-vercel-api-mock/src · high confidence

A new Vite + React example application has been added to the examples/with-vite-react/apps/web directory. This entry point provides a complete setup including the Vite configuration, TypeScript configuration extending the repository's base config, ESLint configuration, and source files for a React app that integrates shared UI components (Header, Counter) from the @repo/ui package.

examples/with-gatsby/apps/web, examples/with-vite-react/apps/web, examples/with-vue-nuxt/apps/web · high confidence

A new community-maintained example (\with-vite-module-federation\) is available, demonstrating how to use Vite with Module Federation in a Turborepo. It includes a host app (\react-host\) and a remote app (\react-remote\) that communicate via the \@module-federation/vite\ plugin, sharing a common UI component library (\@mf-vite-example/shared-ui\). Users can scaffold this setup using \npx create-turbo@latest -e with-vite-module-federation\.

(repo-wide) · high confidence

This change introduces a new \with-vite-react\ example project that includes a shared \ui\ package. The package provides reusable React components (\Header\ and \Counter\) and is configured with TypeScript strict null checks and a shared ESLint configuration based on \typescript-eslint\ and \eslint-config-prettier\. This allows users to see how to structure a Vite-based React application with shared UI libraries and consistent linting rules.

examples/with-vite-react/packages/ui · high confidence

The microfrontends example now includes two new application scaffolds: a Vite-based app (serving as the 'admin' microfrontend) and a Next.js app (serving as the 'web' microfrontend). These applications are configured in \microfrontends.json\ with specific development ports (3002 for Vite, 3000 for Next.js) and routing paths (\/admin\ and \/docs\), enabling users to run and test cross-platform microfrontend interactions locally.

examples/with-microfrontends/apps/web · high confidence

A new \with-biome\ example has been added to the Turborepo examples, providing a Next.js web application configured to use Biome for linting and formatting. This example demonstrates how to integrate Biome into a Next.js project within a monorepo, including a \biome.json\ configuration that extends shared base and Next.js-specific rules, alongside standard Next.js app router files, styles, and assets.

examples/with-biome/apps/web · high confidence

The \examples/with-vitest/apps/web\ directory now contains a complete Next.js application scaffolded with the App Router, including layout, page components, global styles, and public assets. This example integrates Vitest for testing via a dedicated \vitest.config.ts\ and includes a sample test file, while also configuring ESLint and TypeScript to align with the monorepo's shared configurations.

examples/with-vitest/apps/web · high confidence

The acme-core package now includes a new React Button component, exported via index.tsx, along with supporting configuration files. The package uses tsup for bundling to CommonJS and ESM formats with TypeScript declarations, enforces strict null checks via an extended tsconfig, and applies a specific ESLint configuration for React internal projects. This establishes the core library structure for the example.

examples/with-changesets/packages/acme-core · high confidence

The \examples/with-changesets/packages/acme-utils\ directory now contains a new utility library package. It provides a \toSlug\ function for string normalization and two React hooks: \useIsomorphicLayoutEffect\, which safely handles server-side rendering by replacing \useLayoutEffect\ with a no-op on the server, and \usePrevious\, which tracks the previous value of a prop or state. The package is configured with TypeScript strict null checks and extends the shared \@acme/eslint-config/library.js\ configuration.

examples/with-changesets/packages/acme-utils · high confidence

The \examples/with-changesets/packages/eslint-config\ package now includes a README and three new ESLint configuration files: \library.js\, \next.js\, and \react-internal.js\. These provide ready-to-use linting setups for different project types within the example workspace, extending base rules like \eslint:recommended\ and \prettier\, with specific additions such as the Vercel style guide for Next.js and browser globals for React-internal libraries.

examples/with-changesets/packages/eslint-config · high confidence

This change introduces a new \with-mcp-servers\ example that demonstrates how to use the Model Context Protocol (MCP) SDK to connect to and interact with MCP servers. The \mcp-client\ application shows how to spawn server processes (specifically a calculator and a file reader) using \StdioClientTransport\, call tools like \add\, \multiply\, and \list\_directory\, and handle the results. It also includes the necessary TypeScript configuration and an ESLint config package to support the example's development environment.

examples/with-mcp-servers/apps/mcp-client, examples/with-mcp-servers/packages/eslint-config · high confidence

The kitchen-sink API application has been introduced, providing a starter Express server that listens on port 5001 (configurable via the PORT environment variable) and exposes /status and /message/:name endpoints. The example includes a Jest-based test suite verifying these endpoints, uses tsdown for bundling to CommonJS, and is configured with shared repository ESLint and TypeScript configs.

examples/kitchen-sink/apps/api · high confidence

The kitchen-sink example now includes a new \ui\ package containing reusable React components (\CounterButton\ and \Link\) along with their corresponding Jest tests, ESLint configuration, and TypeScript build settings. This addition provides a concrete example of how to structure and test shared UI components within the Turborepo workspace.

examples/kitchen-sink/packages/ui · high confidence

A new logger package has been added to the kitchen-sink example, providing a simple \log\ utility that prefixes console output with 'LOGGER: '. The package includes a test suite verifying this behavior, along with configuration files for TypeScript, ESLint (using the shared repo config), and Turborepo build tasks.

examples/kitchen-sink/packages/logger, examples/with-biome/packages/ui · high confidence

The with-docker example now includes a new logger package that exports a simple log function and a UI package providing a reusable Button component, both configured with TypeScript and ESLint settings to integrate with the repository's shared configs.

examples/with-docker/packages/logger · high confidence

The native app subdirectory within the with-react-native-web example now includes the necessary configuration files to run as a standalone Expo application. This includes an app.json manifest defining the app metadata and Expo Router plugin, a metro.config.js for monorepo-aware bundling, and entry-point files (index.js, app/\_layout.tsx, app/index.tsx) that initialize the Expo Router stack and render a basic UI using shared components.

examples/with-react-native-web/apps/native · high confidence

Turborepo now recognizes and supports the Aube and Nub package managers. Aube is detected by the presence of an \aube-lock.yaml\ file, with lockfile operations delegated to the underlying package manager (defaulting to pnpm). Nub is detected via the \packageManager\ field in \package.json\ (e.g., \nub@x.y.z\) or \devEngines.packageManager\, and similarly delegates lockfile operations to the concrete package manager present in the repository. Both managers are added to the \PackageManager\ enum and include specific detection logic and tests.

_crates/turborepo-repository/src/package\manager · high confidence

Turborepo can now read and write Bun lockfiles (\bun.lock\/\bun.lockb\), including support for lockfile versions 0 through 3. This enables dependency resolution, workspace handling, catalog and override management, and pruning for projects using Bun as their package manager.

crates/turborepo-lockfiles/src/bun · high confidence

The \examples/with-docker/apps/web\ directory now contains a complete Next.js application configured for Docker deployment. The app uses the App Router (\src/app/layout.tsx\, \src/app/page.tsx\) and is configured with \output: 'standalone'\ in \next.config.js\ to enable efficient containerization. The provided \Dockerfile\ implements a multi-stage build using Node.js slim and Alpine images, leveraging Turborepo for pruning and building, and copies the standalone output and static assets into the final runner image. The example also includes a simple UI component that fetches data from an API host.

examples/with-docker/apps/web · high confidence

This change introduces the \with-otel\ example, providing a ready-to-use Next.js application (\examples/with-otel/apps/web\) that demonstrates OpenTelemetry integration. The example includes a shared UI package (\examples/with-otel/packages/ui\) with components like \Button\, \Card\, and \Code\, along with a centralized ESLint configuration (\examples/with-otel/packages/eslint-config\) to enforce consistent code quality across the monorepo.

examples/with-otel/apps/web, examples/with-otel/packages/eslint-config, examples/with-otel/packages/ui · high confidence

The with-vite example now includes a dedicated ESLint configuration file that sets up linting for TypeScript projects. This configuration enables recommended rules from @eslint/js and typescript-eslint, integrates with Prettier, ignores the dist directory, and specifically disables the no-non-null-assertion rule for TypeScript files.

examples/with-vite/packages/eslint-config · high confidence

The \with-tailwind\ example now includes a dedicated \@repo/eslint-config\ package that provides shared ESLint flat configurations. This package exports a base configuration for the monorepo, a Next.js-specific config that integrates the Next.js and React Hooks plugins while ignoring build artifacts, and a React-specific config for internal libraries. It also includes a README noting a workaround for TypeScript 7 compatibility by aliasing to a TypeScript 6 API package for linting purposes.

examples/with-tailwind/packages/eslint-config · high confidence

The \examples/with-gatsby/packages/eslint-config\ package now includes a \gatsby.js\ configuration file that extends the Vercel Engineering Style Guide (browser, TypeScript, and React presets) and disables default export restrictions, enabling consistent linting for Gatsby applications within the example. This change is accompanied by the addition of documentation in \README.md\ and the introduction of shared configuration profiles (\library.js\, \next.js\, and \react-internal.js\) to support various project types in the example workspace.

examples/with-gatsby/packages/eslint-config · high confidence

The kitchen-sink example now includes dedicated Jest preset files for both browser and Node.js contexts. The browser preset (\browser/jest-preset.mjs\) configures \jsdom\ as the test environment, while the Node.js preset (\node/jest-preset.mjs\) omits this environment setting. Both presets share identical configurations for TypeScript transformation via \ts-jest\, module file extensions, and path ignore patterns, ensuring consistent test setup across different execution environments within the example project.

examples/kitchen-sink/packages/jest-presets · high confidence

New TypeScript type definitions have been added to the \crates/turborepo-boundaries/bindings\ directory to support the Turborepo boundaries feature. These generated files (\BoundariesConfig.ts\, \Permissions.ts\, and \TagRules.ts\) expose the structure for configuring package dependency and dependent restrictions, including rules for tags, implicit dependencies, and allow/deny permissions, enabling better type safety for users defining boundary rules in their projects.

crates/turborepo-boundaries/bindings · high confidence

Generated TypeScript type definitions are now available for the Turborepo configuration schema, providing type safety for \turbo.json\ and global configuration files. The new bindings include \RawTurboJson\ for the main configuration structure, \Pipeline\ for individual task definitions, and \GlobalConfig\ for the new global configuration block (accessible via the \futureFlags.globalConfiguration\ flag). Additional types cover remote cache settings (\RemoteCache\), structured task inputs (\StructuredInput\, \TaskInput\), and future flags, enabling better IDE support and validation for Turborepo configuration files.

crates/turborepo-turbo-json/bindings · high confidence

The \with-vitest\ example now includes a dedicated UI package (\packages/ui\) containing reusable React components such as Button, Card, and Code, along with a Turborepo generator that allows developers to scaffold new components automatically. This package is configured with its own ESLint settings, TypeScript configuration, and build outputs, providing a structured way to manage shared UI assets within the monorepo.

examples/with-vitest/packages/ui · high confidence

A new example file (cancel.rs) demonstrates how to use the GlobWatcher with a stop token to cancel file watching operations. The example shows how to integrate the watcher with a stream and how to stop the watcher by dropping the stop source.

crates/turborepo-globwatch/examples · high confidence

A new binary utility named echo\_args has been added to the Turborepo repository. This tool accepts command-line arguments and prints them back out, serving as a simple diagnostic or testing aid for verifying argument passing behavior within the project's native Cargo support infrastructure.

crates/turborepo/src/bin · high confidence

A new example file, \berry\_resolutions.rs\, has been added to the \turborepo-lockfiles\ crate. This example demonstrates how to use the \BerryLockfile\ API to parse a Yarn Berry lockfile and retrieve the dependency tree for a specific package, including how to construct a \BerryManifest\ with resolutions.

crates/turborepo-lockfiles/examples · high confidence

The \turborepo-gitignore\ crate now ensures that the \.turbo\ directory is listed in your project's \.gitignore\ file. On startup, Turborepo checks for the presence of the \.turbo\ entry; if the file is missing or the entry is absent, it automatically appends the necessary configuration to prevent cache artifacts from being committed to version control.

crates/turborepo-gitignore · high confidence

The \eslint-plugin-turbo\ package now supports ESLint's flat configuration format (eslint.config.js) alongside the legacy eslintrc format, and the \no-undeclared-env-vars\ rule has been expanded to detect environment variables accessed via \import.meta.env\ in addition to \process.env\. The rule also now respects workspace-specific \turbo.json\ configurations (including \dotEnv\ and \env\ fields) and automatically infers known framework environment variables (such as \NEXT\PUBLIC\\\ for Next.js and \VITE\\*\ for Vite) based on the file's location within the workspace.

packages/eslint-plugin-turbo · high confidence

The Factory agent now manages a durable, versioned image registry stored in Vercel Blob, ensuring that sandbox environments are built from a consistent, reproducible base layer with compare-and-swap concurrency control. This infrastructure enables automated daily maintenance tasks that audit and update example projects—fixing stale dependencies and regenerating lockfiles—and automatically creates draft pull requests for these changes. The agent also includes robust validation logic to verify example changes before publishing, handles GitHub pull request feedback, and supports SSH terminal access for inspecting completed sandbox runs.

apps/factory/agent/lib · high confidence

The basic example now includes a dedicated \ui\ package containing reusable React components (\Button\, \Card\, \Code\) and standard project configuration files (\eslint.config.mjs\, \tsconfig.json\). The \Button\ component is explicitly marked as a client component, while \Card\ and \Code\ are server-compatible, providing a consistent set of UI primitives for the example application.

examples/basic/packages/ui · high confidence

The \examples/with-rollup/packages/ui\ directory now contains a basic UI package featuring \Button\ and \Header\ React components. This addition includes the necessary build configuration (Rollup with SWC for JSX transformation), TypeScript settings, and ESLint configuration to support the example project.

examples/with-rollup/packages/ui · high confidence

The \eslint-config-turbo\ package is now available, providing a pre-configured ESLint setup for Turborepo projects. It supports both the modern flat config format (via \eslint-config-turbo/flat\) and the legacy \eslintrc\ format, enabling users to easily enforce Turborepo-specific rules such as \turbo/no-undeclared-env-vars\.

packages/eslint-config-turbo · high confidence

The \examples/with-yarn/packages/ui\ directory now contains a fully configured internal UI library package. This includes React components (\Card\, \Code\), TypeScript configuration extending shared repo configs, ESLint rules for React and TypeScript, and a Turborepo task definition for building. Additionally, a Turborepo generator is provided to scaffold new React components, streamlining the addition of new UI elements to the library.

examples/with-yarn/packages/ui · high confidence

Adds the \@turbo/gen\ package, providing a CLI and TypeScript types for creating and running custom Turborepo generators. This includes commands to run custom generator configurations (\turbo gen run\) and scaffold new workspaces (\turbo gen workspace\), along with built-in templates for initializing generator configs in both JavaScript and TypeScript.

packages/turbo-gen · high confidence

This change introduces the new \@turbo/repository\ package, which exposes Turborepo's repository analysis capabilities to JavaScript via a native Rust addon. It provides a \Workspace\ API for discovering packages, resolving dependency graphs, and determining affected packages based on file changes, alongside a \StaticWorkspace\ API for conservative, subprocess-free package inventory and affectedness analysis. The package supports JavaScript, Cargo, uv, and Go workspaces, and includes methods to extract external packages from lockfiles and detect the package manager even when undeclared.

packages/turbo-repository · high confidence

The new \@turbo/utils\ package provides shared internal utilities for the Turborepo monorepo, including functions for case conversion, project creation, and fetching example repositories. It adds support for reading \turbo.jsonc\ configuration files alongside standard JSON, and includes logic to detect available package managers (such as Bun, Nub, and Aube) and validate directory states for new projects.

packages/turbo-utils · high confidence

The Factory agent now exposes a structured channel system that enables durable, stateful workspaces and multi-channel interaction. The new \workspace\ channel provides a REST API for creating and managing persistent agent sessions, automatically tracking sandbox status, turn history, and failure states. The \operator\ channel adds endpoints for triggering scheduled maintenance and performance runs, as well as checking run status via event streams. The \github\ channel restricts agent invocation on pull requests to trusted maintainers and handles Slack notifications for merged Factory PRs, while the \eve\ and \slack\ channels configure authentication and connectivity for browser, local development, and Slack-based interactions.

apps/factory/agent/channels · high confidence

The Factory app is now available as a distinct application within the Turborepo workspace, providing a platform for AI-driven code maintenance and issue resolution. Operators can initiate durable workspaces that persist state and transcripts, allowing them to resume agent sessions across different browser tabs or devices. The app includes automated workflows for daily example maintenance and performance improvements, as well as a system for handling GitHub issues where low-confidence findings trigger Slack alerts while high-confidence issues result in draft pull requests. Additionally, the Factory image is now rebuilt automatically on every merge to main to ensure the agent sandbox stays synchronized with the latest toolchain.

apps/factory · high confidence

Added a new \FixedMap\ data structure in the \turborepo-fixed-map\ crate, designed for thread-safe, one-time initialization of values for a predefined set of keys. This component is used to lazily load and cache \turbo.json\ configurations, ensuring that once a value is set for a key, it cannot be removed or overwritten, while supporting concurrent access via \OnceLock\.

crates/turborepo-fixed-map · high confidence

The \@turbo/telemetry\ package is now available as a JavaScript implementation, ported from the Rust crate, allowing Turborepo node packages to record anonymous usage data. It provides a \telemetry\ CLI command (enable, disable, status) for users to manage their participation, and includes specific event tracking for \create-turbo\ (e.g., example selection, package manager) and \turbo-ignore\ (e.g., CI environment, task types). The implementation uses native Node.js APIs for UUID generation and hashing, respects \DO\_NOT\_TRACK\ and \TURBO\_TELEMETRY\_DISABLED\ environment variables, and suppresses the initial alert on Vercel.

packages/turbo-telemetry · high confidence

This change adds a new \turborepo-otel\ crate that enables exporting Turborepo run and task metrics to any OTLP-compatible observability backend (such as Grafana, Datadog, or Honeycomb). Users can now configure the exporter via a \Config\ struct specifying the endpoint, protocol (gRPC or HTTP/Protobuf), and headers. The crate emits specific metrics including run duration, task attempt/failure/cache counts, and individual task durations, with attributes like task name, package, and cache status attached by default. To manage cardinality, high-volume attributes such as run ID, SCM revision, and task hash are gated behind opt-in configuration flags (\run\_attributes\ and \task\_attributes\), allowing users to control the volume of metric series sent to their backends.

crates/turborepo-otel · high confidence

The \with-prisma\ database package now uses the Prisma ORM (v7.2.0+) with a new \prisma.config.ts\ file to define the Postgres ORM and output directory, alongside a \prisma/schema.prisma\ defining a User model. A new \src/client.ts\ exports a typed database client using \@prisma/orm-postgres/runtime\ and the generated contract, and \src/seed.ts\ provides a script to upsert default users. The package also includes an ESLint config extending the repo's library rules with an allow-list for \NODE\_ENV\, a \.gitignore\ for generated files, and a \tsconfig.json\ enabling strict null checks.

examples/with-prisma/packages/database · high confidence

Added a new \turbo-schema-gen\ binary that generates JSON Schema and TypeScript type definitions for \turbo.json\ directly from the Rust source types. This tool supports generating schemas and types to stdout or files, and includes a verify command to ensure generated artifacts match the current Rust definitions. The generated JSON Schema explicitly enables JSONC support (allowing comments and trailing commas) for better editor integration.

crates/turborepo-schema-gen/src · high confidence

Turborepo now includes a dedicated Rust crate for handling anonymous telemetry. This change introduces a background worker that buffers and asynchronously flushes telemetry events to the Vercel API, ensuring that telemetry collection does not block the main execution path. The library manages its own configuration, including a persistent machine ID and salt for anonymization, and displays a one-time usage warning to users on first run (unless running on Vercel or explicitly disabled via environment variables).

crates/turborepo-telemetry/src · high confidence

A new WebSocket-based devtools server is now available, providing real-time visualization of the repository's package and task dependency graphs. The server listens on port 9876 by default and requires an authentication token for client connections. It watches for changes to relevant configuration files (such as package.json, turbo.json, and lockfiles) and automatically rebuilds the graph state, pushing updates to connected clients. The implementation includes utilities for converting internal package graphs to serializable formats, handling file system watching with debouncing, and managing server lifecycle.

crates/turborepo-devtools/src · high confidence

Adds a new operator dashboard for the Turborepo Factory, providing a centralized interface to manage factory images, workspaces, and agent runs. The dashboard includes a Factory Image page to monitor build statuses and trigger manual rebuilds, a Workspaces page to list and view durable workspace sessions, and a Start Work page to launch ad-hoc workspaces and run scheduled maintenance or performance jobs. It also features a searchable model picker for workspace creation and supports full-page terminal SSH sessions for sandbox debugging.

apps/factory/app · high confidence

The new \turborepo-microfrontends-proxy\ crate provides a local development proxy for routing HTTP and WebSocket traffic to microfrontend applications. To prevent security vulnerabilities such as Server-Side Request Forgery (SSRF) and HTTP request smuggling, the proxy enforces strict validation: it restricts proxied ports to the 3000–9999 range while explicitly blocking common system service ports (e.g., 22, 3306, 5432), and it rejects requests with conflicting Content-Length/Transfer-Encoding headers or Host headers pointing to non-localhost addresses. The proxy also includes a trie-based router for path matching, configurable fallback URLs, and a polished, dark-mode-aware error page to improve the developer experience when upstream services are unreachable.

crates/turborepo-microfrontends-proxy/src · high confidence

A new \UnescapedString\ type has been added to the \turborepo-unescape\ crate to handle JSON strings parsed by Biome that do not automatically process escape sequences. This wrapper transparently unescapes string values during deserialization, ensuring that content like \\\n\ is correctly interpreted as newline characters rather than remaining as literal backslash-n sequences. This change supports the broader integration of Biome for parsing \package.json\ files by providing a compatible string representation that works seamlessly with existing serialization, schema generation, and TypeScript type generation systems.

crates/turborepo-unescape/src · high confidence

Added a new Rust library (\turborepo-analytics\) that handles sending cache usage analytics events to the Vercel API in the background. The library introduces a \Worker\ that buffers events (flushing in batches of 100 or on shutdown) and sends them asynchronously via an \AnalyticsClient\, ensuring that analytics recording does not block the main execution flow while requiring the user to be logged in to Vercel.

crates/turborepo-analytics/src · high confidence

Added the \change\_mapper\ module in \turborepo-repository\ to handle mapping changed files to affected packages for \--filter\ and isolated builds. This introduces a \PackageChangeMapper\ trait with implementations including \DefaultPackageChangeMapper\ (which indexes package directories for efficient lookups and preserves all co-located package owners), \DefaultPackageChangeMapperWithLockfile\ (which conservatively marks the root package as changed when a lockfile is modified), and \GlobalDepsPackageChangeMapper\ (which uses \globalDependencies\ from \turbo.json\ to avoid invalidating all packages for non-global file changes). The module also defines \PackageInclusionReason\ and \AllPackageChangeReason\ enums to track why specific packages or all packages were included in a change set.

_crates/turborepo-repository/src/change\mapper · high confidence

Added the \turborepo-filewatch\ crate, providing file watching utilities that ensure cross-platform consistency by leveraging native APIs (FSEvents on macOS, inotify on Linux, ReadDirectoryChanges on Windows). The crate includes a \FileSystemWatcher\, \PackageWatcher\ for mapping changes to packages, and a \GlobWatcher\ for pattern filtering. A build script configures platform-specific features, enabling recursive watching and ancestor watching on Linux, and ancestor watching on Windows, to optimize event processing and reduce lag.

crates/turborepo-filewatch · high confidence

This change introduces the \turborepo-process\ crate, a new dedicated module for spawning and managing child processes. It provides a \ProcessManager\ that handles cross-platform process lifecycle, including graceful shutdowns and signal forwarding. On Windows, it implements a Job Object wrapper to ensure entire process trees (including ConPTY siblings like \conhost.exe\) are terminated cleanly on shutdown, preventing orphaned processes and PID reuse issues. On Unix, it preserves terminal settings for child PTYs and manages process groups. The crate also includes a \Command\ builder that supports serial execution groups for tools requiring global locks and configurable stdin handling.

crates/turborepo-process/src · high confidence

Added a new \turborepo-signals\ crate that centralizes the detection and handling of OS signals (such as Ctrl+C, SIGTERM, and SIGHUP) and in-process shutdown requests. This provides a unified mechanism for graceful shutdown across the platform, ensuring that output is preserved and cleanup tasks complete correctly before the process exits.

crates/turborepo-signals/src · high confidence

Users can now enable experimental observability by configuring the \experimentalObservability.otel\ section in \turbo.json\ or via environment variables. This change adds a new abstraction layer in \crates/turborepo-run-summary/src/observability\ that initializes an OpenTelemetry backend to record metrics and telemetry for completed Turborepo runs. The implementation includes strict validation for the OTLP endpoint, rejecting non-HTTPS URLs, those containing userinfo, and connections to private, loopback, or cloud metadata IPs to prevent SSRF. It also supports configuring metrics granularity (run summary vs. task details) and run attributes (ID, SCM revision) to control data cardinality.

crates/turborepo-run-summary/src/observability · high confidence

The \turborepo-wax\ crate now supports extracting matched text from glob patterns via the new \MatchedText\ API, allowing users to isolate specific sub-expressions (such as file names) from a match. Additionally, a new diagnostics system has been added that provides detailed, span-located warnings for semantic issues in glob expressions, such as unrecognized literal patterns or trailing separators that may discard matches.

crates/turborepo-wax/src · high confidence

Turborepo now parses \microfrontends.json\ (or \.jsonc\) files to configure the local proxy for microfrontends. The parser supports JSONC syntax, including comments and trailing commas, and allows users to specify a custom config filename via the \VC\_MICROFRONTENDS\_CONFIG\_FILE\_NAME\ environment variable. The configuration defines applications with routing paths, development ports, and fallback URLs, enabling Turborepo to correctly route traffic to local dev servers for each microfrontend application.

crates/turborepo-microfrontends/src · high confidence

Turborepo now supports discovering and orchestrating Rust (Cargo) and Go workspaces as first-class packages. This change adds new modules in the repository crate to parse Cargo manifests and Go workspace definitions, allowing Turborepo to treat Rust crates and Go modules as packages within the same graph as JavaScript/TypeScript projects. Users can now run tasks, prune, and detect affected packages across mixed-language monorepos that include Rust and Go code, provided the respective toolchains are installed.

crates/turborepo-repository/src · high confidence

The \turborepo-ui\ crate has been introduced to replace the previous output pipeline, providing a unified architecture for terminal output, structured logging, and the new TUI. Users benefit from a new \ColorSelector\ that assigns consistent colors to tasks across concurrent operations, and a \LogSinks\ system that coordinates between the \TerminalSink\ (for standard CLI output with per-task prefixes and CI annotations), the \TuiSink\ (for the interactive TUI with event buffering), and optional structured JSON/file logging. The library also includes a \LogWriter\ for multiplexing logs to files and a \UISender\ abstraction to route task events to the TUI, ensuring that log output behavior is consistent whether running in stream mode or the interactive TUI.

crates/turborepo-ui/src · high confidence

A new \turborepo-run-context\ crate has been added to centralize shared repository data for Turborepo runs. This includes the \RepoContext\ struct, which aggregates essential runtime information such as the repository root path, color configuration, version, SCM instance, package dependency graph, and turbo.json configuration. Additionally, the crate defines enums to explicitly represent why remote caching is disabled (e.g., not linked, token without team, config flags) and why it is temporarily unavailable (e.g., connection errors, usage limits), providing clearer context for the run prelude display.

crates/turborepo-run-context · high confidence

The \turborepo-lsp\ crate is introduced as a new, standalone Language Server Protocol implementation for Turborepo, replacing previous integration approaches. This server handles LSP requests and responses, including task reference resolution using JSONC AST parsing and diagnostic support for features like \$TURBO\_EXTENDS\. The binary entry point (\main.rs\) integrates daemon lifecycle management directly, allowing the LSP process to start, stop, restart, and monitor the background daemon, while also supporting custom \turbo.json\ paths and package manager check overrides.

crates/turborepo-lsp/src · high confidence

The new \turborepo-log\ crate replaces the previous logging infrastructure with a structured event system designed for end-user output. It introduces a \GroupingLayer\ that buffers per-task output, allowing Turborepo to flush task logs atomically (grouped mode) or stream them immediately (passthrough mode). The crate includes built-in sinks for collecting events in memory for post-run summaries, writing newline-delimited JSON to files, and producing machine-readable structured logs. It also adds robust handling for child process output, including control character stripping and symlink defense for log file paths.

crates/turborepo-log · high confidence

The new VS Code extension provides repository discovery, task reference navigation, and one-click task execution. It includes daemon controls to start, stop, and check the status of the Turborepo background process, and offers configuration help with instant feedback for invalid globs or non-existent tasks. The extension also supports contextual codemods to fix deprecated syntax and includes a global \turbo\ installer prompt. It features a robust binary discovery mechanism that probes installed LSPs with bounded timeouts and deduplicates candidates, ensuring non-blocking activation even with slow or hanging binaries.

packages/turbo-vsc · high confidence

A new \turbo-trace\ binary and library have been added to provide utilities for tracing and analyzing import dependencies in JavaScript and TypeScript files. The tool parses source files using \oxc\ to extract ES module imports and CommonJS \require()\ calls, supporting filtering by import type (values vs. types) and reverse tracing. It leverages \unrs\_resolver\ for accurate module resolution and exposes a CLI with options for specifying the working directory, TypeScript configuration, node modules path, and trace depth, primarily intended to support the \turbo boundaries\ feature.

crates/turbo-trace/src · high confidence

Added the \turborepo-globwalk\ crate, which provides a layer on top of the \wax\ library to handle glob pattern matching and directory traversal. This new component corrects user-provided glob patterns and escapes characters that \wax\ treats as special but are not supported by Turborepo, ensuring consistent behavior across different platforms and file systems.

crates/turborepo-globwalk/src · high confidence

A new \turborepo-types\ crate has been added to serve as a shared foundation for types used across the Turborepo ecosystem, helping to avoid circular dependencies. This includes configuration enums such as \EnvMode\ (strict/loose), \OutputLogsMode\ (full, hash-only, new-only, errors-only, none), \UIMode\ (tui, stream, stream-with-experimental-timestamps), and \DryRunMode\. It also introduces a \SecretString\ type backed by the \secrecy\ crate to prevent accidental exposure of sensitive values in logs or debug output, and provides logic for matching task input globs against changed files to support affected task detection.

crates/turborepo-types/src · high confidence

The \turborepo-wax\ crate now includes the core tokenization and parsing infrastructure for glob expressions. This change adds the \token\ module, which defines the \Tokenized\ and \Token\ structures to represent parsed glob patterns, along with \parse.rs\ for converting glob strings into these token trees using the \nom\ parser combinator library. It also introduces \variance.rs\, which implements logic for calculating the variance, depth, and breadth of glob patterns to optimize matching performance. This foundational code enables the subsequent handling of glob patterns within Turborepo's file system operations.

crates/turborepo-wax/src/token · high confidence

The \turborepo-cache\ crate has been replaced with a new implementation that supports both local filesystem and remote HTTP caching through a multiplexer. This change introduces an asynchronous worker pool for cache writes, allowing concurrent operations without blocking the main thread. It includes a new \ArtifactBody\ abstraction that keeps small artifacts in memory and spools large ones to temporary files to bound memory usage, and a chunked upload mechanism (256 KB chunks) for remote transfers. The new system also adds support for cache configuration parsing, human-readable duration parsing, and an outage breaker that temporarily disables remote cache access after sustained failures. Additionally, it captures and stores SCM metadata (git SHA and dirty hash) in cache entries for better provenance tracking.

crates/turborepo-cache/src · high confidence

The \turborepo-paths\ crate now provides a dedicated path-handling library with distinct types for different path contexts: \AbsoluteSystemPath\ for absolute filesystem paths, \AnchoredSystemPath\ for paths relative to a specific directory (such as the repository root), and \RelativeUnixPath\ for platform-independent relative paths (using forward slashes, primarily for cache storage). This change replaces previous ad-hoc path handling with a validated, UTF-8-safe system using the \camino\ library, ensuring correct path separators and preventing errors from invalid Unicode or malformed paths across Windows and Unix systems.

crates/turborepo-paths/src · high confidence

The \turborepo-pidlock\ crate has been added to manage process ID lock files, enabling the daemon to prevent concurrent execution by checking for existing locks. This implementation, forked from the external \pidlock\ crate, adds Windows support and the ability to query the lock owner, ensuring that the Turborepo daemon can safely coordinate access to shared resources across different operating systems.

crates/turborepo-pidlock/src · high confidence

The turborepo-hash crate has been extracted and introduced to provide hashing utilities for Turborepo cache keys. It utilizes Cap'n Proto for deterministic cross-platform serialization followed by xxHash64 for fast hashing, ensuring identical inputs produce identical hashes across platforms. The crate includes a build script to compile Cap'n Proto schema files and a README detailing its architecture, which supports both owned and borrowed compatibility wrappers for lockfile-package canonical serialization.

crates/turborepo-hash · high confidence

The \turborepo-task-id\ crate now provides structured, type-safe representations for task identifiers, replacing raw string handling with \TaskId\ (fully qualified, e.g., \package\#task\) and \TaskName\ (user input, optionally qualified). This change ensures that task references in the task graph and configuration files are validated at the type level, improving reliability when resolving dependencies between packages and tasks. The crate also includes automatic JSON Schema and TypeScript type generation to keep frontend and API contracts in sync with the Rust backend definitions.

crates/turborepo-task-id · high confidence

The \turborepo-profile-md\ crate now generates a structured Markdown report alongside the standard \--profile trace\ output. This new feature parses Chromium Trace Event Format JSON files and produces a human- and LLM-readable summary containing a duration overview, the top 10 hottest functions by self-time, a hot functions table, a call tree sorted by total time, and detailed function breakdowns including caller/callee relationships. This allows users to quickly analyze performance bottlenecks without needing specialized profiling tools.

crates/turborepo-profile-md · high confidence

Turborepo now includes a dedicated Rust module for Yarn v1 lockfiles, replacing the previous generic or JavaScript-based handling. This implementation provides a high-performance, single-pass fast parser for standard machine-generated lockfiles, with a fallback to a robust nom-based parser for complex or legacy formats. It supports deterministic dependency ordering via BTreeMap, correctly handles multi-key entries, preserves file: protocol dependencies during pruning, and validates the turbo version directly from the lockfile, improving both parse speed and reliability for Yarn v1 workspaces.

crates/turborepo-lockfiles/src/yarn1 · high confidence

The new \@turbo/types\ package provides TypeScript types and JSON schemas for \turbo.json\ configuration, supporting both v1 and v2 formats. It includes type definitions for task pipelines, environment modes, remote caching, and framework-specific environment wildcards (e.g., Next.js, Nuxt, Remix). The package also contains a script to generate schemas from TypeScript types and integrates with the Rust-based schema generator to keep types and schemas in sync.

packages/turbo-types · high confidence

A new \@turbo/workspaces\ package has been introduced to help users convert their repositories between different package managers (npm, pnpm, yarn, bun, nub, and aube). This package provides both a CLI (\convert\, \summary\) and a Node API (\convert\, \getWorkspaceDetails\, \install\) to detect the current package manager, convert workspace configurations and lockfiles, and install dependencies in the new manager. It supports both monorepos and non-monorepos, handles \devEngines\ and legacy \packageManager\ fields, and includes specific logic for Windows shell execution and lockfile preservation during dry-runs.

packages/turbo-workspaces · high confidence

The \with-docker\ example now includes a complete API application (\examples/with-docker/apps/api\) that can be built and run in Docker. This adds a multi-stage Dockerfile using Node 24.21.0-slim for building and Alpine for the runtime, ensuring a smaller production image. The API itself is an Express server exposing \/status\ and \/message/:name\ endpoints, configured with standard middleware (CORS, body-parser, morgan). It includes a TypeScript configuration extending the repo's base config, an ESLint setup using the shared server config, and Jest tests verifying the server's endpoints.

examples/with-docker/apps/api · high confidence

The \@repo/eslint-config\ package now provides distinct configuration presets tailored for different project types within the example. A \libraryConfig\ is available for general TypeScript libraries, combining recommended rules from ESLint, TypeScript ESLint, and Turborepo, along with Prettier integration. A \nextJsConfig\ is introduced for Next.js applications, extending the base recommendations with specific rules from the Next.js ESLint plugin (including core web vitals) and ignoring Next.js-specific output directories. Additionally, a \reactInternalConfig\ is exported, which simply re-exports the library configuration for internal React packages.

examples/with-npm/packages/eslint-config · high confidence

The with-docker example now includes a dedicated eslint-config package that provides structured linting rules for different project contexts. It introduces a base library configuration using the flat config format with Babel parsing for TypeScript and JSX, a Next.js preset that extends the library config with Next.js-specific rules and core web vitals checks, and server/React-internal presets that reuse the library base. This allows developers in the example to apply consistent linting across library code, Next.js pages, and server-side files.

examples/with-docker/packages/eslint-config · high confidence

The \turborepo-query\ crate now exposes a GraphQL interface that allows users to query which packages or tasks are affected by changes between git refs. This includes an \affectedTasks\ query that detects task-level changes by matching file inputs and propagating through the task dependency graph, and an \affectedPackages\ query for package-level detection. The API supports filtering by specific packages or tasks, handles global changes (like lockfile updates), and provides detailed reasons for why each task or package is considered affected. A static GraphiQL IDE is also served for interactive exploration of the schema.

crates/turborepo-query · high confidence

The \with-mcp-servers\ example now includes two new Model Context Protocol (MCP) server implementations. The \mcp-calculator\ package provides a server exposing arithmetic tools (add, subtract, multiply, divide) with input validation via Zod schemas and proper error handling for invalid or missing arguments. The \mcp-file-reader\ package provides a server for reading files and listing directories, strictly confined to a specified root directory to prevent path traversal attacks (including symlink escapes), with limits on file size and directory entry counts. Both packages include comprehensive test suites verifying their tool behaviors and security constraints.

examples/with-mcp-servers/packages/mcp-calculator, examples/with-mcp-servers/packages/mcp-file-reader · high confidence

The pnpm lockfile handling in Turborepo has been rewritten in Rust, replacing the previous implementation. This new engine introduces a high-performance, fast-path YAML scanner that parses large lockfiles significantly faster by bypassing general-purpose YAML parsing overhead, with automatic fallback to a standard serde parser for complex or unsupported YAML structures. The Rust implementation correctly supports pnpm lockfile versions 5, 6, 7, 9, and 11, including handling of per-workspace lockfiles, catalogs, patched dependencies, and injected workspace packages. It also ensures deterministic dependency ordering and preserves critical lockfile metadata (such as pnpmfile checksums and peer-resolved entries) during pruning operations, resulting in more reliable and faster lockfile analysis and pruning for pnpm-based monorepos.

crates/turborepo-lockfiles/src/pnpm · high confidence

The \with-svelte\ example now includes a dedicated \packages/ui\ module that demonstrates a Svelte component (\CounterView\) and its underlying state logic (\counter.svelte.ts\) using TypeScript and Svelte runes. This package is configured with ESLint for Svelte/TypeScript, Vite for building, and Vitest for both unit and browser-based integration tests (using Playwright/Chromium), providing a complete, testable UI component pattern for the example.

examples/with-svelte/packages/ui · high confidence

A new \turborepo-ci\ crate has been added to provide CI/CD vendor detection and vendor-specific behavior. It detects the current CI environment by inspecting standard environment variables and exposes utilities to retrieve commit SHA, branch, and user information. Additionally, it supports vendor-specific log formatting, such as Azure Pipelines' group markers, to improve log readability in supported CI systems.

crates/turborepo-ci/src · high confidence

Added generated TypeScript type definitions for Turborepo's core configuration modes. The new bindings expose \EnvMode\ (strict or loose), \OutputLogs\ (full, none, hash-only, new-only, errors-only), and \UI\ modes (tui, stream, stream-with-experimental-timestamps), providing explicit type safety for these settings in TypeScript-based tooling.

crates/turborepo-types/bindings · high confidence

The \with-tailwind\ example now includes a dedicated \packages/ui\ component library. This package introduces a new CSS entry point (\src/styles.css\) that imports Tailwind CSS v4 with a custom \ui:\ prefix, allowing component styles to be scoped and avoid conflicts. It provides reusable React components like \Card\ and \Gradient\ that utilize these prefixed utilities (e.g., \ui:rounded-lg\, \ui:border\), along with standard build configuration files (\tsconfig.json\, \turbo.json\) and an ESLint config to support the new structure.

examples/with-tailwind/packages/ui · high confidence

The \examples/with-npm/packages/ui\ package now provides a shared React UI library containing reusable components like \Card\ and \Code\, along with configuration for TypeScript, ESLint, and Turborepo. It also includes a Turborepo generator that allows users to scaffold new React components via the CLI, automatically adding them to the library's exports.

examples/with-npm/packages/ui · high confidence

The \turborepo-vercel-api\ crate now exposes a comprehensive set of types for interacting with the Vercel API, including authentication structures like \VerifiedSsoUser\ and \VerificationResponse\ that utilize \SecretString\ to redact tokens in debug output. It adds support for team membership roles, specifically introducing \VIEWER\_FOR\_PLUS\ and \Security\ variants alongside existing roles like \Owner\ and \Admin\. The crate also defines telemetry event structures (\TelemetryEvent\, \TelemetryTaskEvent\, etc.) and cache analytics events (\AnalyticsEvent\, \CacheSource\, \CacheEvent\) to track build performance, along with token metadata structures for handling scopes and expiration.

crates/turborepo-vercel-api/src · high confidence

The \with-vitest\ example now includes a dedicated \@repo/vitest-config\ package that provides shared Vitest settings, including Istanbul coverage and blob reporter output. This package exports a \sharedConfig\ object for use in individual project configs and includes a script to merge blob reports from all workspace packages. A \turbo.json\ configuration is also added to orchestrate the merging of these reports and generate a final coverage report.

examples/with-vitest/packages/vitest-config · high confidence

The \turborepo-auth\ crate now provides the core authentication logic for the CLI, replacing scattered auth implementations. It introduces a standard OAuth 2.0 Device Authorization Grant (RFC 8628) flow for logging in, which handles OIDC discovery, device code polling, and token exchange. The crate centralizes token storage and validation, supporting both legacy Vercel auth files and new standard OAuth tokens, while enforcing security measures like HTTPS-only URLs for non-Vercel deployments and strict origin validation for OIDC endpoints.

crates/turborepo-auth/src · high confidence

The \turborepo-wax\ crate now exposes a new \walk\ module that enables efficient traversal of directory trees and matching of file paths against glob patterns. This addition introduces a \SeparatingFilter\ system that distinguishes between matched items (filtrate) and non-matched items (residue), allowing for composable filtering that can prune sub-tree traversal without discarding data needed by upstream logic. Users can now use \Glob::walk\ or \PathExt::walk\ to iterate over files, with support for configuring traversal behavior (such as symbolic link handling) and efficiently excluding paths using combinators like \not\.

crates/turborepo-wax/src/walk · high confidence

The \turborepo-env\ crate now provides the core logic for filtering environment variables used in task hashing and execution. It defines a comprehensive list of built-in pass-through variables (including XDG, Windows, Docker, and CI-specific vars) and implements deterministic hashing for cache keys. Additionally, it introduces platform environment variable validation: when \TURBO\_PLATFORM\_ENV\ is configured, Turborepo checks if those variables are present in the execution environment and warns users if they are missing, helping prevent cache misses or build failures in CI environments like Vercel.

crates/turborepo-env/src · high confidence

The examples directory now includes dedicated scripts and configuration to streamline maintenance and validation. A new \check-examples.ts\ script validates core-maintained examples by running them in isolated Vercel Sandboxes, supporting filtering by example name and package manager. An \install-all.ts\ script automates dependency installation across all examples based on their specified package manager, while \update-turbo.ts\ handles updating the Turbo package across all examples, including lockfile synchronization for Yarn. These scripts are orchestrated via a new \turbo.json\ configuration in the examples folder, which defines tasks for checking examples, installing dependencies, and updating Turbo, and explicitly overrides inputs for \lint:prettier\ to avoid expensive glob walks.

examples · high confidence

A new \turborepo-graph-utils\ crate has been added to provide utilities for working with dependency graphs. It includes a \Walker\ component for traversing Directed Acyclic Graphs (DAGs) asynchronously, with explicit documentation that cycles will cause deadlocks, shifting the responsibility of cycle detection to the caller. The crate also provides \validate\_graph\ to detect cyclic and self-dependencies, returning detailed error messages that suggest specific edges to remove to break cycles. Additionally, it exposes functions for calculating transitive closures and finding minimal sets of edges (cuts) to break cycles, with performance safeguards for large strongly connected components.

crates/turborepo-graph-utils/src · high confidence

The TUI has been rewritten to provide an interactive terminal interface for monitoring and controlling tasks. Users can now select tasks from a list, toggle between the TUI view and streamed logs (using 'h' for the selected task or 's' for all tasks), and search/filter tasks with '/'. The interface supports mouse interaction for selection and copying, with clipboard integration that automatically detects the best provider for the current environment (including SSH/Tmux support on macOS). Task output is rendered in a dedicated pane with configurable scrollback, and the UI persists preferences like the active task and sidebar visibility across sessions.

crates/turborepo-ui/src/tui · high confidence

The repository now includes a new internal package, @turbo/test-utils, which centralizes generic testing utilities used across the project. This package provides a Jest preset configured for TypeScript compilation via ts-jest, along with helper functions to manage test fixtures (setupTestFixtures), mock environment variables (mockEnv), spy on console output (spyConsole), and intercept process exits (spyExit). It also includes a utility (validateLogs) to assert on logged messages, allowing tests to share a consistent, reusable testing foundation.

packages/turbo-test-utils · high confidence

A new \turborepo-lockfile-hash\ crate has been introduced to provide cycle-free, byte-compatible hashing for normalized lockfile package closures. It preserves the historical Cap'n Proto layout and xxHash64 output used by Turborepo task hashes, allowing repository knowledge to install package resolution fingerprints during generation construction. The crate serializes \(key, version)\ pairs in the supplied order (typically lexicographic) and outputs a 16-character lowercase hexadecimal hash, ensuring compatibility with existing \turborepo-hash\ wrappers.

crates/turborepo-lockfile-hash · high confidence

The \turborepo-microfrontends-config\ crate has been introduced to centralize microfrontend configuration management. It provides a \UnifiedTurboJsonLoader\ that automatically switches between standard and microfrontend-aware modes based on the presence of MFE configs, and a \MicrofrontendsConfigs\ struct that aggregates per-package configuration data. Additionally, it includes a \port\ module that resolves the correct development port for a given directory by identifying the owning JavaScript package within the workspace graph, ensuring the deepest package scope takes precedence.

crates/turborepo-microfrontends-config · high confidence

A new non-monorepo starter example has been added, allowing users to run Turborepo with a single Next.js application instead of a monorepo structure. This example includes a complete setup with the Next.js App Router, Tailwind CSS, ESLint (using the flat config), and Turborepo task definitions for building, linting, and type-checking. It is accessible via \npx create-turbo@latest -e non-monorepo\ and is maintained by the core team.

examples/non-monorepo · high confidence

The scripts directory now includes \validate-release-pr.mjs\ and \validate-review-gate.mjs\, which enforce strict release workflows by validating that release PRs only modify specific package.json files and version.txt, and by requiring human approval for non-release changes to these files. Additionally, \create-github-api-commit.mjs\ provides a new mechanism to create GitHub-verified commits via the API with sensitive file protection, while \server.js\ adds a test-codemod server script that validates its required \\<cwd-path\>\ argument.

scripts · high confidence

A new \turborepo-task-access\ crate has been introduced to handle task access tracing. This component reads trace files generated by tasks to automatically infer and populate \turbo.json\ pipeline configurations, specifically setting \outputs\ and \env\ fields based on observed file and environment variable access. It includes logic to prevent caching when tasks access network resources or files outside the repository root, ensuring cache safety while streamlining configuration for users.

crates/turborepo-task-access · high confidence

The \turborepo-task-executor\ crate introduces a new \CommandProvider\ trait and \CommandFactory\ that allow the task executor to resolve and execute commands through pluggable providers. This enables the system to support multiple task types (such as native Cargo, uv, and Go tasks) by delegating command resolution to specific providers like \ToolchainCommandProvider\ and \MicroFrontendProxyProvider\, while the \TaskExecutor\ handles the core execution logic, caching, and output management.

crates/turborepo-task-executor/src · high confidence

A new \turborepo-json-rewrite\ crate has been extracted to provide minimal, surgical mutations to JSON and JSONC documents. This library allows updating values at specific paths while preserving the original document's formatting, comments, and structure, making it suitable for programmatic updates to configuration files like \turbo.json\ and \package.json\ without reformatting the entire file.

crates/turborepo-json-rewrite · high confidence

The new \crates/turborepo/src/main.rs\ entry point wires the Rust CLI to handle internal LSP commands, allowing IDEs to probe for the \turbo-lsp\ server and launch it, while also implementing Windows-specific console event handling to gracefully send Ctrl+C signals to child processes. The binary delegates core execution to \turborepo\_cli\, sets up a panic handler, and uses \mimalloc\ as the global allocator (unless heap profiling is enabled), ensuring consistent error reporting and exit codes for the user.

crates/turborepo/src · high confidence

Added a Rust module for parsing Cargo.lock files to compute external dependency closures for hashing and to prune lockfiles for workspace isolation. This implementation allows Turborepo to track changes in Cargo dependencies precisely without relying on the legacy JavaScript-based lockfile analysis, ensuring that task hashes update only when a workspace's specific transitive dependencies change.

crates/turborepo-lockfiles/src · high confidence

The \turborepo-dirs\ crate now allows users to override the default configuration directory location by setting the \TURBO\_CONFIG\_DIR\_PATH\ or \VERCEL\_CONFIG\_DIR\_PATH\ environment variables. When these variables are set, Turborepo will use the specified path instead of the platform's default config directory. Relative paths provided via \TURBO\_CONFIG\_DIR\_PATH\ are resolved against the current working directory, while \VERCEL\_CONFIG\_DIR\_PATH\ expects an absolute path. This change provides greater flexibility for users who need to store configuration files in non-standard locations.

crates/turborepo-dirs/src · high confidence

The \examples/with-svelte/apps/web\ directory now contains a complete SvelteKit application scaffold. This includes the standard SvelteKit configuration files (svelte.config.js, vite.config.ts, tsconfig.json) and a root page that renders a shared \@repo/ui\ component. Additionally, the example is configured with Vitest for testing, featuring a split project setup that runs client-side browser tests via Playwright for Svelte components and server-side unit tests for library code.

examples/with-svelte/apps/web · high confidence

The \@turbo/codemod\ package is introduced to provide programmatic transformations for upgrading Turborepo codebases. This location contributes the core codemod infrastructure, including a \migrate\ command to update the codebase to a specified version and a \transform\ command for running individual transformations. The diff establishes the package structure with a new LICENSE and README, and adds a comprehensive test suite covering various migration scenarios. These tests validate transformers for updating the \$schema\ URL to versioned formats, migrating \pipeline\ to \tasks\, handling environment variable dependencies (converting \globalDependencies\ and \dotEnv\ to \globalEnv\ and \env\), stabilizing experimental features like \passThroughEnv\ and \experimentalUI\, and fixing glob syntax issues in task inputs and outputs.

packages/turbo-codemod · high confidence

The \turbo\ npm package now ships with its documentation files directly in the distribution, allowing users to access version-matched reference materials offline via the \docs\ directory. Additionally, a \schema.json\ file is now included in the package to support validation of \turbo.json\ configuration files, and the \.gitignore\ for the package location has been updated to exclude this schema file from version control.

packages/turbo · high confidence

The \with-vue-nuxt\ example now ships with a \packages/ui\ library that provides reusable Vue components (\Card\, \Gradient\, \Page\) and assets. This library is configured with a custom ESLint setup (\eslint-config-custom\) that enforces Vue and TypeScript standards, and it is exported as a single entry point for use within the example application.

examples/with-vue-nuxt/packages/ui · high confidence

The file-watching and repository-discovery logic previously embedded in the main Turborepo binary has been extracted into a new, standalone \turborepo-package-watcher\ crate. This change introduces a dedicated \PackageChangesWatcher\ component that handles file system events, coalesces changes, and manages repository discovery snapshots, while also exposing configuration for experimental workspace types (Cargo, Python, Go) via \RepositoryGraphFeatures\. For users, this represents an internal architectural refactor that isolates the watch subsystem, potentially improving maintainability and testability without altering the external \turbo watch\ behavior.

crates/turborepo-package-watcher, crates/turborepo-run-cache/src, crates/turborepo-run-summary/src · high confidence

The package scope resolution logic—handling \--filter\ pattern parsing, \--affected\ change detection, and directory-based package inference—has been extracted from the monolithic CLI crate into a new, standalone \turborepo-scope\ crate. This modularization decouples scope selection from the CLI entry point, introducing a clean entry point (\resolve\_packages\_with\_change\_detector\) that accepts an injected change detector. This design allows repository discovery and Git observations to be supplied in-memory for contract tests without altering the production CLI path, while also supporting deterministic package inference for subdirectory filters and explicit handling of exclusion-only filter modes.

crates/turborepo-scope/src · high confidence

The \turborepo-query-api\ crate now defines the \QueryRun\ and \QueryServer\ traits, which serve as the interface between the run orchestrator and the GraphQL query layer. This change allows \turborepo-run\ and \turborepo-query\ to compile in parallel without depending on each other, while the binary crate implements these traits to connect the two halves at runtime.

crates/turborepo-query-api · high confidence

The run options logic has been extracted from the monolithic codebase into a new, dedicated \turborepo-run-opts\ crate. This change introduces a parser-agnostic \Opts\ struct that consolidates configuration layers (environment, arguments, defaults) and command-line arguments into a single resolved state. It also defines specific selectors for run behavior (\RunSelector\) and execution details (\ExecutionSelector\), along with error handling for overlapping cache options and concurrency settings. This modularization isolates the option resolution logic, making it easier to maintain and test independently from the main CLI or execution engines.

crates/turborepo-run-opts · high confidence

The core task execution engine has been extracted from turborepo-lib into a new, standalone turborepo-engine crate. This new module now owns the task graph construction (EngineBuilder), task execution logic, affected-task detection, and graph visualization (DOT, SVG, Mermaid, HTML). This structural change decouples the engine from the CLI and repository discovery layers, allowing for more modular configuration loading and validation.

crates/turborepo-engine/src · high confidence

The task-level filtering and affected-task detection logic has been moved into a new \turborepo-task-filter\ crate. This change centralizes the resolution of \--filter\ patterns (including git-range selectors and dependency/dependent syntax) and \--affected\ detection (including watch mode support) into a single module, improving code organization and reusability across Turborepo's run and query commands.

crates/turborepo-task-filter · high confidence

The core task hashing logic for cache invalidation has been moved from \turborepo-lib\ into a new, standalone \turborepo-task-hash\ crate. This change introduces dedicated modules for global hash computation (including file hashing and environment variable handling) and structured task input hashing, along with comprehensive test suites for JIT inputs, dependency outputs, and structured inputs. By isolating this logic, the codebase improves modularity and allows the hashing engine to be developed and tested independently from the broader repository and run logic.

crates/turborepo-task-hash/src · high confidence

The shim logic for invoking the correct local or global Turbo binary has been extracted from turborepo-lib into a new, standalone crate (crates/turborepo-shim). This new crate handles finding and executing the correct Turbo version based on repository configuration, including support for finding locally installed Turbo in node\_modules, spawning the correct local version as a child process, and falling back to the global Turbo when no local version is found. The extraction uses trait-based dependency injection to avoid circular dependencies with turborepo-cli, introducing traits like TurboRunner, ChildSpawner, ConfigProvider, and VersionProvider to decouple the shim's execution logic from the main CLI implementation.

crates/turborepo-shim/src · high confidence

The \turbo.json\ configuration parsing and validation logic has been extracted into a dedicated Rust crate (\turborepo-turbo-json\). This change introduces a new native parser that replaces previous implementations, providing structured error reporting with source spans and diagnostic codes for issues like invalid environment prefixes, path traversal in outputs, and malformed JSON. It also implements the \futureFlags\ schema (including flags like \affectedUsingTaskInputs\, \globalConfiguration\, and \experimentalCargoWorkspaces\) and handles the merging logic for task definitions via the \extends\ mechanism, ensuring that configuration inheritance behaves correctly across workspace packages.

crates/turborepo-turbo-json/src · high confidence

The \turborepo-run\ crate now contains the core run orchestration logic, including the \RunBuilder\, \Run\ struct, and execution context construction. This change introduces a modular architecture where the run process is split into repository context and execution services, with dedicated modules for package scope resolution, engine loading, and error handling. Users benefit from improved separation of concerns and more maintainable run execution paths.

crates/turborepo-run · high confidence

The task graph visitor, execution context factory, and command provider logic have been extracted into a new \turborepo-task-graph\ crate. This change centralizes the core task execution flow—including command resolution, environment population, and error handling—into a dedicated module, improving code organization and separation of concerns without altering the external behavior of task execution.

crates/turborepo-task-graph · high confidence

The \with-prisma\ example in the \examples/with-prisma/apps/web\ directory has been updated to use the Next.js App Router. The application now features a root layout (\app/layout.tsx\) and a dynamic index page (\app/page.tsx\) that fetches and displays user data via the Prisma ORM. Configuration files for ESLint, TypeScript, and Next.js have been added to support this structure.

examples/with-prisma/apps/web · high confidence

The admin application within the kitchen-sink example has been restructured to use Vite as the build tool and React as the UI framework. This change introduces a new entry point (main.tsx), a root HTML file, and Vite configuration, replacing the previous setup. The app now renders a basic interface using shared UI components from the monorepo and is configured with TypeScript and ESLint for development.

examples/kitchen-sink/apps/admin · high confidence

The \examples/basic/apps/web\ directory has been completely restructured to use the Next.js App Router. The previous Pages Router implementation has been replaced with an \app/\ directory containing \layout.tsx\ and \page.tsx\ components. The UI has been updated to use CSS modules (\page.module.css\) and local fonts (Geist) instead of the previous styling approach, and the configuration now uses the ESLint flat config format (\eslint.config.js\).

examples/basic/apps/web · high confidence

The daemon's gRPC server now uses configurable timeout middleware to prevent indefinite hangs: non-blocking calls default to a 100ms timeout while blocking calls use a 30s server limit, and active requests can extend their deadlines via a bumpable timeout layer. Additionally, the daemon now creates its socket directories with private permissions (0o700 on Unix) and secures socket files (0o600), and the client connector includes retry logic and version-mismatch handling to improve connection reliability.

crates/turborepo-daemon/src · high confidence

The \turbo-ignore\ CLI now displays a deprecation warning at startup, directing Vercel users to use Vercel's built-in project skipping and other users to migrate to \turbo query affected\. The tool continues to function but includes improved error handling for non-fatal issues (such as missing lockfiles or package managers) and adds support for the \\[vercel only \<workspace\>\]\ commit message syntax to control deployment scope.

packages/turbo-ignore · high confidence

The ESLint configuration in the with-rollup example has been rewritten to use ESLint's flat config format. It now uses Babel as the parser for TypeScript files instead of typescript-eslint, which resolves compatibility issues with newer TypeScript compiler APIs. The configuration includes base rules, Turbo integration, and Prettier compatibility, with specific overrides for Next.js and React libraries to handle globals and JSX variable usage correctly.

examples/with-rollup/packages/config-eslint · high confidence

The \turborepo-tracing\ crate has been introduced to centralize tracing subscriber configuration and terminal log formatting. This new component provides a \SwitchableWriter\ that allows the application to dynamically redirect log output between stderr, a file, or null (suppression), which is essential for preventing log corruption when the TUI is active. It also includes a reloadable daemon logging layer that starts disabled to avoid unnecessary CPU overhead during cache-hit runs, ensuring efficient background logging only when explicitly enabled.

crates/turborepo-tracing · high confidence

The hashing utilities previously embedded in turborepo-lib have been extracted into a dedicated \turborepo-hash\ crate. This change introduces Cap'n Proto for deterministic serialization of task and global hash data, replacing previous methods. It also implements a stack-allocated \OidHash\ type to reduce heap allocations during file hashing and uses xxHash64 for faster hash computation. Additionally, the hash calculation now includes task command overrides and experimental CI configuration, ensuring that changes to these settings correctly invalidate cached results.

crates/turborepo-hash/src · high confidence

The Factory agent's runtime behavior is now explicitly defined through new configuration files. The agent sandbox is configured to start from the latest published Factory image, with optional persistent workspace drives and a 45-minute session timeout. The agent's operational logic is governed by strict instructions: it prioritizes maintaining repository examples, handles ad-hoc maintainer requests, and enforces a high-confidence requirement for automatic issue fixes, including mandatory security triage before any code changes. A CLI script is provided to manage these Factory workspaces, allowing operators to list, start, and SSH into sessions.

apps/factory/agent · high confidence

The Factory agent now automatically refreshes the workspace code to the main branch when a session starts, ensuring the environment is up-to-date. Additionally, it provides real-time status updates to users, reflecting the agent's current activity such as thinking, running actions, waiting for approval or input, and working, while also recording pull request details when they are created.

apps/factory/agent/hooks · high confidence

The \turborepo-scm\ package now replicates Git's CRLF-to-LF normalization during file hashing. When a file is marked as \text\ or \text=auto\ in \.gitattributes\, Turbo normalizes its line endings to LF before computing the hash, ensuring that hashes match Git's blob objects regardless of the platform or whether the Git code path is used. This change applies to both the Git-based and manual hashing paths, preventing cache misses caused by line-ending differences.

crates/turborepo-scm/src · high confidence

The framework inference logic has been extracted into the new \turborepo-frameworks\ crate. This change introduces support for detecting frameworks based on \devDependencies\ in single-package mode, ensuring that development-only dependencies are considered when identifying the framework. The implementation includes memoization of framework inference per package during task hashing to improve performance and removes retained package payloads to reduce memory usage.

crates/turborepo-frameworks/src · high confidence

The globwatcher now includes the specific filesystem path in error messages when file watching operations fail, making it easier to diagnose which file or directory caused an issue. Additionally, the watcher setup process has been refined to better handle initialization timing and error propagation, ensuring that configuration changes and backend errors are managed more reliably during the startup phase.

crates/turborepo-globwatch/src · high confidence

The authentication logic now proactively validates existing tokens before reuse, specifically checking if a stored token has lost access to its linked team (a common issue with expired SAML sessions) and triggering a fresh login if so. The login flow also includes recovery mechanisms to automatically re-authenticate when a token is rejected, reducing manual intervention. Additionally, the logout command now supports an optional server-side token invalidation flag to securely revoke credentials rather than just deleting them locally.

crates/turborepo-auth/src/auth · high confidence

The \turborepo-fs\ crate has been introduced to provide file system utilities for Turborepo, specifically replacing the previous implementation for copying package directories during \turbo prune\. This new Rust-based implementation supports respecting \.gitignore\ rules via a \use\_gitignore\ flag and optimizes performance by allowing multiple source directories to be copied in a single repository walk when they share a common gitignore root, reducing redundant I/O and parsing overhead.

crates/turborepo-fs/src · high confidence

The filewatching crate now uses a filesystem cookie mechanism to synchronize file system events, ensuring that downstream services only process requests after the watcher has caught up to the current state. This prevents stale events from being handled during rapid file changes. Additionally, a debouncer has been added to coalesce rapid file events, reducing the frequency of hash computations and package discovery operations. These changes improve the reliability and performance of \turbo watch\ by handling race conditions and high-frequency file updates more gracefully.

crates/turborepo-filewatch/src · high confidence

The update notifier now displays a formatted, bordered message box that adapts to terminal width, and provides the correct codemod execution command based on the detected package manager (Npm, Yarn, Berry, Pnpm, Pnpm6, Pnpm9, Bun, Nub, and Aube).

crates/turborepo-updater/src · high confidence

The storefront application within the kitchen-sink example has been migrated from the Pages Router to the App Router. This change introduces a new file structure centered around \src/app/layout.tsx\ and \src/app/page.tsx\, replacing previous page-based routing. Configuration files have been updated to support this architecture, including a new \next.config.ts\, a \tsconfig.json\ extending the Next.js-specific TypeScript config with the Next plugin, and a \turbo.json\ that correctly scopes build outputs to \.next\. The UI now renders a store page utilizing shared monorepo components like \CounterButton\ and \Link\.

examples/kitchen-sink/apps/storefront · high confidence

The ESLint configuration in the basic example has been updated to use the ESLint v9 flat config format. This introduces a new modular structure with separate configuration files for base rules, Next.js-specific settings, and React-internal libraries, replacing the previous configuration style to align with modern ESLint standards.

examples/basic/packages/eslint-config · high confidence

The \examples/with-berry/apps/web\ application has been updated to use the Next.js App Router. This change introduces the \app/\ directory structure with \layout.tsx\ and \page.tsx\, replacing the previous pages-based setup. The app now imports components from the shared \@repo/ui\ package and is configured via \next.config.js\ to transpile the \ui\ package, while TypeScript and ESLint configurations have been updated to support the new architecture.

examples/with-berry/apps/web · high confidence

Turborepo's terminal user interface now uses a new \turborepo-ghostty\ crate backed by Ghostty's \libghostty-vt\ instead of the previous \vt100\ implementation. This change introduces a new \Parser\ for handling task output and a \TerminalWidget\ for rendering, which improves text selection capabilities (allowing selection beyond the viewport) and ensures colors are preserved in TUI output.

crates/turborepo-ghostty · high confidence

The Yarn Berry (Yarn 2+) lockfile parsing logic has been rewritten in Rust, replacing the previous implementation. This new parser includes a fast-path, hand-written scanner for the specific YAML subset used by Berry lockfiles to improve performance, alongside dedicated modules for parsing identifiers, descriptors, and resolution overrides. It also introduces a new \DescriptorResolver\ to handle protocol resolution (e.g., mapping bare version ranges to explicit \npm:\ or \file:\ protocols) and ensures deterministic ordering of dependencies using \BTreeMap\.

crates/turborepo-lockfiles/src/berry · high confidence

The configuration loading logic in \turborepo-config\ has been restructured to resolve settings from multiple sources (environment variables, \turbo.json\, global/local config files) using a new priority-based merging strategy. Environment variables (e.g., \TURBO\\\) are now mapped to configuration options via a dedicated resolver, while \turbo.json\ is parsed by a new \TurboJsonReader\. A key behavioral change is the deep-merge of nested configuration objects, specifically the experimental OpenTelemetry (\otel\) settings, which allows partial overrides from higher-priority sources without shadowing unrelated fields from lower-priority ones. Additionally, security-sensitive OTEL fields (\headers\, \use\_remote\_cache\_token\) are now coupled to the \endpoint\ configuration; once an endpoint is set by a higher-priority source, credentials from lower-priority sources are discarded to prevent leakage. The system also introduces new configuration options for cache eviction (\cacheMaxAge\, \cacheMaxSize\) and run attributes for OTEL metrics.

crates/turborepo-config/src · high confidence

The \turbo-releaser\ package has been rewritten to replace the previous goreleaser-based pipeline with a custom Node.js CLI that manages the entire release lifecycle. This new tool handles staging (updating versions and creating branches), building and packing platform-specific binaries into scoped \@turbo/\<os\>-\<arch\>\ packages, and publishing all release artifacts (including JavaScript packages like \create-turbo\ and \eslint-plugin-turbo\) to npm. It introduces support for Android (via Linux binaries) and enforces stricter integrity checks and retry logic during npm publishing to ensure reliable, resumable releases.

packages/turbo-releaser · high confidence

The telemetry module in \crates/turborepo-telemetry/src/events\ has been restructured to use dedicated event builders (\CommandEventBuilder\, \GenericEventBuilder\, \RepoEventBuilder\, \PackageTaskEventBuilder\) that standardize how usage data is collected and sent. These builders introduce a parent-child event hierarchy to link related telemetry signals, enforce consistent obfuscation of sensitive values via one-way hashing, and provide specific tracking capabilities such as command-line argument usage, login methods (SSO, Standard, Manual), repository type (single package vs. monorepo), task frameworks, and daemon error states. This change ensures that telemetry data is more granular, securely anonymized, and logically connected for better analysis.

crates/turborepo-telemetry/src/events · high confidence

The \with-tailwind\ web application has been migrated to the Next.js App Router. This update replaces the previous pages directory structure with an \app/\ directory, introducing new layout and page components (\app/layout.tsx\, \app/page.tsx\) and a global CSS file (\app/globals.css\) that imports Tailwind CSS. The configuration has also been updated to use a TypeScript-based Next config (\next.config.ts\) and a shared ESLint configuration (\eslint.config.js\), ensuring the example aligns with modern Next.js standards.

examples/with-tailwind/apps/web · high confidence

The package graph module has been restructured to separate concerns into distinct files: \builder.rs\ now orchestrates the construction of the \PackageGraph\ using immutable \RepositoryKnowledge\ and \RelationshipKnowledge\ instead of transient state; \dep\_splitter.rs\ provides a dedicated, index-backed resolver for internal vs. external dependency splitting (handling \workspace:\ protocols, pnpm catalogs, and path specifiers); \javascript.rs\ manages JavaScript-specific external resolution and lockfile closure generation; and \projections.rs\ exposes typed, efficient views of package relationships (ordering, inputs, pruning) via pre-computed adjacency indices. This change improves performance through parallelized lockfile parsing and shared indices, while enforcing stricter invariants by deriving package scope and relationship data from authoritative, immutable knowledge sources.

_crates/turborepo-repository/src/package\graph · high confidence

The pre-push hook has been updated to source the Cargo environment, ensuring the correct Rust toolchain is available. It now runs \turbo run format check:toml\ and explicitly checks Rust code formatting via \cargo fmt --check\ with warnings treated as errors, aligning local pre-push behavior with CI linting standards.

.husky · high confidence

The engine builder in \crates/turborepo-engine/src/builder\ has been restructured to handle task definitions and inheritance more explicitly. A new \definitions.rs\ module introduces memoization for resolved task definitions and a \probe\_task\_definition\_in\_repo\ mechanism that defers loading of unloaded scopes until necessary, improving how the engine discovers tasks across the package graph. A new \inheritance.rs\ module replaces boolean flags with a \ValidationMode\ enum to control validation during the resolution of \turbo.json\ extends chains, ensuring that \extends: false\ exclusions are correctly propagated and validated. These changes are supported by a new \test.rs\ module containing comprehensive unit tests for the builder, including mock loaders and package graphs to verify task resolution and inheritance behavior.

crates/turborepo-engine/src/builder · high confidence

The \turborepo-prune\ crate has been restructured to separate language-specific rendering from general orchestration. A new \javascript.rs\ module now handles pure JavaScript manifest and workspace pruning (rewriting \package.json\ fields and collecting patch paths) without performing filesystem operations, while the main \lib.rs\ manages the high-level selection and materialization logic. Additionally, a new \tasks.rs\ module implements an opt-in task-aware closure that conservatively retains packages based on their task dependencies and configuration owners, ensuring that necessary toolchain and config files are included in the pruned output.

crates/turborepo-prune · high confidence

The \turbo boundaries\ check has been rewritten in Rust to replace the previous implementation, delivering significant performance gains through parallelization, caching, and efficient source text handling. The new engine resolves TypeScript path aliases correctly, preventing false positives for local imports that shadow package names, and properly ignores imports resolving into \node\_modules\. It also supports dynamic imports, Bun runtime modules, and subpath package imports, while introducing circular dependency detection and stricter error handling by removing unsafe unwrap/expect calls.

crates/turborepo-boundaries/src · high confidence

The kitchen-sink example now uses a streamlined ESLint setup. The shared configuration has been migrated to the modern flat config format, incorporating TypeScript ESLint, Prettier, and Turbo-specific rules, while framework-specific configs for Next.js, React, Vite, and Remix have been updated or simplified to reduce complexity and improve maintainability.

examples/kitchen-sink/packages/config-eslint · high confidence

The repository has migrated its formatting and linting infrastructure to use Oxc (oxlint and oxfmt) and Taplo, replacing previous tools like Prettier and ESLint. This change introduces new configuration files (\.oxfmtrc.jsonc\, \.oxlintrc.jsonc\, \.taplo.toml\) and updates \.editorconfig\ to enforce consistent indentation and line endings across file types. It also adds \AGENTS.md\ to define pull request guidelines and contributor workflows, alongside standard repository files like \CODE\_OF\_CONDUCT.md\ and \.gitattributes\.

(repo-wide) · high confidence

The API client now supports TLS certificate chains signed with P-521 ECDSA keys (such as those used by Cloudflare WARP inspection) by installing a custom rustls CryptoProvider that augments the default ring provider with aws-lc-rs P-521 verification algorithms. Additionally, HTTP client initialization uses a two-phase approach: a fast client with bundled Mozilla CAs is built immediately to avoid blocking on macOS Keychain enumeration, while a full client with system CAs is built in the background, ensuring faster startup and better compatibility with corporate proxies.

crates/turborepo-api-client/src · high confidence

The \turbo\ command-line interface has been refactored to use the \usage-rs\ library for argument parsing, replacing the previous implementation. This change updates the internal CLI composition layer in \crates/turborepo-cli\ and results in modified help text and error messages for global flags and subcommands. Users may notice differences in how arguments are displayed in help output and how invalid arguments (such as \--filter\ or \--no-daemon\) are reported, as the CLI now enforces stricter parsing rules defined by the new library.

crates/turborepo-cli · high confidence

The Tailwind CSS example has been upgraded to version 4, introducing a new configuration structure. A new \postcss.config.js\ file has been added to configure the \@tailwindcss/postcss\ plugin, and a \shared-styles.css\ file now defines custom color tokens (blue-1000, purple-1000, red-1000) using the v4 \@theme\ directive. This reflects the architectural shift in Tailwind CSS v4's configuration and plugin system.

examples/with-tailwind/packages/tailwind-config · high confidence

The ESLint configuration files for the Prisma example have been updated to use the modern flat config format. The \library.js\ and \next.js\ configs now explicitly import \eslint-config-turbo/flat\ and \typescript-eslint\, replacing the previous setup. The Next.js config additionally integrates the \@next/eslint-plugin-next\ to enforce recommended rules and core web vitals, ensuring consistent linting across library and Next.js-specific code within the example.

examples/with-prisma/packages/config-eslint · high confidence

The workspace configuration reload fixtures now use the updated schema URL (https://turborepo.dev/schema.json) in their turbo.json files. Additionally, new test fixtures were added for the web app and UI package to verify environment variable handling; the web app fixture includes a .env file and turbo.json configuration for specific env variables (ENV\_2, NEXT\PUBLIC\\*, etc.), while the UI fixture validates the IS\_SERVER environment variable.

packages/eslint-plugin-turbo/\\fixtures\\/workspace-configs-reload/apps/web, packages/eslint-plugin-turbo/\\fixtures\\/workspace-configs-reload/packages/ui · high confidence

The with-rollup example has been updated to align with the Next.js App Router architecture. This includes migrating configuration files to modern standards, such as adopting the new ESLint flat config format (eslint.config.mjs) and updating TypeScript configuration to support the App Router's type generation. The example application now utilizes shared UI components from the monorepo's design system (@repo/ui) and reflects the current Next.js project structure, ensuring the example remains compatible with the latest framework features and development practices.

examples/with-rollup/apps/web · high confidence

The with-vite example application has been updated to use a standard Vite setup with TypeScript. This includes a new ESLint configuration extending the repository's shared config, a standard HTML entry point, and a main TypeScript entry file that renders UI components from the shared @repo/ui package. The example now uses a dedicated Vite TypeScript config and includes specific styling for the Vite and TypeScript logos, along with a counter component interaction.

examples/with-vite/apps/web · high confidence

The watch functionality has been refactored into a dedicated crate and now operates entirely in-process, replacing the previous daemon-based architecture with standalone file-watching components. This change enables Turborepo to correctly select and rerun impacted tasks in repositories containing mixed toolchains (such as JavaScript, Go, Rust, and Python) by validating toolchain-specific watch specifications and handling partial reruns based on changed files. Users benefit from a more robust watch experience that accurately detects changes across diverse package types without relying on external IPC or gRPC services.

crates/turborepo-watch · high confidence

The \examples/with-yarn/apps/web\ application has been migrated from the Pages Router to the Next.js App Router. This change introduces a new \app/\ directory structure containing \layout.tsx\ and \page.tsx\ to define the root layout and home page, respectively. The previous page-based structure has been replaced, and the configuration now includes an ESLint config extending \@repo/eslint-config/next.js\ and a \next.config.js\ that explicitly transpiles the \@repo/ui\ package to support the new framework conventions.

examples/with-npm/apps/web, examples/with-yarn/apps/web · high confidence

The with-berry example has been updated to use Yarn 3.6.3. This change introduces a \.gitignore\ file tailored for Yarn Berry (ignoring \.pnp\, \.yarn/\*\, and \.turbo\ directories) and embeds the Yarn 3.6.3 release binary directly into the repository, ensuring the example runs with a consistent, modern package manager version.

examples/with-berry · high confidence

The create-turbo package has been reorganized into a new modular structure featuring a Commander-based CLI, a pluggable transform system, and expanded package manager support. Users can now select from npm, yarn, pnpm, bun, nub, and aube during project creation. The tool automatically applies transforms to the generated project, including updating README commands to match the selected package manager, configuring .gitignore, and handling official starter metadata. Git initialization is now streamlined into a single commit, and the CLI includes options for skipping installs, skipping transforms, specifying a turbo version, and using custom examples.

packages/create-turbo · high confidence

The with-docker example now includes a dedicated Jest configuration for Node.js environments. This change introduces a new \esbuild-transformer.js\ module that uses esbuild to transpile TypeScript and TSX files into CommonJS format, and a corresponding \jest-preset.js\ that registers this transformer. This allows tests in the example to resolve and process \.ts\ and \.tsx\ files correctly within the Docker setup.

examples/with-docker/packages/jest-presets · high confidence

This change introduces a new \packages/database\ package and an \apps/migrations\ application to the Bun v1 lockfile test fixture. The database package includes a Prisma schema defining a User model, a corresponding SQL migration, and configuration files, while the migrations app provides a Dockerfile and entrypoint script to build and run database migrations using Bun. These additions support the fix for preserving Bun prune lockfile validity by providing a concrete example of a multi-package setup with database dependencies.

lockfile-tests/fixtures/bun-v1-issue-12653/apps/migrations, lockfile-tests/fixtures/bun-v1-issue-12653/packages/database · high confidence

The integration test fixture for the OXC repro now correctly handles symlinked dependencies. A new \@repo/index.js\ module is added to the local node\_modules, and the \@repo/typescript-config\ package is resolved via a symlink pointing to the shared tooling configuration, ensuring the test environment accurately reflects workspace linking behavior.

_turborepo-tests/integration/fixtures/oxc\repro/apps/web · high confidence

The \turborepo-cache\ crate now uses a new \cache\_archive\ module to manage cache archives, significantly improving restoration reliability and performance. Archive creation (\create.rs\) now employs atomic writes via temporary files to prevent corruption during concurrent operations. Restoration (\restore.rs\, \restore\_directory.rs\, \restore\_regular.rs\, \restore\_symlink.rs\) is hardened against symlink attacks and race conditions by locking the restore root directory and validating all symlink targets remain within the anchor. A new \RestoreManifest\ (\restore\_manifest.rs\) records file metadata (size, mtime, mode) during the first restore, allowing subsequent restores of the same cache to skip redundant file writes if the disk state matches, thereby reducing I/O overhead.

_crates/turborepo-cache/src/cache\archive · high confidence

The \turborepo-rayon-compat\ crate now caps the global Rayon thread pool to a maximum of 72 threads via the \scale\_thread\_count\ function, addressing a known initialization race condition that can cause deadlocks on systems with many CPU cores (e.g., 96+ cores). Additionally, the new \block\_in\_place\ helper safely executes blocking closures within Tokio runtimes by using \tokio::task::block\_in\_place\ on multi-threaded runtimes, ensuring the runtime can spawn replacement workers and preventing potential deadlocks when Rayon is used in async contexts.

crates/turborepo-rayon-compat · high confidence

Turborepo now handles malformed JSON files (such as \package.json\ or \turbo.json\) gracefully instead of crashing. A new \json.rs\ module in the \turborepo-errors\ crate checks for syntax errors before attempting deserialization, ensuring that issues like unterminated string literals produce actionable error diagnostics rather than causing the tool to panic.

crates/turborepo-errors/src · high confidence

The child process handling logic in \turborepo-process\ has been split into dedicated modules (\handle\, \io\, \shutdown\, \state\) to improve maintainability and fix several shutdown issues. On Windows, the implementation now uses ConPTY for interactive tasks and explicitly delivers Ctrl-C keystrokes to child processes during graceful shutdown, ensuring nested processes are stopped correctly. The refactoring also addresses duplicate interrupt signals, prevents PID reuse during cleanup, and preserves terminal settings for child PTYs, resulting in more reliable process termination across both Unix and Windows platforms.

crates/turborepo-process/src/child · high confidence

The \libghostty-vt-sys\ crate has been vendored into the workspace to apply two critical build fixes. On Windows MSVC, the crate now forces static linking of \ghostty-vt-static.lib\ instead of the DLL import library, preventing runtime dependency on \ghostty-vt.dll\. On macOS, the build script now explicitly passes the \MACOSX\_DEPLOYMENT\_TARGET\ to the Zig compiler, ensuring the resulting binary is compatible with older macOS releases rather than just the build host. Additionally, the build now targets baseline CPUs (\-Dcpu=baseline\) to prevent illegal instruction crashes on older hardware.

crates/libghostty-vt-sys · high confidence

The Turborepo binary crate now includes a build script that explicitly sets the thread stack size to 8 MB when compiling for the MSVC target on Windows. This addresses historical issues where the CLI parser required more than the default 1 MB stack space, preventing stack overflow errors during execution on Windows.

crates/turborepo · high confidence

Add 'another' package fixture with subpath and nested import scenarios; Add end-to-end lockfile pruning validation tests; Add global inputs fixture for testing future configuration flags; Add migrations app and database package fixtures for Bun lockfile testing; Add placeholder library fixture for affected tasks testing; Add watch dependency test fixtures for packages a and b; Added Go monorepo and workspace integration test fixtures; Added Go workspace fixture for end-to-end testing; Added Rust snapshot tests for Turborepo core features; Added Terminal UI sanity test fixtures; Added boundaries test fixture with implicit dependency configuration; Added comprehensive test coverage for Factory agent logic; Added engine builder contract tests for task graph construction and validation; Added fixture workspace configs for testing turbo.json support; Added integration test fixture for tracing and module resolution; Added integration test fixtures for composable config scenarios; Added integration test fixtures for missing workspace config and strict environment variables; Added integration tests for the microfrontends proxy router and port availability checks; Added integration tests for turborepo-lsp daemon lifecycle; Added lib-a crate with greeting function and test utility; Added ship type definitions for integration tests; Added test fixture for relationship projection contract; Added test fixtures for codemod workspace config scenarios; Added test fixtures for framework-specific environment variable detection; Added test fixtures for legacy workspace configuration; Added test fixtures for mixed persistent task watch behavior; Added test fixtures for process shutdown and signal handling; Added test fixtures for turbo watch integration; Added test fixtures for turbo-codemod migrations; Added test fixtures for uv workspace integration; Added tests for glob walking functionality; Added tests for isolated task log handling in scoped packages; Added unit tests for Go and Cargo scope planning; Expanded integration test fixtures for Turborepo capabilities; Integration test coverage for absolute path validation in turbo.json; Integration test fixture for boundaries rules expanded; Integration test fixtures updated to support import attributes; New Rust-based integration test infrastructure for Turborepo; Stabilize watch task inputs regression test; Updated integration fixture for shared file dependencies.

This change consists of 3,210 commits updating dependencies across 1,424 manifests, including routine version bumps for packages in the Turborepo core and various example projects (such as Next.js, Svelte, and Tailwind), as well as numerous canary and stable releases of the Turborepo tool itself. These updates maintain the health and compatibility of the monorepo's tooling and example applications without introducing new user-facing features.

(dependencies) · high confidence

Added documentation and licensing for the turborepo-pidlock crate; Documentation and build configuration for the turborepo-daemon crate.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 39 → 61 (+21.8)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 79 → 78 (-1.0)
• Architecture 69 → 99 (+29.8)
• Maturity 58 → 64 (+5.8)
• Readiness 15 → 57 (+42.1)
• Security 58 → 79 (+20.4)
• Domain Modelling 90 (new)
• Event Sourcing 100 (new)
• Accessibility 55 (new)

• Change coupling: index.ts ↔ index.ts (packages/turbo-workspaces/src/commands/convert/index.ts)
• Change coupling: index.ts ↔ operations.ts (packages/turbo-releaser/src/index.ts)
• Change coupling: install.ts ↔ utils.ts (packages/turbo-workspaces/src/install.ts)
• Change coupling: npm.ts ↔ pnpm.ts (packages/turbo-workspaces/src/managers/npm.ts)
• Change coupling: npm.ts ↔ utils.ts (packages/turbo-workspaces/src/managers/npm.ts)
• Change coupling: npm.ts ↔ yarn.ts (packages/turbo-workspaces/src/managers/npm.ts)
• Change coupling: operations.ts ↔ packager.ts (packages/turbo-releaser/src/operations.ts)
• Change coupling: pnpm.ts ↔ utils.ts (packages/turbo-workspaces/src/managers/pnpm.ts)
• Change coupling: pnpm.ts ↔ yarn.ts (packages/turbo-workspaces/src/managers/pnpm.ts)
• Change coupling: yarn.ts ↔ utils.ts (packages/turbo-workspaces/src/managers/yarn.ts)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/bun-peer-dep/bun.lock)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/bun-v1-issue-12653/bun.lock)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/pnpm-catalog/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/pnpm-catalog/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/bun-v1-issue-12653/bun.lock)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/npm-lock/package-lock.json)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/bun-v1-issue-12653/bun.lock)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/pnpm-multiple-catalogs/pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/bun-v1-create-turbo/bun.lock)
• Critical CVE: [GHSA redacted] (lockfile-tests/fixtures/berry/yarn.lock)
• …and 103 more

• Ambiguous naming for identical operations. Both methods retrieve an artifact from the remote cache. 'get' and 'fetch' are semantically equivalent in this context, creating confusion about whether there is a behavioral difference (e.g., caching behavior, error handling, or network strategy).
• App::handle_mouse_at (cognitive 35) (crates/turborepo-ui/src/tui/app.rs)
• App::handle_mouse_at (cyclomatic 27) (crates/turborepo-ui/src/tui/app.rs)
• Args::new (cognitive 26) (crates/turborepo-cli/src/cli/args.rs)
• Args::new (cyclomatic 20) (crates/turborepo-cli/src/cli/args.rs)
• AsyncCache::new (cognitive 28) (crates/turborepo-cache/src/async_cache.rs)
• Backend::handle_file_update (cognitive 50) (crates/turborepo-lsp/src/lib.rs)
• Backend::handle_file_update (cyclomatic 17) (crates/turborepo-lsp/src/lib.rs)
• BerryLockfile::subgraph (cognitive 46) (crates/turborepo-lockfiles/src/berry/mod.rs)
• BerryLockfile::subgraph (cyclomatic 27) (crates/turborepo-lockfiles/src/berry/mod.rs)
• BuildState::build_inner (cognitive 16) (crates/turborepo-repository/src/package_graph/builder.rs)
• BuildState::parse_package_jsons (cognitive 31) (crates/turborepo-repository/src/package_graph/builder.rs)
• BuildState::parse_package_jsons (cyclomatic 16) (crates/turborepo-repository/src/package_graph/builder.rs)
• BunLockfile::all_dependencies (cognitive 16) (crates/turborepo-lockfiles/src/bun/lockfile.rs)
• BunLockfile::format_array (cognitive 22) (crates/turborepo-lockfiles/src/bun/emit.rs)
• BunLockfile::format_array_content (cognitive 19) (crates/turborepo-lockfiles/src/bun/emit.rs)
• BunLockfile::from_str (cognitive 16) (crates/turborepo-lockfiles/src/bun/parse.rs)
• BunLockfile::include_duplicate_alias_children (cognitive 31) (crates/turborepo-lockfiles/src/bun/subgraph.rs)
• BunLockfile::remove_unreachable_entries (cognitive 22) (crates/turborepo-lockfiles/src/bun/subgraph.rs)
• BunLockfile::subgraph (cognitive 375) (crates/turborepo-lockfiles/src/bun/subgraph.rs)
• …and 772 more

• 300 commits — 252 feature/other, 48 fixes

• crates/turborepo — 47 commits
• crates/turborepo-lib — 31 commits
• skills/turborepo — 25 commits
• crates/turborepo-repository — 18 commits
• (root) — 14 commits
• crates/turborepo-cache — 14 commits
• apps/docs — 12 commits
• crates/turborepo-cli — 9 commits
• crates/turborepo-filewatch — 7 commits
• crates/turborepo-run — 7 commits
• crates/turborepo-wax — 7 commits
• crates/turborepo-engine — 6 commits
• crates/turborepo-lockfiles — 6 commits
• crates/turborepo-task-hash — 6 commits
• crates/turborepo-boundaries — 5 commits
• crates/turborepo-scope — 5 commits
• packages/turbo-repository — 5 commits
• crates/turborepo-package-watcher — 4 commits
• .github/workflows — 3 commits
• crates/turborepo-config — 3 commits

• fix: fix(affected): Treat root internal dependency changes as global (#14156)
• fix: fix: Add path context to globwatch errors (#14301)
• fix: fix: Allow esbuild builds for pnpm generators (#14103)
• fix: fix: Avoid duplicate interrupts during task shutdown (#14046)
• fix: fix: Avoid microfrontend polyrepo warnings (#14118)
• fix: fix: Back off remote artifact requests during outages (#14222)
• fix: fix: Coordinate artifact requests after rate limiting (#14221)
• fix: fix: Defer dependency output validation for lazy scopes (#14097)
• fix: fix: Disable remote cache after unrecoverable forbidden responses (#14218)
• fix: fix: Discover native workspace metadata lazily (#14053)
• fix: fix: Fall back to the published tag when the dogfooded turbo version is unpublished (#14067)
• fix: fix: Follow Go default binary output paths (#14079)
• fix: fix: Format pnpm v5 package names (#14295)
• fix: fix: Harden cache archive restoration (#14095)
• fix: fix: Ignore gitignored files in boundaries (#14137)
• fix: fix: Include experimentalCI in task hashes (#14038)
• fix: fix: Infer all co-located packages from cwd (#14074)
• fix: fix: Isolate task logs for co-located packages (#14077)
• fix: fix: Normalize affected task input globs (#14140)
• fix: fix: Normalize bare directory outputs when filtering dependencyOutputs hashes (#13932)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

vercel/turborepo was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.