Cache when not found in LookupLayout

Very visible when using the pprof mutex profiler. ```bash name old time/op new time/op delta Baseline-10 58.4ms ± 1% 51.6ms ± 0% -11.56% (p=0.029 n=4+4) name old alloc/op new alloc/op delta Baseline-10 64.3MB ± 0% 64.2MB ± 0% ~ (p=0.114 n=4+4) name old allocs/op new allocs/op delta Baseline-10 649k ± 0% 649k ± 0% ~ (p=0.229 n=4+4) ```
2026-08-25 15:58:53 +00:00 · 2022-07-13 14:49:00 +02:00
3530 changed files with 129517 additions and 202401 deletions
@@ -1,115 +1,51 @@
-parameters:
-
-# v2: 11m.
 defaults: &defaults
-  resource_class: large
  docker:
-      - image: bepsays/ci-hugoreleaser:1.22600.20300
-environment: &buildenv
-      GOMODCACHE: /root/project/gomodcache
+      - image: bepsays/ci-goreleaser:1.1800.300
+  environment:
+    CGO_ENABLED: "0"
+
 version: 2
 jobs:
-  prepare_release:
-    <<: *defaults 
-    environment: &buildenv
-        GOMODCACHE: /root/project/gomodcache
+  build:
+    <<: *defaults
    steps:
-      - setup_remote_docker
-      - checkout: 
+      - checkout:
          path: hugo
-      - &git-config
-        run:
-           command: |
-            git config --global user.email "bjorn.erik.pedersen+hugoreleaser@gmail.com"
-            git config --global user.name "hugoreleaser"
      - run:
-          command: |
-            cd hugo
-            go mod download
-            go run -tags release main.go release --step 1
-      - save_cache:
-          key: git-sha-{{ .Revision }}
-          paths:
-            - hugo
-            - gomodcache
-  build_container1:
-    <<: [*defaults]
-    environment:
-      <<: [*buildenv]
+            command: |
+                git clone git@github.com:gohugoio/hugoDocs.git
+                cd hugo
+                go mod download
+                sleep 5
+                go mod verify
+      - persist_to_workspace:
+          root: .
+          paths: .
+  release:
+    <<: *defaults
    steps:
-      - &restore-cache
-        restore_cache:
-          key: git-sha-{{ .Revision }}
+      - attach_workspace:
+          at: /root/project
      - run:
-          no_output_timeout: 20m
-          command: |
-            mkdir -p /tmp/files/dist1
-            cd hugo
-            hugoreleaser build -paths "builds/container1/**" -workers 3 -dist /tmp/files/dist1 -chunks $CIRCLE_NODE_TOTAL -chunk-index $CIRCLE_NODE_INDEX
-      - &persist-workspace
-        persist_to_workspace:
-          root: /tmp/files
-          paths:
-            - dist1
-            - dist2
-    parallelism: 7
-  build_container2:
-    <<: [*defaults]
-    environment:
-        <<: [*buildenv]
-    docker:
-    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22600.20300
-    steps:
-      - *restore-cache
-      - &attach-workspace
-        attach_workspace:
-          at: /tmp/workspace
-      - run:
-          command: |
-                  mkdir -p /tmp/files/dist2
-                  cd hugo
-                  hugoreleaser build -paths "builds/container2/**" -workers 1 -dist /tmp/files/dist2
-      - *persist-workspace
-  archive_and_release:
-    <<: [*defaults]
-    environment:
-        <<: [*buildenv]
-    steps:
-      - *restore-cache
-      - *attach-workspace
-      - *git-config
-      - run:
-          name: Add github.com to known hosts
-          command: ssh-keyscan github.com >> ~/.ssh/known_hosts
-      - run:
-          command: |
-            cp -a /tmp/workspace/dist1/. ./hugo/dist
-            cp -a /tmp/workspace/dist2/. ./hugo/dist
-      - run:
-          command: |
-            cd hugo
-            hugoreleaser archive
-            hugoreleaser release
-            go run -tags release main.go release --step 2
+            command: |
+                    cd hugo
+                    git config --global user.email "bjorn.erik.pedersen+hugoreleaser@gmail.com"
+                    git config --global user.name "hugoreleaser"
+                    go run -tags release main.go release -r ${CIRCLE_BRANCH}
+
 workflows:
  version: 2
  release:
      jobs:  
-        - prepare_release:
+        - build:
            filters:
              branches:
                only: /release-.*/
-        - build_container1:
+        - hold:
+            type: approval
            requires:
-            - prepare_release
-        - build_container2:
-            requires:
-            - prepare_release
-        - archive_and_release:
+              - build
+        - release:
            context: org-global
            requires:
-            - build_container1
-            - build_container2
-     
-  
-       
+              - hold
@@ -1,13 +0,0 @@
-have_fun: false
-memory_config:
-  disabled: false
-code_review:
-  disable: false
-  comment_severity_threshold: HIGH
-  max_review_comments: -1
-  pull_request_opened:
-    help: true
-    summary: false
-    code_review: false
-    include_drafts: false
-ignore_patterns: []
@@ -5,12 +5,7 @@ assignees: ''
 about: Create a report to help us improve
 ---

-<!--
-Please do not use the issue queue for questions or troubleshooting. Unless you are certain that your issue is a software defect, use the forum:
-
-https://discourse.gohugo.io
-->
-
+  
 <!-- Please answer these questions before submitting your issue. Thanks! -->

 ### What version of Hugo are you using (`hugo version`)?
@@ -1,49 +0,0 @@
-name: Build Docker image
-
-on:
-  release:
-    types: [published]
-  pull_request:
-permissions:
-  packages: write
-
-env:
-  REGISTRY_IMAGE: ghcr.io/gohugoio/hugo
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
-        with:
-          images: ${{ env.REGISTRY_IMAGE }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
-
-      - name: Login to GHCR
-        # Login is only needed when the image is pushed
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build and push
-        id: build
-        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
-        with:
-          context: .
-          provenance: mode=max
-          sbom: true
-          push: ${{ github.event_name != 'pull_request' }}
-          platforms: linux/amd64,linux/arm64
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          build-args: HUGO_BUILD_TAGS=extended,withdeploy
@@ -3,16 +3,11 @@ on:
  workflow_dispatch:
  schedule:
    - cron: '30 1 * * *'
-permissions:
-  contents: read
 jobs:
  stale:
-    permissions:
-      issues: write
-      pull-requests: write
    runs-on: ubuntu-latest
    steps:
-      - uses: dessant/lock-threads@f5f995c727ac99a91dec92781a8e34e7c839a65e # v6.0.0
+      - uses: dessant/lock-threads@08e671be8ac8944d0e132aa71d0ae8ccfb347675
        with:
          issue-inactive-days: 21
          add-issue-labels: 'Outdated'
@@ -24,7 +19,7 @@ jobs:
            This pull request has been automatically locked since there
            has not been any recent activity after it was closed.
            Please open a new issue for related bugs.
-      - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+      - uses: actions/stale@04a1828bc18ada028d85a0252a47cd2963a91abe
        with:
          operations-per-run: 999
          days-before-issue-stale: 365
@@ -43,7 +38,7 @@ jobs:
          stale-pr-message: This PR has been automatically marked as stale because it has not had
            recent activity. The resources of the Hugo team are limited, and so we are asking for your help.

-            Please check https://github.com/gohugoio/hugo/blob/master/CONTRIBUTING.md#code-contribution and verify that this code contribution fits with the description. If yes, tell us in a comment.
+            Please check https://github.com/gohugoio/hugo/blob/master/CONTRIBUTING.md#code-contribution and verify that this code contribution fits with the description. If yes, tell is in a comment.

            This PR will automatically be closed in the near future if no further activity occurs. Thank you for all your contributions.
          stale-issue-label: 'Stale'
@@ -1,140 +1,90 @@
-on:
-  push:
-    branches: [master]
-  pull_request:
+on: [push, pull_request]
 name: Test
-env:
-  GOPROXY: https://proxy.golang.org
-  GO111MODULE: on
-  SASS_VERSION: 1.80.3
-  DART_SASS_SHA_LINUX: 7c933edbad0a7d389192c5b79393485c088bd2c4398e32f5754c32af006a9ffd
-  DART_SASS_SHA_MACOS: 79e060b0e131c3bb3c16926bafc371dc33feab122bfa8c01aa337a072097967b
-  DART_SASS_SHA_WINDOWS: 0bc4708b37cd1bac4740e83ac5e3176e66b774f77fd5dd364da5b5cfc9bfb469
 permissions:
  contents: read
 jobs:
  test:
+    env:
+      GOPROXY: https://proxy.golang.org
+      GO111MODULE: on
    strategy:
      matrix:
-        go-version: [1.26.x]
-        os: [ubuntu-latest, windows-latest]
+        # Note: We upgraded to Go 1.18 in Hugo v0.95.0
+        # Go 1.18 had some breaking changes on the source level which means Hugo cannot be built
+        # with older Go versions, but the improvements in Go 1.18 were too good to pass on (e.g. break and continue).
+        # Note that you don't need Go (or Go 1.18) to run a pre-built binary.
+        go-version: [1.18.x]
+        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
-      - if: matrix.os == 'ubuntu-latest'
-        name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be # v1.3.1
-        with:
-          tool-cache: true
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: true
-          swap-storage: true
-      - name: Checkout code
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
-        with:
-          go-version: ${{ matrix.go-version }}
-          check-latest: true
-          cache: true
-      - name: Install Node
-        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
-        with:
-          node-version: "22"
-      - name: Install Ruby
-        uses: ruby/setup-ruby@7372622e62b60b3cb750dcd2b9e32c247ffec26a # v1.302.0
-        with:
-          ruby-version: "3.4.5"
-      - name: Install Ruby gems
-        run: |
-          gem install asciidoctor -v "2.0.26"
-          gem install asciidoctor-diagram -v "3.1.0"
-      - name: Install GoAT
-        run: go install github.com/blampe/goat/cmd/goat@177de93b192b8ffae608e5d9ec421cc99bf68402
-      - name: Install Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
-        with:
-          python-version: "3.x"
-      - name: Install Mage
-        run: go install github.com/magefile/mage@v1.15.0
-      - name: Install gotmplfmt
-        run: go install github.com/gohugoio/gotmplfmt@latest
-      - name: Install docutils
-        run: |
-          pip install docutils
-          rst2html --version
-      - if: matrix.os == 'ubuntu-latest'
-        name: Install pandoc on Linux
-        run: |
+    - name: Install Go
+      uses: actions/setup-go@37335c7bb261b353407cff977110895fa0b4f7d8
+      with:
+        go-version: ${{ matrix.go-version }}
+    - name: Install Ruby
+      uses: actions/setup-ruby@5f29a1cd8dfebf420691c4c9a0e832e2fae5a526
+      with:
+        ruby-version: '2.7'
+    - name: Install Python
+      uses: actions/setup-python@3105fb18c05ddd93efea5f9e0bef7a03a6e9e7df
+      with:
+        python-version: '3.x'
+    - name: Install Mage
+      run: go install github.com/magefile/mage@07afc7d24f4d6d6442305d49552f04fbda5ccb3e
+    - name: Install asciidoctor
+      uses: reitzig/actions-asciidoctor@7570212ae20b63653481675fb1ff62d1073632b0
+    - name: Checkout code
+      uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f
+    - name: Install docutils
+      run: |
+        pip install docutils
+        rst2html.py --version
+    - if: matrix.os == 'ubuntu-latest'
+      name: Install pandoc on Linux
+      run: |
          sudo apt-get update -y
          sudo apt-get install -y pandoc
-      - if: matrix.os == 'macos-latest'
-        run: |
-          brew install pandoc
-      - if: matrix.os == 'windows-latest'
-        run: |
-          choco install pandoc
-      - run: pandoc -v
-      - if: matrix.os == 'windows-latest'
-        run: |
-          choco install mingw
-      - if: matrix.os == 'ubuntu-latest'
-        name: Install dart-sass Linux
-        run: |
-          echo "Install Dart Sass version ${SASS_VERSION} ..."
-          curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
-          echo "${DART_SASS_SHA_LINUX}  dart-sass-${SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
-          tar -xvf "dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
-          echo "$GOBIN"
-          echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
-      - if: matrix.os == 'macos-latest'
-        name: Install dart-sass MacOS
-        run: |
-          echo "Install Dart Sass version ${SASS_VERSION} ..."
-          curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
-          echo "${DART_SASS_SHA_MACOS}  dart-sass-${SASS_VERSION}-macos-x64.tar.gz" | shasum -a 256 -c;
-          tar -xvf "dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
-          echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
-      - if: matrix.os == 'windows-latest'
-        name: Install dart-sass Windows
-        run: |
-          echo "Install Dart Sass version ${env:SASS_VERSION} ..."
-          curl -LJO "https://github.com/sass/dart-sass/releases/download/${env:SASS_VERSION}/dart-sass-${env:SASS_VERSION}-windows-x64.zip";
-          Expand-Archive -Path "dart-sass-${env:SASS_VERSION}-windows-x64.zip" -DestinationPath .;
-          echo  "$env:GITHUB_WORKSPACE/dart-sass/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
-      - if: matrix.os == 'ubuntu-latest'
-        name: Install staticcheck
-        run: go install honnef.co/go/tools/cmd/staticcheck@latest
-      - if: matrix.os == 'ubuntu-latest'
-        name: Check embedded go template formatting
-        run: "diff <(gotmplfmt -d tpl/tplimpl/embedded/templates) <(printf '')"
-      - if: matrix.os == 'ubuntu-latest'
-        name: Run staticcheck
-        run: |
-          export STATICCHECK_CACHE="${{ runner.temp }}/staticcheck"
-          staticcheck ./...
-          rm -rf ${{ runner.temp }}/staticcheck
-      - if: matrix.os != 'windows-latest'
-        name: Check
-        run: |
-          sass --version;
-          mage -v check;
-        env:
-          HUGO_BUILD_TAGS: extended,withdeploy
-      - if: matrix.os == 'windows-latest'
-        # See issue #11052. We limit the build to regular test (no -race flag) on Windows for now.
-        name: Test
-        run: |
-          mage -v test
-        env:
-          HUGO_BUILD_TAGS: extended,withdeploy
-      - if: matrix.os == 'ubuntu-latest'
-        name: Build for dragonfly
-        run: |
-          go install
-          go clean -i -cache
-        env:
-          GOARCH: amd64
-          GOOS: dragonfly
+    - if: matrix.os == 'macos-latest'
+      run: |
+        brew install pandoc
+    - if: matrix.os == 'windows-latest'
+      run: |
+        choco install pandoc
+        choco install mingw --version 10.2.0 --allow-downgrade
+    - run: pandoc -v
+    - if: matrix.os == 'ubuntu-latest'
+      name: Install dart-sass-embedded Linux
+      run: |
+        curl -LJO https://github.com/sass/dart-sass-embedded/releases/download/1.0.0-beta.6/sass_embedded-1.0.0-beta.6-linux-x64.tar.gz;
+        echo "04fc1e5e28d29a4585a701941b6dace56771d94bfbe7f9e4db28d24417ceeec3  sass_embedded-1.0.0-beta.6-linux-x64.tar.gz" | sha256sum -c;
+        tar -xvf sass_embedded-1.0.0-beta.6-linux-x64.tar.gz;
+        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
+    - if: matrix.os == 'macos-latest'
+      name: Install dart-sass-embedded MacOS
+      run: |
+        curl -LJO https://github.com/sass/dart-sass-embedded/releases/download/1.0.0-beta.6/sass_embedded-1.0.0-beta.6-macos-x64.tar.gz;
+        echo "b3b984675a9b04aa22f6f2302dda4191b507ac2ca124467db2dfe7e58e72fbad  sass_embedded-1.0.0-beta.6-macos-x64.tar.gz" | shasum -a 256 -c;
+        tar -xvf sass_embedded-1.0.0-beta.6-macos-x64.tar.gz;
+        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
+    - if: matrix.os == 'windows-latest'
+      name: Install dart-sass-embedded Windows
+      run: |
+        curl -LJO https://github.com/sass/dart-sass-embedded/releases/download/1.0.0-beta.6/sass_embedded-1.0.0-beta.6-windows-x64.zip;
+        echo "6ae442129dbb3334bc21ef851261da6c0c1b560da790ca2e1350871d00ab816d  sass_embedded-1.0.0-beta.6-windows-x64.zip" | sha256sum -c;
+        unzip sass_embedded-1.0.0-beta.6-windows-x64.zip;
+        echo  "$env:GITHUB_WORKSPACE/sass_embedded/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
+    - name: Check
+      run: |
+        mage -v check;
+      env:
+        HUGO_BUILD_TAGS: extended
+    - name: Build Docs
+      env:
+        HUGO_BUILD_TAGS: extended
+        HUGO_TIMEOUT: 31000
+        HUGO_IGNOREERRORS: error-remote-getjson
+        HUGO_SERVICES_INSTAGRAM_ACCESSTOKEN: dummytoken
+      run: |
+        mage -v hugo
+        ./hugo -s docs/
+        ./hugo --renderToMemory -s docs/
@@ -1,8 +1,29 @@
-
+/hugo
+docs/public*
+/.idea
+.vscode/*
+hugo.exe
 *.test
-imports.*
-dist/
-public/
-.DS_Store 
-cache/filecache/_gen/
-.claude/
+*.prof
+nohup.out
+cover.out
+*.swp
+*.swo
+.DS_Store
+*~
+vendor/*/
+*.bench
+*.debug
+coverage*.out
+
+dock.sh
+
+GoBuilds
+dist
+
+hugolib/hugo_stats.json
+resources/sunset.jpg
+
+vendor
+
+.hugo_build.lock
@@ -1 +0,0 @@
-tpl/tplimpl/embedded/templates/**
@@ -1,21 +0,0 @@
-
-* Brevity is good.
-* Assume that the maintainers and readers of the code you write are Go experts:
-   * Don't use comments to explain the obvious.
-   * Use self-explanatory variable and function names.
-   * Use short variable names when the context is clear.
-* If you need to add temporary debug printing, use `hdebug.Printf`.[^1]
-* Never export symbols that's not needed outside of the package.
-* Avoid global state at (almost) all cost.
-* This is a project with a long history; assume that a similiar problem has been solved before, look hard for helper functions before creating new ones.
-* In tests, almost always write end-to-end integration tests using `hugolib.Test` or one of its siblings. Write unit tests only for isolated utilities.
-* In tests, use `qt` matchers (e.g. `b.Assert(err, qt.ErrorMatches, ...)`) instead of raw `if`/`t.Fatal` checks.
-* In tests, always use the latest Hugo specification, e.g. for layouts, it's `layouts/page.html` and not `layouts/_default/single.html`, `layouts/list.html` and not `layouts/_default/list.html`
-* Never name tests `TestIssue1234`; always give the test function a descriptive name, e.g. `TestDisablePathToLower`, and add any issue reference as a Go doc function comment, e.g. `// See issue 1234.`.
-* If you're a security researcher, read @SECURITY.md carefully.
-* Brevity is good. This applies to code, comments and commit messages. Don't write a novel.
-* Use `./check.sh ./somepackage/...` when iterating.
-* Use `./check.sh` when you're done.
-
-
-[^1]: CI build fail if you forget to remove the debug printing.
@@ -1 +0,0 @@
-@AGENTS.md
@@ -1,5 +1,7 @@
 # Contributing to Hugo

+**Note  March 16th 2022:** We are currently very constrained on human resources to do code reviews, so we currently require any new Pull Requests to be limited to bug fixes closing an existing issue. Also, we have updated to Go 1.18, but we will currently not accept any generic rewrites, "interface{} to any" replacements and similar.
+
 We welcome contributions to Hugo of any kind including documentation, themes,
 organization, tutorials, blog posts, bug reports, issues, feature requests,
 feature implementations, pull requests, answering questions on the forum,
@@ -17,7 +19,6 @@ The Hugo community and maintainers are [very active](https://github.com/gohugoio
 * [Reporting Issues](#reporting-issues)
 * [Submitting Patches](#submitting-patches)
  * [Code Contribution Guidelines](#code-contribution-guidelines)
-  * [AI Assistance Notice](#ai-assistance-notice)
  * [Git Commit Message Guidelines](#git-commit-message-guidelines)
  * [Fetching the Sources From GitHub](#fetching-the-sources-from-github)
  * [Building Hugo with Your Changes](#building-hugo-with-your-changes)
@@ -51,9 +52,11 @@ Hugo has become a fully featured static site generator, so any new functionality

 If it is of some complexity, the contributor is expected to maintain and support the new feature in the future (answer questions on the forum, fix any bugs etc.).

+It is recommended to open up a discussion on the [Hugo Forum](https://discourse.gohugo.io/) to get feedback on your idea before you begin. 
+
 Any non-trivial code change needs to update an open [issue](https://github.com/gohugoio/hugo/issues). A non-trivial code change without an issue reference with one of the labels `bug` or `enhancement` will not be merged.

-Note that we do not accept new features that require [CGO](https://go.dev/wiki/cgo).
+Note that we do not accept new features that require [CGO](https://github.com/golang/go/wiki/cgo).
 We have one exception to this rule which is LibSASS.

 **Bug fixes are, of course, always welcome.**
@@ -75,22 +78,9 @@ To make the contribution process as seamless as possible, we ask for the followi
    * Run `go fmt`.
    * Add documentation if you are adding new features or changing functionality.  The docs site lives in `/docs`.
    * Squash your commits into a single commit. `git rebase -i`. It’s okay to force update your pull request with `git push -f`.
-    * Ensure that `./check.sh` succeeds. Note that some tests are skipped when running locally, some because they are slow. To run these locally,  do `CI_LOCAL=true ./check.sh ./somepackage/...`.
+    * Ensure that `mage check` succeeds. [Travis CI](https://travis-ci.org/gohugoio/hugo) (Windows, Linux and macOS) will fail the build if `mage check` fails.
    * Follow the **Git Commit Message Guidelines** below.

-## AI Assistance Notice
-
-If a substantial part of your contribution is autogenerated with AI, **this must be disclosed in the pull request**, along with the extent to which AI assistance was used. AI contributions from non-maintainers needs to have a fairly narrow scope (e.g. a bug fix), as we have limited review capacity.
-
-An example disclosure:
-
-> This PR was written primarily by Claude Code.
-
-Also, When using AI assistance:
-
-* We expect contributors to manually verify that the state of the pull request is OK (e.g. that the CLI is signed).
-* We expect contributors to understand the code that is produced and be able to answer critical questions about it
-
 ### Git Commit Message Guidelines

 This [blog article](https://cbea.ms/git-commit/) is a good resource for learning how to write good commit messages,
@@ -105,7 +95,6 @@ Most title/subjects should have a lower-cased prefix with a colon and one whites
 * If this commit touches many packages without a common functional topic, prefix with `all:` (e.g. `all: Reformat Go code`)
 * If this is a documentation update, prefix with `docs:`.
 * If nothing of the above applies, just leave the prefix out.
-* Note that the above excludes nouns seen in other repositories, e.g. "chore:".

 Also, if your commit references one or more GitHub issues, always end your commit message body with *See #1234* or *Fixes #1234*.
 Replace *1234* with the GitHub issue ID. The last example will close the issue when the commit is merged into *master*.
@@ -135,6 +124,8 @@ cd hugo
 go install
 ```

+>Note: Some Go tools may not be fully updated to support Go Modules yet. One example would be LiteIDE. Follow [this workaround](https://github.com/visualfc/liteide/issues/986#issuecomment-428117702) for how to continue to work with Hugo below `GOPATH`.
+
 For some convenient build and test targets, you also will want to install Mage:

 ```bash
@@ -2,100 +2,44 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/

-ARG GO_VERSION="1.26"
-ARG ALPINE_VERSION="3.22"
-ARG DART_SASS_VERSION="1.79.3"
+FROM golang:1.18-alpine AS build

-FROM --platform=$BUILDPLATFORM tonistiigi/xx:1.5.0 AS xx
-FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine${ALPINE_VERSION} AS gobuild
-FROM golang:${GO_VERSION}-alpine${ALPINE_VERSION} AS gorun
+# Optionally set HUGO_BUILD_TAGS to "extended" or "nodeploy" when building like so:
+#   docker build --build-arg HUGO_BUILD_TAGS=extended .
+ARG HUGO_BUILD_TAGS

-
-FROM gobuild AS build
-
-RUN apk add clang lld
-
-# Set up cross-compilation helpers
-COPY --from=xx / /
-
-ARG TARGETPLATFORM
-RUN xx-apk add musl-dev gcc g++
-
-# Optionally set HUGO_BUILD_TAGS to "none" or "withdeploy" when building like so:
-# docker build --build-arg HUGO_BUILD_TAGS=withdeploy .
-#
-# We build the extended version by default.
-ARG HUGO_BUILD_TAGS="extended"
-ENV CGO_ENABLED=1
-ENV GOPROXY=https://proxy.golang.org
-ENV GOCACHE=/root/.cache/go-build
-ENV GOMODCACHE=/go/pkg/mod
-ARG TARGETPLATFORM
+ARG CGO=1
+ENV CGO_ENABLED=${CGO}
+ENV GOOS=linux
+ENV GO111MODULE=on

 WORKDIR /go/src/github.com/gohugoio/hugo

-# For  --mount=type=cache the value of target is the default cache id, so
-# for the go mod cache it would be good if we could share it with other Go images using the same setup,
-# but the go build cache needs to be per platform.
-# See this comment: https://github.com/moby/buildkit/issues/1706#issuecomment-702238282
-RUN --mount=target=. \
-    --mount=type=cache,target=/go/pkg/mod \
-    --mount=type=cache,target=/root/.cache/go-build,id=go-build-$TARGETPLATFORM <<EOT
-    set -ex
-    xx-go build -tags "$HUGO_BUILD_TAGS" -ldflags "-s -w -X github.com/gohugoio/hugo/common/hugo.vendorInfo=docker" -o /usr/bin/hugo
-    xx-verify /usr/bin/hugo
-EOT
+COPY . /go/src/github.com/gohugoio/hugo/

-# dart-sass downloads the dart-sass runtime dependency
-FROM alpine:${ALPINE_VERSION} AS dart-sass
-ARG TARGETARCH
-ARG DART_SASS_VERSION
-ARG DART_ARCH=${TARGETARCH/amd64/x64}
-WORKDIR /out
-ADD https://github.com/sass/dart-sass/releases/download/${DART_SASS_VERSION}/dart-sass-${DART_SASS_VERSION}-linux-${DART_ARCH}.tar.gz .
-RUN tar -xf dart-sass-${DART_SASS_VERSION}-linux-${DART_ARCH}.tar.gz
+# gcc/g++ are required to build SASS libraries for extended version
+RUN apk update && \
+    apk add --no-cache gcc g++ musl-dev git && \
+    go install github.com/magefile/mage

-FROM gorun AS final
+RUN mage hugo && mage install

-COPY --from=build /usr/bin/hugo /usr/bin/hugo
+# ---

-# libc6-compat  are required for extended libraries (libsass, libwebp).
-RUN apk add --no-cache \
-    libc6-compat \
-    git \
-    runuser \
-    nodejs \
-    npm \
-    openssh-client \
-    tar
+FROM alpine:3.12

-RUN mkdir -p /var/hugo/bin /cache && \
-    addgroup -Sg 1000 hugo && \
-    adduser -Sg hugo -u 1000 -h /var/hugo hugo && \
-    chown -R hugo: /var/hugo /cache && \
-    # For the Hugo's Git integration to work.
-    runuser -u hugo -- git config --global --add safe.directory /project && \
-    # See https://github.com/gohugoio/hugo/issues/9810
-    runuser -u hugo -- git config --global core.quotepath false
+COPY --from=build /go/bin/hugo /usr/bin/hugo

-USER hugo:hugo
-VOLUME /project
-WORKDIR /project
-ENV HUGO_CACHEDIR=/cache
-ENV PATH="/var/hugo/bin:$PATH"
+# libc6-compat & libstdc++ are required for extended SASS libraries
+# ca-certificates are required to fetch outside resources (like Twitter oEmbeds)
+RUN apk update && \
+    apk add --no-cache ca-certificates libc6-compat libstdc++ git

-COPY scripts/docker/entrypoint.sh /entrypoint.sh
-COPY --from=dart-sass /out/dart-sass /var/hugo/bin/dart-sass
-
-# Update PATH to reflect the new dependencies.
-# For more complex setups, we should probably find a way to
-# delegate this to the script itself, but this will have to do for now.
-# Also, the dart-sass binary is a little special, other binaries can be put/linked
-# directly in /var/hugo/bin.
-ENV PATH="/var/hugo/bin/dart-sass:$PATH"
+VOLUME /site
+WORKDIR /site

 # Expose port for live server
 EXPOSE 1313

-ENTRYPOINT ["/entrypoint.sh"]
+ENTRYPOINT ["hugo"]
 CMD ["--help"]
@@ -1,310 +1,248 @@
-[Clang]: https://clang.llvm.org/
-[GCC]: https://gcc.gnu.org/
-[Git]: https://git-scm.com/book/en/v2/Getting-Started-Installing-Git
-[Go]: https://go.dev/doc/install
-[bep]: https://github.com/bep
-[bugs]: https://github.com/gohugoio/hugo/issues?q=is%3Aopen+is%3Aissue+label%3ABug
-[contributing]: CONTRIBUTING.md
-[create a proposal]: https://github.com/gohugoio/hugo/issues/new?labels=Proposal%2C+NeedsTriage&template=feature_request.md
-[dart sass]: https://gohugo.io/functions/css/sass/#dart-sass
-[details]: https://gohugo.io/host-and-deploy/deploy-with-hugo-deploy/
-[documentation repository]: https://github.com/gohugoio/hugoDocs
-[documentation]: https://gohugo.io/documentation
-[dragonfly bsd, freebsd, netbsd, and openbsd]: https://gohugo.io/installation/bsd
-[features]: https://gohugo.io/about/features/
-[forum]: https://discourse.gohugo.io
-[friends]: https://github.com/gohugoio/hugo/graphs/contributors
-[hugo modules]: https://gohugo.io/hugo-modules/
-[installation]: https://gohugo.io/installation
-[issue queue]: https://github.com/gohugoio/hugo/issues
-[linux]: https://gohugo.io/installation/linux
-[macos]: https://gohugo.io/installation/macos
-[prebuilt binary]: https://github.com/gohugoio/hugo/releases/latest
-[requesting help]: https://discourse.gohugo.io/t/requesting-help/9132
-[spf13]: https://github.com/spf13
-[static site generator]: https://en.wikipedia.org/wiki/Static_site_generator
-[support]: https://discourse.gohugo.io
-[themes]: https://themes.gohugo.io/
-[transpile sass to css]: https://gohugo.io/functions/css/sass/
-[website]: https://gohugo.io
-[windows]: https://gohugo.io/installation/windows
-
 <a href="https://gohugo.io/"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/static/images/hugo-logo-wide.svg?sanitize=true" alt="Hugo" width="565"></a>

-A fast and flexible static site generator built with love by [bep][], [spf13][], and [friends][] in Go.
+A Fast and Flexible Static Site Generator built with love by [bep](https://github.com/bep), [spf13](https://spf13.com/) and [friends](https://github.com/gohugoio/hugo/graphs/contributors) in [Go][].

---
+[Website](https://gohugo.io) |
+[Forum](https://discourse.gohugo.io) |
+[Documentation](https://gohugo.io/getting-started/) |
+[Installation Guide](https://gohugo.io/getting-started/installing/) |
+[Contribution Guide](CONTRIBUTING.md) |
+[Twitter](https://twitter.com/gohugoio)

 [![GoDoc](https://godoc.org/github.com/gohugoio/hugo?status.svg)](https://godoc.org/github.com/gohugoio/hugo)
 [![Tests on Linux, MacOS and Windows](https://github.com/gohugoio/hugo/workflows/Test/badge.svg)](https://github.com/gohugoio/hugo/actions?query=workflow%3ATest)
 [![Go Report Card](https://goreportcard.com/badge/github.com/gohugoio/hugo)](https://goreportcard.com/report/github.com/gohugoio/hugo)

-[Website][] | [Installation][] | [Documentation][] | [Support][] | [Contributing][] | <a rel="me" href="https://fosstodon.org/@gohugoio">Mastodon</a>
-
 ## Overview

-Hugo is a [static site generator][] written in Go, optimized for speed and designed for flexibility. With its advanced templating system and fast asset pipelines, Hugo renders a complete site in seconds, often less.
+Hugo is a static HTML and CSS website generator written in [Go][].
+It is optimized for speed, ease of use, and configurability.
+Hugo takes a directory with content and templates and renders them into a full HTML website.

-Due to its flexible framework, multilingual support, and powerful taxonomy system, Hugo is widely used to create:
+Hugo relies on Markdown files with front matter for metadata, and you can run Hugo from any directory.
+This works well for shared hosts and other systems where you don’t have a privileged account.

- Corporate, government, nonprofit, education, news, event, and project sites
- Documentation sites
- Image portfolios
- Landing pages
- Business, professional, and personal blogs
- Resumes and CVs
+Hugo renders a typical website of moderate size in a fraction of a second.
+A good rule of thumb is that each piece of content renders in around 1 millisecond.

-Use Hugo's embedded web server during development to instantly see changes to content, structure, behavior, and presentation. Then deploy the site to your host, or push changes to your Git provider for automated builds and deployment.
+Hugo is designed to work well for any kind of website including blogs, tumbles, and docs.

-Hugo's fast asset pipelines include:
+#### Supported Architectures

- CSS Processing &ndash; Bundle, transform, minify, create source maps, perform SRI hashing, and integrate with PostCSS.
- Image processing &ndash; Convert, resize, crop, rotate, adjust colors, apply filters, overlay text and images, and extract metadata
- JavaScript bundling &ndash; Transpile TypeScript and JSX to JavaScript, bundle, tree shake, minify, create source maps, and perform SRI hashing.
- Sass processing &ndash; Transpile Sass to CSS, bundle, tree shake, minify, create source maps, perform SRI hashing, and integrate with PostCSS
- Tailwind CSS processing &ndash; Compile Tailwind CSS utility classes into standard CSS, bundle, tree shake, optimize, minify, perform SRI hashing, and integrate with PostCSS
+Currently, we provide pre-built Hugo binaries for Windows, Linux, FreeBSD, NetBSD, DragonFly BSD, OpenBSD, macOS (Darwin), and [Android](https://gist.github.com/bep/a0d8a26cf6b4f8bc992729b8e50b480b) for x64, i386 and ARM architectures.

-And with [Hugo Modules][], you can share content, assets, data, translations, themes, templates, and configuration with other projects via public or private Git repositories.
+Hugo may also be compiled from source wherever the Go compiler tool chain can run, e.g. for other operating systems including Plan 9 and Solaris.

-See the [features][] section of the documentation for a comprehensive summary of Hugo's capabilities.
+**Complete documentation is available at [Hugo Documentation](https://gohugo.io/getting-started/).**

-## Sponsors
+## Choose How to Install

-<p>&nbsp;</p>
-<p float="left">
-  <a href="https://www.jetbrains.com/go/?utm_source=OSS&utm_medium=referral&utm_campaign=hugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/goland.svg" width="200" alt="The complete IDE crafted for professional Go developers."></a>
-  &nbsp;&nbsp;&nbsp;
-    <a href="https://cloudcannon.com/hugo-cms/?utm_campaign=HugoSponsorship&utm_source=sponsor&utm_content=gohugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/cloudcannon-cms-logo.svg" width="200" alt="CloudCannon"></a>
-</p>
+If you want to use Hugo as your site generator, simply install the Hugo binaries.
+The Hugo binaries have no external dependencies.

-## Editions
+To contribute to the Hugo source code or documentation, you should [fork the Hugo GitHub project](https://github.com/gohugoio/hugo#fork-destination-box) and clone it to your local machine.

-Hugo is available in several editions. Use the standard edition unless you need additional features.
+Finally, you can install the Hugo source code with `go`, build the binaries yourself, and run Hugo that way.
+Building the binaries is an easy task for an experienced `go` getter.

-Feature|standard|deploy|extended|extended/deploy
-:--|:-:|:-:|:-:|:-:
-Core features|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:
-Direct cloud deployment (1)|:x:|:heavy_check_mark:|:x:|:heavy_check_mark:
-LibSass support (2)|:x:|:x:|:heavy_check_mark:|:heavy_check_mark:
+### Install Hugo as Your Site Generator (Binary Install)

-(1) Deploy your site directly to a Google Cloud Storage bucket, an AWS S3 bucket, or an Azure Storage container. See&nbsp;[details][].
+Use the [installation instructions in the Hugo documentation](https://gohugo.io/getting-started/installing/).

-(2) [Transpile Sass to CSS][] via embedded LibSass. Note that embedded LibSass was deprecated in v0.153.0 and will be removed in a future release. Use the [Dart Sass][] transpiler instead, which is compatible with any edition.
+### Build and Install the Binaries from Source (Advanced Install)

-## Installation
+#### Prerequisite Tools

-Install Hugo from a [prebuilt binary][], package manager, or package repository. Please see the installation instructions for your operating system:
+* [Git](https://git-scm.com/)
+* [Go (we test it with the last 2 major versions; but note that Hugo 0.95.0 only builds with >= Go 1.18.)](https://golang.org/dl/)

- [macOS][]
- [Linux][]
- [Windows][]
- [DragonFly BSD, FreeBSD, NetBSD, and OpenBSD][]
+#### Fetch from GitHub

-## Build from source
+To fetch and build the source from GitHub:

-To build Hugo from source you must install:
-
-1. [Git][]
-1. [Go][] version 1.26.0 or later
-
-### Standard edition
-
-To build and install the standard edition:
-
-```sh
-CGO_ENABLED=0 go install github.com/gohugoio/hugo@latest
+```bash
+mkdir $HOME/src
+cd $HOME/src
+git clone https://github.com/gohugoio/hugo.git
+cd hugo
+go install
 ```

-### Deploy edition
+**If you are a Windows user, substitute the `$HOME` environment variable above with `%USERPROFILE%`.**

-To build and install the deploy edition:
+If you want to compile with Sass/SCSS support use `--tags extended` and make sure `CGO_ENABLED=1` is set in your go environment. If you don't want to have CGO enabled, you may use the following command to temporarily enable CGO only for hugo compilation:

-```sh
-CGO_ENABLED=0 go install -tags withdeploy github.com/gohugoio/hugo@latest
+```bash
+CGO_ENABLED=1 go install --tags extended
 ```

-### Extended edition
+## The Hugo Documentation

-To build and install the extended edition, first install a C compiler such as [GCC][] or [Clang][] and then run the following command.
+The Hugo documentation now lives in its own repository, see https://github.com/gohugoio/hugoDocs. But we do keep a version of that documentation as a `git subtree` in this repository. To build the sub folder `/docs` as a Hugo site, you need to clone this repo:

-```sh
-CGO_ENABLED=1 go install -tags extended github.com/gohugoio/hugo@latest
+```bash
+git clone git@github.com:gohugoio/hugo.git
 ```
+## Contributing to Hugo

-### Extended/deploy edition
-
-To build and install the extended/deploy edition, first install a C compiler such as [GCC][] or [Clang][] and then run the following command.
-
-```sh
-CGO_ENABLED=1 go install -tags extended,withdeploy github.com/gohugoio/hugo@latest
-```
-
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=gohugoio/hugo&type=Timeline)](https://star-history.com/#gohugoio/hugo&Timeline)
-
-## Documentation
-
-Hugo's [documentation][] includes installation instructions, a quick start guide, conceptual explanations, reference information, and examples.
-
-Please submit documentation issues and pull requests to the [documentation repository][].
-
-## Support
-
-Please **do not use the issue queue** for questions or troubleshooting. Unless you are certain that your issue is a software defect, use the [forum][].
-
-Hugo's [forum][] is an active community of users and developers who answer questions, share knowledge, and provide examples. A quick search of over 20,000 topics will often answer your question. Please be sure to read about [requesting help][] before asking your first question.
-
-## Contributing
-
-You can contribute to the Hugo project by:
-
- Answering questions on the [forum][]
- Improving the [documentation][]
- Monitoring the [issue queue][]
- Creating or improving [themes][]
- Squashing [bugs][]
-
-Please submit documentation issues and pull requests to the [documentation repository][].
-
-If you have an idea for an enhancement or new feature, create a new topic on the [forum][] in the "Feature" category. This will help you to:
-
- Determine if the capability already exists
- Measure interest
- Refine the concept
-
-If there is sufficient interest, [create a proposal][]. Do not submit a pull request until the project lead accepts the proposal.
+**Note  March 16th 2022:** We are currently very constrained on human resources to do code reviews, so we currently require any new Pull Requests to be limited to bug fixes closing an existing issue. Also, we have updated to Go 1.18, but we will currently not accept any generic rewrites, "interface{} to any" replacements and similar.

 For a complete guide to contributing to Hugo, see the [Contribution Guide](CONTRIBUTING.md).

-## License
+We welcome contributions to Hugo of any kind including documentation, themes,
+organization, tutorials, blog posts, bug reports, issues, feature requests,
+feature implementations, pull requests, answering questions on the forum,
+helping to manage issues, etc.

-For the Hugo source code, see [LICENSE](/LICENSE).
+The Hugo community and maintainers are [very active](https://github.com/gohugoio/hugo/pulse/monthly) and helpful, and the project benefits greatly from this activity.

-We also bundle some libraries in binary/WASM form:
+### Asking Support Questions

- [libwebp](https://github.com/webmproject/libwebp), [BSD-3-Clause license](https://github.com/webmproject/libwebp?tab=BSD-3-Clause-1-ov-file#readme)
- [Katex](https://github.com/KaTeX/KaTeX), [MIT license](https://github.com/KaTeX/KaTeX?tab=MIT-1-ov-file#readme)
- [QuickJS](https://github.com/bellard/quickjs?tab=License-1-ov-file#readme), [License](https://github.com/bellard/quickjs?tab=License-1-ov-file#readme)
+We have an active [discussion forum](https://discourse.gohugo.io) where users and developers can ask questions.
+Please don't use the GitHub issue tracker to ask questions.
+
+### Reporting Issues
+
+If you believe you have found a defect in Hugo or its documentation, use
+the GitHub issue tracker to report the problem to the Hugo maintainers.
+If you're not sure if it's a bug or not, start by asking in the [discussion forum](https://discourse.gohugo.io).
+When reporting the issue, please provide the version of Hugo in use (`hugo version`).
+
+### Submitting Patches
+
+The Hugo project welcomes all contributors and contributions regardless of skill or experience level.
+If you are interested in helping with the project, we will help you with your contribution.
+Hugo is a very active project with many contributions happening daily.
+
+We want to create the best possible product for our users and the best contribution experience for our developers,
+we have a set of guidelines which ensure that all contributions are acceptable.
+The guidelines are not intended as a filter or barrier to participation.
+If you are unfamiliar with the contribution process, the Hugo team will help you and teach you how to bring your contribution in accordance with the guidelines.
+
+For a complete guide to contributing code to Hugo, see the [Contribution Guide](CONTRIBUTING.md).
+
+[Go]: https://golang.org/
+[Hugo Documentation]: https://gohugo.io/overview/introduction/

 ## Dependencies

-Hugo stands on the shoulders of great open source libraries. Run `hugo env --logLevel info` to display a list of dependencies.
+Hugo stands on the shoulder of many great open source libraries.

-<details>
-<summary>See current dependencies</summary>
+If you run `hugo env -v` you will get a complete and up to date list.

-```text
+In Hugo 0.100.1 that list is, in lexical order:
+
+```
+cloud.google.com/go/compute="v1.6.1"
+cloud.google.com/go/iam="v0.3.0"
+cloud.google.com/go/storage="v1.22.0"
+cloud.google.com/go="v0.101.0"
+github.com/Azure/azure-pipeline-go="v0.2.3"
+github.com/Azure/azure-storage-blob-go="v0.14.0"
+github.com/Azure/go-autorest/autorest/adal="v0.9.15"
+github.com/Azure/go-autorest/autorest/date="v0.3.0"
+github.com/Azure/go-autorest/autorest="v0.11.20"
+github.com/Azure/go-autorest/logger="v0.2.1"
+github.com/Azure/go-autorest/tracing="v0.6.0"
 github.com/BurntSushi/locker="v0.0.0-20171006230638-a6e239ea1c69"
-github.com/JohannesKaufmann/dom="v0.2.0"
-github.com/JohannesKaufmann/html-to-markdown/v2="v2.5.0"
-github.com/alecthomas/chroma/v2="v2.21.1"
-github.com/aymerick/douceur="v0.2.0"
-github.com/bep/clocks="v0.5.0"
+github.com/PuerkitoBio/purell="v1.1.1"
+github.com/PuerkitoBio/urlesc="v0.0.0-20170810143723-de5bf2ad4578"
+github.com/alecthomas/chroma="v0.10.0"
+github.com/armon/go-radix="v1.0.0"
+github.com/aws/aws-sdk-go-v2/config="v1.7.0"
+github.com/aws/aws-sdk-go-v2/credentials="v1.4.0"
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds="v1.5.0"
+github.com/aws/aws-sdk-go-v2/internal/ini="v1.2.2"
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url="v1.3.0"
+github.com/aws/aws-sdk-go-v2/service/sso="v1.4.0"
+github.com/aws/aws-sdk-go-v2/service/sts="v1.7.0"
+github.com/aws/aws-sdk-go-v2="v1.9.0"
+github.com/aws/aws-sdk-go="v1.43.5"
+github.com/aws/smithy-go="v1.8.0"
+github.com/bep/clock="v0.3.0"
 github.com/bep/debounce="v1.2.0"
-github.com/bep/gitmap="v1.9.0"
+github.com/bep/gitmap="v1.1.2"
 github.com/bep/goat="v0.5.0"
-github.com/bep/godartsass/v2="v2.5.0"
-github.com/bep/golibsass="v1.2.0"
-github.com/bep/goportabletext="v0.1.0"
-github.com/bep/helpers="v0.6.0"
-github.com/bep/imagemeta="v0.12.0"
-github.com/bep/lazycache="v0.8.0"
-github.com/bep/logg="v0.4.0"
-github.com/bep/mclib="v1.20400.20402"
-github.com/bep/overlayfs="v0.10.0"
-github.com/bep/simplecobra="v0.6.1"
-github.com/bep/textandbinarywriter="v0.0.0-20251212174530-cd9f0732f60f"
+github.com/bep/godartsass="v0.14.0"
+github.com/bep/golibsass="v1.1.0"
+github.com/bep/gowebp="v0.1.0"
+github.com/bep/overlayfs="v0.6.0"
 github.com/bep/tmc="v0.5.1"
-github.com/bits-and-blooms/bitset="v1.24.4"
-github.com/cespare/xxhash/v2="v2.3.0"
-github.com/clbanning/mxj/v2="v2.7.0"
-github.com/clipperhouse/displaywidth="v0.6.0"
-github.com/clipperhouse/stringish="v0.1.1"
-github.com/clipperhouse/uax29/v2="v2.3.0"
-github.com/cpuguy83/go-md2man/v2="v2.0.6"
+github.com/clbanning/mxj/v2="v2.5.5"
+github.com/cli/safeexec="v1.0.0"
+github.com/cpuguy83/go-md2man/v2="v2.0.1"
 github.com/disintegration/gift="v1.2.1"
-github.com/dlclark/regexp2="v1.11.5"
-github.com/evanw/esbuild="v0.27.2"
-github.com/fatih/color="v1.18.0"
-github.com/frankban/quicktest="v1.14.6"
-github.com/fsnotify/fsnotify="v1.9.0"
-github.com/getkin/kin-openapi="v0.133.0"
-github.com/go-openapi/jsonpointer="v0.21.0"
-github.com/go-openapi/swag="v0.23.0"
-github.com/gobuffalo/flect="v1.0.3"
+github.com/dlclark/regexp2="v1.4.0"
+github.com/dustin/go-humanize="v1.0.0"
+github.com/evanw/esbuild="v0.14.42"
+github.com/frankban/quicktest="v1.14.3"
+github.com/fsnotify/fsnotify="v1.5.4"
+github.com/getkin/kin-openapi="v0.94.0"
+github.com/ghodss/yaml="v1.0.0"
+github.com/go-openapi/jsonpointer="v0.19.5"
+github.com/go-openapi/swag="v0.19.5"
+github.com/gobuffalo/flect="v0.2.5"
 github.com/gobwas/glob="v0.2.3"
-github.com/goccy/go-yaml="v1.19.1"
-github.com/gohugoio/go-i18n/v2="v2.1.3-0.20251018145728-cfcc22d823c6"
-github.com/gohugoio/go-radix="v1.2.0"
-github.com/gohugoio/hashstructure="v0.6.0"
-github.com/gohugoio/httpcache="v0.8.0"
-github.com/gohugoio/hugo-goldmark-extensions/extras="v0.5.0"
-github.com/gohugoio/hugo-goldmark-extensions/passthrough="v0.3.1"
+github.com/gohugoio/go-i18n/v2="v2.1.3-0.20210430103248-4c28c89f8013"
 github.com/gohugoio/locales="v0.14.0"
 github.com/gohugoio/localescompressed="v1.0.1"
-github.com/google/go-cmp="v0.7.0"
-github.com/gorilla/css="v1.0.1"
-github.com/gorilla/websocket="v1.5.3"
-github.com/hairyhenderson/go-codeowners="v0.7.0"
-github.com/hashicorp/golang-lru/v2="v2.0.7"
+github.com/golang-jwt/jwt/v4="v4.0.0"
+github.com/golang/groupcache="v0.0.0-20210331224755-41bb18bfe9da"
+github.com/golang/protobuf="v1.5.2"
+github.com/google/go-cmp="v0.5.8"
+github.com/google/uuid="v1.3.0"
+github.com/google/wire="v0.5.0"
+github.com/googleapis/gax-go/v2="v2.3.0"
+github.com/googleapis/go-type-adapters="v1.0.0"
+github.com/gorilla/websocket="v1.5.0"
+github.com/hairyhenderson/go-codeowners="v0.2.3-0.20201026200250-cdc7c0759690"
+github.com/inconshreveable/mousetrap="v1.0.0"
 github.com/jdkato/prose="v1.2.1"
-github.com/josharian/intern="v1.0.0"
-github.com/kr/pretty="v0.3.1"
+github.com/jmespath/go-jmespath="v0.4.0"
+github.com/kr/pretty="v0.3.0"
 github.com/kr/text="v0.2.0"
-github.com/kyokomi/emoji/v2="v2.2.13"
-github.com/mailru/easyjson="v0.7.7"
-github.com/makeworld-the-better-one/dither/v2="v2.4.0"
-github.com/marekm4/color-extractor="v1.2.1"
-github.com/mattn/go-colorable="v0.1.13"
-github.com/mattn/go-isatty="v0.0.20"
-github.com/mattn/go-runewidth="v0.0.19"
-github.com/microcosm-cc/bluemonday="v1.0.27"
-github.com/mitchellh/mapstructure="v1.5.1-0.20231216201459-8508981c8b6c"
-github.com/mohae/deepcopy="v0.0.0-20170929034955-c48cc78d4826"
+github.com/kyokomi/emoji/v2="v2.2.9"
+github.com/mailru/easyjson="v0.0.0-20190626092158-b2ccc519800e"
+github.com/mattn/go-ieproxy="v0.0.1"
+github.com/mattn/go-isatty="v0.0.14"
+github.com/mattn/go-runewidth="v0.0.9"
+github.com/mitchellh/hashstructure="v1.1.0"
+github.com/mitchellh/mapstructure="v1.5.0"
 github.com/muesli/smartcrop="v0.3.0"
-github.com/niklasfasching/go-org="v1.9.1"
-github.com/oasdiff/yaml3="v0.0.0-20250309153720-d2182401db90"
-github.com/oasdiff/yaml="v0.0.0-20250309154309-f31be36b4037"
-github.com/olekukonko/cat="v0.0.0-20250911104152-50322a0618f6"
-github.com/olekukonko/errors="v1.1.0"
-github.com/olekukonko/ll="v0.1.3"
-github.com/olekukonko/tablewriter="v1.1.2"
-github.com/pbnjay/memory="v0.0.0-20210728143218-7b4eea64cf58"
-github.com/pelletier/go-toml/v2="v2.2.4"
-github.com/perimeterx/marshmallow="v1.1.5"
-github.com/pkg/browser="v0.0.0-20240102092130-5ac0b6a4141c"
-github.com/pkg/errors="v0.9.1"
-github.com/rogpeppe/go-internal="v1.14.1"
+github.com/niklasfasching/go-org="v1.6.2"
+github.com/olekukonko/tablewriter="v0.0.5"
+github.com/pelletier/go-toml/v2="v2.0.0-beta.7.0.20220408132554-2377ac4bc04c"
+github.com/rogpeppe/go-internal="v1.8.1"
 github.com/russross/blackfriday/v2="v2.1.0"
-github.com/sass/dart-sass/compiler="1.97.1"
-github.com/sass/dart-sass/implementation="1.97.1"
-github.com/sass/dart-sass/protocol="3.2.0"
-github.com/spf13/afero="v1.15.0"
-github.com/spf13/cast="v1.10.0"
-github.com/spf13/cobra="v1.10.2"
-github.com/spf13/fsync="v0.10.1"
-github.com/spf13/pflag="v1.0.9"
-github.com/tdewolff/minify/v2="v2.24.8"
-github.com/tdewolff/parse/v2="v2.8.5"
-github.com/tetratelabs/wazero="v1.10.1"
-github.com/webmproject/libwebp="v1.6.0"
-github.com/woodsbury/decimal128="v1.3.0"
-github.com/yuin/goldmark-emoji="v1.0.6"
-github.com/yuin/goldmark="v1.7.13"
-go.uber.org/automaxprocs="v1.5.3"
-go.yaml.in/yaml/v3="v3.0.4"
-golang.org/x/crypto="v0.46.0"
-golang.org/x/image="v0.34.0"
-golang.org/x/mod="v0.31.0"
-golang.org/x/net="v0.48.0"
-golang.org/x/sync="v0.19.0"
-golang.org/x/sys="v0.39.0"
-golang.org/x/text="v0.32.0"
-golang.org/x/tools="v0.40.0"
-google.golang.org/protobuf="v1.36.10"
-gopkg.in/yaml.v3="v3.0.1"
-rsc.io/qr="v0.2.0"
-software.sslmate.com/src/go-pkcs12="v0.2.0"
+github.com/rwcarlsen/goexif="v0.0.0-20190401172101-9e8deecbddbd"
+github.com/sanity-io/litter="v1.5.5"
+github.com/sass/libsass="3.6.5"
+github.com/spf13/afero="v1.8.2"
+github.com/spf13/cast="v1.5.0"
+github.com/spf13/cobra="v1.4.0"
+github.com/spf13/fsync="v0.9.0"
+github.com/spf13/jwalterweatherman="v1.1.0"
+github.com/spf13/pflag="v1.0.5"
+github.com/tdewolff/minify/v2="v2.11.5"
+github.com/tdewolff/parse/v2="v2.5.31"
+github.com/webmproject/libwebp="v1.2.0"
+github.com/yuin/goldmark="v1.4.12"
+go.opencensus.io="v0.23.0"
+go.uber.org/atomic="v1.9.0"
+gocloud.dev="v0.24.0"
+golang.org/x/crypto="v0.0.0-20211108221036-ceb1ce70b4fa"
+golang.org/x/image="v0.0.0-20211028202545-6944b10bf410"
+golang.org/x/net="v0.0.0-20220425223048-2871e0cb64e4"
+golang.org/x/oauth2="v0.0.0-20220411215720-9780585627b5"
+golang.org/x/sync="v0.0.0-20210220032951-036812b2e83c"
+golang.org/x/sys="v0.0.0-20220422013727-9388b58f7150"
+golang.org/x/text="v0.3.7"
+golang.org/x/tools="v0.1.10"
+golang.org/x/xerrors="v0.0.0-20220411194840-2f41105eb62f"
+google.golang.org/api="v0.76.0"
+google.golang.org/genproto="v0.0.0-20220426171045-31bebdecfb46"
+google.golang.org/grpc="v1.46.0"
+google.golang.org/protobuf="v1.28.0"
+gopkg.in/yaml.v2="v2.4.0"
 ```
-</details>
+
@@ -1,11 +1,7 @@
 ## Security Policy

-### Before You Report
-
-Please read [Hugo's Security Model](https://gohugo.io/about/security/) first. If the issue reproduces in an upstream project, please report it there — we cannot triage or patch on their behalf.
-
 ### Reporting a Vulnerability

-If, after the above, you believe you have found a vulnerability in Hugo itself with a concrete, reproducible impact, report it privately to **[bjorn.erik.pedersen@gmail.com](mailto:bjorn.erik.pedersen@gmail.com)**. Include a minimal reproducer, the Hugo version, and the observed vs. expected behavior.
+Please report (suspected) security vulnerabilities to **[bjorn.erik.pedersen@gmail.com](mailto:bjorn.erik.pedersen@gmail.com)**. You will receive a response from us within 48 hours. If we can confirm the issue, we will release a patch as soon as possible depending on the complexity of the issue but historically within days.

-You should receive an initial response within a few days. Confirmed issues are typically patched within days, depending on complexity.
+Also see [Hugo's Security Model](https://gohugo.io/about/security-model/).
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+# allow user to override go executable by running as GOEXE=xxx make ...
+GOEXE="${GOEXE-go}"
+
+# Convenience script to
+# - For a given branch
+# - Run  benchmark tests for a given package
+# - Do the same for master
+# - then compare the two runs with benchcmp
+
+benchFilter=".*"
+
+if (( $# < 2 ));
+  then
+    echo "USAGE: ./bench.sh <git-branch> <package-to-bench> (and <benchmark filter> (regexp, optional))"
+    exit 1
+fi
+
+
+
+if [ $# -eq 3 ]; then
+  benchFilter=$3
+fi
+
+
+BRANCH=$1
+PACKAGE=$2
+
+git checkout $BRANCH
+"${GOEXE}" test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-$BRANCH.txt
+
+git checkout master
+"${GOEXE}" test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-master.txt
+
+
+benchcmp /tmp/bench-$PACKAGE-master.txt /tmp/bench-$PACKAGE-$BRANCH.txt
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# allow user to override go executable by running as GOEXE=xxx make ...
+GOEXE="${GOEXE-go}"
+
+# Send in a regexp matching the benchmarks you want to run, i.e. './benchSite.sh "YAML"'.
+# Note the quotes, which will be needed for more complex expressions.
+# The above will run all variations, but only for front matter YAML.
+
+echo "Running with BenchmarkSiteBuilding/${1}"
+
+"${GOEXE}" test -run="NONE" -bench="BenchmarkSiteBuilding/${1}" -test.benchmem=true ./hugolib -memprofile mem.prof -count 3 -cpuprofile cpu.prof
@@ -0,0 +1 @@
+gobench -package=./hugolib -bench="BenchmarkSiteNew/Deep_content_tree"
@@ -0,0 +1 @@
+docker run --rm --mount type=bind,source="$(pwd)",target=/hugo -w /hugo  -i -t bepsays/ci-goreleaser:1.11-2 /bin/bash
@@ -1,2 +0,0 @@
-// Package cache contains the different cache implementations.
-package cache
@@ -1,647 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package dynacache
-
-import (
-	"context"
-	"fmt"
-	"math"
-	"path"
-	"regexp"
-	"runtime"
-	"sync"
-	"time"
-
-	"github.com/bep/lazycache"
-	"github.com/bep/logg"
-	"github.com/gohugoio/hugo/common/collections"
-	"github.com/gohugoio/hugo/common/herrors"
-	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/paths"
-	"github.com/gohugoio/hugo/common/rungroup"
-	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/identity"
-	"github.com/gohugoio/hugo/resources/resource"
-)
-
-const minMaxSize = 10
-
-type KeyIdentity struct {
-	Key      any
-	Identity identity.Identity
-}
-
-// New creates a new cache.
-func New(opts Options) *Cache {
-	if opts.CheckInterval == 0 {
-		opts.CheckInterval = time.Second * 2
-	}
-
-	if opts.MaxSize == 0 {
-		opts.MaxSize = 100000
-	}
-	if opts.Log == nil {
-		panic("nil Log")
-	}
-
-	if opts.MinMaxSize == 0 {
-		opts.MinMaxSize = 30
-	}
-
-	stats := &stats{
-		opts:             opts,
-		adjustmentFactor: 1.0,
-		currentMaxSize:   opts.MaxSize,
-		availableMemory:  config.GetMemoryLimit(),
-	}
-
-	infol := opts.Log.InfoCommand("dynacache")
-
-	evictedIdentities := collections.NewStackThreadSafe[KeyIdentity]()
-
-	onEvict := func(k, v any) {
-		if !opts.Watching {
-			return
-		}
-		identity.WalkIdentitiesShallow(v, func(level int, id identity.Identity) bool {
-			evictedIdentities.Push(KeyIdentity{Key: k, Identity: id})
-			return false
-		})
-		resource.MarkStale(v)
-	}
-
-	c := &Cache{
-		partitions:        make(map[string]PartitionManager),
-		onEvict:           onEvict,
-		evictedIdentities: evictedIdentities,
-		opts:              opts,
-		stats:             stats,
-		infol:             infol,
-	}
-
-	c.stop = c.start()
-
-	return c
-}
-
-// Options for the cache.
-type Options struct {
-	Log           loggers.Logger
-	CheckInterval time.Duration
-	MaxSize       int
-	MinMaxSize    int
-	Watching      bool
-}
-
-// Options for a partition.
-type OptionsPartition struct {
-	// When to clear the this partition.
-	ClearWhen ClearWhen
-
-	// Weight is a number between 1 and 100 that indicates how, in general, how big this partition may get.
-	Weight int
-}
-
-func (o OptionsPartition) WeightFraction() float64 {
-	return float64(o.Weight) / 100
-}
-
-func (o OptionsPartition) CalculateMaxSize(maxSizePerPartition int) int {
-	return int(math.Floor(float64(maxSizePerPartition) * o.WeightFraction()))
-}
-
-// A dynamic partitioned cache.
-type Cache struct {
-	mu sync.RWMutex
-
-	partitions map[string]PartitionManager
-
-	onEvict           func(k, v any)
-	evictedIdentities *collections.StackThreadSafe[KeyIdentity]
-
-	opts  Options
-	infol logg.LevelLogger
-
-	stats    *stats
-	stopOnce sync.Once
-	stop     func()
-}
-
-// DrainEvictedIdentities drains the evicted identities from the cache.
-func (c *Cache) DrainEvictedIdentities() []KeyIdentity {
-	return c.evictedIdentities.Drain()
-}
-
-// DrainEvictedIdentitiesMatching drains the evicted identities from the cache that match the given predicate.
-func (c *Cache) DrainEvictedIdentitiesMatching(predicate func(KeyIdentity) bool) []KeyIdentity {
-	return c.evictedIdentities.DrainMatching(predicate)
-}
-
-// ClearMatching clears all partition for which the predicate returns true.
-func (c *Cache) ClearMatching(predicatePartition func(k string, p PartitionManager) bool, predicateValue func(k, v any) bool) {
-	if predicatePartition == nil {
-		predicatePartition = func(k string, p PartitionManager) bool { return true }
-	}
-	if predicateValue == nil {
-		panic("nil predicateValue")
-	}
-	g := rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
-		NumWorkers: len(c.partitions),
-		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearMatching(predicateValue)
-			return nil
-		},
-	})
-
-	for k, p := range c.partitions {
-		if !predicatePartition(k, p) {
-			continue
-		}
-		g.Enqueue(p)
-	}
-
-	g.Wait()
-}
-
-// ClearOnRebuild prepares the cache for a new rebuild taking the given changeset into account.
-// predicate is optional and will clear any entry for which it returns true.
-func (c *Cache) ClearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity) {
-	g := rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
-		NumWorkers: len(c.partitions),
-		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearOnRebuild(predicate, changeset...)
-			return nil
-		},
-	})
-
-	for _, p := range c.partitions {
-		g.Enqueue(p)
-	}
-
-	g.Wait()
-
-	// Clear any entries marked as stale above.
-	g = rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
-		NumWorkers: len(c.partitions),
-		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearStale()
-			return nil
-		},
-	})
-
-	for _, p := range c.partitions {
-		g.Enqueue(p)
-	}
-
-	g.Wait()
-}
-
-type keysProvider interface {
-	Keys() []string
-}
-
-// Keys returns a list of keys in all partitions.
-func (c *Cache) Keys(predicate func(s string) bool) []string {
-	if predicate == nil {
-		predicate = func(s string) bool { return true }
-	}
-	var keys []string
-	for pn, g := range c.partitions {
-		pkeys := g.(keysProvider).Keys()
-		for _, k := range pkeys {
-			p := path.Join(pn, k)
-			if predicate(p) {
-				keys = append(keys, p)
-			}
-		}
-
-	}
-	return keys
-}
-
-func calculateMaxSizePerPartition(maxItemsTotal, totalWeightQuantity, numPartitions int) int {
-	if numPartitions == 0 {
-		panic("numPartitions must be > 0")
-	}
-	if totalWeightQuantity == 0 {
-		panic("totalWeightQuantity must be > 0")
-	}
-
-	avgWeight := float64(totalWeightQuantity) / float64(numPartitions)
-	return int(math.Floor(float64(maxItemsTotal) / float64(numPartitions) * (100.0 / avgWeight)))
-}
-
-// Stop stops the cache.
-func (c *Cache) Stop() {
-	c.stopOnce.Do(func() {
-		c.stop()
-	})
-}
-
-func (c *Cache) adjustCurrentMaxSize() {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	if len(c.partitions) == 0 {
-		return
-	}
-	var m runtime.MemStats
-	runtime.ReadMemStats(&m)
-	s := c.stats
-	s.memstatsCurrent = m
-	// fmt.Printf("\n\nAvailable = %v\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\nMaxSize = %d\nAdjustmentFactor=%f\n\n", helpers.FormatByteCount(s.availableMemory), helpers.FormatByteCount(m.Alloc), helpers.FormatByteCount(m.TotalAlloc), helpers.FormatByteCount(m.Sys), m.NumGC, c.stats.currentMaxSize, s.adjustmentFactor)
-
-	if s.availableMemory >= s.memstatsCurrent.Alloc {
-		if s.adjustmentFactor <= 1.0 {
-			s.adjustmentFactor += 0.2
-		}
-	} else {
-		// We're low on memory.
-		s.adjustmentFactor -= 0.4
-	}
-
-	if s.adjustmentFactor <= 0 {
-		s.adjustmentFactor = 0.05
-	}
-
-	if !s.adjustCurrentMaxSize() {
-		return
-	}
-
-	totalWeight := 0
-	for _, pm := range c.partitions {
-		totalWeight += pm.getOptions().Weight
-	}
-
-	maxSizePerPartition := calculateMaxSizePerPartition(c.stats.currentMaxSize, totalWeight, len(c.partitions))
-
-	evicted := 0
-	for _, p := range c.partitions {
-		evicted += p.adjustMaxSize(p.getOptions().CalculateMaxSize(maxSizePerPartition))
-	}
-
-	if evicted > 0 {
-		c.infol.
-			WithFields(
-				logg.Fields{
-					{Name: "evicted", Value: evicted},
-					{Name: "numGC", Value: m.NumGC},
-					{Name: "limit", Value: helpers.FormatByteCount(c.stats.availableMemory)},
-					{Name: "alloc", Value: helpers.FormatByteCount(m.Alloc)},
-					{Name: "totalAlloc", Value: helpers.FormatByteCount(m.TotalAlloc)},
-				},
-			).Logf("adjusted partitions' max size")
-	}
-}
-
-func (c *Cache) start() func() {
-	ticker := time.NewTicker(c.opts.CheckInterval)
-	quit := make(chan struct{})
-
-	go func() {
-		for {
-			select {
-			case <-ticker.C:
-				c.adjustCurrentMaxSize()
-				// Reset the ticker to avoid drift.
-				ticker.Reset(c.opts.CheckInterval)
-			case <-quit:
-				ticker.Stop()
-				return
-			}
-		}
-	}()
-
-	return func() {
-		close(quit)
-	}
-}
-
-var partitionNameRe = regexp.MustCompile(`^\/[a-zA-Z0-9]{4}(\/[a-zA-Z0-9]+)?(\/[a-zA-Z0-9]+)?`)
-
-// GetOrCreatePartition gets or creates a partition with the given name.
-func GetOrCreatePartition[K comparable, V any](c *Cache, name string, opts OptionsPartition) *Partition[K, V] {
-	if c == nil {
-		panic("nil Cache")
-	}
-	if opts.Weight < 1 || opts.Weight > 100 {
-		panic("invalid Weight, must be between 1 and 100")
-	}
-
-	if !partitionNameRe.MatchString(name) {
-		panic(fmt.Sprintf("invalid partition name %q", name))
-	}
-
-	c.mu.RLock()
-	p, found := c.partitions[name]
-	c.mu.RUnlock()
-	if found {
-		return p.(*Partition[K, V])
-	}
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	// Double check.
-	p, found = c.partitions[name]
-	if found {
-		return p.(*Partition[K, V])
-	}
-
-	// At this point, we don't know the number of partitions or their configuration, but
-	// this will be re-adjusted later.
-	const numberOfPartitionsEstimate = 10
-	maxSize := opts.CalculateMaxSize(c.opts.MaxSize / numberOfPartitionsEstimate)
-
-	onEvict := func(k K, v V) {
-		c.onEvict(k, v)
-	}
-
-	// Create a new partition and cache it.
-	partition := &Partition[K, V]{
-		c:       lazycache.New(lazycache.Options[K, V]{MaxEntries: maxSize, OnEvict: onEvict}),
-		maxSize: maxSize,
-		trace:   c.opts.Log.Logger().WithLevel(logg.LevelTrace).WithField("partition", name),
-		opts:    opts,
-	}
-
-	c.partitions[name] = partition
-
-	return partition
-}
-
-// Partition is a partition in the cache.
-type Partition[K comparable, V any] struct {
-	c *lazycache.Cache[K, V]
-
-	zero V
-
-	trace logg.LevelLogger
-	opts  OptionsPartition
-
-	maxSize int
-}
-
-// GetOrCreate gets or creates a value for the given key.
-func (p *Partition[K, V]) GetOrCreate(key K, create func(key K) (V, error)) (V, error) {
-	v, err := p.doGetOrCreate(key, create)
-	if err != nil {
-		return p.zero, err
-	}
-	if resource.StaleVersion(v) > 0 {
-		p.c.Delete(key)
-		return p.doGetOrCreate(key, create)
-	}
-	return v, err
-}
-
-func (p *Partition[K, V]) doGetOrCreate(key K, create func(key K) (V, error)) (V, error) {
-	v, _, err := p.c.GetOrCreate(key, create)
-	return v, err
-}
-
-func (p *Partition[K, V]) GetOrCreateWitTimeout(key K, duration time.Duration, create func(key K) (V, error)) (V, error) {
-	v, err := p.doGetOrCreateWitTimeout(key, duration, create)
-	if err != nil {
-		return p.zero, err
-	}
-	if resource.StaleVersion(v) > 0 {
-		p.c.Delete(key)
-		return p.doGetOrCreateWitTimeout(key, duration, create)
-	}
-	return v, err
-}
-
-// GetOrCreateWitTimeout gets or creates a value for the given key and times out if the create function
-// takes too long.
-func (p *Partition[K, V]) doGetOrCreateWitTimeout(key K, duration time.Duration, create func(key K) (V, error)) (V, error) {
-	resultch := make(chan V, 1)
-	errch := make(chan error, 1)
-
-	go func() {
-		var (
-			v   V
-			err error
-		)
-		defer func() {
-			if r := recover(); r != nil {
-				if rerr, ok := r.(error); ok {
-					err = rerr
-				} else {
-					err = fmt.Errorf("panic: %v", r)
-				}
-			}
-			if err != nil {
-				errch <- err
-			} else {
-				resultch <- v
-			}
-		}()
-		v, _, err = p.c.GetOrCreate(key, create)
-	}()
-
-	select {
-	case v := <-resultch:
-		return v, nil
-	case err := <-errch:
-		return p.zero, err
-	case <-time.After(duration):
-		return p.zero, &herrors.TimeoutError{
-			Duration: duration,
-		}
-	}
-}
-
-func (p *Partition[K, V]) clearMatching(predicate func(k, v any) bool) {
-	p.c.DeleteFunc(func(key K, v V) bool {
-		if predicate(key, v) {
-			p.trace.Log(
-				logg.StringFunc(
-					func() string {
-						return fmt.Sprintf("clearing cache key %v", key)
-					},
-				),
-			)
-			return true
-		}
-		return false
-	})
-}
-
-func (p *Partition[K, V]) clearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity) {
-	if predicate == nil {
-		predicate = func(k, v any) bool {
-			return false
-		}
-	}
-	opts := p.getOptions()
-	if opts.ClearWhen == ClearNever {
-		return
-	}
-
-	if opts.ClearWhen == ClearOnRebuild {
-		// Clear all.
-		p.Clear()
-		return
-	}
-
-	depsFinder := identity.NewFinder(identity.FinderConfig{})
-
-	shouldDelete := func(key K, v V) bool {
-		// We always clear elements marked as stale.
-		if resource.StaleVersion(v) > 0 {
-			return true
-		}
-
-		// Now check if this entry has changed based on the changeset
-		// based on filesystem events.
-		if len(changeset) == 0 {
-			// Nothing changed.
-			return false
-		}
-
-		var probablyDependent bool
-		identity.WalkIdentitiesShallow(v, func(level int, id2 identity.Identity) bool {
-			for _, id := range changeset {
-				if r := depsFinder.Contains(id, id2, -1); r > 0 {
-					// It's probably dependent, evict from cache.
-					probablyDependent = true
-					return true
-				}
-			}
-			return false
-		})
-
-		return probablyDependent
-	}
-
-	// First pass.
-	// Second pass needs to be done in a separate loop to catch any
-	// elements marked as stale in the other partitions.
-	p.c.DeleteFunc(func(key K, v V) bool {
-		if predicate(key, v) || shouldDelete(key, v) {
-			p.trace.Log(
-				logg.StringFunc(
-					func() string {
-						return fmt.Sprintf("first pass: clearing cache key %v", key)
-					},
-				),
-			)
-			return true
-		}
-		return false
-	})
-}
-
-func (p *Partition[K, V]) Keys() []K {
-	var keys []K
-	p.c.DeleteFunc(func(key K, v V) bool {
-		keys = append(keys, key)
-		return false
-	})
-	return keys
-}
-
-func (p *Partition[K, V]) clearStale() {
-	p.c.DeleteFunc(func(key K, v V) bool {
-		staleVersion := resource.StaleVersion(v)
-		if staleVersion > 0 {
-			p.trace.Log(
-				logg.StringFunc(
-					func() string {
-						return fmt.Sprintf("second pass: clearing cache key %v", key)
-					},
-				),
-			)
-		}
-
-		return staleVersion > 0
-	})
-}
-
-// adjustMaxSize adjusts the max size of the and returns the number of items evicted.
-func (p *Partition[K, V]) adjustMaxSize(newMaxSize int) int {
-	if newMaxSize < minMaxSize {
-		newMaxSize = minMaxSize
-	}
-	oldMaxSize := p.maxSize
-	if newMaxSize == oldMaxSize {
-		return 0
-	}
-	p.maxSize = newMaxSize
-	// fmt.Println("Adjusting max size of partition from", oldMaxSize, "to", newMaxSize)
-	return p.c.Resize(newMaxSize)
-}
-
-func (p *Partition[K, V]) getMaxSize() int {
-	return p.maxSize
-}
-
-func (p *Partition[K, V]) getOptions() OptionsPartition {
-	return p.opts
-}
-
-func (p *Partition[K, V]) Clear() {
-	p.c.DeleteFunc(func(key K, v V) bool {
-		return true
-	})
-}
-
-func (p *Partition[K, V]) Get(ctx context.Context, key K) (V, bool) {
-	return p.c.Get(key)
-}
-
-type PartitionManager interface {
-	adjustMaxSize(addend int) int
-	getMaxSize() int
-	getOptions() OptionsPartition
-	clearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity)
-	clearMatching(predicate func(k, v any) bool)
-	clearStale()
-}
-
-const (
-	ClearOnRebuild ClearWhen = iota + 1
-	ClearOnChange
-	ClearNever
-)
-
-type ClearWhen int
-
-type stats struct {
-	opts            Options
-	memstatsCurrent runtime.MemStats
-	currentMaxSize  int
-	availableMemory uint64
-
-	adjustmentFactor float64
-}
-
-func (s *stats) adjustCurrentMaxSize() bool {
-	newCurrentMaxSize := int(math.Floor(float64(s.opts.MaxSize) * s.adjustmentFactor))
-
-	if newCurrentMaxSize < s.opts.MinMaxSize {
-		newCurrentMaxSize = int(s.opts.MinMaxSize)
-	}
-	changed := newCurrentMaxSize != s.currentMaxSize
-	s.currentMaxSize = newCurrentMaxSize
-	return changed
-}
-
-// CleanKey turns s into a format suitable for a cache key for this package.
-// The key will be a Unix-styled path with a leading slash but no trailing slash.
-func CleanKey(s string) string {
-	return path.Clean(paths.ToSlashPreserveLeading(s))
-}
@@ -1,230 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package dynacache
-
-import (
-	"errors"
-	"fmt"
-	"path/filepath"
-	"testing"
-	"time"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/identity"
-	"github.com/gohugoio/hugo/resources/resource"
-)
-
-var (
-	_ resource.StaleInfo = (*testItem)(nil)
-	_ identity.Identity  = (*testItem)(nil)
-)
-
-type testItem struct {
-	name         string
-	staleVersion uint32
-}
-
-func (t testItem) StaleVersion() uint32 {
-	return t.staleVersion
-}
-
-func (t testItem) IdentifierBase() string {
-	return t.name
-}
-
-func TestCache(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	cache := New(Options{
-		Log: loggers.NewDefault(),
-	})
-
-	c.Cleanup(func() {
-		cache.Stop()
-	})
-
-	opts := OptionsPartition{Weight: 30}
-
-	c.Assert(cache, qt.Not(qt.IsNil))
-
-	p1 := GetOrCreatePartition[string, testItem](cache, "/aaaa/bbbb", opts)
-	c.Assert(p1, qt.Not(qt.IsNil))
-
-	p2 := GetOrCreatePartition[string, testItem](cache, "/aaaa/bbbb", opts)
-
-	c.Assert(func() { GetOrCreatePartition[string, testItem](cache, "foo bar", opts) }, qt.PanicMatches, ".*invalid partition name.*")
-	c.Assert(func() { GetOrCreatePartition[string, testItem](cache, "/aaaa/cccc", OptionsPartition{Weight: 1234}) }, qt.PanicMatches, ".*invalid Weight.*")
-
-	c.Assert(p2, qt.Equals, p1)
-
-	p3 := GetOrCreatePartition[string, testItem](cache, "/aaaa/cccc", opts)
-	c.Assert(p3, qt.Not(qt.IsNil))
-	c.Assert(p3, qt.Not(qt.Equals), p1)
-
-	c.Assert(func() { New(Options{}) }, qt.PanicMatches, ".*nil Log.*")
-}
-
-func TestCalculateMaxSizePerPartition(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	c.Assert(calculateMaxSizePerPartition(1000, 500, 5), qt.Equals, 200)
-	c.Assert(calculateMaxSizePerPartition(1000, 250, 5), qt.Equals, 400)
-	c.Assert(func() { calculateMaxSizePerPartition(1000, 250, 0) }, qt.PanicMatches, ".*must be > 0.*")
-	c.Assert(func() { calculateMaxSizePerPartition(1000, 0, 1) }, qt.PanicMatches, ".*must be > 0.*")
-}
-
-func TestCleanKey(t *testing.T) {
-	c := qt.New(t)
-
-	c.Assert(CleanKey("a/b/c"), qt.Equals, "/a/b/c")
-	c.Assert(CleanKey("/a/b/c"), qt.Equals, "/a/b/c")
-	c.Assert(CleanKey("a/b/c/"), qt.Equals, "/a/b/c")
-	c.Assert(CleanKey(filepath.FromSlash("/a/b/c/")), qt.Equals, "/a/b/c")
-}
-
-func newTestCache(t *testing.T) *Cache {
-	cache := New(
-		Options{
-			Log: loggers.NewDefault(),
-		},
-	)
-
-	p1 := GetOrCreatePartition[string, testItem](cache, "/aaaa/bbbb", OptionsPartition{Weight: 30, ClearWhen: ClearOnRebuild})
-	p2 := GetOrCreatePartition[string, testItem](cache, "/aaaa/cccc", OptionsPartition{Weight: 30, ClearWhen: ClearOnChange})
-
-	p1.GetOrCreate("clearOnRebuild", func(string) (testItem, error) {
-		return testItem{}, nil
-	})
-
-	p2.GetOrCreate("clearBecauseStale", func(string) (testItem, error) {
-		return testItem{
-			staleVersion: 32,
-		}, nil
-	})
-
-	p2.GetOrCreate("clearBecauseIdentityChanged", func(string) (testItem, error) {
-		return testItem{
-			name: "changed",
-		}, nil
-	})
-
-	p2.GetOrCreate("clearNever", func(string) (testItem, error) {
-		return testItem{
-			staleVersion: 0,
-		}, nil
-	})
-
-	t.Cleanup(func() {
-		cache.Stop()
-	})
-
-	return cache
-}
-
-func TestClear(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	predicateAll := func(string) bool {
-		return true
-	}
-
-	cache := newTestCache(t)
-
-	c.Assert(cache.Keys(predicateAll), qt.HasLen, 4)
-
-	cache.ClearOnRebuild(nil)
-
-	// Stale items are always cleared.
-	c.Assert(cache.Keys(predicateAll), qt.HasLen, 2)
-
-	cache = newTestCache(t)
-	cache.ClearOnRebuild(nil, identity.StringIdentity("changed"))
-
-	c.Assert(cache.Keys(nil), qt.HasLen, 1)
-
-	cache = newTestCache(t)
-
-	cache.ClearMatching(nil, func(k, v any) bool {
-		return k.(string) == "clearOnRebuild"
-	})
-
-	c.Assert(cache.Keys(predicateAll), qt.HasLen, 3)
-
-	cache.adjustCurrentMaxSize()
-}
-
-func TestPanicInCreate(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-	cache := newTestCache(t)
-
-	p1 := GetOrCreatePartition[string, testItem](cache, "/aaaa/bbbb", OptionsPartition{Weight: 30, ClearWhen: ClearOnRebuild})
-
-	willPanic := func(i int) func() {
-		return func() {
-			p1.GetOrCreate(fmt.Sprintf("panic-%d", i), func(key string) (testItem, error) {
-				panic(errors.New(key))
-			})
-		}
-	}
-
-	// GetOrCreateWitTimeout needs to recover from panics in the create func.
-	willErr := func(i int) error {
-		_, err := p1.GetOrCreateWitTimeout(fmt.Sprintf("error-%d", i), 10*time.Second, func(key string) (testItem, error) {
-			return testItem{}, errors.New(key)
-		})
-		return err
-	}
-
-	for i := range 3 {
-		for range 3 {
-			c.Assert(willPanic(i), qt.PanicMatches, fmt.Sprintf("panic-%d", i))
-			c.Assert(willErr(i), qt.ErrorMatches, fmt.Sprintf("error-%d", i))
-		}
-	}
-
-	// Test the same keys again without the panic.
-	for i := range 3 {
-		for range 3 {
-			v, err := p1.GetOrCreate(fmt.Sprintf("panic-%d", i), func(key string) (testItem, error) {
-				return testItem{
-					name: key,
-				}, nil
-			})
-			c.Assert(err, qt.IsNil)
-			c.Assert(v.name, qt.Equals, fmt.Sprintf("panic-%d", i))
-
-			v, err = p1.GetOrCreateWitTimeout(fmt.Sprintf("error-%d", i), 10*time.Second, func(key string) (testItem, error) {
-				return testItem{
-					name: key,
-				}, nil
-			})
-			c.Assert(err, qt.IsNil)
-			c.Assert(v.name, qt.Equals, fmt.Sprintf("error-%d", i))
-		}
-	}
-}
-
-func TestAdjustCurrentMaxSize(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-	cache := newTestCache(t)
-	alloc := cache.stats.memstatsCurrent.Alloc
-	cache.adjustCurrentMaxSize()
-	c.Assert(cache.stats.memstatsCurrent.Alloc, qt.Not(qt.Equals), alloc)
-}
@@ -1,4 +1,4 @@
-// Copyright 2026 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,22 +16,19 @@ package filecache
 import (
 	"bytes"
 	"errors"
-	"fmt"
 	"io"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
 	"sync"
 	"time"

-	"github.com/gohugoio/httpcache"
 	"github.com/gohugoio/hugo/common/hugio"
-	"github.com/gohugoio/hugo/hugofs"

 	"github.com/gohugoio/hugo/helpers"

 	"github.com/BurntSushi/locker"
-	"github.com/bep/helpers/maphelpers"
 	"github.com/spf13/afero"
 )

@@ -39,7 +36,7 @@ import (
 var ErrFatal = errors.New("fatal filecache error")

 const (
-	FilecacheRootDirname = "filecache"
+	filecacheRootDirname = "filecache"
 )

 // Cache caches a set of files in a directory. This is usually a file on
@@ -47,17 +44,19 @@ const (
 type Cache struct {
 	Fs afero.Fs

-	cfg FileCacheConfig
+	// Max age for items in this cache. Negative duration means forever,
+	// 0 is effectively turning this cache off.
+	maxAge time.Duration

-	entryLocker *lockTracker
+	// When set, we just remove this entire root directory on expiration.
+	pruneAllRootDir string

-	initOnce sync.Once
-	isInited bool
-	initErr  error
+	nlocker *lockTracker
 }

 type lockTracker struct {
-	seen *maphelpers.ConcurrentSet[string]
+	seenMu sync.RWMutex
+	seen   map[string]struct{}

 	*locker.Locker
 }
@@ -65,7 +64,16 @@ type lockTracker struct {
 // Lock tracks the ids in use. We use this information to do garbage collection
 // after a Hugo build.
 func (l *lockTracker) Lock(id string) {
-	l.seen.AddIfAbsent(id)
+	l.seenMu.RLock()
+	if _, seen := l.seen[id]; !seen {
+		l.seenMu.RUnlock()
+		l.seenMu.Lock()
+		l.seen[id] = struct{}{}
+		l.seenMu.Unlock()
+	} else {
+		l.seenMu.RUnlock()
+	}
+
 	l.Locker.Lock(id)
 }

@@ -76,15 +84,12 @@ type ItemInfo struct {
 }

 // NewCache creates a new file cache with the given filesystem and max age.
-func NewCache(fs afero.Fs, cfg FileCacheConfig) *Cache {
-	if err := cfg.init(); err != nil {
-		panic(fmt.Sprintf("invalid cache config: %s", err))
-	}
-
+func NewCache(fs afero.Fs, maxAge time.Duration, pruneAllRootDir string) *Cache {
 	return &Cache{
-		Fs:          fs,
-		entryLocker: &lockTracker{Locker: locker.NewLocker(), seen: maphelpers.NewConcurrentSet[string]()},
-		cfg:         cfg,
+		Fs:              fs,
+		nlocker:         &lockTracker{Locker: locker.NewLocker(), seen: make(map[string]struct{})},
+		maxAge:          maxAge,
+		pruneAllRootDir: pruneAllRootDir,
 	}
 }

@@ -99,43 +104,23 @@ func (l *lockedFile) Close() error {
 	return l.File.Close()
 }

-func (c *Cache) init() error {
-	if c == nil {
-		panic("cache is nil")
-	}
-
-	c.initOnce.Do(func() {
-		c.isInited = true
-		// Create the base dir if it does not exist.
-		if err := c.Fs.MkdirAll("", 0o777); err != nil && !os.IsExist(err) {
-			err = fmt.Errorf("failled to create base cache directory: %s", err)
-			c.initErr = err
-		}
-	})
-	return c.initErr
-}
-
 // WriteCloser returns a transactional writer into the cache.
 // It's important that it's closed when done.
 func (c *Cache) WriteCloser(id string) (ItemInfo, io.WriteCloser, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
-
 	id = cleanID(id)
-	c.entryLocker.Lock(id)
+	c.nlocker.Lock(id)

 	info := ItemInfo{Name: id}

 	f, err := helpers.OpenFileForWriting(c.Fs, id)
 	if err != nil {
-		c.entryLocker.Unlock(id)
+		c.nlocker.Unlock(id)
 		return info, nil, err
 	}

 	return info, &lockedFile{
 		File:   f,
-		unlock: func() { c.entryLocker.Unlock(id) },
+		unlock: func() { c.nlocker.Unlock(id) },
 	}, nil
 }

@@ -145,16 +130,11 @@ func (c *Cache) WriteCloser(id string) (ItemInfo, io.WriteCloser, error) {
 // it when done.
 func (c *Cache) ReadOrCreate(id string,
 	read func(info ItemInfo, r io.ReadSeeker) error,
-	create func(info ItemInfo, w io.WriteCloser) error,
-) (info ItemInfo, err error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, err
-	}
-
+	create func(info ItemInfo, w io.WriteCloser) error) (info ItemInfo, err error) {
 	id = cleanID(id)

-	c.entryLocker.Lock(id)
-	defer c.entryLocker.Unlock(id)
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)

 	info = ItemInfo{Name: id}

@@ -180,26 +160,14 @@ func (c *Cache) ReadOrCreate(id string,
 	return
 }

-// NamedLock locks the given id. The lock is released when the returned function is called.
-func (c *Cache) NamedLock(id string) func() {
-	id = cleanID(id)
-	c.entryLocker.Lock(id)
-	return func() {
-		c.entryLocker.Unlock(id)
-	}
-}
-
 // GetOrCreate tries to get the file with the given id from cache. If not found or expired, create will
 // be invoked and the result cached.
 // This method is protected by a named lock using the given id as identifier.
 func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (ItemInfo, io.ReadCloser, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
 	id = cleanID(id)

-	c.entryLocker.Lock(id)
-	defer c.entryLocker.Unlock(id)
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)

 	info := ItemInfo{Name: id}

@@ -217,7 +185,7 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It
 		return info, nil, err
 	}

-	if c.cfg.MaxAge == 0 {
+	if c.maxAge == 0 {
 		// No caching.
 		return info, hugio.ToReadCloser(r), nil
 	}
@@ -225,74 +193,21 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It
 	var buff bytes.Buffer
 	return info,
 		hugio.ToReadCloser(&buff),
-		c.writeReader(id, io.TeeReader(r, &buff))
-}
-
-// AbsFilenameFromID returns the filename for the given id in the cache.
-// This will be an absolute path.
-func (c *Cache) AbsFilenameFromID(id string) string {
-	return filepath.Join(c.cfg.DirCompiled, cleanID(id))
-}
-
-// GetOrCreateInfo tries to get the item info with the given id from cache. If not found or expired, create will
-// be invoked with the id. The create function is expected to create the cache item with the given id. The returned ItemInfo will have the id as Name.
-// This method is protected by a named lock using the given id as identifier.
-func (c *Cache) GetOrCreateInfo(id string, create func(id string) error) (ItemInfo, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, err
-	}
-
-	id = cleanID(id)
-
-	c.entryLocker.Lock(id)
-	defer c.entryLocker.Unlock(id)
-
-	info := ItemInfo{Name: id}
-
-	if !c.removeIfNeeded(id) {
-		// The file exists and is not expired, so we consider it a cache hit.
-		return info, nil
-	}
-
-	if err := create(id); err != nil {
-		c.remove(id)
-		return info, err
-	}
-
-	return info, nil
-}
-
-func (c *Cache) writeReader(id string, r io.Reader) error {
-	dir := filepath.Dir(id)
-	if dir != "" {
-		_ = c.Fs.MkdirAll(dir, 0o777)
-	}
-	f, err := c.Fs.Create(id)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	_, _ = io.Copy(f, r)
-
-	return nil
+		afero.WriteReader(c.Fs, id, io.TeeReader(r, &buff))
 }

 // GetOrCreateBytes is the same as GetOrCreate, but produces a byte slice.
 func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (ItemInfo, []byte, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
 	id = cleanID(id)

-	c.entryLocker.Lock(id)
-	defer c.entryLocker.Unlock(id)
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)

 	info := ItemInfo{Name: id}

 	if r := c.getOrRemove(id); r != nil {
 		defer r.Close()
-		b, err := io.ReadAll(r)
+		b, err := ioutil.ReadAll(r)
 		return info, b, err
 	}

@@ -306,71 +221,40 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 		return info, nil, err
 	}

-	if c.cfg.MaxAge == 0 {
+	if c.maxAge == 0 {
 		return info, b, nil
 	}

-	if err := c.writeReader(id, bytes.NewReader(b)); err != nil {
+	if err := afero.WriteReader(c.Fs, id, bytes.NewReader(b)); err != nil {
 		return info, nil, err
 	}
-
 	return info, b, nil
 }

-// SetBytes sets the file content with the given id in the cache.
-func (c *Cache) SetBytes(id string, data []byte) error {
-	if err := c.init(); err != nil {
-		return err
-	}
-	id = cleanID(id)
-
-	c.entryLocker.Lock(id)
-	defer c.entryLocker.Unlock(id)
-
-	if c.cfg.MaxAge == 0 {
-		// No caching.
-		return nil
-	}
-
-	return c.writeReader(id, bytes.NewReader(data))
-}
-
 // GetBytes gets the file content with the given id from the cache, nil if none found.
-func (c *Cache) GetBytes(id string) ([]byte, error) {
-	_, b, err := c.GetItemBytes(id)
-	return b, err
-}
-
-// GetItemBytes gets the ItemInfo and file content with the given id from the cache, nil if none found.
-func (c *Cache) GetItemBytes(id string) (ItemInfo, []byte, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
+func (c *Cache) GetBytes(id string) (ItemInfo, []byte, error) {
 	id = cleanID(id)

-	c.entryLocker.Lock(id)
-	defer c.entryLocker.Unlock(id)
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)

 	info := ItemInfo{Name: id}

 	if r := c.getOrRemove(id); r != nil {
 		defer r.Close()
-		b, err := io.ReadAll(r)
+		b, err := ioutil.ReadAll(r)
 		return info, b, err
 	}

 	return info, nil, nil
 }

-// Get gets the file with the given id from the cache, nil if none found.
+// Get gets the file with the given id from the cahce, nil if none found.
 func (c *Cache) Get(id string) (ItemInfo, io.ReadCloser, error) {
-	if err := c.init(); err != nil {
-		return ItemInfo{}, nil, err
-	}
 	id = cleanID(id)

-	c.entryLocker.Lock(id)
-	defer c.entryLocker.Unlock(id)
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)

 	info := ItemInfo{Name: id}

@@ -379,29 +263,24 @@ func (c *Cache) Get(id string) (ItemInfo, io.ReadCloser, error) {
 	return info, r, nil
 }

-// removeIfNeeded checks if the file with the given id should be re-created.
-func (c *Cache) removeIfNeeded(id string) bool {
-	if c.cfg.MaxAge == 0 {
-		// No caching, remove.
-		c.remove(id)
-		return true
-	}
-	if removed, err := c.removeIfExpired(id); err != nil || removed {
-		return true
-	}
-	return false
-}
-
 // getOrRemove gets the file with the given id. If it's expired, it will
 // be removed.
 func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
-	if c.cfg.MaxAge == 0 {
+	if c.maxAge == 0 {
 		// No caching.
 		return nil
 	}

-	if removed, err := c.removeIfExpired(id); err != nil || removed {
-		return nil
+	if c.maxAge > 0 {
+		fi, err := c.Fs.Stat(id)
+		if err != nil {
+			return nil
+		}
+
+		if c.isExpired(fi.ModTime()) {
+			c.Fs.Remove(id)
+			return nil
+		}
 	}

 	f, err := c.Fs.Open(id)
@@ -412,73 +291,22 @@ func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
 	return f
 }

-func (c *Cache) getBytesAndRemoveIfExpired(id string) ([]byte, bool) {
-	if c.cfg.MaxAge == 0 {
-		// No caching.
-		return nil, false
-	}
-
-	f, err := c.Fs.Open(id)
-	if err != nil {
-		return nil, false
-	}
-	defer f.Close()
-
-	b, err := io.ReadAll(f)
-	if err != nil {
-		return nil, false
-	}
-
-	removed, err := c.removeIfExpired(id)
-	if err != nil {
-		return nil, false
-	}
-
-	return b, removed
-}
-
-func (c *Cache) removeIfExpired(id string) (bool, error) {
-	if c.cfg.MaxAge <= 0 {
-		return false, nil
-	}
-
-	fi, err := c.Fs.Stat(id)
-	if err != nil {
-		return false, err
-	}
-
-	if c.isExpired(fi.ModTime()) {
-		c.remove(id)
-		return true, nil
-	}
-
-	return false, nil
-}
-
-func (c *Cache) remove(id string) {
-	if c.cfg.entryIsDir {
-		c.Fs.RemoveAll(id)
-	} else {
-		c.Fs.Remove(id)
-	}
-}
-
 func (c *Cache) isExpired(modTime time.Time) bool {
-	if c.cfg.MaxAge < 0 {
+	if c.maxAge < 0 {
 		return false
 	}

 	// Note the use of time.Since here.
 	// We cannot use Hugo's global Clock for this.
-	return c.cfg.MaxAge == 0 || time.Since(modTime) > c.cfg.MaxAge
+	return c.maxAge == 0 || time.Since(modTime) > c.maxAge
 }

 // For testing
-func (c *Cache) GetString(id string) string {
+func (c *Cache) getString(id string) string {
 	id = cleanID(id)

-	c.entryLocker.Lock(id)
-	defer c.entryLocker.Unlock(id)
+	c.nlocker.Lock(id)
+	defer c.nlocker.Unlock(id)

 	f, err := c.Fs.Open(id)
 	if err != nil {
@@ -486,24 +314,13 @@ func (c *Cache) GetString(id string) string {
 	}
 	defer f.Close()

-	b, _ := io.ReadAll(f)
+	b, _ := ioutil.ReadAll(f)
 	return string(b)
 }

 // Caches is a named set of caches.
 type Caches map[string]*Cache

-func (f Caches) SetResourceFs(fs afero.Fs) {
-	for _, c := range f {
-		if c.cfg.IsResourceDir {
-			if c.isInited {
-				panic("cannot set resource fs after init")
-			}
-			c.Fs = hugofs.NewBasePathFs(fs, c.cfg.DirCompiled)
-		}
-	}
-}
-
 // Get gets a named cache, nil if none found.
 func (f Caches) Get(name string) *Cache {
 	return f[strings.ToLower(name)]
@@ -511,21 +328,52 @@ func (f Caches) Get(name string) *Cache {

 // NewCaches creates a new set of file caches from the given
 // configuration.
-func NewCaches(dcfg Configs, sourceFs afero.Fs) (Caches, error) {
-	fs := sourceFs
+func NewCaches(p *helpers.PathSpec) (Caches, error) {
+	var dcfg Configs
+	if c, ok := p.Cfg.Get("filecacheConfigs").(Configs); ok {
+		dcfg = c
+	} else {
+		var err error
+		dcfg, err = DecodeConfig(p.Fs.Source, p.Cfg)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	fs := p.Fs.Source

 	m := make(Caches)
 	for k, v := range dcfg {
 		var cfs afero.Fs
-		if v.IsResourceDir {
-			cfs = nil // Set later. TODO(bep) this needs to be cleanded up.
+
+		if v.isResourceDir {
+			cfs = p.BaseFs.ResourcesCache
 		} else {
-			cfs = hugofs.NewBasePathFs(fs, v.DirCompiled)
+			cfs = fs
 		}

-		c := NewCache(cfs, v)
+		if cfs == nil {
+			// TODO(bep) we still have some places that do not initialize the
+			// full dependencies of a site, e.g. the import Jekyll command.
+			// That command does not need these caches, so let us just continue
+			// for now.
+			continue
+		}

-		m[k] = c
+		baseDir := v.Dir
+
+		if err := cfs.MkdirAll(baseDir, 0777); err != nil && !os.IsExist(err) {
+			return nil, err
+		}
+
+		bfs := afero.NewBasePathFs(cfs, baseDir)
+
+		var pruneAllRootDir string
+		if k == cacheKeyModules {
+			pruneAllRootDir = "pkg"
+		}
+
+		m[k] = NewCache(bfs, v.MaxAge, pruneAllRootDir)
 	}

 	return m, nil
@@ -534,37 +382,3 @@ func NewCaches(dcfg Configs, sourceFs afero.Fs) (Caches, error) {
 func cleanID(name string) string {
 	return strings.TrimPrefix(filepath.Clean(name), helpers.FilePathSeparator)
 }
-
-// AsHTTPCache returns an httpcache.Cache implementation for this file cache.
-// Note that none of the methods are protected by named locks, so you need to make sure
-// to do that in your own code.
-func (c *Cache) AsHTTPCache() httpcache.Cache {
-	return &httpCache{c: c}
-}
-
-type httpCache struct {
-	c *Cache
-}
-
-func (h *httpCache) Get(id string) (resp []byte, ok bool) {
-	id = cleanID(id)
-	b, removed := h.c.getBytesAndRemoveIfExpired(id)
-
-	return b, !removed
-}
-
-func (h *httpCache) Set(id string, resp []byte) {
-	if h.c.cfg.MaxAge == 0 {
-		return
-	}
-
-	id = cleanID(id)
-
-	if err := h.c.writeReader(id, bytes.NewReader(resp)); err != nil {
-		panic(err)
-	}
-}
-
-func (h *httpCache) Delete(key string) {
-	h.c.Fs.Remove(key)
-}
@@ -11,201 +11,120 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-// Package filecache provides a file based cache for Hugo.
 package filecache

 import (
-	"encoding/json"
-	"errors"
 	"fmt"
 	"path"
 	"path/filepath"
 	"strings"
 	"time"

-	"github.com/gohugoio/hugo/common/hmaps"
+	"github.com/gohugoio/hugo/common/maps"
+
 	"github.com/gohugoio/hugo/config"

+	"github.com/gohugoio/hugo/helpers"
+
+	"errors"
+
 	"github.com/mitchellh/mapstructure"
 	"github.com/spf13/afero"
 )

 const (
+	cachesConfigKey = "caches"
+
 	resourcesGenDir = ":resourceDir/_gen"
 	cacheDirProject = ":cacheDir/:project"
 )

-const (
-	CacheKeyImages        = "images"
-	CacheKeyAssets        = "assets"
-	CacheKeyModules       = "modules"
-	CacheKeyModuleQueries = "modulequeries"
-	CacheKeyModuleGitInfo = "modulegitinfo"
-	CacheKeyGetResource   = "getresource"
-	CacheKeyMisc          = "misc"
-)
-
-type Configs map[string]FileCacheConfig
-
-// CacheDirModules returns the compiled path to the modules cache.
-// For internal use.
-func (c Configs) CacheDirModules() string {
-	return c[CacheKeyModules].DirCompiled
+var defaultCacheConfig = Config{
+	MaxAge: -1, // Never expire
+	Dir:    cacheDirProject,
 }

-// CacheDirMisc returns the compiled path to the misc cache.
-// For internal use.
-func (c Configs) CacheDirMisc() string {
-	return c[CacheKeyMisc].DirCompiled
+const (
+	cacheKeyGetJSON     = "getjson"
+	cacheKeyGetCSV      = "getcsv"
+	cacheKeyImages      = "images"
+	cacheKeyAssets      = "assets"
+	cacheKeyModules     = "modules"
+	cacheKeyGetResource = "getresource"
+)
+
+type Configs map[string]Config
+
+func (c Configs) CacheDirModules() string {
+	return c[cacheKeyModules].Dir
 }

 var defaultCacheConfigs = Configs{
-	CacheKeyModules: {
+	cacheKeyModules: {
 		MaxAge: -1,
 		Dir:    ":cacheDir/modules",
-		fileCacheConfigInternal: fileCacheConfigInternal{
-			entryIsDir: true,
-			isReadOnly: true, // we need to make it writable when pruning.
-		},
 	},
-	CacheKeyModuleQueries: {
-		MaxAge: 24 * time.Hour,
-		Dir:    ":cacheDir/modules",
-	},
-	CacheKeyModuleGitInfo: {
-		MaxAge: 24 * time.Hour,
-		Dir:    ":cacheDir/modules",
-		fileCacheConfigInternal: fileCacheConfigInternal{
-			entryIsDir: true,
-		},
-	},
-	CacheKeyImages: {
+	cacheKeyGetJSON: defaultCacheConfig,
+	cacheKeyGetCSV:  defaultCacheConfig,
+	cacheKeyImages: {
 		MaxAge: -1,
 		Dir:    resourcesGenDir,
 	},
-	CacheKeyAssets: {
+	cacheKeyAssets: {
 		MaxAge: -1,
 		Dir:    resourcesGenDir,
 	},
-	CacheKeyGetResource: {
+	cacheKeyGetResource: Config{
 		MaxAge: -1, // Never expire
 		Dir:    cacheDirProject,
 	},
-	CacheKeyMisc: {
-		MaxAge: -1,
-		Dir:    cacheDirProject,
-	},
 }

-func init() {
-	for k, v := range defaultCacheConfigs {
-		v.name = k
-		defaultCacheConfigs[k] = v
-	}
-}
-
-type FileCacheConfig struct {
+type Config struct {
 	// Max age of cache entries in this cache. Any items older than this will
 	// be removed and not returned from the cache.
-	// A negative value means forever, 0 means cache is disabled.
-	// Hugo is lenient with what types it accepts here, but we recommend using
-	// a duration string, a sequence of  decimal numbers, each with optional fraction and a unit suffix,
-	// such as "300ms", "1.5h" or "2h45m".
-	// Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+	// a negative value means forever, 0 means cache is disabled.
 	MaxAge time.Duration

 	// The directory where files are stored.
 	Dir string

-	fileCacheConfigInternal `json:"-"`
+	// Will resources/_gen will get its own composite filesystem that
+	// also checks any theme.
+	isResourceDir bool
 }

-func (cfg *FileCacheConfig) init() error {
-	if cfg.DirCompiled == "" {
-		// From unit tests. Just check that it does not contain any placeholders.
-		if strings.Contains(cfg.Dir, ":") {
-			return fmt.Errorf("cache dir %q contains unresolved placeholders", cfg.Dir)
-		}
-		cfg.DirCompiled = cfg.Dir
-	}
-	// Sanity check the config.
-	if len(cfg.DirCompiled) < 5 {
-		panic(fmt.Sprintf("invalid cache dir: %q", cfg.DirCompiled))
-	}
-	return nil
+// GetJSONCache gets the file cache for getJSON.
+func (f Caches) GetJSONCache() *Cache {
+	return f[cacheKeyGetJSON]
 }

-type fileCacheConfigInternal struct {
-	DirCompiled string
-
-	name          string // The name of this cache, e.g. "images", "modules" etc.
-	entryIsDir    bool   // when set, the cache entries represents directories directly below the base dir.
-	isReadOnly    bool   // when set, the cache is read only and needs to be pruned differently. This is used for the Go modules cache.
-	IsResourceDir bool   //  resources/_gen will get its own composite filesystem that also checks any theme. TODO(bep) unexport this.
-}
-
-// MarshalJSON marshals FileCacheConfig to JSON with MaxAge as a human-readable string.
-func (c FileCacheConfig) MarshalJSON() ([]byte, error) {
-	var maxAge any
-	if c.MaxAge == -1 {
-		maxAge = -1
-	} else {
-		maxAge = strings.TrimSuffix(c.MaxAge.String(), "0m0s")
-	}
-	return json.Marshal(&struct {
-		MaxAge any    `json:"maxAge"`
-		Dir    string `json:"dir"`
-	}{
-		MaxAge: maxAge,
-		Dir:    c.Dir,
-	})
+// GetCSVCache gets the file cache for getCSV.
+func (f Caches) GetCSVCache() *Cache {
+	return f[cacheKeyGetCSV]
 }

 // ImageCache gets the file cache for processed images.
 func (f Caches) ImageCache() *Cache {
-	return f[CacheKeyImages]
+	return f[cacheKeyImages]
 }

 // ModulesCache gets the file cache for Hugo Modules.
 func (f Caches) ModulesCache() *Cache {
-	return f[CacheKeyModules]
-}
-
-// ModuleQueriesCache gets the file cache for Hugo Module version queries.
-// Returns nil if not found.
-func (f Caches) ModuleQueriesCache() *Cache {
-	c, ok := f[CacheKeyModuleQueries]
-	if !ok {
-		panic("module queries cache not set")
-	}
-	return c
-}
-
-// ModuleGitInfoCache gets the file cache for Hugo Module git info.
-func (f Caches) ModuleGitInfoCache() *Cache {
-	c, ok := f[CacheKeyModuleGitInfo]
-	if !ok {
-		panic("module git info cache not set")
-	}
-	return c
+	return f[cacheKeyModules]
 }

 // AssetsCache gets the file cache for assets (processed resources, SCSS etc.).
 func (f Caches) AssetsCache() *Cache {
-	return f[CacheKeyAssets]
-}
-
-// MiscCache gets the file cache for miscellaneous stuff.
-func (f Caches) MiscCache() *Cache {
-	return f[CacheKeyMisc]
+	return f[cacheKeyAssets]
 }

 // GetResourceCache gets the file cache for remote resources.
 func (f Caches) GetResourceCache() *Cache {
-	return f[CacheKeyGetResource]
+	return f[cacheKeyGetResource]
 }

-func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Configs, error) {
+func DecodeConfig(fs afero.Fs, cfg config.Provider) (Configs, error) {
 	c := make(Configs)
 	valid := make(map[string]bool)
 	// Add defaults
@@ -214,17 +133,15 @@ func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Config
 		valid[k] = true
 	}

+	m := cfg.GetStringMap(cachesConfigKey)
+
 	_, isOsFs := fs.(*afero.OsFs)

 	for k, v := range m {
-		if _, ok := v.(hmaps.Params); !ok {
+		if _, ok := v.(maps.Params); !ok {
 			continue
 		}
-		var ok bool
-		cc, ok := c[k]
-		if !ok {
-			return nil, fmt.Errorf("%q is not a valid cache name", k)
-		}
+		cc := defaultCacheConfig

 		dc := &mapstructure.DecoderConfig{
 			Result:           &cc,
@@ -245,10 +162,17 @@ func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Config
 			return c, errors.New("must provide cache Dir")
 		}

-		c[k] = cc
+		name := strings.ToLower(k)
+		if !valid[name] {
+			return nil, fmt.Errorf("%q is not a valid cache name", name)
+		}

+		c[name] = cc
 	}

+	// This is a very old flag in Hugo, but we need to respect it.
+	disabled := cfg.GetBool("ignoreCache")
+
 	for k, v := range c {
 		dir := filepath.ToSlash(filepath.Clean(v.Dir))
 		hadSlash := strings.HasPrefix(dir, "/")
@@ -256,12 +180,12 @@ func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Config

 		for i, part := range parts {
 			if strings.HasPrefix(part, ":") {
-				resolved, isResource, err := resolveDirPlaceholder(fs, bcfg, part)
+				resolved, isResource, err := resolveDirPlaceholder(fs, cfg, part)
 				if err != nil {
 					return c, err
 				}
 				if isResource {
-					v.IsResourceDir = true
+					v.isResourceDir = true
 				}
 				parts[i] = resolved
 			}
@@ -271,29 +195,33 @@ func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Config
 		if hadSlash {
 			dir = "/" + dir
 		}
-		v.DirCompiled = filepath.Clean(filepath.FromSlash(dir))
+		v.Dir = filepath.Clean(filepath.FromSlash(dir))

-		if !v.IsResourceDir {
-			if isOsFs && !filepath.IsAbs(v.DirCompiled) {
-				return c, fmt.Errorf("%q must resolve to an absolute directory", v.DirCompiled)
+		if !v.isResourceDir {
+			if isOsFs && !filepath.IsAbs(v.Dir) {
+				return c, fmt.Errorf("%q must resolve to an absolute directory", v.Dir)
 			}

 			// Avoid cache in root, e.g. / (Unix) or c:\ (Windows)
-			if len(strings.TrimPrefix(v.DirCompiled, filepath.VolumeName(v.DirCompiled))) == 1 {
-				return c, fmt.Errorf("%q is a root folder and not allowed as cache dir", v.DirCompiled)
+			if len(strings.TrimPrefix(v.Dir, filepath.VolumeName(v.Dir))) == 1 {
+				return c, fmt.Errorf("%q is a root folder and not allowed as cache dir", v.Dir)
 			}
 		}

-		if !strings.HasPrefix(v.DirCompiled, "_gen") {
+		if !strings.HasPrefix(v.Dir, "_gen") {
 			// We do cache eviction (file removes) and since the user can set
 			// his/hers own cache directory, we really want to make sure
 			// we do not delete any files that do not belong to this cache.
 			// We do add the cache name as the root, but this is an extra safe
 			// guard. We skip the files inside /resources/_gen/ because
 			// that would be breaking.
-			v.DirCompiled = filepath.Join(v.DirCompiled, FilecacheRootDirname, k)
+			v.Dir = filepath.Join(v.Dir, filecacheRootDirname, k)
 		} else {
-			v.DirCompiled = filepath.Join(v.DirCompiled, k)
+			v.Dir = filepath.Join(v.Dir, k)
+		}
+
+		if disabled {
+			v.MaxAge = 0
 		}

 		c[k] = v
@@ -303,14 +231,17 @@ func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Config
 }

 // Resolves :resourceDir => /myproject/resources etc., :cacheDir => ...
-func resolveDirPlaceholder(fs afero.Fs, bcfg config.BaseConfig, placeholder string) (cacheDir string, isResource bool, err error) {
+func resolveDirPlaceholder(fs afero.Fs, cfg config.Provider, placeholder string) (cacheDir string, isResource bool, err error) {
+	workingDir := cfg.GetString("workingDir")
+
 	switch strings.ToLower(placeholder) {
 	case ":resourcedir":
 		return "", true, nil
 	case ":cachedir":
-		return bcfg.CacheDir, false, nil
+		d, err := helpers.GetCacheDir(fs, cfg)
+		return d, false, err
 	case ":project":
-		return filepath.Base(bcfg.WorkingDir), false, nil
+		return filepath.Base(workingDir), false, nil
 	}

 	return "", false, fmt.Errorf("%q is not a valid placeholder (valid values are :cacheDir or :resourceDir)", placeholder)
@@ -11,20 +11,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-package filecache_test
+package filecache

 import (
-	"encoding/json"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"testing"
 	"time"

 	"github.com/spf13/afero"

-	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/config/testconfig"

 	qt "github.com/frankban/quicktest"
 )
@@ -44,9 +42,12 @@ assetDir = "assets"
 archetypeDir = "archetypes"

 [caches]
-[caches.misc]
+[caches.getJSON]
 maxAge = "10m"
 dir = "/path/to/c1"
+[caches.getCSV]
+maxAge = "11h"
+dir = "/path/to/c2"
 [caches.images]
 dir = "/path/to/c3"
 [caches.getResource]
@@ -56,20 +57,22 @@ dir = "/path/to/c4"
 	cfg, err := config.FromConfigString(configStr, "toml")
 	c.Assert(err, qt.IsNil)
 	fs := afero.NewMemMapFs()
-	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)
+	decoded, err := DecodeConfig(fs, cfg)
+	c.Assert(err, qt.IsNil)

-	c2 := decoded["misc"]
-	c.Assert(c2.MaxAge.String(), qt.Equals, "10m0s")
-	c.Assert(c2.DirCompiled, qt.Equals, filepath.FromSlash("/path/to/c1/filecache/misc"))
+	c.Assert(len(decoded), qt.Equals, 6)
+
+	c2 := decoded["getcsv"]
+	c.Assert(c2.MaxAge.String(), qt.Equals, "11h0m0s")
+	c.Assert(c2.Dir, qt.Equals, filepath.FromSlash("/path/to/c2/filecache/getcsv"))

 	c3 := decoded["images"]
 	c.Assert(c3.MaxAge, qt.Equals, time.Duration(-1))
-	c.Assert(c3.DirCompiled, qt.Equals, filepath.FromSlash("/path/to/c3/filecache/images"))
+	c.Assert(c3.Dir, qt.Equals, filepath.FromSlash("/path/to/c3/filecache/images"))

 	c4 := decoded["getresource"]
 	c.Assert(c4.MaxAge, qt.Equals, time.Duration(-1))
-	c.Assert(c4.DirCompiled, qt.Equals, filepath.FromSlash("/path/to/c4/filecache/getresource"))
+	c.Assert(c4.Dir, qt.Equals, filepath.FromSlash("/path/to/c4/filecache/getresource"))
 }

 func TestDecodeConfigIgnoreCache(t *testing.T) {
@@ -88,9 +91,12 @@ archeTypedir = "archetypes"

 ignoreCache = true
 [caches]
-[caches.misc]
+[caches.getJSON]
 maxAge = 1234
 dir = "/path/to/c1"
+[caches.getCSV]
+maxAge = 3456
+dir = "/path/to/c2"
 [caches.images]
 dir = "/path/to/c3"
 [caches.getResource]
@@ -100,8 +106,10 @@ dir = "/path/to/c4"
 	cfg, err := config.FromConfigString(configStr, "toml")
 	c.Assert(err, qt.IsNil)
 	fs := afero.NewMemMapFs()
-	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)
+	decoded, err := DecodeConfig(fs, cfg)
+	c.Assert(err, qt.IsNil)
+
+	c.Assert(len(decoded), qt.Equals, 6)

 	for _, v := range decoded {
 		c.Assert(v.MaxAge, qt.Equals, time.Duration(0))
@@ -110,7 +118,7 @@ dir = "/path/to/c4"

 func TestDecodeConfigDefault(t *testing.T) {
 	c := qt.New(t)
-	cfg := config.New()
+	cfg := newTestConfig()

 	if runtime.GOOS == "windows" {
 		cfg.Set("resourceDir", "c:\\cache\\resources")
@@ -120,52 +128,71 @@ func TestDecodeConfigDefault(t *testing.T) {
 		cfg.Set("resourceDir", "/cache/resources")
 		cfg.Set("cacheDir", "/cache/thecache")
 	}
-	cfg.Set("workingDir", filepath.FromSlash("/my/cool/hugoproject"))

 	fs := afero.NewMemMapFs()
-	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)

-	imgConfig := decoded[filecache.CacheKeyImages]
-	miscConfig := decoded[filecache.CacheKeyMisc]
+	decoded, err := DecodeConfig(fs, cfg)
+
+	c.Assert(err, qt.IsNil)
+
+	c.Assert(len(decoded), qt.Equals, 6)
+
+	imgConfig := decoded[cacheKeyImages]
+	jsonConfig := decoded[cacheKeyGetJSON]

 	if runtime.GOOS == "windows" {
-		c.Assert(imgConfig.DirCompiled, qt.Equals, filepath.FromSlash("_gen/images"))
+		c.Assert(imgConfig.Dir, qt.Equals, filepath.FromSlash("_gen/images"))
 	} else {
-		c.Assert(imgConfig.DirCompiled, qt.Equals, "_gen/images")
-		c.Assert(miscConfig.DirCompiled, qt.Equals, "/cache/thecache/hugoproject/filecache/misc")
+		c.Assert(imgConfig.Dir, qt.Equals, "_gen/images")
+		c.Assert(jsonConfig.Dir, qt.Equals, "/cache/thecache/hugoproject/filecache/getjson")
 	}

-	c.Assert(imgConfig.IsResourceDir, qt.Equals, true)
-	c.Assert(miscConfig.IsResourceDir, qt.Equals, false)
+	c.Assert(imgConfig.isResourceDir, qt.Equals, true)
+	c.Assert(jsonConfig.isResourceDir, qt.Equals, false)
 }

-func TestFileCacheConfigMarshalJSON(t *testing.T) {
+func TestDecodeConfigInvalidDir(t *testing.T) {
+	t.Parallel()
+
 	c := qt.New(t)

-	cfg := config.New()
-	cfg.Set("cacheDir", "/cache")
-	cfg.Set("workingDir", "/my/project")
+	configStr := `
+resourceDir = "myresources"
+contentDir = "content"
+dataDir = "data"
+i18nDir = "i18n"
+layoutDir = "layouts"
+assetDir = "assets"
+archeTypedir = "archetypes"

+[caches]
+[caches.getJSON]
+maxAge = "10m"
+dir = "/"
+
+`
+	if runtime.GOOS == "windows" {
+		configStr = strings.Replace(configStr, "/", "c:\\\\", 1)
+	}
+
+	cfg, err := config.FromConfigString(configStr, "toml")
+	c.Assert(err, qt.IsNil)
 	fs := afero.NewMemMapFs()
-	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches

-	moduleQueriesConfig := decoded[filecache.CacheKeyModuleQueries]
-	c.Assert(moduleQueriesConfig.MaxAge, qt.Equals, 24*time.Hour)
-
-	// Also verify the new moduleGitInfo cache.
-	moduleGitInfoConfig := decoded[filecache.CacheKeyModuleGitInfo]
-	c.Assert(moduleGitInfoConfig.MaxAge, qt.Equals, 24*time.Hour)
-
-	b, err := json.Marshal(moduleQueriesConfig)
-	c.Assert(err, qt.IsNil)
-
-	c.Assert(string(b), qt.Contains, `"maxAge":"24h"`)
-	c.Assert(string(b), qt.Not(qt.Contains), "86400000000000")
-	c.Assert(string(b), qt.Not(qt.Contains), "8.64e")
-
-	moduleQueriesConfig.MaxAge = -1
-	b, err = json.Marshal(moduleQueriesConfig)
-	c.Assert(err, qt.IsNil)
-	c.Assert(string(b), qt.Contains, `"maxAge":-1`)
+	_, err = DecodeConfig(fs, cfg)
+	c.Assert(err, qt.Not(qt.IsNil))
+}
+
+func newTestConfig() config.Provider {
+	cfg := config.NewWithTestDefaults()
+	cfg.Set("workingDir", filepath.FromSlash("/my/cool/hugoproject"))
+	cfg.Set("contentDir", "content")
+	cfg.Set("dataDir", "data")
+	cfg.Set("resourceDir", "resources")
+	cfg.Set("i18nDir", "i18n")
+	cfg.Set("layoutDir", "layouts")
+	cfg.Set("archetypeDir", "archetypes")
+	cfg.Set("assetDir", "assets")
+
+	return cfg
 }
@@ -1,105 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package filecache_test
-
-import (
-	"path/filepath"
-	"testing"
-	"time"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/htesting"
-	"github.com/gohugoio/hugo/hugolib"
-)
-
-// See issue #10781. That issue wouldn't have been triggered if we kept
-// the empty root directories (e.g. _resources/gen/images).
-// It's still an upstream Go issue that we also need to handle, but
-// this is a test for the first part.
-func TestPruneShouldPreserveEmptyCacheRoots(t *testing.T) {
-	files := `
-- hugo.toml --
-baseURL = "https://example.com"
-- content/_index.md --
---
-title: "Home"
---
-
-`
-
-	b := hugolib.Test(t, files, hugolib.TestOptOsFs(), hugolib.TestOptWithConfig(func(c *hugolib.IntegrationTestConfig) {
-		c.RunGC = true
-	}))
-
-	_, err := b.H.BaseFs.ResourcesCache.Stat(filepath.Join("_gen", "images"))
-
-	b.Assert(err, qt.IsNil)
-}
-
-func TestPruneImages(t *testing.T) {
-	if htesting.IsCI() {
-		// TODO(bep)
-		t.Skip("skip flaky test on CI server")
-	}
-	t.Skip("skip flaky test")
-	files := `
-- hugo.toml --
-baseURL = "https://example.com"
-[caches]
-[caches.images]
-maxAge = "200ms"
-dir = ":resourceDir/_gen"
-- content/_index.md --
---
-title: "Home"
---
-- assets/a/pixel.png --
-iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
-- layouts/home.html --
-{{ warnf "HOME!" }}
-{{ $img := resources.GetMatch "**.png" }}
-{{ $img = $img.Resize "3x3" }}
-{{ $img.RelPermalink }}
-
-
-
-`
-
-	b := hugolib.TestRunning(t, files, hugolib.TestOptOsFs(), hugolib.TestOptInfo(), hugolib.TestOptWithConfig(func(c *hugolib.IntegrationTestConfig) {
-		c.RunGC = true
-	}))
-
-	b.Assert(b.GCCount, qt.Equals, 0)
-	b.Assert(b.H, qt.IsNotNil)
-
-	imagesCacheDir := filepath.Join("_gen", "images")
-	_, err := b.H.BaseFs.ResourcesCache.Stat(imagesCacheDir)
-
-	b.Assert(err, qt.IsNil)
-
-	// TODO(bep) we need a way to test full rebuilds.
-	// For now, just sleep a little so the cache elements expires.
-	time.Sleep(500 * time.Millisecond)
-
-	b.RenameFile("assets/a/pixel.png", "assets/b/pixel2.png").Build()
-
-	b.Assert(b.GCCount, qt.Equals, 1)
-	// Build it again to GC the empty a dir.
-	b.Build()
-
-	_, err = b.H.BaseFs.ResourcesCache.Stat(filepath.Join(imagesCacheDir, "a"))
-	b.Assert(err, qt.Not(qt.IsNil))
-	_, err = b.H.BaseFs.ResourcesCache.Stat(imagesCacheDir)
-	b.Assert(err, qt.IsNil)
-}
@@ -18,7 +18,6 @@ import (
 	"io"
 	"os"

-	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/hugofs"

 	"github.com/spf13/afero"
@@ -31,12 +30,13 @@ import (
 func (c Caches) Prune() (int, error) {
 	counter := 0
 	for k, cache := range c {
+
 		count, err := cache.Prune(false)

 		counter += count

 		if err != nil {
-			if herrors.IsNotExist(err) {
+			if os.IsNotExist(err) {
 				continue
 			}
 			return counter, fmt.Errorf("failed to prune cache %q: %w", k, err)
@@ -50,11 +50,8 @@ func (c Caches) Prune() (int, error) {
 // Prune removes expired and unused items from this cache.
 // If force is set, everything will be removed not considering expiry time.
 func (c *Cache) Prune(force bool) (int, error) {
-	if c.cfg.entryIsDir {
-		return c.pruneRootDirs(force)
-	}
-	if err := c.init(); err != nil {
-		return 0, err
+	if c.pruneAllRootDir != "" {
+		return c.pruneRootDir(force)
 	}

 	counter := 0
@@ -72,19 +69,14 @@ func (c *Cache) Prune(force bool) (int, error) {
 				// This cache dir may not exist.
 				return nil
 			}
+			defer f.Close()
 			_, err = f.Readdirnames(1)
-			f.Close()
 			if err == io.EOF {
 				// Empty dir.
-				if name == "." {
-					// e.g. /_gen/images -- keep it even if empty.
-					err = nil
-				} else {
-					err = c.Fs.Remove(name)
-				}
+				err = c.Fs.Remove(name)
 			}

-			if err != nil && !herrors.IsNotExist(err) {
+			if err != nil && !os.IsNotExist(err) {
 				return err
 			}

@@ -93,9 +85,10 @@ func (c *Cache) Prune(force bool) (int, error) {

 		shouldRemove := force || c.isExpired(info.ModTime())

-		if !shouldRemove && c.entryLocker.seen.Len() > 0 {
+		if !shouldRemove && len(c.nlocker.seen) > 0 {
 			// Remove it if it's not been touched/used in the last build.
-			shouldRemove = !c.entryLocker.seen.Has(name)
+			_, seen := c.nlocker.seen[name]
+			shouldRemove = !seen
 		}

 		if shouldRemove {
@@ -104,7 +97,7 @@ func (c *Cache) Prune(force bool) (int, error) {
 				counter++
 			}

-			if err != nil && !herrors.IsNotExist(err) {
+			if err != nil && !os.IsNotExist(err) {
 				return err
 			}

@@ -116,45 +109,10 @@ func (c *Cache) Prune(force bool) (int, error) {
 	return counter, err
 }

-func (c *Cache) pruneRootDirs(force bool) (int, error) {
-	dirs, err := afero.ReadDir(c.Fs, "")
+func (c *Cache) pruneRootDir(force bool) (int, error) {
+	info, err := c.Fs.Stat(c.pruneAllRootDir)
 	if err != nil {
-		if herrors.IsNotExist(err) {
-			return 0, nil
-		}
-		return 0, err
-	}
-
-	counter := 0
-
-	for _, dir := range dirs {
-		if !dir.IsDir() {
-			continue
-		}
-
-		count, err := c.pruneRootDir(dir.Name(), force)
-		if err != nil {
-			return counter, err
-		}
-		counter += count
-	}
-
-	return counter, nil
-}
-
-func (c *Cache) pruneRootDir(dirname string, force bool) (int, error) {
-	if err := c.init(); err != nil {
-		return 0, err
-	}
-
-	// Sanity check.
-	if dirname != "pkg" && len(dirname) < 5 {
-		panic(fmt.Sprintf("invalid cache dir name: %q", dirname))
-	}
-
-	info, err := c.Fs.Stat(dirname)
-	if err != nil {
-		if herrors.IsNotExist(err) {
+		if os.IsNotExist(err) {
 			return 0, nil
 		}
 		return 0, err
@@ -164,9 +122,5 @@ func (c *Cache) pruneRootDir(dirname string, force bool) (int, error) {
 		return 0, nil
 	}

-	if c.cfg.isReadOnly {
-		return hugofs.MakeReadableAndRemoveAllModulePkgDir(c.Fs, dirname)
-	}
-
-	return 1, c.Fs.RemoveAll(dirname)
+	return hugofs.MakeReadableAndRemoveAllModulePkgDir(c.Fs, c.pruneAllRootDir)
 }
@@ -11,15 +11,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-package filecache_test
+package filecache

 import (
 	"fmt"
 	"testing"
-	"testing/synctest"
 	"time"

-	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/spf13/afero"

 	qt "github.com/frankban/quicktest"
@@ -28,10 +26,9 @@ import (
 func TestPrune(t *testing.T) {
 	t.Parallel()

-	synctest.Test(t, func(t *testing.T) {
-		c := qt.New(t)
+	c := qt.New(t)

-		configStr := `
+	configStr := `
 resourceDir = "myresources"
 contentDir = "content"
 dataDir = "data"
@@ -41,9 +38,12 @@ assetDir = "assets"
 archeTypedir = "archetypes"

 [caches]
-[caches.misc]
+[caches.getjson]
 maxAge = "200ms"
 dir = "/cache/c"
+[caches.getcsv]
+maxAge = "200ms"
+dir = "/cache/d"
 [caches.assets]
 maxAge = "200ms"
 dir = ":resourceDir/_gen"
@@ -52,64 +52,59 @@ maxAge = "200ms"
 dir = ":resourceDir/_gen"
 `

-		for _, name := range []string{filecache.CacheKeyAssets, filecache.CacheKeyImages} {
-			msg := qt.Commentf("cache: %s", name)
-			fs := afero.NewMemMapFs()
-			p := newPathsSpec(t, fs, configStr)
-			fileCachConfig := p.Cfg.GetConfigSection("caches").(filecache.Configs)
-			caches, err := filecache.NewCaches(fileCachConfig, fs)
-			c.Assert(err, qt.IsNil)
-			caches.SetResourceFs(fs)
-			cache := caches[name]
-			for i := range 10 {
-				id := fmt.Sprintf("i%d", i)
-				cache.GetOrCreateBytes(id, func() ([]byte, error) {
-					return []byte("abc"), nil
-				})
-				if i == 4 {
-					// This will expire the first 5
-					time.Sleep(201 * time.Millisecond)
-				}
-			}
-
-			count, err := caches.Prune()
-			c.Assert(err, qt.IsNil)
-			c.Assert(count, qt.Equals, 5, msg)
-
-			for i := range 10 {
-				id := fmt.Sprintf("i%d", i)
-				v := cache.GetString(id)
-				if i < 5 {
-					c.Assert(v, qt.Equals, "")
-				} else {
-					c.Assert(v, qt.Equals, "abc")
-				}
-			}
-
-			caches, err = filecache.NewCaches(fileCachConfig, fs)
-			c.Assert(err, qt.IsNil)
-			caches.SetResourceFs(fs)
-			cache = caches[name]
-			// Touch one and then prune.
-			cache.GetOrCreateBytes("i5", func() ([]byte, error) {
+	for _, name := range []string{cacheKeyGetCSV, cacheKeyGetJSON, cacheKeyAssets, cacheKeyImages} {
+		msg := qt.Commentf("cache: %s", name)
+		p := newPathsSpec(t, afero.NewMemMapFs(), configStr)
+		caches, err := NewCaches(p)
+		c.Assert(err, qt.IsNil)
+		cache := caches[name]
+		for i := 0; i < 10; i++ {
+			id := fmt.Sprintf("i%d", i)
+			cache.GetOrCreateBytes(id, func() ([]byte, error) {
 				return []byte("abc"), nil
 			})
-
-			count, err = caches.Prune()
-			c.Assert(err, qt.IsNil)
-			c.Assert(count, qt.Equals, 4)
-
-			// Now only the i5 should be left.
-			for i := range 10 {
-				id := fmt.Sprintf("i%d", i)
-				v := cache.GetString(id)
-				if i != 5 {
-					c.Assert(v, qt.Equals, "")
-				} else {
-					c.Assert(v, qt.Equals, "abc")
-				}
+			if i == 4 {
+				// This will expire the first 5
+				time.Sleep(201 * time.Millisecond)
 			}
-
 		}
-	})
+
+		count, err := caches.Prune()
+		c.Assert(err, qt.IsNil)
+		c.Assert(count, qt.Equals, 5, msg)
+
+		for i := 0; i < 10; i++ {
+			id := fmt.Sprintf("i%d", i)
+			v := cache.getString(id)
+			if i < 5 {
+				c.Assert(v, qt.Equals, "")
+			} else {
+				c.Assert(v, qt.Equals, "abc")
+			}
+		}
+
+		caches, err = NewCaches(p)
+		c.Assert(err, qt.IsNil)
+		cache = caches[name]
+		// Touch one and then prune.
+		cache.GetOrCreateBytes("i5", func() ([]byte, error) {
+			return []byte("abc"), nil
+		})
+
+		count, err = caches.Prune()
+		c.Assert(err, qt.IsNil)
+		c.Assert(count, qt.Equals, 4)
+
+		// Now only the i5 should be left.
+		for i := 0; i < 10; i++ {
+			id := fmt.Sprintf("i%d", i)
+			v := cache.getString(id)
+			if i != 5 {
+				c.Assert(v, qt.Equals, "")
+			} else {
+				c.Assert(v, qt.Equals, "abc")
+			}
+		}
+
+	}
 }
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,23 +11,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-package filecache_test
+package filecache

 import (
 	"errors"
 	"fmt"
 	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"testing"
 	"time"

-	"github.com/gohugoio/hugo/htesting"
+	"github.com/gobwas/glob"
+
+	"github.com/gohugoio/hugo/langs"
+	"github.com/gohugoio/hugo/modules"

-	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/common/hugio"
 	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/config/testconfig"
 	"github.com/gohugoio/hugo/helpers"

 	"github.com/gohugoio/hugo/hugofs"
@@ -40,8 +44,13 @@ func TestFileCache(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)

-	tempWorkingDir := t.TempDir()
-	tempCacheDir := t.TempDir()
+	tempWorkingDir, err := ioutil.TempDir("", "hugo_filecache_test_work")
+	c.Assert(err, qt.IsNil)
+	defer os.Remove(tempWorkingDir)
+
+	tempCacheDir, err := ioutil.TempDir("", "hugo_filecache_test_cache")
+	c.Assert(err, qt.IsNil)
+	defer os.Remove(tempCacheDir)

 	osfs := afero.NewOsFs()

@@ -66,7 +75,7 @@ assetDir = "assets"
 archeTypedir = "archetypes"

 [caches]
-[caches.misc]
+[caches.getJSON]
 maxAge = "10h"
 dir = ":cacheDir/c"

@@ -80,17 +89,32 @@ dir = ":cacheDir/c"
 		configStr = strings.Replace(configStr, "\\", winPathSep, -1)

 		p := newPathsSpec(t, osfs, configStr)
-		fileCachConfig := p.Cfg.GetConfigSection("caches").(filecache.Configs)

-		caches, err := filecache.NewCaches(fileCachConfig, p.Fs.Source)
+		caches, err := NewCaches(p)
 		c.Assert(err, qt.IsNil)
-		caches.SetResourceFs(p.SourceFs)

-		cache := caches.Get("Misc")
+		cache := caches.Get("GetJSON")
 		c.Assert(cache, qt.Not(qt.IsNil))
+		c.Assert(cache.maxAge.String(), qt.Equals, "10h0m0s")
+
+		bfs, ok := cache.Fs.(*afero.BasePathFs)
+		c.Assert(ok, qt.Equals, true)
+		filename, err := bfs.RealPath("key")
+		c.Assert(err, qt.IsNil)
+		if test.cacheDir != "" {
+			c.Assert(filename, qt.Equals, filepath.Join(test.cacheDir, "c/"+filecacheRootDirname+"/getjson/key"))
+		} else {
+			// Temp dir.
+			c.Assert(filename, qt.Matches, ".*hugo_cache.*"+filecacheRootDirname+".*key")
+		}

 		cache = caches.Get("Images")
 		c.Assert(cache, qt.Not(qt.IsNil))
+		c.Assert(cache.maxAge, qt.Equals, time.Duration(-1))
+		bfs, ok = cache.Fs.(*afero.BasePathFs)
+		c.Assert(ok, qt.Equals, true)
+		filename, _ = bfs.RealPath("key")
+		c.Assert(filename, qt.Equals, filepath.FromSlash("_gen/images/key"))

 		rf := func(s string) func() (io.ReadCloser, error) {
 			return func() (io.ReadCloser, error) {
@@ -99,7 +123,7 @@ dir = ":cacheDir/c"
 					io.Closer
 				}{
 					strings.NewReader(s),
-					io.NopCloser(nil),
+					ioutil.NopCloser(nil),
 				}, nil
 			}
 		}
@@ -108,13 +132,13 @@ dir = ":cacheDir/c"
 			return []byte("bcd"), nil
 		}

-		for _, ca := range []*filecache.Cache{caches.ImageCache(), caches.AssetsCache()} {
-			for range 2 {
+		for _, ca := range []*Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
+			for i := 0; i < 2; i++ {
 				info, r, err := ca.GetOrCreate("a", rf("abc"))
 				c.Assert(err, qt.IsNil)
 				c.Assert(r, qt.Not(qt.IsNil))
 				c.Assert(info.Name, qt.Equals, "a")
-				b, _ := io.ReadAll(r)
+				b, _ := ioutil.ReadAll(r)
 				r.Close()
 				c.Assert(string(b), qt.Equals, "abc")

@@ -130,28 +154,30 @@ dir = ":cacheDir/c"

 				_, r, err = ca.GetOrCreate("a", rf("bcd"))
 				c.Assert(err, qt.IsNil)
-				b, _ = io.ReadAll(r)
+				b, _ = ioutil.ReadAll(r)
 				r.Close()
 				c.Assert(string(b), qt.Equals, "abc")
 			}
 		}

+		c.Assert(caches.Get("getJSON"), qt.Not(qt.IsNil))
+
 		info, w, err := caches.ImageCache().WriteCloser("mykey")
 		c.Assert(err, qt.IsNil)
 		c.Assert(info.Name, qt.Equals, "mykey")
 		io.WriteString(w, "Hugo is great!")
 		w.Close()
-		c.Assert(caches.ImageCache().GetString("mykey"), qt.Equals, "Hugo is great!")
+		c.Assert(caches.ImageCache().getString("mykey"), qt.Equals, "Hugo is great!")

 		info, r, err := caches.ImageCache().Get("mykey")
 		c.Assert(err, qt.IsNil)
 		c.Assert(r, qt.Not(qt.IsNil))
 		c.Assert(info.Name, qt.Equals, "mykey")
-		b, _ := io.ReadAll(r)
+		b, _ := ioutil.ReadAll(r)
 		r.Close()
 		c.Assert(string(b), qt.Equals, "Hugo is great!")

-		info, b, err = caches.ImageCache().GetItemBytes("mykey")
+		info, b, err = caches.ImageCache().GetBytes("mykey")
 		c.Assert(err, qt.IsNil)
 		c.Assert(info.Name, qt.Equals, "mykey")
 		c.Assert(string(b), qt.Equals, "Hugo is great!")
@@ -160,7 +186,6 @@ dir = ":cacheDir/c"
 }

 func TestFileCacheConcurrent(t *testing.T) {
-	htesting.SkipSlowTestUnlessCI(t)
 	t.Parallel()

 	c := qt.New(t)
@@ -175,19 +200,18 @@ assetDir = "assets"
 archeTypedir = "archetypes"

 [caches]
-[caches.misc]
+[caches.getjson]
 maxAge = "1s"
 dir = "/cache/c"

 `

 	p := newPathsSpec(t, afero.NewMemMapFs(), configStr)
-	fileCachConfig := p.Cfg.GetConfigSection("caches").(filecache.Configs)
-	caches, err := filecache.NewCaches(fileCachConfig, p.Fs.Source)
-	c.Assert(err, qt.IsNil)
-	caches.SetResourceFs(p.Fs.Source)

-	const cacheName = "misc"
+	caches, err := NewCaches(p)
+	c.Assert(err, qt.IsNil)
+
+	const cacheName = "getjson"

 	filenameData := func(i int) (string, string) {
 		data := fmt.Sprintf("data: %d", i)
@@ -197,11 +221,11 @@ dir = "/cache/c"

 	var wg sync.WaitGroup

-	for i := range 50 {
+	for i := 0; i < 50; i++ {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
-			for range 20 {
+			for j := 0; j < 20; j++ {
 				ca := caches.Get(cacheName)
 				c.Assert(ca, qt.Not(qt.IsNil))
 				filename, data := filenameData(i)
@@ -209,7 +233,7 @@ dir = "/cache/c"
 					return hugio.ToReadCloser(strings.NewReader(data)), nil
 				})
 				c.Assert(err, qt.IsNil)
-				b, _ := io.ReadAll(r)
+				b, _ := ioutil.ReadAll(r)
 				r.Close()
 				c.Assert(string(b), qt.Equals, data)
 				// Trigger some expiration.
@@ -227,24 +251,24 @@ func TestFileCacheReadOrCreateErrorInRead(t *testing.T) {

 	var result string

-	rf := func(failLevel int) func(info filecache.ItemInfo, r io.ReadSeeker) error {
-		return func(info filecache.ItemInfo, r io.ReadSeeker) error {
+	rf := func(failLevel int) func(info ItemInfo, r io.ReadSeeker) error {
+		return func(info ItemInfo, r io.ReadSeeker) error {
 			if failLevel > 0 {
 				if failLevel > 1 {
-					return filecache.ErrFatal
+					return ErrFatal
 				}
 				return errors.New("fail")
 			}

-			b, _ := io.ReadAll(r)
+			b, _ := ioutil.ReadAll(r)
 			result = string(b)

 			return nil
 		}
 	}

-	bf := func(s string) func(info filecache.ItemInfo, w io.WriteCloser) error {
-		return func(info filecache.ItemInfo, w io.WriteCloser) error {
+	bf := func(s string) func(info ItemInfo, w io.WriteCloser) error {
+		return func(info ItemInfo, w io.WriteCloser) error {
 			defer w.Close()
 			result = s
 			_, err := w.Write([]byte(s))
@@ -252,12 +276,7 @@ func TestFileCacheReadOrCreateErrorInRead(t *testing.T) {
 		}
 	}

-	cfg := filecache.FileCacheConfig{
-		MaxAge: 100 * time.Hour,
-		Dir:    "cache/c",
-	}
-
-	cache := filecache.NewCache(afero.NewMemMapFs(), cfg)
+	cache := NewCache(afero.NewMemMapFs(), 100*time.Hour, "")

 	const id = "a32"

@@ -271,15 +290,60 @@ func TestFileCacheReadOrCreateErrorInRead(t *testing.T) {
 	c.Assert(err, qt.IsNil)
 	c.Assert(result, qt.Equals, "v3")
 	_, err = cache.ReadOrCreate(id, rf(2), bf("v3"))
-	c.Assert(err, qt.Equals, filecache.ErrFatal)
+	c.Assert(err, qt.Equals, ErrFatal)
+}
+
+func TestCleanID(t *testing.T) {
+	c := qt.New(t)
+	c.Assert(cleanID(filepath.FromSlash("/a/b//c.txt")), qt.Equals, filepath.FromSlash("a/b/c.txt"))
+	c.Assert(cleanID(filepath.FromSlash("a/b//c.txt")), qt.Equals, filepath.FromSlash("a/b/c.txt"))
+}
+
+func initConfig(fs afero.Fs, cfg config.Provider) error {
+	if _, err := langs.LoadLanguageSettings(cfg, nil); err != nil {
+		return err
+	}
+
+	modConfig, err := modules.DecodeConfig(cfg)
+	if err != nil {
+		return err
+	}
+
+	workingDir := cfg.GetString("workingDir")
+	themesDir := cfg.GetString("themesDir")
+	if !filepath.IsAbs(themesDir) {
+		themesDir = filepath.Join(workingDir, themesDir)
+	}
+	globAll := glob.MustCompile("**", '/')
+	modulesClient := modules.NewClient(modules.ClientConfig{
+		Fs:           fs,
+		WorkingDir:   workingDir,
+		ThemesDir:    themesDir,
+		ModuleConfig: modConfig,
+		IgnoreVendor: globAll,
+	})
+
+	moduleConfig, err := modulesClient.Collect()
+	if err != nil {
+		return err
+	}
+
+	if err := modules.ApplyProjectConfigDefaults(cfg, moduleConfig.ActiveModules[len(moduleConfig.ActiveModules)-1]); err != nil {
+		return err
+	}
+
+	cfg.Set("allModules", moduleConfig.ActiveModules)
+
+	return nil
 }

 func newPathsSpec(t *testing.T, fs afero.Fs, configStr string) *helpers.PathSpec {
 	c := qt.New(t)
 	cfg, err := config.FromConfigString(configStr, "toml")
 	c.Assert(err, qt.IsNil)
-	acfg := testconfig.GetTestConfig(fs, cfg)
-	p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, acfg.BaseConfig()), acfg, nil, nil)
+	initConfig(fs, cfg)
+	config.SetBaseTestDefaults(cfg)
+	p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, cfg), cfg, nil)
 	c.Assert(err, qt.IsNil)
 	return p
 }
@@ -1,240 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package httpcache
-
-import (
-	"encoding/json"
-	"time"
-
-	"github.com/gobwas/glob"
-	"github.com/gohugoio/hugo/common/predicate"
-	"github.com/gohugoio/hugo/config"
-	"github.com/mitchellh/mapstructure"
-)
-
-// DefaultConfig holds the default configuration for the HTTP cache.
-var DefaultConfig = Config{
-	RespectCacheControlNoStoreInRequest:  true,
-	RespectCacheControlNoStoreInResponse: false,
-	Cache: Cache{
-		For: GlobMatcher{
-			Excludes: []string{"**"},
-		},
-	},
-	Polls: []PollConfig{
-		{
-			For: GlobMatcher{
-				Includes: []string{"**"},
-			},
-			Disable: true,
-		},
-	},
-}
-
-// Config holds the configuration for the HTTP cache.
-type Config struct {
-	// When enabled and there's a Cache-Control: no-store directive in the request, response will never be stored in disk cache.
-	RespectCacheControlNoStoreInRequest bool
-
-	// When enabled and there's a Cache-Control: no-store directive in the response, response will never be stored in disk cache.
-	RespectCacheControlNoStoreInResponse bool
-
-	// Enables HTTP cache behavior (RFC 9111) for these resources.
-	// When this is not enabled for a resource, Hugo will go straight to the file cache.
-	Cache Cache
-
-	// Polls holds a list of configurations for polling remote resources to detect changes in watch mode.
-	// This can be disabled for some resources, typically if they are known to not change.
-	Polls []PollConfig
-}
-
-type Cache struct {
-	// Enable HTTP cache behavior (RFC 9111) for these resources.
-	For GlobMatcher
-}
-
-func (c *Config) Compile() (ConfigCompiled, error) {
-	cc := ConfigCompiled{
-		Base: *c,
-	}
-
-	p, err := c.Cache.For.CompilePredicate()
-	if err != nil {
-		return cc, err
-	}
-
-	cc.For = p
-
-	for _, pc := range c.Polls {
-
-		p, err := pc.For.CompilePredicate()
-		if err != nil {
-			return cc, err
-		}
-
-		cc.PollConfigs = append(cc.PollConfigs, PollConfigCompiled{
-			For:    p,
-			Config: pc,
-		})
-	}
-
-	return cc, nil
-}
-
-// PollConfig holds the configuration for polling remote resources to detect changes in watch mode.
-type PollConfig struct {
-	// What remote resources to apply this configuration to.
-	For GlobMatcher
-
-	// Disable polling for this configuration.
-	Disable bool
-
-	// Low is the lower bound for the polling interval.
-	// This is the starting point when the resource has recently changed,
-	// if that resource stops changing, the polling interval will gradually increase towards High.
-	Low time.Duration
-
-	// High is the upper bound for the polling interval.
-	// This is the interval used when the resource is stable.
-	High time.Duration
-}
-
-func (c PollConfig) MarshalJSON() (b []byte, err error) {
-	// Marshal the durations as strings.
-	type Alias PollConfig
-	return json.Marshal(&struct {
-		Low  string
-		High string
-		Alias
-	}{
-		Low:   c.Low.String(),
-		High:  c.High.String(),
-		Alias: (Alias)(c),
-	})
-}
-
-type GlobMatcher struct {
-	// Excludes holds a list of glob patterns that will be excluded.
-	Excludes []string
-
-	// Includes holds a list of glob patterns that will be included.
-	Includes []string
-}
-
-func (gm GlobMatcher) IsZero() bool {
-	return len(gm.Includes) == 0 && len(gm.Excludes) == 0
-}
-
-type ConfigCompiled struct {
-	Base        Config
-	For         predicate.P[string]
-	PollConfigs []PollConfigCompiled
-}
-
-func (c *ConfigCompiled) PollConfigFor(s string) PollConfigCompiled {
-	for _, pc := range c.PollConfigs {
-		if pc.For(s) {
-			return pc
-		}
-	}
-	return PollConfigCompiled{}
-}
-
-func (c *ConfigCompiled) IsPollingDisabled() bool {
-	for _, pc := range c.PollConfigs {
-		if !pc.Config.Disable {
-			return false
-		}
-	}
-	return true
-}
-
-type PollConfigCompiled struct {
-	For    predicate.P[string]
-	Config PollConfig
-}
-
-func (p PollConfigCompiled) IsZero() bool {
-	return p.For == nil
-}
-
-func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
-	if gm.IsZero() {
-		panic("no includes or excludes")
-	}
-	var b predicate.PR[string]
-	for _, include := range gm.Includes {
-		g, err := glob.Compile(include, '/')
-		if err != nil {
-			return nil, err
-		}
-		fn := func(s string) predicate.Match {
-			return predicate.BoolMatch(g.Match(s))
-		}
-		b = b.Or(fn)
-	}
-
-	for _, exclude := range gm.Excludes {
-		g, err := glob.Compile(exclude, '/')
-		if err != nil {
-			return nil, err
-		}
-		fn := func(s string) predicate.Match {
-			return predicate.BoolMatch(!g.Match(s))
-		}
-		b = b.And(fn)
-	}
-
-	return b.BoolFunc(), nil
-}
-
-func DecodeConfig(_ config.BaseConfig, m map[string]any) (Config, error) {
-	if len(m) == 0 {
-		return DefaultConfig, nil
-	}
-
-	var c Config
-
-	dc := &mapstructure.DecoderConfig{
-		Result:           &c,
-		DecodeHook:       mapstructure.StringToTimeDurationHookFunc(),
-		WeaklyTypedInput: true,
-	}
-
-	decoder, err := mapstructure.NewDecoder(dc)
-	if err != nil {
-		return c, err
-	}
-
-	if err := decoder.Decode(m); err != nil {
-		return c, err
-	}
-
-	if c.Cache.For.IsZero() {
-		c.Cache.For = DefaultConfig.Cache.For
-	}
-
-	for pci := range c.Polls {
-		if c.Polls[pci].For.IsZero() {
-			c.Polls[pci].For = DefaultConfig.Cache.For
-			c.Polls[pci].Disable = true
-		}
-	}
-
-	if len(c.Polls) == 0 {
-		c.Polls = DefaultConfig.Polls
-	}
-
-	return c, nil
-}
@@ -1,95 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package httpcache_test
-
-import (
-	"testing"
-	"time"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/hugolib"
-)
-
-func TestConfigCustom(t *testing.T) {
-	t.Parallel()
-
-	files := `
-- hugo.toml --
-[httpcache]
-[httpcache.cache.for]
-includes = ["**gohugo.io**"]
-[[httpcache.polls]]
-low = "5s"
-high = "32s"
-[httpcache.polls.for]
-includes = ["**gohugo.io**"]
-		
-	
-`
-
-	b := hugolib.Test(t, files)
-
-	httpcacheConf := b.H.Configs.Base.HTTPCache
-	compiled := b.H.Configs.Base.C.HTTPCache
-
-	b.Assert(httpcacheConf.Cache.For.Includes, qt.DeepEquals, []string{"**gohugo.io**"})
-	b.Assert(httpcacheConf.Cache.For.Excludes, qt.IsNil)
-
-	pc := compiled.PollConfigFor("https://gohugo.io/foo.jpg")
-	b.Assert(pc.Config.Low, qt.Equals, 5*time.Second)
-	b.Assert(pc.Config.High, qt.Equals, 32*time.Second)
-	b.Assert(compiled.PollConfigFor("https://example.com/foo.jpg").IsZero(), qt.IsTrue)
-}
-
-func TestConfigDefault(t *testing.T) {
-	t.Parallel()
-
-	files := `
-- hugo.toml --
-`
-	b := hugolib.Test(t, files)
-
-	compiled := b.H.Configs.Base.C.HTTPCache
-
-	b.Assert(compiled.For("https://gohugo.io/posts.json"), qt.IsFalse)
-	b.Assert(compiled.For("https://gohugo.io/foo.jpg"), qt.IsFalse)
-	b.Assert(compiled.PollConfigFor("https://gohugo.io/foo.jpg").Config.Disable, qt.IsTrue)
-}
-
-func TestConfigPollsOnly(t *testing.T) {
-	t.Parallel()
-	files := `
-- hugo.toml --
-[httpcache]
-[[httpcache.polls]]
-low = "5s"
-high = "32s"
-[httpcache.polls.for]
-includes = ["**gohugo.io**"]
-		
-	
-`
-
-	b := hugolib.Test(t, files)
-
-	compiled := b.H.Configs.Base.C.HTTPCache
-
-	b.Assert(compiled.For("https://gohugo.io/posts.json"), qt.IsFalse)
-	b.Assert(compiled.For("https://gohugo.io/foo.jpg"), qt.IsFalse)
-
-	pc := compiled.PollConfigFor("https://gohugo.io/foo.jpg")
-	b.Assert(pc.Config.Low, qt.Equals, 5*time.Second)
-	b.Assert(pc.Config.High, qt.Equals, 32*time.Second)
-	b.Assert(compiled.PollConfigFor("https://example.com/foo.jpg").IsZero(), qt.IsTrue)
-}
@@ -1,73 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package httpcache
-
-import (
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/config"
-)
-
-func TestGlobMatcher(t *testing.T) {
-	c := qt.New(t)
-
-	g := GlobMatcher{
-		Includes: []string{"**/*.jpg", "**.png", "**/bar/**"},
-		Excludes: []string{"**/foo.jpg", "**.css"},
-	}
-
-	p, err := g.CompilePredicate()
-	c.Assert(err, qt.IsNil)
-
-	c.Assert(p("foo.jpg"), qt.IsFalse)
-	c.Assert(p("foo.png"), qt.IsTrue)
-	c.Assert(p("foo/bar.jpg"), qt.IsTrue)
-	c.Assert(p("foo/bar.png"), qt.IsTrue)
-	c.Assert(p("foo/bar/foo.jpg"), qt.IsFalse)
-	c.Assert(p("foo/bar/foo.css"), qt.IsFalse)
-	c.Assert(p("foo.css"), qt.IsFalse)
-	c.Assert(p("foo/bar/foo.css"), qt.IsFalse)
-	c.Assert(p("foo/bar/foo.xml"), qt.IsTrue)
-}
-
-func TestDefaultConfig(t *testing.T) {
-	c := qt.New(t)
-
-	_, err := DefaultConfig.Compile()
-	c.Assert(err, qt.IsNil)
-}
-
-func TestDecodeConfigInjectsDefaultAndCompiles(t *testing.T) {
-	c := qt.New(t)
-
-	cfg, err := DecodeConfig(config.BaseConfig{}, map[string]any{})
-	c.Assert(err, qt.IsNil)
-	c.Assert(cfg, qt.DeepEquals, DefaultConfig)
-
-	_, err = cfg.Compile()
-	c.Assert(err, qt.IsNil)
-
-	cfg, err = DecodeConfig(config.BaseConfig{}, map[string]any{
-		"cache": map[string]any{
-			"polls": []map[string]any{
-				{"disable": true},
-			},
-		},
-	})
-	c.Assert(err, qt.IsNil)
-
-	_, err = cfg.Compile()
-	c.Assert(err, qt.IsNil)
-}
@@ -0,0 +1,78 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package namedmemcache provides a memory cache with a named lock. This is suitable
+// for situations where creating the cached resource can be time consuming or otherwise
+// resource hungry, or in situations where a "once only per key" is a requirement.
+package namedmemcache
+
+import (
+	"sync"
+
+	"github.com/BurntSushi/locker"
+)
+
+// Cache holds the cached values.
+type Cache struct {
+	nlocker *locker.Locker
+	cache   map[string]cacheEntry
+	mu      sync.RWMutex
+}
+
+type cacheEntry struct {
+	value any
+	err   error
+}
+
+// New creates a new cache.
+func New() *Cache {
+	return &Cache{
+		nlocker: locker.NewLocker(),
+		cache:   make(map[string]cacheEntry),
+	}
+}
+
+// Clear clears the cache state.
+func (c *Cache) Clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.cache = make(map[string]cacheEntry)
+	c.nlocker = locker.NewLocker()
+}
+
+// GetOrCreate tries to get the value with the given cache key, if not found
+// create will be called and cached.
+// This method is thread safe. It also guarantees that the create func for a given
+// key is invoked only once for this cache.
+func (c *Cache) GetOrCreate(key string, create func() (any, error)) (any, error) {
+	c.mu.RLock()
+	entry, found := c.cache[key]
+	c.mu.RUnlock()
+
+	if found {
+		return entry.value, entry.err
+	}
+
+	c.nlocker.Lock(key)
+	defer c.nlocker.Unlock(key)
+
+	// Create it.
+	value, err := create()
+
+	c.mu.Lock()
+	c.cache[key] = cacheEntry{value: value, err: err}
+	c.mu.Unlock()
+
+	return value, err
+}
@@ -0,0 +1,80 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package namedmemcache
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestNamedCache(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	cache := New()
+
+	counter := 0
+	create := func() (any, error) {
+		counter++
+		return counter, nil
+	}
+
+	for i := 0; i < 5; i++ {
+		v1, err := cache.GetOrCreate("a1", create)
+		c.Assert(err, qt.IsNil)
+		c.Assert(v1, qt.Equals, 1)
+		v2, err := cache.GetOrCreate("a2", create)
+		c.Assert(err, qt.IsNil)
+		c.Assert(v2, qt.Equals, 2)
+	}
+
+	cache.Clear()
+
+	v3, err := cache.GetOrCreate("a2", create)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v3, qt.Equals, 3)
+}
+
+func TestNamedCacheConcurrent(t *testing.T) {
+	t.Parallel()
+
+	c := qt.New(t)
+
+	var wg sync.WaitGroup
+
+	cache := New()
+
+	create := func(i int) func() (any, error) {
+		return func() (any, error) {
+			return i, nil
+		}
+	}
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 100; j++ {
+				id := fmt.Sprintf("id%d", j)
+				v, err := cache.GetOrCreate(id, create(j))
+				c.Assert(err, qt.IsNil)
+				c.Assert(v, qt.Equals, j)
+			}
+		}()
+	}
+	wg.Wait()
+}
@@ -1,82 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Default to all packages if none specified
-PACKAGES="${1:-./...}"
-
-echo "==> Checking packages: $PACKAGES"
-
-# Timing arrays
-declare -a STEP_NAMES
-declare -a STEP_TIMES
-
-time_step() {
-    local name="$1"
-    shift
-    local start=$(date +%s.%N)
-    "$@"
-    local end=$(date +%s.%N)
-    local elapsed=$(echo "$end - $start" | bc)
-    STEP_NAMES+=("$name")
-    STEP_TIMES+=("$elapsed")
-}
-
-# Check gofmt
-run_gofmt() {
-    echo "==> Running gofmt..."
-    # Convert package pattern to path (e.g., ./hugolib/... -> ./hugolib)
-    local path="${PACKAGES%/...}"
-    GOFMT_OUTPUT=$(gofmt -l "$path" 2>&1) || true
-    if [ -n "$GOFMT_OUTPUT" ]; then
-        echo "gofmt found issues in:"
-        echo "$GOFMT_OUTPUT"
-        exit 1
-    fi
-    echo "    OK"
-}
-
-# Run staticcheck
-run_staticcheck() {
-    # Check if staticcheck is installed, install if not
-    if ! command -v staticcheck &> /dev/null; then
-        echo "==> Installing staticcheck..."
-        go install honnef.co/go/tools/cmd/staticcheck@latest
-    fi
-    echo "==> Running staticcheck..."
-    staticcheck $PACKAGES
-    echo "    OK"
-}
-
-# Run tests
-run_tests() {
-    echo "==> Running tests..."
-    local output
-    if ! output=$(go test -failfast $PACKAGES 2>&1); then
-        echo "$output"
-        exit 1
-    fi
-    echo "    OK"
-}
-
-# Run all steps with timing
-TOTAL_START=$(date +%s.%N)
-
-time_step "gofmt" run_gofmt
-time_step "staticcheck" run_staticcheck
-time_step "tests" run_tests
-
-TOTAL_END=$(date +%s.%N)
-TOTAL_ELAPSED=$(echo "$TOTAL_END - $TOTAL_START" | bc)
-
-# Print timing summary
-echo ""
-echo "==> All checks passed!"
-echo ""
-echo "Timing summary:"
-echo "---------------"
-for i in "${!STEP_NAMES[@]}"; do
-    printf "  %-15s %6.2fs\n" "${STEP_NAMES[$i]}" "${STEP_TIMES[$i]}"
-done
-echo "---------------"
-printf "  %-15s %6.2fs\n" "Total" "$TOTAL_ELAPSED"
@@ -1,2 +0,0 @@
-#!/usr/bin/env bash
-diff <(gofmt -d .) <(printf '')
@@ -26,7 +26,6 @@ import (
 	"path/filepath"
 	"reflect"
 	"regexp"
-	"slices"
 	"sort"
 	"strings"
 	"sync"
@@ -73,7 +72,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 	nameAndPackage := func(t reflect.Type) (string, string) {
 		var name, pkg string

-		isPointer := t.Kind() == reflect.Pointer
+		isPointer := t.Kind() == reflect.Ptr

 		if isPointer {
 			t = t.Elem()
@@ -103,7 +102,9 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 	}

 	for _, t := range include {
-		for m := range t.Methods() {
+		for i := 0; i < t.NumMethod(); i++ {
+
+			m := t.Method(i)
 			if excludes[m.Name] || seen[m.Name] {
 				continue
 			}
@@ -121,7 +122,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T

 			method := Method{Owner: t, OwnerName: ownerName, Name: m.Name}

-			for i := range numIn {
+			for i := 0; i < numIn; i++ {
 				in := m.Type.In(i)

 				name, pkg := nameAndPackage(in)
@@ -136,7 +137,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 			numOut := m.Type.NumOut()

 			if numOut > 0 {
-				for i := range numOut {
+				for i := 0; i < numOut; i++ {
 					out := m.Type.Out(i)
 					name, pkg := nameAndPackage(out)

@@ -303,7 +304,7 @@ func (m Method) inOutStr() string {
 	}

 	args := make([]string, len(m.In))
-	for i := range args {
+	for i := 0; i < len(args); i++ {
 		args[i] = fmt.Sprintf("arg%d", i)
 	}
 	return "(" + strings.Join(args, ", ") + ")"
@@ -315,7 +316,7 @@ func (m Method) inStr() string {
 	}

 	args := make([]string, len(m.In))
-	for i := range args {
+	for i := 0; i < len(args); i++ {
 		args[i] = fmt.Sprintf("arg%d %s", i, m.In[i])
 	}
 	return "(" + strings.Join(args, ", ") + ")"
@@ -338,7 +339,7 @@ func (m Method) outStrNamed() string {
 	}

 	outs := make([]string, len(m.Out))
-	for i := range outs {
+	for i := 0; i < len(outs); i++ {
 		outs[i] = fmt.Sprintf("o%d %s", i, m.Out[i])
 	}

@@ -434,7 +435,7 @@ func (m Methods) ToMarshalJSON(receiver, pkgPath string, excludes ...string) (st
 		// Exclude self
 		for i, pkgImp := range pkgImports {
 			if pkgImp == pkgPath {
-				pkgImports = slices.Delete(pkgImports, i, i+1)
+				pkgImports = append(pkgImports[:i], pkgImports[i+1:]...)
 			}
 		}
 	}
@@ -451,15 +452,12 @@ func collectMethodsRecursive(pkg string, f []*ast.Field) []string {
 		}

 		if ident, ok := m.Type.(*ast.Ident); ok && ident.Obj != nil {
-			switch tt := ident.Obj.Decl.(*ast.TypeSpec).Type.(type) {
-			case *ast.InterfaceType:
-				// Embedded interface
-				methodNames = append(
-					methodNames,
-					collectMethodsRecursive(
-						pkg,
-						tt.Methods.List)...)
-			}
+			// Embedded interface
+			methodNames = append(
+				methodNames,
+				collectMethodsRecursive(
+					pkg,
+					ident.Obj.Decl.(*ast.TypeSpec).Type.(*ast.InterfaceType).Methods.List)...)
 		} else {
 			// Embedded, but in a different file/package. Return the
 			// package.Name and deal with that later.
@@ -26,9 +26,9 @@ import (

 func TestMethods(t *testing.T) {
 	var (
-		zeroIE     = reflect.TypeFor[IEmbed]()
-		zeroIEOnly = reflect.TypeFor[IEOnly]()
-		zeroI      = reflect.TypeFor[I]()
+		zeroIE     = reflect.TypeOf((*IEmbed)(nil)).Elem()
+		zeroIEOnly = reflect.TypeOf((*IEOnly)(nil)).Elem()
+		zeroI      = reflect.TypeOf((*I)(nil)).Elem()
 	)

 	dir, _ := os.Getwd()
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2019 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,60 +14,330 @@
 package commands

 import (
-	"context"
+	"fmt"
+	"os"
+	"time"

-	"github.com/bep/simplecobra"
+	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/common/loggers"
+	hpaths "github.com/gohugoio/hugo/common/paths"
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/spf13/cobra"
 )

-// newExec wires up all of Hugo's CLI.
-func newExec() (*simplecobra.Exec, error) {
-	rootCmd := &rootCommand{
-		commands: []simplecobra.Commander{
-			newHugoBuildCmd(),
-			newVersionCmd(),
-			newEnvCommand(),
-			newServerCommand(),
-			newDeployCommand(),
-			newConfigCommand(),
-			newNewCommand(),
-			newConvertCommand(),
-			newImportCommand(),
-			newListCommand(),
-			newModCommands(),
-			newGenCommand(),
-			newReleaseCommand(),
-		},
+type commandsBuilder struct {
+	hugoBuilderCommon
+
+	commands []cmder
+}
+
+func newCommandsBuilder() *commandsBuilder {
+	return &commandsBuilder{}
+}
+
+func (b *commandsBuilder) addCommands(commands ...cmder) *commandsBuilder {
+	b.commands = append(b.commands, commands...)
+	return b
+}
+
+func (b *commandsBuilder) addAll() *commandsBuilder {
+	b.addCommands(
+		b.newServerCmd(),
+		newVersionCmd(),
+		newEnvCmd(),
+		b.newConfigCmd(),
+		b.newDeployCmd(),
+		b.newConvertCmd(),
+		b.newNewCmd(),
+		b.newListCmd(),
+		newImportCmd(),
+		newGenCmd(),
+		createReleaser(),
+		b.newModCmd(),
+	)
+
+	return b
+}
+
+func (b *commandsBuilder) build() *hugoCmd {
+	h := b.newHugoCmd()
+	addCommands(h.getCommand(), b.commands...)
+	return h
+}
+
+func addCommands(root *cobra.Command, commands ...cmder) {
+	for _, command := range commands {
+		cmd := command.getCommand()
+		if cmd == nil {
+			continue
+		}
+		root.AddCommand(cmd)
 	}
-
-	return simplecobra.New(rootCmd)
 }

-func newHugoBuildCmd() simplecobra.Commander {
-	return &hugoBuildCommand{}
+type baseCmd struct {
+	cmd *cobra.Command
 }

-// hugoBuildCommand just delegates to the rootCommand.
-type hugoBuildCommand struct {
-	rootCmd *rootCommand
+var _ commandsBuilderGetter = (*baseBuilderCmd)(nil)
+
+// Used in tests.
+type commandsBuilderGetter interface {
+	getCommandsBuilder() *commandsBuilder
 }

-func (c *hugoBuildCommand) Commands() []simplecobra.Commander {
+type baseBuilderCmd struct {
+	*baseCmd
+	*commandsBuilder
+}
+
+func (b *baseBuilderCmd) getCommandsBuilder() *commandsBuilder {
+	return b.commandsBuilder
+}
+
+func (c *baseCmd) getCommand() *cobra.Command {
+	return c.cmd
+}
+
+func newBaseCmd(cmd *cobra.Command) *baseCmd {
+	return &baseCmd{cmd: cmd}
+}
+
+func (b *commandsBuilder) newBuilderCmd(cmd *cobra.Command) *baseBuilderCmd {
+	bcmd := &baseBuilderCmd{commandsBuilder: b, baseCmd: &baseCmd{cmd: cmd}}
+	bcmd.hugoBuilderCommon.handleFlags(cmd)
+	return bcmd
+}
+
+func (b *commandsBuilder) newBuilderBasicCmd(cmd *cobra.Command) *baseBuilderCmd {
+	bcmd := &baseBuilderCmd{commandsBuilder: b, baseCmd: &baseCmd{cmd: cmd}}
+	bcmd.hugoBuilderCommon.handleCommonBuilderFlags(cmd)
+	return bcmd
+}
+
+func (c *baseCmd) flagsToConfig(cfg config.Provider) {
+	initializeFlags(c.cmd, cfg)
+}
+
+type hugoCmd struct {
+	*baseBuilderCmd
+
+	// Need to get the sites once built.
+	c *commandeer
+}
+
+var _ cmder = (*nilCommand)(nil)
+
+type nilCommand struct{}
+
+func (c *nilCommand) getCommand() *cobra.Command {
 	return nil
 }

-func (c *hugoBuildCommand) Name() string {
-	return "build"
+func (c *nilCommand) flagsToConfig(cfg config.Provider) {
 }

-func (c *hugoBuildCommand) Init(cd *simplecobra.Commandeer) error {
-	c.rootCmd = cd.Root.Command.(*rootCommand)
-	return c.rootCmd.initRootCommand("build", cd)
+func (b *commandsBuilder) newHugoCmd() *hugoCmd {
+	cc := &hugoCmd{}
+
+	cc.baseBuilderCmd = b.newBuilderCmd(&cobra.Command{
+		Use:   "hugo",
+		Short: "hugo builds your site",
+		Long: `hugo is the main command, used to build your Hugo site.
+
+Hugo is a Fast and Flexible Static Site Generator
+built with love by spf13 and friends in Go.
+
+Complete documentation is available at https://gohugo.io/.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			defer cc.timeTrack(time.Now(), "Total")
+			cfgInit := func(c *commandeer) error {
+				if cc.buildWatch {
+					c.Set("disableLiveReload", true)
+				}
+				return nil
+			}
+
+			// prevent cobra printing error so it can be handled here (before the timeTrack prints)
+			cmd.SilenceErrors = true
+
+			c, err := initializeConfig(true, true, cc.buildWatch, &cc.hugoBuilderCommon, cc, cfgInit)
+			if err != nil {
+				cmd.PrintErrln("Error:", err.Error())
+				return err
+			}
+			cc.c = c
+
+			err = c.build()
+			if err != nil {
+				cmd.PrintErrln("Error:", err.Error())
+			}
+			return err
+		},
+	})
+
+	cc.cmd.PersistentFlags().StringVar(&cc.cfgFile, "config", "", "config file (default is path/config.yaml|json|toml)")
+	cc.cmd.PersistentFlags().StringVar(&cc.cfgDir, "configDir", "config", "config dir")
+	cc.cmd.PersistentFlags().BoolVar(&cc.quiet, "quiet", false, "build in quiet mode")
+
+	// Set bash-completion
+	_ = cc.cmd.PersistentFlags().SetAnnotation("config", cobra.BashCompFilenameExt, config.ValidConfigFileExtensions)
+
+	cc.cmd.PersistentFlags().BoolVarP(&cc.verbose, "verbose", "v", false, "verbose output")
+	cc.cmd.PersistentFlags().BoolVarP(&cc.debug, "debug", "", false, "debug output")
+	cc.cmd.PersistentFlags().BoolVar(&cc.logging, "log", false, "enable Logging")
+	cc.cmd.PersistentFlags().StringVar(&cc.logFile, "logFile", "", "log File path (if set, logging enabled automatically)")
+	cc.cmd.PersistentFlags().BoolVar(&cc.verboseLog, "verboseLog", false, "verbose logging")
+
+	cc.cmd.Flags().BoolVarP(&cc.buildWatch, "watch", "w", false, "watch filesystem for changes and recreate as needed")
+
+	cc.cmd.Flags().Bool("renderToMemory", false, "render to memory (only useful for benchmark testing)")
+
+	// Set bash-completion
+	_ = cc.cmd.PersistentFlags().SetAnnotation("logFile", cobra.BashCompFilenameExt, []string{})
+
+	cc.cmd.SetGlobalNormalizationFunc(helpers.NormalizeHugoFlags)
+	cc.cmd.SilenceUsage = true
+
+	return cc
 }

-func (c *hugoBuildCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	return c.rootCmd.PreRun(cd, runner)
+type hugoBuilderCommon struct {
+	source      string
+	baseURL     string
+	environment string
+
+	buildWatch bool
+	poll       string
+	clock      string
+
+	gc bool
+
+	// Profile flags (for debugging of performance problems)
+	cpuprofile   string
+	memprofile   string
+	mutexprofile string
+	traceprofile string
+	printm       bool
+
+	// TODO(bep) var vs string
+	logging    bool
+	verbose    bool
+	verboseLog bool
+	debug      bool
+	quiet      bool
+
+	cfgFile string
+	cfgDir  string
+	logFile string
 }

-func (c *hugoBuildCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	return c.rootCmd.Run(ctx, cd, args)
+func (cc *hugoBuilderCommon) timeTrack(start time.Time, name string) {
+	if cc.quiet {
+		return
+	}
+	elapsed := time.Since(start)
+	fmt.Printf("%s in %v ms\n", name, int(1000*elapsed.Seconds()))
+}
+
+func (cc *hugoBuilderCommon) getConfigDir(baseDir string) string {
+	if cc.cfgDir != "" {
+		return hpaths.AbsPathify(baseDir, cc.cfgDir)
+	}
+
+	if v, found := os.LookupEnv("HUGO_CONFIGDIR"); found {
+		return hpaths.AbsPathify(baseDir, v)
+	}
+
+	return hpaths.AbsPathify(baseDir, "config")
+}
+
+func (cc *hugoBuilderCommon) getEnvironment(isServer bool) string {
+	if cc.environment != "" {
+		return cc.environment
+	}
+
+	if v, found := os.LookupEnv("HUGO_ENVIRONMENT"); found {
+		return v
+	}
+
+	//  Used by Netlify and Forestry
+	if v, found := os.LookupEnv("HUGO_ENV"); found {
+		return v
+	}
+
+	if isServer {
+		return hugo.EnvironmentDevelopment
+	}
+
+	return hugo.EnvironmentProduction
+}
+
+func (cc *hugoBuilderCommon) handleCommonBuilderFlags(cmd *cobra.Command) {
+	cmd.PersistentFlags().StringVarP(&cc.source, "source", "s", "", "filesystem path to read files relative from")
+	cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+	cmd.PersistentFlags().StringVarP(&cc.environment, "environment", "e", "", "build environment")
+	cmd.PersistentFlags().StringP("themesDir", "", "", "filesystem path to themes directory")
+	cmd.PersistentFlags().StringP("ignoreVendorPaths", "", "", "ignores any _vendor for module paths matching the given Glob pattern")
+	cmd.PersistentFlags().StringVar(&cc.clock, "clock", "", "set the clock used by Hugo, e.g. --clock 2021-11-06T22:30:00.00+09:00")
+}
+
+func (cc *hugoBuilderCommon) handleFlags(cmd *cobra.Command) {
+	cc.handleCommonBuilderFlags(cmd)
+	cmd.Flags().Bool("cleanDestinationDir", false, "remove files from destination not found in static directories")
+	cmd.Flags().BoolP("buildDrafts", "D", false, "include content marked as draft")
+	cmd.Flags().BoolP("buildFuture", "F", false, "include content with publishdate in the future")
+	cmd.Flags().BoolP("buildExpired", "E", false, "include expired content")
+	cmd.Flags().StringP("contentDir", "c", "", "filesystem path to content directory")
+	cmd.Flags().StringP("layoutDir", "l", "", "filesystem path to layout directory")
+	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/")
+	cmd.Flags().BoolP("ignoreCache", "", false, "ignores the cache directory")
+	cmd.Flags().StringP("destination", "d", "", "filesystem path to write files to")
+	cmd.Flags().StringSliceP("theme", "t", []string{}, "themes to use (located in /themes/THEMENAME/)")
+	cmd.Flags().StringVarP(&cc.baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. https://spf13.com/")
+	cmd.Flags().Bool("enableGitInfo", false, "add Git revision, date, author, and CODEOWNERS info to the pages")
+	cmd.Flags().BoolVar(&cc.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
+	cmd.Flags().StringVar(&cc.poll, "poll", "", "set this to a poll interval, e.g --poll 700ms, to use a poll based approach to watch for file system changes")
+	cmd.Flags().BoolVar(&loggers.PanicOnWarning, "panicOnWarning", false, "panic on first WARNING log")
+	cmd.Flags().Bool("templateMetrics", false, "display metrics about template executions")
+	cmd.Flags().Bool("templateMetricsHints", false, "calculate some improvement hints when combined with --templateMetrics")
+	cmd.Flags().BoolP("forceSyncStatic", "", false, "copy all files when static is changed.")
+	cmd.Flags().BoolP("noTimes", "", false, "don't sync modification time of files")
+	cmd.Flags().BoolP("noChmod", "", false, "don't sync permission mode of files")
+	cmd.Flags().BoolP("noBuildLock", "", false, "don't create .hugo_build.lock file")
+	cmd.Flags().BoolP("printI18nWarnings", "", false, "print missing translations")
+	cmd.Flags().BoolP("printPathWarnings", "", false, "print warnings on duplicate target paths etc.")
+	cmd.Flags().BoolP("printUnusedTemplates", "", false, "print warnings on unused templates.")
+	cmd.Flags().StringVarP(&cc.cpuprofile, "profile-cpu", "", "", "write cpu profile to `file`")
+	cmd.Flags().StringVarP(&cc.memprofile, "profile-mem", "", "", "write memory profile to `file`")
+	cmd.Flags().BoolVarP(&cc.printm, "printMemoryUsage", "", false, "print memory usage to screen at intervals")
+	cmd.Flags().StringVarP(&cc.mutexprofile, "profile-mutex", "", "", "write Mutex profile to `file`")
+	cmd.Flags().StringVarP(&cc.traceprofile, "trace", "", "", "write trace to `file` (not useful in general)")
+
+	// Hide these for now.
+	cmd.Flags().MarkHidden("profile-cpu")
+	cmd.Flags().MarkHidden("profile-mem")
+	cmd.Flags().MarkHidden("profile-mutex")
+
+	cmd.Flags().StringSlice("disableKinds", []string{}, "disable different kind of pages (home, RSS etc.)")
+
+	cmd.Flags().Bool("minify", false, "minify any supported output format (HTML, XML etc.)")
+
+	// Set bash-completion.
+	// Each flag must first be defined before using the SetAnnotation() call.
+	_ = cmd.Flags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.Flags().SetAnnotation("cacheDir", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.Flags().SetAnnotation("destination", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
+}
+
+func checkErr(logger loggers.Logger, err error, s ...string) {
+	if err == nil {
+		return
+	}
+	for _, message := range s {
+		logger.Errorln(message)
+	}
+	logger.Errorln(err)
 }
@@ -0,0 +1,396 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/gohugoio/hugo/config"
+
+	"github.com/spf13/afero"
+
+	"github.com/gohugoio/hugo/hugofs"
+
+	"github.com/gohugoio/hugo/common/types"
+
+	"github.com/spf13/cobra"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestExecute(t *testing.T) {
+	c := qt.New(t)
+
+	createSite := func(c *qt.C) string {
+		dir := createSimpleTestSite(t, testSiteConfig{})
+		return dir
+	}
+
+	c.Run("hugo", func(c *qt.C) {
+		dir := createSite(c)
+		resp := Execute([]string{"-s=" + dir})
+		c.Assert(resp.Err, qt.IsNil)
+		result := resp.Result
+		c.Assert(len(result.Sites) == 1, qt.Equals, true)
+		c.Assert(len(result.Sites[0].RegularPages()) == 1, qt.Equals, true)
+		c.Assert(result.Sites[0].Info.Params()["myparam"], qt.Equals, "paramproduction")
+	})
+
+	c.Run("hugo, set environment", func(c *qt.C) {
+		dir := createSite(c)
+		resp := Execute([]string{"-s=" + dir, "-e=staging"})
+		c.Assert(resp.Err, qt.IsNil)
+		result := resp.Result
+		c.Assert(result.Sites[0].Info.Params()["myparam"], qt.Equals, "paramstaging")
+	})
+
+	c.Run("convert toJSON", func(c *qt.C) {
+		dir := createSite(c)
+		output := filepath.Join(dir, "myjson")
+		resp := Execute([]string{"convert", "toJSON", "-s=" + dir, "-e=staging", "-o=" + output})
+		c.Assert(resp.Err, qt.IsNil)
+		converted := readFileFrom(c, filepath.Join(output, "content", "p1.md"))
+		c.Assert(converted, qt.Equals, "{\n   \"title\": \"P1\",\n   \"weight\": 1\n}\n\nContent\n\n", qt.Commentf(converted))
+	})
+
+	c.Run("config, set environment", func(c *qt.C) {
+		dir := createSite(c)
+		out, err := captureStdout(func() error {
+			resp := Execute([]string{"config", "-s=" + dir, "-e=staging"})
+			return resp.Err
+		})
+		c.Assert(err, qt.IsNil)
+		c.Assert(out, qt.Contains, "params = map[myparam:paramstaging]", qt.Commentf(out))
+	})
+
+	c.Run("deploy, environment set", func(c *qt.C) {
+		dir := createSite(c)
+		resp := Execute([]string{"deploy", "-s=" + dir, "-e=staging", "--target=mydeployment", "--dryRun"})
+		c.Assert(resp.Err, qt.Not(qt.IsNil))
+		c.Assert(resp.Err.Error(), qt.Contains, `no driver registered for "hugocloud"`)
+	})
+
+	c.Run("list", func(c *qt.C) {
+		dir := createSite(c)
+		out, err := captureStdout(func() error {
+			resp := Execute([]string{"list", "all", "-s=" + dir, "-e=staging"})
+			return resp.Err
+		})
+		c.Assert(err, qt.IsNil)
+		c.Assert(out, qt.Contains, "p1.md")
+	})
+
+	c.Run("new theme", func(c *qt.C) {
+		dir := createSite(c)
+		themesDir := filepath.Join(dir, "mythemes")
+		resp := Execute([]string{"new", "theme", "mytheme", "-s=" + dir, "-e=staging", "--themesDir=" + themesDir})
+		c.Assert(resp.Err, qt.IsNil)
+		themeTOML := readFileFrom(c, filepath.Join(themesDir, "mytheme", "theme.toml"))
+		c.Assert(themeTOML, qt.Contains, "name = \"Mytheme\"")
+	})
+
+	c.Run("new site", func(c *qt.C) {
+		dir := createSite(c)
+		siteDir := filepath.Join(dir, "mysite")
+		resp := Execute([]string{"new", "site", siteDir, "-e=staging"})
+		c.Assert(resp.Err, qt.IsNil)
+		config := readFileFrom(c, filepath.Join(siteDir, "config.toml"))
+		c.Assert(config, qt.Contains, "baseURL = 'http://example.org/'")
+		checkNewSiteInited(c, siteDir)
+	})
+}
+
+func checkNewSiteInited(c *qt.C, basepath string) {
+	paths := []string{
+		filepath.Join(basepath, "layouts"),
+		filepath.Join(basepath, "content"),
+		filepath.Join(basepath, "archetypes"),
+		filepath.Join(basepath, "static"),
+		filepath.Join(basepath, "data"),
+		filepath.Join(basepath, "config.toml"),
+	}
+
+	for _, path := range paths {
+		_, err := os.Stat(path)
+		c.Assert(err, qt.IsNil)
+	}
+}
+
+func readFileFrom(c *qt.C, filename string) string {
+	c.Helper()
+	filename = filepath.Clean(filename)
+	b, err := afero.ReadFile(hugofs.Os, filename)
+	c.Assert(err, qt.IsNil)
+	return string(b)
+}
+
+func TestFlags(t *testing.T) {
+	c := qt.New(t)
+
+	noOpRunE := func(cmd *cobra.Command, args []string) error {
+		return nil
+	}
+
+	tests := []struct {
+		name  string
+		args  []string
+		check func(c *qt.C, cmd *serverCmd)
+	}{
+		{
+			// https://github.com/gohugoio/hugo/issues/7642
+			name: "ignoreVendorPaths",
+			args: []string{"server", "--ignoreVendorPaths=github.com/**"},
+			check: func(c *qt.C, cmd *serverCmd) {
+				cfg := config.NewWithTestDefaults()
+				cmd.flagsToConfig(cfg)
+				c.Assert(cfg.Get("ignoreVendorPaths"), qt.Equals, "github.com/**")
+			},
+		},
+		{
+			name: "Persistent flags",
+			args: []string{
+				"server",
+				"--config=myconfig.toml",
+				"--configDir=myconfigdir",
+				"--contentDir=mycontent",
+				"--disableKinds=page,home",
+				"--environment=testing",
+				"--configDir=myconfigdir",
+				"--layoutDir=mylayouts",
+				"--theme=mytheme",
+				"--gc",
+				"--themesDir=mythemes",
+				"--cleanDestinationDir",
+				"--navigateToChanged",
+				"--disableLiveReload",
+				"--noHTTPCache",
+				"--printI18nWarnings",
+				"--destination=/tmp/mydestination",
+				"-b=https://example.com/b/",
+				"--port=1366",
+				"--renderToDisk",
+				"--source=mysource",
+				"--printPathWarnings",
+				"--printUnusedTemplates",
+			},
+			check: func(c *qt.C, sc *serverCmd) {
+				c.Assert(sc, qt.Not(qt.IsNil))
+				c.Assert(sc.navigateToChanged, qt.Equals, true)
+				c.Assert(sc.disableLiveReload, qt.Equals, true)
+				c.Assert(sc.noHTTPCache, qt.Equals, true)
+				c.Assert(sc.renderToDisk, qt.Equals, true)
+				c.Assert(sc.serverPort, qt.Equals, 1366)
+				c.Assert(sc.environment, qt.Equals, "testing")
+
+				cfg := config.NewWithTestDefaults()
+				sc.flagsToConfig(cfg)
+				c.Assert(cfg.GetString("publishDir"), qt.Equals, "/tmp/mydestination")
+				c.Assert(cfg.GetString("contentDir"), qt.Equals, "mycontent")
+				c.Assert(cfg.GetString("layoutDir"), qt.Equals, "mylayouts")
+				c.Assert(cfg.GetStringSlice("theme"), qt.DeepEquals, []string{"mytheme"})
+				c.Assert(cfg.GetString("themesDir"), qt.Equals, "mythemes")
+				c.Assert(cfg.GetString("baseURL"), qt.Equals, "https://example.com/b/")
+
+				c.Assert(cfg.Get("disableKinds"), qt.DeepEquals, []string{"page", "home"})
+
+				c.Assert(cfg.GetBool("gc"), qt.Equals, true)
+
+				// The flag is named printPathWarnings
+				c.Assert(cfg.GetBool("logPathWarnings"), qt.Equals, true)
+
+				// The flag is named printI18nWarnings
+				c.Assert(cfg.GetBool("logI18nWarnings"), qt.Equals, true)
+			},
+		},
+	}
+
+	for _, test := range tests {
+		c.Run(test.name, func(c *qt.C) {
+			b := newCommandsBuilder()
+			root := b.addAll().build()
+
+			for _, cmd := range b.commands {
+				if cmd.getCommand() == nil {
+					continue
+				}
+				// We are only intereseted in the flag handling here.
+				cmd.getCommand().RunE = noOpRunE
+			}
+			rootCmd := root.getCommand()
+			rootCmd.SetArgs(test.args)
+			c.Assert(rootCmd.Execute(), qt.IsNil)
+			test.check(c, b.commands[0].(*serverCmd))
+		})
+	}
+}
+
+func TestCommandsExecute(t *testing.T) {
+	c := qt.New(t)
+
+	dir := createSimpleTestSite(t, testSiteConfig{})
+	dirOut := t.TempDir()
+
+	sourceFlag := fmt.Sprintf("-s=%s", dir)
+
+	tests := []struct {
+		commands           []string
+		flags              []string
+		expectErrToContain string
+	}{
+		// TODO(bep) permission issue on my OSX? "operation not permitted" {[]string{"check", "ulimit"}, nil, false},
+		{[]string{"env"}, nil, ""},
+		{[]string{"version"}, nil, ""},
+		// no args = hugo build
+		{nil, []string{sourceFlag}, ""},
+		{nil, []string{sourceFlag, "--renderToMemory"}, ""},
+		{[]string{"completion", "bash"}, nil, ""},
+		{[]string{"completion", "fish"}, nil, ""},
+		{[]string{"completion", "powershell"}, nil, ""},
+		{[]string{"completion", "zsh"}, nil, ""},
+		{[]string{"config"}, []string{sourceFlag}, ""},
+		{[]string{"convert", "toTOML"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "toml")}, ""},
+		{[]string{"convert", "toYAML"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "yaml")}, ""},
+		{[]string{"convert", "toJSON"}, []string{sourceFlag, "-o=" + filepath.Join(dirOut, "json")}, ""},
+		{[]string{"gen", "chromastyles"}, []string{"--style=manni"}, ""},
+		{[]string{"gen", "doc"}, []string{"--dir=" + filepath.Join(dirOut, "doc")}, ""},
+		{[]string{"gen", "man"}, []string{"--dir=" + filepath.Join(dirOut, "man")}, ""},
+		{[]string{"list", "drafts"}, []string{sourceFlag}, ""},
+		{[]string{"list", "expired"}, []string{sourceFlag}, ""},
+		{[]string{"list", "future"}, []string{sourceFlag}, ""},
+		{[]string{"new", "new-page.md"}, []string{sourceFlag}, ""},
+		{[]string{"new", "site", filepath.Join(dirOut, "new-site")}, nil, ""},
+		{[]string{"unknowncommand"}, nil, "unknown command"},
+		// TODO(bep) cli refactor fix https://github.com/gohugoio/hugo/issues/4450
+		//{[]string{"new", "theme", filepath.Join(dirOut, "new-theme")}, nil,false},
+	}
+
+	for _, test := range tests {
+		name := "hugo"
+		if len(test.commands) > 0 {
+			name = test.commands[0]
+		}
+		c.Run(name, func(c *qt.C) {
+			b := newCommandsBuilder().addAll().build()
+			hugoCmd := b.getCommand()
+			test.flags = append(test.flags, "--quiet")
+			hugoCmd.SetArgs(append(test.commands, test.flags...))
+
+			// TODO(bep) capture output and add some simple asserts
+			// TODO(bep) misspelled subcommands does not return an error. We should investigate this
+			// but before that, check for "Error: unknown command".
+
+			_, err := hugoCmd.ExecuteC()
+			if test.expectErrToContain != "" {
+				c.Assert(err, qt.Not(qt.IsNil))
+				c.Assert(err.Error(), qt.Contains, test.expectErrToContain)
+			} else {
+				c.Assert(err, qt.IsNil)
+			}
+
+			// Assert that we have not left any development debug artifacts in
+			// the code.
+			if b.c != nil {
+				_, ok := b.c.publishDirFs.(types.DevMarker)
+				c.Assert(ok, qt.Equals, false)
+			}
+		})
+
+	}
+}
+
+type testSiteConfig struct {
+	configTOML string
+	contentDir string
+}
+
+func createSimpleTestSite(t testing.TB, cfg testSiteConfig) string {
+	dir := t.TempDir()
+
+	cfgStr := `
+
+baseURL = "https://example.org"
+title = "Hugo Commands"
+
+
+`
+
+	contentDir := "content"
+
+	if cfg.configTOML != "" {
+		cfgStr = cfg.configTOML
+	}
+	if cfg.contentDir != "" {
+		contentDir = cfg.contentDir
+	}
+
+	os.MkdirAll(filepath.Join(dir, "public"), 0777)
+
+	// Just the basic. These are for CLI tests, not site testing.
+	writeFile(t, filepath.Join(dir, "config.toml"), cfgStr)
+	writeFile(t, filepath.Join(dir, "config", "staging", "params.toml"), `myparam="paramstaging"`)
+	writeFile(t, filepath.Join(dir, "config", "staging", "deployment.toml"), `
+[[targets]]
+name = "mydeployment"
+URL = "hugocloud://hugotestbucket"
+`)
+
+	writeFile(t, filepath.Join(dir, "config", "testing", "params.toml"), `myparam="paramtesting"`)
+	writeFile(t, filepath.Join(dir, "config", "production", "params.toml"), `myparam="paramproduction"`)
+
+	writeFile(t, filepath.Join(dir, "static", "myfile.txt"), `Hello World!`)
+
+	writeFile(t, filepath.Join(dir, contentDir, "p1.md"), `
+---
+title: "P1"
+weight: 1
+---
+
+Content
+
+`)
+
+	writeFile(t, filepath.Join(dir, "layouts", "_default", "single.html"), `
+
+Single: {{ .Title }}
+
+`)
+
+	writeFile(t, filepath.Join(dir, "layouts", "_default", "list.html"), `
+
+List: {{ .Title }}
+Environment: {{ hugo.Environment }}
+
+For issue 9788:
+{{ $foo :="abc" | resources.FromString "foo.css" | minify | resources.PostProcess }}
+PostProcess: {{ $foo.RelPermalink }}
+
+`)
+
+	return dir
+}
+
+func writeFile(t testing.TB, filename, content string) {
+	must(t, os.MkdirAll(filepath.Dir(filename), os.FileMode(0755)))
+	must(t, ioutil.WriteFile(filename, []byte(content), os.FileMode(0755)))
+}
+
+func must(t testing.TB, err error) {
+	if err != nil {
+		t.Fatal(err)
+	}
+}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2015 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -9,145 +9,131 @@
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
-// limitations under the License.
+// limitations under the License.Print the version number of Hug

 package commands

 import (
-	"bytes"
-	"context"
 	"encoding/json"
 	"fmt"
 	"os"
+	"reflect"
+	"regexp"
+	"sort"
 	"strings"
 	"time"

-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/hmaps"
-	"github.com/gohugoio/hugo/config/allconfig"
-	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
-	"github.com/gohugoio/hugo/modules"
+	"github.com/gohugoio/hugo/common/maps"
+
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
+
+	"github.com/gohugoio/hugo/modules"
+
 	"github.com/spf13/cobra"
 )

-// newConfigCommand creates a new config command and its subcommands.
-func newConfigCommand() *configCommand {
-	return &configCommand{
-		commands: []simplecobra.Commander{
-			&configMountsCommand{},
-		},
+var _ cmder = (*configCmd)(nil)
+
+type configCmd struct {
+	*baseBuilderCmd
+}
+
+func (b *commandsBuilder) newConfigCmd() *configCmd {
+	cc := &configCmd{}
+	cmd := &cobra.Command{
+		Use:   "config",
+		Short: "Print the site configuration",
+		Long:  `Print the site configuration, both default and custom settings.`,
+		RunE:  cc.printConfig,
 	}
+
+	printMountsCmd := &cobra.Command{
+		Use:   "mounts",
+		Short: "Print the configured file mounts",
+		RunE:  cc.printMounts,
+	}
+
+	cmd.AddCommand(printMountsCmd)
+
+	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
+
+	return cc
 }

-type configCommand struct {
-	r *rootCommand
-
-	format    string
-	lang      string
-	printZero bool
-
-	commands []simplecobra.Commander
-}
-
-func (c *configCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *configCommand) Name() string {
-	return "config"
-}
-
-func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	conf, err := c.r.ConfigFromProvider(configKey{counter: c.r.configVersionID.Load()}, flagsToCfg(cd, nil))
+func (c *configCmd) printMounts(cmd *cobra.Command, args []string) error {
+	cfg, err := initializeConfig(true, false, false, &c.hugoBuilderCommon, c, nil)
 	if err != nil {
 		return err
 	}
-	var config *allconfig.Config
-	if c.lang != "" {
-		var found bool
-		config, found = conf.configs.LanguageConfigMap[c.lang]
-		if !found {
-			return fmt.Errorf("language %q not found", c.lang)
+
+	allModules := cfg.Cfg.Get("allmodules").(modules.Modules)
+
+	for _, m := range allModules {
+		if err := parser.InterfaceToConfig(&modMounts{m: m, verbose: c.verbose}, metadecoders.JSON, os.Stdout); err != nil {
+			return err
 		}
-	} else {
-		config = conf.configs.LanguageConfigMap[conf.configs.Base.DefaultContentLanguage]
 	}
+	return nil
+}

-	var buf bytes.Buffer
-	dec := json.NewEncoder(&buf)
-	dec.SetIndent("", "  ")
-	dec.SetEscapeHTML(false)
-
-	if err := dec.Encode(parser.ReplacingJSONMarshaller{Value: config, KeysToLower: true, OmitEmpty: !c.printZero}); err != nil {
+func (c *configCmd) printConfig(cmd *cobra.Command, args []string) error {
+	cfg, err := initializeConfig(true, false, false, &c.hugoBuilderCommon, c, nil)
+	if err != nil {
 		return err
 	}

-	format := strings.ToLower(c.format)
+	allSettings := cfg.Cfg.Get("").(maps.Params)

-	switch format {
-	case "json":
-		os.Stdout.Write(buf.Bytes())
-	default:
-		// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
-		var m map[string]any
-		if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
-			return err
+	// We need to clean up this, but we store objects in the config that
+	// isn't really interesting to the end user, so filter these.
+	ignoreKeysRe := regexp.MustCompile("client|sorted|filecacheconfigs|allmodules|multilingual")
+
+	separator := ": "
+
+	if len(cfg.configFiles) > 0 && strings.HasSuffix(cfg.configFiles[0], ".toml") {
+		separator = " = "
+	}
+
+	var keys []string
+	for k := range allSettings {
+		if ignoreKeysRe.MatchString(k) {
+			continue
 		}
-		hmaps.ConvertFloat64WithNoDecimalsToInt(m)
-		switch format {
-		case "yaml":
-			return parser.InterfaceToConfig(m, metadecoders.YAML, os.Stdout)
-		case "toml":
-			return parser.InterfaceToConfig(m, metadecoders.TOML, os.Stdout)
-		default:
-			return fmt.Errorf("unsupported format: %q", format)
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		kv := reflect.ValueOf(allSettings[k])
+		if kv.Kind() == reflect.String {
+			fmt.Printf("%s%s\"%+v\"\n", k, separator, allSettings[k])
+		} else {
+			fmt.Printf("%s%s%+v\n", k, separator, allSettings[k])
 		}
 	}

 	return nil
 }

-func (c *configCommand) Init(cd *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	cmd := cd.CobraCommand
-	cmd.Short = "Display project configuration"
-	cmd.Long = `Display project configuration, both default and custom settings.`
-	cmd.Flags().StringVar(&c.format, "format", "toml", "preferred file format (toml, yaml or json)")
-	_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
-	cmd.Flags().StringVar(&c.lang, "lang", "", "the language to display config for. Defaults to the first language defined.")
-	cmd.Flags().BoolVar(&c.printZero, "printZero", false, `include config options with zero values (e.g. false, 0, "") in the output`)
-	_ = cmd.RegisterFlagCompletionFunc("lang", cobra.NoFileCompletions)
-	applyLocalFlagsBuildConfig(cmd, c.r)
-
-	return nil
-}
-
-func (c *configCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	return nil
-}
-
-type configModMount struct {
-	Source string            `json:"source"`
-	Target string            `json:"target"`
-	Sites  sitesmatrix.Sites `json:"sites,omitzero"`
-}
-
-type configModMounts struct {
+type modMounts struct {
 	verbose bool
 	m       modules.Module
 }

-// MarshalJSON is for internal use only.
-func (m *configModMounts) MarshalJSON() ([]byte, error) {
-	var mounts []configModMount
+type modMount struct {
+	Source string `json:"source"`
+	Target string `json:"target"`
+	Lang   string `json:"lang,omitempty"`
+}
+
+func (m *modMounts) MarshalJSON() ([]byte, error) {
+	var mounts []modMount

 	for _, mount := range m.m.Mounts() {
-		mounts = append(mounts, configModMount{
+		mounts = append(mounts, modMount{
 			Source: mount.Source,
 			Target: mount.Target,
-			Sites:  mount.Sites,
+			Lang:   mount.Lang,
 		})
 	}

@@ -167,7 +153,7 @@ func (m *configModMounts) MarshalJSON() ([]byte, error) {
 			Meta        map[string]any      `json:"meta"`
 			HugoVersion modules.HugoVersion `json:"hugoVersion"`

-			Mounts []configModMount `json:"mounts"`
+			Mounts []modMount `json:"mounts"`
 		}{
 			Path:        m.m.Path(),
 			Version:     m.m.Version(),
@@ -181,12 +167,12 @@ func (m *configModMounts) MarshalJSON() ([]byte, error) {
 	}

 	return json.Marshal(&struct {
-		Path    string           `json:"path"`
-		Version string           `json:"version"`
-		Time    time.Time        `json:"time"`
-		Owner   string           `json:"owner"`
-		Dir     string           `json:"dir"`
-		Mounts  []configModMount `json:"mounts"`
+		Path    string     `json:"path"`
+		Version string     `json:"version"`
+		Time    time.Time  `json:"time"`
+		Owner   string     `json:"owner"`
+		Dir     string     `json:"dir"`
+		Mounts  []modMount `json:"mounts"`
 	}{
 		Path:    m.m.Path(),
 		Version: m.m.Version(),
@@ -195,46 +181,5 @@ func (m *configModMounts) MarshalJSON() ([]byte, error) {
 		Dir:     m.m.Dir(),
 		Mounts:  mounts,
 	})
-}

-type configMountsCommand struct {
-	r         *rootCommand
-	configCmd *configCommand
-}
-
-func (c *configMountsCommand) Commands() []simplecobra.Commander {
-	return nil
-}
-
-func (c *configMountsCommand) Name() string {
-	return "mounts"
-}
-
-func (c *configMountsCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	r := c.configCmd.r
-	conf, err := r.ConfigFromProvider(configKey{counter: c.r.configVersionID.Load()}, flagsToCfg(cd, nil))
-	if err != nil {
-		return err
-	}
-
-	for _, m := range conf.configs.Modules {
-		if err := parser.InterfaceToConfig(&configModMounts{m: m, verbose: r.isVerbose()}, metadecoders.JSON, os.Stdout); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *configMountsCommand) Init(cd *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	cmd := cd.CobraCommand
-	cmd.Short = "Print the configured file mounts"
-	cmd.ValidArgsFunction = cobra.NoFileCompletions
-	applyLocalFlagsBuildConfig(cmd, c.r)
-	return nil
-}
-
-func (c *configMountsCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.configCmd = cd.Parent.Command.(*configCommand)
-	return nil
 }
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2019 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,139 +15,134 @@ package commands

 import (
 	"bytes"
-	"context"
 	"fmt"
 	"path/filepath"
-	"slices"
 	"strings"
 	"time"

-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/hugio"
-	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/parser/pageparser"
+
+	"github.com/gohugoio/hugo/resources/page"
+
 	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/hugolib"
+
+	"github.com/gohugoio/hugo/helpers"
+
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
-	"github.com/gohugoio/hugo/parser/pageparser"
-	"github.com/gohugoio/hugo/resources/page"
+
+	"github.com/gohugoio/hugo/hugolib"
+
 	"github.com/spf13/cobra"
 )

-func newConvertCommand() *convertCommand {
-	var c *convertCommand
-	c = &convertCommand{
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "toJSON",
-				short: "Convert front matter to JSON",
-				long: `toJSON converts all front matter in the content directory
-to use JSON for the front matter.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					return c.convertContents(metadecoders.JSON)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "toTOML",
-				short: "Convert front matter to TOML",
-				long: `toTOML converts all front matter in the content directory
-to use TOML for the front matter.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					return c.convertContents(metadecoders.TOML)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "toYAML",
-				short: "Convert front matter to YAML",
-				long: `toYAML converts all front matter in the content directory
-to use YAML for the front matter.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					return c.convertContents(metadecoders.YAML)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-		},
-	}
-	return c
-}
+var _ cmder = (*convertCmd)(nil)

-type convertCommand struct {
-	// Flags.
+type convertCmd struct {
 	outputDir string
 	unsafe    bool

-	// Deps.
-	r *rootCommand
-	h *hugolib.HugoSites
-
-	// Commands.
-	commands []simplecobra.Commander
+	*baseBuilderCmd
 }

-func (c *convertCommand) Commands() []simplecobra.Commander {
-	return c.commands
+func (b *commandsBuilder) newConvertCmd() *convertCmd {
+	cc := &convertCmd{}
+
+	cmd := &cobra.Command{
+		Use:   "convert",
+		Short: "Convert your content to different formats",
+		Long: `Convert your content (e.g. front matter) to different formats.
+
+See convert's subcommands toJSON, toTOML and toYAML for more information.`,
+		RunE: nil,
+	}
+
+	cmd.AddCommand(
+		&cobra.Command{
+			Use:   "toJSON",
+			Short: "Convert front matter to JSON",
+			Long: `toJSON converts all front matter in the content directory
+to use JSON for the front matter.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return cc.convertContents(metadecoders.JSON)
+			},
+		},
+		&cobra.Command{
+			Use:   "toTOML",
+			Short: "Convert front matter to TOML",
+			Long: `toTOML converts all front matter in the content directory
+to use TOML for the front matter.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return cc.convertContents(metadecoders.TOML)
+			},
+		},
+		&cobra.Command{
+			Use:   "toYAML",
+			Short: "Convert front matter to YAML",
+			Long: `toYAML converts all front matter in the content directory
+to use YAML for the front matter.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return cc.convertContents(metadecoders.YAML)
+			},
+		},
+	)
+
+	cmd.PersistentFlags().StringVarP(&cc.outputDir, "output", "o", "", "filesystem path to write files to")
+	cmd.PersistentFlags().BoolVar(&cc.unsafe, "unsafe", false, "enable less safe operations, please backup first")
+
+	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
+
+	return cc
 }

-func (c *convertCommand) Name() string {
-	return "convert"
-}
+func (cc *convertCmd) convertContents(format metadecoders.Format) error {
+	if cc.outputDir == "" && !cc.unsafe {
+		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
+	}

-func (c *convertCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	return nil
-}
-
-func (c *convertCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Convert front matter to another format"
-	cmd.Long = `Convert front matter to another format.
-
-See convert's subcommands toJSON, toTOML and toYAML for more information.`
-
-	cmd.PersistentFlags().StringVarP(&c.outputDir, "output", "o", "", "filesystem path to write files to")
-	_ = cmd.MarkFlagDirname("output")
-	cmd.PersistentFlags().BoolVar(&c.unsafe, "unsafe", false, "enable less safe operations, please backup first")
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *convertCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	cfg := config.New()
-	cfg.Set("buildDrafts", true)
-	h, err := c.r.Hugo(flagsToCfg(cd, cfg))
+	c, err := initializeConfig(true, false, false, &cc.hugoBuilderCommon, cc, nil)
 	if err != nil {
 		return err
 	}
-	c.h = h
+
+	c.Cfg.Set("buildDrafts", true)
+
+	h, err := hugolib.NewHugoSites(*c.DepsCfg)
+	if err != nil {
+		return err
+	}
+
+	if err := h.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+		return err
+	}
+
+	site := h.Sites[0]
+
+	site.Log.Println("processing", len(site.AllPages()), "content files")
+	for _, p := range site.AllPages() {
+		if err := cc.convertAndSavePage(p, site, format); err != nil {
+			return err
+		}
+	}
 	return nil
 }

-func (c *convertCommand) convertAndSavePage(p page.Page, site *hugolib.Site, targetFormat metadecoders.Format) error {
+func (cc *convertCmd) convertAndSavePage(p page.Page, site *hugolib.Site, targetFormat metadecoders.Format) error {
 	// The resources are not in .Site.AllPages.
 	for _, r := range p.Resources().ByType("page") {
-		if err := c.convertAndSavePage(r.(page.Page), site, targetFormat); err != nil {
+		if err := cc.convertAndSavePage(r.(page.Page), site, targetFormat); err != nil {
 			return err
 		}
 	}

-	if p.File() == nil {
+	if p.File().IsZero() {
 		// No content file.
 		return nil
 	}

-	errMsg := fmt.Errorf("error processing file %q", p.File().Path())
+	errMsg := fmt.Errorf("Error processing file %q", p.File().Path())

-	site.Log.Infoln("attempting to convert", p.File().Filename())
+	site.Log.Infoln("Attempting to convert", p.File().Filename())

 	f := p.File()
 	file, err := f.FileInfo().Meta().Open()
@@ -187,129 +182,26 @@ func (c *convertCommand) convertAndSavePage(p page.Page, site *hugolib.Site, tar

 	newFilename := p.File().Filename()

-	if c.outputDir != "" {
+	if cc.outputDir != "" {
 		contentDir := strings.TrimSuffix(newFilename, p.File().Path())
 		contentDir = filepath.Base(contentDir)

-		newFilename = filepath.Join(c.outputDir, contentDir, p.File().Path())
+		newFilename = filepath.Join(cc.outputDir, contentDir, p.File().Path())
 	}

 	fs := hugofs.Os
 	if err := helpers.WriteToDisk(newFilename, &newContent, fs); err != nil {
-		return fmt.Errorf("failed to save file %q:: %w", newFilename, err)
+		return fmt.Errorf("Failed to save file %q:: %w", newFilename, err)
 	}

 	return nil
 }

-func (c *convertCommand) copyContentDirsForOutput(pagesBackedByFile page.Pages) error {
-	contentDirs := make(map[string]bool)
-	for _, p := range pagesBackedByFile {
-		filename := p.File().Filename()
-		contentDir := strings.TrimSuffix(filename, p.File().Path())
-		if contentDir == filename {
-			continue
-		}
-		contentDirs[filepath.Clean(contentDir)] = true
-	}
+type parsedFile struct {
+	frontMatterFormat metadecoders.Format
+	frontMatterSource []byte
+	frontMatter       map[string]any

-	var contentDirList []string
-	for contentDir := range contentDirs {
-		contentDirList = append(contentDirList, contentDir)
-	}
-	slices.Sort(contentDirList)
-
-	outputDirAbs, err := filepath.Abs(c.outputDir)
-	if err != nil {
-		return fmt.Errorf("failed to resolve output path %q: %w", c.outputDir, err)
-	}
-
-	for _, contentDir := range contentDirList {
-		outputContentDirAbs := filepath.Join(outputDirAbs, filepath.Base(contentDir))
-
-		skipDirs := make(map[string]bool)
-		relToOutputDir, err := filepath.Rel(contentDir, outputDirAbs)
-		if err == nil && relToOutputDir != ".." && !strings.HasPrefix(relToOutputDir, ".."+string(filepath.Separator)) {
-			skipDirs[filepath.Clean(outputDirAbs)] = true
-		}
-		relToOutputContentDir, err := filepath.Rel(contentDir, outputContentDirAbs)
-		if err == nil && relToOutputContentDir != ".." && !strings.HasPrefix(relToOutputContentDir, ".."+string(filepath.Separator)) {
-			skipDirs[filepath.Clean(outputContentDirAbs)] = true
-		}
-
-		var shouldCopy func(filename string) bool
-		if len(skipDirs) > 0 {
-			shouldCopy = func(filename string) bool {
-				return !skipDirs[filepath.Clean(filename)]
-			}
-		}
-
-		if err := hugio.CopyDir(hugofs.Os, contentDir, outputContentDirAbs, shouldCopy); err != nil {
-			return fmt.Errorf("failed to copy %q to %q: %w", contentDir, outputContentDirAbs, err)
-		}
-	}
-
-	return nil
-}
-
-func (c *convertCommand) convertContents(format metadecoders.Format) error {
-	if c.outputDir == "" && !c.unsafe {
-		return newUserError("Unsafe operation not allowed, use --unsafe or set a different output path")
-	}
-
-	if err := c.h.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
-		return err
-	}
-
-	site := c.h.Sites[0]
-
-	workingDir := c.h.Sites[0].Deps.Conf.WorkingDir() + string(filepath.Separator)
-
-	isConvertible := func(p page.Page) bool {
-		// Skip pages not backed by a content file.
-		if p.File() == nil {
-			return false
-		}
-		// Skip content adapters.
-		if p.File().IsContentAdapter() {
-			return false
-		}
-		// Skip content files provided by modules, including vendored modules.
-		if !p.File().FileInfo().Meta().IsProject {
-			return false
-		}
-		// Skip content files in project mounts outside the working directory.
-		if !strings.HasPrefix(p.File().Filename(), workingDir) {
-			return false
-		}
-		return true
-	}
-
-	seen := make(map[string]bool)
-	var pagesBackedByFile page.Pages
-	for _, p := range c.h.Pages() {
-		if !isConvertible(p) {
-			continue
-		}
-		filename := p.File().Filename()
-		if seen[filename] {
-			continue
-		}
-		seen[filename] = true
-		pagesBackedByFile = append(pagesBackedByFile, p)
-	}
-
-	if c.outputDir != "" {
-		if err := c.copyContentDirsForOutput(pagesBackedByFile); err != nil {
-			return err
-		}
-	}
-
-	site.Log.Println("processing", len(pagesBackedByFile), "content files")
-	for _, p := range pagesBackedByFile {
-		if err := c.convertAndSavePage(p, site, format); err != nil {
-			return err
-		}
-	}
-	return nil
+	// Everything after Front Matter
+	content []byte
 }
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2019 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-//go:build withdeploy
+//go:build !nodeploy
+// +build !nodeploy

 package commands

@@ -19,33 +20,67 @@ import (
 	"context"

 	"github.com/gohugoio/hugo/deploy"
-
-	"github.com/bep/simplecobra"
 	"github.com/spf13/cobra"
 )

-func newDeployCommand() simplecobra.Commander {
-	return &simpleCommand{
-		name:  "deploy",
-		short: "Deploy your project to a cloud provider",
-		long: `Deploy your project to a cloud provider
+var _ cmder = (*deployCmd)(nil)
+
+// deployCmd supports deploying sites to Cloud providers.
+type deployCmd struct {
+	*baseBuilderCmd
+
+	invalidateCDN bool
+	maxDeletes    int
+}
+
+// TODO: In addition to the "deploy" command, consider adding a "--deploy"
+// flag for the default command; this would build the site and then deploy it.
+// It's not obvious how to do this; would all of the deploy-specific flags
+// have to exist at the top level as well?
+
+// TODO:  The output files change every time "hugo" is executed, it looks
+// like because of map order randomization. This means that you can
+// run "hugo && hugo deploy" again and again and upload new stuff every time. Is
+// this intended?
+
+func (b *commandsBuilder) newDeployCmd() *deployCmd {
+	cc := &deployCmd{}
+
+	cmd := &cobra.Command{
+		Use:   "deploy",
+		Short: "Deploy your site to a Cloud provider.",
+		Long: `Deploy your site to a Cloud provider.

 See https://gohugo.io/hosting-and-deployment/hugo-deploy/ for detailed
 documentation.
 `,
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			h, err := r.Hugo(flagsToCfgWithAdditionalConfigBase(cd, nil, "deployment"))
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfgInit := func(c *commandeer) error {
+				c.Set("invalidateCDN", cc.invalidateCDN)
+				c.Set("maxDeletes", cc.maxDeletes)
+				return nil
+			}
+			comm, err := initializeConfig(true, true, false, &cc.hugoBuilderCommon, cc, cfgInit)
 			if err != nil {
 				return err
 			}
-			deployer, err := deploy.New(h.Configs.GetFirstLanguageConfig(), h.Log, h.PathSpec.PublishFs)
+			deployer, err := deploy.New(comm.Cfg, comm.hugo().PathSpec.PublishFs)
 			if err != nil {
 				return err
 			}
-			return deployer.Deploy(ctx)
-		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			applyDeployFlags(cmd, r)
+			return deployer.Deploy(context.Background())
 		},
 	}
+
+	cmd.Flags().String("target", "", "target deployment from deployments section in config file; defaults to the first one")
+	cmd.Flags().Bool("confirm", false, "ask for confirmation before making changes to the target")
+	cmd.Flags().Bool("dryRun", false, "dry run")
+	cmd.Flags().Bool("force", false, "force upload of all files")
+	cmd.Flags().BoolVar(&cc.invalidateCDN, "invalidateCDN", true, "invalidate the CDN cache listed in the deployment target")
+	cmd.Flags().IntVar(&cc.maxDeletes, "maxDeletes", 256, "maximum # of files to delete, or -1 to disable")
+
+	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
+
+	return cc
 }
@@ -1,33 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package commands
-
-import (
-	"github.com/gohugoio/hugo/deploy/deployconfig"
-	"github.com/spf13/cobra"
-)
-
-func applyDeployFlags(cmd *cobra.Command, r *rootCommand) {
-	cmd.ValidArgsFunction = cobra.NoFileCompletions
-	cmd.Flags().String("target", "", "target deployment from deployments section in config file; defaults to the first one")
-	_ = cmd.RegisterFlagCompletionFunc("target", cobra.NoFileCompletions)
-	cmd.Flags().Bool("confirm", false, "ask for confirmation before making changes to the target")
-	cmd.Flags().Bool("dryRun", false, "dry run")
-	cmd.Flags().Bool("force", false, "force upload of all files")
-	cmd.Flags().Bool("invalidateCDN", deployconfig.DefaultConfig.InvalidateCDN, "invalidate the CDN cache listed in the deployment target")
-	cmd.Flags().Int("maxDeletes", deployconfig.DefaultConfig.MaxDeletes, "maximum # of files to delete, or -1 to disable")
-	_ = cmd.RegisterFlagCompletionFunc("maxDeletes", cobra.NoFileCompletions)
-	cmd.Flags().Int("workers", deployconfig.DefaultConfig.Workers, "number of workers to transfer files. defaults to 10")
-	_ = cmd.RegisterFlagCompletionFunc("workers", cobra.NoFileCompletions)
-}
@@ -1,50 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build !withdeploy
-
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package commands
-
-import (
-	"context"
-	"errors"
-
-	"github.com/bep/simplecobra"
-	"github.com/spf13/cobra"
-)
-
-func newDeployCommand() simplecobra.Commander {
-	return &simpleCommand{
-		name: "deploy",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			return errors.New("deploy not supported in this version of Hugo; install a release with 'withdeploy' in the archive filename or build yourself with the 'withdeploy' build tag. Also see https://github.com/gohugoio/hugo/pull/12995")
-		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			applyDeployFlags(cmd, r)
-			cmd.Hidden = true
-		},
-	}
-}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2016 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,57 +14,47 @@
 package commands

 import (
-	"context"
 	"runtime"

-	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/common/hugo"
+
 	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
 )

-func newEnvCommand() simplecobra.Commander {
-	return &simpleCommand{
-		name:  "env",
-		short: "Display version and environment info",
-		long:  "Display version and environment info. This is useful in Hugo bug reports",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			r.Printf("%s\n", hugo.BuildVersionString())
-			r.Printf("GOOS=%q\n", runtime.GOOS)
-			r.Printf("GOARCH=%q\n", runtime.GOARCH)
-			r.Printf("GOVERSION=%q\n", runtime.Version())
+var _ cmder = (*envCmd)(nil)

-			if r.isVerbose() {
-				deps := hugo.GetDependencyList()
-				for _, dep := range deps {
-					r.Printf("%s\n", dep)
-				}
-			} else {
-				// These are also included in the GetDependencyList above;
-				// always print these as these are most likely the most useful to know about.
-				deps := hugo.GetDependencyListNonGo()
-				for _, dep := range deps {
-					r.Printf("%s\n", dep)
-				}
-			}
-			return nil
-		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			cmd.ValidArgsFunction = cobra.NoFileCompletions
-		},
-	}
+type envCmd struct {
+	*baseCmd
 }

-func newVersionCmd() simplecobra.Commander {
-	return &simpleCommand{
-		name: "version",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			r.Println(hugo.BuildVersionString())
-			return nil
-		},
-		short: "Display version",
-		long:  "Display version and environment info. This is useful in Hugo bug reports.",
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			cmd.ValidArgsFunction = cobra.NoFileCompletions
-		},
+func newEnvCmd() *envCmd {
+	return &envCmd{
+		baseCmd: newBaseCmd(&cobra.Command{
+			Use:   "env",
+			Short: "Print Hugo version and environment info",
+			Long: `Print Hugo version and environment info. This is useful in Hugo bug reports.
+
+If you add the -v flag, you will get a full dependency list.
+`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				printHugoVersion()
+				jww.FEEDBACK.Printf("GOOS=%q\n", runtime.GOOS)
+				jww.FEEDBACK.Printf("GOARCH=%q\n", runtime.GOARCH)
+				jww.FEEDBACK.Printf("GOVERSION=%q\n", runtime.Version())
+
+				isVerbose, _ := cmd.Flags().GetBool("verbose")
+
+				if isVerbose {
+					deps := hugo.GetDependencyList()
+					for _, dep := range deps {
+						jww.FEEDBACK.Printf("%s\n", dep)
+					}
+				}
+
+				return nil
+			},
+		}),
 	}
+
 }
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2015 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,323 +14,27 @@
 package commands

 import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"slices"
-	"strings"
-
-	"github.com/alecthomas/chroma/v2"
-	"github.com/alecthomas/chroma/v2/formatters/html"
-	"github.com/alecthomas/chroma/v2/styles"
-	"github.com/bep/simplecobra"
-	"github.com/goccy/go-yaml"
-	"github.com/gohugoio/hugo/common/hugo"
-	"github.com/gohugoio/hugo/docshelper"
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/hugolib"
-	"github.com/gohugoio/hugo/parser"
 	"github.com/spf13/cobra"
-	"github.com/spf13/cobra/doc"
 )

-func newGenCommand() *genCommand {
-	var (
-		// Flags.
-		gendocdir string
-		genmandir string
+var _ cmder = (*genCmd)(nil)

-		// Chroma flags.
-		style                  string
-		highlightStyle         string
-		lineNumbersInlineStyle string
-		lineNumbersTableStyle  string
-		omitEmpty              bool
-		omitClassComments      bool
-	)
-
-	newChromaStyles := func() simplecobra.Commander {
-		return &simpleCommand{
-			name:  "chromastyles",
-			short: "Generate CSS stylesheet for the Chroma code highlighter",
-			long: `Generate CSS stylesheet for the Chroma code highlighter for a given style. This stylesheet is needed if markup.highlight.noClasses is disabled in config.
-
-See https://gohugo.io/quick-reference/syntax-highlighting-styles/ for a preview of the available styles.`,
-
-			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-				style = strings.ToLower(style)
-				if !slices.Contains(styles.Names(), style) {
-					return fmt.Errorf("invalid style: %s", style)
-				}
-				builder := styles.Get(style).Builder()
-				if highlightStyle != "" {
-					builder.Add(chroma.LineHighlight, highlightStyle)
-				}
-				if lineNumbersInlineStyle != "" {
-					builder.Add(chroma.LineNumbers, lineNumbersInlineStyle)
-				}
-				if lineNumbersTableStyle != "" {
-					builder.Add(chroma.LineNumbersTable, lineNumbersTableStyle)
-				}
-				style, err := builder.Build()
-				if err != nil {
-					return err
-				}
-
-				if omitEmpty {
-					// See https://github.com/alecthomas/chroma/commit/5b2a4c5a26c503c79bc86ba3c4ae5b330028bd3d
-					hugo.Deprecate("--omitEmpty", "Flag is no longer needed, empty classes are now always omitted.", "v0.149.0")
-				}
-				options := []html.Option{
-					html.WithCSSComments(!omitClassComments),
-					html.WithCustomCSS(chromaCSSOverrides(style)),
-				}
-				formatter := html.New(options...)
-
-				w := os.Stdout
-				fmt.Fprintf(w, "/* Generated using: hugo %s */\n\n", strings.Join(os.Args[1:], " "))
-				formatter.WriteCSS(w, style)
-				return nil
-			},
-			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVar(&style, "style", "friendly", "highlighter style")
-				_ = cmd.RegisterFlagCompletionFunc("style", cobra.NoFileCompletions)
-				cmd.PersistentFlags().StringVar(&highlightStyle, "highlightStyle", "", `foreground and background colors for highlighted lines, e.g. --highlightStyle "#fff000 bg:#000fff"`)
-				_ = cmd.RegisterFlagCompletionFunc("highlightStyle", cobra.NoFileCompletions)
-				cmd.PersistentFlags().StringVar(&lineNumbersInlineStyle, "lineNumbersInlineStyle", "", `foreground and background colors for inline line numbers, e.g. --lineNumbersInlineStyle "#fff000 bg:#000fff"`)
-				_ = cmd.RegisterFlagCompletionFunc("lineNumbersInlineStyle", cobra.NoFileCompletions)
-				cmd.PersistentFlags().StringVar(&lineNumbersTableStyle, "lineNumbersTableStyle", "", `foreground and background colors for table line numbers, e.g. --lineNumbersTableStyle "#fff000 bg:#000fff"`)
-				_ = cmd.RegisterFlagCompletionFunc("lineNumbersTableStyle", cobra.NoFileCompletions)
-				cmd.PersistentFlags().BoolVar(&omitEmpty, "omitEmpty", false, `omit empty CSS rules (deprecated, no longer needed)`)
-				_ = cmd.RegisterFlagCompletionFunc("omitEmpty", cobra.NoFileCompletions)
-				cmd.PersistentFlags().BoolVar(&omitClassComments, "omitClassComments", false, `omit CSS class comment prefixes in the generated CSS`)
-				_ = cmd.RegisterFlagCompletionFunc("omitClassComments", cobra.NoFileCompletions)
-			},
-		}
-	}
-
-	newMan := func() simplecobra.Commander {
-		return &simpleCommand{
-			name:  "man",
-			short: "Generate man pages for the Hugo CLI",
-			long: `This command automatically generates up-to-date man pages of Hugo's
-	command-line interface.  By default, it creates the man page files
-	in the "man" directory under the current directory.`,
-
-			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-				header := &doc.GenManHeader{
-					Section: "1",
-					Manual:  "Hugo Manual",
-					Source:  fmt.Sprintf("Hugo %s", hugo.CurrentVersion),
-				}
-				if !strings.HasSuffix(genmandir, helpers.FilePathSeparator) {
-					genmandir += helpers.FilePathSeparator
-				}
-				if found, _ := helpers.Exists(genmandir, hugofs.Os); !found {
-					r.Println("Directory", genmandir, "does not exist, creating...")
-					if err := hugofs.Os.MkdirAll(genmandir, 0o777); err != nil {
-						return err
-					}
-				}
-				cd.CobraCommand.Root().DisableAutoGenTag = true
-
-				r.Println("Generating Hugo man pages in", genmandir, "...")
-				doc.GenManTree(cd.CobraCommand.Root(), header, genmandir)
-
-				r.Println("Done.")
-
-				return nil
-			},
-			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVar(&genmandir, "dir", "man/", "the directory to write the man pages.")
-				_ = cmd.MarkFlagDirname("dir")
-			},
-		}
-	}
-
-	newGen := func() simplecobra.Commander {
-		const gendocFrontmatterTemplate = `---
-title: "%s"
-slug: %s
-url: %s
---
-`
-
-		return &simpleCommand{
-			name:  "doc",
-			short: "Generate Markdown documentation for the Hugo CLI",
-			long: `Generate Markdown documentation for the Hugo CLI.
-			This command is, mostly, used to create up-to-date documentation
-	of Hugo's command-line interface for https://gohugo.io/.
-
-	It creates one Markdown file per command with front matter suitable
-	for rendering in Hugo.`,
-			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-				cd.CobraCommand.VisitParents(func(c *cobra.Command) {
-					// Disable the "Auto generated by spf13/cobra on DATE"
-					// as it creates a lot of diffs.
-					c.DisableAutoGenTag = true
-				})
-				if !strings.HasSuffix(gendocdir, helpers.FilePathSeparator) {
-					gendocdir += helpers.FilePathSeparator
-				}
-				if found, _ := helpers.Exists(gendocdir, hugofs.Os); !found {
-					r.Println("Directory", gendocdir, "does not exist, creating...")
-					if err := hugofs.Os.MkdirAll(gendocdir, 0o777); err != nil {
-						return err
-					}
-				}
-				prepender := func(filename string) string {
-					name := filepath.Base(filename)
-					base := strings.TrimSuffix(name, path.Ext(name))
-					url := "/docs/reference/commands/" + strings.ToLower(base) + "/"
-					return fmt.Sprintf(gendocFrontmatterTemplate, strings.Replace(base, "_", " ", -1), base, url)
-				}
-
-				linkHandler := func(name string) string {
-					base := strings.TrimSuffix(name, path.Ext(name))
-					return "/docs/reference/commands/" + strings.ToLower(base) + "/"
-				}
-				r.Println("Generating Hugo command-line documentation in", gendocdir, "...")
-				doc.GenMarkdownTreeCustom(cd.CobraCommand.Root(), gendocdir, prepender, linkHandler)
-				r.Println("Done.")
-
-				return nil
-			},
-			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVar(&gendocdir, "dir", "/tmp/hugodoc/", "the directory to write the doc.")
-				_ = cmd.MarkFlagDirname("dir")
-			},
-		}
-	}
-
-	var docsHelperTarget string
-
-	newDocsHelper := func() simplecobra.Commander {
-		return &simpleCommand{
-			name:  "docshelper",
-			short: "Generate some data files for the Hugo docs",
-
-			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-				r.Println("Generate docs data to", docsHelperTarget)
-
-				var buf bytes.Buffer
-				jsonEnc := json.NewEncoder(&buf)
-
-				configProvider := func() docshelper.DocProvider {
-					conf := hugolib.DefaultConfig()
-					conf.CacheDir = "" // The default value does not make sense in the docs.
-					defaultConfig := parser.NullBoolJSONMarshaller{Wrapped: parser.LowerCaseCamelJSONMarshaller{Value: conf}}
-					return docshelper.DocProvider{"config": defaultConfig}
-				}
-
-				docshelper.AddDocProviderFunc(configProvider)
-				if err := jsonEnc.Encode(docshelper.GetDocProvider()); err != nil {
-					return err
-				}
-
-				// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
-				var m map[string]any
-				if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
-					return err
-				}
-
-				targetFile := filepath.Join(docsHelperTarget, "docs.yaml")
-
-				f, err := os.Create(targetFile)
-				if err != nil {
-					return err
-				}
-				defer f.Close()
-				yamlEnc := yaml.NewEncoder(f, yaml.UseSingleQuote(true), yaml.AutoInt())
-				if err := yamlEnc.Encode(m); err != nil {
-					return err
-				}
-
-				r.Println("Done!")
-				return nil
-			},
-			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.Hidden = true
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVarP(&docsHelperTarget, "dir", "", "docs/data", "data dir")
-			},
-		}
-	}
-
-	return &genCommand{
-		commands: []simplecobra.Commander{
-			newChromaStyles(),
-			newGen(),
-			newMan(),
-			newDocsHelper(),
-		},
-	}
+type genCmd struct {
+	*baseCmd
 }

-func chromaCSSOverrides(style *chroma.Style) map[chroma.TokenType]string {
-	bg := style.Get(chroma.Background)
-	m := make(map[chroma.TokenType]string)
-	for tt := range chroma.StandardTypes {
-		if tt == chroma.Background || !style.Has(tt) || !chromaLeafToken(tt) {
-			continue
-		}
-		entry := style.Get(tt)
-		if !entry.Sub(bg).IsZero() || !entry.Colour.IsSet() {
-			continue
-		}
-		if css := html.StyleEntryToCSS(chroma.StyleEntry{Colour: entry.Colour}); css != "" {
-			m[tt] = css
-		}
-	}
-	return m
-}
-
-func chromaLeafToken(tt chroma.TokenType) bool {
-	for other := range chroma.StandardTypes {
-		if other != tt && (other.Category() == tt || other.SubCategory() == tt) {
-			return false
-		}
-	}
-	return true
-}
-
-type genCommand struct {
-	rootCmd *rootCommand
-
-	commands []simplecobra.Commander
-}
-
-func (c *genCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *genCommand) Name() string {
-	return "gen"
-}
-
-func (c *genCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	return nil
-}
-
-func (c *genCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Generate documentation and syntax highlighting styles"
-	cmd.Long = "Generate documentation for your project using Hugo's documentation engine, including syntax highlighting for various programming languages."
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *genCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.rootCmd = cd.Root.Command.(*rootCommand)
-	return nil
+func newGenCmd() *genCmd {
+	cc := &genCmd{}
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "gen",
+		Short: "A collection of several useful generators.",
+	})
+
+	cc.cmd.AddCommand(
+		newGenDocCmd().getCommand(),
+		newGenManCmd().getCommand(),
+		createGenDocsHelper().getCommand(),
+		createGenChromaStyles().getCommand())
+
+	return cc
 }
@@ -0,0 +1,72 @@
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"os"
+
+	"github.com/alecthomas/chroma/v2"
+	"github.com/alecthomas/chroma/v2/formatters/html"
+	"github.com/alecthomas/chroma/v2/styles"
+	"github.com/spf13/cobra"
+)
+
+var _ cmder = (*genChromaStyles)(nil)
+
+type genChromaStyles struct {
+	style          string
+	highlightStyle string
+	linesStyle     string
+	*baseCmd
+}
+
+// TODO(bep) highlight
+func createGenChromaStyles() *genChromaStyles {
+	g := &genChromaStyles{
+		baseCmd: newBaseCmd(&cobra.Command{
+			Use:   "chromastyles",
+			Short: "Generate CSS stylesheet for the Chroma code highlighter",
+			Long: `Generate CSS stylesheet for the Chroma code highlighter for a given style. This stylesheet is needed if markup.highlight.noClasses is disabled in config.
+
+See https://xyproto.github.io/splash/docs/all.html for a preview of the available styles`,
+		}),
+	}
+
+	g.cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return g.generate()
+	}
+
+	g.cmd.PersistentFlags().StringVar(&g.style, "style", "friendly", "highlighter style (see https://xyproto.github.io/splash/docs/)")
+	g.cmd.PersistentFlags().StringVar(&g.highlightStyle, "highlightStyle", "bg:#ffffcc", "style used for highlighting lines (see https://github.com/alecthomas/chroma)")
+	g.cmd.PersistentFlags().StringVar(&g.linesStyle, "linesStyle", "", "style used for line numbers (see https://github.com/alecthomas/chroma)")
+
+	return g
+}
+
+func (g *genChromaStyles) generate() error {
+	builder := styles.Get(g.style).Builder()
+	if g.highlightStyle != "" {
+		builder.Add(chroma.LineHighlight, g.highlightStyle)
+	}
+	if g.linesStyle != "" {
+		builder.Add(chroma.LineNumbers, g.linesStyle)
+	}
+	style, err := builder.Build()
+	if err != nil {
+		return err
+	}
+	formatter := html.New(html.WithAllClasses(true))
+	formatter.WriteCSS(os.Stdout, style)
+	return nil
+}
@@ -0,0 +1,98 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"fmt"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*genDocCmd)(nil)
+
+type genDocCmd struct {
+	gendocdir string
+	*baseCmd
+}
+
+func newGenDocCmd() *genDocCmd {
+	const gendocFrontmatterTemplate = `---
+title: "%s"
+slug: %s
+url: %s
+---
+`
+
+	cc := &genDocCmd{}
+
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "doc",
+		Short: "Generate Markdown documentation for the Hugo CLI.",
+		Long: `Generate Markdown documentation for the Hugo CLI.
+
+This command is, mostly, used to create up-to-date documentation
+of Hugo's command-line interface for https://gohugo.io/.
+
+It creates one Markdown file per command with front matter suitable
+for rendering in Hugo.`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cmd.VisitParents(func(c *cobra.Command) {
+				// Disable the "Auto generated by spf13/cobra on DATE"
+				// as it creates a lot of diffs.
+				c.DisableAutoGenTag = true
+			})
+
+			if !strings.HasSuffix(cc.gendocdir, helpers.FilePathSeparator) {
+				cc.gendocdir += helpers.FilePathSeparator
+			}
+			if found, _ := helpers.Exists(cc.gendocdir, hugofs.Os); !found {
+				jww.FEEDBACK.Println("Directory", cc.gendocdir, "does not exist, creating...")
+				if err := hugofs.Os.MkdirAll(cc.gendocdir, 0777); err != nil {
+					return err
+				}
+			}
+			prepender := func(filename string) string {
+				name := filepath.Base(filename)
+				base := strings.TrimSuffix(name, path.Ext(name))
+				url := "/commands/" + strings.ToLower(base) + "/"
+				return fmt.Sprintf(gendocFrontmatterTemplate, strings.Replace(base, "_", " ", -1), base, url)
+			}
+
+			linkHandler := func(name string) string {
+				base := strings.TrimSuffix(name, path.Ext(name))
+				return "/commands/" + strings.ToLower(base) + "/"
+			}
+			jww.FEEDBACK.Println("Generating Hugo command-line documentation in", cc.gendocdir, "...")
+			doc.GenMarkdownTreeCustom(cmd.Root(), cc.gendocdir, prepender, linkHandler)
+			jww.FEEDBACK.Println("Done.")
+
+			return nil
+		},
+	})
+
+	cc.cmd.PersistentFlags().StringVar(&cc.gendocdir, "dir", "/tmp/hugodoc/", "the directory to write the doc.")
+
+	// For bash-completion
+	cc.cmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
+
+	return cc
+}
@@ -0,0 +1,71 @@
+// Copyright 2017-present The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/docshelper"
+	"github.com/spf13/cobra"
+)
+
+var _ cmder = (*genDocsHelper)(nil)
+
+type genDocsHelper struct {
+	target string
+	*baseCmd
+}
+
+func createGenDocsHelper() *genDocsHelper {
+	g := &genDocsHelper{
+		baseCmd: newBaseCmd(&cobra.Command{
+			Use:    "docshelper",
+			Short:  "Generate some data files for the Hugo docs.",
+			Hidden: true,
+		}),
+	}
+
+	g.cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return g.generate()
+	}
+
+	g.cmd.PersistentFlags().StringVarP(&g.target, "dir", "", "docs/data", "data dir")
+
+	return g
+}
+
+func (g *genDocsHelper) generate() error {
+	fmt.Println("Generate docs data to", g.target)
+
+	targetFile := filepath.Join(g.target, "docs.json")
+
+	f, err := os.Create(targetFile)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	enc := json.NewEncoder(f)
+	enc.SetIndent("", "  ")
+
+	if err := enc.Encode(docshelper.GetDocProvider()); err != nil {
+		return err
+	}
+
+	fmt.Println("Done!")
+	return nil
+}
@@ -0,0 +1,77 @@
+// Copyright 2016 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*genManCmd)(nil)
+
+type genManCmd struct {
+	genmandir string
+	*baseCmd
+}
+
+func newGenManCmd() *genManCmd {
+	cc := &genManCmd{}
+
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "man",
+		Short: "Generate man pages for the Hugo CLI",
+		Long: `This command automatically generates up-to-date man pages of Hugo's
+command-line interface.  By default, it creates the man page files
+in the "man" directory under the current directory.`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			header := &doc.GenManHeader{
+				Section: "1",
+				Manual:  "Hugo Manual",
+				Source:  fmt.Sprintf("Hugo %s", hugo.CurrentVersion),
+			}
+			if !strings.HasSuffix(cc.genmandir, helpers.FilePathSeparator) {
+				cc.genmandir += helpers.FilePathSeparator
+			}
+			if found, _ := helpers.Exists(cc.genmandir, hugofs.Os); !found {
+				jww.FEEDBACK.Println("Directory", cc.genmandir, "does not exist, creating...")
+				if err := hugofs.Os.MkdirAll(cc.genmandir, 0777); err != nil {
+					return err
+				}
+			}
+			cmd.Root().DisableAutoGenTag = true
+
+			jww.FEEDBACK.Println("Generating Hugo man pages in", cc.genmandir, "...")
+			doc.GenManTree(cmd.Root(), header, cc.genmandir)
+
+			jww.FEEDBACK.Println("Done.")
+
+			return nil
+		},
+	})
+
+	cc.cmd.PersistentFlags().StringVar(&cc.genmandir, "dir", "man/", "the directory to write the man pages.")
+
+	// For bash-completion
+	cc.cmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
+
+	return cc
+}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,19 +11,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

+// Package commands defines and implements command-line commands and flags
+// used by Hugo. Commands and flags are implemented using Cobra.
 package commands

 import (
-	"errors"
 	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
+	"regexp"

-	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/config"
-	"github.com/spf13/pflag"
+	"github.com/spf13/cobra"
 )

 const (
@@ -33,89 +30,50 @@ const (
 	showCursor = ansiEsc + "[?25h"
 )

-func newUserError(a ...any) *simplecobra.CommandError {
-	return &simplecobra.CommandError{Err: errors.New(fmt.Sprint(a...))}
+type flagsToConfigHandler interface {
+	flagsToConfig(cfg config.Provider)
 }

-func setValueFromFlag(flags *pflag.FlagSet, key string, cfg config.Provider, targetKey string, force bool) {
-	key = strings.TrimSpace(key)
-	if (force && flags.Lookup(key) != nil) || flags.Changed(key) {
-		f := flags.Lookup(key)
-		configKey := key
-		if targetKey != "" {
-			configKey = targetKey
-		}
-		// Gotta love this API.
-		switch f.Value.Type() {
-		case "bool":
-			bv, _ := flags.GetBool(key)
-			cfg.Set(configKey, bv)
-		case "string":
-			cfg.Set(configKey, f.Value.String())
-		case "stringSlice":
-			bv, _ := flags.GetStringSlice(key)
-			cfg.Set(configKey, bv)
-		case "int":
-			iv, _ := flags.GetInt(key)
-			cfg.Set(configKey, iv)
-		default:
-			panic(fmt.Sprintf("update switch with %s", f.Value.Type()))
-		}
-
-	}
+type cmder interface {
+	flagsToConfigHandler
+	getCommand() *cobra.Command
 }

-func flagsToCfg(cd *simplecobra.Commandeer, cfg config.Provider) config.Provider {
-	return flagsToCfgWithAdditionalConfigBase(cd, cfg, "")
+// commandError is an error used to signal different error situations in command handling.
+type commandError struct {
+	s         string
+	userError bool
 }

-func flagsToCfgWithAdditionalConfigBase(cd *simplecobra.Commandeer, cfg config.Provider, additionalConfigBase string) config.Provider {
-	if cfg == nil {
-		cfg = config.New()
-	}
-
-	// Flags with a different name in the config.
-	keyMap := map[string]string{
-		"minify":      "minify.minifyOutput",
-		"destination": "publishDir",
-		"editor":      "newContentEditor",
-	}
-
-	// Flags that we for some reason don't want to expose in the project config.
-	internalKeySet := map[string]bool{
-		"quiet":          true,
-		"verbose":        true,
-		"watch":          true,
-		"liveReloadPort": true,
-		"renderToMemory": true,
-		"clock":          true,
-	}
-
-	cmd := cd.CobraCommand
-	flags := cmd.Flags()
-
-	flags.VisitAll(func(f *pflag.Flag) {
-		if f.Changed {
-			targetKey := f.Name
-			if internalKeySet[targetKey] {
-				targetKey = "internal." + targetKey
-			} else if mapped, ok := keyMap[targetKey]; ok {
-				targetKey = mapped
-			}
-			setValueFromFlag(flags, f.Name, cfg, targetKey, false)
-			if additionalConfigBase != "" {
-				setValueFromFlag(flags, f.Name, cfg, additionalConfigBase+"."+targetKey, true)
-			}
-		}
-	})
-
-	return cfg
+func (c commandError) Error() string {
+	return c.s
 }

-func mkdir(x ...string) {
-	p := filepath.Join(x...)
-	err := os.MkdirAll(p, 0o777) // before umask
-	if err != nil {
-		log.Fatal(err)
-	}
+func (c commandError) isUserError() bool {
+	return c.userError
+}
+
+func newUserError(a ...any) commandError {
+	return commandError{s: fmt.Sprintln(a...), userError: true}
+}
+
+func newSystemError(a ...any) commandError {
+	return commandError{s: fmt.Sprintln(a...), userError: false}
+}
+
+func newSystemErrorF(format string, a ...any) commandError {
+	return commandError{s: fmt.Sprintf(format, a...), userError: false}
+}
+
+// Catch some of the obvious user errors from Cobra.
+// We don't want to show the usage message for every error.
+// The below may be to generic. Time will show.
+var userErrorRegexp = regexp.MustCompile("unknown flag")
+
+func isUserError(err error) bool {
+	if cErr, ok := err.(commandError); ok && cErr.isUserError() {
+		return true
+	}
+
+	return userErrorRegexp.MatchString(err.Error())
 }
@@ -0,0 +1,206 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"fmt"
+	"math/rand"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/bep/clock"
+	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/common/htime"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/afero"
+	"golang.org/x/tools/txtar"
+)
+
+// Issue #5662
+func TestHugoWithContentDirOverride(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	files := `
+-- config.toml --
+baseURL = "https://example.org"
+title = "Hugo Commands"
+-- mycontent/p1.md --
+---
+title: "P1"
+---
+-- layouts/_default/single.html --
+Page: {{ .Title }}|
+
+`
+	s := newTestHugoCmdBuilder(c, files, []string{"-c", "mycontent"}).Build()
+	s.AssertFileContent("public/p1/index.html", `Page: P1|`)
+
+}
+
+// Issue #9794
+func TestHugoStaticFilesMultipleStaticAndManyFolders(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	files := `
+-- config.toml --
+baseURL = "https://example.org"
+theme = "mytheme"
+-- layouts/index.html --
+Home.
+
+`
+	const (
+		numDirs     = 33
+		numFilesMax = 12
+	)
+
+	r := rand.New(rand.NewSource(32))
+
+	for i := 0; i < numDirs; i++ {
+		for j := 0; j < r.Intn(numFilesMax); j++ {
+			if j%3 == 0 {
+				files += fmt.Sprintf("-- themes/mytheme/static/d%d/f%d.txt --\nHellot%d-%d\n", i, j, i, j)
+				files += fmt.Sprintf("-- themes/mytheme/static/d%d/ft%d.txt --\nHellot%d-%d\n", i, j, i, j)
+			}
+			files += fmt.Sprintf("-- static/d%d/f%d.txt --\nHello%d-%d\n", i, j, i, j)
+		}
+	}
+
+	r = rand.New(rand.NewSource(32))
+
+	s := newTestHugoCmdBuilder(c, files, []string{"-c", "mycontent"}).Build()
+	for i := 0; i < numDirs; i++ {
+		for j := 0; j < r.Intn(numFilesMax); j++ {
+			if j%3 == 0 {
+				if j%3 == 0 {
+					s.AssertFileContent(fmt.Sprintf("public/d%d/ft%d.txt", i, j), fmt.Sprintf("Hellot%d-%d", i, j))
+				}
+				s.AssertFileContent(fmt.Sprintf("public/d%d/f%d.txt", i, j), fmt.Sprintf("Hello%d-%d", i, j))
+			}
+		}
+	}
+
+}
+
+// Issue #8787
+func TestHugoListCommandsWithClockFlag(t *testing.T) {
+	t.Cleanup(func() { htime.Clock = clock.System() })
+
+	c := qt.New(t)
+
+	files := `
+-- config.toml --
+baseURL = "https://example.org"
+title = "Hugo Commands"
+timeZone = "UTC"
+-- content/past.md --
+---
+title: "Past"
+date: 2000-11-06
+---
+-- content/future.md --
+---
+title: "Future"
+date: 2200-11-06
+---
+-- layouts/_default/single.html --
+Page: {{ .Title }}|
+
+`
+	s := newTestHugoCmdBuilder(c, files, []string{"list", "future"})
+	s.captureOut = true
+	s.Build()
+	p := filepath.Join("content", "future.md")
+	s.AssertStdout(p + ",2200-11-06T00:00:00Z")
+
+	s = newTestHugoCmdBuilder(c, files, []string{"list", "future", "--clock", "2300-11-06"}).Build()
+	s.AssertStdout("")
+}
+
+type testHugoCmdBuilder struct {
+	*qt.C
+
+	fs    afero.Fs
+	dir   string
+	files string
+	args  []string
+
+	captureOut bool
+	out        string
+}
+
+func newTestHugoCmdBuilder(c *qt.C, files string, args []string) *testHugoCmdBuilder {
+	s := &testHugoCmdBuilder{C: c, files: files, args: args}
+	s.dir = s.TempDir()
+	s.fs = afero.NewBasePathFs(hugofs.Os, s.dir)
+
+	return s
+}
+
+func (s *testHugoCmdBuilder) Build() *testHugoCmdBuilder {
+	data := txtar.Parse([]byte(s.files))
+
+	for _, f := range data.Files {
+		filename := filepath.Clean(f.Name)
+		data := bytes.TrimSuffix(f.Data, []byte("\n"))
+		s.Assert(s.fs.MkdirAll(filepath.Dir(filename), 0777), qt.IsNil)
+		s.Assert(afero.WriteFile(s.fs, filename, data, 0666), qt.IsNil)
+	}
+
+	hugoCmd := newCommandsBuilder().addAll().build()
+	cmd := hugoCmd.getCommand()
+	args := append(s.args, "-s="+s.dir, "--quiet")
+	cmd.SetArgs(args)
+
+	if s.captureOut {
+		out, err := captureStdout(func() error {
+			_, err := cmd.ExecuteC()
+			return err
+		})
+		s.Assert(err, qt.IsNil)
+		s.out = out
+	} else {
+		_, err := cmd.ExecuteC()
+		s.Assert(err, qt.IsNil)
+	}
+
+	return s
+}
+
+func (s *testHugoCmdBuilder) AssertFileContent(filename string, matches ...string) {
+	s.Helper()
+	data, err := afero.ReadFile(s.fs, filename)
+	s.Assert(err, qt.IsNil)
+	content := strings.TrimSpace(string(data))
+	for _, m := range matches {
+		lines := strings.Split(m, "\n")
+		for _, match := range lines {
+			match = strings.TrimSpace(match)
+			if match == "" || strings.HasPrefix(match, "#") {
+				continue
+			}
+			s.Assert(content, qt.Contains, match, qt.Commentf(m))
+		}
+	}
+}
+
+func (s *testHugoCmdBuilder) AssertStdout(match string) {
+	s.Helper()
+	content := strings.TrimSpace(s.out)
+	s.Assert(content, qt.Contains, strings.TrimSpace(match))
+}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2015 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -25,9 +25,9 @@ func init() {
 	// This message to show to Windows users if Hugo is opened from explorer.exe
 	cobra.MousetrapHelpText = `

-  Hugo is a command-line tool for generating static websites.
-
-  You need to open PowerShell and run Hugo from there.
+  Hugo is a command-line tool for generating static website.

+  You need to open cmd.exe and run Hugo from there.
+  
  Visit https://gohugo.io/ for more information.`
 }
@@ -1,625 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package commands
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-
-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/hmaps"
-	"github.com/gohugoio/hugo/common/htime"
-	"github.com/gohugoio/hugo/common/hugio"
-	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/parser"
-	"github.com/gohugoio/hugo/parser/metadecoders"
-	"github.com/gohugoio/hugo/parser/pageparser"
-	"github.com/spf13/afero"
-	"github.com/spf13/cobra"
-)
-
-func newImportCommand() *importCommand {
-	var c *importCommand
-	c = &importCommand{
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "jekyll",
-				short: "hugo import from Jekyll",
-				long: `hugo import from Jekyll.
-
-Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					if len(args) < 2 {
-						return newUserError(`import from jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.")
-					}
-					return c.importFromJekyll(args)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					cmd.Flags().BoolVar(&c.force, "force", false, "allow import into non-empty target directory")
-				},
-			},
-		},
-	}
-
-	return c
-}
-
-type importCommand struct {
-	r *rootCommand
-
-	force bool
-
-	commands []simplecobra.Commander
-}
-
-func (c *importCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *importCommand) Name() string {
-	return "import"
-}
-
-func (c *importCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	return nil
-}
-
-func (c *importCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Import a project from another system"
-	cmd.Long = `Import a project from another system.
-
-Import requires a subcommand, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`."
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *importCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	return nil
-}
-
-func (i *importCommand) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]any) (err error) {
-	title := "My New Hugo Project"
-	baseURL := "http://example.org/"
-
-	for key, value := range jekyllConfig {
-		lowerKey := strings.ToLower(key)
-
-		switch lowerKey {
-		case "title":
-			if str, ok := value.(string); ok {
-				title = str
-			}
-
-		case "url":
-			if str, ok := value.(string); ok {
-				baseURL = str
-			}
-		}
-	}
-
-	in := map[string]any{
-		"baseURL":            baseURL,
-		"title":              title,
-		"locale":             "en-us",
-		"disablePathToLower": true,
-	}
-
-	var buf bytes.Buffer
-	err = parser.InterfaceToConfig(in, kind, &buf)
-	if err != nil {
-		return err
-	}
-
-	return helpers.WriteToDisk(filepath.Join(inpath, "hugo."+string(kind)), &buf, fs)
-}
-
-func (c *importCommand) getJekyllDirInfo(fs afero.Fs, jekyllRoot string) (map[string]bool, bool) {
-	postDirs := make(map[string]bool)
-	hasAnyPost := false
-	if entries, err := os.ReadDir(jekyllRoot); err == nil {
-		for _, entry := range entries {
-			if entry.IsDir() {
-				subDir := filepath.Join(jekyllRoot, entry.Name())
-				if isPostDir, hasAnyPostInDir := c.retrieveJekyllPostDir(fs, subDir); isPostDir {
-					postDirs[entry.Name()] = hasAnyPostInDir
-					if hasAnyPostInDir {
-						hasAnyPost = true
-					}
-				}
-			}
-		}
-	}
-	return postDirs, hasAnyPost
-}
-
-func (c *importCommand) createProjectFromJekyll(jekyllRoot, targetDir string, jekyllPostDirs map[string]bool) error {
-	fs := &afero.OsFs{}
-	if exists, _ := helpers.Exists(targetDir, fs); exists {
-		if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
-			return errors.New("target path \"" + targetDir + "\" exists but is not a directory")
-		}
-
-		isEmpty, _ := helpers.IsEmpty(targetDir, fs)
-
-		if !isEmpty && !c.force {
-			return errors.New("target path \"" + targetDir + "\" exists and is not empty")
-		}
-	}
-
-	jekyllConfig := c.loadJekyllConfig(fs, jekyllRoot)
-
-	mkdir(targetDir, "layouts")
-	mkdir(targetDir, "content")
-	mkdir(targetDir, "archetypes")
-	mkdir(targetDir, "static")
-	mkdir(targetDir, "data")
-	mkdir(targetDir, "themes")
-
-	c.createConfigFromJekyll(fs, targetDir, "yaml", jekyllConfig)
-
-	c.copyJekyllFilesAndFolders(jekyllRoot, filepath.Join(targetDir, "static"), jekyllPostDirs)
-
-	return nil
-}
-
-func (c *importCommand) convertJekyllContent(m any, content string) (string, error) {
-	metadata, _ := hmaps.ToStringMapE(m)
-
-	lines := strings.Split(content, "\n")
-	var resultLines []string
-	for _, line := range lines {
-		resultLines = append(resultLines, strings.Trim(line, "\r\n"))
-	}
-
-	content = strings.Join(resultLines, "\n")
-
-	excerptSep := "<!--more-->"
-	if value, ok := metadata["excerpt_separator"]; ok {
-		if str, strOk := value.(string); strOk {
-			content = strings.Replace(content, strings.TrimSpace(str), excerptSep, -1)
-		}
-	}
-
-	replaceList := []struct {
-		re      *regexp.Regexp
-		replace string
-	}{
-		{regexp.MustCompile("(?i)<!-- more -->"), "<!--more-->"},
-		{regexp.MustCompile(`\{%\s*raw\s*%\}\s*(.*?)\s*\{%\s*endraw\s*%\}`), "$1"},
-		{regexp.MustCompile(`{%\s*endhighlight\s*%}`), "{{< / highlight >}}"},
-	}
-
-	for _, replace := range replaceList {
-		content = replace.re.ReplaceAllString(content, replace.replace)
-	}
-
-	replaceListFunc := []struct {
-		re      *regexp.Regexp
-		replace func(string) string
-	}{
-		// Octopress image tag: http://octopress.org/docs/plugins/image-tag/
-		{regexp.MustCompile(`{%\s+img\s*(.*?)\s*%}`), c.replaceImageTag},
-		{regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`), c.replaceHighlightTag},
-	}
-
-	for _, replace := range replaceListFunc {
-		content = replace.re.ReplaceAllStringFunc(content, replace.replace)
-	}
-
-	var buf bytes.Buffer
-	if len(metadata) != 0 {
-		err := parser.InterfaceToFrontMatter(m, metadecoders.YAML, &buf)
-		if err != nil {
-			return "", err
-		}
-	}
-	buf.WriteString(content)
-
-	return buf.String(), nil
-}
-
-func (c *importCommand) convertJekyllMetaData(m any, postName string, postDate time.Time, draft bool) (any, error) {
-	metadata, err := hmaps.ToStringMapE(m)
-	if err != nil {
-		return nil, err
-	}
-
-	if draft {
-		metadata["draft"] = true
-	}
-
-	for key, value := range metadata {
-		lowerKey := strings.ToLower(key)
-
-		switch lowerKey {
-		case "layout":
-			delete(metadata, key)
-		case "permalink":
-			if str, ok := value.(string); ok {
-				metadata["url"] = str
-			}
-			delete(metadata, key)
-		case "category":
-			if str, ok := value.(string); ok {
-				metadata["categories"] = []string{str}
-			}
-			delete(metadata, key)
-		case "excerpt_separator":
-			if key != lowerKey {
-				delete(metadata, key)
-				metadata[lowerKey] = value
-			}
-		case "date":
-			if str, ok := value.(string); ok {
-				re := regexp.MustCompile(`(\d+):(\d+):(\d+)`)
-				r := re.FindAllStringSubmatch(str, -1)
-				if len(r) > 0 {
-					hour, _ := strconv.Atoi(r[0][1])
-					minute, _ := strconv.Atoi(r[0][2])
-					second, _ := strconv.Atoi(r[0][3])
-					postDate = time.Date(postDate.Year(), postDate.Month(), postDate.Day(), hour, minute, second, 0, time.UTC)
-				}
-			}
-			delete(metadata, key)
-		}
-
-	}
-
-	metadata["date"] = postDate.Format(time.RFC3339)
-
-	return metadata, nil
-}
-
-func (c *importCommand) convertJekyllPost(path, relPath, targetDir string, draft bool) error {
-	log.Println("Converting", path)
-
-	filename := filepath.Base(path)
-	postDate, postName, err := c.parseJekyllFilename(filename)
-	if err != nil {
-		c.r.Printf("Failed to parse filename '%s': %s. Skipping.", filename, err)
-		return nil
-	}
-
-	log.Println(filename, postDate, postName)
-
-	targetFile := filepath.Join(targetDir, relPath)
-	targetParentDir := filepath.Dir(targetFile)
-	os.MkdirAll(targetParentDir, 0o777)
-
-	contentBytes, err := os.ReadFile(path)
-	if err != nil {
-		c.r.logger.Errorln("Read file error:", path)
-		return err
-	}
-	pf, err := pageparser.ParseFrontMatterAndContent(bytes.NewReader(contentBytes))
-	if err != nil {
-		return fmt.Errorf("failed to parse file %q: %s", filename, err)
-	}
-	newmetadata, err := c.convertJekyllMetaData(pf.FrontMatter, postName, postDate, draft)
-	if err != nil {
-		return fmt.Errorf("failed to convert metadata for file %q: %s", filename, err)
-	}
-
-	content, err := c.convertJekyllContent(newmetadata, string(pf.Content))
-	if err != nil {
-		return fmt.Errorf("failed to convert content for file %q: %s", filename, err)
-	}
-
-	fs := hugofs.Os
-	if err := helpers.WriteToDisk(targetFile, strings.NewReader(content), fs); err != nil {
-		return fmt.Errorf("failed to save file %q: %s", filename, err)
-	}
-	return nil
-}
-
-func (c *importCommand) copyJekyllFilesAndFolders(jekyllRoot, dest string, jekyllPostDirs map[string]bool) (err error) {
-	fs := hugofs.Os
-
-	fi, err := fs.Stat(jekyllRoot)
-	if err != nil {
-		return err
-	}
-	if !fi.IsDir() {
-		return errors.New(jekyllRoot + " is not a directory")
-	}
-	err = os.MkdirAll(dest, fi.Mode())
-	if err != nil {
-		return err
-	}
-	entries, err := os.ReadDir(jekyllRoot)
-	if err != nil {
-		return err
-	}
-
-	for _, entry := range entries {
-		sfp := filepath.Join(jekyllRoot, entry.Name())
-		dfp := filepath.Join(dest, entry.Name())
-		if entry.IsDir() {
-			if entry.Name()[0] != '_' && entry.Name()[0] != '.' {
-				if _, ok := jekyllPostDirs[entry.Name()]; !ok {
-					err = hugio.CopyDir(fs, sfp, dfp, nil)
-					if err != nil {
-						c.r.logger.Errorln(err)
-					}
-				}
-			}
-		} else {
-			lowerEntryName := strings.ToLower(entry.Name())
-			exceptSuffix := []string{
-				".md", ".markdown", ".html", ".htm",
-				".xml", ".textile", "rakefile", "gemfile", ".lock",
-			}
-			isExcept := false
-			for _, suffix := range exceptSuffix {
-				if strings.HasSuffix(lowerEntryName, suffix) {
-					isExcept = true
-					break
-				}
-			}
-
-			if !isExcept && entry.Name()[0] != '.' && entry.Name()[0] != '_' {
-				err = hugio.CopyFile(fs, sfp, dfp)
-				if err != nil {
-					c.r.logger.Errorln(err)
-				}
-			}
-		}
-
-	}
-	return nil
-}
-
-func (c *importCommand) importFromJekyll(args []string) error {
-	jekyllRoot, err := filepath.Abs(filepath.Clean(args[0]))
-	if err != nil {
-		return newUserError("path error:", args[0])
-	}
-
-	targetDir, err := filepath.Abs(filepath.Clean(args[1]))
-	if err != nil {
-		return newUserError("path error:", args[1])
-	}
-
-	c.r.Println("Import Jekyll from:", jekyllRoot, "to:", targetDir)
-
-	if strings.HasPrefix(filepath.Dir(targetDir), jekyllRoot) {
-		return newUserError("abort: target path should not be inside the Jekyll root")
-	}
-
-	fs := afero.NewOsFs()
-	jekyllPostDirs, hasAnyPost := c.getJekyllDirInfo(fs, jekyllRoot)
-	if !hasAnyPost {
-		return errors.New("abort: jekyll root contains neither posts nor drafts")
-	}
-
-	err = c.createProjectFromJekyll(jekyllRoot, targetDir, jekyllPostDirs)
-	if err != nil {
-		return newUserError(err)
-	}
-
-	c.r.Println("Importing...")
-
-	fileCount := 0
-	callback := func(ctx context.Context, path string, fi hugofs.FileMetaInfo) error {
-		if fi.IsDir() {
-			return nil
-		}
-
-		relPath, err := filepath.Rel(jekyllRoot, path)
-		if err != nil {
-			return newUserError("get rel path error:", path)
-		}
-
-		relPath = filepath.ToSlash(relPath)
-		draft := false
-
-		switch {
-		case strings.Contains(relPath, "_posts/"):
-			relPath = filepath.Join("content/post", strings.Replace(relPath, "_posts/", "", -1))
-		case strings.Contains(relPath, "_drafts/"):
-			relPath = filepath.Join("content/draft", strings.Replace(relPath, "_drafts/", "", -1))
-			draft = true
-		default:
-			return nil
-		}
-
-		fileCount++
-		return c.convertJekyllPost(path, relPath, targetDir, draft)
-	}
-
-	for jekyllPostDir, hasAnyPostInDir := range jekyllPostDirs {
-		if hasAnyPostInDir {
-			if err = helpers.Walk(hugofs.Os, filepath.Join(jekyllRoot, jekyllPostDir), callback); err != nil {
-				return err
-			}
-		}
-	}
-
-	c.r.Println("Congratulations!", fileCount, "post(s) imported!")
-	c.r.Println("Now, start Hugo by yourself:")
-	c.r.Println("cd " + args[1])
-	c.r.Println("git init")
-	c.r.Println("git submodule add https://github.com/gohugo-ananke/ananke themes/ananke")
-	c.r.Println("echo \"theme: ananke\" >> hugo.yaml")
-	c.r.Println("hugo server")
-
-	return nil
-}
-
-func (c *importCommand) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]any {
-	for _, candidate := range []struct {
-		filename string
-		format   metadecoders.Format
-	}{
-		{"_config.yml", metadecoders.YAML},
-		{"_config.yaml", metadecoders.YAML},
-		{"_config.toml", metadecoders.TOML},
-	} {
-		path := filepath.Join(jekyllRoot, candidate.filename)
-		exists, err := helpers.Exists(path, fs)
-		if err != nil || !exists {
-			continue
-		}
-
-		f, err := fs.Open(path)
-		if err != nil {
-			continue
-		}
-		b, err := io.ReadAll(f)
-		f.Close()
-		if err != nil {
-			continue
-		}
-
-		m, err := metadecoders.Default.UnmarshalToMap(b, candidate.format)
-		if err != nil {
-			continue
-		}
-
-		return m
-	}
-
-	c.r.Println("no config file (_config.yml, _config.yaml, or _config.toml) found: is the specified Jekyll root correct?")
-	return nil
-}
-
-func (c *importCommand) parseJekyllFilename(filename string) (time.Time, string, error) {
-	re := regexp.MustCompile(`(\d+-\d+-\d+)-(.+)\..*`)
-	r := re.FindAllStringSubmatch(filename, -1)
-	if len(r) == 0 {
-		return htime.Now(), "", errors.New("filename not match")
-	}
-
-	postDate, err := time.Parse("2006-1-2", r[0][1])
-	if err != nil {
-		return htime.Now(), "", err
-	}
-
-	postName := r[0][2]
-
-	return postDate, postName, nil
-}
-
-func (c *importCommand) replaceHighlightTag(match string) string {
-	r := regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`)
-	parts := r.FindStringSubmatch(match)
-	lastQuote := rune(0)
-	f := func(c rune) bool {
-		switch {
-		case c == lastQuote:
-			lastQuote = rune(0)
-			return false
-		case lastQuote != rune(0):
-			return false
-		case unicode.In(c, unicode.Quotation_Mark):
-			lastQuote = c
-			return false
-		default:
-			return unicode.IsSpace(c)
-		}
-	}
-	// splitting string by space but considering quoted section
-	items := strings.FieldsFunc(parts[1], f)
-
-	result := bytes.NewBufferString("{{< highlight ")
-	result.WriteString(items[0]) // language
-	options := items[1:]
-	for i, opt := range options {
-		opt = strings.Replace(opt, "\"", "", -1)
-		if opt == "linenos" {
-			opt = "linenos=table"
-		}
-		if i == 0 {
-			opt = " \"" + opt
-		}
-		if i < len(options)-1 {
-			opt += ","
-		} else if i == len(options)-1 {
-			opt += "\""
-		}
-		result.WriteString(opt)
-	}
-
-	result.WriteString(" >}}")
-	return result.String()
-}
-
-func (c *importCommand) replaceImageTag(match string) string {
-	r := regexp.MustCompile(`{%\s+img\s*(\p{L}*)\s+([\S]*/[\S]+)\s+(\d*)\s*(\d*)\s*(.*?)\s*%}`)
-	result := bytes.NewBufferString("{{< figure ")
-	parts := r.FindStringSubmatch(match)
-	// Index 0 is the entire string, ignore
-	c.replaceOptionalPart(result, "class", parts[1])
-	c.replaceOptionalPart(result, "src", parts[2])
-	c.replaceOptionalPart(result, "width", parts[3])
-	c.replaceOptionalPart(result, "height", parts[4])
-	// title + alt
-	part := parts[5]
-	if len(part) > 0 {
-		splits := strings.Split(part, "'")
-		lenSplits := len(splits)
-		if lenSplits == 1 {
-			c.replaceOptionalPart(result, "title", splits[0])
-		} else if lenSplits == 3 {
-			c.replaceOptionalPart(result, "title", splits[1])
-		} else if lenSplits == 5 {
-			c.replaceOptionalPart(result, "title", splits[1])
-			c.replaceOptionalPart(result, "alt", splits[3])
-		}
-	}
-	result.WriteString(">}}")
-	return result.String()
-}
-
-func (c *importCommand) replaceOptionalPart(buffer *bytes.Buffer, partName string, part string) {
-	if len(part) > 0 {
-		buffer.WriteString(partName + "=\"" + part + "\" ")
-	}
-}
-
-func (c *importCommand) retrieveJekyllPostDir(fs afero.Fs, dir string) (bool, bool) {
-	if strings.HasSuffix(dir, "_posts") || strings.HasSuffix(dir, "_drafts") {
-		isEmpty, _ := helpers.IsEmpty(dir, fs)
-		return true, !isEmpty
-	}
-
-	if entries, err := os.ReadDir(dir); err == nil {
-		for _, entry := range entries {
-			if entry.IsDir() {
-				subDir := filepath.Join(dir, entry.Name())
-				if isPostDir, hasAnyPost := c.retrieveJekyllPostDir(fs, subDir); isPostDir {
-					return isPostDir, hasAnyPost
-				}
-			}
-		}
-	}
-
-	return false, true
-}
@@ -0,0 +1,604 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+
+	"github.com/gohugoio/hugo/parser/pageparser"
+
+	"github.com/gohugoio/hugo/common/htime"
+	"github.com/gohugoio/hugo/common/hugio"
+
+	"github.com/gohugoio/hugo/parser/metadecoders"
+
+	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/parser"
+	"github.com/spf13/afero"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*importCmd)(nil)
+
+type importCmd struct {
+	*baseCmd
+}
+
+func newImportCmd() *importCmd {
+	cc := &importCmd{}
+
+	cc.baseCmd = newBaseCmd(&cobra.Command{
+		Use:   "import",
+		Short: "Import your site from others.",
+		Long: `Import your site from other web site generators like Jekyll.
+
+Import requires a subcommand, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
+		RunE: nil,
+	})
+
+	importJekyllCmd := &cobra.Command{
+		Use:   "jekyll",
+		Short: "hugo import from Jekyll",
+		Long: `hugo import from Jekyll.
+
+Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
+		RunE: cc.importFromJekyll,
+	}
+
+	importJekyllCmd.Flags().Bool("force", false, "allow import into non-empty target directory")
+
+	cc.cmd.AddCommand(importJekyllCmd)
+
+	return cc
+}
+
+func (i *importCmd) importFromJekyll(cmd *cobra.Command, args []string) error {
+	if len(args) < 2 {
+		return newUserError(`import from jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.")
+	}
+
+	jekyllRoot, err := filepath.Abs(filepath.Clean(args[0]))
+	if err != nil {
+		return newUserError("path error:", args[0])
+	}
+
+	targetDir, err := filepath.Abs(filepath.Clean(args[1]))
+	if err != nil {
+		return newUserError("path error:", args[1])
+	}
+
+	jww.INFO.Println("Import Jekyll from:", jekyllRoot, "to:", targetDir)
+
+	if strings.HasPrefix(filepath.Dir(targetDir), jekyllRoot) {
+		return newUserError("abort: target path should not be inside the Jekyll root")
+	}
+
+	forceImport, _ := cmd.Flags().GetBool("force")
+
+	fs := afero.NewOsFs()
+	jekyllPostDirs, hasAnyPost := i.getJekyllDirInfo(fs, jekyllRoot)
+	if !hasAnyPost {
+		return errors.New("abort: jekyll root contains neither posts nor drafts")
+	}
+
+	err = i.createSiteFromJekyll(jekyllRoot, targetDir, jekyllPostDirs, forceImport)
+
+	if err != nil {
+		return newUserError(err)
+	}
+
+	jww.FEEDBACK.Println("Importing...")
+
+	fileCount := 0
+	callback := func(path string, fi hugofs.FileMetaInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if fi.IsDir() {
+			return nil
+		}
+
+		relPath, err := filepath.Rel(jekyllRoot, path)
+		if err != nil {
+			return newUserError("get rel path error:", path)
+		}
+
+		relPath = filepath.ToSlash(relPath)
+		draft := false
+
+		switch {
+		case strings.Contains(relPath, "_posts/"):
+			relPath = filepath.Join("content/post", strings.Replace(relPath, "_posts/", "", -1))
+		case strings.Contains(relPath, "_drafts/"):
+			relPath = filepath.Join("content/draft", strings.Replace(relPath, "_drafts/", "", -1))
+			draft = true
+		default:
+			return nil
+		}
+
+		fileCount++
+		return convertJekyllPost(path, relPath, targetDir, draft)
+	}
+
+	for jekyllPostDir, hasAnyPostInDir := range jekyllPostDirs {
+		if hasAnyPostInDir {
+			if err = helpers.SymbolicWalk(hugofs.Os, filepath.Join(jekyllRoot, jekyllPostDir), callback); err != nil {
+				return err
+			}
+		}
+	}
+
+	jww.FEEDBACK.Println("Congratulations!", fileCount, "post(s) imported!")
+	jww.FEEDBACK.Println("Now, start Hugo by yourself:\n" +
+		"$ git clone https://github.com/spf13/herring-cove.git " + args[1] + "/themes/herring-cove")
+	jww.FEEDBACK.Println("$ cd " + args[1] + "\n$ hugo server --theme=herring-cove")
+
+	return nil
+}
+
+func (i *importCmd) getJekyllDirInfo(fs afero.Fs, jekyllRoot string) (map[string]bool, bool) {
+	postDirs := make(map[string]bool)
+	hasAnyPost := false
+	if entries, err := ioutil.ReadDir(jekyllRoot); err == nil {
+		for _, entry := range entries {
+			if entry.IsDir() {
+				subDir := filepath.Join(jekyllRoot, entry.Name())
+				if isPostDir, hasAnyPostInDir := i.retrieveJekyllPostDir(fs, subDir); isPostDir {
+					postDirs[entry.Name()] = hasAnyPostInDir
+					if hasAnyPostInDir {
+						hasAnyPost = true
+					}
+				}
+			}
+		}
+	}
+	return postDirs, hasAnyPost
+}
+
+func (i *importCmd) retrieveJekyllPostDir(fs afero.Fs, dir string) (bool, bool) {
+	if strings.HasSuffix(dir, "_posts") || strings.HasSuffix(dir, "_drafts") {
+		isEmpty, _ := helpers.IsEmpty(dir, fs)
+		return true, !isEmpty
+	}
+
+	if entries, err := ioutil.ReadDir(dir); err == nil {
+		for _, entry := range entries {
+			if entry.IsDir() {
+				subDir := filepath.Join(dir, entry.Name())
+				if isPostDir, hasAnyPost := i.retrieveJekyllPostDir(fs, subDir); isPostDir {
+					return isPostDir, hasAnyPost
+				}
+			}
+		}
+	}
+
+	return false, true
+}
+
+func (i *importCmd) createSiteFromJekyll(jekyllRoot, targetDir string, jekyllPostDirs map[string]bool, force bool) error {
+	fs := &afero.OsFs{}
+	if exists, _ := helpers.Exists(targetDir, fs); exists {
+		if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
+			return errors.New("target path \"" + targetDir + "\" exists but is not a directory")
+		}
+
+		isEmpty, _ := helpers.IsEmpty(targetDir, fs)
+
+		if !isEmpty && !force {
+			return errors.New("target path \"" + targetDir + "\" exists and is not empty")
+		}
+	}
+
+	jekyllConfig := i.loadJekyllConfig(fs, jekyllRoot)
+
+	mkdir(targetDir, "layouts")
+	mkdir(targetDir, "content")
+	mkdir(targetDir, "archetypes")
+	mkdir(targetDir, "static")
+	mkdir(targetDir, "data")
+	mkdir(targetDir, "themes")
+
+	i.createConfigFromJekyll(fs, targetDir, "yaml", jekyllConfig)
+
+	i.copyJekyllFilesAndFolders(jekyllRoot, filepath.Join(targetDir, "static"), jekyllPostDirs)
+
+	return nil
+}
+
+func (i *importCmd) loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]any {
+	path := filepath.Join(jekyllRoot, "_config.yml")
+
+	exists, err := helpers.Exists(path, fs)
+
+	if err != nil || !exists {
+		jww.WARN.Println("_config.yaml not found: Is the specified Jekyll root correct?")
+		return nil
+	}
+
+	f, err := fs.Open(path)
+	if err != nil {
+		return nil
+	}
+
+	defer f.Close()
+
+	b, err := ioutil.ReadAll(f)
+	if err != nil {
+		return nil
+	}
+
+	c, err := metadecoders.Default.UnmarshalToMap(b, metadecoders.YAML)
+	if err != nil {
+		return nil
+	}
+
+	return c
+}
+
+func (i *importCmd) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]any) (err error) {
+	title := "My New Hugo Site"
+	baseURL := "http://example.org/"
+
+	for key, value := range jekyllConfig {
+		lowerKey := strings.ToLower(key)
+
+		switch lowerKey {
+		case "title":
+			if str, ok := value.(string); ok {
+				title = str
+			}
+
+		case "url":
+			if str, ok := value.(string); ok {
+				baseURL = str
+			}
+		}
+	}
+
+	in := map[string]any{
+		"baseURL":            baseURL,
+		"title":              title,
+		"languageCode":       "en-us",
+		"disablePathToLower": true,
+	}
+
+	var buf bytes.Buffer
+	err = parser.InterfaceToConfig(in, kind, &buf)
+	if err != nil {
+		return err
+	}
+
+	return helpers.WriteToDisk(filepath.Join(inpath, "config."+string(kind)), &buf, fs)
+}
+
+func (i *importCmd) copyJekyllFilesAndFolders(jekyllRoot, dest string, jekyllPostDirs map[string]bool) (err error) {
+	fs := hugofs.Os
+
+	fi, err := fs.Stat(jekyllRoot)
+	if err != nil {
+		return err
+	}
+	if !fi.IsDir() {
+		return errors.New(jekyllRoot + " is not a directory")
+	}
+	err = os.MkdirAll(dest, fi.Mode())
+	if err != nil {
+		return err
+	}
+	entries, err := ioutil.ReadDir(jekyllRoot)
+	if err != nil {
+		return err
+	}
+
+	for _, entry := range entries {
+		sfp := filepath.Join(jekyllRoot, entry.Name())
+		dfp := filepath.Join(dest, entry.Name())
+		if entry.IsDir() {
+			if entry.Name()[0] != '_' && entry.Name()[0] != '.' {
+				if _, ok := jekyllPostDirs[entry.Name()]; !ok {
+					err = hugio.CopyDir(fs, sfp, dfp, nil)
+					if err != nil {
+						jww.ERROR.Println(err)
+					}
+				}
+			}
+		} else {
+			lowerEntryName := strings.ToLower(entry.Name())
+			exceptSuffix := []string{
+				".md", ".markdown", ".html", ".htm",
+				".xml", ".textile", "rakefile", "gemfile", ".lock",
+			}
+			isExcept := false
+			for _, suffix := range exceptSuffix {
+				if strings.HasSuffix(lowerEntryName, suffix) {
+					isExcept = true
+					break
+				}
+			}
+
+			if !isExcept && entry.Name()[0] != '.' && entry.Name()[0] != '_' {
+				err = hugio.CopyFile(fs, sfp, dfp)
+				if err != nil {
+					jww.ERROR.Println(err)
+				}
+			}
+		}
+
+	}
+	return nil
+}
+
+func parseJekyllFilename(filename string) (time.Time, string, error) {
+	re := regexp.MustCompile(`(\d+-\d+-\d+)-(.+)\..*`)
+	r := re.FindAllStringSubmatch(filename, -1)
+	if len(r) == 0 {
+		return htime.Now(), "", errors.New("filename not match")
+	}
+
+	postDate, err := time.Parse("2006-1-2", r[0][1])
+	if err != nil {
+		return htime.Now(), "", err
+	}
+
+	postName := r[0][2]
+
+	return postDate, postName, nil
+}
+
+func convertJekyllPost(path, relPath, targetDir string, draft bool) error {
+	jww.TRACE.Println("Converting", path)
+
+	filename := filepath.Base(path)
+	postDate, postName, err := parseJekyllFilename(filename)
+	if err != nil {
+		jww.WARN.Printf("Failed to parse filename '%s': %s. Skipping.", filename, err)
+		return nil
+	}
+
+	jww.TRACE.Println(filename, postDate, postName)
+
+	targetFile := filepath.Join(targetDir, relPath)
+	targetParentDir := filepath.Dir(targetFile)
+	os.MkdirAll(targetParentDir, 0777)
+
+	contentBytes, err := ioutil.ReadFile(path)
+	if err != nil {
+		jww.ERROR.Println("Read file error:", path)
+		return err
+	}
+
+	pf, err := pageparser.ParseFrontMatterAndContent(bytes.NewReader(contentBytes))
+	if err != nil {
+		jww.ERROR.Println("Parse file error:", path)
+		return err
+	}
+
+	newmetadata, err := convertJekyllMetaData(pf.FrontMatter, postName, postDate, draft)
+	if err != nil {
+		jww.ERROR.Println("Convert metadata error:", path)
+		return err
+	}
+
+	content, err := convertJekyllContent(newmetadata, string(pf.Content))
+	if err != nil {
+		jww.ERROR.Println("Converting Jekyll error:", path)
+		return err
+	}
+
+	fs := hugofs.Os
+	if err := helpers.WriteToDisk(targetFile, strings.NewReader(content), fs); err != nil {
+		return fmt.Errorf("failed to save file %q: %s", filename, err)
+	}
+
+	return nil
+}
+
+func convertJekyllMetaData(m any, postName string, postDate time.Time, draft bool) (any, error) {
+	metadata, err := maps.ToStringMapE(m)
+	if err != nil {
+		return nil, err
+	}
+
+	if draft {
+		metadata["draft"] = true
+	}
+
+	for key, value := range metadata {
+		lowerKey := strings.ToLower(key)
+
+		switch lowerKey {
+		case "layout":
+			delete(metadata, key)
+		case "permalink":
+			if str, ok := value.(string); ok {
+				metadata["url"] = str
+			}
+			delete(metadata, key)
+		case "category":
+			if str, ok := value.(string); ok {
+				metadata["categories"] = []string{str}
+			}
+			delete(metadata, key)
+		case "excerpt_separator":
+			if key != lowerKey {
+				delete(metadata, key)
+				metadata[lowerKey] = value
+			}
+		case "date":
+			if str, ok := value.(string); ok {
+				re := regexp.MustCompile(`(\d+):(\d+):(\d+)`)
+				r := re.FindAllStringSubmatch(str, -1)
+				if len(r) > 0 {
+					hour, _ := strconv.Atoi(r[0][1])
+					minute, _ := strconv.Atoi(r[0][2])
+					second, _ := strconv.Atoi(r[0][3])
+					postDate = time.Date(postDate.Year(), postDate.Month(), postDate.Day(), hour, minute, second, 0, time.UTC)
+				}
+			}
+			delete(metadata, key)
+		}
+
+	}
+
+	metadata["date"] = postDate.Format(time.RFC3339)
+
+	return metadata, nil
+}
+
+func convertJekyllContent(m any, content string) (string, error) {
+	metadata, _ := maps.ToStringMapE(m)
+
+	lines := strings.Split(content, "\n")
+	var resultLines []string
+	for _, line := range lines {
+		resultLines = append(resultLines, strings.Trim(line, "\r\n"))
+	}
+
+	content = strings.Join(resultLines, "\n")
+
+	excerptSep := "<!--more-->"
+	if value, ok := metadata["excerpt_separator"]; ok {
+		if str, strOk := value.(string); strOk {
+			content = strings.Replace(content, strings.TrimSpace(str), excerptSep, -1)
+		}
+	}
+
+	replaceList := []struct {
+		re      *regexp.Regexp
+		replace string
+	}{
+		{regexp.MustCompile("(?i)<!-- more -->"), "<!--more-->"},
+		{regexp.MustCompile(`\{%\s*raw\s*%\}\s*(.*?)\s*\{%\s*endraw\s*%\}`), "$1"},
+		{regexp.MustCompile(`{%\s*endhighlight\s*%}`), "{{< / highlight >}}"},
+	}
+
+	for _, replace := range replaceList {
+		content = replace.re.ReplaceAllString(content, replace.replace)
+	}
+
+	replaceListFunc := []struct {
+		re      *regexp.Regexp
+		replace func(string) string
+	}{
+		// Octopress image tag: http://octopress.org/docs/plugins/image-tag/
+		{regexp.MustCompile(`{%\s+img\s*(.*?)\s*%}`), replaceImageTag},
+		{regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`), replaceHighlightTag},
+	}
+
+	for _, replace := range replaceListFunc {
+		content = replace.re.ReplaceAllStringFunc(content, replace.replace)
+	}
+
+	var buf bytes.Buffer
+	if len(metadata) != 0 {
+		err := parser.InterfaceToFrontMatter(m, metadecoders.YAML, &buf)
+		if err != nil {
+			return "", err
+		}
+	}
+	buf.WriteString(content)
+
+	return buf.String(), nil
+}
+
+func replaceHighlightTag(match string) string {
+	r := regexp.MustCompile(`{%\s*highlight\s*(.*?)\s*%}`)
+	parts := r.FindStringSubmatch(match)
+	lastQuote := rune(0)
+	f := func(c rune) bool {
+		switch {
+		case c == lastQuote:
+			lastQuote = rune(0)
+			return false
+		case lastQuote != rune(0):
+			return false
+		case unicode.In(c, unicode.Quotation_Mark):
+			lastQuote = c
+			return false
+		default:
+			return unicode.IsSpace(c)
+		}
+	}
+	// splitting string by space but considering quoted section
+	items := strings.FieldsFunc(parts[1], f)
+
+	result := bytes.NewBufferString("{{< highlight ")
+	result.WriteString(items[0]) // language
+	options := items[1:]
+	for i, opt := range options {
+		opt = strings.Replace(opt, "\"", "", -1)
+		if opt == "linenos" {
+			opt = "linenos=table"
+		}
+		if i == 0 {
+			opt = " \"" + opt
+		}
+		if i < len(options)-1 {
+			opt += ","
+		} else if i == len(options)-1 {
+			opt += "\""
+		}
+		result.WriteString(opt)
+	}
+
+	result.WriteString(" >}}")
+	return result.String()
+}
+
+func replaceImageTag(match string) string {
+	r := regexp.MustCompile(`{%\s+img\s*(\p{L}*)\s+([\S]*/[\S]+)\s+(\d*)\s*(\d*)\s*(.*?)\s*%}`)
+	result := bytes.NewBufferString("{{< figure ")
+	parts := r.FindStringSubmatch(match)
+	// Index 0 is the entire string, ignore
+	replaceOptionalPart(result, "class", parts[1])
+	replaceOptionalPart(result, "src", parts[2])
+	replaceOptionalPart(result, "width", parts[3])
+	replaceOptionalPart(result, "height", parts[4])
+	// title + alt
+	part := parts[5]
+	if len(part) > 0 {
+		splits := strings.Split(part, "'")
+		lenSplits := len(splits)
+		if lenSplits == 1 {
+			replaceOptionalPart(result, "title", splits[0])
+		} else if lenSplits == 3 {
+			replaceOptionalPart(result, "title", splits[1])
+		} else if lenSplits == 5 {
+			replaceOptionalPart(result, "title", splits[1])
+			replaceOptionalPart(result, "alt", splits[3])
+		}
+	}
+	result.WriteString(">}}")
+	return result.String()
+}
+
+func replaceOptionalPart(buffer *bytes.Buffer, partName string, part string) {
+	if len(part) > 0 {
+		buffer.WriteString(partName + "=\"" + part + "\" ")
+	}
+}
@@ -0,0 +1,177 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestParseJekyllFilename(t *testing.T) {
+	c := qt.New(t)
+	filenameArray := []string{
+		"2015-01-02-test.md",
+		"2012-03-15-中文.markup",
+	}
+
+	expectResult := []struct {
+		postDate time.Time
+		postName string
+	}{
+		{time.Date(2015, time.January, 2, 0, 0, 0, 0, time.UTC), "test"},
+		{time.Date(2012, time.March, 15, 0, 0, 0, 0, time.UTC), "中文"},
+	}
+
+	for i, filename := range filenameArray {
+		postDate, postName, err := parseJekyllFilename(filename)
+		c.Assert(err, qt.IsNil)
+		c.Assert(expectResult[i].postDate.Format("2006-01-02"), qt.Equals, postDate.Format("2006-01-02"))
+		c.Assert(expectResult[i].postName, qt.Equals, postName)
+	}
+}
+
+func TestConvertJekyllMetadata(t *testing.T) {
+	c := qt.New(t)
+	testDataList := []struct {
+		metadata any
+		postName string
+		postDate time.Time
+		draft    bool
+		expect   string
+	}{
+		{
+			map[any]any{},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z"}`,
+		},
+		{
+			map[any]any{},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
+			`{"date":"2015-10-01T00:00:00Z","draft":true}`,
+		},
+		{
+			map[any]any{"Permalink": "/permalink.html", "layout": "post"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
+		},
+		{
+			map[any]any{"permalink": "/permalink.html"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
+		},
+		{
+			map[any]any{"category": nil, "permalink": 123},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z"}`,
+		},
+		{
+			map[any]any{"Excerpt_Separator": "sep"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"date":"2015-10-01T00:00:00Z","excerpt_separator":"sep"}`,
+		},
+		{
+			map[any]any{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
+			"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+			`{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z"}`,
+		},
+	}
+
+	for _, data := range testDataList {
+		result, err := convertJekyllMetaData(data.metadata, data.postName, data.postDate, data.draft)
+		c.Assert(err, qt.IsNil)
+		jsonResult, err := json.Marshal(result)
+		c.Assert(err, qt.IsNil)
+		c.Assert(string(jsonResult), qt.Equals, data.expect)
+	}
+}
+
+func TestConvertJekyllContent(t *testing.T) {
+	c := qt.New(t)
+	testDataList := []struct {
+		metadata any
+		content  string
+		expect   string
+	}{
+		{
+			map[any]any{},
+			"Test content\r\n<!-- more -->\npart2 content", "Test content\n<!--more-->\npart2 content",
+		},
+		{
+			map[any]any{},
+			"Test content\n<!-- More -->\npart2 content", "Test content\n<!--more-->\npart2 content",
+		},
+		{
+			map[any]any{"excerpt_separator": "<!--sep-->"},
+			"Test content\n<!--sep-->\npart2 content",
+			"---\nexcerpt_separator: <!--sep-->\n---\nTest content\n<!--more-->\npart2 content",
+		},
+		{map[any]any{}, "{% raw %}text{% endraw %}", "text"},
+		{map[any]any{}, "{%raw%} text2 {%endraw %}", "text2"},
+		{
+			map[any]any{},
+			"{% highlight go %}\nvar s int\n{% endhighlight %}",
+			"{{< highlight go >}}\nvar s int\n{{< / highlight >}}",
+		},
+		{
+			map[any]any{},
+			"{% highlight go linenos hl_lines=\"1 2\" %}\nvar s string\nvar i int\n{% endhighlight %}",
+			"{{< highlight go \"linenos=table,hl_lines=1 2\" >}}\nvar s string\nvar i int\n{{< / highlight >}}",
+		},
+
+		// Octopress image tag
+		{
+			map[any]any{},
+			"{% img http://placekitten.com/890/280 %}",
+			"{{< figure src=\"http://placekitten.com/890/280\" >}}",
+		},
+		{
+			map[any]any{},
+			"{% img left http://placekitten.com/320/250 Place Kitten #2 %}",
+			"{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}",
+		},
+		{
+			map[any]any{},
+			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #3' %}",
+			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #3\" >}}",
+		},
+		{
+			map[any]any{},
+			"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
+			"{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+		},
+		{
+			map[any]any{},
+			"{% img http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
+			"{{< figure src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+		},
+		{
+			map[any]any{},
+			"{% img right /placekitten/300/500 'Place Kitten #4' 'An image of a very cute kitten' %}",
+			"{{< figure class=\"right\" src=\"/placekitten/300/500\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+		},
+		{
+			map[any]any{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
+			"somecontent",
+			"---\nDate: \"2015-10-01 12:13:11\"\ncategory: book\nlayout: post\n---\nsomecontent",
+		},
+	}
+	for _, data := range testDataList {
+		result, err := convertJekyllContent(data.metadata, data.content)
+		c.Assert(result, qt.Equals, data.expect)
+		c.Assert(err, qt.IsNil)
+	}
+}
@@ -0,0 +1,84 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"syscall"
+
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*limitCmd)(nil)
+
+type limitCmd struct {
+	*baseCmd
+}
+
+func newLimitCmd() *limitCmd {
+	ccmd := &cobra.Command{
+		Use:   "ulimit",
+		Short: "Check system ulimit settings",
+		Long: `Hugo will inspect the current ulimit settings on the system.
+This is primarily to ensure that Hugo can watch enough files on some OSs`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			var rLimit syscall.Rlimit
+			err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+			if err != nil {
+				return newSystemError("Error Getting rlimit ", err)
+			}
+
+			jww.FEEDBACK.Println("Current rLimit:", rLimit)
+
+			if rLimit.Cur >= newRlimit {
+				return nil
+			}
+
+			jww.FEEDBACK.Println("Attempting to increase limit")
+			rLimit.Cur = newRlimit
+			err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+			if err != nil {
+				return newSystemError("Error Setting rLimit ", err)
+			}
+			err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+			if err != nil {
+				return newSystemError("Error Getting rLimit ", err)
+			}
+			jww.FEEDBACK.Println("rLimit after change:", rLimit)
+
+			return nil
+		},
+	}
+
+	return &limitCmd{baseCmd: newBaseCmd(ccmd)}
+}
+
+const newRlimit = 10240
+
+func tweakLimit() {
+	var rLimit syscall.Rlimit
+	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+	if err != nil {
+		jww.WARN.Println("Unable to get rlimit:", err)
+		return
+	}
+	if rLimit.Cur < newRlimit {
+		rLimit.Cur = newRlimit
+		err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rLimit)
+		if err != nil {
+			// This may not succeed, see https://github.com/golang/go/issues/30401
+			jww.INFO.Println("Unable to increase number of open files limit:", err)
+		}
+	}
+}
@@ -0,0 +1,21 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build !darwin
+// +build !darwin
+
+package commands
+
+func tweakLimit() {
+	// nothing to do
+}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2019 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,200 +14,197 @@
 package commands

 import (
-	"context"
 	"encoding/csv"
 	"os"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"time"

-	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/hugolib"
-	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/resources/resource"
 	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
 )

-// newListCommand creates a new list command and its subcommands.
-func newListCommand() *listCommand {
-	createRecord := func(workingDir string, p page.Page) []string {
-		return []string{
-			filepath.ToSlash(strings.TrimPrefix(p.File().Filename(), workingDir+string(os.PathSeparator))),
-			p.Slug(),
-			p.Title(),
-			p.Date().Format(time.RFC3339),
-			p.ExpiryDate().Format(time.RFC3339),
-			p.PublishDate().Format(time.RFC3339),
-			strconv.FormatBool(p.Draft()),
-			p.Permalink(),
-			p.Kind(),
-			p.Section(),
+var _ cmder = (*listCmd)(nil)
+
+type listCmd struct {
+	*baseBuilderCmd
+}
+
+func (lc *listCmd) buildSites(config map[string]any) (*hugolib.HugoSites, error) {
+	cfgInit := func(c *commandeer) error {
+		for key, value := range config {
+			c.Set(key, value)
 		}
-	}
-
-	list := func(cd *simplecobra.Commandeer, r *rootCommand, shouldInclude func(page.Page) bool, opts ...any) error {
-		bcfg := hugolib.BuildCfg{SkipRender: true}
-		cfg := flagsToCfg(cd, nil)
-		for i := 0; i < len(opts); i += 2 {
-			cfg.Set(opts[i].(string), opts[i+1])
-		}
-		h, err := r.Build(cd, bcfg, cfg)
-		if err != nil {
-			return err
-		}
-
-		writer := csv.NewWriter(r.StdOut)
-		defer writer.Flush()
-
-		writer.Write([]string{
-			"path",
-			"slug",
-			"title",
-			"date",
-			"expiryDate",
-			"publishDate",
-			"draft",
-			"permalink",
-			"kind",
-			"section",
-		})
-
-		for _, p := range h.Pages() {
-			if shouldInclude(p) {
-				record := createRecord(h.Conf.BaseConfig().WorkingDir, p)
-				if err := writer.Write(record); err != nil {
-					return err
-				}
-			}
-		}
-
 		return nil
 	}

-	return &listCommand{
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "drafts",
-				short: "List draft content",
-				long:  `List draft content.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						if !p.Draft() || p.File() == nil {
-							return false
-						}
-						return true
+	c, err := initializeConfig(true, true, false, &lc.hugoBuilderCommon, lc, cfgInit)
+	if err != nil {
+		return nil, err
+	}
+
+	sites, err := hugolib.NewHugoSites(*c.DepsCfg)
+	if err != nil {
+		return nil, newSystemError("Error creating sites", err)
+	}
+
+	if err := sites.Build(hugolib.BuildCfg{SkipRender: true}); err != nil {
+		return nil, newSystemError("Error Processing Source Content", err)
+	}
+
+	return sites, nil
+}
+
+func (b *commandsBuilder) newListCmd() *listCmd {
+	cc := &listCmd{}
+
+	cmd := &cobra.Command{
+		Use:   "list",
+		Short: "Listing out various types of content",
+		Long: `Listing out various types of content.
+
+List requires a subcommand, e.g. ` + "`hugo list drafts`.",
+		RunE: nil,
+	}
+
+	cmd.AddCommand(
+		&cobra.Command{
+			Use:   "drafts",
+			Short: "List all drafts",
+			Long:  `List all of the drafts in your content directory.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				sites, err := cc.buildSites(map[string]any{"buildDrafts": true})
+				if err != nil {
+					return newSystemError("Error building sites", err)
+				}
+
+				for _, p := range sites.Pages() {
+					if p.Draft() {
+						jww.FEEDBACK.Println(strings.TrimPrefix(p.File().Filename(), sites.WorkingDir+string(os.PathSeparator)))
 					}
-					return list(cd, r, shouldInclude,
-						"buildDrafts", true,
-						"buildFuture", true,
-						"buildExpired", true,
-					)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "future",
-				short: "List future content",
-				long:  `List content with a future publication date.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						if !resource.IsFuture(p) || p.File() == nil {
-							return false
-						}
-						return true
-					}
-					return list(cd, r, shouldInclude,
-						"buildFuture", true,
-						"buildDrafts", true,
-					)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "expired",
-				short: "List expired content",
-				long:  `List content with a past expiration date.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						if !resource.IsExpired(p) || p.File() == nil {
-							return false
-						}
-						return true
-					}
-					return list(cd, r, shouldInclude,
-						"buildExpired", true,
-						"buildDrafts", true,
-					)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "all",
-				short: "List all content",
-				long:  `List all content including draft, future, and expired.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						return p.File() != nil
-					}
-					return list(cd, r, shouldInclude, "buildDrafts", true, "buildFuture", true, "buildExpired", true)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-			},
-			&simpleCommand{
-				name:  "published",
-				short: "List published content",
-				long:  `List content that is not draft, future, or expired.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					shouldInclude := func(p page.Page) bool {
-						return !p.Draft() && !resource.IsFuture(p) && !resource.IsExpired(p) && p.File() != nil
-					}
-					return list(cd, r, shouldInclude)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
+				}
+
+				return nil
 			},
 		},
-	}
-}
-
-type listCommand struct {
-	commands []simplecobra.Commander
-}
-
-func (c *listCommand) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *listCommand) Name() string {
-	return "list"
-}
-
-func (c *listCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	// Do nothing.
-	return nil
-}
-
-func (c *listCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "List content"
-	cmd.Long = `List content.
-
-List requires a subcommand, e.g. hugo list drafts`
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *listCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	return nil
+		&cobra.Command{
+			Use:   "future",
+			Short: "List all posts dated in the future",
+			Long:  `List all of the posts in your content directory which will be posted in the future.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				sites, err := cc.buildSites(map[string]any{"buildFuture": true})
+				if err != nil {
+					return newSystemError("Error building sites", err)
+				}
+
+				if err != nil {
+					return newSystemError("Error building sites", err)
+				}
+
+				writer := csv.NewWriter(os.Stdout)
+				defer writer.Flush()
+
+				for _, p := range sites.Pages() {
+					if resource.IsFuture(p) {
+						err := writer.Write([]string{
+							strings.TrimPrefix(p.File().Filename(), sites.WorkingDir+string(os.PathSeparator)),
+							p.PublishDate().Format(time.RFC3339),
+						})
+						if err != nil {
+							return newSystemError("Error writing future posts to stdout", err)
+						}
+					}
+				}
+
+				return nil
+			},
+		},
+		&cobra.Command{
+			Use:   "expired",
+			Short: "List all posts already expired",
+			Long:  `List all of the posts in your content directory which has already expired.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				sites, err := cc.buildSites(map[string]any{"buildExpired": true})
+				if err != nil {
+					return newSystemError("Error building sites", err)
+				}
+
+				if err != nil {
+					return newSystemError("Error building sites", err)
+				}
+
+				writer := csv.NewWriter(os.Stdout)
+				defer writer.Flush()
+
+				for _, p := range sites.Pages() {
+					if resource.IsExpired(p) {
+						err := writer.Write([]string{
+							strings.TrimPrefix(p.File().Filename(), sites.WorkingDir+string(os.PathSeparator)),
+							p.ExpiryDate().Format(time.RFC3339),
+						})
+						if err != nil {
+							return newSystemError("Error writing expired posts to stdout", err)
+						}
+					}
+				}
+
+				return nil
+			},
+		},
+		&cobra.Command{
+			Use:   "all",
+			Short: "List all posts",
+			Long:  `List all of the posts in your content directory, include drafts, future and expired pages.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				sites, err := cc.buildSites(map[string]any{
+					"buildExpired": true,
+					"buildDrafts":  true,
+					"buildFuture":  true,
+				})
+				if err != nil {
+					return newSystemError("Error building sites", err)
+				}
+
+				writer := csv.NewWriter(os.Stdout)
+				defer writer.Flush()
+
+				writer.Write([]string{
+					"path",
+					"slug",
+					"title",
+					"date",
+					"expiryDate",
+					"publishDate",
+					"draft",
+					"permalink",
+				})
+				for _, p := range sites.Pages() {
+					if !p.IsPage() {
+						continue
+					}
+					err := writer.Write([]string{
+						strings.TrimPrefix(p.File().Filename(), sites.WorkingDir+string(os.PathSeparator)),
+						p.Slug(),
+						p.Title(),
+						p.Date().Format(time.RFC3339),
+						p.ExpiryDate().Format(time.RFC3339),
+						p.PublishDate().Format(time.RFC3339),
+						strconv.FormatBool(p.Draft()),
+						p.Permalink(),
+					})
+					if err != nil {
+						return newSystemError("Error writing posts to stdout", err)
+					}
+				}
+
+				return nil
+			},
+		},
+	)
+
+	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
+
+	return cc
 }
@@ -0,0 +1,68 @@
+package commands
+
+import (
+	"bytes"
+	"encoding/csv"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func captureStdout(f func() error) (string, error) {
+	old := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	err := f()
+
+	w.Close()
+	os.Stdout = old
+
+	var buf bytes.Buffer
+	io.Copy(&buf, r)
+	return buf.String(), err
+}
+
+func TestListAll(t *testing.T) {
+	c := qt.New(t)
+	dir := createSimpleTestSite(t, testSiteConfig{})
+
+	hugoCmd := newCommandsBuilder().addAll().build()
+	cmd := hugoCmd.getCommand()
+
+	t.Cleanup(func() {
+		os.RemoveAll(dir)
+	})
+
+	cmd.SetArgs([]string{"-s=" + dir, "list", "all"})
+
+	out, err := captureStdout(func() error {
+		_, err := cmd.ExecuteC()
+		return err
+	})
+	c.Assert(err, qt.IsNil)
+
+	r := csv.NewReader(strings.NewReader(out))
+
+	header, err := r.Read()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(header, qt.DeepEquals, []string{
+		"path", "slug", "title",
+		"date", "expiryDate", "publishDate",
+		"draft", "permalink",
+	})
+
+	record, err := r.Read()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(record, qt.DeepEquals, []string{
+		filepath.Join("content", "p1.md"), "", "P1",
+		"0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z",
+		"false", "https://example.org/p1/",
+	})
+}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2020 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,20 +14,88 @@
 package commands

 import (
-	"context"
 	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"

-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/hugolib"
-	"github.com/gohugoio/hugo/modules/npm"
+
+	"github.com/gohugoio/hugo/modules"
 	"github.com/spf13/cobra"
 )

-const commonUsageMod = `
-Note that Hugo will always start out by resolving the components defined in the project
+var _ cmder = (*modCmd)(nil)
+
+type modCmd struct {
+	*baseBuilderCmd
+}
+
+func (c *modCmd) newVerifyCmd() *cobra.Command {
+	var clean bool
+
+	verifyCmd := &cobra.Command{
+		Use:   "verify",
+		Short: "Verify dependencies.",
+		Long: `Verify checks that the dependencies of the current module, which are stored in a local downloaded source cache, have not been modified since being downloaded.
+`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return c.withModsClient(true, func(c *modules.Client) error {
+				return c.Verify(clean)
+			})
+		},
+	}
+
+	verifyCmd.Flags().BoolVarP(&clean, "clean", "", false, "delete module cache for dependencies that fail verification")
+
+	return verifyCmd
+}
+
+var moduleNotFoundRe = regexp.MustCompile("module.*not found")
+
+func (c *modCmd) newCleanCmd() *cobra.Command {
+	var pattern string
+	var all bool
+	cmd := &cobra.Command{
+		Use:   "clean",
+		Short: "Delete the Hugo Module cache for the current project.",
+		Long: `Delete the Hugo Module cache for the current project.
+
+Note that after you run this command, all of your dependencies will be re-downloaded next time you run "hugo".
+
+Also note that if you configure a positive maxAge for the "modules" file cache, it will also be cleaned as part of "hugo --gc".
+ 
+`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if all {
+				com, err := c.initConfig(false)
+
+				if err != nil && com == nil {
+					return err
+				}
+
+				count, err := com.hugo().FileCaches.ModulesCache().Prune(true)
+				com.logger.Printf("Deleted %d files from module cache.", count)
+				return err
+			}
+			return c.withModsClient(true, func(c *modules.Client) error {
+				return c.Clean(pattern)
+			})
+		},
+	}
+
+	cmd.Flags().StringVarP(&pattern, "pattern", "", "", `pattern matching module paths to clean (all if not set), e.g. "**hugo*"`)
+	cmd.Flags().BoolVarP(&all, "all", "", false, "clean entire module cache")
+
+	return cmd
+}
+
+func (b *commandsBuilder) newModCmd() *modCmd {
+	c := &modCmd{}
+
+	const commonUsage = `
+Note that Hugo will always start out by resolving the components defined in the site
 configuration, provided by a _vendor directory (if no --ignoreVendorPaths flag provided),
 Go Modules, or a folder inside the themes directory, in that order.

@@ -35,320 +103,191 @@ See https://gohugo.io/hugo-modules/ for more information.

 `

-// buildConfigCommands creates a new config command and its subcommands.
-func newModCommands() *modCommands {
-	var (
-		clean   bool
-		pattern string
-		all     bool
-	)
+	cmd := &cobra.Command{
+		Use:   "mod",
+		Short: "Various Hugo Modules helpers.",
+		Long: `Various helpers to help manage the modules in your project's dependency graph.

-	npmCommand := &simpleCommand{
-		name:  "npm",
-		short: "Various npm helpers",
-		long:  `Various npm (Node package manager) helpers.`,
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "pack",
-				short: "Merges module Node.js dependencies into an npm workspace",
-				long: `Merges Node.js dependencies from all Hugo modules into a "packages/hugoautogen" npm workspace.
+Most operations here requires a Go version installed on your system (>= Go 1.12) and the relevant VCS client (typically Git).
+This is not needed if you only operate on modules inside /themes or if you have vendored them via "hugo mod vendor".

-The merged dependencies are written to packages/hugoautogen/package.json, and the root package.json
-is updated with a "workspaces" entry pointing to "packages/hugoautogen".
+` + commonUsage,

-The source entries are read from either package.hugo.json or package.json in the module root, with package.hugo.json taking precedence if both exist.
-
-See [Node.js dependencies](/hugo-modules/nodejs-dependencies/) for more information.
-`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					cfg := flagsToCfg(cd, nil)
-					k := configKey{counter: r.configVersionID.Load(), skipNpmCheck: true}
-					h, _, err := r.hugoSites.GetOrCreate(k, func(key configKey) (*hugolib.HugoSites, error) {
-						conf, err := r.ConfigFromProvider(key, cfg)
-						if err != nil {
-							return nil, err
-						}
-						return hugolib.NewHugoSites(r.newDepsConfig(conf))
-					})
-					if err != nil {
-						return err
-					}
-					return npm.Pack(h.BaseFs.ProjectSourceFs, h.BaseFs.AssetsWithDuplicatesPreserved.Fs, h.Configs.Modules)
-				},
-			},
-		},
+		RunE: nil,
 	}

-	return &modCommands{
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "init",
-				short: "Initialize this project as a Hugo Module",
-				long: `Initialize this project as a Hugo Module.
-	It will try to guess the module path, but you may help by passing it as an argument, e.g:
+	cmd.AddCommand(newModNPMCmd(c))

-		hugo mod init github.com/gohugoio/testshortcodes
-
-	Note that Hugo Modules supports multi-module projects, so you can initialize a Hugo Module
-	inside a subfolder on GitHub, as one example.
-	`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.getOrCreateHugo(flagsToCfg(cd, nil), true)
-					if err != nil {
-						return err
-					}
-					var initPath string
-					if len(args) >= 1 {
-						initPath = args[0]
-					}
-					c := h.Configs.ModulesClient
-					if err := c.Init(initPath); err != nil {
-						return err
-					}
-					return nil
-				},
-			},
-			&simpleCommand{
-				name:  "verify",
-				short: "Verify dependencies",
-				long:  `Verify checks that the dependencies of the current module, which are stored in a local downloaded source cache, have not been modified since being downloaded.`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-					cmd.Flags().BoolVarP(&clean, "clean", "", false, "delete module cache for dependencies that fail verification")
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					client := conf.configs.ModulesClient
-					return client.Verify(clean)
-				},
-			},
-			&simpleCommand{
-				name:  "graph",
-				short: "Print a module dependency graph",
-				long: `Print a module dependency graph with information about module status (disabled, vendored).
-Note that for vendored modules, that is the version listed and not the one from go.mod.
-`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-					cmd.Flags().BoolVarP(&clean, "clean", "", false, "delete module cache for dependencies that fail verification")
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					client := conf.configs.ModulesClient
-					return client.Graph(os.Stdout)
-				},
-			},
-			&simpleCommand{
-				name:  "clean",
-				short: "Delete the Hugo Module cache for the current project",
-				long:  `Delete the Hugo Module cache for the current project.`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-					cmd.Flags().StringVarP(&pattern, "pattern", "", "", `pattern matching module paths to clean (all if not set), e.g. "**hugo*"`)
-					_ = cmd.RegisterFlagCompletionFunc("pattern", cobra.NoFileCompletions)
-					cmd.Flags().BoolVarP(&all, "all", "", false, "clean entire module cache")
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.Hugo(flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					if all {
-						modCache := h.ResourceSpec.FileCaches.ModulesCache()
-						count, err := modCache.Prune(true)
-						r.Printf("Deleted %d directories from module cache.", count)
-						return err
-					}
-
-					return h.Configs.ModulesClient.Clean(pattern)
-				},
-			},
-			&simpleCommand{
-				name:  "tidy",
-				short: "Remove unused entries in go.mod and go.sum",
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.Hugo(flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					return h.Configs.ModulesClient.Tidy()
-				},
-			},
-			&simpleCommand{
-				name:  "vendor",
-				short: "Vendor all module dependencies into the _vendor directory",
-				long: `Vendor all module dependencies into the _vendor directory.
-	If a module is vendored, that is where Hugo will look for it's dependencies.
-	`,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					h, err := r.Hugo(flagsToCfg(cd, nil))
-					if err != nil {
-						return err
-					}
-					return h.Configs.ModulesClient.Vendor()
-				},
-			},
-
-			&simpleCommand{
-				name:  "get",
-				short: "Resolves dependencies in your current Hugo project",
-				long: `
-Resolves dependencies in your current Hugo project.
+	cmd.AddCommand(
+		&cobra.Command{
+			Use:                "get",
+			DisableFlagParsing: true,
+			Short:              "Resolves dependencies in your current Hugo Project.",
+			Long: `
+Resolves dependencies in your current Hugo Project.

 Some examples:

 Install the latest version possible for a given module:

    hugo mod get github.com/gohugoio/testshortcodes
-
+    
 Install a specific version:

    hugo mod get github.com/gohugoio/testshortcodes@v0.3.0

-Install the latest versions of all direct module dependencies:
-
-    hugo mod get
-    hugo mod get ./... (recursive)
-
-Install the latest versions of all module dependencies (direct and indirect):
+Install the latest versions of all module dependencies:

    hugo mod get -u
    hugo mod get -u ./... (recursive)

 Run "go help get" for more information. All flags available for "go get" is also relevant here.
-` + commonUsageMod,
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.DisableFlagParsing = true
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					// We currently just pass on the flags we get to Go and
-					// need to do the flag handling manually.
-					if len(args) == 1 && (args[0] == "-h" || args[0] == "--help") {
-						return errHelp
+` + commonUsage,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				// We currently just pass on the flags we get to Go and
+				// need to do the flag handling manually.
+				if len(args) == 1 && args[0] == "-h" {
+					return cmd.Help()
+				}
+
+				var lastArg string
+				if len(args) != 0 {
+					lastArg = args[len(args)-1]
+				}
+
+				if lastArg == "./..." {
+					args = args[:len(args)-1]
+					// Do a recursive update.
+					dirname, err := os.Getwd()
+					if err != nil {
+						return err
 					}

-					var lastArg string
-					if len(args) != 0 {
-						lastArg = args[len(args)-1]
+					// Sanity check. We do recursive walking and want to avoid
+					// accidents.
+					if len(dirname) < 5 {
+						return errors.New("must not be run from the file system root")
 					}

-					if lastArg == "./..." {
-						args = args[:len(args)-1]
-						// Do a recursive update.
-						dirname, err := os.Getwd()
-						if err != nil {
-							return err
-						}
-
-						// Sanity chesimplecobra. We do recursive walking and want to avoid
-						// accidents.
-						if len(dirname) < 5 {
-							return errors.New("must not be run from the file system root")
-						}
-
-						filepath.Walk(dirname, func(path string, info os.FileInfo, err error) error {
-							if info.IsDir() {
-								return nil
-							}
-							if info.Name() == "go.mod" {
-								// Found a module.
-								dir := filepath.Dir(path)
-
-								cfg := config.New()
-								cfg.Set("workingDir", dir)
-								conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Add(1)}, flagsToCfg(cd, cfg))
-								if err != nil {
-									return err
-								}
-								r.Println("Update module in", conf.configs.Base.WorkingDir)
-								client := conf.configs.ModulesClient
-								return client.Get(args...)
-
-							}
+					filepath.Walk(dirname, func(path string, info os.FileInfo, err error) error {
+						if info.IsDir() {
 							return nil
-						})
-						return nil
-					} else {
-						conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, nil))
-						if err != nil {
-							return err
 						}
-						client := conf.configs.ModulesClient
-						if err := client.Get(args...); err != nil {
-							return err
+
+						if info.Name() == "go.mod" {
+							// Found a module.
+							dir := filepath.Dir(path)
+							fmt.Println("Update module in", dir)
+							c.source = dir
+							err := c.withModsClient(false, func(c *modules.Client) error {
+								if len(args) == 1 && args[0] == "-h" {
+									return cmd.Help()
+								}
+								return c.Get(args...)
+							})
+							if err != nil {
+								return err
+							}
+
 						}
+
 						return nil
-					}
-				},
+					})
+
+					return nil
+				}
+
+				return c.withModsClient(false, func(c *modules.Client) error {
+					return c.Get(args...)
+				})
 			},
-			npmCommand,
 		},
-	}
+		&cobra.Command{
+			Use:   "graph",
+			Short: "Print a module dependency graph.",
+			Long: `Print a module dependency graph with information about module status (disabled, vendored).
+Note that for vendored modules, that is the version listed and not the one from go.mod.
+`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return c.withModsClient(true, func(c *modules.Client) error {
+					return c.Graph(os.Stdout)
+				})
+			},
+		},
+		&cobra.Command{
+			Use:   "init",
+			Short: "Initialize this project as a Hugo Module.",
+			Long: `Initialize this project as a Hugo Module.
+It will try to guess the module path, but you may help by passing it as an argument, e.g:
+
+    hugo mod init github.com/gohugoio/testshortcodes
+
+Note that Hugo Modules supports multi-module projects, so you can initialize a Hugo Module
+inside a subfolder on GitHub, as one example.
+`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				var path string
+				if len(args) >= 1 {
+					path = args[0]
+				}
+				return c.withModsClient(false, func(c *modules.Client) error {
+					return c.Init(path)
+				})
+			},
+		},
+		&cobra.Command{
+			Use:   "vendor",
+			Short: "Vendor all module dependencies into the _vendor directory.",
+			Long: `Vendor all module dependencies into the _vendor directory.
+
+If a module is vendored, that is where Hugo will look for it's dependencies.
+`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return c.withModsClient(true, func(c *modules.Client) error {
+					return c.Vendor()
+				})
+			},
+		},
+		c.newVerifyCmd(),
+		&cobra.Command{
+			Use:   "tidy",
+			Short: "Remove unused entries in go.mod and go.sum.",
+			RunE: func(cmd *cobra.Command, args []string) error {
+				return c.withModsClient(true, func(c *modules.Client) error {
+					return c.Tidy()
+				})
+			},
+		},
+		c.newCleanCmd(),
+	)
+
+	c.baseBuilderCmd = b.newBuilderCmd(cmd)
+
+	return c
 }

-type modCommands struct {
-	r *rootCommand
-
-	commands []simplecobra.Commander
-}
-
-func (c *modCommands) Commands() []simplecobra.Commander {
-	return c.commands
-}
-
-func (c *modCommands) Name() string {
-	return "mod"
-}
-
-func (c *modCommands) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	_, err := c.r.ConfigFromProvider(configKey{counter: c.r.configVersionID.Load()}, nil)
+func (c *modCmd) withModsClient(failOnMissingConfig bool, f func(*modules.Client) error) error {
+	com, err := c.initConfig(failOnMissingConfig)
 	if err != nil {
 		return err
 	}
-	// config := conf.configs.Base

-	return nil
+	return f(com.hugo().ModulesClient)
 }

-func (c *modCommands) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Manage modules"
-	cmd.Long = `Various helpers to help manage the modules in your project's dependency graph.
-Most operations here requires a Go version installed on your system (>= Go 1.12) and the relevant VCS client (typically Git).
-This is not needed if you only operate on modules inside /themes or if you have vendored them via "hugo mod vendor".
+func (c *modCmd) withHugo(f func(*hugolib.HugoSites) error) error {
+	com, err := c.initConfig(true)
+	if err != nil {
+		return err
+	}

-` + commonUsageMod
-	cmd.RunE = nil
-	return nil
+	return f(com.hugo())
 }

-func (c *modCommands) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.r = cd.Root.Command.(*rootCommand)
-	return nil
+func (c *modCmd) initConfig(failOnNoConfig bool) (*commandeer, error) {
+	com, err := initializeConfig(failOnNoConfig, false, false, &c.hugoBuilderCommon, c, nil)
+	if err != nil {
+		return nil, err
+	}
+	return com, nil
 }
@@ -0,0 +1,56 @@
+// Copyright 2020 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/modules/npm"
+	"github.com/spf13/cobra"
+)
+
+func newModNPMCmd(c *modCmd) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "npm",
+		Short: "Various npm helpers.",
+		Long:  `Various npm (Node package manager) helpers.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return c.withHugo(func(h *hugolib.HugoSites) error {
+				return nil
+			})
+		},
+	}
+
+	cmd.AddCommand(&cobra.Command{
+		Use:   "pack",
+		Short: "Experimental: Prepares and writes a composite package.json file for your project.",
+		Long: `Prepares and writes a composite package.json file for your project.
+
+On first run it creates a "package.hugo.json" in the project root if not already there. This file will be used as a template file
+with the base dependency set. 
+
+This set will be merged with all "package.hugo.json" files found in the dependency tree, picking the version closest to the project.
+
+This command is marked as 'Experimental'. We think it's a great idea, so it's not likely to be
+removed from Hugo, but we need to test this out in "real life" to get a feel of it,
+so this may/will change in future versions of Hugo.
+`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return c.withHugo(func(h *hugolib.HugoSites) error {
+				return npm.Pack(h.BaseFs.SourceFs, h.BaseFs.Assets.Dirs)
+			})
+		},
+	})
+
+	return cmd
+}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,216 +15,112 @@ package commands

 import (
 	"bytes"
-	"context"
+	"os"
 	"path/filepath"
 	"strings"

-	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/paths"
-	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/create"
-	"github.com/gohugoio/hugo/create/skeletons"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
 )

-func newNewCommand() *newCommand {
-	var (
-		force       bool
-		contentType string
-		format      string
-	)
+var _ cmder = (*newCmd)(nil)

-	var c *newCommand
-	c = &newCommand{
-		commands: []simplecobra.Commander{
-			&simpleCommand{
-				name:  "content",
-				use:   "content [path]",
-				short: "Create new content",
-				long: `Create a new content file and automatically set the date and title.
+type newCmd struct {
+	contentEditor string
+	contentType   string
+
+	*baseBuilderCmd
+}
+
+func (b *commandsBuilder) newNewCmd() *newCmd {
+	cmd := &cobra.Command{
+		Use:   "new [path]",
+		Short: "Create new content for your site",
+		Long: `Create a new content file and automatically set the date and title.
 It will guess which kind of file to create based on the path provided.

 You can also specify the kind with ` + "`-k KIND`" + `.

-If archetypes are provided in your theme or project, they will be used.
+If archetypes are provided in your theme or site, they will be used.

-Ensure you run this within the root directory of your project.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					if len(args) < 1 {
-						return newUserError("path needs to be provided")
-					}
-					cfg := flagsToCfg(cd, nil)
-					cfg.Set("BuildFuture", true)
-					h, err := r.Hugo(cfg)
-					if err != nil {
-						return err
-					}
-					return create.NewContent(h, contentType, args[0], force)
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-						if len(args) != 0 {
-							return []string{}, cobra.ShellCompDirectiveNoFileComp
-						}
-						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
-					}
-					cmd.Flags().StringVarP(&contentType, "kind", "k", "", "content type to create")
-					cmd.Flags().String("editor", "", "edit new content with this editor, if provided")
-					_ = cmd.RegisterFlagCompletionFunc("editor", cobra.NoFileCompletions)
-					cmd.Flags().BoolVarP(&force, "force", "f", false, "overwrite file if it already exists")
-					applyLocalFlagsBuildConfig(cmd, r)
-				},
-			},
-			&simpleCommand{
-				name:    "project",
-				use:     "project [path]",
-				short:   "Create a new project",
-				long:    `Create a new project at the specified path.`,
-				aliases: []string{"site"},
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					if len(args) < 1 {
-						return newUserError("path needs to be provided")
-					}
-					createpath, err := filepath.Abs(filepath.Clean(args[0]))
-					if err != nil {
-						return err
-					}
-
-					cfg := config.New()
-					cfg.Set("workingDir", createpath)
-					cfg.Set("publishDir", "public")
-
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, cfg))
-					if err != nil {
-						return err
-					}
-					sourceFs := conf.fs.Source
-
-					err = skeletons.CreateProject(createpath, sourceFs, force, format)
-					if err != nil {
-						return err
-					}
-
-					r.Printf("Congratulations! Your new Hugo project was created in %s.\n\n", createpath)
-					r.Println(c.newProjectNextStepsText(createpath, format))
-
-					return nil
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-						if len(args) != 0 {
-							return []string{}, cobra.ShellCompDirectiveNoFileComp
-						}
-						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
-					}
-					cmd.Flags().BoolVarP(&force, "force", "f", false, "init inside non-empty directory")
-					cmd.Flags().StringVar(&format, "format", "toml", "preferred file format (toml, yaml or json)")
-					_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
-				},
-			},
-			&simpleCommand{
-				name:  "theme",
-				use:   "theme [name]",
-				short: "Create a new theme",
-				long: `Create a new theme with the specified name in the ./themes directory.
-This generates a functional theme including template examples and sample content.`,
-				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-					if len(args) < 1 {
-						return newUserError("theme name needs to be provided")
-					}
-					cfg := config.New()
-					cfg.Set("publishDir", "public")
-
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, cfg))
-					if err != nil {
-						return err
-					}
-					sourceFs := conf.fs.Source
-					createpath := paths.AbsPathify(conf.configs.Base.WorkingDir, filepath.Join(conf.configs.Base.ThemesDir, args[0]))
-					r.Println("Creating new theme in", createpath)
-
-					err = skeletons.CreateTheme(createpath, sourceFs, format)
-					if err != nil {
-						return err
-					}
-
-					return nil
-				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-						if len(args) != 0 {
-							return []string{}, cobra.ShellCompDirectiveNoFileComp
-						}
-						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
-					}
-					cmd.Flags().StringVar(&format, "format", "toml", "preferred file format (toml, yaml or json)")
-					_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
-				},
-			},
-		},
+Ensure you run this within the root directory of your site.`,
 	}

-	return c
+	cc := &newCmd{baseBuilderCmd: b.newBuilderCmd(cmd)}
+
+	cmd.Flags().StringVarP(&cc.contentType, "kind", "k", "", "content type to create")
+	cmd.Flags().StringVar(&cc.contentEditor, "editor", "", "edit new content with this editor, if provided")
+
+	cmd.AddCommand(b.newNewSiteCmd().getCommand())
+	cmd.AddCommand(b.newNewThemeCmd().getCommand())
+
+	cmd.RunE = cc.newContent
+
+	return cc
 }

-type newCommand struct {
-	rootCmd *rootCommand
+func (n *newCmd) newContent(cmd *cobra.Command, args []string) error {
+	cfgInit := func(c *commandeer) error {
+		if cmd.Flags().Changed("editor") {
+			c.Set("newContentEditor", n.contentEditor)
+		}
+		return nil
+	}

-	commands []simplecobra.Commander
+	c, err := initializeConfig(true, true, false, &n.hugoBuilderCommon, n, cfgInit)
+	if err != nil {
+		return err
+	}
+
+	if len(args) < 1 {
+		return newUserError("path needs to be provided")
+	}
+
+	return create.NewContent(c.hugo(), n.contentType, args[0])
 }

-func (c *newCommand) Commands() []simplecobra.Commander {
-	return c.commands
+func mkdir(x ...string) {
+	p := filepath.Join(x...)
+
+	err := os.MkdirAll(p, 0777) // before umask
+	if err != nil {
+		jww.FATAL.Fatalln(err)
+	}
 }

-func (c *newCommand) Name() string {
-	return "new"
+func touchFile(fs afero.Fs, x ...string) {
+	inpath := filepath.Join(x...)
+	mkdir(filepath.Dir(inpath))
+	err := helpers.WriteToDisk(inpath, bytes.NewReader([]byte{}), fs)
+	if err != nil {
+		jww.FATAL.Fatalln(err)
+	}
 }

-func (c *newCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	return nil
-}
-
-func (c *newCommand) Init(cd *simplecobra.Commandeer) error {
-	cmd := cd.CobraCommand
-	cmd.Short = "Create new content"
-	cmd.Long = `Create a new content file and automatically set the date and title.
-It will guess which kind of file to create based on the path provided.
-
-You can also specify the kind with ` + "`-k KIND`" + `.
-
-If archetypes are provided in your theme or project, they will be used.
-
-Ensure you run this within the root directory of your project.`
-
-	cmd.RunE = nil
-	return nil
-}
-
-func (c *newCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	c.rootCmd = cd.Root.Command.(*rootCommand)
-	return nil
-}
-
-func (c *newCommand) newProjectNextStepsText(path string, format string) string {
-	format = strings.ToLower(format)
-	var nextStepsText bytes.Buffer
-
-	nextStepsText.WriteString(`Just a few more steps...
-
-1. Change the current directory to ` + path + `.
-2. Create or install a theme:
-   - Create a new theme with the command "hugo new theme <THEMENAME>"
-   - Or, install a theme from https://themes.gohugo.io/
-3. Edit hugo.` + format + `, setting the "theme" property to the theme name.
-4. Create new content with the command "hugo new content `)
-
-	nextStepsText.WriteString(filepath.Join("<SECTIONNAME>", "<FILENAME>.<FORMAT>"))
-
-	nextStepsText.WriteString(`".
-5. Start the embedded web server with the command "hugo server --buildDrafts".
-
-See documentation at https://gohugo.io/.`)
-
-	return nextStepsText.String()
+func newContentPathSection(h *hugolib.HugoSites, path string) (string, string) {
+	// Forward slashes is used in all examples. Convert if needed.
+	// Issue #1133
+	createpath := filepath.FromSlash(path)
+
+	if h != nil {
+		for _, dir := range h.BaseFs.Content.Dirs {
+			createpath = strings.TrimPrefix(createpath, dir.Meta().Filename)
+		}
+	}
+
+	var section string
+	// assume the first directory is the section (kind)
+	if strings.Contains(createpath[1:], helpers.FilePathSeparator) {
+		parts := strings.Split(strings.TrimPrefix(createpath, helpers.FilePathSeparator), helpers.FilePathSeparator)
+		if len(parts) > 0 {
+			section = parts[0]
+		}
+
+	}
+
+	return createpath, section
 }
@@ -0,0 +1,29 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"path/filepath"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+// Issue #1133
+func TestNewContentPathSectionWithForwardSlashes(t *testing.T) {
+	c := qt.New(t)
+	p, s := newContentPathSection(nil, "/post/new.md")
+	c.Assert(p, qt.Equals, filepath.FromSlash("/post/new.md"))
+	c.Assert(s, qt.Equals, "post")
+}
@@ -0,0 +1,165 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/parser/metadecoders"
+
+	"github.com/gohugoio/hugo/create"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/parser"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*newSiteCmd)(nil)
+
+type newSiteCmd struct {
+	configFormat string
+
+	*baseBuilderCmd
+}
+
+func (b *commandsBuilder) newNewSiteCmd() *newSiteCmd {
+	cc := &newSiteCmd{}
+
+	cmd := &cobra.Command{
+		Use:   "site [path]",
+		Short: "Create a new site (skeleton)",
+		Long: `Create a new site in the provided directory.
+The new site will have the correct structure, but no content or theme yet.
+Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
+		RunE: cc.newSite,
+	}
+
+	cmd.Flags().StringVarP(&cc.configFormat, "format", "f", "toml", "config file format")
+	cmd.Flags().Bool("force", false, "init inside non-empty directory")
+
+	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
+
+	return cc
+}
+
+func (n *newSiteCmd) doNewSite(fs *hugofs.Fs, basepath string, force bool) error {
+	archeTypePath := filepath.Join(basepath, "archetypes")
+	dirs := []string{
+		filepath.Join(basepath, "layouts"),
+		filepath.Join(basepath, "content"),
+		archeTypePath,
+		filepath.Join(basepath, "static"),
+		filepath.Join(basepath, "data"),
+		filepath.Join(basepath, "themes"),
+	}
+
+	if exists, _ := helpers.Exists(basepath, fs.Source); exists {
+		if isDir, _ := helpers.IsDir(basepath, fs.Source); !isDir {
+			return errors.New(basepath + " already exists but not a directory")
+		}
+
+		isEmpty, _ := helpers.IsEmpty(basepath, fs.Source)
+
+		switch {
+		case !isEmpty && !force:
+			return errors.New(basepath + " already exists and is not empty. See --force.")
+
+		case !isEmpty && force:
+			all := append(dirs, filepath.Join(basepath, "config."+n.configFormat))
+			for _, path := range all {
+				if exists, _ := helpers.Exists(path, fs.Source); exists {
+					return errors.New(path + " already exists")
+				}
+			}
+		}
+	}
+
+	for _, dir := range dirs {
+		if err := fs.Source.MkdirAll(dir, 0777); err != nil {
+			return fmt.Errorf("Failed to create dir: %w", err)
+		}
+	}
+
+	createConfig(fs, basepath, n.configFormat)
+
+	// Create a default archetype file.
+	helpers.SafeWriteToDisk(filepath.Join(archeTypePath, "default.md"),
+		strings.NewReader(create.DefaultArchetypeTemplateTemplate), fs.Source)
+
+	jww.FEEDBACK.Printf("Congratulations! Your new Hugo site is created in %s.\n\n", basepath)
+	jww.FEEDBACK.Println(nextStepsText())
+
+	return nil
+}
+
+// newSite creates a new Hugo site and initializes a structured Hugo directory.
+func (n *newSiteCmd) newSite(cmd *cobra.Command, args []string) error {
+	if len(args) < 1 {
+		return newUserError("path needs to be provided")
+	}
+
+	createpath, err := filepath.Abs(filepath.Clean(args[0]))
+	if err != nil {
+		return newUserError(err)
+	}
+
+	forceNew, _ := cmd.Flags().GetBool("force")
+	cfg := config.New()
+	cfg.Set("workingDir", createpath)
+	cfg.Set("publishDir", "public")
+	return n.doNewSite(hugofs.NewDefault(cfg), createpath, forceNew)
+}
+
+func createConfig(fs *hugofs.Fs, inpath string, kind string) (err error) {
+	in := map[string]string{
+		"baseURL":      "http://example.org/",
+		"title":        "My New Hugo Site",
+		"languageCode": "en-us",
+	}
+
+	var buf bytes.Buffer
+	err = parser.InterfaceToConfig(in, metadecoders.FormatFromString(kind), &buf)
+	if err != nil {
+		return err
+	}
+
+	return helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), &buf, fs.Source)
+}
+
+func nextStepsText() string {
+	var nextStepsText bytes.Buffer
+
+	nextStepsText.WriteString(`Just a few more steps and you're ready to go:
+
+1. Download a theme into the same-named folder.
+   Choose a theme from https://themes.gohugo.io/ or
+   create your own with the "hugo new theme <THEMENAME>" command.
+2. Perhaps you want to add some content. You can add single files
+   with "hugo new `)
+
+	nextStepsText.WriteString(filepath.Join("<SECTIONNAME>", "<FILENAME>.<FORMAT>"))
+
+	nextStepsText.WriteString(`".
+3. Start the built-in live server via "hugo server".
+
+Visit https://gohugo.io/ for quickstart guide and full documentation.`)
+
+	return nextStepsText.String()
+}
@@ -0,0 +1,176 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"errors"
+	"path/filepath"
+	"strings"
+
+	"github.com/gohugoio/hugo/common/htime"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*newThemeCmd)(nil)
+
+type newThemeCmd struct {
+	*baseBuilderCmd
+}
+
+func (b *commandsBuilder) newNewThemeCmd() *newThemeCmd {
+	cc := &newThemeCmd{}
+
+	cmd := &cobra.Command{
+		Use:   "theme [name]",
+		Short: "Create a new theme",
+		Long: `Create a new theme (skeleton) called [name] in ./themes.
+New theme is a skeleton. Please add content to the touched files. Add your
+name to the copyright line in the license and adjust the theme.toml file
+as you see fit.`,
+		RunE: cc.newTheme,
+	}
+
+	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
+
+	return cc
+}
+
+// newTheme creates a new Hugo theme template
+func (n *newThemeCmd) newTheme(cmd *cobra.Command, args []string) error {
+	c, err := initializeConfig(false, false, false, &n.hugoBuilderCommon, n, nil)
+	if err != nil {
+		return err
+	}
+
+	if len(args) < 1 {
+		return newUserError("theme name needs to be provided")
+	}
+
+	createpath := c.hugo().PathSpec.AbsPathify(filepath.Join(c.Cfg.GetString("themesDir"), args[0]))
+	jww.FEEDBACK.Println("Creating theme at", createpath)
+
+	cfg := c.DepsCfg
+
+	if x, _ := helpers.Exists(createpath, cfg.Fs.Source); x {
+		return errors.New(createpath + " already exists")
+	}
+
+	mkdir(createpath, "layouts", "_default")
+	mkdir(createpath, "layouts", "partials")
+
+	touchFile(cfg.Fs.Source, createpath, "layouts", "index.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "404.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "_default", "list.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "_default", "single.html")
+
+	baseofDefault := []byte(`<!DOCTYPE html>
+<html>
+    {{- partial "head.html" . -}}
+    <body>
+        {{- partial "header.html" . -}}
+        <div id="content">
+        {{- block "main" . }}{{- end }}
+        </div>
+        {{- partial "footer.html" . -}}
+    </body>
+</html>
+`)
+	err = helpers.WriteToDisk(filepath.Join(createpath, "layouts", "_default", "baseof.html"), bytes.NewReader(baseofDefault), cfg.Fs.Source)
+	if err != nil {
+		return err
+	}
+
+	touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "head.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "header.html")
+	touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "footer.html")
+
+	mkdir(createpath, "archetypes")
+
+	archDefault := []byte("+++\n+++\n")
+
+	err = helpers.WriteToDisk(filepath.Join(createpath, "archetypes", "default.md"), bytes.NewReader(archDefault), cfg.Fs.Source)
+	if err != nil {
+		return err
+	}
+
+	mkdir(createpath, "static", "js")
+	mkdir(createpath, "static", "css")
+
+	by := []byte(`The MIT License (MIT)
+
+Copyright (c) ` + htime.Now().Format("2006") + ` YOUR_NAME_HERE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+`)
+
+	err = helpers.WriteToDisk(filepath.Join(createpath, "LICENSE"), bytes.NewReader(by), cfg.Fs.Source)
+	if err != nil {
+		return err
+	}
+
+	n.createThemeMD(cfg.Fs, createpath)
+
+	return nil
+}
+
+func (n *newThemeCmd) createThemeMD(fs *hugofs.Fs, inpath string) (err error) {
+	by := []byte(`# theme.toml template for a Hugo theme
+# See https://github.com/gohugoio/hugoThemes#themetoml for an example
+
+name = "` + strings.Title(helpers.MakeTitle(filepath.Base(inpath))) + `"
+license = "MIT"
+licenselink = "https://github.com/yourname/yourtheme/blob/master/LICENSE"
+description = ""
+homepage = "http://example.com/"
+tags = []
+features = []
+min_version = "0.41.0"
+
+[author]
+  name = ""
+  homepage = ""
+
+# If porting an existing theme
+[original]
+  name = ""
+  homepage = ""
+  repo = ""
+`)
+
+	err = helpers.WriteToDisk(filepath.Join(inpath, "theme.toml"), bytes.NewReader(by), fs.Source)
+	if err != nil {
+		return
+	}
+
+	return nil
+}
@@ -0,0 +1,51 @@
+// Copyright 2019 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build nodeploy
+// +build nodeploy
+
+package commands
+
+import (
+	"errors"
+
+	"github.com/spf13/cobra"
+)
+
+var _ cmder = (*deployCmd)(nil)
+
+// deployCmd supports deploying sites to Cloud providers.
+type deployCmd struct {
+	*baseBuilderCmd
+}
+
+func (b *commandsBuilder) newDeployCmd() *deployCmd {
+	cc := &deployCmd{}
+
+	cmd := &cobra.Command{
+		Use:   "deploy",
+		Short: "Deploy your site to a Cloud provider.",
+		Long: `Deploy your site to a Cloud provider.
+
+See https://gohugo.io/hosting-and-deployment/hugo-deploy/ for detailed
+documentation.
+`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return errors.New("build without HUGO_BUILD_TAGS=nodeploy to use this command")
+		},
+	}
+
+	cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
+
+	return cc
+}
@@ -1,4 +1,7 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+//go:build release
+// +build release
+
+// Copyright 2017-present The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,42 +17,56 @@
 package commands

 import (
-	"context"
+	"errors"

-	"github.com/bep/simplecobra"
+	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/releaser"
 	"github.com/spf13/cobra"
 )

-// Note: This is a command only meant for internal use and must be run
-// via "go run -tags release main.go release" on the actual code base that is in the release.
-func newReleaseCommand() simplecobra.Commander {
-	var (
-		step     int
-		skipPush bool
-		try      bool
-		version  string
-	)
+var _ cmder = (*releaseCommandeer)(nil)

-	return &simpleCommand{
-		name:  "release",
-		short: "Release a new version of Hugo",
-		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			rel, err := releaser.New(skipPush, try, step, version)
-			if err != nil {
-				return err
-			}
+type releaseCommandeer struct {
+	cmd *cobra.Command

-			return rel.Run()
-		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			cmd.Hidden = true
-			cmd.ValidArgsFunction = cobra.NoFileCompletions
-			cmd.PersistentFlags().BoolVarP(&skipPush, "skip-push", "", false, "skip pushing to remote")
-			cmd.PersistentFlags().BoolVarP(&try, "try", "", false, "no changes")
-			cmd.PersistentFlags().IntVarP(&step, "step", "", 0, "step to run (1: set new version 2: prepare next dev version)")
-			cmd.PersistentFlags().StringVarP(&version, "version", "", "", "version to release (derived from branch name if not set)")
-			_ = cmd.RegisterFlagCompletionFunc("step", cobra.FixedCompletions([]string{"1", "2"}, cobra.ShellCompDirectiveNoFileComp))
+	version string
+
+	skipPublish bool
+	try         bool
+}
+
+func createReleaser() cmder {
+	// Note: This is a command only meant for internal use and must be run
+	// via "go run -tags release main.go release" on the actual code base that is in the release.
+	r := &releaseCommandeer{
+		cmd: &cobra.Command{
+			Use:    "release",
+			Short:  "Release a new version of Hugo.",
+			Hidden: true,
 		},
 	}
+
+	r.cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return r.release()
+	}
+
+	r.cmd.PersistentFlags().StringVarP(&r.version, "rel", "r", "", "new release version, i.e. 0.25.1")
+	r.cmd.PersistentFlags().BoolVarP(&r.skipPublish, "skip-publish", "", false, "skip all publishing pipes of the release")
+	r.cmd.PersistentFlags().BoolVarP(&r.try, "try", "", false, "simulate a release, i.e. no changes")
+
+	return r
+}
+
+func (c *releaseCommandeer) getCommand() *cobra.Command {
+	return c.cmd
+}
+
+func (c *releaseCommandeer) flagsToConfig(cfg config.Provider) {
+}
+
+func (r *releaseCommandeer) release() error {
+	if r.version == "" {
+		return errors.New("must set the --rel flag to the relevant version number")
+	}
+	return releaser.New(r.version, r.skipPublish, r.try).Run()
 }
@@ -0,0 +1,21 @@
+//go:build !release
+// +build !release
+
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+func createReleaser() cmder {
+	return &nilCommand{}
+}
@@ -0,0 +1,31 @@
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"bytes"
+	"io"
+	"net/url"
+
+	"github.com/gohugoio/hugo/transform"
+	"github.com/gohugoio/hugo/transform/livereloadinject"
+)
+
+func injectLiveReloadScript(src io.Reader, baseURL url.URL) string {
+	var b bytes.Buffer
+	chain := transform.Chain{livereloadinject.New(baseURL)}
+	chain.Apply(&b, src)
+
+	return b.String()
+}
@@ -0,0 +1,280 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/helpers"
+	"golang.org/x/net/context"
+	"golang.org/x/sync/errgroup"
+
+	qt "github.com/frankban/quicktest"
+)
+
+// Issue 9518
+func TestServerPanicOnConfigError(t *testing.T) {
+	c := qt.New(t)
+
+	config := `
+[markup]
+[markup.highlight]
+linenos='table'
+`
+
+	r := runServerTest(c, 0, config)
+
+	c.Assert(r.err, qt.IsNotNil)
+	c.Assert(r.err.Error(), qt.Contains, "cannot parse 'Highlight.LineNos' as bool:")
+}
+
+func TestServerFlags(t *testing.T) {
+	c := qt.New(t)
+
+	assertPublic := func(c *qt.C, r serverTestResult, renderStaticToDisk bool) {
+		c.Assert(r.err, qt.IsNil)
+		c.Assert(r.homesContent[0], qt.Contains, "Environment: development")
+		c.Assert(r.publicDirnames["myfile.txt"], qt.Equals, renderStaticToDisk)
+
+	}
+
+	for _, test := range []struct {
+		flag   string
+		assert func(c *qt.C, r serverTestResult)
+	}{
+		{"", func(c *qt.C, r serverTestResult) {
+			assertPublic(c, r, false)
+		}},
+		{"--renderToDisk", func(c *qt.C, r serverTestResult) {
+			assertPublic(c, r, true)
+		}},
+		{"--renderStaticToDisk", func(c *qt.C, r serverTestResult) {
+			assertPublic(c, r, true)
+		}},
+	} {
+		c.Run(test.flag, func(c *qt.C) {
+			config := `
+baseURL="https://example.org"
+`
+
+			var args []string
+			if test.flag != "" {
+				args = strings.Split(test.flag, "=")
+			}
+
+			r := runServerTest(c, 1, config, args...)
+
+			test.assert(c, r)
+
+		})
+
+	}
+
+}
+
+func TestServerBugs(t *testing.T) {
+	c := qt.New(t)
+
+	for _, test := range []struct {
+		name       string
+		config     string
+		flag       string
+		numservers int
+		assert     func(c *qt.C, r serverTestResult)
+	}{
+		// Issue 9788
+		{"PostProcess, memory", "", "", 1, func(c *qt.C, r serverTestResult) {
+			c.Assert(r.err, qt.IsNil)
+			c.Assert(r.homesContent[0], qt.Contains, "PostProcess: /foo.min.css")
+		}},
+		{"PostProcess, disk", "", "--renderToDisk", 1, func(c *qt.C, r serverTestResult) {
+			c.Assert(r.err, qt.IsNil)
+			c.Assert(r.homesContent[0], qt.Contains, "PostProcess: /foo.min.css")
+		}},
+		// Isue 9901
+		{"Multihost", `
+defaultContentLanguage = 'en'
+[languages]
+[languages.en]
+baseURL = 'https://example.com'
+title = 'My blog'
+weight = 1
+[languages.fr]
+baseURL = 'https://example.fr'
+title = 'Mon blogue'
+weight = 2
+`, "", 2, func(c *qt.C, r serverTestResult) {
+			c.Assert(r.err, qt.IsNil)
+			for i, s := range []string{"My blog", "Mon blogue"} {
+				c.Assert(r.homesContent[i], qt.Contains, s)
+			}
+		}},
+	} {
+		c.Run(test.name, func(c *qt.C) {
+			if test.config == "" {
+				test.config = `
+baseURL="https://example.org"
+`
+			}
+
+			var args []string
+			if test.flag != "" {
+				args = strings.Split(test.flag, "=")
+			}
+			r := runServerTest(c, test.numservers, test.config, args...)
+			test.assert(c, r)
+
+		})
+
+	}
+
+}
+
+type serverTestResult struct {
+	err            error
+	homesContent   []string
+	publicDirnames map[string]bool
+}
+
+func runServerTest(c *qt.C, getNumHomes int, config string, args ...string) (result serverTestResult) {
+	dir := createSimpleTestSite(c, testSiteConfig{configTOML: config})
+
+	sp, err := helpers.FindAvailablePort()
+	c.Assert(err, qt.IsNil)
+	port := sp.Port
+
+	defer func() {
+		os.RemoveAll(dir)
+	}()
+
+	stop := make(chan bool)
+
+	b := newCommandsBuilder()
+	scmd := b.newServerCmdSignaled(stop)
+
+	cmd := scmd.getCommand()
+	args = append([]string{"-s=" + dir, fmt.Sprintf("-p=%d", port)}, args...)
+	cmd.SetArgs(args)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	wg, ctx := errgroup.WithContext(ctx)
+
+	wg.Go(func() error {
+		_, err := cmd.ExecuteC()
+		return err
+	})
+
+	if getNumHomes > 0 {
+		// Esp. on slow CI machines, we need to wait a little before the web
+		// server is ready.
+		time.Sleep(567 * time.Millisecond)
+		result.homesContent = make([]string, getNumHomes)
+		for i := 0; i < getNumHomes; i++ {
+			func() {
+				resp, err := http.Get(fmt.Sprintf("http://localhost:%d/", port+i))
+				c.Check(err, qt.IsNil)
+				c.Check(resp.StatusCode, qt.Equals, http.StatusOK)
+				if err == nil {
+					defer resp.Body.Close()
+					result.homesContent[i] = helpers.ReaderToString(resp.Body)
+				}
+			}()
+		}
+	}
+
+	time.Sleep(1 * time.Second)
+
+	select {
+	case <-stop:
+	case stop <- true:
+	}
+
+	pubFiles, err := os.ReadDir(filepath.Join(dir, "public"))
+	c.Check(err, qt.IsNil)
+	result.publicDirnames = make(map[string]bool)
+	for _, f := range pubFiles {
+		result.publicDirnames[f.Name()] = true
+	}
+
+	result.err = wg.Wait()
+
+	return
+
+}
+
+func TestFixURL(t *testing.T) {
+	type data struct {
+		TestName   string
+		CLIBaseURL string
+		CfgBaseURL string
+		AppendPort bool
+		Port       int
+		Result     string
+	}
+	tests := []data{
+		{"Basic http localhost", "", "http://foo.com", true, 1313, "http://localhost:1313/"},
+		{"Basic https production, http localhost", "", "https://foo.com", true, 1313, "http://localhost:1313/"},
+		{"Basic subdir", "", "http://foo.com/bar", true, 1313, "http://localhost:1313/bar/"},
+		{"Basic production", "http://foo.com", "http://foo.com", false, 80, "http://foo.com/"},
+		{"Production subdir", "http://foo.com/bar", "http://foo.com/bar", false, 80, "http://foo.com/bar/"},
+		{"No http", "", "foo.com", true, 1313, "//localhost:1313/"},
+		{"Override configured port", "", "foo.com:2020", true, 1313, "//localhost:1313/"},
+		{"No http production", "foo.com", "foo.com", false, 80, "//foo.com/"},
+		{"No http production with port", "foo.com", "foo.com", true, 2020, "//foo.com:2020/"},
+		{"No config", "", "", true, 1313, "//localhost:1313/"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.TestName, func(t *testing.T) {
+			b := newCommandsBuilder()
+			s := b.newServerCmd()
+			v := config.NewWithTestDefaults()
+			baseURL := test.CLIBaseURL
+			v.Set("baseURL", test.CfgBaseURL)
+			s.serverAppend = test.AppendPort
+			s.serverPort = test.Port
+			result, err := s.fixURL(v, baseURL, s.serverPort)
+			if err != nil {
+				t.Errorf("Unexpected error %s", err)
+			}
+			if result != test.Result {
+				t.Errorf("Expected %q, got %q", test.Result, result)
+			}
+		})
+	}
+}
+
+func TestRemoveErrorPrefixFromLog(t *testing.T) {
+	c := qt.New(t)
+	content := `ERROR 2018/10/07 13:11:12 Error while rendering "home": template: _default/baseof.html:4:3: executing "main" at <partial "logo" .>: error calling partial: template: partials/logo.html:5:84: executing "partials/logo.html" at <$resized.AHeight>: can't evaluate field AHeight in type *resource.Image
+ERROR 2018/10/07 13:11:12 Rebuild failed: logged 1 error(s)
+`
+
+	withoutError := removeErrorPrefixFromLog(content)
+
+	c.Assert(strings.Contains(withoutError, "ERROR"), qt.Equals, false)
+}
+
+func isWindowsCI() bool {
+	return runtime.GOOS == "windows" && os.Getenv("CI") != ""
+}
@@ -0,0 +1,129 @@
+// Copyright 2017 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/hugolib/filesystems"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/spf13/fsync"
+)
+
+type staticSyncer struct {
+	c *commandeer
+}
+
+func newStaticSyncer(c *commandeer) (*staticSyncer, error) {
+	return &staticSyncer{c: c}, nil
+}
+
+func (s *staticSyncer) isStatic(filename string) bool {
+	return s.c.hugo().BaseFs.SourceFilesystems.IsStatic(filename)
+}
+
+func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
+	c := s.c
+
+	syncFn := func(sourceFs *filesystems.SourceFilesystem) (uint64, error) {
+		publishDir := helpers.FilePathSeparator
+
+		if sourceFs.PublishFolder != "" {
+			publishDir = filepath.Join(publishDir, sourceFs.PublishFolder)
+		}
+
+		syncer := fsync.NewSyncer()
+		syncer.NoTimes = c.Cfg.GetBool("noTimes")
+		syncer.NoChmod = c.Cfg.GetBool("noChmod")
+		syncer.ChmodFilter = chmodFilter
+		syncer.SrcFs = sourceFs.Fs
+		syncer.DestFs = c.Fs.PublishDir
+		if c.renderStaticToDisk {
+			syncer.DestFs = c.Fs.PublishDirStatic
+		}
+
+		// prevent spamming the log on changes
+		logger := helpers.NewDistinctErrorLogger()
+
+		for _, ev := range staticEvents {
+			// Due to our approach of layering both directories and the content's rendered output
+			// into one we can't accurately remove a file not in one of the source directories.
+			// If a file is in the local static dir and also in the theme static dir and we remove
+			// it from one of those locations we expect it to still exist in the destination
+			//
+			// If Hugo generates a file (from the content dir) over a static file
+			// the content generated file should take precedence.
+			//
+			// Because we are now watching and handling individual events it is possible that a static
+			// event that occupies the same path as a content generated file will take precedence
+			// until a regeneration of the content takes places.
+			//
+			// Hugo assumes that these cases are very rare and will permit this bad behavior
+			// The alternative is to track every single file and which pipeline rendered it
+			// and then to handle conflict resolution on every event.
+
+			fromPath := ev.Name
+
+			relPath, found := sourceFs.MakePathRelative(fromPath)
+
+			if !found {
+				// Not member of this virtual host.
+				continue
+			}
+
+			// Remove || rename is harder and will require an assumption.
+			// Hugo takes the following approach:
+			// If the static file exists in any of the static source directories after this event
+			// Hugo will re-sync it.
+			// If it does not exist in all of the static directories Hugo will remove it.
+			//
+			// This assumes that Hugo has not generated content on top of a static file and then removed
+			// the source of that static file. In this case Hugo will incorrectly remove that file
+			// from the published directory.
+			if ev.Op&fsnotify.Rename == fsnotify.Rename || ev.Op&fsnotify.Remove == fsnotify.Remove {
+				if _, err := sourceFs.Fs.Stat(relPath); os.IsNotExist(err) {
+					// If file doesn't exist in any static dir, remove it
+					logger.Println("File no longer exists in static dir, removing", relPath)
+					_ = c.Fs.PublishDirStatic.RemoveAll(relPath)
+
+				} else if err == nil {
+					// If file still exists, sync it
+					logger.Println("Syncing", relPath, "to", publishDir)
+
+					if err := syncer.Sync(relPath, relPath); err != nil {
+						c.logger.Errorln(err)
+					}
+				} else {
+					c.logger.Errorln(err)
+				}
+
+				continue
+			}
+
+			// For all other event operations Hugo will sync static.
+			logger.Println("Syncing", relPath, "to", publishDir)
+			if err := syncer.Sync(filepath.Join(publishDir, relPath), relPath); err != nil {
+				c.logger.Errorln(err)
+			}
+		}
+
+		return 0, nil
+	}
+
+	_, err := c.doWithPublishDirs(syncFn)
+	return err
+}
@@ -0,0 +1,44 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/spf13/cobra"
+	jww "github.com/spf13/jwalterweatherman"
+)
+
+var _ cmder = (*versionCmd)(nil)
+
+type versionCmd struct {
+	*baseCmd
+}
+
+func newVersionCmd() *versionCmd {
+	return &versionCmd{
+		newBaseCmd(&cobra.Command{
+			Use:   "version",
+			Short: "Print the version number of Hugo",
+			Long:  `All software has versions. This is Hugo's.`,
+			RunE: func(cmd *cobra.Command, args []string) error {
+				printHugoVersion()
+				return nil
+			},
+		}),
+	}
+}
+
+func printHugoVersion() {
+	jww.FEEDBACK.Println(hugo.BuildVersionString())
+}
@@ -16,72 +16,35 @@ package collections
 import (
 	"fmt"
 	"reflect"
-
-	"github.com/gohugoio/hugo/common/hreflect"
 )

 // Append appends from to a slice to and returns the resulting slice.
 // If length of from is one and the only element is a slice of same type as to,
 // it will be appended.
 func Append(to any, from ...any) (any, error) {
-	if len(from) == 0 {
-		return to, nil
-	}
-	tov, toIsNil := hreflect.Indirect(reflect.ValueOf(to))
+	tov, toIsNil := indirect(reflect.ValueOf(to))

 	toIsNil = toIsNil || to == nil
 	var tot reflect.Type

 	if !toIsNil {
-		if tov.Kind() == reflect.Slice {
-			// Create a copy of tov, so we don't modify the original.
-			c := reflect.MakeSlice(tov.Type(), tov.Len(), tov.Len()+len(from))
-			reflect.Copy(c, tov)
-			tov = c
-		}
-
 		if tov.Kind() != reflect.Slice {
 			return nil, fmt.Errorf("expected a slice, got %T", to)
 		}

 		tot = tov.Type().Elem()
-		if tot.Kind() == reflect.Slice {
-			totvt := tot.Elem()
-			fromvs := make([]reflect.Value, len(from))
-			for i, f := range from {
-				fromv := reflect.ValueOf(f)
-				fromt := fromv.Type()
-				if fromt.Kind() == reflect.Slice {
-					fromt = fromt.Elem()
-				}
-				if totvt != fromt {
-					return nil, fmt.Errorf("cannot append slice of %s to slice of %s", fromt, totvt)
-				} else {
-					fromvs[i] = fromv
-				}
-			}
-			return reflect.Append(tov, fromvs...).Interface(), nil
-
-		}
-
 		toIsNil = tov.Len() == 0

 		if len(from) == 1 {
 			fromv := reflect.ValueOf(from[0])
-			if !fromv.IsValid() {
-				// from[0] is nil
-				return appendToInterfaceSliceFromValues(tov, fromv)
-			}
-			fromt := fromv.Type()
-			if fromt.Kind() == reflect.Slice {
-				fromt = fromt.Elem()
-			}
 			if fromv.Kind() == reflect.Slice {
 				if toIsNil {
 					// If we get nil []string, we just return the []string
 					return from[0], nil
 				}

+				fromt := reflect.TypeOf(from[0]).Elem()
+
 				// If we get []string []string, we append the from slice to to
 				if tot == fromt {
 					return reflect.AppendSlice(tov, fromv).Interface(), nil
@@ -89,7 +52,6 @@ func Append(to any, from ...any) (any, error) {
 					// Fall back to a []interface{} slice.
 					return appendToInterfaceSliceFromValues(tov, fromv)
 				}
-
 			}
 		}
 	}
@@ -100,9 +62,9 @@ func Append(to any, from ...any) (any, error) {

 	for _, f := range from {
 		fv := reflect.ValueOf(f)
-		if !fv.IsValid() || !fv.Type().AssignableTo(tot) {
+		if !fv.Type().AssignableTo(tot) {
 			// Fall back to a []interface{} slice.
-			tov, _ := hreflect.Indirect(reflect.ValueOf(to))
+			tov, _ := indirect(reflect.ValueOf(to))
 			return appendToInterfaceSlice(tov, from...)
 		}
 		tov = reflect.Append(tov, fv)
@@ -115,11 +77,7 @@ func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]any, erro
 	var tos []any

 	for _, slice := range []reflect.Value{slice1, slice2} {
-		if !slice.IsValid() {
-			tos = append(tos, nil)
-			continue
-		}
-		for i := range slice.Len() {
+		for i := 0; i < slice.Len(); i++ {
 			tos = append(tos, slice.Index(i).Interface())
 		}
 	}
@@ -130,7 +88,7 @@ func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]any, erro
 func appendToInterfaceSlice(tov reflect.Value, from ...any) ([]any, error) {
 	var tos []any

-	for i := range tov.Len() {
+	for i := 0; i < tov.Len(); i++ {
 		tos = append(tos, tov.Index(i).Interface())
 	}

@@ -138,3 +96,17 @@ func appendToInterfaceSlice(tov reflect.Value, from ...any) ([]any, error) {

 	return tos, nil
 }
+
+// indirect is borrowed from the Go stdlib: 'text/template/exec.go'
+// TODO(bep) consolidate
+func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
+	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
+		if v.IsNil() {
+			return v, true
+		}
+		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
+			break
+		}
+	}
+	return v, false
+}
@@ -24,7 +24,7 @@ func TestAppend(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)

-	for i, test := range []struct {
+	for _, test := range []struct {
 		start    any
 		addend   []any
 		expected any
@@ -55,7 +55,7 @@ func TestAppend(t *testing.T) {
 			[]any{&tstSlicerIn1{"c"}},
 			testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}, &tstSlicerIn1{"c"}},
 		},
-		// https://github.com/gohugoio/hugo/issues/5361
+		//https://github.com/gohugoio/hugo/issues/5361
 		{
 			[]string{"a", "b"},
 			[]any{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
@@ -74,10 +74,6 @@ func TestAppend(t *testing.T) {
 			[]any{"c"},
 			false,
 		},
-		{[]string{"a", "b"}, []any{nil}, []any{"a", "b", nil}},
-		{[]string{"a", "b"}, []any{nil, "d", nil}, []any{"a", "b", nil, "d", nil}},
-		{[]any{"a", nil, "c"}, []any{"d", nil, "f"}, []any{"a", nil, "c", "d", nil, "f"}},
-		{[]string{"a", "b"}, []any{}, []string{"a", "b"}},
 	} {

 		result, err := Append(test.start, test.addend...)
@@ -89,61 +85,6 @@ func TestAppend(t *testing.T) {
 		}

 		c.Assert(err, qt.IsNil)
-		c.Assert(result, qt.DeepEquals, test.expected, qt.Commentf("test: [%d] %v", i, test))
+		c.Assert(result, qt.DeepEquals, test.expected)
 	}
 }
-
-// #11093
-func TestAppendToMultiDimensionalSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	for _, test := range []struct {
-		to       any
-		from     []any
-		expected any
-	}{
-		{
-			[][]string{{"a", "b"}},
-			[]any{[]string{"c", "d"}},
-			[][]string{
-				{"a", "b"},
-				{"c", "d"},
-			},
-		},
-		{
-			[][]string{{"a", "b"}},
-			[]any{[]string{"c", "d"}, []string{"e", "f"}},
-			[][]string{
-				{"a", "b"},
-				{"c", "d"},
-				{"e", "f"},
-			},
-		},
-		{
-			[][]string{{"a", "b"}},
-			[]any{[]int{1, 2}},
-			false,
-		},
-	} {
-		result, err := Append(test.to, test.from...)
-		if b, ok := test.expected.(bool); ok && !b {
-			c.Assert(err, qt.Not(qt.IsNil))
-		} else {
-			c.Assert(err, qt.IsNil)
-			c.Assert(result, qt.DeepEquals, test.expected)
-		}
-	}
-}
-
-func TestAppendShouldMakeACopyOfTheInputSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-	slice := make([]string, 0, 100)
-	slice = append(slice, "a", "b")
-	result, err := Append(slice, "c")
-	c.Assert(err, qt.IsNil)
-	slice[0] = "d"
-	c.Assert(result, qt.DeepEquals, []string{"a", "b", "c"})
-	c.Assert(slice, qt.DeepEquals, []string{"d", "b"})
-}
@@ -15,7 +15,6 @@ package collections

 import (
 	"reflect"
-	"sort"
 )

 // Slicer defines a very generic way to create a typed slice. This is used
@@ -73,23 +72,5 @@ func StringSliceToInterfaceSlice(ss []string) []any {
 		result[i] = s
 	}
 	return result
-}

-type SortedStringSlice []string
-
-// Contains returns true if s is in ss.
-func (ss SortedStringSlice) Contains(s string) bool {
-	i := sort.SearchStrings(ss, s)
-	return i < len(ss) && ss[i] == s
-}
-
-// Count returns the number of times s is in ss.
-func (ss SortedStringSlice) Count(s string) int {
-	var count int
-	i := sort.SearchStrings(ss, s)
-	for i < len(ss) && ss[i] == s {
-		count++
-		i++
-	}
-	return count
 }
@@ -122,51 +122,3 @@ func TestSlice(t *testing.T) {
 		c.Assert(test.expected, qt.DeepEquals, result, errMsg)
 	}
 }
-
-func TestSortedStringSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	var s SortedStringSlice = []string{"a", "b", "b", "b", "c", "d"}
-
-	c.Assert(s.Contains("a"), qt.IsTrue)
-	c.Assert(s.Contains("b"), qt.IsTrue)
-	c.Assert(s.Contains("z"), qt.IsFalse)
-	c.Assert(s.Count("b"), qt.Equals, 3)
-	c.Assert(s.Count("z"), qt.Equals, 0)
-	c.Assert(s.Count("a"), qt.Equals, 1)
-}
-
-func TestStringSliceToInterfaceSlice(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	tests := []struct {
-		name string
-		in   []string
-		want []any
-	}{
-		{
-			name: "empty slice",
-			in:   []string{},
-			want: []any{},
-		},
-		{
-			name: "single element",
-			in:   []string{"hello"},
-			want: []any{"hello"},
-		},
-		{
-			name: "multiple elements",
-			in:   []string{"a", "b", "c"},
-			want: []any{"a", "b", "c"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := StringSliceToInterfaceSlice(tt.in)
-			c.Assert(got, qt.DeepEquals, tt.want)
-		})
-	}
-}
@@ -1,135 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package collections
-
-import (
-	"iter"
-	"slices"
-	"sync"
-
-	"github.com/gohugoio/hugo/common/hiter"
-)
-
-// StackThreadSafe is a simple LIFO stack that is safe for concurrent use.
-type StackThreadSafe[T any] struct {
-	items []T
-	zero  T
-	mu    sync.RWMutex
-}
-
-func NewStackThreadSafe[T any]() *StackThreadSafe[T] {
-	return &StackThreadSafe[T]{}
-}
-
-func (s *StackThreadSafe[T]) Push(item T) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.items = append(s.items, item)
-}
-
-func (s *StackThreadSafe[T]) Pop() (T, bool) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if len(s.items) == 0 {
-		return s.zero, false
-	}
-	item := s.items[len(s.items)-1]
-	s.items = s.items[:len(s.items)-1]
-	return item, true
-}
-
-func (s *StackThreadSafe[T]) Peek() (T, bool) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	if len(s.items) == 0 {
-		return s.zero, false
-	}
-	return s.items[len(s.items)-1], true
-}
-
-func (s *StackThreadSafe[T]) Len() int {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return len(s.items)
-}
-
-// All returns all items in the stack, from bottom to top.
-func (s *StackThreadSafe[T]) All() iter.Seq2[int, T] {
-	return hiter.Lock2(slices.All(s.items), s.mu.RLock, s.mu.RUnlock)
-}
-
-func (s *StackThreadSafe[T]) Drain() []T {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	items := s.items
-	s.items = nil
-	return items
-}
-
-func (s *StackThreadSafe[T]) DrainMatching(predicate func(T) bool) []T {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	var items []T
-	for i := len(s.items) - 1; i >= 0; i-- {
-		if predicate(s.items[i]) {
-			items = append(items, s.items[i])
-			s.items = slices.Delete(s.items, i, i+1)
-		}
-	}
-	return items
-}
-
-// Stack is a simple LIFO stack that is not safe for concurrent use.
-type Stack[T any] struct {
-	items []T
-	zero  T
-}
-
-func NewStack[T any]() *Stack[T] {
-	return &Stack[T]{}
-}
-
-func (s *Stack[T]) Push(item T) {
-	s.items = append(s.items, item)
-}
-
-func (s *Stack[T]) Pop() (T, bool) {
-	if len(s.items) == 0 {
-		return s.zero, false
-	}
-	item := s.items[len(s.items)-1]
-	s.items = s.items[:len(s.items)-1]
-	return item, true
-}
-
-func (s *Stack[T]) Peek() (T, bool) {
-	if len(s.items) == 0 {
-		return s.zero, false
-	}
-	return s.items[len(s.items)-1], true
-}
-
-func (s *Stack[T]) Len() int {
-	return len(s.items)
-}
-
-func (s *Stack[T]) All() iter.Seq2[int, T] {
-	return slices.All(s.items)
-}
-
-func (s *Stack[T]) Drain() []T {
-	items := s.items
-	s.items = nil
-	return items
-}
@@ -1,77 +0,0 @@
-package collections
-
-import (
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestNewStack(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	s := NewStackThreadSafe[int]()
-
-	c.Assert(s, qt.IsNotNil)
-}
-
-func TestStackBasic(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	s := NewStackThreadSafe[int]()
-
-	c.Assert(s.Len(), qt.Equals, 0)
-
-	s.Push(1)
-	s.Push(2)
-	s.Push(3)
-
-	c.Assert(s.Len(), qt.Equals, 3)
-
-	top, ok := s.Peek()
-	c.Assert(ok, qt.Equals, true)
-	c.Assert(top, qt.Equals, 3)
-
-	popped, ok := s.Pop()
-	c.Assert(ok, qt.Equals, true)
-	c.Assert(popped, qt.Equals, 3)
-
-	c.Assert(s.Len(), qt.Equals, 2)
-
-	_, _ = s.Pop()
-	_, _ = s.Pop()
-	_, ok = s.Pop()
-
-	c.Assert(ok, qt.Equals, false)
-}
-
-func TestStackDrain(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	s := NewStackThreadSafe[string]()
-	s.Push("a")
-	s.Push("b")
-
-	got := s.Drain()
-
-	c.Assert(got, qt.DeepEquals, []string{"a", "b"})
-	c.Assert(s.Len(), qt.Equals, 0)
-}
-
-func TestStackDrainMatching(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	s := NewStackThreadSafe[int]()
-	s.Push(1)
-	s.Push(2)
-	s.Push(3)
-	s.Push(4)
-
-	got := s.DrainMatching(func(v int) bool { return v%2 == 0 })
-
-	c.Assert(got, qt.DeepEquals, []int{4, 2})
-	c.Assert(s.Drain(), qt.DeepEquals, []int{1, 3})
-}
@@ -13,32 +13,13 @@

 package constants

-// Error/Warning IDs.
+// Error IDs.
 // Do not change these values.
 const (
-	WarnRenderShortcodesInHTML   = "warning-rendershortcodes-in-html"
-	WarnGoldmarkRawHTML          = "warning-goldmark-raw-html"
-	WarnPartialSuperfluousPrefix = "warning-partial-superfluous-prefix"
-	WarnHomePageIsLeafBundle     = "warning-home-page-is-leaf-bundle"
+	ErrIDAmbigousDisableKindTaxonomy = "error-disable-taxonomy"
+	ErrIDAmbigousOutputKindTaxonomy  = "error-output-taxonomy"
+
+	// IDs for remote errors in tpl/data.
+	ErrRemoteGetJSON = "error-remote-getjson"
+	ErrRemoteGetCSV  = "error-remote-getcsv"
 )
-
-// Field/method names with special meaning.
-const (
-	FieldRelPermalink = "RelPermalink"
-	FieldPermalink    = "Permalink"
-)
-
-// IsFieldRelOrPermalink returns whether the given name is a RelPermalink or Permalink.
-func IsFieldRelOrPermalink(name string) bool {
-	return name == FieldRelPermalink || name == FieldPermalink
-}
-
-// Resource transformations.
-const (
-	ResourceTransformationFingerprint = "fingerprint"
-)
-
-// IsResourceTransformationPermalinkHash returns whether the given name is a resource transformation that changes the permalink based on the content.
-func IsResourceTransformationPermalinkHash(name string) bool {
-	return name == ResourceTransformationFingerprint
-}
@@ -1,2 +0,0 @@
-// Package common provides common helper functionality for Hugo.
-package common
@@ -1,225 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package hashing provides common hashing utilities.
-package hashing
-
-import (
-	"crypto/md5"
-	"encoding/hex"
-	"io"
-	"strconv"
-	"sync"
-
-	"github.com/cespare/xxhash/v2"
-	"github.com/gohugoio/hashstructure"
-	"github.com/gohugoio/hugo/common/hugio"
-	"github.com/gohugoio/hugo/identity"
-)
-
-// XXHashFromReader calculates the xxHash for the given reader.
-func XXHashFromReader(r io.Reader) (uint64, int64, error) {
-	h := getXxHashReadFrom()
-	defer putXxHashReadFrom(h)
-
-	size, err := io.Copy(h, r)
-	if err != nil {
-		return 0, 0, err
-	}
-	return h.Sum64(), size, nil
-}
-
-type Hasher interface {
-	io.StringWriter
-	io.Writer
-	io.ReaderFrom
-	Sum64() uint64
-}
-
-type HashCloser interface {
-	Hasher
-	io.Closer
-}
-
-// XxHasher returns a Hasher that uses xxHash.
-// Remember to call Close when done.
-func XxHasher() HashCloser {
-	h := getXxHashReadFrom()
-	return struct {
-		Hasher
-		io.Closer
-	}{
-		Hasher: h,
-		Closer: hugio.CloserFunc(func() error {
-			putXxHashReadFrom(h)
-			return nil
-		}),
-	}
-}
-
-// XxHashFromReaderHexEncoded calculates the xxHash for the given reader
-// and returns the hash as a hex encoded string.
-func XxHashFromReaderHexEncoded(r io.Reader) (string, error) {
-	h := getXxHashReadFrom()
-	defer putXxHashReadFrom(h)
-	_, err := io.Copy(h, r)
-	if err != nil {
-		return "", err
-	}
-	hash := h.Sum(nil)
-	return hex.EncodeToString(hash), nil
-}
-
-// XXHashFromString calculates the xxHash for the given string.
-func XXHashFromString(s string) (uint64, error) {
-	h := xxhash.New()
-	h.WriteString(s)
-	return h.Sum64(), nil
-}
-
-// XxHashFromStringHexEncoded calculates the xxHash for the given strings
-// and returns the hash as a hex encoded string.
-func XxHashFromStringHexEncoded(s ...string) string {
-	h := xxhash.New()
-	for _, f := range s {
-		h.WriteString(f)
-	}
-	hash := h.Sum(nil)
-	return hex.EncodeToString(hash)
-}
-
-// MD5FromStringHexEncoded returns the MD5 hash of the given string.
-func MD5FromStringHexEncoded(f string) string {
-	h := md5.New()
-	h.Write([]byte(f))
-	return hex.EncodeToString(h.Sum(nil))
-}
-
-// HashString returns a hash from the given elements.
-// It will panic if the hash cannot be calculated.
-// Note that this hash should be used primarily for identity, not for change detection as
-// it in the more complex values (e.g. Page) will not hash the full content.
-func HashString(vs ...any) string {
-	hash := HashUint64(vs...)
-	return strconv.FormatUint(hash, 10)
-}
-
-// HashStringHex returns a hash from the given elements as a hex encoded string.
-// See HashString for more information.
-func HashStringHex(vs ...any) string {
-	hash := HashUint64(vs...)
-	return strconv.FormatUint(hash, 16)
-}
-
-var hashOptsPool = sync.Pool{
-	New: func() any {
-		return &hashstructure.HashOptions{
-			Hasher: xxhash.New(),
-		}
-	},
-}
-
-func getHashOpts() *hashstructure.HashOptions {
-	return hashOptsPool.Get().(*hashstructure.HashOptions)
-}
-
-func putHashOpts(opts *hashstructure.HashOptions) {
-	opts.Hasher.Reset()
-	hashOptsPool.Put(opts)
-}
-
-// HashUint64 returns a hash from the given elements.
-// It will panic if the hash cannot be calculated.
-// Note that this hash should be used primarily for identity, not for change detection as
-// it in the more complex values (e.g. Page) will not hash the full content.
-func HashUint64(vs ...any) uint64 {
-	var o any
-	if len(vs) == 1 {
-		o = toHashable(vs[0])
-	} else {
-		elements := make([]any, len(vs))
-		for i, e := range vs {
-			elements[i] = toHashable(e)
-		}
-		o = elements
-	}
-
-	hash, err := Hash(o)
-	if err != nil {
-		panic(err)
-	}
-	return hash
-}
-
-// Hash returns a hash from vs.
-func Hash(vs ...any) (uint64, error) {
-	hashOpts := getHashOpts()
-	defer putHashOpts(hashOpts)
-	var v any = vs
-	if len(vs) == 1 {
-		v = vs[0]
-	}
-	return hashstructure.Hash(v, hashOpts)
-}
-
-type keyer interface {
-	Key() string
-}
-
-// For structs, hashstructure.Hash only works on the exported fields,
-// so rewrite the input slice for known identity types.
-func toHashable(v any) any {
-	switch t := v.(type) {
-	case keyer:
-		return t.Key()
-	case identity.IdentityProvider:
-		return t.GetIdentity()
-	default:
-		return v
-	}
-}
-
-type xxhashReadFrom struct {
-	buff []byte
-	*xxhash.Digest
-}
-
-func (x *xxhashReadFrom) ReadFrom(r io.Reader) (int64, error) {
-	for {
-		n, err := r.Read(x.buff)
-		if n > 0 {
-			x.Digest.Write(x.buff[:n])
-		}
-		if err != nil {
-			if err == io.EOF {
-				err = nil
-			}
-			return int64(n), err
-		}
-	}
-}
-
-var xXhashReadFromPool = sync.Pool{
-	New: func() any {
-		return &xxhashReadFrom{Digest: xxhash.New(), buff: make([]byte, 48*1024)}
-	},
-}
-
-func getXxHashReadFrom() *xxhashReadFrom {
-	return xXhashReadFromPool.Get().(*xxhashReadFrom)
-}
-
-func putXxHashReadFrom(h *xxhashReadFrom) {
-	h.Reset()
-	xXhashReadFromPool.Put(h)
-}
@@ -1,152 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package hashing
-
-import (
-	"fmt"
-	"math"
-	"strings"
-	"sync"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestXxHashFromReader(t *testing.T) {
-	c := qt.New(t)
-	s := "Hello World"
-	r := strings.NewReader(s)
-	got, size, err := XXHashFromReader(r)
-	c.Assert(err, qt.IsNil)
-	c.Assert(size, qt.Equals, int64(len(s)))
-	c.Assert(got, qt.Equals, uint64(7148569436472236994))
-}
-
-func TestXxHashFromReaderPara(t *testing.T) {
-	c := qt.New(t)
-
-	var wg sync.WaitGroup
-	for i := range 10 {
-		wg.Go(func() {
-			for j := range 100 {
-				s := strings.Repeat("Hello ", i+j+1*42)
-				r := strings.NewReader(s)
-				got, size, err := XXHashFromReader(r)
-				c.Assert(size, qt.Equals, int64(len(s)))
-				c.Assert(err, qt.IsNil)
-				expect, _ := XXHashFromString(s)
-				c.Assert(got, qt.Equals, expect)
-			}
-		})
-	}
-
-	wg.Wait()
-}
-
-func TestXxHashFromString(t *testing.T) {
-	c := qt.New(t)
-	s := "Hello World"
-	got, err := XXHashFromString(s)
-	c.Assert(err, qt.IsNil)
-	c.Assert(got, qt.Equals, uint64(7148569436472236994))
-}
-
-func TestXxHashFromStringHexEncoded(t *testing.T) {
-	c := qt.New(t)
-	s := "The quick brown fox jumps over the lazy dog"
-	got := XxHashFromStringHexEncoded(s)
-	// Facit: https://asecuritysite.com/encryption/xxhash?val=The%20quick%20brown%20fox%20jumps%20over%20the%20lazy%20dog
-	c.Assert(got, qt.Equals, "0b242d361fda71bc")
-}
-
-func BenchmarkXXHashFromReader(b *testing.B) {
-	r := strings.NewReader("Hello World")
-
-	for b.Loop() {
-		XXHashFromReader(r)
-		r.Seek(0, 0)
-	}
-}
-
-func BenchmarkXXHashFromString(b *testing.B) {
-	s := "Hello World"
-
-	for b.Loop() {
-		XXHashFromString(s)
-	}
-}
-
-func BenchmarkXXHashFromStringHexEncoded(b *testing.B) {
-	s := "The quick brown fox jumps over the lazy dog"
-
-	for b.Loop() {
-		XxHashFromStringHexEncoded(s)
-	}
-}
-
-func TestHashString(t *testing.T) {
-	c := qt.New(t)
-
-	c.Assert(HashString("a", "b"), qt.Equals, "3176555414984061461")
-	c.Assert(HashString("ab"), qt.Equals, "7347350983217793633")
-
-	var vals []any = []any{"a", "b", tstKeyer{"c"}}
-
-	c.Assert(HashString(vals...), qt.Equals, "4438730547989914315")
-	c.Assert(vals[2], qt.Equals, tstKeyer{"c"})
-}
-
-type tstKeyer struct {
-	key string
-}
-
-func (t tstKeyer) Key() string {
-	return t.key
-}
-
-func (t tstKeyer) String() string {
-	return "key: " + t.key
-}
-
-func BenchmarkHashString(b *testing.B) {
-	word := " hello "
-
-	var tests []string
-
-	for i := 1; i <= 5; i++ {
-		sentence := strings.Repeat(word, int(math.Pow(4, float64(i))))
-		tests = append(tests, sentence)
-	}
-
-	b.ResetTimer()
-
-	for _, test := range tests {
-		b.Run(fmt.Sprintf("n%d", len(test)), func(b *testing.B) {
-			for b.Loop() {
-				HashString(test)
-			}
-		})
-	}
-}
-
-func BenchmarkHashMap(b *testing.B) {
-	m := map[string]any{}
-	for i := range 1000 {
-		m[fmt.Sprintf("key%d", i)] = i
-	}
-
-	for b.Loop() {
-		HashString(m)
-	}
-}
@@ -1,61 +0,0 @@
-// Copyright 2025 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package hdebug
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/gohugoio/hugo/common/types"
-	"github.com/gohugoio/hugo/htesting"
-)
-
-// Printf is a debug print function that should be removed before committing code to the repository.
-func Printf(format string, args ...any) {
-	panicIfRealCI()
-	if len(args) == 1 && !strings.Contains(format, "%") {
-		format = format + ": %v"
-	}
-	if !strings.HasSuffix(format, "\n") {
-		format = format + "\n"
-	}
-	fmt.Printf(format, args...)
-}
-
-func AssertNotNil(a ...any) {
-	panicIfRealCI()
-	for _, v := range a {
-		if types.IsNil(v) {
-			panic("hdebug.AssertNotNil: value is nil")
-		}
-	}
-}
-
-func Panicf(format string, args ...any) {
-	panicIfRealCI()
-	// fmt.Println(stack())
-	if len(args) == 1 && !strings.Contains(format, "%") {
-		format = format + ": %v"
-	}
-	if !strings.HasSuffix(format, "\n") {
-		format = format + "\n"
-	}
-	panic(fmt.Sprintf(format, args...))
-}
-
-func panicIfRealCI() {
-	if htesting.IsRealCI() {
-		panic("This debug statement should be removed before committing code!")
-	}
-}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2022 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@ package herrors

 import (
 	"io"
+	"io/ioutil"
 	"path/filepath"
 	"strings"

@@ -33,7 +34,7 @@ type LineMatcher struct {
 }

 // LineMatcherFn is used to match a line with an error.
-// It returns the column number or 0 if the line was found, but column could not be determined. Returns -1 if no line match.
+// It returns the column number or 0 if the line was found, but column could not be determinde. Returns -1 if no line match.
 type LineMatcherFn func(m LineMatcher) int

 // SimpleLineMatcher simply matches by line number.
@@ -61,19 +62,10 @@ var OffsetMatcher = func(m LineMatcher) int {
 	return -1
 }

-// ContainsMatcher is a line matcher that matches by line content.
-func ContainsMatcher(text string) func(m LineMatcher) int {
-	return func(m LineMatcher) int {
-		if idx := strings.Index(m.Line, text); idx != -1 {
-			return idx + 1
-		}
-		return -1
-	}
-}
-
 // ErrorContext contains contextual information about an error. This will
 // typically be the lines surrounding some problem in a file.
 type ErrorContext struct {
+
 	// If a match will contain the matched line and up to 2 lines before and after.
 	// Will be empty if no match.
 	Lines []string
@@ -122,7 +114,7 @@ func locateError(r io.Reader, le FileError, matches LineMatcherFn) *ErrorContext

 	ectx := &ErrorContext{LinesPos: -1, Position: text.Position{Offset: -1}}

-	b, err := io.ReadAll(r)
+	b, err := ioutil.ReadAll(r)
 	if err != nil {
 		return ectx
 	}
@@ -152,7 +144,10 @@ func locateError(r io.Reader, le FileError, matches LineMatcherFn) *ErrorContext
 	}

 	if ectx.Position.LineNumber > 0 {
-		low := max(ectx.Position.LineNumber-3, 0)
+		low := ectx.Position.LineNumber - 3
+		if low < 0 {
+			low = 0
+		}

 		if ectx.Position.LineNumber > 2 {
 			ectx.LinesPos = 2
@@ -160,7 +155,10 @@ func locateError(r io.Reader, le FileError, matches LineMatcherFn) *ErrorContext
 			ectx.LinesPos = ectx.Position.LineNumber - 1
 		}

-		high := min(ectx.Position.LineNumber+2, len(lines))
+		high := ectx.Position.LineNumber + 2
+		if high > len(lines) {
+			high = len(lines)
+		}

 		ectx.Lines = lines[low:high]

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2022 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,15 +15,22 @@
 package herrors

 import (
+	"bytes"
 	"errors"
 	"fmt"
-	"os"
-	"regexp"
+	"io"
 	"runtime"
-	"strings"
-	"time"
+	"runtime/debug"
+	"strconv"
 )

+// PrintStackTrace prints the current stacktrace to w.
+func PrintStackTrace(w io.Writer) {
+	buf := make([]byte, 1<<16)
+	runtime.Stack(buf, true)
+	fmt.Fprintf(w, "%s", buf)
+}
+
 // ErrorSender is a, typically, non-blocking error handler.
 type ErrorSender interface {
 	SendError(err error)
@@ -31,78 +38,30 @@ type ErrorSender interface {

 // Recover is a helper function that can be used to capture panics.
 // Put this at the top of a method/function that crashes in a template:
-//
-//	defer herrors.Recover()
+//     defer herrors.Recover()
 func Recover(args ...any) {
 	if r := recover(); r != nil {
 		fmt.Println("ERR:", r)
-		buf := make([]byte, 64<<10)
-		buf = buf[:runtime.Stack(buf, false)]
-		args = append(args, "stacktrace from panic: \n"+string(buf), "\n")
+		args = append(args, "stacktrace from panic: \n"+string(debug.Stack()), "\n")
 		fmt.Println(args...)
 	}
 }

-// IsTimeoutError returns true if the given error is or contains a TimeoutError.
-func IsTimeoutError(err error) bool {
-	return errors.Is(err, &TimeoutError{})
-}
-
-type TimeoutError struct {
-	Duration time.Duration
-}
-
-func (e *TimeoutError) Error() string {
-	return fmt.Sprintf("timeout after %s", e.Duration)
-}
-
-func (e *TimeoutError) Is(target error) bool {
-	_, ok := target.(*TimeoutError)
-	return ok
-}
-
-// errMessage wraps an error with a message.
-type errMessage struct {
-	msg string
-	err error
-}
-
-func (e *errMessage) Error() string {
-	return e.msg
-}
-
-func (e *errMessage) Unwrap() error {
-	return e.err
-}
-
-// IsFeatureNotAvailableError returns true if the given error is or contains a FeatureNotAvailableError.
-func IsFeatureNotAvailableError(err error) bool {
-	return errors.Is(err, &FeatureNotAvailableError{})
+// Get the current goroutine id. Used only for debugging.
+func GetGID() uint64 {
+	b := make([]byte, 64)
+	b = b[:runtime.Stack(b, false)]
+	b = bytes.TrimPrefix(b, []byte("goroutine "))
+	b = b[:bytes.IndexByte(b, ' ')]
+	n, _ := strconv.ParseUint(string(b), 10, 64)
+	return n
 }

 // ErrFeatureNotAvailable denotes that a feature is unavailable.
 //
 // We will, at least to begin with, make some Hugo features (SCSS with libsass) optional,
 // and this error is used to signal those situations.
-var ErrFeatureNotAvailable = &FeatureNotAvailableError{Cause: errors.New("this feature is not available in your current Hugo version, see https://goo.gl/YMrWcn for more information")}
-
-// FeatureNotAvailableError is an error type used to signal that a feature is not available.
-type FeatureNotAvailableError struct {
-	Cause error
-}
-
-func (e *FeatureNotAvailableError) Unwrap() error {
-	return e.Cause
-}
-
-func (e *FeatureNotAvailableError) Error() string {
-	return e.Cause.Error()
-}
-
-func (e *FeatureNotAvailableError) Is(target error) bool {
-	_, ok := target.(*FeatureNotAvailableError)
-	return ok
-}
+var ErrFeatureNotAvailable = errors.New("this feature is not available in your current Hugo version, see https://goo.gl/YMrWcn for more information")

 // Must panics if err != nil.
 func Must(err error) {
@@ -110,71 +69,3 @@ func Must(err error) {
 		panic(err)
 	}
 }
-
-// IsNotExist returns true if the error is a file not found error.
-// Unlike os.IsNotExist, this also considers wrapped errors.
-func IsNotExist(err error) bool {
-	if os.IsNotExist(err) {
-		return true
-	}
-
-	// os.IsNotExist does not consider wrapped errors.
-	if os.IsNotExist(errors.Unwrap(err)) {
-		return true
-	}
-
-	return false
-}
-
-// IsExist returns true if the error is a file exists error.
-// Unlike os.IsExist, this also considers wrapped errors.
-func IsExist(err error) bool {
-	if os.IsExist(err) {
-		return true
-	}
-
-	// os.IsExist does not consider wrapped errors.
-	if os.IsExist(errors.Unwrap(err)) {
-		return true
-	}
-
-	return false
-}
-
-var nilPointerErrRe = regexp.MustCompile(`at <(.*)>: error calling (.*?): runtime error: invalid memory address or nil pointer dereference`)
-
-const deferredPrefix = "__hdeferred/"
-
-var deferredStringToRemove = regexp.MustCompile(`executing "__hdeferred/.*?" `)
-
-// ImproveRenderErr improves the error message for rendering errors.
-func ImproveRenderErr(inErr error) (outErr error) {
-	outErr = inErr
-	msg := improveIfNilPointerMsg(inErr)
-	if msg != "" {
-		outErr = &errMessage{msg: msg, err: outErr}
-	}
-
-	if strings.Contains(inErr.Error(), deferredPrefix) {
-		msg := deferredStringToRemove.ReplaceAllString(inErr.Error(), "executing ")
-		outErr = &errMessage{msg: msg, err: outErr}
-	}
-	return
-}
-
-func improveIfNilPointerMsg(inErr error) string {
-	m := nilPointerErrRe.FindStringSubmatch(inErr.Error())
-	if len(m) == 0 {
-		return ""
-	}
-	call := m[1]
-	field := m[2]
-	parts := strings.Split(call, ".")
-	if len(parts) < 2 {
-		return ""
-	}
-	receiverName := parts[len(parts)-2]
-	receiver := strings.Join(parts[:len(parts)-1], ".")
-	s := fmt.Sprintf("– %s is nil; wrap it in if or with: {{ with %s }}{{ .%s }}{{ end }}", receiverName, receiver, field)
-	return nilPointerErrRe.ReplaceAllString(inErr.Error(), s)
-}
@@ -1,45 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package herrors
-
-import (
-	"errors"
-	"fmt"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-	"github.com/spf13/afero"
-)
-
-func TestIsNotExist(t *testing.T) {
-	c := qt.New(t)
-
-	c.Assert(IsNotExist(afero.ErrFileNotFound), qt.Equals, true)
-	c.Assert(IsNotExist(afero.ErrFileExists), qt.Equals, false)
-	c.Assert(IsNotExist(afero.ErrDestinationExists), qt.Equals, false)
-	c.Assert(IsNotExist(nil), qt.Equals, false)
-
-	c.Assert(IsNotExist(fmt.Errorf("foo")), qt.Equals, false)
-
-	// os.IsNotExist returns false for wrapped errors.
-	c.Assert(IsNotExist(fmt.Errorf("foo: %w", afero.ErrFileNotFound)), qt.Equals, true)
-}
-
-func TestIsFeatureNotAvailableError(t *testing.T) {
-	c := qt.New(t)
-
-	c.Assert(IsFeatureNotAvailableError(ErrFeatureNotAvailable), qt.Equals, true)
-	c.Assert(IsFeatureNotAvailableError(&FeatureNotAvailableError{}), qt.Equals, true)
-	c.Assert(IsFeatureNotAvailableError(errors.New("asdf")), qt.Equals, false)
-}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2022 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,18 +15,19 @@ package herrors

 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"path/filepath"

-	"github.com/bep/godartsass/v2"
+	"github.com/bep/godartsass"
 	"github.com/bep/golibsass/libsass/libsasserrors"
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/text"
 	"github.com/pelletier/go-toml/v2"
 	"github.com/spf13/afero"
 	"github.com/tdewolff/parse/v2"
+
+	"errors"
 )

 // FileError represents an error when handling a file: Parsing a config file,
@@ -34,7 +35,7 @@ import (
 type FileError interface {
 	error

-	// ErrorContext holds some context information about the error.
+	// ErroContext holds some context information about the error.
 	ErrorContext() *ErrorContext

 	text.Positioner
@@ -44,9 +45,6 @@ type FileError interface {

 	// UpdateContent updates the error with a new ErrorContext from the content of the file.
 	UpdateContent(r io.Reader, linematcher LineMatcherFn) FileError
-
-	// SetFilename sets the filename of the error.
-	SetFilename(filename string) FileError
 }

 // Unwrapper can unwrap errors created with fmt.Errorf.
@@ -59,11 +57,6 @@ var (
 	_ Unwrapper = (*fileError)(nil)
 )

-func (fe *fileError) SetFilename(filename string) FileError {
-	fe.position.Filename = filename
-	return fe
-}
-
 func (fe *fileError) UpdatePosition(pos text.Position) FileError {
 	oldFilename := fe.Position().Filename
 	if pos.Filename != "" && fe.fileType == "" {
@@ -110,15 +103,16 @@ func (fe *fileError) UpdateContent(r io.Reader, linematcher LineMatcherFn) FileE

 	fe.errorContext = ectx

-	if ectx.Position.LineNumber > 0 && ectx.Position.LineNumber > fe.position.LineNumber {
+	if ectx.Position.LineNumber > 0 {
 		fe.position.LineNumber = ectx.Position.LineNumber
 	}

-	if ectx.Position.ColumnNumber > 0 && ectx.Position.ColumnNumber > fe.position.ColumnNumber {
+	if ectx.Position.ColumnNumber > 0 {
 		fe.position.ColumnNumber = ectx.Position.ColumnNumber
 	}

 	return fe
+
 }

 type fileError struct {
@@ -177,12 +171,12 @@ func NewFileErrorFromName(err error, name string) FileError {
 	// Filetype is used to determine the Chroma lexer to use.
 	fileType, pos := extractFileTypePos(err)
 	pos.Filename = name
-
 	if fileType == "" {
 		_, fileType = paths.FileAndExtNoDelimiter(filepath.Clean(name))
 	}

 	return &fileError{cause: err, fileType: fileType, position: pos}
+
 }

 // NewFileErrorFromPos will use the filename and line number from pos to create a new FileError, wrapping err.
@@ -193,6 +187,7 @@ func NewFileErrorFromPos(err error, pos text.Position) FileError {
 		_, fileType = paths.FileAndExtNoDelimiter(filepath.Clean(pos.Filename))
 	}
 	return &fileError{cause: err, fileType: fileType, position: pos}
+
 }

 func NewFileErrorFromFileInErr(err error, fs afero.Fs, linematcher LineMatcherFn) FileError {
@@ -235,9 +230,7 @@ func NewFileErrorFromFile(err error, filename string, fs afero.Fs, linematcher L
 		return NewFileErrorFromName(err, realFilename)
 	}
 	defer f.Close()
-	fe := NewFileErrorFromName(err, realFilename)
-	fe = fe.UpdateContent(f, linematcher)
-	return fe
+	return NewFileErrorFromName(err, realFilename).UpdateContent(f, linematcher)
 }

 func openFile(filename string, fs afero.Fs) (afero.File, string, error) {
@@ -251,6 +244,7 @@ func openFile(filename string, fs afero.Fs) (afero.File, string, error) {
 		}); ok {
 			realFilename = s.Filename()
 		}
+
 	}

 	f, err2 := fs.Open(filename)
@@ -261,79 +255,16 @@ func openFile(filename string, fs afero.Fs) (afero.File, string, error) {
 	return f, realFilename, nil
 }

-// Cause returns the underlying error, that is,
-// it unwraps errors until it finds one that does not implement
-// the Unwrap method.
-// For a shallow variant, see Unwrap.
+// Cause returns the underlying error or itself if it does not implement Unwrap.
 func Cause(err error) error {
-	type unwrapper interface {
-		Unwrap() error
-	}
-
-	for err != nil {
-		cause, ok := err.(unwrapper)
-		if !ok {
-			break
-		}
-		err = cause.Unwrap()
-	}
-	return err
-}
-
-// Unwrap returns the underlying error or itself if it does not implement Unwrap.
-func Unwrap(err error) error {
 	if u := errors.Unwrap(err); u != nil {
 		return u
 	}
 	return err
 }

-// UnwrapFileErrors returns all FileError contained in err.
-func UnwrapFileErrors(err error) []FileError {
-	if err == nil {
-		return nil
-	}
-	errs := Errors(err)
-	var fileErrors []FileError
-	for _, e := range errs {
-		if v, ok := e.(FileError); ok {
-			fileErrors = append(fileErrors, v)
-		}
-		fileErrors = append(fileErrors, UnwrapFileErrors(errors.Unwrap(e))...)
-	}
-	return fileErrors
-}
-
-// UnwrapFileErrorsWithErrorContext tries to unwrap all FileError in err that has an ErrorContext.
-func UnwrapFileErrorsWithErrorContext(err error) []FileError {
-	errs := UnwrapFileErrors(err)
-	var n int
-	for _, e := range errs {
-		if e.ErrorContext() != nil {
-			errs[n] = e
-			n++
-		}
-	}
-	return errs[:n]
-}
-
-// Errors returns the list of errors contained in err.
-func Errors(err error) []error {
-	if err == nil {
-		return nil
-	}
-
-	type unwrapper interface {
-		Unwrap() []error
-	}
-	if u, ok := err.(unwrapper); ok {
-		return u.Unwrap()
-	}
-	return []error{err}
-}
-
 func extractFileTypePos(err error) (string, text.Position) {
-	err = Unwrap(err)
+	err = Cause(err)

 	var fileType string

@@ -361,16 +292,20 @@ func extractFileTypePos(err error) (string, text.Position) {
 	}

 	// The error type from the minifier contains line number and column number.
-	if line, col := extractLineNumberAndColumnNumber(err); line >= 0 {
+	if line, col := exctractLineNumberAndColumnNumber(err); line >= 0 {
 		pos.LineNumber = line
 		pos.ColumnNumber = col
 		return fileType, pos
 	}

 	// Look in the error message for the line number.
-	if lno, col := commonLineNumberExtractor(err); lno > 0 {
-		pos.ColumnNumber = col
-		pos.LineNumber = lno
+	for _, handle := range lineNumberExtractors {
+		lno, col := handle(err)
+		if lno > 0 {
+			pos.ColumnNumber = col
+			pos.LineNumber = lno
+			break
+		}
 	}

 	if fileType == "" && pos.Filename != "" {
@@ -394,6 +329,30 @@ func UnwrapFileError(err error) FileError {
 	return nil
 }

+// UnwrapFileErrors tries to unwrap all FileError.
+func UnwrapFileErrors(err error) []FileError {
+	var errs []FileError
+	for err != nil {
+		if v, ok := err.(FileError); ok {
+			errs = append(errs, v)
+		}
+		err = errors.Unwrap(err)
+	}
+	return errs
+}
+
+// UnwrapFileErrorsWithErrorContext tries to unwrap all FileError in err that has an ErrorContext.
+func UnwrapFileErrorsWithErrorContext(err error) []FileError {
+	var errs []FileError
+	for err != nil {
+		if v, ok := err.(FileError); ok && v.ErrorContext() != nil {
+			errs = append(errs, v)
+		}
+		err = errors.Unwrap(err)
+	}
+	return errs
+}
+
 func extractOffsetAndType(e error) (int, string) {
 	switch v := e.(type) {
 	case *json.UnmarshalTypeError:
@@ -405,7 +364,7 @@ func extractOffsetAndType(e error) (int, string) {
 	}
 }

-func extractLineNumberAndColumnNumber(e error) (int, int) {
+func exctractLineNumberAndColumnNumber(e error) (int, int) {
 	switch v := e.(type) {
 	case *parse.Error:
 		return v.Line, v.Column
@@ -422,7 +381,7 @@ func extractPosition(e error) (pos text.Position) {
 	case godartsass.SassError:
 		span := v.Span
 		start := span.Start
-		filename, _ := paths.UrlStringToFilename(span.Url)
+		filename, _ := paths.UrlToFilename(span.Url)
 		pos.Filename = filename
 		pos.Offset = start.Offset
 		pos.ColumnNumber = start.Column
@@ -433,17 +392,3 @@ func extractPosition(e error) (pos text.Position) {
 	}
 	return
 }
-
-// TextSegmentError is an error with a text segment attached.
-type TextSegmentError struct {
-	Segment string
-	Err     error
-}
-
-func (e TextSegmentError) Unwrap() error {
-	return e.Err
-}
-
-func (e TextSegmentError) Error() string {
-	return e.Err.Error()
-}
@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2022 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,11 +14,12 @@
 package herrors

 import (
-	"errors"
 	"fmt"
 	"strings"
 	"testing"

+	"errors"
+
 	"github.com/gohugoio/hugo/common/text"

 	qt "github.com/frankban/quicktest"
@@ -32,21 +33,22 @@ func TestNewFileError(t *testing.T) {
 	fe := NewFileErrorFromName(errors.New("bar"), "foo.html")
 	c.Assert(fe.Error(), qt.Equals, `"foo.html:1:1": bar`)

-	var lines strings.Builder
+	lines := ""
 	for i := 1; i <= 100; i++ {
-		lines.WriteString(fmt.Sprintf("line %d\n", i))
+		lines += fmt.Sprintf("line %d\n", i)
 	}

 	fe.UpdatePosition(text.Position{LineNumber: 32, ColumnNumber: 2})
 	c.Assert(fe.Error(), qt.Equals, `"foo.html:32:2": bar`)
 	fe.UpdatePosition(text.Position{LineNumber: 0, ColumnNumber: 0, Offset: 212})
-	fe.UpdateContent(strings.NewReader(lines.String()), nil)
+	fe.UpdateContent(strings.NewReader(lines), nil)
 	c.Assert(fe.Error(), qt.Equals, `"foo.html:32:0": bar`)
 	errorContext := fe.ErrorContext()
 	c.Assert(errorContext, qt.IsNotNil)
 	c.Assert(errorContext.Lines, qt.DeepEquals, []string{"line 30", "line 31", "line 32", "line 33", "line 34"})
 	c.Assert(errorContext.LinesPos, qt.Equals, 2)
 	c.Assert(errorContext.ChromaLexer, qt.Equals, "go-html-template")
+
 }

 func TestNewFileErrorExtractFromMessage(t *testing.T) {
@@ -19,27 +19,17 @@ import (
 )

 var lineNumberExtractors = []lineNumberExtractor{
-	// YAML parse errors.
-	newLineNumberErrHandlerFromRegexp(`\[(\d+):(\d+)\]`),
-
 	// Template/shortcode parse errors
 	newLineNumberErrHandlerFromRegexp(`:(\d+):(\d*):`),
 	newLineNumberErrHandlerFromRegexp(`:(\d+):`),

+	// YAML parse errors
+	newLineNumberErrHandlerFromRegexp(`line (\d+):`),
+
 	// i18n bundle errors
 	newLineNumberErrHandlerFromRegexp(`\((\d+),\s(\d*)`),
 }

-func commonLineNumberExtractor(e error) (int, int) {
-	for _, handler := range lineNumberExtractors {
-		lno, col := handler(e)
-		if lno > 0 {
-			return lno, col
-		}
-	}
-	return 0, 0
-}
-
 type lineNumberExtractor func(e error) (int, int)

 func newLineNumberErrHandlerFromRegexp(expression string) lineNumberExtractor {
@@ -1,31 +0,0 @@
-// Copyright 2025 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package herrors
-
-import (
-	"errors"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestCommonLineNumberExtractor(t *testing.T) {
-	t.Parallel()
-
-	c := qt.New(t)
-
-	lno, col := commonLineNumberExtractor(errors.New("[4:9] value is not allowed in this context"))
-	c.Assert(lno, qt.Equals, 4)
-	c.Assert(col, qt.Equals, 9)
-}
@@ -1,30 +0,0 @@
-// Copyright 2026 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package hexec
-
-import (
-	_ "embed"
-	"encoding/base64"
-	"sync"
-)
-
-//go:embed esmloader.mjs
-var esmLoaderSource string
-
-// nodeESMLoaderImportArg returns a "--import=data:..." argument that installs
-// a Node.js ESM resolver hook making NODE_PATH a fallback for failed bare
-// imports. See esmloader.mjs for the rationale.
-var nodeESMLoaderImportArg = sync.OnceValue(func() string {
-	return "--import=data:text/javascript;base64," + base64.StdEncoding.EncodeToString([]byte(esmLoaderSource))
-})
@@ -1,61 +0,0 @@
-// Node.js ESM resolver hook installed by Hugo.
-//
-// Node's ESM resolver does not consult NODE_PATH, unlike CJS require().
-// That breaks postcss.config.js / babel.config.js / etc. files written in
-// ESM and loaded from outside the project tree (typically the Hugo module
-// cache): bare imports like `import x from "postcss-import"` cannot be
-// resolved by walking up from the file's location.
-//
-// This hook makes the ESM resolver fall back to NODE_PATH for bare
-// specifiers when Node's normal resolution fails. It is a no-op for
-// relative/absolute paths and URL-scheme specifiers, and it never fires
-// unless Node would itself have thrown ERR_MODULE_NOT_FOUND or
-// ERR_ACCESS_DENIED.
-//
-// ERR_ACCESS_DENIED is handled because Node's resolver walks up the
-// directory tree looking for node_modules. Under the permission model that
-// walk can hit a node_modules outside the allow-list (e.g. Netlify stores
-// its node_modules cache in the same tree as the Hugo file cache), aborting
-// resolution even though the package is reachable via NODE_PATH. If the
-// NODE_PATH fallback also fails we re-throw the original error so the
-// access-denied resource is still reported.
-//
-// Uses the synchronous registerHooks API so it runs on the main thread and
-// does not require --allow-worker under the Node permission model.
-
-import { registerHooks, createRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
-
-const resolvers = [];
-const np = process.env.NODE_PATH;
-if (np) {
-	const sep = process.platform === 'win32' ? ';' : ':';
-	for (const p of np.split(sep)) {
-		if (p) resolvers.push(createRequire(p + '/_'));
-	}
-}
-
-function isBareSpecifier(s) {
-	if (!s) return false;
-	if (s.startsWith('.') || s.startsWith('/') || s.startsWith('#')) return false;
-	if (/^[a-z][a-z0-9+.-]*:/i.test(s)) return false;
-	return true;
-}
-
-registerHooks({
-	resolve(specifier, context, nextResolve) {
-		try {
-			return nextResolve(specifier, context);
-		} catch (err) {
-			if (err?.code !== 'ERR_MODULE_NOT_FOUND' && err?.code !== 'ERR_ACCESS_DENIED') throw err;
-			if (!isBareSpecifier(specifier)) throw err;
-			for (const r of resolvers) {
-				try {
-					const resolved = r.resolve(specifier);
-					return { url: pathToFileURL(resolved).href, shortCircuit: true, format: null };
-				} catch (_) { /* try next */ }
-			}
-			throw err;
-		}
-	},
-});
@@ -1,4 +1,4 @@
-// Copyright 2026 The Hugo Authors. All rights reserved.
+// Copyright 2020 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,22 +14,18 @@
 package hexec

 import (
-	"bufio"
 	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
 	"regexp"
-	"slices"
 	"strings"

-	"github.com/bep/logg"
-	"github.com/gohugoio/hugo/common/hmaps"
-	"github.com/gohugoio/hugo/common/loggers"
+	"os"
+	"os/exec"
+
+	"github.com/cli/safeexec"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/security"
 )
@@ -89,7 +85,7 @@ var WithEnviron = func(env []string) func(c *commandeer) {
 }

 // New creates a new Exec using the provided security config.
-func New(cfg security.Config, workingDir string, log loggers.Logger) *Exec {
+func New(cfg security.Config) *Exec {
 	var baseEnviron []string
 	for _, v := range os.Environ() {
 		k, _ := config.SplitEnvVar(v)
@@ -99,11 +95,8 @@ func New(cfg security.Config, workingDir string, log loggers.Logger) *Exec {
 	}

 	return &Exec{
-		sc:              cfg,
-		workingDir:      workingDir,
-		infol:           log.InfoCommand("exec"),
-		baseEnviron:     baseEnviron,
-		nodeRunnerCache: hmaps.NewCache[string, func(arg ...any) (Runner, error)](),
+		sc:          cfg,
+		baseEnviron: baseEnviron,
 	}
 }

@@ -113,34 +106,29 @@ func IsNotFound(err error) bool {
 	return errors.As(err, &notFoundErr)
 }

-// Exec enforces a security policy for commands run via os/exec.
+// SafeCommand is a wrapper around os/exec Command which uses a LookPath
+// implementation that does not search in current directory before looking in PATH.
+// See https://github.com/cli/safeexec and the linked issues.
+func SafeCommand(name string, arg ...string) (*exec.Cmd, error) {
+	bin, err := safeexec.LookPath(name)
+	if err != nil {
+		return nil, err
+	}
+
+	return exec.Command(bin, arg...), nil
+}
+
+// Exec encorces a security policy for commands run via os/exec.
 type Exec struct {
-	sc         security.Config
-	workingDir string
-	infol      logg.LevelLogger
+	sc security.Config

 	// os.Environ filtered by the Exec.OsEnviron whitelist filter.
 	baseEnviron []string
-
-	// Additional absolute paths to allow reading from in the Node.js permission model.
-	nodeReadPaths []string
-
-	nodeRunnerCache *hmaps.Cache[string, func(arg ...any) (Runner, error)]
-}
-
-// SetNodeReadPaths sets additional absolute paths to allow reading from
-// in the Node.js permission model (e.g. Hugo module cache directories).
-func (e *Exec) SetNodeReadPaths(paths []string) {
-	e.nodeReadPaths = paths
-}
-
-func (e *Exec) New(name string, arg ...any) (Runner, error) {
-	return e.new(name, "", arg...)
 }

 // New will fail if name is not allowed according to the configured security policy.
 // Else a configured Runner will be returned ready to be Run.
-func (e *Exec) new(name string, fullyQualifiedName string, arg ...any) (Runner, error) {
+func (e *Exec) New(name string, arg ...any) (Runner, error) {
 	if err := e.sc.CheckAllowedExec(name); err != nil {
 		return nil, err
 	}
@@ -149,278 +137,18 @@ func (e *Exec) new(name string, fullyQualifiedName string, arg ...any) (Runner,
 	copy(env, e.baseEnviron)

 	cm := &commandeer{
-		name:               name,
-		fullyQualifiedName: fullyQualifiedName,
-		env:                env,
+		name: name,
+		env:  env,
 	}

 	return cm.command(arg...)
+
 }

-type binaryLocation int
-
-func (b binaryLocation) String() string {
-	switch b {
-	case binaryLocationNodeModules:
-		return "node_modules/.bin"
-	case binaryLocationPath:
-		return "PATH"
-	}
-	return "unknown"
-}
-
-const (
-	binaryLocationNodeModules binaryLocation = iota + 1
-	binaryLocationPath
-)
-
-// Npx finds and runs a Node.js tool. The binary is located first in
-// WORKINGDIR/node_modules/.bin, then in PATH. The tool is always invoked via
-// "node [--permission <flags>] <script> <args>"; the --permission flags are
-// added when the Node.js permission model is enabled.
+// Npx is a convenience method to create a Runner running npx --no-install <name> <args.
 func (e *Exec) Npx(name string, arg ...any) (Runner, error) {
-	if err := e.sc.CheckAllowedExec(name); err != nil {
-		return nil, err
-	}
-	if err := e.sc.CheckAllowedExec("node"); err != nil {
-		// Legacy path: We replaced npx with node in v0.161.0, and anyone using these tools with a custom security.exec.allow list
-		// would get an error when upgrading. To avoid this, check for npx as well.
-		if err2 := e.sc.CheckAllowedExec("npx"); err2 != nil {
-			return nil, err
-		}
-	}
-
-	newRunner, err := e.nodeRunnerCache.GetOrCreate(name, func() (func(...any) (Runner, error), error) {
-		var resolvedBin string
-		var loc binaryLocation
-
-		nodeBinFilename := filepath.Join(e.workingDir, nodeModulesBinPath, name)
-		if p, err := exec.LookPath(nodeBinFilename); err == nil {
-			resolvedBin = p
-			loc = binaryLocationNodeModules
-		} else if p, err := exec.LookPath(name); err == nil {
-			resolvedBin = p
-			loc = binaryLocationPath
-		} else {
-			return nil, &NotFoundError{name: name, method: "in PATH"}
-		}
-
-		scriptPath := resolveNodeBin(resolvedBin)
-
-		e.infol.WithFields(logg.Fields{
-			logg.Field{Name: "location", Value: loc},
-			logg.Field{Name: "bin", Value: resolvedBin},
-			logg.Field{Name: "script", Value: scriptPath},
-		}).Logf("resolve %q", name)
-
-		if scriptPath == "" {
-			return nil, fmt.Errorf("binary %q is not a Node.js script", name)
-		}
-
-		return func(arg2 ...any) (Runner, error) {
-			return e.newNode(name, scriptPath, arg2...)
-		}, nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return newRunner(arg...)
-}
-
-// newNode runs a Node.js script via "node [--permission <flags>] <scriptPath> <args>".
-func (e *Exec) newNode(name, scriptPath string, arg ...any) (Runner, error) {
-	var allArgs []any
-	for _, pa := range e.nodePermissionArgs(name, scriptPath) {
-		allArgs = append(allArgs, pa)
-	}
-	// Install an ESM resolver hook that makes NODE_PATH a fallback for failed
-	// bare imports, so postcss.config.js / babel.config.js / etc. written in
-	// ESM work when loaded from the Hugo module cache. See esmloader.mjs.
-	allArgs = append(allArgs, nodeESMLoaderImportArg())
-	allArgs = append(allArgs, scriptPath)
-	allArgs = append(allArgs, arg...)
-	// When the script lives outside the working dir (a globally installed
-	// tool), point NODE_PATH at the script's node_modules ancestor so Node's
-	// resolver (and tools that honor it, e.g. tailwindcss v4) can locate the
-	// tool's sibling packages. tailwindcss v4's CSS resolver treats NODE_PATH
-	// as a single path, not a list, so we don't concatenate with the local
-	// path here. For local installs the caller's NODE_PATH (set by
-	// hugo.GetExecEnviron to <workDir>/node_modules) already covers the need.
-	localNM := filepath.Join(e.workingDir, "node_modules")
-	if p := nodeScriptReadPath(scriptPath); p != "" && p != localNM {
-		allArgs = append(allArgs, WithEnviron([]string{"NODE_PATH=" + p}))
-	}
-
-	return e.New("node", allArgs...)
-}
-
-// nodePermissionArgs builds the Node.js --permission flags from the security config.
-func (e *Exec) nodePermissionArgs(name, scriptPath string) []string {
-	perms := e.sc.Node.Permissions
-	if !perms.IsEnabled() {
-		return nil
-	}
-
-	args := []string{"--permission"}
-
-	for _, p := range e.resolveNodePermPaths(perms.AllowRead) {
-		args = append(args, "--allow-fs-read="+p)
-	}
-	for _, p := range e.nodeReadPaths {
-		args = append(args, "--allow-fs-read="+p)
-	}
-	if p := nodeScriptReadPath(scriptPath); p != "" {
-		args = append(args, "--allow-fs-read="+p)
-	}
-
-	for _, p := range e.resolveNodePermPaths(perms.AllowWrite) {
-		args = append(args, "--allow-fs-write="+p)
-	}
-
-	var silenceSecurityWarnings bool
-	if slices.Contains(perms.AllowAddons, name) {
-		silenceSecurityWarnings = true
-		args = append(args, "--allow-addons")
-	}
-
-	if slices.Contains(perms.AllowWorker, name) {
-		silenceSecurityWarnings = true
-		args = append(args, "--allow-worker")
-	}
-
-	if slices.Contains(perms.AllowChildProcess, name) {
-		silenceSecurityWarnings = true
-		args = append(args, "--allow-child-process")
-	}
-
-	if silenceSecurityWarnings {
-		// There are no more fine grained way to do this, see https://github.com/nodejs/node/issues/59818
-		// If the process is configured to allow either workers or addons, Node will print warnings that's not very helpful.
-		args = append(args, "--disable-warning=SecurityWarning")
-	}
-
-	return args
-}
-
-// resolveNodePermPaths resolves relative paths against the working directory.
-func (e *Exec) resolveNodePermPaths(paths []string) []string {
-	resolved := make([]string, len(paths))
-	for i, p := range paths {
-		switch {
-		case p == "*":
-			resolved[i] = "*"
-		case filepath.IsAbs(p):
-			resolved[i] = p
-		default:
-			resolved[i] = filepath.Join(e.workingDir, p)
-		}
-	}
-	return resolved
-}
-
-const nodeModulesBinPath = "node_modules/.bin"
-
-// nodeScriptReadPath returns a path to add to the Node.js read allow-list so
-// a script can load its dependencies. For scripts inside a node_modules tree
-// it returns the nearest ancestor "node_modules" directory, so both nested
-// and hoisted deps are reachable. Otherwise the script's own directory.
-func nodeScriptReadPath(scriptPath string) string {
-	if scriptPath == "" {
-		return ""
-	}
-	dir := filepath.Dir(scriptPath)
-	for {
-		if filepath.Base(dir) == "node_modules" {
-			return dir
-		}
-		parent := filepath.Dir(dir)
-		if parent == dir {
-			return filepath.Dir(scriptPath)
-		}
-		dir = parent
-	}
-}
-
-// resolveNodeBin resolves a binary path to the underlying Node.js script.
-// Returns the path to the JS entry point, or "" if the binary is not a Node script.
-func resolveNodeBin(path string) string {
-	// 1. If the file is a symlink, resolve it (macOS/Linux npm creates symlinks in node_modules/.bin).
-	if info, err := os.Lstat(path); err == nil && info.Mode()&os.ModeSymlink != 0 {
-		if resolved, err := filepath.EvalSymlinks(path); err == nil {
-			if hasJSExtension(resolved) || isNodeScript(resolved) {
-				return resolved
-			}
-		}
-		return ""
-	}
-	// 2. Check if the file itself is a Node script (e.g. globally installed with #!/usr/bin/env node).
-	if isNodeScript(path) {
-		return path
-	}
-	// 3. Try extracting JS entry point from an npm wrapper script (.cmd or shell).
-	return extractNodeEntryPoint(path)
-}
-
-// nodeEntryPointRe matches a relative path in npm-generated wrapper scripts.
-// The entry may be a .js/.mjs/.cjs file or an extensionless Node shebang
-// script (e.g. postcss-cli 7's bin/postcss). Local installs reference the
-// entry via "..", global installs via "node_modules" (notably on Windows,
-// where npm does not symlink global binaries).
-// Examples:
-//
-//	Local shell:  "$basedir/../postcss-cli/index.js"
-//	Local cmd:    "%dp0%\..\postcss-cli\index.js"
-//	Scoped:       "$basedir/../@babel/cli/bin/babel.js"
-//	No ext:       "%dp0%\..\postcss-cli\bin\postcss"
-//	Global shell: "$basedir/node_modules/postcss-cli/index.js"
-//	Global cmd:   "%dp0%\node_modules\postcss-cli\index.js"
-var nodeEntryPointRe = regexp.MustCompile(`[/\\]((?:\.\.|node_modules)[/\\][\w@][\w@./\\-]*)`)
-
-// extractNodeEntryPoint reads an npm wrapper script and extracts the Node
-// entry point path, validating that it's a JS file or a Node shebang script.
-func extractNodeEntryPoint(wrapperPath string) string {
-	data, err := os.ReadFile(wrapperPath)
-	if err != nil {
-		return ""
-	}
-	m := nodeEntryPointRe.FindSubmatch(data)
-	if m == nil {
-		return ""
-	}
-	// Normalize backslashes from Windows .cmd wrappers.
-	relPath := strings.ReplaceAll(string(m[1]), "\\", "/")
-	resolved := filepath.Join(filepath.Dir(wrapperPath), relPath)
-	if _, err := os.Stat(resolved); err != nil {
-		return ""
-	}
-	if !hasJSExtension(resolved) && !isNodeScript(resolved) {
-		return ""
-	}
-	return resolved
-}
-
-func hasJSExtension(path string) bool {
-	switch filepath.Ext(path) {
-	case ".js", ".mjs", ".cjs":
-		return true
-	}
-	return false
-}
-
-// isNodeScript reports whether the file at path has a Node.js shebang.
-func isNodeScript(path string) bool {
-	f, err := os.Open(path)
-	if err != nil {
-		return false
-	}
-	defer f.Close()
-	r := bufio.NewReader(f)
-	line, err := r.ReadString('\n')
-	if err != nil && len(line) == 0 {
-		return false
-	}
-	return strings.HasPrefix(line, "#!") && strings.Contains(line, "node")
+	arg = append(arg[:0], append([]any{"--no-install", name}, arg[0:]...)...)
+	return e.New("npx", arg...)
 }

 // Sec returns the security policies this Exec is configured with.
@@ -429,12 +157,11 @@ func (e *Exec) Sec() security.Config {
 }

 type NotFoundError struct {
-	name   string
-	method string
+	name string
 }

 func (e *NotFoundError) Error() string {
-	return fmt.Sprintf("binary with name %q not found %s", e.name, e.method)
+	return fmt.Sprintf("binary with name %q not found", e.name)
 }

 // Runner wraps a *os.Cmd.
@@ -458,7 +185,7 @@ func (c *cmdWrapper) Run() error {
 		return nil
 	}
 	if notFoundRe.MatchString(c.outerr.String()) {
-		return &NotFoundError{name: c.name, method: "in PATH"}
+		return &NotFoundError{name: c.name}
 	}
 	return fmt.Errorf("failed to execute binary %q with args %v: %s", c.name, c.c.Args[1:], c.outerr.String())
 }
@@ -474,9 +201,8 @@ type commandeer struct {
 	dir    string
 	ctx    context.Context

-	name               string
-	fullyQualifiedName string
-	env                []string
+	name string
+	env  []string
 }

 func (c *commandeer) command(arg ...any) (*cmdWrapper, error) {
@@ -496,17 +222,10 @@ func (c *commandeer) command(arg ...any) (*cmdWrapper, error) {
 		}
 	}

-	var bin string
-	if c.fullyQualifiedName != "" {
-		bin = c.fullyQualifiedName
-	} else {
-		var err error
-		bin, err = exec.LookPath(c.name)
-		if err != nil {
-			return nil, &NotFoundError{
-				name:   c.name,
-				method: "in PATH",
-			}
+	bin, err := safeexec.LookPath(c.name)
+	if err != nil {
+		return nil, &NotFoundError{
+			name: c.name,
 		}
 	}

@@ -539,7 +258,7 @@ func InPath(binaryName string) bool {
 	if strings.Contains(binaryName, "/") {
 		panic("binary name should not contain any slash")
 	}
-	_, err := exec.LookPath(binaryName)
+	_, err := safeexec.LookPath(binaryName)
 	return err == nil
 }

@@ -549,7 +268,7 @@ func LookPath(binaryName string) string {
 	if strings.Contains(binaryName, "/") {
 		panic("binary name should not contain any slash")
 	}
-	s, err := exec.LookPath(binaryName)
+	s, err := safeexec.LookPath(binaryName)
 	if err != nil {
 		return ""
 	}
@@ -1,74 +0,0 @@
-// Copyright 2026 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package hexec_test
-
-import (
-	"testing"
-
-	"github.com/gohugoio/hugo/htesting"
-	"github.com/gohugoio/hugo/hugolib"
-)
-
-func TestNPMGlobalInstalls(t *testing.T) {
-	if !htesting.IsRealCI() {
-		t.Skip("We only ever want to run this in CI.")
-	}
-	files := `
-- hugo.toml --
-disableKinds = ["taxonomy", "term"]
-[security.exec]
-allow = ['^(babel|node|postcss|tailwindcss)$']
-
-- package.json --
-{}
-- hugo_stats.json --
-- assets/js/main.js --
-console.log("Hello, world!");
-- assets/css/main1.css --
-body { color: red }
-- assets/css/main2.css --
-@import "tailwindcss";
-@plugin "@tailwindcss/typography";
-@source "hugo_stats.json";
-body { color: blue }
-- layouts/home.html --
-{{ with resources.Get "css/main1.css"  }}
-	{{ with . | css.PostCSS  }}
-		 CSS1: {{ .RelPermalink }}|{{ gt (.Content | len) 10 }}|
-	{{ end }}
-{{ end }}
- {{ with resources.Get "css/main2.css" }}
-	{{ with . | css.TailwindCSS  }}
-		 CSS2: {{ .RelPermalink }}|{{ gt (.Content | len) 10 }}|
-	{{ end }}
-{{ end }}
-{{ with resources.Get "js/main.js" }}
-	{{ with . | js.Babel  }}
-		 JS: {{ .RelPermalink }}|{{ gt (.Content | len) 10 }}|
-	{{ end }}
-{{ end }}
-`
-
-	b := hugolib.Test(t, files, hugolib.TestOptOsFs(), hugolib.TestOptWithNpmInstallGlobal(
-		"postcss", "postcss-cli",
-		"@babel/core", "@babel/cli",
-		"tailwindcss", "@tailwindcss/cli", "@tailwindcss/typography",
-	))
-
-	b.AssertFileContent("public/index.html",
-		"CSS1: /css/main1.css|true|",
-		"CSS2: /css/main2.css|true|",
-		"JS: /js/main.js|true|",
-	)
-}
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`gobench -package=./hugolib -bench="BenchmarkSiteNew/Deep_content_tree"`
				`@@ -0,0 +1 @@`
				`docker run --rm --mount type=bind,source="$(pwd)",target=/hugo -w /hugo -i -t bepsays/ci-goreleaser:1.11-2 /bin/bash`