fix(react): add missing offset variable for generateFiles

When using pnpm with its strict symlink structure, TypeScript fails to resolve
the @nx/react/typings/cssmodule.d.ts file when it's specified in the types array.
This is because pnpm doesn't hoist dependencies in the same way as npm/yarn.

By moving these type definitions to the files array  we ensure they are always included regardless of the package manager's module resolution

Fixes: #29945

.cargo/config.toml

@@ -1,5 +1,5 @@
 [build]
-target-dir = 'build/target'
+target-dir = 'dist/target'
 
 [target.x86_64-unknown-linux-musl]
 rustflags = [

.claude/commands/commit.md

@@ -0,0 +1,47 @@
+# Commit Command
+
+## Description
+
+Create a git commit following Nx repository standards and validation requirements.
+
+## Usage
+
+```bash
+/commit [message]
+```
+
+## What this command does:
+
+1. **Pre-commit validation**: Runs the full validation suite (`pnpm nx prepush`) to ensure code quality
+2. **Formatting**: Automatically formats changed files with Prettier
+3. **Testing**: Runs tests on affected projects to validate changes
+4. **Commit creation**: Creates a well-formed commit with proper message formatting (without co-author attribution)
+5. **Status reporting**: Provides clear feedback on the commit process
+
+## Workflow:
+
+1. Format any modified files with Prettier
+2. Run the prepush validation suite
+3. If validation passes, stage relevant changes
+4. Create commit with descriptive message
+5. Provide summary of what was committed
+
+## Commit Message Format:
+
+- Use conventional commit format when appropriate
+- Include scope (e.g., `feat(core):`, `fix(angular):`, `docs(nx):`)
+- Keep first line under 72 characters
+- Include detailed description if needed
+
+## Examples:
+
+- `/commit "feat(core): add new project graph visualization"`
+- `/commit "fix(react): resolve build issues with webpack config"`
+- `/commit "docs(nx): update getting started guide"`
+
+## Validation Requirements:
+
+- All tests must pass
+- Code must be properly formatted
+- No linting errors
+- E2E tests for affected areas should pass

.claude/commands/gh-issue-plan.md

@@ -0,0 +1,155 @@
+# GitHub Issue Planning and Resolution
+
+This command provides guidance for both automated and manual GitHub issue workflows.
+
+## Automated Workflow (GitHub Actions)
+
+The automated workflow consists of two phases:
+
+### Phase 1: Planning (`@claude plan` or `claude:plan` label)
+
+- Claude analyzes the issue and creates a detailed implementation plan
+- Plan is posted as a comment on the issue
+- Issue is labeled with `claude:planned`
+
+### Phase 2: Implementation (`@claude implement` or `claude:implement` label)
+
+- Claude implements the solution based on the plan
+- Runs validation tests and creates a feature branch
+- Suggests opening a PR with proper formatting
+
+## Planning Phase Template
+
+When creating a plan (either automated or manual), include these sections:
+
+### Problem Analysis
+
+- Root cause identification
+- Impact assessment
+- Related components or systems affected
+
+### Proposed Solution
+
+- High-level approach
+- Alternative solutions considered
+- Trade-offs and rationale
+
+### Implementation Details
+
+- Files that need to be modified
+- Key changes required
+- Dependencies or prerequisites
+
+### Testing Strategy
+
+- Unit tests to add/modify
+- Integration tests needed
+- E2E test considerations
+
+### Validation Steps
+
+```bash
+# Test specific affected projects
+nx run-many -t test,build,lint -p PROJECT_NAME
+
+# Test all affected projects
+nx affected -t build,test,lint
+
+# Run affected e2e tests
+nx affected -t e2e-local
+
+# Format code
+npx nx prettier -- FILES
+
+# Final validation
+pnpm nx prepush
+```
+
+### Risks and Considerations
+
+- Breaking changes
+- Performance implications
+- Migration requirements
+
+## Manual Workflow
+
+When working on a GitHub issue manually, follow this systematic approach:
+
+## 1. Get Issue Details
+
+```bash
+# Get issue details using GitHub CLI (replace ISSUE_NUMBER with actual number)
+gh issue view ISSUE_NUMBER
+```
+
+When cloning reproduction repos, please clone within `./tmp/claude/repro-ISSUE_NUMBER`
+
+## 2. Analyze the Plan
+
+- Look for a plan or implementation details in the issue description
+- Check comments for additional context or clarification
+- Identify affected projects and components
+
+## 3. Implement the Solution
+
+- Follow the plan outlined in the issue
+- Make focused changes that address the specific problem
+- Ensure code follows existing patterns and conventions
+
+## 4. Run Full Validation
+
+```bash
+# Test specific affected projects first
+nx run-many -t test,build,lint -p PROJECT_NAME
+
+# Test all affected projects
+nx affected -t build,test,lint
+
+# Run affected e2e tests
+nx affected -t e2e-local
+
+# Final pre-push validation
+pnpm nx prepush
+```
+
+## 5. Submit Pull Request
+
+- Create a descriptive PR title that references the issue
+- Include "Fixes #ISSUE_NUMBER" in the PR description
+- Provide a clear summary of changes made
+- Request appropriate reviewers
+
+## Pull Request Template
+
+When creating a pull request, follow the template found in `.github/PULL_REQUEST_TEMPLATE.md`. The template includes:
+
+### Required Sections
+
+1. **Current Behavior**: Describe the behavior we have today
+2. **Expected Behavior**: Describe the behavior we should expect with the changes in this PR
+3. **Related Issue(s)**: Link the issue being fixed so it gets closed when the PR is merged
+
+### Template Format
+
+```markdown
+## Current Behavior
+
+<!-- This is the behavior we have today -->
+
+## Expected Behavior
+
+<!-- This is the behavior we should expect with the changes in this PR -->
+
+## Related Issue(s)
+
+<!-- Please link the issue being fixed so it gets closed when this is merged. -->
+
+Fixes #ISSUE_NUMBER
+```
+
+### Guidelines
+
+- Ensure your commit message follows the conventional commit format (use `pnpm commit`)
+- Read the submission guidelines in CONTRIBUTING.md before posting
+- For complex changes, you can request a dedicated Nx release by mentioning the Nx team
+- Always link the related issue using "Fixes #ISSUE_NUMBER" to automatically close it when merged

.claude/commands/issue-workflow-guide.md

@@ -0,0 +1,30 @@
+# Claude Issue Workflow Usage Guide
+
+## Quick Start
+
+## Expected Outputs
+
+### Planning Phase
+
+- Detailed analysis comment posted to issue
+- Implementation plan with steps and file changes
+- Testing strategy and validation steps
+- Risk assessment
+
+### Implementation Phase
+
+- Code changes made according to plan
+- Tests run and validated
+- Feature branch created: `fix/issue-{number}`
+- PR suggestion with proper title format
+
+## Manual Override
+
+If you need to work on an issue manually, use the `/gh-issue-plan` command for structured guidance following the same workflow patterns.
+
+## Troubleshooting
+
+- Ensure you're on the authorized users list
+- Check that the issue has sufficient detail for analysis
+- For implementation, ensure a plan comment exists from the planning phase
+- If workflows fail, check the Actions tab for detailed logs

.claude/settings.json

@@ -0,0 +1,34 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(ls:*)",
+      "Bash(mkdir:*)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:www.typescriptlang.org)",
+      "Bash(git log:*)",
+      "Bash(gh issue list:*)",
+      "Bash(gh issue view:*)",
+      "Bash(npx prettier:*)",
+      "Bash(nx prepush:*)",
+      "Bash(pnpm commit:*)",
+      "Bash(rg:*)",
+      "mcp__nx__nx_docs",
+      "mcp__nx__nx_workspace",
+      "mcp__nx__nx_project_details",
+      "Bash(nx show projects:*)",
+      "Bash(nx run-many:*)",
+      "Bash(nx run:*)",
+      "Bash(nx affected:*)",
+      "Bash(nx lint:*)",
+      "Bash(nx test:*)",
+      "Bash(nx build:*)",
+      "Bash(nx documentation:*)"
+    ],
+    "deny": []
+  },
+  "enableAllProjectMcpServers": true,
+  "env": {
+    "BASH_MAX_TIMEOUT_MS": "1800000"
+  }
+}

.cursor/mcp.json

@@ -0,0 +1,7 @@
+{
+  "mcpServers": {
+    "nx-mcp": {
+      "url": "http://localhost:9470/mcp"
+    }
+  }
+}

.gitattributes

@@ -7,3 +7,5 @@
 # These are Windows script files and should use crlf
 *.bat           text eol=crlf
 
+# Exclude files from Graphite reviews
+docs/generated/* linguist-generated=true

.github/workflows/ci.yml

@@ -4,12 +4,14 @@ on:
   push:
     branches:
       - master
+      - '[0-9]+.[0-9]+.x'
   pull_request:
     branches:
       - "**"
 
 env:
   NX_CLOUD_ACCESS_TOKEN: ${{ secrets.NX_CLOUD_ACCESS_TOKEN }}
+  PNPM_HOME: ~/.pnpm
 
 jobs:
   main-linux:
@@ -57,13 +59,26 @@ jobs:
       - uses: pnpm/action-setup@v4
         name: Install pnpm
         with:
-          version: 9.8.0
+          version: 10.11.1
           run_install: false
 
-      - name: Install project dependencies
-        run: |
-          pnpm install --frozen-lockfile
-          pnpm playwright install --with-deps
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'pnpm'
+
+      - name: Cache Rust toolchain and cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
 
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
@@ -74,6 +89,14 @@ jobs:
           distribution: temurin
           java-version: 17
 
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Install project dependencies
+        run: |
+          pnpm install --frozen-lockfile
+          pnpm playwright install --with-deps
+
       - name: Check Documentation
         run: pnpm nx documentation
         timeout-minutes: 20
@@ -143,10 +166,100 @@ jobs:
 
       - name: Configure Detox Environment, Install applesimutils
         run: |
-          HOMEBREW_NO_AUTO_UPDATE=1 brew tap wix/brew >/dev/null
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install applesimutils >/dev/null
-          xcrun simctl shutdown all && xcrun simctl erase all
-        timeout-minutes: 20
+          # Ensure Xcode command line tools are installed and configured
+          xcode-select --print-path || sudo xcode-select --reset
+          sudo xcode-select -s /Applications/Xcode.app
+          
+          # Install or update applesimutils with error handling
+          if ! brew list applesimutils &>/dev/null; then
+            echo "Installing applesimutils..."
+            HOMEBREW_NO_AUTO_UPDATE=1 brew tap wix/brew >/dev/null
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install applesimutils >/dev/null || {
+              echo "Failed to install applesimutils, retrying with update..."
+              brew update
+              HOMEBREW_NO_AUTO_UPDATE=1 brew install applesimutils
+            }
+          else
+            echo "Updating applesimutils..."
+            HOMEBREW_NO_AUTO_UPDATE=1 brew upgrade applesimutils || true
+          fi
+          
+          # Verify applesimutils installation
+          applesimutils --version || (echo "applesimutils installation failed" && exit 1)
+          
+          # Configure environment for M-series Mac
+          echo "DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer" >> $GITHUB_ENV
+          echo "PLATFORM_NAME=iOS Simulator" >> $GITHUB_ENV
+          
+          # Set additional environment variables for better debugging
+          echo "DETOX_DISABLE_TELEMETRY=1" >> $GITHUB_ENV
+          echo "DETOX_LOG_LEVEL=trace" >> $GITHUB_ENV
+          
+          # Verify Xcode installation
+          xcodebuild -version
+          
+          # List available simulators
+          xcrun simctl list devices available
+        timeout-minutes: 10
+        continue-on-error: false
+  
+      - name: Reset iOS Simulators
+        id: reset-simulators
+        run: |
+          echo "Resetting iOS Simulators..."
+          
+          # Kill simulator processes
+          sudo killall -9 com.apple.CoreSimulator.CoreSimulatorService 2>/dev/null || true
+          killall "Simulator" 2>/dev/null || true
+          killall "iOS Simulator" 2>/dev/null || true
+          
+          # Wait for processes to terminate
+          sleep 3
+          
+          # Shutdown and erase all simulators (ignore failures)
+          xcrun simctl shutdown all 2>/dev/null || true
+          sleep 5
+          xcrun simctl erase all 2>/dev/null || true
+          
+          # If erase failed, try the nuclear option
+          if xcrun simctl list devices | grep -q "Booted" 2>/dev/null; then
+            echo "Standard reset failed, using nuclear option..."
+            rm -rf ~/Library/Developer/CoreSimulator/Devices/* 2>/dev/null || true
+            launchctl remove com.apple.CoreSimulator.CoreSimulatorService 2>/dev/null || true
+            sleep 3
+          fi
+          
+          # Clean up additional directories
+          rm -rf ~/Library/Developer/CoreSimulator/Caches/* 2>/dev/null || true
+          rm -rf ~/Library/Logs/CoreSimulator/* 2>/dev/null || true
+          rm -rf ~/Library/Developer/Xcode/DerivedData/* 2>/dev/null || true
+          
+          echo "Simulator reset completed"
+        timeout-minutes: 5
+        continue-on-error: true
+
+      - name: Verify Simulator Reset
+        if: ${{ steps.reset-simulators.outcome == 'success' }}
+        run: |
+          # Verify CoreSimulator service restarted
+          pgrep -fl "CoreSimulator" || (echo "CoreSimulator service not running" && exit 1)
+          
+          # Check simulator list is clean
+          xcrun simctl list devices
+          
+          # Verify simulator runtime paths exist and are writable
+          test -d ~/Library/Developer/CoreSimulator/Devices || (echo "Simulator devices directory missing" && exit 1)
+          touch ~/Library/Developer/CoreSimulator/Devices/test || (echo "Simulator devices directory not writable" && exit 1)
+          rm ~/Library/Developer/CoreSimulator/Devices/test
+        timeout-minutes: 5
+
+      - name: Diagnose Simulator Reset Failure
+        if: ${{ steps.reset-simulators.outcome == 'failure' }}
+        run: |
+          echo "Simulator reset failed. Collecting diagnostic information..."
+          xcrun simctl list
+          echo "Checking simulator logs..."
+          ls -la ~/Library/Logs/CoreSimulator/ || echo "No simulator logs found"
 
       - name: Save Homebrew Cache
         uses: actions/cache@v4
@@ -159,17 +272,35 @@ jobs:
       - uses: pnpm/action-setup@v4
         name: Install pnpm
         with:
-          version: 9.8.0
+          version: 10.11.1
           run_install: false
 
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'pnpm'
+
+      - name: Cache Rust toolchain and cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
       - name: Install project dependencies
         run: |
           pnpm install --frozen-lockfile
           pnpm playwright install --with-deps
 
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-
       - name: Set SHAs
         uses: nrwl/nx-set-shas@v4
         with:

.github/workflows/claude.yml

@@ -0,0 +1,93 @@
+name: Claude Code
+
+env:
+  PNPM_HOME: ~/.pnpm
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      contains(fromJson('["AgentEnder", "barbados-clemens", "Cammisuli", "Coly010", "FrozenPandaz", "isaacplmann", "JamesHenry", "jaysoo", "leosvelperez", "mandarini", "MaxKless", "meeroslav", "nartc", "ndcunningham", "philipjfulcher", "vsavkin", "xiongemi"]'), github.actor) &&
+      ((github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+       (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+       (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+       (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude'))))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      actions: read
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 250
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ca-certificates lsof libvips-dev libglib2.0-dev libgirepository1.0-dev
+
+      - name: Install Chrome
+        uses: browser-actions/setup-chrome@v1
+
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        with:
+          version: 10.11.1
+          run_install: false
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'pnpm'
+
+      - name: Cache cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            .cargo-cache
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Install project dependencies
+        run: |
+          pnpm install --frozen-lockfile
+          pnpm playwright install --with-deps
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@beta
+        timeout-minutes: 90
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          allowed_tools: "Bash,Edit,Read,Write,Glob,Grep,LS,MultiEdit,NotebookRead,NotebookEdit"
+

.github/workflows/e2e-matrix.yml

@@ -25,7 +25,8 @@ jobs:
         os:
           - ubuntu-latest
           - macos-latest
-          - windows-latest
+          # - windows-latest Windows fails to build gradle wrapper which always runs when we build nx.
+          ## https://staging.nx.app/runs/LgD4vxGn8w?utm_source=pull-request&utm_medium=comment
         node_version:
           - 20
           - 22
@@ -36,9 +37,9 @@ jobs:
             node_version: 22
           # - os: macos-latest
           #   node_version: 23
-          - os: windows-latest
-            node_version: 22
-          # - os: windows-latest
+          # - os: windows-latest TODO (emily): Windows fails to build gradle wrapper which always runs when we build nx. Re-enable when we fix this.
+            # node_version: 22
+          # - os: windows-latest TODO (emily): Windows fails to build gradle wrapper which always runs when we build nx. Re-enable when we fix this.
           #   node_version: 23
 
     name: Cache install (${{ matrix.os }}, node v${{ matrix.node_version }})
@@ -52,7 +53,7 @@ jobs:
       - uses: pnpm/action-setup@v4
         name: Install pnpm
         with:
-          version: 9.8.0
+          version: 10.11.1
           run_install: false
 
       - name: Set node
@@ -61,13 +62,17 @@ jobs:
           node-version: ${{ matrix.node_version }}
           cache: 'pnpm'
 
-      - name: Cache node_modules
-        id: cache-modules
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        run: echo "path=$(pnpm store path)" >> $GITHUB_OUTPUT
+
+      - name: Cache pnpm store
         uses: actions/cache@v4
         with:
-          lookup-only: true
-          path: '**/node_modules'
-          key: ${{ runner.os }}-modules-${{ matrix.node_version }}-${{ hashFiles('pnpm-lock.yaml') }}
+          path: ${{ steps.pnpm-cache.outputs.path }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
 
       - name: Ensure Python setuptools Installed on Macos
         if: ${{ matrix.os == 'macos-latest' }}
@@ -75,7 +80,6 @@ jobs:
         run: brew install python-setuptools
 
       - name: Install packages
-        if: steps.cache-modules.outputs.cache-hit != 'true'
         run: pnpm install --frozen-lockfile
 
       - name: Homebrew cache directory path
@@ -132,7 +136,7 @@ jobs:
     permissions:
       contents: read
     runs-on: ${{ matrix.os }}
-    timeout-minutes: 70     # <- cap each job to 70 minutes
+    timeout-minutes: 200     # <- cap each job to 200 minutes
     strategy:
       matrix: ${{fromJson(needs.prepare-matrix.outputs.matrix)}} # Load matrix from previous job
       fail-fast: false
@@ -151,7 +155,7 @@ jobs:
       - uses: pnpm/action-setup@v4
         name: Install pnpm
         with:
-          version: 9.8.0
+          version: 10.11.1
           run_install: false
 
       - name: Use Node.js ${{ matrix.node_version }}
@@ -220,33 +224,110 @@ jobs:
       - name: Configure Detox Environment, Install applesimutils
         if: ${{ matrix.os == 'macos-latest' }}
         run: |
-          # Check if applesimutils is already installed
+          # Ensure Xcode command line tools are installed and configured
+          xcode-select --print-path || sudo xcode-select --reset
+          sudo xcode-select -s /Applications/Xcode.app
+          
+          # Install or update applesimutils with error handling
           if ! brew list applesimutils &>/dev/null; then
+            echo "Installing applesimutils..."
             HOMEBREW_NO_AUTO_UPDATE=1 brew tap wix/brew >/dev/null
-            HOMEBREW_NO_AUTO_UPDATE=1 brew install applesimutils >/dev/null
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install applesimutils >/dev/null || {
+              echo "Failed to install applesimutils, retrying with update..."
+              brew update
+              HOMEBREW_NO_AUTO_UPDATE=1 brew install applesimutils
+            }
           else
-            echo "applesimutils is already installed, skipping installation"
+            echo "Updating applesimutils..."
+            HOMEBREW_NO_AUTO_UPDATE=1 brew upgrade applesimutils || true
           fi
+          
+          # Verify applesimutils installation
+          applesimutils --version || (echo "applesimutils installation failed" && exit 1)
+          
+          # Configure environment for M-series Mac
+          echo "DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer" >> $GITHUB_ENV
+          echo "PLATFORM_NAME=iOS Simulator" >> $GITHUB_ENV
+          
+          # Set additional environment variables for better debugging
+          echo "DETOX_DISABLE_TELEMETRY=1" >> $GITHUB_ENV
+          echo "DETOX_LOG_LEVEL=trace" >> $GITHUB_ENV
+          
+          # Verify Xcode installation
+          xcodebuild -version
+          
         timeout-minutes: 10
+        continue-on-error: false
 
       - name: Reset iOS Simulators
         if: ${{ matrix.os == 'macos-latest' }}
+        id: reset-simulators
         run: |
-          xcrun simctl shutdown all && xcrun simctl erase all
+          echo "Resetting iOS Simulators..."
+          
+          # Kill simulator processes
+          sudo killall -9 com.apple.CoreSimulator.CoreSimulatorService 2>/dev/null || true
+          killall "Simulator" 2>/dev/null || true
+          killall "iOS Simulator" 2>/dev/null || true
+          
+          # Wait for processes to terminate
+          sleep 3
+          
+          # Shutdown and erase all simulators (ignore failures)
+          xcrun simctl shutdown all 2>/dev/null || true
+          sleep 5
+          xcrun simctl erase all 2>/dev/null || true
+          
+          # If erase failed, try the nuclear option
+          if xcrun simctl list devices | grep -q "Booted" 2>/dev/null; then
+            echo "Standard reset failed, using nuclear option..."
+            rm -rf ~/Library/Developer/CoreSimulator/Devices/* 2>/dev/null || true
+            launchctl remove com.apple.CoreSimulator.CoreSimulatorService 2>/dev/null || true
+            sleep 3
+          fi
+          
+          # Clean up additional directories
+          rm -rf ~/Library/Developer/CoreSimulator/Caches/* 2>/dev/null || true
+          rm -rf ~/Library/Logs/CoreSimulator/* 2>/dev/null || true
+          rm -rf ~/Library/Developer/Xcode/DerivedData/* 2>/dev/null || true
+          
+          echo "Simulator reset completed"
+        timeout-minutes: 5
+        continue-on-error: true
+
+      - name: Verify Simulator Reset
+        if: ${{ matrix.os == 'macos-latest' && steps.reset-simulators.outcome == 'success' }}
+        run: |
+          # Verify CoreSimulator service restarted
+          pgrep -fl "CoreSimulator" || (echo "CoreSimulator service not running" && exit 1)
+          
+          # Verify simulator runtime paths exist and are writable
+          test -d ~/Library/Developer/CoreSimulator/Devices || (echo "Simulator devices directory missing" && exit 1)
+          touch ~/Library/Developer/CoreSimulator/Devices/test || (echo "Simulator devices directory not writable" && exit 1)
+          rm ~/Library/Developer/CoreSimulator/Devices/test
         timeout-minutes: 5
 
+      - name: Diagnose Simulator Reset Failure
+        if: ${{ matrix.os == 'macos-latest' && steps.reset-simulators.outcome == 'failure' }}
+        run: |
+          echo "Simulator reset failed. Collecting diagnostic information..."
+          xcrun simctl list
+          echo "Checking simulator logs..."
+          ls -la ~/Library/Logs/CoreSimulator/ || echo "No simulator logs found"
+
       - name: Configure git metadata (needed for lerna smoke tests)
+        if: ${{ (matrix.os != 'macos-latest') || (matrix.os == 'macos-latest' && steps.reset-simulators.outcome == 'success') }}
         run: |
           git config --global user.email test@test.com
           git config --global user.name "Test Test"
 
       - name: Set starting timestamp
+        if: ${{ (matrix.os != 'macos-latest') || (matrix.os == 'macos-latest' && steps.reset-simulators.outcome == 'success') }}
         id: before-e2e
         shell: bash
         run: |
           echo "timestamp=$(date +%s)" >> $GITHUB_OUTPUT
 
-
       - name: Run e2e tests with pnpm (Linux/Windows)
         id: e2e-run-pnpm
         if: ${{ matrix.os != 'macos-latest' }}
@@ -270,7 +351,7 @@ jobs:
   
       - name: Run e2e tests with npm (macOS)
         id: e2e-run-npm
-        if: ${{ matrix.os == 'macos-latest' }}
+        if: ${{ matrix.os == 'macos-latest' && steps.reset-simulators.outcome == 'success' }}
         run: |
           # Run the tests
           if [[ "${{ matrix.project }}" == "e2e-detox" ]] || [[ "${{ matrix.project }}" == "e2e-react-native" ]] || [[ "${{ matrix.project }}" == "e2e-expo" ]]; then
@@ -328,16 +409,23 @@ jobs:
           sudo: ${{ matrix.os != 'windows-latest' }} # disable sudo for windows debugging
 
   process-result:
-    if: ${{ always() && github.repository_owner == 'nrwl' }}
+    if: ${{ always() && github.repository_owner == 'nrwl' && github.event_name != 'workflow_dispatch' }}
     runs-on: ubuntu-latest
     needs: e2e
     timeout-minutes: 10
     outputs:
-      message: ${{ steps.process-json.outputs.SLACK_MESSAGE }}
-      proj-duration: ${{ steps.process-json.outputs.SLACK_PROJ_DURATION }}
-      pm-duration: ${{ steps.process-json.outputs.SLACK_PM_DURATION }}
-      codeowners: ${{ steps.process-json.outputs.CODEOWNERS }}
+      message: ${{ steps.process-json.outputs.slack_message }}
+      proj_duration: ${{ steps.process-json.outputs.slack_proj_duration }}
+      pm_duration: ${{ steps.process-json.outputs.slack_pm_duration }}
+      codeowners: ${{ steps.process-json.outputs.codeowners }}
+      has_golden_failures: ${{ steps.process-json.outputs.has_golden_failures }}
     steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          filter: tree:0
+
       - name: Prepare dir for output
         run: mkdir -p outputs
 
@@ -349,145 +437,16 @@ jobs:
       - name: Join and stringify matrix configs
         id: combine-json
         run: |
-          combined=$((jq -s . outputs/*/matrix.json) | jq tostring)
+          combined=$(jq -sc . outputs/*/matrix.json)
           echo "combined=$combined" >> $GITHUB_OUTPUT
 
-      - name: Make slack outputs
+      - name: Process results with TypeScript script
         id: process-json
-        uses: actions/github-script@v7
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        with:
-          script: |
-            const combined = JSON.parse(${{ steps.combine-json.outputs.combined }});
-            const failedProjects = combined.filter(c => c.status === 'failure').sort((a, b) => a.project.localeCompare(b.project));
-
-            // codeowners
-            const codeowners = new Set();
-            failedProjects.forEach(c => {
-              codeowners.add(c.codeowners);
-            });
-            core.setOutput('CODEOWNERS', Array.from(codeowners).join(','));
-
-            function trimSpace(res) {
-              return res.split('\n').map((l) => l.trim()).join('\n');
-            }
-
-            // failed message
-            let lastProject;
-            let result = `
-              \`\`\`
-              | Failed project                 | PM   | OS    | Node |
-              |--------------------------------|------|-------|------|`;
-            failedProjects.forEach(matrix => {
-              const project = matrix.project !== lastProject ? matrix.project : '...';
-              result += `\n| ${project.padEnd(30)} | ${matrix.package_manager.padEnd(4)} | ${matrix.os_name} | v${matrix.node_version}  |`
-              lastProject = matrix.project;
-            });
-            result += `\`\`\``;
-            core.setOutput('SLACK_MESSAGE', trimSpace(result));
-            console.log(trimSpace(result));
-
-            function humanizeDuration(num) {
-              let res = '';
-              const hours = Math.floor(num / 3600);
-              if (hours) {
-                res += `${hours}h `;
-              }
-              const mins = Math.floor((num % 3600) / 60);
-              if (mins) {
-                res += `${mins}m `;
-              }
-              const sec = num % 60;
-              if (sec) {
-                res += `${sec}s`
-              }
-              return res;
-            }
-
-            // duration message
-            const timeReport = {};
-            const pmReport = {
-              npm: 0,
-              yarn: 0,
-              pnpm: 0
-            };
-            const macosProjects = ['e2e-detox', 'e2e-expo', 'e2e-react-native'];
-            combined.forEach((matrix) => {
-              if (matrix.os_name === 'Linux' && matrix.node_version === 20) {
-                pmReport[matrix.package_manager] += matrix.duration;
-              }
-              if (matrix.os_name === 'Linux' || macosProjects.includes(matrix.project)) {
-                if (timeReport[matrix.project]) {
-                  if (matrix.duration > timeReport[matrix.project].max) {
-                    timeReport[matrix.project].max = matrix.duration;
-                    timeReport[
-                      matrix.project
-                    ].maxEnv = `${matrix.os_name}, ${matrix.package_manager}`;
-                  }
-                  if (matrix.duration < timeReport[matrix.project].min) {
-                    timeReport[matrix.project].min = matrix.duration;
-                    timeReport[
-                      matrix.project
-                    ].minEnv = `${matrix.os_name}, ${matrix.package_manager}`;
-                  }
-                } else {
-                  timeReport[matrix.project] = {
-                    min: matrix.duration,
-                    max: matrix.duration,
-                    minEnv: `${matrix.os_name}, ${matrix.package_manager}`,
-                    maxEnv: `${matrix.os_name}, ${matrix.package_manager}`,
-                  };
-                }
-              }
-            });
-
-            // project time report
-            let resultPkg = `
-                \`\`\`
-                | Project                        | Time                      |
-                |--------------------------------|---------------------------|`;
-            function mapProjectTime(proj, section) {
-              let res = '';
-              res += `${humanizeDuration(timeReport[proj][section])}`;
-              res += ` (${timeReport[proj][section + 'Env']})`
-              return res;
-            }
-            function durationIcon(proj, section) {
-              if (timeReport[proj][section] < 12 * 60) {
-                return `${section} ✅`;
-              }
-              if (timeReport[proj][section] < 15 * 60) {
-                return `${section} ❗`;
-              }
-              return `${section} ❌`;
-            }
-            Object.keys(timeReport).forEach(proj => {
-              resultPkg += `\n| ${proj.padEnd(30)} |                           |`;
-              resultPkg += `\n| ${durationIcon(proj, 'min').padStart(29)} | ${mapProjectTime(proj, 'min').padEnd(25)} |`;
-              resultPkg += `\n| ${durationIcon(proj, 'max').padStart(29)} | ${mapProjectTime(proj, 'max').padEnd(25)} |`;
-            });
-            resultPkg += `\`\`\``;
-            core.setOutput('SLACK_PROJ_DURATION', trimSpace(resultPkg));
-
-            // Print project duration report inline to allow reviewing on manual runs (when no slack message will be sent)
-            console.log(trimSpace(resultPkg));
-
-            let resultPm = `
-                \`\`\`
-                | PM   | Total time  |
-                |------|-------------|`;
-            Object.keys(pmReport).forEach(pm => {
-              resultPm += `\n| ${pm.padEnd(4)} | ${humanizeDuration(pmReport[pm]).padEnd(11)} |`
-            });
-            resultPm += `\`\`\``;
-            core.setOutput('SLACK_PM_DURATION', trimSpace(resultPm));
-
-            // Print package manager duration report inline to allow reviewing on manual runs (when no slack message will be sent)
-            console.log(trimSpace(resultPm));
+        run: |
+          echo '${{ steps.combine-json.outputs.combined }}' | npx tsx .github/workflows/nightly/process-result.ts
 
   report-failure:
-    if: ${{ failure() && github.repository_owner == 'nrwl' && github.event_name != 'workflow_dispatch' }}
+    if: ${{ always() && needs.process-result.outputs.has_golden_failures == 'true' && github.repository_owner == 'nrwl' && github.event_name != 'workflow_dispatch' }}
     needs: process-result
     runs-on: ubuntu-latest
     name: Report failure
@@ -497,16 +456,16 @@ jobs:
         uses: ravsamhq/notify-slack-action@v2
         with:
           status: 'failure'
-          message_format: '{emoji} Workflow has {status_message} ${{ needs.process-result.outputs.message }}'
-          notification_title: '{workflow}'
+          message_format: '${{ needs.process-result.outputs.message }}'
+          notification_title: 'Golden Test Failure'
           footer: '<{run_url}|View Run> / Last commit <{commit_url}|{commit_sha}>'
           mention_groups: ${{ needs.process-result.outputs.codeowners }}
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.ACTION_MONITORING_SLACK }}
 
   report-success:
-    if: ${{ success() && github.repository_owner == 'nrwl' && github.event_name != 'workflow_dispatch' }}
-    needs: e2e
+    if: ${{ always() && needs.process-result.outputs.has_golden_failures == 'false' && github.repository_owner == 'nrwl' && github.event_name != 'workflow_dispatch' }}
+    needs: process-result
     runs-on: ubuntu-latest
     name: Report status
     timeout-minutes: 10
@@ -514,9 +473,9 @@ jobs:
       - name: Send notification
         uses: ravsamhq/notify-slack-action@v2
         with:
-          status: ${{ needs.e2e.result }}
-          message_format: '{emoji} Workflow has {status_message}'
-          notification_title: '{workflow}'
+          status: 'success'
+          message_format: '${{ needs.process-result.outputs.message }}'
+          notification_title: '✅ Golden Tests: All Passed!'
           footer: '<{run_url}|View Run> / Last commit <{commit_url}|{commit_sha}>'
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.ACTION_MONITORING_SLACK }}
@@ -532,8 +491,8 @@ jobs:
         uses: ravsamhq/notify-slack-action@v2
         with:
           status: 'skipped'
-          message_format: '${{ needs.process-result.outputs.pm-duration }}'
-          notification_title: 'Total duration per package manager (ubuntu only)'
+          message_format: '${{ needs.process-result.outputs.pm_duration }}'
+          notification_title: '⌛ Total duration per package manager (ubuntu only)'
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.ACTION_MONITORING_SLACK }}
 
@@ -542,13 +501,13 @@ jobs:
     needs: process-result
     runs-on: ubuntu-latest
     timeout-minutes: 10
-    name: Report duration per package manager
+    name: Report duration per project
     steps:
       - name: Send notification
         uses: ravsamhq/notify-slack-action@v2
         with:
           status: 'skipped'
-          message_format: '${{ needs.process-result.outputs.proj-duration }}'
-          notification_title: 'E2E Project duration stats'
+          message_format: '${{ needs.process-result.outputs.proj_duration }}'
+          notification_title: '⌛ E2E Project duration stats'
         env:
           SLACK_WEBHOOK_URL: ${{ secrets.ACTION_MONITORING_SLACK }}

.github/workflows/generate-embeddings.yml

@@ -25,7 +25,7 @@ jobs:
         uses: pnpm/action-setup@v4
         id: pnpm-install
         with:
-          version: 9.8.0
+          version: 10.11.1
           run_install: false
 
       - name: Get pnpm store directory

.github/workflows/issue-notifier.yml

@@ -20,7 +20,7 @@ jobs:
 
       - uses: pnpm/action-setup@v4
         with:
-          version: 9.8.0
+          version: 10.11.1
 
       - name: Use Node.js ${{ matrix.node_version }}
         uses: actions/setup-node@v3

.github/workflows/nightly/process-matrix.ts

@@ -1,6 +1,7 @@
 type MatrixDataProject = {
   name: string,
   codeowners: string,
+  is_golden?: boolean, // true if this is a golden project, false otherwise
 };
 
 type MatrixDataOS = {
@@ -19,58 +20,62 @@ type MatrixData = {
   setup: MatrixDataOS[],
 }
 
-// TODO: Extract Slack groups into named groups for easier maintenance
-const matrixData: MatrixData = {
-  coreProjects: [
-    { name: 'e2e-lerna-smoke-tests', codeowners: 'S04TNCVEETS' },
-    { name: 'e2e-js', codeowners: 'S04SJ6HHP0X' },
-    { name: 'e2e-nx-init', codeowners: 'S04SYHYKGNP' },
-    { name: 'e2e-nx', codeowners: 'S04SYHYKGNP' },
-    { name: 'e2e-release', codeowners: 'S04SYHYKGNP' },
-    { name: 'e2e-workspace-create', codeowners: 'S04SYHYKGNP' }
-  ],
-  projects: [
-    { name: 'e2e-angular', codeowners: 'S04SS457V38' },
-    { name: 'e2e-cypress', codeowners: 'S04T16BTJJY' },
-    { name: 'e2e-detox', codeowners: 'S04TNCNJG5N' },
-    { name: 'e2e-esbuild', codeowners: 'S04SJ6HHP0X' },
-    { name: 'e2e-expo', codeowners: 'S04TNCNJG5N' },
-    { name: 'e2e-gradle', codeowners: 'S04TNCNJG5N' },
-    { name: 'e2e-jest', codeowners: 'S04T16BTJJY' },
-    { name: 'e2e-eslint', codeowners: 'S04SYJGKSCT' },
-    { name: 'e2e-next', codeowners: 'S04TNCNJG5N' },
-    { name: 'e2e-node', codeowners: 'S04SJ6HHP0X' },
-    { name: 'e2e-plugin', codeowners: 'S04SYHYKGNP' },
-    { name: 'e2e-react', codeowners: 'S04TNCNJG5N' },
-    { name: 'e2e-react-native', codeowners: 'S04TNCNJG5N' },
-    { name: 'e2e-web', codeowners: 'S04SJ6PL98X' },
-    { name: 'e2e-rollup', codeowners: 'S04SJ6PL98X' },
-    { name: 'e2e-storybook', codeowners: 'S04SVQ8H0G5' },
-    { name: 'e2e-playwright', codeowners: 'S04SVQ8H0G5' },
-    { name: 'e2e-remix', codeowners: 'S04SVQ8H0G5' },
-    { name: 'e2e-rspack', codeowners: 'S04SJ6HHP0X' },
-    { name: 'e2e-vite', codeowners: 'S04SJ6PL98X' },
-    { name: 'e2e-vue', codeowners: 'S04SJ6PL98X' },
-    { name: 'e2e-nuxt', codeowners: 'S04SJ6PL98X' },
-    { name: 'e2e-webpack', codeowners: 'S04SJ6PL98X' }
-  ],
-  nodeTLS: 20,
-  setup: [
-    { os: 'ubuntu-latest', os_name: 'Linux', os_timeout: 60, package_managers: ['npm', 'pnpm', 'yarn'], node_versions: ['20.19.0', "22.12.0"], excluded: ['e2e-detox', 'e2e-react-native', 'e2e-expo'] },
-    { os: 'macos-latest', os_name: 'MacOS', os_timeout: 90, package_managers: ['npm'], node_versions: ['20.19.0'] },
-    { os: 'windows-latest', os_name: 'WinOS', os_timeout: 180, package_managers: ['npm'], node_versions: ['20.19.0'], excluded: ['e2e-detox', 'e2e-react-native', 'e2e-expo'] }
-  ]
-};
-
-const matrix: Array<{
+export type MatrixItem = {
   project: string,
   codeowners: string,
   node_version: number | string,
   package_manager: string,
   os: string,
   os_name: string,
-  os_timeout: number
-}> = [];
+  os_timeout: number,
+  is_golden?: boolean,
+};
+
+// TODO: Extract Slack groups into named groups for easier maintenance
+const matrixData: MatrixData = {
+  coreProjects: [
+    { name: 'e2e-lerna-smoke-tests', codeowners: 'S04TNCVEETS', is_golden: true },
+    { name: 'e2e-js', codeowners: 'S04SJ6HHP0X', is_golden: true },
+    { name: 'e2e-nx-init', codeowners: 'S04SYHYKGNP', is_golden: true },
+    { name: 'e2e-nx', codeowners: 'S04SYHYKGNP' },
+    { name: 'e2e-release', codeowners: 'S04SYHYKGNP'},
+    { name: 'e2e-workspace-create', codeowners: 'S04SYHYKGNP' },
+  ],
+  projects: [
+    { name: 'e2e-cypress', codeowners: 'S04T16BTJJY', is_golden: true },
+    { name: 'e2e-detox', codeowners: 'S04TNCNJG5N' , is_golden: true},
+    { name: 'e2e-esbuild', codeowners: 'S04SJ6HHP0X' , is_golden: true},
+    { name: 'e2e-gradle', codeowners: 'S04TNCNJG5N' , is_golden: true},
+    { name: 'e2e-eslint', codeowners: 'S04SYJGKSCT', is_golden: true },
+    { name: 'e2e-node', codeowners: 'S04SJ6HHP0X', is_golden: true },
+    { name: 'e2e-playwright', codeowners: 'S04SVQ8H0G5', is_golden: true },
+    { name: 'e2e-remix', codeowners: 'S04SVQ8H0G5' , is_golden: true},
+    { name: 'e2e-rspack', codeowners: 'S04SJ6HHP0X', is_golden: true },
+    { name: 'e2e-vite', codeowners: 'S04SJ6PL98X' , is_golden: true},
+    { name: 'e2e-vue', codeowners: 'S04SJ6PL98X' , is_golden: true},
+    { name: 'e2e-web', codeowners: 'S04SJ6PL98X', is_golden: true },
+    { name: 'e2e-webpack', codeowners: 'S04SJ6PL98X', is_golden: true },
+    { name: 'e2e-jest', codeowners: 'S04T16BTJJY', is_golden: true },
+    { name: 'e2e-angular', codeowners: 'S04SS457V38' },
+    { name: 'e2e-expo', codeowners: 'S04TNCNJG5N' },
+    { name: 'e2e-next', codeowners: 'S04TNCNJG5N' },
+    { name: 'e2e-plugin', codeowners: 'S04SYHYKGNP' },
+    { name: 'e2e-react', codeowners: 'S04TNCNJG5N' },
+    { name: 'e2e-react-native', codeowners: 'S04TNCNJG5N' },
+    { name: 'e2e-rollup', codeowners: 'S04SJ6PL98X' },
+    { name: 'e2e-storybook', codeowners: 'S04SVQ8H0G5' },
+    { name: 'e2e-nuxt', codeowners: 'S04SJ6PL98X' }
+  ],
+  nodeTLS: 20,
+  setup: [
+    { os: 'ubuntu-latest', os_name: 'Linux', os_timeout: 60, package_managers: ['npm', 'pnpm', 'yarn'], node_versions: ['20.19.0', "22.12.0"], excluded: ['e2e-detox', 'e2e-react-native', 'e2e-expo'] },
+    { os: 'macos-latest', os_name: 'MacOS', os_timeout: 90, package_managers: ['npm'], node_versions: ['20.19.0'] },
+    // TODO (emily): Fix Windows support as gradle fails when running nx build https://staging.nx.app/runs/LgD4vxGn8w?utm_source=pull-request&utm_medium=comment
+    // { os: 'windows-latest', os_name: 'WinOS', os_timeout: 180, package_managers: ['npm'], node_versions: ['20.19.0'], excluded: ['e2e-detox', 'e2e-react-native', 'e2e-expo'] }
+  ]
+};
+
+const matrix: Array<MatrixItem> = [];
 
 function addMatrixCombo(project: MatrixDataProject, nodeVersion: number | string, pm: number, os: number) {
   matrix.push({
@@ -81,6 +86,7 @@ function addMatrixCombo(project: MatrixDataProject, nodeVersion: number | string
     os: matrixData.setup[os].os,
     os_name: matrixData.setup[os].os_name,
     os_timeout: matrixData.setup[os].os_timeout,
+    is_golden: !!project.is_golden, // Mark golden projects as true, others as false
   });
 }
 

.github/workflows/nightly/process-result.ts

@@ -0,0 +1,197 @@
+import * as fs from 'fs';
+import { MatrixItem } from './process-matrix';
+
+interface MatrixResult extends MatrixItem {
+  status: 'success' | 'failure' | 'cancelled';
+  duration: number;
+}
+
+interface ProcessedResults {
+  codeowners: string;
+  slack_message: string;
+  slack_proj_duration: string;
+  slack_pm_duration: string;
+  has_golden_failures: string;
+}
+
+function trimSpace(res: string): string {
+  return res.split('\n').map((l) => l.trim()).join('\n');
+}
+
+function humanizeDuration(num: number): string {
+  let res = '';
+  const hours = Math.floor(num / 3600);
+  if (hours) res += `${hours}h `;
+  const mins = Math.floor((num % 3600) / 60);
+  if (mins) res += `${mins}m `;
+  const sec = num % 60;
+  if (sec) res += `${sec}s`;
+  return res;
+}
+
+function processResults(combined: MatrixResult[]): ProcessedResults {
+  const failedProjects = combined.filter(c => c.status === 'failure' || c.status === 'cancelled').sort((a, b) => a.project.localeCompare(b.project));
+  const failedGoldenProjects = failedProjects.filter(c => c.is_golden);
+  const hasGoldenFailures = failedGoldenProjects.length > 0;
+  const codeowners = new Set<string>();
+  failedGoldenProjects.forEach(c => codeowners.add(c.codeowners));
+
+  let result = '';
+
+  const allGoldenProjects = combined.filter(c => c.is_golden);
+  const uniqueGoldenProjects = new Set(allGoldenProjects.map(c => c.project));
+  const uniqueFailedGoldenProjects = new Set(failedGoldenProjects.map(c => c.project));
+  const goldenPassingCount = uniqueGoldenProjects.size - uniqueFailedGoldenProjects.size;
+  const goldenFailingCount = uniqueFailedGoldenProjects.size;
+
+  const allOtherProjects = combined.filter(c => !c.is_golden);
+  const uniqueOtherProjects = new Set(allOtherProjects.map(c => c.project));
+  const failedRegularProjects = failedProjects.filter(c => !c.is_golden);
+  const uniqueFailedOtherProjects = new Set(failedRegularProjects.map(c => c.project));
+  const otherPassingCount = uniqueOtherProjects.size - uniqueFailedOtherProjects.size;
+  const otherFailingCount = uniqueFailedOtherProjects.size;
+
+  result += `\n🌟 *Golden Projects*`;
+  result += `\n✅ Passing: ${goldenPassingCount}`;
+  result += `\n❌ Failing: ${goldenFailingCount}`;
+
+  if (failedGoldenProjects.length > 0) {
+    result += `\n\n🚨 *Failed Golden Projects*\n\`\`\``;
+    result += `\n| Failed project                 |`;
+    result += `\n|--------------------------------|`;
+    let lastProject: string | undefined;
+    failedGoldenProjects.forEach(matrix => {
+      const project = matrix.project !== lastProject ? matrix.project : '';
+      if (project) {
+        result += `\n| ${project.padEnd(30)} |`;
+        lastProject = matrix.project;
+      }
+    });
+    result += `\n\`\`\``;
+  }
+
+  result += `\n\n🔧 *Other Projects*`;
+  result += `\n✅ Passing: ${otherPassingCount}`;
+  result += `\n❌ Failing: ${otherFailingCount}`;
+
+  // Failed Other Projects Table (if any)
+  if (failedRegularProjects.length > 0) {
+    result += `\n\n⚠️ *Failed Other Projects*\n\`\`\``;
+    result += `\n| Failed project                 |`;
+    result += `\n|--------------------------------|`;
+    let lastProject: string | undefined;
+    failedRegularProjects.forEach(matrix => {
+      const project = matrix.project !== lastProject ? matrix.project : '';
+      if (project) {
+        result += `\n| ${project.padEnd(30)} |`;
+        lastProject = matrix.project;
+      }
+    });
+    result += `\n\`\`\``;
+  }
+
+  if (failedProjects.length === 0) {
+    result = '🎉 *No test failures detected!* All systems green! 🟢';
+  }
+
+  const timeReport: Record<string, { min: number; max: number; minEnv: string; maxEnv: string }> = {};
+  const pmReport = { npm: 0, yarn: 0, pnpm: 0 };
+  const macosProjects = ['e2e-detox', 'e2e-expo', 'e2e-react-native'];
+
+  combined.forEach(matrix => {
+    const nodeVersion = parseInt(matrix.node_version.toString());
+    if (matrix.os_name === 'Linux' && nodeVersion === 20 && matrix.package_manager in pmReport) {
+      pmReport[matrix.package_manager as keyof typeof pmReport] += matrix.duration;
+    }
+    if (matrix.os_name === 'Linux' || macosProjects.includes(matrix.project)) {
+      if (timeReport[matrix.project]) {
+        if (matrix.duration > timeReport[matrix.project].max) {
+          timeReport[matrix.project].max = matrix.duration;
+          timeReport[matrix.project].maxEnv = `${matrix.os_name}, ${matrix.package_manager}`;
+        }
+        if (matrix.duration < timeReport[matrix.project].min) {
+          timeReport[matrix.project].min = matrix.duration;
+          timeReport[matrix.project].minEnv = `${matrix.os_name}, ${matrix.package_manager}`;
+        }
+      } else {
+        timeReport[matrix.project] = {
+          min: matrix.duration,
+          max: matrix.duration,
+          minEnv: `${matrix.os_name}, ${matrix.package_manager}`,
+          maxEnv: `${matrix.os_name}, ${matrix.package_manager}`,
+        };
+      }
+    }
+  });
+
+  let resultPkg = `
+    \`\`\`
+    | Project                        | Time                      |
+    |--------------------------------|---------------------------|`;
+
+  function mapProjectTime(proj: string, section: 'min' | 'max'): string {
+    return `${humanizeDuration(timeReport[proj][section])} (${timeReport[proj][`${section}Env`]})`;
+  }
+
+  function durationIcon(proj: string, section: 'min' | 'max'): string {
+    const duration = timeReport[proj][section];
+    if (duration < 12 * 60) return `${section} ✅`;
+    if (duration < 15 * 60) return `${section} ❗`;
+    return `${section} ❌`;
+  }
+
+  Object.keys(timeReport).forEach(proj => {
+    resultPkg += `\n| ${proj.padEnd(30)} |                           |`;
+    resultPkg += `\n| ${durationIcon(proj, 'min').padStart(29)} | ${mapProjectTime(proj, 'min').padEnd(25)} |`;
+    resultPkg += `\n| ${durationIcon(proj, 'max').padStart(29)} | ${mapProjectTime(proj, 'max').padEnd(25)} |`;
+  });
+  resultPkg += `\`\`\``;
+
+  let resultPm = `
+    \`\`\`
+    | PM   | Total time  |
+    |------|-------------|`;
+  Object.keys(pmReport).forEach(pm => {
+    resultPm += `\n| ${pm.padEnd(4)} | ${humanizeDuration(pmReport[pm as keyof typeof pmReport]).padEnd(11)} |`;
+  });
+  resultPm += `\`\`\``;
+
+  return {
+    codeowners: Array.from(codeowners).join(','),
+    slack_message: trimSpace(result),
+    slack_proj_duration: trimSpace(resultPkg),
+    slack_pm_duration: trimSpace(resultPm),
+    has_golden_failures: hasGoldenFailures.toString(),
+  };
+}
+
+function setOutput(key: string, value: string) {
+  const outputPath = process.env.GITHUB_OUTPUT;
+  if (!outputPath) {
+    console.warn(`GITHUB_OUTPUT not set. Skipping output for "${key}".`);
+    return;
+  }
+
+  if (value.includes('\n')) {
+    const delimiter = `EOF_${key}_${Date.now()}`;
+    fs.appendFileSync(outputPath, `${key}<<${delimiter}\n${value}\n${delimiter}\n`);
+  } else {
+    fs.appendFileSync(outputPath, `${key}=${value}\n`);
+  }
+}
+
+try {
+  const combinedInput = process.argv[2]
+    ? process.argv[2]
+    : fs.readFileSync(0, 'utf-8').trim();
+
+  const combined: MatrixResult[] = JSON.parse(combinedInput);
+  const results = processResults(combined);
+
+  Object.entries(results).forEach(([key, value]) => {
+    setOutput(key, value);
+  });
+} catch (error) {
+  console.error('Error processing results:', error);
+  process.exit(1);
+}

.github/workflows/npm-audit.yml

@@ -18,7 +18,7 @@ jobs:
 
       - uses: pnpm/action-setup@v4
         with:
-          version: 9.8.0 # Aligned with root package.json (pnpm/action-setup will helpfully error if out of sync)
+          version: 10.11.1 # Aligned with root package.json (pnpm/action-setup will helpfully error if out of sync)
 
       - name: Run a security audit
         run: pnpm dlx audit-ci --critical --report-type summary

.github/workflows/publish.yml

@@ -21,8 +21,8 @@ env:
   DEBUG: napi:*
   NX_RUN_GROUP: ${{ github.run_id }}-${{ github.run_attempt }}
   CYPRESS_INSTALL_BINARY: 0
-  NODE_VERSION: 20.19.0
-  PNPM_VERSION: 9.8.0 # Aligned with root package.json (pnpm/action-setup will helpfully error if out of sync)
+  NODE_VERSION: 22.16.0
+  PNPM_VERSION: 10.11.1 # Aligned with root package.json (pnpm/action-setup will helpfully error if out of sync)
 
 jobs:
   # We first need to determine the version we are releasing, and if we need a custom repo or ref to use for the git checkout in subsequent steps.
@@ -140,23 +140,50 @@ jobs:
           - host: ubuntu-latest
             target: x86_64-unknown-linux-gnu
             docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
-            build: |-
-              set -e &&
-              npm i -g pnpm@9.8.0 --force &&
-              pnpm --version &&
-              pnpm install --frozen-lockfile &&
-              rustup target add aarch64-unknown-linux-gnu &&
+            build: |
+              set -e
+              apt-get update
+
+              curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+              apt-get install -y nodejs=22.16.0-1nodesource1
+            
+              export PATH="/usr/local/bin:$PATH"
+              node --version
+              npm --version
+            
+              npm i -g pnpm@${PNPM_VERSION} --force
+              pnpm --version
+            
+              pnpm install --frozen-lockfile
+              rustup target add x86_64-unknown-linux-gnu
               pnpm nx run-many --verbose --target=build-native -- --target=x86_64-unknown-linux-gnu
           - host: ubuntu-latest
             target: x86_64-unknown-linux-musl
             docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
-            build: |-
-              set -e &&
-              npm i -g pnpm@9.8.0 --force &&
-              pnpm --version &&
-              pnpm install --frozen-lockfile &&
-              rustup target add x86_64-unknown-linux-musl &&
-              pnpm nx run-many --verbose --target=build-native -- --target=x86_64-unknown-linux-musl
+            build: |
+              bash -c "
+                set -e
+                echo 'https://dl-cdn.alpinelinux.org/alpine/edge/community' >> /etc/apk/repositories
+                apk add --no-cache curl xz
+
+                curl -fsSL https://unofficial-builds.nodejs.org/download/release/v22.16.0/node-v22.16.0-linux-x64-musl.tar.xz -o node.tar.xz
+                tar -xJf node.tar.xz
+                mv node-v22.16.0-linux-x64-musl /usr/local/node
+            
+                export PATH=\"/usr/local/node/bin:\$PATH\"
+            
+                echo Node: \$(node -v)
+                echo NPM: \$(npm -v)
+            
+                # Install PNPM
+                npm i -g pnpm@${PNPM_VERSION} --force
+                pnpm --version
+            
+                # Install deps and run native build
+                pnpm install --frozen-lockfile
+                rustup target add x86_64-unknown-linux-musl
+                pnpm nx run-many --verbose --target=build-native -- --target=x86_64-unknown-linux-musl
+              "
           - host: macos-13
             target: aarch64-apple-darwin
             setup: |-
@@ -171,12 +198,22 @@ jobs:
           - host: ubuntu-latest
             target: aarch64-unknown-linux-gnu
             docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
-            build: |-
-              set -e &&
-              npm i -g pnpm@9.8.0 --force &&
-              pnpm --version &&
-              pnpm install --frozen-lockfile &&
-              rustup target add aarch64-unknown-linux-gnu &&
+            build: |
+              set -e
+              apt-get update
+            
+              curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+              apt-get install -y nodejs=22.16.0-1nodesource1
+            
+              export PATH="/usr/local/bin:$PATH"
+              node --version
+              npm --version
+            
+              npm i -g pnpm@${PNPM_VERSION} --force
+              pnpm --version
+            
+              pnpm install --frozen-lockfile
+              rustup target add aarch64-unknown-linux-gnu
               pnpm nx run-many --verbose --target=build-native -- --target=aarch64-unknown-linux-gnu
           - host: ubuntu-latest
             target: armv7-unknown-linux-gnueabihf
@@ -198,19 +235,36 @@ jobs:
           - host: ubuntu-latest
             target: aarch64-unknown-linux-musl
             docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
-            build: |-
-              set -e &&
-              rustup target add aarch64-unknown-linux-musl &&
-              npm i -g pnpm@9.8.0 --force &&
-              pnpm --version &&
-              pnpm install --frozen-lockfile &&
-              pnpm nx run-many --verbose --target=build-native -- --target=aarch64-unknown-linux-musl
+            build: |
+              bash -c "
+                set -e
+                echo 'https://dl-cdn.alpinelinux.org/alpine/edge/community' >> /etc/apk/repositories
+                apk add --no-cache curl xz
+            
+                curl -fsSL https://unofficial-builds.nodejs.org/download/release/v22.16.0/node-v22.16.0-linux-x64-musl.tar.xz -o node.tar.xz
+                tar -xJf node.tar.xz
+                mv node-v22.16.0-linux-x64-musl /usr/local/node
+            
+                export PATH=\"/usr/local/node/bin:\$PATH\"
+            
+                echo Node: \$(node -v)
+                echo NPM: \$(npm -v)
+            
+                # Install PNPM
+                npm i -g pnpm@${PNPM_VERSION} --force
+                pnpm --version
+            
+                # Install deps and run native build
+                pnpm install --frozen-lockfile
+                rustup target add aarch64-unknown-linux-musl  
+                pnpm nx run-many --verbose --target=build-native -- --target=aarch64-unknown-linux-musl  
+              "
           - host: windows-latest
             target: aarch64-pc-windows-msvc
             setup: |-
               rustup target add aarch64-pc-windows-msvc
             build: pnpm nx run-many --target=build-native -- --target=aarch64-pc-windows-msvc
-    name: stable - ${{ matrix.settings.target }} - node@18
+    name: stable - ${{ matrix.settings.target }} - node@22.16.0
     runs-on: ${{ matrix.settings.host }}
     steps:
       - uses: actions/checkout@v4
@@ -296,6 +350,7 @@ jobs:
           path: |
             packages/**/*.node
             packages/**/*.wasm
+            !packages/*/node_modules/**
           if-no-files-found: error
 
   build-freebsd:
@@ -318,17 +373,18 @@ jobs:
           RUSTUP_IO_THREADS: 1
           NX_PREFER_TS_NODE: true
           PLAYWRIGHT_BROWSERS_PATH: 0
+          NODE_VERSION: 22.16.0
         with:
           operating_system: freebsd
           version: '14.0'
           architecture: x86-64
-          environment_variables: DEBUG RUSTUP_IO_THREADS CI NX_PREFER_TS_NODE PLAYWRIGHT_BROWSERS_PATH
+          environment_variables: DEBUG RUSTUP_IO_THREADS CI NX_PREFER_TS_NODE PLAYWRIGHT_BROWSERS_PATH NODE_VERSION
           shell: bash
           run: |
             env
             whoami
             sudo pkg install -y -f node libnghttp2 www/npm git
-            sudo npm install --location=global --ignore-scripts pnpm@9.8.0
+            sudo npm install --location=global --ignore-scripts pnpm@10.11.1
             curl https://sh.rustup.rs -sSf --output rustup.sh
             sh rustup.sh -y --profile minimal --default-toolchain stable
             source "$HOME/.cargo/env"
@@ -343,8 +399,11 @@ jobs:
             whoami
             env
             freebsd-version
+            echo "Installing dependencies"
             pnpm install --frozen-lockfile --ignore-scripts
+            echo "Building FreeBSD bindings"
             pnpm nx run-many --verbose --outputStyle stream --target=build-native -- --target=x86_64-unknown-freebsd
+            echo "Cleaning up"
             pnpm nx reset
             rm -rf node_modules
             rm -rf dist
@@ -356,7 +415,9 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: bindings-freebsd
-          path: packages/**/*.node
+          path: |
+            packages/**/*.node
+            !packages/*/node_modules/**
           if-no-files-found: error
 
   publish:

.gitignore

@@ -2,7 +2,6 @@ node_modules
 /.idea
 /.fleet
 /.vscode
-/.cursor
 dist
 /build
 /coverage
@@ -36,6 +35,7 @@ CHANGELOG.md
 .next
 out
 
+
 # Angular Cache
 .angular
 
@@ -73,5 +73,38 @@ storybook-static
 .gradle
 .kotlin
 
+.claude/settings.local.json
+
 .cursor/rules/nx-rules.mdc
-.github/instructions/nx.instructions.md
+.cursor/mcp.json
+.github/instructions/nx.instructions.md
+
+# Added by Claude Task Master
+# Logs
+logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+dev-debug.log
+# Dependency directories
+node_modules/
+# Environment variables
+.env
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+.specstory/**
+.cursorindexingignore
+# OS specific
+# Task files
+tasks.json
+tasks/
+
+# Upstream docs local configuration (machine-specific)
+.upstreamdocs.local.json
+

.mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "nx": {
+      "command": "pnpm",
+      "args": ["nx-mcp"],
+      "env": {}
+    }
+  }
+}

.pnpmrc

@@ -0,0 +1,13 @@
+# Enable pre/post-install which are disabled by default. Installing peer deps which is also disabled by default
+auto-install-peers=true
+enable-pre-post-scripts=true
+
+# Enable lifecycle scripts for specific packages that require them (like post-install)
+enable-scripts=@napi-rs/canvas,sharp,@swc/core,@swc/cli,@swc-node/register,esbuild
+
+# Compatibility
+strict-peer-dependencies=false
+lockfile-version-strict=false
+
+# Consistency across environments
+use-node-version=20.19.0 

.prettierignore

@@ -51,3 +51,6 @@ CODEOWNERS
 /.nx/workflows/dynamic-changesets.yaml
 _files
 _solution
+
+# this file uses TS import attributes which the current prettier version does not support
+tools/documentation/create-embeddings/src/main.mts

.upstreamdocs.json

@@ -0,0 +1,10 @@
+{
+  "include": ["apps/**/*", "libs/**/*", "packages/**/*"],
+  "exclude": [
+    "**/*.spec.*",
+    "**/test/**/*",
+    "**/__tests__/**/*",
+    "**/*.test.*",
+    "node_modules/**/*"
+  ]
+}

.verdaccio/config.yml

@@ -5,7 +5,7 @@ auth:
   htpasswd:
     file: ./htpasswd
 
-max_body_size: 15mb
+max_body_size: 20mb
 
 # a list of other known repositories we can talk to
 uplinks:

CLAUDE.md

@@ -0,0 +1,184 @@
+When responding to queries about this repository:
+
+1. Use the `nx_workspace` mcp tool for understanding the workspace architecture when appropriate
+2. When working in projects, use the `nx_project` mcp tool to analyze and understand the specific project structure and
+   dependencies
+3. Suggest relevant commands from the "Essential Commands" section when applicable
+4. Highlight Nx's focus on monorepos and its key features like smart task execution, code generation, and project graph
+   analysis
+5. Mention the plugin ecosystem and support for various frameworks when relevant
+6. Emphasize the importance of running the full validation suite before committing changes
+
+Always strive to provide accurate, helpful responses that align with the best practices and workflows described in this
+file.
+
+## GitHub Issue Response Mode
+
+When responding to GitHub issues, determine your approach based on how the request is phrased:
+
+### Plan-First Mode (Default)
+
+Use this approach when users ask you to:
+
+- "analyze", "investigate", "assess", "review", "examine", or "plan"
+- Or when the request is ambiguous
+
+In this mode:
+
+1. Provide a detailed analysis of the issue
+2. Create a comprehensive implementation plan
+3. Break down the solution into clear steps
+4. Then please post the plan as a comment on the issue
+
+### Immediate Implementation Mode
+
+Use this approach when users ask you to:
+
+- "fix", "implement", "solve", "build", "create", "update", or "add"
+- Or when they explicitly request immediate action
+
+In this mode:
+
+1. Analyze the issue quickly
+2. Implement the complete solution immediately
+3. Make all necessary code changes. Please make multiple commits so that the changes are easier to review.
+4. Run appropriate tests and validation
+5. If the tests, are not passing, please fix the issues and continue doing this up to 3 more times until the tests pass
+6. Once the tests pass, push a branch and then suggest opening a PR which has a description of the changes made, and
+   that
+   it make sure that it explicitly says "Fixes #ISSUE_NUMBER" to automatically close the issue when the PR is merged.
+
+## Avoid making changes to generated files
+
+Files under `generated` directories are generated based on a different source file and should not be modified directly.
+Find the underlying source and modify that instead.
+
+## Essential Commands
+
+### Code Formatting
+
+After code changes are made, please make sure to format the files with prettier via `npx prettier -- FILE_NAME`
+
+### Pre-push Validation
+
+```bash
+# Full validation suite - run before committing
+nx prepush
+```
+
+If the prepush validation suite fails, please fix the issues before proceeding with your work. This ensures that all
+code adheres to the project's standards and passes all tests. DO NOT make a new commit to fix these issues. Instead,
+amend the current commit.
+
+### Testing Changes
+
+After code changes are made, first test the specific project where the changes were made:
+
+```bash
+nx run-many -t test,build,lint -p PROJECT_NAME
+```
+
+After verifying the individual project, validate that the changes in projects which have been affected:
+
+```bash
+# Test only affected projects (recommended for development)
+nx affected -t build,test,lint
+```
+
+As the last step, run the e2e tests to fully ensure that changes are valid:
+
+```bash
+# Run affected e2e tests (recommended for development)
+nx affected -t e2e-local
+```
+
+## Fixing GitHub Issues
+
+When working on a GitHub issue, follow this systematic approach:
+
+### 1. Get Issue Details
+
+```bash
+# Get issue details using GitHub CLI (replace ISSUE_NUMBER with actual number)
+gh issue view ISSUE_NUMBER
+
+# View multiple issues efficiently in one command
+gh issue list --limit 50 --json number,title,state,labels,assignees,updatedAt,body --jq '.[] | select(.number == 123 or .number == 456 or .number == 789)'
+
+# Or filter by specific criteria to get multiple related issues
+gh issue list --label "bug" --state "open" --json number,title,body,labels --jq '.[]'
+gh issue list --assignee "@me" --json number,title,body,state --jq '.[]'
+```
+
+**Tip**: Instead of running `gh issue view` multiple times, use `gh issue list` with JSON output and filtering to gather
+information about multiple issues in a single command. This is much more efficient than viewing issues one at a time.
+
+**Always provide clickable links**: When discussing GitHub issues or PRs, always include the full GitHub URL so the user
+can easily open them in their browser. For example:
+
+- Issue #12345: https://github.com/nrwl/nx/issues/12345
+- PR #67890: https://github.com/nrwl/nx/pull/67890
+
+When cloning reproduction repos, please clone within `./tmp/claude/repro-ISSUE_NUMBER`
+
+### 2. Analyze the Plan
+
+- Look for a plan or implementation details in the issue description
+- Check comments for additional context or clarification
+- Identify affected projects and components
+
+### 3. Implement the Solution
+
+- Follow the plan outlined in the issue
+- Make focused changes that address the specific problem
+- Ensure code follows existing patterns and conventions
+
+### 4. Run Full Validation
+
+Use the testing workflow from the "Essential Commands" section.
+
+### 5. Submit Pull Request
+
+- Create a descriptive PR title that references the issue
+- **Always fill in the PR template** - don't leave it empty
+- Include "Fixes #ISSUE_NUMBER" in the PR description
+- Provide a clear summary of changes made
+- Request appropriate reviewers
+
+## Pull Request Template
+
+**IMPORTANT**: When creating a pull request, you MUST fill in the template found in `.github/PULL_REQUEST_TEMPLATE.md`.
+Do not leave the template sections empty. The template includes:
+
+### Required Sections
+
+1. **Current Behavior**: Describe the behavior we have today
+2. **Expected Behavior**: Describe the behavior we should expect with the changes in this PR
+3. **Related Issue(s)**: Link the issue being fixed so it gets closed when the PR is merged
+
+### Template Format
+
+```markdown
+## Current Behavior
+
+<!-- This is the behavior we have today -->
+
+## Expected Behavior
+
+<!-- This is the behavior we should expect with the changes in this PR -->
+
+## Related Issue(s)
+
+<!-- Please link the issue being fixed so it gets closed when this is merged. -->
+
+Fixes #ISSUE_NUMBER
+```
+
+### Guidelines
+
+- Ensure your commit message follows the conventional commit format (use `pnpm commit`)
+  - Use `fix:`, `feat:`, `chore:`, etc. as appropriate types.
+  - Scope is **required** for all commits. Possible scopes are listed in `scripts/commitizen.js`.
+- Read the submission guidelines in CONTRIBUTING.md before posting
+- For complex changes, you can request a dedicated Nx release by mentioning the Nx team
+- Always link the related issue using "Fixes #ISSUE_NUMBER" to automatically close it when merged

CODEOWNERS

@@ -191,6 +191,11 @@ rust-toolchain.toml @nrwl/nx-native-reviewers
 /.husky/** @nrwl/nx-pipelines-reviewers
 /packages/workspace/src/generators/ci-workflow/** @nrwl/nx-pipelines-reviewers
 
+# Claude AI Integration
+CLAUDE.md @FrozenPandaz
+.claude/** @FrozenPandaz
+.mcp.json @FrozenPandaz
+
 # Global Files
 project.json @FrozenPandaz @vsavkin
 jest.config.ts @nrwl/nx-testing-tools-reviewers @FrozenPandaz

CONTRIBUTING.md

@@ -27,14 +27,25 @@ can [submit a Pull Request](https://github.com/nrwl/nx/blob/master/CONTRIBUTING.
 
 Source code and documentation are included in the top-level folders listed below.
 
-- `docs` - Markdown and configuration files for documentation including tutorials, guides for each supported platform,
-  and API docs.
-- `e2e` - E2E tests.
 - `packages` - Source code for Nx packages such as Angular, React, Web, NestJS, Next and others including generators and
   executors (or builders).
+- `e2e` - E2E tests for the Nx packages
+- `graph` - Source code for the Nx Graph application which shows the project graph, task graph, project details, and more in the browser.
+- `docs` - Markdown and configuration files for documentation including tutorials, guides for each supported platform,
+  and API docs.
+- `nx-dev` - Source code for the Nx documentation site which displays the markdown in `docs` and more.
+- `tools` - Workspace-specific tooling and plugins
 - `scripts` - Miscellaneous scripts for project tasks such as building documentation, testing, and code formatting.
 - `tmp` - Folder used by e2e tests. If you are a WebStorm user, make sure to mark this folder as excluded.
 
+## Technologies
+
+This repo contains a mix of different technologies, including:
+
+- **Rust**: The core of Nx is written in Rust, which provides performance and safety.
+- **TypeScript**: The primary language for Nx packages and the Nx DevKit.
+- **Kotlin**: Used for the Gradle and Java plugins.
+
 ## Development Workstation Setup
 
 If you are using `VSCode`, and provided you have [Docker](https://docker.com) installed on your machine, then you can leverage [Dev Containers](https://containers.dev) through this [VSCode extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers), to easily setup your development environment, with everything needed to contribute to Nx, already installed (namely `NodeJS`, `Yarn`, `Rust`, `Cargo`, plus some useful extensions like `Nx Console`).
@@ -374,6 +385,57 @@ To simplify and automate the process of committing with this format,
 **Nx is a [Commitizen](https://github.com/commitizen/cz-cli) friendly repository**, just do `git add` and
 execute `pnpm commit`.
 
+##### Using the Interactive Commit Tool
+
+Instead of `git commit`, use:
+
+```bash
+pnpm commit
+```
+
+This will launch an interactive prompt that will:
+
+1. Ask you to select the type of change (feat, fix, docs, cleanup, chore)
+2. Let you choose the appropriate scope from the predefined list
+3. Guide you through writing a clear, descriptive commit message
+4. Ensure your commit follows the conventional commit format
+
+##### Available Commit Types
+
+- **feat**: A new feature
+- **fix**: A bug fix
+- **docs**: Documentation only changes
+- **cleanup**: A code change that neither fixes a bug nor adds a feature
+- **chore**: Other changes that don't modify src or test files
+
+##### Available Scopes
+
+The repository includes many predefined scopes. Use the one which is most specific to the changes being committed
+
+- **core**: anything Nx core specific
+- **angular**: anything Angular specific
+- **react**: anything React specific
+- **nextjs**: anything Next specific
+- **node**: anything Node specific
+- **devkit**: devkit-related changes
+- **graph**: anything graph app specific
+- **testing**: anything testing specific (e.g. jest or cypress)
+- **misc**: misc stuff
+- **repo**: anything related to managing the repo itself
+- **nx-dev**: anything related to docs infrastructure
+
+For the complete list of available scopes, see `/scripts/commitizen.js`.
+
+##### Example Commits
+
+```bash
+feat(core): add new project graph visualization
+fix(angular): resolve build issues with standalone components
+docs(misc): update contributing guidelines
+chore(repo): bump dependencies
+cleanup(devkit): refactor utility functions for better readability
+```
+
 #### PR releases
 
 If you are working on a particularly complex change or feature addition, you can request a dedicated Nx release for the associated pull request branch. Mention someone from the Nx team or the `@nrwl/nx-pipelines-reviewers` and they will confirm if the PR warrants its own release for testing purposes, and generate it for you if appropriate.

README.md

@@ -1,7 +1,7 @@
 <p style="text-align: center;">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
-    <img alt="Nx - Smart Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+    <img alt="Nx - Smart Repos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
   </picture>
 </p>
 
@@ -19,9 +19,9 @@
 
 <hr>
 
-# Smart Monorepos · Fast CI
+# Smart Repos · Fast Builds
 
-Build system, optimized for monorepos, with AI-powered architectural awareness and advanced CI capabilities.
+An AI-first build platform that connects everything from your editor to CI. Helping you deliver fast, without breaking things.
 
 Create a new Nx workspace with
 
@@ -35,7 +35,7 @@ npx create-nx-workspace
 npx nx init
 ```
 
-to add Nx to your existing workspace to get faster task scheduling, caching and more. More [in the docs](https://nx.dev/getting-started/intro#try-nx-yourself).
+to add Nx to your existing workspace to get faster task scheduling, caching and more. More [in the docs](https://nx.dev/getting-started/intro).
 
 ## Learn about CI with Nx Cloud
 
@@ -58,7 +58,7 @@ Learn more in the [Nx CI docs &raquo;](https://nx.dev/ci/intro?utm_source=nxrepo
 - [Our Twitter/X](https://x.com/nxdevtools)
 
 <p style="text-align: center;"><a href="https://www.youtube.com/@nxdevtools/videos" target="_blank" rel="noreferrer"><img src="./images/nx-courses-and-videos.svg" 
-width="100%" alt="Nx - Smart Monorepos · Fast CI"></a></p>
+width="100%" alt="Nx - Smart Repos · Fast Builds"></a></p>
 
 ## Want to help?
 
@@ -82,17 +82,17 @@ help you get started.
 | ![James Henry](https://avatars.githubusercontent.com/u/900523?s=160&v=4) | ![Jon Cammisuli](https://avatars2.githubusercontent.com/u/4332460?s=160) | ![Isaac Mann](https://avatars1.githubusercontent.com/u/861504?s=160) | ![Juri Strumpflohner](https://avatars1.githubusercontent.com/u/542458?s=160) |
 | [JamesHenry](https://github.com/JamesHenry)                              | [cammisuli](https://github.com/cammisuli)                                | [isaacplmann](https://github.com/isaacplmann)                        | [juristr](https://github.com/juristr)                                        |
 
-| Philip Fulcher                                                            | Caleb Ukle                                                            | Katerina Skroumpelou                                                            | Colum Ferry                                                            |
-| ------------------------------------------------------------------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| ![Philip Fulcher](https://avatars1.githubusercontent.com/u/1536471?s=160) | ![Caleb Ukle](https://avatars.githubusercontent.com/u/23272162?s=160) | ![Katerina Skroumpelou](https://avatars0.githubusercontent.com/u/6603745?s=160) | ![Colum Ferry](https://avatars.githubusercontent.com/u/12140467?s=160) |
-| [philipjfulcher](https://github.com/philipjfulcher)                       | [barbados-clemens](https://github.com/barbados-clemens)               | [mandarini](https://github.com/mandarini)                                       | [Coly010](https://github.com/Coly010)                                  |
+| Philip Fulcher                                                            | Caleb Ukle                                                            | Colum Ferry                                                            | Emily Xiong                                                            |
+| ------------------------------------------------------------------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| ![Philip Fulcher](https://avatars1.githubusercontent.com/u/1536471?s=160) | ![Caleb Ukle](https://avatars.githubusercontent.com/u/23272162?s=160) | ![Colum Ferry](https://avatars.githubusercontent.com/u/12140467?s=160) | ![Emily Xiong](https://avatars.githubusercontent.com/u/16211801?s=160) |
+| [philipjfulcher](https://github.com/philipjfulcher)                       | [barbados-clemens](https://github.com/barbados-clemens)               | [Coly010](https://github.com/Coly010)                                  | [xiongemi](https://github.com/xiongemi)                                |
 
-| Emily Xiong                                                            | Miroslav Jonaš                                                          | Leosvel Pérez Espinosa                                                            | Zachary DeRose                                                           |
-| ---------------------------------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
-| ![Emily Xiong](https://avatars.githubusercontent.com/u/16211801?s=160) | ![Miroslav Jonaš](https://avatars.githubusercontent.com/u/881612?s=160) | ![Leosvel Pérez Espinosa](https://avatars.githubusercontent.com/u/12051310?s=160) | ![Zachary DeRose](https://avatars.githubusercontent.com/u/3788405?s=160) |
-| [xiongemi](https://github.com/xiongemi)                                | [meeroslav](https://github.com/meeroslav)                               | [leosvelperez](https://github.com/leosvelperez)                                   | [ZackDeRose](https://github.com/ZackDeRose)                              |
+| Miroslav Jonaš                                                          | Leosvel Pérez Espinosa                                                            | Zachary DeRose                                                           | Craigory Coppola                                                           |
+| ----------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------ | -------------------------------------------------------------------------- |
+| ![Miroslav Jonaš](https://avatars.githubusercontent.com/u/881612?s=160) | ![Leosvel Pérez Espinosa](https://avatars.githubusercontent.com/u/12051310?s=160) | ![Zachary DeRose](https://avatars.githubusercontent.com/u/3788405?s=160) | ![Craigory Coppola](https://avatars.githubusercontent.com/u/6933928?s=160) |
+| [meeroslav](https://github.com/meeroslav)                               | [leosvelperez](https://github.com/leosvelperez)                                   | [ZackDeRose](https://github.com/ZackDeRose)                              | [AgentEnder](https://github.com/AgentEnder)                                |
 
-| Craigory Coppola                                                           | Chau Tran                                                            | Nicholas Cunningham                                                          | Max Kless                                                            |
-| -------------------------------------------------------------------------- | -------------------------------------------------------------------- | ---------------------------------------------------------------------------- | -------------------------------------------------------------------- |
-| ![Craigory Coppola](https://avatars.githubusercontent.com/u/6933928?s=160) | ![Chau Tran](https://avatars.githubusercontent.com/u/25516557?s=160) | ![Nicholas Cunningham](https://avatars.githubusercontent.com/u/338948?s=160) | ![Max Kless](https://avatars.githubusercontent.com/u/34165455?s=160) |
-| [AgentEnder](https://github.com/AgentEnder)                                | [nartc](https://github.com/nartc)                                    | [ndcunningham](https://github.com/ndcunningham)                              | [MaxKless](https://github.com/MaxKless)                              |
+| Chau Tran                                                            | Nicholas Cunningham                                                          | Max Kless                                                            |
+| -------------------------------------------------------------------- | ---------------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| ![Chau Tran](https://avatars.githubusercontent.com/u/25516557?s=160) | ![Nicholas Cunningham](https://avatars.githubusercontent.com/u/338948?s=160) | ![Max Kless](https://avatars.githubusercontent.com/u/34165455?s=160) |
+| [nartc](https://github.com/nartc)                                    | [ndcunningham](https://github.com/ndcunningham)                              | [MaxKless](https://github.com/MaxKless)                              |

docs/README.md

@@ -88,7 +88,7 @@ The documentation website [nx.dev](https://nx.dev) is using custom Markdown synt
 Callouts are available to get the attention of the reader on some specific type of information.
 
 ```markdown
-{% callout type="caution|check|note|warning" title="string" %}
+{% callout type="announcement|caution|check|note|warning" title="string" %}
 Your content goes here.
 {% /callout %}
 ```

docs/blog/2021-12-17-mastering-the-project-boundaries-in-nx.md

@@ -54,7 +54,7 @@ The `allow` array acts as a whitelist listing the import definitions that should
 
 The `depConstraints` section is the one you will be spending most time fine-tuning. It represents an array of constraints, each consisting of `sourceTag` and `onlyDependOnLibsWithTags` properties. The default configuration has a wildcard `*` set as a value for both of them, meaning that any project can import (depend on) any other project.
 
-> Note, the wildcard only applies to libraries. Applications and E2E applications cannot be imported. It wouldn't make any sense. If you want to combine applications, you should use the [micro-frontends](/recipes/angular/dynamic-module-federation-with-angular) approach with the module federation.
+> Note, the wildcard only applies to libraries. Applications and E2E applications cannot be imported. It wouldn't make any sense. If you want to combine applications, you should use the [micro-frontends](/technologies/angular/recipes/dynamic-module-federation-with-angular) approach with the module federation.
 
 The circular dependency chains such as `lib A -> lib B -> lib C -> lib A` are also not allowed. The self circular dependency (when lib imports from a named alias of itself), while not recommended, can be overridden by setting the flag `allowCircularSelfDependency` to true.
 

docs/blog/2021-12-23-single-file-monorepo-config-custom-workspace-presets-improved-tailwind-support-and-more-in-nx-13.md

@@ -65,7 +65,7 @@ Tailwind is a utility-first CSS framework packed with classes that can be compos
 nx g @nrwl/angular:app my-app --addTailwind
 ```
 
-Read more about Angular and Tailwind in our [docs](/nx-api/angular/generators/setup-tailwind).
+Read more about Angular and Tailwind in our [docs](/technologies/angular/api/generators/setup-tailwind).
 
 ### Other Highlights 🗒
 

docs/blog/2022-01-25-new-terminal-output-performance-improvements-in-nx-13-5.md

@@ -55,7 +55,7 @@ Thanks [Jason](https://twitter.com/FrozenPandaz) for working on this feature!
 ### React Native now supports Environment Variables
 
 Whenever you set up React Native support within an Nx workspace, it should now automatically come with the [react-native-config](https://github.com/luggit/react-native-config) package installed. That allows you to have a `.env` file in the React Native app folder which can then be loaded from within your React Native application.  
-You can find all the details on the [Nx docs](/recipes/react/react-native).
+You can find all the details on the [Nx docs](/technologies/react/recipes/react-native).
 
 Thanks [Emily Xiong](https://twitter.com/xiongemily) for implementing this!
 

docs/blog/2022-01-28-set-up-tailwind-css-with-angular-in-an-nx-workspace.md

@@ -317,7 +317,7 @@ At this point, if we serve again the application, everything should still be wor
 
 Similar to the previous section we are going to start by creating a new library to add the card component to. The only difference is that this library is going to be buildable.
 
-> If you are not aware of what buildable libraries are or what problem do they intend to solve, please make sure to read [/ci/incremental-builds](/recipes/angular/setup-incremental-builds-angular).
+> If you are not aware of what buildable libraries are or what problem do they intend to solve, please make sure to read [/technologies/angular/recipes/setup-incremental-builds-angular](/technologies/angular/recipes/setup-incremental-builds-angular).
 
 Run the following command to generate the library:
 
@@ -420,7 +420,7 @@ And finally, replace the existing markup for the cards in the `apps/app1/src/app
 
 With that in place, we can serve the application and it should be working exactly as before, but our application is still not fully set up to consume the library build output. As it stands right now, when the application that's consuming it is built, the library will be built together with it and its files will be processed as part of the application build pipeline.
 
-To finish the buildable library setup, we can follow the instructions in [/recipes/angular/setup-incremental-builds-angular](/recipes/angular/setup-incremental-builds-angular). We need to install the `@nrwl/web` package, change the application `build` target executor to `@nrwl/angular:webpack-browser`, and change the application `serve` target executor to `@nrwl/web:file-server`:
+To finish the buildable library setup, we can follow the instructions in [/technologies/angular/recipes/setup-incremental-builds-angular](/technologies/angular/recipes/setup-incremental-builds-angular). We need to install the `@nrwl/web` package, change the application `build` target executor to `@nrwl/angular:webpack-browser`, and change the application `serve` target executor to `@nrwl/web:file-server`:
 
 ```shell
 yarn add -D @nrwl/web@latest

docs/blog/2022-03-29-the-react-cli-you-always-wanted-but-didnt-know-about.md

@@ -129,7 +129,7 @@ Many of these generators come with a rich set of flags. For example, passing `--
 
 **How do we find all these generators though?** There are different options:
 
-- **Nx documentation** — use the search function there or just navigate the docs. All the reference pages are structured like `nx.dev/packages/<packagename>`. As an example for React that would look like: [/nx-api/react](/nx-api/react).
+- **Nx documentation** — use the search function there or just navigate the docs. All the reference pages are structured like `nx.dev/packages/<packagename>`. As an example for React that would look like: [/technologies/react/api](/technologies/react/api).
 - `npx nx list` - lists a set of installed plugins as well as other available plugins that can be installed. To get a list of generators for a specific plugin - say for the `@nrwl/react` plugin - run `npx nx list @nrwl/react`. Similarly, you can then run `npx nx g @nrwl/react:lib --help` to get help for a particular generator
 
 However, the absolute easiest way to explore the potential and even use Nx if you are not the "terminal type of person" is [Nx Console](https://marketplace.visualstudio.com/items?itemName=nrwl.angular-console)! I'll go a bit deeper into that in a later section.
@@ -152,7 +152,7 @@ Let's have a closer look.
 
 The Nx core team strongly believes in the benefits of TypeScript (in fact, check out the [new Nx and TypeScript setup](/getting-started/intro)). As such, by default every project is automatically set up and configured to use TypeScript, making sure builds, as well as IDEs, are able to properly pick up TypeScript definitions. All without you having to worry about it.
 
-Now, if you really want to use pure JavaScript you totally can. Just pass the `--js` when running a generator. Read [more on the docs](/recipes/tips-n-tricks/js-and-ts).
+Now, if you really want to use pure JavaScript you totally can. Just pass the `--js` when running a generator. Read [more on the docs](/technologies/typescript/recipes/js-and-ts).
 
 ## ESLint preconfigured!
 
@@ -273,7 +273,7 @@ One of the advantages of using Nx over — say CRA or a custom starter template
 
 Just to mention an example: when upgrading Nx to v13, all Nx users automatically got migrated to Webpack 5.
 
-This is possible with Nx's [migrate command](/nx-api/nx/documents/migrate) that allows you to keep up to date with your framework in a mostly automated fashion. Whenever you upgrade Nx, you run
+This is possible with Nx's [migrate command](/reference/core-api/nx/documents/migrate) that allows you to keep up to date with your framework in a mostly automated fashion. Whenever you upgrade Nx, you run
 
 ```shell
 npx nx migrate latest
@@ -346,7 +346,7 @@ Here's the `project.json` for our `happynrwl` React application. I clipped out t
 }
 ```
 
-As you can see, all these "targets" (`build`, `serve`,...) have a so-called `options` property that allows you to configure how the target behaves. The actual configuration is abstracted behind the "[Nx Executor](/concepts/executors-and-configurations)", in our case `@nrwl/web:webpack`. You can find the details of how to configure that on the Nx docs in the CLI reference for the `@nrwl/web` package: [/nx-api/webpack/executors/webpack](/nx-api/webpack/executors/webpack).
+As you can see, all these "targets" (`build`, `serve`,...) have a so-called `options` property that allows you to configure how the target behaves. The actual configuration is abstracted behind the "[Nx Executor](/concepts/executors-and-configurations)", in our case `@nrwl/web:webpack`. You can find the details of how to configure that on the Nx docs in the CLI reference for the `@nrwl/web` package: [/nx-api/webpack/executors/webpack](/technologies/build-tools/webpack/api/executors/webpack).
 
 To read more about how the `project.json`, its executors, and configuration options are structured, check out the official docs: [/reference/project-configuration](/reference/project-configuration).
 
@@ -356,8 +356,8 @@ Nx's extensibility and customizability have really no limits, allowing it to rea
 
 - [Custom workspace executors](/extending-nx/recipes/local-executors)
 - [Custom workspace generators](/extending-nx/recipes/local-generators)
-- [Create Nx plugins](/nx-api/plugin)
-- Control the entire workspace setup with [custom presets](/nx-api/plugin)
+- [Create Nx plugins](/reference/core-api/plugin)
+- Control the entire workspace setup with [custom presets](/reference/core-api/plugin)
 
 ## Q: Can I customize my Webpack config used to build my React app?
 

docs/blog/2022-04-08-what-is-new-in-nx-13-10.md

@@ -36,7 +36,7 @@ Nx can be used in a wide range of scenarios, from small open source projects, st
 - `@nrwl/*` plugins which are those actively maintained by the Nx core team
 - [Community plugins](/community)
 
-This illustration should give you a rough idea. obviously some of the plugins may be built on top of others, leveraging common functionality. An example is the [@nrwl/js](/nx-api/js) plugin which not only can be used as a standalone plugin but also builds the basis for of many others by providing core JavaScript/TypeScript features.
+This illustration should give you a rough idea. obviously some of the plugins may be built on top of others, leveraging common functionality. An example is the [@nrwl/js](/technologies/typescript/introduction) plugin which not only can be used as a standalone plugin but also builds the basis for of many others by providing core JavaScript/TypeScript features.
 
 ![](/blog/images/2022-04-08/iMPg692nMj5ty709M7tTQQ.avif)
 
@@ -206,7 +206,7 @@ If however you're curious, you can now append `--allPrompts` to get all possible
 npx create-nx-workspace@next myorg --allPrompts
 ```
 
-Alternatively you can browse the [API docs on the Nx website](/nx-api/nx/documents/create-nx-workspace) to find out more.
+Alternatively you can browse the [API docs on the Nx website](/reference/core-api/nx/documents/create-nx-workspace) to find out more.
 
 ## Deliver the best possible TypeScript experience with `@nrwl/js`
 
@@ -242,7 +242,7 @@ Learn more in this short video walkthrough:
 
 ## Our docs keep getting more and more awesome
 
-Besides delivering awesome features, we keep improving our docs. They are essential to help discover new features and better understand existing ones. In the last weeks we've improved the navigation support, allowing you to navigate to a specific package with `/packages/<package-name>` such as [/nx-api/react](/nx-api/react) listing executors and generators that come with that Nx package, also improving the API docs of the individual executor options including a live embedded editor playground to experiment with different configuration setup.
+Besides delivering awesome features, we keep improving our docs. They are essential to help discover new features and better understand existing ones. In the last weeks we've improved the navigation support, allowing you to navigate to a specific package with `/packages/<package-name>` such as [/technologies/react/api](/technologies/react/api) listing executors and generators that come with that Nx package, also improving the API docs of the individual executor options including a live embedded editor playground to experiment with different configuration setup.
 
 Check out Benjamin Cabanes' tweet with some short videos:
 

docs/blog/2022-05-02-nx-v14-is-out-here-is-all-you-need-to-know.md

@@ -74,7 +74,7 @@ Also see this example repository with some more information: [https://github.com
 
 ## Simplifying Nx
 
-Nx follows a modular plugin architecture. There is the core part of Nx which has the main logic around managing the project graph, computation caching, hashing and more. On top of that we have a series of Nx provided plugins for some of the most common frameworks and libraries out there, like [TypeScript/Javascript](/nx-api/js), [Angular](/nx-api/angular), [React](/nx-api/react) & [React Native](/nx-api/react-native), [Next.js](/nx-api/next), [Nest.js](/nx-api/nest), [Node](/nx-api/node) and many more, not to forget about [all the community plugins](/community). We also have a [labs project section](https://github.com/nrwl/nx-labs) which is our incubator for potentially new, natively supported Nx plugins.
+Nx follows a modular plugin architecture. There is the core part of Nx which has the main logic around managing the project graph, computation caching, hashing and more. On top of that we have a series of Nx provided plugins for some of the most common frameworks and libraries out there, like [TypeScript/Javascript](/technologies/typescript/introduction), [Angular](/technologies/angular/introduction), [React](/technologies/react/introduction) & [React Native](/technologies/react/react-native/introduction), [Next.js](/technologies/react/next/introduction), [Nest.js](/technologies/node/nest/introduction), [Node](/technologies/node/introduction) and many more, not to forget about [all the community plugins](/community). We also have a [labs project section](https://github.com/nrwl/nx-labs) which is our incubator for potentially new, natively supported Nx plugins.
 
 This modular structure allows you to just use [Nx core without plugins](/getting-started/intro). An ideal approach if you want to add Nx to an [existing Lerna/Yarn/NPM/PNPM workspace](/recipes/adopting-nx/adding-to-monorepo). With v14 we made it even simpler s.t. now you only have a single `nx` package in your dependencies with the core setup.
 
@@ -197,14 +197,14 @@ This can be a game-changer when building huge apps. Stay tuned for more content
 
 We recommend this approach if you want to speed up local serve and build times, but you still deploy the application as a whole.
 
-Read more in our docs: [/concepts/module-federation/faster-builds-with-module-federation](/concepts/module-federation/faster-builds-with-module-federation)
+Read more in our docs: [/technologies/module-federation/concepts/faster-builds-with-module-federation](/technologies/module-federation/concepts/faster-builds-with-module-federation)
 
 ## Micro Frontend Architecture with Nx
 
 As mentioned in the previous section, Nx v14 comes with out-of-the-box for Webpack Module Federation. The Micro Frontend architecture builds on top of that and adds the ability for independent deployability. While Module Federation enables faster builds by vertically slicing your application into smaller ones, the MFE architecture layers _independent deployments_  
 on top of federation. Teams should only choose MFEs if they want to deploy their host and remotes on different cadences.
 
-Read more in our docs: [/concepts/module-federation/micro-frontend-architecture](/concepts/module-federation/micro-frontend-architecture)
+Read more in our docs: [/technologies/module-federation/concepts/micro-frontend-architecture](/technologies/module-federation/concepts/micro-frontend-architecture)
 
 ## Dark mode for Project Graph as well as path tracking
 
@@ -250,7 +250,7 @@ Nx v14 ships with React 18 support for React DOM and React Native. The latter ha
 
 In addition to that, Expo and Expo Application Service support has been added which has lead already to some drastic speed improvements with some of our clients.
 
-Finally, it is the first version which ships the built-in module federation support for React as we've mentioned a couple of sections above. Check out the React package docs page and search for the `host` and `remote` generator: [/nx-api/react](/nx-api/react)
+Finally, it is the first version which ships the built-in module federation support for React as we've mentioned a couple of sections above. Check out the React package docs page and search for the `host` and `remote` generator: [/technologies/react/api](/technologies/react/api)
 
 ## Angular
 
@@ -258,7 +258,7 @@ There have been a lot of highlights for the Nx Angular plugin since v13. Here ar
 
 - Support and migrations for Angular 13 (Angular v14 coming soon. We will release that as a minor upgrade in Nx once the Angular team releases v14)
 - Tailwind CSS support (generators, added support to library executors). Read [our blog detailed post](/blog/set-up-tailwind-css-with-angular-in-an-nx-workspace).
-- Single Component Application Modules (SCAM) generators for components, directives and pipes ([see our docs](/nx-api/angular))
+- Single Component Application Modules (SCAM) generators for components, directives and pipes ([see our docs](/technologies/angular/api))
 - Improved Angular CLI to Nx migration support. We invested quite some time refactoring our current migration support from the Angular CLI which not only will allow us to implement more migration scenarios in the future but it also provides better error messages and hints during the migration process. This also allowed us to add support for multi-project Angular CLI workspaces which can now be seamlessly migrated. Multi-application Angular CLI workspace support will be added soon.
 
 Finally, similar to React also Angular gets built-in support for Webpack Module federation and hence also Microfrontends within Nx. See the sections about Module Federation and Microservices for more info and links to the docs.

docs/blog/2022-08-02-nx-14-5-cypess-v10-output-globs-linter-perf-react-tailwind-support.md

@@ -37,7 +37,7 @@ You can also append the `--generate-tests` to automatically generate Cypress com
 nx g @nrwl/react:cypress-component-configuration --project=my-react-project --generate-tests
 ```
 
-Check out our [generator docs](/nx-api/react/generators/cypress-component-configuration) for more info.
+Check out our [generator docs](/technologies/react/api/generators/cypress-component-configuration) for more info.
 
 {% youtube src="https://youtu.be/QDWN4C7T-Ck" /%}
 

docs/blog/2022-10-14-whats-new-in-nx-15.md

@@ -215,7 +215,7 @@ Cypress v10 also comes with [Component Testing](https://docs.cypress.io/guides/c
 npx nx g @nrwl/react:cypress-component-configuration --project=your-projectnpx nx g @nrwl/angular:cypress-component-configuration --project=your-project
 ```
 
-Read more here: [/recipes/cypress/cypress-component-testing](/recipes/cypress/cypress-component-testing)
+Read more here: [/technologies/test-tools/cypress/recipes/cypress-component-testing](/technologies/test-tools/cypress/recipes/cypress-component-testing)
 
 ## Angular: Improved Angular CLI Migrations and Standalone Components
 
@@ -223,7 +223,7 @@ We landed generators to support Angular developers in leveraging the new standal
 
 {% tweet url="https://twitter.com/NxDevTools/status/1567513106380894215" /%}
 
-In addition, we improved the migration support for moving projects from the Angular CLI to an Nx workspace. Whether for a single Angular CLI project or to consolidate multiple Angular CLI projects into a single Nx workspace. Please read all about it here: [/recipes/angular/migration/angular](/recipes/angular/migration/angular)
+In addition, we improved the migration support for moving projects from the Angular CLI to an Nx workspace. Whether for a single Angular CLI project or to consolidate multiple Angular CLI projects into a single Nx workspace. Please read all about it here: [/technologies/angular/migration/angular](/technologies/angular/migration/angular)
 
 ## Easily add Nx to an existing repository
 

docs/blog/2022-12-06-nx-15-3-standalone-projects-vite-task-graph-and-more.md

@@ -198,9 +198,9 @@ If you are currently using the NxExt based Vite plugin, or even a Webpack based
 npx nx g @nrwl/vite:configuration
 ```
 
-This will adjust the NxExt Vite plugin configuration to match the one provided by our core team. Check out our docs for more info: [/nx-api/vite/generators/configuration](/nx-api/vite/generators/configuration)
+This will adjust the NxExt Vite plugin configuration to match the one provided by our core team. Check out our docs for more info: [/technologies/build-tools/vite/generators/configuration](/technologies/build-tools/vite/api/generators/configuration)
 
-You can also find all the details about the new Vite package in our docs: [/nx-api/vite](/nx-api/vite)
+You can also find all the details about the new Vite package in our docs: [/technologies/build-tools/vite/introduction](/technologies/build-tools/vite/introduction)
 
 ## Adopting Nx has never been easier
 
@@ -227,7 +227,7 @@ Check out our docs for all the details on
 - [adding Nx to an existing monorepo](/recipes/adopting-nx/adding-to-monorepo)
 - [adding Nx to any non-monorepo setup](/recipes/adopting-nx/adding-to-existing-project)
 - [migrating your CRA project to Nx](/recipes/adopting-nx/adding-to-existing-project)
-- [migrating your Angular CLI app to Nx](/recipes/angular/migration/angular)
+- [migrating your Angular CLI app to Nx](/technologies/angular/migration/angular)
 
 Oh..you're wondering why you would want to add Nx to an existing non-monorepo project? Then keep reading 👇
 

docs/blog/2022-12-22-nx-15-4-vite-4-support-a-new-nx-watch-command-and-more.md

@@ -30,17 +30,17 @@ Nx 15.4 brings in the latest Vite major version following the Vite 4 release ear
 
 As the [Vite launch article](https://vitejs.dev/blog/announcing-vite4.html) mentions, we are investing in the Vite ecosystem, and now officially support a first-party Vite plugin. Nx 15.4 continues this investment with timely support for Vite 4, and we're excited to be a part of the Vite ecosystem and a part of bringing more value to our devs through Vite support!
 
-Projects already using our [@nrwl/vite plugin](/nx-api/vite) will be automatically upgraded to Vite 4 when they upgrade to the latest Nx version with the `nx migrate` command, and we've also simplified the configuration required to support Vite.
+Projects already using our [@nrwl/vite plugin](/technologies/build-tools/vite/introduction) will be automatically upgraded to Vite 4 when they upgrade to the latest Nx version with the `nx migrate` command, and we've also simplified the configuration required to support Vite.
 
 We've also spent some effort into making the conversion of existing projects to use Vite simpler, including:
 
 - the ability to choose which targets you want to convert
 - enhanced `vite.config.ts` file configuration
 - better DX with detailed messages during conversion
-- [better documentation around converting using our generator](/nx-api/vite/generators/configuration)
-- [adding a guide to our docs for converting manually](/recipes/vite/configure-vite)
+- [better documentation around converting using our generator](/technologies/build-tools/vite/api/generators/configuration)
+- [adding a guide to our docs for converting manually](/technologies/build-tools/vite/recipes/configure-vite)
 
-You can check out more details about our Vite plugin including how to add Vite and Vitest to your existing Nx workspace by visiting our docs at [nx.dev/nx-api/vite](/nx-api/vite)
+You can check out more details about our Vite plugin including how to add Vite and Vitest to your existing Nx workspace by visiting our docs at [nx.dev/technologies/build-tools/vite/introduction](/technologies/build-tools/vite/introduction)
 
 ## Nx Watch
 
@@ -96,7 +96,7 @@ Our existing `host` and `remote` Module Federation generators have an added `--s
 
 We've also added a new executor to allow you to serve the host server locally, along with all remote servers from a single command.
 
-Learn more about this new feature [in our docs](/recipes/react/module-federation-with-ssr)!
+Learn more about this new feature [in our docs](/technologies/react/recipes/module-federation-with-ssr)!
 
 ## Running Multiple Targets in Parallel for Multiple Projects
 

docs/blog/2023-01-10-setting-up-module-federation-with-server-side-rendering-for-angular.md

@@ -13,7 +13,7 @@ This technology has enabled a much cleaner approach to Micro Frontend Architectu
 
 Nx offers great out-of-the-box support and developer experience for Module Federation for Angular and React. You can learn more about it from the resources below:
 
-📄 [Module Federation Recipes on Nx](/recipes/module-federation)  
+📄 [Module Federation Recipes on Nx](/technologies/module-federation/recipes)
 📺 [Speed up your Angular serve and build times with Module Federation and Nx](https://www.youtube.com/watch?v=JkcaGzhRjkc)
 
 However, until now, it has only supported Client-Side Rendering (CSR). Essentially it worked only for Single Page Applications (SPAs). While this is still valuable, it is becoming ever more apparent that Server-Side Rendering (SSR) is becoming the de-facto standard for building web applications, due to the multitude of benefits it provides.
@@ -56,7 +56,7 @@ Answer with the following:
 
 When your workspace is created, run `cd myorg`.
 
-Next, we will need to install the [Official Nx Angular Plugin](/nx-api/angular):
+Next, we will need to install the [Official Nx Angular Plugin](/technologies/angular/introduction):
 
 ```
 npm install @nrwl/angular

docs/blog/2023-01-12-react-vite-and-typescript-get-started-in-under-2-minutes.md

@@ -200,7 +200,7 @@ This might look weird initially, but basically, we run the `e2e` target (see `e2
 
 By default, these tests run in headless mode, but you can pass `--watch` to run it interactively with the Cypress test runner such that the tests get re-executed whenever we change our source.
 
-> _Want Cypress Component testing? There's an Nx generator that can help set that up. Check out the docs:_ [_/nx-api/react/generators/cypress-component-configuration_](/nx-api/react/generators/cypress-component-configuration)
+> _Want Cypress Component testing? There's an Nx generator that can help set that up. Check out the docs:_ [_/nx-api/react/generators/cypress-component-configuration_](/technologies/react/api/generators/cypress-component-configuration)
 
 ## Linting
 

docs/blog/2023-02-16-nx-15-7-node-support-angular-lts-lockfile-pruning.md

@@ -88,7 +88,7 @@ $ nx migrate latest --from=nx@<version>
 
 In particular, we're working on making that part more intuitive in upcoming versions.
 
-Also, have a look at our [updated docs](/recipes/tips-n-tricks/advanced-update) as well as our [Nx and Angular compatibility matrix](/nx-api/angular/documents/angular-nx-version-matrix) for more details.
+Also, have a look at our [updated docs](/recipes/tips-n-tricks/advanced-update) as well as our [Nx and Angular compatibility matrix](/technologies/angular/recipes/angular-nx-version-matrix) for more details.
 
 ## Bootstrapping a new Angular app with Standalone API support
 
@@ -135,7 +135,7 @@ Stay tuned for a more in-depth blog post coming soon to [our blog](/blog).
 
 Nx provides support for Storybook version 7.0 beta, with generators and executors, so that you can try it out now, either in a new or in your existing Nx workspace. Storybook version 7 is a major release that brings a lot of new features and improvements. You can read more about it in the [Storybook 7 beta announcement blog post](https://storybook.js.org/blog/7-0-beta/). Apart from the new features and enhancements, it also brings some breaking changes. You can read more about them in the [Storybook 7 migration docs](https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#from-version-65x-to-700) and the [Storybook 7 migration guide](https://chromatic-ui.notion.site/Storybook-7-migration-guide-dbf41fa347304eb2a5e9c69b34503937). Do note that _version 7 is still in beta_, and so is the Nx support for it.
 
-You can try out Storybook 7.0 beta in a new Nx workspace by passing the `--storybook7betaConfiguration` flag when generating the Storybook configuration for your projects. Read more in our [Storybook 7 setup guide](/nx-api/storybook/documents/storybook-7-setup). If you want to migrate your existing Storybook configuration to Storybook 7.0 beta, please read our [migration guide](/nx-api/storybook/generators/migrate-7).
+You can try out Storybook 7.0 beta in a new Nx workspace by passing the `--storybook7betaConfiguration` flag when generating the Storybook configuration for your projects.
 
 ## More flexible Webpack config
 
@@ -147,11 +147,11 @@ Previously when you created a new React application with the Nx `@nrwl/react` pl
 
 It was for a good reason, but at the same time, it is a thin line to walk between giving more flexibility and ensuring integrity and consistency (not to speak about features such as [automated code migrations](/features/automate-updating-dependencies)). We wrote a [blog post about it last week](/blog/configuration-files-and-potholes-in-your-codebase).
 
-Inspired by our new [Vite setup](/nx-api/vite), which allows for a more modular configuration in the `vite.config.ts`, we wanted to bring some of the same flexibility to our Webpack setup as well. As such, now every Nx Webpack setup (e.g. a new React + Webpack based app) have a `webpack.config.js` in the project root. Old project are automatically migrated to this new setup.
+Inspired by our new [Vite setup](/technologies/build-tools/vite/introduction), which allows for a more modular configuration in the `vite.config.ts`, we wanted to bring some of the same flexibility to our Webpack setup as well. As such, now every Nx Webpack setup (e.g. a new React + Webpack based app) have a `webpack.config.js` in the project root. Old project are automatically migrated to this new setup.
 
 ![](/blog/images/2023-02-16/emRP2gF7umWc4UE-.avif)
 
-If you want to upgrade but still retain the previous behavior, we introduced an `isolatedConfig` mode that can be set to `false`. More details in our docs: [/recipes/webpack/webpack-config-setup](/recipes/webpack/webpack-config-setup)
+If you want to upgrade but still retain the previous behavior, we introduced an `isolatedConfig` mode that can be set to `false`. More details in our docs: [/technologies/build-tools/webpack/recipes/webpack-config-setup](/technologies/build-tools/webpack/recipes/webpack-config-setup)
 
 ## How to Update Nx
 

docs/blog/2023-03-02-expanding-nx-console-to-jetbrains-ides.md

@@ -203,7 +203,7 @@ host apps and libraries in any language. With the newly released [**_Encapsulate
 The codebase contains both Typescript code for the VSCode extension and Kotlin code for the IntelliJ plugin. Currently,
 all the Kotlin code resides in a single app. Targets defined in `project.json` are available that wrap different gradle
 tasks like running a development instance, building or formatting the plugin using the
-[`nx:run-commands`](/nx-api/nx/executors/run-commands) executor.  
+[`nx:run-commands`](/reference/core-api/nx/executors/run-commands) executor.  
 Since the plugin depends on artifacts provided by other Nx apps (namely the `nxls` and `generate-ui`), we have also
 created gradle tasks that call Nx to build these dependencies under the hood. This roundabout way of calling one tool
 from the other (and back again) could definitely be improved and we might look into having a more straightforward

docs/blog/2023-03-08-nx-15-8-rust-hasher-nx-console-for-intellij-deno-node-and-storybook.md

@@ -137,7 +137,7 @@ Read all the details [on our blog post](/blog/expanding-nx-console-to-jetbrains-
 
 {% youtube src="https://youtu.be/JJ12zKedwIs" /%}
 
-Nx Console has proven a highly valuable tool for exploring Nx generators. Especially if you cannot recall all the various parameters, you can possibly pass. And sure, you could always pass the `--help` or browse [the docs](/nx-api/react/generators/library), but it is just less convenient.
+Nx Console has proven a highly valuable tool for exploring Nx generators. Especially if you cannot recall all the various parameters, you can possibly pass. And sure, you could always pass the `--help` or browse [the docs](/technologies/react/api/generators/library), but it is just less convenient.
 
 ![](/blog/images/2023-03-08/xFSreZ1G_zifIsdf.avif)
 
@@ -164,7 +164,7 @@ Read all about it [in the doc about Customizing Generator Options](/extending-nx
 
 ## Modular Node Applications
 
-Nx has had Node backend support since the beginning, where you could add an [ExpressJS](/nx-api/express) or [Nest.js](/nx-api/nest) based application to your monorepo. This is a powerful approach as it allows you to colocate your frontend and backend code, which helps share code and, in particular, TypeScript types for your APIs!!
+Nx has had Node backend support since the beginning, where you could add an [ExpressJS](/technologies/node/express/introduction) or [Nest.js](/technologies/node/nest/introduction) based application to your monorepo. This is a powerful approach as it allows you to colocate your frontend and backend code, which helps share code and, in particular, TypeScript types for your APIs!!
 
 In [Nx 15.7](/blog/nx-15-7-node-support-angular-lts-lockfile-pruning), we then announced [Nx Standalone Projects](https://youtu.be/qEaVzh-oBBc) support for Node. This allows to develop a Node backend in isolation but still leverages all the features from Nx in terms of code generators, automated migrations, and speed features such as [affected commands](/ci/features/affected), [caching](/concepts/how-caching-works), and [optimized CI setups](/ci/features/distribute-task-execution).
 
@@ -180,7 +180,7 @@ Check out the following video walkthrough on using these features for modularizi
 
 ## Storybook
 
-Nx now generates stories using [Component Storybook Format 3 (CSF3)](https://storybook.js.org/blog/storybook-csf3-is-here/). If you are using our `@nrwl/react:storybook-configuration`, `@nrwl/angular:storybook-configuration`, `@nrwl/react:stories` and `@nrwl/angular:stories` generators, you will notice that the stories are now generated in the new format. You can check out our documentation for [Storybook and Angular](/recipes/storybook/overview-angular) or [Storybook and React](/recipes/storybook/overview-react) to see the new syntax.
+Nx now generates stories using [Component Storybook Format 3 (CSF3)](https://storybook.js.org/blog/storybook-csf3-is-here/). If you are using our `@nrwl/react:storybook-configuration`, `@nrwl/angular:storybook-configuration`, `@nrwl/react:stories` and `@nrwl/angular:stories` generators, you will notice that the stories are now generated in the new format. You can check out our documentation for [Storybook and Angular](/technologies/test-tools/storybook/recipes/overview-angular) or [Storybook and React](/technologies/test-tools/storybook/recipes/overview-react) to see the new syntax.
 
 As the Storybook doc mentions, CSF3 _reduces boilerplate code and improves ergonomics. This makes stories more concise, faster to write and easier to maintain._
 

docs/blog/2023-03-10-rspack-getting-up-to-speed-with-nx.md

@@ -70,11 +70,11 @@ This creates a new application in your Nx monorepo that uses Rspack as the bundl
 Go and learn more on the
 
 - official Rspack website: [https://rspack.dev](https://rspack.dev/)
-- learn about the Nx Rspack plugin: [/nx-api/rspack](/nx-api/rspack)
+- learn about the Nx Rspack plugin: [/technologies/build-tools/rspack/introduction](/technologies/build-tools/rspack/introduction)
 
 ## Learn more
 
-- 🦀 [Rspack and Nx docs](/nx-api/rspack)
+- 🦀 [Rspack and Nx docs](/technologies/build-tools/rspack/introduction)
 - 🧠 [Nx Docs](/getting-started/intro)
 - 👩‍💻 [Nx GitHub](https://github.com/nrwl/nx)
 - 💬 [Nx Official Discord Server](https://go.nx.dev/community)

docs/blog/2023-05-02-nx-16-is-here.md

@@ -13,7 +13,7 @@ We're proud to announce the release of Nx version 16! In this article, we'll go
 But before we jump into the new features of Nx 16, let's recap some of the recent features from our Nx 15 minor releases!
 
 - We introduced simpler presets for React, Angular, and [Node starter applications](https://youtu.be/K4f-fMuAoRY)
-- We added official support for [Vite](/nx-api/vite) and Vitest for integrated Nx monorepos
+- We added official support for [Vite](/technologies/build-tools/vite/introduction) and Vitest for integrated Nx monorepos
 - We introduced an [official Deno plugin](https://youtu.be/NpH8cFSp51E), including integration for Node and Deno project collocation and project graph support for Deno imports
 - We added Rust into the Nx codebase to speed up core functionality
 - We added support for [non-npm workspaces](https://youtu.be/QOhdL02f6BY) to support workspaces focused on other languages like C#, Java, and Kotlin, and saw some of those in action with community plugins for [.NET](https://www.nx-dotnet.com/) and [Java/Kotlin](https://github.com/tinesoft/nxrocks)
@@ -81,8 +81,8 @@ Nx has had support for developing Node-based backends for a while. It was a popu
 
 It’s all about **Edge functions** recently (and, well, serverless in general). Especially when developing with Node it is common that you might want to deploy to the Edge or some serverless environment. Therefore, we..
 
-- created a brand new `@nx/netlify` package (currently [in labs](https://github.com/nrwl/nx-labs/tree/main/packages/netlify)) which allows you to set up a brand new project for developing and pushing Netlify functions, or you can add serverless deployment support to an existing project, using the `@nx/netlify:setup-serverless` generator. Check out our in-depth recipe on the topic: [/recipes/node/node-serverless-functions-netlify](/recipes/node/node-serverless-functions-netlify)
-- published anew `@nx/aws-lambda` for deploying [Lambda functions](https://aws.amazon.com/lambda/) to AWS. All details in our latest recipe: [/recipes/node/node-aws-lambda](/recipes/node/node-aws-lambda)
+- created a brand new `@nx/netlify` package (currently [in labs](https://github.com/nrwl/nx-labs/tree/main/packages/netlify)) which allows you to set up a brand new project for developing and pushing Netlify functions, or you can add serverless deployment support to an existing project, using the `@nx/netlify:setup-serverless` generator. Check out our in-depth recipe on the topic: [/technologies/node/recipes/node-serverless-functions-netlify](/technologies/node/recipes/node-serverless-functions-netlify)
+- published anew `@nx/aws-lambda` for deploying [Lambda functions](https://aws.amazon.com/lambda/) to AWS. All details in our latest recipe: [/technologies/node/recipes/node-aws-lambda](/technologies/node/recipes/node-aws-lambda)
 - Improved our existing Deno package to add support for serverless deployment to both Deno Deploy as well as Netlify. Such support can be added to an existing app using the `@nx/deno:setup-serverless` generator and providing the `--platform` flag that either point to `deno-deploy` or `netlify`.
 
 ## Cypress Feature Testing

docs/blog/2023-05-26-determine-your-user-location-with-netlify-edge-functions.md

@@ -101,8 +101,8 @@ By following these steps, you've successfully used `@nx/netlify` serverless func
 
 ### Wrapping up
 
-Never used Nx before? Learn more about Nx [here](/getting-started/why-nx).  
-[Official recipe from Nx](/recipes/node/node-serverless-functions-netlify)  
+Never used Nx before? Learn more about Nx [here](/getting-started/intro).  
+[Official recipe from Nx](/technologies/node/recipes/node-serverless-functions-netlify)  
 [Github example](https://github.com/ndcunningham/nx-netlify-serverless)
 
 ### Learn more

docs/blog/2023-06-29-nx-console-gets-lit.md

@@ -274,7 +274,7 @@ Using it, you get the native look, a11y, and theme-aware styling for free! Thank
 
 One big upside of using a webview is the huge Javascript ecosystem is available to you! To make sure that no regressions are introduced later on, we use [Cypress](https://www.cypress.io/). We can mock the editor communication and provide different schemas, make sure the form is rendered correctly and the right messages are sent back to the IDE.
 
-While there's no particular Lit integration for Cypress, the tool itself is framework agnostic so it still works perfectly fine. Using the [`@nx/cypress`](/nx-api/cypress) executors did most of the work for us so setup was pretty quick too.
+While there's no particular Lit integration for Cypress, the tool itself is framework agnostic so it still works perfectly fine. Using the [`@nx/cypress`](/technologies/test-tools/cypress/introduction) executors did most of the work for us so setup was pretty quick too.
 
 ### Results: Comparing Performance
 
@@ -610,7 +610,7 @@ Using it, you get the native look, a11y, and theme-aware styling for free! Thank
 
 One big upside of using a webview is the huge Javascript ecosystem is available to you! To make sure that no regressions are introduced later on, we use [Cypress](https://www.cypress.io/). We can mock the editor communication and provide different schemas, make sure the form is rendered correctly and the right messages are sent back to the IDE.
 
-While there’s no particular Lit integration for Cypress, the tool itself is framework agnostic so it still works perfectly fine. Using the [`@nx/cypress`](/nx-api/cypress) executors did most of the work for us so setup was pretty quick too.
+While there’s no particular Lit integration for Cypress, the tool itself is framework agnostic so it still works perfectly fine. Using the [`@nx/cypress`](/technologies/test-tools/cypress/introduction) executors did most of the work for us so setup was pretty quick too.
 
 ### Results: Comparing Performance
 

docs/blog/2023-07-06-nx-16-5-release.md

@@ -19,13 +19,13 @@ Be sure to mark your calendars for our Nx 16.5 livestream as well! We'll highlig
 
 Our first major feature actually comes to us from the community. Nx has supported a tags property in your project.json file for awhile now — and it's main purpose has been to be used in conjuncture with the [Nx Module Boundary lint rule](/features/enforce-module-boundaries) to define which projects in your Nx workspace can depend on what — for example, you don't want your frontend applications to depend on any backend-specific code.
 
-With this new feature, you can add the `--tag` option to the [`nx affected`](/nx-api/nx/documents/affected) and [`nx run-many`](/nx-api/nx/documents/run-many) commands to specify to Nx to only run commands for projects that match the given tags.
+With this new feature, you can add the `--tag` option to the [`nx affected`](/reference/core-api/nx/documents/affected) and [`nx run-many`](/reference/core-api/nx/documents/run-many) commands to specify to Nx to only run commands for projects that match the given tags.
 
 {% youtube src="https://youtu.be/enQDQmFquGU" /%}
 
 ## NextJS 13 Support
 
-React Server Components and the new NextJS app router are here, and Nx is here to support them. We've added support for the latest versions of Next — complete with generators and executors. We've also made sure that our [`withNx` NextJS plugin](/recipes/next/next-config-setup), which allows you to import from your other projects in your workspace while still working with the NextJS build scripts, works both for workspaces using our executors in an Integrated Monorepo approach, as well as for those using a Package-Based approach that are simply using the `next dev` command directly to start their dev server.
+React Server Components and the new NextJS app router are here, and Nx is here to support them. We've added support for the latest versions of Next — complete with generators and executors. We've also made sure that our [`withNx` NextJS plugin](/technologies/react/next/recipes/next-config-setup), which allows you to import from your other projects in your workspace while still working with the NextJS build scripts, works both for workspaces using our executors in an Integrated Monorepo approach, as well as for those using a Package-Based approach that are simply using the `next dev` command directly to start their dev server.
 
 There's also built-in support for the new turbopack builder option via the `--turbo` command, for example: `nx serve webapp --turbo`
 
@@ -60,7 +60,7 @@ Angular is continuing their pattern of releasing new and exciting features — a
 
 As usual, we provide migrations to the most recent Angular version to cover your codebase for any breaking changes going to Angular 16.
 
-And in case you missed it, Nx is no longer tied to your Angular version — the most recent version of Nx will now always [support all currently LTS versions of Angular](/nx-api/angular/documents/angular-nx-version-matrix), meaning you DON'T have to upgrade your Angular version in order to get all these latest Nx Features. Be sure to use the `--interactive` flag to take advantage of this feature: `nx migrate latest --interactive`. You can find more details in [our docs for choosing optional packages to apply](/recipes/tips-n-tricks/advanced-update).
+And in case you missed it, Nx is no longer tied to your Angular version — the most recent version of Nx will now always [support all currently LTS versions of Angular](/technologies/angular/recipes/angular-nx-version-matrix), meaning you DON'T have to upgrade your Angular version in order to get all these latest Nx Features. Be sure to use the `--interactive` flag to take advantage of this feature: `nx migrate latest --interactive`. You can find more details in [our docs for choosing optional packages to apply](/recipes/tips-n-tricks/advanced-update).
 
 {% youtube src="https://youtu.be/AQV4WFldwlY" /%}
 

docs/blog/2023-07-26-evergreen-tooling-more-than-just-codemods.md

@@ -148,7 +148,7 @@ Nx’s modular design helps as each plugin is responsible for a particular area
 
 ![](/blog/images/2023-07-26/LNYWLmdgxQ07bqyt.avif)
 
-_(Source:_ [_/getting-started/why-nx_](/getting-started/why-nx)_)_
+_(Source:_ [_/getting-started/intro_](/getting-started/intro)_)_
 
 These plugins are usually technology-specific, like a plugin to help you manage React, Next, Remix, or Angular projects and tooling like ESLint, Cypress, Playwright, Vite, Jest, and so on. There are no limits as you can [create your own](/extending-nx/intro/getting-started). They are **optional**, in that you can use Nx and React and set everything up on your own. But it might be worth relying on them for some better DX and automation, such as the update mechanism we’re currently looking at.
 

docs/blog/2023-08-03-storybook-interaction-tests-in-nx.md

@@ -25,7 +25,7 @@ You write a story to set up the component's initial state, simulate user behavio
 
 ## Setting Up Storybook Interaction Tests on Nx
 
-You can read our detailed guide on how to set up Storybook interaction tests on Nx, here: [/recipes/storybook/storybook-interaction-tests](/recipes/storybook/storybook-interaction-tests).
+You can read our detailed guide on how to set up Storybook interaction tests on Nx, here: [/technologies/test-tools/storybook/recipes/storybook-interaction-tests](technologies/test-tools/storybook/recipes/storybook-interaction-tests).
 
 ## Writing Interaction Tests in Storybook
 
@@ -63,7 +63,7 @@ Moreover, since Storybook isolates each component, you can ensure that the tests
 ## Useful Links
 
 - [https://storybook.js.org/docs/react/writing-tests/interaction-testing](https://storybook.js.org/docs/react/writing-tests/interaction-testing)
-- [/recipes/storybook/storybook-interaction-tests](/recipes/storybook/storybook-interaction-tests)
+- [/technologies/test-tools/storybook/recipes/storybook-interaction-tests](technologies/test-tools/storybook/recipes/storybook-interaction-tests)
 
 ## Learn more
 

docs/blog/2023-08-10-create-your-own-create-react-app-cli.md

@@ -188,7 +188,7 @@ The preset generator does 2 things:
 ![](/blog/images/2023-08-10/38RvkLIwUAvVDDrEp5sFPQ.avif)
 _preset generator_
 
-The `addProjectConfiguration` and `generateFiles` functions are from [@nx/devkit](/nx-api/devkit/documents/nx_devkit), a library that contains utility functions for writing plugins for Nx. For the future, see the [complete list of utility functions](/nx-api/devkit/documents/nx_devkit).
+The `addProjectConfiguration` and `generateFiles` functions are from [@nx/devkit](/reference/core-api/devkit/documents/nx_devkit), a library that contains utility functions for writing plugins for Nx. For the future, see the [complete list of utility functions](/reference/core-api/devkit/documents/nx_devkit).
 
 1.  Change the project which is created with `addProjectConfiguration`:
 
@@ -311,7 +311,7 @@ And finally, another file to host the actual HTML template: `src/generators/pres
 </html>
 ```
 
-3\. Our application uses some npm dependencies so add those to the workspace as well with the [addDependenciesToPackageJson](/nx-api/devkit/documents/nx_devkit) function to the end of the export default function in `src/generators/preset/generator.ts`:
+3\. Our application uses some npm dependencies so add those to the workspace as well with the [addDependenciesToPackageJson](/reference/core-api/devkit/documents/nx_devkit) function to the end of the export default function in `src/generators/preset/generator.ts`:
 
 ```
 import {

docs/blog/2023-08-15-qwikify-your-dev.md

@@ -11,7 +11,7 @@ In the ever-evolving web development landscape, efficiency and modularity have b
 
 Qwik is a modern web framework that focuses on application performance by reducing the amount of JavaScript that needs to be shipped to the browser. You can learn more about how Qwik achieves this with [Resumability in their docs](https://qwik.dev/docs/concepts/resumable/).
 
-Nx is a powerful tool that helps you build extensible and maintainable codebases that scale as your application and team grows. Nx utilises computation cache and workspace analysis to ensure maximum efficiency and developer experience. You can [learn more about Nx here](/getting-started/why-nx).
+Nx is a powerful tool that helps you build extensible and maintainable codebases that scale as your application and team grows. Nx utilises computation cache and workspace analysis to ensure maximum efficiency and developer experience. You can [learn more about Nx here](/getting-started/intro).
 
 In this blog post, we'll explore how to combine the strengths of Nx and Qwik to create a todo app. To do this, we'll take advantage of an Nx Plugin that was created by the Qwikifiers team to maximise the integration between Qwik and Nx, called [`qwik-nx`](https://github.com/qwikifiers/qwik-nx).
 

docs/blog/2023-08-24-step-by-step-guide-to-creating-an-expo-monorepo-with-nx.md

@@ -294,7 +294,7 @@ If you want to create a build locally using your own infrastructure:
 npx nx build cats --local
 ```
 
-Here is the complete list of flags for the build command: [/nx-api/expo/executors/build](/nx-api/expo/executors/build).
+Here is the complete list of flags for the build command: [/technologies/react/expo/executors/build](/technologies/react/expo/api/executors/build).
 
 ## Submit to the App Store
 

docs/blog/2023-09-06-nx-16-8-release.md

@@ -282,7 +282,7 @@ Towards the start of the year, we added support for Nx standalone applications.
 
 Ever since we introduced these, we've had requests from the community to add a generator to convert your standalone workspace to a monorepo setup — to support repos that grew to emcompass more than just the 1 application.
 
-This is where our new [`convert-to-monorepo` generator](/nx-api/workspace/generators/convert-to-monorepo) comes into play!
+This is where our new [`convert-to-monorepo` generator](/reference/core-api/workspace/generators/convert-to-monorepo) comes into play!
 
 ```shell
 nx g convert-to-monorepo
@@ -332,7 +332,7 @@ You can find all of the examples and more on our "Showcase" section: [/showcase]
 
 ESLint has announced a new config system — nicknamed "flat config" — whose intent is to be be familiar and much simpler than the current config system. You can read more about this [in their blog post](https://eslint.org/blog/2022/08/new-config-system-part-2/).
 
-As part of our continued support for ESLint, we've introduced [a new generator](/nx-api/eslint/generators/convert-to-flat-config) to convert your Nx monorepo to this new system:
+As part of our continued support for ESLint, we've introduced [a new generator](/technologies/eslint/api/generators/convert-to-flat-config) to convert your Nx monorepo to this new system:
 
 ```
 > nx g convert-to-flat-config

docs/blog/2023-09-18-introducing-playwright-support-for-nx.md

@@ -300,7 +300,7 @@ In this blog, we have:
 - Used Nx to run Playwright tests
 - Set up a Playwright configuration for an existing Nx app
 
-Hopefully, this gives you good insight into how to get started with Playwright. The Playwright configuration in this example is pretty simple, to learn more about `@nx/playwright` plugin, check out the Nx documentation: [/nx-api/playwright](/nx-api/playwright).
+Hopefully, this gives you good insight into how to get started with Playwright. The Playwright configuration in this example is pretty simple, to learn more about `@nx/playwright` plugin, check out the Nx documentation: [/technologies/test-tools/playwright/introduction](/technologies/test-tools/playwright/introduction).
 
 ## Learn more
 

docs/blog/2023-10-13-nx-conf-2023-recap.md

@@ -17,7 +17,7 @@ The 3rd edition of [Nx Conf](/conf), this year live from New York City. If you m
 
 {% youtube src="https://www.youtube.com/watch?v=WSqivWlEDFw" /%}
 
-Juri Strumpflohner (me 😅) opens the keynote. He focuses on the Nx ecosystem, how it is [much more than monorepos](/getting-started/why-nx) by helping you integrate your framework of choice (whether that is Angular, React, or Vue) with tooling such as ESLint, Playwright, Cypress, Webpack, ESBuild, Vite etc.
+Juri Strumpflohner (me 😅) opens the keynote. He focuses on the Nx ecosystem, how it is [much more than monorepos](/getting-started/intro) by helping you integrate your framework of choice (whether that is Angular, React, or Vue) with tooling such as ESLint, Playwright, Cypress, Webpack, ESBuild, Vite etc.
 
 ![](/blog/images/2023-10-13/bodyimg1.webp)
 

docs/blog/2023-10-20-nx-17-release.md

@@ -226,7 +226,7 @@ In Nx 17, we removed any remaining traces of `tslint` from our linter package, s
 
 As we solidify this command, we intend to bring robust support for various versioning and publishing strategies, as well as built-in support for publishing packages or modules to a variety of languages, registries, and platforms.
 
-For more [checkout our API docs](/nx-api/nx/documents/release), and be sure to catch James Henry's announcement of this new command at [Nx Conf](/blog/nx-conf-2023-recap):
+For more [checkout our API docs](/reference/core-api/nx/documents/release), and be sure to catch James Henry's announcement of this new command at [Nx Conf](/blog/nx-conf-2023-recap):
 
 {% youtube src="https://www.youtube.com/embed/p5qW5-2nKqI?si=FzpGMJwPVINc1hgL" /%}
 
@@ -234,7 +234,7 @@ For more [checkout our API docs](/nx-api/nx/documents/release), and be sure to c
 
 At Nx, we're OBSESSED with building a better, more robust experience for our developers. Towards this end, we're now in [v2 of our Project Inference API](/extending-nx/recipes/project-graph-plugins).
 
-This API is a way of extending the Nx project graph, which can be particularly helpful for extending Nx to support other languages, allowing Nx to determine where to find and draw boundaries around projects in your workspace. A great example is our very own [Vue plugin](/nx-api/vue).
+This API is a way of extending the Nx project graph, which can be particularly helpful for extending Nx to support other languages, allowing Nx to determine where to find and draw boundaries around projects in your workspace. A great example is our very own [Vue plugin](/technologies/vue/introduction).
 
 Interestingly, v2 includes support for dynamic targets as well. This opens up exciting new doors to reducing configuration, and we hope to expand on this to better support our first-party plugins in the near future.
 

docs/blog/2023-11-08-state-management.md

@@ -706,8 +706,8 @@ Here is a simple app that uses TanStack Query and Redux for state management. Th
 Nx is a powerful monorepo tool. Together with Nx and these 2 state management tools, it will be very easy to scale up any app.
 
 - TanStack Query site: [https://tanstack.com/query/latest](https://tanstack.com/query/latest)
-- Official @nx/expo plugin: [/nx-api/expo](/nx-api/expo)
-- Official @nx/react-native plugin: [/nx-api/react-native](/nx-api/react-native)
+- Official @nx/expo plugin: [/technologies/react/expo/introduction](/technologies/react/expo/introduction)
+- Official @nx/react-native plugin: [/technologies/react/react-native/introduction](/technologies/react/react-native/introduction)
 
 ---
 

docs/blog/2023-12-20-nx-17-2-release.md

@@ -15,7 +15,7 @@ It's been a bit since we launched [Nx 17](/blog/nx-17-release)! In this article,
 - [Module Federation Updates](#module-federation-updates)
 - [Nx Release Updates](#nx-release-updates)
 - [Angular 17 (AND NgRx 17) Support](#angular-17-and-ngrx-17-support)
-- [Smart Monorepos — Fast CI](#smart-monorepos-fast-ci)
+- [Smart Repos — Fast Builds](#smart-repos-fast-builds)
 - [New Canary Releases](#new-canary-releases)
 - [Upcoming Release Livestream](#upcoming-release-livestream)
 - [Automatically Update Nx](#automatically-update-nx)
@@ -139,7 +139,7 @@ nx migrate latest --interactive
    - Run 'nx migrate --run-migrations'
 ```
 
-## Smart Monorepos — Fast CI
+## Smart Repos — Fast Builds
 
 We just gave our Nx homepage a small facelift, including a new tagline, subtagline and illustration to better reflect Nx's mission statement.
 

docs/blog/2023-12-28-highlights-2023.md

@@ -25,7 +25,7 @@ It is that time again: getting flooded by Year of Review blog posts. We did it l
 - [Many OSS repos adopt Nx](#many-oss-repos-adopt-nx)
 - [Nx Community](#nx-community)
 - [New Content & Improved Docs](#new-content-improved-docs)
-- [New Tagline: Smart Monorepos — Fast CI](#new-tagline-smart-monorepos-fast-ci)
+- [New Tagline: Smart Repos — Fast Builds](#new-tagline-smart-repos-fast-builds)
 - [Nx Conf](#nx-conf)
 - [Looking ahead — 2024](#looking-ahead-2024)
   - [Solving CI](#solving-ci)
@@ -57,7 +57,7 @@ Our collaboration with our friends in the Vite core team has been incredibly fru
 
 ![](/blog/images/2023-12-28/bodyimg1.webp)
 
-We also built some powerful code generators that not only facilitate a seamless [transition from Webpack to Vite](/nx-api/vite/generators/configuration#nxviteconfiguration) but also pave the way for an effortless [migration from a CRA-based setup](/recipes/adopting-nx/adding-to-existing-project) to a modern Nx + Vite based workspace. To see this process in action, [check out this short video](https://www.youtube.com/watch?v=zvYb7XCLQzU).
+We also built some powerful code generators that not only facilitate a seamless [transition from Webpack to Vite](/technologies/build-tools/vite/api/generators/configuration#nxviteconfiguration) but also pave the way for an effortless [migration from a CRA-based setup](/recipes/adopting-nx/adding-to-existing-project) to a modern Nx + Vite based workspace. To see this process in action, [check out this short video](https://www.youtube.com/watch?v=zvYb7XCLQzU).
 
 [AnalogJS](https://analogjs.org/) — the fullstack Angular meta-framework which also heavily builds on top of Vite — is using the `@nx/vite` plugin to power its Angular and Nx based workspaces.
 
@@ -220,7 +220,7 @@ And you'll then have access to Nx generators so you can create Vue applications,
 
 ![](/blog/images/2023-12-28/bodyimg6.gif)
 
-Checkout out our [Vue API docs](/nx-api/vue), and stay tuned as Nx prepares to offer more Vue support (including support for [Nuxt](https://nuxt.com/), a full-stack framework built around Vue) in the near future!
+Checkout out our [Vue docs](/technologies/vue/introduction), and stay tuned as Nx prepares to offer more Vue support (including support for [Nuxt](https://nuxt.com/), a full-stack framework built around Vue) in the near future!
 
 ### Extending Nx: Local Generators, Build your Own CLI, Verdaccio Support
 
@@ -252,7 +252,7 @@ Simply put, Module Federation allows a Javascript application running in a brows
 
 This is an exciting development as it allows a paradigm shift in how you can architect, build, and deploy Javascript applications! And this is especially exciting for monorepo fans, as Nx has best-in-class support for module federation that makes a Module Federation approach easy to adopt and simple to understand!
 
-Currently, our `@nx/angular` and `@nx/react` plugins both have generators to [create a "host" application](/recipes/module-federation/create-a-host) that will load and consume federated modules from ["remote" applications](/recipes/module-federation/create-a-remote), which you can also generate using Nx. Then, by running a simple command with Nx, you can serve all applications required for your host application with the command:
+Currently, our `@nx/angular` and `@nx/react` plugins both have generators to [create a "host" application](/technologies/module-federation/recipes/create-a-host) that will load and consume federated modules from ["remote" applications](/technologies/module-federation/recipes/create-a-remote), which you can also generate using Nx. Then, by running a simple command with Nx, you can serve all applications required for your host application with the command:
 
 ```shell
 nx serve host-application --devRemotes=remote-application
@@ -260,9 +260,9 @@ nx serve host-application --devRemotes=remote-application
 
 Where in the example above your host application is named "host-application" and a remote application that you want live updates on as you're developing is named "remote-application".
 
-Throughout 2023, we've continued to increase Nx's support and general dev experience around Module Federation, including [adding a generator to federate an existing module](/recipes/module-federation/federate-a-module), improving the local developer experience by improving local webserver performance, and introducing the concept of [Dynamic Module Federation](/recipes/angular/dynamic-module-federation-with-angular#advanced-angular-micro-frontends-with-dynamic-module-federation) which will allow you to dynamically specify the location of your remote applications via a "module-federation.manifest.json" file!
+Throughout 2023, we've continued to increase Nx's support and general dev experience around Module Federation, including [adding a generator to federate an existing module](/technologies/module-federation/recipes/federate-a-module), improving the local developer experience by improving local webserver performance, and introducing the concept of [Dynamic Module Federation](/technologies/angular/recipes/dynamic-module-federation-with-angular#advanced-angular-micro-frontends-with-dynamic-module-federation) which will allow you to dynamically specify the location of your remote applications via a "module-federation.manifest.json" file!
 
-At Nx, we're excited about the Module Federation support we offer for our users, and think that it has many interesting applications when paired with Nx's CI capabilities, in particular allowing for [much shorter build times](/concepts/module-federation/faster-builds-with-module-federation) especially for larger Angular applications.
+At Nx, we're excited about the Module Federation support we offer for our users, and think that it has many interesting applications when paired with Nx's CI capabilities, in particular allowing for [much shorter build times](/technologies/module-federation/concepts/faster-builds-with-module-federation) especially for larger Angular applications.
 
 ## Many OSS repos adopt Nx
 
@@ -316,9 +316,9 @@ We also poured a lot of [effort into the docs](/getting-started/intro). We restr
 - [**Concept docs**](/concepts) — which explain some of the inner workings and mental model behind certain features. Like [how caching works](/concepts/how-caching-works).
 - [**Recipes**](/recipes) — which are solution oriented. You already know how to cook, we provide the exact recipe for it.
 - [**Tutorials**](/getting-started/tutorials) — for when you just want to sit down and follow along, step by step to learn how to use Nx in a certain context.
-- [**Reference**](/reference) and [**API docs**](/nx-api) — pure, raw and to the point.
+- [**Reference**](/reference) and [**API docs**](/reference/core-api) — pure, raw and to the point.
 
-We created a brand new ["Why Nx"](/getting-started/why-nx) page explaining the overall architecture of Nx including a [brand new video](https://www.youtube.com/watch?v=-_4WMl-Fn0w) giving you a holistic overview of what Nx is capable of.
+We created a brand new ["Why Nx"](/getting-started/intro) page explaining the overall architecture of Nx including a [brand new video](https://www.youtube.com/watch?v=-_4WMl-Fn0w) giving you a holistic overview of what Nx is capable of.
 
 We also refreshed our [entry pages](/getting-started/intro), including dedicated examples of using Nx with popular stacks:
 
@@ -330,11 +330,11 @@ You can also browse them in the [nx-recipes](https://github.com/nrwl/nx-recipes)
 
 And obviously, we jumped on the AI train as well. A couple of months ago, we added the [Nx Assistant](/ai-chat). A ChatGPT-powered interface trained in our docs. [Katerina](https://twitter.com/psybercity) wrote about it [on our blog](/blog/nx-docs-ai-assistant). The AI chat allows to interactively ask questions about Nx and will give you relevant answers from our docs (including linking to the sources).
 
-## New Tagline: Smart Monorepos — Fast CI
+## New Tagline: Smart Repos — Fast Builds
 
 Nx stands out for its flexibility, accommodating for both monorepo and non-monorepo project structures. This approach allows users to begin with simpler project configurations, leveraging the benefits of Nx's robust tooling, and later, when the need arises, seamlessly [migrate to a monorepo](/recipes/tips-n-tricks/standalone-to-monorepo).
 
-However, Nx's true strength becomes most apparent at scale, typically within a monorepo setup. We wanted to capture it in our new tagline: **Smart Monorepos — Fast CI**.
+However, Nx's true strength becomes most apparent at scale, typically within a monorepo setup. We wanted to capture it in our new tagline: **Smart Repos — Fast Builds**.
 
 {% tweet url="https://twitter.com/juristr/status/1734558895547568634" /%}
 

docs/blog/2024-02-07-fast-effortless-ci.md

@@ -18,7 +18,7 @@ In 2014, the state of the art for running tests and builds in your repository we
 
 Nx was created in 2017 to address this problem. Nx is a build system that operates on a **higher level** where developers define the relationships between tasks and then Nx to decides the optimal way to run those tasks. In the same way, developers can define the inputs and outputs of tasks, then Nx automatically caches those task results. Developers tell Nx what a task does and then Nx can decide how best to run that task.
 
-With [Nx Agents](/ci/features/distribute-task-execution), Nx is applying this same mindset to the problem of slow and costly CI pipelines. Nx gives you both **Smart Monorepos** and **Fast CI**.
+With [Nx Agents](/ci/features/distribute-task-execution), Nx is applying this same mindset to the problem of slow and costly CI pipelines. Nx gives you both **Smart Repos** and **Fast Builds**.
 
 ## Why is CI So Hard?
 

docs/blog/2024-05-08-nx-19-release.md

@@ -141,7 +141,7 @@ And after running the generator, you can expect your project detail view to look
 
 Notice that in addition to reducing the configuration in your `project.json` file, this generator will also turn on the Nx Atomizer for your Cypress and Playwright projects, so Nx will allow sharding for your end-to-end tasks in CI based on the tests present in your workspace going forward. Note that Nx Agents are very highly highly encouraged as a way of taking advantage of this sharding capability.
 
-As a note, if you cannot see `e2e-ci` tasks after converting your cypress projects, you can [take a closer look here](/nx-api/cypress/documents/overview#splitting-e2e-tasks-by-file) at how to configure them correctly.
+As a note, if you cannot see `e2e-ci` tasks after converting your cypress projects, you can [take a closer look here](/technologies/test-tools/cypress/introduction#splitting-e2e-tasks-by-file) at how to configure them correctly.
 
 ## BREAKING CHANGE: Updating Bundled Environment Variables: `NX_` to `NX_PUBLIC_`
 

docs/blog/2024-07-19-podcast-episode-2-tine-kondo.md

@@ -16,4 +16,4 @@ In this episode, welcome Nx Champion and Nx Expert, Tine Kondo. Our discussion h
 
 We touch on the difficulties larger organizations face when merging PRs in a timely manner, emphasizing how a monorepo alleviates the headache of coordinating multiple PRs across various repositories, and share firsthand experiences and frustrations with traditional multi-repo setups, underscoring the benefits of a unified approach.
 
-In particular, Nx's new plugin: [@nx/gradle](/nx-api/gradle) is of interest, and Tine provides some valuable insight on the impact this plugin can make, as well as the importance for Maven support.
+In particular, Nx's new plugin: [@nx/gradle](/technologies/java/introduction) is of interest, and Tine provides some valuable insight on the impact this plugin can make, as well as the importance for Maven support.

docs/blog/2024-08-01-nx-19-5-update.md

@@ -106,7 +106,7 @@ Note that the new, free [hobby tier for Nx Cloud](#new-nx-cloud-hobby-tier) incl
 
 ## Pattern Support for `targetDefaults`
 
-When using the [Atomizer features](/ci/features/split-e2e-tasks) of plugins like [`@nx/playwright`](/nx-api/playwright) and [`@nx/cypress`](/nx-api/cypress), you end up creating tasks with dynamic but predictable names.
+When using the [Atomizer features](/ci/features/split-e2e-tasks) of plugins like [`@nx/playwright`](/technologies/test-tools/playwright/introduction) and [`@nx/cypress`](/technologies/test-tools/cypress/introduction), you end up creating tasks with dynamic but predictable names.
 
 ![Tasks Created With Atomizer](/blog/images/2024-08-01/e2e-task-names.avif)
 
@@ -169,7 +169,7 @@ nx affected --targets=lint,test,build,e2e-ci
 
 In CI, Nx Agents will allow all tasks to run in parallel on the same machine, except for the atomized end-to-end tasks, which will only run in isolation.
 
-Learn more about how you can [Parallelize Tasks Across Multiple Machines Using Nx Agents](/ci/intro/tutorials/github-actions#parallelize-tasks-across-multiple-machines-using-nx-agents):
+Learn more about how you can [Parallelize Tasks Across Multiple Machines Using Nx Agents](/ci/features/split-e2e-tasks):
 
 {% youtube
 src="https://youtu.be/0YxcxIR7QU0"
@@ -178,7 +178,7 @@ width="100%" /%}
 
 ## Support For Incremental Builds For Vite
 
-Nx now supports incremental builds with our [`vite` plugin](/nx-api/vite). Incremental builds in Nx workspaces allow you to build any package in your workspace individually, and will then automatically use that built artifact when then building any project or application that consumes the package. This way you can speed up your build and CI times through optimizations like [only building packages that were affected](/nx-api/nx/documents/affected), using [Nx Replay](/ci/features/remote-cache) to effortlessly cache and share your built artifacts, and allowing you to run builds of your various packages in parallel using [Nx Agents](/ci/features/distribute-task-execution).
+Nx now supports incremental builds with our [`vite` plugin](/technologies/build-tools/vite/introduction). Incremental builds in Nx workspaces allow you to build any package in your workspace individually, and will then automatically use that built artifact when then building any project or application that consumes the package. This way you can speed up your build and CI times through optimizations like [only building packages that were affected](/reference/core-api/nx/documents/affected), using [Nx Replay](/ci/features/remote-cache) to effortlessly cache and share your built artifacts, and allowing you to run builds of your various packages in parallel using [Nx Agents](/ci/features/distribute-task-execution).
 
 Read more about [buildable libraries and incremental builds](/concepts/buildable-and-publishable-libraries).
 
@@ -194,11 +194,11 @@ npx nx g convert-to-inferred
 
 The important thing to note here is that while this generator will make adjustments to the `project.json` file of the projects you convert, the behavior of your tasks should remain the same. You can see project details via the [Nx Console](/getting-started/editor-setup) plugin of your IDE, or in a browser by running the command: `nx show project [projectName]`.
 
-In Nx 19, we were focused on adding `convert-to-inferred` to our [Playwright](/nx-api/playwright), [Cypress](/nx-api/cypress), and [ESLint](/nx-api/eslint) plugins - where bringing the [Nx Atomizer](/ci/features/split-e2e-tasks) provided the greatest value. Since then, we've added this generator to most other plugins. Currently, our React native plugins (react native, expo, detox) are the only plugins that are outstanding, and we'll be providing `convert-to-inferred` generators here in the near future.
+In Nx 19, we were focused on adding `convert-to-inferred` to our [Playwright](/technologies/test-tools/playwright/introduction), [Cypress](/technologies/test-tools/cypress/introduction), and [ESLint](/technologies/eslint/introduction) plugins - where bringing the [Nx Atomizer](/ci/features/split-e2e-tasks) provided the greatest value. Since then, we've added this generator to most other plugins. Currently, our React native plugins (react native, expo, detox) are the only plugins that are outstanding, and we'll be providing `convert-to-inferred` generators here in the near future.
 
 ## Gradle Composite Builds Support
 
-In [Nx 19.0](/blog/nx-19-release), we introduced support for Gradle through our [Gradle plugin](/nx-api/gradle). With the latest update, this plugin now also supports [Gradle Composite builds](https://docs.gradle.org/current/userguide/composite_builds.html), in addition to multi-project builds.
+In [Nx 19.0](/blog/nx-19-release), we introduced support for Gradle through our [Gradle plugin](/technologies/java/introduction). With the latest update, this plugin now also supports [Gradle Composite builds](https://docs.gradle.org/current/userguide/composite_builds.html), in addition to multi-project builds.
 
 Gradle Composite builds are commonly used in larger workspaces to manage dependencies across multiple projects. With this new support, Nx can now leverage composite builds to enhance the Nx Task Graph. For example, consider the following `settings.gradle.kts` file:
 
@@ -217,7 +217,7 @@ You can read more on composite builds in the [Gradle documentation](https://docs
 
 ## Experimental: Gradle Test Atomization
 
-The new [`@nx/gradle` plugin](/nx-api/gradle) now includes experimental support for [Test Atomization](/ci/features/split-e2e-tasks).
+The new [`@nx/gradle` plugin](/technologies/java/introduction) now includes experimental support for [Test Atomization](/ci/features/split-e2e-tasks).
 
 ![Gradle Atomized](/blog/images/2024-08-01/gradle-atomized.avif)
 
@@ -225,7 +225,7 @@ With Test Atomization, as you add tests to your Gradle projects, Nx will automat
 
 ## Experimental: Nx Release Adds File Based Versioning Support
 
-Currently with [Nx release](/nx-api/nx/documents/release), you already have two different ways of figuring out the how to modify the current version of a package to get its updated version:
+Currently with [Nx release](/reference/core-api/nx/documents/release), you already have two different ways of figuring out the how to modify the current version of a package to get its updated version:
 
 - Imperatively via the CLI/prompt by telling it your desired relative (semver keyword) or absolute (e.g. `1.2.3`) version.
 - Declaratively by letting Nx inspect your git history and determine the semver bump to apply based on the conventional commits specification.
@@ -259,9 +259,9 @@ Fetching @angular/core@18.1.2
  NX   The migrate command has run successfully.
 ```
 
-Our `@nx/react` package will now create new React applications using version 18.3, and we now support the new experimental `reactCompiler`. Users can install the [`babel-plugin-react-compiler` package](https://www.npmjs.com/package/babel-plugin-react-compiler) and you can follow [this guide for how to enable it with Nx](/recipes/react/react-compiler#react-compiler-with-nx).
+Our `@nx/react` package will now create new React applications using version 18.3, and we now support the new experimental `reactCompiler`. Users can install the [`babel-plugin-react-compiler` package](https://www.npmjs.com/package/babel-plugin-react-compiler) and you can follow [this guide for how to enable it with Nx](/technologies/react/recipes/react-compiler#react-compiler-with-nx).
 
-Note that due to the extent of breaking changes coming with React 19, we will not be providing a automated migration to React 19 via [`nx migrate`](/nx-api/nx/documents/migrate).
+Note that due to the extent of breaking changes coming with React 19, we will not be providing a automated migration to React 19 via [`nx migrate`](/reference/core-api/nx/documents/migrate).
 
 ## Automatically Update Nx
 

docs/blog/2024-09-12-next-gen-module-federation-deployments.md

@@ -81,7 +81,7 @@ Next, we'll want to navigate into our new workspace:
 cd myorg
 ```
 
-And finally, we'll add the [`@nx/react`](/nx-api/react) plugin to our workspace.
+And finally, we'll add the [`@nx/react`](/technologies/react/introduction) plugin to our workspace.
 
 ```shell
 npx nx add @nx/react
@@ -94,7 +94,7 @@ generator now to scaffold out Module Federation projects.
 
 {% callout type="note" title="Generating host applications" %}
 If you'd like a more indepth recipe for scaffolding `host` and `remote` generators you can take a look through
-our [Module Federation Recipes](/recipes/module-federation).
+our [Module Federation Recipes](/technologies/module-federation/recipes).
 {% /callout %}
 
 ```{% command="npx nx g @nx/react:host apps/shell --remotes=remote1 --bundler=rspack" path="~/myorg" %}
@@ -173,7 +173,7 @@ Nx itself has employed this strategy to solve a long-standing issue with shared
 the possibility that a shared library would be served from a static remote. This in turn would prevent HMR updates to
 the library from being reflected in the locally served application.
 You can learn more about the
-`NxRuntimeLibraryControlPlugin` [here](/concepts/module-federation/nx-module-federation-technical-overview).
+`NxRuntimeLibraryControlPlugin` [here](/technologies/module-federation/concepts/nx-module-federation-technical-overview).
 {% /callout %}
 
 ## Step 4: Building and Serving
@@ -203,7 +203,7 @@ Serving statically means that we can reuse the build artifacts for the `remotes`
 that is scalable. Combined with Nx caching, this works well to ensure a great developer experience.
 
 You can learn more about how this works in
-our [Nx Module Federation Technical Overview](/concepts/module-federation/nx-module-federation-technical-overview#what-happens-when-you-serve-your-host)
+our [Nx Module Federation Technical Overview](/technologies/module-federation/concepts/nx-module-federation-technical-overview#what-happens-when-you-serve-your-host)
 document.
 
 {% /callout %}

docs/blog/2024-09-20-nx-19-8.md

@@ -28,11 +28,11 @@ In this blog post:
 
 ## Nx Import
 
-In Nx 19.8, [`nx import`](/nx-api/nx/documents/import) has now moved from beta support to now generally available!
+In Nx 19.8, [`nx import`](/reference/core-api/nx/documents/import) has now moved from beta support to now generally available!
 
 Nx Import is a new [top-level command of the Nx CLI](/reference/nx-commands) which allows you to import projects along with its git history from some other repository into your current Nx workspace.
 
-Keep an eye out for more on Nx Import on our [YouTube Channel](https://www.youtube.com/@nxdevtools) coming soon, and in the meantime be sure to check [the documentation](/nx-api/nx/documents/import) as this is now fully documented!
+Keep an eye out for more on Nx Import on our [YouTube Channel](https://www.youtube.com/@nxdevtools) coming soon, and in the meantime be sure to check [the documentation](/reference/core-api/nx/documents/import) as this is now fully documented!
 
 ## Improved Task Scheduling!
 
@@ -62,7 +62,7 @@ With Nx 19.8, we've added a [`infer-targets`](/recipes/running-tasks/convert-to-
 
 When creating a new workspace with the command: `npx create-nx-workspace`, those workspaces will now be created with [`eslint`](https://www.npmjs.com/package/eslint) v9, and [`typescript-eslint`](https://www.npmjs.com/package/typescript-eslint) v8 - their most recent versions respectively.
 
-Keep in mind as well that ESLint v8 faces end-of-life on October 5th, meaning only [flat config](https://eslint.org/docs/latest/use/configure/migration-guide) is supported moving forward. Nx users should migrate to this new config format using [our flat config generator](/recipes/tips-n-tricks/flat-config#switching-to-eslints-flat-config-format).
+Keep in mind as well that ESLint v8 faces end-of-life on October 5th, meaning only [flat config](https://eslint.org/docs/latest/use/configure/migration-guide) is supported moving forward. Nx users should migrate to this new config format using [our flat config generator](/technologies/eslint/recipes/flat-config#switching-to-eslints-flat-config-format).
 
 For more on eslint's flat config, and how to use our generator to get to flat config checkout this video:
 
@@ -73,7 +73,7 @@ title="ESLint Config Automation With Nx"
 
 ## Nx Release Enhancements
 
-[`nx release`](/nx-api/nx/documents/release) is a framework/language/platform agnostic solution to versioning, publishing, and changelogs for your monorepo. We've been continuing to invest in Nx Release in 19.8, adding support specifically for [`pnpm publish`](https://pnpm.io/cli/publish) and [Github Enterprise Server](https://github.com/nrwl/nx/pull/26482)!
+[`nx release`](/reference/core-api/nx/documents/release) is a framework/language/platform agnostic solution to versioning, publishing, and changelogs for your monorepo. We've been continuing to invest in Nx Release in 19.8, adding support specifically for [`pnpm publish`](https://pnpm.io/cli/publish) and [Github Enterprise Server](https://github.com/nrwl/nx/pull/26482)!
 
 We also have a new feature from Nx Champion, Jonathan Gelin - which allows you to use `groupPreVersionCommand` in addition to the `preVersionCommand` when using the release groups feature to support [building before versioning](/recipes/nx-release/build-before-versioning).
 

docs/blog/2024-09-25-introducing-nx-powerpack.md

@@ -130,8 +130,8 @@ Read all about how to [configure Codeowners for your project in our docs](/nx-en
 
 We're releasing the `@nx/conformance` plugin in an early preview. This new package focuses specifically on the maintainability of your monorepo. It allows you to encode your organization's standards so they can be enforced automatically. In this first version, the workspace conformance package ships with:
 
-- [Enforce Module Boundaries](/nx-api/conformance#enforce-module-boundaries): Similar to the Nx ESLint [Enforce Module Boundaries rule](/features/enforce-module-boundaries), but enforces boundaries on every project dependency, not just those created from TypeScript imports or `package.json` dependencies.
-- [Ensure Owners](/nx-api/conformance#ensure-owners): Requires every project to have an owner defined for the `@nx/owners` plugin.
+- [Enforce Module Boundaries](/reference/core-api/conformance#enforce-module-boundaries): Similar to the Nx ESLint [Enforce Module Boundaries rule](/features/enforce-module-boundaries), but enforces boundaries on every project dependency, not just those created from TypeScript imports or `package.json` dependencies.
+- [Ensure Owners](/reference/core-api/conformance#ensure-owners): Requires every project to have an owner defined for the `@nx/owners` plugin.
 
 To get started, install the following package:
 

docs/blog/2024-10-03-nx-20-release.md

@@ -65,7 +65,7 @@ npx nx e2e myapp-e2e
 
 In [Nx 19.8](/blog/nx-19-8-update#new-nx-workspaces-created-with-eslint-v9), we highlighted that workspaces will now be created with [`eslint`](https://www.npmjs.com/package/eslint) v9, and [`typescript-eslint`](https://www.npmjs.com/package/typescript-eslint) v8.
 
-This not only brings us inline with the latest version of eslint and typescript-eslint, but also that [flat config](https://eslint.org/docs/latest/use/configure/migration-guide) is only supported moving forward. Nx users should migrate to this new config format using [our flat config generator](/recipes/tips-n-tricks/flat-config#switching-to-eslints-flat-config-format).
+This not only brings us inline with the latest version of eslint and typescript-eslint, but also that [flat config](https://eslint.org/docs/latest/use/configure/migration-guide) is only supported moving forward. Nx users should migrate to this new config format using [our flat config generator](/technologies/eslint/recipes/flat-config#switching-to-eslints-flat-config-format).
 
 For more on eslint's flat config, and how to use our generator to get to flat config checkout this video:
 
@@ -141,7 +141,7 @@ There's a lot more in Nx 20, so be sure to check the full changelog for all the
 [gradle-atomizer]: /blog/nx-19-5-adds-stackblitz-new-features-and-more#experimental-gradle-test-atomization
 [nx-gradle]: /blog/nx-19-release#new-plugin-nxgradle
 [file-based-versioning]: /recipes/nx-release/file-based-versioning-version-plans
-[nx-rspack]: /nx-api/rspack
+[nx-rspack]: /technologies/build-tools/rspack/introduction
 [crystalize-command]: /blog/nx-19-8-update#crystalize-your-entire-workspace-in-one-command
 [nx-import]: /recipes/adopting-nx/import-project
 [migration-step]: /features/automate-updating-dependencies

docs/blog/2024-10-29-nx-import.md

@@ -23,7 +23,7 @@ However, while we've always had a great story for starting up a fresh monorepo f
 
 Prior to this work, it was always possible to do manually - but it takes some finessing both in terms of copying/pasting files over, and (as we'll see later) maintaining combining git history from the old project into its new home.
 
-We always wanted to make this better - and now, we've now added a new top-level command to Nx specifically to address this: [`nx import`](http://localhost:4200/nx-api/nx/documents/import).
+We always wanted to make this better - and now, we've now added a new top-level command to Nx specifically to address this: [`nx import`](http://localhost:4200/reference/core-api/nx/documents/import).
 
 ## How It Works
 

docs/blog/2024-11-30-advent-of-code-crystal.md

@@ -84,7 +84,7 @@ Sometimes the second part of the problem simply builds on top of the first. On t
 
 ### New Feature for 2.0.0: File Watching!
 
-We've also added file watching (using [`nx watch`](/nx-api/nx/documents/watch) behind the scenes!)
+We've also added file watching (using [`nx watch`](/reference/core-api/nx/documents/watch) behind the scenes!)
 
 Simply add `watch-` to the start of any of the commands and aliases listed above to start any of them in watch mode, so they automatically re-run as soon as any changes to the file system are detected! Example:
 

docs/blog/2024-12-10-tailoring-nx-for-your-organization.md

@@ -47,7 +47,7 @@ Once installed, run the following generator that ships with the `@nx/plugin` pac
 nx g plugin packages/nx-plugin --importPath=@org/nx-plugin
 ```
 
-Also, make sure to check out our [extensive instructions in our docs for building plugins](/extending-nx/intro/getting-started), or you can jump right to the API for [@nx/plugin](/nx-api/plugin).
+Also, make sure to check out our [extensive instructions in our docs for building plugins](/extending-nx/intro/getting-started), or you can jump right to the API for [@nx/plugin](/reference/core-api/plugin).
 
 ## Setting up custom generators
 
@@ -137,7 +137,7 @@ To support consistency across your org, you can publish this plugin so that all
 nx release --first-release
 ```
 
-If you want to test your package by publishing locally, your project will also be set up with a [Verdaccio configuration](/nx-api/js/executors/verdaccio) that allows you to run a local registry for testing your new plugin locally:
+If you want to test your package by publishing locally, your project will also be set up with a [Verdaccio configuration](/technologies/typescript/api/executors/verdaccio) that allows you to run a local registry for testing your new plugin locally:
 
 ```bash
 nx local-registry
@@ -171,7 +171,7 @@ Your plugin can provide _anything an existing Nx plugin provides._ This includes
 
 - [Generators](/extending-nx/recipes/local-generators)
 - [Task inference](/extending-nx/tutorials/tooling-plugin)
-- [Custom eslint rules](/nx-api/eslint/generators/workspace-rule#nxeslintworkspacerule)
+- [Custom eslint rules](/technologies/eslint/api/generators/workspace-rule#nxeslintworkspacerule)
 - [Migrations](/extending-nx/recipes/migration-generators)
 - Shared tool configs
 - CI pipeline starters

docs/blog/2024-12-22-nx-highlights-2024.md

@@ -147,7 +147,7 @@ We also adopted **Module Federation 2.0**, adding runtime plugins and key enhanc
 
 To simplify setup, we launched **@nx/module-federation**, a package that streamlines configuration and management of federated apps in Nx workspaces. Nx's approach to Module Federation has been highlighted by the community and is now featured on [module-federation.io](https://module-federation.io/practice/monorepos/nx-for-module-federation.html).
 
-For more details on how Module Federation works in Nx, check out the [technical overview](/concepts/module-federation/nx-module-federation-technical-overview) or catch one of our [live streams on Rspack and Module Federation](https://www.youtube.com/watch?v=_c4zjYm0pYE).
+For more details on how Module Federation works in Nx, check out the [technical overview](/technologies/module-federation/concepts/nx-module-federation-technical-overview) or catch one of our [live streams on Rspack and Module Federation](https://www.youtube.com/watch?v=_c4zjYm0pYE).
 
 ### Nx Console
 

docs/blog/2025-01-06-nx-update-20-3.md

@@ -123,11 +123,11 @@ And we will continue to add this as the default to all our official presets soon
 
 ## Rspack updates
 
-Our [`@nx/rspack`](/nx-api/rspack) plugin has moved from labs into our main repo now, and we now have [a dedicated plugin](/nx-api/rsbuild) for [Rsbuild](https://rsbuild.dev/) (a vite-like build tool with streamlined config built on top of Rspack) as well.
+Our [`@nx/rspack`](/technologies/build-tools/rspack/introduction) plugin has moved from labs into our main repo now, and we now have [a dedicated plugin](/technologies/build-tools/rsbuild/introduction) for [Rsbuild](https://rsbuild.dev/) (a vite-like build tool with streamlined config built on top of Rspack) as well.
 
-With the latest improvements, our Rspack plugin is now at feature parity with our [`@nx/webpack`](/nx-api/webpack) plugin, which should make it easier for teams to migrate from Webpack to Rspack now and take advantage of the significant performance gains.
+With the latest improvements, our Rspack plugin is now at feature parity with our [`@nx/webpack`](/technologies/build-tools/webpack/introduction) plugin, which should make it easier for teams to migrate from Webpack to Rspack now and take advantage of the significant performance gains.
 
-Our new [Rsbuild plugin](/nx-api/rsbuild) will bring support for React and Vue applications, and we have measured a massive performance increase here over webpack. Running the command:
+Our new [Rsbuild plugin](/technologies/build-tools/rsbuild/introduction) will bring support for React and Vue applications, and we have measured a massive performance increase here over webpack. Running the command:
 
 ```shell
 nx g @nx/rsbuild:configuration
@@ -195,9 +195,9 @@ We've also introduced spinners into the terminal ui for instances where a task i
 
 > Update: Self-hosted cache was previously part of Powerpack. But no more, it is no free for everyone to use.
 
-We just improved support for our [self-hosted caching packages](/recipes/running-tasks/self-hosted-caching) by adding adapters for [Azure](/nx-api/azure-cache) and [Google Cloud Storage](/nx-api/gcs-cache) as supported storage providers (in addition to [S3](/nx-api/s3-cache) or [simply using a shared file system](/nx-api/shared-fs-cache)).
+We just improved support for our [self-hosted caching packages](/recipes/running-tasks/self-hosted-caching) by adding adapters for [Azure](/reference/core-api/azure-cache/overview) and [Google Cloud Storage](/reference/core-api/gcs-cache/overview) as supported storage providers (in addition to [S3](/reference/core-api/s3-cache/overview) or [simply using a shared file system](/reference/core-api/shared-fs-cache/overview)).
 
-We've also [added support for S3 compatible providers](/nx-api/s3-cache#s3-compatible-providers) such as:
+We've also [added support for S3 compatible providers](/reference/core-api/s3-cache#s3-compatible-providers) such as:
 
 - [MinIO](https://min.io/product/s3-compatibility)
 - [LocalStack](https://www.localstack.cloud)

docs/blog/2025-01-27-project-references.md

@@ -39,7 +39,7 @@ export function isEven(n: number): boolean {
 }
 ```
 
-```ts {% fileName="is-even/index.ts" %}
+```ts {% fileName="is-odd/index.ts" %}
 import { isEven } from 'is-even';
 
 export function isOdd(n: number): boolean {

docs/blog/2025-01-28-managing-ts-pkgs-in-monorepos.md

@@ -663,7 +663,7 @@ npx create-nx-workspace mymonorepo --workspaces
 Also check out our docs:
 
 - [TypeScript Project Linking](/concepts/typescript-project-linking)
-- [Switching to Workspaces and Project References](/recipes/tips-n-tricks/switch-to-workspaces-project-references)
+- [Switching to Workspaces and Project References](/technologies/typescript/recipes/switch-to-workspaces-project-references)
 
 ---
 

docs/blog/2025-01-31-over-the-air-updates-with-zephyr.md

@@ -7,7 +7,7 @@ cover_image: /blog/images/2025-01-31/cover-image.jpg
 description: 'Deploy React Native app updates instantly with Module Federation and Zephyr Cloud, skipping app store review processes.'
 ---
 
-Module Federation is an exciting and continually evolving technology. The use cases for Module Federation have expanded from [Micro Frontends](/concepts/module-federation/micro-frontend-architecture) and [Faster Builds](/concepts/module-federation/faster-builds-with-module-federation) to also include something that should be extremely interesting for React Native users.
+Module Federation is an exciting and continually evolving technology. The use cases for Module Federation have expanded from [Micro Frontends](/technologies/module-federation/concepts/micro-frontend-architecture) and [Faster Builds](/technologies/module-federation/concepts/faster-builds-with-module-federation) to also include something that should be extremely interesting for React Native users.
 
 Thanks to the wonderful work from the [Re.Pack](https://re-pack.dev/) team at [Callstack](https://www.callstack.com/) and [Zephyr Cloud](https://www.zephyr-cloud.io/) now you can provide over-the-air (OTA) updates to your deployed native mobile apps by running a build from your laptop - without having to deal with the difficulties or time-consuming process of deploying a new binary to each of the app stores your application is deployed to.
 
@@ -60,7 +60,7 @@ Beyond just mitigating risk of changing dependencies that can cause runtime erro
 
 If you sprinkle [Nx Cloud](/ci/intro/why-nx-cloud) on top - you can ensure your CI remains fast as you scale out your application through [Nx Replay](/ci/features/remote-cache#use-remote-caching-nx-replay) and [Nx Agents](/ci/features/distribute-task-execution). Increased scalability does not come with an increased maintenance cost of managing CI machines manually thanks to declarative [config files](/ci/recipes/set-up/monorepo-ci-github-actions).
 
-You can learn more about Why to use Nx beyond Module Federation support [here](/getting-started/why-nx).
+You can learn more about Why to use Nx beyond Module Federation support [here](/getting-started/intro).
 
 ## Setting up a Super App with Nx
 

docs/blog/2025-02-06-hetzner-cloud-success-story.md

@@ -48,7 +48,7 @@ Hetzner Cloud needed a solution that would streamline their development process,
 After evaluating Nx and Turborepo, Hetzner Cloud selected Nx for its advanced monorepo management capabilities. They started a [Nx Enterprise](/enterprise) contract and closely collaborated with the Nx Developer Productivity Engineers to assess Hetzner's current software landscape and evaluate the best strategy. Their goal was not necessarily to create a monorepo in the first place, but to modularize their monolithic application. Nx provided the right tools to:
 
 - **Break down the monolith** into modular packages without affecting deployment.
-- **Define clear domain boundaries** using [module boundary rules](/features/enforce-module-boundaries) and [conformance rules](/nx-api/conformance).
+- **Define clear domain boundaries** using [module boundary rules](/features/enforce-module-boundaries) and [conformance rules](/reference/core-api/conformance).
 - **Improve ownership management** by having a more modular structure with clear boundaries allowing for easier allocaton of owernship. Something that could further be improved in the future by using [CodeOwners](/nx-enterprise/powerpack/owners).
 
 Beyond modularization, Nx helped consolidate fragmented projects into a single, structured workspace. This reduced the overhead of maintaining multiple repositories and simplified dependency management. Using the [Nx Graph](/features/explore-graph), the team gained visibility into their project relationships, making it easier to coordinate work and optimize collaboration.

docs/blog/2025-02-17-monorepos-are-ai-future-proof.md

@@ -15,6 +15,11 @@ youtubeUrl: https://youtu.be/RNilYmJJzdk
 - [Nx MCP Now Available for VS Code Copilot](/blog/nx-mcp-vscode-copilot)
 - [Nx and AI: Why They Work so Well Together](/blog/nx-and-ai-why-they-work-together)
 - [Save Time: Connecting Your Editor, CI and LLMs](/blog/nx-editor-ci-llm-integration)
+- [Enhancing Nx Generators with AI: Predictability Meets Intelligence](/blog/nx-generators-ai-integration)
+- [Your AI Assistant Can Now Read Your Terminal: Real-Time Development Error Fixing](/blog/nx-terminal-integration-ai)
+- [Introducing Self-Healing CI for Nx and Nx Cloud](/blog/nx-self-healing-ci)
+- [Analyze Your Nx Cloud Runs With Your AI Assistant](/blog/nx-cloud-analyze-via-nx-mcp)
+- [Automatically Fix your CI Failures with JetBrains AI Assistant](/blog/jetbrains-ci-autofix)
 
 {% /callout %}
 
@@ -138,7 +143,7 @@ And this is just the beginning. While Nx already understands your local monorepo
 
 ## Try It Out Yourself
 
-If you want to test this out, [create a new Nx workspace](/getting-started/intro#try-nx-yourself) and make sure you have [Nx Console](/getting-started/editor-setup) installed or updated to the latest version.
+If you want to test this out, [create a new Nx workspace](/getting-started/start-new-project) and make sure you have [Nx Console](/getting-started/editor-setup) installed or updated to the latest version.
 
 > If you already have an existing NPM/Yarn/PNPM workspace, you can add Nx with `nx init`. Check out [our free course](/courses/pnpm-nx-next) to learn more.
 

docs/blog/2025-03-06-making-cursor-smarter.md

@@ -15,6 +15,11 @@ youtubeUrl: https://youtu.be/V2W94Sq_v6A
 - [Nx MCP Now Available for VS Code Copilot](/blog/nx-mcp-vscode-copilot)
 - [Nx and AI: Why They Work so Well Together](/blog/nx-and-ai-why-they-work-together)
 - [Save Time: Connecting Your Editor, CI and LLMs](/blog/nx-editor-ci-llm-integration)
+- [Enhancing Nx Generators with AI: Predictability Meets Intelligence](/blog/nx-generators-ai-integration)
+- [Your AI Assistant Can Now Read Your Terminal: Real-Time Development Error Fixing](/blog/nx-terminal-integration-ai)
+- [Introducing Self-Healing CI for Nx and Nx Cloud](/blog/nx-self-healing-ci)
+- [Analyze Your Nx Cloud Runs With Your AI Assistant](/blog/nx-cloud-analyze-via-nx-mcp)
+- [Automatically Fix your CI Failures with JetBrains AI Assistant](/blog/jetbrains-ci-autofix)
 
 {% /callout %}
 

docs/blog/2025-03-07-nx-update-20-5.md

@@ -8,13 +8,13 @@ description: Discover the latest in Nx 20.5, featuring TypeScript project refere
 youtubeUrl: https://youtu.be/IujhR3-Iidk
 ---
 
-Time moves fast, and so do Nx releases. Let’s catch up with the latest development on Nx since our [last release post for 20.3](/blog/nx-update-20-3#rfc-for-infinite-tasks).
+Time moves fast, and so do Nx releases. Let's catch up with the latest development on Nx since our [last release post for 20.3](/blog/nx-update-20-3#rfc-for-infinite-tasks).
 
 {% toc /%}
 
 ## LLM improvements galore
 
-We think that monorepos are the solution to better AI-assisted development, and we’re doing the work to support that. We’ve recently released updates that enhance the LLM experience for both [Copilot](/blog/nx-just-made-your-llm-smarter) and [Cursor](/blog/nx-made-cursor-smarter).
+We think that monorepos are the solution to better AI-assisted development, and we're doing the work to support that. We've recently released updates that enhance the LLM experience for both [Copilot](/blog/nx-just-made-your-llm-smarter) and [Cursor](/blog/nx-made-cursor-smarter).
 
 AI-powered coding assistants can edit files, but they're blind to the bigger picture – they don't understand how your entire codebase fits together. Nx changes that. With full visibility into your monorepo's project relationships, dependencies, and ownership, Nx enables your LLM to move beyond local file changes by providing this essential monorepo context.
 
@@ -24,7 +24,7 @@ Take each of these for a spin and then [sign up for our webinar](/blog/are-monor
 
 ## TypeScript project references improvements
 
-ICYMI, we announced a [new experience for TypeScript monorepos](/blog/new-nx-experience-for-typescript-monorepos) in January. The new setup is [faster, more efficient in memory use](/blog/new-nx-experience-for-typescript-monorepos#key-highlight-performance), and fixes common issues with TypeScript editor support for large monorepos. Since then, we’ve steadily improved this experience with many performance and quality-of-life improvements.
+ICYMI, we announced a [new experience for TypeScript monorepos](/blog/new-nx-experience-for-typescript-monorepos) in January. The new setup is [faster, more efficient in memory use](/blog/new-nx-experience-for-typescript-monorepos#key-highlight-performance), and fixes common issues with TypeScript editor support for large monorepos. Since then, we've steadily improved this experience with many performance and quality-of-life improvements.
 
 One of the significant improvements is that you can now run tasks with a partial match of the project name rather than needing to use the full name every time. Say you have these projects:
 
@@ -48,27 +48,27 @@ By default, Nx will use the `name` property from the `package.json` for a projec
 
 We have also made projects inferred by `@nx/js` more efficient by eliminating the duplicate typechecks that were occurring. Previously, when `@nx/js` inferred tasks in a workspace using TypeScript project references, buildable libraries would have both a `build` and `typecheck` target inferred. However, since typechecking occurs as part of `build`, this resulted in typechecking being run twice. Now, buildable projects will only have the `build` target, saving time.
 
-[See more details on how `@nx/js` infers tasks](/nx-api/js#how-nxjs-infers-tasks)
+[See more details on how `@nx/js` infers tasks](/technologies/typescript/introduction#how-nxjs-infers-tasks)
 
 {% youtube src="https://www.youtube.com/watch?v=O2xBQJMTs9E" /%}
 
 ## Migration docs
 
-When `nx migrate` is run, Nx determines what migrations need to be run, but it hasn't been easy for users to understand what the migrations do. The first step we're taking to address this is providing migrations docs for each plugin, going back to version 20 of Nx. [See the Angular plugin migration for an example](/nx-api/angular/migrations).
+When `nx migrate` is run, Nx determines what migrations need to be run, but it hasn't been easy for users to understand what the migrations do. The first step we're taking to address this is providing migrations docs for each plugin, going back to version 20 of Nx. [See the Angular plugin migration for an example](/technologies/angular/api/migrations).
 
 Additionally, when running migrations, the terminal will provide links for each migration with richer information about what is actually happening. This is just our first step in addressing confusion during migrations, keep an eye out for more development here.
 
 ## ESM support for eslint config
 
-`@nx/eslint` now uses ESM for configuration by default. This means that new workspaces will use ESM. Existing workspaces will continue to use CommonJS. We don’t currently have a migration path between CommonJS and ESM because of the possibility to break something in your lint rules. Both CommonJS and ESM will be supported for the near future.
+`@nx/eslint` now uses ESM for configuration by default. This means that new workspaces will use ESM. Existing workspaces will continue to use CommonJS. We don't currently have a migration path between CommonJS and ESM because of the possibility to break something in your lint rules. Both CommonJS and ESM will be supported for the near future.
 
 ## React 19 support for new workspaces
 
-New Nx workspaces now default to React 19. Note that due to the extent of breaking changes coming with React 19, we will not be providing an automated migration to React 19 via [**`nx migrate`**](/nx-api/nx/documents/migrate). If you’re ready to make this migration on your own, [see our docs about using the new `reactCompiler`](/recipes/react/react-compiler#react-compiler-with-nx)
+New Nx workspaces now default to React 19. Note that due to the extent of breaking changes coming with React 19, we will not be providing an automated migration to React 19 via [**`nx migrate`**](/reference/core-api/nx/documents/migrate). If you're ready to make this migration on your own, [see our docs about using the new `reactCompiler`](/technologies/react/recipes/react-compiler#react-compiler-with-nx)
 
 ## Angular 19.2 support
 
-`@nx/angular` now supports up to Angular 19.2 Time to give their new experimental [Resources API](https://angular.dev/guide/signals/resource) a try! If you’re not quite ready to upgrade your version of Angular, remember that you can migrate to the latest Nx while keeping your current version of Angular using the `--interactive` flag during migration. [See our docs for more details](/recipes/tips-n-tricks/advanced-update#choosing-optional-package-updates-to-apply).
+`@nx/angular` now supports up to Angular 19.2 Time to give their new experimental [Resources API](https://angular.dev/guide/signals/resource) a try! If you're not quite ready to upgrade your version of Angular, remember that you can migrate to the latest Nx while keeping your current version of Angular using the `--interactive` flag during migration. [See our docs for more details](/recipes/tips-n-tricks/advanced-update#choosing-optional-package-updates-to-apply).
 
 ## Vite 6 + Vitest 3 support
 
@@ -76,7 +76,7 @@ New Nx workspaces now default to React 19. Note that due to the extent of breaki
 
 ## Update on Infinite Tasks/Continuous Tasks
 
-In our [20.3 release post](/blog/nx-update-20-3#rfc-for-infinite-tasks), we introduced an RFC for “Infinite Tasks” (now called [Continuous Tasks](https://github.com/nrwl/nx/discussions/29025)). Nx will add the concept of **Continuous tasks** which Nx will orchestrate as part of the task graph. This will allow for tasks to depend on other running tasks in addition how it already allows depending on other completed tasks. This will allow for better support of long-running tasks like backend servers for frontend applications that depend on them, or tools that run in a watch mode. We’ve been hard at work implementing this feature, and you can look forward to a beta version before the release of Nx 21.
+In our [20.3 release post](/blog/nx-update-20-3#rfc-for-infinite-tasks), we introduced an RFC for "Infinite Tasks" (now called [Continuous Tasks](https://github.com/nrwl/nx/discussions/29025)). Nx will add the concept of **Continuous tasks** which Nx will orchestrate as part of the task graph. This will allow for tasks to depend on other running tasks in addition how it already allows depending on other completed tasks. This will allow for better support of long-running tasks like backend servers for frontend applications that depend on them, or tools that run in a watch mode. We've been hard at work implementing this feature, and you can look forward to a beta version before the release of Nx 21.
 
 ## Fixes and improvements
 

docs/blog/2025-03-17-modern-angular-testing-with-nx.md

@@ -109,7 +109,7 @@ When run on a single machine, `e2e-ci` will be slower because it starts multiple
 npx nx connect
 ```
 
-Follow the onboarding steps and you should be connected within five minutes. For more information, check out our [GitHub Actions Tutorial](/ci/intro/tutorials/github-actions) or our [guides](/ci/recipes/set-up) for all supported CI providers (GitHub, GitLab, Azure, etc.).
+Follow the onboarding steps and you should be connected within five minutes. For more information, check out our [setup guides](/ci/recipes/set-up) for all supported CI providers (GitHub, GitLab, Azure, etc.).
 
 Now, let's take a look at a concrete example to get an idea of how much time-saving you can unlock with Nx Atomizer. I created [this repo](https://github.com/jaysoo/angular-testing-demo) that contains a simple Angular application and a UI package. It also has 40 Playwright test files.
 

docs/blog/2025-03-18-architecting-angular-applications.md

@@ -158,7 +158,7 @@ It uses Nx for running and building your project. Nx relies on the Angular Devki
 }
 ```
 
-If you have an existing Angular CLI project, you can also [add Nx support to it](/recipes/angular/migration/angular) by running:
+If you have an existing Angular CLI project, you can also [add Nx support to it](/technologies/angular/migration/angular) by running:
 
 ```shell
 npx nx init

docs/blog/2025-03-19-using-angular-with-rspack.md

@@ -71,7 +71,7 @@ The steps are very simple:
 1. Run `nx migrate latest` to update your workspace to the latest version of Nx.
 2. Run `nx g @nx/angular:convert-to-rspack` to migrate your Angular application to Rspack.
 
-There is also a [guide in our documentation](/recipes/angular/rspack/migrate-from-webpack) that walks you through the process step-by-step.
+There is also a [guide in our documentation](/technologies/angular/angular-rspack/recipes/migrate-from-webpack) that walks you through the process step-by-step.
 Even if you're currently using the Angular CLI, it's as simple as first running `npx nx init` in your workspace and then running `npx nx g convert-to-rspack`.
 
 ## Using Angular Rspack
@@ -121,7 +121,7 @@ export default createConfig(
 
 {% callout type="deepdive" title="createConfig Information" %}
 The `createConfig` function is used to create an Rspack configuration object setup for Angular applications.
-You can read more about it [here](/nx-api/angular-rspack/documents/create-config).
+You can read more about it [here](/technologies/angular/angular-rspack/api/create-config).
 {% /callout %}
 
 ### Building and Serving your Application
@@ -226,7 +226,7 @@ Exciting times ahead! You can follow our progress by starring the [Angular Rspac
 
 ## Further Reading
 
-- [Nx Angular Rspack](/recipes/angular/rspack/introduction)
+- [Nx Angular Rspack](/technologies/angular/angular-rspack/introduction)
 - [Angular](https://angular.dev)
 - [Rspack](https://rspack.dev)
 - 🧠 [Nx Docs](/getting-started/intro)

docs/blog/2025-04-14-scaffold-angular-rspack-applications.md

@@ -34,7 +34,7 @@ Docusaurus has even [reported that switching to Rspack has resulted in a 2x-4x f
 
 However, Angular’s Webpack build pipeline proved to be an issue. It had not been possible to use Rspack as a drop-in replacement for Angular applications.
 
-Which is why [Angular Rspack](/recipes/angular/rspack/introduction) was created.
+Which is why [Angular Rspack](/technologies/angular/angular-rspack/introduction) was created.
 
 ## Angular Rspack
 
@@ -46,7 +46,7 @@ Angular Rspack provides Rspack Plugins and Loaders that makes it possible to bui
 
 You can learn more about Angular Rspack from the resources below:
 
-- [Angular Rspack - Introduction](/recipes/angular/rspack/introduction)
+- [Angular Rspack - Introduction](/technologies/angular/angular-rspack/introduction)
 - [Using Rspack with Angular](/blog/using-rspack-with-angular)
 
 {% /callout %}
@@ -64,7 +64,7 @@ From the benchmark results below, you can see the vast improvement using Angular
 
 You can see that the results from Rspack are comparable to the results provided by Angular’s Esbuild build pipeline.
 
-That said, it is worth noting that there are still currently some [known limitations and missing features](/recipes/angular/rspack/introduction#known-limitations-and-missing-features).
+That said, it is worth noting that there are still currently some [known limitations and missing features](/technologies/angular/angular-rspack/introduction#known-limitations-and-missing-features).
 
 ## Why Choose Rspack for New Projects?
 
@@ -121,7 +121,7 @@ npx nx g @nx/angular:app myapp --bundler=rspack
 
 ### Converting an Existing Angular Webpack Application
 
-If you have an existing Angular Webpack application you can easily migrate it to use Angular Rspack by using the `@nx/angular:convert-to-rspack` generator. The [Migrate Angular with Webpack to Rspack](/recipes/angular/rspack/migrate-from-webpack) guide explains more on this.
+If you have an existing Angular Webpack application you can easily migrate it to use Angular Rspack by using the `@nx/angular:convert-to-rspack` generator. The [Migrate Angular with Webpack to Rspack](/technologies/angular/angular-rspack/recipes/migrate-from-webpack) guide explains more on this.
 
 ## Future Work
 

docs/blog/2025-04-15-nx-mcp-vscode-copilot.md

@@ -6,7 +6,6 @@ tags: ['nx', 'nx-console', 'ai']
 cover_image: /blog/images/articles/bg-copilot-nx-mcp.avif
 description: 'Learn how to enhance VS Code Copilot with Nx MCP integration, providing rich monorepo context for smarter AI assistance.'
 youtubeUrl: https://youtu.be/dRQq_B1HSLA
-pinned: true
 ---
 
 {% callout type="deepdive" title="Series: Making your LLM smarter" expanded=true %}
@@ -16,6 +15,11 @@ pinned: true
 - **Nx MCP Now Available for VS Code Copilot**
 - [Nx and AI: Why They Work so Well Together](/blog/nx-and-ai-why-they-work-together)
 - [Save Time: Connecting Your Editor, CI and LLMs](/blog/nx-editor-ci-llm-integration)
+- [Enhancing Nx Generators with AI: Predictability Meets Intelligence](/blog/nx-generators-ai-integration)
+- [Your AI Assistant Can Now Read Your Terminal: Real-Time Development Error Fixing](/blog/nx-terminal-integration-ai)
+- [Introducing Self-Healing CI for Nx and Nx Cloud](/blog/nx-self-healing-ci)
+- [Analyze Your Nx Cloud Runs With Your AI Assistant](/blog/nx-cloud-analyze-via-nx-mcp)
+- [Automatically Fix your CI Failures with JetBrains AI Assistant](/blog/jetbrains-ci-autofix)
 
 {% /callout %}
 

docs/blog/2025-04-17-nx-and-ai-why-they-work-together.md

@@ -14,6 +14,11 @@ description: 'Explore how Nx monorepos amplify AI benefits by providing complete
 - [Nx MCP Now Available for VS Code Copilot](/blog/nx-mcp-vscode-copilot)
 - **Nx and AI: Why They Work so Well Together**
 - [Save Time: Connecting Your Editor, CI and LLMs](/blog/nx-editor-ci-llm-integration)
+- [Enhancing Nx Generators with AI: Predictability Meets Intelligence](/blog/nx-generators-ai-integration)
+- [Your AI Assistant Can Now Read Your Terminal: Real-Time Development Error Fixing](/blog/nx-terminal-integration-ai)
+- [Introducing Self-Healing CI for Nx and Nx Cloud](/blog/nx-self-healing-ci)
+- [Analyze Your Nx Cloud Runs With Your AI Assistant](/blog/nx-cloud-analyze-via-nx-mcp)
+- [Automatically Fix your CI Failures with JetBrains AI Assistant](/blog/jetbrains-ci-autofix)
 
 {% /callout %}
 

docs/blog/2025-04-23-test-splitting-techniques.md

@@ -103,7 +103,7 @@ Or more generically:
 
 - `{ciTargetName}--{path/to/test/file}`
 
-You can find more information on how to configure the Atomizer on the respective [Jest](/nx-api/jest#splitting-e2e-tests), [Cypress](/nx-api/cypress#nxcypress-configuration), [Playwright](/nx-api/playwright#nxplaywright-configuration), [Gradle](/nx-api/gradle/documents/overview#nxgradle-configuration) or follow [this recipe](/extending-nx/recipes/project-graph-plugins) to create your own inferred plugin.
+You can find more information on how to configure the Atomizer on the respective [Jest](/technologies/test-tools/jest/introduction#splitting-e2e-tests), [Cypress](/technologies/test-tools/cypress/introduction#nxcypress-configuration), [Playwright](/technologies/test-tools/playwright/introduction#nxplaywright-configuration), [Gradle](/technologies/java/introduction#nxgradle-configuration) or follow [this recipe](/extending-nx/recipes/project-graph-plugins) to create your own inferred plugin.
 
 ## Manual E2E Project Splitting
 

docs/blog/2025-05-01-nx-mcp-ci-fixes.md

@@ -15,6 +15,11 @@ youtubeUrl: https://youtu.be/fPqPh4h8RJg
 - [Nx MCP Now Available for VS Code Copilot](/blog/nx-mcp-vscode-copilot)
 - [Nx and AI: Why They Work so Well Together](/blog/nx-and-ai-why-they-work-together)
 - **Save Time: Connecting Your Editor, CI and LLMs**
+- [Enhancing Nx Generators with AI: Predictability Meets Intelligence](/blog/nx-generators-ai-integration)
+- [Your AI Assistant Can Now Read Your Terminal: Real-Time Development Error Fixing](/blog/nx-terminal-integration-ai)
+- [Introducing Self-Healing CI for Nx and Nx Cloud](/blog/nx-self-healing-ci)
+- [Analyze Your Nx Cloud Runs With Your AI Assistant](/blog/nx-cloud-analyze-via-nx-mcp)
+- [Automatically Fix your CI Failures with JetBrains AI Assistant](/blog/jetbrains-ci-autofix)
 
 {% /callout %}
 

docs/blog/2025-05-05-nx-21-release.md

@@ -6,7 +6,6 @@ tags: ['nx', 'release']
 cover_image: /blog/images/2025-05-05/header.avif
 description: 'Discover the latest in Nx 21, featuring continuous tasks and the new Terminal UI'
 youtubeUrl: https://youtu.be/9zsncTxfcl4
-pinned: true
 ---
 
 {% callout type="deepdive" title="Nx 21 Launch Week" expanded=true %}
@@ -128,13 +127,13 @@ To test how performance improved, we forked the Spring Boot repo and converted i
 
 These two changes make the `@nx/gradle` plugin better than ever for managing your Gradle plugins. Be sure to explore this new plugin if you're using Gradle, and watch out for what else we're bringing to the Java ecosystem, later this year.
 
-[Check out the docs for more details.](/nx-api/gradle)
+[Check out the docs for more details.](/technologies/java/introduction)
 
 ## Migrate UI in Nx Console makes migrations easier than ever
 
 ![Screenshot of Nx Console's Migrate UI showing a list of migrations to approve.](/blog/images/2025-05-05/migrate-ui.avif)
 
-[Automated migrations](/features/automate-updating-dependencies) have always been a massively valuable part of Nx. Previously, we [added migration docs](/nx-api/angular/migrations) to better inform you of what's happening during these migrations. Now, we're bringing the migration process to the Nx Console so that you can step through migrations even easier than before.
+[Automated migrations](/features/automate-updating-dependencies) have always been a massively valuable part of Nx. Previously, we [added migration docs](/technologies/angular/api/migrations) to better inform you of what's happening during these migrations. Now, we're bringing the migration process to the Nx Console so that you can step through migrations even easier than before.
 
 After updating to the latest version of Nx Console, you'll see a **new Migrate UI panel**. Through this, you'll be able to start a migration, install packages, and then individually approve different migrations. You'll be able to see the change before approving and moving on to the next one. This allows for better visibility into each change and helps you stay informed. As always, you'll have an option to commit after each change or squash them together into a single commit.
 
@@ -146,7 +145,7 @@ This is another item we're excited to talk about more later this week.
 
 If you're using React Router in declarative or data mode, you can continue using the existing workflows that build your React app.
 
-However, if you're ready to start a new app using the framework mode in React Router or need to migrate a Remix app to React Router, we've got you covered. Our new [inferred task plugin](/recipes/react/react-router) will handle running the React Router CLI based on projects with a React Router config file. If you're migrating from Remix, follow the React Router team's [migration guidance](https://reactrouter.com/upgrading/remix). Once migrated, you can remove the Remix plugin and use the React Router plugin.
+However, if you're ready to start a new app using the framework mode in React Router or need to migrate a Remix app to React Router, we've got you covered. Our new [inferred task plugin](/technologies/react/recipes/react-router) will handle running the React Router CLI based on projects with a React Router config file. If you're migrating from Remix, follow the React Router team's [migration guidance](https://reactrouter.com/upgrading/remix). Once migrated, you can remove the Remix plugin and use the React Router plugin.
 
 ## Updated release versioning
 

docs/blog/2025-05-08-improved-module-federation.md

@@ -27,9 +27,9 @@ However, before even being able to contemplate that, a different feature needed
 
 We have introduced three new [Rspack](https://rspack.dev) Plugins for Module Federation that can be used with Nx.
 
-- [NxModuleFederationPlugin](/nx-api/module-federation/documents/nx-module-federation-plugin): Gathers information from the Nx Workspace to correctly configure `rspack.ModuleFederationPlugin`
-- [NxModuleFederationDevServerPlugin](/nx-api/module-federation/documents/nx-module-federation-dev-server-plugin): Used to handle the static-serving of non-dev remotes for CSR applications
-- [NxModuleFederationSSRDevServerPlugin](/nx-api/module-federation/documents/nx-module-federation-dev-server-plugin#server-side-rendering): Used to handle the static-serving of non-dev remotes for SSR applications
+- [NxModuleFederationPlugin](/technologies/module-federation/recipes/nx-module-federation-plugin): Gathers information from the Nx Workspace to correctly configure `rspack.ModuleFederationPlugin`
+- [NxModuleFederationDevServerPlugin](/technologies/module-federation/recipes/nx-module-federation-dev-server-plugin): Used to handle the static-serving of non-dev remotes for CSR applications
+- [NxModuleFederationSSRDevServerPlugin](/technologies/module-federation/recipes/nx-module-federation-dev-server-plugin#server-side-rendering): Used to handle the static-serving of non-dev remotes for SSR applications
 
 These are true Rspack Plugins that should be added to the `plugins: []` of an `rspack.config` file.
 
@@ -133,8 +133,8 @@ With the new [Terminal UI](/recipes/running-tasks/terminal-ui) you can very easi
 
 ## Further Reading
 
-- [Module Federation and Nx](/concepts/module-federation/module-federation-and-nx)
-- [Nx Module Federation Technical Overview](/concepts/module-federation/nx-module-federation-technical-overview)
+- [Module Federation and Nx](/technologies/module-federation/concepts/module-federation-and-nx)
+- [Nx Module Federation Technical Overview](/technologies/module-federation/concepts/nx-module-federation-technical-overview)
 - 🧠 [**Nx Docs**](/getting-started/intro)
 - 👩‍💻 [**Nx GitHub**](https://github.com/nrwl/nx)
 - 💬 [**Nx Official Discord Server**](https://go.nx.dev/community)

docs/blog/2025-05-09-terminal-ui.md

@@ -6,7 +6,6 @@ tags: ['nx']
 cover_image: /blog/images/2025-05-09/terminal-ui.avif
 description: 'Nx 21 introduces the new Terminal UI, an elegant way of viewing log output from multiple running tasks.'
 youtubeUrl: https://youtu.be/ykaMAh83fPM
-pinned: true
 ---
 
 {% callout type="deepdive" title="Nx 21 Launch Week" expanded=true %}

docs/blog/2025-05-13-nx-generators-ai-integration.md

@@ -16,6 +16,10 @@ youtubeUrl: https://youtu.be/PXNjedYhZDs
 - [Nx and AI: Why They Work so Well Together](/blog/nx-and-ai-why-they-work-together)
 - [Save Time: Connecting Your Editor, CI and LLMs](/blog/nx-editor-ci-llm-integration)
 - **Enhancing Nx Generators with AI: Predictability Meets Intelligence**
+- [Your AI Assistant Can Now Read Your Terminal: Real-Time Development Error Fixing](/blog/nx-terminal-integration-ai)
+- [Introducing Self-Healing CI for Nx and Nx Cloud](/blog/nx-self-healing-ci)
+- [Analyze Your Nx Cloud Runs With Your AI Assistant](/blog/nx-cloud-analyze-via-nx-mcp)
+- [Automatically Fix your CI Failures with JetBrains AI Assistant](/blog/jetbrains-ci-autofix)
 
 {% /callout %}
 
@@ -118,7 +122,7 @@ To use this feature, you'll need:
 
 Once set up, you can start leveraging this powerful combination of predictable generators and intelligent AI assistance.
 
-This integration is just one example of our broader vision for AI-enhanced development with Nx, providing useful and deep integration of LLMs into your development workflow. Currently we're looking into integrating our [new Nx terminal UI](blog/nx-21-terminal-ui) with your coding assistant, allowing for some interesting new AI powered workflows.
+This integration is just one example of our broader vision for AI-enhanced development with Nx, providing useful and deep integration of LLMs into your development workflow. Currently we're looking into integrating our [new Nx terminal UI](/blog/nx-21-terminal-ui) with your coding assistant, allowing for some interesting new AI powered workflows.
 
 That said, don't forget to subscribe to our [YouTube channel](https://www.youtube.com/@nxdevtools) or [subscribe to our newsletter](https://go.nx.dev/nx-newsletter) for future announcements and demonstrations.
 

docs/blog/2025-05-27-practical-guide-effective-ai-coding.md

@@ -0,0 +1,292 @@
+---
+title: 'A Practical Guide on Effective AI Use - AI as Your Peer Programmer'
+slug: practical-guide-effective-ai-coding
+authors: ['Victor Savkin']
+tags: ['ai', 'development', 'productivity', 'best-practices']
+cover_image: /blog/images/articles/bg-practical-ai-guide-part-1.avif
+description: 'Learn how to effectively use AI coding assistants beyond simple prompts. Discover proven workflows, best practices, and strategies that transform AI from a novelty into a powerful development multiplier.'
+pinned: false
+---
+
+> _"Tools amplify your talent. The better your skills, the better the tools serve you."_ — Andrew Hunt, The Pragmatic Programmer
+
+_This is the first post in the series. Much of it aggregates the insights of colleagues at Nx (Juri Strumpflohner, James Henry, and others)
+and other developers I frequently discuss this topic with (special thanks to Matt Briggs, who is a de-facto co-author of this post)._
+
+**The main takeaway from this guide**: Being intentional and investing in workflows instead of just "using Cursor" or "chatting with GPT" is what separates effective AI-assisted development from impressive demos that don't translate to real productivity gains.
+
+AI can supercharge your development process, but it's not a magic wand. It's like learning to use power tools - requiring practice to master but transformative once you do. The difference between developers who get 10-30% productivity gains and those who struggle with AI comes down to **having proper procedures and workflows** rather than shooting random prompts at their LLM.
+
+{% toc /%}
+
+## Setting Realistic Expectations
+
+AI can enhance your development process significantly. It's useful for:
+
+- Coding
+- Thinking
+- Content creation
+- Learning
+
+Depending on the company you work at and your position, how you use AI will be drastically different. A web developer at a startup spends much of their day coding. A VP at a financial organization may not have written code in years and would benefit more from content creation and thinking. Regardless, you'll find useful patterns here.
+
+For software engineers, expected outcomes with proper AI implementation:
+
+- Faster coding on real projects (10-30% in my personal experience)
+- Faster content creation (30-50% in my personal experience)
+- Improved code quality
+- Accelerated skill acquisition
+
+Getting there requires patience and experimentation. We're all figuring this out together as tools improve every few months. No one has mastered AI-assisted development yet. Give yourself room to build this skill - the learning curve is real but worth climbing.
+
+However, set your expectations right. **The total output of your team won't go up by 30%, especially in large organizations.** Engineers in large organizations spend only a fraction of their time coding, creating content, and learning new skills. Smaller teams will get much more leverage out of using AI.
+
+## Tool Categories, Agents and Some Recommendations
+
+The AI space is awash with investment, making any list quickly outdated. Effective workflows typically combine tools from multiple categories.
+
+### Main Tool Categories
+
+- **AI-integrated Editors** - VSCode, Cursor, Windsurf, Roo Code, Intellij, Zed. Most developers' primary coding environment with integrated AI capabilities.
+- **Terminal-based AI Agents** - Claude Code, Codex, Aider. Command-line tools for delegating coding tasks directly from terminal.
+- **Dedicated Web/Desktop Applications** - Offer unrestricted model capabilities and features like research agents and web search, despite lacking codebase context.
+- **Cloud-based Agents** - Devin, Copilot, Codex. Finally reaching reliability for simple task delegation on real projects.
+- **Code Review Tools** - Graphite Diamond, Copilot. Provide early PR feedback and are increasingly useful.
+
+For tasks outside specific coding work - research, planning, documentation, and general problem-solving - I rely on dedicated web/desktop applications that offer broader capabilities:
+
+- **Claude Desktop** - Large context, web search, research capabilities, robust MCP support (some features require expensive Claude Max)
+- **ChatGPT** - Image creation, web search, research capabilities (less code-proficient than competitors)
+- **AI Studio (Gemini)** - Massive context window, code-optimized models, Google search integration
+- **T3 Chat** - A fast web-based chat client that allows you to switch between multiple models and comes with a competitive, convenient pricing approach.
+- **ChatWise** - A desktop-based chat client that uses a bring-your-own-key strategy, allowing you to integrate with all the models out there. You can provision a key via [OpenRouter](https://openrouter.ai/) or directly plug in the key.
+
+All five are comparable - consistency matters more than choice. I personally value MCP integrations, so primarily use Claude Desktop.
+
+**Model Control Protocols (MCPs)** are plug-and-play tools that AI can use to fulfill requests. They're remarkably quick to create and integrate with most agent-based tools and Claude desktop. MCPs are particularly valuable as they can enhance any of the above tool categories, providing specialized capabilities and integrations that extend the base functionality of AI coding assistants. This is exactly how we integrate Nx's capabilities with existing coding assistants like VS Code Copilot and Cursor - [learn more about our MCP implementation](/blog/nx-mcp-vscode-copilot).
+
+### Agent Types
+
+The most important type of tool you would use while coding is an Agent. Most of the AI work you do in Cursor, Windsurf or JetBrains is done via Agents. You can chat with agents to instruct it to do several things to your code base. Agents have built-in capabilities (integrating with your editor) and can be extended via MCP.
+
+**There are two styles of agents:** interactive and non-interactive
+
+### Interactive Agents (Quick Doers)
+
+These are your everyday workhorses for AI-assisted coding. They're quick, cost-effective, but with some capability limitations.
+
+**Recommended options:**
+
+- **Cursor** (VSCode fork)
+- **Windsurf** (Available as VSCode fork or JetBrains plugin)
+- **Copilot** (VSCode native integration; almost as effective as Cursor/Windsurf and improving fast)
+
+### Non-interactive Agents (Deep Thinkers)
+
+More precise than interactive assistants but slower and pricier - like precision power tools versus hand tools. These excel at widespread codebase changes requiring sub-agents or extensive context.
+
+**Recommended options:**
+
+- **Claude Code** (terminal-based interface)
+- **OpenAI Codex** (terminal-based interface)
+- **JetBrains Junie**
+
+They get less attention online because most streamers do work that works well with interactive agents. Any agent can put together a web page. "Deep Thinkers" can spend many minutes performing an operation which doesn't make for impressive videos, but they're very valuable when working on real complex systems.
+
+Most of my work involves distributed systems, where interactive agents aren't particularly effective. In these systems, application behavior isn't easily derivable from source code—things operate at a higher level of abstraction.
+
+I get significantly more leverage from tools like Claude Code (or Junie) than Cursor/Copilot, which creates more robust plans and provide real value in my domain. But even with Claude Code I use specific patterns and prompt and keep it on a short leash.
+
+For tasks like writing new scripts or building web UIs, I find Copilot or Cursor work better.
+
+## The Main Rule: Understanding and Quality over Speed
+
+> Never commit code you don't understand.
+
+While AI may write it, you are responsible for every character. Understanding your code completely is essential. Read, understand, investigate the code that AI generates.
+
+If AI generates subpar code, improve it and learn how to get better results. The goal is AI that produces what you would have written yourself.
+
+**Effective AI use means:**
+
+- More thinking and reading
+- Less typing
+
+One of the greatest risks of using AI is generating large amounts of code that are poorly understood and do not integrate well with the overall system architecture. Mitigate this risk. **AI tools create space for better engineering practices - not just cramming in more features. **
+
+**Critical thinking and deep codebase familiarity remain essential. They're the foundation for effective AI use.**
+
+### Beyond "Vibing" with AI
+
+AI is much better at being impressive compared to being correct. There's a lot of excitement in creating quick prototypes using AI without understanding what the code does. This can be useful but it is not software engineering. It's closer to sketching, wireframing, exploring.
+
+Although impressive demos get attention, the vast majority of effort is spent on non-prototypes. And there is a lot more gain to be had in optimizing actual engineering workflows.
+
+## The Core Workflow
+
+The most effective AI-assisted development follows a structured approach: **Plan → Act → Review → Repeat**. This isn't just good practice - it's essential for avoiding the common pitfalls that lead to frustration and wasted time.
+
+### Plan
+
+![Planning Phase Workflow](/blog/images/articles/ai-flow-planning-phase.avif)
+
+Keep the agent in discussion mode - no code execution yet. Provide necessary context. For complex features, thorough planning preserves the necessary context between executions.
+
+The amount of planning needed depends on the task. Small tasks require minimal planning, but skipping planning for large tasks virtually guarantees poor results.
+
+Planning needs substantial context. This is where tools like [Nx's AI integration](/features/enhance-AI) shine by providing agents with derived context about your codebase architecture, team responsibilities, and organizational boundaries. All of these helps LLMs and humans operate from the same architectural and organizational context.
+
+For large changes, it's a good idea to persist the created plan to disk.
+
+### Act
+
+![Acting Phase Workflow](/blog/images/articles/ai-flow-acting-phase.avif)
+
+Ask the agent to execute the plan.
+
+Stay engaged. Monitor execution and check work in progress. Halt immediately if problems arise or new information emerges, then return to planning. Sometimes Agents can get stuck. If this happens, remind them of their original objective. A useful technique is to break the current task into smaller subtasks and have the agent focus on the first one.
+
+An Agent's effectiveness increases dramatically when it can use higher-level operations. Without these, ensuring consistency and adherence to best practices becomes much harder. This primarily affects real organizations, not demo projects, as demos don't need to be correct or follow best practices. That was a big focus for us when developing Nx MCP (which provides many tools that help guarantee consistency and compliance with standards) because of us working with a lot of large companies with 1000s of engineers working in the same org.
+
+Agents excel at being almost right but struggle with executing exactly what's required. Good interactions should include requesting user input for high-impact operations that are difficult to adjust later (like creating a new package). For instance, when using Nx, an Agent would open a UI with pre-filled generator options that users can modify and confirm. The Agent then continues the work from that point. Have a look at our [latest blog post for a deeper dive into what this looks like](/blog/nx-generators-ai-integration).
+
+If things go sideways, don't hesitate to reset: dump context, revert changes, and start fresh. These tools drastically reduce "grunt work" costs, making restarts practical.
+
+### Review
+
+![Review Phase Workflow](/blog/images/articles/ai-flow-review-phase.avif)
+
+Even though I try to keep a document where I note things that will require a follow-up, most likely won't keep pace with the agent's output. That's why it's important to do a thorough review afterward. Most often I make small changes directly, but sometimes I ask the agent to make them for me.
+
+### Repeat
+
+The process can vary, but it follows this general pattern.
+
+**Common mistakes**: skipping either "Plan" or "Repeat" - both are essential. Do not skip them when working on real projects.
+
+## Using Rules and Persistent Context
+
+Every AI coding assistant offers automatic prompt inclusion: Cursor rules, Windsurf rules etc. These are essential for consistent output.
+
+Keep it manageable - a few hundred lines work well. Your rules should document coding style, recurring patterns, and in some cases architecture. If you repeat yourself during development, encode it in rules.
+
+For persistent prompts, create a human-readable version and let AI optimize it for machines. AI excels at prompt engineering - focus on tweaking, not creating from scratch.
+
+### Example Workflow for Rules
+
+1. Create `STANDARDS.md` with coding standards
+2. Review with AI and request clarifications
+3. Identify gaps (AI can help) and address them
+4. Format standards appropriately
+5. Update rules files
+
+I have a Claude project where I discuss coding standards and other topics that often end up in rules files.
+
+### For Working on Features
+
+For every major PR I worked on, I often kept a notes document with the issue description, my thoughts, architecture notes, specs, TODOs, and progress. Turns out, wonderful things happen when you let AI see it.
+
+Maintain a `PR.md` at project root. Start with issue instructions and update it with any relevant information about the PR you are working on. With this, you can instantly provide context in any chat.
+
+Create implementation steps and save the checklist in `PR.md`. Start separate chats for each step, checking off as you complete them. Add new steps as things become clearer.
+
+## Quick Recommendations
+
+### Documentation & Planning
+
+- Use AI to document - documentation costs drop 10x with AI assistance
+- Leverage AI for planning - preparation costs decrease drastically
+- Explicitly reference examples to produce consistent documents
+- Use Claude Projects (or other similar affordances) to improve repeatability
+
+### Debugging & Fixing
+
+- Always plan/ask before fixing a non-trivial issue
+- Paste a stack trace and ask to explain what caused it. AI is very good at this.
+- When dealing with non-trivial problems, ask for several solutions
+
+### Session Management
+
+- Commit code frequently (you will undo often)
+- Keep chat sessions short to prevent context drift
+- Start fresh chats for each issue/task
+- If you use Claude Code, use "/compact" to keep a summary in the context.
+- If not available, do an ad-hoc compact by requesting a summary before starting a new chat
+
+### Task Structure
+
+- Plan first, then divide into incremental tasks
+- Keep individual tasks straightforward and simple
+- Focus on iterative tasks - AI performs better with focused objectives
+
+### Coding Approach
+
+- Maintain consistent code style - AI generates better matches when surrounding code is consistent
+- Avoid clever solutions - AI is much better at dealing with boring code
+- Use well-known idioms - AI knows them and can process them very effectively
+- Use AI to generate or modify tests. Tests are often linear, simple and formulaic. AI excels at manipulating such code.
+
+## Handling Hallucinations
+
+Hallucinations remain a significant challenge for LLMs, though the problem has improved over the past year. If a solution seems suspiciously perfect, prompting the AI with "are you sure?" often triggers self-correction. This issue is diminishing as more tools provide MCP servers with access to current documentation. The Nx MCP server, for example, reduces hallucinations by providing direct access to up-to-date documentation.
+
+## Understand What Models are Good At
+
+Every AI journey follows the same arc: initial awe at its superhuman abilities, then disillusionment when it fails at basic math or fabricates facts, before finally reaching a balanced understanding of AI's strengths and limitations.
+
+## AI as a Mighty Refactoring Tool
+
+AI excels with formulaic, pattern-based code - much like a powerful template engine. **Tests represent the perfect application**: developers can achieve higher quality and greater coverage while investing significantly less time.
+
+Similarly, AI transforms documentation from time-consuming to nearly effortless. The cost approaches zero for both inline module comments and comprehensive documentation files, eliminating any practical excuse for poor documentation.
+
+Code translation tasks - converting between natural language and programming syntax - also benefit tremendously from AI assistance, dramatically accelerating these previously tedious processes.
+
+Once you recognize that AI can make some operations almost free while others remain beyond its reach, you start structuring your work differently. You divide tasks into units where AI can handle specific parts in isolation. It's like refactoring tools—knowing they can make certain transformations free changes how you approach large code changes.
+
+## AI as a Debugger
+
+When I work on distributed systems and hit a problem, AI rarely offers an immediate solution, but it's still invaluable. Explaining complex problems to a system capable of understanding often reveals connections your mind hasn't made.
+Effective AI debugging strategies:
+
+- Ask "What is missing?" when evaluating a theory
+- Ask for alternative theories
+- Use AI to organize and format disorganized thoughts
+- Also, AI excels at pattern matching, so feed it logs and see what it finds.
+
+Nx 21+ can pipe its terminal output (and other information) to your AI agent, so you can simply ask "Why is my command failing?"
+
+## AI as Stack Overflow
+
+AI delivers immense value as an educational tool. Unlike static resources, AI enables true dialogue. You can:
+
+- Ask questions in any format
+- Request simplified explanations when confused
+- Test your understanding by explaining concepts back
+- Take personalized quizzes
+- Receive evaluations of your comprehension
+- Get recommendations for logical next learning steps
+
+Make sure the AI gets this information through web search to provide up-to-date results.
+
+Another technique I use is when learning a new tool, I provide the website URL and ask Claude to review the entire site to answer a set of questions. This saves me hours of research and lets me explore documentation in a very different way.
+
+Similar to Stack Overflow, AI can have a negative effect on learning because it provides answers without the supporting information needed to build a mental model and understand why the answer makes sense. For me, it's not a replacement for a good book or course, but a good complementary tool.
+
+## The Long View: Building Sustainable AI Workflows
+
+The trajectory is clear: developers who invest in proper AI workflows and understand the tools' capabilities will have a growing competitive advantage. **The key is being intentional about your approach rather than hoping that better prompts will magically solve workflow problems.**
+
+Start small, experiment with the patterns outlined here, and gradually build your AI-assisted development skills. The investment in learning proper workflows pays dividends as the technology continues to evolve.
+
+---
+
+Learn more:
+
+- 🧠 [Nx AI Docs](/features/enhance-AI)
+- 📖 [Nx and AI: Why They Work so Well Together](/blog/nx-and-ai-why-they-work-together)
+- 📖 [Combining Predictability and Intelligence With Nx Generators and AI](/blog/nx-generators-ai-integration)
+- 👩‍💻 [Nx GitHub](https://github.com/nrwl/nx)
+- 👩‍💻 [Nx Console GitHub](https://github.com/nrwl/nx-console)
+- 💬 [Nx Official Discord Server](https://go.nx.dev/community)
+- 📹 [Nx Youtube Channel](https://www.youtube.com/@nxdevtools)

docs/blog/2025-05-28-build-better-shipfaster-monorepos-apps-component-libraries-with-nx-cloud.md

@@ -1,16 +1,16 @@
 ---
-title: "**Build Better,Ship ****Faster: ****Monorepos, Apps, & Component Libraries **with Nx Cloud"
+title: "Build Better, Ship Faster: Monorepos, Apps, & Component Libraries with Nx Cloud"
 description: "Unlock faster development and more efficient CI/CD workflows with Nx and Bitovi.
 
 Bitovi's Ilyass Elfouih and Nx's Jordan Powell will walk through a **real-world scenario** where a frontend team updates a shared component, faces a classic code owner approval challenge, and uses Nx Cloud to fix and validate the change without triggering a full test suite."
 date: 2025-05-14
-slug: 'build-bettershipfaster-monorepos-apps-component-libraries-with-nx-cloud'
+slug: 'build-better-shipfaster-monorepos-apps-component-libraries-with-nx-cloud'
 authors: ['Jordan Powell (Nx)', 'Ilyass Elfouih (Bitovi)']
 tags: [webinar]
 cover_image: /blog/images/2025-05-28/Nx-Partner-Webinar---May-2025.avif
 time: 1pm ET/5pm UTC
-status: Upcoming
-registrationUrl: https://bit.ly/4jQLCqp
+status: Past - Ungated
+registrationUrl: https://bit.ly/4kv5tfb
 ---
 
 **May 28, 2025 - 1pm ET/5pm UTC**
@@ -21,4 +21,4 @@ Unlock faster development and more efficient CI/CD workflows with Nx and Bitovi.
 
 Bitovi's Ilyass Elfouih and Nx's Jordan Powell will walk through a **real-world scenario** where a frontend team updates a shared component, faces a classic code owner approval challenge, and uses Nx Cloud to fix and validate the change without triggering a full test suite.
 
-{% call-to-action title="Register today!" url="https://bit.ly/4jQLCqp" description="Save your spot" /%}
+{% call-to-action title="View the recording" url="https://bit.ly/4kv5tfb" description="Watch on youtube" /%}

docs/blog/2025-05-28-nx-terminal-integration-ai.md

@@ -0,0 +1,115 @@
+---
+title: 'Your AI Assistant Can Now Read Your Terminal: Real-Time Development Error Fixing'
+slug: nx-terminal-integration-ai
+authors: ['Juri Strumpflohner']
+tags: ['nx', 'nx-console', 'ai', 'terminal']
+cover_image: /blog/images/articles/bg-nx-tui-llm-integration.avif
+description: 'Learn how Nx Console now enables AI assistants to read your terminal output in real-time, automatically detecting and fixing development errors as they happen.'
+youtubeUrl: https://youtu.be/Cbc9_W5J6DA
+pinned: false
+---
+
+{% callout type="deepdive" title="Series: Making your LLM smarter" expanded=true %}
+
+- [Nx Just Made Your LLM Way Smarter](/blog/nx-just-made-your-llm-smarter)
+- [Making Cursor Smarter with an MCP Server For Nx Monorepos](/blog/nx-made-cursor-smarter)
+- [Nx MCP Now Available for VS Code Copilot](/blog/nx-mcp-vscode-copilot)
+- [Nx and AI: Why They Work so Well Together](/blog/nx-and-ai-why-they-work-together)
+- [Save Time: Connecting Your Editor, CI and LLMs](/blog/nx-editor-ci-llm-integration)
+- [Enhancing Nx Generators with AI: Predictability Meets Intelligence](/blog/nx-generators-ai-integration)
+- **Your AI Assistant Can Now Read Your Terminal: Real-Time Development Error Fixing**
+- [Introducing Self-Healing CI for Nx and Nx Cloud](/blog/nx-self-healing-ci)
+- [Analyze Your Nx Cloud Runs With Your AI Assistant](/blog/nx-cloud-analyze-via-nx-mcp)
+- [Automatically Fix your CI Failures with JetBrains AI Assistant](/blog/jetbrains-ci-autofix)
+
+{% /callout %}
+
+One of the most frustrating aspects of working with AI coding assistants has been **their inability to see what's happening in your terminal**. When your development server crashes with an error, you'd have to manually copy the error message, paste it into your chat, and explain the context.
+
+**Not anymore.** We've just shipped an integration that allows your AI assistant to access your [Nx terminal](/blog/nx-21-terminal-ui), the tasks that are currently running as well as their output. This opens up a whole new interaction workflow where you don't have to provide context: the LLM "would just know" about it. Let's dive in.
+
+{% toc /%}
+
+## Let's backtrack for a second - what's this actually about?
+
+Besides helping you write new code, LLMs are also great at helping you debug issues. Stacktraces are ideal for that because they provide a lot of information. To involve your AI assistant, you'd usually copy & paste the stacktrace to your chat window, or use the "Add to Chat" functionalities of editors.
+
+![](/blog/images/articles/llm-add-to-chat.avif)
+
+While this works perfectly, **we figured we can do better**. We want to open up the workflow so that the LLM can independently - even as part of a separate interaction - just grab the necessary context from the terminal to satisfy a user request with more precision.
+
+To demo that, I can just ask `What's currently running in my terminal` or even more concretely `Help me fix my broken dev server`:
+
+![](/blog/images/articles/nx-tui-llm-fix-my-broken-code.avif)
+
+As a side note, for convenience, we also added a shortcut directly to our Nx terminal UI that allows you to send the output to a new LLM chat conversation.
+
+![](/blog/images/articles/nx-tui-send-to-llm.avif)
+
+## Technical architecture: How does this actually work?
+
+![](/blog/images/articles/nx-llm-terminal-integration.avif)
+
+This integration leverages several components working together:
+
+- **Nx Console as the MCP Host**: [Nx Console](/getting-started/editor-setup) acts as the Model Context Protocol (MCP) host, providing the communication bridge between your AI assistant and the Nx ecosystem.
+
+- **JSON RPC Communication**: When you launch the new Nx terminal UI, Nx Console establishes a JSON RPC server that creates a communication channel between the terminal running your tasks, the Nx Console instance in your editor, and your AI assistant through the MCP.
+
+- **Nx Terminal UI**: The new [Nx Terminal UI](/blog/nx-21-terminal-ui) connects to this RPC server to send updates on the current tasks that are run, their state and output.
+
+When the LLM assistant requires knowledge about the tasks or terminal output, it communicates via the Nx MCP hosted by Nx Console, which in turn returns the relevant data.
+
+Some things to point out here:
+
+- **This also works if you run the Nx TUI in another terminal, like Warp.** It doesn't have to run within VSCode or Cursor. As long as Nx Console runs in one of the editors (for this workspace), the Nx TUI would be able to connect to it.
+- All of this is also **made in a way that it is "workspace-aware"**, ensuring that the terminal communication is tied to the correct workspace instance, so you don't get confused data if you have multiple Nx workspaces running simultaneously.
+
+## Why this integration is powerful
+
+This terminal integration gives your AI assistant **complete visibility into the three critical areas of your development workflow**:
+
+- **Source Code**: Your LLM already has access to your codebase, which gets significantly enhanced by the [Nx MCP's higher-level structural understanding](/blog/nx-mcp-vscode-copilot) of workspace architecture, project relationships, and monorepo organization.
+
+- **Browser Environment**: For web applications, you can combine this with browser monitoring tools like [Playwright MCP or BrowserTools MCP](https://github.com/AgentDeskAI/browser-tools-mcp) to give your AI assistant access to console logs, network requests, and browser dev tools data.
+
+- **Terminal Output**: And now, with this new feature, your AI assistant has direct access to terminal processes, build outputs, error logs, and running tasks.
+
+**But this isn't just about convenience** (though never having to copy-paste stack traces again is pretty amazing). The real power lies in **autonomous context retrieval**: your LLM can now independently call into terminal processes and output logs whenever it determines this information might be useful to satisfy your request, without you explicitly saying "fix my terminal" or "look at the terminal."
+
+## Getting started
+
+To use this feature, you'll need:
+
+1. **[Nx Console](/getting-started/editor-setup)** installed in your editor
+2. **The [Nx MCP server configured](/features/enhance-AI)** for your AI assistant
+3. **The new Nx terminal UI** (available in the latest version of Nx)
+
+Once set up, simply run your development tasks through Nx and start asking your AI assistant for help when issues arise.
+
+## Looking forward
+
+This terminal integration represents another crucial step in our core mission at Nx: **improving developer experience and making LLMs truly usable for large-scale workspaces**. The key to achieving this lies in providing LLMs with comprehensive context, enabling them to make better-informed decisions rather than operating in isolation.
+
+Large monorepos present unique challenges that generic AI assistants simply can't handle effectively without deep contextual understanding. By systematically exposing different layers of your development environment to LLMs, we're building a complete picture that enables truly intelligent assistance:
+
+- **Workspace Structure Context**: Through our [MCP integration](/blog/nx-mcp-vscode-copilot), LLMs gain architectural awareness of your monorepo - understanding project relationships, dependencies, and organizational patterns that are crucial for making informed development decisions.
+
+- **CI Pipeline Context**: Our [CI integration](/blog/nx-editor-ci-llm-integration) provides LLMs with real-time visibility into build failures, test results, and deployment status, enabling proactive problem-solving before issues compound.
+
+- **Terminal Context**: And now, with this terminal integration, LLMs have access to local development processes, build outputs, and runtime errors - completing the picture of your development environment.
+
+This isn't just about convenience (though never having to copy-paste stack traces is pretty amazing). **It's about fundamentally changing how AI assistants understand and interact with complex development workflows.** When an LLM has visibility into your workspace architecture, your CI pipeline status, and your local terminal output, it can provide contextually relevant assistance that actually scales with your codebase complexity.
+
+We're already working on even more "agentic" features that will further enhance this integrated experience, **making your AI assistant a reliable peer programmer** that actually provides value.
+
+---
+
+Learn more:
+
+- 🧠 [Nx AI Docs](/features/enhance-AI)
+- 🛠️ [Nx Terminal UI](/blog/nx-21-terminal-ui)
+- 👩‍💻 [Nx GitHub](https://github.com/nrwl/nx)
+- 👩‍💻 [Nx Console GitHub](https://github.com/nrwl/nx-console)
+- 💬 [Nx Official Discord Server](https://go.nx.dev/community)
+- 📹 [Nx Youtube Channel](https://www.youtube.com/@nxdevtools)

docs/blog/2025-05-29-mcp-server-with-nx.md

@@ -0,0 +1,370 @@
+---
+title: 'Building an MCP Server with Nx'
+slug: building-mcp-server-with-nx
+authors: ['Max Kless']
+tags: ['nx', 'mcp', 'ai', 'node']
+cover_image: /blog/images/articles/bg-building-mcp-server.avif
+description: 'Learn how to build a Model Context Protocol (MCP) server using Nx to make your applications AI-ready.'
+---
+
+Since the Model Context Protocol (MCP) [was released by Anthropic in late 2024](https://www.anthropic.com/news/model-context-protocol), it has quickly become an important part of the AI ecosystem. The [MCP provides an open standard](https://modelcontextprotocol.io/introduction) for connecting AI agents to the rest of the world - the web, software systems and developer tools, just to name a few examples.
+
+We've been busy building the [Nx MCP server](/features/enhance-AI), which gives LLMs deep access to your monorepo's structure. It helps AI tools to better understand your workspace architecture, browse the Nx docs and even trigger actions in your IDE like executing generators or visualizing the graph.
+
+{% youtube
+src="https://www.youtube.com/watch?v=fPqPh4h8RJg"
+title="The MCP Server that fixes CI for you"
+width="100%" /%}
+
+There are many examples of MCP servers for popular tools popping up all over the place. [Check out the official MCP repo](https://github.com/modelcontextprotocol/servers) to see a long list of reference servers as well as official and community integrations.
+
+Whatever you're building, it's becoming more and more important to ensure that AI systems can interact with your software. So let's learn how to build your very own MCP server to make your technology be usable for AI - all from an Nx monorepo!
+
+{% toc /%}
+
+---
+
+In this series of blog posts, we'll be using a fictional startup as an example: Astra Arcana - a bewitched SaaS company that lets you cast spells from anywhere with a few simple clicks.
+
+![Screenshot of the Astra Arcana app visualizing a spell](/blog/images/2025-05-29/astra-arcana-screenshot.avif)
+
+You can go and try casting some spells right away at [https://astra-arcana.pages.dev/](https://astra-arcana.pages.dev/)
+
+Of course, like any modern software company, they need to be ready for the coming shift towards AI - let's help them by building an MCP server that lets you browse ingredients and cast spells directly from your AI chat!
+
+---
+
+## Setting up the Server
+
+{% callout type="info" title="Code Along" %}
+If you want to code along and build your own mcp server, clone the [https://github.com/MaxKless/astra-arcana](https://github.com/MaxKless/astra-arcana) repo on GitHub to get started.
+{% /callout %}
+
+Astra Arcana is built in an Nx monorepo, where the web app and api live. There's also a shared types library as well as the Typescript SDK, which lets users programmatically cast spells.
+
+```
+apps
+ ├── web
+ └── api
+libs
+ ├── spellcasting-types
+ └── spellcasting-sdk
+```
+
+We will create a new Node application that contains our MCP server and use the Typescript SDK to power it.
+
+### Creating the MCP Server
+
+MCP are JSON-RPC servers that communicate with clients via stdio or http. Thankfully, [the official Typescript SDK](https://github.com/modelcontextprotocol/typescript-sdk) abstracts away large pieces of the implementation, making it easier to get started - let's get started by installing it.
+
+```shell
+npm install @modelcontextprotocol/sdk
+```
+
+We'll continue by installing the `@nx/node` plugin and using it to generate a new Node application:
+
+```shell
+npx nx add @nx/node
+```
+
+```shell
+npx nx generate @nx/node:application --directory=apps/mcp-server --framework=none --no-interactive
+```
+
+This generates a basic node application:
+
+```
+UPDATE package.json
+CREATE apps/mcp-server/src/assets/.gitkeep
+CREATE apps/mcp-server/src/main.ts
+CREATE apps/mcp-server/tsconfig.app.json
+CREATE apps/mcp-server/tsconfig.json
+UPDATE nx.json
+CREATE apps/mcp-server/package.json
+UPDATE tsconfig.json
+```
+
+In `package.json`, you'll see that Nx has configured a build and serve target for our app that uses `webpack`. Now that our setup is ready, let's implement the actual server.
+
+First, let's import some things and set up an instance of `McpServer`. This is part of the MCP SDK and will take care of actually implementing the [Protocol Layer](https://modelcontextprotocol.io/docs/concepts/architecture#core-components) of the [MCP specification](https://modelcontextprotocol.io/specification/2025-03-26), for example how to communicate with the client.
+
+```ts {% fileName="apps/mcp-server/src/main.ts" %}
+import { SpellcastingSDK } from '@astra-arcana/spellcasting-sdk';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+const server = new McpServer({
+  name: 'Astra Arcana',
+  version: '1.0.0',
+});
+```
+
+Next, we'll register a set of MCP tools. A tool is essentially a function that the AI model can call, passing some input parameters if necessary. Instead of constructing API calls manually, our tools will expose three main parts of casting a spell with the Spellcasting SDK: Ingredients, Incantations and Recipes. This is really the core piece of the MCP server, as it defines what it can do. There are [other features you can implement](https://modelcontextprotocol.io/docs/concepts/resources), but currently, tools are by far the most widely supported and important part.
+
+```ts {% fileName="apps/mcp-server/src/main.ts" %}
+const sdk = new SpellcastingSDK();
+
+server.tool('get-ingredients', async () => {
+  const ingredients = await sdk.getIngredients();
+  return {
+    content: [{ type: 'text', text: JSON.stringify(ingredients) }],
+  };
+});
+
+server.tool('get-incantations', async () => {
+  const incantations = await sdk.getIncantations();
+  return {
+    content: [{ type: 'text', text: JSON.stringify(incantations) }],
+  };
+});
+
+server.tool('get-recipes', async () => {
+  const recipes = await sdk.getRecipes();
+  return {
+    content: [{ type: 'text', text: JSON.stringify(recipes) }],
+  };
+});
+```
+
+Finally, let's implement the Transport Layer, letting the MCP server listen to and send messages via process inputs and outputs (stdio). It's only a few lines of code:
+
+```ts {% fileName="apps/mcp-server/src/main.ts" %}
+const transport = new StdioServerTransport();
+(async () => {
+  await server.connect(transport);
+})();
+```
+
+And just like that, we've built our very own MCP server! Let's make sure it works.
+
+## Testing with the MCP Inspector
+
+Anthropic has not just come up with the protocol, they've also created [a great ecosystem around it](https://github.com/modelcontextprotocol): Various SDKs, reference servers and a visual testing tool: [The MCP Inspector](https://github.com/modelcontextprotocol/inspector).
+
+Let's modify our serve target to use the Inspector, letting us explore our newly created server. First, delete the existing `serve` target in `apps/mcp-server/package.json` , as it doesn't really apply to our use case. Replace it with this
+
+```json {% fileName="apps/mcp-server/package.json" %}
+"serve": {
+  "command": "npx -y @modelcontextprotocol/inspector node ./apps/mcp-server/dist/main.js",
+  "dependsOn": ["build"],
+  "continuous": true
+}
+```
+
+Let's break it down:
+
+- the command runs the Inspector, pointing to the build output location of our MCP server
+- `"dependsOn": ["build"]` tells nx to always run the build before this target, making sure that the bundled javascript is available
+- `"continuous": true` marks the serve as a [continuous task](/recipes/running-tasks/defining-task-pipeline#continuous-task-dependencies) so that will work properly in more complex task pipelines
+
+You can see the result by running `npx nx serve mcp-server` and looking at the website it spins up (usually on [`http://localhost:6274`](http://127.0.0.1:6274/) ).
+
+The sidebar contains all the information required to start the server - here the `STDIO` transport is correctly preselected as well as the command needed to start the server.
+
+![Screenshot of the MCP Inspector sidebar](/blog/images/2025-05-29/mcp-inspector-sidebar.avif)
+
+After clicking on the Connect button, the server is started in the background and you'll be able to see the available tools and call them under the `Tools` tab.
+
+![Screenshot of the MCP Inspector showing the available tools](/blog/images/2025-05-29/mcp-inspector-tools.avif)
+
+## Agents that can take actions
+
+The `get-*` tools that we've built are already super useful and budding spellcasters will be glad to have help in perfecting their concoctions and learning ancient incantations. However, where the power of AI agents really starts to shine is when they go beyond just reading data and start taking actions. Let's give AI the ability to cast spells. 🪄
+
+We'll register another tool in `apps/mcp-server/src/main.ts`
+
+```ts {% fileName="apps/mcp-server/src/main.ts" %}
+import { z } from 'zod';
+
+// ... previous tools
+
+server.tool(
+  'cast-spell',
+  'Lets the user cast a spell via the Astra Arcana API.',
+  { ingredients: z.array(z.string()), incantations: z.array(z.string()) },
+  async ({ ingredients, incantations }) => {
+    const result = await sdk.castSpell(ingredients, incantations);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result) }],
+    };
+  }
+);
+```
+
+There are two key differences in this tool definition:
+
+- We've passed a description string as the second argument. You can do this for every tool in order to describe what to use it for and what will happen when the agent calls it. `cast-spell` is sort of self-explanatory but it's still good practice to add a description and increase the model's chances of picking the right tool for the job. You can even add more annotations to mark a tool as read-only, destructive or more.
+- We've passed an object that defines the shape of the input using [`zod`](https://zod.dev/). This lets the agent know how to structure the inputs that are passed to the tool. `ingredients` and `incantations` as arrays of strings aren't very complicated, but you could also add descriptions to each individual option to explain what it does. The full feature set of `zod` is available to define exactly what's possible with each tool.
+
+Now, let's try it out in an actual agent. I'll use VSCode & GitHub Copilot for this but any agent implementation with MCP support will do. I really like [Windsurf](https://docs.windsurf.com/windsurf/getting-started) or [Cursor](https://www.cursor.com/), for example.
+
+Register the MCP server by editing `.vscode/mcp.json` (or using the built-in command):
+
+```json {% fileName=".vscode/mcp.json" %}
+{
+  "servers": {
+    "astra-arcana": {
+      "command": "node",
+      "args": ["/path/astra-arcana/apps/mcp-server/dist/main.js"]
+    }
+  }
+}
+```
+
+Once you open a Copilot chat in Agent mode, the MCP server will start automatically and you should see all four tools available
+
+![Screenshot of the VSCode quickinput listing available MCP tools](/blog/images/2025-05-29/mcp-list-vscode.avif)
+
+Let's try to cast a spell! For obvious reasons, I want to make sure that I'm writing high-quality blog posts and could use a magic boost. You can see that the AI agent uses all the tools to figure out what's available and then tries to cast the spell. Some models might ask for permission first or ask follow up questions to make sure they're getting it right.
+
+![Screenshot of a conversation with Copilot that uses the built MCP tools](/blog/images/2025-05-29/copilot-using-tools.avif)
+
+After casting, you can head over to [https://astra-arcana.pages.dev/](https://astra-arcana.pages.dev/) and check the logs to see your spell! 🎉
+
+![Screenshot of the Astra Arcana app showing the cast spell in the browser](/blog/images/2025-05-29/astra-arcana-logs.avif)
+
+## Publishing to npm
+
+Of course, now that we've built our magical MCP server, we want to make sure people can use it easily. Let's go through the process of publishing an executable file to the npm registry. In the future, anyone will be able to run `npx @astra-arcana/mcp-server` and spin it up immediately!
+
+{% callout type="note" title="Learn More About nx release" %}
+This section goes over the release process of this specific example. If you want to learn how to use `nx release` in detail, I recommend checking out Juri's great course on the topic: https://www.epicweb.dev/tutorials/versioning-and-releasing-npm-packages-with-nx
+{% /callout %}
+
+### Publishing Pre-Requisites
+
+In order to have our bundled code be executable via npx, we need to add a shebang (`#!/usr/bin/env node`) to the first line of the file. We'll make sure this is added in a new script in the `apps/mcp-server` directory called `setup-publish.js`.
+
+```js {% fileName="apps/mcp-server/setup-publish.js" %}
+import path from 'path';
+import fs from 'fs';
+
+const distDir = path.resolve(import.meta.dirname, './dist');
+const distMainJsPath = path.resolve(distDir, 'main.js');
+const mainJsContent = fs.readFileSync(distMainJsPath, 'utf8');
+const shebang = '#!/usr/bin/env node\n';
+
+if (!mainJsContent.startsWith(shebang)) {
+  fs.writeFileSync(distMainJsPath, shebang + mainJsContent);
+  console.log('Shebang added');
+}
+
+console.log('Setup completed successfully!');
+```
+
+We'll also set up a target that calls this script after making sure the main bundle is built.
+
+```json {% fileName="apps/mcp-server/package.json" %}
+"setup-publish": {
+  "command": "node apps/mcp-server/setup-publish.js",
+  "dependsOn": ["build"]
+}
+```
+
+While we're in `package.json` , let's also make sure that our package is publishable and let `npx` and similar tools know where to find the executable javascript file.
+
+```diff {% fileName="apps/mcp-server/package.json" %}
+{
+  "name": "@astra-arcana/mcp-server",
+  "version": "0.0.1",
+- "private": true,
++ "private": false,
++ "bin": "./main.js",
+  // ...
+```
+
+### Local Publishing with Verdaccio
+
+{% callout type="warning" title="Publishing" %}
+Keep in mind that the `@astra-arcana/mcp-server` package already exists on the official npm registry, so we will only publish to a local registry.
+{% /callout %}
+
+At Nx, we use an awesome open-source tool called [Verdaccio](https://verdaccio.org/). It's a lightweight implementation of a local npm registry - let's use it to test out our publishing flow.
+
+You can add verdaccio to the repo by running the `setup-verdaccio` generator:
+
+```shell
+npx nx g @nx/js:setup-verdaccio
+```
+
+This will create a verdaccio config and an nx target to spin it up at the root of our workspace. Start the local registry by running.
+
+```shell
+npx nx run @astra-arcana/source:local-registry
+```
+
+On [`http://localhost:4873/`](http://localhost:4873/) , you'll see an instance of verdaccio running with no packages published yet. Let's change that!
+
+### Configuring Nx Release
+
+Now that everything is set up, let's configure `nx release` to actually version our package, generate changelogs and publish to npm.
+
+There are a couple of things we want to configure. Check out [the comprehensive release documentation](/features/manage-releases) to learn more about the different configuration options.
+
+- Since we're in a monorepo with different kinds of packages, we have to let `nx release` know which ones to configure releases for - in this case, only the `mcp-server` app
+- When releasing, we need to make sure that not only is the version in the repo's `package.json` is incremented, but also the version in the `dist` folder that we'll actually release from. We can do this by setting `manifestRootsToUpdate`.
+- We have to make sure the `dist` folder exists, so we'll run our new `setup-publish` action first by specifying the command in `preVersionCommand` .
+- Since our mcp server will be released independently, we configure the changelogs to be generated per-project instead of for the entire workspace.
+
+```json {% fileName="nx.json" %}
+"release": {
+  "projects": ["mcp-server"],
+  "version": {
+    "manifestRootsToUpdate": [
+      "{projectRoot}",
+      "{projectRoot}/dist"
+    ],
+    "preVersionCommand": "npx nx run mcp-server:setup-publish"
+  },
+  "changelog": {
+    "projectChangelogs": true,
+    "workspaceChangelog": false
+  }
+}
+```
+
+This is enough to configure `nx release` for our exact use case. With this, we can run `npx nx release --dry-run` . Nx will run the `setup-publish` target, prompt you for the kind of version change that's happening and give you a preview of what the result would be.
+
+![Screenshot of the version prompt asked by nx release](/blog/images/2025-05-29/nx-release-prompt.avif)
+
+If you're happy with the results, rerun the command without `--dry-run` and watch as `nx release` does its _magic_. The versions will be updated across both `package.json` files, and a changelog file, a git commit and tag will be created.
+
+In order to release to npm, we have to add some final configuration to `nx.json` .
+
+```json {% fileName="nx.json" %}
+"targetDefaults": {
+  // ... other config
+  "nx-release-publish": {
+    "options": {
+      "packageRoot": "{projectRoot}/dist"
+    }
+  }
+}
+```
+
+This will tell the automatically generated `nx-release-publish` target where to find the built files so that it can publish them to npm (or verdaccio, in our case). After running `npx nx release publish` , refresh Verdaccio to see the successfully published package! 🎉 You can spin up the MCP server using the published version by running `npx @astra-arcana/mcp-server` and try it out.
+
+That's it! You can view the `@astra-arcana/mcp-server` package on npm here: https://www.npmjs.com/package/@astra-arcana/mcp-server
+
+## Looking back and into the Future
+
+We've come a long way. Looking back, we've
+
+- learned about the Model Context Protocol
+- set up a node application and built an MCP server with it
+- used the MCP Inspector to test and debug our implementation
+- used AI agents to cast spells 🪄
+- learned how to publish an executable package to npm
+
+The next post in this series will dive into implementing a different MCP transport layer in streamable HTTP and hosting our server on Cloudflare!
+
+---
+
+Learn more:
+
+- 📖️ [Blog: AI Series](/blog/nx-mcp-vscode-copilot)
+- 🧠 [Nx AI Docs](/features/enhance-AI)
+- 👩‍💻 [Nx GitHub](https://github.com/nrwl/nx)
+- 👩‍💻 [Nx Console GitHub](https://github.com/nrwl/nx-console)
+- 💬 [Nx Official Discord Server](https://go.nx.dev/community)
+- 📹 [Nx Youtube Channel](https://www.youtube.com/@nxdevtools)

docs/blog/2025-06-12-cve-2025-36852-critical-cache-poisoning-vulnerability-creep.md

@@ -0,0 +1,101 @@
+---
+title: 'CVE-2025-36852: Critical Cache Poisoning Vulnerability Affects Multiple Build Systems'
+slug: cve-2025-36852-critical-cache-poisoning-vulnerability-creep
+authors: ['Victor Savkin']
+tags: ['caching', 'security']
+cover_image: /blog/images/2025-06-12/header.avif
+description: 'A critical security vulnerability called CREEP (Cache Race-condition Exploit Enables Poisoning) has been published as CVE-2025-36852. This vulnerability affects remote cache plugins across numerous build systems, including Nx.'
+---
+
+A critical security vulnerability called **CREEP** (Cache Race-condition Exploit Enables Poisoning) has been published as **CVE-2025-36852**. This vulnerability affects remote cache plugins across numerous build systems, including Nx.
+
+The CREEP vulnerability allows any contributor with pull request privileges to inject compromised artifacts into production environments without detection. While it primarily impacts bucket-based caching solutions (such as S3, GCS, or similar object storage), it can also affect other build systems with similar caching architectures.
+
+**Key Points:**
+
+- Nx without remote cache is **NOT** affected
+- Nx Cloud is **NOT** affected due to its security architecture
+- Review this post to determine if your self-hosted cache solution is vulnerable
+
+{% callout type="warning" title="DIY implementations are vulnerable" %}
+DIY remote caches are likely vulnerable. Scanners won't catch all affected implementations, so understanding the vulnerability is crucial.
+{% /callout %}
+
+## **Understanding the Vulnerability**
+
+A typical remote-cache flow using storage services follows these steps:
+
+1. Artifact construction (via bundler, compiler, etc.)
+2. Artifact packaging (by Nx or similar tool)
+3. Encryption and hashing of the packaged artifact
+4. Uploading the encrypted artifact to storage (transit)
+5. Storing artifacts until needed (at rest)
+6. Downloading from storage (transit)
+7. Decryption of the packaged artifact
+8. Unpacking
+
+Traditional cache poisoning attacks occur during transit or storage. The CREEP vulnerability is fundamentally different—it exploits the artifact construction phase itself, before any transit or storage security measures take effect. Because poisoning happens during construction, malicious data is sent and inserted into the cache through the system's own protected mechanisms.
+
+The security threat comes from creating a branch with the same file system state and simplified CI setup, such that it can execute the build before the main branch and upload the artifacts. It's caused by a race condition where the "first-to-cache-wins" principle applies. Whichever branch or PR first uploads a build artifact for a particular source file state will have its version used everywhere that source state appears, including production deployments.
+
+**Critical implications:**
+
+- Correct and poisoned artifacts are identical from a validation perspective
+- Checksums always match because poisoning occurs before hashing
+- No direct remote cache access is required to execute the attack
+- Standard detection methods cannot identify compromised artifacts
+- Traditional security protections (encryption, access control, key management) do not address this vulnerability
+
+## **Severity**
+
+CVE-2025-36852 has a severity score of 9.4 (Critical). It requires only low privileges and enables attackers to perform:
+
+- Code execution
+- Data exfiltration
+- Lateral movement
+- Additional attack vectors
+
+## **How Nx Cloud Prevents This Attack**
+
+Nx Cloud's architecture inherently prevents this vulnerability through:
+
+### **1\. Hierarchical Caching System**
+
+Nx Cloud implements a two-tier caching hierarchy:
+
+- Protected branches (like main) can write to the shared cache
+- Feature branches can only write to their own isolated, branch-scoped caches
+- All branches can read from the shared cache, but write privileges are strictly controlled
+
+### **2\. VCS Integration**
+
+Nx Cloud integrates directly with version control systems to enforce proper cache scoping, ensuring cache permissions align with code permissions.
+
+### **3\. Trust Boundaries**
+
+By establishing clear trust boundaries between different branch types, Nx Cloud eliminates the race condition that makes CVE-2025-36852 possible.
+
+## **What Organizations Should Do**
+
+### **For Nx Cloud users:**
+
+- No action required
+- Continue following security best practices for your CI/CD pipeline
+
+### **For systems using self-hosted cache:**
+
+1. Read and understand [CVE-2025-36852](https://www.cve.org/CVERecord?id=CVE-2025-36852)
+2. Review the detailed analysis at [https://nx.app/files/cve-2025-06](https://nx.app/files/cve-2025-06)
+3. Assess your exposure—any system where PRs and main branches share the same cache is vulnerable
+
+## **Conclusion**
+
+CVE-2025-36852 represents a serious threat to organizations using vulnerable caching systems. The "first-to-cache-wins" principle many build systems rely on creates an exploitable race condition that traditional security measures cannot address.
+
+**Action Required:**
+
+- If your organization uses bucket-based remote caching: immediate action is required
+- If your organization uses other self-hosted remote cache solutions: immediate review required (most self-hosted caching solutions across many build systems—not just JavaScript, but also Java—are affected)
+- If your organization uses custom tasks runners to implement remote caching: immediate review required
+- If using Nx without remote caching: no action is required
+- If using Nx with Nx Cloud: [Review your settings](/ci/concepts/cache-security#use-scoped-tokens-in-ci). If you are using default settings, no actions should be required.

docs/blog/2025-06-13-nx-21-2-release.md

@@ -0,0 +1,78 @@
+---
+title: 'Nx 21.2 Release: Big upgrades to Angular 20, NestJS 11, and Storybook 9'
+slug: nx-21-2-release
+authors: ['Philip Fulcher']
+tags: ['nx', 'release']
+cover_image: /blog/images/2025-06-13/header.avif
+description: 'Discover the latest in Nx 21.2, featuring Angular 20, NestJS 11, and Storybook 9'
+---
+
+Nx 21.2 is here! This release is focused on migrating to newer versions of some of our favorite technologies: Angular 20, Storybook 9, and NestJS 11.
+
+{% toc /%}
+
+## What's new in Angular 20
+
+![Angular logo on a dark background](/blog/images/2025-06-13/angular.avif)
+
+We'll leave it to the Angular team for [all the details](https://blog.angular.dev/announcing-angular-v20-b5c9c06cf301), but we wanted to call out a few changes that may impact Nx workspaces.
+
+### Structural directives deprecated
+
+It's time to part ways with structural directives like `*ngIf` and `*ngFor` and move on to control flow with `@if` and `@for`.
+
+Your workspace will be migrated to control flow by default during migration to Nx 21.2. If you’d like to hang on to that syntax a little longer, see our docs on [running migration in interactive mode](/recipes/tips-n-tricks/advanced-update) to skip this migration. Or use the newly introduced [Migrate UI in Nx Console](/recipes/nx-console/console-migrate-ui) to skip the migration.
+
+If you choose not to migrate now, you’ll be able to re-run the migration later:
+
+```shell
+nx g @angular/core control-flow
+```
+
+### Experimental support for Vitest from the Angular team
+
+Angular 20 introduces experimental support for [vitest](https://vitest.dev/) as a unit test runner. This is a fantastic addition to the core set of tools offered by the Angular team. Nx already offers vitest as an option when creating Angular apps and libraries, which is enabled by installing the [Analog plugin](https://analogjs.org/docs/features/testing/overview). You can choose between vitest support via the Analog plugin or through the new experimental vitest support. Nx generators will continue to use the Analog plugin. See the [Angular documentation](https://angular.dev/guide/testing/unit-tests) on how to use the vitest builder.
+
+### New style guide changes
+
+Last year, the Angular team opened [an RFC for changes to the style guide](https://github.com/angular/angular/discussions/58412), and Angular 20 implements the changes discussed. One of the bigger changes is that the Angular CLI has changed the format of filenames used when generating code. Generators provided by Nx will also follow the new style guide for new workspaces using Angular, but **the previous behavior will be retained for existing workspaces**. This is the same process the Angular CLI is following.
+
+As part of migrating to Nx 21.2, generator and schematic defaults will be set for your workspace so that filename suffixes continue to be added. You can see what that change looks like in the [migration documentation](/technologies/angular/api/migrations#setgeneratordefaultsforpreviousstyleguide).
+
+### BREAKING CHANGE: Angular 17 support removed
+
+Following our [support schedule](/technologies/angular/recipes/angular-nx-version-matrix), Angular 17 is no longer supported in Nx 21.2. If you want to continue with Angular 17, you'll need to postpone upgrading to Nx 21.2 for now.
+
+## NestJS 11 is here!
+
+![NestJS logo on a dark background](/blog/images/2025-06-13/nest.avif)
+
+Angular isn't the only framework getting attention with this release: we've also added support for [NestJS 11](https://trilon.io/blog/announcing-nestjs-11-whats-new)! This release brings better logging, more flexible microservices, and faster application startup. Your workspace will automatically be migrated to this new version as part of migrating to Nx 21.2.
+
+## Storybook 9 makes testing components better than ever
+
+![Storybook logo on a dark background](/blog/images/2025-06-13/storybook.avif)
+
+[Storybook 9 is here](https://storybook.js.org/blog/storybook-9/) with faster, leaner component tests powered by vitest. By default, your workspace will be automatically migrated to Storybook 9 as part of Nx 21.2. If you choose to skip that migration, you can re-run it later using our [Storybook 9 setup guide](/technologies/test-tools/storybook/recipes/storybook-9-setup).
+
+### BREAKING CHANGE: Deprecated Storybook generators removed
+
+Deprecated Storybook generators have been removed: `@nx/storybook:cypress-project`, `@nx/react-native:storybook-configuration`, `@nx/react-native:stories`, `@nx/react-native:component-story`. Use [`@nx/storybook:configuration`](/technologies/test-tools/storybook/api/generators/configuration) instead.
+
+## Migrating to latest version
+
+As always, to migrate to the latest version of Nx, you can use the `migrate` command:
+
+```shell
+nx migrate latest
+```
+
+Or if you're using Nx Console, you can use the recently introduced [Migrate UI](/recipes/nx-console/console-migrate-ui).
+
+Learn more:
+
+- 👩‍💻 [Automate updating dependencies](/features/automate-updating-dependencies)
+- 👩‍💻 [Nx GitHub](https://github.com/nrwl/nx)
+- 👩‍💻 [Nx Console GitHub](https://github.com/nrwl/nx-console)
+- 💬 [Nx Official Discord Server](https://go.nx.dev/community)
+- 📹 [Nx Youtube Channel](https://www.youtube.com/@nxdevtools)

docs/blog/2025-06-18-polygraph-launch-preview-conformance-workspace-graph-and-custom-workflows.md

@@ -0,0 +1,24 @@
+---
+title: "Polygraph Launch Preview: Conformance, Workspace Graph, and Custom Workflows"
+description: "Join us for a demo of the new polygraph features in Nx Cloud, launching this month with Nx Enterprise!
+
+These features are designed to extend some of the powerful benefits of an Nx workspace to multi-workspace environments and take Nx Cloud beyond CI. We'll cover our updated conformance dashboard, how to visualize dependencies across your repos, the new onboarding experience for workspaces that aren’t yet a part of Nx Cloud, and preview how Nx Cloud will be able to fix your code automatically via agentic AI."
+date: 2025-06-09
+slug: 'polygraph-launch-preview-conformance-workspace-graph-and-custom-workflows'
+authors: ['James Henry']
+tags: [webinar]
+cover_image: /blog/images/2025-06-18/June-2025-Webinar-Card.avif
+time: 10am ET/2pm UTC
+status: Past - Gated
+registrationUrl: https://go.nx.dev/june2025-webinar
+---
+
+**Jun 18, 2025 - 10am ET/2pm UTC**
+
+Presented by James Henry
+
+Join us for a demo of the new polygraph features in Nx Cloud, launching this month with Nx Enterprise!
+
+These features are designed to extend some of the powerful benefits of an Nx workspace to multi-workspace environments and take Nx Cloud beyond CI. We'll cover our updated conformance dashboard, how to visualize dependencies across your repos, the new onboarding experience for workspaces that aren’t yet a part of Nx Cloud, and preview how Nx Cloud will be able to fix your code automatically via agentic AI.
+
+{% call-to-action title="Download the recording" url="https://go.nx.dev/june2025-webinar" description="Sign up to gain access" /%}

docs/blog/2025-06-19-setup-tailwind4-npm-workspace.md

@@ -0,0 +1,238 @@
+---
+title: 'Configure Tailwind 4 with Vite in an NPM Workspace: The Complete Guide'
+slug: setup-tailwind-4-npm-workspace
+authors: ['Juri Strumpflohner']
+tags: ['nx', 'tailwind', 'vite', 'npm-workspaces', 'sync-generators']
+cover_image: /blog/images/articles/bg-tailwind-4-guide.avif
+description: 'Learn how to set up Tailwind CSS v4 with Vite in an NPM workspace monorepo, and automate your configuration with Nx Sync Generators for optimal performance.'
+youtubeUrl: https://youtu.be/tg3LnqhNNws
+---
+
+Tailwind CSS v4 brings revolutionary changes to how we configure and use the popular utility-first framework. The simplified setup eliminates configuration files and complex PostCSS setups - you just install, import, and start building. But when working in NPM workspaces or monorepos, there's still one crucial challenge: **how do you tell Tailwind which packages to scan for classes?**
+
+This guide walks you through setting up Tailwind v4 with Vite in an NPM workspace, then shows you how to automate the configuration using Nx Sync Generators to **eliminate manual maintenance**.
+
+{% github-repository url="https://github.com/juristr/tailwind4-vite-npm-workspaces" /%}
+
+{% toc /%}
+
+## Setting up Tailwind v4
+
+[Tailwind v4](https://tailwindcss.com/blog/tailwindcss-v4) introduced some nice simplifications when it comes to configuring Tailwind:
+
+- **No more `tailwind.config.js`** - The framework works out of the box
+- **Minimal dependencies** - Just `tailwindcss` and `@tailwindcss/vite` for Vite projects
+- **Simple CSS import** - Add `@import "tailwindcss"` to your stylesheet and you're ready
+
+Since we're using Vite in this workspace, we can leverage the dedicated Tailwind Vite plugin instead of PostCSS configuration. Here's what you need:
+
+Install the required packages at your workspace root:
+
+```json {% fileName="package.json" %}
+{
+  "devDependencies": {
+    "tailwindcss": "^4.0.0",
+    "@tailwindcss/vite": "^4.0.0"
+  }
+}
+```
+
+Configure your Vite setup:
+
+```typescript {% fileName="apps/shop/vite.config.ts" %}
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  // ... rest of your config
+});
+```
+
+Add the import to your main CSS file:
+
+```css {% fileName="apps/shop/src/styles.css" %}
+@import 'tailwindcss';
+```
+
+## The NPM workspace challenge
+
+Consider a typical e-commerce application structured as an NPM workspace:
+
+```plain
+apps/
+  shop/
+    src                  <<<< where tailwind is configured
+packages/
+  products/
+    feat-product-list/
+    feat-product-detail/
+    data-access-products/
+  shared/
+    ui/
+    utils/
+```
+
+At this point, your application will build and serve, but you'll notice that styles from your `packages/` are missing. In this modular setup, your main application (`shop`) depends on various feature packages, but **Tailwind only scans the main app by default**. This means styles defined in your packages won't be included in the final bundle, leading to missing styles and broken layouts.
+
+## Solving the scanning problem with @source directives
+
+Tailwind v4 introduces the `@source` directive to address exactly this problem. You can explicitly tell Tailwind which directories to scan by adding these directives to your CSS file:
+
+```css {% fileName="apps/shop/src/styles.css" %}
+@import 'tailwindcss';
+
+@source "../../../packages/products/feat-product-list";
+@source "../../../packages/products/feat-product-detail";
+@source "../../../packages/shared/ui";
+...
+```
+
+With these directives in place, Tailwind will scan the specified packages and include any utility classes found there. Your application styles will now work correctly across all packages.
+
+## Automating @source entries - enter Nx sync generators
+
+While `@source` directives solve the technical problem, they introduce a maintenance challenge:
+
+- **manual updates required** when adding or removing dependencies,
+- **easy to forget updating** the directives,
+- **hard-to-debug issues** since missing styles don't break builds (just cause visual problems), and
+- **team coordination** since every developer needs to remember to update these paths.
+
+This is where automation becomes crucial and where Nx can help. [Nx Sync Generators](/concepts/sync-generators) provide a powerful solution for **automating configuration that needs to stay in sync with your project structure**.
+
+For our specific use case we can automate the generation of the `@source` directives by
+
+- analyzing and traversing all of the `shop` application's dependencies (leveraging the [Nx project graph](/features/explore-graph))
+- generating the `@source` entries into the correct `styles.css` file
+
+You can follow [the guide on the Nx docs](/extending-nx/recipes/create-sync-generator) for all the details on how to implement your own Nx sync generator. At a high level these are the steps you'll need:
+
+**Step 1: Add Nx Plugin development support**
+
+```shell
+npx nx add @nx/plugin
+```
+
+**Step 2: Generate a new plugin into your workspace**
+
+```shell
+npx nx g @nx/plugin:plugin tools/tailwind-sync-plugin
+```
+
+Note, you can choose whatever folder you like. I happen to use the `tools/` folder for this example.
+
+**Step 3: Generate a sync generator**
+
+```shell
+npx nx g @nx/plugin:generator --name=update-tailwind-globs --path=tools/tailwind-sync-plugin/src/generators/update-tailwind-globs
+```
+
+With that you have the infrastructure in place and we can look at the actual implementation of the sync generator:
+
+```typescript
+import { Tree, createProjectGraphAsync, joinPathFragments } from '@nx/devkit';
+import { SyncGeneratorResult } from 'nx/src/utils/sync-generators';
+
+export async function updateTailwindGlobsGenerator(
+  tree: Tree
+): Promise<SyncGeneratorResult> {
+  const appName = '@aishop/shop';
+  const projectGraph = await createProjectGraphAsync();
+
+  // Traverse all dependencies of the shop app
+  const dependencies = new Set<string>();
+  const queue = [appName];
+  const visited = new Set<string>();
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    if (visited.has(current)) continue;
+    visited.add(current);
+
+    const deps = projectGraph.dependencies[current] || [];
+    deps.forEach((dep) => {
+      dependencies.add(dep.target);
+      queue.push(dep.target);
+    });
+  }
+
+  // Generate @source directives for each dependency
+  const sourceDirectives: string[] = [];
+  dependencies.forEach((dep) => {
+    const project = projectGraph.nodes[dep];
+    if (project && project.data.root) {
+      const relativePath = joinPathFragments('../../../', project.data.root);
+      sourceDirectives.push(`@source "${relativePath}";`);
+    }
+  });
+
+  // Update the styles.css file
+  const stylesPath = 'apps/shop/src/styles.css';
+  const currentContent = tree.read(stylesPath)?.toString() || '';
+
+  // Insert the @source directives after @import "tailwindcss"
+  // ... (implementation details)
+
+  return {
+    outOfSyncMessage: 'Tailwind @source directives updated',
+  };
+}
+```
+
+_(Check out the [Github repo for the full implementation](https://github.com/juristr/tailwind4-vite-npm-workspaces))_
+
+You can manually run sync generators with `nx sync`, but we want this to run automatically whenever we build or serve our application. As such we can register the sync generator in the app's `package.json`:
+
+```json {% fileName="apps/shop/package.json" %}
+{
+  "name": "@aishop/shop",
+  ...
+  "nx": {
+    "targets": {
+      "build": {
+        "syncGenerators": ["@aishop/tailwind-sync-plugin:update-tailwind-globs"]
+      },
+      "serve": {
+        "syncGenerators": ["@aishop/tailwind-sync-plugin:update-tailwind-globs"]
+      }
+    }
+  }
+}
+```
+
+## Nx sync generators in action
+
+When you run your development server with `nx serve shop`, the sync generator automatically checks if your `@source` directives are up to date:
+
+![Tailwind Nx sync generator in action](/blog/images/articles/tailwind-sync-generator.avif)
+
+Your CSS file is automatically updated with the correct directives based on your actual project dependencies. If you add or remove dependencies later, the next build or serve will **detect the changes and update the configuration automatically**.
+
+You can find the complete implementation in this [GitHub repository](https://github.com/juristr/tailwind4-vite-npm-workspaces).
+
+## Using Tailwind v3?
+
+If you're currently using Tailwind v3, the concept is similar but the implementation differs. Instead of updating `@source` directives, you'd modify the `tailwind.config.js` file with glob patterns.
+
+Check out the following video which explains the same approach for Tailwind v3:
+
+{% youtube src="https://www.youtube.com/watch?v=huTmV-F8c0A" title="Optimizing Tailwind with Nx Sync Generators (v3)" /%}
+
+The [Tailwind v3 demo repository](https://github.com/juristr/tailwind-sync-demo) shows how to implement this approach for older versions.
+
+## Conclusion
+
+While Tailwind v4's simplified setup is a significant improvement, manually maintaining `@source` directives creates a maintenance burden in monorepos. Nx Sync Generators solve this by automatically keeping your Tailwind configuration in sync with your project dependencies, eliminating manual updates and preventing hard-to-debug styling issues.
+
+This approach transforms configuration maintenance into a completely automated process, letting you focus on building features rather than managing paths.
+
+## Learn more
+
+- 🧠 [Nx Docs](/getting-started/intro)
+- 👩‍💻 [Tailwind v4 Vite NPM Workspace Demo](https://github.com/juristr/tailwind4-vite-npm-workspaces)
+- 📖 [Nx Sync Generators Documentation](/extending-nx/recipes/create-sync-generator)
+- 📹 [Nx Youtube Channel](https://www.youtube.com/@nxdevtools)
+- 💬 [Nx Official Discord Server](https://go.nx.dev/community)
+- 🐦 [Follow me on Twitter/X](https://twitter.com/juristr)