deploy: Fix CloudFront invalidation with AWS SDK2

.circleci/config.yml

@@ -4,7 +4,7 @@ parameters:
 defaults: &defaults
   resource_class: large
   docker:
-      - image: bepsays/ci-hugoreleaser:1.22300.20200
+      - image: bepsays/ci-hugoreleaser:1.22100.20600
 environment: &buildenv
       GOMODCACHE: /root/project/gomodcache
 version: 2
@@ -14,7 +14,9 @@ jobs:
     environment: &buildenv
         GOMODCACHE: /root/project/gomodcache
     steps:
-      - setup_remote_docker
+      - &remote-docker
+        setup_remote_docker: 
+          version: 20.10.14
       - checkout: 
           path: hugo
       - &git-config
@@ -58,7 +60,7 @@ jobs:
     environment:
         <<: [*buildenv]
     docker:
-    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22300.20200
+    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22100.20600
     steps:
       - *restore-cache
       - &attach-workspace

.github/workflows/image.yml

@@ -1,48 +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@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81 # v5.5.1
-        with:
-          images: ${{ env.REGISTRY_IMAGE }}
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db # v3.6.1
-
-      - name: Login to GHCR
-        # Login is only needed when the image is pushed
-        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3.3.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build and push
-        id: build
-        uses: docker/build-push-action@16ebe778df0e7752d2cfcbd924afdbbd89c1a755 # v6.6.1
-        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 }}

.github/workflows/stale.yml

@@ -12,7 +12,7 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: dessant/lock-threads@7de207be1d3ce97a9abe6ff1306222982d1ca9f9 # v5.0.1
+      - uses: dessant/lock-threads@08e671be8ac8944d0e132aa71d0ae8ccfb347675
         with:
           issue-inactive-days: 21
           add-issue-labels: 'Outdated'
@@ -24,7 +24,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@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9.0.0
+      - uses: actions/stale@04a1828bc18ada028d85a0252a47cd2963a91abe
         with:
           operations-per-run: 999
           days-before-issue-stale: 365

.github/workflows/test-dart-sass-v1.yml

@@ -0,0 +1,73 @@
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+name: TestDartSassV1
+env:
+    GOPROXY: https://proxy.golang.org
+    GO111MODULE: on
+    DART_SASS_VERSION: 1.62.1
+    DART_SASS_SHA_LINUX: 3574da75a7322a539034648b8ff84ff2cca162eb924d72b663d718cd3936f075
+permissions:
+  contents: read
+jobs:
+  test:
+    strategy:
+      matrix:
+        go-version: [1.21.x]
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+    - name: Install Go
+      uses: actions/setup-go@fac708d6674e30b6ba41289acaab6d4b75aa0753
+      with:
+        go-version: ${{ matrix.go-version }}
+        check-latest: true
+        cache: true
+        cache-dependency-path: |
+          **/go.sum
+          **/go.mod
+    - name: Install Ruby
+      uses: ruby/setup-ruby@036ef458ddccddb148a2b9fb67e95a22fdbf728b
+      with:
+        ruby-version: '2.7' 
+        bundler-cache: true #
+    - name: Install Python
+      uses: actions/setup-python@3105fb18c05ddd93efea5f9e0bef7a03a6e9e7df
+      with:
+        python-version: '3.x'
+    - name: Install Mage
+      run: go install github.com/magefile/mage@v1.15.0
+    - name: Install asciidoctor
+      uses: reitzig/actions-asciidoctor@7570212ae20b63653481675fb1ff62d1073632b0
+    - 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 -PackageName pandoc
+    - run: pandoc -v
+    - name: Install dart-sass-embedded Linux
+      run: |
+        echo "Install Dart Sass version ${DART_SASS_VERSION} ..."
+        curl -LJO "https://github.com/sass/dart-sass-embedded/releases/download/${DART_SASS_VERSION}/sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz";
+        echo "${DART_SASS_SHA_LINUX}  sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
+        tar -xvf "sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz";
+        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
+    - name: Check
+      run: |
+        dart-sass-embedded --version
+        mage -v check;
+      env:
+        HUGO_BUILD_TAGS: extended

.github/workflows/test.yml

@@ -1,132 +1,119 @@
 on:
   push:
-    branches: [master]
+    branches: [ master ]
   pull_request:
 name: Test
 env:
-  GOPROXY: https://proxy.golang.org
-  GO111MODULE: on
-  SASS_VERSION: 1.63.2
-  DART_SASS_SHA_LINUX: 3ea33c95ad5c35fda6e9a0956199eef38a398f496cfb8750e02479d7d1dd42af
-  DART_SASS_SHA_MACOS: 11c70f259836b250b44a9cb57fed70e030f21f45069b467d371685855f1eb4f0
-  DART_SASS_SHA_WINDOWS: cd8cd36a619dd8e27f93d3186c52d70eb7d69472aa6c85f5094b29693e773f64
+    GOPROXY: https://proxy.golang.org
+    GO111MODULE: on
+    SASS_VERSION: 1.63.2
+    DART_SASS_SHA_LINUX: 3ea33c95ad5c35fda6e9a0956199eef38a398f496cfb8750e02479d7d1dd42af
+    DART_SASS_SHA_MACOS: 11c70f259836b250b44a9cb57fed70e030f21f45069b467d371685855f1eb4f0
+    DART_SASS_SHA_WINDOWS: cd8cd36a619dd8e27f93d3186c52d70eb7d69472aa6c85f5094b29693e773f64
 permissions:
   contents: read
 jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.22.x, 1.23.x]
-        os: [ubuntu-latest, windows-latest] # macos disabled for now because of disk space issues.
+        go-version: [1.20.x,1.21.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:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: false
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: true
-          swap-storage: true
-      - name: Checkout code
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
-      - name: Install Go
-        uses: actions/setup-go@0a12ed9d6a96ab950c8f026ed9f722fe0da7ef32 # v5.0.2
-        with:
-          go-version: ${{ matrix.go-version }}
-          check-latest: true
-          cache: true
-          cache-dependency-path: |
-            **/go.sum
-            **/go.mod
-      - name: Install Ruby
-        uses: ruby/setup-ruby@a6e6f86333f0a2523ece813039b8b4be04560854 # v1.190.0
-        with:
-          ruby-version: "2.7"
-          bundler-cache: true #
-      - name: Install Python
-        uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f # v5.1.1
-        with:
-          python-version: "3.x"
-      - name: Install Mage
-        run: go install github.com/magefile/mage@v1.15.0
-      - name: Install asciidoctor
-        uses: reitzig/actions-asciidoctor@c642db5eedd1d729bb8c92034770d0b2f769eda6 # v2.0.2
-      - name: Install docutils
-        run: |
-          pip install docutils
-          rst2html --version
-      - if: matrix.os == 'ubuntu-latest'
-        name: Install pandoc on Linux
-        run: |
+    - name: Checkout code
+      uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+    - name: Install Go
+      uses: actions/setup-go@fac708d6674e30b6ba41289acaab6d4b75aa0753
+      with:
+        go-version: ${{ matrix.go-version }}
+        check-latest: true
+        cache: true
+        cache-dependency-path: |
+          **/go.sum
+          **/go.mod
+    - name: Install Ruby
+      uses: ruby/setup-ruby@036ef458ddccddb148a2b9fb67e95a22fdbf728b
+      with:
+        ruby-version: '2.7'
+        bundler-cache: true #
+    - name: Install Python
+      uses: actions/setup-python@3105fb18c05ddd93efea5f9e0bef7a03a6e9e7df
+      with:
+        python-version: '3.x'
+    - name: Install Mage
+      run: go install github.com/magefile/mage@v1.15.0
+    - name: Install asciidoctor
+      uses: reitzig/actions-asciidoctor@7570212ae20b63653481675fb1ff62d1073632b0
+    - 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: Run staticcheck
-        run: 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
-      - name: Build tags
-        run: |
-          go install -tags extended
-      - if: matrix.os == 'ubuntu-latest'
-        name: Build for dragonfly
-        run: |
-          go install
-        env:
-          GOARCH: amd64
-          GOOS: dragonfly
+    - 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: Run staticcheck
+      run: staticcheck ./...
+    - if: matrix.os != 'windows-latest'
+      name: Check
+      run: |
+        sass --version;
+        mage -v check;
+      env:
+        HUGO_BUILD_TAGS: extended
+    - 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
+    - name: Build tags
+      run: |
+        go install -tags extended,nodeploy
+    - if: matrix.os == 'ubuntu-latest'
+      name: Build for dragonfly
+      run: |
+        go install
+      env:
+        GOARCH: amd64
+        GOOS: dragonfly

.gitignore

@@ -1,5 +1,3 @@
 
 *.test
-imports.*
-dist/
-public/
+imports.*

Dockerfile

@@ -2,98 +2,44 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/
 
-ARG GO_VERSION="1.23.2"
-ARG ALPINE_VERSION="3.20"
-ARG DART_SASS_VERSION="1.79.3"
+FROM golang:1.21-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
+FROM alpine:3.18
 
-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"]

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2022 The Hugo Authors.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -5,7 +5,6 @@
 [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
 [go]: https://go.dev/
@@ -20,6 +19,7 @@
 [static site generator]: https://en.wikipedia.org/wiki/Static_site_generator
 [support]: https://discourse.gohugo.io
 [themes]: https://themes.gohugo.io/
+[twitter]: https://twitter.com/gohugoio
 [website]: https://gohugo.io
 [windows]: https://gohugo.io/installation/windows
 
@@ -33,7 +33,7 @@ A fast and flexible static site generator built with love by [bep], [spf13], and
 [![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> | <a rel="me" href="https://x.com/gohugoiov2">X</a>
+[Website] | [Installation] | [Documentation] | [Support] | [Contributing] | <a rel="me" href="https://fosstodon.org/@gohugoio">Mastodon</a>
 
 ## Overview
 
@@ -52,23 +52,19 @@ Use Hugo's embedded web server during development to instantly see changes to co
 
 Hugo's fast asset pipelines include:
 
-- Image processing &ndash; Convert, resize, crop, rotate, adjust colors, apply filters, overlay text and images, and extract EXIF data
-- 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
+- CSS bundling &ndash; transpilation (Sass), tree shaking, minification, source maps, SRI hashing, and PostCSS integration
+- JavaScript bundling &ndash; transpilation (TypeScript, JSX), tree shaking, minification, source maps, and SRI hashing
+- Image processing &ndash; convert, resize, crop, rotate,  adjust colors, apply filters, overlay text and images, and extract EXIF data
 
 And with [Hugo Modules], you can share content, assets, data, translations, themes, templates, and configuration with other projects via public or private Git repositories.
 
-See the [features] section of the documentation for a comprehensive summary of Hugo's capabilities.
-
 ## Sponsors
 
 <p>&nbsp;</p>
 <p float="left">
-  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></a>
-&nbsp;&nbsp;&nbsp;
-  <a href="https://route4me.com/" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/Route4MeLogoBlueOnWhite.svg" width="200" alt="Route Planning & Route Optimization Software"></a>
-</p>
+  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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/gohugoioTheme/master/assets/images/sponsors/cloudcannon-blue.svg" width="220" alt="CloudCannon"></a>
+<p>&nbsp;</p>
 
 ## Installation
 
@@ -102,9 +98,6 @@ Build the extended edition:
 ```text
 CGO_ENABLED=1 go install -tags extended 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
 
@@ -149,39 +142,40 @@ Hugo stands on the shoulders of great open source libraries. Run `hugo env --log
 
 ```text
 cloud.google.com/go/compute/metadata="v0.2.3"
-cloud.google.com/go/iam="v1.1.5"
-cloud.google.com/go/storage="v1.35.1"
-cloud.google.com/go="v0.110.10"
-github.com/Azure/azure-sdk-for-go/sdk/azcore="v1.9.0"
-github.com/Azure/azure-sdk-for-go/sdk/azidentity="v1.4.0"
-github.com/Azure/azure-sdk-for-go/sdk/internal="v1.5.0"
-github.com/Azure/azure-sdk-for-go/sdk/storage/azblob="v1.2.0"
+cloud.google.com/go/iam="v1.1.3"
+cloud.google.com/go/storage="v1.31.0"
+cloud.google.com/go="v0.110.8"
+github.com/Azure/azure-sdk-for-go/sdk/azcore="v1.7.0"
+github.com/Azure/azure-sdk-for-go/sdk/azidentity="v1.3.0"
+github.com/Azure/azure-sdk-for-go/sdk/internal="v1.3.0"
+github.com/Azure/azure-sdk-for-go/sdk/storage/azblob="v1.1.0"
 github.com/Azure/go-autorest/autorest/to="v0.4.0"
-github.com/AzureAD/microsoft-authentication-library-for-go="v1.2.0"
+github.com/AzureAD/microsoft-authentication-library-for-go="v1.0.0"
 github.com/BurntSushi/locker="v0.0.0-20171006230638-a6e239ea1c69"
-github.com/alecthomas/chroma/v2="v2.14.0"
-github.com/armon/go-radix="v1.0.1-0.20221118154546-54df44f2176c"
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream="v1.5.4"
-github.com/aws/aws-sdk-go-v2/config="v1.26.1"
-github.com/aws/aws-sdk-go-v2/credentials="v1.16.12"
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds="v1.14.10"
-github.com/aws/aws-sdk-go-v2/feature/s3/manager="v1.15.7"
-github.com/aws/aws-sdk-go-v2/internal/configsources="v1.3.5"
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2="v2.6.5"
-github.com/aws/aws-sdk-go-v2/internal/ini="v1.7.2"
-github.com/aws/aws-sdk-go-v2/internal/v4a="v1.2.9"
-github.com/aws/aws-sdk-go-v2/service/cloudfront="v1.35.4"
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding="v1.10.4"
-github.com/aws/aws-sdk-go-v2/service/internal/checksum="v1.2.9"
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url="v1.10.9"
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared="v1.16.9"
-github.com/aws/aws-sdk-go-v2/service/s3="v1.47.5"
-github.com/aws/aws-sdk-go-v2/service/sso="v1.18.5"
-github.com/aws/aws-sdk-go-v2/service/ssooidc="v1.21.5"
-github.com/aws/aws-sdk-go-v2/service/sts="v1.26.5"
-github.com/aws/aws-sdk-go-v2="v1.26.1"
-github.com/aws/aws-sdk-go="v1.50.7"
-github.com/aws/smithy-go="v1.20.2"
+github.com/PuerkitoBio/purell="v1.1.1"
+github.com/PuerkitoBio/urlesc="v0.0.0-20170810143723-de5bf2ad4578"
+github.com/alecthomas/chroma/v2="v2.11.1"
+github.com/armon/go-radix="v1.0.0"
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream="v1.4.11"
+github.com/aws/aws-sdk-go-v2/config="v1.18.32"
+github.com/aws/aws-sdk-go-v2/credentials="v1.13.31"
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds="v1.13.7"
+github.com/aws/aws-sdk-go-v2/feature/s3/manager="v1.11.76"
+github.com/aws/aws-sdk-go-v2/internal/configsources="v1.1.37"
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2="v2.4.31"
+github.com/aws/aws-sdk-go-v2/internal/ini="v1.3.38"
+github.com/aws/aws-sdk-go-v2/internal/v4a="v1.1.0"
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding="v1.9.12"
+github.com/aws/aws-sdk-go-v2/service/internal/checksum="v1.1.32"
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url="v1.9.31"
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared="v1.15.0"
+github.com/aws/aws-sdk-go-v2/service/s3="v1.38.1"
+github.com/aws/aws-sdk-go-v2/service/sso="v1.13.1"
+github.com/aws/aws-sdk-go-v2/service/ssooidc="v1.15.1"
+github.com/aws/aws-sdk-go-v2/service/sts="v1.21.1"
+github.com/aws/aws-sdk-go-v2="v1.20.0"
+github.com/aws/aws-sdk-go="v1.48.2"
+github.com/aws/smithy-go="v1.14.0"
 github.com/bep/clocks="v0.5.0"
 github.com/bep/debounce="v1.2.0"
 github.com/bep/gitmap="v1.1.2"
@@ -190,35 +184,32 @@ github.com/bep/godartsass/v2="v2.0.0"
 github.com/bep/godartsass="v1.2.0"
 github.com/bep/golibsass="v1.1.1"
 github.com/bep/gowebp="v0.3.0"
-github.com/bep/lazycache="v0.4.0"
-github.com/bep/logg="v0.4.0"
+github.com/bep/lazycache="v0.2.0"
+github.com/bep/logg="v0.3.0"
 github.com/bep/mclib="v1.20400.20402"
-github.com/bep/overlayfs="v0.9.2"
-github.com/bep/simplecobra="v0.4.0"
+github.com/bep/overlayfs="v0.6.0"
+github.com/bep/simplecobra="v0.3.2"
 github.com/bep/tmc="v0.5.1"
 github.com/clbanning/mxj/v2="v2.7.0"
 github.com/cli/safeexec="v1.0.1"
-github.com/cpuguy83/go-md2man/v2="v2.0.3"
+github.com/cpuguy83/go-md2man/v2="v2.0.2"
 github.com/disintegration/gift="v1.2.1"
-github.com/dlclark/regexp2="v1.11.0"
+github.com/dlclark/regexp2="v1.10.0"
 github.com/dustin/go-humanize="v1.0.1"
-github.com/evanw/esbuild="v0.21.4"
+github.com/evanw/esbuild="v0.19.7"
 github.com/fatih/color="v1.16.0"
 github.com/frankban/quicktest="v1.14.6"
 github.com/fsnotify/fsnotify="v1.7.0"
-github.com/getkin/kin-openapi="v0.123.0"
+github.com/getkin/kin-openapi="v0.120.0"
 github.com/ghodss/yaml="v1.0.0"
-github.com/go-openapi/jsonpointer="v0.20.2"
-github.com/go-openapi/swag="v0.22.8"
+github.com/go-openapi/jsonpointer="v0.19.6"
+github.com/go-openapi/swag="v0.22.4"
 github.com/gobuffalo/flect="v1.0.2"
 github.com/gobwas/glob="v0.2.3"
 github.com/gohugoio/go-i18n/v2="v2.1.3-0.20230805085216-e63c13218d0e"
-github.com/gohugoio/httpcache="v0.7.0"
-github.com/gohugoio/hugo-goldmark-extensions/extras="v0.2.0"
-github.com/gohugoio/hugo-goldmark-extensions/passthrough="v0.2.0"
 github.com/gohugoio/locales="v0.14.0"
 github.com/gohugoio/localescompressed="v1.0.1"
-github.com/golang-jwt/jwt/v5="v5.1.0"
+github.com/golang-jwt/jwt/v4="v4.5.0"
 github.com/golang/groupcache="v0.0.0-20210331224755-41bb18bfe9da"
 github.com/golang/protobuf="v1.5.3"
 github.com/google/go-cmp="v0.6.0"
@@ -229,7 +220,7 @@ github.com/googleapis/enterprise-certificate-proxy="v0.3.2"
 github.com/googleapis/gax-go/v2="v2.12.0"
 github.com/gorilla/websocket="v1.5.1"
 github.com/hairyhenderson/go-codeowners="v0.4.0"
-github.com/hashicorp/golang-lru/v2="v2.0.7"
+github.com/hashicorp/golang-lru/v2="v2.0.1"
 github.com/invopop/yaml="v0.2.0"
 github.com/jdkato/prose="v1.2.1"
 github.com/jmespath/go-jmespath="v0.4.0"
@@ -239,62 +230,63 @@ github.com/kr/text="v0.2.0"
 github.com/kylelemons/godebug="v1.1.0"
 github.com/kyokomi/emoji/v2="v2.2.12"
 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.9"
 github.com/mitchellh/hashstructure="v1.1.0"
-github.com/mitchellh/mapstructure="v1.5.1-0.20231216201459-8508981c8b6c"
+github.com/mitchellh/mapstructure="v1.5.0"
 github.com/mohae/deepcopy="v0.0.0-20170929034955-c48cc78d4826"
 github.com/muesli/smartcrop="v0.3.0"
 github.com/niklasfasching/go-org="v1.7.0"
 github.com/olekukonko/tablewriter="v0.0.5"
-github.com/pbnjay/memory="v0.0.0-20210728143218-7b4eea64cf58"
-github.com/pelletier/go-toml/v2="v2.2.2"
+github.com/pelletier/go-toml/v2="v2.1.0"
 github.com/perimeterx/marshmallow="v1.1.5"
 github.com/pkg/browser="v0.0.0-20210911075715-681adbf594b8"
 github.com/pkg/errors="v0.9.1"
-github.com/rogpeppe/go-internal="v1.12.0"
+github.com/rogpeppe/go-internal="v1.11.0"
 github.com/russross/blackfriday/v2="v2.1.0"
 github.com/rwcarlsen/goexif="v0.0.0-20190401172101-9e8deecbddbd"
-github.com/sass/dart-sass/compiler="1.77.5"
-github.com/sass/dart-sass/implementation="1.77.5"
-github.com/sass/dart-sass/protocol="2.7.1"
+github.com/sanity-io/litter="v1.5.5"
+github.com/sass/dart-sass/compiler="1.63.2"
+github.com/sass/dart-sass/implementation="1.63.2"
+github.com/sass/dart-sass/protocol="2.0.0"
 github.com/sass/libsass="3.6.5"
-github.com/spf13/afero="v1.11.0"
-github.com/spf13/cast="v1.6.0"
-github.com/spf13/cobra="v1.8.0"
-github.com/spf13/fsync="v0.10.1"
+github.com/spf13/afero="v1.10.0"
+github.com/spf13/cast="v1.5.1"
+github.com/spf13/cobra="v1.7.0"
+github.com/spf13/fsync="v0.9.0"
 github.com/spf13/pflag="v1.0.5"
-github.com/tdewolff/minify/v2="v2.20.20"
-github.com/tdewolff/parse/v2="v2.7.13"
+github.com/tdewolff/minify/v2="v2.20.7"
+github.com/tdewolff/parse/v2="v2.7.5"
 github.com/webmproject/libwebp="v1.3.2"
-github.com/yuin/goldmark-emoji="v1.0.3"
-github.com/yuin/goldmark="v1.7.4"
+github.com/yuin/goldmark-emoji="v1.0.2"
+github.com/yuin/goldmark="v1.6.0"
 go.opencensus.io="v0.24.0"
+go.uber.org/atomic="v1.11.0"
 go.uber.org/automaxprocs="v1.5.3"
-gocloud.dev="v0.36.0"
-golang.org/x/crypto="v0.23.0"
+gocloud.dev="v0.34.0"
+golang.org/x/crypto="v0.15.0"
 golang.org/x/exp="v0.0.0-20221031165847-c99f073a8326"
-golang.org/x/image="v0.16.0"
-golang.org/x/mod="v0.17.0"
-golang.org/x/net="v0.25.0"
-golang.org/x/oauth2="v0.15.0"
-golang.org/x/sync="v0.7.0"
-golang.org/x/sys="v0.20.0"
-golang.org/x/text="v0.15.0"
-golang.org/x/time="v0.5.0"
-golang.org/x/tools="v0.20.0"
-golang.org/x/xerrors="v0.0.0-20231012003039-104605ab7028"
-google.golang.org/api="v0.152.0"
-google.golang.org/genproto/googleapis/api="v0.0.0-20231120223509-83a465c0220f"
-google.golang.org/genproto/googleapis/rpc="v0.0.0-20231120223509-83a465c0220f"
-google.golang.org/genproto="v0.0.0-20231120223509-83a465c0220f"
+golang.org/x/image="v0.13.0"
+golang.org/x/mod="v0.14.0"
+golang.org/x/net="v0.18.0"
+golang.org/x/oauth2="v0.13.0"
+golang.org/x/sync="v0.5.0"
+golang.org/x/sys="v0.14.0"
+golang.org/x/text="v0.14.0"
+golang.org/x/time="v0.3.0"
+golang.org/x/tools="v0.15.0"
+golang.org/x/xerrors="v0.0.0-20220907171357-04be3eba64a2"
+google.golang.org/api="v0.151.0"
+google.golang.org/genproto/googleapis/api="v0.0.0-20231016165738-49dd2c1f3d0b"
+google.golang.org/genproto/googleapis/rpc="v0.0.0-20231030173426-d783a09b4405"
+google.golang.org/genproto="v0.0.0-20231016165738-49dd2c1f3d0b"
 google.golang.org/grpc="v1.59.0"
-google.golang.org/protobuf="v1.33.0"
+google.golang.org/protobuf="v1.31.0"
 gopkg.in/yaml.v2="v2.4.0"
 gopkg.in/yaml.v3="v3.0.1"
+howett.net/plist="v1.0.0"
 software.sslmate.com/src/go-pkcs12="v0.2.0"
 ```
 </details>

SECURITY.md

@@ -4,4 +4,4 @@
 
 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.
 
-Also see [Hugo's Security Model](https://gohugo.io/about/security/).
+Also see [Hugo's Security Model](https://gohugo.io/about/security-model/).

cache/dynacache/dynacache.go

@@ -25,7 +25,6 @@ import (
 
 	"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"
@@ -38,11 +37,6 @@ import (
 
 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 {
@@ -69,26 +63,11 @@ func New(opts Options) *Cache {
 
 	infol := opts.Log.InfoCommand("dynacache")
 
-	evictedIdentities := collections.NewStack[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,
+		partitions: make(map[string]PartitionManager),
+		opts:       opts,
+		stats:      stats,
+		infol:      infol,
 	}
 
 	c.stop = c.start()
@@ -102,7 +81,7 @@ type Options struct {
 	CheckInterval time.Duration
 	MaxSize       int
 	MinMaxSize    int
-	Watching      bool
+	Running       bool
 }
 
 // Options for a partition.
@@ -127,48 +106,25 @@ type Cache struct {
 	mu sync.RWMutex
 
 	partitions map[string]PartitionManager
-
-	onEvict           func(k, v any)
-	evictedIdentities *collections.Stack[KeyIdentity]
-
-	opts  Options
-	infol logg.LevelLogger
+	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")
-	}
+func (c *Cache) ClearMatching(predicate func(k, v any) bool) {
 	g := rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
 		NumWorkers: len(c.partitions),
 		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearMatching(predicateValue)
+			partition.clearMatching(predicate)
 			return nil
 		},
 	})
 
-	for k, p := range c.partitions {
-		if !predicatePartition(k, p) {
-			continue
-		}
+	for _, p := range c.partitions {
 		g.Enqueue(p)
 	}
 
@@ -314,8 +270,6 @@ func (c *Cache) start() func() {
 			select {
 			case <-ticker.C:
 				c.adjustCurrentMaxSize()
-				// Reset the ticker to avoid drift.
-				ticker.Reset(c.opts.CheckInterval)
 			case <-quit:
 				ticker.Stop()
 				return
@@ -359,23 +313,18 @@ func GetOrCreatePartition[K comparable, V any](c *Cache, name string, opts Optio
 		return p.(*Partition[K, V])
 	}
 
-	// At this point, we don't know the number of partitions or their configuration, but
+	// At this point, we don't know the 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}),
+		c:       lazycache.New(lazycache.Options[K, V]{MaxEntries: maxSize}),
 		maxSize: maxSize,
 		trace:   c.opts.Log.Logger().WithLevel(logg.LevelTrace).WithField("partition", name),
 		opts:    opts,
 	}
-
 	c.partitions[name] = partition
 
 	return partition
@@ -395,60 +344,23 @@ type Partition[K comparable, V any] struct {
 
 // 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) {
+func (p *Partition[K, V]) GetOrCreateWitTimeout(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)
+		v, _, err := p.c.GetOrCreate(key, create)
+		if err != nil {
+			errch <- err
+			return
+		}
+		resultch <- v
 	}()
 
 	select {
@@ -495,7 +407,7 @@ func (p *Partition[K, V]) clearOnRebuild(changeset ...identity.Identity) {
 
 	shouldDelete := func(key K, v V) bool {
 		// We always clear elements marked as stale.
-		if resource.StaleVersion(v) > 0 {
+		if resource.IsStaleAny(v) {
 			return true
 		}
 
@@ -533,6 +445,7 @@ func (p *Partition[K, V]) clearOnRebuild(changeset ...identity.Identity) {
 					},
 				),
 			)
+			resource.MarkStale(v)
 			return true
 		}
 		return false
@@ -550,8 +463,8 @@ func (p *Partition[K, V]) Keys() []K {
 
 func (p *Partition[K, V]) clearStale() {
 	p.c.DeleteFunc(func(key K, v V) bool {
-		staleVersion := resource.StaleVersion(v)
-		if staleVersion > 0 {
+		isStale := resource.IsStaleAny(v)
+		if isStale {
 			p.trace.Log(
 				logg.StringFunc(
 					func() string {
@@ -561,7 +474,7 @@ func (p *Partition[K, V]) clearStale() {
 			)
 		}
 
-		return staleVersion > 0
+		return isStale
 	})
 }
 
@@ -570,10 +483,6 @@ 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)
@@ -626,7 +535,7 @@ type stats struct {
 func (s *stats) adjustCurrentMaxSize() bool {
 	newCurrentMaxSize := int(math.Floor(float64(s.opts.MaxSize) * s.adjustmentFactor))
 
-	if newCurrentMaxSize < s.opts.MinMaxSize {
+	if newCurrentMaxSize < s.opts.MaxSize {
 		newCurrentMaxSize = int(s.opts.MinMaxSize)
 	}
 	changed := newCurrentMaxSize != s.currentMaxSize

cache/dynacache/dynacache_test.go

@@ -14,11 +14,8 @@
 package dynacache
 
 import (
-	"errors"
-	"fmt"
 	"path/filepath"
 	"testing"
-	"time"
 
 	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/common/loggers"
@@ -32,12 +29,12 @@ var (
 )
 
 type testItem struct {
-	name         string
-	staleVersion uint32
+	name    string
+	isStale bool
 }
 
-func (t testItem) StaleVersion() uint32 {
-	return t.staleVersion
+func (t testItem) IsStale() bool {
+	return t.isStale
 }
 
 func (t testItem) IdentifierBase() string {
@@ -112,7 +109,7 @@ func newTestCache(t *testing.T) *Cache {
 
 	p2.GetOrCreate("clearBecauseStale", func(string) (testItem, error) {
 		return testItem{
-			staleVersion: 32,
+			isStale: true,
 		}, nil
 	})
 
@@ -124,7 +121,7 @@ func newTestCache(t *testing.T) *Cache {
 
 	p2.GetOrCreate("clearNever", func(string) (testItem, error) {
 		return testItem{
-			staleVersion: 0,
+			isStale: false,
 		}, nil
 	})
 
@@ -159,7 +156,7 @@ func TestClear(t *testing.T) {
 
 	cache = newTestCache(t)
 
-	cache.ClearMatching(nil, func(k, v any) bool {
+	cache.ClearMatching(func(k, v any) bool {
 		return k.(string) == "clearOnRebuild"
 	})
 
@@ -168,58 +165,6 @@ func TestClear(t *testing.T) {
 	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 := 0; i < 3; i++ {
-		for j := 0; j < 3; j++ {
-			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 := 0; i < 3; i++ {
-		for j := 0; j < 3; j++ {
-			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/filecache/filecache.go

@@ -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.
@@ -23,7 +23,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/gohugoio/httpcache"
 	"github.com/gohugoio/hugo/common/hugio"
 	"github.com/gohugoio/hugo/hugofs"
 
@@ -183,15 +182,6 @@ 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.nlocker.Lock(id)
-	return func() {
-		c.nlocker.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.
@@ -228,23 +218,7 @@ 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))
-}
-
-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.
@@ -279,10 +253,9 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 		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
 }
 
@@ -332,8 +305,16 @@ func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
 		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)
@@ -344,49 +325,6 @@ func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
 	return f
 }
 
-func (c *Cache) getBytesAndRemoveIfExpired(id string) ([]byte, bool) {
-	if c.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.maxAge <= 0 {
-		return false, nil
-	}
-
-	fi, err := c.Fs.Stat(id)
-	if err != nil {
-		return false, err
-	}
-
-	if c.isExpired(fi.ModTime()) {
-		c.Fs.Remove(id)
-		return true, nil
-	}
-
-	return false, nil
-}
-
 func (c *Cache) isExpired(modTime time.Time) bool {
 	if c.maxAge < 0 {
 		return false
@@ -460,37 +398,3 @@ func NewCaches(p *helpers.PathSpec) (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.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)
-}

cache/filecache/filecache_config.go

@@ -46,7 +46,6 @@ const (
 	CacheKeyAssets      = "assets"
 	CacheKeyModules     = "modules"
 	CacheKeyGetResource = "getresource"
-	CacheKeyMisc        = "misc"
 )
 
 type Configs map[string]FileCacheConfig
@@ -71,14 +70,10 @@ var defaultCacheConfigs = Configs{
 		MaxAge: -1,
 		Dir:    resourcesGenDir,
 	},
-	CacheKeyGetResource: {
+	CacheKeyGetResource: FileCacheConfig{
 		MaxAge: -1, // Never expire
 		Dir:    cacheDirProject,
 	},
-	CacheKeyMisc: {
-		MaxAge: -1,
-		Dir:    cacheDirProject,
-	},
 }
 
 type FileCacheConfig struct {
@@ -125,11 +120,6 @@ func (f Caches) AssetsCache() *Cache {
 	return f[CacheKeyAssets]
 }
 
-// MiscCache gets the file cache for miscellaneous stuff.
-func (f Caches) MiscCache() *Cache {
-	return f[CacheKeyMisc]
-}
-
 // GetResourceCache gets the file cache for remote resources.
 func (f Caches) GetResourceCache() *Cache {
 	return f[CacheKeyGetResource]

cache/filecache/filecache_config_test.go

@@ -59,7 +59,7 @@ dir = "/path/to/c4"
 	c.Assert(err, qt.IsNil)
 	fs := afero.NewMemMapFs()
 	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)
+	c.Assert(len(decoded), qt.Equals, 6)
 
 	c2 := decoded["getcsv"]
 	c.Assert(c2.MaxAge.String(), qt.Equals, "11h0m0s")
@@ -106,7 +106,7 @@ dir = "/path/to/c4"
 	c.Assert(err, qt.IsNil)
 	fs := afero.NewMemMapFs()
 	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)
+	c.Assert(len(decoded), qt.Equals, 6)
 
 	for _, v := range decoded {
 		c.Assert(v.MaxAge, qt.Equals, time.Duration(0))
@@ -129,7 +129,7 @@ func TestDecodeConfigDefault(t *testing.T) {
 
 	fs := afero.NewMemMapFs()
 	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
-	c.Assert(len(decoded), qt.Equals, 7)
+	c.Assert(len(decoded), qt.Equals, 6)
 
 	imgConfig := decoded[filecache.CacheKeyImages]
 	jsonConfig := decoded[filecache.CacheKeyGetJSON]

cache/httpcache/httpcache.go

@@ -1,207 +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{
-	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 {
-	// Configures the HTTP cache behaviour (RFC 9111).
-	// 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 behaviour (RFC 9111) for these rsources.
-	For GlobMatcher
-}
-
-func (c *Config) Compile() (ConfigCompiled, error) {
-	var cc ConfigCompiled
-
-	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
-}
-
-type ConfigCompiled struct {
-	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) {
-	var p predicate.P[string]
-	for _, include := range gm.Includes {
-		g, err := glob.Compile(include, '/')
-		if err != nil {
-			return nil, err
-		}
-		fn := func(s string) bool {
-			return g.Match(s)
-		}
-		p = p.Or(fn)
-	}
-
-	for _, exclude := range gm.Excludes {
-		g, err := glob.Compile(exclude, '/')
-		if err != nil {
-			return nil, err
-		}
-		fn := func(s string) bool {
-			return !g.Match(s)
-		}
-		p = p.And(fn)
-	}
-
-	return p, nil
-}
-
-func DecodeConfig(bcfg 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
-	}
-
-	return c, nil
-}

cache/httpcache/httpcache_integration_test.go

@@ -1,64 +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) {
-	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) {
-	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)
-}

cache/httpcache/httpcache_test.go

@@ -1,42 +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"
-)
-
-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)
-}

commands/commandeer.go

@@ -22,7 +22,6 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -42,15 +41,12 @@ import (
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/paths"
-	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/hugolib"
-	"github.com/gohugoio/hugo/identity"
-	"github.com/gohugoio/hugo/resources/kinds"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 )
@@ -67,12 +63,6 @@ func Execute(args []string) error {
 	}
 	args = mapLegacyArgs(args)
 	cd, err := x.Execute(context.Background(), args)
-	if cd != nil {
-		if closer, ok := cd.Root.Command.(types.Closer); ok {
-			closer.Close()
-		}
-	}
-
 	if err != nil {
 		if err == errHelp {
 			cd.CobraCommand.Help()
@@ -95,11 +85,6 @@ type commonConfig struct {
 	fs      *hugofs.Fs
 }
 
-type configKey struct {
-	counter                    int32
-	ignoreModulesDoesNotExists bool
-}
-
 // This is the root command.
 type rootCommand struct {
 	Printf  func(format string, v ...interface{})
@@ -113,11 +98,8 @@ type rootCommand struct {
 
 	// Some, but not all commands need access to these.
 	// Some needs more than one, so keep them in a small cache.
-	commonConfigs *lazycache.Cache[configKey, *commonConfig]
-	hugoSites     *lazycache.Cache[configKey, *hugolib.HugoSites]
-
-	// changesFromBuild received from Hugo in watch mode.
-	changesFromBuild chan []identity.Identity
+	commonConfigs *lazycache.Cache[int32, *commonConfig]
+	hugoSites     *lazycache.Cache[int32, *hugolib.HugoSites]
 
 	commands []simplecobra.Commander
 
@@ -144,7 +126,6 @@ type rootCommand struct {
 	verbose bool
 	debug   bool
 	quiet   bool
-	devMode bool // Hidden flag.
 
 	renderToMemory bool
 
@@ -156,18 +137,6 @@ func (r *rootCommand) isVerbose() bool {
 	return r.logger.Level() <= logg.LevelInfo
 }
 
-func (r *rootCommand) Close() error {
-	if r.hugoSites != nil {
-		r.hugoSites.DeleteFunc(func(key configKey, value *hugolib.HugoSites) bool {
-			if value != nil {
-				value.Close()
-			}
-			return false
-		})
-	}
-	return nil
-}
-
 func (r *rootCommand) Build(cd *simplecobra.Commandeer, bcfg hugolib.BuildCfg, cfg config.Provider) (*hugolib.HugoSites, error) {
 	h, err := r.Hugo(cfg)
 	if err != nil {
@@ -184,18 +153,17 @@ func (r *rootCommand) Commands() []simplecobra.Commander {
 	return r.commands
 }
 
-func (r *rootCommand) ConfigFromConfig(key configKey, oldConf *commonConfig) (*commonConfig, error) {
-	cc, _, err := r.commonConfigs.GetOrCreate(key, func(key configKey) (*commonConfig, error) {
+func (r *rootCommand) ConfigFromConfig(key int32, oldConf *commonConfig) (*commonConfig, error) {
+	cc, _, err := r.commonConfigs.GetOrCreate(key, func(key int32) (*commonConfig, error) {
 		fs := oldConf.fs
 		configs, err := allconfig.LoadConfig(
 			allconfig.ConfigSourceDescriptor{
-				Flags:                    oldConf.cfg,
-				Fs:                       fs.Source,
-				Filename:                 r.cfgFile,
-				ConfigDir:                r.cfgDir,
-				Logger:                   r.logger,
-				Environment:              r.environment,
-				IgnoreModuleDoesNotExist: key.ignoreModulesDoesNotExists,
+				Flags:       oldConf.cfg,
+				Fs:          fs.Source,
+				Filename:    r.cfgFile,
+				ConfigDir:   r.cfgDir,
+				Logger:      r.logger,
+				Environment: r.environment,
 			},
 		)
 		if err != nil {
@@ -218,11 +186,11 @@ func (r *rootCommand) ConfigFromConfig(key configKey, oldConf *commonConfig) (*c
 	return cc, err
 }
 
-func (r *rootCommand) ConfigFromProvider(key configKey, cfg config.Provider) (*commonConfig, error) {
+func (r *rootCommand) ConfigFromProvider(key int32, cfg config.Provider) (*commonConfig, error) {
 	if cfg == nil {
 		panic("cfg must be set")
 	}
-	cc, _, err := r.commonConfigs.GetOrCreate(key, func(key configKey) (*commonConfig, error) {
+	cc, _, err := r.commonConfigs.GetOrCreate(key, func(key int32) (*commonConfig, error) {
 		var dir string
 		if r.source != "" {
 			dir, _ = filepath.Abs(r.source)
@@ -234,6 +202,9 @@ func (r *rootCommand) ConfigFromProvider(key configKey, cfg config.Provider) (*c
 			cfg = config.New()
 		}
 
+		if !cfg.IsSet("renderToDisk") {
+			cfg.Set("renderToDisk", true)
+		}
 		if !cfg.IsSet("workingDir") {
 			cfg.Set("workingDir", dir)
 		} else {
@@ -245,13 +216,12 @@ func (r *rootCommand) ConfigFromProvider(key configKey, cfg config.Provider) (*c
 		// Load the config first to allow publishDir to be configured in config file.
 		configs, err := allconfig.LoadConfig(
 			allconfig.ConfigSourceDescriptor{
-				Flags:                    cfg,
-				Fs:                       hugofs.Os,
-				Filename:                 r.cfgFile,
-				ConfigDir:                r.cfgDir,
-				Environment:              r.environment,
-				Logger:                   r.logger,
-				IgnoreModuleDoesNotExist: key.ignoreModulesDoesNotExists,
+				Flags:       cfg,
+				Fs:          hugofs.Os,
+				Filename:    r.cfgFile,
+				ConfigDir:   r.cfgDir,
+				Environment: r.environment,
+				Logger:      r.logger,
 			},
 		)
 		if err != nil {
@@ -268,7 +238,9 @@ func (r *rootCommand) ConfigFromProvider(key configKey, cfg config.Provider) (*c
 
 		sourceFs := hugofs.Os
 		var destinationFs afero.Fs
-		if cfg.GetBool("renderToMemory") {
+		if cfg.GetBool("renderToDisk") {
+			destinationFs = hugofs.Os
+		} else {
 			destinationFs = afero.NewMemMapFs()
 			if renderStaticToDisk {
 				// Hybrid, render dynamic content to Root.
@@ -278,8 +250,6 @@ func (r *rootCommand) ConfigFromProvider(key configKey, cfg config.Provider) (*c
 				cfg.Set("publishDirDynamic", "/")
 				cfg.Set("publishDirStatic", "/")
 			}
-		} else {
-			destinationFs = hugofs.Os
 		}
 
 		fs := hugofs.NewFromSourceAndDestination(sourceFs, destinationFs, cfg)
@@ -333,46 +303,36 @@ func (r *rootCommand) ConfigFromProvider(key configKey, cfg config.Provider) (*c
 }
 
 func (r *rootCommand) HugFromConfig(conf *commonConfig) (*hugolib.HugoSites, error) {
-	k := configKey{counter: r.configVersionID.Load()}
-	h, _, err := r.hugoSites.GetOrCreate(k, func(key configKey) (*hugolib.HugoSites, error) {
-		depsCfg := r.newDepsConfig(conf)
+	h, _, err := r.hugoSites.GetOrCreate(r.configVersionID.Load(), func(key int32) (*hugolib.HugoSites, error) {
+		depsCfg := deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level()}
 		return hugolib.NewHugoSites(depsCfg)
 	})
 	return h, err
 }
 
 func (r *rootCommand) Hugo(cfg config.Provider) (*hugolib.HugoSites, error) {
-	return r.getOrCreateHugo(cfg, false)
-}
-
-func (r *rootCommand) getOrCreateHugo(cfg config.Provider, ignoreModuleDoesNotExist bool) (*hugolib.HugoSites, error) {
-	k := configKey{counter: r.configVersionID.Load(), ignoreModulesDoesNotExists: ignoreModuleDoesNotExist}
-	h, _, err := r.hugoSites.GetOrCreate(k, func(key configKey) (*hugolib.HugoSites, error) {
+	h, _, err := r.hugoSites.GetOrCreate(r.configVersionID.Load(), func(key int32) (*hugolib.HugoSites, error) {
 		conf, err := r.ConfigFromProvider(key, cfg)
 		if err != nil {
 			return nil, err
 		}
-		depsCfg := r.newDepsConfig(conf)
+		depsCfg := deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level()}
 		return hugolib.NewHugoSites(depsCfg)
 	})
 	return h, err
 }
 
-func (r *rootCommand) newDepsConfig(conf *commonConfig) deps.DepsCfg {
-	return deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level(), ChangesFromBuild: r.changesFromBuild}
-}
-
 func (r *rootCommand) Name() string {
 	return "hugo"
 }
 
 func (r *rootCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	b := newHugoBuilder(r, nil)
-
 	if !r.buildWatch {
-		defer b.postBuild("Total", time.Now())
+		defer r.timeTrack(time.Now(), "Total")
 	}
 
+	b := newHugoBuilder(r, nil)
+
 	if err := b.loadConfig(cd, false); err != nil {
 		return err
 	}
@@ -382,10 +342,7 @@ func (r *rootCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args
 			defer r.timeTrack(time.Now(), "Built")
 		}
 		err := b.build()
-		if err != nil {
-			return err
-		}
-		return nil
+		return err
 	}()
 	if err != nil {
 		return err
@@ -448,15 +405,12 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 		return err
 	}
 
-	r.changesFromBuild = make(chan []identity.Identity, 10)
-
-	r.commonConfigs = lazycache.New(lazycache.Options[configKey, *commonConfig]{MaxEntries: 5})
+	r.commonConfigs = lazycache.New(lazycache.Options[int32, *commonConfig]{MaxEntries: 5})
 	// We don't want to keep stale HugoSites in memory longer than needed.
-	r.hugoSites = lazycache.New(lazycache.Options[configKey, *hugolib.HugoSites]{
+	r.hugoSites = lazycache.New(lazycache.Options[int32, *hugolib.HugoSites]{
 		MaxEntries: 1,
-		OnEvict: func(key configKey, value *hugolib.HugoSites) {
+		OnEvict: func(key int32, value *hugolib.HugoSites) {
 			value.Close()
-			runtime.GC()
 		},
 	})
 
@@ -466,33 +420,29 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 func (r *rootCommand) createLogger(running bool) (loggers.Logger, error) {
 	level := logg.LevelWarn
 
-	if r.devMode {
-		level = logg.LevelTrace
+	if r.logLevel != "" {
+		switch strings.ToLower(r.logLevel) {
+		case "debug":
+			level = logg.LevelDebug
+		case "info":
+			level = logg.LevelInfo
+		case "warn", "warning":
+			level = logg.LevelWarn
+		case "error":
+			level = logg.LevelError
+		default:
+			return nil, fmt.Errorf("invalid log level: %q, must be one of debug, warn, info or error", r.logLevel)
+		}
 	} else {
-		if r.logLevel != "" {
-			switch strings.ToLower(r.logLevel) {
-			case "debug":
-				level = logg.LevelDebug
-			case "info":
-				level = logg.LevelInfo
-			case "warn", "warning":
-				level = logg.LevelWarn
-			case "error":
-				level = logg.LevelError
-			default:
-				return nil, fmt.Errorf("invalid log level: %q, must be one of debug, warn, info or error", r.logLevel)
-			}
-		} else {
-			if r.verbose {
-				hugo.Deprecate("--verbose", "use --logLevel info", "v0.114.0")
-				hugo.Deprecate("--verbose", "use --logLevel info", "v0.114.0")
-				level = logg.LevelInfo
-			}
+		if r.verbose {
+			hugo.Deprecate("--verbose", "use --logLevel info", "v0.114.0")
+			hugo.Deprecate("--verbose", "use --logLevel info", "v0.114.0")
+			level = logg.LevelInfo
+		}
 
-			if r.debug {
-				hugo.Deprecate("--debug", "use --logLevel debug", "v0.114.0")
-				level = logg.LevelDebug
-			}
+		if r.debug {
+			hugo.Deprecate("--debug", "use --logLevel debug", "v0.114.0")
+			level = logg.LevelDebug
 		}
 	}
 
@@ -507,7 +457,7 @@ func (r *rootCommand) createLogger(running bool) (loggers.Logger, error) {
 	return loggers.New(optsLogger), nil
 }
 
-func (r *rootCommand) resetLogs() {
+func (r *rootCommand) Reset() {
 	r.logger.Reset()
 	loggers.Log().Reset()
 }
@@ -518,72 +468,58 @@ func (r *rootCommand) IsTestRun() bool {
 }
 
 func (r *rootCommand) Init(cd *simplecobra.Commandeer) error {
-	return r.initRootCommand("", cd)
-}
-
-func (r *rootCommand) initRootCommand(subCommandName string, cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
-	commandName := "hugo"
-	if subCommandName != "" {
-		commandName = subCommandName
-	}
-	cmd.Use = fmt.Sprintf("%s [flags]", commandName)
-	cmd.Short = "Build your site"
-	cmd.Long = `COMMAND_NAME is the main command, used to build your Hugo site.
+	cmd.Use = "hugo [flags]"
+	cmd.Short = "hugo builds your site"
+	cmd.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/.`
 
-	cmd.Long = strings.ReplaceAll(cmd.Long, "COMMAND_NAME", commandName)
-
 	// Configure persistent flags
 	cmd.PersistentFlags().StringVarP(&r.source, "source", "s", "", "filesystem path to read files relative from")
-	_ = cmd.MarkFlagDirname("source")
+	cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
 	cmd.PersistentFlags().StringP("destination", "d", "", "filesystem path to write files to")
-	_ = cmd.MarkFlagDirname("destination")
+	cmd.PersistentFlags().SetAnnotation("destination", cobra.BashCompSubdirsInDir, []string{})
 
 	cmd.PersistentFlags().StringVarP(&r.environment, "environment", "e", "", "build environment")
-	_ = cmd.RegisterFlagCompletionFunc("environment", cobra.NoFileCompletions)
 	cmd.PersistentFlags().StringP("themesDir", "", "", "filesystem path to themes directory")
-	_ = cmd.MarkFlagDirname("themesDir")
 	cmd.PersistentFlags().StringP("ignoreVendorPaths", "", "", "ignores any _vendor for module paths matching the given Glob pattern")
-	_ = cmd.RegisterFlagCompletionFunc("ignoreVendorPaths", cobra.NoFileCompletions)
 	cmd.PersistentFlags().String("clock", "", "set the clock used by Hugo, e.g. --clock 2021-11-06T22:30:00.00+09:00")
-	_ = cmd.RegisterFlagCompletionFunc("clock", cobra.NoFileCompletions)
 
 	cmd.PersistentFlags().StringVar(&r.cfgFile, "config", "", "config file (default is hugo.yaml|json|toml)")
-	_ = cmd.MarkFlagFilename("config", config.ValidConfigFileExtensions...)
 	cmd.PersistentFlags().StringVar(&r.cfgDir, "configDir", "config", "config dir")
-	_ = cmd.MarkFlagDirname("configDir")
 	cmd.PersistentFlags().BoolVar(&r.quiet, "quiet", false, "build in quiet mode")
-	cmd.PersistentFlags().BoolVarP(&r.renderToMemory, "renderToMemory", "M", false, "render to memory (mostly useful when running the server)")
+
+	// Set bash-completion
+	_ = cmd.PersistentFlags().SetAnnotation("config", cobra.BashCompFilenameExt, config.ValidConfigFileExtensions)
 
 	cmd.PersistentFlags().BoolVarP(&r.verbose, "verbose", "v", false, "verbose output")
 	cmd.PersistentFlags().BoolVarP(&r.debug, "debug", "", false, "debug output")
-	cmd.PersistentFlags().BoolVarP(&r.devMode, "devMode", "", false, "only used for internal testing, flag hidden.")
 	cmd.PersistentFlags().StringVar(&r.logLevel, "logLevel", "", "log level (debug|info|warn|error)")
-	_ = cmd.RegisterFlagCompletionFunc("logLevel", cobra.FixedCompletions([]string{"debug", "info", "warn", "error"}, cobra.ShellCompDirectiveNoFileComp))
 	cmd.Flags().BoolVarP(&r.buildWatch, "watch", "w", false, "watch filesystem for changes and recreate as needed")
-
-	cmd.PersistentFlags().MarkHidden("devMode")
+	cmd.Flags().BoolVar(&r.renderToMemory, "renderToMemory", false, "render to memory (only useful for benchmark testing)")
 
 	// Configure local flags
 	applyLocalFlagsBuild(cmd, r)
 
+	// Set bash-completion.
+	// Each flag must first be defined before using the SetAnnotation() call.
+	_ = cmd.Flags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+
 	return nil
 }
 
 // A sub set of the complete build flags. These flags are used by new and mod.
 func applyLocalFlagsBuildConfig(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().StringSliceP("theme", "t", []string{}, "themes to use (located in /themes/THEMENAME/)")
-	_ = cmd.MarkFlagDirname("theme")
 	cmd.Flags().StringVarP(&r.baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. https://spf13.com/")
 	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory")
-	_ = cmd.MarkFlagDirname("cacheDir")
+	_ = cmd.Flags().SetAnnotation("cacheDir", cobra.BashCompSubdirsInDir, []string{})
 	cmd.Flags().StringP("contentDir", "c", "", "filesystem path to content directory")
-	cmd.Flags().StringSliceP("renderSegments", "", []string{}, "named segments to render (configured in the segments config)")
+	_ = cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
 }
 
 // Flags needed to do a build (used by hugo and hugo server commands)
@@ -596,10 +532,8 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().BoolP("ignoreCache", "", false, "ignores the cache directory")
 	cmd.Flags().Bool("enableGitInfo", false, "add Git revision, date, author, and CODEOWNERS info to the pages")
 	cmd.Flags().StringP("layoutDir", "l", "", "filesystem path to layout directory")
-	_ = cmd.MarkFlagDirname("layoutDir")
 	cmd.Flags().BoolVar(&r.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
 	cmd.Flags().StringVar(&r.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.RegisterFlagCompletionFunc("poll", cobra.NoFileCompletions)
 	cmd.Flags().Bool("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")
@@ -622,8 +556,8 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().MarkHidden("profile-mutex")
 
 	cmd.Flags().StringSlice("disableKinds", []string{}, "disable different kind of pages (home, RSS etc.)")
-	_ = cmd.RegisterFlagCompletionFunc("disableKinds", cobra.FixedCompletions(kinds.AllKinds, cobra.ShellCompDirectiveNoFileComp))
 	cmd.Flags().Bool("minify", false, "minify any supported output format (HTML, XML etc.)")
+	_ = cmd.Flags().SetAnnotation("destination", cobra.BashCompSubdirsInDir, []string{})
 }
 
 func (r *rootCommand) timeTrack(start time.Time, name string) {

commands/commands.go

@@ -14,8 +14,6 @@
 package commands
 
 import (
-	"context"
-
 	"github.com/bep/simplecobra"
 )
 
@@ -23,7 +21,6 @@ import (
 func newExec() (*simplecobra.Exec, error) {
 	rootCmd := &rootCommand{
 		commands: []simplecobra.Commander{
-			newHugoBuildCmd(),
 			newVersionCmd(),
 			newEnvCommand(),
 			newServerCommand(),
@@ -41,33 +38,3 @@ func newExec() (*simplecobra.Exec, error) {
 
 	return simplecobra.New(rootCmd)
 }
-
-func newHugoBuildCmd() simplecobra.Commander {
-	return &hugoBuildCommand{}
-}
-
-// hugoBuildCommand just delegates to the rootCommand.
-type hugoBuildCommand struct {
-	rootCmd *rootCommand
-}
-
-func (c *hugoBuildCommand) Commands() []simplecobra.Commander {
-	return nil
-}
-
-func (c *hugoBuildCommand) Name() string {
-	return "build"
-}
-
-func (c *hugoBuildCommand) Init(cd *simplecobra.Commandeer) error {
-	c.rootCmd = cd.Root.Command.(*rootCommand)
-	return c.rootCmd.initRootCommand("build", cd)
-}
-
-func (c *hugoBuildCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	return c.rootCmd.PreRun(cd, runner)
-}
-
-func (c *hugoBuildCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	return c.rootCmd.Run(ctx, cd, args)
-}

commands/config.go

@@ -28,7 +28,6 @@ import (
 	"github.com/gohugoio/hugo/modules"
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
-	"github.com/spf13/cobra"
 )
 
 // newConfigCommand creates a new config command and its subcommands.
@@ -58,7 +57,7 @@ func (c *configCommand) Name() string {
 }
 
 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))
+	conf, err := c.r.ConfigFromProvider(c.r.configVersionID.Load(), flagsToCfg(cd, nil))
 	if err != nil {
 		return err
 	}
@@ -110,12 +109,10 @@ func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 func (c *configCommand) Init(cd *simplecobra.Commandeer) error {
 	c.r = cd.Root.Command.(*rootCommand)
 	cmd := cd.CobraCommand
-	cmd.Short = "Display site configuration"
-	cmd.Long = `Display site configuration, both default and custom settings.`
+	cmd.Short = "Print the site configuration"
+	cmd.Long = `Print the site 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.RegisterFlagCompletionFunc("lang", cobra.NoFileCompletions)
 	applyLocalFlagsBuildConfig(cmd, c.r)
 
 	return nil
@@ -209,7 +206,7 @@ func (c *configMountsCommand) Name() string {
 
 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))
+	conf, err := r.ConfigFromProvider(r.configVersionID.Load(), flagsToCfg(cd, nil))
 	if err != nil {
 		return err
 	}
@@ -226,7 +223,6 @@ 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
 }

commands/convert.go

@@ -46,7 +46,6 @@ to use JSON for the front matter.`,
 					return c.convertContents(metadecoders.JSON)
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
 				},
 			},
 			&simpleCommand{
@@ -58,7 +57,6 @@ to use TOML for the front matter.`,
 					return c.convertContents(metadecoders.TOML)
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
 				},
 			},
 			&simpleCommand{
@@ -70,7 +68,6 @@ to use YAML for the front matter.`,
 					return c.convertContents(metadecoders.YAML)
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
 				},
 			},
 		},
@@ -105,13 +102,12 @@ func (c *convertCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, ar
 
 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.
+	cmd.Short = "Convert your content to different formats"
+	cmd.Long = `Convert your content (e.g. front matter) to different formats.
 
 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

commands/deploy.go

@@ -11,26 +11,37 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build withdeploy
-// +build withdeploy
+//go:build !nodeploy
+// +build !nodeploy
+
+// 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"
 
-	"github.com/gohugoio/hugo/deploy"
-	"github.com/gohugoio/hugo/deploy/deployconfig"
-
 	"github.com/bep/simplecobra"
+	"github.com/gohugoio/hugo/deploy"
 	"github.com/spf13/cobra"
 )
 
 func newDeployCommand() simplecobra.Commander {
 	return &simpleCommand{
 		name:  "deploy",
-		short: "Deploy your site to a cloud provider",
-		long: `Deploy your site to a cloud provider
+		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.
@@ -47,17 +58,13 @@ documentation.
 			return deployer.Deploy(ctx)
 		},
 		withc: func(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)
+			cmd.Flags().Bool("invalidateCDN", deploy.DefaultConfig.InvalidateCDN, "invalidate the CDN cache listed in the deployment target")
+			cmd.Flags().Int("maxDeletes", deploy.DefaultConfig.MaxDeletes, "maximum # of files to delete, or -1 to disable")
+			cmd.Flags().Int("workers", deploy.DefaultConfig.Workers, "number of workers to transfer files. defaults to 10")
 		},
 	}
 }

commands/deploy_off.go

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build !withdeploy
-// +build !withdeploy
+//go:build nodeploy
+// +build nodeploy
 
 // Copyright 2024 The Hugo Authors. All rights reserved.
 //
@@ -31,7 +31,6 @@ package commands
 
 import (
 	"context"
-	"errors"
 
 	"github.com/bep/simplecobra"
 	"github.com/spf13/cobra"
@@ -41,7 +40,7 @@ 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")
+			return nil
 		},
 		withc: func(cmd *cobra.Command, r *rootCommand) {
 			cmd.Hidden = true

commands/env.go

@@ -19,14 +19,13 @@ import (
 
 	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/common/hugo"
-	"github.com/spf13/cobra"
 )
 
 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",
+		short: "Print Hugo version and environment info",
+		long:  "Print Hugo 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)
@@ -48,9 +47,6 @@ func newEnvCommand() simplecobra.Commander {
 			}
 			return nil
 		},
-		withc: func(cmd *cobra.Command, r *rootCommand) {
-			cmd.ValidArgsFunction = cobra.NoFileCompletions
-		},
 	}
 }
 
@@ -61,10 +57,7 @@ func newVersionCmd() simplecobra.Commander {
 			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
-		},
+		short: "Print Hugo version and environment info",
+		long:  "Print Hugo version and environment info. This is useful in Hugo bug reports.",
 	}
 }

commands/gen.go

@@ -45,10 +45,9 @@ func newGenCommand() *genCommand {
 		genmandir string
 
 		// Chroma flags.
-		style                  string
-		highlightStyle         string
-		lineNumbersInlineStyle string
-		lineNumbersTableStyle  string
+		style          string
+		highlightStyle string
+		linesStyle     string
 	)
 
 	newChromaStyles := func() simplecobra.Commander {
@@ -64,11 +63,8 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				if highlightStyle != "" {
 					builder.Add(chroma.LineHighlight, highlightStyle)
 				}
-				if lineNumbersInlineStyle != "" {
-					builder.Add(chroma.LineNumbers, lineNumbersInlineStyle)
-				}
-				if lineNumbersTableStyle != "" {
-					builder.Add(chroma.LineNumbersTable, lineNumbersTableStyle)
+				if linesStyle != "" {
+					builder.Add(chroma.LineNumbers, linesStyle)
 				}
 				style, err := builder.Build()
 				if err != nil {
@@ -79,15 +75,9 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				return nil
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
 				cmd.PersistentFlags().StringVar(&style, "style", "friendly", "highlighter style (see https://xyproto.github.io/splash/docs/)")
-				_ = 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().StringVar(&highlightStyle, "highlightStyle", "", "style used for highlighting lines (see https://github.com/alecthomas/chroma)")
+				cmd.PersistentFlags().StringVar(&linesStyle, "linesStyle", "", "style used for line numbers (see https://github.com/alecthomas/chroma)")
 			},
 		}
 	}
@@ -125,9 +115,9 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				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")
+				// For bash-completion
+				cmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
 			},
 		}
 	}
@@ -182,9 +172,9 @@ url: %s
 				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")
+				// For bash-completion
+				cmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
 			},
 		}
 	}
@@ -237,7 +227,6 @@ url: %s
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
 				cmd.Hidden = true
-				cmd.ValidArgsFunction = cobra.NoFileCompletions
 				cmd.PersistentFlags().StringVarP(&docsHelperTarget, "dir", "", "docs/data", "data dir")
 			},
 		}
@@ -273,8 +262,7 @@ func (c *genCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args [
 
 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.Short = "A collection of several useful generators."
 
 	cmd.RunE = nil
 	return nil

commands/hugobuilder.go

@@ -27,6 +27,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/bep/logg"
 	"github.com/bep/simplecobra"
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
@@ -42,7 +43,6 @@ import (
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/hugolib/filesystems"
-	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/livereload"
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/watcher"
@@ -75,14 +75,9 @@ type hugoBuilder struct {
 	errState hugoBuilderErrState
 }
 
-var errConfigNotSet = errors.New("config not set")
-
 func (c *hugoBuilder) withConfE(fn func(conf *commonConfig) error) error {
 	c.confmu.Lock()
 	defer c.confmu.Unlock()
-	if c.conf == nil {
-		return errConfigNotSet
-	}
 	return fn(c.conf)
 }
 
@@ -135,6 +130,10 @@ func (e *hugoBuilderErrState) wasErr() bool {
 	return e.waserr
 }
 
+func (c *hugoBuilder) errCount() int {
+	return c.r.logger.LoggCount(logg.LevelError) + loggers.Log().LoggCount(logg.LevelError)
+}
+
 // getDirList provides NewWatcher() with a list of directories to watch for changes.
 func (c *hugoBuilder) getDirList() ([]string, error) {
 	h, err := c.hugo()
@@ -339,26 +338,6 @@ func (c *hugoBuilder) newWatcher(pollIntervalStr string, dirList ...string) (*wa
 	go func() {
 		for {
 			select {
-			case changes := <-c.r.changesFromBuild:
-				unlock, err := h.LockBuild()
-				if err != nil {
-					c.r.logger.Errorln("Failed to acquire a build lock: %s", err)
-					return
-				}
-				c.changeDetector.PrepareNew()
-				err = c.rebuildSitesForChanges(changes)
-				if err != nil {
-					c.r.logger.Errorln("Error while watching:", err)
-				}
-				if c.s != nil && c.s.doLiveReload {
-					doReload := c.changeDetector == nil || len(c.changeDetector.changed()) > 0
-					doReload = doReload || c.showErrorInBrowser && c.errState.buildErr() != nil
-					if doReload {
-						livereload.ForceRefresh()
-					}
-				}
-				unlock()
-
 			case evs := <-watcher.Events:
 				unlock, err := h.LockBuild()
 				if err != nil {
@@ -366,7 +345,7 @@ func (c *hugoBuilder) newWatcher(pollIntervalStr string, dirList ...string) (*wa
 					return
 				}
 				c.handleEvents(watcher, staticSyncer, evs, configSet)
-				if c.showErrorInBrowser && c.errState.buildErr() != nil {
+				if c.showErrorInBrowser && c.errCount() > 0 {
 					// Need to reload browser to show the error
 					livereload.ForceRefresh()
 				}
@@ -413,17 +392,11 @@ func (c *hugoBuilder) build() error {
 }
 
 func (c *hugoBuilder) buildSites(noBuildLock bool) (err error) {
-	defer func() {
-		c.errState.setBuildErr(err)
-	}()
-
-	var h *hugolib.HugoSites
-	h, err = c.hugo()
+	h, err := c.hugo()
 	if err != nil {
-		return
+		return err
 	}
-	err = h.Build(hugolib.BuildCfg{NoBuildLock: noBuildLock})
-	return
+	return h.Build(hugolib.BuildCfg{NoBuildLock: noBuildLock})
 }
 
 func (c *hugoBuilder) copyStatic() (map[string]uint64, error) {
@@ -612,16 +585,13 @@ func (c *hugoBuilder) fullRebuild(changeType string) {
 			time.Sleep(2 * time.Second)
 		}()
 
-		defer c.postBuild("Rebuilt", time.Now())
+		defer c.r.timeTrack(time.Now(), "Rebuilt")
 
 		err := c.reloadConfig()
 		if err != nil {
 			// Set the processing on pause until the state is recovered.
 			c.errState.setPaused(true)
 			c.handleBuildErr(err, "Failed to reload config")
-			if c.s.doLiveReload {
-				livereload.ForceRefresh()
-			}
 		} else {
 			c.errState.setPaused(false)
 		}
@@ -747,20 +717,6 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 	staticEvents := []fsnotify.Event{}
 	dynamicEvents := []fsnotify.Event{}
 
-	filterDuplicateEvents := func(evs []fsnotify.Event) []fsnotify.Event {
-		seen := make(map[string]bool)
-		var n int
-		for _, ev := range evs {
-			if seen[ev.Name] {
-				continue
-			}
-			seen[ev.Name] = true
-			evs[n] = ev
-			n++
-		}
-		return evs[:n]
-	}
-
 	h, err := c.hugo()
 	if err != nil {
 		c.r.logger.Errorln("Error getting the Hugo object:", err)
@@ -782,7 +738,6 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 		istemp := strings.HasSuffix(ext, "~") ||
 			(ext == ".swp") || // vim
 			(ext == ".swx") || // vim
-			(ext == ".bck") || // helix
 			(ext == ".tmp") || // generic temp file
 			(ext == ".DS_Store") || // OSX Thumbnail
 			baseName == "4913" || // vim
@@ -851,11 +806,6 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 		}
 	}
 
-	lrl := c.r.logger.InfoCommand("livereload")
-
-	staticEvents = filterDuplicateEvents(staticEvents)
-	dynamicEvents = filterDuplicateEvents(dynamicEvents)
-
 	if len(staticEvents) > 0 {
 		c.printChangeDetected("Static files")
 
@@ -876,20 +826,19 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 		if c.s != nil && c.s.doLiveReload {
 			// Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
 
+			// force refresh when more than one file
 			if !c.errState.wasErr() && len(staticEvents) == 1 {
+				ev := staticEvents[0]
 				h, err := c.hugo()
 				if err != nil {
 					c.r.logger.Errorln("Error getting the Hugo object:", err)
 					return
 				}
-
-				path := h.BaseFs.SourceFilesystems.MakeStaticPathRelative(staticEvents[0].Name)
+				path := h.BaseFs.SourceFilesystems.MakeStaticPathRelative(ev.Name)
 				path = h.RelURL(paths.ToSlashTrimLeading(path), false)
 
-				lrl.Logf("refreshing static file %q", path)
 				livereload.RefreshPath(path)
 			} else {
-				lrl.Logf("got %d static file change events, force refresh", len(staticEvents))
 				livereload.ForceRefresh()
 			}
 		}
@@ -900,43 +849,33 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 			h.BaseFs.SourceFilesystems,
 			dynamicEvents)
 
-		onePageName := pickOneWriteOrCreatePath(h.Conf.ContentTypes(), partitionedEvents.ContentEvents)
+		onePageName := pickOneWriteOrCreatePath(partitionedEvents.ContentEvents)
 
 		c.printChangeDetected("")
 		c.changeDetector.PrepareNew()
 
 		func() {
-			defer c.postBuild("Total", time.Now())
+			defer c.r.timeTrack(time.Now(), "Total")
 			if err := c.rebuildSites(dynamicEvents); err != nil {
 				c.handleBuildErr(err, "Rebuild failed")
 			}
 		}()
 
 		if c.s != nil && c.s.doLiveReload {
-			if c.errState.wasErr() {
-				livereload.ForceRefresh()
-				return
-			}
-
-			changed := c.changeDetector.changed()
-			if c.changeDetector != nil {
-				lrl.Logf("build changed %d files", len(changed))
-				if len(changed) == 0 {
-					// Nothing has changed.
+			if len(partitionedEvents.ContentEvents) == 0 && len(partitionedEvents.AssetEvents) > 0 {
+				if c.errState.wasErr() {
+					livereload.ForceRefresh()
 					return
 				}
-			}
-
-			// If this change set also contains one or more CSS files, we need to
-			// refresh these as well.
-			var cssChanges []string
-			var otherChanges []string
-
-			for _, ev := range changed {
-				if strings.HasSuffix(ev, ".css") {
-					cssChanges = append(cssChanges, ev)
+				changed := c.changeDetector.changed()
+				if c.changeDetector != nil && len(changed) == 0 {
+					// Nothing has changed.
+					return
+				} else if len(changed) == 1 {
+					pathToRefresh := h.PathSpec.RelURL(paths.ToSlashTrimLeading(changed[0]), false)
+					livereload.RefreshPath(pathToRefresh)
 				} else {
-					otherChanges = append(otherChanges, ev)
+					livereload.ForceRefresh()
 				}
 			}
 
@@ -952,48 +891,16 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 					}
 				}
 
-				if p != nil && p.RelPermalink() != "" {
-					link, port := p.RelPermalink(), p.Site().ServerPort()
-					lrl.Logf("navigating to %q using port %d", link, port)
-					livereload.NavigateToPathForPort(link, port)
+				if p != nil {
+					livereload.NavigateToPathForPort(p.RelPermalink(), p.Site().ServerPort())
 				} else {
-					lrl.Logf("no page to navigate to, force refresh")
 					livereload.ForceRefresh()
 				}
-			} else if len(otherChanges) > 0 {
-				if len(otherChanges) == 1 {
-					// Allow single changes to be refreshed without a full page reload.
-					pathToRefresh := h.PathSpec.RelURL(paths.ToSlashTrimLeading(otherChanges[0]), false)
-					lrl.Logf("refreshing %q", pathToRefresh)
-					livereload.RefreshPath(pathToRefresh)
-				} else if len(cssChanges) == 0 {
-					lrl.Logf("force refresh")
-					livereload.ForceRefresh()
-				}
-			}
-
-			if len(cssChanges) > 0 {
-				// Allow some time for the live reload script to get reconnected.
-				if len(otherChanges) > 0 {
-					time.Sleep(200 * time.Millisecond)
-				}
-				for _, ev := range cssChanges {
-					pathToRefresh := h.PathSpec.RelURL(paths.ToSlashTrimLeading(ev), false)
-					lrl.Logf("refreshing CSS %q", pathToRefresh)
-					livereload.RefreshPath(pathToRefresh)
-				}
 			}
 		}
 	}
 }
 
-func (c *hugoBuilder) postBuild(what string, start time.Time) {
-	if h, err := c.hugo(); err == nil && h.Conf.Running() {
-		h.LogServerAddresses()
-	}
-	c.r.timeTrack(start, what)
-}
-
 func (c *hugoBuilder) hugo() (*hugolib.HugoSites, error) {
 	var h *hugolib.HugoSites
 	if err := c.withConfE(func(conf *commonConfig) error {
@@ -1023,7 +930,7 @@ func (c *hugoBuilder) hugoTry() *hugolib.HugoSites {
 
 func (c *hugoBuilder) loadConfig(cd *simplecobra.Commandeer, running bool) error {
 	cfg := config.New()
-	cfg.Set("renderToMemory", c.r.renderToMemory)
+	cfg.Set("renderToDisk", (c.s == nil && !c.r.renderToMemory) || (c.s != nil && c.s.renderToDisk))
 	watch := c.r.buildWatch || (c.s != nil && c.s.serverWatch)
 	if c.r.environment == "" {
 		// We need to set the environment as early as possible because we need it to load the correct config.
@@ -1044,13 +951,12 @@ func (c *hugoBuilder) loadConfig(cd *simplecobra.Commandeer, running bool) error
 	cfg.Set("environment", c.r.environment)
 
 	cfg.Set("internal", maps.Params{
-		"running":        running,
-		"watch":          watch,
-		"verbose":        c.r.isVerbose(),
-		"fastRenderMode": c.fastRenderMode,
+		"running": running,
+		"watch":   watch,
+		"verbose": c.r.isVerbose(),
 	})
 
-	conf, err := c.r.ConfigFromProvider(configKey{counter: c.r.configVersionID.Load()}, flagsToCfg(cd, cfg))
+	conf, err := c.r.ConfigFromProvider(c.r.configVersionID.Load(), flagsToCfg(cd, cfg))
 	if err != nil {
 		return err
 	}
@@ -1084,49 +990,29 @@ func (c *hugoBuilder) printChangeDetected(typ string) {
 	c.r.logger.Println(htime.Now().Format(layout))
 }
 
-func (c *hugoBuilder) rebuildSites(events []fsnotify.Event) (err error) {
-	defer func() {
-		c.errState.setBuildErr(err)
-	}()
+func (c *hugoBuilder) rebuildSites(events []fsnotify.Event) error {
 	if err := c.errState.buildErr(); err != nil {
 		ferrs := herrors.UnwrapFileErrorsWithErrorContext(err)
 		for _, err := range ferrs {
 			events = append(events, fsnotify.Event{Name: err.Position().Filename, Op: fsnotify.Write})
 		}
 	}
-	var h *hugolib.HugoSites
-	h, err = c.hugo()
+	c.errState.setBuildErr(nil)
+	h, err := c.hugo()
 	if err != nil {
-		return
+		return err
 	}
-	err = h.Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()}, events...)
-	return
-}
 
-func (c *hugoBuilder) rebuildSitesForChanges(ids []identity.Identity) (err error) {
-	defer func() {
-		c.errState.setBuildErr(err)
-	}()
-
-	var h *hugolib.HugoSites
-	h, err = c.hugo()
-	if err != nil {
-		return
-	}
-	whatChanged := &hugolib.WhatChanged{}
-	whatChanged.Add(ids...)
-	err = h.Build(hugolib.BuildCfg{NoBuildLock: true, WhatChanged: whatChanged, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()})
-
-	return
+	return h.Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()}, events...)
 }
 
 func (c *hugoBuilder) reloadConfig() error {
-	c.r.resetLogs()
+	c.r.Reset()
 	c.r.configVersionID.Add(1)
 
 	if err := c.withConfE(func(conf *commonConfig) error {
 		oldConf := conf
-		newConf, err := c.r.ConfigFromConfig(configKey{counter: c.r.configVersionID.Load()}, conf)
+		newConf, err := c.r.ConfigFromConfig(c.r.configVersionID.Load(), conf)
 		if err != nil {
 			return err
 		}

commands/import.go

@@ -58,7 +58,6 @@ Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root
 					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")
 				},
 			},
@@ -90,8 +89,8 @@ func (c *importCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 
 func (c *importCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
-	cmd.Short = "Import a site from another system"
-	cmd.Long = `Import a site from another system.
+	cmd.Short = "Import your site from others."
+	cmd.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`."
 

commands/list.go

@@ -23,10 +23,10 @@ import (
 	"time"
 
 	"github.com/bep/simplecobra"
+	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/resources/resource"
-	"github.com/spf13/cobra"
 )
 
 // newListCommand creates a new list command and its subcommands.
@@ -41,14 +41,12 @@ func newListCommand() *listCommand {
 			p.PublishDate().Format(time.RFC3339),
 			strconv.FormatBool(p.Draft()),
 			p.Permalink(),
-			p.Kind(),
-			p.Section(),
 		}
 	}
 
 	list := func(cd *simplecobra.Commandeer, r *rootCommand, shouldInclude func(page.Page) bool, opts ...any) error {
 		bcfg := hugolib.BuildCfg{SkipRender: true}
-		cfg := flagsToCfg(cd, nil)
+		cfg := config.New()
 		for i := 0; i < len(opts); i += 2 {
 			cfg.Set(opts[i].(string), opts[i+1])
 		}
@@ -69,8 +67,6 @@ func newListCommand() *listCommand {
 			"publishDate",
 			"draft",
 			"permalink",
-			"kind",
-			"section",
 		})
 
 		for _, p := range h.Pages() {
@@ -79,6 +75,9 @@ func newListCommand() *listCommand {
 				if err := writer.Write(record); err != nil {
 					return err
 				}
+				if err != nil {
+					return err
+				}
 			}
 		}
 
@@ -89,8 +88,8 @@ func newListCommand() *listCommand {
 		commands: []simplecobra.Commander{
 			&simpleCommand{
 				name:  "drafts",
-				short: "List draft content",
-				long:  `List draft content.`,
+				short: "List all drafts",
+				long:  `List all of the drafts in your content directory.`,
 				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 {
@@ -104,14 +103,11 @@ func newListCommand() *listCommand {
 						"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.`,
+				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.`,
 				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 {
@@ -124,14 +120,11 @@ func newListCommand() *listCommand {
 						"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.`,
+				short: "List all posts already expired",
+				long:  `List all of the posts in your content directory which has already expired.`,
 				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 {
@@ -144,37 +137,17 @@ func newListCommand() *listCommand {
 						"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.`,
+				short: "List all posts",
+				long:  `List all of the posts in your content directory, include drafts, future and expired pages.`,
 				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
-				},
 			},
 		},
 	}
@@ -199,8 +172,8 @@ func (c *listCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args
 
 func (c *listCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
-	cmd.Short = "List content"
-	cmd.Long = `List content.
+	cmd.Short = "Listing out various types of content"
+	cmd.Long = `Listing out various types of content.
 
 List requires a subcommand, e.g. hugo list drafts`
 

commands/mod.go

@@ -62,7 +62,6 @@ removed from Hugo, but we need to test this out in "real life" to get a feel of
 so this may/will change in future versions of Hugo.
 `,
 				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 {
@@ -90,11 +89,10 @@ so this may/will change in future versions of Hugo.
 	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)
+					h, err := r.Hugo(flagsToCfg(cd, nil))
 					if err != nil {
 						return err
 					}
@@ -102,11 +100,7 @@ so this may/will change in future versions of Hugo.
 					if len(args) >= 1 {
 						initPath = args[0]
 					}
-					c := h.Configs.ModulesClient
-					if err := c.Init(initPath); err != nil {
-						return err
-					}
-					return nil
+					return h.Configs.ModulesClient.Init(initPath)
 				},
 			},
 			&simpleCommand{
@@ -114,12 +108,11 @@ so this may/will change in future versions of Hugo.
 				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))
+					conf, err := r.ConfigFromProvider(r.configVersionID.Load(), flagsToCfg(cd, nil))
 					if err != nil {
 						return err
 					}
@@ -134,12 +127,11 @@ so this may/will change in future versions of Hugo.
 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))
+					conf, err := r.ConfigFromProvider(r.configVersionID.Load(), flagsToCfg(cd, nil))
 					if err != nil {
 						return err
 					}
@@ -152,10 +144,8 @@ Note that for vendored modules, that is the version listed and not the one from
 				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 {
@@ -177,7 +167,6 @@ Note that for vendored modules, that is the version listed and not the one from
 				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 {
@@ -195,7 +184,6 @@ Note that for vendored modules, that is the version listed and not the one from
 	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 {
@@ -237,7 +225,6 @@ Run "go help get" for more information. All flags available for "go get" is also
 ` + 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
@@ -272,14 +259,13 @@ Run "go help get" for more information. All flags available for "go get" is also
 							if info.Name() == "go.mod" {
 								// Found a module.
 								dir := filepath.Dir(path)
-
+								r.Println("Update module in", dir)
 								cfg := config.New()
 								cfg.Set("workingDir", dir)
-								conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Add(1)}, flagsToCfg(cd, cfg))
+								conf, err := r.ConfigFromProvider(r.configVersionID.Load(), 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...)
 
@@ -288,7 +274,7 @@ Run "go help get" for more information. All flags available for "go get" is also
 						})
 						return nil
 					} else {
-						conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, nil))
+						conf, err := r.ConfigFromProvider(r.configVersionID.Load(), flagsToCfg(cd, nil))
 						if err != nil {
 							return err
 						}
@@ -317,7 +303,7 @@ func (c *modCommands) Name() string {
 }
 
 func (c *modCommands) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	_, err := c.r.ConfigFromProvider(configKey{counter: c.r.configVersionID.Load()}, nil)
+	_, err := c.r.ConfigFromProvider(c.r.configVersionID.Load(), nil)
 	if err != nil {
 		return err
 	}
@@ -328,7 +314,7 @@ func (c *modCommands) Run(ctx context.Context, cd *simplecobra.Commandeer, args
 
 func (c *modCommands) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
-	cmd.Short = "Manage modules"
+	cmd.Short = "Various Hugo Modules helpers."
 	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".

commands/new.go

@@ -40,7 +40,7 @@ func newNewCommand() *newCommand {
 			&simpleCommand{
 				name:  "content",
 				use:   "content [path]",
-				short: "Create new content",
+				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.
 
@@ -60,15 +60,8 @@ Ensure you run this within the root directory of your site.`,
 					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)
 				},
@@ -93,7 +86,7 @@ Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 					cfg.Set("workingDir", createpath)
 					cfg.Set("publishDir", "public")
 
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, cfg))
+					conf, err := r.ConfigFromProvider(r.configVersionID.Load(), flagsToCfg(cd, cfg))
 					if err != nil {
 						return err
 					}
@@ -110,15 +103,8 @@ Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 					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{
@@ -136,7 +122,7 @@ according to your needs.`,
 					cfg := config.New()
 					cfg.Set("publishDir", "public")
 
-					conf, err := r.ConfigFromProvider(configKey{counter: r.configVersionID.Load()}, flagsToCfg(cd, cfg))
+					conf, err := r.ConfigFromProvider(r.configVersionID.Load(), flagsToCfg(cd, cfg))
 					if err != nil {
 						return err
 					}
@@ -151,9 +137,6 @@ according to your needs.`,
 
 					return nil
 				},
-				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
-				},
 			},
 		},
 	}
@@ -181,7 +164,7 @@ func (c *newCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args [
 
 func (c *newCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
-	cmd.Short = "Create new content"
+	cmd.Short = "Create new content for your site"
 	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.
 
@@ -209,7 +192,7 @@ func (c *newCommand) newSiteNextStepsText(path string, format string) string {
 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/
+   - 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 `)
 

commands/release.go

@@ -43,11 +43,9 @@ func newReleaseCommand() simplecobra.Commander {
 		},
 		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.RegisterFlagCompletionFunc("step", cobra.FixedCompletions([]string{"1", "2"}, cobra.ShellCompDirectiveNoFileComp))
 		},
 	}
 }

commands/server.go

@@ -25,7 +25,6 @@ import (
 	"io"
 	"net"
 	"net/http"
-	_ "net/http/pprof"
 	"net/url"
 	"os"
 	"os/signal"
@@ -46,12 +45,12 @@ import (
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/hugo"
-
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/common/urls"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/hugofs/files"
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/hugolib/filesystems"
 	"github.com/gohugoio/hugo/livereload"
@@ -123,7 +122,6 @@ func newServerCommand() *serverCommand {
 					return mclib.RunMain()
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					cmd.Flags().BoolVar(&uninstall, "uninstall", false, "Uninstall the local CA (but do not delete it).")
 				},
 			},
@@ -162,16 +160,16 @@ type dynamicEvents struct {
 
 type fileChangeDetector struct {
 	sync.Mutex
-	current map[string]uint64
-	prev    map[string]uint64
+	current map[string]string
+	prev    map[string]string
 
 	irrelevantRe *regexp.Regexp
 }
 
-func (f *fileChangeDetector) OnFileClose(name string, checksum uint64) {
+func (f *fileChangeDetector) OnFileClose(name, md5sum string) {
 	f.Lock()
 	defer f.Unlock()
-	f.current[name] = checksum
+	f.current[name] = md5sum
 }
 
 func (f *fileChangeDetector) PrepareNew() {
@@ -183,16 +181,16 @@ func (f *fileChangeDetector) PrepareNew() {
 	defer f.Unlock()
 
 	if f.current == nil {
-		f.current = make(map[string]uint64)
-		f.prev = make(map[string]uint64)
+		f.current = make(map[string]string)
+		f.prev = make(map[string]string)
 		return
 	}
 
-	f.prev = make(map[string]uint64)
+	f.prev = make(map[string]string)
 	for k, v := range f.current {
 		f.prev[k] = v
 	}
-	f.current = make(map[string]uint64)
+	f.current = make(map[string]string)
 }
 
 func (f *fileChangeDetector) changed() []string {
@@ -237,16 +235,15 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string
 	listener := f.c.serverPorts[i].ln
 	logger := f.c.r.logger
 
+	r.Printf("Environment: %q\n", f.c.hugoTry().Deps.Site.Hugo().Environment)
+
 	if i == 0 {
-		r.Printf("Environment: %q\n", f.c.hugoTry().Deps.Site.Hugo().Environment)
-		mainTarget := "disk"
-		if f.c.r.renderToMemory {
-			mainTarget = "memory"
-		}
-		if f.c.renderStaticToDisk {
-			r.Printf("Serving pages from %s and static files from disk\n", mainTarget)
+		if f.c.renderToDisk {
+			r.Println("Serving pages from disk")
+		} else if f.c.renderStaticToDisk {
+			r.Println("Serving pages from memory and static files from disk")
 		} else {
-			r.Printf("Serving pages from %s\n", mainTarget)
+			r.Println("Serving pages from memory")
 		}
 	}
 
@@ -307,7 +304,7 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string
 			if redirect := serverConfig.MatchRedirect(requestURI); !redirect.IsZero() {
 				// fullName := filepath.Join(dir, filepath.FromSlash(path.Clean("/"+name)))
 				doRedirect := true
-				// This matches Netlify's behavior and is needed for SPA behavior.
+				// This matches Netlify's behaviour and is needed for SPA behaviour.
 				// See https://docs.netlify.com/routing/redirects/rewrites-proxies/
 				if !redirect.Force {
 					path := filepath.Clean(strings.TrimPrefix(requestURI, baseURL.Path()))
@@ -446,6 +443,7 @@ type serverCommand struct {
 	doLiveReload bool
 
 	// Flags.
+	renderToDisk        bool
 	renderStaticToDisk  bool
 	navigateToChanged   bool
 	serverAppend        bool
@@ -453,7 +451,6 @@ type serverCommand struct {
 	tlsCertFile         string
 	tlsKeyFile          string
 	tlsAuto             bool
-	pprof               bool
 	serverPort          int
 	liveReloadPort      int
 	serverWatch         bool
@@ -468,11 +465,6 @@ func (c *serverCommand) Name() string {
 }
 
 func (c *serverCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	if c.pprof {
-		go func() {
-			http.ListenAndServe("localhost:8080", nil)
-		}()
-	}
 	// Watch runs its own server as part of the routine
 	if c.serverWatch {
 
@@ -497,7 +489,8 @@ func (c *serverCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 
 	err := func() error {
 		defer c.r.timeTrack(time.Now(), "Built")
-		return c.build()
+		err := c.build()
+		return err
 	}()
 	if err != nil {
 		return err
@@ -508,13 +501,12 @@ func (c *serverCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 
 func (c *serverCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
-	cmd.Short = "Start the embedded web server"
+	cmd.Short = "A high performance webserver"
 	cmd.Long = `Hugo provides its own webserver which builds and serves the site.
 While hugo server is high performance, it is a webserver with limited options.
 
-The ` + "`" + `hugo server` + "`" + ` command will by default write and serve files from disk, but
-you can render to memory by using the ` + "`" + `--renderToMemory` + "`" + ` flag. This can be
-faster in some cases, but it will consume more memory.
+'hugo server' will avoid writing the rendered and served content to disk,
+preferring to store it in memory.
 
 By default hugo will also watch your files for any changes you make and
 automatically rebuild the site. It will then live reload any open browser pages
@@ -523,26 +515,27 @@ of a second, you will be able to save and see your changes nearly instantly.`
 	cmd.Aliases = []string{"serve"}
 
 	cmd.Flags().IntVarP(&c.serverPort, "port", "p", 1313, "port on which the server will listen")
-	_ = cmd.RegisterFlagCompletionFunc("port", cobra.NoFileCompletions)
 	cmd.Flags().IntVar(&c.liveReloadPort, "liveReloadPort", -1, "port for live reloading (i.e. 443 in HTTPS proxy situations)")
-	_ = cmd.RegisterFlagCompletionFunc("liveReloadPort", cobra.NoFileCompletions)
 	cmd.Flags().StringVarP(&c.serverInterface, "bind", "", "127.0.0.1", "interface to which the server will bind")
-	_ = cmd.RegisterFlagCompletionFunc("bind", cobra.NoFileCompletions)
 	cmd.Flags().StringVarP(&c.tlsCertFile, "tlsCertFile", "", "", "path to TLS certificate file")
-	_ = cmd.MarkFlagFilename("tlsCertFile", "pem")
 	cmd.Flags().StringVarP(&c.tlsKeyFile, "tlsKeyFile", "", "", "path to TLS key file")
-	_ = cmd.MarkFlagFilename("tlsKeyFile", "pem")
 	cmd.Flags().BoolVar(&c.tlsAuto, "tlsAuto", false, "generate and use locally-trusted certificates.")
-	cmd.Flags().BoolVar(&c.pprof, "pprof", false, "enable the pprof server (port 8080)")
 	cmd.Flags().BoolVarP(&c.serverWatch, "watch", "w", true, "watch filesystem for changes and recreate as needed")
 	cmd.Flags().BoolVar(&c.noHTTPCache, "noHTTPCache", false, "prevent HTTP caching")
 	cmd.Flags().BoolVarP(&c.serverAppend, "appendPort", "", true, "append port to baseURL")
 	cmd.Flags().BoolVar(&c.disableLiveReload, "disableLiveReload", false, "watch without enabling live browser reload on rebuild")
-	cmd.Flags().BoolVarP(&c.navigateToChanged, "navigateToChanged", "N", false, "navigate to changed content file on live browser reload")
+	cmd.Flags().BoolVar(&c.navigateToChanged, "navigateToChanged", false, "navigate to changed content file on live browser reload")
+	cmd.Flags().BoolVar(&c.renderToDisk, "renderToDisk", false, "serve all files from disk (default is from memory)")
 	cmd.Flags().BoolVar(&c.renderStaticToDisk, "renderStaticToDisk", false, "serve static files from disk and dynamic files from memory")
 	cmd.Flags().BoolVar(&c.disableFastRender, "disableFastRender", false, "enables full re-renders on changes")
 	cmd.Flags().BoolVar(&c.disableBrowserError, "disableBrowserError", false, "do not show build errors in the browser")
 
+	cmd.Flags().String("memstats", "", "log memory usage to this file")
+	cmd.Flags().String("meminterval", "100ms", "interval to poll memory usage (requires --memstats), valid time units are \"ns\", \"us\" (or \"µs\"), \"ms\", \"s\", \"m\", \"h\".")
+
+	cmd.Flags().SetAnnotation("tlsCertFile", cobra.BashCompSubdirsInDir, []string{})
+	cmd.Flags().SetAnnotation("tlsKeyFile", cobra.BashCompSubdirsInDir, []string{})
+
 	r := cd.Root.Command.(*rootCommand)
 	applyLocalFlagsBuild(cmd, r)
 
@@ -568,7 +561,7 @@ func (c *serverCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 				}
 			}
 
-			if err := c.setServerInfoInConfig(); err != nil {
+			if err := c.setBaseURLsInConfig(); err != nil {
 				return err
 			}
 
@@ -584,9 +577,7 @@ func (c *serverCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 	)
 
 	destinationFlag := cd.CobraCommand.Flags().Lookup("destination")
-	if c.r.renderToMemory && (destinationFlag != nil && destinationFlag.Changed) {
-		return fmt.Errorf("cannot use --renderToMemory with --destination")
-	}
+	c.renderToDisk = c.renderToDisk || (destinationFlag != nil && destinationFlag.Changed)
 	c.doLiveReload = !c.disableLiveReload
 	c.fastRenderMode = !c.disableFastRender
 	c.showErrorInBrowser = c.doLiveReload && !c.disableBrowserError
@@ -613,15 +604,15 @@ func (c *serverCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 	return nil
 }
 
-func (c *serverCommand) setServerInfoInConfig() error {
+func (c *serverCommand) setBaseURLsInConfig() error {
 	if len(c.serverPorts) == 0 {
 		panic("no server ports set")
 	}
 	return c.withConfE(func(conf *commonConfig) error {
 		for i, language := range conf.configs.Languages {
-			isMultihost := conf.configs.IsMultihost
+			isMultiHost := conf.configs.IsMultihost
 			var serverPort int
-			if isMultihost {
+			if isMultiHost {
 				serverPort = c.serverPorts[i].p
 			} else {
 				serverPort = c.serverPorts[0].p
@@ -640,16 +631,16 @@ func (c *serverCommand) setServerInfoInConfig() error {
 			if c.liveReloadPort != -1 {
 				baseURLLiveReload, _ = baseURLLiveReload.WithPort(c.liveReloadPort)
 			}
-			langConfig.C.SetServerInfo(baseURL, baseURLLiveReload, c.serverInterface)
-
+			langConfig.C.SetBaseURL(baseURL, baseURLLiveReload)
 		}
 		return nil
 	})
 }
 
 func (c *serverCommand) getErrorWithContext() any {
-	buildErr := c.errState.buildErr()
-	if buildErr == nil {
+	errCount := c.errCount()
+
+	if errCount == 0 {
 		return nil
 	}
 
@@ -658,7 +649,7 @@ func (c *serverCommand) getErrorWithContext() any {
 	m["Error"] = cleanErrorLog(c.r.logger.Errors())
 
 	m["Version"] = hugo.BuildVersionString()
-	ferrors := herrors.UnwrapFileErrorsWithErrorContext(buildErr)
+	ferrors := herrors.UnwrapFileErrorsWithErrorContext(c.errState.buildErr())
 	m["Files"] = ferrors
 
 	return m
@@ -739,9 +730,9 @@ func (c *serverCommand) createServerPorts(cd *simplecobra.Commandeer) error {
 	flags := cd.CobraCommand.Flags()
 	var cerr error
 	c.withConf(func(conf *commonConfig) {
-		isMultihost := conf.configs.IsMultihost
+		isMultiHost := conf.configs.IsMultihost
 		c.serverPorts = make([]serverPortListener, 1)
-		if isMultihost {
+		if isMultiHost {
 			if !c.serverAppend {
 				cerr = errors.New("--appendPort=false not supported when in multihost mode")
 				return
@@ -829,25 +820,22 @@ func (c *serverCommand) fixURL(baseURLFromConfig, baseURLFromFlag string, port i
 	return u.String(), nil
 }
 
-func (c *serverCommand) partialReRender(urls ...string) (err error) {
+func (c *serverCommand) partialReRender(urls ...string) error {
 	defer func() {
 		c.errState.setWasErr(false)
 	}()
+	c.errState.setBuildErr(nil)
 	visited := types.NewEvictingStringQueue(len(urls))
 	for _, url := range urls {
 		visited.Add(url)
 	}
 
-	var h *hugolib.HugoSites
-	h, err = c.hugo()
+	h, err := c.hugo()
 	if err != nil {
-		return
+		return err
 	}
-
 	// Note: We do not set NoBuildLock as the file lock is not acquired at this stage.
-	err = h.Build(hugolib.BuildCfg{NoBuildLock: false, RecentlyVisited: visited, PartialReRender: true, ErrRecovery: c.errState.wasErr()})
-
-	return
+	return h.Build(hugolib.BuildCfg{NoBuildLock: false, RecentlyVisited: visited, PartialReRender: true, ErrRecovery: c.errState.wasErr()})
 }
 
 func (c *serverCommand) serve() error {
@@ -857,7 +845,7 @@ func (c *serverCommand) serve() error {
 		h        *hugolib.HugoSites
 	)
 	err := c.withConfE(func(conf *commonConfig) error {
-		isMultihost := conf.configs.IsMultihost
+		isMultiHost := conf.configs.IsMultihost
 		var err error
 		h, err = c.r.HugFromConfig(conf)
 		if err != nil {
@@ -867,7 +855,7 @@ func (c *serverCommand) serve() error {
 		// We need the server to share the same logger as the Hugo build (for error counts etc.)
 		c.r.logger = h.Log
 
-		if isMultihost {
+		if isMultiHost {
 			for _, l := range conf.configs.ConfigLangs() {
 				baseURLs = append(baseURLs, l.BaseURL())
 				roots = append(roots, l.Language().Lang)
@@ -1010,10 +998,15 @@ func (c *serverCommand) serve() error {
 			}
 		}
 	}()
+
 	if err != nil {
 		c.r.Println("Error:", err)
 	}
 
+	if h := c.hugoTry(); h != nil {
+		h.Close()
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	wg2, ctx := errgroup.WithContext(ctx)
@@ -1087,7 +1080,7 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 
 			fromPath := ev.Name
 
-			relPath, found := sourceFs.MakePathRelative(fromPath, true)
+			relPath, found := sourceFs.MakePathRelative(fromPath)
 
 			if !found {
 				// Not member of this virtual host.
@@ -1186,16 +1179,16 @@ func partitionDynamicEvents(sourceFs *filesystems.SourceFilesystems, events []fs
 	return
 }
 
-func pickOneWriteOrCreatePath(contentTypes config.ContentTypesProvider, events []fsnotify.Event) string {
+func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
 	name := ""
 
 	for _, ev := range events {
 		if ev.Op&fsnotify.Write == fsnotify.Write || ev.Op&fsnotify.Create == fsnotify.Create {
-			if contentTypes.IsIndexContentFile(ev.Name) {
+			if files.IsIndexContentFile(ev.Name) {
 				return ev.Name
 			}
 
-			if contentTypes.IsContentFile(ev.Name) {
+			if files.IsContentFile(ev.Name) {
 				name = ev.Name
 			}
 

common/collections/stack.go

@@ -1,80 +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 "sync"
-
-// Stack is a simple LIFO stack that is safe for concurrent use.
-type Stack[T any] struct {
-	items []T
-	zero  T
-	mu    sync.RWMutex
-}
-
-func NewStack[T any]() *Stack[T] {
-	return &Stack[T]{}
-}
-
-func (s *Stack[T]) Push(item T) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.items = append(s.items, item)
-}
-
-func (s *Stack[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 *Stack[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 *Stack[T]) Len() int {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return len(s.items)
-}
-
-func (s *Stack[T]) Drain() []T {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	items := s.items
-	s.items = nil
-	return items
-}
-
-func (s *Stack[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 = append(s.items[:i], s.items[i+1:]...)
-		}
-	}
-	return items
-}

common/hashing/hashing.go

@@ -1,166 +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/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
-}
-
-// 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 string
-// and returns the hash as a hex encoded string.
-func XxHashFromStringHexEncoded(f string) string {
-	h := xxhash.New()
-	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)
-}
-
-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
-	}
-
-	hashOpts := getHashOpts()
-	defer putHashOpts(hashOpts)
-
-	hash, err := hashstructure.Hash(o, hashOpts)
-	if err != nil {
-		panic(err)
-	}
-	return hash
-}
-
-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)
-}

common/hashing/hashing_test.go

@@ -1,144 +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 := 0; i < 10; i++ {
-		i := i
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := 0; j < 100; j++ {
-				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")
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		XXHashFromReader(r)
-		r.Seek(0, 0)
-	}
-}
-
-func BenchmarkXXHashFromString(b *testing.B) {
-	s := "Hello World"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		XXHashFromString(s)
-	}
-}
-
-func BenchmarkXXHashFromStringHexEncoded(b *testing.B) {
-	s := "The quick brown fox jumps over the lazy dog"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		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 i := 0; i < b.N; i++ {
-				HashString(test)
-			}
-		})
-	}
-}

common/herrors/errors.go

@@ -19,10 +19,8 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"regexp"
 	"runtime"
 	"runtime/debug"
-	"strings"
 	"time"
 )
 
@@ -68,20 +66,6 @@ func (e *TimeoutError) Is(target error) bool {
 	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{})
@@ -132,41 +116,3 @@ func IsNotExist(err error) bool {
 
 	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)
-}

common/hexec/exec.go

@@ -21,10 +21,8 @@ import (
 	"io"
 	"os"
 	"os/exec"
-	"path/filepath"
 	"regexp"
 	"strings"
-	"sync"
 
 	"github.com/cli/safeexec"
 	"github.com/gohugoio/hugo/config"
@@ -86,7 +84,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) *Exec {
+func New(cfg security.Config) *Exec {
 	var baseEnviron []string
 	for _, v := range os.Environ() {
 		k, _ := config.SplitEnvVar(v)
@@ -97,7 +95,6 @@ func New(cfg security.Config, workingDir string) *Exec {
 
 	return &Exec{
 		sc:          cfg,
-		workingDir:  workingDir,
 		baseEnviron: baseEnviron,
 	}
 }
@@ -122,23 +119,15 @@ func SafeCommand(name string, arg ...string) (*exec.Cmd, error) {
 
 // Exec enforces a security policy for commands run via os/exec.
 type Exec struct {
-	sc         security.Config
-	workingDir string
+	sc security.Config
 
 	// os.Environ filtered by the Exec.OsEnviron whitelist filter.
 	baseEnviron []string
-
-	npxInit      sync.Once
-	npxAvailable bool
-}
-
-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
 	}
@@ -147,51 +136,17 @@ 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...)
 }
 
-// Npx will in order:
-// 1. Try fo find the binary in the WORKINGDIR/node_modules/.bin directory.
-// 2. If not found, and npx is available, run npx --no-install <name> <args>.
-// 3. Fall back to the PATH.
+// 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) {
-	// npx is slow, so first try the common case.
-	nodeBinFilename := filepath.Join(e.workingDir, nodeModulesBinPath, name)
-	_, err := safeexec.LookPath(nodeBinFilename)
-	if err == nil {
-		return e.new(name, nodeBinFilename, arg...)
-	}
-	e.checkNpx()
-	if e.npxAvailable {
-		r, err := e.npx(name, arg...)
-		if err == nil {
-			return r, nil
-		}
-	}
-	return e.New(name, arg...)
-}
-
-const (
-	npxNoInstall       = "--no-install"
-	npxBinary          = "npx"
-	nodeModulesBinPath = "node_modules/.bin"
-)
-
-func (e *Exec) checkNpx() {
-	e.npxInit.Do(func() {
-		e.npxAvailable = InPath(npxBinary)
-	})
-}
-
-// 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) {
-	arg = append(arg[:0], append([]any{npxNoInstall, name}, arg[0:]...)...)
-	return e.New(npxBinary, arg...)
+	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.
@@ -200,12 +155,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.
@@ -228,14 +182,8 @@ func (c *cmdWrapper) Run() error {
 	if err == nil {
 		return nil
 	}
-	name := c.name
-	method := "in PATH"
-	if name == npxBinary {
-		name = c.c.Args[2]
-		method = "using npx"
-	}
 	if notFoundRe.MatchString(c.outerr.String()) {
-		return &NotFoundError{name: name, method: method}
+		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())
 }
@@ -251,9 +199,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) {
@@ -273,17 +220,10 @@ func (c *commandeer) command(arg ...any) (*cmdWrapper, error) {
 		}
 	}
 
-	var bin string
-	if c.fullyQualifiedName != "" {
-		bin = c.fullyQualifiedName
-	} else {
-		var err error
-		bin, err = safeexec.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,
 		}
 	}
 

common/hreflect/helpers.go

@@ -268,8 +268,7 @@ func IsContextType(tp reflect.Type) bool {
 		return true
 	}
 
-	isContext, _ := isContextCache.GetOrCreate(tp, func() (bool, error) {
-		return tp.Implements(contextInterface), nil
+	return isContextCache.GetOrCreate(tp, func() bool {
+		return tp.Implements(contextInterface)
 	})
-	return isContext
 }

common/hstrings/strings.go

@@ -123,20 +123,6 @@ func InSlicEqualFold(arr []string, el string) bool {
 	return false
 }
 
-// ToString converts the given value to a string.
-// Note that this is a more strict version compared to cast.ToString,
-// as it will not try to convert numeric values to strings,
-// but only accept strings or fmt.Stringer.
-func ToString(v any) (string, bool) {
-	switch vv := v.(type) {
-	case string:
-		return vv, true
-	case fmt.Stringer:
-		return vv.String(), true
-	}
-	return "", false
-}
-
 type Tuple struct {
 	First  string
 	Second string

common/hugio/hasBytesWriter.go

@@ -17,35 +17,24 @@ import (
 	"bytes"
 )
 
-// HasBytesWriter is a writer will match against a slice of patterns.
+// HasBytesWriter is a writer that will set Match to true if the given pattern
+// is found in the stream.
 type HasBytesWriter struct {
-	Patterns []*HasBytesPattern
+	Match   bool
+	Pattern []byte
 
 	i    int
 	done bool
 	buff []byte
 }
 
-type HasBytesPattern struct {
-	Match   bool
-	Pattern []byte
-}
-
-func (h *HasBytesWriter) patternLen() int {
-	l := 0
-	for _, p := range h.Patterns {
-		l += len(p.Pattern)
-	}
-	return l
-}
-
 func (h *HasBytesWriter) Write(p []byte) (n int, err error) {
 	if h.done {
 		return len(p), nil
 	}
 
 	if len(h.buff) == 0 {
-		h.buff = make([]byte, h.patternLen()*2)
+		h.buff = make([]byte, len(h.Pattern)*2)
 	}
 
 	for i := range p {
@@ -57,23 +46,11 @@ func (h *HasBytesWriter) Write(p []byte) (n int, err error) {
 			h.i = len(h.buff) / 2
 		}
 
-		for _, pp := range h.Patterns {
-			if bytes.Contains(h.buff, pp.Pattern) {
-				pp.Match = true
-				done := true
-				for _, ppp := range h.Patterns {
-					if !ppp.Match {
-						done = false
-						break
-					}
-				}
-				if done {
-					h.done = true
-				}
-				return len(p), nil
-			}
+		if bytes.Contains(h.buff, h.Pattern) {
+			h.Match = true
+			h.done = true
+			return len(p), nil
 		}
-
 	}
 
 	return len(p), nil

common/hugio/hasBytesWriter_test.go

@@ -34,11 +34,8 @@ func TestHasBytesWriter(t *testing.T) {
 		var b bytes.Buffer
 
 		h := &HasBytesWriter{
-			Patterns: []*HasBytesPattern{
-				{Pattern: []byte("__foo")},
-			},
+			Pattern: []byte("__foo"),
 		}
-
 		return h, io.MultiWriter(&b, h)
 	}
 
@@ -49,19 +46,19 @@ func TestHasBytesWriter(t *testing.T) {
 	for i := 0; i < 22; i++ {
 		h, w := neww()
 		fmt.Fprintf(w, rndStr()+"abc __foobar"+rndStr())
-		c.Assert(h.Patterns[0].Match, qt.Equals, true)
+		c.Assert(h.Match, qt.Equals, true)
 
 		h, w = neww()
 		fmt.Fprintf(w, rndStr()+"abc __f")
 		fmt.Fprintf(w, "oo bar"+rndStr())
-		c.Assert(h.Patterns[0].Match, qt.Equals, true)
+		c.Assert(h.Match, qt.Equals, true)
 
 		h, w = neww()
 		fmt.Fprintf(w, rndStr()+"abc __moo bar")
-		c.Assert(h.Patterns[0].Match, qt.Equals, false)
+		c.Assert(h.Match, qt.Equals, false)
 	}
 
 	h, w := neww()
 	fmt.Fprintf(w, "__foo")
-	c.Assert(h.Patterns[0].Match, qt.Equals, true)
+	c.Assert(h.Match, qt.Equals, true)
 }

common/hugio/readers.go

@@ -37,47 +37,32 @@ type ReadSeekCloserProvider interface {
 	ReadSeekCloser() (ReadSeekCloser, error)
 }
 
-// readSeekerNopCloser implements ReadSeekCloser by doing nothing in Close.
-type readSeekerNopCloser struct {
+// ReadSeekerNoOpCloser implements ReadSeekCloser by doing nothing in Close.
+// TODO(bep) rename this and similar to ReadSeekerNopCloser, naming used in stdlib, which kind of makes sense.
+type ReadSeekerNoOpCloser struct {
 	ReadSeeker
 }
 
 // Close does nothing.
-func (r readSeekerNopCloser) Close() error {
+func (r ReadSeekerNoOpCloser) Close() error {
 	return nil
 }
 
 // NewReadSeekerNoOpCloser creates a new ReadSeekerNoOpCloser with the given ReadSeeker.
-func NewReadSeekerNoOpCloser(r ReadSeeker) ReadSeekCloser {
-	return readSeekerNopCloser{r}
+func NewReadSeekerNoOpCloser(r ReadSeeker) ReadSeekerNoOpCloser {
+	return ReadSeekerNoOpCloser{r}
 }
 
 // NewReadSeekerNoOpCloserFromString uses strings.NewReader to create a new ReadSeekerNoOpCloser
 // from the given string.
-func NewReadSeekerNoOpCloserFromString(content string) ReadSeekCloser {
-	return stringReadSeeker{s: content, readSeekerNopCloser: readSeekerNopCloser{strings.NewReader(content)}}
-}
-
-var _ StringReader = (*stringReadSeeker)(nil)
-
-type stringReadSeeker struct {
-	s string
-	readSeekerNopCloser
-}
-
-func (s *stringReadSeeker) ReadString() string {
-	return s.s
-}
-
-// StringReader provides a way to read a string.
-type StringReader interface {
-	ReadString() string
+func NewReadSeekerNoOpCloserFromString(content string) ReadSeekerNoOpCloser {
+	return ReadSeekerNoOpCloser{strings.NewReader(content)}
 }
 
 // NewReadSeekerNoOpCloserFromString uses strings.NewReader to create a new ReadSeekerNoOpCloser
 // from the given bytes slice.
-func NewReadSeekerNoOpCloserFromBytes(content []byte) readSeekerNopCloser {
-	return readSeekerNopCloser{bytes.NewReader(content)}
+func NewReadSeekerNoOpCloserFromBytes(content []byte) ReadSeekerNoOpCloser {
+	return ReadSeekerNoOpCloser{bytes.NewReader(content)}
 }
 
 // NewReadSeekCloser creates a new ReadSeekCloser from the given ReadSeeker.
@@ -92,15 +77,3 @@ func NewOpenReadSeekCloser(r ReadSeekCloser) OpenReadSeekCloser {
 // OpenReadSeekCloser allows setting some other way (than reading from a filesystem)
 // to open or create a ReadSeekCloser.
 type OpenReadSeekCloser func() (ReadSeekCloser, error)
-
-// ReadString reads from the given reader and returns the content as a string.
-func ReadString(r io.Reader) (string, error) {
-	if sr, ok := r.(StringReader); ok {
-		return sr.ReadString(), nil
-	}
-	b, err := io.ReadAll(r)
-	if err != nil {
-		return "", err
-	}
-	return string(b), nil
-}

common/hugio/writers.go

@@ -81,33 +81,3 @@ func ToReadCloser(r io.Reader) io.ReadCloser {
 		io.NopCloser(nil),
 	}
 }
-
-type ReadWriteCloser interface {
-	io.Reader
-	io.Writer
-	io.Closer
-}
-
-// PipeReadWriteCloser is a convenience type to create a pipe with a ReadCloser and a WriteCloser.
-type PipeReadWriteCloser struct {
-	*io.PipeReader
-	*io.PipeWriter
-}
-
-// NewPipeReadWriteCloser creates a new PipeReadWriteCloser.
-func NewPipeReadWriteCloser() PipeReadWriteCloser {
-	pr, pw := io.Pipe()
-	return PipeReadWriteCloser{pr, pw}
-}
-
-func (c PipeReadWriteCloser) Close() (err error) {
-	if err = c.PipeReader.Close(); err != nil {
-		return
-	}
-	err = c.PipeWriter.Close()
-	return
-}
-
-func (c PipeReadWriteCloser) WriteString(s string) (int, error) {
-	return c.PipeWriter.Write([]byte(s))
-}

common/hugo/hugo.go

@@ -14,7 +14,6 @@
 package hugo
 
 import (
-	"context"
 	"fmt"
 	"html/template"
 	"os"
@@ -30,7 +29,6 @@ import (
 	"github.com/mitchellh/mapstructure"
 
 	"github.com/bep/godartsass/v2"
-	"github.com/gohugoio/hugo/common/hcontext"
 	"github.com/gohugoio/hugo/common/hexec"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/hugofs/files"
@@ -71,9 +69,6 @@ type HugoInfo struct {
 
 	conf ConfigProvider
 	deps []*Dependency
-
-	// Context gives access to some of the context scoped variables.
-	Context Context
 }
 
 // Version returns the current version as a comparable version string.
@@ -116,49 +111,11 @@ func (i HugoInfo) Deps() []*Dependency {
 	return i.deps
 }
 
-// Deprecated: Use hugo.IsMultihost instead.
-func (i HugoInfo) IsMultiHost() bool {
-	Deprecate("hugo.IsMultiHost", "Use hugo.IsMultihost instead.", "v0.124.0")
-	return i.conf.IsMultihost()
-}
-
-// IsMultihost reports whether each configured language has a unique baseURL.
-func (i HugoInfo) IsMultihost() bool {
-	return i.conf.IsMultihost()
-}
-
-// IsMultilingual reports whether there are two or more configured languages.
-func (i HugoInfo) IsMultilingual() bool {
-	return i.conf.IsMultilingual()
-}
-
-type contextKey string
-
-var markupScope = hcontext.NewContextDispatcher[string](contextKey("markupScope"))
-
-type Context struct{}
-
-func (c Context) MarkupScope(ctx context.Context) string {
-	return GetMarkupScope(ctx)
-}
-
-// SetMarkupScope sets the markup scope in the context.
-func SetMarkupScope(ctx context.Context, s string) context.Context {
-	return markupScope.Set(ctx, s)
-}
-
-// GetMarkupScope gets the markup scope from the context.
-func GetMarkupScope(ctx context.Context) string {
-	return markupScope.Get(ctx)
-}
-
 // ConfigProvider represents the config options that are relevant for HugoInfo.
 type ConfigProvider interface {
 	Environment() string
 	Running() bool
 	WorkingDir() string
-	IsMultihost() bool
-	IsMultilingual() bool
 }
 
 // NewInfo creates a new Hugo Info object.
@@ -301,7 +258,7 @@ func GetDependencyListNonGo() []string {
 	if IsExtended {
 		deps = append(
 			deps,
-			formatDep("github.com/sass/libsass", "3.6.6"),
+			formatDep("github.com/sass/libsass", "3.6.5"),
 			formatDep("github.com/webmproject/libwebp", "v1.3.2"),
 		)
 	}

common/hugo/hugo_integration_test.go

@@ -1,77 +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 hugo_test
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/gohugoio/hugo/hugolib"
-)
-
-func TestIsMultilingualAndIsMultihost(t *testing.T) {
-	t.Parallel()
-
-	files := `
--- hugo.toml --
-disableKinds = ['page','rss','section','sitemap','taxonomy','term']
-defaultContentLanguageInSubdir = true
-[languages.de]
-baseURL = 'https://de.example.org/'
-[languages.en]
-baseURL = 'https://en.example.org/'
--- content/_index.md --
----
-title: home
----
--- layouts/index.html --
-multilingual={{ hugo.IsMultilingual }}
-multihost={{ hugo.IsMultihost }}
-  `
-
-	b := hugolib.Test(t, files)
-
-	b.AssertFileContent("public/de/index.html",
-		"multilingual=true",
-		"multihost=true",
-	)
-	b.AssertFileContent("public/en/index.html",
-		"multilingual=true",
-		"multihost=true",
-	)
-
-	files = strings.ReplaceAll(files, "baseURL = 'https://de.example.org/'", "")
-	files = strings.ReplaceAll(files, "baseURL = 'https://en.example.org/'", "")
-
-	b = hugolib.Test(t, files)
-
-	b.AssertFileContent("public/de/index.html",
-		"multilingual=true",
-		"multihost=false",
-	)
-	b.AssertFileContent("public/en/index.html",
-		"multilingual=true",
-		"multihost=false",
-	)
-
-	files = strings.ReplaceAll(files, "[languages.de]", "")
-	files = strings.ReplaceAll(files, "[languages.en]", "")
-
-	b = hugolib.Test(t, files)
-
-	b.AssertFileContent("public/en/index.html",
-		"multilingual=false",
-		"multihost=false",
-	)
-}

common/hugo/hugo_test.go

@@ -14,7 +14,6 @@
 package hugo
 
 import (
-	"context"
 	"fmt"
 	"testing"
 
@@ -65,25 +64,10 @@ func TestDeprecationLogLevelFromVersion(t *testing.T) {
 	c.Assert(deprecationLogLevelFromVersion(ver.String()), qt.Equals, logg.LevelError)
 }
 
-func TestMarkupScope(t *testing.T) {
-	c := qt.New(t)
-
-	conf := testConfig{environment: "production", workingDir: "/mywork", running: false}
-	info := NewInfo(conf, nil)
-
-	ctx := context.Background()
-
-	ctx = SetMarkupScope(ctx, "foo")
-
-	c.Assert(info.Context.MarkupScope(ctx), qt.Equals, "foo")
-}
-
 type testConfig struct {
-	environment  string
-	running      bool
-	workingDir   string
-	multihost    bool
-	multilingual bool
+	environment string
+	running     bool
+	workingDir  string
 }
 
 func (c testConfig) Environment() string {
@@ -97,11 +81,3 @@ func (c testConfig) Running() bool {
 func (c testConfig) WorkingDir() string {
 	return c.workingDir
 }
-
-func (c testConfig) IsMultihost() bool {
-	return c.multihost
-}
-
-func (c testConfig) IsMultilingual() bool {
-	return c.multilingual
-}

common/hugo/version_current.go

@@ -17,7 +17,7 @@ package hugo
 // This should be the only one.
 var CurrentVersion = Version{
 	Major:      0,
-	Minor:      137,
+	Minor:      123,
 	PatchLevel: 0,
 	Suffix:     "-DEV",
 }

common/loggers/handlersmisc.go

@@ -21,7 +21,7 @@ import (
 	"sync"
 
 	"github.com/bep/logg"
-	"github.com/gohugoio/hugo/common/hashing"
+	"github.com/gohugoio/hugo/identity"
 )
 
 // PanicOnWarningHook panics on warnings.
@@ -85,7 +85,7 @@ func (h *logOnceHandler) HandleLog(e *logg.Entry) error {
 	}
 	h.mu.Lock()
 	defer h.mu.Unlock()
-	hash := hashing.HashUint64(e.Level, e.Message, e.Fields)
+	hash := identity.HashUint64(e.Level, e.Message, e.Fields)
 	if h.seen[hash] {
 		return errStop
 	}

common/loggers/logger.go

@@ -110,7 +110,7 @@ func New(opts Options) Logger {
 		logHandler = newStopHandler(logOnce, logHandler)
 	}
 
-	if len(opts.SuppressStatements) > 0 {
+	if opts.SuppressStatements != nil && len(opts.SuppressStatements) > 0 {
 		logHandler = newStopHandler(newSuppressStatementsHandler(opts.SuppressStatements), logHandler)
 	}
 
@@ -323,13 +323,11 @@ func (l *logAdapter) Errors() string {
 }
 
 func (l *logAdapter) Erroridf(id, format string, v ...any) {
-	id = strings.ToLower(id)
 	format += l.idfInfoStatement("error", id, format)
 	l.errorl.WithField(FieldNameStatementID, id).Logf(format, v...)
 }
 
 func (l *logAdapter) Warnidf(id, format string, v ...any) {
-	id = strings.ToLower(id)
 	format += l.idfInfoStatement("warning", id, format)
 	l.warnl.WithField(FieldNameStatementID, id).Logf(format, v...)
 }

common/maps/cache.go

@@ -27,12 +27,7 @@ func NewCache[K comparable, T any]() *Cache[K, T] {
 }
 
 // Delete deletes the given key from the cache.
-// If c is nil, this method is a no-op.
 func (c *Cache[K, T]) Get(key K) (T, bool) {
-	if c == nil {
-		var zero T
-		return zero, false
-	}
 	c.RLock()
 	v, found := c.m[key]
 	c.RUnlock()
@@ -40,25 +35,22 @@ func (c *Cache[K, T]) Get(key K) (T, bool) {
 }
 
 // GetOrCreate gets the value for the given key if it exists, or creates it if not.
-func (c *Cache[K, T]) GetOrCreate(key K, create func() (T, error)) (T, error) {
+func (c *Cache[K, T]) GetOrCreate(key K, create func() T) T {
 	c.RLock()
 	v, found := c.m[key]
 	c.RUnlock()
 	if found {
-		return v, nil
+		return v
 	}
 	c.Lock()
 	defer c.Unlock()
 	v, found = c.m[key]
 	if found {
-		return v, nil
-	}
-	v, err := create()
-	if err != nil {
-		return v, err
+		return v
 	}
+	v = create()
 	c.m[key] = v
-	return v, nil
+	return v
 }
 
 // Set sets the given key to the given value.
@@ -68,35 +60,6 @@ func (c *Cache[K, T]) Set(key K, value T) {
 	c.Unlock()
 }
 
-// ForEeach calls the given function for each key/value pair in the cache.
-func (c *Cache[K, T]) ForEeach(f func(K, T)) {
-	c.RLock()
-	defer c.RUnlock()
-	for k, v := range c.m {
-		f(k, v)
-	}
-}
-
-func (c *Cache[K, T]) Drain() map[K]T {
-	c.Lock()
-	m := c.m
-	c.m = make(map[K]T)
-	c.Unlock()
-	return m
-}
-
-func (c *Cache[K, T]) Len() int {
-	c.RLock()
-	defer c.RUnlock()
-	return len(c.m)
-}
-
-func (c *Cache[K, T]) Reset() {
-	c.Lock()
-	c.m = make(map[K]T)
-	c.Unlock()
-}
-
 // SliceCache is a simple thread safe cache backed by a map.
 type SliceCache[T any] struct {
 	m map[string][]T

common/maps/maps.go

@@ -112,17 +112,17 @@ func ToSliceStringMap(in any) ([]map[string]any, error) {
 }
 
 // LookupEqualFold finds key in m with case insensitive equality checks.
-func LookupEqualFold[T any | string](m map[string]T, key string) (T, string, bool) {
+func LookupEqualFold[T any | string](m map[string]T, key string) (T, bool) {
 	if v, found := m[key]; found {
-		return v, key, true
+		return v, true
 	}
 	for k, v := range m {
 		if strings.EqualFold(k, key) {
-			return v, k, true
+			return v, true
 		}
 	}
 	var s T
-	return s, "", false
+	return s, false
 }
 
 // MergeShallow merges src into dst, but only if the key does not already exist in dst.

common/maps/maps_test.go

@@ -180,18 +180,16 @@ func TestLookupEqualFold(t *testing.T) {
 		"B": "bv",
 	}
 
-	v, k, found := LookupEqualFold(m1, "b")
+	v, found := LookupEqualFold(m1, "b")
 	c.Assert(found, qt.IsTrue)
 	c.Assert(v, qt.Equals, "bv")
-	c.Assert(k, qt.Equals, "B")
 
 	m2 := map[string]string{
 		"a": "av",
 		"B": "bv",
 	}
 
-	v, k, found = LookupEqualFold(m2, "b")
+	v, found = LookupEqualFold(m2, "b")
 	c.Assert(found, qt.IsTrue)
-	c.Assert(k, qt.Equals, "B")
 	c.Assert(v, qt.Equals, "bv")
 }

common/paths/path.go

@@ -237,17 +237,12 @@ func prettifyPath(in string, b filepathPathBridge) string {
 	return b.Join(b.Dir(in), name, "index"+ext)
 }
 
-// CommonDirPath returns the common directory of the given paths.
-func CommonDirPath(path1, path2 string) string {
+// CommonDir returns the common directory of the given paths.
+func CommonDir(path1, path2 string) string {
 	if path1 == "" || path2 == "" {
 		return ""
 	}
 
-	hadLeadingSlash := strings.HasPrefix(path1, "/") || strings.HasPrefix(path2, "/")
-
-	path1 = TrimLeading(path1)
-	path2 = TrimLeading(path2)
-
 	p1 := strings.Split(path1, "/")
 	p2 := strings.Split(path2, "/")
 
@@ -261,13 +256,7 @@ func CommonDirPath(path1, path2 string) string {
 		}
 	}
 
-	s := strings.Join(common, "/")
-
-	if hadLeadingSlash && s != "" {
-		s = "/" + s
-	}
-
-	return s
+	return strings.Join(common, "/")
 }
 
 // Sanitize sanitizes string to be used in Hugo's file paths and URLs, allowing only
@@ -395,27 +384,12 @@ func PathEscape(pth string) string {
 
 // ToSlashTrimLeading is just a filepath.ToSlash with an added / prefix trimmer.
 func ToSlashTrimLeading(s string) string {
-	return TrimLeading(filepath.ToSlash(s))
-}
-
-// TrimLeading trims the leading slash from the given string.
-func TrimLeading(s string) string {
-	return strings.TrimPrefix(s, "/")
+	return strings.TrimPrefix(filepath.ToSlash(s), "/")
 }
 
 // ToSlashTrimTrailing is just a filepath.ToSlash with an added / suffix trimmer.
 func ToSlashTrimTrailing(s string) string {
-	return TrimTrailing(filepath.ToSlash(s))
-}
-
-// TrimTrailing trims the trailing slash from the given string.
-func TrimTrailing(s string) string {
-	return strings.TrimSuffix(s, "/")
-}
-
-// ToSlashTrim trims any leading and trailing slashes from the given string and converts it to a forward slash separated path.
-func ToSlashTrim(s string) string {
-	return strings.Trim(filepath.ToSlash(s), "/")
+	return strings.TrimSuffix(filepath.ToSlash(s), "/")
 }
 
 // ToSlashPreserveLeading converts the path given to a forward slash separated path
@@ -423,8 +397,3 @@ func ToSlashTrim(s string) string {
 func ToSlashPreserveLeading(s string) string {
 	return "/" + strings.Trim(filepath.ToSlash(s), "/")
 }
-
-// IsSameFilePath checks if s1 and s2 are the same file path.
-func IsSameFilePath(s1, s2 string) bool {
-	return path.Clean(ToSlashTrim(s1)) == path.Clean(ToSlashTrim(s2))
-}

common/paths/path_test.go

@@ -262,52 +262,3 @@ func TestFieldsSlash(t *testing.T) {
 	c.Assert(FieldsSlash("/"), qt.DeepEquals, []string{})
 	c.Assert(FieldsSlash(""), qt.DeepEquals, []string{})
 }
-
-func TestCommonDirPath(t *testing.T) {
-	c := qt.New(t)
-
-	for _, this := range []struct {
-		a, b, expected string
-	}{
-		{"/a/b/c", "/a/b/d", "/a/b"},
-		{"/a/b/c", "a/b/d", "/a/b"},
-		{"a/b/c", "/a/b/d", "/a/b"},
-		{"a/b/c", "a/b/d", "a/b"},
-		{"/a/b/c", "/a/b/c", "/a/b/c"},
-		{"/a/b/c", "/a/b/c/d", "/a/b/c"},
-		{"/a/b/c", "/a/b", "/a/b"},
-		{"/a/b/c", "/a", "/a"},
-		{"/a/b/c", "/d/e/f", ""},
-	} {
-		c.Assert(CommonDirPath(this.a, this.b), qt.Equals, this.expected, qt.Commentf("a: %s b: %s", this.a, this.b))
-	}
-}
-
-func TestIsSameFilePath(t *testing.T) {
-	c := qt.New(t)
-
-	for _, this := range []struct {
-		a, b     string
-		expected bool
-	}{
-		{"/a/b/c", "/a/b/c", true},
-		{"/a/b/c", "/a/b/c/", true},
-		{"/a/b/c", "/a/b/d", false},
-		{"/a/b/c", "/a/b", false},
-		{"/a/b/c", "/a/b/c/d", false},
-		{"/a/b/c", "/a/b/cd", false},
-		{"/a/b/c", "/a/b/cc", false},
-		{"/a/b/c", "/a/b/c/", true},
-		{"/a/b/c", "/a/b/c//", true},
-		{"/a/b/c", "/a/b/c/.", true},
-		{"/a/b/c", "/a/b/c/./", true},
-		{"/a/b/c", "/a/b/c/./.", true},
-		{"/a/b/c", "/a/b/c/././", true},
-		{"/a/b/c", "/a/b/c/././.", true},
-		{"/a/b/c", "/a/b/c/./././", true},
-		{"/a/b/c", "/a/b/c/./././.", true},
-		{"/a/b/c", "/a/b/c/././././", true},
-	} {
-		c.Assert(IsSameFilePath(filepath.FromSlash(this.a), filepath.FromSlash(this.b)), qt.Equals, this.expected, qt.Commentf("a: %s b: %s", this.a, this.b))
-	}
-}

common/paths/pathparser.go

@@ -18,23 +18,22 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
-	"sync"
 
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/hugofs/files"
-	"github.com/gohugoio/hugo/identity"
 )
 
+var defaultPathParser PathParser
+
 // PathParser parses a path into a Path.
 type PathParser struct {
 	// Maps the language code to its index in the languages/sites slice.
 	LanguageIndex map[string]int
+}
 
-	// Reports whether the given language is disabled.
-	IsLangDisabled func(string) bool
-
-	// Reports whether the given ext is a content file.
-	IsContentExt func(string) bool
+// Parse parses component c with path s into Path using the default path parser.
+func Parse(c, s string) *Path {
+	return defaultPathParser.Parse(c, s)
 }
 
 // NormalizePathString returns a normalized path string using the very basic Hugo rules.
@@ -48,54 +47,19 @@ func NormalizePathStringBasic(s string) string {
 	return s
 }
 
-// ParseIdentity parses component c with path s into a StringIdentity.
-func (pp *PathParser) ParseIdentity(c, s string) identity.StringIdentity {
-	p := pp.parsePooled(c, s)
-	defer putPath(p)
-	return identity.StringIdentity(p.IdentifierBase())
-}
-
-// ParseBaseAndBaseNameNoIdentifier parses component c with path s into a base and a base name without any identifier.
-func (pp *PathParser) ParseBaseAndBaseNameNoIdentifier(c, s string) (string, string) {
-	p := pp.parsePooled(c, s)
-	defer putPath(p)
-	return p.Base(), p.BaseNameNoIdentifier()
-}
-
-func (pp *PathParser) parsePooled(c, s string) *Path {
-	s = NormalizePathStringBasic(s)
-	p := getPath()
-	p.component = c
-	p, err := pp.doParse(c, s, p)
-	if err != nil {
-		panic(err)
-	}
-	return p
-}
-
 // Parse parses component c with path s into Path using Hugo's content path rules.
-func (pp *PathParser) Parse(c, s string) *Path {
-	p, err := pp.parse(c, s)
+func (parser PathParser) Parse(c, s string) *Path {
+	p, err := parser.parse(c, s)
 	if err != nil {
 		panic(err)
 	}
 	return p
 }
 
-func (pp *PathParser) newPath(component string) *Path {
-	return &Path{
-		component:             component,
-		posContainerLow:       -1,
-		posContainerHigh:      -1,
-		posSectionHigh:        -1,
-		posIdentifierLanguage: -1,
-	}
-}
-
 func (pp *PathParser) parse(component, s string) (*Path, error) {
 	ss := NormalizePathStringBasic(s)
 
-	p, err := pp.doParse(component, ss, pp.newPath(component))
+	p, err := pp.doParse(component, ss)
 	if err != nil {
 		return nil, err
 	}
@@ -103,7 +67,8 @@ func (pp *PathParser) parse(component, s string) (*Path, error) {
 	if s != ss {
 		var err error
 		// Preserve the original case for titles etc.
-		p.unnormalized, err = pp.doParse(component, s, pp.newPath(component))
+		p.unnormalized, err = pp.doParse(component, s)
+
 		if err != nil {
 			return nil, err
 		}
@@ -114,7 +79,15 @@ func (pp *PathParser) parse(component, s string) (*Path, error) {
 	return p, nil
 }
 
-func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
+func (pp *PathParser) doParse(component, s string) (*Path, error) {
+	p := &Path{
+		component:             component,
+		posContainerLow:       -1,
+		posContainerHigh:      -1,
+		posSectionHigh:        -1,
+		posIdentifierLanguage: -1,
+	}
+
 	hasLang := pp.LanguageIndex != nil
 	hasLang = hasLang && (component == files.ComponentFolderContent || component == files.ComponentFolderLayouts)
 
@@ -153,7 +126,7 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 				} else {
 					high = len(p.s)
 				}
-				id := types.LowHigh[string]{Low: i + 1, High: high}
+				id := types.LowHigh{Low: i + 1, High: high}
 				if len(p.identifiers) == 0 {
 					p.identifiers = append(p.identifiers, id)
 				} else if len(p.identifiers) == 1 {
@@ -161,16 +134,7 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 					s := p.s[id.Low:id.High]
 
 					if hasLang {
-						var disabled bool
-						_, langFound := pp.LanguageIndex[s]
-						if !langFound {
-							disabled = pp.IsLangDisabled != nil && pp.IsLangDisabled(s)
-							if disabled {
-								p.disabled = true
-								langFound = true
-							}
-						}
-						if langFound {
+						if _, found := pp.LanguageIndex[s]; found {
 							p.posIdentifierLanguage = 1
 							p.identifiers = append(p.identifiers, id)
 						}
@@ -190,26 +154,23 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 		}
 	}
 
-	if len(p.identifiers) > 0 {
-		isContentComponent := p.component == files.ComponentFolderContent || p.component == files.ComponentFolderArchetypes
-		isContent := isContentComponent && pp.IsContentExt(p.Ext())
+	isContentComponent := p.component == files.ComponentFolderContent || p.component == files.ComponentFolderArchetypes
+	isContent := isContentComponent && files.IsContentExt(p.Ext())
+
+	if isContent {
 		id := p.identifiers[len(p.identifiers)-1]
 		b := p.s[p.posContainerHigh : id.Low-1]
-		if isContent {
-			switch b {
-			case "index":
-				p.bundleType = PathTypeLeaf
-			case "_index":
-				p.bundleType = PathTypeBranch
-			default:
-				p.bundleType = PathTypeContentSingle
-			}
+		switch b {
+		case "index":
+			p.bundleType = PathTypeLeaf
+		case "_index":
+			p.bundleType = PathTypeBranch
+		default:
+			p.bundleType = PathTypeContentSingle
+		}
 
-			if slashCount == 2 && p.IsLeafBundle() {
-				p.posSectionHigh = 0
-			}
-		} else if b == files.NameContentData && files.IsContentDataExt(p.Ext()) {
-			p.bundleType = PathTypeContentData
+		if slashCount == 2 && p.IsLeafBundle() {
+			p.posSectionHigh = 0
 		}
 	}
 
@@ -237,20 +198,16 @@ const (
 	// E.g. /blog/my-post.md
 	PathTypeContentSingle
 
-	// All below are bundled content files.
+	// All bewlow are bundled content files.
 
 	// Leaf bundles, e.g. /blog/my-post/index.md
 	PathTypeLeaf
 
 	// Branch bundles, e.g. /blog/_index.md
 	PathTypeBranch
-
-	// Content data file, _content.gotmpl.
-	PathTypeContentData
 )
 
 type Path struct {
-	// Note: Any additions to this struct should also be added to the pathPool.
 	s string
 
 	posContainerLow  int
@@ -260,47 +217,15 @@ type Path struct {
 	component  string
 	bundleType PathType
 
-	identifiers []types.LowHigh[string]
+	identifiers []types.LowHigh
 
 	posIdentifierLanguage int
-	disabled              bool
 
 	trimLeadingSlash bool
 
 	unnormalized *Path
 }
 
-var pathPool = &sync.Pool{
-	New: func() any {
-		p := &Path{}
-		p.reset()
-		return p
-	},
-}
-
-func getPath() *Path {
-	return pathPool.Get().(*Path)
-}
-
-func putPath(p *Path) {
-	p.reset()
-	pathPool.Put(p)
-}
-
-func (p *Path) reset() {
-	p.s = ""
-	p.posContainerLow = -1
-	p.posContainerHigh = -1
-	p.posSectionHigh = -1
-	p.component = ""
-	p.bundleType = 0
-	p.identifiers = p.identifiers[:0]
-	p.posIdentifierLanguage = -1
-	p.disabled = false
-	p.trimLeadingSlash = false
-	p.unnormalized = nil
-}
-
 // TrimLeadingSlash returns a copy of the Path with the leading slash removed.
 func (p Path) TrimLeadingSlash() *Path {
 	p.trimLeadingSlash = true
@@ -314,9 +239,9 @@ func (p *Path) norm(s string) string {
 	return s
 }
 
-// IdentifierBase satisfies identity.Identity.
+// IdentifierBase satifies identity.Identity.
 func (p *Path) IdentifierBase() string {
-	return p.Base()
+	return p.Base()[1:]
 }
 
 // Component returns the component for this path (e.g. "content").
@@ -369,7 +294,7 @@ func (p *Path) Name() string {
 	return p.s
 }
 
-// Name returns the last element of path without any extension.
+// Name returns the last element of path withhout any extension.
 func (p *Path) NameNoExt() string {
 	if i := p.identifierIndex(0); i != -1 {
 		return p.s[p.posContainerHigh : p.identifiers[i].Low-1]
@@ -377,7 +302,7 @@ func (p *Path) NameNoExt() string {
 	return p.s[p.posContainerHigh:]
 }
 
-// Name returns the last element of path without any language identifier.
+// Name returns the last element of path withhout any language identifier.
 func (p *Path) NameNoLang() string {
 	i := p.identifierIndex(p.posIdentifierLanguage)
 	if i == -1 {
@@ -387,7 +312,7 @@ func (p *Path) NameNoLang() string {
 	return p.s[p.posContainerHigh:p.identifiers[i].Low-1] + p.s[p.identifiers[i].High:]
 }
 
-// BaseNameNoIdentifier returns the logical base name for a resource without any identifier (e.g. no extension).
+// BaseNameNoIdentifier returns the logcical base name for a resource without any idenifier (e.g. no extension).
 // For bundles this will be the containing directory's name, e.g. "blog".
 func (p *Path) BaseNameNoIdentifier() string {
 	if p.IsBundle() {
@@ -396,7 +321,7 @@ func (p *Path) BaseNameNoIdentifier() string {
 	return p.NameNoIdentifier()
 }
 
-// NameNoIdentifier returns the last element of path without any identifier (e.g. no extension).
+// NameNoIdentifier returns the last element of path withhout any identifier (e.g. no extension).
 func (p *Path) NameNoIdentifier() string {
 	if len(p.identifiers) > 0 {
 		return p.s[p.posContainerHigh : p.identifiers[len(p.identifiers)-1].Low-1]
@@ -421,8 +346,8 @@ func (p *Path) Path() (d string) {
 	return p.norm(p.s)
 }
 
-// Unnormalized returns the Path with the original case preserved.
-func (p *Path) Unnormalized() *Path {
+// Unmormalized returns the Path with the original case preserved.
+func (p *Path) Unmormalized() *Path {
 	return p.unnormalized
 }
 
@@ -436,7 +361,7 @@ func (p *Path) PathNoIdentifier() string {
 	return p.base(false, false)
 }
 
-// PathRel returns the path relative to the given owner.
+// PathRel returns the path relativeto the given owner.
 func (p *Path) PathRel(owner *Path) string {
 	ob := owner.Base()
 	if !strings.HasSuffix(ob, "/") {
@@ -510,10 +435,6 @@ func (p *Path) Identifier(i int) string {
 	return p.identifierAsString(i)
 }
 
-func (p *Path) Disabled() bool {
-	return p.disabled
-}
-
 func (p *Path) Identifiers() []string {
 	ids := make([]string, len(p.identifiers))
 	for i, id := range p.identifiers {
@@ -522,6 +443,10 @@ func (p *Path) Identifiers() []string {
 	return ids
 }
 
+func (p *Path) IsHTML() bool {
+	return files.IsHTML(p.Ext())
+}
+
 func (p *Path) BundleType() PathType {
 	return p.bundleType
 }
@@ -538,15 +463,6 @@ func (p *Path) IsLeafBundle() bool {
 	return p.bundleType == PathTypeLeaf
 }
 
-func (p *Path) IsContentData() bool {
-	return p.bundleType == PathTypeContentData
-}
-
-func (p Path) ForBundleType(t PathType) *Path {
-	p.bundleType = t
-	return &p
-}
-
 func (p *Path) identifierAsString(i int) string {
 	i = p.identifierIndex(i)
 	if i == -1 {

common/paths/pathparser_test.go

@@ -27,9 +27,6 @@ var testParser = &PathParser{
 		"no": 0,
 		"en": 1,
 	},
-	IsContentExt: func(ext string) bool {
-		return ext == "md"
-	},
 }
 
 func TestParse(t *testing.T) {
@@ -96,7 +93,7 @@ func TestParse(t *testing.T) {
 			"Basic text file, mixed case and spaces, unnormalized",
 			"/a/Foo BAR.txt",
 			func(c *qt.C, p *Path) {
-				pp := p.Unnormalized()
+				pp := p.Unmormalized()
 				c.Assert(pp, qt.IsNotNil)
 				c.Assert(pp.BaseNameNoIdentifier(), qt.Equals, "Foo BAR")
 			},
@@ -336,22 +333,6 @@ func TestParse(t *testing.T) {
 				c.Assert(p.Path(), qt.Equals, "/a/b/c.txt")
 			},
 		},
-		{
-			"Content data file gotmpl",
-			"/a/b/_content.gotmpl",
-			func(c *qt.C, p *Path) {
-				c.Assert(p.Path(), qt.Equals, "/a/b/_content.gotmpl")
-				c.Assert(p.Ext(), qt.Equals, "gotmpl")
-				c.Assert(p.IsContentData(), qt.IsTrue)
-			},
-		},
-		{
-			"Content data file yaml",
-			"/a/b/_content.yaml",
-			func(c *qt.C, p *Path) {
-				c.Assert(p.IsContentData(), qt.IsFalse)
-			},
-		},
 	}
 	for _, test := range tests {
 		c.Run(test.name, func(c *qt.C) {
@@ -368,9 +349,3 @@ func TestHasExt(t *testing.T) {
 	c.Assert(HasExt("/a/b/c"), qt.IsFalse)
 	c.Assert(HasExt("/a/b.c/d"), qt.IsFalse)
 }
-
-func BenchmarkParseIdentity(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		testParser.ParseIdentity(files.ComponentFolderAssets, "/a/b.css")
-	}
-}

common/predicate/predicate.go

@@ -24,9 +24,6 @@ func (p P[T]) And(ps ...P[T]) P[T] {
 				return false
 			}
 		}
-		if p == nil {
-			return true
-		}
 		return p(v)
 	}
 }
@@ -39,9 +36,6 @@ func (p P[T]) Or(ps ...P[T]) P[T] {
 				return true
 			}
 		}
-		if p == nil {
-			return false
-		}
 		return p(v)
 	}
 }

common/tasks/tasks.go

@@ -1,153 +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 tasks
-
-import (
-	"sync"
-	"time"
-)
-
-// RunEvery runs a function at intervals defined by the function itself.
-// Functions can be added and removed while running.
-type RunEvery struct {
-	// Any error returned from the function will be passed to this function.
-	HandleError func(string, error)
-
-	// If set, the function will be run immediately.
-	RunImmediately bool
-
-	// The named functions to run.
-	funcs map[string]*Func
-
-	mu      sync.Mutex
-	started bool
-	closed  bool
-	quit    chan struct{}
-}
-
-type Func struct {
-	// The shortest interval between each run.
-	IntervalLow time.Duration
-
-	// The longest interval between each run.
-	IntervalHigh time.Duration
-
-	// The function to run.
-	F func(interval time.Duration) (time.Duration, error)
-
-	interval time.Duration
-	last     time.Time
-}
-
-func (r *RunEvery) Start() error {
-	if r.started {
-		return nil
-	}
-
-	r.started = true
-	r.quit = make(chan struct{})
-
-	go func() {
-		if r.RunImmediately {
-			r.run()
-		}
-		ticker := time.NewTicker(500 * time.Millisecond)
-		defer ticker.Stop()
-		for {
-			select {
-			case <-r.quit:
-				return
-			case <-ticker.C:
-				r.run()
-			}
-		}
-	}()
-
-	return nil
-}
-
-// Close stops the RunEvery from running.
-func (r *RunEvery) Close() error {
-	if r.closed {
-		return nil
-	}
-	r.closed = true
-	if r.quit != nil {
-		close(r.quit)
-	}
-	return nil
-}
-
-// Add adds a function to the RunEvery.
-func (r *RunEvery) Add(name string, f Func) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	if r.funcs == nil {
-		r.funcs = make(map[string]*Func)
-	}
-	if f.IntervalLow == 0 {
-		f.IntervalLow = 500 * time.Millisecond
-	}
-	if f.IntervalHigh <= f.IntervalLow {
-		f.IntervalHigh = 20 * time.Second
-	}
-
-	start := f.IntervalHigh / 3
-	if start < f.IntervalLow {
-		start = f.IntervalLow
-	}
-	f.interval = start
-	f.last = time.Now()
-
-	r.funcs[name] = &f
-}
-
-// Remove removes a function from the RunEvery.
-func (r *RunEvery) Remove(name string) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	delete(r.funcs, name)
-}
-
-// Has returns whether the RunEvery has a function with the given name.
-func (r *RunEvery) Has(name string) bool {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	_, found := r.funcs[name]
-	return found
-}
-
-func (r *RunEvery) run() {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	for name, f := range r.funcs {
-		if time.Now().Before(f.last.Add(f.interval)) {
-			continue
-		}
-		f.last = time.Now()
-		interval, err := f.F(f.interval)
-		if err != nil && r.HandleError != nil {
-			r.HandleError(name, err)
-		}
-
-		if interval < f.IntervalLow {
-			interval = f.IntervalLow
-		}
-
-		if interval > f.IntervalHigh {
-			interval = f.IntervalHigh
-		}
-		f.interval = interval
-	}
-}

common/types/closer.go

@@ -1,47 +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 types
-
-import "sync"
-
-type Closer interface {
-	Close() error
-}
-
-type CloseAdder interface {
-	Add(Closer)
-}
-
-type Closers struct {
-	mu sync.Mutex
-	cs []Closer
-}
-
-func (cs *Closers) Add(c Closer) {
-	cs.mu.Lock()
-	defer cs.mu.Unlock()
-	cs.cs = append(cs.cs, c)
-}
-
-func (cs *Closers) Close() error {
-	cs.mu.Lock()
-	defer cs.mu.Unlock()
-	for _, c := range cs.cs {
-		c.Close()
-	}
-
-	cs.cs = cs.cs[:0]
-
-	return nil
-}

common/types/hstring/stringtypes.go

@@ -13,24 +13,8 @@
 
 package hstring
 
-import (
-	"html/template"
+type RenderedString string
 
-	"github.com/gohugoio/hugo/common/types"
-)
-
-var _ types.PrintableValueProvider = HTML("")
-
-// HTML is a string that represents rendered HTML.
-// When printed in templates it will be rendered as template.HTML and considered safe so no need to pipe it into `safeHTML`.
-// This type was introduced as a wasy to prevent a common case of inifinite recursion in the template rendering
-// when the `linkify` option is enabled with a common (wrong) construct like `{{ .Text | .Page.RenderString }}` in a hook template.
-type HTML string
-
-func (s HTML) String() string {
+func (s RenderedString) String() string {
 	return string(s)
 }
-
-func (s HTML) PrintableValue() any {
-	return template.HTML(s)
-}

common/types/hstring/stringtypes_test.go

@@ -25,6 +25,6 @@ func TestRenderedString(t *testing.T) {
 	c := qt.New(t)
 
 	// Validate that it will behave like a string in Hugo settings.
-	c.Assert(cast.ToString(HTML("Hugo")), qt.Equals, "Hugo")
-	c.Assert(template.HTML(HTML("Hugo")), qt.Equals, template.HTML("Hugo"))
+	c.Assert(cast.ToString(RenderedString("Hugo")), qt.Equals, "Hugo")
+	c.Assert(template.HTML(RenderedString("Hugo")), qt.Equals, template.HTML("Hugo"))
 }

common/types/types.go

@@ -99,28 +99,12 @@ type Unwrapper interface {
 	Unwrapv() any
 }
 
-// Unwrap returns the underlying value of v if it implements Unwrapper, otherwise v is returned.
-func Unwrapv(v any) any {
-	if u, ok := v.(Unwrapper); ok {
-		return u.Unwrapv()
-	}
-	return v
-}
-
-// LowHigh represents a byte or slice boundary.
-type LowHigh[S ~[]byte | string] struct {
+// LowHigh is typically used to represent a slice boundary.
+type LowHigh struct {
 	Low  int
 	High int
 }
 
-func (l LowHigh[S]) IsZero() bool {
-	return l.Low < 0 || (l.Low == 0 && l.High == 0)
-}
-
-func (l LowHigh[S]) Value(source S) S {
-	return source[l.Low:l.High]
-}
-
 // This is only used for debugging purposes.
 var InvocationCounter atomic.Int64
 
@@ -128,27 +112,3 @@ var InvocationCounter atomic.Int64
 func NewBool(b bool) *bool {
 	return &b
 }
-
-// PrintableValueProvider is implemented by types that can provide a printable value.
-type PrintableValueProvider interface {
-	PrintableValue() any
-}
-
-var _ PrintableValueProvider = Result[any]{}
-
-// Result is a generic result type.
-type Result[T any] struct {
-	// The result value.
-	Value T
-
-	// The error value.
-	Err error
-}
-
-// PrintableValue returns the value or panics if there is an error.
-func (r Result[T]) PrintableValue() any {
-	if r.Err != nil {
-		panic(r.Err)
-	}
-	return r.Value
-}

common/types/types_test.go

@@ -27,25 +27,3 @@ func TestKeyValues(t *testing.T) {
 	c.Assert(kv.KeyString(), qt.Equals, "key")
 	c.Assert(kv.Values, qt.DeepEquals, []any{"a1", "a2"})
 }
-
-func TestLowHigh(t *testing.T) {
-	c := qt.New(t)
-
-	lh := LowHigh[string]{
-		Low:  2,
-		High: 10,
-	}
-
-	s := "abcdefghijklmnopqrstuvwxyz"
-	c.Assert(lh.IsZero(), qt.IsFalse)
-	c.Assert(lh.Value(s), qt.Equals, "cdefghij")
-
-	lhb := LowHigh[[]byte]{
-		Low:  2,
-		High: 10,
-	}
-
-	sb := []byte(s)
-	c.Assert(lhb.IsZero(), qt.IsFalse)
-	c.Assert(lhb.Value(sb), qt.DeepEquals, []byte("cdefghij"))
-}

config/allconfig/allconfig.go

@@ -27,7 +27,6 @@ import (
 	"time"
 
 	"github.com/gohugoio/hugo/cache/filecache"
-	"github.com/gohugoio/hugo/cache/httpcache"
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/maps"
@@ -38,9 +37,8 @@ import (
 	"github.com/gohugoio/hugo/config/privacy"
 	"github.com/gohugoio/hugo/config/security"
 	"github.com/gohugoio/hugo/config/services"
-	"github.com/gohugoio/hugo/deploy/deployconfig"
+	"github.com/gohugoio/hugo/deploy"
 	"github.com/gohugoio/hugo/helpers"
-	"github.com/gohugoio/hugo/hugolib/segments"
 	"github.com/gohugoio/hugo/langs"
 	"github.com/gohugoio/hugo/markup/markup_config"
 	"github.com/gohugoio/hugo/media"
@@ -67,7 +65,6 @@ type InternalConfig struct {
 	Verbose        bool
 	Clock          string
 	Watch          bool
-	FastRenderMode bool
 	LiveReloadPort int
 }
 
@@ -105,11 +102,9 @@ type Config struct {
 	RootConfig
 
 	// Author information.
-	// Deprecated: Use taxonomies instead.
 	Author map[string]any
 
 	// Social links.
-	// Deprecated: Use .Site.Params instead.
 	Social map[string]string
 
 	// The build configuration section contains build-related configuration options.
@@ -120,10 +115,6 @@ type Config struct {
 	// <docsmeta>{"identifiers": ["caches"] }</docsmeta>
 	Caches filecache.Configs `mapstructure:"-"`
 
-	// The httpcache configuration section contains HTTP-cache-related configuration options.
-	// <docsmeta>{"identifiers": ["httpcache"] }</docsmeta>
-	HTTPCache httpcache.Config `mapstructure:"-"`
-
 	// The markup configuration section contains markup-related configuration options.
 	// <docsmeta>{"identifiers": ["markup"] }</docsmeta>
 	Markup markup_config.Config `mapstructure:"-"`
@@ -145,15 +136,12 @@ type Config struct {
 	// a slice of page matcher and params to apply to those pages.
 	Cascade *config.ConfigNamespace[[]page.PageMatcherParamsConfig, map[page.PageMatcher]maps.Params] `mapstructure:"-"`
 
-	// The segments defines segments for the site. Used for partial/segmented builds.
-	Segments *config.ConfigNamespace[map[string]segments.SegmentConfig, segments.Segments] `mapstructure:"-"`
-
 	// Menu configuration.
 	// <docsmeta>{"refs": ["config:languages:menus"] }</docsmeta>
 	Menus *config.ConfigNamespace[map[string]navigation.MenuConfig, navigation.Menus] `mapstructure:"-"`
 
-	// The deployment configuration section contains for hugo deployconfig.
-	Deployment deployconfig.DeployConfig `mapstructure:"-"`
+	// The deployment configuration section contains for hugo deploy.
+	Deployment deploy.DeployConfig `mapstructure:"-"`
 
 	// Module configuration.
 	Module modules.Config `mapstructure:"-"`
@@ -179,12 +167,6 @@ type Config struct {
 	// Server configuration.
 	Server config.Server `mapstructure:"-"`
 
-	// Pagination configuration.
-	Pagination config.Pagination `mapstructure:"-"`
-
-	// Page configuration.
-	Page config.PageConfig `mapstructure:"-"`
-
 	// Privacy configuration.
 	Privacy privacy.Config `mapstructure:"-"`
 
@@ -318,13 +300,9 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		}
 	}
 
-	for i, s := range c.IgnoreLogs {
-		c.IgnoreLogs[i] = strings.ToLower(s)
-	}
-
 	ignoredLogIDs := make(map[string]bool)
 	for _, err := range c.IgnoreLogs {
-		ignoredLogIDs[err] = true
+		ignoredLogIDs[strings.ToLower(err)] = true
 	}
 
 	baseURL, err := urls.NewBaseURLFromString(c.BaseURL)
@@ -374,22 +352,6 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		}
 	}
 
-	httpCache, err := c.HTTPCache.Compile()
-	if err != nil {
-		return err
-	}
-
-	// Legacy paginate values.
-	if c.Paginate != 0 {
-		hugo.Deprecate("site config key paginate", "Use pagination.pagerSize instead.", "v0.128.0")
-		c.Pagination.PagerSize = c.Paginate
-	}
-
-	if c.PaginatePath != "" {
-		hugo.Deprecate("site config key paginatePath", "Use pagination.path instead.", "v0.128.0")
-		c.Pagination.Path = c.PaginatePath
-	}
-
 	c.C = &ConfigCompiled{
 		Timeout:           timeout,
 		BaseURL:           baseURL,
@@ -398,14 +360,11 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		DisabledLanguages: disabledLangs,
 		IgnoredLogs:       ignoredLogIDs,
 		KindOutputFormats: kindOutputFormats,
-		ContentTypes:      media.DefaultContentTypes.FromTypes(c.MediaTypes.Config),
 		CreateTitle:       helpers.GetTitleFunc(c.TitleCaseStyle),
 		IsUglyURLSection:  isUglyURL,
 		IgnoreFile:        ignoreFile,
-		SegmentFilter:     c.Segments.Config.Get(func(s string) { logger.Warnf("Render segment %q not found in configuration", s) }, c.RootConfig.RenderSegments...),
 		MainSections:      c.MainSections,
 		Clock:             clock,
-		HTTPCache:         httpCache,
 		transientErr:      transientErr,
 	}
 
@@ -433,19 +392,15 @@ type ConfigCompiled struct {
 	Timeout           time.Duration
 	BaseURL           urls.BaseURL
 	BaseURLLiveReload urls.BaseURL
-	ServerInterface   string
 	KindOutputFormats map[string]output.Formats
-	ContentTypes      media.ContentTypes
 	DisabledKinds     map[string]bool
 	DisabledLanguages map[string]bool
 	IgnoredLogs       map[string]bool
 	CreateTitle       func(s string) string
 	IsUglyURLSection  func(section string) bool
 	IgnoreFile        func(filename string) bool
-	SegmentFilter     segments.SegmentFilter
 	MainSections      []string
 	Clock             time.Time
-	HTTPCache         httpcache.ConfigCompiled
 
 	// This is set to the last transient error found during config compilation.
 	// With themes/modules we compute the configuration in multiple passes, and
@@ -470,10 +425,9 @@ func (c *ConfigCompiled) IsMainSectionsSet() bool {
 }
 
 // This is set after the config is compiled by the server command.
-func (c *ConfigCompiled) SetServerInfo(baseURL, baseURLLiveReload urls.BaseURL, serverInterface string) {
+func (c *ConfigCompiled) SetBaseURL(baseURL, baseURLLiveReload urls.BaseURL) {
 	c.BaseURL = baseURL
 	c.BaseURLLiveReload = baseURLLiveReload
-	c.ServerInterface = serverInterface
 }
 
 // RootConfig holds all the top-level configuration options in Hugo
@@ -517,10 +471,6 @@ type RootConfig struct {
 	// A list of languages to disable.
 	DisableLanguages []string
 
-	// The named segments to render.
-	// This needs to match the name of the segment in the segments configuration.
-	RenderSegments []string
-
 	// Disable the injection of the Hugo generator tag on the home page.
 	DisableHugoGeneratorInject bool
 
@@ -578,20 +528,15 @@ type RootConfig struct {
 	HasCJKLanguage bool
 
 	// The default number of pages per page when paginating.
-	// Deprecated: Use the Pagination struct.
 	Paginate int
 
 	// The path to use when creating pagination URLs, e.g. "page" in /page/2/.
-	// Deprecated: Use the Pagination struct.
 	PaginatePath string
 
 	// Whether to pluralize default list titles.
 	// Note that this currently only works for English, but you can provide your own title in the content file's front matter.
 	PluralizeListTitles bool
 
-	// Whether to capitalize automatic page titles, applicable to section, taxonomy, and term pages.
-	CapitalizeListTitles bool
-
 	// Make all relative URLs absolute using the baseURL.
 	// <docsmeta>{"identifiers": ["baseURL"] }</docsmeta>
 	CanonifyURLs bool
@@ -717,18 +662,11 @@ type Configs struct {
 	// All below is set in Init.
 	Languages             langs.Languages
 	LanguagesDefaultFirst langs.Languages
-	ContentPathParser     *paths.PathParser
+	ContentPathParser     paths.PathParser
 
 	configLangs []config.AllProvider
 }
 
-func (c *Configs) Validate(logger loggers.Logger) error {
-	for p := range c.Base.Cascade.Config {
-		page.CheckCascadePattern(logger, p)
-	}
-	return nil
-}
-
 // transientErr returns the last transient error found during config compilation.
 func (c *Configs) transientErr() error {
 	for _, l := range c.LanguageConfigSlice {
@@ -795,8 +733,7 @@ func (c *Configs) Init() error {
 
 	c.Languages = languages
 	c.LanguagesDefaultFirst = languagesDefaultFirst
-
-	c.ContentPathParser = &paths.PathParser{LanguageIndex: languagesDefaultFirst.AsIndexSet(), IsLangDisabled: c.Base.IsLangDisabled, IsContentExt: c.Base.C.ContentTypes.IsContentSuffix}
+	c.ContentPathParser = paths.PathParser{LanguageIndex: languagesDefaultFirst.AsIndexSet()}
 
 	c.configLangs = make([]config.AllProvider, len(c.Languages))
 	for i, l := range c.LanguagesDefaultFirst {
@@ -809,7 +746,7 @@ func (c *Configs) Init() error {
 	}
 
 	if len(c.Modules) == 0 {
-		return errors.New("no modules loaded (need at least the main module)")
+		return errors.New("no modules loaded (ned at least the main module)")
 	}
 
 	// Apply default project mounts.
@@ -877,7 +814,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 	langConfigMap := make(map[string]*Config)
 
 	languagesConfig := cfg.GetStringMap("languages")
-	var isMultihost bool
+	var isMultiHost bool
 
 	if err := all.CompileConfig(logger); err != nil {
 		return nil, err
@@ -914,7 +851,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 				}
 				if kk == "baseurl" {
 					// baseURL configure don the language level is a multihost setup.
-					isMultihost = true
+					isMultiHost = true
 				}
 				mergedConfig.Set(kk, vv)
 				rootv := cfg.Get(kk)
@@ -964,7 +901,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 			}
 
 			// Adjust Goldmark config defaults for multilingual, single-host sites.
-			if len(languagesConfig) > 1 && !isMultihost && !clone.Markup.Goldmark.DuplicateResourceFiles {
+			if len(languagesConfig) > 1 && !isMultiHost && !clone.Markup.Goldmark.DuplicateResourceFiles {
 				if !clone.Markup.Goldmark.DuplicateResourceFiles {
 					if clone.Markup.Goldmark.RenderHooks.Link.EnableDefault == nil {
 						clone.Markup.Goldmark.RenderHooks.Link.EnableDefault = types.NewBool(true)
@@ -994,7 +931,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 		Base:              all,
 		LanguageConfigMap: langConfigMap,
 		LoadingInfo:       res,
-		IsMultihost:       isMultihost,
+		IsMultihost:       isMultiHost,
 	}
 
 	return cm, nil

config/allconfig/allconfig_integration_test.go

@@ -84,94 +84,3 @@ logPathWarnings = true
 	b.Assert(conf.PrintI18nWarnings, qt.Equals, true)
 	b.Assert(conf.PrintPathWarnings, qt.Equals, true)
 }
-
-func TestRedefineContentTypes(t *testing.T) {
-	files := `
--- hugo.toml --
-baseURL = "https://example.com"
-[mediaTypes]
-[mediaTypes."text/html"]
-suffixes = ["html", "xhtml"]
-`
-
-	b := hugolib.Test(t, files)
-
-	conf := b.H.Configs.Base
-	contentTypes := conf.C.ContentTypes
-
-	b.Assert(contentTypes.HTML.Suffixes(), qt.DeepEquals, []string{"html", "xhtml"})
-	b.Assert(contentTypes.Markdown.Suffixes(), qt.DeepEquals, []string{"md", "mdown", "markdown"})
-}
-
-func TestPaginationConfig(t *testing.T) {
-	files := `
--- hugo.toml --
- [languages.en]
- weight = 1
- [languages.en.pagination]
- pagerSize = 20
- [languages.de]
- weight = 2
- [languages.de.pagination]
- path = "page-de"
-
-`
-
-	b := hugolib.Test(t, files)
-
-	confEn := b.H.Sites[0].Conf.Pagination()
-	confDe := b.H.Sites[1].Conf.Pagination()
-
-	b.Assert(confEn.Path, qt.Equals, "page")
-	b.Assert(confEn.PagerSize, qt.Equals, 20)
-	b.Assert(confDe.Path, qt.Equals, "page-de")
-	b.Assert(confDe.PagerSize, qt.Equals, 10)
-}
-
-func TestPaginationConfigDisableAliases(t *testing.T) {
-	files := `
--- hugo.toml --
-disableKinds = ["taxonomy", "term"]
-[pagination]
-disableAliases = true
-pagerSize = 2
--- layouts/_default/list.html --
-{{ $paginator := .Paginate  site.RegularPages }}
-{{ template "_internal/pagination.html" . }}
-{{ range $paginator.Pages }}
-  {{ .Title }}
-{{ end }}
--- content/p1.md --
----
-title: "p1"
----
--- content/p2.md --
----
-title: "p2"
----
--- content/p3.md --
----
-title: "p3"
----
-`
-
-	b := hugolib.Test(t, files)
-
-	b.AssertFileExists("public/page/1/index.html", false)
-	b.AssertFileContent("public/page/2/index.html", "pagination-default")
-}
-
-func TestMapUglyURLs(t *testing.T) {
-	files := `
--- hugo.toml --
-[uglyurls]
-  posts = true
-`
-
-	b := hugolib.Test(t, files)
-
-	c := b.H.Configs.Base
-
-	b.Assert(c.C.IsUglyURLSection("posts"), qt.IsTrue)
-	b.Assert(c.C.IsUglyURLSection("blog"), qt.IsFalse)
-}

config/allconfig/alldecoders.go

@@ -18,22 +18,18 @@ import (
 	"strings"
 
 	"github.com/gohugoio/hugo/cache/filecache"
-
-	"github.com/gohugoio/hugo/cache/httpcache"
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/privacy"
 	"github.com/gohugoio/hugo/config/security"
 	"github.com/gohugoio/hugo/config/services"
-	"github.com/gohugoio/hugo/deploy/deployconfig"
-	"github.com/gohugoio/hugo/hugolib/segments"
+	"github.com/gohugoio/hugo/deploy"
 	"github.com/gohugoio/hugo/langs"
 	"github.com/gohugoio/hugo/markup/markup_config"
 	"github.com/gohugoio/hugo/media"
 	"github.com/gohugoio/hugo/minifiers"
 	"github.com/gohugoio/hugo/modules"
-
 	"github.com/gohugoio/hugo/navigation"
 	"github.com/gohugoio/hugo/output"
 	"github.com/gohugoio/hugo/related"
@@ -98,18 +94,6 @@ var allDecoderSetups = map[string]decodeWeight{
 			return err
 		},
 	},
-	"httpcache": {
-		key: "httpcache",
-		decode: func(d decodeWeight, p decodeConfig) error {
-			var err error
-			p.c.HTTPCache, err = httpcache.DecodeConfig(p.bcfg, p.p.GetStringMap(d.key))
-			if p.c.IgnoreCache {
-				p.c.HTTPCache.Cache.For.Excludes = []string{"**"}
-				p.c.HTTPCache.Cache.For.Includes = []string{}
-			}
-			return err
-		},
-	},
 	"build": {
 		key: "build",
 		decode: func(d decodeWeight, p decodeConfig) error {
@@ -136,14 +120,6 @@ var allDecoderSetups = map[string]decodeWeight{
 			return err
 		},
 	},
-	"segments": {
-		key: "segments",
-		decode: func(d decodeWeight, p decodeConfig) error {
-			var err error
-			p.c.Segments, err = segments.DecodeSegments(p.p.GetStringMap(d.key))
-			return err
-		},
-	},
 	"server": {
 		key: "server",
 		decode: func(d decodeWeight, p decodeConfig) error {
@@ -315,7 +291,7 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "cascade",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			p.c.Cascade, err = page.DecodeCascadeConfig(nil, p.p.Get(d.key))
+			p.c.Cascade, err = page.DecodeCascadeConfig(p.p.Get(d.key))
 			return err
 		},
 	},
@@ -327,41 +303,6 @@ var allDecoderSetups = map[string]decodeWeight{
 			return err
 		},
 	},
-	"page": {
-		key: "page",
-		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Page = config.PageConfig{
-				NextPrevSortOrder:          "desc",
-				NextPrevInSectionSortOrder: "desc",
-			}
-			if p.p.IsSet(d.key) {
-				if err := mapstructure.WeakDecode(p.p.Get(d.key), &p.c.Page); err != nil {
-					return err
-				}
-			}
-
-			return nil
-		},
-		getCompiler: func(c *Config) configCompiler {
-			return &c.Page
-		},
-	},
-	"pagination": {
-		key: "pagination",
-		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Pagination = config.Pagination{
-				PagerSize: 10,
-				Path:      "page",
-			}
-			if p.p.IsSet(d.key) {
-				if err := mapstructure.WeakDecode(p.p.Get(d.key), &p.c.Pagination); err != nil {
-					return err
-				}
-			}
-
-			return nil
-		},
-	},
 	"privacy": {
 		key: "privacy",
 		decode: func(d decodeWeight, p decodeConfig) error {
@@ -390,7 +331,7 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "deployment",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			p.c.Deployment, err = deployconfig.DecodeConfig(p.p)
+			p.c.Deployment, err = deploy.DecodeConfig(p.p)
 			return err
 		},
 	},
@@ -419,8 +360,6 @@ var allDecoderSetups = map[string]decodeWeight{
 				p.c.UglyURLs = vv
 			case string:
 				p.c.UglyURLs = vv == "true"
-			case maps.Params:
-				p.c.UglyURLs = cast.ToStringMapBool(maps.CleanConfigStringMap(vv))
 			default:
 				p.c.UglyURLs = cast.ToStringMapBool(v)
 			}

config/allconfig/configlanguage.go

@@ -19,7 +19,6 @@ import (
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/urls"
 	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/langs"
 )
 
@@ -43,7 +42,7 @@ func (c ConfigLanguage) LanguagesDefaultFirst() langs.Languages {
 	return c.m.LanguagesDefaultFirst
 }
 
-func (c ConfigLanguage) PathParser() *paths.PathParser {
+func (c ConfigLanguage) PathParser() paths.PathParser {
 	return c.m.ContentPathParser
 }
 
@@ -52,7 +51,7 @@ func (c ConfigLanguage) LanguagePrefix() string {
 		return c.Language().Lang
 	}
 
-	if !c.IsMultilingual() || c.DefaultContentLanguage() == c.Language().Lang {
+	if !c.IsMultiLingual() || c.DefaultContentLanguage() == c.Language().Lang {
 		return ""
 	}
 	return c.Language().Lang
@@ -71,17 +70,10 @@ func (c ConfigLanguage) Environment() string {
 }
 
 func (c ConfigLanguage) IsMultihost() bool {
-	if len(c.m.Languages)-len(c.config.C.DisabledLanguages) <= 1 {
-		return false
-	}
 	return c.m.IsMultihost
 }
 
-func (c ConfigLanguage) FastRenderMode() bool {
-	return c.config.Internal.FastRenderMode
-}
-
-func (c ConfigLanguage) IsMultilingual() bool {
+func (c ConfigLanguage) IsMultiLingual() bool {
 	return len(c.m.Languages) > 1
 }
 
@@ -137,17 +129,6 @@ func (c ConfigLanguage) Watching() bool {
 	return c.m.Base.Internal.Watch
 }
 
-func (c ConfigLanguage) NewIdentityManager(name string) identity.Manager {
-	if !c.Watching() {
-		return identity.NopManager
-	}
-	return identity.NewManager(name)
-}
-
-func (c ConfigLanguage) ContentTypes() config.ContentTypesProvider {
-	return c.config.C.ContentTypes
-}
-
 // GetConfigSection is mostly used in tests. The switch statement isn't complete, but what's in use.
 func (c ConfigLanguage) GetConfigSection(s string) any {
 	switch s {
@@ -173,8 +154,6 @@ func (c ConfigLanguage) GetConfigSection(s string) any {
 		return c.m.Modules
 	case "deployment":
 		return c.config.Deployment
-	case "httpCacheCompiled":
-		return c.config.C.HTTPCache
 	default:
 		panic("not implemented: " + s)
 	}
@@ -248,8 +227,12 @@ func (c ConfigLanguage) CreateTitle(s string) string {
 	return c.config.C.CreateTitle(s)
 }
 
-func (c ConfigLanguage) Pagination() config.Pagination {
-	return c.config.Pagination
+func (c ConfigLanguage) Paginate() int {
+	return c.config.Paginate
+}
+
+func (c ConfigLanguage) PaginatePath() string {
+	return c.config.PaginatePath
 }
 
 func (c ConfigLanguage) StaticDirs() []string {

config/allconfig/load.go

@@ -64,7 +64,7 @@ func LoadConfig(d ConfigSourceDescriptor) (*Configs, error) {
 		return nil, fmt.Errorf("failed to create config from result: %w", err)
 	}
 
-	moduleConfig, modulesClient, err := l.loadModules(configs, d.IgnoreModuleDoesNotExist)
+	moduleConfig, modulesClient, err := l.loadModules(configs)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load modules: %w", err)
 	}
@@ -116,9 +116,6 @@ type ConfigSourceDescriptor struct {
 
 	// Defaults to os.Environ if not set.
 	Environ []string
-
-	// If set, this will be used to ignore the module does not exist error.
-	IgnoreModuleDoesNotExist bool
 }
 
 func (d ConfigSourceDescriptor) configFilenames() []string {
@@ -192,13 +189,12 @@ func (l configLoader) applyDefaultConfig() error {
 		"menus":                                maps.Params{},
 		"disableLiveReload":                    false,
 		"pluralizeListTitles":                  true,
-		"capitalizeListTitles":                 true,
 		"forceSyncStatic":                      false,
 		"footnoteAnchorPrefix":                 "",
 		"footnoteReturnLinkContents":           "",
 		"newContentEditor":                     "",
-		"paginate":                             0,  // Moved into the paginator struct in Hugo v0.128.0.
-		"paginatePath":                         "", // Moved into the paginator struct in Hugo v0.128.0.
+		"paginate":                             10,
+		"paginatePath":                         "page",
 		"summaryLength":                        70,
 		"rssLimit":                             -1,
 		"sectionPagesMenu":                     "",
@@ -456,12 +452,11 @@ func (l *configLoader) loadConfigMain(d ConfigSourceDescriptor) (config.LoadConf
 	return res, l.ModulesConfig, err
 }
 
-func (l *configLoader) loadModules(configs *Configs, ignoreModuleDoesNotExist bool) (modules.ModulesConfig, *modules.Client, error) {
+func (l *configLoader) loadModules(configs *Configs) (modules.ModulesConfig, *modules.Client, error) {
 	bcfg := configs.LoadingInfo.BaseConfig
 	conf := configs.Base
 	workingDir := bcfg.WorkingDir
 	themesDir := bcfg.ThemesDir
-	publishDir := bcfg.PublishDir
 
 	cfg := configs.LoadingInfo.Cfg
 
@@ -470,7 +465,7 @@ func (l *configLoader) loadModules(configs *Configs, ignoreModuleDoesNotExist bo
 		ignoreVendor, _ = hglob.GetGlob(hglob.NormalizePath(s))
 	}
 
-	ex := hexec.New(conf.Security, workingDir)
+	ex := hexec.New(conf.Security)
 
 	hook := func(m *modules.ModulesConfig) error {
 		for _, tc := range m.AllModules {
@@ -490,18 +485,16 @@ func (l *configLoader) loadModules(configs *Configs, ignoreModuleDoesNotExist bo
 	}
 
 	modulesClient := modules.NewClient(modules.ClientConfig{
-		Fs:                       l.Fs,
-		Logger:                   l.Logger,
-		Exec:                     ex,
-		HookBeforeFinalize:       hook,
-		WorkingDir:               workingDir,
-		ThemesDir:                themesDir,
-		PublishDir:               publishDir,
-		Environment:              l.Environment,
-		CacheDir:                 conf.Caches.CacheDirModules(),
-		ModuleConfig:             conf.Module,
-		IgnoreVendor:             ignoreVendor,
-		IgnoreModuleDoesNotExist: ignoreModuleDoesNotExist,
+		Fs:                 l.Fs,
+		Logger:             l.Logger,
+		Exec:               ex,
+		HookBeforeFinalize: hook,
+		WorkingDir:         workingDir,
+		ThemesDir:          themesDir,
+		Environment:        l.Environment,
+		CacheDir:           conf.Caches.CacheDirModules(),
+		ModuleConfig:       conf.Module,
+		IgnoreVendor:       ignoreVendor,
 	})
 
 	moduleConfig, err := modulesClient.Collect()

config/commonConfig.go

@@ -98,6 +98,10 @@ type BuildConfig struct {
 	// One of never, fallback, always. Default is fallback
 	UseResourceCacheWhen string
 
+	// When enabled, will duplicate bundled resource files across languages that
+	// doesn't have a translated version.
+	DuplicateResourceFiles bool
+
 	// When enabled, will collect and write a hugo_stats.json with some build
 	// related aggregated data (e.g. CSS class names).
 	// Note that this was a bool <= v0.115.0.
@@ -211,8 +215,6 @@ type SitemapConfig struct {
 	Priority float64
 	// The sitemap filename.
 	Filename string
-	// Whether to disable page inclusion.
-	Disable bool
 }
 
 func DecodeSitemap(prototype SitemapConfig, input map[string]any) (SitemapConfig, error) {
@@ -410,30 +412,3 @@ func DecodeServer(cfg Provider) (Server, error) {
 
 	return *s, nil
 }
-
-// Pagination configures the pagination behavior.
-type Pagination struct {
-	//  Default number of elements per pager in pagination.
-	PagerSize int
-
-	// The path element used during pagination.
-	Path string
-
-	// Whether to disable generation of alias for the first pagination page.
-	DisableAliases bool
-}
-
-// PageConfig configures the behavior of pages.
-type PageConfig struct {
-	// Sort order for Page.Next and Page.Prev. Default "desc" (the default page sort order in Hugo).
-	NextPrevSortOrder string
-
-	// Sort order for Page.NextInSection and Page.PrevInSection. Default "desc".
-	NextPrevInSectionSortOrder string
-}
-
-func (c *PageConfig) CompileConfig(loggers.Logger) error {
-	c.NextPrevInSectionSortOrder = strings.ToLower(c.NextPrevInSectionSortOrder)
-	c.NextPrevSortOrder = strings.ToLower(c.NextPrevSortOrder)
-	return nil
-}

config/configProvider.go

@@ -20,7 +20,6 @@ import (
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/common/urls"
-	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/langs"
 )
 
@@ -32,16 +31,15 @@ type AllProvider interface {
 	LanguagePrefix() string
 	BaseURL() urls.BaseURL
 	BaseURLLiveReload() urls.BaseURL
-	PathParser() *paths.PathParser
+	PathParser() paths.PathParser
 	Environment() string
 	IsMultihost() bool
-	IsMultilingual() bool
+	IsMultiLingual() bool
 	NoBuildLock() bool
 	BaseConfig() BaseConfig
 	Dirs() CommonDirs
 	Quiet() bool
 	DirsBase() CommonDirs
-	ContentTypes() ContentTypesProvider
 	GetConfigSection(string) any
 	GetConfig() any
 	CanonifyURLs() bool
@@ -52,14 +50,13 @@ type AllProvider interface {
 	DefaultContentLanguageInSubdir() bool
 	IsLangDisabled(string) bool
 	SummaryLength() int
-	Pagination() Pagination
+	Paginate() int
+	PaginatePath() string
 	BuildExpired() bool
 	BuildFuture() bool
 	BuildDrafts() bool
 	Running() bool
 	Watching() bool
-	NewIdentityManager(name string) identity.Manager
-	FastRenderMode() bool
 	PrintUnusedTemplates() bool
 	EnableMissingTranslationPlaceholders() bool
 	TemplateMetrics() bool
@@ -75,15 +72,6 @@ type AllProvider interface {
 	EnableEmoji() bool
 }
 
-// We cannot import the media package as that would create a circular dependency.
-// This interface defineds a sub set of what media.ContentTypes provides.
-type ContentTypesProvider interface {
-	IsContentSuffix(suffix string) bool
-	IsContentFile(filename string) bool
-	IsIndexContentFile(filename string) bool
-	IsHTMLSuffix(suffix string) bool
-}
-
 // Provider provides the configuration settings for Hugo.
 type Provider interface {
 	GetString(key string) string

config/namespace.go

@@ -16,13 +16,13 @@ package config
 import (
 	"encoding/json"
 
-	"github.com/gohugoio/hugo/common/hashing"
+	"github.com/gohugoio/hugo/identity"
 )
 
 func DecodeNamespace[S, C any](configSource any, buildConfig func(any) (C, any, error)) (*ConfigNamespace[S, C], error) {
 	// Calculate the hash of the input (not including any defaults applied later).
 	// This allows us to introduce new config options without breaking the hash.
-	h := hashing.HashString(configSource)
+	h := identity.HashString(configSource)
 
 	// Build the config
 	c, ext, err := buildConfig(configSource)

config/namespace_test.go

@@ -43,7 +43,7 @@ func TestNamespace(t *testing.T) {
 	c.Assert(err, qt.IsNil)
 	c.Assert(ns, qt.Not(qt.IsNil))
 	c.Assert(ns.SourceStructure, qt.DeepEquals, map[string]interface{}{"foo": "bar"})
-	c.Assert(ns.SourceHash, qt.Equals, "1450430416588600409")
+	c.Assert(ns.SourceHash, qt.Equals, "14368731254619220105")
 	c.Assert(ns.Config, qt.DeepEquals, &tstNsExt{Foo: "bar"})
 	c.Assert(ns.Signature(), qt.DeepEquals, []*tstNsExt(nil))
 }

config/privacy/privacyConfig.go

@@ -44,9 +44,15 @@ type Disqus struct {
 type GoogleAnalytics struct {
 	Service `mapstructure:",squash"`
 
+	// Enabling this will disable the use of Cookies and use Session Storage to Store the GA Client ID.
+	UseSessionStorage bool
+
 	// Enabling this will make the GA templates respect the
 	// "Do Not Track" HTTP header. See  https://www.paulfurley.com/google-analytics-dnt/.
 	RespectDoNotTrack bool
+
+	// Enabling this will make it so the users' IP addresses are anonymized within Google Analytics.
+	AnonymizeIP bool
 }
 
 // Instagram holds the privacy configuration settings related to the Instagram shortcode.

config/privacy/privacyConfig_test.go

@@ -33,6 +33,8 @@ disable = true
 [privacy.googleAnalytics]
 disable = true
 respectDoNotTrack = true
+anonymizeIP = true
+useSessionStorage = true
 [privacy.instagram]
 disable = true
 simple = true
@@ -58,7 +60,8 @@ simple = true
 
 	got := []bool{
 		pc.Disqus.Disable, pc.GoogleAnalytics.Disable,
-		pc.GoogleAnalytics.RespectDoNotTrack, pc.Instagram.Disable,
+		pc.GoogleAnalytics.RespectDoNotTrack, pc.GoogleAnalytics.AnonymizeIP,
+		pc.GoogleAnalytics.UseSessionStorage, pc.Instagram.Disable,
 		pc.Instagram.Simple, pc.Twitter.Disable, pc.Twitter.EnableDNT,
 		pc.Twitter.Simple, pc.Vimeo.Disable, pc.Vimeo.EnableDNT, pc.Vimeo.Simple,
 		pc.YouTube.PrivacyEnhanced, pc.YouTube.Disable,

config/security/securityConfig.go

@@ -37,14 +37,12 @@ var DefaultConfig = Config{
 		Allow: MustNewWhitelist(
 			"^(dart-)?sass(-embedded)?$", // sass, dart-sass, dart-sass-embedded.
 			"^go$",                       // for Go Modules
-			"^git$",                      // For Git info
 			"^npx$",                      // used by all Node tools (Babel, PostCSS).
 			"^postcss$",
-			"^tailwindcss$",
 		),
 		// These have been tested to work with Hugo's external programs
 		// on Windows, Linux and MacOS.
-		OsEnv: MustNewWhitelist(`(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\w+|(XDG_CONFIG_)?HOME|USERPROFILE|SSH_AUTH_SOCK|DISPLAY|LANG|SYSTEMDRIVE)$`),
+		OsEnv: MustNewWhitelist(`(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\w+|(XDG_CONFIG_)?HOME|USERPROFILE|SSH_AUTH_SOCK|DISPLAY|LANG)$`),
 	},
 	Funcs: Funcs{
 		Getenv: MustNewWhitelist("^HUGO_", "^CI$"),

config/security/securityConfig_test.go

@@ -135,7 +135,7 @@ func TestToTOML(t *testing.T) {
 	got := DefaultConfig.ToTOML()
 
 	c.Assert(got, qt.Equals,
-		"[security]\n  enableInlineShortcodes = false\n\n  [security.exec]\n    allow = ['^(dart-)?sass(-embedded)?$', '^go$', '^git$', '^npx$', '^postcss$', '^tailwindcss$']\n    osEnv = ['(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\\w+|(XDG_CONFIG_)?HOME|USERPROFILE|SSH_AUTH_SOCK|DISPLAY|LANG|SYSTEMDRIVE)$']\n\n  [security.funcs]\n    getenv = ['^HUGO_', '^CI$']\n\n  [security.http]\n    methods = ['(?i)GET|POST']\n    urls = ['.*']",
+		"[security]\n  enableInlineShortcodes = false\n\n  [security.exec]\n    allow = ['^(dart-)?sass(-embedded)?$', '^go$', '^npx$', '^postcss$']\n    osEnv = ['(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\\w+|(XDG_CONFIG_)?HOME|USERPROFILE|SSH_AUTH_SOCK|DISPLAY|LANG)$']\n\n  [security.funcs]\n    getenv = ['^HUGO_', '^CI$']\n\n  [security.http]\n    methods = ['(?i)GET|POST']\n    urls = ['.*']",
 	)
 }
 

create/content.go

@@ -29,6 +29,8 @@ import (
 	"github.com/gohugoio/hugo/common/hstrings"
 	"github.com/gohugoio/hugo/common/paths"
 
+	"github.com/gohugoio/hugo/hugofs/files"
+
 	"github.com/gohugoio/hugo/hugofs"
 
 	"github.com/gohugoio/hugo/helpers"
@@ -96,7 +98,7 @@ func NewContent(h *hugolib.HugoSites, kind, targetPath string, force bool) error
 			return "", fmt.Errorf("failed to resolve %q to an archetype template", targetPath)
 		}
 
-		if !h.Conf.ContentTypes().IsContentFile(b.targetPath) {
+		if !files.IsContentFile(b.targetPath) {
 			return "", fmt.Errorf("target path %q is not a known content format", b.targetPath)
 		}
 

create/skeletons/site/archetypes/default.md

@@ -0,0 +1,5 @@
++++
+title = '{{ replace .File.ContentBaseName "-" " " | title }}'
+date = {{ .Date }}
+draft = true
++++

create/skeletons/skeletons.go

@@ -76,11 +76,6 @@ func CreateSite(createpath string, sourceFs afero.Fs, force bool, format string)
 		return err
 	}
 
-	err = newSiteCreateArchetype(sourceFs, createpath, format)
-	if err != nil {
-		return err
-	}
-
 	return copyFiles(createpath, sourceFs, siteFs)
 }
 
@@ -114,19 +109,3 @@ func newSiteCreateConfig(fs afero.Fs, createpath string, format string) (err err
 
 	return helpers.WriteToDisk(filepath.Join(createpath, "hugo."+format), &buf, fs)
 }
-
-func newSiteCreateArchetype(fs afero.Fs, createpath string, format string) (err error) {
-	in := map[string]any{
-		"title": "{{ replace .File.ContentBaseName \"-\" \" \" | title }}",
-		"date":  "{{ .Date }}",
-		"draft": true,
-	}
-
-	var buf bytes.Buffer
-	err = parser.InterfaceToFrontMatter(in, metadecoders.FormatFromString(format), &buf)
-	if err != nil {
-		return err
-	}
-
-	return helpers.WriteToDisk(filepath.Join(createpath, "archetypes", "default.md"), &buf, fs)
-}

create/skeletons/theme/hugo.toml

@@ -1,5 +1,5 @@
 baseURL = 'https://example.org/'
-languageCode = 'en-US'
+languageCode = 'en-us'
 title = 'My New Hugo Site'
 
 [[menus.main]]

create/skeletons/theme/layouts/_default/baseof.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="{{ site.Language.LanguageCode }}" dir="{{ or site.Language.LanguageDirection `ltr` }}">
+<html lang="{{ or site.Language.LanguageCode site.Language.Lang }}" dir="{{ or site.Language.LanguageDirection `ltr` }}">
 <head>
   {{ partial "head.html" . }}
 </head>

create/skeletons/theme/layouts/partials/terms.html

@@ -2,7 +2,7 @@
 For a given taxonomy, renders a list of terms assigned to the page.
 
 @context {page} page The current page.
-@context {string} taxonomy The taxonomy.
+@context {string} taxonomy The taxonony.
 
 @example: {{ partial "terms.html" (dict "taxonomy" "tags" "page" .) }}
 */}}

deploy/cloudfront.go

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build withdeploy
-// +build withdeploy
+//go:build !nodeploy
+// +build !nodeploy
 
 package deploy
 
@@ -24,7 +24,6 @@ import (
 	"github.com/aws/aws-sdk-go-v2/aws"
 	"github.com/aws/aws-sdk-go-v2/service/cloudfront"
 	"github.com/aws/aws-sdk-go-v2/service/cloudfront/types"
-	"github.com/gohugoio/hugo/deploy/deployconfig"
 	gcaws "gocloud.dev/aws"
 )
 
@@ -39,7 +38,7 @@ var v2ConfigValidParams = map[string]bool{
 
 // InvalidateCloudFront invalidates the CloudFront cache for distributionID.
 // Uses AWS credentials config from the bucket URL.
-func InvalidateCloudFront(ctx context.Context, target *deployconfig.Target) error {
+func InvalidateCloudFront(ctx context.Context, target *Target) error {
 	u, err := url.Parse(target.URL)
 	if err != nil {
 		return err

deploy/deploy.go

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build withdeploy
-// +build withdeploy
+//go:build !nodeploy
+// +build !nodeploy
 
 package deploy
 
@@ -38,7 +38,6 @@ import (
 	"github.com/gobwas/glob"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/config"
-	"github.com/gohugoio/hugo/deploy/deployconfig"
 	"github.com/gohugoio/hugo/media"
 	"github.com/spf13/afero"
 	"golang.org/x/text/unicode/norm"
@@ -58,10 +57,10 @@ type Deployer struct {
 	mediaTypes media.Types // Hugo's MediaType to guess ContentType
 	quiet      bool        // true reduces STDOUT // TODO(bep) remove, this is a global feature.
 
-	cfg    deployconfig.DeployConfig
+	cfg    DeployConfig
 	logger loggers.Logger
 
-	target *deployconfig.Target // the target to deploy to
+	target *Target // the target to deploy to
 
 	// For tests...
 	summary deploySummary // summary of latest Deploy results
@@ -75,7 +74,7 @@ const metaMD5Hash = "md5chksum" // the meta key to store md5hash in
 
 // New constructs a new *Deployer.
 func New(cfg config.AllProvider, logger loggers.Logger, localFs afero.Fs) (*Deployer, error) {
-	dcfg := cfg.GetConfigSection(deployconfig.DeploymentConfigKey).(deployconfig.DeployConfig)
+	dcfg := cfg.GetConfigSection(deploymentConfigKey).(DeployConfig)
 	targetName := dcfg.Target
 
 	if len(dcfg.Targets) == 0 {
@@ -84,7 +83,7 @@ func New(cfg config.AllProvider, logger loggers.Logger, localFs afero.Fs) (*Depl
 	mediaTypes := cfg.GetConfigSection("mediaTypes").(media.Types)
 
 	// Find the target to deploy to.
-	var tgt *deployconfig.Target
+	var tgt *Target
 	if targetName == "" {
 		// Default to the first target.
 		tgt = dcfg.Targets[0]
@@ -133,14 +132,10 @@ func (d *Deployer) Deploy(ctx context.Context) error {
 
 	// Load local files from the source directory.
 	var include, exclude glob.Glob
-	var mappath func(string) string
 	if d.target != nil {
-		include, exclude = d.target.IncludeGlob, d.target.ExcludeGlob
-		if d.target.StripIndexHTML {
-			mappath = stripIndexHTML
-		}
+		include, exclude = d.target.includeGlob, d.target.excludeGlob
 	}
-	local, err := d.walkLocal(d.localFs, d.cfg.Matchers, include, exclude, d.mediaTypes, mappath)
+	local, err := d.walkLocal(d.localFs, d.cfg.Matchers, include, exclude, d.mediaTypes)
 	if err != nil {
 		return err
 	}
@@ -183,7 +178,7 @@ func (d *Deployer) Deploy(ctx context.Context) error {
 
 	// Order the uploads. They are organized in groups; all uploads in a group
 	// must be complete before moving on to the next group.
-	uploadGroups := applyOrdering(d.cfg.Ordering, uploads)
+	uploadGroups := applyOrdering(d.cfg.ordering, uploads)
 
 	nParallel := d.cfg.Workers
 	var errs []error
@@ -348,14 +343,14 @@ type localFile struct {
 	UploadSize int64
 
 	fs         afero.Fs
-	matcher    *deployconfig.Matcher
+	matcher    *Matcher
 	md5        []byte       // cache
 	gzipped    bytes.Buffer // cached of gzipped contents if gzipping
 	mediaTypes media.Types
 }
 
 // newLocalFile initializes a *localFile.
-func newLocalFile(fs afero.Fs, nativePath, slashpath string, m *deployconfig.Matcher, mt media.Types) (*localFile, error) {
+func newLocalFile(fs afero.Fs, nativePath, slashpath string, m *Matcher, mt media.Types) (*localFile, error) {
 	f, err := fs.Open(nativePath)
 	if err != nil {
 		return nil, err
@@ -487,7 +482,7 @@ func knownHiddenDirectory(name string) bool {
 
 // walkLocal walks the source directory and returns a flat list of files,
 // using localFile.SlashPath as the map keys.
-func (d *Deployer) walkLocal(fs afero.Fs, matchers []*deployconfig.Matcher, include, exclude glob.Glob, mediaTypes media.Types, mappath func(string) string) (map[string]*localFile, error) {
+func (d *Deployer) walkLocal(fs afero.Fs, matchers []*Matcher, include, exclude glob.Glob, mediaTypes media.Types) (map[string]*localFile, error) {
 	retval := map[string]*localFile{}
 	err := afero.Walk(fs, "", func(path string, info os.FileInfo, err error) error {
 		if err != nil {
@@ -526,18 +521,13 @@ func (d *Deployer) walkLocal(fs afero.Fs, matchers []*deployconfig.Matcher, incl
 		}
 
 		// Find the first matching matcher (if any).
-		var m *deployconfig.Matcher
+		var m *Matcher
 		for _, cur := range matchers {
 			if cur.Matches(slashpath) {
 				m = cur
 				break
 			}
 		}
-		// Apply any additional modifications to the local path, to map it to
-		// the remote path.
-		if mappath != nil {
-			slashpath = mappath(slashpath)
-		}
 		lf, err := newLocalFile(fs, path, slashpath, m, mediaTypes)
 		if err != nil {
 			return err
@@ -551,15 +541,6 @@ func (d *Deployer) walkLocal(fs afero.Fs, matchers []*deployconfig.Matcher, incl
 	return retval, nil
 }
 
-// stripIndexHTML remaps keys matching "<dir>/index.html" to "<dir>/".
-func stripIndexHTML(slashpath string) string {
-	const suffix = "/index.html"
-	if strings.HasSuffix(slashpath, suffix) {
-		return slashpath[:len(slashpath)-len(suffix)+1]
-	}
-	return slashpath
-}
-
 // walkRemote walks the target bucket and returns a flat list.
 func (d *Deployer) walkRemote(ctx context.Context, bucket *blob.Bucket, include, exclude glob.Glob) (map[string]*blob.ListObject, error) {
 	retval := map[string]*blob.ListObject{}

deploy/deployConfig.go

@@ -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,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package deployconfig
+package deploy
 
 import (
 	"errors"
@@ -24,7 +24,7 @@ import (
 	"github.com/mitchellh/mapstructure"
 )
 
-const DeploymentConfigKey = "deployment"
+const deploymentConfigKey = "deployment"
 
 // DeployConfig is the complete configuration for deployment.
 type DeployConfig struct {
@@ -48,7 +48,7 @@ type DeployConfig struct {
 	// Number of concurrent workers to use when uploading files.
 	Workers int
 
-	Ordering []*regexp.Regexp `json:"-"` // compiled Order
+	ordering []*regexp.Regexp // compiled Order
 }
 
 type Target struct {
@@ -67,25 +67,20 @@ type Target struct {
 	Exclude string
 
 	// Parsed versions of Include/Exclude.
-	IncludeGlob glob.Glob `json:"-"`
-	ExcludeGlob glob.Glob `json:"-"`
-
-	// If true, any local path matching <dir>/index.html will be mapped to the
-	// remote path <dir>/. This does not affect the top-level index.html file,
-	// since that would result in an empty path.
-	StripIndexHTML bool
+	includeGlob glob.Glob
+	excludeGlob glob.Glob
 }
 
-func (tgt *Target) ParseIncludeExclude() error {
+func (tgt *Target) parseIncludeExclude() error {
 	var err error
 	if tgt.Include != "" {
-		tgt.IncludeGlob, err = hglob.GetGlob(tgt.Include)
+		tgt.includeGlob, err = hglob.GetGlob(tgt.Include)
 		if err != nil {
 			return fmt.Errorf("invalid deployment.target.include %q: %v", tgt.Include, err)
 		}
 	}
 	if tgt.Exclude != "" {
-		tgt.ExcludeGlob, err = hglob.GetGlob(tgt.Exclude)
+		tgt.excludeGlob, err = hglob.GetGlob(tgt.Exclude)
 		if err != nil {
 			return fmt.Errorf("invalid deployment.target.exclude %q: %v", tgt.Exclude, err)
 		}
@@ -120,12 +115,12 @@ type Matcher struct {
 	// other route-determined metadata (e.g., ContentType) has changed.
 	Force bool
 
-	// Re is Pattern compiled.
-	Re *regexp.Regexp `json:"-"`
+	// re is Pattern compiled.
+	re *regexp.Regexp
 }
 
 func (m *Matcher) Matches(path string) bool {
-	return m.Re.MatchString(path)
+	return m.re.MatchString(path)
 }
 
 var DefaultConfig = DeployConfig{
@@ -138,10 +133,10 @@ var DefaultConfig = DeployConfig{
 func DecodeConfig(cfg config.Provider) (DeployConfig, error) {
 	dcfg := DefaultConfig
 
-	if !cfg.IsSet(DeploymentConfigKey) {
+	if !cfg.IsSet(deploymentConfigKey) {
 		return dcfg, nil
 	}
-	if err := mapstructure.WeakDecode(cfg.GetStringMap(DeploymentConfigKey), &dcfg); err != nil {
+	if err := mapstructure.WeakDecode(cfg.GetStringMap(deploymentConfigKey), &dcfg); err != nil {
 		return dcfg, err
 	}
 
@@ -153,7 +148,7 @@ func DecodeConfig(cfg config.Provider) (DeployConfig, error) {
 		if *tgt == (Target{}) {
 			return dcfg, errors.New("empty deployment target")
 		}
-		if err := tgt.ParseIncludeExclude(); err != nil {
+		if err := tgt.parseIncludeExclude(); err != nil {
 			return dcfg, err
 		}
 	}
@@ -162,7 +157,7 @@ func DecodeConfig(cfg config.Provider) (DeployConfig, error) {
 		if *m == (Matcher{}) {
 			return dcfg, errors.New("empty deployment matcher")
 		}
-		m.Re, err = regexp.Compile(m.Pattern)
+		m.re, err = regexp.Compile(m.Pattern)
 		if err != nil {
 			return dcfg, fmt.Errorf("invalid deployment.matchers.pattern: %v", err)
 		}
@@ -172,7 +167,7 @@ func DecodeConfig(cfg config.Provider) (DeployConfig, error) {
 		if err != nil {
 			return dcfg, fmt.Errorf("invalid deployment.orderings.pattern: %v", err)
 		}
-		dcfg.Ordering = append(dcfg.Ordering, re)
+		dcfg.ordering = append(dcfg.ordering, re)
 	}
 
 	return dcfg, nil

deploy/deployConfig_test.go

@@ -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,10 +11,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build withdeploy
-// +build withdeploy
+//go:build !nodeploy
+// +build !nodeploy
 
-package deployconfig
+package deploy
 
 import (
 	"fmt"
@@ -91,7 +91,7 @@ force = true
 	c.Assert(len(dcfg.Order), qt.Equals, 2)
 	c.Assert(dcfg.Order[0], qt.Equals, "o1")
 	c.Assert(dcfg.Order[1], qt.Equals, "o2")
-	c.Assert(len(dcfg.Ordering), qt.Equals, 2)
+	c.Assert(len(dcfg.ordering), qt.Equals, 2)
 
 	// Targets.
 	c.Assert(len(dcfg.Targets), qt.Equals, 3)
@@ -104,11 +104,11 @@ force = true
 		c.Assert(tgt.CloudFrontDistributionID, qt.Equals, fmt.Sprintf("cdn%d", i))
 		c.Assert(tgt.Include, qt.Equals, wantInclude[i])
 		if wantInclude[i] != "" {
-			c.Assert(tgt.IncludeGlob, qt.Not(qt.IsNil))
+			c.Assert(tgt.includeGlob, qt.Not(qt.IsNil))
 		}
 		c.Assert(tgt.Exclude, qt.Equals, wantExclude[i])
 		if wantExclude[i] != "" {
-			c.Assert(tgt.ExcludeGlob, qt.Not(qt.IsNil))
+			c.Assert(tgt.excludeGlob, qt.Not(qt.IsNil))
 		}
 	}
 
@@ -117,7 +117,7 @@ force = true
 	for i := 0; i < 3; i++ {
 		m := dcfg.Matchers[i]
 		c.Assert(m.Pattern, qt.Equals, fmt.Sprintf("^pattern%d$", i))
-		c.Assert(m.Re, qt.Not(qt.IsNil))
+		c.Assert(m.re, qt.Not(qt.IsNil))
 		c.Assert(m.CacheControl, qt.Equals, fmt.Sprintf("cachecontrol%d", i))
 		c.Assert(m.ContentEncoding, qt.Equals, fmt.Sprintf("contentencoding%d", i))
 		c.Assert(m.ContentType, qt.Equals, fmt.Sprintf("contenttype%d", i))

deploy/deploy_azure.go

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build !solaris && withdeploy
-// +build !solaris,withdeploy
+//go:build !solaris && !nodeploy
+// +build !solaris,!nodeploy
 
 package deploy
 

deploy/deploy_test.go

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build withdeploy
-// +build withdeploy
+//go:build !nodeploy
+// +build !nodeploy
 
 package deploy
 
@@ -31,7 +31,6 @@ import (
 	"testing"
 
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/deploy/deployconfig"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/media"
 	"github.com/google/go-cmp/cmp"
@@ -111,7 +110,7 @@ func TestFindDiffs(t *testing.T) {
 		{
 			Description: "local == remote with route.Force true -> diffs",
 			Local: []*localFile{
-				{NativePath: "aaa", SlashPath: "aaa", UploadSize: 1, matcher: &deployconfig.Matcher{Force: true}, md5: hash1},
+				{NativePath: "aaa", SlashPath: "aaa", UploadSize: 1, matcher: &Matcher{Force: true}, md5: hash1},
 				makeLocal("bbb", 2, hash1),
 			},
 			Remote: []*blob.ListObject{
@@ -216,9 +215,8 @@ func TestFindDiffs(t *testing.T) {
 
 func TestWalkLocal(t *testing.T) {
 	tests := map[string]struct {
-		Given   []string
-		Expect  []string
-		MapPath func(string) string
+		Given  []string
+		Expect []string
 	}{
 		"Empty": {
 			Given:  []string{},
@@ -236,11 +234,6 @@ func TestWalkLocal(t *testing.T) {
 			Given:  []string{"file.txt", ".hidden_dir/file.txt", ".well-known/file.txt"},
 			Expect: []string{"file.txt", ".well-known/file.txt"},
 		},
-		"StripIndexHTML": {
-			Given:   []string{"index.html", "file.txt", "dir/index.html", "dir/file.txt"},
-			Expect:  []string{"index.html", "file.txt", "dir/", "dir/file.txt"},
-			MapPath: stripIndexHTML,
-		},
 	}
 
 	for desc, tc := range tests {
@@ -260,7 +253,7 @@ func TestWalkLocal(t *testing.T) {
 				}
 			}
 			d := newDeployer()
-			if got, err := d.walkLocal(fs, nil, nil, nil, media.DefaultTypes, tc.MapPath); err != nil {
+			if got, err := d.walkLocal(fs, nil, nil, nil, media.DefaultTypes); err != nil {
 				t.Fatal(err)
 			} else {
 				expect := map[string]any{}
@@ -280,63 +273,6 @@ func TestWalkLocal(t *testing.T) {
 	}
 }
 
-func TestStripIndexHTML(t *testing.T) {
-	tests := map[string]struct {
-		Input  string
-		Output string
-	}{
-		"Unmapped": {Input: "normal_file.txt", Output: "normal_file.txt"},
-		"Stripped": {Input: "directory/index.html", Output: "directory/"},
-		"NoSlash":  {Input: "prefix_index.html", Output: "prefix_index.html"},
-		"Root":     {Input: "index.html", Output: "index.html"},
-	}
-	for desc, tc := range tests {
-		t.Run(desc, func(t *testing.T) {
-			got := stripIndexHTML(tc.Input)
-			if got != tc.Output {
-				t.Errorf("got %q, expect %q", got, tc.Output)
-			}
-		})
-	}
-}
-
-func TestStripIndexHTMLMatcher(t *testing.T) {
-	// StripIndexHTML should not affect matchers.
-	fs := afero.NewMemMapFs()
-	if err := fs.Mkdir("dir", 0o755); err != nil {
-		t.Fatal(err)
-	}
-	for _, name := range []string{"index.html", "dir/index.html", "file.txt"} {
-		if fd, err := fs.Create(name); err != nil {
-			t.Fatal(err)
-		} else {
-			fd.Close()
-		}
-	}
-	d := newDeployer()
-	const pattern = `\.html$`
-	matcher := &deployconfig.Matcher{Pattern: pattern, Gzip: true, Re: regexp.MustCompile(pattern)}
-	if got, err := d.walkLocal(fs, []*deployconfig.Matcher{matcher}, nil, nil, media.DefaultTypes, stripIndexHTML); err != nil {
-		t.Fatal(err)
-	} else {
-		for _, name := range []string{"index.html", "dir/"} {
-			lf := got[name]
-			if lf == nil {
-				t.Errorf("missing file %q", name)
-			} else if lf.matcher == nil {
-				t.Errorf("file %q has nil matcher, expect %q", name, pattern)
-			}
-		}
-		const name = "file.txt"
-		lf := got[name]
-		if lf == nil {
-			t.Errorf("missing file %q", name)
-		} else if lf.matcher != nil {
-			t.Errorf("file %q has matcher %q, expect nil", name, lf.matcher.Pattern)
-		}
-	}
-}
-
 func TestLocalFile(t *testing.T) {
 	const (
 		content = "hello world!"
@@ -357,7 +293,7 @@ func TestLocalFile(t *testing.T) {
 	tests := []struct {
 		Description         string
 		Path                string
-		Matcher             *deployconfig.Matcher
+		Matcher             *Matcher
 		MediaTypesConfig    map[string]any
 		WantContent         []byte
 		WantSize            int64
@@ -383,7 +319,7 @@ func TestLocalFile(t *testing.T) {
 		{
 			Description:      "CacheControl from matcher",
 			Path:             "foo.txt",
-			Matcher:          &deployconfig.Matcher{CacheControl: "max-age=630720000"},
+			Matcher:          &Matcher{CacheControl: "max-age=630720000"},
 			WantContent:      contentBytes,
 			WantSize:         contentLen,
 			WantMD5:          contentMD5[:],
@@ -392,7 +328,7 @@ func TestLocalFile(t *testing.T) {
 		{
 			Description:         "ContentEncoding from matcher",
 			Path:                "foo.txt",
-			Matcher:             &deployconfig.Matcher{ContentEncoding: "foobar"},
+			Matcher:             &Matcher{ContentEncoding: "foobar"},
 			WantContent:         contentBytes,
 			WantSize:            contentLen,
 			WantMD5:             contentMD5[:],
@@ -401,7 +337,7 @@ func TestLocalFile(t *testing.T) {
 		{
 			Description:     "ContentType from matcher",
 			Path:            "foo.txt",
-			Matcher:         &deployconfig.Matcher{ContentType: "foo/bar"},
+			Matcher:         &Matcher{ContentType: "foo/bar"},
 			WantContent:     contentBytes,
 			WantSize:        contentLen,
 			WantMD5:         contentMD5[:],
@@ -410,7 +346,7 @@ func TestLocalFile(t *testing.T) {
 		{
 			Description:         "gzipped content",
 			Path:                "foo.txt",
-			Matcher:             &deployconfig.Matcher{Gzip: true},
+			Matcher:             &Matcher{Gzip: true},
 			WantContent:         gzBytes,
 			WantSize:            gzLen,
 			WantMD5:             gzMD5[:],
@@ -624,7 +560,7 @@ func TestEndToEndSync(t *testing.T) {
 				localFs:    test.fs,
 				bucket:     test.bucket,
 				mediaTypes: media.DefaultTypes,
-				cfg:        deployconfig.DeployConfig{MaxDeletes: -1},
+				cfg:        DeployConfig{MaxDeletes: -1},
 			}
 
 			// Initial deployment should sync remote with local.
@@ -707,7 +643,7 @@ func TestMaxDeletes(t *testing.T) {
 				localFs:    test.fs,
 				bucket:     test.bucket,
 				mediaTypes: media.DefaultTypes,
-				cfg:        deployconfig.DeployConfig{MaxDeletes: -1},
+				cfg:        DeployConfig{MaxDeletes: -1},
 			}
 
 			// Sync remote with local.
@@ -828,16 +764,16 @@ func TestIncludeExclude(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			tgt := &deployconfig.Target{
+			tgt := &Target{
 				Include: test.Include,
 				Exclude: test.Exclude,
 			}
-			if err := tgt.ParseIncludeExclude(); err != nil {
+			if err := tgt.parseIncludeExclude(); err != nil {
 				t.Error(err)
 			}
 			deployer := &Deployer{
 				localFs: fsTest.fs,
-				cfg:     deployconfig.DeployConfig{MaxDeletes: -1}, bucket: fsTest.bucket,
+				cfg:     DeployConfig{MaxDeletes: -1}, bucket: fsTest.bucket,
 				target:     tgt,
 				mediaTypes: media.DefaultTypes,
 			}
@@ -894,7 +830,7 @@ func TestIncludeExcludeRemoteDelete(t *testing.T) {
 			}
 			deployer := &Deployer{
 				localFs: fsTest.fs,
-				cfg:     deployconfig.DeployConfig{MaxDeletes: -1}, bucket: fsTest.bucket,
+				cfg:     DeployConfig{MaxDeletes: -1}, bucket: fsTest.bucket,
 				mediaTypes: media.DefaultTypes,
 			}
 
@@ -912,11 +848,11 @@ func TestIncludeExcludeRemoteDelete(t *testing.T) {
 			}
 
 			// Second sync
-			tgt := &deployconfig.Target{
+			tgt := &Target{
 				Include: test.Include,
 				Exclude: test.Exclude,
 			}
-			if err := tgt.ParseIncludeExclude(); err != nil {
+			if err := tgt.parseIncludeExclude(); err != nil {
 				t.Error(err)
 			}
 			deployer.target = tgt
@@ -946,7 +882,7 @@ func TestCompression(t *testing.T) {
 			deployer := &Deployer{
 				localFs:    test.fs,
 				bucket:     test.bucket,
-				cfg:        deployconfig.DeployConfig{MaxDeletes: -1, Matchers: []*deployconfig.Matcher{{Pattern: ".*", Gzip: true, Re: regexp.MustCompile(".*")}}},
+				cfg:        DeployConfig{MaxDeletes: -1, Matchers: []*Matcher{{Pattern: ".*", Gzip: true, re: regexp.MustCompile(".*")}}},
 				mediaTypes: media.DefaultTypes,
 			}
 
@@ -1001,7 +937,7 @@ func TestMatching(t *testing.T) {
 			deployer := &Deployer{
 				localFs:    test.fs,
 				bucket:     test.bucket,
-				cfg:        deployconfig.DeployConfig{MaxDeletes: -1, Matchers: []*deployconfig.Matcher{{Pattern: "^subdir/aaa$", Force: true, Re: regexp.MustCompile("^subdir/aaa$")}}},
+				cfg:        DeployConfig{MaxDeletes: -1, Matchers: []*Matcher{{Pattern: "^subdir/aaa$", Force: true, re: regexp.MustCompile("^subdir/aaa$")}}},
 				mediaTypes: media.DefaultTypes,
 			}
 
@@ -1026,7 +962,7 @@ func TestMatching(t *testing.T) {
 			}
 
 			// Repeat with a matcher that should now match 3 files.
-			deployer.cfg.Matchers = []*deployconfig.Matcher{{Pattern: "aaa", Force: true, Re: regexp.MustCompile("aaa")}}
+			deployer.cfg.Matchers = []*Matcher{{Pattern: "aaa", Force: true, re: regexp.MustCompile("aaa")}}
 			if err := deployer.Deploy(ctx); err != nil {
 				t.Errorf("no-op deploy with triple force matcher: %v", err)
 			}

deploy/google.go

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build withdeploy
-// +build withdeploy
+//go:build !nodeploy
+// +build !nodeploy
 
 package deploy
 

deps/deps.go

@@ -15,15 +15,11 @@ import (
 	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/common/hexec"
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/maps"
-	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/config/security"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/identity"
-	"github.com/gohugoio/hugo/internal/warpc"
 	"github.com/gohugoio/hugo/media"
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/resources/postpub"
@@ -89,17 +85,11 @@ type Deps struct {
 	BuildEndListeners *Listeners
 
 	// Resources that gets closed when the build is done or the server shuts down.
-	BuildClosers *types.Closers
+	BuildClosers *Closers
 
 	// This is common/global for all sites.
 	BuildState *BuildState
 
-	// Holds RPC dispatchers for Katex etc.
-	// TODO(bep) rethink this re. a plugin setup, but this will have to do for now.
-	WasmDispatchers *warpc.Dispatchers
-
-	isClosed bool
-
 	*globalErrHandler
 }
 
@@ -143,15 +133,6 @@ func (d *Deps) Init() error {
 	if d.BuildState == nil {
 		d.BuildState = &BuildState{}
 	}
-	if d.BuildState.DeferredExecutions == nil {
-		if d.BuildState.DeferredExecutionsGroupedByRenderingContext == nil {
-			d.BuildState.DeferredExecutionsGroupedByRenderingContext = make(map[tpl.RenderingContext]*DeferredExecutions)
-		}
-		d.BuildState.DeferredExecutions = &DeferredExecutions{
-			Executions:              maps.NewCache[string, *tpl.DeferredExecution](),
-			FilenamesWithPostPrefix: maps.NewCache[string, bool](),
-		}
-	}
 
 	if d.BuildStartListeners == nil {
 		d.BuildStartListeners = &Listeners{}
@@ -162,7 +143,7 @@ func (d *Deps) Init() error {
 	}
 
 	if d.BuildClosers == nil {
-		d.BuildClosers = &types.Closers{}
+		d.BuildClosers = &Closers{}
 	}
 
 	if d.Metrics == nil && d.Conf.TemplateMetrics() {
@@ -170,37 +151,28 @@ func (d *Deps) Init() error {
 	}
 
 	if d.ExecHelper == nil {
-		d.ExecHelper = hexec.New(d.Conf.GetConfigSection("security").(security.Config), d.Conf.WorkingDir())
+		d.ExecHelper = hexec.New(d.Conf.GetConfigSection("security").(security.Config))
 	}
 
 	if d.MemCache == nil {
-		d.MemCache = dynacache.New(dynacache.Options{Watching: d.Conf.Watching(), Log: d.Log})
+		d.MemCache = dynacache.New(dynacache.Options{Running: d.Conf.Running(), Log: d.Log})
 	}
 
 	if d.PathSpec == nil {
-		hashBytesReceiverFunc := func(name string, match []byte) {
-			s := string(match)
-			switch s {
-			case postpub.PostProcessPrefix:
-				d.BuildState.AddFilenameWithPostPrefix(name)
-			case tpl.HugoDeferredTemplatePrefix:
-				d.BuildState.DeferredExecutions.FilenamesWithPostPrefix.Set(name, true)
+		hashBytesReceiverFunc := func(name string, match bool) {
+			if !match {
+				return
 			}
+			d.BuildState.AddFilenameWithPostPrefix(name)
 		}
 
 		// Skip binary files.
 		mediaTypes := d.Conf.GetConfigSection("mediaTypes").(media.Types)
-		hashBytesShouldCheck := func(name string) bool {
+		hashBytesSHouldCheck := func(name string) bool {
 			ext := strings.TrimPrefix(filepath.Ext(name), ".")
 			return mediaTypes.IsTextSuffix(ext)
 		}
-		d.Fs.PublishDir = hugofs.NewHasBytesReceiver(
-			d.Fs.PublishDir,
-			hashBytesShouldCheck,
-			hashBytesReceiverFunc,
-			[]byte(tpl.HugoDeferredTemplatePrefix),
-			[]byte(postpub.PostProcessPrefix))
-
+		d.Fs.PublishDir = hugofs.NewHasBytesReceiver(d.Fs.PublishDir, hashBytesSHouldCheck, hashBytesReceiverFunc, []byte(postpub.PostProcessPrefix))
 		pathSpec, err := helpers.NewPathSpec(d.Fs, d.Conf, d.Log)
 		if err != nil {
 			return err
@@ -236,7 +208,7 @@ func (d *Deps) Init() error {
 		return fmt.Errorf("failed to create file caches from configuration: %w", err)
 	}
 
-	resourceSpec, err := resources.NewSpec(d.PathSpec, common, fileCaches, d.MemCache, d.BuildState, d.Log, d, d.ExecHelper, d.BuildClosers, d.BuildState)
+	resourceSpec, err := resources.NewSpec(d.PathSpec, common, fileCaches, d.MemCache, d.BuildState, d.Log, d, d.ExecHelper)
 	if err != nil {
 		return fmt.Errorf("failed to create resource spec: %w", err)
 	}
@@ -347,17 +319,9 @@ func (d *Deps) TextTmpl() tpl.TemplateParseFinder {
 }
 
 func (d *Deps) Close() error {
-	if d.isClosed {
-		return nil
-	}
-	d.isClosed = true
-
 	if d.MemCache != nil {
 		d.MemCache.Stop()
 	}
-	if d.WasmDispatchers != nil {
-		d.WasmDispatchers.Close()
-	}
 	return d.BuildClosers.Close()
 }
 
@@ -389,9 +353,6 @@ type DepsCfg struct {
 
 	// i18n handling.
 	TranslationProvider ResourceProvider
-
-	// ChangesFromBuild for changes passed back to the server/watch process.
-	ChangesFromBuild chan []identity.Identity
 }
 
 // BuildState are state used during a build.
@@ -400,44 +361,9 @@ type BuildState struct {
 
 	mu sync.Mutex // protects state below.
 
-	OnSignalRebuild func(ids ...identity.Identity)
-
-	// A set of filenames in /public that
+	// A set of ilenames in /public that
 	// contains a post-processing prefix.
 	filenamesWithPostPrefix map[string]bool
-
-	DeferredExecutions *DeferredExecutions
-
-	// Deferred executions grouped by rendering context.
-	DeferredExecutionsGroupedByRenderingContext map[tpl.RenderingContext]*DeferredExecutions
-}
-
-type DeferredExecutions struct {
-	// A set of filenames in /public that
-	// contains a post-processing prefix.
-	FilenamesWithPostPrefix *maps.Cache[string, bool]
-
-	// Maps a placeholder to a deferred execution.
-	Executions *maps.Cache[string, *tpl.DeferredExecution]
-}
-
-var _ identity.SignalRebuilder = (*BuildState)(nil)
-
-// StartStageRender will be called before a stage is rendered.
-func (b *BuildState) StartStageRender(stage tpl.RenderingContext) {
-}
-
-// StopStageRender will be called after a stage is rendered.
-func (b *BuildState) StopStageRender(stage tpl.RenderingContext) {
-	b.DeferredExecutionsGroupedByRenderingContext[stage] = b.DeferredExecutions
-	b.DeferredExecutions = &DeferredExecutions{
-		Executions:              maps.NewCache[string, *tpl.DeferredExecution](),
-		FilenamesWithPostPrefix: maps.NewCache[string, bool](),
-	}
-}
-
-func (b *BuildState) SignalRebuild(ids ...identity.Identity) {
-	b.OnSignalRebuild(ids...)
 }
 
 func (b *BuildState) AddFilenameWithPostPrefix(filename string) {
@@ -463,3 +389,30 @@ func (b *BuildState) GetFilenamesWithPostPrefix() []string {
 func (b *BuildState) Incr() int {
 	return int(atomic.AddUint64(&b.counter, uint64(1)))
 }
+
+type Closer interface {
+	Close() error
+}
+
+type Closers struct {
+	mu sync.Mutex
+	cs []Closer
+}
+
+func (cs *Closers) Add(c Closer) {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+	cs.cs = append(cs.cs, c)
+}
+
+func (cs *Closers) Close() error {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+	for _, c := range cs.cs {
+		c.Close()
+	}
+
+	cs.cs = cs.cs[:0]
+
+	return nil
+}

docs/.cspell.json

@@ -20,11 +20,13 @@
   ],
   "ignoreRegExpList": [
     "# cspell: ignore fenced code blocks",
-    "^(\\s*`{3,}).*[\\s\\S]*?^\\1$",
+    "^(\\s*`{3,}).*[\\s\\S]*?^\\1",
     "# cspell: ignore words joined with dot",
     "\\w+\\.\\w+",
     "# cspell: ignore strings within backticks",
     "`.+`",
+    "# cspell: ignore strings within single quotes",
+    "'.+'",
     "# cspell: ignore strings within double quotes",
     "\".+\"",
     "# cspell: ignore strings within brackets",
@@ -40,11 +42,14 @@
   ],
   "language": "en",
   "words": [
+    "antialiasing",
+    "codeowners",
     "composability",
     "configurators",
     "defang",
     "deindent",
     "downscale",
+    "downscaled",
     "downscaling",
     "exif",
     "geolocalized",
@@ -52,101 +57,59 @@
     "marshal",
     "marshaling",
     "multihost",
-    "multiplatfom",
     "performantly",
     "preconfigured",
     "prerendering",
     "redirection",
     "redirections",
+    "shortcode",
+    "shortcodes",
     "subexpression",
-    "suppressible",
+    "subexpressions",
+    "suppressable",
     "templating",
     "transpile",
+    "transpiles",
     "unmarshal",
-    "unmarshaling",
     "unmarshals",
-    "# ----------------------------------------------------------------------",
-    "# cspell: ignore hugo terminology",
-    "# ----------------------------------------------------------------------",
-    "attrlink",
-    "canonify",
-    "codeowners",
-    "dynacache",
-    "eturl",
-    "getenv",
-    "gohugo",
-    "gohugoio",
-    "keyvals",
-    "leftdelim",
-    "linkify",
-    "numworkermultiplier",
-    "rightdelim",
-    "shortcode",
-    "stringifier",
-    "struct",
-    "toclevels",
-    "zgotmplz",
+    "unmarshaling",
     "# ----------------------------------------------------------------------",
     "# cspell: ignore foreign language words",
     "# ----------------------------------------------------------------------",
     "bezpieczeństwo",
-    "blatt",
-    "buch",
-    "descripción",
     "dokumentation",
-    "erklärungen",
     "libros",
-    "mercredi",
     "miesiąc",
     "miesiąc",
-    "miesiąca",
-    "miesiące",
+    "miesięcy",
     "miesięcy",
     "misérables",
-    "mittwoch",
-    "muchos",
-    "novembre",
-    "otro",
-    "pocos",
-    "produkte",
     "projekt",
-    "prywatność",
-    "referenz",
     "régime",
     "# ----------------------------------------------------------------------",
-    "# cspell: ignore names",
+    "# cspell: ignore proper nouns",
     "# ----------------------------------------------------------------------",
-    "Atishay",
-    "Cosette",
     "Eliott",
-    "Furet",
     "Gregor",
     "Jaco",
-    "Lanczos",
-    "Ninke",
     "Noll",
     "Pastorius",
     "Samsa",
-    "Stucki",
-    "Thénardier",
     "# ----------------------------------------------------------------------",
     "# cspell: ignore operating systems and software packages",
     "# ----------------------------------------------------------------------",
     "asciidoctor",
     "brotli",
-    "cifs",
     "corejs",
     "disqus",
-    "docutils",
-    "dpkg",
     "doas",
     "eopkg",
     "gitee",
     "goldmark",
-    "katex",
+    "KaTeX",
     "kubuntu",
     "lubuntu",
-    "mathjax",
+    "MathJax",
     "nosql",
     "pandoc",
     "pkgin",
@@ -155,19 +118,21 @@
     "# ----------------------------------------------------------------------",
     "# cspell: ignore miscellaneous",
     "# ----------------------------------------------------------------------",
-    "achristie",
-    "ddmaurier",
     "dring",
+    "getenv",
+    "gohugo",
     "inor",
-    "jausten",
     "jdoe",
-    "jsmith",
     "milli",
     "rgba",
     "rsmith",
+    "stringifier",
+    "struct",
     "tdewolff",
     "tjones",
-    "wcag",
-    "xfeff"
+    "toclevels",
+    "vals",
+    "xfeff",
+    "zgotmplz"
   ]
 }

docs/.github/workflows/codeql-analysis.yml

@@ -18,9 +18,9 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v2
         with:
           languages: "javascript"
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v2

docs/.github/workflows/super-linter.yml

@@ -21,7 +21,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Lint Code Base
-        uses: super-linter/super-linter/slim@v6
+        uses: super-linter/super-linter/slim@v5
         env:
           DEFAULT_BRANCH: master
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

docs/README.md

@@ -1,20 +1,56 @@
-<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].
-
----
-
 [![Netlify Status](https://api.netlify.com/api/v1/badges/e0dbbfc7-34f1-4393-a679-c16e80162705/deploy-status)](https://app.netlify.com/sites/gohugoio/deploys)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://gohugo.io/contribute/documentation/)
 
-This is the repository for the [Hugo](https://github.com/gohugoio/hugo) documentation site. 
+# Hugo Docs
 
-Please see the [contributing] section for guidelines, examples, and process.
+Documentation site for [Hugo](https://github.com/gohugoio/hugo), the very fast and flexible static site generator built with love in Go.
 
+## Contributing
 
+We welcome contributions to Hugo of any kind including documentation, suggestions, bug reports, pull requests etc. Also check out our [contribution guide](https://gohugo.io/contribute/documentation/). We would love to hear from you.
 
-[bep]: https://github.com/bep
-[spf13]: https://github.com/spf13
-[friends]: https://github.com/gohugoio/hugo/graphs/contributors
-[go]: https://go.dev/
-[contributing]: https://gohugo.io/contribute/documentation
+Note that this repository contains solely the documentation for Hugo. For contributions that aren't documentation-related please refer to the [hugo](https://github.com/gohugoio/hugo) repository.
+
+*Pull requests shall **only** contain changes to the actual documentation. However, changes on the codebase of Hugo **and** the documentation shall be a single, atomic pull request in the [hugo](https://github.com/gohugoio/hugo) repository.*
+
+Spelling fixes are most welcomed, and if you want to contribute longer sections to the documentation, it would be great if you had the following criteria in mind when writing:
+
+* Short is good. People go to the library to read novels. If there is more than one way to _do a thing_ in Hugo, describe the current _best practice_ (avoid "… but you can also do …" and "… in older versions of Hugo you had to …".
+* For example, try to find short snippets that teaches people about the concept. If the example is also useful as-is (copy and paste), then great. Don't list long and similar examples just so people can use them on their sites.
+* Hugo has users from all over the world, so easy to understand and [simple English](https://simple.wikipedia.org/wiki/Basic_English) is good.
+
+## Edit the theme
+
+If you want to do docs-related theme changes, the simplest way is to have both `hugoDocs` and `gohugoioTheme` cloned as sibling directories, and then run:
+
+```sh
+HUGO_MODULE_WORKSPACE=hugo.work hugo server --ignoreVendorPaths "**"
+```
+
+## Branches
+
+* The `master` branch is where the site is automatically built from, and is the place to put changes relevant to the current Hugo version.
+* The `next` branch is where we store changes that are related to the next Hugo release. This can be previewed here: https://next--gohugoio.netlify.com/
+
+## Build
+
+To view the documentation site locally, you need to clone this repository:
+
+```sh
+git clone https://github.com/gohugoio/hugoDocs.git
+```
+
+Also note that the documentation version for a given version of Hugo can also be found in the `/docs` sub-folder of the [Hugo source repository](https://github.com/gohugoio/hugo).
+
+Then to view the docs in your browser, run Hugo and open up the link:
+
+```sh
+▶ hugo server
+
+Started building sites ...
+.
+.
+Serving pages from memory
+Web Server is available at http://localhost:1313/ (bind address 127.0.0.1)
+Press Ctrl+C to stop
+```

docs/_vendor/github.com/gohugoio/gohugoioTheme/assets/images/sponsors/Route4MeLogoBlueOnWhite.svg

@@ -1,15 +0,0 @@
-<svg width="150" height="36" viewBox="0 0 150 36" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M38.9337 13.4895H41.1147C41.4378 13.4895 41.8417 13.4895 42.1648 13.4895C42.5686 13.4895 42.8917 13.4087 43.2148 13.2472C43.5379 13.0856 43.7803 12.9241 43.9418 12.6818C44.1034 12.4394 44.2649 12.0355 44.2649 11.6317C44.2649 11.2278 44.1841 10.8239 44.0226 10.5816C43.861 10.3393 43.6187 10.0969 43.3764 10.0162C43.1341 9.85461 42.811 9.77384 42.4879 9.77384C42.1648 9.69306 41.7609 9.69306 41.4378 9.69306H39.0145V13.4895H38.9337ZM35.2181 6.46204H41.7609C42.6494 6.46204 43.4572 6.54282 44.1841 6.70437C44.9919 6.86592 45.6381 7.18902 46.2035 7.51212C46.769 7.916 47.2536 8.40065 47.5767 9.12763C47.8998 9.77384 48.0614 10.6624 48.0614 11.6317C48.0614 12.8433 47.7383 13.8934 47.0921 14.7011C46.4459 15.5089 45.5573 16.0743 44.3457 16.3166L48.6268 23.5057H44.1841L40.63 16.7205H38.7722V23.5057H35.0565V6.46204H35.2181Z" fill="#425277"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M53.3926 17.6091C53.3926 18.4976 53.6349 19.2246 54.1195 19.79C54.6042 20.3554 55.3312 20.5977 56.2197 20.5977C57.1082 20.5977 57.8352 20.3554 58.3199 19.79C58.8045 19.2246 59.0468 18.4976 59.0468 17.6091C59.0468 16.7205 58.8045 15.9935 58.3199 15.4281C57.8352 14.8627 57.1082 14.6204 56.2197 14.6204C55.3312 14.6204 54.6042 14.8627 54.1195 15.4281C53.6349 16.0743 53.3926 16.7205 53.3926 17.6091ZM49.8384 17.6091C49.8384 16.6397 50 15.832 50.3231 15.105C50.6462 14.378 51.1308 13.7318 51.6963 13.1664C52.2617 12.601 52.9887 12.1971 53.7157 11.9548C54.5234 11.6317 55.3312 11.5509 56.2197 11.5509C57.1082 11.5509 57.916 11.7124 58.7237 11.9548C59.5315 12.2779 60.1777 12.6818 60.7431 13.1664C61.3086 13.7318 61.7932 14.378 62.1163 15.105C62.4394 15.832 62.601 16.7205 62.601 17.6091C62.601 18.5784 62.4394 19.3861 62.1163 20.1131C61.7932 20.8401 61.3086 21.4863 60.7431 22.0517C60.1777 22.6171 59.4507 23.021 58.7237 23.2633C57.916 23.5864 57.1082 23.6672 56.2197 23.6672C55.3312 23.6672 54.5234 23.5057 53.7157 23.2633C52.9079 22.9402 52.2617 22.5364 51.6963 22.0517C51.1308 21.4863 50.6462 20.8401 50.3231 20.1131C50 19.3861 49.8384 18.5784 49.8384 17.6091Z" fill="#425277"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M75.929 23.5057H72.4556V21.8902H72.3748C72.2133 22.1325 72.0517 22.3748 71.8902 22.5364C71.7286 22.7787 71.4863 22.9403 71.1632 23.1826C70.8401 23.3441 70.517 23.5057 70.1939 23.5865C69.79 23.6672 69.4669 23.748 68.9823 23.748C68.0937 23.748 67.3668 23.5865 66.8013 23.3441C66.2359 23.1018 65.832 22.6979 65.5089 22.2133C65.1858 21.7286 65.0243 21.1632 64.8627 20.4362C64.782 19.79 64.7012 19.063 64.7012 18.2553V11.7932H68.2553V17.5283C68.2553 17.8514 68.2553 18.1745 68.2553 18.5784C68.2553 18.9015 68.3361 19.3054 68.4976 19.5477C68.6592 19.79 68.8207 20.1131 69.063 20.2747C69.3054 20.4362 69.6285 20.5978 70.1131 20.5978C70.5978 20.5978 70.9209 20.517 71.244 20.3554C71.5671 20.1939 71.7286 19.9516 71.8902 19.7092C72.0517 19.4669 72.1325 19.1438 72.2133 18.7399C72.2941 18.4168 72.2941 18.013 72.2941 17.6091V11.7932H75.929V23.5057Z" fill="#425277"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M86.3489 14.7011H83.1987V18.5784C83.1987 18.9015 83.1987 19.2246 83.2794 19.4669C83.2794 19.7092 83.3602 19.9515 83.5218 20.1131C83.6026 20.2746 83.7641 20.4362 84.0064 20.5977C84.2488 20.6785 84.5719 20.7593 84.895 20.7593C85.0565 20.7593 85.2988 20.7593 85.6219 20.6785C85.945 20.6785 86.1874 20.517 86.3489 20.4362V23.4249C85.945 23.5864 85.5412 23.6672 85.1373 23.748C84.7334 23.8288 84.2488 23.8288 83.8449 23.8288C83.2795 23.8288 82.714 23.748 82.1486 23.6672C81.6639 23.5057 81.1793 23.3441 80.7754 23.021C80.3715 22.7787 80.1292 22.3748 79.8869 21.8902C79.6446 21.4055 79.5638 20.9208 79.5638 20.2746V14.7011H77.3021V11.7932H79.5638V8.31988H83.1179V11.7932H86.2681V14.7011H86.3489Z" fill="#425277"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M96.1228 16.3166C96.1228 15.6704 95.9612 15.1858 95.5573 14.7819C95.1535 14.378 94.588 14.1357 93.9418 14.1357C93.5379 14.1357 93.2148 14.2165 92.8917 14.2973C92.5686 14.4588 92.3263 14.6204 92.084 14.7819C91.8417 15.0242 91.6801 15.1858 91.5993 15.5089C91.5186 15.7512 91.4378 16.0743 91.357 16.3166H96.1228ZM99.1922 21.4863C98.6268 22.2133 97.8998 22.7787 97.0113 23.1826C96.1228 23.5864 95.2342 23.748 94.2649 23.748C93.3764 23.748 92.5686 23.5864 91.7609 23.3441C90.9531 23.021 90.3069 22.6171 89.7415 22.1325C89.1761 21.567 88.6914 20.9208 88.3683 20.1939C88.0452 19.4669 87.8837 18.5784 87.8837 17.6898C87.8837 16.7205 88.0452 15.9128 88.3683 15.1858C88.6914 14.4588 89.1761 13.8126 89.7415 13.2472C90.3069 12.6817 91.0339 12.2779 91.7609 12.0355C92.5686 11.7124 93.3764 11.6317 94.2649 11.6317C95.0727 11.6317 95.8804 11.7932 96.5266 12.0355C97.1728 12.3586 97.7383 12.7625 98.2229 13.2472C98.7076 13.8126 99.0307 14.4588 99.273 15.1858C99.5153 15.9128 99.6769 16.8013 99.6769 17.6898V18.8207H91.357C91.5186 19.5477 91.8417 20.0323 92.3263 20.4362C92.811 20.8401 93.3764 21.0824 94.1034 21.0824C94.6688 21.0824 95.1535 20.9208 95.5573 20.6785C95.9612 20.4362 96.2843 20.0323 96.6074 19.6284L99.1922 21.4863Z" fill="#425277"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M108.562 11.147L104.766 17.0436H108.562V11.147ZM108.562 20.1131H101.212V17.0436L108.078 6.46205H111.955V17.0436H114.136V20.1131H111.955V23.5057H108.481V20.1131H108.562Z" fill="#FFC63C"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M116.478 6.46205H122.052L126.01 17.6091L129.968 6.46205H135.541V23.5057H131.826V10.42H131.745L127.302 23.5057H124.475L120.194 10.42V23.5057H116.478V6.46205Z" fill="#425277"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M146.446 16.3166C146.446 15.6704 146.284 15.1858 145.88 14.7819C145.477 14.378 144.911 14.1357 144.265 14.1357C143.861 14.1357 143.538 14.2165 143.215 14.2973C142.892 14.4588 142.649 14.6204 142.407 14.7819C142.165 15.0242 142.003 15.1858 141.922 15.5089C141.842 15.7512 141.761 16.0743 141.68 16.3166H146.446ZM149.515 21.4863C148.95 22.2133 148.223 22.7787 147.334 23.1826C146.446 23.5864 145.557 23.748 144.588 23.748C143.7 23.748 142.892 23.5864 142.084 23.3441C141.276 23.021 140.63 22.6171 140.065 22.1325C139.499 21.567 139.015 20.9208 138.691 20.1939C138.368 19.4669 138.207 18.5784 138.207 17.6898C138.207 16.7205 138.368 15.9128 138.691 15.1858C139.015 14.4588 139.499 13.8126 140.065 13.2472C140.63 12.6817 141.357 12.2779 142.084 12.0355C142.892 11.7124 143.7 11.6317 144.588 11.6317C145.396 11.6317 146.204 11.7932 146.85 12.0355C147.496 12.3586 148.061 12.7625 148.546 13.2472C149.031 13.8126 149.354 14.4588 149.596 15.1858C149.838 15.9128 150 16.8013 150 17.6898V18.8207H141.68C141.842 19.5477 142.165 20.0323 142.649 20.4362C143.134 20.8401 143.7 21.0824 144.426 21.0824C144.992 21.0824 145.477 20.9208 145.88 20.6785C146.284 20.4362 146.607 20.0323 146.931 19.6284L149.515 21.4863Z" fill="#425277"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M28.1906 1.53473C28.1906 0.646204 28.9176 0 29.7253 0C30.6139 0 31.2601 0.726979 31.2601 1.53473C31.2601 2.42326 30.5331 3.06947 29.7253 3.06947C28.9176 3.15024 28.1906 2.42326 28.1906 1.53473Z" fill="#FF6400"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M0 1.53473C0 0.726979 0.726979 0 1.53473 0C2.42326 0 3.15024 0.726979 3.15024 1.53473C3.15024 2.42326 2.42326 3.15024 1.53473 3.15024C0.726979 3.15024 0 2.42326 0 1.53473Z" fill="#FF6400"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M22.2941 33.6834C22.2941 32.7948 23.021 32.1486 23.8288 32.1486C24.7173 32.1486 25.3635 32.8756 25.3635 33.6834C25.3635 34.5719 24.6366 35.2181 23.8288 35.2181C23.021 35.2181 22.2941 34.5719 22.2941 33.6834Z" fill="#FF6400"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M20.0323 6.62363C20.2746 6.86595 20.2746 7.18906 20.0323 7.35061L17.3667 10.0162C17.1244 10.2585 17.2051 10.4201 17.5283 10.5816C19.063 11.1471 20.2746 12.3587 20.7593 13.8126C20.84 14.055 21.0824 14.1357 21.3247 13.9742L23.9903 11.3086C24.2326 11.0663 24.5557 11.0663 24.7173 11.3086L27.0598 13.6511C27.3021 13.8934 27.4636 13.8126 27.4636 13.4895V4.20036C27.4636 4.03881 27.3829 3.95804 27.2213 3.95804H17.8514C17.5282 3.95804 17.5282 4.11959 17.6898 4.36191L20.0323 6.62363ZM13.7318 10.5008C13.9741 10.4201 14.0549 10.1777 13.8934 9.93542L11.2278 7.26983C10.9854 7.0275 10.9854 6.7044 11.2278 6.54285L13.5703 4.20036C13.8126 3.95804 13.7318 3.79649 13.4087 3.79649H4.2003C4.03875 3.95804 3.8772 4.03881 3.8772 4.20036V13.4895C3.8772 13.8126 4.03875 13.8126 4.28107 13.6511L6.62356 11.3086C6.86589 11.0663 7.18899 11.0663 7.35054 11.3086L10.0161 13.9742C10.2585 14.2165 10.42 14.1357 10.5816 13.8126C11.0662 12.2779 12.2778 11.0663 13.7318 10.5008ZM15.9127 21.1632C15.5896 21.1632 15.5089 21.4055 15.5896 21.6479L17.1244 25.0404C17.2051 25.2828 17.1244 25.6059 16.882 25.7674L13.8934 27.1406C13.651 27.3021 13.651 27.4637 13.8934 27.5445L22.6171 30.6947C22.7787 30.7755 22.9402 30.6947 22.9402 30.5332L26.1712 21.8094C26.252 21.5671 26.1712 21.4055 25.8481 21.5671L22.8594 22.9403C22.6171 23.1018 22.294 22.9403 22.1324 22.6979L20.4362 19.063C20.3554 18.8207 20.1131 18.8207 19.9515 18.9823C19.4669 19.6285 18.8207 20.1939 18.0129 20.5978C17.5282 20.8401 16.882 21.0017 16.3166 21.0824C16.3166 21.0824 16.0743 21.1632 15.9127 21.1632Z" fill="#FFC63C"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M11.7124 15.6705C11.7124 13.4895 13.4895 11.7932 15.5896 11.7932C17.7706 11.7932 19.4668 13.5703 19.4668 15.6705C19.4668 17.8514 17.6898 19.6285 15.5896 19.6285C13.4895 19.5477 11.7124 17.8514 11.7124 15.6705Z" fill="#FF6400"/>
-</svg>

docs/_vendor/github.com/gohugoio/gohugoioTheme/data/sponsors.toml

@@ -6,13 +6,13 @@
     bgcolor      = "#ffffff"
 
 [[banners]]
-    name            = "Route4Me"
-    link            = "https://route4me.com/"
-    title           = "Route Planning & Route Optimization Software"
-    no_query_params = true
-    utm_campaign    = "hugosponsor"
-    bgcolor         = "#334799"
-    link_attr       = "style='color: #ffffff; font-weight: bold; text-decoration: none; text-align: center'"
+    name         = "CloudCannon"
+    link         = "https://cloudcannon.com/hugo-cms/"
+    logo         = "/images/sponsors/cloudcannon-white.svg"
+    utm_campaign = "HugoSponsorship"
+    utm_source   = "sponsor"
+    utm_content  = "gohugo"
+    bgcolor      = "#034AD8"
 
 [[banners]]
     name          = "Your Company?"
@@ -20,4 +20,3 @@
     utm_campaign  = "hugosponsor"
     show_on_hover = true
     bgcolor       = "#4e4f4f"
-    link_attr     = "style='color: #ffffff; font-weight: bold; text-decoration: none; text-align: center'"

docs/_vendor/github.com/gohugoio/gohugoioTheme/layouts/_default/_markup/render-link.html

@@ -1,4 +1,4 @@
-{{- /* Last modified: 2024-04-26T13:54:00-07:00 */}}
+{{- /* Last modified: 2023-09-04T09:23:04-07:00 */}}
 
 {{- /*
 Copyright 2023 Veriphor LLC
@@ -118,7 +118,7 @@ either of these shortcodes in conjunction with this render hook.
   {{- $attrs = merge $attrs (dict "rel" "external") }}
 {{- else }}
   {{- with $u.Path }}
-    {{- with $p := or ($.PageInner.GetPage .) ($.PageInner.GetPage (strings.TrimRight "/" .)) }}
+    {{- with $p := or ($.Page.GetPage .) ($.Page.GetPage (strings.TrimRight "/" .)) }}
       {{- /* Destination is a page. */}}
       {{- $href := .RelPermalink }}
       {{- with $u.RawQuery }}
@@ -137,7 +137,7 @@ either of these shortcodes in conjunction with this render hook.
       {{- end }}
       {{- $attrs = dict "href" $href }}
     {{- else }}
-      {{- with $.PageInner.Resources.Get $u.Path }}
+      {{- with $.Page.Resources.Get $u.Path }}
         {{- /* Destination is a page resource; drop query and fragment. */}}
         {{- $attrs = dict "href" .RelPermalink }}
       {{- else }}
@@ -185,14 +185,14 @@ either of these shortcodes in conjunction with this render hook.
     {{- end }}
   {{- end }}
 {{- end }}
-{{- $attrs = merge $attrs (dict "title" (.Title | transform.HTMLEscape)) }}
+{{- with .Title }}
+  {{- $attrs = merge $attrs (dict "title" .) }}
+{{- end -}}
 
 {{- /* Render anchor element. */ -}}
 <a
   {{- range $k, $v := $attrs }}
-    {{- if $v }}
-      {{- printf " %s=%q" $k $v | safeHTMLAttr }}
-    {{- end }}
+    {{- printf " %s=%q" $k $v | safeHTMLAttr }}
   {{- end -}}
 >{{ .Text | safeHTML }}</a>
 

docs/_vendor/github.com/gohugoio/gohugoioTheme/layouts/_default/baseof.html

@@ -1,4 +1,4 @@
-<!doctype html>
+<!DOCTYPE html>
 <html
   class="no-js"
   lang="{{ with $.Site.LanguageCode }}
@@ -98,8 +98,7 @@
       {{ partial "gtag.html" . }}
     {{ end }}
 
-    {{ $hasMath := .Param "math" }}
-    {{ if $hasMath }}
+    {{ if .Param "math" }}
       {{ partialCached "math.html" . }}
     {{ end }}
 
@@ -108,7 +107,7 @@
   <body
     class="ma0 sans-serif bg-primary-color-light{{ with getenv "HUGO_ENV" }}
       {{ . }}
-    {{ end }} {{ if $hasMath }}{{ print " dn" }}{{ end }}">
+    {{ end }}">
     {{ partial "hooks/after-body-start.html" . }}
     {{ block "nav" . }}{{ partial "site-nav.html" . }}{{ end }}
     {{ block "header" . }}{{ end }}

docs/_vendor/github.com/gohugoio/gohugoioTheme/layouts/_default/documentation-home.html

@@ -1,4 +1,4 @@
 {{ define "main" }}
-{{ $section_to_display := (.Site.Taxonomies.categories.fundamentals).Pages | lang.Merge (.Sites.Default.Taxonomies.categories.fundamentals).Pages }}
+{{ $section_to_display := (.Site.Taxonomies.categories.fundamentals).Pages | lang.Merge (.Sites.First.Taxonomies.categories.fundamentals).Pages }}
   {{ partial "pagelayout.html" (dict "context" . "section_to_display" $section_to_display ) }}
 {{ end }}