deploy: walkLocal worker pool for performance

releaser: Prepare repository for 0.148.0-DEV
[ci skip]
2025-06-30 12:49:53 +00:00 · 2025-06-29 16:41:56 +02:00 · 2025-06-23 08:38:21 +00:00 · 2025-06-23 08:22:20 +00:00 · 2025-06-22 16:55:43 +02:00 · 2025-06-21 14:38:06 +02:00
2170 changed files with 42052 additions and 39398 deletions
--- a/.circleci/config.yml
+++ b/.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.22400.20000
 environment: &buildenv
      GOMODCACHE: /root/project/gomodcache
 version: 2
@ -58,7 +58,7 @@ jobs:
    environment:
        <<: [*buildenv]
    docker:
-    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22300.20200
+    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22400.20000
    steps:
      - *restore-cache
      - &attach-workspace
--- a/.github/workflows/image.yml
+++ b/.github/workflows/image.yml
@ -46,3 +46,4 @@ jobs:
          platforms: linux/amd64,linux/arm64
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
+          build-args: HUGO_BUILD_TAGS=extended,withdeploy
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@ -16,7 +16,7 @@ jobs:
  test:
    strategy:
      matrix:
-        go-version: [1.22.x, 1.23.x]
+        go-version: [1.23.x, 1.24.x]
        os: [ubuntu-latest, windows-latest] # macos disabled for now because of disk space issues.
    runs-on: ${{ matrix.os }}
    steps:
--- a/.gitignore
+++ b/.gitignore
@ -3,3 +3,4 @@
 imports.*
 dist/
 public/
+.DS_Store 
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -1,4 +1,4 @@
->**Note:** We would apprecitate if you hold on with any big refactorings (like renaming deprecated Go packages), mainly because of potential for extra merge work for future coming in in the near future.
+>**Note:** We would appreciate if you hold on with any big refactoring (like renaming deprecated Go packages), mainly because of potential for extra merge work for future coming in in the near future.

 # Contributing to Hugo

@ -93,6 +93,7 @@ Most title/subjects should have a lower-cased prefix with a colon and one whites
 * If this commit touches many packages without a common functional topic, prefix with `all:` (e.g. `all: Reformat Go code`)
 * If this is a documentation update, prefix with `docs:`.
 * If nothing of the above applies, just leave the prefix out.
+* Note that the above excludes nouns seen in other repositories, e.g. "chore:".

 Also, if your commit references one or more GitHub issues, always end your commit message body with *See #1234* or *Fixes #1234*.
 Replace *1234* with the GitHub issue ID. The last example will close the issue when the commit is merged into *master*.
--- a/8
+++ b/8
@ -2,8 +2,8 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/

-ARG GO_VERSION="1.23.2"
-ARG ALPINE_VERSION="3.20"
+ARG GO_VERSION="1.24"
+ARG ALPINE_VERSION="3.22"
 ARG DART_SASS_VERSION="1.79.3"

 FROM --platform=$BUILDPLATFORM tonistiigi/xx:1.5.0 AS xx
@ -19,7 +19,7 @@ RUN apk add clang lld
 COPY --from=xx / /

 ARG TARGETPLATFORM
-RUN xx-apk add musl-dev gcc g++ 
+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 .
@ -72,7 +72,7 @@ RUN mkdir -p /var/hugo/bin /cache && \
    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 && \ 
+    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

--- a/README.md
+++ b/README.md
@ -34,6 +34,7 @@ A fast and flexible static site generator built with love by [bep], [spf13], and
 [![Go Report Card](https://goreportcard.com/badge/github.com/gohugoio/hugo)](https://goreportcard.com/report/github.com/gohugoio/hugo)

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

 Hugo is a [static site generator] written in [Go], optimized for speed and designed for flexibility. With its advanced templating system and fast asset pipelines, Hugo renders a complete site in seconds, often less.
@ -64,13 +65,30 @@ See the [features] section of the documentation for a comprehensive summary of H

 <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>
+  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/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>
+  <a href="https://www.jetbrains.com/go/?utm_source=OSS&utm_medium=referral&utm_campaign=hugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/goland.svg" width="200" alt="The complete IDE crafted for professional Go developers."></a>
  &nbsp;&nbsp;&nbsp;
-  <a href="https://www.jetbrains.com/go/?utm_source=OSS&utm_medium=referral&utm_campaign=hugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/goland.svg" width="200" alt="The complete IDE crafted for professional Go developers."></a>
+  <a href="https://pinme.eth.limo/?s=hugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/logo-pinme.svg" width="200" alt="PinMe."></a>
 </p>

+## Editions
+
+Hugo is available in three editions: standard, extended, and extended/deploy. While the standard edition provides core functionality, the extended and extended/deploy editions offer advanced features.
+
+Feature|extended edition|extended/deploy edition
+:--|:-:|:-:
+Encode to the WebP format when [processing images]. You can decode WebP images with any edition.|:heavy_check_mark:|:heavy_check_mark:
+[Transpile Sass to CSS] using the embedded LibSass transpiler. You can use the [Dart Sass] transpiler with any edition.|:heavy_check_mark:|:heavy_check_mark:
+Deploy your site directly to a Google Cloud Storage bucket, an AWS S3 bucket, or an Azure Storage container. See&nbsp;[details].|:x:|:heavy_check_mark:
+
+[dart sass]: https://gohugo.io/functions/css/sass/#dart-sass
+[processing images]: https://gohugo.io/content-management/image-processing/
+[transpile sass to css]: https://gohugo.io/functions/css/sass/
+[details]: https://gohugo.io/hosting-and-deployment/hugo-deploy/
+
+Unless your specific deployment needs require the extended/deploy edition, we recommend the extended edition.
+
 ## Installation

 Install Hugo from a [prebuilt binary], package manager, or package repository. Please see the installation instructions for your operating system:
@ -82,15 +100,11 @@ Install Hugo from a [prebuilt binary], package manager, or package repository. P

 ## Build from source

-Hugo is available in two editions: standard and extended. With the extended edition you can:
-
- Encode to the WebP format when processing images. You can decode WebP images with either edition.
- Transpile Sass to CSS using the embedded LibSass transpiler. The extended edition is not required to use the Dart Sass transpiler.
-
 Prerequisites to build Hugo from source:

- Standard edition: Go 1.20 or later
- Extended edition: Go 1.20 or later, and GCC
+- Standard edition: Go 1.23.0 or later
+- Extended edition: Go 1.23.0 or later, and GCC
+- Extended/deploy edition: Go 1.23.0 or later, and GCC

 Build the standard edition:

@ -103,6 +117,13 @@ Build the extended edition:
 ```text
 CGO_ENABLED=1 go install -tags extended github.com/gohugoio/hugo@latest
 ```
+
+Build the extended/deploy edition:
+
+```text
+CGO_ENABLED=1 go install -tags extended,withdeploy github.com/gohugoio/hugo@latest
+```
+
 ## Star History

 [![Star History Chart](https://api.star-history.com/svg?repos=gohugoio/hugo&type=Timeline)](https://star-history.com/#gohugoio/hugo&Timeline)
@ -150,100 +171,112 @@ Hugo stands on the shoulders of great open source libraries. Run `hugo env --log

 ```text
 github.com/BurntSushi/locker="v0.0.0-20171006230638-a6e239ea1c69"
-github.com/alecthomas/chroma/v2="v2.14.0"
+github.com/PuerkitoBio/goquery="v1.10.1"
+github.com/alecthomas/chroma/v2="v2.15.0"
+github.com/andybalholm/cascadia="v1.3.3"
 github.com/armon/go-radix="v1.0.1-0.20221118154546-54df44f2176c"
 github.com/bep/clocks="v0.5.0"
 github.com/bep/debounce="v1.2.0"
 github.com/bep/gitmap="v1.6.0"
 github.com/bep/goat="v0.5.0"
-github.com/bep/godartsass/v2="v2.3.0"
+github.com/bep/godartsass/v2="v2.3.2"
 github.com/bep/golibsass="v1.2.0"
 github.com/bep/gowebp="v0.3.0"
-github.com/bep/imagemeta="v0.8.3"
+github.com/bep/imagemeta="v0.8.4"
 github.com/bep/lazycache="v0.7.0"
 github.com/bep/logg="v0.4.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/simplecobra="v0.5.0"
 github.com/bep/tmc="v0.5.1"
 github.com/cespare/xxhash/v2="v2.3.0"
 github.com/clbanning/mxj/v2="v2.7.0"
-github.com/cli/safeexec="v1.0.1"
 github.com/cpuguy83/go-md2man/v2="v2.0.4"
 github.com/disintegration/gift="v1.2.1"
-github.com/dlclark/regexp2="v1.11.0"
-github.com/evanw/esbuild="v0.24.0"
+github.com/dlclark/regexp2="v1.11.5"
+github.com/dop251/goja="v0.0.0-20250125213203-5ef83b82af17"
+github.com/evanw/esbuild="v0.24.2"
 github.com/fatih/color="v1.18.0"
 github.com/frankban/quicktest="v1.14.6"
 github.com/fsnotify/fsnotify="v1.8.0"
-github.com/getkin/kin-openapi="v0.123.0"
+github.com/getkin/kin-openapi="v0.129.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.21.0"
+github.com/go-openapi/swag="v0.23.0"
+github.com/go-sourcemap/sourcemap="v2.1.4+incompatible"
 github.com/gobuffalo/flect="v1.0.3"
 github.com/gobwas/glob="v0.2.3"
 github.com/gohugoio/go-i18n/v2="v2.1.3-0.20230805085216-e63c13218d0e"
-github.com/gohugoio/hashstructure="v0.1.0"
+github.com/gohugoio/hashstructure="v0.5.0"
 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.3.0"
 github.com/gohugoio/locales="v0.14.0"
 github.com/gohugoio/localescompressed="v1.0.1"
+github.com/golang/freetype="v0.0.0-20170609003504-e2365dfdc4a0"
 github.com/google/go-cmp="v0.6.0"
+github.com/google/pprof="v0.0.0-20250208200701-d0013a598941"
 github.com/gorilla/websocket="v1.5.3"
-github.com/hairyhenderson/go-codeowners="v0.6.1"
+github.com/hairyhenderson/go-codeowners="v0.7.0"
 github.com/hashicorp/golang-lru/v2="v2.0.7"
-github.com/invopop/yaml="v0.2.0"
 github.com/jdkato/prose="v1.2.1"
 github.com/josharian/intern="v1.0.0"
 github.com/kr/pretty="v0.3.1"
 github.com/kr/text="v0.2.0"
 github.com/kyokomi/emoji/v2="v2.2.13"
+github.com/lucasb-eyer/go-colorful="v1.2.0"
 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/mazznoer/csscolorparser="v0.1.5"
 github.com/mitchellh/mapstructure="v1.5.1-0.20231216201459-8508981c8b6c"
 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/oasdiff/yaml3="v0.0.0-20241210130736-a94c01f36349"
+github.com/oasdiff/yaml="v0.0.0-20241210131133-6b86fb107d80"
 github.com/olekukonko/tablewriter="v0.0.5"
 github.com/pbnjay/memory="v0.0.0-20210728143218-7b4eea64cf58"
 github.com/pelletier/go-toml/v2="v2.2.3"
 github.com/perimeterx/marshmallow="v1.1.5"
 github.com/pkg/browser="v0.0.0-20240102092130-5ac0b6a4141c"
 github.com/pkg/errors="v0.9.1"
+github.com/rivo/uniseg="v0.4.7"
 github.com/rogpeppe/go-internal="v1.13.1"
 github.com/russross/blackfriday/v2="v2.1.0"
-github.com/sass/dart-sass/compiler="1.81.0"
-github.com/sass/dart-sass/implementation="1.81.0"
-github.com/sass/dart-sass/protocol="3.1.0"
+github.com/sass/libsass="3.6.6"
 github.com/spf13/afero="v1.11.0"
-github.com/spf13/cast="v1.7.0"
+github.com/spf13/cast="v1.7.1"
 github.com/spf13/cobra="v1.8.1"
 github.com/spf13/fsync="v0.10.1"
-github.com/spf13/pflag="v1.0.5"
-github.com/tdewolff/minify/v2="v2.21.1"
-github.com/tdewolff/parse/v2="v2.7.18"
-github.com/tetratelabs/wazero="v1.8.1"
+github.com/spf13/pflag="v1.0.6"
+github.com/tdewolff/minify/v2="v2.20.37"
+github.com/tdewolff/parse/v2="v2.7.15"
+github.com/tetratelabs/wazero="v1.8.2"
+github.com/webmproject/libwebp="v1.3.2"
 github.com/yuin/goldmark-emoji="v1.0.4"
 github.com/yuin/goldmark="v1.7.8"
 go.uber.org/automaxprocs="v1.5.3"
-golang.org/x/crypto="v0.29.0"
-golang.org/x/exp="v0.0.0-20221031165847-c99f073a8326"
-golang.org/x/image="v0.22.0"
-golang.org/x/mod="v0.22.0"
-golang.org/x/net="v0.31.0"
-golang.org/x/sync="v0.9.0"
-golang.org/x/sys="v0.27.0"
-golang.org/x/text="v0.20.0"
-golang.org/x/tools="v0.27.0"
-google.golang.org/protobuf="v1.35.1"
+golang.org/x/crypto="v0.33.0"
+golang.org/x/exp="v0.0.0-20250210185358-939b2ce775ac"
+golang.org/x/image="v0.24.0"
+golang.org/x/mod="v0.23.0"
+golang.org/x/net="v0.35.0"
+golang.org/x/sync="v0.11.0"
+golang.org/x/sys="v0.30.0"
+golang.org/x/text="v0.22.0"
+golang.org/x/tools="v0.30.0"
+golang.org/x/xerrors="v0.0.0-20240903120638-7835f813f4da"
+gonum.org/v1/plot="v0.15.0"
+google.golang.org/protobuf="v1.36.5"
 gopkg.in/yaml.v2="v2.4.0"
 gopkg.in/yaml.v3="v3.0.1"
-howett.net/plist="v1.0.0"
+oss.terrastruct.com/d2="v0.6.9"
+oss.terrastruct.com/util-go="v0.0.0-20241005222610-44c011a04896"
+rsc.io/qr="v0.2.0"
 software.sslmate.com/src/go-pkcs12="v0.2.0"
 ```
 </details>
--- a/bench.sh
+++ b/bench.sh
@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-
-# allow user to override go executable by running as GOEXE=xxx make ...
-GOEXE="${GOEXE-go}"
-
-# Convenience script to
-# - For a given branch
-# - Run  benchmark tests for a given package
-# - Do the same for master
-# - then compare the two runs with benchcmp
-
-benchFilter=".*"
-
-if (( $# < 2 ));
-  then
-    echo "USAGE: ./bench.sh <git-branch> <package-to-bench> (and <benchmark filter> (regexp, optional))"
-    exit 1
-fi
-
-
-
-if [ $# -eq 3 ]; then
-  benchFilter=$3
-fi
-
-
-BRANCH=$1
-PACKAGE=$2
-
-git checkout $BRANCH
-"${GOEXE}" test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-$BRANCH.txt
-
-git checkout master
-"${GOEXE}" test -test.run=NONE -bench="$benchFilter" -test.benchmem=true ./$PACKAGE > /tmp/bench-$PACKAGE-master.txt
-
-
-benchcmp /tmp/bench-$PACKAGE-master.txt /tmp/bench-$PACKAGE-$BRANCH.txt
--- a/benchSite.sh
+++ b/benchSite.sh
@ -1,12 +0,0 @@
-#!/bin/bash
-
-# allow user to override go executable by running as GOEXE=xxx make ...
-GOEXE="${GOEXE-go}"
-
-# Send in a regexp matching the benchmarks you want to run, i.e. './benchSite.sh "YAML"'.
-# Note the quotes, which will be needed for more complex expressions.
-# The above will run all variations, but only for front matter YAML.
-
-echo "Running with BenchmarkSiteBuilding/${1}"
-
-"${GOEXE}" test -run="NONE" -bench="BenchmarkSiteBuilding/${1}" -test.benchmem=true ./hugolib -memprofile mem.prof -count 3 -cpuprofile cpu.prof
--- a/benchbep.sh
+++ b/benchbep.sh
@ -1 +0,0 @@
-gobench -package=./hugolib -bench="BenchmarkSiteNew/Deep_content_tree"
--- a/bepdock.sh
+++ b/bepdock.sh
@ -1 +0,0 @@
-docker run --rm --mount type=bind,source="$(pwd)",target=/hugo -w /hugo  -i -t bepsays/ci-goreleaser:1.11-2 /bin/bash
--- a/cache/dynacache/dynacache.go
+++ b/cache/dynacache/dynacache.go
@ -176,11 +176,12 @@ func (c *Cache) ClearMatching(predicatePartition func(k string, p PartitionManag
 }

 // ClearOnRebuild prepares the cache for a new rebuild taking the given changeset into account.
-func (c *Cache) ClearOnRebuild(changeset ...identity.Identity) {
+// predicate is optional and will clear any entry for which it returns true.
+func (c *Cache) ClearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity) {
 	g := rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
 		NumWorkers: len(c.partitions),
 		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearOnRebuild(changeset...)
+			partition.clearOnRebuild(predicate, changeset...)
 			return nil
 		},
 	})
@ -479,7 +480,12 @@ func (p *Partition[K, V]) clearMatching(predicate func(k, v any) bool) {
 	})
 }

-func (p *Partition[K, V]) clearOnRebuild(changeset ...identity.Identity) {
+func (p *Partition[K, V]) clearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity) {
+	if predicate == nil {
+		predicate = func(k, v any) bool {
+			return false
+		}
+	}
 	opts := p.getOptions()
 	if opts.ClearWhen == ClearNever {
 		return
@ -525,7 +531,7 @@ func (p *Partition[K, V]) clearOnRebuild(changeset ...identity.Identity) {
 	// Second pass needs to be done in a separate loop to catch any
 	// elements marked as stale in the other partitions.
 	p.c.DeleteFunc(func(key K, v V) bool {
-		if shouldDelete(key, v) {
+		if predicate(key, v) || shouldDelete(key, v) {
 			p.trace.Log(
 				logg.StringFunc(
 					func() string {
@ -601,7 +607,7 @@ type PartitionManager interface {
 	adjustMaxSize(addend int) int
 	getMaxSize() int
 	getOptions() OptionsPartition
-	clearOnRebuild(changeset ...identity.Identity)
+	clearOnRebuild(predicate func(k, v any) bool, changeset ...identity.Identity)
 	clearMatching(predicate func(k, v any) bool)
 	clearStale()
 }
--- a/cache/dynacache/dynacache_test.go
+++ b/cache/dynacache/dynacache_test.go
@ -147,13 +147,13 @@ func TestClear(t *testing.T) {

 	c.Assert(cache.Keys(predicateAll), qt.HasLen, 4)

-	cache.ClearOnRebuild()
+	cache.ClearOnRebuild(nil)

 	// Stale items are always cleared.
 	c.Assert(cache.Keys(predicateAll), qt.HasLen, 2)

 	cache = newTestCache(t)
-	cache.ClearOnRebuild(identity.StringIdentity("changed"))
+	cache.ClearOnRebuild(nil, identity.StringIdentity("changed"))

 	c.Assert(cache.Keys(nil), qt.HasLen, 1)

@ -191,16 +191,16 @@ func TestPanicInCreate(t *testing.T) {
 		return err
 	}

-	for i := 0; i < 3; i++ {
-		for j := 0; j < 3; j++ {
+	for i := range 3 {
+		for range 3 {
 			c.Assert(willPanic(i), qt.PanicMatches, fmt.Sprintf("panic-%d", i))
 			c.Assert(willErr(i), qt.ErrorMatches, fmt.Sprintf("error-%d", i))
 		}
 	}

 	// Test the same keys again without the panic.
-	for i := 0; i < 3; i++ {
-		for j := 0; j < 3; j++ {
+	for i := range 3 {
+		for range 3 {
 			v, err := p1.GetOrCreate(fmt.Sprintf("panic-%d", i), func(key string) (testItem, error) {
 				return testItem{
 					name: key,
--- a/cache/filecache/filecache_pruner_test.go
+++ b/cache/filecache/filecache_pruner_test.go
@ -59,7 +59,7 @@ dir = ":resourceDir/_gen"
 		caches, err := filecache.NewCaches(p)
 		c.Assert(err, qt.IsNil)
 		cache := caches[name]
-		for i := 0; i < 10; i++ {
+		for i := range 10 {
 			id := fmt.Sprintf("i%d", i)
 			cache.GetOrCreateBytes(id, func() ([]byte, error) {
 				return []byte("abc"), nil
@ -74,7 +74,7 @@ dir = ":resourceDir/_gen"
 		c.Assert(err, qt.IsNil)
 		c.Assert(count, qt.Equals, 5, msg)

-		for i := 0; i < 10; i++ {
+		for i := range 10 {
 			id := fmt.Sprintf("i%d", i)
 			v := cache.GetString(id)
 			if i < 5 {
@ -97,7 +97,7 @@ dir = ":resourceDir/_gen"
 		c.Assert(count, qt.Equals, 4)

 		// Now only the i5 should be left.
-		for i := 0; i < 10; i++ {
+		for i := range 10 {
 			id := fmt.Sprintf("i%d", i)
 			v := cache.GetString(id)
 			if i != 5 {
--- a/cache/filecache/filecache_test.go
+++ b/cache/filecache/filecache_test.go
@ -105,7 +105,7 @@ dir = ":cacheDir/c"
 		}

 		for _, ca := range []*filecache.Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
-			for i := 0; i < 2; i++ {
+			for range 2 {
 				info, r, err := ca.GetOrCreate("a", rf("abc"))
 				c.Assert(err, qt.IsNil)
 				c.Assert(r, qt.Not(qt.IsNil))
@ -193,11 +193,11 @@ dir = "/cache/c"

 	var wg sync.WaitGroup

-	for i := 0; i < 50; i++ {
+	for i := range 50 {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
-			for j := 0; j < 20; j++ {
+			for range 20 {
 				ca := caches.Get(cacheName)
 				c.Assert(ca, qt.Not(qt.IsNil))
 				filename, data := filenameData(i)
--- a/cache/httpcache/httpcache.go
+++ b/cache/httpcache/httpcache.go
@ -42,7 +42,7 @@ var DefaultConfig = Config{

 // Config holds the configuration for the HTTP cache.
 type Config struct {
-	// Configures the HTTP cache behaviour (RFC 9111).
+	// Configures the HTTP cache behavior (RFC 9111).
 	// When this is not enabled for a resource, Hugo will go straight to the file cache.
 	Cache Cache

@ -52,7 +52,7 @@ type Config struct {
 }

 type Cache struct {
-	// Enable HTTP cache behaviour (RFC 9111) for these rsources.
+	// Enable HTTP cache behavior (RFC 9111) for these resources.
 	For GlobMatcher
 }

@ -122,6 +122,10 @@ type GlobMatcher struct {
 	Includes []string
 }

+func (gm GlobMatcher) IsZero() bool {
+	return len(gm.Includes) == 0 && len(gm.Excludes) == 0
+}
+
 type ConfigCompiled struct {
 	For         predicate.P[string]
 	PollConfigs []PollConfigCompiled
@ -155,6 +159,9 @@ func (p PollConfigCompiled) IsZero() bool {
 }

 func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
+	if gm.IsZero() {
+		panic("no includes or excludes")
+	}
 	var p predicate.P[string]
 	for _, include := range gm.Includes {
 		g, err := glob.Compile(include, '/')
@ -181,7 +188,7 @@ func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
 	return p, nil
 }

-func DecodeConfig(bcfg config.BaseConfig, m map[string]any) (Config, error) {
+func DecodeConfig(_ config.BaseConfig, m map[string]any) (Config, error) {
 	if len(m) == 0 {
 		return DefaultConfig, nil
 	}
@ -203,5 +210,20 @@ func DecodeConfig(bcfg config.BaseConfig, m map[string]any) (Config, error) {
 		return c, err
 	}

+	if c.Cache.For.IsZero() {
+		c.Cache.For = DefaultConfig.Cache.For
+	}
+
+	for pci := range c.Polls {
+		if c.Polls[pci].For.IsZero() {
+			c.Polls[pci].For = DefaultConfig.Cache.For
+			c.Polls[pci].Disable = true
+		}
+	}
+
+	if len(c.Polls) == 0 {
+		c.Polls = DefaultConfig.Polls
+	}
+
 	return c, nil
 }
--- a/cache/httpcache/httpcache_integration_test.go
+++ b/cache/httpcache/httpcache_integration_test.go
@ -22,6 +22,8 @@ import (
 )

 func TestConfigCustom(t *testing.T) {
+	t.Parallel()
+
 	files := `
 -- hugo.toml --
 [httpcache]
@ -51,6 +53,8 @@ includes = ["**gohugo.io**"]
 }

 func TestConfigDefault(t *testing.T) {
+	t.Parallel()
+
 	files := `
 -- hugo.toml --
 `
@ -62,3 +66,30 @@ func TestConfigDefault(t *testing.T) {
 	b.Assert(compiled.For("https://gohugo.io/foo.jpg"), qt.IsFalse)
 	b.Assert(compiled.PollConfigFor("https://gohugo.io/foo.jpg").Config.Disable, qt.IsTrue)
 }
+
+func TestConfigPollsOnly(t *testing.T) {
+	t.Parallel()
+	files := `
+-- hugo.toml --
+[httpcache]
+[[httpcache.polls]]
+low = "5s"
+high = "32s"
+[httpcache.polls.for]
+includes = ["**gohugo.io**"]
+		
+	
+`
+
+	b := hugolib.Test(t, files)
+
+	compiled := b.H.Configs.Base.C.HTTPCache
+
+	b.Assert(compiled.For("https://gohugo.io/posts.json"), qt.IsFalse)
+	b.Assert(compiled.For("https://gohugo.io/foo.jpg"), qt.IsFalse)
+
+	pc := compiled.PollConfigFor("https://gohugo.io/foo.jpg")
+	b.Assert(pc.Config.Low, qt.Equals, 5*time.Second)
+	b.Assert(pc.Config.High, qt.Equals, 32*time.Second)
+	b.Assert(compiled.PollConfigFor("https://example.com/foo.jpg").IsZero(), qt.IsTrue)
+}
--- a/cache/httpcache/httpcache_test.go
+++ b/cache/httpcache/httpcache_test.go
@ -17,6 +17,7 @@ import (
 	"testing"

 	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/config"
 )

 func TestGlobMatcher(t *testing.T) {
@ -40,3 +41,33 @@ func TestGlobMatcher(t *testing.T) {
 	c.Assert(p("foo/bar/foo.css"), qt.IsFalse)
 	c.Assert(p("foo/bar/foo.xml"), qt.IsTrue)
 }
+
+func TestDefaultConfig(t *testing.T) {
+	c := qt.New(t)
+
+	_, err := DefaultConfig.Compile()
+	c.Assert(err, qt.IsNil)
+}
+
+func TestDecodeConfigInjectsDefaultAndCompiles(t *testing.T) {
+	c := qt.New(t)
+
+	cfg, err := DecodeConfig(config.BaseConfig{}, map[string]interface{}{})
+	c.Assert(err, qt.IsNil)
+	c.Assert(cfg, qt.DeepEquals, DefaultConfig)
+
+	_, err = cfg.Compile()
+	c.Assert(err, qt.IsNil)
+
+	cfg, err = DecodeConfig(config.BaseConfig{}, map[string]any{
+		"cache": map[string]any{
+			"polls": []map[string]any{
+				{"disable": true},
+			},
+		},
+	})
+	c.Assert(err, qt.IsNil)
+
+	_, err = cfg.Compile()
+	c.Assert(err, qt.IsNil)
+}
--- a/codegen/methods.go
+++ b/codegen/methods.go
@ -26,6 +26,7 @@ import (
 	"path/filepath"
 	"reflect"
 	"regexp"
+	"slices"
 	"sort"
 	"strings"
 	"sync"
@ -102,7 +103,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 	}

 	for _, t := range include {
-		for i := 0; i < t.NumMethod(); i++ {
+		for i := range t.NumMethod() {

 			m := t.Method(i)
 			if excludes[m.Name] || seen[m.Name] {
@ -122,7 +123,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T

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

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

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

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

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

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

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

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

@ -435,7 +436,7 @@ func (m Methods) ToMarshalJSON(receiver, pkgPath string, excludes ...string) (st
 		// Exclude self
 		for i, pkgImp := range pkgImports {
 			if pkgImp == pkgPath {
-				pkgImports = append(pkgImports[:i], pkgImports[i+1:]...)
+				pkgImports = slices.Delete(pkgImports, i, i+1)
 			}
 		}
 	}
--- a/commands/commandeer.go
+++ b/commands/commandeer.go
@ -101,9 +101,10 @@ type configKey struct {

 // This is the root command.
 type rootCommand struct {
-	Printf  func(format string, v ...interface{})
-	Println func(a ...interface{})
-	Out     io.Writer
+	Printf  func(format string, v ...any)
+	Println func(a ...any)
+	StdOut  io.Writer
+	StdErr  io.Writer

 	logger loggers.Logger

@ -356,7 +357,7 @@ func (r *rootCommand) getOrCreateHugo(cfg config.Provider, ignoreModuleDoesNotEx
 }

 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}
+	return deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, StdOut: r.logger.StdOut(), StdErr: r.logger.StdErr(), LogLevel: r.logger.Level(), ChangesFromBuild: r.changesFromBuild}
 }

 func (r *rootCommand) Name() string {
@ -421,21 +422,23 @@ func (r *rootCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args
 }

 func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
-	r.Out = os.Stdout
+	r.StdOut = os.Stdout
+	r.StdErr = os.Stderr
 	if r.quiet {
-		r.Out = io.Discard
+		r.StdOut = io.Discard
+		r.StdErr = io.Discard
 	}
 	// Used by mkcert (server).
-	log.SetOutput(r.Out)
+	log.SetOutput(r.StdOut)

-	r.Printf = func(format string, v ...interface{}) {
+	r.Printf = func(format string, v ...any) {
 		if !r.quiet {
-			fmt.Fprintf(r.Out, format, v...)
+			fmt.Fprintf(r.StdOut, format, v...)
 		}
 	}
-	r.Println = func(a ...interface{}) {
+	r.Println = func(a ...any) {
 		if !r.quiet {
-			fmt.Fprintln(r.Out, a...)
+			fmt.Fprintln(r.StdOut, a...)
 		}
 	}
 	_, running := runner.Command.(*serverCommand)
@ -444,6 +447,8 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 	if err != nil {
 		return err
 	}
+	// Set up the global logger early to allow info deprecations during config load.
+	loggers.SetGlobalLogger(r.logger)

 	r.changesFromBuild = make(chan []identity.Identity, 10)

@ -485,8 +490,8 @@ func (r *rootCommand) createLogger(running bool) (loggers.Logger, error) {
 	optsLogger := loggers.Options{
 		DistinctLevel: logg.LevelWarn,
 		Level:         level,
-		Stdout:        r.Out,
-		Stderr:        r.Out,
+		StdOut:        r.StdOut,
+		StdErr:        r.StdErr,
 		StoreErrors:   running,
 	}

@ -535,6 +540,7 @@ Complete documentation is available at https://gohugo.io/.`
 	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.PersistentFlags().BoolP("noBuildLock", "", false, "don't create .hugo_build.lock file")
 	_ = 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)
@ -590,7 +596,6 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().BoolVar(&r.forceSyncStatic, "forceSyncStatic", false, "copy all files when static is changed.")
 	cmd.Flags().BoolP("noTimes", "", false, "don't sync modification time of files")
 	cmd.Flags().BoolP("noChmod", "", false, "don't sync permission mode of files")
-	cmd.Flags().BoolP("noBuildLock", "", false, "don't create .hugo_build.lock file")
 	cmd.Flags().BoolP("printI18nWarnings", "", false, "print missing translations")
 	cmd.Flags().BoolP("printPathWarnings", "", false, "print warnings on duplicate target paths etc.")
 	cmd.Flags().BoolP("printUnusedTemplates", "", false, "print warnings on unused templates.")
--- a/commands/config.go
+++ b/commands/config.go
@ -43,8 +43,9 @@ func newConfigCommand() *configCommand {
 type configCommand struct {
 	r *rootCommand

-	format string
-	lang   string
+	format    string
+	lang      string
+	printZero bool

 	commands []simplecobra.Commander
 }
@ -78,7 +79,7 @@ func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 	dec.SetIndent("", "  ")
 	dec.SetEscapeHTML(false)

-	if err := dec.Encode(parser.ReplacingJSONMarshaller{Value: config, KeysToLower: true, OmitEmpty: true}); err != nil {
+	if err := dec.Encode(parser.ReplacingJSONMarshaller{Value: config, KeysToLower: true, OmitEmpty: !c.printZero}); err != nil {
 		return err
 	}

@ -89,7 +90,7 @@ func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 		os.Stdout.Write(buf.Bytes())
 	default:
 		// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
-		var m map[string]interface{}
+		var m map[string]any
 		if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
 			return err
 		}
@ -115,6 +116,7 @@ func (c *configCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd.Flags().StringVar(&c.format, "format", "toml", "preferred file format (toml, yaml or json)")
 	_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
 	cmd.Flags().StringVar(&c.lang, "lang", "", "the language to display config for. Defaults to the first language defined.")
+	cmd.Flags().BoolVar(&c.printZero, "printZero", false, `include config options with zero values (e.g. false, 0, "") in the output`)
 	_ = cmd.RegisterFlagCompletionFunc("lang", cobra.NoFileCompletions)
 	applyLocalFlagsBuildConfig(cmd, c.r)

--- a/commands/deploy.go
+++ b/commands/deploy.go
@ -12,7 +12,6 @@
 // limitations under the License.

 //go:build withdeploy
-// +build withdeploy

 package commands

--- a/commands/deploy_off.go
+++ b/commands/deploy_off.go
@ -12,7 +12,6 @@
 // limitations under the License.

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

 // Copyright 2024 The Hugo Authors. All rights reserved.
 //
--- a/commands/gen.go
+++ b/commands/gen.go
@ -21,6 +21,7 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"slices"
 	"strings"

 	"github.com/alecthomas/chroma/v2"
@ -49,6 +50,7 @@ func newGenCommand() *genCommand {
 		highlightStyle         string
 		lineNumbersInlineStyle string
 		lineNumbersTableStyle  string
+		omitEmpty              bool
 	)

 	newChromaStyles := func() simplecobra.Commander {
@ -60,6 +62,10 @@ func newGenCommand() *genCommand {
 See https://xyproto.github.io/splash/docs/all.html for a preview of the available styles`,

 			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
+				style = strings.ToLower(style)
+				if !slices.Contains(styles.Names(), style) {
+					return fmt.Errorf("invalid style: %s", style)
+				}
 				builder := styles.Get(style).Builder()
 				if highlightStyle != "" {
 					builder.Add(chroma.LineHighlight, highlightStyle)
@ -74,8 +80,17 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				if err != nil {
 					return err
 				}
-				formatter := html.New(html.WithAllClasses(true))
-				formatter.WriteCSS(os.Stdout, style)
+
+				var formatter *html.Formatter
+				if omitEmpty {
+					formatter = html.New(html.WithClasses(true))
+				} else {
+					formatter = html.New(html.WithAllClasses(true))
+				}
+
+				w := os.Stdout
+				fmt.Fprintf(w, "/* Generated using: hugo %s */\n\n", strings.Join(os.Args[1:], " "))
+				formatter.WriteCSS(w, style)
 				return nil
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
@ -88,6 +103,8 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				_ = cmd.RegisterFlagCompletionFunc("lineNumbersInlineStyle", cobra.NoFileCompletions)
 				cmd.PersistentFlags().StringVar(&lineNumbersTableStyle, "lineNumbersTableStyle", "", `foreground and background colors for table line numbers, e.g. --lineNumbersTableStyle "#fff000 bg:#000fff"`)
 				_ = cmd.RegisterFlagCompletionFunc("lineNumbersTableStyle", cobra.NoFileCompletions)
+				cmd.PersistentFlags().BoolVar(&omitEmpty, "omitEmpty", false, `omit empty CSS rules`)
+				_ = cmd.RegisterFlagCompletionFunc("omitEmpty", cobra.NoFileCompletions)
 			},
 		}
 	}
@ -142,7 +159,7 @@ url: %s

 		return &simpleCommand{
 			name:  "doc",
-			short: "Generate Markdown documentation for the Hugo CLI.",
+			short: "Generate Markdown documentation for the Hugo CLI",
 			long: `Generate Markdown documentation for the Hugo CLI.
 			This command is, mostly, used to create up-to-date documentation
 	of Hugo's command-line interface for https://gohugo.io/.
@ -167,13 +184,13 @@ url: %s
 				prepender := func(filename string) string {
 					name := filepath.Base(filename)
 					base := strings.TrimSuffix(name, path.Ext(name))
-					url := "/commands/" + strings.ToLower(base) + "/"
+					url := "/docs/reference/commands/" + strings.ToLower(base) + "/"
 					return fmt.Sprintf(gendocFrontmatterTemplate, strings.Replace(base, "_", " ", -1), base, url)
 				}

 				linkHandler := func(name string) string {
 					base := strings.TrimSuffix(name, path.Ext(name))
-					return "/commands/" + strings.ToLower(base) + "/"
+					return "/docs/reference/commands/" + strings.ToLower(base) + "/"
 				}
 				r.Println("Generating Hugo command-line documentation in", gendocdir, "...")
 				doc.GenMarkdownTreeCustom(cd.CobraCommand.Root(), gendocdir, prepender, linkHandler)
@ -194,7 +211,7 @@ url: %s
 	newDocsHelper := func() simplecobra.Commander {
 		return &simpleCommand{
 			name:  "docshelper",
-			short: "Generate some data files for the Hugo docs.",
+			short: "Generate some data files for the Hugo docs",

 			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 				r.Println("Generate docs data to", docsHelperTarget)
@ -215,7 +232,7 @@ url: %s
 				}

 				// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
-				var m map[string]interface{}
+				var m map[string]any
 				if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
 					return err
 				}
--- a/commands/hugobuilder.go
+++ b/commands/hugobuilder.go
@ -62,7 +62,7 @@ type hugoBuilder struct {

 	// Currently only set when in "fast render mode".
 	changeDetector *fileChangeDetector
-	visitedURLs    *types.EvictingStringQueue
+	visitedURLs    *types.EvictingQueue[string]

 	fullRebuildSem *semaphore.Weighted
 	debounce       func(f func())
@ -663,7 +663,20 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 	var n int
 	for _, ev := range evs {
 		keep := true
-		if ev.Has(fsnotify.Create) || ev.Has(fsnotify.Write) {
+		// Write and rename operations are often followed by CHMOD.
+		// There may be valid use cases for rebuilding the site on CHMOD,
+		// but that will require more complex logic than this simple conditional.
+		// On OS X this seems to be related to Spotlight, see:
+		// https://github.com/go-fsnotify/fsnotify/issues/15
+		// A workaround is to put your site(s) on the Spotlight exception list,
+		// but that may be a little mysterious for most end users.
+		// So, for now, we skip reload on CHMOD.
+		// We do have to check for WRITE though. On slower laptops a Chmod
+		// could be aggregated with other important events, and we still want
+		// to rebuild on those
+		if ev.Op == fsnotify.Chmod {
+			keep = false
+		} else if ev.Has(fsnotify.Create) || ev.Has(fsnotify.Write) {
 			if _, err := os.Stat(ev.Name); err != nil {
 				keep = false
 			}
@ -805,21 +818,6 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 			continue
 		}

-		// Write and rename operations are often followed by CHMOD.
-		// There may be valid use cases for rebuilding the site on CHMOD,
-		// but that will require more complex logic than this simple conditional.
-		// On OS X this seems to be related to Spotlight, see:
-		// https://github.com/go-fsnotify/fsnotify/issues/15
-		// A workaround is to put your site(s) on the Spotlight exception list,
-		// but that may be a little mysterious for most end users.
-		// So, for now, we skip reload on CHMOD.
-		// We do have to check for WRITE though. On slower laptops a Chmod
-		// could be aggregated with other important events, and we still want
-		// to rebuild on those
-		if ev.Op&(fsnotify.Chmod|fsnotify.Write|fsnotify.Create) == fsnotify.Chmod {
-			continue
-		}
-
 		walkAdder := func(path string, f hugofs.FileMetaInfo) error {
 			if f.IsDir() {
 				c.r.logger.Println("adding created directory to watchlist", path)
@ -920,7 +918,11 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,

 			changed := c.changeDetector.changed()
 			if c.changeDetector != nil {
-				lrl.Logf("build changed %d files", len(changed))
+				if len(changed) >= 10 {
+					lrl.Logf("build changed %d files", len(changed))
+				} else {
+					lrl.Logf("build changed %d files: %q", len(changed), changed)
+				}
 				if len(changed) == 0 {
 					// Nothing has changed.
 					return
@ -970,6 +972,9 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 					lrl.Logf("force refresh")
 					livereload.ForceRefresh()
 				}
+			} else {
+				lrl.Logf("force refresh")
+				livereload.ForceRefresh()
 			}

 			if len(cssChanges) > 0 {
@ -1099,7 +1104,7 @@ func (c *hugoBuilder) rebuildSites(events []fsnotify.Event) (err error) {
 	if err != nil {
 		return
 	}
-	err = h.Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()}, events...)
+	err = h.Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyTouched: c.visitedURLs, ErrRecovery: c.errState.wasErr()}, events...)
 	return
 }

@ -1115,7 +1120,7 @@ func (c *hugoBuilder) rebuildSitesForChanges(ids []identity.Identity) (err error
 	}
 	whatChanged := &hugolib.WhatChanged{}
 	whatChanged.Add(ids...)
-	err = h.Build(hugolib.BuildCfg{NoBuildLock: true, WhatChanged: whatChanged, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()})
+	err = h.Build(hugolib.BuildCfg{NoBuildLock: true, WhatChanged: whatChanged, RecentlyTouched: c.visitedURLs, ErrRecovery: c.errState.wasErr()})

 	return
 }
--- a/commands/list.go
+++ b/commands/list.go
@ -57,7 +57,7 @@ func newListCommand() *listCommand {
 			return err
 		}

-		writer := csv.NewWriter(r.Out)
+		writer := csv.NewWriter(r.StdOut)
 		defer writer.Flush()

 		writer.Write([]string{
--- a/commands/mod.go
+++ b/commands/mod.go
@ -44,16 +44,16 @@ func newModCommands() *modCommands {

 	npmCommand := &simpleCommand{
 		name:  "npm",
-		short: "Various npm helpers.",
+		short: "Various npm helpers",
 		long:  `Various npm (Node package manager) helpers.`,
 		commands: []simplecobra.Commander{
 			&simpleCommand{
 				name:  "pack",
-				short: "Experimental: Prepares and writes a composite package.json file for your project.",
+				short: "Experimental: Prepares and writes a composite package.json file for your project",
 				long: `Prepares and writes a composite package.json file for your project.

 On first run it creates a "package.hugo.json" in the project root if not already there. This file will be used as a template file
-with the base dependency set. 
+with the base dependency set.

 This set will be merged with all "package.hugo.json" files found in the dependency tree, picking the version closest to the project.

@ -80,12 +80,12 @@ so this may/will change in future versions of Hugo.
 		commands: []simplecobra.Commander{
 			&simpleCommand{
 				name:  "init",
-				short: "Initialize this project as a Hugo Module.",
+				short: "Initialize this project as a Hugo Module",
 				long: `Initialize this project as a Hugo Module.
 	It will try to guess the module path, but you may help by passing it as an argument, e.g:
-	
+
 		hugo mod init github.com/gohugoio/testshortcodes
-	
+
 	Note that Hugo Modules supports multi-module projects, so you can initialize a Hugo Module
 	inside a subfolder on GitHub, as one example.
 	`,
@ -111,7 +111,7 @@ so this may/will change in future versions of Hugo.
 			},
 			&simpleCommand{
 				name:  "verify",
-				short: "Verify dependencies.",
+				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
@ -129,7 +129,7 @@ so this may/will change in future versions of Hugo.
 			},
 			&simpleCommand{
 				name:  "graph",
-				short: "Print a module dependency graph.",
+				short: "Print a module dependency graph",
 				long: `Print a module dependency graph with information about module status (disabled, vendored).
 Note that for vendored modules, that is the version listed and not the one from go.mod.
 `,
@ -149,7 +149,7 @@ Note that for vendored modules, that is the version listed and not the one from
 			},
 			&simpleCommand{
 				name:  "clean",
-				short: "Delete the Hugo Module cache for the current project.",
+				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
@ -175,7 +175,7 @@ Note that for vendored modules, that is the version listed and not the one from
 			},
 			&simpleCommand{
 				name:  "tidy",
-				short: "Remove unused entries in go.mod and go.sum.",
+				short: "Remove unused entries in go.mod and go.sum",
 				withc: func(cmd *cobra.Command, r *rootCommand) {
 					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					applyLocalFlagsBuildConfig(cmd, r)
@ -190,7 +190,7 @@ Note that for vendored modules, that is the version listed and not the one from
 			},
 			&simpleCommand{
 				name:  "vendor",
-				short: "Vendor all module dependencies into the _vendor directory.",
+				short: "Vendor all module dependencies into the _vendor directory",
 				long: `Vendor all module dependencies into the _vendor directory.
 	If a module is vendored, that is where Hugo will look for it's dependencies.
 	`,
@ -209,16 +209,16 @@ Note that for vendored modules, that is the version listed and not the one from

 			&simpleCommand{
 				name:  "get",
-				short: "Resolves dependencies in your current Hugo Project.",
+				short: "Resolves dependencies in your current Hugo project",
 				long: `
-Resolves dependencies in your current Hugo Project.
+Resolves dependencies in your current Hugo project.

 Some examples:

 Install the latest version possible for a given module:

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

    hugo mod get github.com/gohugoio/testshortcodes@v0.3.0
--- a/commands/new.go
+++ b/commands/new.go
@ -76,10 +76,8 @@ Ensure you run this within the root directory of your site.`,
 			&simpleCommand{
 				name:  "site",
 				use:   "site [path]",
-				short: "Create a new site (skeleton)",
-				long: `Create a new site in the provided directory.
-The new site will have the correct structure, but no content or theme yet.
-Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
+				short: "Create a new site",
+				long:  `Create a new site at the specified path.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 1 {
 						return newUserError("path needs to be provided")
@ -124,11 +122,9 @@ Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 			&simpleCommand{
 				name:  "theme",
 				use:   "theme [name]",
-				short: "Create a new theme (skeleton)",
-				long: `Create a new theme (skeleton) called [name] in ./themes.
-New theme is a skeleton. Please add content to the touched files. Add your
-name to the copyright line in the license and adjust the theme.toml file
-according to your needs.`,
+				short: "Create a new theme",
+				long: `Create a new theme with the specified name in the ./themes directory.
+This generates a functional theme including template examples and sample content.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 1 {
 						return newUserError("theme name needs to be provided")
@ -144,7 +140,7 @@ according to your needs.`,
 					createpath := paths.AbsPathify(conf.configs.Base.WorkingDir, filepath.Join(conf.configs.Base.ThemesDir, args[0]))
 					r.Println("Creating new theme in", createpath)

-					err = skeletons.CreateTheme(createpath, sourceFs)
+					err = skeletons.CreateTheme(createpath, sourceFs, format)
 					if err != nil {
 						return err
 					}
@ -152,7 +148,14 @@ according to your needs.`,
 					return nil
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
+					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+						if len(args) != 0 {
+							return []string{}, cobra.ShellCompDirectiveNoFileComp
+						}
+						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
+					}
+					cmd.Flags().StringVar(&format, "format", "toml", "preferred file format (toml, yaml or json)")
+					_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
 				},
 			},
 		},
--- a/commands/release.go
+++ b/commands/release.go
@ -32,7 +32,7 @@ func newReleaseCommand() simplecobra.Commander {

 	return &simpleCommand{
 		name:  "release",
-		short: "Release a new version of Hugo.",
+		short: "Release a new version of Hugo",
 		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 			rel, err := releaser.New(skipPush, try, step)
 			if err != nil {
--- a/commands/server.go
+++ b/commands/server.go
@ -23,6 +23,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"maps"
 	"net"
 	"net/http"
 	_ "net/http/pprof"
@ -32,6 +33,7 @@ import (
 	"path"
 	"path/filepath"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 	"sync"
@ -47,6 +49,7 @@ import (
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/tpl/tplimpl"

 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/common/urls"
@ -56,7 +59,6 @@ import (
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/hugolib/filesystems"
 	"github.com/gohugoio/hugo/livereload"
-	"github.com/gohugoio/hugo/tpl"
 	"github.com/gohugoio/hugo/transform"
 	"github.com/gohugoio/hugo/transform/livereloadinject"
 	"github.com/spf13/afero"
@ -83,10 +85,14 @@ const (
 	configChangeGoWork = "go work file"
 )

+const (
+	hugoHeaderRedirect = "X-Hugo-Redirect"
+)
+
 func newHugoBuilder(r *rootCommand, s *serverCommand, onConfigLoaded ...func(reloaded bool) error) *hugoBuilder {
-	var visitedURLs *types.EvictingStringQueue
+	var visitedURLs *types.EvictingQueue[string]
 	if s != nil && !s.disableFastRender {
-		visitedURLs = types.NewEvictingStringQueue(20)
+		visitedURLs = types.NewEvictingQueue[string](20)
 	}
 	return &hugoBuilder{
 		r:              r,
@ -114,7 +120,7 @@ func newServerCommand() *serverCommand {
 		commands: []simplecobra.Commander{
 			&simpleCommand{
 				name:  "trust",
-				short: "Install the local CA in the system trust store.",
+				short: "Install the local CA in the system trust store",
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					action := "-install"
 					if uninstall {
@ -190,9 +196,7 @@ func (f *fileChangeDetector) PrepareNew() {
 	}

 	f.prev = make(map[string]uint64)
-	for k, v := range f.current {
-		f.prev[k] = v
-	}
+	maps.Copy(f.prev, f.current)
 	f.current = make(map[string]uint64)
 }

@ -210,16 +214,17 @@ func (f *fileChangeDetector) changed() []string {
 		}
 	}

-	return f.filterIrrelevant(c)
+	return f.filterIrrelevantAndSort(c)
 }

-func (f *fileChangeDetector) filterIrrelevant(in []string) []string {
+func (f *fileChangeDetector) filterIrrelevantAndSort(in []string) []string {
 	var filtered []string
 	for _, v := range in {
 		if !f.irrelevantRe.MatchString(v) {
 			filtered = append(filtered, v)
 		}
 	}
+	sort.Strings(filtered)
 	return filtered
 }

@ -305,64 +310,65 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string
 				w.Header().Set(header.Key, header.Value)
 			}

-			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.
-				// See https://docs.netlify.com/routing/redirects/rewrites-proxies/
-				if !redirect.Force {
-					path := filepath.Clean(strings.TrimPrefix(requestURI, baseURL.Path()))
-					if root != "" {
-						path = filepath.Join(root, path)
-					}
-					var fs afero.Fs
-					f.c.withConf(func(conf *commonConfig) {
-						fs = conf.fs.PublishDirServer
-					})
-
-					fi, err := fs.Stat(path)
-
-					if err == nil {
-						if fi.IsDir() {
-							// There will be overlapping directories, so we
-							// need to check for a file.
-							_, err = fs.Stat(filepath.Join(path, "index.html"))
-							doRedirect = err != nil
-						} else {
-							doRedirect = false
+			if canRedirect(requestURI, r) {
+				if redirect := serverConfig.MatchRedirect(requestURI, r.Header); !redirect.IsZero() {
+					doRedirect := true
+					// This matches Netlify's behavior and is needed for SPA behavior.
+					// See https://docs.netlify.com/routing/redirects/rewrites-proxies/
+					if !redirect.Force {
+						path := filepath.Clean(strings.TrimPrefix(requestURI, baseURL.Path()))
+						if root != "" {
+							path = filepath.Join(root, path)
 						}
-					}
-				}
+						var fs afero.Fs
+						f.c.withConf(func(conf *commonConfig) {
+							fs = conf.fs.PublishDirServer
+						})
+
+						fi, err := fs.Stat(path)

-				if doRedirect {
-					switch redirect.Status {
-					case 404:
-						w.WriteHeader(404)
-						file, err := fs.Open(strings.TrimPrefix(redirect.To, baseURL.Path()))
 						if err == nil {
-							defer file.Close()
-							io.Copy(w, file)
-						} else {
-							fmt.Fprintln(w, "<h1>Page Not Found</h1>")
+							if fi.IsDir() {
+								// There will be overlapping directories, so we
+								// need to check for a file.
+								_, err = fs.Stat(filepath.Join(path, "index.html"))
+								doRedirect = err != nil
+							} else {
+								doRedirect = false
+							}
 						}
-						return
-					case 200:
-						if r2 := f.rewriteRequest(r, strings.TrimPrefix(redirect.To, baseURL.Path())); r2 != nil {
-							requestURI = redirect.To
-							r = r2
-						}
-					default:
-						w.Header().Set("Content-Type", "")
-						http.Redirect(w, r, redirect.To, redirect.Status)
-						return
+					}

+					if doRedirect {
+						w.Header().Set(hugoHeaderRedirect, "true")
+						switch redirect.Status {
+						case 404:
+							w.WriteHeader(404)
+							file, err := fs.Open(strings.TrimPrefix(redirect.To, baseURL.Path()))
+							if err == nil {
+								defer file.Close()
+								io.Copy(w, file)
+							} else {
+								fmt.Fprintln(w, "<h1>Page Not Found</h1>")
+							}
+							return
+						case 200:
+							if r2 := f.rewriteRequest(r, strings.TrimPrefix(redirect.To, baseURL.Path())); r2 != nil {
+								requestURI = redirect.To
+								r = r2
+							}
+						default:
+							w.Header().Set("Content-Type", "")
+							http.Redirect(w, r, redirect.To, redirect.Status)
+							return
+
+						}
 					}
 				}
-
 			}

 			if f.c.fastRenderMode && f.c.errState.buildErr() == nil {
-				if strings.HasSuffix(requestURI, "/") || strings.HasSuffix(requestURI, "html") || strings.HasSuffix(requestURI, "htm") {
+				if isNavigation(requestURI, r) {
 					if !f.c.visitedURLs.Contains(requestURI) {
 						// If not already on stack, re-render that single page.
 						if err := f.c.partialReRender(requestURI); err != nil {
@ -621,7 +627,7 @@ func (c *serverCommand) setServerInfoInConfig() error {
 		panic("no server ports set")
 	}
 	return c.withConfE(func(conf *commonConfig) error {
-		for i, language := range conf.configs.Languages {
+		for i, language := range conf.configs.LanguagesDefaultFirst {
 			isMultihost := conf.configs.IsMultihost
 			var serverPort int
 			if isMultihost {
@ -752,7 +758,7 @@ func (c *serverCommand) createServerPorts(cd *simplecobra.Commandeer) error {
 			c.serverPorts = make([]serverPortListener, len(conf.configs.Languages))
 		}
 		currentServerPort := c.serverPort
-		for i := 0; i < len(c.serverPorts); i++ {
+		for i := range c.serverPorts {
 			l, err := net.Listen("tcp", net.JoinHostPort(c.serverInterface, strconv.Itoa(currentServerPort)))
 			if err == nil {
 				c.serverPorts[i] = serverPortListener{ln: l, p: currentServerPort}
@ -836,7 +842,7 @@ func (c *serverCommand) partialReRender(urls ...string) (err error) {
 	defer func() {
 		c.errState.setWasErr(false)
 	}()
-	visited := types.NewEvictingStringQueue(len(urls))
+	visited := types.NewEvictingQueue[string](len(urls))
 	for _, url := range urls {
 		visited.Add(url)
 	}
@ -848,7 +854,7 @@ func (c *serverCommand) partialReRender(urls ...string) (err error) {
 	}

 	// 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()})
+	err = h.Build(hugolib.BuildCfg{NoBuildLock: false, RecentlyTouched: visited, PartialReRender: true, ErrRecovery: c.errState.wasErr()})

 	return
 }
@ -891,16 +897,16 @@ func (c *serverCommand) serve() error {
 	// To allow the en user to change the error template while the server is running, we use
 	// the freshest template we can provide.
 	var (
-		errTempl     tpl.Template
-		templHandler tpl.TemplateHandler
+		errTempl     *tplimpl.TemplInfo
+		templHandler *tplimpl.TemplateStore
 	)
-	getErrorTemplateAndHandler := func(h *hugolib.HugoSites) (tpl.Template, tpl.TemplateHandler) {
+	getErrorTemplateAndHandler := func(h *hugolib.HugoSites) (*tplimpl.TemplInfo, *tplimpl.TemplateStore) {
 		if h == nil {
 			return errTempl, templHandler
 		}
-		templHandler := h.Tmpl()
-		errTempl, found := templHandler.Lookup("_server/error.html")
-		if !found {
+		templHandler := h.GetTemplateStore()
+		errTempl := templHandler.LookupByPath("/_server/error.html")
+		if errTempl == nil {
 			panic("template server/error.html not found")
 		}
 		return errTempl, templHandler
@ -1228,3 +1234,24 @@ func formatByteCount(b uint64) string {
 	return fmt.Sprintf("%.1f %cB",
 		float64(b)/float64(div), "kMGTPE"[exp])
 }
+
+func canRedirect(requestURIWithoutQuery string, r *http.Request) bool {
+	if r.Header.Get(hugoHeaderRedirect) != "" {
+		return false
+	}
+	return isNavigation(requestURIWithoutQuery, r)
+}
+
+// Sec-Fetch-Mode should be sent by all recent browser versions, see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-Fetch-Mode#navigate
+// Fall back to the file extension if not set.
+// The main take here is that we don't want to have CSS/JS files etc. partake in this logic.
+func isNavigation(requestURIWithoutQuery string, r *http.Request) bool {
+	return r.Header.Get("Sec-Fetch-Mode") == "navigate" || isPropablyHTMLRequest(requestURIWithoutQuery)
+}
+
+func isPropablyHTMLRequest(requestURIWithoutQuery string) bool {
+	if strings.HasSuffix(requestURIWithoutQuery, "/") || strings.HasSuffix(requestURIWithoutQuery, "html") || strings.HasSuffix(requestURIWithoutQuery, "htm") {
+		return true
+	}
+	return !strings.Contains(requestURIWithoutQuery, ".")
+}
--- a/common/collections/append.go
+++ b/common/collections/append.go
@ -117,7 +117,7 @@ func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]any, erro
 			tos = append(tos, nil)
 			continue
 		}
-		for i := 0; i < slice.Len(); i++ {
+		for i := range slice.Len() {
 			tos = append(tos, slice.Index(i).Interface())
 		}
 	}
@ -128,7 +128,7 @@ func appendToInterfaceSliceFromValues(slice1, slice2 reflect.Value) ([]any, erro
 func appendToInterfaceSlice(tov reflect.Value, from ...any) ([]any, error) {
 	var tos []any

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

--- a/common/collections/append_test.go
+++ b/common/collections/append_test.go
@ -15,6 +15,7 @@ package collections

 import (
 	"html/template"
+	"reflect"
 	"testing"

 	qt "github.com/frankban/quicktest"
@ -77,6 +78,7 @@ func TestAppend(t *testing.T) {
 		{[]string{"a", "b"}, []any{nil}, []any{"a", "b", nil}},
 		{[]string{"a", "b"}, []any{nil, "d", nil}, []any{"a", "b", nil, "d", nil}},
 		{[]any{"a", nil, "c"}, []any{"d", nil, "f"}, []any{"a", nil, "c", "d", nil, "f"}},
+		{[]string{"a", "b"}, []any{}, []string{"a", "b"}},
 	} {

 		result, err := Append(test.start, test.addend...)
@ -146,3 +148,66 @@ func TestAppendShouldMakeACopyOfTheInputSlice(t *testing.T) {
 	c.Assert(result, qt.DeepEquals, []string{"a", "b", "c"})
 	c.Assert(slice, qt.DeepEquals, []string{"d", "b"})
 }
+
+func TestIndirect(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	type testStruct struct {
+		Field string
+	}
+
+	var (
+		nilPtr      *testStruct
+		nilIface    interface{} = nil
+		nonNilIface interface{} = &testStruct{Field: "hello"}
+	)
+
+	tests := []struct {
+		name     string
+		input    any
+		wantKind reflect.Kind
+		wantNil  bool
+	}{
+		{
+			name:     "nil pointer",
+			input:    nilPtr,
+			wantKind: reflect.Ptr,
+			wantNil:  true,
+		},
+		{
+			name:     "nil interface",
+			input:    nilIface,
+			wantKind: reflect.Invalid,
+			wantNil:  false,
+		},
+		{
+			name:     "non-nil pointer to struct",
+			input:    &testStruct{Field: "abc"},
+			wantKind: reflect.Struct,
+			wantNil:  false,
+		},
+		{
+			name:     "non-nil interface holding pointer",
+			input:    nonNilIface,
+			wantKind: reflect.Struct,
+			wantNil:  false,
+		},
+		{
+			name:     "plain value",
+			input:    testStruct{Field: "xyz"},
+			wantKind: reflect.Struct,
+			wantNil:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := reflect.ValueOf(tt.input)
+			got, isNil := indirect(v)
+
+			c.Assert(got.Kind(), qt.Equals, tt.wantKind)
+			c.Assert(isNil, qt.Equals, tt.wantNil)
+		})
+	}
+}
--- a/common/collections/slice_test.go
+++ b/common/collections/slice_test.go
@ -136,3 +136,37 @@ func TestSortedStringSlice(t *testing.T) {
 	c.Assert(s.Count("z"), qt.Equals, 0)
 	c.Assert(s.Count("a"), qt.Equals, 1)
 }
+
+func TestStringSliceToInterfaceSlice(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	tests := []struct {
+		name string
+		in   []string
+		want []any
+	}{
+		{
+			name: "empty slice",
+			in:   []string{},
+			want: []any{},
+		},
+		{
+			name: "single element",
+			in:   []string{"hello"},
+			want: []any{"hello"},
+		},
+		{
+			name: "multiple elements",
+			in:   []string{"a", "b", "c"},
+			want: []any{"a", "b", "c"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := StringSliceToInterfaceSlice(tt.in)
+			c.Assert(got, qt.DeepEquals, tt.want)
+		})
+	}
+}
--- a/common/collections/stack.go
+++ b/common/collections/stack.go
@ -13,6 +13,8 @@

 package collections

+import "slices"
+
 import "sync"

 // Stack is a simple LIFO stack that is safe for concurrent use.
@ -73,7 +75,7 @@ func (s *Stack[T]) DrainMatching(predicate func(T) bool) []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:]...)
+			s.items = slices.Delete(s.items, i, i+1)
 		}
 	}
 	return items
--- a/common/collections/stack_test.go
+++ b/common/collections/stack_test.go
@ -0,0 +1,77 @@
+package collections
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestNewStack(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	s := NewStack[int]()
+
+	c.Assert(s, qt.IsNotNil)
+}
+
+func TestStackBasic(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	s := NewStack[int]()
+
+	c.Assert(s.Len(), qt.Equals, 0)
+
+	s.Push(1)
+	s.Push(2)
+	s.Push(3)
+
+	c.Assert(s.Len(), qt.Equals, 3)
+
+	top, ok := s.Peek()
+	c.Assert(ok, qt.Equals, true)
+	c.Assert(top, qt.Equals, 3)
+
+	popped, ok := s.Pop()
+	c.Assert(ok, qt.Equals, true)
+	c.Assert(popped, qt.Equals, 3)
+
+	c.Assert(s.Len(), qt.Equals, 2)
+
+	_, _ = s.Pop()
+	_, _ = s.Pop()
+	_, ok = s.Pop()
+
+	c.Assert(ok, qt.Equals, false)
+}
+
+func TestStackDrain(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	s := NewStack[string]()
+	s.Push("a")
+	s.Push("b")
+
+	got := s.Drain()
+
+	c.Assert(got, qt.DeepEquals, []string{"a", "b"})
+	c.Assert(s.Len(), qt.Equals, 0)
+}
+
+func TestStackDrainMatching(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	s := NewStack[int]()
+	s.Push(1)
+	s.Push(2)
+	s.Push(3)
+	s.Push(4)
+
+	got := s.DrainMatching(func(v int) bool { return v%2 == 0 })
+
+	c.Assert(got, qt.DeepEquals, []int{4, 2})
+	c.Assert(s.Drain(), qt.DeepEquals, []int{1, 3})
+}
--- a/common/constants/constants.go
+++ b/common/constants/constants.go
@ -23,6 +23,8 @@ const (
 	WarnFrontMatterParamsOverrides = "warning-frontmatter-params-overrides"
 	WarnRenderShortcodesInHTML     = "warning-rendershortcodes-in-html"
 	WarnGoldmarkRawHTML            = "warning-goldmark-raw-html"
+	WarnPartialSuperfluousPrefix   = "warning-partial-superfluous-prefix"
+	WarnHomePageIsLeafBundle       = "warning-home-page-is-leaf-bundle"
 )

 // Field/method names with special meaning.
--- a/common/hashing/hashing.go
+++ b/common/hashing/hashing.go
@ -38,6 +38,19 @@ func XXHashFromReader(r io.Reader) (uint64, int64, error) {
 	return h.Sum64(), size, nil
 }

+// XxHashFromReaderHexEncoded calculates the xxHash for the given reader
+// and returns the hash as a hex encoded string.
+func XxHashFromReaderHexEncoded(r io.Reader) (string, error) {
+	h := getXxHashReadFrom()
+	defer putXxHashReadFrom(h)
+	_, err := io.Copy(h, r)
+	if err != nil {
+		return "", err
+	}
+	hash := h.Sum(nil)
+	return hex.EncodeToString(hash), nil
+}
+
 // XXHashFromString calculates the xxHash for the given string.
 func XXHashFromString(s string) (uint64, error) {
 	h := xxhash.New()
@ -70,6 +83,13 @@ func HashString(vs ...any) string {
 	return strconv.FormatUint(hash, 10)
 }

+// HashStringHex returns a hash from the given elements as a hex encoded string.
+// See HashString for more information.
+func HashStringHex(vs ...any) string {
+	hash := HashUint64(vs...)
+	return strconv.FormatUint(hash, 16)
+}
+
 var hashOptsPool = sync.Pool{
 	New: func() any {
 		return &hashstructure.HashOptions{
@ -103,16 +123,24 @@ func HashUint64(vs ...any) uint64 {
 		o = elements
 	}

-	hashOpts := getHashOpts()
-	defer putHashOpts(hashOpts)
-
-	hash, err := hashstructure.Hash(o, hashOpts)
+	hash, err := Hash(o)
 	if err != nil {
 		panic(err)
 	}
 	return hash
 }

+// Hash returns a hash from vs.
+func Hash(vs ...any) (uint64, error) {
+	hashOpts := getHashOpts()
+	defer putHashOpts(hashOpts)
+	var v any = vs
+	if len(vs) == 1 {
+		v = vs[0]
+	}
+	return hashstructure.Hash(v, hashOpts)
+}
+
 type keyer interface {
 	Key() string
 }
--- a/common/hashing/hashing_test.go
+++ b/common/hashing/hashing_test.go
@ -37,12 +37,12 @@ func TestXxHashFromReaderPara(t *testing.T) {
 	c := qt.New(t)

 	var wg sync.WaitGroup
-	for i := 0; i < 10; i++ {
+	for i := range 10 {
 		i := i
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < 100; j++ {
+			for j := range 100 {
 				s := strings.Repeat("Hello ", i+j+1*42)
 				r := strings.NewReader(s)
 				got, size, err := XXHashFromReader(r)
@ -142,3 +142,16 @@ func BenchmarkHashString(b *testing.B) {
 		})
 	}
 }
+
+func BenchmarkHashMap(b *testing.B) {
+	m := map[string]any{}
+	for i := range 1000 {
+		m[fmt.Sprintf("key%d", i)] = i
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		HashString(m)
+	}
+}
--- a/common/herrors/error_locator.go
+++ b/common/herrors/error_locator.go
@ -152,10 +152,7 @@ func locateError(r io.Reader, le FileError, matches LineMatcherFn) *ErrorContext
 	}

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

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

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

 		ectx.Lines = lines[low:high]

--- a/common/herrors/errors.go
+++ b/common/herrors/errors.go
@ -133,6 +133,21 @@ func IsNotExist(err error) bool {
 	return false
 }

+// IsExist returns true if the error is a file exists error.
+// Unlike os.IsExist, this also considers wrapped errors.
+func IsExist(err error) bool {
+	if os.IsExist(err) {
+		return true
+	}
+
+	// os.IsExist does not consider wrapped errors.
+	if os.IsExist(errors.Unwrap(err)) {
+		return true
+	}
+
+	return false
+}
+
 var nilPointerErrRe = regexp.MustCompile(`at <(.*)>: error calling (.*?): runtime error: invalid memory address or nil pointer dereference`)

 const deferredPrefix = "__hdeferred/"
--- a/common/herrors/file_error.go
+++ b/common/herrors/file_error.go
@ -258,8 +258,27 @@ func openFile(filename string, fs afero.Fs) (afero.File, string, error) {
 	return f, realFilename, nil
 }

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

 func extractFileTypePos(err error) (string, text.Position) {
-	err = Cause(err)
+	err = Unwrap(err)

 	var fileType string

@ -384,7 +403,7 @@ func extractPosition(e error) (pos text.Position) {
 	case godartsass.SassError:
 		span := v.Span
 		start := span.Start
-		filename, _ := paths.UrlToFilename(span.Url)
+		filename, _ := paths.UrlStringToFilename(span.Url)
 		pos.Filename = filename
 		pos.Offset = start.Offset
 		pos.ColumnNumber = start.Column
--- a/common/hexec/exec.go
+++ b/common/hexec/exec.go
@ -26,7 +26,9 @@ import (
 	"strings"
 	"sync"

-	"github.com/cli/safeexec"
+	"github.com/bep/logg"
+	"github.com/gohugoio/hugo/common/loggers"
+	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/security"
 )
@ -86,7 +88,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, workingDir string, log loggers.Logger) *Exec {
 	var baseEnviron []string
 	for _, v := range os.Environ() {
 		k, _ := config.SplitEnvVar(v)
@ -96,9 +98,11 @@ func New(cfg security.Config, workingDir string) *Exec {
 	}

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

@ -108,28 +112,18 @@ func IsNotFound(err error) bool {
 	return errors.As(err, &notFoundErr)
 }

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

 	// os.Environ filtered by the Exec.OsEnviron whitelist filter.
 	baseEnviron []string

-	npxInit      sync.Once
-	npxAvailable bool
+	newNPXRunnerCache *maps.Cache[string, func(arg ...any) (Runner, error)]
+	npxInit           sync.Once
+	npxAvailable      bool
 }

 func (e *Exec) New(name string, arg ...any) (Runner, error) {
@ -155,25 +149,86 @@ func (e *Exec) new(name string, fullyQualifiedName string, arg ...any) (Runner,
 	return cm.command(arg...)
 }

+type binaryLocation int
+
+func (b binaryLocation) String() string {
+	switch b {
+	case binaryLocationNodeModules:
+		return "node_modules/.bin"
+	case binaryLocationNpx:
+		return "npx"
+	case binaryLocationPath:
+		return "PATH"
+	}
+	return "unknown"
+}
+
+const (
+	binaryLocationNodeModules binaryLocation = iota + 1
+	binaryLocationNpx
+	binaryLocationPath
+)
+
 // 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.
+// If name is "tailwindcss", we will try the PATH as the second option.
 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...)
+	if err := e.sc.CheckAllowedExec(name); err != nil {
+		return nil, err
 	}
-	e.checkNpx()
-	if e.npxAvailable {
-		r, err := e.npx(name, arg...)
-		if err == nil {
-			return r, nil
+
+	newRunner, err := e.newNPXRunnerCache.GetOrCreate(name, func() (func(...any) (Runner, error), error) {
+		type tryFunc func() func(...any) (Runner, error)
+		tryFuncs := map[binaryLocation]tryFunc{
+			binaryLocationNodeModules: func() func(...any) (Runner, error) {
+				nodeBinFilename := filepath.Join(e.workingDir, nodeModulesBinPath, name)
+				_, err := exec.LookPath(nodeBinFilename)
+				if err != nil {
+					return nil
+				}
+				return func(arg2 ...any) (Runner, error) {
+					return e.new(name, nodeBinFilename, arg2...)
+				}
+			},
+			binaryLocationNpx: func() func(...any) (Runner, error) {
+				e.checkNpx()
+				if !e.npxAvailable {
+					return nil
+				}
+				return func(arg2 ...any) (Runner, error) {
+					return e.npx(name, arg2...)
+				}
+			},
+			binaryLocationPath: func() func(...any) (Runner, error) {
+				if _, err := exec.LookPath(name); err != nil {
+					return nil
+				}
+				return func(arg2 ...any) (Runner, error) {
+					return e.New(name, arg2...)
+				}
+			},
 		}
+
+		locations := []binaryLocation{binaryLocationNodeModules, binaryLocationNpx, binaryLocationPath}
+		if name == "tailwindcss" {
+			// See https://github.com/gohugoio/hugo/issues/13221#issuecomment-2574801253
+			locations = []binaryLocation{binaryLocationNodeModules, binaryLocationPath, binaryLocationNpx}
+		}
+		for _, loc := range locations {
+			if f := tryFuncs[loc](); f != nil {
+				e.infol.Logf("resolve %q using %s", name, loc)
+				return f, nil
+			}
+		}
+		return nil, &NotFoundError{name: name, method: fmt.Sprintf("in %s", locations[len(locations)-1])}
+	})
+	if err != nil {
+		return nil, err
 	}
-	return e.New(name, arg...)
+
+	return newRunner(arg...)
 }

 const (
@ -278,7 +333,7 @@ func (c *commandeer) command(arg ...any) (*cmdWrapper, error) {
 		bin = c.fullyQualifiedName
 	} else {
 		var err error
-		bin, err = safeexec.LookPath(c.name)
+		bin, err = exec.LookPath(c.name)
 		if err != nil {
 			return nil, &NotFoundError{
 				name:   c.name,
@ -316,7 +371,7 @@ func InPath(binaryName string) bool {
 	if strings.Contains(binaryName, "/") {
 		panic("binary name should not contain any slash")
 	}
-	_, err := safeexec.LookPath(binaryName)
+	_, err := exec.LookPath(binaryName)
 	return err == nil
 }

@ -326,7 +381,7 @@ func LookPath(binaryName string) string {
 	if strings.Contains(binaryName, "/") {
 		panic("binary name should not contain any slash")
 	}
-	s, err := safeexec.LookPath(binaryName)
+	s, err := exec.LookPath(binaryName)
 	if err != nil {
 		return ""
 	}
--- a/common/hreflect/helpers.go
+++ b/common/hreflect/helpers.go
@ -74,6 +74,16 @@ func IsTruthful(in any) bool {
 	}
 }

+// IsMap reports whether v is a map.
+func IsMap(v any) bool {
+	return reflect.ValueOf(v).Kind() == reflect.Map
+}
+
+// IsSlice reports whether v is a slice.
+func IsSlice(v any) bool {
+	return reflect.ValueOf(v).Kind() == reflect.Slice
+}
+
 var zeroType = reflect.TypeOf((*types.Zeroer)(nil)).Elem()

 // IsTruthfulValue returns whether the given value has a meaningful truth value.
@ -124,12 +134,7 @@ type methodKey struct {
 	name string
 }

-type methods struct {
-	sync.RWMutex
-	cache map[methodKey]int
-}
-
-var methodCache = &methods{cache: make(map[methodKey]int)}
+var methodCache sync.Map

 // GetMethodByName is the same as reflect.Value.MethodByName, but it caches the
 // type lookup.
@ -147,22 +152,16 @@ func GetMethodByName(v reflect.Value, name string) reflect.Value {
 // -1 if no such method exists.
 func GetMethodIndexByName(tp reflect.Type, name string) int {
 	k := methodKey{tp, name}
-	methodCache.RLock()
-	index, found := methodCache.cache[k]
-	methodCache.RUnlock()
+	v, found := methodCache.Load(k)
 	if found {
-		return index
+		return v.(int)
 	}
-
-	methodCache.Lock()
-	defer methodCache.Unlock()
-
 	m, ok := tp.MethodByName(name)
-	index = m.Index
+	index := m.Index
 	if !ok {
 		index = -1
 	}
-	methodCache.cache[k] = index
+	methodCache.Store(k, index)

 	if !ok {
 		return -1
@ -223,6 +222,27 @@ func AsTime(v reflect.Value, loc *time.Location) (time.Time, bool) {
 	return time.Time{}, false
 }

+// ToSliceAny converts the given value to a slice of any if possible.
+func ToSliceAny(v any) ([]any, bool) {
+	if v == nil {
+		return nil, false
+	}
+	switch vv := v.(type) {
+	case []any:
+		return vv, true
+	default:
+		vvv := reflect.ValueOf(v)
+		if vvv.Kind() == reflect.Slice {
+			out := make([]any, vvv.Len())
+			for i := range vvv.Len() {
+				out[i] = vvv.Index(i).Interface()
+			}
+			return out, true
+		}
+	}
+	return nil, false
+}
+
 func CallMethodByName(cxt context.Context, name string, v reflect.Value) []reflect.Value {
 	fn := v.MethodByName(name)
 	var args []reflect.Value
--- a/common/hreflect/helpers_test.go
+++ b/common/hreflect/helpers_test.go
@ -50,6 +50,19 @@ func TestIsContextType(t *testing.T) {
 	c.Assert(IsContextType(reflect.TypeOf(valueCtx)), qt.IsTrue)
 }

+func TestToSliceAny(t *testing.T) {
+	c := qt.New(t)
+
+	checkOK := func(in any, expected []any) {
+		out, ok := ToSliceAny(in)
+		c.Assert(ok, qt.Equals, true)
+		c.Assert(out, qt.DeepEquals, expected)
+	}
+
+	checkOK([]any{1, 2, 3}, []any{1, 2, 3})
+	checkOK([]int{1, 2, 3}, []any{1, 2, 3})
+}
+
 func BenchmarkIsContextType(b *testing.B) {
 	type k string
 	b.Run("value", func(b *testing.B) {
@ -121,3 +134,17 @@ func BenchmarkGetMethodByName(b *testing.B) {
 		}
 	}
 }
+
+func BenchmarkGetMethodByNamePara(b *testing.B) {
+	v := reflect.ValueOf(&testStruct{})
+	methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			for _, method := range methods {
+				_ = GetMethodByName(v, method)
+			}
+		}
+	})
+}
--- a/common/hstrings/strings.go
+++ b/common/hstrings/strings.go
@ -16,6 +16,7 @@ package hstrings
 import (
 	"fmt"
 	"regexp"
+	"slices"
 	"strings"
 	"sync"

@ -50,12 +51,7 @@ func (s StringEqualFold) Eq(s2 any) bool {

 // EqualAny returns whether a string is equal to any of the given strings.
 func EqualAny(a string, b ...string) bool {
-	for _, s := range b {
-		if a == s {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(b, a)
 }

 // regexpCache represents a cache of regexp objects protected by a mutex.
@ -103,12 +99,7 @@ func GetOrCompileRegexp(pattern string) (re *regexp.Regexp, err error) {
 // InSlice checks if a string is an element of a slice of strings
 // and returns a boolean value.
 func InSlice(arr []string, el string) bool {
-	for _, v := range arr {
-		if v == el {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(arr, el)
 }

 // InSlicEqualFold checks if a string is an element of a slice of strings
@ -137,7 +128,7 @@ func ToString(v any) (string, bool) {
 	return "", false
 }

-type Tuple struct {
-	First  string
-	Second string
-}
+type (
+	Strings2 [2]string
+	Strings3 [3]string
+)
--- a/common/hugio/hasBytesWriter_test.go
+++ b/common/hugio/hasBytesWriter_test.go
@ -46,18 +46,18 @@ func TestHasBytesWriter(t *testing.T) {
 		return strings.Repeat("ab cfo", r.Intn(33))
 	}

-	for i := 0; i < 22; i++ {
+	for range 22 {
 		h, w := neww()
-		fmt.Fprintf(w, rndStr()+"abc __foobar"+rndStr())
+		fmt.Fprint(w, rndStr()+"abc __foobar"+rndStr())
 		c.Assert(h.Patterns[0].Match, qt.Equals, true)

 		h, w = neww()
-		fmt.Fprintf(w, rndStr()+"abc __f")
-		fmt.Fprintf(w, "oo bar"+rndStr())
+		fmt.Fprint(w, rndStr()+"abc __f")
+		fmt.Fprint(w, "oo bar"+rndStr())
 		c.Assert(h.Patterns[0].Match, qt.Equals, true)

 		h, w = neww()
-		fmt.Fprintf(w, rndStr()+"abc __moo bar")
+		fmt.Fprint(w, rndStr()+"abc __moo bar")
 		c.Assert(h.Patterns[0].Match, qt.Equals, false)
 	}

--- a/common/hugo/hugo.go
+++ b/common/hugo/hugo.go
@ -139,9 +139,13 @@ func (i HugoInfo) IsMultilingual() bool {
 	return i.conf.IsMultilingual()
 }

-type contextKey string
+type contextKey uint8

-var markupScope = hcontext.NewContextDispatcher[string](contextKey("markupScope"))
+const (
+	contextKeyMarkupScope contextKey = iota
+)
+
+var markupScope = hcontext.NewContextDispatcher[string](contextKeyMarkupScope)

 type Context struct{}

@ -411,19 +415,36 @@ func IsDartSassGeV2() bool {
 // 2. Their theme to work for at least the last few Hugo versions.
 func Deprecate(item, alternative string, version string) {
 	level := deprecationLogLevelFromVersion(version)
-	DeprecateLevel(item, alternative, version, level)
+	deprecateLevel(item, alternative, version, level)
+}
+
+// See Deprecate for details.
+func DeprecateWithLogger(item, alternative string, version string, log logg.Logger) {
+	level := deprecationLogLevelFromVersion(version)
+	deprecateLevelWithLogger(item, alternative, version, level, log)
+}
+
+// DeprecateLevelMin informs about a deprecation starting at the given version, but with a minimum log level.
+func DeprecateLevelMin(item, alternative string, version string, minLevel logg.Level) {
+	level := max(deprecationLogLevelFromVersion(version), minLevel)
+	deprecateLevel(item, alternative, version, level)
+}
+
+// deprecateLevel informs about a deprecation logging at the given level.
+func deprecateLevel(item, alternative, version string, level logg.Level) {
+	deprecateLevelWithLogger(item, alternative, version, level, loggers.Log().Logger())
 }

 // DeprecateLevel informs about a deprecation logging at the given level.
-func DeprecateLevel(item, alternative, version string, level logg.Level) {
+func deprecateLevelWithLogger(item, alternative, version string, level logg.Level, log logg.Logger) {
 	var msg string
 	if level == logg.LevelError {
-		msg = fmt.Sprintf("%s was deprecated in Hugo %s and will be removed in Hugo %s. %s", item, version, CurrentVersion.Next().ReleaseVersion(), alternative)
+		msg = fmt.Sprintf("%s was deprecated in Hugo %s and subsequently removed. %s", item, version, alternative)
 	} else {
 		msg = fmt.Sprintf("%s was deprecated in Hugo %s and will be removed in a future release. %s", item, version, alternative)
 	}

-	loggers.Log().Logger().WithLevel(level).WithField(loggers.FieldNameCmd, "deprecated").Logf(msg)
+	log.WithLevel(level).WithField(loggers.FieldNameCmd, "deprecated").Logf("%s", msg)
 }

 // We usually do about one minor version a month.
@ -434,11 +455,11 @@ func deprecationLogLevelFromVersion(ver string) logg.Level {
 	to := CurrentVersion
 	minorDiff := to.Minor - from.Minor
 	switch {
-	case minorDiff >= 12:
-		// Start failing the build after about a year.
+	case minorDiff >= 15:
+		// Start failing the build after about 15 months.
 		return logg.LevelError
-	case minorDiff >= 6:
-		// Start printing warnings after about six months.
+	case minorDiff >= 3:
+		// Start printing warnings after about 3 months.
 		return logg.LevelWarn
 	default:
 		return logg.LevelInfo
--- a/common/hugo/hugo_test.go
+++ b/common/hugo/hugo_test.go
@ -57,11 +57,11 @@ func TestDeprecationLogLevelFromVersion(t *testing.T) {
 	c.Assert(deprecationLogLevelFromVersion("0.55.0"), qt.Equals, logg.LevelError)
 	ver := CurrentVersion
 	c.Assert(deprecationLogLevelFromVersion(ver.String()), qt.Equals, logg.LevelInfo)
-	ver.Minor -= 1
-	c.Assert(deprecationLogLevelFromVersion(ver.String()), qt.Equals, logg.LevelInfo)
-	ver.Minor -= 6
+	ver.Minor -= 3
 	c.Assert(deprecationLogLevelFromVersion(ver.String()), qt.Equals, logg.LevelWarn)
-	ver.Minor -= 6
+	ver.Minor -= 4
+	c.Assert(deprecationLogLevelFromVersion(ver.String()), qt.Equals, logg.LevelWarn)
+	ver.Minor -= 13
 	c.Assert(deprecationLogLevelFromVersion(ver.String()), qt.Equals, logg.LevelError)

 	// Added just to find the threshold for where we can remove deprecated items.
--- a/common/hugo/vars_extended.go
+++ b/common/hugo/vars_extended.go
@ -12,7 +12,6 @@
 // limitations under the License.

 //go:build extended
-// +build extended

 package hugo

--- a/common/hugo/vars_regular.go
+++ b/common/hugo/vars_regular.go
@ -12,7 +12,6 @@
 // limitations under the License.

 //go:build !extended
-// +build !extended

 package hugo

--- a/common/hugo/vars_withdeploy.go
+++ b/common/hugo/vars_withdeploy.go
@ -12,7 +12,6 @@
 // limitations under the License.

 //go:build withdeploy
-// +build withdeploy

 package hugo

--- a/common/hugo/vars_withdeploy_off.go
+++ b/common/hugo/vars_withdeploy_off.go
@ -12,7 +12,6 @@
 // limitations under the License.

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

 package hugo

--- a/common/hugo/version_current.go
+++ b/common/hugo/version_current.go
@ -17,7 +17,7 @@ package hugo
 // This should be the only one.
 var CurrentVersion = Version{
 	Major:      0,
-	Minor:      139,
-	PatchLevel: 4,
-	Suffix:     "",
+	Minor:      148,
+	PatchLevel: 0,
+	Suffix:     "-DEV",
 }
--- a/common/loggers/handlerterminal.go
+++ b/common/loggers/handlerterminal.go
@ -40,8 +40,8 @@ func newNoAnsiEscapeHandler(outWriter, errWriter io.Writer, noLevelPrefix bool,

 type noAnsiEscapeHandler struct {
 	mu            sync.Mutex
-	outWriter     io.Writer // Defaults to os.Stdout.
-	errWriter     io.Writer // Defaults to os.Stderr.
+	outWriter     io.Writer
+	errWriter     io.Writer
 	predicate     func(*logg.Entry) bool
 	noLevelPrefix bool
 }
--- a/common/loggers/logger.go
+++ b/common/loggers/logger.go
@ -38,8 +38,8 @@ var (
 // Options defines options for the logger.
 type Options struct {
 	Level              logg.Level
-	Stdout             io.Writer
-	Stderr             io.Writer
+	StdOut             io.Writer
+	StdErr             io.Writer
 	DistinctLevel      logg.Level
 	StoreErrors        bool
 	HandlerPost        func(e *logg.Entry) error
@ -48,21 +48,22 @@ type Options struct {

 // New creates a new logger with the given options.
 func New(opts Options) Logger {
-	if opts.Stdout == nil {
-		opts.Stdout = os.Stdout
+	if opts.StdOut == nil {
+		opts.StdOut = os.Stdout
 	}
-	if opts.Stderr == nil {
-		opts.Stderr = os.Stdout
+	if opts.StdErr == nil {
+		opts.StdErr = os.Stderr
 	}
+
 	if opts.Level == 0 {
 		opts.Level = logg.LevelWarn
 	}

 	var logHandler logg.Handler
-	if terminal.PrintANSIColors(os.Stdout) {
-		logHandler = newDefaultHandler(opts.Stdout, opts.Stderr)
+	if terminal.PrintANSIColors(os.Stderr) {
+		logHandler = newDefaultHandler(opts.StdErr, opts.StdErr)
 	} else {
-		logHandler = newNoAnsiEscapeHandler(opts.Stdout, opts.Stderr, false, nil)
+		logHandler = newNoAnsiEscapeHandler(opts.StdErr, opts.StdErr, false, nil)
 	}

 	errorsw := &strings.Builder{}
@ -137,7 +138,8 @@ func New(opts Options) Logger {
 		logCounters: logCounters,
 		errors:      errorsw,
 		reset:       reset,
-		out:         opts.Stdout,
+		stdOut:      opts.StdOut,
+		stdErr:      opts.StdErr,
 		level:       opts.Level,
 		logger:      logger,
 		tracel:      l.WithLevel(logg.LevelTrace),
@ -153,8 +155,6 @@ func NewDefault() Logger {
 	opts := Options{
 		DistinctLevel: logg.LevelWarn,
 		Level:         logg.LevelWarn,
-		Stdout:        os.Stdout,
-		Stderr:        os.Stdout,
 	}
 	return New(opts)
 }
@ -163,8 +163,6 @@ func NewTrace() Logger {
 	opts := Options{
 		DistinctLevel: logg.LevelWarn,
 		Level:         logg.LevelTrace,
-		Stdout:        os.Stdout,
-		Stderr:        os.Stdout,
 	}
 	return New(opts)
 }
@ -189,7 +187,8 @@ type Logger interface {
 	Level() logg.Level
 	LoggCount(logg.Level) int
 	Logger() logg.Logger
-	Out() io.Writer
+	StdOut() io.Writer
+	StdErr() io.Writer
 	Printf(format string, v ...any)
 	Println(v ...any)
 	PrintTimerIfDelayed(start time.Time, name string)
@ -207,7 +206,8 @@ type logAdapter struct {
 	logCounters *logLevelCounter
 	errors      *strings.Builder
 	reset       func()
-	out         io.Writer
+	stdOut      io.Writer
+	stdErr      io.Writer
 	level       logg.Level
 	logger      logg.Logger
 	tracel      logg.LevelLogger
@ -259,8 +259,12 @@ func (l *logAdapter) Logger() logg.Logger {
 	return l.logger
 }

-func (l *logAdapter) Out() io.Writer {
-	return l.out
+func (l *logAdapter) StdOut() io.Writer {
+	return l.stdOut
+}
+
+func (l *logAdapter) StdErr() io.Writer {
+	return l.stdErr
 }

 // PrintTimerIfDelayed prints a time statement to the FEEDBACK logger
@ -271,7 +275,7 @@ func (l *logAdapter) PrintTimerIfDelayed(start time.Time, name string) {
 	if milli < 500 {
 		return
 	}
-	l.Printf("%s in %v ms", name, milli)
+	fmt.Fprintf(l.stdErr, "%s in %v ms", name, milli)
 }

 func (l *logAdapter) Printf(format string, v ...any) {
@ -279,11 +283,11 @@ func (l *logAdapter) Printf(format string, v ...any) {
 	if !strings.HasSuffix(format, "\n") {
 		format += "\n"
 	}
-	fmt.Fprintf(l.out, format, v...)
+	fmt.Fprintf(l.stdOut, format, v...)
 }

 func (l *logAdapter) Println(v ...any) {
-	fmt.Fprintln(l.out, v...)
+	fmt.Fprintln(l.stdOut, v...)
 }

 func (l *logAdapter) Reset() {
--- a/common/loggers/logger_test.go
+++ b/common/loggers/logger_test.go
@ -31,13 +31,13 @@ func TestLogDistinct(t *testing.T) {
 	opts := loggers.Options{
 		DistinctLevel: logg.LevelWarn,
 		StoreErrors:   true,
-		Stdout:        io.Discard,
-		Stderr:        io.Discard,
+		StdOut:        io.Discard,
+		StdErr:        io.Discard,
 	}

 	l := loggers.New(opts)

-	for i := 0; i < 10; i++ {
+	for range 10 {
 		l.Errorln("error 1")
 		l.Errorln("error 2")
 		l.Warnln("warn 1")
@ -54,8 +54,8 @@ func TestHookLast(t *testing.T) {
 		HandlerPost: func(e *logg.Entry) error {
 			panic(e.Message)
 		},
-		Stdout: io.Discard,
-		Stderr: io.Discard,
+		StdOut: io.Discard,
+		StdErr: io.Discard,
 	}

 	l := loggers.New(opts)
@ -70,8 +70,8 @@ func TestOptionStoreErrors(t *testing.T) {

 	opts := loggers.Options{
 		StoreErrors: true,
-		Stderr:      &sb,
-		Stdout:      &sb,
+		StdErr:      &sb,
+		StdOut:      &sb,
 	}

 	l := loggers.New(opts)
@ -131,13 +131,13 @@ func TestReset(t *testing.T) {
 	opts := loggers.Options{
 		StoreErrors:   true,
 		DistinctLevel: logg.LevelWarn,
-		Stdout:        io.Discard,
-		Stderr:        io.Discard,
+		StdOut:        io.Discard,
+		StdErr:        io.Discard,
 	}

 	l := loggers.New(opts)

-	for i := 0; i < 3; i++ {
+	for range 3 {
 		l.Errorln("error 1")
 		l.Errorln("error 2")
 		l.Errorln("error 1")
--- a/common/loggers/loggerglobal.go
+++ b/common/loggers/loggerglobal.go
@ -21,7 +21,15 @@ import (
 	"github.com/bep/logg"
 )

-func InitGlobalLogger(level logg.Level, panicOnWarnings bool) {
+// SetGlobalLogger sets the global logger.
+// This is used in a few places in Hugo, e.g. deprecated functions.
+func SetGlobalLogger(logger Logger) {
+	logMu.Lock()
+	defer logMu.Unlock()
+	log = logger
+}
+
+func initGlobalLogger(level logg.Level, panicOnWarnings bool) {
 	logMu.Lock()
 	defer logMu.Unlock()
 	var logHookLast func(e *logg.Entry) error
@ -50,5 +58,5 @@ func Log() Logger {
 var log Logger

 func init() {
-	InitGlobalLogger(logg.LevelWarn, false)
+	initGlobalLogger(logg.LevelWarn, false)
 }
--- a/common/maps/cache.go
+++ b/common/maps/cache.go
@ -69,6 +69,14 @@ func (c *Cache[K, T]) GetOrCreate(key K, create func() (T, error)) (T, error) {
 	return v, nil
 }

+// Contains returns whether the given key exists in the cache.
+func (c *Cache[K, T]) Contains(key K) bool {
+	c.RLock()
+	_, found := c.m[key]
+	c.RUnlock()
+	return found
+}
+
 // InitAndGet initializes the cache if not already done and returns the value for the given key.
 // The init state will be reset on Reset or Drain.
 func (c *Cache[K, T]) InitAndGet(key K, init func(get func(key K) (T, bool), set func(key K, value T)) error) (T, error) {
@ -108,16 +116,30 @@ func (c *Cache[K, T]) Set(key K, value T) {
 	c.Unlock()
 }

+// SetIfAbsent sets the given key to the given value if the key does not already exist in the cache.
+func (c *Cache[K, T]) SetIfAbsent(key K, value T) {
+	c.RLock()
+	if _, found := c.get(key); !found {
+		c.RUnlock()
+		c.Set(key, value)
+	} else {
+		c.RUnlock()
+	}
+}
+
 func (c *Cache[K, T]) set(key K, value T) {
 	c.m[key] = value
 }

 // ForEeach calls the given function for each key/value pair in the cache.
-func (c *Cache[K, T]) ForEeach(f func(K, T)) {
+// If the function returns false, the iteration stops.
+func (c *Cache[K, T]) ForEeach(f func(K, T) bool) {
 	c.RLock()
 	defer c.RUnlock()
 	for k, v := range c.m {
-		f(k, v)
+		if !f(k, v) {
+			return
+		}
 	}
 }

@ -138,7 +160,7 @@ func (c *Cache[K, T]) Len() int {

 func (c *Cache[K, T]) Reset() {
 	c.Lock()
-	c.m = make(map[K]T)
+	clear(c.m)
 	c.hasBeenInitialized = false
 	c.Unlock()
 }
--- a/common/maps/maps_test.go
+++ b/common/maps/maps_test.go
@ -73,10 +73,14 @@ func TestPrepareParams(t *testing.T) {
 	for i, test := range tests {
 		t.Run(fmt.Sprint(i), func(t *testing.T) {
 			// PrepareParams modifies input.
+			prepareClone := PrepareParamsClone(test.input)
 			PrepareParams(test.input)
 			if !reflect.DeepEqual(test.expected, test.input) {
 				t.Errorf("[%d] Expected\n%#v, got\n%#v\n", i, test.expected, test.input)
 			}
+			if !reflect.DeepEqual(test.expected, prepareClone) {
+				t.Errorf("[%d] Expected\n%#v, got\n%#v\n", i, test.expected, prepareClone)
+			}
 		})
 	}
 }
--- a/common/maps/ordered.go
+++ b/common/maps/ordered.go
@ -0,0 +1,144 @@
+// 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 maps
+
+import (
+	"slices"
+
+	"github.com/gohugoio/hugo/common/hashing"
+)
+
+// Ordered is a map that can be iterated in the order of insertion.
+// Note that insertion order is not affected if a key is re-inserted into the map.
+// In a nil map, all operations are no-ops.
+// This is not thread safe.
+type Ordered[K comparable, T any] struct {
+	// The keys in the order they were added.
+	keys []K
+	// The values.
+	values map[K]T
+}
+
+// NewOrdered creates a new Ordered map.
+func NewOrdered[K comparable, T any]() *Ordered[K, T] {
+	return &Ordered[K, T]{values: make(map[K]T)}
+}
+
+// Set sets the value for the given key.
+// Note that insertion order is not affected if a key is re-inserted into the map.
+func (m *Ordered[K, T]) Set(key K, value T) {
+	if m == nil {
+		return
+	}
+	// Check if key already exists.
+	if _, found := m.values[key]; !found {
+		m.keys = append(m.keys, key)
+	}
+	m.values[key] = value
+}
+
+// Get gets the value for the given key.
+func (m *Ordered[K, T]) Get(key K) (T, bool) {
+	if m == nil {
+		var v T
+		return v, false
+	}
+	value, found := m.values[key]
+	return value, found
+}
+
+// Has returns whether the given key exists in the map.
+func (m *Ordered[K, T]) Has(key K) bool {
+	if m == nil {
+		return false
+	}
+	_, found := m.values[key]
+	return found
+}
+
+// Delete deletes the value for the given key.
+func (m *Ordered[K, T]) Delete(key K) {
+	if m == nil {
+		return
+	}
+	delete(m.values, key)
+	for i, k := range m.keys {
+		if k == key {
+			m.keys = slices.Delete(m.keys, i, i+1)
+			break
+		}
+	}
+}
+
+// Clone creates a shallow copy of the map.
+func (m *Ordered[K, T]) Clone() *Ordered[K, T] {
+	if m == nil {
+		return nil
+	}
+	clone := NewOrdered[K, T]()
+	for _, k := range m.keys {
+		clone.Set(k, m.values[k])
+	}
+	return clone
+}
+
+// Keys returns the keys in the order they were added.
+func (m *Ordered[K, T]) Keys() []K {
+	if m == nil {
+		return nil
+	}
+	return m.keys
+}
+
+// Values returns the values in the order they were added.
+func (m *Ordered[K, T]) Values() []T {
+	if m == nil {
+		return nil
+	}
+	var values []T
+	for _, k := range m.keys {
+		values = append(values, m.values[k])
+	}
+	return values
+}
+
+// Len returns the number of items in the map.
+func (m *Ordered[K, T]) Len() int {
+	if m == nil {
+		return 0
+	}
+	return len(m.keys)
+}
+
+// Range calls f sequentially for each key and value present in the map.
+// If f returns false, range stops the iteration.
+// TODO(bep) replace with iter.Seq2 when we bump go Go 1.24.
+func (m *Ordered[K, T]) Range(f func(key K, value T) bool) {
+	if m == nil {
+		return
+	}
+	for _, k := range m.keys {
+		if !f(k, m.values[k]) {
+			return
+		}
+	}
+}
+
+// Hash calculates a hash from the values.
+func (m *Ordered[K, T]) Hash() (uint64, error) {
+	if m == nil {
+		return 0, nil
+	}
+	return hashing.Hash(m.values)
+}
--- a/common/maps/ordered_test.go
+++ b/common/maps/ordered_test.go
@ -0,0 +1,99 @@
+// 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 maps
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestOrdered(t *testing.T) {
+	c := qt.New(t)
+
+	m := NewOrdered[string, int]()
+	m.Set("a", 1)
+	m.Set("b", 2)
+	m.Set("c", 3)
+
+	c.Assert(m.Keys(), qt.DeepEquals, []string{"a", "b", "c"})
+	c.Assert(m.Values(), qt.DeepEquals, []int{1, 2, 3})
+
+	v, found := m.Get("b")
+	c.Assert(found, qt.Equals, true)
+	c.Assert(v, qt.Equals, 2)
+
+	m.Set("b", 22)
+	c.Assert(m.Keys(), qt.DeepEquals, []string{"a", "b", "c"})
+	c.Assert(m.Values(), qt.DeepEquals, []int{1, 22, 3})
+
+	m.Delete("b")
+
+	c.Assert(m.Keys(), qt.DeepEquals, []string{"a", "c"})
+	c.Assert(m.Values(), qt.DeepEquals, []int{1, 3})
+}
+
+func TestOrderedHash(t *testing.T) {
+	c := qt.New(t)
+
+	m := NewOrdered[string, int]()
+	m.Set("a", 1)
+	m.Set("b", 2)
+	m.Set("c", 3)
+
+	h1, err := m.Hash()
+	c.Assert(err, qt.IsNil)
+
+	m.Set("d", 4)
+
+	h2, err := m.Hash()
+	c.Assert(err, qt.IsNil)
+
+	c.Assert(h1, qt.Not(qt.Equals), h2)
+
+	m = NewOrdered[string, int]()
+	m.Set("b", 2)
+	m.Set("a", 1)
+	m.Set("c", 3)
+
+	h3, err := m.Hash()
+	c.Assert(err, qt.IsNil)
+	// Order does not matter.
+	c.Assert(h1, qt.Equals, h3)
+}
+
+func TestOrderedNil(t *testing.T) {
+	c := qt.New(t)
+
+	var m *Ordered[string, int]
+
+	m.Set("a", 1)
+	c.Assert(m.Keys(), qt.IsNil)
+	c.Assert(m.Values(), qt.IsNil)
+	v, found := m.Get("a")
+	c.Assert(found, qt.Equals, false)
+	c.Assert(v, qt.Equals, 0)
+	m.Delete("a")
+	var b bool
+	m.Range(func(k string, v int) bool {
+		b = true
+		return true
+	})
+	c.Assert(b, qt.Equals, false)
+	c.Assert(m.Len(), qt.Equals, 0)
+	c.Assert(m.Clone(), qt.IsNil)
+	h, err := m.Hash()
+	c.Assert(err, qt.IsNil)
+	c.Assert(h, qt.Equals, uint64(0))
+}
--- a/common/maps/params.go
+++ b/common/maps/params.go
@ -303,7 +303,7 @@ func toMergeStrategy(v any) ParamsMergeStrategy {
 }

 // PrepareParams
-// * makes all the keys in the given map lower cased and will do so
+// * makes all the keys in the given map lower cased and will do so recursively.
 // * This will modify the map given.
 // * Any nested map[interface{}]interface{}, map[string]interface{},map[string]string  will be converted to Params.
 // * Any _merge value will be converted to proper type and value.
@ -343,3 +343,42 @@ func PrepareParams(m Params) {
 		}
 	}
 }
+
+// PrepareParamsClone is like PrepareParams, but it does not modify the input.
+func PrepareParamsClone(m Params) Params {
+	m2 := make(Params)
+	for k, v := range m {
+		var retyped bool
+		lKey := strings.ToLower(k)
+		if lKey == MergeStrategyKey {
+			v = toMergeStrategy(v)
+			retyped = true
+		} else {
+			switch vv := v.(type) {
+			case map[any]any:
+				var p Params = cast.ToStringMap(v)
+				v = PrepareParamsClone(p)
+				retyped = true
+			case map[string]any:
+				var p Params = v.(map[string]any)
+				v = PrepareParamsClone(p)
+				retyped = true
+			case map[string]string:
+				p := make(Params)
+				for k, v := range vv {
+					p[k] = v
+				}
+				v = p
+				PrepareParams(p)
+				retyped = true
+			}
+		}
+
+		if retyped || k != lKey {
+			m2[lKey] = v
+		} else {
+			m2[k] = v
+		}
+	}
+	return m2
+}
--- a/common/maps/scratch_test.go
+++ b/common/maps/scratch_test.go
@ -140,7 +140,7 @@ func TestScratchInParallel(t *testing.T) {
 	for i := 1; i <= 10; i++ {
 		wg.Add(1)
 		go func(j int) {
-			for k := 0; k < 10; k++ {
+			for k := range 10 {
 				newVal := int64(k + j)

 				_, err := scratch.Add(key, newVal)
--- a/common/para/para_test.go
+++ b/common/para/para_test.go
@ -42,7 +42,7 @@ func TestPara(t *testing.T) {
 	c.Run("Order", func(c *qt.C) {
 		n := 500
 		ints := make([]int, n)
-		for i := 0; i < n; i++ {
+		for i := range n {
 			ints[i] = i
 		}

@ -51,7 +51,7 @@ func TestPara(t *testing.T) {

 		var result []int
 		var mu sync.Mutex
-		for i := 0; i < n; i++ {
+		for i := range n {
 			i := i
 			r.Run(func() error {
 				mu.Lock()
@ -78,7 +78,7 @@ func TestPara(t *testing.T) {

 		var counter int64

-		for i := 0; i < n; i++ {
+		for range n {
 			r.Run(func() error {
 				atomic.AddInt64(&counter, 1)
 				time.Sleep(1 * time.Millisecond)
--- a/common/paths/pathparser.go
+++ b/common/paths/pathparser.go
@ -23,6 +23,11 @@ import (
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/hugofs/files"
 	"github.com/gohugoio/hugo/identity"
+	"github.com/gohugoio/hugo/resources/kinds"
+)
+
+const (
+	identifierBaseof = "baseof"
 )

 // PathParser parses a path into a Path.
@ -33,6 +38,10 @@ type PathParser struct {
 	// Reports whether the given language is disabled.
 	IsLangDisabled func(string) bool

+	// IsOutputFormat reports whether the given name is a valid output format.
+	// The second argument is optional.
+	IsOutputFormat func(name, ext string) bool
+
 	// Reports whether the given ext is a content file.
 	IsContentExt func(string) bool
 }
@ -83,13 +92,10 @@ func (pp *PathParser) Parse(c, s string) *Path {
 }

 func (pp *PathParser) newPath(component string) *Path {
-	return &Path{
-		component:             component,
-		posContainerLow:       -1,
-		posContainerHigh:      -1,
-		posSectionHigh:        -1,
-		posIdentifierLanguage: -1,
-	}
+	p := &Path{}
+	p.reset()
+	p.component = component
+	return p
 }

 func (pp *PathParser) parse(component, s string) (*Path, error) {
@ -114,10 +120,101 @@ func (pp *PathParser) parse(component, s string) (*Path, error) {
 	return p, nil
 }

-func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
-	hasLang := pp.LanguageIndex != nil
-	hasLang = hasLang && (component == files.ComponentFolderContent || component == files.ComponentFolderLayouts)
+func (pp *PathParser) parseIdentifier(component, s string, p *Path, i, lastDot, numDots int, isLast bool) {
+	if p.posContainerHigh != -1 {
+		return
+	}
+	mayHaveLang := numDots > 1 && p.posIdentifierLanguage == -1 && pp.LanguageIndex != nil
+	mayHaveLang = mayHaveLang && (component == files.ComponentFolderContent || component == files.ComponentFolderLayouts)
+	mayHaveOutputFormat := component == files.ComponentFolderLayouts
+	mayHaveKind := p.posIdentifierKind == -1 && mayHaveOutputFormat
+	var mayHaveLayout bool
+	if p.pathType == TypeShortcode {
+		mayHaveLayout = !isLast && component == files.ComponentFolderLayouts
+	} else {
+		mayHaveLayout = component == files.ComponentFolderLayouts
+	}

+	var found bool
+	var high int
+	if len(p.identifiersKnown) > 0 {
+		high = lastDot
+	} else {
+		high = len(p.s)
+	}
+	id := types.LowHigh[string]{Low: i + 1, High: high}
+	sid := p.s[id.Low:id.High]
+
+	if len(p.identifiersKnown) == 0 {
+		// The first is always the extension.
+		p.identifiersKnown = append(p.identifiersKnown, id)
+		found = true
+
+		// May also be the output format.
+		if mayHaveOutputFormat && pp.IsOutputFormat(sid, "") {
+			p.posIdentifierOutputFormat = 0
+		}
+	} else {
+
+		var langFound bool
+
+		if mayHaveLang {
+			var disabled bool
+			_, langFound = pp.LanguageIndex[sid]
+			if !langFound {
+				disabled = pp.IsLangDisabled != nil && pp.IsLangDisabled(sid)
+				if disabled {
+					p.disabled = true
+					langFound = true
+				}
+			}
+			found = langFound
+			if langFound {
+				p.identifiersKnown = append(p.identifiersKnown, id)
+				p.posIdentifierLanguage = len(p.identifiersKnown) - 1
+			}
+		}
+
+		if !found && mayHaveOutputFormat {
+			// At this point we may already have resolved an output format,
+			// but we need to keep looking for a more specific one, e.g. amp before html.
+			// Use both name and extension to prevent
+			// false positives on the form css.html.
+			if pp.IsOutputFormat(sid, p.Ext()) {
+				found = true
+				p.identifiersKnown = append(p.identifiersKnown, id)
+				p.posIdentifierOutputFormat = len(p.identifiersKnown) - 1
+			}
+		}
+
+		if !found && mayHaveKind {
+			if kinds.GetKindMain(sid) != "" {
+				found = true
+				p.identifiersKnown = append(p.identifiersKnown, id)
+				p.posIdentifierKind = len(p.identifiersKnown) - 1
+			}
+		}
+
+		if !found && sid == identifierBaseof {
+			found = true
+			p.identifiersKnown = append(p.identifiersKnown, id)
+			p.posIdentifierBaseof = len(p.identifiersKnown) - 1
+		}
+
+		if !found && mayHaveLayout {
+			p.identifiersKnown = append(p.identifiersKnown, id)
+			p.posIdentifierLayout = len(p.identifiersKnown) - 1
+			found = true
+		}
+
+		if !found {
+			p.identifiersUnknown = append(p.identifiersUnknown, id)
+		}
+
+	}
+}
+
+func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 	if runtime.GOOS == "windows" {
 		s = path.Clean(filepath.ToSlash(s))
 		if s == "." {
@ -140,46 +237,26 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {

 	p.s = s
 	slashCount := 0
+	lastDot := 0
+	lastSlashIdx := strings.LastIndex(s, "/")
+	numDots := strings.Count(s[lastSlashIdx+1:], ".")
+	if strings.Contains(s, "/_shortcodes/") {
+		p.pathType = TypeShortcode
+	}

 	for i := len(s) - 1; i >= 0; i-- {
 		c := s[i]

 		switch c {
 		case '.':
-			if p.posContainerHigh == -1 {
-				var high int
-				if len(p.identifiers) > 0 {
-					high = p.identifiers[len(p.identifiers)-1].Low - 1
-				} else {
-					high = len(p.s)
-				}
-				id := types.LowHigh[string]{Low: i + 1, High: high}
-				if len(p.identifiers) == 0 {
-					p.identifiers = append(p.identifiers, id)
-				} else if len(p.identifiers) == 1 {
-					// Check for a valid language.
-					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 {
-							p.posIdentifierLanguage = 1
-							p.identifiers = append(p.identifiers, id)
-						}
-					}
-				}
-			}
+			pp.parseIdentifier(component, s, p, i, lastDot, numDots, false)
+			lastDot = i
 		case '/':
 			slashCount++
 			if p.posContainerHigh == -1 {
+				if lastDot > 0 {
+					pp.parseIdentifier(component, s, p, i, lastDot, numDots, true)
+				}
 				p.posContainerHigh = i + 1
 			} else if p.posContainerLow == -1 {
 				p.posContainerLow = i + 1
@ -190,26 +267,52 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 		}
 	}

-	if len(p.identifiers) > 0 {
+	if len(p.identifiersKnown) > 0 {
 		isContentComponent := p.component == files.ComponentFolderContent || p.component == files.ComponentFolderArchetypes
 		isContent := isContentComponent && pp.IsContentExt(p.Ext())
-		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
-			}
+		id := p.identifiersKnown[len(p.identifiersKnown)-1]

-			if slashCount == 2 && p.IsLeafBundle() {
-				p.posSectionHigh = 0
+		if id.Low > p.posContainerHigh {
+			b := p.s[p.posContainerHigh : id.Low-1]
+			if isContent {
+				switch b {
+				case "index":
+					p.pathType = TypeLeaf
+				case "_index":
+					p.pathType = TypeBranch
+				default:
+					p.pathType = TypeContentSingle
+				}
+
+				if slashCount == 2 && p.IsLeafBundle() {
+					p.posSectionHigh = 0
+				}
+			} else if b == files.NameContentData && files.IsContentDataExt(p.Ext()) {
+				p.pathType = TypeContentData
 			}
-		} else if b == files.NameContentData && files.IsContentDataExt(p.Ext()) {
-			p.bundleType = PathTypeContentData
+		}
+	}
+
+	if p.pathType < TypeMarkup && component == files.ComponentFolderLayouts {
+		if p.posIdentifierBaseof != -1 {
+			p.pathType = TypeBaseof
+		} else {
+			pth := p.Path()
+			if strings.Contains(pth, "/_shortcodes/") {
+				p.pathType = TypeShortcode
+			} else if strings.Contains(pth, "/_markup/") {
+				p.pathType = TypeMarkup
+			} else if strings.HasPrefix(pth, "/_partials/") {
+				p.pathType = TypePartial
+			}
+		}
+	}
+
+	if p.pathType == TypeShortcode && p.posIdentifierLayout != -1 {
+		id := p.identifiersKnown[p.posIdentifierLayout]
+		if id.Low == p.posContainerHigh {
+			// First identifier is shortcode name.
+			p.posIdentifierLayout = -1
 		}
 	}

@ -218,35 +321,44 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {

 func ModifyPathBundleTypeResource(p *Path) {
 	if p.IsContent() {
-		p.bundleType = PathTypeContentResource
+		p.pathType = TypeContentResource
 	} else {
-		p.bundleType = PathTypeFile
+		p.pathType = TypeFile
 	}
 }

-type PathType int
+//go:generate stringer -type Type
+
+type Type int

 const (
+
 	// A generic resource, e.g. a JSON file.
-	PathTypeFile PathType = iota
+	TypeFile Type = iota

 	// All below are content files.
 	// A resource of a content type with front matter.
-	PathTypeContentResource
+	TypeContentResource

 	// E.g. /blog/my-post.md
-	PathTypeContentSingle
+	TypeContentSingle

 	// All below are bundled content files.

 	// Leaf bundles, e.g. /blog/my-post/index.md
-	PathTypeLeaf
+	TypeLeaf

 	// Branch bundles, e.g. /blog/_index.md
-	PathTypeBranch
+	TypeBranch

 	// Content data file, _content.gotmpl.
-	PathTypeContentData
+	TypeContentData
+
+	// Layout types.
+	TypeMarkup
+	TypeShortcode
+	TypePartial
+	TypeBaseof
 )

 type Path struct {
@ -257,13 +369,18 @@ type Path struct {
 	posContainerHigh int
 	posSectionHigh   int

-	component  string
-	bundleType PathType
+	component string
+	pathType  Type

-	identifiers []types.LowHigh[string]
+	identifiersKnown   []types.LowHigh[string]
+	identifiersUnknown []types.LowHigh[string]

-	posIdentifierLanguage int
-	disabled              bool
+	posIdentifierLanguage     int
+	posIdentifierOutputFormat int
+	posIdentifierKind         int
+	posIdentifierLayout       int
+	posIdentifierBaseof       int
+	disabled                  bool

 	trimLeadingSlash bool

@ -293,9 +410,13 @@ func (p *Path) reset() {
 	p.posContainerHigh = -1
 	p.posSectionHigh = -1
 	p.component = ""
-	p.bundleType = 0
-	p.identifiers = p.identifiers[:0]
+	p.pathType = 0
+	p.identifiersKnown = p.identifiersKnown[:0]
 	p.posIdentifierLanguage = -1
+	p.posIdentifierOutputFormat = -1
+	p.posIdentifierKind = -1
+	p.posIdentifierLayout = -1
+	p.posIdentifierBaseof = -1
 	p.disabled = false
 	p.trimLeadingSlash = false
 	p.unnormalized = nil
@ -316,6 +437,9 @@ func (p *Path) norm(s string) string {

 // IdentifierBase satisfies identity.Identity.
 func (p *Path) IdentifierBase() string {
+	if p.Component() == files.ComponentFolderLayouts {
+		return p.Path()
+	}
 	return p.Base()
 }

@ -332,6 +456,13 @@ func (p *Path) Container() string {
 	return p.norm(p.s[p.posContainerLow : p.posContainerHigh-1])
 }

+func (p *Path) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return p.Path()
+}
+
 // ContainerDir returns the container directory for this path.
 // For content bundles this will be the parent directory.
 func (p *Path) ContainerDir() string {
@ -352,13 +483,13 @@ func (p *Path) Section() string {
 // IsContent returns true if the path is a content file (e.g. mypost.md).
 // Note that this will also return true for content files in a bundle.
 func (p *Path) IsContent() bool {
-	return p.BundleType() >= PathTypeContentResource
+	return p.Type() >= TypeContentResource && p.Type() <= TypeContentData
 }

 // isContentPage returns true if the path is a content file (e.g. mypost.md),
 // but nof if inside a leaf bundle.
 func (p *Path) isContentPage() bool {
-	return p.BundleType() >= PathTypeContentSingle
+	return p.Type() >= TypeContentSingle && p.Type() <= TypeContentData
 }

 // Name returns the last element of path.
@ -372,7 +503,7 @@ func (p *Path) Name() string {
 // Name returns the last element of path without any extension.
 func (p *Path) NameNoExt() string {
 	if i := p.identifierIndex(0); i != -1 {
-		return p.s[p.posContainerHigh : p.identifiers[i].Low-1]
+		return p.s[p.posContainerHigh : p.identifiersKnown[i].Low-1]
 	}
 	return p.s[p.posContainerHigh:]
 }
@ -384,7 +515,7 @@ func (p *Path) NameNoLang() string {
 		return p.Name()
 	}

-	return p.s[p.posContainerHigh:p.identifiers[i].Low-1] + p.s[p.identifiers[i].High:]
+	return p.s[p.posContainerHigh:p.identifiersKnown[i].Low-1] + p.s[p.identifiersKnown[i].High:]
 }

 // BaseNameNoIdentifier returns the logical base name for a resource without any identifier (e.g. no extension).
@ -398,10 +529,26 @@ func (p *Path) BaseNameNoIdentifier() string {

 // NameNoIdentifier returns the last element of path without 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]
+	lowHigh := p.nameLowHigh()
+	return p.s[lowHigh.Low:lowHigh.High]
+}
+
+func (p *Path) nameLowHigh() types.LowHigh[string] {
+	if len(p.identifiersKnown) > 0 {
+		lastID := p.identifiersKnown[len(p.identifiersKnown)-1]
+		if p.posContainerHigh == lastID.Low {
+			// The last identifier is the name.
+			return lastID
+		}
+		return types.LowHigh[string]{
+			Low:  p.posContainerHigh,
+			High: p.identifiersKnown[len(p.identifiersKnown)-1].Low - 1,
+		}
+	}
+	return types.LowHigh[string]{
+		Low:  p.posContainerHigh,
+		High: len(p.s),
 	}
-	return p.s[p.posContainerHigh:]
 }

 // Dir returns all but the last element of path, typically the path's directory.
@ -421,6 +568,11 @@ func (p *Path) Path() (d string) {
 	return p.norm(p.s)
 }

+// PathNoLeadingSlash returns the full path without the leading slash.
+func (p *Path) PathNoLeadingSlash() string {
+	return p.Path()[1:]
+}
+
 // Unnormalized returns the Path with the original case preserved.
 func (p *Path) Unnormalized() *Path {
 	return p.unnormalized
@ -436,6 +588,28 @@ func (p *Path) PathNoIdentifier() string {
 	return p.base(false, false)
 }

+// PathBeforeLangAndOutputFormatAndExt returns the path up to the first identifier that is not a language or output format.
+func (p *Path) PathBeforeLangAndOutputFormatAndExt() string {
+	if len(p.identifiersKnown) == 0 {
+		return p.norm(p.s)
+	}
+	i := p.identifierIndex(0)
+
+	if j := p.posIdentifierOutputFormat; i == -1 || (j != -1 && j < i) {
+		i = j
+	}
+	if j := p.posIdentifierLanguage; i == -1 || (j != -1 && j < i) {
+		i = j
+	}
+
+	if i == -1 {
+		return p.norm(p.s)
+	}
+
+	id := p.identifiersKnown[i]
+	return p.norm(p.s[:id.Low-1])
+}
+
 // PathRel returns the path relative to the given owner.
 func (p *Path) PathRel(owner *Path) string {
 	ob := owner.Base()
@ -462,26 +636,42 @@ func (p *Path) Base() string {
 	return p.base(!p.isContentPage(), p.IsBundle())
 }

+// Used in template lookups.
+// For pages with Type set, we treat that as the section.
+func (p *Path) BaseReTyped(typ string) (d string) {
+	base := p.Base()
+	if typ == "" || p.Section() == typ {
+		return base
+	}
+	d = "/" + typ
+	if p.posSectionHigh != -1 {
+		d += base[p.posSectionHigh:]
+	}
+	d = p.norm(d)
+	return
+}
+
 // BaseNoLeadingSlash returns the base path without the leading slash.
 func (p *Path) BaseNoLeadingSlash() string {
 	return p.Base()[1:]
 }

 func (p *Path) base(preserveExt, isBundle bool) string {
-	if len(p.identifiers) == 0 {
+	if len(p.identifiersKnown) == 0 {
 		return p.norm(p.s)
 	}

-	if preserveExt && len(p.identifiers) == 1 {
+	if preserveExt && len(p.identifiersKnown) == 1 {
 		// Preserve extension.
 		return p.norm(p.s)
 	}

-	id := p.identifiers[len(p.identifiers)-1]
-	high := id.Low - 1
+	var high int

 	if isBundle {
 		high = p.posContainerHigh - 1
+	} else {
+		high = p.nameLowHigh().High
 	}

 	if high == 0 {
@ -493,7 +683,7 @@ func (p *Path) base(preserveExt, isBundle bool) string {
 	}

 	// For txt files etc. we want to preserve the extension.
-	id = p.identifiers[0]
+	id := p.identifiersKnown[0]

 	return p.norm(p.s[:high] + p.s[id.Low-1:id.High])
 }
@ -502,8 +692,20 @@ func (p *Path) Ext() string {
 	return p.identifierAsString(0)
 }

+func (p *Path) OutputFormat() string {
+	return p.identifierAsString(p.posIdentifierOutputFormat)
+}
+
+func (p *Path) Kind() string {
+	return p.identifierAsString(p.posIdentifierKind)
+}
+
+func (p *Path) Layout() string {
+	return p.identifierAsString(p.posIdentifierLayout)
+}
+
 func (p *Path) Lang() string {
-	return p.identifierAsString(1)
+	return p.identifierAsString(p.posIdentifierLanguage)
 }

 func (p *Path) Identifier(i int) string {
@ -515,35 +717,43 @@ func (p *Path) Disabled() bool {
 }

 func (p *Path) Identifiers() []string {
-	ids := make([]string, len(p.identifiers))
-	for i, id := range p.identifiers {
+	ids := make([]string, len(p.identifiersKnown))
+	for i, id := range p.identifiersKnown {
 		ids[i] = p.s[id.Low:id.High]
 	}
 	return ids
 }

-func (p *Path) BundleType() PathType {
-	return p.bundleType
+func (p *Path) IdentifiersUnknown() []string {
+	ids := make([]string, len(p.identifiersUnknown))
+	for i, id := range p.identifiersUnknown {
+		ids[i] = p.s[id.Low:id.High]
+	}
+	return ids
+}
+
+func (p *Path) Type() Type {
+	return p.pathType
 }

 func (p *Path) IsBundle() bool {
-	return p.bundleType >= PathTypeLeaf
+	return p.pathType >= TypeLeaf && p.pathType <= TypeContentData
 }

 func (p *Path) IsBranchBundle() bool {
-	return p.bundleType == PathTypeBranch
+	return p.pathType == TypeBranch
 }

 func (p *Path) IsLeafBundle() bool {
-	return p.bundleType == PathTypeLeaf
+	return p.pathType == TypeLeaf
 }

 func (p *Path) IsContentData() bool {
-	return p.bundleType == PathTypeContentData
+	return p.pathType == TypeContentData
 }

-func (p Path) ForBundleType(t PathType) *Path {
-	p.bundleType = t
+func (p Path) ForType(t Type) *Path {
+	p.pathType = t
 	return &p
 }

@ -553,12 +763,12 @@ func (p *Path) identifierAsString(i int) string {
 		return ""
 	}

-	id := p.identifiers[i]
+	id := p.identifiersKnown[i]
 	return p.s[id.Low:id.High]
 }

 func (p *Path) identifierIndex(i int) int {
-	if i < 0 || i >= len(p.identifiers) {
+	if i < 0 || i >= len(p.identifiersKnown) {
 		return -1
 	}
 	return i
--- a/common/paths/pathparser_test.go
+++ b/common/paths/pathparser_test.go
@ -18,6 +18,7 @@ import (
 	"testing"

 	"github.com/gohugoio/hugo/hugofs/files"
+	"github.com/gohugoio/hugo/resources/kinds"

 	qt "github.com/frankban/quicktest"
 )
@ -26,10 +27,18 @@ var testParser = &PathParser{
 	LanguageIndex: map[string]int{
 		"no": 0,
 		"en": 1,
+		"fr": 2,
 	},
 	IsContentExt: func(ext string) bool {
 		return ext == "md"
 	},
+	IsOutputFormat: func(name, ext string) bool {
+		switch name {
+		case "html", "amp", "csv", "rss":
+			return true
+		}
+		return false
+	},
 }

 func TestParse(t *testing.T) {
@ -105,17 +114,19 @@ func TestParse(t *testing.T) {
 			"Basic Markdown file",
 			"/a/b/c.md",
 			func(c *qt.C, p *Path) {
+				c.Assert(p.Ext(), qt.Equals, "md")
+				c.Assert(p.Type(), qt.Equals, TypeContentSingle)
 				c.Assert(p.IsContent(), qt.IsTrue)
 				c.Assert(p.IsLeafBundle(), qt.IsFalse)
 				c.Assert(p.Name(), qt.Equals, "c.md")
 				c.Assert(p.Base(), qt.Equals, "/a/b/c")
+				c.Assert(p.BaseReTyped("foo"), qt.Equals, "/foo/b/c")
 				c.Assert(p.Section(), qt.Equals, "a")
 				c.Assert(p.BaseNameNoIdentifier(), qt.Equals, "c")
 				c.Assert(p.Path(), qt.Equals, "/a/b/c.md")
 				c.Assert(p.Dir(), qt.Equals, "/a/b")
 				c.Assert(p.Container(), qt.Equals, "b")
 				c.Assert(p.ContainerDir(), qt.Equals, "/a/b")
-				c.Assert(p.Ext(), qt.Equals, "md")
 			},
 		},
 		{
@ -130,7 +141,7 @@ func TestParse(t *testing.T) {

 				// Reclassify it as a content resource.
 				ModifyPathBundleTypeResource(p)
-				c.Assert(p.BundleType(), qt.Equals, PathTypeContentResource)
+				c.Assert(p.Type(), qt.Equals, TypeContentResource)
 				c.Assert(p.IsContent(), qt.IsTrue)
 				c.Assert(p.Name(), qt.Equals, "b.md")
 				c.Assert(p.Base(), qt.Equals, "/a/b.md")
@ -163,8 +174,10 @@ func TestParse(t *testing.T) {
 				c.Assert(p.NameNoIdentifier(), qt.Equals, "b.a.b")
 				c.Assert(p.NameNoLang(), qt.Equals, "b.a.b.txt")
 				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"txt", "no"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{"b", "a", "b"})
 				c.Assert(p.Base(), qt.Equals, "/a/b.a.b.txt")
 				c.Assert(p.BaseNoLeadingSlash(), qt.Equals, "a/b.a.b.txt")
+				c.Assert(p.Path(), qt.Equals, "/a/b.a.b.no.txt")
 				c.Assert(p.PathNoLang(), qt.Equals, "/a/b.a.b.txt")
 				c.Assert(p.Ext(), qt.Equals, "txt")
 				c.Assert(p.PathNoIdentifier(), qt.Equals, "/a/b.a.b")
@ -174,7 +187,11 @@ func TestParse(t *testing.T) {
 			"Home branch cundle",
 			"/_index.md",
 			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"md"})
+				c.Assert(p.IsBranchBundle(), qt.IsTrue)
+				c.Assert(p.IsBundle(), qt.IsTrue)
 				c.Assert(p.Base(), qt.Equals, "/")
+				c.Assert(p.BaseReTyped("foo"), qt.Equals, "/foo")
 				c.Assert(p.Path(), qt.Equals, "/_index.md")
 				c.Assert(p.Container(), qt.Equals, "")
 				c.Assert(p.ContainerDir(), qt.Equals, "/")
@ -185,12 +202,14 @@ func TestParse(t *testing.T) {
 			"/a/index.md",
 			func(c *qt.C, p *Path) {
 				c.Assert(p.Base(), qt.Equals, "/a")
+				c.Assert(p.BaseReTyped("foo"), qt.Equals, "/foo/a")
 				c.Assert(p.BaseNameNoIdentifier(), qt.Equals, "a")
 				c.Assert(p.Container(), qt.Equals, "a")
 				c.Assert(p.Container(), qt.Equals, "a")
 				c.Assert(p.ContainerDir(), qt.Equals, "")
 				c.Assert(p.Dir(), qt.Equals, "/a")
 				c.Assert(p.Ext(), qt.Equals, "md")
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{"index"})
 				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"md"})
 				c.Assert(p.IsBranchBundle(), qt.IsFalse)
 				c.Assert(p.IsBundle(), qt.IsTrue)
@ -208,6 +227,7 @@ func TestParse(t *testing.T) {
 			func(c *qt.C, p *Path) {
 				c.Assert(p.Base(), qt.Equals, "/a/b")
 				c.Assert(p.BaseNameNoIdentifier(), qt.Equals, "b")
+				c.Assert(p.BaseReTyped("foo"), qt.Equals, "/foo/b")
 				c.Assert(p.Container(), qt.Equals, "b")
 				c.Assert(p.ContainerDir(), qt.Equals, "/a")
 				c.Assert(p.Dir(), qt.Equals, "/a/b")
@ -220,6 +240,7 @@ func TestParse(t *testing.T) {
 				c.Assert(p.NameNoExt(), qt.Equals, "index.no")
 				c.Assert(p.NameNoIdentifier(), qt.Equals, "index")
 				c.Assert(p.NameNoLang(), qt.Equals, "index.md")
+				c.Assert(p.Path(), qt.Equals, "/a/b/index.no.md")
 				c.Assert(p.PathNoLang(), qt.Equals, "/a/b/index.md")
 				c.Assert(p.Section(), qt.Equals, "a")
 			},
@ -355,11 +376,225 @@ func TestParse(t *testing.T) {
 	}
 	for _, test := range tests {
 		c.Run(test.name, func(c *qt.C) {
+			if test.name != "Home branch cundle" {
+				// return
+			}
 			test.assert(c, testParser.Parse(files.ComponentFolderContent, test.path))
 		})
 	}
 }

+func TestParseLayouts(t *testing.T) {
+	c := qt.New(t)
+
+	tests := []struct {
+		name   string
+		path   string
+		assert func(c *qt.C, p *Path)
+	}{
+		{
+			"Basic",
+			"/list.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Base(), qt.Equals, "/list.html")
+				c.Assert(p.OutputFormat(), qt.Equals, "html")
+			},
+		},
+		{
+			"Lang",
+			"/list.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "no", "list"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Base(), qt.Equals, "/list.html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+			},
+		},
+		{
+			"Kind",
+			"/section.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Kind(), qt.Equals, kinds.KindSection)
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "no", "section"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Base(), qt.Equals, "/section.html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+			},
+		},
+		{
+			"Layout",
+			"/list.section.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Layout(), qt.Equals, "list")
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "no", "section", "list"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Base(), qt.Equals, "/list.html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+			},
+		},
+		{
+			"Layout multiple",
+			"/mylayout.list.section.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Layout(), qt.Equals, "mylayout")
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "no", "section", "list", "mylayout"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Base(), qt.Equals, "/mylayout.html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+			},
+		},
+		{
+			"Layout shortcode",
+			"/_shortcodes/myshort.list.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Layout(), qt.Equals, "list")
+			},
+		},
+		{
+			"Layout baseof",
+			"/baseof.list.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Layout(), qt.Equals, "list")
+			},
+		},
+		{
+			"Lang and output format",
+			"/list.no.amp.not.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "not", "amp", "no", "list"})
+				c.Assert(p.OutputFormat(), qt.Equals, "amp")
+				c.Assert(p.Ext(), qt.Equals, "html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+				c.Assert(p.Base(), qt.Equals, "/list.html")
+			},
+		},
+		{
+			"Term",
+			"/term.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Base(), qt.Equals, "/term.html")
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "term"})
+				c.Assert(p.PathNoIdentifier(), qt.Equals, "/term")
+				c.Assert(p.PathBeforeLangAndOutputFormatAndExt(), qt.Equals, "/term")
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.Kind(), qt.Equals, "term")
+				c.Assert(p.OutputFormat(), qt.Equals, "html")
+			},
+		},
+		{
+			"Shortcode with layout",
+			"/_shortcodes/myshortcode.list.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Base(), qt.Equals, "/_shortcodes/myshortcode.html")
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "list"})
+				c.Assert(p.Layout(), qt.Equals, "list")
+				c.Assert(p.PathNoIdentifier(), qt.Equals, "/_shortcodes/myshortcode")
+				c.Assert(p.PathBeforeLangAndOutputFormatAndExt(), qt.Equals, "/_shortcodes/myshortcode.list")
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.Kind(), qt.Equals, "")
+				c.Assert(p.OutputFormat(), qt.Equals, "html")
+			},
+		},
+		{
+			"Sub dir",
+			"/pages/home.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "home"})
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.Kind(), qt.Equals, "home")
+				c.Assert(p.OutputFormat(), qt.Equals, "html")
+				c.Assert(p.Dir(), qt.Equals, "/pages")
+			},
+		},
+		{
+			"Baseof",
+			"/pages/baseof.list.section.fr.amp.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "amp", "fr", "section", "list", "baseof"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Kind(), qt.Equals, kinds.KindSection)
+				c.Assert(p.Lang(), qt.Equals, "fr")
+				c.Assert(p.OutputFormat(), qt.Equals, "amp")
+				c.Assert(p.Dir(), qt.Equals, "/pages")
+				c.Assert(p.NameNoIdentifier(), qt.Equals, "baseof")
+				c.Assert(p.Type(), qt.Equals, TypeBaseof)
+				c.Assert(p.IdentifierBase(), qt.Equals, "/pages/baseof.list.section.fr.amp.html")
+			},
+		},
+		{
+			"Markup",
+			"/_markup/render-link.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeMarkup)
+			},
+		},
+		{
+			"Markup nested",
+			"/foo/_markup/render-link.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeMarkup)
+			},
+		},
+		{
+			"Shortcode",
+			"/_shortcodes/myshortcode.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+			},
+		},
+		{
+			"Shortcode nested",
+			"/foo/_shortcodes/myshortcode.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+			},
+		},
+		{
+			"Shortcode nested sub",
+			"/foo/_shortcodes/foo/myshortcode.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+			},
+		},
+		{
+			"Partials",
+			"/_partials/foo.bar",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypePartial)
+			},
+		},
+		{
+			"Shortcode lang in root",
+			"/_shortcodes/no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.NameNoIdentifier(), qt.Equals, "no")
+			},
+		},
+		{
+			"Shortcode lang layout",
+			"/_shortcodes/myshortcode.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+				c.Assert(p.Lang(), qt.Equals, "no")
+				c.Assert(p.Layout(), qt.Equals, "")
+				c.Assert(p.NameNoIdentifier(), qt.Equals, "myshortcode")
+			},
+		},
+	}
+
+	for _, test := range tests {
+		c.Run(test.name, func(c *qt.C) {
+			if test.name != "Shortcode lang layout" {
+				// return
+			}
+			test.assert(c, testParser.Parse(files.ComponentFolderLayouts, test.path))
+		})
+	}
+}
+
 func TestHasExt(t *testing.T) {
 	c := qt.New(t)

--- a/common/paths/paths_integration_test.go
+++ b/common/paths/paths_integration_test.go
@ -78,3 +78,26 @@ disablePathToLower = true
 	b.AssertFileContent("public/en/mysection/mybundle/index.html", "en|Single")
 	b.AssertFileContent("public/fr/MySection/MyBundle/index.html", "fr|Single")
 }
+
+func TestIssue13596(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['home','rss','section','sitemap','taxonomy','term']
+-- content/p1/index.md --
+---
+title: p1
+---
+-- content/p1/a.1.txt --
+-- content/p1/a.2.txt --
+-- layouts/all.html --
+{{ range .Resources.Match "*" }}{{ .Name }}|{{ end }}
+`
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/p1/index.html", "a.1.txt|a.2.txt|")
+	b.AssertFileExists("public/p1/a.1.txt", true)
+	b.AssertFileExists("public/p1/a.2.txt", true) // fails
+}
--- a/common/paths/pathtype_string.go
+++ b/common/paths/pathtype_string.go
@ -1,27 +0,0 @@
-// Code generated by "stringer -type=PathType"; DO NOT EDIT.
-
-package paths
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[PathTypeFile-0]
-	_ = x[PathTypeContentResource-1]
-	_ = x[PathTypeContentSingle-2]
-	_ = x[PathTypeLeaf-3]
-	_ = x[PathTypeBranch-4]
-}
-
-const _PathType_name = "PathTypeFilePathTypeContentResourcePathTypeContentSinglePathTypeLeafPathTypeBranch"
-
-var _PathType_index = [...]uint8{0, 12, 35, 56, 68, 82}
-
-func (i PathType) String() string {
-	if i < 0 || i >= PathType(len(_PathType_index)-1) {
-		return "PathType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _PathType_name[_PathType_index[i]:_PathType_index[i+1]]
-}
--- a/common/paths/type_string.go
+++ b/common/paths/type_string.go
@ -0,0 +1,32 @@
+// Code generated by "stringer -type Type"; DO NOT EDIT.
+
+package paths
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[TypeFile-0]
+	_ = x[TypeContentResource-1]
+	_ = x[TypeContentSingle-2]
+	_ = x[TypeLeaf-3]
+	_ = x[TypeBranch-4]
+	_ = x[TypeContentData-5]
+	_ = x[TypeMarkup-6]
+	_ = x[TypeShortcode-7]
+	_ = x[TypePartial-8]
+	_ = x[TypeBaseof-9]
+}
+
+const _Type_name = "TypeFileTypeContentResourceTypeContentSingleTypeLeafTypeBranchTypeContentDataTypeMarkupTypeShortcodeTypePartialTypeBaseof"
+
+var _Type_index = [...]uint8{0, 8, 27, 44, 52, 62, 77, 87, 100, 111, 121}
+
+func (i Type) String() string {
+	if i < 0 || i >= Type(len(_Type_index)-1) {
+		return "Type(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _Type_name[_Type_index[i]:_Type_index[i+1]]
+}
--- a/common/paths/url.go
+++ b/common/paths/url.go
@ -1,4 +1,4 @@
-// Copyright 2021 The Hugo Authors. All rights reserved.
+// 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.
@ -18,6 +18,7 @@ import (
 	"net/url"
 	"path"
 	"path/filepath"
+	"runtime"
 	"strings"
 )

@ -159,31 +160,6 @@ func Uglify(in string) string {
 	return path.Clean(in)
 }

-// UrlToFilename converts the URL s to a filename.
-// If ParseRequestURI fails, the input is just converted to OS specific slashes and returned.
-func UrlToFilename(s string) (string, bool) {
-	u, err := url.ParseRequestURI(s)
-	if err != nil {
-		return filepath.FromSlash(s), false
-	}
-
-	p := u.Path
-
-	if p == "" {
-		p, _ = url.QueryUnescape(u.Opaque)
-		return filepath.FromSlash(p), true
-	}
-
-	p = filepath.FromSlash(p)
-
-	if u.Host != "" {
-		// C:\data\file.txt
-		p = strings.ToUpper(u.Host) + ":" + p
-	}
-
-	return p, true
-}
-
 // URLEscape escapes unicode letters.
 func URLEscape(uri string) string {
 	// escape unicode letters
@ -193,3 +169,105 @@ func URLEscape(uri string) string {
 	}
 	return u.String()
 }
+
+// TrimExt trims the extension from a path..
+func TrimExt(in string) string {
+	return strings.TrimSuffix(in, path.Ext(in))
+}
+
+// From https://github.com/golang/go/blob/e0c76d95abfc1621259864adb3d101cf6f1f90fc/src/cmd/go/internal/web/url.go#L45
+func UrlFromFilename(filename string) (*url.URL, error) {
+	if !filepath.IsAbs(filename) {
+		return nil, fmt.Errorf("filepath must be absolute")
+	}
+
+	// If filename has a Windows volume name, convert the volume to a host and prefix
+	// per https://blogs.msdn.microsoft.com/ie/2006/12/06/file-uris-in-windows/.
+	if vol := filepath.VolumeName(filename); vol != "" {
+		if strings.HasPrefix(vol, `\\`) {
+			filename = filepath.ToSlash(filename[2:])
+			i := strings.IndexByte(filename, '/')
+
+			if i < 0 {
+				// A degenerate case.
+				// \\host.example.com (without a share name)
+				// becomes
+				// file://host.example.com/
+				return &url.URL{
+					Scheme: "file",
+					Host:   filename,
+					Path:   "/",
+				}, nil
+			}
+
+			// \\host.example.com\Share\path\to\file
+			// becomes
+			// file://host.example.com/Share/path/to/file
+			return &url.URL{
+				Scheme: "file",
+				Host:   filename[:i],
+				Path:   filepath.ToSlash(filename[i:]),
+			}, nil
+		}
+
+		// C:\path\to\file
+		// becomes
+		// file:///C:/path/to/file
+		return &url.URL{
+			Scheme: "file",
+			Path:   "/" + filepath.ToSlash(filename),
+		}, nil
+	}
+
+	// /path/to/file
+	// becomes
+	// file:///path/to/file
+	return &url.URL{
+		Scheme: "file",
+		Path:   filepath.ToSlash(filename),
+	}, nil
+}
+
+// UrlStringToFilename converts the URL s to a filename.
+// If ParseRequestURI fails, the input is just converted to OS specific slashes and returned.
+func UrlStringToFilename(s string) (string, bool) {
+	u, err := url.ParseRequestURI(s)
+	if err != nil {
+		return filepath.FromSlash(s), false
+	}
+
+	p := u.Path
+
+	if p == "" {
+		p, _ = url.QueryUnescape(u.Opaque)
+		return filepath.FromSlash(p), false
+	}
+
+	if runtime.GOOS != "windows" {
+		return p, true
+	}
+
+	if len(p) == 0 || p[0] != '/' {
+		return filepath.FromSlash(p), false
+	}
+
+	p = filepath.FromSlash(p)
+
+	if len(u.Host) == 1 {
+		// file://c/Users/...
+		return strings.ToUpper(u.Host) + ":" + p, true
+	}
+
+	if u.Host != "" && u.Host != "localhost" {
+		if filepath.VolumeName(u.Host) != "" {
+			return "", false
+		}
+		return `\\` + u.Host + p, true
+	}
+
+	if vol := filepath.VolumeName(p[1:]); vol == "" || strings.HasPrefix(vol, `\\`) {
+		return "", false
+	}
+
+	return p[1:], true
+}
--- a/common/rungroup/rungroup.go
+++ b/common/rungroup/rungroup.go
@ -51,7 +51,7 @@ func Run[T any](ctx context.Context, cfg Config[T]) Group[T] {
 	// Buffered for performance.
 	ch := make(chan T, cfg.NumWorkers)

-	for i := 0; i < cfg.NumWorkers; i++ {
+	for range cfg.NumWorkers {
 		g.Go(func() error {
 			for {
 				select {
--- a/common/tasks/tasks.go
+++ b/common/tasks/tasks.go
@ -103,10 +103,7 @@ func (r *RunEvery) Add(name string, f Func) {
 		f.IntervalHigh = 20 * time.Second
 	}

-	start := f.IntervalHigh / 3
-	if start < f.IntervalLow {
-		start = f.IntervalLow
-	}
+	start := max(f.IntervalHigh/3, f.IntervalLow)
 	f.interval = start
 	f.last = time.Now()

--- a/common/terminal/colors.go
+++ b/common/terminal/colors.go
@ -17,7 +17,6 @@ package terminal
 import (
 	"fmt"
 	"os"
-	"runtime"
 	"strings"

 	isatty "github.com/mattn/go-isatty"
@ -41,10 +40,6 @@ func PrintANSIColors(f *os.File) bool {
 // IsTerminal return true if the file descriptor is terminal and the TERM
 // environment variable isn't a dumb one.
 func IsTerminal(f *os.File) bool {
-	if runtime.GOOS == "windows" {
-		return false
-	}
-
 	fd := f.Fd()
 	return os.Getenv("TERM") != "dumb" && (isatty.IsTerminal(fd) || isatty.IsCygwinTerminal(fd))
 }
--- a/common/types/closer.go
+++ b/common/types/closer.go
@ -19,6 +19,13 @@ type Closer interface {
 	Close() error
 }

+// CloserFunc is a convenience type to create a Closer from a function.
+type CloserFunc func() error
+
+func (f CloserFunc) Close() error {
+	return f()
+}
+
 type CloseAdder interface {
 	Add(Closer)
 }
--- a/common/types/convert.go
+++ b/common/types/convert.go
@ -69,7 +69,7 @@ func ToStringSlicePreserveStringE(v any) ([]string, error) {
 	switch vv.Kind() {
 	case reflect.Slice, reflect.Array:
 		result = make([]string, vv.Len())
-		for i := 0; i < vv.Len(); i++ {
+		for i := range vv.Len() {
 			s, err := cast.ToStringE(vv.Index(i).Interface())
 			if err != nil {
 				return nil, err
--- a/common/types/evictingqueue.go
+++ b/common/types/evictingqueue.go
@ -15,27 +15,28 @@
 package types

 import (
+	"slices"
 	"sync"
 )

-// EvictingStringQueue is a queue which automatically evicts elements from the head of
+// EvictingQueue is a queue which automatically evicts elements from the head of
 // the queue when attempting to add new elements onto the queue and it is full.
 // This queue orders elements LIFO (last-in-first-out). It throws away duplicates.
-// Note: This queue currently does not contain any remove (poll etc.) methods.
-type EvictingStringQueue struct {
+type EvictingQueue[T comparable] struct {
 	size int
-	vals []string
-	set  map[string]bool
+	vals []T
+	set  map[T]bool
 	mu   sync.Mutex
+	zero T
 }

-// NewEvictingStringQueue creates a new queue with the given size.
-func NewEvictingStringQueue(size int) *EvictingStringQueue {
-	return &EvictingStringQueue{size: size, set: make(map[string]bool)}
+// NewEvictingQueue creates a new queue with the given size.
+func NewEvictingQueue[T comparable](size int) *EvictingQueue[T] {
+	return &EvictingQueue[T]{size: size, set: make(map[T]bool)}
 }

 // Add adds a new string to the tail of the queue if it's not already there.
-func (q *EvictingStringQueue) Add(v string) *EvictingStringQueue {
+func (q *EvictingQueue[T]) Add(v T) *EvictingQueue[T] {
 	q.mu.Lock()
 	if q.set[v] {
 		q.mu.Unlock()
@ -45,7 +46,7 @@ func (q *EvictingStringQueue) Add(v string) *EvictingStringQueue {
 	if len(q.set) == q.size {
 		// Full
 		delete(q.set, q.vals[0])
-		q.vals = append(q.vals[:0], q.vals[1:]...)
+		q.vals = slices.Delete(q.vals, 0, 1)
 	}
 	q.set[v] = true
 	q.vals = append(q.vals, v)
@ -54,7 +55,7 @@ func (q *EvictingStringQueue) Add(v string) *EvictingStringQueue {
 	return q
 }

-func (q *EvictingStringQueue) Len() int {
+func (q *EvictingQueue[T]) Len() int {
 	if q == nil {
 		return 0
 	}
@ -64,19 +65,22 @@ func (q *EvictingStringQueue) Len() int {
 }

 // Contains returns whether the queue contains v.
-func (q *EvictingStringQueue) Contains(v string) bool {
+func (q *EvictingQueue[T]) Contains(v T) bool {
+	if q == nil {
+		return false
+	}
 	q.mu.Lock()
 	defer q.mu.Unlock()
 	return q.set[v]
 }

 // Peek looks at the last element added to the queue.
-func (q *EvictingStringQueue) Peek() string {
+func (q *EvictingQueue[T]) Peek() T {
 	q.mu.Lock()
 	l := len(q.vals)
 	if l == 0 {
 		q.mu.Unlock()
-		return ""
+		return q.zero
 	}
 	elem := q.vals[l-1]
 	q.mu.Unlock()
@ -84,9 +88,12 @@ func (q *EvictingStringQueue) Peek() string {
 }

 // PeekAll looks at all the elements in the queue, with the newest first.
-func (q *EvictingStringQueue) PeekAll() []string {
+func (q *EvictingQueue[T]) PeekAll() []T {
+	if q == nil {
+		return nil
+	}
 	q.mu.Lock()
-	vals := make([]string, len(q.vals))
+	vals := make([]T, len(q.vals))
 	copy(vals, q.vals)
 	q.mu.Unlock()
 	for i, j := 0, len(vals)-1; i < j; i, j = i+1, j-1 {
@ -96,9 +103,9 @@ func (q *EvictingStringQueue) PeekAll() []string {
 }

 // PeekAllSet returns PeekAll as a set.
-func (q *EvictingStringQueue) PeekAllSet() map[string]bool {
+func (q *EvictingQueue[T]) PeekAllSet() map[T]bool {
 	all := q.PeekAll()
-	set := make(map[string]bool)
+	set := make(map[T]bool)
 	for _, v := range all {
 		set[v] = true
 	}
--- a/common/types/evictingqueue_test.go
+++ b/common/types/evictingqueue_test.go
@ -23,7 +23,7 @@ import (
 func TestEvictingStringQueue(t *testing.T) {
 	c := qt.New(t)

-	queue := NewEvictingStringQueue(3)
+	queue := NewEvictingQueue[string](3)

 	c.Assert(queue.Peek(), qt.Equals, "")
 	queue.Add("a")
@ -53,9 +53,9 @@ func TestEvictingStringQueueConcurrent(t *testing.T) {
 	var wg sync.WaitGroup
 	val := "someval"

-	queue := NewEvictingStringQueue(3)
+	queue := NewEvictingQueue[string](3)

-	for j := 0; j < 100; j++ {
+	for range 100 {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
--- a/common/types/types.go
+++ b/common/types/types.go
@ -28,6 +28,16 @@ type RLocker interface {
 	RUnlock()
 }

+type Locker interface {
+	Lock()
+	Unlock()
+}
+
+type RWLocker interface {
+	RLocker
+	Locker
+}
+
 // KeyValue is a interface{} tuple.
 type KeyValue struct {
 	Key   any
@ -59,7 +69,7 @@ func (k KeyValues) String() string {
 // KeyValues struct.
 func NewKeyValuesStrings(key string, values ...string) KeyValues {
 	iv := make([]any, len(values))
-	for i := 0; i < len(values); i++ {
+	for i := range values {
 		iv[i] = values[i]
 	}
 	return KeyValues{Key: key, Values: iv}
@ -133,22 +143,3 @@ func NewBool(b bool) *bool {
 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
-}
--- a/config/allconfig/allconfig.go
+++ b/config/allconfig/allconfig.go
@ -82,7 +82,7 @@ func init() {
 	}
 	configLanguageKeys = make(map[string]bool)
 	addKeys := func(v reflect.Value) {
-		for i := 0; i < v.NumField(); i++ {
+		for i := range v.NumField() {
 			name := strings.ToLower(v.Type().Field(i).Name)
 			if skip[name] {
 				continue
@ -128,6 +128,9 @@ type Config struct {
 	// <docsmeta>{"identifiers": ["markup"] }</docsmeta>
 	Markup markup_config.Config `mapstructure:"-"`

+	// ContentTypes are the media types that's considered content in Hugo.
+	ContentTypes *config.ConfigNamespace[map[string]media.ContentTypeConfig, media.ContentTypes] `mapstructure:"-"`
+
 	// The mediatypes configuration section maps the MIME type (a string) to a configuration object for that type.
 	// <docsmeta>{"identifiers": ["mediatypes"], "refs": ["types:media:type"] }</docsmeta>
 	MediaTypes *config.ConfigNamespace[map[string]media.MediaTypeConfig, media.Types] `mapstructure:"-"`
@ -143,7 +146,7 @@ type Config struct {

 	// The cascade configuration section contains the top level front matter cascade configuration options,
 	// a slice of page matcher and params to apply to those pages.
-	Cascade *config.ConfigNamespace[[]page.PageMatcherParamsConfig, map[page.PageMatcher]maps.Params] `mapstructure:"-"`
+	Cascade *config.ConfigNamespace[[]page.PageMatcherParamsConfig, *maps.Ordered[page.PageMatcher, page.PageMatcherParamsConfig]] `mapstructure:"-"`

 	// The segments defines segments for the site. Used for partial/segmented builds.
 	Segments *config.ConfigNamespace[map[string]segments.SegmentConfig, segments.Segments] `mapstructure:"-"`
@ -301,6 +304,18 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		}
 	}

+	defaultOutputFormat := outputFormats[0]
+	c.DefaultOutputFormat = strings.ToLower(c.DefaultOutputFormat)
+	if c.DefaultOutputFormat != "" {
+		f, found := outputFormats.GetByName(c.DefaultOutputFormat)
+		if !found {
+			return fmt.Errorf("unknown default output format %q", c.DefaultOutputFormat)
+		}
+		defaultOutputFormat = f
+	} else {
+		c.DefaultOutputFormat = defaultOutputFormat.Name
+	}
+
 	disabledLangs := make(map[string]bool)
 	for _, lang := range c.DisableLanguages {
 		disabledLangs[lang] = true
@ -381,32 +396,63 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {

 	// Legacy paginate values.
 	if c.Paginate != 0 {
-		hugo.Deprecate("site config key paginate", "Use pagination.pagerSize instead.", "v0.128.0")
+		hugo.DeprecateWithLogger("site config key paginate", "Use pagination.pagerSize instead.", "v0.128.0", logger.Logger())
 		c.Pagination.PagerSize = c.Paginate
 	}

 	if c.PaginatePath != "" {
-		hugo.Deprecate("site config key paginatePath", "Use pagination.path instead.", "v0.128.0")
+		hugo.DeprecateWithLogger("site config key paginatePath", "Use pagination.path instead.", "v0.128.0", logger.Logger())
 		c.Pagination.Path = c.PaginatePath
 	}

+	// Legacy privacy values.
+	if c.Privacy.Twitter.Disable {
+		hugo.DeprecateWithLogger("site config key privacy.twitter.disable", "Use privacy.x.disable instead.", "v0.141.0", logger.Logger())
+		c.Privacy.X.Disable = c.Privacy.Twitter.Disable
+	}
+
+	if c.Privacy.Twitter.EnableDNT {
+		hugo.DeprecateWithLogger("site config key privacy.twitter.enableDNT", "Use privacy.x.enableDNT instead.", "v0.141.0", logger.Logger())
+		c.Privacy.X.EnableDNT = c.Privacy.Twitter.EnableDNT
+	}
+
+	if c.Privacy.Twitter.Simple {
+		hugo.DeprecateWithLogger("site config key privacy.twitter.simple", "Use privacy.x.simple instead.", "v0.141.0", logger.Logger())
+		c.Privacy.X.Simple = c.Privacy.Twitter.Simple
+	}
+
+	// Legacy services values.
+	if c.Services.Twitter.DisableInlineCSS {
+		hugo.DeprecateWithLogger("site config key services.twitter.disableInlineCSS", "Use services.x.disableInlineCSS instead.", "v0.141.0", logger.Logger())
+		c.Services.X.DisableInlineCSS = c.Services.Twitter.DisableInlineCSS
+	}
+
+	// Legacy permalink tokens
+	vs := fmt.Sprintf("%v", c.Permalinks)
+	if strings.Contains(vs, ":filename") {
+		hugo.DeprecateWithLogger("the \":filename\" permalink token", "Use \":contentbasename\" instead.", "0.144.0", logger.Logger())
+	}
+	if strings.Contains(vs, ":slugorfilename") {
+		hugo.DeprecateWithLogger("the \":slugorfilename\" permalink token", "Use \":slugorcontentbasename\" instead.", "0.144.0", logger.Logger())
+	}
+
 	c.C = &ConfigCompiled{
-		Timeout:           timeout,
-		BaseURL:           baseURL,
-		BaseURLLiveReload: baseURL,
-		DisabledKinds:     disabledKinds,
-		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,
+		Timeout:             timeout,
+		BaseURL:             baseURL,
+		BaseURLLiveReload:   baseURL,
+		DisabledKinds:       disabledKinds,
+		DisabledLanguages:   disabledLangs,
+		IgnoredLogs:         ignoredLogIDs,
+		KindOutputFormats:   kindOutputFormats,
+		DefaultOutputFormat: defaultOutputFormat,
+		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,
 	}

 	for _, s := range allDecoderSetups {
@ -430,22 +476,22 @@ func (c *Config) IsLangDisabled(lang string) bool {

 // ConfigCompiled holds values and functions that are derived from the config.
 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
+	Timeout             time.Duration
+	BaseURL             urls.BaseURL
+	BaseURLLiveReload   urls.BaseURL
+	ServerInterface     string
+	KindOutputFormats   map[string]output.Formats
+	DefaultOutputFormat output.Format
+	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
@ -505,6 +551,13 @@ type RootConfig struct {
 	// Set this to true to put all languages below their language ID.
 	DefaultContentLanguageInSubdir bool

+	// The default output format to use for the site.
+	// If not set, we will use the first output format.
+	DefaultOutputFormat string
+
+	// Disable generation of redirect to the default language when DefaultContentLanguageInSubdir is enabled.
+	DisableDefaultLanguageRedirect bool
+
 	// Disable creation of alias redirect pages.
 	DisableAliases bool

@ -723,15 +776,16 @@ type Configs struct {
 }

 func (c *Configs) Validate(logger loggers.Logger) error {
-	for p := range c.Base.Cascade.Config {
+	c.Base.Cascade.Config.Range(func(p page.PageMatcher, cfg page.PageMatcherParamsConfig) bool {
 		page.CheckCascadePattern(logger, p)
-	}
+		return true
+	})
 	return nil
 }

 // transientErr returns the last transient error found during config compilation.
 func (c *Configs) transientErr() error {
-	for _, l := range c.LanguageConfigSlice {
+	for _, l := range c.LanguageConfigMap {
 		if l.C.transientErr != nil {
 			return l.C.transientErr
 		}
@ -746,31 +800,58 @@ func (c *Configs) IsZero() bool {

 func (c *Configs) Init() error {
 	var languages langs.Languages
-	defaultContentLanguage := c.Base.DefaultContentLanguage
-	for k, v := range c.LanguageConfigMap {
+
+	var langKeys []string
+	var hasEn bool
+
+	const en = "en"
+
+	for k := range c.LanguageConfigMap {
+		langKeys = append(langKeys, k)
+		if k == en {
+			hasEn = true
+		}
+	}
+
+	// Sort the LanguageConfigSlice by language weight (if set) or lang.
+	sort.Slice(langKeys, func(i, j int) bool {
+		ki := langKeys[i]
+		kj := langKeys[j]
+		lki := c.LanguageConfigMap[ki]
+		lkj := c.LanguageConfigMap[kj]
+		li := lki.Languages[ki]
+		lj := lkj.Languages[kj]
+		if li.Weight != lj.Weight {
+			return li.Weight < lj.Weight
+		}
+		return ki < kj
+	})
+
+	// See issue #13646.
+	defaultConfigLanguageFallback := en
+	if !hasEn {
+		// Pick the first one.
+		defaultConfigLanguageFallback = langKeys[0]
+	}
+
+	if c.Base.DefaultContentLanguage == "" {
+		c.Base.DefaultContentLanguage = defaultConfigLanguageFallback
+	}
+
+	for _, k := range langKeys {
+		v := c.LanguageConfigMap[k]
+		if v.DefaultContentLanguage == "" {
+			v.DefaultContentLanguage = defaultConfigLanguageFallback
+		}
 		c.LanguageConfigSlice = append(c.LanguageConfigSlice, v)
 		languageConf := v.Languages[k]
-		language, err := langs.NewLanguage(k, defaultContentLanguage, v.TimeZone, languageConf)
+		language, err := langs.NewLanguage(k, c.Base.DefaultContentLanguage, v.TimeZone, languageConf)
 		if err != nil {
 			return err
 		}
 		languages = append(languages, language)
 	}

-	// Sort the sites by language weight (if set) or lang.
-	sort.Slice(languages, func(i, j int) bool {
-		li := languages[i]
-		lj := languages[j]
-		if li.Weight != lj.Weight {
-			return li.Weight < lj.Weight
-		}
-		return li.Lang < lj.Lang
-	})
-
-	for _, l := range languages {
-		c.LanguageConfigSlice = append(c.LanguageConfigSlice, c.LanguageConfigMap[l.Lang])
-	}
-
 	// Filter out disabled languages.
 	var n int
 	for _, l := range languages {
@ -783,12 +864,12 @@ func (c *Configs) Init() error {

 	var languagesDefaultFirst langs.Languages
 	for _, l := range languages {
-		if l.Lang == defaultContentLanguage {
+		if l.Lang == c.Base.DefaultContentLanguage {
 			languagesDefaultFirst = append(languagesDefaultFirst, l)
 		}
 	}
 	for _, l := range languages {
-		if l.Lang != defaultContentLanguage {
+		if l.Lang != c.Base.DefaultContentLanguage {
 			languagesDefaultFirst = append(languagesDefaultFirst, l)
 		}
 	}
@ -796,7 +877,24 @@ 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(),
+		IsLangDisabled: c.Base.IsLangDisabled,
+		IsContentExt:   c.Base.ContentTypes.Config.IsContentSuffix,
+		IsOutputFormat: func(name, ext string) bool {
+			if name == "" {
+				return false
+			}
+
+			if of, ok := c.Base.OutputFormats.Config.GetByName(name); ok {
+				if ext != "" && !of.MediaType.HasSuffix(ext) {
+					return false
+				}
+				return true
+			}
+			return false
+		},
+	}

 	c.configLangs = make([]config.AllProvider, len(c.Languages))
 	for i, l := range c.LanguagesDefaultFirst {
@ -857,17 +955,48 @@ func (c Configs) GetByLang(lang string) config.AllProvider {
 	return nil
 }

+func newDefaultConfig() *Config {
+	return &Config{
+		Taxonomies: map[string]string{"tag": "tags", "category": "categories"},
+		Sitemap:    config.SitemapConfig{Priority: -1, Filename: "sitemap.xml"},
+		RootConfig: RootConfig{
+			Environment:          hugo.EnvironmentProduction,
+			TitleCaseStyle:       "AP",
+			PluralizeListTitles:  true,
+			CapitalizeListTitles: true,
+			StaticDir:            []string{"static"},
+			SummaryLength:        70,
+			Timeout:              "60s",
+
+			CommonDirs: config.CommonDirs{
+				ArcheTypeDir: "archetypes",
+				ContentDir:   "content",
+				ResourceDir:  "resources",
+				PublishDir:   "public",
+				ThemesDir:    "themes",
+				AssetDir:     "assets",
+				LayoutDir:    "layouts",
+				I18nDir:      "i18n",
+				DataDir:      "data",
+			},
+		},
+	}
+}
+
 // fromLoadConfigResult creates a new Config from res.
 func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadConfigResult) (*Configs, error) {
 	if !res.Cfg.IsSet("languages") {
 		// We need at least one
 		lang := res.Cfg.GetString("defaultContentLanguage")
+		if lang == "" {
+			lang = "en"
+		}
 		res.Cfg.Set("languages", maps.Params{lang: maps.Params{}})
 	}
 	bcfg := res.BaseConfig
 	cfg := res.Cfg

-	all := &Config{}
+	all := newDefaultConfig()

 	err := decodeConfigFromParams(fs, logger, bcfg, cfg, all, nil)
 	if err != nil {
@ -877,6 +1006,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 	langConfigMap := make(map[string]*Config)

 	languagesConfig := cfg.GetStringMap("languages")
+
 	var isMultihost bool

 	if err := all.CompileConfig(logger); err != nil {
--- a/config/allconfig/allconfig_integration_test.go
+++ b/config/allconfig/allconfig_integration_test.go
@ -5,8 +5,10 @@ import (
 	"testing"

 	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/media"
 )

 func TestDirsMount(t *testing.T) {
@ -97,7 +99,7 @@ suffixes = ["html", "xhtml"]
 	b := hugolib.Test(t, files)

 	conf := b.H.Configs.Base
-	contentTypes := conf.C.ContentTypes
+	contentTypes := conf.ContentTypes.Config

 	b.Assert(contentTypes.HTML.Suffixes(), qt.DeepEquals, []string{"html", "xhtml"})
 	b.Assert(contentTypes.Markdown.Suffixes(), qt.DeepEquals, []string{"md", "mdown", "markdown"})
@ -175,3 +177,205 @@ func TestMapUglyURLs(t *testing.T) {
 	b.Assert(c.C.IsUglyURLSection("posts"), qt.IsTrue)
 	b.Assert(c.C.IsUglyURLSection("blog"), qt.IsFalse)
 }
+
+// Issue 13199
+func TestInvalidOutputFormat(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['page','rss','section','sitemap','taxonomy','term']
+[outputs]
+home = ['html','foo']
+-- layouts/index.html --
+x
+`
+
+	b, err := hugolib.TestE(t, files)
+	b.Assert(err, qt.IsNotNil)
+	b.Assert(err.Error(), qt.Contains, `failed to create config: unknown output format "foo" for kind "home"`)
+}
+
+// Issue 13201
+func TestLanguageConfigSlice(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['page','rss','section','sitemap','taxonomy','term']
+[languages.en]
+title = 'TITLE_EN'
+weight = 2
+[languages.de]
+title = 'TITLE_DE'
+weight = 1
+[languages.fr]
+title = 'TITLE_FR'
+weight = 3
+`
+
+	b := hugolib.Test(t, files)
+	b.Assert(b.H.Configs.LanguageConfigSlice[0].Title, qt.Equals, `TITLE_DE`)
+}
+
+func TestContentTypesDefault(t *testing.T) {
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+
+
+`
+
+	b := hugolib.Test(t, files)
+
+	ct := b.H.Configs.Base.ContentTypes
+	c := ct.Config
+	s := ct.SourceStructure.(map[string]media.ContentTypeConfig)
+
+	b.Assert(c.IsContentFile("foo.md"), qt.Equals, true)
+	b.Assert(len(s), qt.Equals, 6)
+}
+
+func TestMergeDeep(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+theme = ["theme1", "theme2"]
+_merge = "deep"
+-- themes/theme1/hugo.toml --
+[sitemap]
+filename = 'mysitemap.xml'
+[services]
+[services.googleAnalytics]
+id = 'foo bar'
+[taxonomies]
+  foo = 'bars'
+-- themes/theme2/config/_default/hugo.toml --
+[taxonomies]
+  bar = 'baz'
+-- layouts/home.html --
+GA ID: {{ site.Config.Services.GoogleAnalytics.ID }}.
+
+`
+
+	b := hugolib.Test(t, files)
+
+	conf := b.H.Configs
+	base := conf.Base
+
+	b.Assert(base.Environment, qt.Equals, hugo.EnvironmentProduction)
+	b.Assert(base.BaseURL, qt.Equals, "https://example.com")
+	b.Assert(base.Sitemap.Filename, qt.Equals, "mysitemap.xml")
+	b.Assert(base.Taxonomies, qt.DeepEquals, map[string]string{"bar": "baz", "foo": "bars"})
+
+	b.AssertFileContent("public/index.html", "GA ID: foo bar.")
+}
+
+func TestMergeDeepBuildStats(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+title = "Theme 1"
+_merge = "deep"
+[module]
+[module.hugoVersion]
+[[module.imports]]
+path = "theme1"
+-- themes/theme1/hugo.toml --
+[build]
+[build.buildStats]
+disableIDs = true
+enable     = true
+-- layouts/home.html --
+Home.
+
+`
+
+	b := hugolib.Test(t, files, hugolib.TestOptOsFs())
+
+	conf := b.H.Configs
+	base := conf.Base
+
+	b.Assert(base.Title, qt.Equals, "Theme 1")
+	b.Assert(len(base.Module.Imports), qt.Equals, 1)
+	b.Assert(base.Build.BuildStats.Enable, qt.Equals, true)
+	b.AssertFileExists("/hugo_stats.json", true)
+}
+
+func TestMergeDeepBuildStatsTheme(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+_merge = "deep"
+theme = ["theme1"]
+-- themes/theme1/hugo.toml --
+title = "Theme 1"
+[build]
+[build.buildStats]
+disableIDs = true
+enable     = true
+-- layouts/home.html --
+Home.
+
+`
+
+	b := hugolib.Test(t, files, hugolib.TestOptOsFs())
+
+	conf := b.H.Configs
+	base := conf.Base
+
+	b.Assert(base.Title, qt.Equals, "Theme 1")
+	b.Assert(len(base.Module.Imports), qt.Equals, 1)
+	b.Assert(base.Build.BuildStats.Enable, qt.Equals, true)
+	b.AssertFileExists("/hugo_stats.json", true)
+}
+
+func TestDefaultConfigLanguageBlankWhenNoEnglishExists(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+[languages]
+[languages.nn]
+weight = 20
+[languages.sv]
+weight = 10
+[languages.sv.taxonomies]
+  tag = "taggar"
+-- layouts/all.html --
+All.
+`
+
+	b := hugolib.Test(t, files)
+
+	b.Assert(b.H.Conf.DefaultContentLanguage(), qt.Equals, "sv")
+}
+
+func TestDefaultConfigEnvDisableLanguagesIssue13707(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableLanguages = []
+[languages]
+[languages.en]
+weight = 1
+[languages.nn]
+weight = 2
+[languages.sv]
+weight = 3
+`
+
+	b := hugolib.Test(t, files, hugolib.TestOptWithConfig(func(conf *hugolib.IntegrationTestConfig) {
+		conf.Environ = []string{`HUGO_DISABLELANGUAGES=sv nn`}
+	}))
+
+	b.Assert(len(b.H.Sites), qt.Equals, 1)
+}
--- a/config/allconfig/alldecoders.go
+++ b/config/allconfig/alldecoders.go
@ -163,6 +163,15 @@ var allDecoderSetups = map[string]decodeWeight{
 			return err
 		},
 	},
+	"contenttypes": {
+		key:    "contenttypes",
+		weight: 100, // This needs to be decoded after media types.
+		decode: func(d decodeWeight, p decodeConfig) error {
+			var err error
+			p.c.ContentTypes, err = media.DecodeContentTypes(p.p.GetStringMap(d.key), p.c.MediaTypes.Config)
+			return err
+		},
+	},
 	"mediatypes": {
 		key: "mediatypes",
 		decode: func(d decodeWeight, p decodeConfig) error {
@ -240,14 +249,18 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "sitemap",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			p.c.Sitemap, err = config.DecodeSitemap(config.SitemapConfig{Priority: -1, Filename: "sitemap.xml"}, p.p.GetStringMap(d.key))
+			if p.p.IsSet(d.key) {
+				p.c.Sitemap, err = config.DecodeSitemap(p.c.Sitemap, p.p.GetStringMap(d.key))
+			}
 			return err
 		},
 	},
 	"taxonomies": {
 		key: "taxonomies",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Taxonomies = maps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
+			if p.p.IsSet(d.key) {
+				p.c.Taxonomies = maps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
+			}
 			return nil
 		},
 	},
@ -297,15 +310,17 @@ var allDecoderSetups = map[string]decodeWeight{
 			}

 			// Validate defaultContentLanguage.
-			var found bool
-			for lang := range p.c.Languages {
-				if lang == p.c.DefaultContentLanguage {
-					found = true
-					break
+			if p.c.DefaultContentLanguage != "" {
+				var found bool
+				for lang := range p.c.Languages {
+					if lang == p.c.DefaultContentLanguage {
+						found = true
+						break
+					}
+				}
+				if !found {
+					return fmt.Errorf("config value %q for defaultContentLanguage does not match any language definition", p.c.DefaultContentLanguage)
 				}
-			}
-			if !found {
-				return fmt.Errorf("config value %q for defaultContentLanguage does not match any language definition", p.c.DefaultContentLanguage)
 			}

 			return nil
@ -315,7 +330,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(nil, true, p.p.Get(d.key))
 			return err
 		},
 	},
--- a/config/allconfig/configlanguage.go
+++ b/config/allconfig/configlanguage.go
@ -137,15 +137,15 @@ func (c ConfigLanguage) Watching() bool {
 	return c.m.Base.Internal.Watch
 }

-func (c ConfigLanguage) NewIdentityManager(name string) identity.Manager {
+func (c ConfigLanguage) NewIdentityManager(name string, opts ...identity.ManagerOption) identity.Manager {
 	if !c.Watching() {
 		return identity.NopManager
 	}
-	return identity.NewManager(name)
+	return identity.NewManager(name, opts...)
 }

 func (c ConfigLanguage) ContentTypes() config.ContentTypesProvider {
-	return c.config.C.ContentTypes
+	return c.config.ContentTypes.Config
 }

 // GetConfigSection is mostly used in tests. The switch statement isn't complete, but what's in use.
--- a/config/allconfig/load.go
+++ b/config/allconfig/load.go
@ -91,7 +91,7 @@ func LoadConfig(d ConfigSourceDescriptor) (*Configs, error) {
 		return nil, fmt.Errorf("failed to init config: %w", err)
 	}

-	loggers.InitGlobalLogger(d.Logger.Level(), configs.Base.PanicOnWarning)
+	loggers.SetGlobalLogger(d.Logger)

 	return configs, nil
 }
@ -159,63 +159,9 @@ func (l configLoader) applyConfigAliases() error {

 func (l configLoader) applyDefaultConfig() error {
 	defaultSettings := maps.Params{
-		"baseURL":                              "",
-		"cleanDestinationDir":                  false,
-		"watch":                                false,
-		"contentDir":                           "content",
-		"resourceDir":                          "resources",
-		"publishDir":                           "public",
-		"publishDirOrig":                       "public",
-		"themesDir":                            "themes",
-		"assetDir":                             "assets",
-		"layoutDir":                            "layouts",
-		"i18nDir":                              "i18n",
-		"dataDir":                              "data",
-		"archetypeDir":                         "archetypes",
-		"configDir":                            "config",
-		"staticDir":                            "static",
-		"buildDrafts":                          false,
-		"buildFuture":                          false,
-		"buildExpired":                         false,
-		"params":                               maps.Params{},
-		"environment":                          hugo.EnvironmentProduction,
-		"uglyURLs":                             false,
-		"verbose":                              false,
-		"ignoreCache":                          false,
-		"canonifyURLs":                         false,
-		"relativeURLs":                         false,
-		"removePathAccents":                    false,
-		"titleCaseStyle":                       "AP",
-		"taxonomies":                           maps.Params{"tag": "tags", "category": "categories"},
-		"permalinks":                           maps.Params{},
-		"sitemap":                              maps.Params{"priority": -1, "filename": "sitemap.xml"},
-		"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.
-		"summaryLength":                        70,
-		"rssLimit":                             -1,
-		"sectionPagesMenu":                     "",
-		"disablePathToLower":                   false,
-		"hasCJKLanguage":                       false,
-		"enableEmoji":                          false,
-		"defaultContentLanguage":               "en",
-		"defaultContentLanguageInSubdir":       false,
-		"enableMissingTranslationPlaceholders": false,
-		"enableGitInfo":                        false,
-		"ignoreFiles":                          make([]string, 0),
-		"disableAliases":                       false,
-		"debug":                                false,
-		"disableFastRender":                    false,
-		"timeout":                              "30s",
-		"timeZone":                             "",
-		"enableInlineShortcodes":               false,
+		// These dirs are used early/before we build the config struct.
+		"themesDir": "themes",
+		"configDir": "config",
 	}

 	l.cfg.SetDefaults(defaultSettings)
@ -287,40 +233,51 @@ func (l configLoader) applyOsEnvOverrides(environ []string) error {

 		if existing != nil {
 			val, err := metadecoders.Default.UnmarshalStringTo(env.Value, existing)
-			if err != nil {
+			if err == nil {
+				val = l.envValToVal(env.Key, val)
+				if owner != nil {
+					owner[nestedKey] = val
+				} else {
+					l.cfg.Set(env.Key, val)
+				}
 				continue
 			}
-
-			if owner != nil {
-				owner[nestedKey] = val
-			} else {
-				l.cfg.Set(env.Key, val)
-			}
-		} else {
-			if nestedKey != "" {
-				owner[nestedKey] = env.Value
-			} else {
-				var val any
-				key := strings.ReplaceAll(env.Key, delim, ".")
-				_, ok := allDecoderSetups[key]
-				if ok {
-					// A map.
-					if v, err := metadecoders.Default.UnmarshalStringTo(env.Value, map[string]interface{}{}); err == nil {
-						val = v
-					}
-				}
-				if val == nil {
-					// A string.
-					val = l.envStringToVal(key, env.Value)
-				}
-				l.cfg.Set(key, val)
-			}
 		}
+
+		if owner != nil && nestedKey != "" {
+			owner[nestedKey] = env.Value
+		} else {
+			var val any
+			key := strings.ReplaceAll(env.Key, delim, ".")
+			_, ok := allDecoderSetups[key]
+			if ok {
+				// A map.
+				if v, err := metadecoders.Default.UnmarshalStringTo(env.Value, map[string]any{}); err == nil {
+					val = v
+				}
+			}
+
+			if val == nil {
+				// A string.
+				val = l.envStringToVal(key, env.Value)
+			}
+			l.cfg.Set(key, val)
+		}
+
 	}

 	return nil
 }

+func (l *configLoader) envValToVal(k string, v any) any {
+	switch v := v.(type) {
+	case string:
+		return l.envStringToVal(k, v)
+	default:
+		return v
+	}
+}
+
 func (l *configLoader) envStringToVal(k, v string) any {
 	switch k {
 	case "disablekinds", "disablelanguages":
@ -470,7 +427,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, workingDir, l.Logger)

 	hook := func(m *modules.ModulesConfig) error {
 		for _, tc := range m.AllModules {
--- a/config/commonConfig.go
+++ b/config/commonConfig.go
@ -15,7 +15,9 @@ package config

 import (
 	"fmt"
+	"net/http"
 	"regexp"
+	"slices"
 	"sort"
 	"strings"

@ -127,7 +129,7 @@ func (w BuildStats) Enabled() bool {
 }

 func (b BuildConfig) clone() BuildConfig {
-	b.CacheBusters = append([]CacheBuster{}, b.CacheBusters...)
+	b.CacheBusters = slices.Clone(b.CacheBusters)
 	return b
 }

@ -226,7 +228,22 @@ type Server struct {
 	Redirects []Redirect

 	compiledHeaders   []glob.Glob
-	compiledRedirects []glob.Glob
+	compiledRedirects []redirect
+}
+
+type redirect struct {
+	from    glob.Glob
+	fromRe  *regexp.Regexp
+	headers map[string]glob.Glob
+}
+
+func (r redirect) matchHeader(header http.Header) bool {
+	for k, v := range r.headers {
+		if !v.Match(header.Get(k)) {
+			return false
+		}
+	}
+	return true
 }

 func (s *Server) CompileConfig(logger loggers.Logger) error {
@ -234,10 +251,41 @@ func (s *Server) CompileConfig(logger loggers.Logger) error {
 		return nil
 	}
 	for _, h := range s.Headers {
-		s.compiledHeaders = append(s.compiledHeaders, glob.MustCompile(h.For))
+		g, err := glob.Compile(h.For)
+		if err != nil {
+			return fmt.Errorf("failed to compile Headers glob %q: %w", h.For, err)
+		}
+		s.compiledHeaders = append(s.compiledHeaders, g)
 	}
 	for _, r := range s.Redirects {
-		s.compiledRedirects = append(s.compiledRedirects, glob.MustCompile(r.From))
+		if r.From == "" && r.FromRe == "" {
+			return fmt.Errorf("redirects must have either From or FromRe set")
+		}
+		rd := redirect{
+			headers: make(map[string]glob.Glob),
+		}
+		if r.From != "" {
+			g, err := glob.Compile(r.From)
+			if err != nil {
+				return fmt.Errorf("failed to compile Redirect glob %q: %w", r.From, err)
+			}
+			rd.from = g
+		}
+		if r.FromRe != "" {
+			re, err := regexp.Compile(r.FromRe)
+			if err != nil {
+				return fmt.Errorf("failed to compile Redirect regexp %q: %w", r.FromRe, err)
+			}
+			rd.fromRe = re
+		}
+		for k, v := range r.FromHeaders {
+			g, err := glob.Compile(v)
+			if err != nil {
+				return fmt.Errorf("failed to compile Redirect header glob %q: %w", v, err)
+			}
+			rd.headers[k] = g
+		}
+		s.compiledRedirects = append(s.compiledRedirects, rd)
 	}

 	return nil
@ -266,22 +314,42 @@ func (s *Server) MatchHeaders(pattern string) []types.KeyValueStr {
 	return matches
 }

-func (s *Server) MatchRedirect(pattern string) Redirect {
+func (s *Server) MatchRedirect(pattern string, header http.Header) Redirect {
 	if s.compiledRedirects == nil {
 		return Redirect{}
 	}

 	pattern = strings.TrimSuffix(pattern, "index.html")

-	for i, g := range s.compiledRedirects {
+	for i, r := range s.compiledRedirects {
 		redir := s.Redirects[i]

-		// No redirect to self.
-		if redir.To == pattern {
-			return Redirect{}
+		var found bool
+
+		if r.from != nil {
+			if r.from.Match(pattern) {
+				found = header == nil || r.matchHeader(header)
+				// We need to do regexp group replacements if needed.
+			}
 		}

-		if g.Match(pattern) {
+		if r.fromRe != nil {
+			m := r.fromRe.FindStringSubmatch(pattern)
+			if m != nil {
+				if !found {
+					found = header == nil || r.matchHeader(header)
+				}
+
+				if found {
+					// Replace $1, $2 etc. in To.
+					for i, g := range m[1:] {
+						redir.To = strings.ReplaceAll(redir.To, fmt.Sprintf("$%d", i+1), g)
+					}
+				}
+			}
+		}
+
+		if found {
 			return redir
 		}
 	}
@ -295,8 +363,22 @@ type Headers struct {
 }

 type Redirect struct {
+	// From is the Glob pattern to match.
+	// One of From or FromRe must be set.
 	From string
-	To   string
+
+	// FromRe is the regexp to match.
+	// This regexp can contain group matches (e.g. $1) that can be used in the To field.
+	// One of From or FromRe must be set.
+	FromRe string
+
+	// To is the target URL.
+	To string
+
+	// Headers to match for the redirect.
+	// This maps the HTTP header name to a Glob pattern with values to match.
+	// If the map is empty, the redirect will always be triggered.
+	FromHeaders map[string]string

 	// HTTP status code to use for the redirect.
 	// A status code of 200 will trigger a URL rewrite.
@ -369,7 +451,7 @@ func (c *CacheBuster) CompileConfig(logger loggers.Logger) error {
 }

 func (r Redirect) IsZero() bool {
-	return r.From == ""
+	return r.From == "" && r.FromRe == ""
 }

 const (
@ -383,17 +465,7 @@ func DecodeServer(cfg Provider) (Server, error) {
 	_ = mapstructure.WeakDecode(cfg.GetStringMap("server"), s)

 	for i, redir := range s.Redirects {
-		// Get it in line with the Hugo server for OK responses.
-		// We currently treat the 404 as a special case, they are always "ugly", so keep them as is.
-		if redir.Status != 404 {
-			redir.To = strings.TrimSuffix(redir.To, "index.html")
-			if !strings.HasPrefix(redir.To, "https") && !strings.HasSuffix(redir.To, "/") {
-				// There are some tricky infinite loop situations when dealing
-				// when the target does not have a trailing slash.
-				// This can certainly be handled better, but not time for that now.
-				return Server{}, fmt.Errorf("unsupported redirect to value %q in server config; currently this must be either a remote destination or a local folder, e.g. \"/blog/\" or \"/blog/index.html\"", redir.To)
-			}
-		}
+		redir.To = strings.TrimSuffix(redir.To, "index.html")
 		s.Redirects[i] = redir
 	}

@ -401,7 +473,7 @@ func DecodeServer(cfg Provider) (Server, error) {
 		// Set up a default redirect for 404s.
 		s.Redirects = []Redirect{
 			{
-				From:   "**",
+				From:   "/**",
 				To:     "/404.html",
 				Status: 404,
 			},
--- a/config/commonConfig_test.go
+++ b/config/commonConfig_test.go
@ -71,7 +71,28 @@ X-Content-Type-Options = "nosniff"

 [[server.redirects]]
 from = "/foo/**"
-to = "/foo/index.html"
+to = "/baz/index.html"
+status = 200
+
+[[server.redirects]]
+from = "/loop/**"
+to = "/loop/foo/"
+status = 200
+
+[[server.redirects]]
+from = "/b/**"
+fromRe = "/b/(.*)/"
+to = "/baz/$1/"
+status = 200
+
+[[server.redirects]]
+fromRe = "/c/(.*)/"
+to = "/boo/$1/"
+status = 200
+
+[[server.redirects]]
+fromRe = "/d/(.*)/"
+to = "/boo/$1/"
 status = 200

 [[server.redirects]]
@ -79,11 +100,6 @@ from = "/google/**"
 to = "https://google.com/"
 status = 301

-[[server.redirects]]
-from = "/**"
-to = "/default/index.html"
-status = 301
-


 `, "toml")
@ -100,45 +116,35 @@ status = 301
 		{Key: "X-XSS-Protection", Value: "1; mode=block"},
 	})

-	c.Assert(s.MatchRedirect("/foo/bar/baz"), qt.DeepEquals, Redirect{
+	c.Assert(s.MatchRedirect("/foo/bar/baz", nil), qt.DeepEquals, Redirect{
 		From:   "/foo/**",
-		To:     "/foo/",
+		To:     "/baz/",
 		Status: 200,
 	})

-	c.Assert(s.MatchRedirect("/someother"), qt.DeepEquals, Redirect{
-		From:   "/**",
-		To:     "/default/",
-		Status: 301,
+	c.Assert(s.MatchRedirect("/foo/bar/", nil), qt.DeepEquals, Redirect{
+		From:   "/foo/**",
+		To:     "/baz/",
+		Status: 200,
 	})

-	c.Assert(s.MatchRedirect("/google/foo"), qt.DeepEquals, Redirect{
+	c.Assert(s.MatchRedirect("/b/c/", nil), qt.DeepEquals, Redirect{
+		From:   "/b/**",
+		FromRe: "/b/(.*)/",
+		To:     "/baz/c/",
+		Status: 200,
+	})
+
+	c.Assert(s.MatchRedirect("/c/d/", nil).To, qt.Equals, "/boo/d/")
+	c.Assert(s.MatchRedirect("/c/d/e/", nil).To, qt.Equals, "/boo/d/e/")
+
+	c.Assert(s.MatchRedirect("/someother", nil), qt.DeepEquals, Redirect{})
+
+	c.Assert(s.MatchRedirect("/google/foo", nil), qt.DeepEquals, Redirect{
 		From:   "/google/**",
 		To:     "https://google.com/",
 		Status: 301,
 	})
-
-	// No redirect loop, please.
-	c.Assert(s.MatchRedirect("/default/index.html"), qt.DeepEquals, Redirect{})
-	c.Assert(s.MatchRedirect("/default/"), qt.DeepEquals, Redirect{})
-
-	for _, errorCase := range []string{
-		`[[server.redirects]]
-from = "/**"
-to = "/file"
-status = 301`,
-		`[[server.redirects]]
-from = "/**"
-to = "/foo/file.html"
-status = 301`,
-	} {
-
-		cfg, err := FromConfigString(errorCase, "toml")
-		c.Assert(err, qt.IsNil)
-		_, err = DecodeServer(cfg)
-		c.Assert(err, qt.Not(qt.IsNil))
-
-	}
 }

 func TestBuildConfigCacheBusters(t *testing.T) {
@ -160,7 +166,7 @@ func TestBuildConfigCacheBusters(t *testing.T) {
 func TestBuildConfigCacheBusterstTailwindSetup(t *testing.T) {
 	c := qt.New(t)
 	cfg := New()
-	cfg.Set("build", map[string]interface{}{
+	cfg.Set("build", map[string]any{
 		"cacheBusters": []map[string]string{
 			{
 				"source": "assets/watching/hugo_stats\\.json",
--- a/config/configProvider.go
+++ b/config/configProvider.go
@ -58,7 +58,7 @@ type AllProvider interface {
 	BuildDrafts() bool
 	Running() bool
 	Watching() bool
-	NewIdentityManager(name string) identity.Manager
+	NewIdentityManager(name string, opts ...identity.ManagerOption) identity.Manager
 	FastRenderMode() bool
 	PrintUnusedTemplates() bool
 	EnableMissingTranslationPlaceholders() bool
@ -76,7 +76,7 @@ type AllProvider interface {
 }

 // We cannot import the media package as that would create a circular dependency.
-// This interface defineds a sub set of what media.ContentTypes provides.
+// This interface defines a subset of what media.ContentTypes provides.
 type ContentTypesProvider interface {
 	IsContentSuffix(suffix string) bool
 	IsContentFile(filename string) bool
--- a/config/defaultConfigProvider.go
+++ b/config/defaultConfigProvider.go
@ -15,7 +15,6 @@ package config

 import (
 	"fmt"
-	"sort"
 	"strings"
 	"sync"

@ -26,42 +25,6 @@ import (
 	"github.com/gohugoio/hugo/common/maps"
 )

-var (
-
-	// ConfigRootKeysSet contains all of the config map root keys.
-	ConfigRootKeysSet = map[string]bool{
-		"build":         true,
-		"caches":        true,
-		"cascade":       true,
-		"frontmatter":   true,
-		"languages":     true,
-		"imaging":       true,
-		"markup":        true,
-		"mediatypes":    true,
-		"menus":         true,
-		"minify":        true,
-		"module":        true,
-		"outputformats": true,
-		"params":        true,
-		"permalinks":    true,
-		"related":       true,
-		"sitemap":       true,
-		"privacy":       true,
-		"security":      true,
-		"taxonomies":    true,
-	}
-
-	// ConfigRootKeys is a sorted version of ConfigRootKeysSet.
-	ConfigRootKeys []string
-)
-
-func init() {
-	for k := range ConfigRootKeysSet {
-		ConfigRootKeys = append(ConfigRootKeys, k)
-	}
-	sort.Strings(ConfigRootKeys)
-}
-
 // New creates a Provider backed by an empty maps.Params.
 func New() Provider {
 	return &defaultConfigProvider{
@ -382,7 +345,7 @@ func (c *defaultConfigProvider) getNestedKeyAndMap(key string, create bool) (str
 		c.keyCache.Store(key, parts)
 	}
 	current := c.root
-	for i := 0; i < len(parts)-1; i++ {
+	for i := range len(parts) - 1 {
 		next, found := current[parts[i]]
 		if !found {
 			if create {
--- a/config/defaultConfigProvider_test.go
+++ b/config/defaultConfigProvider_test.go
@ -332,7 +332,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			return nil
 		}

-		for i := 0; i < 20; i++ {
+		for i := range 20 {
 			i := i
 			r.Run(func() error {
 				const v = 42
--- a/config/namespace.go
+++ b/config/namespace.go
@ -22,7 +22,7 @@ import (
 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 := hashing.HashStringHex(configSource)

 	// Build the config
 	c, ext, err := buildConfig(configSource)
--- a/config/namespace_test.go
+++ b/config/namespace_test.go
@ -29,7 +29,7 @@ func TestNamespace(t *testing.T) {
 	// ns, err := config.DecodeNamespace[map[string]DocsMediaTypeConfig](in, defaultMediaTypesConfig, buildConfig)

 	ns, err := DecodeNamespace[[]*tstNsExt](
-		map[string]interface{}{"foo": "bar"},
+		map[string]any{"foo": "bar"},
 		func(v any) (*tstNsExt, any, error) {
 			t := &tstNsExt{}
 			m, err := maps.ToStringMapE(v)
@ -42,8 +42,8 @@ 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.SourceStructure, qt.DeepEquals, map[string]any{"foo": "bar"})
+	c.Assert(ns.SourceHash, qt.Equals, "1420f6c7782f7459")
 	c.Assert(ns.Config, qt.DeepEquals, &tstNsExt{Foo: "bar"})
 	c.Assert(ns.Signature(), qt.DeepEquals, []*tstNsExt(nil))
 }
--- a/config/privacy/privacyConfig.go
+++ b/config/privacy/privacyConfig.go
@ -30,9 +30,10 @@ type Config struct {
 	Disqus          Disqus
 	GoogleAnalytics GoogleAnalytics
 	Instagram       Instagram
-	Twitter         Twitter
+	Twitter         Twitter // deprecated in favor of X in v0.141.0
 	Vimeo           Vimeo
 	YouTube         YouTube
+	X               X
 }

 // Disqus holds the privacy configuration settings related to the Disqus template.
@ -58,7 +59,8 @@ type Instagram struct {
 	Simple bool
 }

-// Twitter holds the privacy configuration settingsrelated to the Twitter shortcode.
+// Twitter holds the privacy configuration settings related to the Twitter shortcode.
+// Deprecated in favor of X in v0.141.0.
 type Twitter struct {
 	Service `mapstructure:",squash"`

@ -70,7 +72,7 @@ type Twitter struct {
 	Simple bool
 }

-// Vimeo holds the privacy configuration settingsrelated to the Vimeo shortcode.
+// Vimeo holds the privacy configuration settings related to the Vimeo shortcode.
 type Vimeo struct {
 	Service `mapstructure:",squash"`

@ -84,7 +86,7 @@ type Vimeo struct {
 	Simple bool
 }

-// YouTube holds the privacy configuration settingsrelated to the YouTube shortcode.
+// YouTube holds the privacy configuration settings related to the YouTube shortcode.
 type YouTube struct {
 	Service `mapstructure:",squash"`

@ -94,6 +96,20 @@ type YouTube struct {
 	PrivacyEnhanced bool
 }

+// X holds the privacy configuration settings related to the X shortcode.
+type X struct {
+	Service `mapstructure:",squash"`
+
+	// When set to true, the X post and its embedded page on your site are not
+	// used for purposes that include personalized suggestions and personalized
+	// ads.
+	EnableDNT bool
+
+	// If simple mode is enabled, a static and no-JS version of the X post will
+	// be built.
+	Simple bool
+}
+
 // DecodeConfig creates a privacy Config from a given Hugo configuration.
 func DecodeConfig(cfg config.Provider) (pc Config, err error) {
 	if !cfg.IsSet(privacyConfigKey) {
--- a/config/privacy/privacyConfig_test.go
+++ b/config/privacy/privacyConfig_test.go
@ -36,7 +36,7 @@ respectDoNotTrack = true
 [privacy.instagram]
 disable = true
 simple = true
-[privacy.twitter]
+[privacy.x]
 disable = true
 enableDNT = true
 simple = true
@ -59,9 +59,10 @@ simple = true
 	got := []bool{
 		pc.Disqus.Disable, pc.GoogleAnalytics.Disable,
 		pc.GoogleAnalytics.RespectDoNotTrack, 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,
+		pc.Instagram.Simple,
+		pc.Vimeo.Disable, pc.Vimeo.EnableDNT, pc.Vimeo.Simple,
+		pc.YouTube.PrivacyEnhanced, pc.YouTube.Disable, pc.X.Disable, pc.X.EnableDNT,
+		pc.X.Simple,
 	}

 	c.Assert(got, qt.All(qt.Equals), true)
--- a/config/security/whitelist.go
+++ b/config/security/whitelist.go
@ -73,7 +73,7 @@ func NewWhitelist(patterns ...string) (Whitelist, error) {

 	var patternsr []*regexp.Regexp

-	for i := 0; i < len(patterns); i++ {
+	for i := range patterns {
 		p := strings.TrimSpace(patterns[i])
 		if p == "" {
 			continue
--- a/config/services/servicesConfig.go
+++ b/config/services/servicesConfig.go
@ -31,7 +31,8 @@ type Config struct {
 	Disqus          Disqus
 	GoogleAnalytics GoogleAnalytics
 	Instagram       Instagram
-	Twitter         Twitter
+	Twitter         Twitter // deprecated in favor of X in v0.141.0
+	X               X
 	RSS             RSS
 }

@ -61,6 +62,7 @@ type Instagram struct {
 }

 // Twitter holds the functional configuration settings related to the Twitter shortcodes.
+// Deprecated in favor of X in v0.141.0.
 type Twitter struct {
 	// The Simple variant of Twitter is decorated with a basic set of inline styles.
 	// This means that if you want to provide your own CSS, you want
@ -68,6 +70,14 @@ type Twitter struct {
 	DisableInlineCSS bool
 }

+// X holds the functional configuration settings related to the X shortcodes.
+type X struct {
+	// The Simple variant of X is decorated with a basic set of inline styles.
+	// This means that if you want to provide your own CSS, you want
+	// to disable the inline CSS provided by Hugo.
+	DisableInlineCSS bool
+}
+
 // RSS holds the functional configuration settings related to the RSS feeds.
 type RSS struct {
 	// Limit the number of pages.
@ -91,6 +101,9 @@ func DecodeConfig(cfg config.Provider) (c Config, err error) {

 	if c.RSS.Limit == 0 {
 		c.RSS.Limit = cfg.GetInt(rssLimitKey)
+		if c.RSS.Limit == 0 {
+			c.RSS.Limit = -1
+		}
 	}

 	return
--- a/config/services/servicesConfig_test.go
+++ b/config/services/servicesConfig_test.go
@ -36,6 +36,8 @@ id = "ga_id"
 disableInlineCSS = true
 [services.twitter]
 disableInlineCSS = true
+[services.x]
+disableInlineCSS = true
 `
 	cfg, err := config.FromConfigString(tomlConfig, "toml")
 	c.Assert(err, qt.IsNil)
--- a/create/content.go
+++ b/create/content.go
@ -82,11 +82,13 @@ func NewContent(h *hugolib.HugoSites, kind, targetPath string, force bool) error
 	b.setArcheTypeFilenameToUse(ext)

 	withBuildLock := func() (string, error) {
-		unlock, err := h.BaseFs.LockBuild()
-		if err != nil {
-			return "", fmt.Errorf("failed to acquire a build lock: %s", err)
+		if !h.Configs.Base.NoBuildLock {
+			unlock, err := h.BaseFs.LockBuild()
+			if err != nil {
+				return "", fmt.Errorf("failed to acquire a build lock: %s", err)
+			}
+			defer unlock()
 		}
-		defer unlock()

 		if b.isDir {
 			return "", b.buildDir()
@ -289,7 +291,7 @@ func (b *contentBuilder) applyArcheType(contentFilename string, archetypeFi hugo
 func (b *contentBuilder) mapArcheTypeDir() error {
 	var m archetypeMap

-	seen := map[hstrings.Tuple]bool{}
+	seen := map[hstrings.Strings2]bool{}

 	walkFn := func(path string, fim hugofs.FileMetaInfo) error {
 		if fim.IsDir() {
@ -299,7 +301,7 @@ func (b *contentBuilder) mapArcheTypeDir() error {
 		pi := fim.Meta().PathInfo

 		if pi.IsContent() {
-			pathLang := hstrings.Tuple{First: pi.PathNoIdentifier(), Second: fim.Meta().Lang}
+			pathLang := hstrings.Strings2{pi.PathBeforeLangAndOutputFormatAndExt(), fim.Meta().Lang}
 			if seen[pathLang] {
 				// Duplicate content file, e.g. page.md and page.html.
 				// In the regular build, we will filter out the duplicates, but
--- a/create/content_test.go
+++ b/create/content_test.go
@ -129,7 +129,7 @@ site RegularPages: {{ len site.RegularPages  }}

 `

-	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0o755), qt.IsNil)
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.md"), fmt.Appendf(nil, contentFile, "index.md"), 0o755), qt.IsNil)
 	c.Assert(afero.WriteFile(mm, filepath.Join(defaultArchetypeDir, "index.md"), []byte("default archetype index.md"), 0o755), qt.IsNil)

 	c.Assert(initFs(mm), qt.IsNil)
--- a/create/skeletons/skeletons.go
+++ b/create/skeletons/skeletons.go
@ -34,10 +34,60 @@ var siteFs embed.FS
 var themeFs embed.FS

 // CreateTheme creates a theme skeleton.
-func CreateTheme(createpath string, sourceFs afero.Fs) error {
+func CreateTheme(createpath string, sourceFs afero.Fs, format string) error {
 	if exists, _ := helpers.Exists(createpath, sourceFs); exists {
 		return errors.New(createpath + " already exists")
 	}
+
+	format = strings.ToLower(format)
+
+	siteConfig := map[string]any{
+		"baseURL":      "https://example.org/",
+		"languageCode": "en-US",
+		"title":        "My New Hugo Site",
+		"menus": map[string]any{
+			"main": []any{
+				map[string]any{
+					"name":    "Home",
+					"pageRef": "/",
+					"weight":  10,
+				},
+				map[string]any{
+					"name":    "Posts",
+					"pageRef": "/posts",
+					"weight":  20,
+				},
+				map[string]any{
+					"name":    "Tags",
+					"pageRef": "/tags",
+					"weight":  30,
+				},
+			},
+		},
+		"module": map[string]any{
+			"hugoVersion": map[string]any{
+				"extended": false,
+				"min":      "0.146.0",
+			},
+		},
+	}
+
+	err := createSiteConfig(sourceFs, createpath, siteConfig, format)
+	if err != nil {
+		return err
+	}
+
+	defaultArchetype := map[string]any{
+		"title": "{{ replace .File.ContentBaseName \"-\" \" \" | title }}",
+		"date":  "{{ .Date }}",
+		"draft": true,
+	}
+
+	err = createDefaultArchetype(sourceFs, createpath, defaultArchetype, format)
+	if err != nil {
+		return err
+	}
+
 	return copyFiles(createpath, sourceFs, themeFs)
 }

@ -71,12 +121,24 @@ func CreateSite(createpath string, sourceFs afero.Fs, force bool, format string)
 		}
 	}

-	err := newSiteCreateConfig(sourceFs, createpath, format)
+	siteConfig := map[string]any{
+		"baseURL":      "https://example.org/",
+		"title":        "My New Hugo Site",
+		"languageCode": "en-us",
+	}
+
+	err := createSiteConfig(sourceFs, createpath, siteConfig, format)
 	if err != nil {
 		return err
 	}

-	err = newSiteCreateArchetype(sourceFs, createpath, format)
+	defaultArchetype := map[string]any{
+		"title": "{{ replace .File.ContentBaseName \"-\" \" \" | title }}",
+		"date":  "{{ .Date }}",
+		"draft": true,
+	}
+
+	err = createDefaultArchetype(sourceFs, createpath, defaultArchetype, format)
 	if err != nil {
 		return err
 	}
@ -99,13 +161,7 @@ func copyFiles(createpath string, sourceFs afero.Fs, skeleton embed.FS) error {
 	})
 }

-func newSiteCreateConfig(fs afero.Fs, createpath string, format string) (err error) {
-	in := map[string]string{
-		"baseURL":      "https://example.org/",
-		"title":        "My New Hugo Site",
-		"languageCode": "en-us",
-	}
-
+func createSiteConfig(fs afero.Fs, createpath string, in map[string]any, format string) (err error) {
 	var buf bytes.Buffer
 	err = parser.InterfaceToConfig(in, metadecoders.FormatFromString(format), &buf)
 	if err != nil {
@ -115,13 +171,7 @@ 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,
-	}
-
+func createDefaultArchetype(fs afero.Fs, createpath string, in map[string]any, format string) (err error) {
 	var buf bytes.Buffer
 	err = parser.InterfaceToFrontMatter(in, metadecoders.FormatFromString(format), &buf)
 	if err != nil {
--- a/create/skeletons/theme/LICENSE
+++ b/create/skeletons/theme/LICENSE
@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) [year] [fullname]
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
--- a/create/skeletons/theme/README.md
+++ b/create/skeletons/theme/README.md
@ -1,7 +0,0 @@
-# Theme Name
-
-## Features
-
-## Installation
-
-## Configuration
--- a/Show more
+++ b/Show more
				`@ -1 +0,0 @@`
				`gobench -package=./hugolib -bench="BenchmarkSiteNew/Deep_content_tree"`
				`@ -1 +0,0 @@`
				`docker run --rm --mount type=bind,source="$(pwd)",target=/hugo -w /hugo -i -t bepsays/ci-goreleaser:1.11-2 /bin/bash`