releaser: Bump versions for release of 0.157.0

[ci skip]

.circleci/config.yml

@@ -4,7 +4,7 @@ parameters:
 defaults: &defaults
   resource_class: large
   docker:
-      - image: bepsays/ci-hugoreleaser:1.22500.20400
+      - image: bepsays/ci-hugoreleaser:1.22600.20000
 environment: &buildenv
       GOMODCACHE: /root/project/gomodcache
 version: 2
@@ -58,7 +58,7 @@ jobs:
     environment:
         <<: [*buildenv]
     docker:
-    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22500.20400
+    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22600.20000
     steps:
       - *restore-cache
       - &attach-workspace

.github/workflows/aiwatchdog.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
       - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: AI Watchdog
-        uses: bep/ai-watchdog@995475dd81767f8035dc2c943e9230918d06caca # temporary fork (probably)
+        uses: bep/ai-watchdog@e85b3674edb3f174950e7622b87350ad54b2013e # temporary fork (probably)
         with:
           openai-api-key: ${{ secrets.OPENAI_API_KEY }}
           pr-label: AI Suspect

.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.24.x, 1.25.x]
+        go-version: [1.25.x, 1.26.x]
         os: [ubuntu-latest, windows-latest] # macos disabled for now because of disk space issues.
     runs-on: ${{ matrix.os }}
     steps:
@@ -106,7 +106,10 @@ jobs:
         run: go install honnef.co/go/tools/cmd/staticcheck@latest
       - if: matrix.os == 'ubuntu-latest'
         name: Run staticcheck
-        run: staticcheck ./...
+        run: |
+          export STATICCHECK_CACHE="${{ runner.temp }}/staticcheck"
+          staticcheck ./...
+          rm -rf ${{ runner.temp }}/staticcheck
       - if: matrix.os != 'windows-latest'
         name: Check
         run: |
@@ -118,16 +121,14 @@ jobs:
         # See issue #11052. We limit the build to regular test (no -race flag) on Windows for now.
         name: Test
         run: |
-          mage -v test;
+          mage -v test
         env:
           HUGO_BUILD_TAGS: extended,withdeploy
-      - name: Build tags
-        run: |
-          go install -tags extended
       - if: matrix.os == 'ubuntu-latest'
         name: Build for dragonfly
         run: |
           go install
+          go clean -i -cache
         env:
           GOARCH: amd64
           GOOS: dragonfly

.gitignore

@@ -3,4 +3,5 @@
 imports.*
 dist/
 public/
-.DS_Store 
+.DS_Store 
+cache/filecache/_gen/

.prettierignore

@@ -0,0 +1 @@
+tpl/tplimpl/embedded/templates/**

AGENTS.md

@@ -0,0 +1,17 @@
+* Brevity is good.
+* Assume that the maintainers and readers of the code you write are Go experts:
+   * Don't use comments to explain the obvious.
+   * Use self-explanatory variable and function names.
+   * Use short variable names when the context is clear.
+* If you need to add temporary debug printing, use `hdebug.Printf`.[^1]
+* Never export symbols that's not needed outside of the package.
+* Avoid global state at (almost) all cost.
+* This is a project with a long history; assume that a similiar problem has been solved before, look hard for helper functions before creating new ones.
+* In tests, use `qt` matchers (e.g. `b.Assert(err, qt.ErrorMatches, ...)`) instead of raw `if`/`t.Fatal` checks.
+* In tests, always use the latest Hugo specification, e.g. for layouts, it's `layouts/page.html` and not `layouts/_default/single.html`, `layouts/list.html` and not `layouts/_default/list.html`
+* Brevity is good. This applies to code, comments and commit messages. Don't write a novel.
+* Use `./check.sh ./somepackage/...` when iterating.
+* Use `./check.sh` when you're done.
+
+
+[^1]: CI build fail if you forget to remove the debug printing.

CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

CONTRIBUTING.md

@@ -77,7 +77,7 @@ To make the contribution process as seamless as possible, we ask for the followi
     * Run `go fmt`.
     * Add documentation if you are adding new features or changing functionality.  The docs site lives in `/docs`.
     * Squash your commits into a single commit. `git rebase -i`. It’s okay to force update your pull request with `git push -f`.
-    * Ensure that `mage check` succeeds. [Travis CI](https://travis-ci.org/gohugoio/hugo) (Windows, Linux and macOS) will fail the build if `mage check` fails.
+    * Ensure that `./check.sh` succeeds. Note that some tests are skipped when running locally, some because they are slow. To run these locally,  do `CI_LOCAL=true ./check.sh ./somepackage/...`.
     * Follow the **Git Commit Message Guidelines** below.
 
 ## AI Assistance Notice
@@ -88,7 +88,7 @@ An example disclosure:
 
 > This PR was written primarily by Claude Code.
 
-When using AI assistance, we expect contributors to understand the code that is produced and be able to answer critical questions about it.
+When using AI assistance, we expect contributors to understand the code that is produced and be able to answer critical questions about it. Also, AI contributions from non-maintainers needs to have a fairly narrow scope (e.g. a bug fix), as we have limited review capacity.
 
 ### Git Commit Message Guidelines
 

Dockerfile

@@ -2,7 +2,7 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/
 
-ARG GO_VERSION="1.25"
+ARG GO_VERSION="1.26"
 ARG ALPINE_VERSION="3.22"
 ARG DART_SASS_VERSION="1.79.3"
 
@@ -65,7 +65,9 @@ RUN apk add --no-cache \
     git \
     runuser \
     nodejs \
-    npm
+    npm \
+    openssh-client \
+    tar
 
 RUN mkdir -p /var/hugo/bin /cache && \
     addgroup -Sg 1000 hugo && \

README.md

@@ -52,7 +52,7 @@ Use Hugo's embedded web server during development to instantly see changes to co
 
 Hugo's fast asset pipelines include:
 
-- Image processing – Convert, resize, crop, rotate, adjust colors, apply filters, overlay text and images, and extract EXIF data
+- Image processing – Convert, resize, crop, rotate, adjust colors, apply filters, overlay text and images, and extract metadata
 - JavaScript bundling – Transpile TypeScript and JSX to JavaScript, bundle, tree shake, minify, create source maps, and perform SRI hashing.
 - Sass processing – Transpile Sass to CSS, bundle, tree shake, minify, create source maps, perform SRI hashing, and integrate with PostCSS
 - Tailwind CSS processing – Compile Tailwind CSS utility classes into standard CSS, bundle, tree shake, optimize, minify, perform SRI hashing, and integrate with PostCSS
@@ -65,8 +65,6 @@ 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/hugoDocs/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></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/hugoDocs/master/assets/images/sponsors/goland.svg" width="200" alt="The complete IDE crafted for professional Go developers."></a>
   &nbsp;&nbsp;&nbsp;
     <a href="https://cloudcannon.com/hugo-cms/?utm_campaign=HugoSponsorship&utm_source=sponsor&utm_content=gohugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/cloudcannon-cms-logo.svg" width="200" alt="CloudCannon"></a>
@@ -158,6 +156,16 @@ If there is sufficient interest, [create a proposal]. Do not submit a pull reque
 
 For a complete guide to contributing to Hugo, see the [Contribution Guide](CONTRIBUTING.md).
 
+## License
+
+For the Hugo source code, see [LICENSE](/LICENSE).
+
+We also bundle some libraries in binary/WASM form:
+
+* [libwebp](https://github.com/webmproject/libwebp), [BSD-3-Clause license](https://github.com/webmproject/libwebp?tab=BSD-3-Clause-1-ov-file#readme)
+* [Katex](https://github.com/KaTeX/KaTeX), [MIT license](https://github.com/KaTeX/KaTeX?tab=MIT-1-ov-file#readme)
+* [QuickJS](https://github.com/bellard/quickjs?tab=License-1-ov-file#readme), [License](https://github.com/bellard/quickjs?tab=License-1-ov-file#readme)
+
 ## Dependencies
 
 Hugo stands on the shoulders of great open source libraries. Run `hugo env --logLevel info` to display a list of dependencies.

cache/dynacache/dynacache.go

@@ -69,7 +69,7 @@ func New(opts Options) *Cache {
 
 	infol := opts.Log.InfoCommand("dynacache")
 
-	evictedIdentities := collections.NewStack[KeyIdentity]()
+	evictedIdentities := collections.NewStackThreadSafe[KeyIdentity]()
 
 	onEvict := func(k, v any) {
 		if !opts.Watching {
@@ -129,7 +129,7 @@ type Cache struct {
 	partitions map[string]PartitionManager
 
 	onEvict           func(k, v any)
-	evictedIdentities *collections.Stack[KeyIdentity]
+	evictedIdentities *collections.StackThreadSafe[KeyIdentity]
 
 	opts  Options
 	infol logg.LevelLogger

cache/filecache/filecache.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@ package filecache
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -45,16 +46,12 @@ const (
 type Cache struct {
 	Fs afero.Fs
 
-	// Max age for items in this cache. Negative duration means forever,
-	// 0 is effectively turning this cache off.
-	maxAge time.Duration
+	cfg FileCacheConfig
 
-	// When set, we just remove this entire root directory on expiration.
-	pruneAllRootDir string
-
-	nlocker *lockTracker
+	entryLocker *lockTracker
 
 	initOnce sync.Once
+	isInited bool
 	initErr  error
 }
 
@@ -88,12 +85,15 @@ type ItemInfo struct {
 }
 
 // NewCache creates a new file cache with the given filesystem and max age.
-func NewCache(fs afero.Fs, maxAge time.Duration, pruneAllRootDir string) *Cache {
+func NewCache(fs afero.Fs, cfg FileCacheConfig) *Cache {
+	if err := cfg.init(); err != nil {
+		panic(fmt.Sprintf("invalid cache config: %s", err))
+	}
+
 	return &Cache{
-		Fs:              fs,
-		nlocker:         &lockTracker{Locker: locker.NewLocker(), seen: make(map[string]struct{})},
-		maxAge:          maxAge,
-		pruneAllRootDir: pruneAllRootDir,
+		Fs:          fs,
+		entryLocker: &lockTracker{Locker: locker.NewLocker(), seen: make(map[string]struct{})},
+		cfg:         cfg,
 	}
 }
 
@@ -109,9 +109,15 @@ func (l *lockedFile) Close() error {
 }
 
 func (c *Cache) init() error {
+	if c == nil {
+		panic("cache is nil")
+	}
+
 	c.initOnce.Do(func() {
+		c.isInited = true
 		// Create the base dir if it does not exist.
 		if err := c.Fs.MkdirAll("", 0o777); err != nil && !os.IsExist(err) {
+			err = fmt.Errorf("failled to create base cache directory: %s", err)
 			c.initErr = err
 		}
 	})
@@ -126,19 +132,19 @@ func (c *Cache) WriteCloser(id string) (ItemInfo, io.WriteCloser, error) {
 	}
 
 	id = cleanID(id)
-	c.nlocker.Lock(id)
+	c.entryLocker.Lock(id)
 
 	info := ItemInfo{Name: id}
 
 	f, err := helpers.OpenFileForWriting(c.Fs, id)
 	if err != nil {
-		c.nlocker.Unlock(id)
+		c.entryLocker.Unlock(id)
 		return info, nil, err
 	}
 
 	return info, &lockedFile{
 		File:   f,
-		unlock: func() { c.nlocker.Unlock(id) },
+		unlock: func() { c.entryLocker.Unlock(id) },
 	}, nil
 }
 
@@ -156,8 +162,8 @@ func (c *Cache) ReadOrCreate(id string,
 
 	id = cleanID(id)
 
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
+	c.entryLocker.Lock(id)
+	defer c.entryLocker.Unlock(id)
 
 	info = ItemInfo{Name: id}
 
@@ -186,9 +192,9 @@ func (c *Cache) ReadOrCreate(id string,
 // NamedLock locks the given id. The lock is released when the returned function is called.
 func (c *Cache) NamedLock(id string) func() {
 	id = cleanID(id)
-	c.nlocker.Lock(id)
+	c.entryLocker.Lock(id)
 	return func() {
-		c.nlocker.Unlock(id)
+		c.entryLocker.Unlock(id)
 	}
 }
 
@@ -201,8 +207,8 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It
 	}
 	id = cleanID(id)
 
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
+	c.entryLocker.Lock(id)
+	defer c.entryLocker.Unlock(id)
 
 	info := ItemInfo{Name: id}
 
@@ -220,7 +226,7 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It
 		return info, nil, err
 	}
 
-	if c.maxAge == 0 {
+	if c.cfg.MaxAge == 0 {
 		// No caching.
 		return info, hugio.ToReadCloser(r), nil
 	}
@@ -231,6 +237,40 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It
 		c.writeReader(id, io.TeeReader(r, &buff))
 }
 
+// AbsFilenameFromID returns the filename for the given id in the cache.
+// This will be an absolute path.
+func (c *Cache) AbsFilenameFromID(id string) string {
+	return filepath.Join(c.cfg.DirCompiled, cleanID(id))
+}
+
+// GetOrCreateInfo tries to get the item info with the given id from cache. If not found or expired, create will
+// be invoked with the id. The create function is expected to create the cache item with the given id. The returned ItemInfo will have the id as Name.
+// This method is protected by a named lock using the given id as identifier.
+func (c *Cache) GetOrCreateInfo(id string, create func(id string) error) (ItemInfo, error) {
+	if err := c.init(); err != nil {
+		return ItemInfo{}, err
+	}
+
+	id = cleanID(id)
+
+	c.entryLocker.Lock(id)
+	defer c.entryLocker.Unlock(id)
+
+	info := ItemInfo{Name: id}
+
+	if !c.removeIfNeeded(id) {
+		// The file exists and is not expired, so we consider it a cache hit.
+		return info, nil
+	}
+
+	if err := create(id); err != nil {
+		c.remove(id)
+		return info, err
+	}
+
+	return info, nil
+}
+
 func (c *Cache) writeReader(id string, r io.Reader) error {
 	dir := filepath.Dir(id)
 	if dir != "" {
@@ -254,8 +294,8 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 	}
 	id = cleanID(id)
 
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
+	c.entryLocker.Lock(id)
+	defer c.entryLocker.Unlock(id)
 
 	info := ItemInfo{Name: id}
 
@@ -275,7 +315,7 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 		return info, nil, err
 	}
 
-	if c.maxAge == 0 {
+	if c.cfg.MaxAge == 0 {
 		return info, b, nil
 	}
 
@@ -286,15 +326,39 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 	return info, b, nil
 }
 
+// SetBytes sets the file content with the given id in the cache.
+func (c *Cache) SetBytes(id string, data []byte) error {
+	if err := c.init(); err != nil {
+		return err
+	}
+	id = cleanID(id)
+
+	c.entryLocker.Lock(id)
+	defer c.entryLocker.Unlock(id)
+
+	if c.cfg.MaxAge == 0 {
+		// No caching.
+		return nil
+	}
+
+	return c.writeReader(id, bytes.NewReader(data))
+}
+
 // GetBytes gets the file content with the given id from the cache, nil if none found.
-func (c *Cache) GetBytes(id string) (ItemInfo, []byte, error) {
+func (c *Cache) GetBytes(id string) ([]byte, error) {
+	_, b, err := c.GetItemBytes(id)
+	return b, err
+}
+
+// GetItemBytes gets the ItemInfo and file content with the given id from the cache, nil if none found.
+func (c *Cache) GetItemBytes(id string) (ItemInfo, []byte, error) {
 	if err := c.init(); err != nil {
 		return ItemInfo{}, nil, err
 	}
 	id = cleanID(id)
 
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
+	c.entryLocker.Lock(id)
+	defer c.entryLocker.Unlock(id)
 
 	info := ItemInfo{Name: id}
 
@@ -314,8 +378,8 @@ func (c *Cache) Get(id string) (ItemInfo, io.ReadCloser, error) {
 	}
 	id = cleanID(id)
 
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
+	c.entryLocker.Lock(id)
+	defer c.entryLocker.Unlock(id)
 
 	info := ItemInfo{Name: id}
 
@@ -324,10 +388,23 @@ func (c *Cache) Get(id string) (ItemInfo, io.ReadCloser, error) {
 	return info, r, nil
 }
 
+// removeIfNeeded checks if the file with the given id should be re-created.
+func (c *Cache) removeIfNeeded(id string) bool {
+	if c.cfg.MaxAge == 0 {
+		// No caching, remove.
+		c.remove(id)
+		return true
+	}
+	if removed, err := c.removeIfExpired(id); err != nil || removed {
+		return true
+	}
+	return false
+}
+
 // getOrRemove gets the file with the given id. If it's expired, it will
 // be removed.
 func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
-	if c.maxAge == 0 {
+	if c.cfg.MaxAge == 0 {
 		// No caching.
 		return nil
 	}
@@ -345,7 +422,7 @@ func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
 }
 
 func (c *Cache) getBytesAndRemoveIfExpired(id string) ([]byte, bool) {
-	if c.maxAge == 0 {
+	if c.cfg.MaxAge == 0 {
 		// No caching.
 		return nil, false
 	}
@@ -370,7 +447,7 @@ func (c *Cache) getBytesAndRemoveIfExpired(id string) ([]byte, bool) {
 }
 
 func (c *Cache) removeIfExpired(id string) (bool, error) {
-	if c.maxAge <= 0 {
+	if c.cfg.MaxAge <= 0 {
 		return false, nil
 	}
 
@@ -380,29 +457,37 @@ func (c *Cache) removeIfExpired(id string) (bool, error) {
 	}
 
 	if c.isExpired(fi.ModTime()) {
-		c.Fs.Remove(id)
+		c.remove(id)
 		return true, nil
 	}
 
 	return false, nil
 }
 
+func (c *Cache) remove(id string) {
+	if c.cfg.entryIsDir {
+		c.Fs.RemoveAll(id)
+	} else {
+		c.Fs.Remove(id)
+	}
+}
+
 func (c *Cache) isExpired(modTime time.Time) bool {
-	if c.maxAge < 0 {
+	if c.cfg.MaxAge < 0 {
 		return false
 	}
 
 	// Note the use of time.Since here.
 	// We cannot use Hugo's global Clock for this.
-	return c.maxAge == 0 || time.Since(modTime) > c.maxAge
+	return c.cfg.MaxAge == 0 || time.Since(modTime) > c.cfg.MaxAge
 }
 
 // For testing
 func (c *Cache) GetString(id string) string {
 	id = cleanID(id)
 
-	c.nlocker.Lock(id)
-	defer c.nlocker.Unlock(id)
+	c.entryLocker.Lock(id)
+	defer c.entryLocker.Unlock(id)
 
 	f, err := c.Fs.Open(id)
 	if err != nil {
@@ -417,6 +502,17 @@ func (c *Cache) GetString(id string) string {
 // Caches is a named set of caches.
 type Caches map[string]*Cache
 
+func (f Caches) SetResourceFs(fs afero.Fs) {
+	for _, c := range f {
+		if c.cfg.IsResourceDir {
+			if c.isInited {
+				panic("cannot set resource fs after init")
+			}
+			c.Fs = hugofs.NewBasePathFs(fs, c.cfg.DirCompiled)
+		}
+	}
+}
+
 // Get gets a named cache, nil if none found.
 func (f Caches) Get(name string) *Cache {
 	return f[strings.ToLower(name)]
@@ -424,34 +520,21 @@ func (f Caches) Get(name string) *Cache {
 
 // NewCaches creates a new set of file caches from the given
 // configuration.
-func NewCaches(p *helpers.PathSpec) (Caches, error) {
-	dcfg := p.Cfg.GetConfigSection("caches").(Configs)
-	fs := p.Fs.Source
+func NewCaches(dcfg Configs, sourceFs afero.Fs) (Caches, error) {
+	fs := sourceFs
 
 	m := make(Caches)
 	for k, v := range dcfg {
 		var cfs afero.Fs
-
 		if v.IsResourceDir {
-			cfs = p.BaseFs.ResourcesCache
+			cfs = nil // Set later. TODO(bep) this needs to be cleanded up.
 		} else {
-			cfs = fs
+			cfs = hugofs.NewBasePathFs(fs, v.DirCompiled)
 		}
 
-		if cfs == nil {
-			panic("nil fs")
-		}
+		c := NewCache(cfs, v)
 
-		baseDir := v.DirCompiled
-
-		bfs := hugofs.NewBasePathFs(cfs, baseDir)
-
-		var pruneAllRootDir string
-		if k == CacheKeyModules {
-			pruneAllRootDir = "pkg"
-		}
-
-		m[k] = NewCache(bfs, v.MaxAge, pruneAllRootDir)
+		m[k] = c
 	}
 
 	return m, nil
@@ -480,7 +563,7 @@ func (h *httpCache) Get(id string) (resp []byte, ok bool) {
 }
 
 func (h *httpCache) Set(id string, resp []byte) {
-	if h.c.maxAge == 0 {
+	if h.c.cfg.MaxAge == 0 {
 		return
 	}
 

cache/filecache/filecache_config.go

@@ -15,6 +15,7 @@
 package filecache
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"path"
@@ -22,7 +23,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/config"
 
 	"github.com/mitchellh/mapstructure"
@@ -34,19 +35,14 @@ const (
 	cacheDirProject = ":cacheDir/:project"
 )
 
-var defaultCacheConfig = FileCacheConfig{
-	MaxAge: -1, // Never expire
-	Dir:    cacheDirProject,
-}
-
 const (
-	CacheKeyGetJSON     = "getjson"
-	CacheKeyGetCSV      = "getcsv"
-	CacheKeyImages      = "images"
-	CacheKeyAssets      = "assets"
-	CacheKeyModules     = "modules"
-	CacheKeyGetResource = "getresource"
-	CacheKeyMisc        = "misc"
+	CacheKeyImages        = "images"
+	CacheKeyAssets        = "assets"
+	CacheKeyModules       = "modules"
+	CacheKeyModuleQueries = "modulequeries"
+	CacheKeyModuleGitInfo = "modulegitinfo"
+	CacheKeyGetResource   = "getresource"
+	CacheKeyMisc          = "misc"
 )
 
 type Configs map[string]FileCacheConfig
@@ -67,9 +63,22 @@ var defaultCacheConfigs = Configs{
 	CacheKeyModules: {
 		MaxAge: -1,
 		Dir:    ":cacheDir/modules",
+		fileCacheConfigInternal: fileCacheConfigInternal{
+			entryIsDir: true,
+			isReadOnly: true, // we need to make it writable when pruning.
+		},
+	},
+	CacheKeyModuleQueries: {
+		MaxAge: 24 * time.Hour,
+		Dir:    ":cacheDir/modules",
+	},
+	CacheKeyModuleGitInfo: {
+		MaxAge: 24 * time.Hour,
+		Dir:    ":cacheDir/modules",
+		fileCacheConfigInternal: fileCacheConfigInternal{
+			entryIsDir: true,
+		},
 	},
-	CacheKeyGetJSON: defaultCacheConfig,
-	CacheKeyGetCSV:  defaultCacheConfig,
 	CacheKeyImages: {
 		MaxAge: -1,
 		Dir:    resourcesGenDir,
@@ -88,6 +97,13 @@ var defaultCacheConfigs = Configs{
 	},
 }
 
+func init() {
+	for k, v := range defaultCacheConfigs {
+		v.name = k
+		defaultCacheConfigs[k] = v
+	}
+}
+
 type FileCacheConfig struct {
 	// Max age of cache entries in this cache. Any items older than this will
 	// be removed and not returned from the cache.
@@ -99,22 +115,50 @@ type FileCacheConfig struct {
 	MaxAge time.Duration
 
 	// The directory where files are stored.
-	Dir         string
-	DirCompiled string `json:"-"`
+	Dir string
 
-	// Will resources/_gen will get its own composite filesystem that
-	// also checks any theme.
-	IsResourceDir bool `json:"-"`
+	fileCacheConfigInternal `json:"-"`
 }
 
-// GetJSONCache gets the file cache for getJSON.
-func (f Caches) GetJSONCache() *Cache {
-	return f[CacheKeyGetJSON]
+func (cfg *FileCacheConfig) init() error {
+	if cfg.DirCompiled == "" {
+		// From unit tests. Just check that it does not contain any placeholders.
+		if strings.Contains(cfg.Dir, ":") {
+			return fmt.Errorf("cache dir %q contains unresolved placeholders", cfg.Dir)
+		}
+		cfg.DirCompiled = cfg.Dir
+	}
+	// Sanity check the config.
+	if len(cfg.DirCompiled) < 5 {
+		panic(fmt.Sprintf("invalid cache dir: %q", cfg.DirCompiled))
+	}
+	return nil
 }
 
-// GetCSVCache gets the file cache for getCSV.
-func (f Caches) GetCSVCache() *Cache {
-	return f[CacheKeyGetCSV]
+type fileCacheConfigInternal struct {
+	DirCompiled string
+
+	name          string // The name of this cache, e.g. "images", "modules" etc.
+	entryIsDir    bool   // when set, the cache entries represents directories directly below the base dir.
+	isReadOnly    bool   // when set, the cache is read only and needs to be pruned differently. This is used for the Go modules cache.
+	IsResourceDir bool   //  resources/_gen will get its own composite filesystem that also checks any theme. TODO(bep) unexport this.
+}
+
+// MarshalJSON marshals FileCacheConfig to JSON with MaxAge as a human-readable string.
+func (c FileCacheConfig) MarshalJSON() ([]byte, error) {
+	var maxAge any
+	if c.MaxAge == -1 {
+		maxAge = -1
+	} else {
+		maxAge = strings.TrimSuffix(c.MaxAge.String(), "0m0s")
+	}
+	return json.Marshal(&struct {
+		MaxAge any    `json:"maxAge"`
+		Dir    string `json:"dir"`
+	}{
+		MaxAge: maxAge,
+		Dir:    c.Dir,
+	})
 }
 
 // ImageCache gets the file cache for processed images.
@@ -127,6 +171,25 @@ func (f Caches) ModulesCache() *Cache {
 	return f[CacheKeyModules]
 }
 
+// ModuleQueriesCache gets the file cache for Hugo Module version queries.
+// Returns nil if not found.
+func (f Caches) ModuleQueriesCache() *Cache {
+	c, ok := f[CacheKeyModuleQueries]
+	if !ok {
+		panic("module queries cache not set")
+	}
+	return c
+}
+
+// ModuleGitInfoCache gets the file cache for Hugo Module git info.
+func (f Caches) ModuleGitInfoCache() *Cache {
+	c, ok := f[CacheKeyModuleGitInfo]
+	if !ok {
+		panic("module git info cache not set")
+	}
+	return c
+}
+
 // AssetsCache gets the file cache for assets (processed resources, SCSS etc.).
 func (f Caches) AssetsCache() *Cache {
 	return f[CacheKeyAssets]
@@ -154,10 +217,14 @@ func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Config
 	_, isOsFs := fs.(*afero.OsFs)
 
 	for k, v := range m {
-		if _, ok := v.(maps.Params); !ok {
+		if _, ok := v.(hmaps.Params); !ok {
 			continue
 		}
-		cc := defaultCacheConfig
+		var ok bool
+		cc, ok := c[k]
+		if !ok {
+			return nil, fmt.Errorf("%q is not a valid cache name", k)
+		}
 
 		dc := &mapstructure.DecoderConfig{
 			Result:           &cc,
@@ -178,12 +245,8 @@ func DecodeConfig(fs afero.Fs, bcfg config.BaseConfig, m map[string]any) (Config
 			return c, errors.New("must provide cache Dir")
 		}
 
-		name := strings.ToLower(k)
-		if !valid[name] {
-			return nil, fmt.Errorf("%q is not a valid cache name", name)
-		}
+		c[k] = cc
 
-		c[name] = cc
 	}
 
 	for k, v := range c {

cache/filecache/filecache_config_test.go

@@ -14,6 +14,7 @@
 package filecache_test
 
 import (
+	"encoding/json"
 	"path/filepath"
 	"runtime"
 	"testing"
@@ -43,12 +44,9 @@ assetDir = "assets"
 archetypeDir = "archetypes"
 
 [caches]
-[caches.getJSON]
+[caches.misc]
 maxAge = "10m"
 dir = "/path/to/c1"
-[caches.getCSV]
-maxAge = "11h"
-dir = "/path/to/c2"
 [caches.images]
 dir = "/path/to/c3"
 [caches.getResource]
@@ -61,9 +59,9 @@ dir = "/path/to/c4"
 	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
 	c.Assert(len(decoded), qt.Equals, 7)
 
-	c2 := decoded["getcsv"]
-	c.Assert(c2.MaxAge.String(), qt.Equals, "11h0m0s")
-	c.Assert(c2.DirCompiled, qt.Equals, filepath.FromSlash("/path/to/c2/filecache/getcsv"))
+	c2 := decoded["misc"]
+	c.Assert(c2.MaxAge.String(), qt.Equals, "10m0s")
+	c.Assert(c2.DirCompiled, qt.Equals, filepath.FromSlash("/path/to/c1/filecache/misc"))
 
 	c3 := decoded["images"]
 	c.Assert(c3.MaxAge, qt.Equals, time.Duration(-1))
@@ -90,12 +88,9 @@ archeTypedir = "archetypes"
 
 ignoreCache = true
 [caches]
-[caches.getJSON]
+[caches.misc]
 maxAge = 1234
 dir = "/path/to/c1"
-[caches.getCSV]
-maxAge = 3456
-dir = "/path/to/c2"
 [caches.images]
 dir = "/path/to/c3"
 [caches.getResource]
@@ -132,15 +127,45 @@ func TestDecodeConfigDefault(t *testing.T) {
 	c.Assert(len(decoded), qt.Equals, 7)
 
 	imgConfig := decoded[filecache.CacheKeyImages]
-	jsonConfig := decoded[filecache.CacheKeyGetJSON]
+	miscConfig := decoded[filecache.CacheKeyMisc]
 
 	if runtime.GOOS == "windows" {
 		c.Assert(imgConfig.DirCompiled, qt.Equals, filepath.FromSlash("_gen/images"))
 	} else {
 		c.Assert(imgConfig.DirCompiled, qt.Equals, "_gen/images")
-		c.Assert(jsonConfig.DirCompiled, qt.Equals, "/cache/thecache/hugoproject/filecache/getjson")
+		c.Assert(miscConfig.DirCompiled, qt.Equals, "/cache/thecache/hugoproject/filecache/misc")
 	}
 
 	c.Assert(imgConfig.IsResourceDir, qt.Equals, true)
-	c.Assert(jsonConfig.IsResourceDir, qt.Equals, false)
+	c.Assert(miscConfig.IsResourceDir, qt.Equals, false)
+}
+
+func TestFileCacheConfigMarshalJSON(t *testing.T) {
+	c := qt.New(t)
+
+	cfg := config.New()
+	cfg.Set("cacheDir", "/cache")
+	cfg.Set("workingDir", "/my/project")
+
+	fs := afero.NewMemMapFs()
+	decoded := testconfig.GetTestConfigs(fs, cfg).Base.Caches
+
+	moduleQueriesConfig := decoded[filecache.CacheKeyModuleQueries]
+	c.Assert(moduleQueriesConfig.MaxAge, qt.Equals, 24*time.Hour)
+
+	// Also verify the new moduleGitInfo cache.
+	moduleGitInfoConfig := decoded[filecache.CacheKeyModuleGitInfo]
+	c.Assert(moduleGitInfoConfig.MaxAge, qt.Equals, 24*time.Hour)
+
+	b, err := json.Marshal(moduleQueriesConfig)
+	c.Assert(err, qt.IsNil)
+
+	c.Assert(string(b), qt.Contains, `"maxAge":"24h"`)
+	c.Assert(string(b), qt.Not(qt.Contains), "86400000000000")
+	c.Assert(string(b), qt.Not(qt.Contains), "8.64e")
+
+	moduleQueriesConfig.MaxAge = -1
+	b, err = json.Marshal(moduleQueriesConfig)
+	c.Assert(err, qt.IsNil)
+	c.Assert(string(b), qt.Contains, `"maxAge":-1`)
 }

cache/filecache/filecache_pruner.go

@@ -50,8 +50,8 @@ func (c Caches) Prune() (int, error) {
 // Prune removes expired and unused items from this cache.
 // If force is set, everything will be removed not considering expiry time.
 func (c *Cache) Prune(force bool) (int, error) {
-	if c.pruneAllRootDir != "" {
-		return c.pruneRootDir(force)
+	if c.cfg.entryIsDir {
+		return c.pruneRootDirs(force)
 	}
 	if err := c.init(); err != nil {
 		return 0, err
@@ -93,9 +93,9 @@ func (c *Cache) Prune(force bool) (int, error) {
 
 		shouldRemove := force || c.isExpired(info.ModTime())
 
-		if !shouldRemove && len(c.nlocker.seen) > 0 {
+		if !shouldRemove && len(c.entryLocker.seen) > 0 {
 			// Remove it if it's not been touched/used in the last build.
-			_, seen := c.nlocker.seen[name]
+			_, seen := c.entryLocker.seen[name]
 			shouldRemove = !seen
 		}
 
@@ -117,11 +117,43 @@ func (c *Cache) Prune(force bool) (int, error) {
 	return counter, err
 }
 
-func (c *Cache) pruneRootDir(force bool) (int, error) {
+func (c *Cache) pruneRootDirs(force bool) (int, error) {
+	dirs, err := afero.ReadDir(c.Fs, "")
+	if err != nil {
+		if herrors.IsNotExist(err) {
+			return 0, nil
+		}
+		return 0, err
+	}
+
+	counter := 0
+
+	for _, dir := range dirs {
+		if !dir.IsDir() {
+			continue
+		}
+
+		count, err := c.pruneRootDir(dir.Name(), force)
+		if err != nil {
+			return counter, err
+		}
+		counter += count
+	}
+
+	return counter, nil
+}
+
+func (c *Cache) pruneRootDir(dirname string, force bool) (int, error) {
 	if err := c.init(); err != nil {
 		return 0, err
 	}
-	info, err := c.Fs.Stat(c.pruneAllRootDir)
+
+	// Sanity check.
+	if dirname != "pkg" && len(dirname) < 5 {
+		panic(fmt.Sprintf("invalid cache dir name: %q", dirname))
+	}
+
+	info, err := c.Fs.Stat(dirname)
 	if err != nil {
 		if herrors.IsNotExist(err) {
 			return 0, nil
@@ -133,5 +165,9 @@ func (c *Cache) pruneRootDir(force bool) (int, error) {
 		return 0, nil
 	}
 
-	return hugofs.MakeReadableAndRemoveAllModulePkgDir(c.Fs, c.pruneAllRootDir)
+	if c.cfg.isReadOnly {
+		return hugofs.MakeReadableAndRemoveAllModulePkgDir(c.Fs, dirname)
+	}
+
+	return 1, c.Fs.RemoveAll(dirname)
 }

cache/filecache/filecache_pruner_test.go

@@ -39,12 +39,9 @@ assetDir = "assets"
 archeTypedir = "archetypes"
 
 [caches]
-[caches.getjson]
+[caches.misc]
 maxAge = "200ms"
 dir = "/cache/c"
-[caches.getcsv]
-maxAge = "200ms"
-dir = "/cache/d"
 [caches.assets]
 maxAge = "200ms"
 dir = ":resourceDir/_gen"
@@ -53,11 +50,14 @@ maxAge = "200ms"
 dir = ":resourceDir/_gen"
 `
 
-	for _, name := range []string{filecache.CacheKeyGetCSV, filecache.CacheKeyGetJSON, filecache.CacheKeyAssets, filecache.CacheKeyImages} {
+	for _, name := range []string{filecache.CacheKeyAssets, filecache.CacheKeyImages} {
 		msg := qt.Commentf("cache: %s", name)
-		p := newPathsSpec(t, afero.NewMemMapFs(), configStr)
-		caches, err := filecache.NewCaches(p)
+		fs := afero.NewMemMapFs()
+		p := newPathsSpec(t, fs, configStr)
+		fileCachConfig := p.Cfg.GetConfigSection("caches").(filecache.Configs)
+		caches, err := filecache.NewCaches(fileCachConfig, fs)
 		c.Assert(err, qt.IsNil)
+		caches.SetResourceFs(fs)
 		cache := caches[name]
 		for i := range 10 {
 			id := fmt.Sprintf("i%d", i)
@@ -84,8 +84,9 @@ dir = ":resourceDir/_gen"
 			}
 		}
 
-		caches, err = filecache.NewCaches(p)
+		caches, err = filecache.NewCaches(fileCachConfig, fs)
 		c.Assert(err, qt.IsNil)
+		caches.SetResourceFs(fs)
 		cache = caches[name]
 		// Touch one and then prune.
 		cache.GetOrCreateBytes("i5", func() ([]byte, error) {

cache/filecache/filecache_test.go

@@ -22,6 +22,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/gohugoio/hugo/htesting"
+
 	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/common/hugio"
 	"github.com/gohugoio/hugo/config"
@@ -64,7 +66,7 @@ assetDir = "assets"
 archeTypedir = "archetypes"
 
 [caches]
-[caches.getJSON]
+[caches.misc]
 maxAge = "10h"
 dir = ":cacheDir/c"
 
@@ -78,11 +80,13 @@ dir = ":cacheDir/c"
 		configStr = strings.Replace(configStr, "\\", winPathSep, -1)
 
 		p := newPathsSpec(t, osfs, configStr)
+		fileCachConfig := p.Cfg.GetConfigSection("caches").(filecache.Configs)
 
-		caches, err := filecache.NewCaches(p)
+		caches, err := filecache.NewCaches(fileCachConfig, p.Fs.Source)
 		c.Assert(err, qt.IsNil)
+		caches.SetResourceFs(p.SourceFs)
 
-		cache := caches.Get("GetJSON")
+		cache := caches.Get("Misc")
 		c.Assert(cache, qt.Not(qt.IsNil))
 
 		cache = caches.Get("Images")
@@ -104,7 +108,7 @@ dir = ":cacheDir/c"
 			return []byte("bcd"), nil
 		}
 
-		for _, ca := range []*filecache.Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
+		for _, ca := range []*filecache.Cache{caches.ImageCache(), caches.AssetsCache()} {
 			for range 2 {
 				info, r, err := ca.GetOrCreate("a", rf("abc"))
 				c.Assert(err, qt.IsNil)
@@ -132,8 +136,6 @@ dir = ":cacheDir/c"
 			}
 		}
 
-		c.Assert(caches.Get("getJSON"), qt.Not(qt.IsNil))
-
 		info, w, err := caches.ImageCache().WriteCloser("mykey")
 		c.Assert(err, qt.IsNil)
 		c.Assert(info.Name, qt.Equals, "mykey")
@@ -149,7 +151,7 @@ dir = ":cacheDir/c"
 		r.Close()
 		c.Assert(string(b), qt.Equals, "Hugo is great!")
 
-		info, b, err = caches.ImageCache().GetBytes("mykey")
+		info, b, err = caches.ImageCache().GetItemBytes("mykey")
 		c.Assert(err, qt.IsNil)
 		c.Assert(info.Name, qt.Equals, "mykey")
 		c.Assert(string(b), qt.Equals, "Hugo is great!")
@@ -158,6 +160,7 @@ dir = ":cacheDir/c"
 }
 
 func TestFileCacheConcurrent(t *testing.T) {
+	htesting.SkipSlowTestUnlessCI(t)
 	t.Parallel()
 
 	c := qt.New(t)
@@ -172,18 +175,19 @@ assetDir = "assets"
 archeTypedir = "archetypes"
 
 [caches]
-[caches.getjson]
+[caches.misc]
 maxAge = "1s"
 dir = "/cache/c"
 
 `
 
 	p := newPathsSpec(t, afero.NewMemMapFs(), configStr)
-
-	caches, err := filecache.NewCaches(p)
+	fileCachConfig := p.Cfg.GetConfigSection("caches").(filecache.Configs)
+	caches, err := filecache.NewCaches(fileCachConfig, p.Fs.Source)
 	c.Assert(err, qt.IsNil)
+	caches.SetResourceFs(p.Fs.Source)
 
-	const cacheName = "getjson"
+	const cacheName = "misc"
 
 	filenameData := func(i int) (string, string) {
 		data := fmt.Sprintf("data: %d", i)
@@ -248,7 +252,12 @@ func TestFileCacheReadOrCreateErrorInRead(t *testing.T) {
 		}
 	}
 
-	cache := filecache.NewCache(afero.NewMemMapFs(), 100*time.Hour, "")
+	cfg := filecache.FileCacheConfig{
+		MaxAge: 100 * time.Hour,
+		Dir:    "cache/c",
+	}
+
+	cache := filecache.NewCache(afero.NewMemMapFs(), cfg)
 
 	const id = "a32"
 

check.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+set -e
+
+# Default to all packages if none specified
+PACKAGES="${1:-./...}"
+
+echo "==> Checking packages: $PACKAGES"
+
+# Timing arrays
+declare -a STEP_NAMES
+declare -a STEP_TIMES
+
+time_step() {
+    local name="$1"
+    shift
+    local start=$(date +%s.%N)
+    "$@"
+    local end=$(date +%s.%N)
+    local elapsed=$(echo "$end - $start" | bc)
+    STEP_NAMES+=("$name")
+    STEP_TIMES+=("$elapsed")
+}
+
+# Check gofmt
+run_gofmt() {
+    echo "==> Running gofmt..."
+    # Convert package pattern to path (e.g., ./hugolib/... -> ./hugolib)
+    local path="${PACKAGES%/...}"
+    GOFMT_OUTPUT=$(gofmt -l "$path" 2>&1) || true
+    if [ -n "$GOFMT_OUTPUT" ]; then
+        echo "gofmt found issues in:"
+        echo "$GOFMT_OUTPUT"
+        exit 1
+    fi
+    echo "    OK"
+}
+
+# Run staticcheck
+run_staticcheck() {
+    # Check if staticcheck is installed, install if not
+    if ! command -v staticcheck &> /dev/null; then
+        echo "==> Installing staticcheck..."
+        go install honnef.co/go/tools/cmd/staticcheck@latest
+    fi
+    echo "==> Running staticcheck..."
+    staticcheck $PACKAGES
+    echo "    OK"
+}
+
+# Run tests
+run_tests() {
+    echo "==> Running tests..."
+    local output
+    if ! output=$(go test $PACKAGES 2>&1); then
+        echo "$output"
+        exit 1
+    fi
+    echo "    OK"
+}
+
+# Run all steps with timing
+TOTAL_START=$(date +%s.%N)
+
+time_step "gofmt" run_gofmt
+time_step "staticcheck" run_staticcheck
+time_step "tests" run_tests
+
+TOTAL_END=$(date +%s.%N)
+TOTAL_ELAPSED=$(echo "$TOTAL_END - $TOTAL_START" | bc)
+
+# Print timing summary
+echo ""
+echo "==> All checks passed!"
+echo ""
+echo "Timing summary:"
+echo "---------------"
+for i in "${!STEP_NAMES[@]}"; do
+    printf "  %-15s %6.2fs\n" "${STEP_NAMES[$i]}" "${STEP_TIMES[$i]}"
+done
+echo "---------------"
+printf "  %-15s %6.2fs\n" "Total" "$TOTAL_ELAPSED"

commands/commandeer.go

@@ -131,6 +131,7 @@ type rootCommand struct {
 	gc              bool
 	poll            string
 	forceSyncStatic bool
+	panicOnWarning  bool
 
 	// Profile flags (for debugging of performance problems)
 	cpuprofile   string
@@ -331,6 +332,9 @@ func (r *rootCommand) ConfigFromProvider(key configKey, cfg config.Provider) (*c
 }
 
 func (r *rootCommand) HugFromConfig(conf *commonConfig) (*hugolib.HugoSites, error) {
+	if conf == nil {
+		return nil, fmt.Errorf("conf must be set")
+	}
 	k := configKey{counter: r.configVersionID.Load()}
 	h, _, err := r.hugoSites.GetOrCreate(k, func(key configKey) (*hugolib.HugoSites, error) {
 		depsCfg := r.newDepsConfig(conf)
@@ -485,12 +489,18 @@ func (r *rootCommand) createLogger(running bool) (loggers.Logger, error) {
 		}
 	}
 
+	var logHookLast func(e *logg.Entry) error
+	if r.panicOnWarning {
+		logHookLast = loggers.PanicOnWarningHook
+	}
+
 	optsLogger := loggers.Options{
 		DistinctLevel: logg.LevelWarn,
 		Level:         level,
 		StdOut:        r.StdOut,
 		StdErr:        r.StdErr,
 		StoreErrors:   running,
+		HandlerPost:   logHookLast,
 	}
 
 	return loggers.New(optsLogger), nil
@@ -517,8 +527,8 @@ func (r *rootCommand) initRootCommand(subCommandName string, cd *simplecobra.Com
 		commandName = subCommandName
 	}
 	cmd.Use = fmt.Sprintf("%s [flags]", commandName)
-	cmd.Short = "Build your site"
-	cmd.Long = `COMMAND_NAME is the main command, used to build your Hugo site.
+	cmd.Short = "Build your project"
+	cmd.Long = `COMMAND_NAME is the main command, used to build your Hugo project.
 
 Hugo is a Fast and Flexible Static Site Generator
 built with love by spf13 and friends in Go.
@@ -588,7 +598,7 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().BoolVar(&r.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
 	cmd.Flags().StringVar(&r.poll, "poll", "", "set this to a poll interval, e.g --poll 700ms, to use a poll based approach to watch for file system changes")
 	_ = cmd.RegisterFlagCompletionFunc("poll", cobra.NoFileCompletions)
-	cmd.Flags().Bool("panicOnWarning", false, "panic on first WARNING log")
+	cmd.Flags().BoolVar(&r.panicOnWarning, "panicOnWarning", false, "panic on first WARNING log")
 	cmd.Flags().Bool("templateMetrics", false, "display metrics about template executions")
 	cmd.Flags().Bool("templateMetricsHints", false, "calculate some improvement hints when combined with --templateMetrics")
 	cmd.Flags().BoolVar(&r.forceSyncStatic, "forceSyncStatic", false, "copy all files when static is changed.")
@@ -619,13 +629,14 @@ func (r *rootCommand) timeTrack(start time.Time, name string) {
 }
 
 type simpleCommand struct {
-	use   string
-	name  string
-	short string
-	long  string
-	run   func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *rootCommand, args []string) error
-	withc func(cmd *cobra.Command, r *rootCommand)
-	initc func(cd *simplecobra.Commandeer) error
+	use     string
+	name    string
+	short   string
+	long    string
+	aliases []string
+	run     func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *rootCommand, args []string) error
+	withc   func(cmd *cobra.Command, r *rootCommand)
+	initc   func(cd *simplecobra.Commandeer) error
 
 	commands []simplecobra.Commander
 
@@ -652,6 +663,7 @@ func (c *simpleCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
 	cmd.Short = c.short
 	cmd.Long = c.long
+	cmd.Aliases = c.aliases
 	if c.use != "" {
 		cmd.Use = c.use
 	}
@@ -669,7 +681,7 @@ func (c *simpleCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 }
 
 func mapLegacyArgs(args []string) []string {
-	if len(args) > 1 && args[0] == "new" && !hstrings.EqualAny(args[1], "site", "theme", "content") {
+	if len(args) > 1 && args[0] == "new" && !hstrings.EqualAny(args[1], "project", "site", "theme", "content") {
 		// Insert "content" as the second argument
 		args = append(args[:1], append([]string{"content"}, args[1:]...)...)
 	}

commands/config.go

@@ -23,7 +23,7 @@ import (
 	"time"
 
 	"github.com/bep/simplecobra"
-	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
 	"github.com/gohugoio/hugo/modules"
@@ -95,7 +95,7 @@ func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 		if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
 			return err
 		}
-		maps.ConvertFloat64WithNoDecimalsToInt(m)
+		hmaps.ConvertFloat64WithNoDecimalsToInt(m)
 		switch format {
 		case "yaml":
 			return parser.InterfaceToConfig(m, metadecoders.YAML, os.Stdout)
@@ -112,8 +112,8 @@ func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 func (c *configCommand) Init(cd *simplecobra.Commandeer) error {
 	c.r = cd.Root.Command.(*rootCommand)
 	cmd := cd.CobraCommand
-	cmd.Short = "Display site configuration"
-	cmd.Long = `Display site configuration, both default and custom settings.`
+	cmd.Short = "Display project configuration"
+	cmd.Long = `Display project configuration, both default and custom settings.`
 	cmd.Flags().StringVar(&c.format, "format", "toml", "preferred file format (toml, yaml or json)")
 	_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
 	cmd.Flags().StringVar(&c.lang, "lang", "", "the language to display config for. Defaults to the first language defined.")

commands/deploy.go

@@ -27,8 +27,8 @@ import (
 func newDeployCommand() simplecobra.Commander {
 	return &simpleCommand{
 		name:  "deploy",
-		short: "Deploy your site to a cloud provider",
-		long: `Deploy your site to a cloud provider
+		short: "Deploy your project to a cloud provider",
+		long: `Deploy your project to a cloud provider
 
 See https://gohugo.io/hosting-and-deployment/hugo-deploy/ for detailed
 documentation.

commands/gen.go

@@ -60,7 +60,7 @@ func newGenCommand() *genCommand {
 			short: "Generate CSS stylesheet for the Chroma code highlighter",
 			long: `Generate CSS stylesheet for the Chroma code highlighter for a given style. This stylesheet is needed if markup.highlight.noClasses is disabled in config.
 
-See https://xyproto.github.io/splash/docs/all.html for a preview of the available styles`,
+See https://gohugo.io/quick-reference/syntax-highlighting-styles/ for a preview of the available styles.`,
 
 			run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 				style = strings.ToLower(style)
@@ -98,7 +98,7 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
 				cmd.ValidArgsFunction = cobra.NoFileCompletions
-				cmd.PersistentFlags().StringVar(&style, "style", "friendly", "highlighter style (see https://xyproto.github.io/splash/docs/)")
+				cmd.PersistentFlags().StringVar(&style, "style", "friendly", "highlighter style")
 				_ = cmd.RegisterFlagCompletionFunc("style", cobra.NoFileCompletions)
 				cmd.PersistentFlags().StringVar(&highlightStyle, "highlightStyle", "", `foreground and background colors for highlighted lines, e.g. --highlightStyle "#fff000 bg:#000fff"`)
 				_ = cmd.RegisterFlagCompletionFunc("highlightStyle", cobra.NoFileCompletions)

commands/helpers.go

@@ -81,7 +81,7 @@ func flagsToCfgWithAdditionalConfigBase(cd *simplecobra.Commandeer, cfg config.P
 		"editor":      "newContentEditor",
 	}
 
-	// Flags that we for some reason don't want to expose in the site config.
+	// Flags that we for some reason don't want to expose in the project config.
 	internalKeySet := map[string]bool{
 		"quiet":          true,
 		"verbose":        true,

commands/hugobuilder.go

@@ -31,11 +31,11 @@ import (
 	"github.com/bep/simplecobra"
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/hstrings"
 	"github.com/gohugoio/hugo/common/htime"
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/terminal"
 	"github.com/gohugoio/hugo/common/types"
@@ -56,8 +56,9 @@ import (
 type hugoBuilder struct {
 	r *rootCommand
 
-	confmu sync.Mutex
-	conf   *commonConfig
+	confmu  sync.Mutex
+	confOld *commonConfig
+	conf    *commonConfig
 
 	// May be nil.
 	s *serverCommand
@@ -94,6 +95,27 @@ func (c *hugoBuilder) withConf(fn func(conf *commonConfig)) {
 	fn(c.conf)
 }
 
+func (c *hugoBuilder) withConfOrOldConf(fn func(conf *commonConfig)) {
+	c.confmu.Lock()
+	defer c.confmu.Unlock()
+	if c.conf != nil {
+		fn(c.conf)
+	} else if c.confOld != nil {
+		fn(c.confOld)
+	}
+}
+
+func (c *hugoBuilder) withConfOrOldConfE(fn func(conf *commonConfig) error) error {
+	c.confmu.Lock()
+	defer c.confmu.Unlock()
+	if c.conf != nil {
+		return fn(c.conf)
+	} else if c.confOld != nil {
+		return fn(c.confOld)
+	}
+	return errConfigNotSet
+}
+
 type hugoBuilderErrState struct {
 	mu       sync.Mutex
 	paused   bool
@@ -1077,7 +1099,7 @@ func (c *hugoBuilder) loadConfig(cd *simplecobra.Commandeer, running bool) error
 	}
 	cfg.Set("environment", c.r.environment)
 
-	cfg.Set("internal", maps.Params{
+	cfg.Set("internal", hmaps.Params{
 		"running":        running,
 		"watch":          watch,
 		"verbose":        c.r.isVerbose(),
@@ -1091,10 +1113,11 @@ func (c *hugoBuilder) loadConfig(cd *simplecobra.Commandeer, running bool) error
 
 	if len(conf.configs.LoadingInfo.ConfigFiles) == 0 {
 		//lint:ignore ST1005 end user message.
-		return errors.New("Unable to locate config file or config directory. Perhaps you need to create a new site.\nRun `hugo help new` for details.")
+		return errors.New("Unable to locate config file or config directory. Perhaps you need to create a new project.\nRun `hugo help new` for details.")
 	}
 
 	c.conf = conf
+	c.confOld = conf
 	if c.onConfigLoaded != nil {
 		if err := c.onConfigLoaded(false); err != nil {
 			return err
@@ -1158,8 +1181,9 @@ func (c *hugoBuilder) reloadConfig() error {
 	c.r.resetLogs()
 	c.r.configVersionID.Add(1)
 
-	if err := c.withConfE(func(conf *commonConfig) error {
+	if err := c.withConfOrOldConfE(func(conf *commonConfig) error {
 		oldConf := conf
+		c.conf = nil
 		newConf, err := c.r.ConfigFromConfig(configKey{counter: c.r.configVersionID.Load()}, conf)
 		if err != nil {
 			return err

commands/import.go

@@ -29,9 +29,9 @@ import (
 	"unicode"
 
 	"github.com/bep/simplecobra"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/htime"
 	"github.com/gohugoio/hugo/common/hugio"
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/parser"
@@ -49,7 +49,7 @@ func newImportCommand() *importCommand {
 				name:  "jekyll",
 				short: "hugo import from Jekyll",
 				long: `hugo import from Jekyll.
-		
+
 Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.",
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 2 {
@@ -90,8 +90,8 @@ func (c *importCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 
 func (c *importCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
-	cmd.Short = "Import a site from another system"
-	cmd.Long = `Import a site from another system.
+	cmd.Short = "Import a project from another system"
+	cmd.Long = `Import a project from another system.
 
 Import requires a subcommand, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`."
 
@@ -105,7 +105,7 @@ func (c *importCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 }
 
 func (i *importCommand) createConfigFromJekyll(fs afero.Fs, inpath string, kind metadecoders.Format, jekyllConfig map[string]any) (err error) {
-	title := "My New Hugo Site"
+	title := "My New Hugo Project"
 	baseURL := "http://example.org/"
 
 	for key, value := range jekyllConfig {
@@ -159,7 +159,7 @@ func (c *importCommand) getJekyllDirInfo(fs afero.Fs, jekyllRoot string) (map[st
 	return postDirs, hasAnyPost
 }
 
-func (c *importCommand) createSiteFromJekyll(jekyllRoot, targetDir string, jekyllPostDirs map[string]bool) error {
+func (c *importCommand) createProjectFromJekyll(jekyllRoot, targetDir string, jekyllPostDirs map[string]bool) error {
 	fs := &afero.OsFs{}
 	if exists, _ := helpers.Exists(targetDir, fs); exists {
 		if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
@@ -190,7 +190,7 @@ func (c *importCommand) createSiteFromJekyll(jekyllRoot, targetDir string, jekyl
 }
 
 func (c *importCommand) convertJekyllContent(m any, content string) (string, error) {
-	metadata, _ := maps.ToStringMapE(m)
+	metadata, _ := hmaps.ToStringMapE(m)
 
 	lines := strings.Split(content, "\n")
 	var resultLines []string
@@ -246,7 +246,7 @@ func (c *importCommand) convertJekyllContent(m any, content string) (string, err
 }
 
 func (c *importCommand) convertJekyllMetaData(m any, postName string, postDate time.Time, draft bool) (any, error) {
-	metadata, err := maps.ToStringMapE(m)
+	metadata, err := hmaps.ToStringMapE(m)
 	if err != nil {
 		return nil, err
 	}
@@ -419,7 +419,7 @@ func (c *importCommand) importFromJekyll(args []string) error {
 		return errors.New("abort: jekyll root contains neither posts nor drafts")
 	}
 
-	err = c.createSiteFromJekyll(jekyllRoot, targetDir, jekyllPostDirs)
+	err = c.createProjectFromJekyll(jekyllRoot, targetDir, jekyllPostDirs)
 	if err != nil {
 		return newUserError(err)
 	}
@@ -463,7 +463,7 @@ func (c *importCommand) importFromJekyll(args []string) error {
 	}
 
 	c.r.Println("Congratulations!", fileCount, "post(s) imported!")
-	c.r.Println("Now, start Hugo by yourself:\n")
+	c.r.Println("Now, start Hugo by yourself:")
 	c.r.Println("cd " + args[1])
 	c.r.Println("git init")
 	c.r.Println("git submodule add https://github.com/theNewDynamic/gohugo-theme-ananke themes/ananke")

commands/mod.go

@@ -26,7 +26,7 @@ import (
 )
 
 const commonUsageMod = `
-Note that Hugo will always start out by resolving the components defined in the site
+Note that Hugo will always start out by resolving the components defined in the project
 configuration, provided by a _vendor directory (if no --ignoreVendorPaths flag provided),
 Go Modules, or a folder inside the themes directory, in that order.
 
@@ -166,7 +166,7 @@ Note that for vendored modules, that is the version listed and not the one from
 					if all {
 						modCache := h.ResourceSpec.FileCaches.ModulesCache()
 						count, err := modCache.Prune(true)
-						r.Printf("Deleted %d files from module cache.", count)
+						r.Printf("Deleted %d directories from module cache.", count)
 						return err
 					}
 

commands/new.go

@@ -46,9 +46,9 @@ It will guess which kind of file to create based on the path provided.
 
 You can also specify the kind with ` + "`-k KIND`" + `.
 
-If archetypes are provided in your theme or site, they will be used.
+If archetypes are provided in your theme or project, they will be used.
 
-Ensure you run this within the root directory of your site.`,
+Ensure you run this within the root directory of your project.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 1 {
 						return newUserError("path needs to be provided")
@@ -76,10 +76,11 @@ Ensure you run this within the root directory of your site.`,
 				},
 			},
 			&simpleCommand{
-				name:  "site",
-				use:   "site [path]",
-				short: "Create a new site",
-				long:  `Create a new site at the specified path.`,
+				name:    "project",
+				use:     "project [path]",
+				short:   "Create a new project",
+				long:    `Create a new project at the specified path.`,
+				aliases: []string{"site"},
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 1 {
 						return newUserError("path needs to be provided")
@@ -99,13 +100,13 @@ Ensure you run this within the root directory of your site.`,
 					}
 					sourceFs := conf.fs.Source
 
-					err = skeletons.CreateSite(createpath, sourceFs, force, format)
+					err = skeletons.CreateProject(createpath, sourceFs, force, format)
 					if err != nil {
 						return err
 					}
 
-					r.Printf("Congratulations! Your new Hugo site was created in %s.\n\n", createpath)
-					r.Println(c.newSiteNextStepsText(createpath, format))
+					r.Printf("Congratulations! Your new Hugo project was created in %s.\n\n", createpath)
+					r.Println(c.newProjectNextStepsText(createpath, format))
 
 					return nil
 				},
@@ -192,9 +193,9 @@ It will guess which kind of file to create based on the path provided.
 
 You can also specify the kind with ` + "`-k KIND`" + `.
 
-If archetypes are provided in your theme or site, they will be used.
+If archetypes are provided in your theme or project, they will be used.
 
-Ensure you run this within the root directory of your site.`
+Ensure you run this within the root directory of your project.`
 
 	cmd.RunE = nil
 	return nil
@@ -205,7 +206,7 @@ func (c *newCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 	return nil
 }
 
-func (c *newCommand) newSiteNextStepsText(path string, format string) string {
+func (c *newCommand) newProjectNextStepsText(path string, format string) string {
 	format = strings.ToLower(format)
 	var nextStepsText bytes.Buffer
 

commands/server.go

@@ -246,7 +246,7 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string
 	logger := f.c.r.logger
 
 	if i == 0 {
-		r.Printf("Environment: %q\n", f.c.hugoTry().Deps.Site.Hugo().Environment)
+		r.Printf("Environment: %q\n", f.c.hugoTry().Deps.Site.Hugo().Environment())
 		mainTarget := "disk"
 		if f.c.r.renderToMemory {
 			mainTarget = "memory"
@@ -282,7 +282,7 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string
 					}
 
 					port = 1313
-					f.c.withConf(func(conf *commonConfig) {
+					f.c.withConfOrOldConf(func(conf *commonConfig) {
 						if lrport := conf.configs.GetFirstLanguageConfig().BaseURLLiveReload().Port(); lrport != 0 {
 							port = lrport
 						}
@@ -523,7 +523,7 @@ func (c *serverCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 func (c *serverCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd := cd.CobraCommand
 	cmd.Short = "Start the embedded web server"
-	cmd.Long = `Hugo provides its own webserver which builds and serves the site.
+	cmd.Long = `Hugo provides its own webserver which builds and serves the project.
 While hugo server is high performance, it is a webserver with limited options.
 
 The ` + "`" + `hugo server` + "`" + ` command will by default write and serve files from disk, but
@@ -531,8 +531,8 @@ you can render to memory by using the ` + "`" + `--renderToMemory` + "`" + ` fla
 faster in some cases, but it will consume more memory.
 
 By default hugo will also watch your files for any changes you make and
-automatically rebuild the site. It will then live reload any open browser pages
-and push the latest content to them. As most Hugo sites are built in a fraction
+automatically rebuild the project. It will then live reload any open browser pages
+and push the latest content to them. As most Hugo projects are built in a fraction
 of a second, you will be able to save and see your changes nearly instantly.`
 	cmd.Aliases = []string{"serve"}
 
@@ -553,7 +553,7 @@ of a second, you will be able to save and see your changes nearly instantly.`
 	cmd.Flags().BoolVarP(&c.serverAppend, "appendPort", "", true, "append port to baseURL")
 	cmd.Flags().BoolVar(&c.disableLiveReload, "disableLiveReload", false, "watch without enabling live browser reload on rebuild")
 	cmd.Flags().BoolVarP(&c.navigateToChanged, "navigateToChanged", "N", false, "navigate to changed content file on live browser reload")
-	cmd.Flags().BoolVarP(&c.openBrowser, "openBrowser", "O", false, "open the site in a browser after server startup")
+	cmd.Flags().BoolVarP(&c.openBrowser, "openBrowser", "O", false, "open the project in a browser after server startup")
 	cmd.Flags().BoolVar(&c.renderStaticToDisk, "renderStaticToDisk", false, "serve static files from disk and dynamic files from memory")
 	cmd.Flags().BoolVar(&c.disableFastRender, "disableFastRender", false, "enables full re-renders on changes")
 	cmd.Flags().BoolVar(&c.disableBrowserError, "disableBrowserError", false, "do not show build errors in the browser")
@@ -1160,14 +1160,14 @@ func (s *staticSyncer) syncsStaticEvents(staticEvents []fsnotify.Event) error {
 	return err
 }
 
+// chmodFilter is a ChmodFilter for static syncing.
+// Returns true to skip syncing permissions for directories and files without
+// owner-write permission. The primary use case is files from the module cache (0444).
 func chmodFilter(dst, src os.FileInfo) bool {
-	// Hugo publishes data from multiple sources, potentially
-	// with overlapping directory structures. We cannot sync permissions
-	// for directories as that would mean that we might end up with write-protected
-	// directories inside /public.
-	// One example of this would be syncing from the Go Module cache,
-	// which have 0555 directories.
-	return src.IsDir()
+	if src.IsDir() {
+		return true
+	}
+	return src.Mode().Perm()&0o200 == 0
 }
 
 func cleanErrorLog(content string) string {

common/collections/stack.go

@@ -21,24 +21,24 @@ import (
 	"github.com/gohugoio/hugo/common/hiter"
 )
 
-// Stack is a simple LIFO stack that is safe for concurrent use.
-type Stack[T any] struct {
+// StackThreadSafe is a simple LIFO stack that is safe for concurrent use.
+type StackThreadSafe[T any] struct {
 	items []T
 	zero  T
 	mu    sync.RWMutex
 }
 
-func NewStack[T any]() *Stack[T] {
-	return &Stack[T]{}
+func NewStackThreadSafe[T any]() *StackThreadSafe[T] {
+	return &StackThreadSafe[T]{}
 }
 
-func (s *Stack[T]) Push(item T) {
+func (s *StackThreadSafe[T]) Push(item T) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.items = append(s.items, item)
 }
 
-func (s *Stack[T]) Pop() (T, bool) {
+func (s *StackThreadSafe[T]) Pop() (T, bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	if len(s.items) == 0 {
@@ -49,7 +49,7 @@ func (s *Stack[T]) Pop() (T, bool) {
 	return item, true
 }
 
-func (s *Stack[T]) Peek() (T, bool) {
+func (s *StackThreadSafe[T]) Peek() (T, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	if len(s.items) == 0 {
@@ -58,18 +58,18 @@ func (s *Stack[T]) Peek() (T, bool) {
 	return s.items[len(s.items)-1], true
 }
 
-func (s *Stack[T]) Len() int {
+func (s *StackThreadSafe[T]) Len() int {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	return len(s.items)
 }
 
 // All returns all items in the stack, from bottom to top.
-func (s *Stack[T]) All() iter.Seq2[int, T] {
+func (s *StackThreadSafe[T]) All() iter.Seq2[int, T] {
 	return hiter.Lock2(slices.All(s.items), s.mu.RLock, s.mu.RUnlock)
 }
 
-func (s *Stack[T]) Drain() []T {
+func (s *StackThreadSafe[T]) Drain() []T {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	items := s.items
@@ -77,7 +77,7 @@ func (s *Stack[T]) Drain() []T {
 	return items
 }
 
-func (s *Stack[T]) DrainMatching(predicate func(T) bool) []T {
+func (s *StackThreadSafe[T]) DrainMatching(predicate func(T) bool) []T {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	var items []T
@@ -89,3 +89,47 @@ func (s *Stack[T]) DrainMatching(predicate func(T) bool) []T {
 	}
 	return items
 }
+
+// Stack is a simple LIFO stack that is not safe for concurrent use.
+type Stack[T any] struct {
+	items []T
+	zero  T
+}
+
+func NewStack[T any]() *Stack[T] {
+	return &Stack[T]{}
+}
+
+func (s *Stack[T]) Push(item T) {
+	s.items = append(s.items, item)
+}
+
+func (s *Stack[T]) Pop() (T, bool) {
+	if len(s.items) == 0 {
+		return s.zero, false
+	}
+	item := s.items[len(s.items)-1]
+	s.items = s.items[:len(s.items)-1]
+	return item, true
+}
+
+func (s *Stack[T]) Peek() (T, bool) {
+	if len(s.items) == 0 {
+		return s.zero, false
+	}
+	return s.items[len(s.items)-1], true
+}
+
+func (s *Stack[T]) Len() int {
+	return len(s.items)
+}
+
+func (s *Stack[T]) All() iter.Seq2[int, T] {
+	return slices.All(s.items)
+}
+
+func (s *Stack[T]) Drain() []T {
+	items := s.items
+	s.items = nil
+	return items
+}

common/collections/stack_test.go

@@ -10,7 +10,7 @@ func TestNewStack(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	s := NewStack[int]()
+	s := NewStackThreadSafe[int]()
 
 	c.Assert(s, qt.IsNotNil)
 }
@@ -19,7 +19,7 @@ func TestStackBasic(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	s := NewStack[int]()
+	s := NewStackThreadSafe[int]()
 
 	c.Assert(s.Len(), qt.Equals, 0)
 
@@ -50,7 +50,7 @@ func TestStackDrain(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	s := NewStack[string]()
+	s := NewStackThreadSafe[string]()
 	s.Push("a")
 	s.Push("b")
 
@@ -64,7 +64,7 @@ func TestStackDrainMatching(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	s := NewStack[int]()
+	s := NewStackThreadSafe[int]()
 	s.Push(1)
 	s.Push(2)
 	s.Push(3)

common/hashing/hashing.go

@@ -87,11 +87,13 @@ func XXHashFromString(s string) (uint64, error) {
 	return h.Sum64(), nil
 }
 
-// XxHashFromStringHexEncoded calculates the xxHash for the given string
+// XxHashFromStringHexEncoded calculates the xxHash for the given strings
 // and returns the hash as a hex encoded string.
-func XxHashFromStringHexEncoded(f string) string {
+func XxHashFromStringHexEncoded(s ...string) string {
 	h := xxhash.New()
-	h.WriteString(f)
+	for _, f := range s {
+		h.WriteString(f)
+	}
 	hash := h.Sum(nil)
 	return hex.EncodeToString(hash)
 }

common/hexec/exec.go

@@ -27,8 +27,8 @@ import (
 	"sync"
 
 	"github.com/bep/logg"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/security"
 )
@@ -102,7 +102,7 @@ func New(cfg security.Config, workingDir string, log loggers.Logger) *Exec {
 		workingDir:        workingDir,
 		infol:             log.InfoCommand("exec"),
 		baseEnviron:       baseEnviron,
-		newNPXRunnerCache: maps.NewCache[string, func(arg ...any) (Runner, error)](),
+		newNPXRunnerCache: hmaps.NewCache[string, func(arg ...any) (Runner, error)](),
 	}
 }
 
@@ -121,7 +121,7 @@ type Exec struct {
 	// os.Environ filtered by the Exec.OsEnviron whitelist filter.
 	baseEnviron []string
 
-	newNPXRunnerCache *maps.Cache[string, func(arg ...any) (Runner, error)]
+	newNPXRunnerCache *hmaps.Cache[string, func(arg ...any) (Runner, error)]
 	npxInit           sync.Once
 	npxAvailable      bool
 }

common/hmaps/cache.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"sync"

common/hmaps/cache_test.go

@@ -1,4 +1,4 @@
-// Copyright 2025 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"testing"

common/hmaps/map.go

@@ -1,4 +1,4 @@
-// Copyright 2025 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"iter"
@@ -73,6 +73,18 @@ func (m *Map[K, T]) Set(key K, value T) {
 	m.mu.Unlock()
 }
 
+// Delete deletes the given key from the map.
+// It returns true if the key was found and deleted, false otherwise.
+func (m *Map[K, T]) Delete(key K) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if _, found := m.m[key]; found {
+		delete(m.m, key)
+		return true
+	}
+	return false
+}
+
 // WithWriteLock executes the given function with a write lock on the map.
 func (m *Map[K, T]) WithWriteLock(f func(m map[K]T) error) error {
 	m.mu.Lock()

common/hmaps/map_test.go

@@ -1,4 +1,4 @@
-// Copyright 2025 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"testing"

common/hmaps/maps.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"fmt"

common/hmaps/maps_test.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"fmt"

common/hmaps/ordered.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"slices"

common/hmaps/ordered_test.go

@@ -1,4 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"testing"

common/hmaps/orderedintset.go

@@ -1,4 +1,4 @@
-// Copyright 2025 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"fmt"

common/hmaps/orderedintset_test.go

@@ -1,4 +1,4 @@
-// Copyright 2025 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"testing"

common/hmaps/params.go

@@ -1,4 +1,4 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"errors"

common/hmaps/params_test.go

@@ -1,4 +1,4 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
+// Copyright 2026 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hmaps
 
 import (
 	"testing"

common/hreflect/helpers.go

@@ -20,8 +20,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/htime"
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/types"
 )
 
@@ -355,7 +355,7 @@ func IsNil(v reflect.Value) bool {
 
 var contextInterface = reflect.TypeOf((*context.Context)(nil)).Elem()
 
-var isContextCache = maps.NewCache[reflect.Type, bool]()
+var isContextCache = hmaps.NewCache[reflect.Type, bool]()
 
 type k string
 

common/hugio/readers.go

@@ -19,16 +19,10 @@ import (
 	"strings"
 )
 
-// ReadSeeker wraps io.Reader and io.Seeker.
-type ReadSeeker interface {
-	io.Reader
-	io.Seeker
-}
-
 // ReadSeekCloser is implemented by afero.File. We use this as the common type for
 // content in Resource objects, even for strings.
 type ReadSeekCloser interface {
-	ReadSeeker
+	io.ReadSeeker
 	io.Closer
 }
 
@@ -70,7 +64,7 @@ type ReadSeekCloserProvider interface {
 
 // readSeekerNopCloser implements ReadSeekCloser by doing nothing in Close.
 type readSeekerNopCloser struct {
-	ReadSeeker
+	io.ReadSeeker
 }
 
 // Close does nothing.
@@ -79,7 +73,7 @@ func (r readSeekerNopCloser) Close() error {
 }
 
 // NewReadSeekerNoOpCloser creates a new ReadSeekerNoOpCloser with the given ReadSeeker.
-func NewReadSeekerNoOpCloser(r ReadSeeker) ReadSeekCloser {
+func NewReadSeekerNoOpCloser(r io.ReadSeeker) ReadSeekCloser {
 	return readSeekerNopCloser{r}
 }
 
@@ -111,6 +105,22 @@ func NewReadSeekerNoOpCloserFromBytes(content []byte) readSeekerNopCloser {
 	return readSeekerNopCloser{bytes.NewReader(content)}
 }
 
+// NewReadSeekerNoOpCloserFromReader creates a new ReadSeekerNoOpCloser from the given io.Reader.
+// If the given io.Reader is not an io.ReadSeeker, the entire content will be read into memory.
+func NewReadSeekerNoOpCloserFromReader(r io.Reader) (readSeekerNopCloser, error) {
+	var rs io.ReadSeeker
+	if s, ok := r.(io.ReadSeeker); ok {
+		rs = s
+	} else {
+		b, err := io.ReadAll(r)
+		if err != nil {
+			return readSeekerNopCloser{rs}, err
+		}
+		rs = bytes.NewReader(b)
+	}
+	return readSeekerNopCloser{rs}, nil
+}
+
 // NewOpenReadSeekCloser creates a new ReadSeekCloser from the given ReadSeeker.
 // The ReadSeeker will be seeked to the beginning before returned.
 func NewOpenReadSeekCloser(r ReadSeekCloser) OpenReadSeekCloser {

common/hugo/hugo.go

@@ -16,7 +16,6 @@ package hugo
 import (
 	"context"
 	"fmt"
-	"html/template"
 	"os"
 	"path/filepath"
 	"runtime/debug"
@@ -25,17 +24,16 @@ import (
 	"sync"
 	"time"
 
+	"github.com/bep/helpers/contexthelpers"
 	"github.com/bep/logg"
 
 	"github.com/bep/godartsass/v2"
 
 	"github.com/gohugoio/hugo/common/hexec"
-	"github.com/gohugoio/hugo/common/hstore"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/version"
 	"github.com/gohugoio/hugo/hugofs/files"
 
-	"github.com/bep/helpers/contexthelpers"
 	"github.com/spf13/afero"
 
 	iofs "io/fs"
@@ -56,89 +54,24 @@ var (
 	vendorInfo string
 )
 
-var _ hstore.StoreProvider = (*HugoInfo)(nil)
-
-// HugoInfo contains information about the current Hugo environment
-type HugoInfo struct {
-	CommitHash string
-	BuildDate  string
-
-	// The build environment.
-	// Defaults are "production" (hugo) and "development" (hugo server).
-	// This can also be set by the user.
-	// It can be any string, but it will be all lower case.
-	Environment string
-
-	// version of go that the Hugo binary was built with
-	GoVersion string
-
-	conf ConfigProvider
-	deps []*Dependency
-
-	store *hstore.Scratch
-
-	// Context gives access to some of the context scoped variables.
-	Context Context
+// BuildInfo holds build information extracted from runtime/debug.
+type BuildInfo struct {
+	Revision     string
+	RevisionTime string
+	GoVersion    string
 }
 
-// Version returns the current version as a comparable version string.
-func (i HugoInfo) Version() version.VersionString {
-	return CurrentVersion.Version()
-}
-
-// Generator a Hugo meta generator HTML tag.
-func (i HugoInfo) Generator() template.HTML {
-	return template.HTML(fmt.Sprintf(`<meta name="generator" content="Hugo %s">`, CurrentVersion.String()))
-}
-
-// IsDevelopment reports whether the current running environment is "development".
-func (i HugoInfo) IsDevelopment() bool {
-	return i.Environment == EnvironmentDevelopment
-}
-
-// IsProduction reports whether the current running environment is "production".
-func (i HugoInfo) IsProduction() bool {
-	return i.Environment == EnvironmentProduction
-}
-
-// IsServer reports whether the built-in server is running.
-func (i HugoInfo) IsServer() bool {
-	return i.conf.Running()
-}
-
-// IsExtended reports whether the Hugo binary is the extended version.
-func (i HugoInfo) IsExtended() bool {
-	return IsExtended
-}
-
-// WorkingDir returns the project working directory.
-func (i HugoInfo) WorkingDir() string {
-	return i.conf.WorkingDir()
-}
-
-// Deps gets a list of dependencies for this Hugo build.
-func (i HugoInfo) Deps() []*Dependency {
-	return i.deps
-}
-
-func (i HugoInfo) Store() *hstore.Scratch {
-	return i.store
-}
-
-// Deprecated: Use hugo.IsMultihost instead.
-func (i HugoInfo) IsMultiHost() bool {
-	Deprecate("hugo.IsMultiHost", "Use hugo.IsMultihost instead.", "v0.124.0")
-	return i.conf.IsMultihost()
-}
-
-// IsMultihost reports whether each configured language has a unique baseURL.
-func (i HugoInfo) IsMultihost() bool {
-	return i.conf.IsMultihost()
-}
-
-// IsMultilingual reports whether there are two or more configured languages.
-func (i HugoInfo) IsMultilingual() bool {
-	return i.conf.IsMultilingual()
+// GetBuildInfo returns the build info for the current binary.
+func GetBuildInfo() *BuildInfo {
+	bi := getBuildInfo()
+	if bi == nil {
+		return nil
+	}
+	return &BuildInfo{
+		Revision:     bi.Revision,
+		RevisionTime: bi.RevisionTime,
+		GoVersion:    bi.GoVersion,
+	}
 }
 
 type contextKey uint8
@@ -149,6 +82,7 @@ const (
 
 var markupScope = contexthelpers.NewContextDispatcher[string](contextKeyMarkupScope)
 
+// Context gives access to some of the context scoped variables.
 type Context struct{}
 
 func (c Context) MarkupScope(ctx context.Context) string {
@@ -165,44 +99,6 @@ func GetMarkupScope(ctx context.Context) string {
 	return markupScope.Get(ctx)
 }
 
-// ConfigProvider represents the config options that are relevant for HugoInfo.
-type ConfigProvider interface {
-	Environment() string
-	Running() bool
-	WorkingDir() string
-	IsMultihost() bool
-	IsMultilingual() bool
-}
-
-// NewInfo creates a new Hugo Info object.
-func NewInfo(conf ConfigProvider, deps []*Dependency) HugoInfo {
-	if conf.Environment() == "" {
-		panic("environment not set")
-	}
-	var (
-		commitHash string
-		buildDate  string
-		goVersion  string
-	)
-
-	bi := getBuildInfo()
-	if bi != nil {
-		commitHash = bi.Revision
-		buildDate = bi.RevisionTime
-		goVersion = bi.GoVersion
-	}
-
-	return HugoInfo{
-		CommitHash:  commitHash,
-		BuildDate:   buildDate,
-		Environment: conf.Environment(),
-		conf:        conf,
-		deps:        deps,
-		store:       hstore.NewScratch(),
-		GoVersion:   goVersion,
-	}
-}
-
 // GetExecEnviron creates and gets the common os/exec environment used in the
 // external programs we interact with via os/exec, e.g. postcss.
 func GetExecEnviron(workDir string, cfg config.AllProvider, fs afero.Fs) []string {

common/hugo/hugo_integration_test.go

@@ -75,3 +75,39 @@ multihost={{ hugo.IsMultihost }}
 		"multihost=false",
 	)
 }
+
+func TestHugoSites(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['page','rss','section','sitemap','taxonomy','term']
+defaultContentLanguage = 'fr'
+defaultContentLanguageInSubdir = true
+defaultContentVersionInSubdir = true
+defaultContentRoleInSubdir = true
+[languages]
+[languages.en]
+weight = 1
+[languages.fr]
+weight = 2
+[languages.de]
+weight = 3
+[roles]
+[roles.guest]
+weight = 1
+[roles.member]
+weight = 2
+[versions]
+[versions.'v1.0.0']
+weight = 1
+[versions.'v2.0.0']
+weight = 2
+-- layouts/home.html --
+{{ range hugo.Sites }}{{ .Language.Name }}-{{ .Role.Name }}-{{ .Version.Name }}|{{ end }}
+  `
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/guest/v1.0.0/en/index.html", "en-guest-v1.0.0|en-member-v1.0.0|en-guest-v2.0.0|en-member-v2.0.0|fr-guest-v1.0.0|fr-member-v1.0.0|fr-guest-v2.0.0|fr-member-v2.0.0|de-guest-v1.0.0|de-member-v1.0.0|de-guest-v2.0.0|de-member-v2.0.0|")
+}

common/hugo/hugo_test.go

@@ -15,43 +15,12 @@ package hugo
 
 import (
 	"context"
-	"fmt"
 	"testing"
 
 	"github.com/bep/logg"
 	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/common/version"
 )
 
-func TestHugoInfo(t *testing.T) {
-	c := qt.New(t)
-
-	conf := testConfig{environment: "production", workingDir: "/mywork", running: false}
-	hugoInfo := NewInfo(conf, nil)
-
-	c.Assert(hugoInfo.Version(), qt.Equals, CurrentVersion.Version())
-	c.Assert(fmt.Sprintf("%T", version.VersionString("")), qt.Equals, fmt.Sprintf("%T", hugoInfo.Version()))
-	c.Assert(hugoInfo.WorkingDir(), qt.Equals, "/mywork")
-
-	bi := getBuildInfo()
-	if bi != nil {
-		c.Assert(hugoInfo.CommitHash, qt.Equals, bi.Revision)
-		c.Assert(hugoInfo.BuildDate, qt.Equals, bi.RevisionTime)
-		c.Assert(hugoInfo.GoVersion, qt.Equals, bi.GoVersion)
-	}
-	c.Assert(hugoInfo.Environment, qt.Equals, "production")
-	c.Assert(string(hugoInfo.Generator()), qt.Contains, fmt.Sprintf("Hugo %s", hugoInfo.Version()))
-	c.Assert(hugoInfo.IsDevelopment(), qt.Equals, false)
-	c.Assert(hugoInfo.IsProduction(), qt.Equals, true)
-	c.Assert(hugoInfo.IsExtended(), qt.Equals, IsExtended)
-	c.Assert(hugoInfo.IsServer(), qt.Equals, false)
-
-	devHugoInfo := NewInfo(testConfig{environment: "development", running: true}, nil)
-	c.Assert(devHugoInfo.IsDevelopment(), qt.Equals, true)
-	c.Assert(devHugoInfo.IsProduction(), qt.Equals, false)
-	c.Assert(devHugoInfo.IsServer(), qt.Equals, true)
-}
-
 func TestDeprecationLogLevelFromVersion(t *testing.T) {
 	c := qt.New(t)
 
@@ -66,47 +35,27 @@ func TestDeprecationLogLevelFromVersion(t *testing.T) {
 	c.Assert(deprecationLogLevelFromVersion(ver.String()), qt.Equals, logg.LevelError)
 
 	// Added just to find the threshold for where we can remove deprecated items.
-	// Subtract 5 from the minor version of the first ERRORed version => 0.122.0.
-	c.Assert(deprecationLogLevelFromVersion("0.127.0"), qt.Equals, logg.LevelError)
+	// Subtract 5 from the minor version of the first ERRORed version => 0.136.0.
+	c.Assert(deprecationLogLevelFromVersion("0.141.0"), qt.Equals, logg.LevelError)
 }
 
 func TestMarkupScope(t *testing.T) {
 	c := qt.New(t)
 
-	conf := testConfig{environment: "production", workingDir: "/mywork", running: false}
-	info := NewInfo(conf, nil)
-
 	ctx := context.Background()
-
 	ctx = SetMarkupScope(ctx, "foo")
 
-	c.Assert(info.Context.MarkupScope(ctx), qt.Equals, "foo")
+	var hugoCtx Context
+	c.Assert(hugoCtx.MarkupScope(ctx), qt.Equals, "foo")
+	c.Assert(GetMarkupScope(ctx), qt.Equals, "foo")
 }
 
-type testConfig struct {
-	environment  string
-	running      bool
-	workingDir   string
-	multihost    bool
-	multilingual bool
-}
+func TestGetBuildInfo(t *testing.T) {
+	c := qt.New(t)
 
-func (c testConfig) Environment() string {
-	return c.environment
-}
-
-func (c testConfig) Running() bool {
-	return c.running
-}
-
-func (c testConfig) WorkingDir() string {
-	return c.workingDir
-}
-
-func (c testConfig) IsMultihost() bool {
-	return c.multihost
-}
-
-func (c testConfig) IsMultilingual() bool {
-	return c.multilingual
+	bi := GetBuildInfo()
+	// In test mode, build info may or may not be available.
+	if bi != nil {
+		c.Assert(bi.GoVersion, qt.Not(qt.Equals), "")
+	}
 }

common/hugo/version_current.go

@@ -19,7 +19,7 @@ import "github.com/gohugoio/hugo/common/version"
 // This should be the only one.
 var CurrentVersion = version.Version{
 	Major:      0,
-	Minor:      154,
+	Minor:      157,
 	PatchLevel: 0,
-	Suffix:     "-DEV",
+	Suffix:     "",
 }

common/loggers/logger.go

@@ -20,6 +20,7 @@ import (
 	"io"
 	"os"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/bep/logg"
@@ -123,8 +124,11 @@ func New(opts Options) Logger {
 	)
 
 	l := logger.WithLevel(opts.Level)
+	logMu := &sync.Mutex{}
 
 	reset := func() {
+		logMu.Lock()
+		defer logMu.Unlock()
 		logCounters.mu.Lock()
 		defer logCounters.mu.Unlock()
 		logCounters.counters = make(map[logg.Level]int)
@@ -135,6 +139,7 @@ func New(opts Options) Logger {
 	}
 
 	return &logAdapter{
+		mu:          logMu,
 		logCounters: logCounters,
 		errors:      errorsw,
 		reset:       reset,
@@ -173,6 +178,7 @@ func LevelLoggerToWriter(l logg.LevelLogger) io.Writer {
 
 type Logger interface {
 	Debug() logg.LevelLogger
+	DebugCommand(command string) logg.LevelLogger
 	Debugf(format string, v ...any)
 	Debugln(v ...any)
 	Error() logg.LevelLogger
@@ -203,6 +209,7 @@ type Logger interface {
 }
 
 type logAdapter struct {
+	mu          *sync.Mutex
 	logCounters *logLevelCounter
 	errors      *strings.Builder
 	reset       func()
@@ -221,6 +228,10 @@ func (l *logAdapter) Debug() logg.LevelLogger {
 	return l.debugl
 }
 
+func (l *logAdapter) DebugCommand(command string) logg.LevelLogger {
+	return l.debugl.WithField(FieldNameCmd, command)
+}
+
 func (l *logAdapter) Debugf(format string, v ...any) {
 	l.debugl.Logf(format, v...)
 }
@@ -323,6 +334,8 @@ func (l *logAdapter) Errorln(v ...any) {
 }
 
 func (l *logAdapter) Errors() string {
+	l.mu.Lock()
+	defer l.mu.Unlock()
 	return l.errors.String()
 }
 
@@ -339,7 +352,7 @@ func (l *logAdapter) Warnidf(id, format string, v ...any) {
 }
 
 func (l *logAdapter) idfInfoStatement(what, id, format string) string {
-	return fmt.Sprintf("\nYou can suppress this %s by adding the following to your site configuration:\nignoreLogs = ['%s']", what, id)
+	return fmt.Sprintf("\nYou can suppress this %s by adding the following to your project configuration:\nignoreLogs = ['%s']", what, id)
 }
 
 func (l *logAdapter) Trace(s logg.StringFunc) {

common/paths/pathparser.go

@@ -21,7 +21,7 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/hugofs/files"
 	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
@@ -30,10 +30,18 @@ import (
 )
 
 const (
-	identifierBaseof         = "baseof"
-	identifierCurstomWrapper = "_"
+	identifierBaseof        = "baseof"
+	identifierCustomWrapper = "_"
 )
 
+// isCustomWrapperIdentifier tells whether a supplied path is of the form _xyz_.
+// must have non-empty content between the identifierCustomWrapper's to pass.
+func isCustomWrapperIdentifier(s string) bool {
+	return len(s) > 2*len(identifierCustomWrapper) &&
+		strings.HasPrefix(s, identifierCustomWrapper) &&
+		strings.HasSuffix(s, identifierCustomWrapper)
+}
+
 // PathParser parses and manages paths.
 type PathParser struct {
 	// Maps the language code to its index in the languages/sites slice.
@@ -54,12 +62,12 @@ type PathParser struct {
 
 	// Below gets created on demand.
 	initOnce         sync.Once
-	sitesMatrixCache *maps.Cache[string, sitesmatrix.VectorStore] // Maps language index to sites matrix vector store.
+	sitesMatrixCache *hmaps.Cache[string, sitesmatrix.VectorStore] // Maps language index to sites matrix vector store.
 }
 
 func (pp *PathParser) init() {
 	pp.initOnce.Do(func() {
-		pp.sitesMatrixCache = maps.NewCache[string, sitesmatrix.VectorStore]()
+		pp.sitesMatrixCache = hmaps.NewCache[string, sitesmatrix.VectorStore]()
 	})
 }
 
@@ -188,7 +196,7 @@ func (pp *PathParser) parseIdentifier(component, s string, p *Path, i, lastDot,
 	id := types.LowHigh[string]{Low: i + 1, High: high}
 	sid := p.s[id.Low:id.High]
 
-	if strings.HasPrefix(sid, identifierCurstomWrapper) && strings.HasSuffix(sid, identifierCurstomWrapper) {
+	if isCustomWrapperIdentifier(sid) {
 		p.identifiersKnown = append(p.identifiersKnown, id)
 		p.posIdentifierCustom = len(p.identifiersKnown) - 1
 		found = true
@@ -775,7 +783,7 @@ func (p *Path) Lang() string {
 }
 
 func (p *Path) Custom() string {
-	return strings.TrimSuffix(strings.TrimPrefix(p.identifierAsString(p.posIdentifierCustom), identifierCurstomWrapper), identifierCurstomWrapper)
+	return strings.TrimSuffix(strings.TrimPrefix(p.identifierAsString(p.posIdentifierCustom), identifierCustomWrapper), identifierCustomWrapper)
 }
 
 func (p *Path) Identifier(i int) string {

common/predicate/predicate.go

@@ -153,6 +153,35 @@ func (p PR[T]) FilterCopy(s []T) []T {
 	return result
 }
 
+const (
+	rangeOpNone = iota
+	rangeOpLT
+	rangeOpLTE
+	rangeOpGT
+	rangeOpGTE
+	rangeOpEQ
+	rangeOpNE
+)
+
+func cutRangeOp(s string) (op int, rest string) {
+	switch {
+	case strings.HasPrefix(s, ">= "):
+		return rangeOpGTE, s[3:]
+	case strings.HasPrefix(s, "<= "):
+		return rangeOpLTE, s[3:]
+	case strings.HasPrefix(s, "== "):
+		return rangeOpEQ, s[3:]
+	case strings.HasPrefix(s, "!= "):
+		return rangeOpNE, s[3:]
+	case strings.HasPrefix(s, "> "):
+		return rangeOpGT, s[2:]
+	case strings.HasPrefix(s, "< "):
+		return rangeOpLT, s[2:]
+	default:
+		return rangeOpNone, s
+	}
+}
+
 // NewStringPredicateFromGlobs creates a string predicate from the given glob patterns.
 // A glob pattern starting with "!" is a negation pattern which will be ANDed with the rest.
 func NewStringPredicateFromGlobs(patterns []string, getGlob func(pattern string) (glob.Glob, error)) (P[string], error) {
@@ -187,6 +216,86 @@ func NewStringPredicateFromGlobs(patterns []string, getGlob func(pattern string)
 	return p.BoolFunc(), nil
 }
 
-type IndexMatcher interface {
-	IndexMatch(match P[string]) (iter.Seq[int], error)
+// NewIndexStringPredicateFromGlobsAndRanges creates an IndexString predicate from the given glob patterns and range patterns.
+// A glob pattern starting with "!" is a negation pattern which will be ANDed with the rest.
+// A range pattern is one of "> value", ">= value", "< value" or "<= value".
+func NewIndexStringPredicateFromGlobsAndRanges(patterns []string, getIndex func(s string) int, getGlob func(pattern string) (glob.Glob, error)) (P[IndexString], error) {
+	var p PR[IndexString]
+	for _, pattern := range patterns {
+		pattern = strings.TrimSpace(pattern)
+		if pattern == "" {
+			continue
+		}
+		negate := strings.HasPrefix(pattern, hglob.NegationPrefix)
+		if negate {
+			pattern = pattern[2:]
+			g, err := getGlob(pattern)
+			if err != nil {
+				return nil, err
+			}
+			p = p.And(func(s IndexString) Match {
+				return BoolMatch(!g.Match(s.String))
+			})
+		} else {
+			// This can be either a glob or a value prefixed with one of >, >=, < or <=.
+			o, v := cutRangeOp(pattern)
+			if o != rangeOpNone {
+				i := getIndex(v)
+				if i == -1 {
+					// No match possible.
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(false)
+					})
+					continue
+				}
+				switch o {
+				// The greater values starts at the top with index 0.
+				case rangeOpGT:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index < i)
+					})
+				case rangeOpGTE:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index <= i)
+					})
+				case rangeOpLT:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index > i)
+					})
+				case rangeOpLTE:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index >= i)
+					})
+				case rangeOpEQ:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index == i)
+					})
+				case rangeOpNE:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index != i)
+					})
+				}
+			} else {
+				g, err := getGlob(pattern)
+				if err != nil {
+					return nil, err
+				}
+				p = p.Or(func(s IndexString) Match {
+					return BoolMatch(g.Match(s.String))
+				})
+			}
+
+		}
+	}
+
+	return p.BoolFunc(), nil
+}
+
+type IndexString struct {
+	Index  int
+	String string
+}
+
+type IndexMatcher interface {
+	IndexMatch(match P[IndexString]) (iter.Seq[int], error)
 }

common/predicate/predicate_test.go

@@ -146,6 +146,107 @@ func TestNewStringPredicateFromGlobs(t *testing.T) {
 	c.Assert(m("anything"), qt.IsFalse)
 }
 
+func TestNewIndexStringPredicateFromGlobsAndRanges(t *testing.T) {
+	c := qt.New(t)
+
+	// Simulate versions: v4.0.0=0, v3.0.0=1, v2.0.0=2, v1.0.0=3
+	// Lower index = greater value.
+	versions := []string{"v4.0.0", "v3.0.0", "v2.0.0", "v1.0.0"}
+	getIndex := func(s string) int {
+		for i, v := range versions {
+			if v == s {
+				return i
+			}
+		}
+		return -1
+	}
+	getGlob := func(pattern string) (glob.Glob, error) {
+		return glob.Compile(pattern)
+	}
+
+	n := func(patterns ...string) predicate.P[predicate.IndexString] {
+		p, err := predicate.NewIndexStringPredicateFromGlobsAndRanges(patterns, getIndex, getGlob)
+		c.Assert(err, qt.IsNil)
+		return p
+	}
+
+	is := func(i int) predicate.IndexString {
+		return predicate.IndexString{Index: i, String: versions[i]}
+	}
+
+	// Test >= v2.0.0 (index 2): should match indices <= 2
+	m := n(">= v2.0.0")
+	c.Assert(m(is(0)), qt.IsTrue)  // v4.0.0
+	c.Assert(m(is(1)), qt.IsTrue)  // v3.0.0
+	c.Assert(m(is(2)), qt.IsTrue)  // v2.0.0
+	c.Assert(m(is(3)), qt.IsFalse) // v1.0.0
+
+	// Test > v2.0.0 (index 2): should match indices < 2
+	m = n("> v2.0.0")
+	c.Assert(m(is(0)), qt.IsTrue)  // v4.0.0
+	c.Assert(m(is(1)), qt.IsTrue)  // v3.0.0
+	c.Assert(m(is(2)), qt.IsFalse) // v2.0.0
+	c.Assert(m(is(3)), qt.IsFalse) // v1.0.0
+
+	// Test < v3.0.0 (index 1): should match indices > 1
+	m = n("< v3.0.0")
+	c.Assert(m(is(0)), qt.IsFalse) // v4.0.0
+	c.Assert(m(is(1)), qt.IsFalse) // v3.0.0
+	c.Assert(m(is(2)), qt.IsTrue)  // v2.0.0
+	c.Assert(m(is(3)), qt.IsTrue)  // v1.0.0
+
+	// Test range: >= v2.0.0 AND <= v3.0.0
+	m = n(">= v2.0.0", "<= v3.0.0")
+	c.Assert(m(is(0)), qt.IsFalse) // v4.0.0 - too high
+	c.Assert(m(is(1)), qt.IsTrue)  // v3.0.0
+	c.Assert(m(is(2)), qt.IsTrue)  // v2.0.0
+	c.Assert(m(is(3)), qt.IsFalse) // v1.0.0 - too low
+
+	// Test glob pattern
+	m = n("v2.*.*")
+	c.Assert(m(is(0)), qt.IsFalse) // v4.0.0
+	c.Assert(m(is(2)), qt.IsTrue)  // v2.0.0
+
+	// Test glob with negation
+	m = n("v*.*.*", "! v3.*.*")
+	c.Assert(m(is(0)), qt.IsTrue)  // v4.0.0
+	c.Assert(m(is(1)), qt.IsFalse) // v3.0.0 - negated
+	c.Assert(m(is(2)), qt.IsTrue)  // v2.0.0
+
+	// Test range with negation: >= v2.0.0 but not v3.0.0
+	m = n(">= v2.0.0", "! v3.0.0")
+	c.Assert(m(is(0)), qt.IsTrue)  // v4.0.0
+	c.Assert(m(is(1)), qt.IsFalse) // v3.0.0 - negated
+	c.Assert(m(is(2)), qt.IsTrue)  // v2.0.0
+	c.Assert(m(is(3)), qt.IsFalse) // v1.0.0 - out of range
+
+	// Test unknown value in range returns no match
+	m = n(">= v99.0.0")
+	c.Assert(m(is(0)), qt.IsFalse)
+	c.Assert(m(is(3)), qt.IsFalse)
+
+	// Test == v2.0.0: should only match v2.0.0
+	m = n("== v2.0.0")
+	c.Assert(m(is(0)), qt.IsFalse) // v4.0.0
+	c.Assert(m(is(1)), qt.IsFalse) // v3.0.0
+	c.Assert(m(is(2)), qt.IsTrue)  // v2.0.0
+	c.Assert(m(is(3)), qt.IsFalse) // v1.0.0
+
+	// Test != v2.0.0: should match everything except v2.0.0
+	m = n("!= v2.0.0")
+	c.Assert(m(is(0)), qt.IsTrue)  // v4.0.0
+	c.Assert(m(is(1)), qt.IsTrue)  // v3.0.0
+	c.Assert(m(is(2)), qt.IsFalse) // v2.0.0
+	c.Assert(m(is(3)), qt.IsTrue)  // v1.0.0
+
+	// Test != with range: >= v2.0.0 AND != v3.0.0
+	m = n(">= v2.0.0", "!= v3.0.0")
+	c.Assert(m(is(0)), qt.IsTrue)  // v4.0.0
+	c.Assert(m(is(1)), qt.IsFalse) // v3.0.0 - excluded by !=
+	c.Assert(m(is(2)), qt.IsTrue)  // v2.0.0
+	c.Assert(m(is(3)), qt.IsFalse) // v1.0.0 - out of range
+}
+
 func BenchmarkPredicate(b *testing.B) {
 	b.Run("and or no match", func(b *testing.B) {
 		var p predicate.PR[int] = intP1

common/predicate/rangeop_test.go

@@ -0,0 +1,52 @@
+// Copyright 2026 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package predicate
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestCutRangeOp(t *testing.T) {
+	c := qt.New(t)
+
+	op, rest := cutRangeOp(">= value")
+	c.Assert(op, qt.Equals, rangeOpGTE)
+	c.Assert(rest, qt.Equals, "value")
+
+	op, rest = cutRangeOp("<= value")
+	c.Assert(op, qt.Equals, rangeOpLTE)
+	c.Assert(rest, qt.Equals, "value")
+
+	op, rest = cutRangeOp("> value")
+	c.Assert(op, qt.Equals, rangeOpGT)
+	c.Assert(rest, qt.Equals, "value")
+
+	op, rest = cutRangeOp("< value")
+	c.Assert(op, qt.Equals, rangeOpLT)
+	c.Assert(rest, qt.Equals, "value")
+
+	op, rest = cutRangeOp("== value")
+	c.Assert(op, qt.Equals, rangeOpEQ)
+	c.Assert(rest, qt.Equals, "value")
+
+	op, rest = cutRangeOp("!= value")
+	c.Assert(op, qt.Equals, rangeOpNE)
+	c.Assert(rest, qt.Equals, "value")
+
+	op, rest = cutRangeOp("value")
+	c.Assert(op, qt.Equals, rangeOpNone)
+	c.Assert(rest, qt.Equals, "value")
+}

common/version/version.go

@@ -37,6 +37,9 @@ type Version struct {
 	// HugoVersionSuffix is the suffix used in the Hugo version string.
 	// It will be blank for release versions.
 	Suffix string
+
+	// Set when parsed from a string,
+	source string
 }
 
 var (
@@ -51,6 +54,10 @@ func (v Version) IsAlphaBetaOrRC() bool {
 	return strings.Contains(s, "alpha.") || strings.Contains(s, "beta.") || strings.Contains(s, "rc.")
 }
 
+func (v Version) IsZero() bool {
+	return v.Major == 0 && v.Minor == 0 && v.PatchLevel == 0 && v.Suffix == ""
+}
+
 func (v Version) String() string {
 	return version(v.Major, v.Minor, v.PatchLevel, v.Suffix)
 }
@@ -109,6 +116,7 @@ func ParseVersion(s string) (Version, error) {
 		vv.Suffix = suffix
 	}
 	vv.Major, vv.Minor, vv.PatchLevel = parseVersion(s)
+	vv.source = s
 
 	return vv, nil
 }
@@ -176,6 +184,10 @@ func CompareVersions(v1 Version, v2 any) int {
 	case int64:
 		c = compareFloatWithVersion(float64(d), v1)
 	case Version:
+		if v1.IsZero() && d.IsZero() {
+			// Fall back to source comparison.
+			return strings.Compare(v1.source, d.source)
+		}
 		if d.Major == v1.Major && d.Minor == v1.Minor && d.PatchLevel == v1.PatchLevel {
 			return strings.Compare(v1.Suffix, d.Suffix)
 		}
@@ -200,11 +212,13 @@ func CompareVersions(v1 Version, v2 any) int {
 			return -1
 		}
 
-		v, err := ParseVersion(s)
-		if err != nil {
-			return -1
+		v2v, _ := ParseVersion(s)
+		if v1.IsZero() && v2v.IsZero() {
+			// Fall back to source comparison.
+			return strings.Compare(v1.source, v2v.source)
 		}
-		return v1.Compare(v)
+
+		return v1.Compare(v2v)
 
 	}
 

common/version/version_test.go

@@ -50,6 +50,11 @@ func TestHugoVersion(t *testing.T) {
 func TestCompareVersions(t *testing.T) {
 	c := qt.New(t)
 
+	parseIgnoreErr := func(s string) Version {
+		v, _ := ParseVersion(s)
+		return v
+	}
+
 	c.Assert(CompareVersions(MustParseVersion("0.20.0"), 0.20), qt.Equals, 0)
 	c.Assert(CompareVersions(MustParseVersion("0.20.0"), float32(0.20)), qt.Equals, 0)
 	c.Assert(CompareVersions(MustParseVersion("0.20.0"), float64(0.20)), qt.Equals, 0)
@@ -69,6 +74,15 @@ func TestCompareVersions(t *testing.T) {
 	c.Assert(CompareVersions(MustParseVersion("0.22.0-DEV"), "0.22"), qt.Equals, 1)
 	c.Assert(CompareVersions(MustParseVersion("0.22.1-DEV"), "0.22"), qt.Equals, -1)
 	c.Assert(CompareVersions(MustParseVersion("0.22.1-DEV"), "0.22.1-DEV"), qt.Equals, 0)
+
+	c.Assert(CompareVersions(parseIgnoreErr("foobar"), "v1.0.0"), qt.Equals, 1)
+	c.Assert(CompareVersions(parseIgnoreErr("v1.0.0"), "foobar"), qt.Equals, -1)
+	c.Assert(CompareVersions(parseIgnoreErr("foobar"), "foobar"), qt.Equals, 0)
+	c.Assert(CompareVersions(parseIgnoreErr("foobar"), parseIgnoreErr("foobar")), qt.Equals, 0)
+	c.Assert(CompareVersions(parseIgnoreErr("a"), "b"), qt.Equals, -1)
+	c.Assert(CompareVersions(parseIgnoreErr("a"), parseIgnoreErr("b")), qt.Equals, -1)
+	c.Assert(CompareVersions(parseIgnoreErr("b"), "a"), qt.Equals, 1)
+	c.Assert(CompareVersions(parseIgnoreErr("b"), parseIgnoreErr("a")), qt.Equals, 1)
 }
 
 func TestParseHugoVersion(t *testing.T) {

config/allconfig/allconfig.go

@@ -29,10 +29,10 @@ import (
 
 	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/cache/httpcache"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/hstrings"
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/urls"
 	"github.com/gohugoio/hugo/config"
@@ -212,7 +212,7 @@ type Config struct {
 
 	// User provided parameters.
 	// <docsmeta>{"refs": ["config:languages:params"] }</docsmeta>
-	Params maps.Params `mapstructure:"-"`
+	Params hmaps.Params `mapstructure:"-"`
 
 	// UglyURLs configuration. Either a boolean or a sections map.
 	UglyURLs any `mapstructure:"-"`
@@ -399,33 +399,23 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		return err
 	}
 
-	// Legacy paginate values.
-	if c.Paginate != 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.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())
+		hugo.DeprecateWithLogger("project 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())
+		hugo.DeprecateWithLogger("project 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())
+		hugo.DeprecateWithLogger("project 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())
+		hugo.DeprecateWithLogger("project config key services.twitter.disableInlineCSS", "Use services.x.disableInlineCSS instead.", "v0.141.0", logger.Logger())
 		c.Services.X.DisableInlineCSS = c.Services.Twitter.DisableInlineCSS
 	}
 
@@ -446,7 +436,7 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 	)
 	if c.Markup.Goldmark.RenderHooks.Image.EnableDefault != nil {
 		alternative := "Use markup.goldmark.renderHooks.image.useEmbedded instead." + " " + alternativeDetails
-		hugo.DeprecateWithLogger("site config key markup.goldmark.renderHooks.image.enableDefault", alternative, "0.148.0", logger.Logger())
+		hugo.DeprecateWithLogger("project config key markup.goldmark.renderHooks.image.enableDefault", alternative, "0.148.0", logger.Logger())
 		if *c.Markup.Goldmark.RenderHooks.Image.EnableDefault {
 			c.Markup.Goldmark.RenderHooks.Image.UseEmbedded = gc.RenderHookUseEmbeddedFallback
 		} else {
@@ -455,7 +445,7 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 	}
 	if c.Markup.Goldmark.RenderHooks.Link.EnableDefault != nil {
 		alternative := "Use markup.goldmark.renderHooks.link.useEmbedded instead." + " " + alternativeDetails
-		hugo.DeprecateWithLogger("site config key markup.goldmark.renderHooks.link.enableDefault", alternative, "0.148.0", logger.Logger())
+		hugo.DeprecateWithLogger("project config key markup.goldmark.renderHooks.link.enableDefault", alternative, "0.148.0", logger.Logger())
 		if *c.Markup.Goldmark.RenderHooks.Link.EnableDefault {
 			c.Markup.Goldmark.RenderHooks.Link.UseEmbedded = gc.RenderHookUseEmbeddedFallback
 		} else {
@@ -471,10 +461,10 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		gc.RenderHookUseEmbeddedNever,
 	}
 	if !slices.Contains(renderHookUseEmbeddedModes, c.Markup.Goldmark.RenderHooks.Image.UseEmbedded) {
-		return fmt.Errorf("site config markup.goldmark.renderHooks.image.useEmbedded must be one of %s", helpers.StringSliceToList(renderHookUseEmbeddedModes, "or"))
+		return fmt.Errorf("project config markup.goldmark.renderHooks.image.useEmbedded must be one of %s", helpers.StringSliceToList(renderHookUseEmbeddedModes, "or"))
 	}
 	if !slices.Contains(renderHookUseEmbeddedModes, c.Markup.Goldmark.RenderHooks.Link.UseEmbedded) {
-		return fmt.Errorf("site config markup.goldmark.renderHooks.link.useEmbedded must be one of %s", helpers.StringSliceToList(renderHookUseEmbeddedModes, "or"))
+		return fmt.Errorf("project config markup.goldmark.renderHooks.link.useEmbedded must be one of %s", helpers.StringSliceToList(renderHookUseEmbeddedModes, "or"))
 	}
 
 	c.C = &ConfigCompiled{
@@ -607,8 +597,14 @@ type RootConfig struct {
 	DefaultOutputFormat string
 
 	// Disable generation of redirect to the default language when DefaultContentLanguageInSubdir is enabled.
+	// Note that this currently is an alias for DisableDefaultSiteRedirect introduced in v0.154.5.
+	// It's not obvious how a more fine grained setup would work.
 	DisableDefaultLanguageRedirect bool
 
+	// Disable generation of redirects to the default site when DefaultContentRoleInSubdir or DefaultContentVersionInSubdir or DefaultContentLanguageInSubdir is enabled.
+	// The default site is the site is the combination of defaultContentLanguage, defaultContentVersion and defaultContentRole.
+	DisableDefaultSiteRedirect bool
+
 	// Disable creation of alias redirect pages.
 	DisableAliases bool
 
@@ -681,14 +677,6 @@ type RootConfig struct {
 	// Enable if the site content has CJK language (Chinese, Japanese, or Korean). This affects how Hugo counts words.
 	HasCJKLanguage bool
 
-	// The default number of pages per page when paginating.
-	// Deprecated: Use the Pagination struct.
-	Paginate int
-
-	// The path to use when creating pagination URLs, e.g. "page" in /page/2/.
-	// Deprecated: Use the Pagination struct.
-	PaginatePath string
-
 	// Whether to pluralize default list titles.
 	// Note that this currently only works for English, but you can provide your own title in the content file's front matter.
 	PluralizeListTitles bool
@@ -816,6 +804,7 @@ type Configs struct {
 
 	Modules       modules.Modules
 	ModulesClient *modules.Client
+	FileCaches    filecache.Caches
 
 	// All below is set in Init.
 	Languages                 langs.Languages
@@ -846,7 +835,7 @@ func (c *Configs) IsZero() bool {
 	return c == nil || len(c.Languages) == 0
 }
 
-func (c *Configs) Init(logger loggers.Logger) error {
+func (c *Configs) Init(sourceFs afero.Fs, logger loggers.Logger) error {
 	var languages langs.Languages
 
 	for _, f := range c.Base.Languages.Config.Sorted {
@@ -915,10 +904,9 @@ func (c *Configs) Init(logger loggers.Logger) error {
 	// avoid initializing the same config more than once.
 	for i, l := range c.Languages {
 		langConfig := c.LanguageConfigMap[l.Lang]
-		sitesMatrix := sitesmatrix.NewIntSetsBuilder(c.ConfiguredDimensions).WithLanguageIndices(i).WithAllIfNotSet().Build()
 		for _, s := range allDecoderSetups {
 			if getInitializer := s.getInitializer; getInitializer != nil {
-				if err := getInitializer(langConfig).InitConfig(logger, sitesMatrix, c.ConfiguredDimensions); err != nil {
+				if err := getInitializer(langConfig).InitConfig(logger, nil, c.ConfiguredDimensions); err != nil {
 					return err
 				}
 			}
@@ -1018,7 +1006,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 		if lang == "" {
 			lang = "en"
 		}
-		res.Cfg.Set("languages", maps.Params{lang: maps.Params{}})
+		res.Cfg.Set("languages", hmaps.Params{lang: hmaps.Params{}})
 	}
 	bcfg := res.BaseConfig
 	cfg := res.Cfg
@@ -1045,11 +1033,11 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 		var differentRootKeys []string
 		switch x := v.(type) {
 		case nil:
-		case maps.Params:
+		case hmaps.Params:
 			_, found := x["params"]
 			if !found {
-				x["params"] = maps.Params{
-					maps.MergeStrategyKey: maps.ParamsMergeStrategyDeep,
+				x["params"] = hmaps.Params{
+					hmaps.MergeStrategyKey: hmaps.ParamsMergeStrategyDeep,
 				}
 			}
 			for kk, vv := range x {
@@ -1061,16 +1049,16 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 					isMultihost = true
 				}
 
-				if p, ok := vv.(maps.Params); ok {
+				if p, ok := vv.(hmaps.Params); ok {
 					// With the introduction of YAML anchor and alias support, language config entries
 					// may be contain shared references.
 					// This also break potential cycles.
-					vv = maps.CloneParamsDeep(p)
+					vv = hmaps.CloneParamsDeep(p)
 				}
 
 				if kk == "cascade" {
 					// If not set, add the current language to make sure it does not get applied to other languages.
-					page.AddLangToCascadeTargetMap(k, vv.(maps.Params))
+					page.AddLangToCascadeTargetMap(k, vv.(hmaps.Params))
 					// Always clone cascade config to get the sites matrix right.
 					differentRootKeys = append(differentRootKeys, kk)
 				}
@@ -1081,14 +1069,14 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 					// This overrides a root key and potentially needs a merge.
 					if !reflect.DeepEqual(rootv, vv) {
 						switch vvv := vv.(type) {
-						case maps.Params:
+						case hmaps.Params:
 							differentRootKeys = append(differentRootKeys, kk)
 
 							// Use the language value as base.
 							// Note that this is already cloned above.
 							mergedConfigEntry := vvv
 							// Merge in the root value.
-							maps.MergeParams(mergedConfigEntry, rootv.(maps.Params))
+							hmaps.MergeParams(mergedConfigEntry, rootv.(hmaps.Params))
 
 							mergedConfig.Set(kk, mergedConfigEntry)
 						default:
@@ -1098,7 +1086,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 					}
 				} else {
 					switch vv.(type) {
-					case maps.Params:
+					case hmaps.Params:
 						differentRootKeys = append(differentRootKeys, kk)
 					default:
 						// Apply new values to the root.
@@ -1134,7 +1122,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 			}
 
 			langConfigMap[k] = clone
-		case maps.ParamsMergeStrategy:
+		case hmaps.ParamsMergeStrategy:
 
 		default:
 			panic(fmt.Sprintf("unknown type in languages config: %T", v))
@@ -1149,10 +1137,16 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 		l.CommonDirs.CacheDir = bcfg.CacheDir
 	}
 
+	caches, err := filecache.NewCaches(all.Caches, fs)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create file caches from configuration: %w", err)
+	}
+
 	cm := &Configs{
 		Base:              all,
 		LanguageConfigMap: langConfigMap,
 		LoadingInfo:       res,
+		FileCaches:        caches,
 		IsMultihost:       isMultihost,
 	}
 

config/allconfig/alldecoders.go

@@ -22,9 +22,9 @@ import (
 	"github.com/gohugoio/hugo/langs"
 
 	"github.com/gohugoio/hugo/cache/httpcache"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/hstrings"
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/privacy"
@@ -196,7 +196,7 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "outputs",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			defaults := createDefaultOutputFormats(p.c.OutputFormats.Config)
-			m := maps.CleanConfigStringMap(p.p.GetStringMap("outputs"))
+			m := hmaps.CleanConfigStringMap(p.p.GetStringMap("outputs"))
 			p.c.Outputs = make(map[string][]string)
 			for k, v := range m {
 				s := types.ToStringSlicePreserveString(v)
@@ -225,13 +225,13 @@ var allDecoderSetups = map[string]decodeWeight{
 	"languages": {
 		key: "languages",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			m := maps.CleanConfigStringMap(p.p.GetStringMap(d.key))
+			m := hmaps.CleanConfigStringMap(p.p.GetStringMap(d.key))
 			if len(m) == 1 {
 				// In v0.112.4 we moved this to the language config, but it's very commmon for mono language sites to have this at the top level.
-				var first maps.Params
+				var first hmaps.Params
 				var ok bool
 				for _, v := range m {
-					first, ok = v.(maps.Params)
+					first, ok = v.(hmaps.Params)
 					if ok {
 						break
 					}
@@ -266,7 +266,7 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "versions",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			m := maps.CleanConfigStringMap(p.p.GetStringMap(d.key))
+			m := hmaps.CleanConfigStringMap(p.p.GetStringMap(d.key))
 			p.c.Versions, err = versions.DecodeConfig(p.c.RootConfig.DefaultContentVersion, m)
 			return err
 		},
@@ -278,7 +278,7 @@ var allDecoderSetups = map[string]decodeWeight{
 				err                error
 				defaultContentRole string
 			)
-			m := maps.CleanConfigStringMap(p.p.GetStringMap(d.key))
+			m := hmaps.CleanConfigStringMap(p.p.GetStringMap(d.key))
 			p.c.Roles, defaultContentRole, err = roles.DecodeConfig(p.c.RootConfig.DefaultContentRole, m)
 			p.c.RootConfig.DefaultContentRole = defaultContentRole
 
@@ -289,7 +289,7 @@ var allDecoderSetups = map[string]decodeWeight{
 	"params": {
 		key: "params",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Params = maps.CleanConfigStringMap(p.p.GetStringMap("params"))
+			p.c.Params = hmaps.CleanConfigStringMap(p.p.GetStringMap("params"))
 			if p.c.Params == nil {
 				p.c.Params = make(map[string]any)
 			}
@@ -335,7 +335,14 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "taxonomies",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			if p.p.IsSet(d.key) {
-				p.c.Taxonomies = maps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
+				m := hmaps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
+				// Remove invalid entries (e.g. non-taxonomy keys placed inside [taxonomies] in TOML).
+				for k, v := range m {
+					if k == "" || v == "" {
+						delete(m, k)
+					}
+				}
+				p.c.Taxonomies = m
 			}
 			return nil
 		},
@@ -447,7 +454,7 @@ var allDecoderSetups = map[string]decodeWeight{
 	"author": {
 		key: "author",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Author = maps.CleanConfigStringMap(p.p.GetStringMap(d.key))
+			p.c.Author = hmaps.CleanConfigStringMap(p.p.GetStringMap(d.key))
 			return nil
 		},
 		internalOrDeprecated: true,
@@ -455,7 +462,7 @@ var allDecoderSetups = map[string]decodeWeight{
 	"social": {
 		key: "social",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Social = maps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
+			p.c.Social = hmaps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
 			return nil
 		},
 		internalOrDeprecated: true,
@@ -469,8 +476,8 @@ var allDecoderSetups = map[string]decodeWeight{
 				p.c.UglyURLs = vv
 			case string:
 				p.c.UglyURLs = vv == "true"
-			case maps.Params:
-				p.c.UglyURLs = cast.ToStringMapBool(maps.CleanConfigStringMap(vv))
+			case hmaps.Params:
+				p.c.UglyURLs = cast.ToStringMapBool(hmaps.CleanConfigStringMap(vv))
 			default:
 				p.c.UglyURLs = cast.ToStringMapBool(v)
 			}

config/allconfig/configlanguage.go

@@ -25,9 +25,8 @@ import (
 )
 
 type ConfigLanguage struct {
-	config     *Config
-	baseConfig config.BaseConfig
-
+	config        *Config
+	baseConfig    config.BaseConfig
 	m             *Configs
 	language      *langs.Language
 	languageIndex int
@@ -123,6 +122,10 @@ func (c ConfigLanguage) BaseConfig() config.BaseConfig {
 	return c.baseConfig
 }
 
+func (c ConfigLanguage) FileCaches() any {
+	return c.m.FileCaches
+}
+
 func (c ConfigLanguage) Dirs() config.CommonDirs {
 	return c.config.CommonDirs
 }

config/allconfig/docshelper.go

@@ -14,7 +14,7 @@
 package allconfig
 
 import (
-	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/docshelper"
 )
@@ -27,12 +27,12 @@ func init() {
 			if v.internalOrDeprecated {
 				continue
 			}
-			cfg.Set(configRoot, make(maps.Params))
+			cfg.Set(configRoot, make(hmaps.Params))
 		}
-		lang := maps.Params{
-			"en": maps.Params{
-				"menus":  maps.Params{},
-				"params": maps.Params{},
+		lang := hmaps.Params{
+			"en": hmaps.Params{
+				"menus":  hmaps.Params{},
+				"params": hmaps.Params{},
 			},
 		}
 		cfg.Set("languages", lang)

config/allconfig/load.go

@@ -25,9 +25,9 @@ import (
 	"github.com/gobwas/glob"
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/hexec"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
@@ -39,7 +39,7 @@ import (
 )
 
 //lint:ignore ST1005 end user message.
-var ErrNoConfigFile = errors.New("Unable to locate config file or config directory. Perhaps you need to create a new site.\n       Run `hugo help new` for details.\n")
+var ErrNoConfigFile = errors.New("Unable to locate config file or config directory. Perhaps you need to create a new project.\n       Run `hugo help new` for details.\n")
 
 func LoadConfig(d ConfigSourceDescriptor) (configs *Configs, err error) {
 	defer func() {
@@ -95,7 +95,7 @@ func LoadConfig(d ConfigSourceDescriptor) (configs *Configs, err error) {
 	configs.Modules = moduleConfig.AllModules
 	configs.ModulesClient = modulesClient
 
-	if err := configs.Init(d.Logger); err != nil {
+	if err := configs.Init(d.Fs, d.Logger); err != nil {
 		return nil, fmt.Errorf("failed to init config: %w", err)
 	}
 
@@ -166,7 +166,7 @@ func (l configLoader) applyConfigAliases() error {
 }
 
 func (l configLoader) applyDefaultConfig() error {
-	defaultSettings := maps.Params{
+	defaultSettings := hmaps.Params{
 		// These dirs are used early/before we build the config struct.
 		"themesDir": "themes",
 		"configDir": "config",
@@ -179,14 +179,14 @@ func (l configLoader) applyDefaultConfig() error {
 
 func (l configLoader) normalizeCfg(cfg config.Provider) error {
 	if b, ok := cfg.Get("minifyOutput").(bool); ok {
-		hugo.Deprecate("site config minifyOutput", "Use minify.minifyOutput instead.", "v0.150.0")
+		hugo.Deprecate("project config minifyOutput", "Use minify.minifyOutput instead.", "v0.150.0")
 		if b {
 			cfg.Set("minify.minifyOutput", true)
 		}
 	} else if b, ok := cfg.Get("minify").(bool); ok {
-		hugo.Deprecate("site config minify", "Use minify.minifyOutput instead.", "v0.150.0")
+		hugo.Deprecate("project config minify", "Use minify.minifyOutput instead.", "v0.150.0")
 		if b {
-			cfg.Set("minify", maps.Params{"minifyOutput": true})
+			cfg.Set("minify", hmaps.Params{"minifyOutput": true})
 		}
 	}
 
@@ -240,7 +240,7 @@ func (l configLoader) applyOsEnvOverrides(environ []string) error {
 	}
 
 	for _, env := range hugoEnv {
-		existing, nestedKey, owner, err := maps.GetNestedParamFn(env.Key, delim, l.cfg.Get)
+		existing, nestedKey, owner, err := hmaps.GetNestedParamFn(env.Key, delim, l.cfg.Get)
 		if err != nil {
 			return err
 		}
@@ -477,6 +477,7 @@ func (l *configLoader) loadModules(configs *Configs, ignoreModuleDoesNotExist bo
 		PublishDir:               publishDir,
 		Environment:              l.Environment,
 		CacheDir:                 conf.Caches.CacheDirModules(),
+		ModuleQueriesCache:       configs.FileCaches.ModuleQueriesCache(),
 		ModuleConfig:             conf.Module,
 		IgnoreVendor:             ignoreVendor,
 		IgnoreModuleDoesNotExist: ignoreModuleDoesNotExist,
@@ -547,7 +548,7 @@ func (l configLoader) loadConfig(configName string) (string, error) {
 }
 
 func (l configLoader) deleteMergeStrategies() (err error) {
-	l.cfg.WalkParams(func(params ...maps.KeyParams) bool {
+	l.cfg.WalkParams(func(params ...hmaps.KeyParams) bool {
 		params[len(params)-1].Params.DeleteMergeStrategy()
 		return false
 	})

config/commonConfig.go

@@ -437,7 +437,7 @@ func (c *CacheBuster) CompileConfig(logger loggers.Logger) error {
 			return nil
 		}
 		return func(ss string) bool {
-			match = targetRe.MatchString(ss)
+			match := targetRe.MatchString(ss)
 			matchString := "no match"
 			if match {
 				matchString = "match!"

config/configLoader.go

@@ -20,11 +20,11 @@ import (
 	"strings"
 
 	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/parser"
 
 	"github.com/gohugoio/hugo/common/paths"
 
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/parser/metadecoders"
 	"github.com/spf13/afero"
 )
@@ -222,11 +222,11 @@ func LoadConfigFromDir(sourceFs afero.Fs, configDir, environment string) (Provid
 	return cfg, dirnames, nil
 }
 
-var keyAliases maps.KeyRenamer
+var keyAliases hmaps.KeyRenamer
 
 func init() {
 	var err error
-	keyAliases, err = maps.NewKeyRenamer(
+	keyAliases, err = hmaps.NewKeyRenamer(
 		// Before 0.53 we used singular for "menu".
 		"{menu,languages/*/menu}", "menus",
 	)

config/configProvider.go

@@ -16,7 +16,7 @@ package config
 import (
 	"time"
 
-	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/common/urls"
@@ -41,6 +41,7 @@ type AllProvider interface {
 	Dirs() CommonDirs
 	Quiet() bool
 	DirsBase() CommonDirs
+	FileCaches() any
 	ContentTypes() ContentTypesProvider
 	GetConfigSection(string) any
 	GetConfig() any
@@ -96,7 +97,7 @@ type Provider interface {
 	GetString(key string) string
 	GetInt(key string) int
 	GetBool(key string) bool
-	GetParams(key string) maps.Params
+	GetParams(key string) hmaps.Params
 	GetStringMap(key string) map[string]any
 	GetStringMapString(key string) map[string]string
 	GetStringSlice(key string) []string
@@ -104,9 +105,9 @@ type Provider interface {
 	Set(key string, value any)
 	Keys() []string
 	Merge(key string, value any)
-	SetDefaults(params maps.Params)
+	SetDefaults(params hmaps.Params)
 	SetDefaultMergeStrategy()
-	WalkParams(walkFn func(params ...maps.KeyParams) bool)
+	WalkParams(walkFn func(params ...hmaps.KeyParams) bool)
 	IsSet(key string) bool
 }
 

config/defaultConfigProvider.go

@@ -20,21 +20,20 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/spf13/cast"
-
-	"github.com/gohugoio/hugo/common/maps"
 )
 
-// New creates a Provider backed by an empty maps.Params.
+// New creates a Provider backed by an empty hmaps.Params.
 func New() Provider {
 	return &defaultConfigProvider{
-		root: make(maps.Params),
+		root: make(hmaps.Params),
 	}
 }
 
 // NewFrom creates a Provider backed by params.
-func NewFrom(params maps.Params) Provider {
-	maps.PrepareParams(params)
+func NewFrom(params hmaps.Params) Provider {
+	hmaps.PrepareParams(params)
 	return &defaultConfigProvider{
 		root: params,
 	}
@@ -44,7 +43,7 @@ func NewFrom(params maps.Params) Provider {
 // All methods are thread safe.
 type defaultConfigProvider struct {
 	mu   sync.RWMutex
-	root maps.Params
+	root hmaps.Params
 
 	keyCache sync.Map
 }
@@ -90,22 +89,22 @@ func (c *defaultConfigProvider) GetString(k string) string {
 	return cast.ToString(v)
 }
 
-func (c *defaultConfigProvider) GetParams(k string) maps.Params {
+func (c *defaultConfigProvider) GetParams(k string) hmaps.Params {
 	v := c.Get(k)
 	if v == nil {
 		return nil
 	}
-	return v.(maps.Params)
+	return v.(hmaps.Params)
 }
 
 func (c *defaultConfigProvider) GetStringMap(k string) map[string]any {
 	v := c.Get(k)
-	return maps.ToStringMap(v)
+	return hmaps.ToStringMap(v)
 }
 
 func (c *defaultConfigProvider) GetStringMapString(k string) map[string]string {
 	v := c.Get(k)
-	return maps.ToStringMapString(v)
+	return hmaps.ToStringMapString(v)
 }
 
 func (c *defaultConfigProvider) GetStringSlice(k string) []string {
@@ -120,9 +119,9 @@ func (c *defaultConfigProvider) Set(k string, v any) {
 	k = strings.ToLower(k)
 
 	if k == "" {
-		if p, err := maps.ToParamsAndPrepare(v); err == nil {
+		if p, err := hmaps.ToParamsAndPrepare(v); err == nil {
 			// Set the values directly in root.
-			maps.SetParams(c.root, p)
+			hmaps.SetParams(c.root, p)
 		} else {
 			c.root[k] = v
 		}
@@ -132,7 +131,7 @@ func (c *defaultConfigProvider) Set(k string, v any) {
 
 	switch vv := v.(type) {
 	case map[string]any, map[any]any, map[string]string:
-		p := maps.MustToParamsAndPrepare(vv)
+		p := hmaps.MustToParamsAndPrepare(vv)
 		v = p
 	}
 
@@ -142,9 +141,9 @@ func (c *defaultConfigProvider) Set(k string, v any) {
 	}
 
 	if existing, found := m[key]; found {
-		if p1, ok := existing.(maps.Params); ok {
-			if p2, ok := v.(maps.Params); ok {
-				maps.SetParams(p1, p2)
+		if p1, ok := existing.(hmaps.Params); ok {
+			if p2, ok := v.(hmaps.Params); ok {
+				hmaps.SetParams(p1, p2)
 				return
 			}
 		}
@@ -154,8 +153,8 @@ func (c *defaultConfigProvider) Set(k string, v any) {
 }
 
 // SetDefaults will set values from params if not already set.
-func (c *defaultConfigProvider) SetDefaults(params maps.Params) {
-	maps.PrepareParams(params)
+func (c *defaultConfigProvider) SetDefaults(params hmaps.Params) {
+	hmaps.PrepareParams(params)
 	for k, v := range params {
 		if _, found := c.root[k]; !found {
 			c.root[k] = v
@@ -170,28 +169,28 @@ func (c *defaultConfigProvider) Merge(k string, v any) {
 
 	if k == "" {
 		rs, f := c.root.GetMergeStrategy()
-		if f && rs == maps.ParamsMergeStrategyNone {
+		if f && rs == hmaps.ParamsMergeStrategyNone {
 			// The user has set a "no merge" strategy on this,
 			// nothing more to do.
 			return
 		}
 
-		if p, err := maps.ToParamsAndPrepare(v); err == nil {
+		if p, err := hmaps.ToParamsAndPrepare(v); err == nil {
 			// As there may be keys in p not in root, we need to handle
 			// those as a special case.
 			var keysToDelete []string
 			for kk, vv := range p {
-				if pp, ok := vv.(maps.Params); ok {
+				if pp, ok := vv.(hmaps.Params); ok {
 					if pppi, ok := c.root[kk]; ok {
-						ppp := pppi.(maps.Params)
-						maps.MergeParamsWithStrategy("", ppp, pp)
+						ppp := pppi.(hmaps.Params)
+						hmaps.MergeParamsWithStrategy("", ppp, pp)
 					} else {
 						// We need to use the default merge strategy for
 						// this key.
-						np := make(maps.Params)
-						strategy := c.determineMergeStrategy(maps.KeyParams{Key: "", Params: c.root}, maps.KeyParams{Key: kk, Params: np})
+						np := make(hmaps.Params)
+						strategy := c.determineMergeStrategy(hmaps.KeyParams{Key: "", Params: c.root}, hmaps.KeyParams{Key: kk, Params: np})
 						np.SetMergeStrategy(strategy)
-						maps.MergeParamsWithStrategy("", np, pp)
+						hmaps.MergeParamsWithStrategy("", np, pp)
 						c.root[kk] = np
 						if np.IsZero() {
 							// Just keep it until merge is done.
@@ -201,7 +200,7 @@ func (c *defaultConfigProvider) Merge(k string, v any) {
 				}
 			}
 			// Merge the rest.
-			maps.MergeParams(c.root, p)
+			hmaps.MergeParams(c.root, p)
 			for _, k := range keysToDelete {
 				delete(c.root, k)
 			}
@@ -214,7 +213,7 @@ func (c *defaultConfigProvider) Merge(k string, v any) {
 
 	switch vv := v.(type) {
 	case map[string]any, map[any]any, map[string]string:
-		p := maps.MustToParamsAndPrepare(vv)
+		p := hmaps.MustToParamsAndPrepare(vv)
 		v = p
 	}
 
@@ -224,9 +223,9 @@ func (c *defaultConfigProvider) Merge(k string, v any) {
 	}
 
 	if existing, found := m[key]; found {
-		if p1, ok := existing.(maps.Params); ok {
-			if p2, ok := v.(maps.Params); ok {
-				maps.MergeParamsWithStrategy("", p1, p2)
+		if p1, ok := existing.(hmaps.Params); ok {
+			if p2, ok := v.(hmaps.Params); ok {
+				hmaps.MergeParamsWithStrategy("", p1, p2)
 			}
 		}
 	} else {
@@ -245,10 +244,10 @@ func (c *defaultConfigProvider) Keys() []string {
 	return keys
 }
 
-func (c *defaultConfigProvider) WalkParams(walkFn func(params ...maps.KeyParams) bool) {
+func (c *defaultConfigProvider) WalkParams(walkFn func(params ...hmaps.KeyParams) bool) {
 	maxDepth := 1000
-	var walk func(depth int, params ...maps.KeyParams)
-	walk = func(depth int, params ...maps.KeyParams) {
+	var walk func(depth int, params ...hmaps.KeyParams)
+	walk = func(depth int, params ...hmaps.KeyParams) {
 		if depth > maxDepth {
 			panic(errors.New("max depth exceeded"))
 		}
@@ -258,24 +257,24 @@ func (c *defaultConfigProvider) WalkParams(walkFn func(params ...maps.KeyParams)
 		p1 := params[len(params)-1]
 		i := len(params)
 		for k, v := range p1.Params {
-			if p2, ok := v.(maps.Params); ok {
-				paramsplus1 := make([]maps.KeyParams, i+1)
+			if p2, ok := v.(hmaps.Params); ok {
+				paramsplus1 := make([]hmaps.KeyParams, i+1)
 				copy(paramsplus1, params)
-				paramsplus1[i] = maps.KeyParams{Key: k, Params: p2}
+				paramsplus1[i] = hmaps.KeyParams{Key: k, Params: p2}
 				walk(depth+1, paramsplus1...)
 			}
 		}
 	}
-	walk(0, maps.KeyParams{Key: "", Params: c.root})
+	walk(0, hmaps.KeyParams{Key: "", Params: c.root})
 }
 
-func (c *defaultConfigProvider) determineMergeStrategy(params ...maps.KeyParams) maps.ParamsMergeStrategy {
+func (c *defaultConfigProvider) determineMergeStrategy(params ...hmaps.KeyParams) hmaps.ParamsMergeStrategy {
 	if len(params) == 0 {
-		return maps.ParamsMergeStrategyNone
+		return hmaps.ParamsMergeStrategyNone
 	}
 
 	var (
-		strategy   maps.ParamsMergeStrategy
+		strategy   hmaps.ParamsMergeStrategy
 		prevIsRoot bool
 		curr       = params[len(params)-1]
 	)
@@ -299,10 +298,10 @@ func (c *defaultConfigProvider) determineMergeStrategy(params ...maps.KeyParams)
 	// Don't set a merge strategy on the root unless set by user.
 	// This will be handled as a special case.
 	case "params":
-		strategy = maps.ParamsMergeStrategyDeep
+		strategy = hmaps.ParamsMergeStrategyDeep
 	case "outputformats", "mediatypes":
 		if prevIsRoot {
-			strategy = maps.ParamsMergeStrategyShallow
+			strategy = hmaps.ParamsMergeStrategyShallow
 		}
 	case "menus":
 		isMenuKey := prevIsRoot
@@ -314,11 +313,11 @@ func (c *defaultConfigProvider) determineMergeStrategy(params ...maps.KeyParams)
 			}
 		}
 		if isMenuKey {
-			strategy = maps.ParamsMergeStrategyShallow
+			strategy = hmaps.ParamsMergeStrategyShallow
 		}
 	default:
 		if strategy == "" {
-			strategy = maps.ParamsMergeStrategyNone
+			strategy = hmaps.ParamsMergeStrategyNone
 		}
 	}
 
@@ -326,7 +325,7 @@ func (c *defaultConfigProvider) determineMergeStrategy(params ...maps.KeyParams)
 }
 
 func (c *defaultConfigProvider) SetDefaultMergeStrategy() {
-	c.WalkParams(func(params ...maps.KeyParams) bool {
+	c.WalkParams(func(params ...hmaps.KeyParams) bool {
 		if len(params) == 0 {
 			return false
 		}
@@ -344,7 +343,7 @@ func (c *defaultConfigProvider) SetDefaultMergeStrategy() {
 	})
 }
 
-func (c *defaultConfigProvider) getNestedKeyAndMap(key string, create bool) (string, maps.Params) {
+func (c *defaultConfigProvider) getNestedKeyAndMap(key string, create bool) (string, hmaps.Params) {
 	var parts []string
 	v, ok := c.keyCache.Load(key)
 	if ok {
@@ -358,14 +357,14 @@ func (c *defaultConfigProvider) getNestedKeyAndMap(key string, create bool) (str
 		next, found := current[parts[i]]
 		if !found {
 			if create {
-				next = make(maps.Params)
+				next = make(hmaps.Params)
 				current[parts[i]] = next
 			} else {
 				return "", nil
 			}
 		}
 		var ok bool
-		current, ok = next.(maps.Params)
+		current, ok = next.(hmaps.Params)
 		if !ok {
 			// E.g. a string, not a map that we can store values in.
 			return "", nil

config/defaultConfigProvider_test.go

@@ -22,10 +22,9 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/para"
 
-	"github.com/gohugoio/hugo/common/maps"
-
 	qt "github.com/frankban/quicktest"
 )
 
@@ -48,7 +47,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 		c.Assert(cfg.Get(k), qt.Equals, v)
 		c.Assert(cfg.GetInt(k), qt.Equals, v)
 
-		c.Assert(cfg.Get(""), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get(""), qt.DeepEquals, hmaps.Params{
 			"foo": 42,
 		})
 	})
@@ -60,7 +59,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"bar": "baz",
 		})
 
-		c.Assert(cfg.Get("foo"), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get("foo"), qt.DeepEquals, hmaps.Params{
 			"bar": "baz",
 		})
 
@@ -76,14 +75,14 @@ func TestDefaultConfigProvider(t *testing.T) {
 		})
 		cfg.Set("a.c", "cv")
 
-		c.Assert(cfg.Get("a"), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get("a"), qt.DeepEquals, hmaps.Params{
 			"b": "bv",
 			"c": "cv",
 		})
 		c.Assert(cfg.Get("a.c"), qt.Equals, "cv")
 
 		cfg.Set("b.a", "av")
-		c.Assert(cfg.Get("b"), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get("b"), qt.DeepEquals, hmaps.Params{
 			"a": "av",
 		})
 
@@ -91,7 +90,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"b": "bv",
 		})
 
-		c.Assert(cfg.Get("b"), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get("b"), qt.DeepEquals, hmaps.Params{
 			"a": "av",
 			"b": "bv",
 		})
@@ -105,7 +104,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"b": "bv2",
 		})
 
-		c.Assert(cfg.Get(""), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get(""), qt.DeepEquals, hmaps.Params{
 			"a": "av2",
 			"b": "bv2",
 		})
@@ -118,7 +117,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"b": "bv2",
 		})
 
-		c.Assert(cfg.Get(""), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get(""), qt.DeepEquals, hmaps.Params{
 			"a": "av",
 			"b": "bv2",
 		})
@@ -137,7 +136,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			},
 		})
 
-		c.Assert(cfg.Get("foo"), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get("foo"), qt.DeepEquals, hmaps.Params{
 			"a": "av",
 			"b": "bv2",
 		})
@@ -155,7 +154,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"c": "cv2",
 		})
 
-		c.Assert(cfg.Get("a"), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get("a"), qt.DeepEquals, hmaps.Params{
 			"b": "bv",
 			"c": "cv2",
 		})
@@ -169,7 +168,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"b": "bv2",
 		})
 
-		c.Assert(cfg.Get(""), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get(""), qt.DeepEquals, hmaps.Params{
 			"a": "av",
 		})
 	})
@@ -192,11 +191,11 @@ func TestDefaultConfigProvider(t *testing.T) {
 			"e": "ev2",
 		})
 
-		c.Assert(cfg.Get("a"), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get("a"), qt.DeepEquals, hmaps.Params{
 			"e":      "ev2",
-			"_merge": maps.ParamsMergeStrategyShallow,
+			"_merge": hmaps.ParamsMergeStrategyShallow,
 			"b":      "bv",
-			"c": maps.Params{
+			"c": hmaps.Params{
 				"b": "bv",
 			},
 		})
@@ -221,15 +220,15 @@ func TestDefaultConfigProvider(t *testing.T) {
 				"b": left,
 			})
 
-			cfg.Merge("", maps.Params{
-				"b": maps.Params{
+			cfg.Merge("", hmaps.Params{
+				"b": hmaps.Params{
 					"c": "cv2",
 					"d": "dv2",
 				},
 			})
 
-			c.Assert(cfg.Get(""), qt.DeepEquals, maps.Params{
-				"b": maps.Params{
+			c.Assert(cfg.Get(""), qt.DeepEquals, hmaps.Params{
+				"b": hmaps.Params{
 					"c": "cv1",
 					"d": "dv2",
 				},
@@ -267,8 +266,8 @@ func TestDefaultConfigProvider(t *testing.T) {
 
 				cfg.Merge("a", right)
 
-				c.Assert(cfg.Get(""), qt.DeepEquals, maps.Params{
-					"a": maps.Params{
+				c.Assert(cfg.Get(""), qt.DeepEquals, hmaps.Params{
+					"a": hmaps.Params{
 						"b": "bv1",
 						"c": "cv2",
 					},
@@ -292,7 +291,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			},
 		})
 
-		c.Assert(cfg.Get(""), qt.DeepEquals, maps.Params{
+		c.Assert(cfg.Get(""), qt.DeepEquals, hmaps.Params{
 			"b": "bv",
 		})
 	})
@@ -341,7 +340,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 					return err
 				}
 
-				m := maps.Params{
+				m := hmaps.Params{
 					"new": 42,
 				}
 
@@ -371,8 +370,8 @@ func TestDefaultConfigProvider(t *testing.T) {
 		cfg := New()
 		k := "foo"
 
-		cfg.Set(k, maps.Params{k: true})
-		c.Assert(cfg.GetParams(k), qt.DeepEquals, maps.Params{
+		cfg.Set(k, hmaps.Params{k: true})
+		c.Assert(cfg.GetParams(k), qt.DeepEquals, hmaps.Params{
 			k: true,
 		})
 
@@ -384,8 +383,8 @@ func TestDefaultConfigProvider(t *testing.T) {
 		k := "foo"
 		k2 := "bar"
 
-		cfg.Set(k, maps.Params{k: struct{}{}})
-		cfg.Set(k2, maps.Params{k2: struct{}{}})
+		cfg.Set(k, hmaps.Params{k: struct{}{}})
+		cfg.Set(k2, hmaps.Params{k2: struct{}{}})
 
 		c.Assert(len(cfg.Keys()), qt.Equals, 2)
 
@@ -401,11 +400,11 @@ func TestDefaultConfigProvider(t *testing.T) {
 	c.Run("WalkParams", func(c *qt.C) {
 		cfg := New()
 
-		cfg.Set("x", maps.Params{})
-		cfg.Set("y", maps.Params{})
+		cfg.Set("x", hmaps.Params{})
+		cfg.Set("y", hmaps.Params{})
 
 		var got []string
-		cfg.WalkParams(func(params ...maps.KeyParams) bool {
+		cfg.WalkParams(func(params ...hmaps.KeyParams) bool {
 			got = append(got, params[len(params)-1].Key)
 			return false
 		})
@@ -417,7 +416,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 		c.Assert(got, qt.DeepEquals, want)
 
 		cfg = New()
-		cfg.WalkParams(func(params ...maps.KeyParams) bool {
+		cfg.WalkParams(func(params ...hmaps.KeyParams) bool {
 			return true
 		})
 
@@ -429,7 +428,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 	c.Run("SetDefaults", func(c *qt.C) {
 		cfg := New()
 
-		cfg.SetDefaults(maps.Params{
+		cfg.SetDefaults(hmaps.Params{
 			"foo": "bar",
 			"bar": "baz",
 		})

config/namespace_test.go

@@ -18,7 +18,7 @@ import (
 	"testing"
 
 	qt "github.com/frankban/quicktest"
-	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/mitchellh/mapstructure"
 )
 
@@ -32,7 +32,7 @@ func TestNamespace(t *testing.T) {
 		map[string]any{"foo": "bar"},
 		func(v any) (*tstNsExt, any, error) {
 			t := &tstNsExt{}
-			m, err := maps.ToStringMapE(v)
+			m, err := hmaps.ToStringMapE(v)
 			if err != nil {
 				return nil, nil, err
 			}

config/testconfig/testconfig.go

@@ -17,7 +17,7 @@ package testconfig
 import (
 	_ "unsafe"
 
-	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/deps"
@@ -84,7 +84,7 @@ func GetTestConfigSectionFromStruct(section string, v any) config.AllProvider {
 	if err != nil {
 		panic(err)
 	}
-	p := maps.Params{
+	p := hmaps.Params{
 		section: config.FromTOMLConfigString(string(data)).Get(""),
 	}
 	cfg := config.NewFrom(p)

create/content.go

@@ -36,7 +36,7 @@ import (
 )
 
 const (
-	// DefaultArchetypeTemplateTemplate is the template used in 'hugo new site'
+	// DefaultArchetypeTemplateTemplate is the template used in 'hugo new project'
 	// and the template we use as a fall back.
 	DefaultArchetypeTemplateTemplate = `---
 title: "{{ replace .File.ContentBaseName "-" " " | title }}"

create/skeletons/skeletons.go

@@ -27,8 +27,8 @@ import (
 	"github.com/spf13/afero"
 )
 
-//go:embed all:site/*
-var siteFs embed.FS
+//go:embed all:project/*
+var projectFs embed.FS
 
 //go:embed all:theme/*
 var themeFs embed.FS
@@ -41,10 +41,10 @@ func CreateTheme(createpath string, sourceFs afero.Fs, format string) error {
 
 	format = strings.ToLower(format)
 
-	siteConfig := map[string]any{
+	projectConfig := map[string]any{
 		"baseURL":      "https://example.org/",
 		"languageCode": "en-US",
-		"title":        "My New Hugo Site",
+		"title":        "My New Hugo Project",
 		"menus": map[string]any{
 			"main": []any{
 				map[string]any{
@@ -72,7 +72,7 @@ func CreateTheme(createpath string, sourceFs afero.Fs, format string) error {
 		},
 	}
 
-	err := createSiteConfig(sourceFs, createpath, siteConfig, format)
+	err := createProjectConfig(sourceFs, createpath, projectConfig, format)
 	if err != nil {
 		return err
 	}
@@ -91,8 +91,8 @@ func CreateTheme(createpath string, sourceFs afero.Fs, format string) error {
 	return copyFiles(createpath, sourceFs, themeFs)
 }
 
-// CreateSite creates a site skeleton.
-func CreateSite(createpath string, sourceFs afero.Fs, force bool, format string) error {
+// CreateProject creates a project skeleton.
+func CreateProject(createpath string, sourceFs afero.Fs, force bool, format string) error {
 	format = strings.ToLower(format)
 	if exists, _ := helpers.Exists(createpath, sourceFs); exists {
 		if isDir, _ := helpers.IsDir(createpath, sourceFs); !isDir {
@@ -106,7 +106,7 @@ func CreateSite(createpath string, sourceFs afero.Fs, force bool, format string)
 			return errors.New(createpath + " already exists and is not empty. See --force.")
 		case !isEmpty && force:
 			var all []string
-			fs.WalkDir(siteFs, ".", func(path string, d fs.DirEntry, err error) error {
+			fs.WalkDir(projectFs, ".", func(path string, d fs.DirEntry, err error) error {
 				if d.IsDir() && path != "." {
 					all = append(all, path)
 				}
@@ -121,13 +121,13 @@ func CreateSite(createpath string, sourceFs afero.Fs, force bool, format string)
 		}
 	}
 
-	siteConfig := map[string]any{
+	projectConfig := map[string]any{
 		"baseURL":      "https://example.org/",
-		"title":        "My New Hugo Site",
+		"title":        "My New Hugo Project",
 		"languageCode": "en-us",
 	}
 
-	err := createSiteConfig(sourceFs, createpath, siteConfig, format)
+	err := createProjectConfig(sourceFs, createpath, projectConfig, format)
 	if err != nil {
 		return err
 	}
@@ -143,7 +143,7 @@ func CreateSite(createpath string, sourceFs afero.Fs, force bool, format string)
 		return err
 	}
 
-	return copyFiles(createpath, sourceFs, siteFs)
+	return copyFiles(createpath, sourceFs, projectFs)
 }
 
 func copyFiles(createpath string, sourceFs afero.Fs, skeleton embed.FS) error {
@@ -161,7 +161,7 @@ func copyFiles(createpath string, sourceFs afero.Fs, skeleton embed.FS) error {
 	})
 }
 
-func createSiteConfig(fs afero.Fs, createpath string, in map[string]any, format string) (err error) {
+func createProjectConfig(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 {

deps/deps.go

@@ -28,8 +28,8 @@ import (
 	"github.com/gohugoio/hugo/cache/dynacache"
 	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/common/hexec"
+	"github.com/gohugoio/hugo/common/hmaps"
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/allconfig"
@@ -173,8 +173,8 @@ func (d *Deps) Init() error {
 			d.BuildState.DeferredExecutionsGroupedByRenderingContext = make(map[tpl.RenderingContext]*DeferredExecutions)
 		}
 		d.BuildState.DeferredExecutions = &DeferredExecutions{
-			Executions:              maps.NewCache[string, *tpl.DeferredExecution](),
-			FilenamesWithPostPrefix: maps.NewCache[string, bool](),
+			Executions:              hmaps.NewCache[string, *tpl.DeferredExecution](),
+			FilenamesWithPostPrefix: hmaps.NewCache[string, bool](),
 		}
 	}
 
@@ -260,10 +260,10 @@ func (d *Deps) Init() error {
 		common = d.ResourceSpec.SpecCommon
 	}
 
-	fileCaches, err := filecache.NewCaches(d.PathSpec)
-	if err != nil {
-		return fmt.Errorf("failed to create file caches from configuration: %w", err)
-	}
+	d.Cfg.BaseConfig()
+
+	fileCaches := d.Cfg.FileCaches().(filecache.Caches)
+	fileCaches.SetResourceFs(d.BaseFs.ResourcesCache)
 
 	resourceSpec, err := resources.NewSpec(d.PathSpec, common, d.WasmDispatchers, fileCaches, d.MemCache, d.BuildState, d.Log, d, d.ExecHelper, d.BuildClosers, d.BuildState)
 	if err != nil {
@@ -464,10 +464,10 @@ type Counters struct {
 type DeferredExecutions struct {
 	// A set of filenames in /public that
 	// contains a post-processing prefix.
-	FilenamesWithPostPrefix *maps.Cache[string, bool]
+	FilenamesWithPostPrefix *hmaps.Cache[string, bool]
 
 	// Maps a placeholder to a deferred execution.
-	Executions *maps.Cache[string, *tpl.DeferredExecution]
+	Executions *hmaps.Cache[string, *tpl.DeferredExecution]
 }
 
 var _ identity.SignalRebuilder = (*BuildState)(nil)
@@ -480,8 +480,8 @@ func (b *BuildState) StartStageRender(stage tpl.RenderingContext) {
 func (b *BuildState) StopStageRender(stage tpl.RenderingContext) {
 	b.DeferredExecutionsGroupedByRenderingContext[stage] = b.DeferredExecutions
 	b.DeferredExecutions = &DeferredExecutions{
-		Executions:              maps.NewCache[string, *tpl.DeferredExecution](),
-		FilenamesWithPostPrefix: maps.NewCache[string, bool](),
+		Executions:              hmaps.NewCache[string, *tpl.DeferredExecution](),
+		FilenamesWithPostPrefix: hmaps.NewCache[string, bool](),
 	}
 }
 

docs/.codespellrc

@@ -4,7 +4,7 @@
 [codespell]
 
 # Comma separated list of dirs to be skipped.
-skip = *.ai,chroma.css,chroma_dark.css,.cspell.json
+skip = *.ai,chroma.css,chroma_dark.css,.cspell.json,./data/docs.yaml
 
 # Comma separated list of words to be ignored. Words must be lowercased.
 ignore-words-list = abl,edn,januar,te,trys,ue,womens

docs/.cspell.json

@@ -23,8 +23,7 @@
     "**/emojis.md",
     "**/commands/*",
     "**/showcase/*",
-    "**/tools/*",
-    "data/docs.yaml"
+    "**/tools/*"
   ],
   "ignoreRegExpList": [
     "# cspell: ignore fenced code blocks",
@@ -182,6 +181,7 @@
     "dring",
     "fleqn",
     "inor",
+    "iptc",
     "jausten",
     "jdoe",
     "jsmith",

docs/.gitignore

@@ -1,5 +1,6 @@
 .DS_Store
 .hugo_build.lock
+.hvm
 /.idea
 /.vscode
 /dist

docs/.markdownlint-cli2.yaml

@@ -80,7 +80,7 @@ config:
     url_inline: false
   MD055:
     style: consistent
-  MD056: true
+  MD056: false # interferes with Markdown attributes
   # MD057 deprecated
   MD058: true
   MD059:
@@ -89,3 +89,6 @@ config:
       - here
       - link
       - more
+  MD060:
+    aligned_delimiter: false
+    style: any

docs/AGENTS.md

@@ -0,0 +1,25 @@
+## Theme
+
+### Role
+You are an expert front-end and Tailwind CSS developer. Your primary goal is to build reliable, readable, and scalable user interfaces using the existing project structure and design system.
+
+### Directives
+*   **ALWAYS** use existing Tailwind utility classes for styling.
+*   **NEVER** write raw CSS in `.css` files unless absolutely necessary for a non-utility-based global reset.
+*   **NEVER** use inline styles (e.g., `<div style="...">`).
+
+### Project Knowledge
+
+*  **Tech Stack:** Hugo (static site generator), AlpineJS, Tailwind CSS. Icons from https://heroicons.com/.
+*  **Core Files and Directories:**
+   - `hugo.toml`: Hugo configuration file.
+   - `assets/css/styles.css`: Main CSS file with Tailwind directives.
+   - `assets/js/main.js`: Main JavaScript with AlpineJS configuration.
+   - `package.json`: Project dependencies and scripts.
+   - `content/`: Directory for markdown content files.
+   - `layouts/`: Directory for Hugo templates and partials.
+   - `layouts/_partials/icons.html`: SVG icon sprites.
+
+
+
+

docs/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

docs/README.md

@@ -23,5 +23,3 @@ Please see the [contributing] section for guidelines, examples, and process.
 npm i
 hugo server
 ```
-
-**Note:** We're working on removing the need to run `npm i` for local development. Stay tuned.

docs/assets/css/components/all.css

@@ -5,3 +5,4 @@
 @import "./shortcodes.css";
 @import "./tableofcontents.css";
 @import "./view-transitions.css";
+@import "./todo-lists.css";

docs/assets/css/components/todo-lists.css

@@ -0,0 +1,15 @@
+ul.todo {
+  padding-left: 0;
+}
+
+ul.todo li {
+  display: flex;
+  gap: 0.8em;
+}
+
+ul.todo li input[type="checkbox"] {
+  width: 1em;
+  height: 1em;
+  flex-shrink: 0;
+  margin-top: 0.3em;
+}

docs/assets/css/styles.css

@@ -77,8 +77,9 @@
 
   /* Fonts. */
   --font-sans:
-    "Mulish", ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji",
-    "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+    "Mulish", -apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans",
+    Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji",
+    "Segoe UI Symbol", "Noto Color Emoji";
 }
 
 html {
@@ -104,14 +105,14 @@ body {
   padding-right: max(env(safe-area-inset-right), 1rem);
 }
 
-@media screen(md) {
+@media (min-width: theme('--breakpoint-md')) {
   .px-main {
     padding-left: max(env(safe-area-inset-left), 2rem);
     padding-right: max(env(safe-area-inset-right), 2rem);
   }
 }
 
-@media screen(lg) {
+@media (min-width: theme('--breakpoint-lg')) {
   .px-main {
     padding-left: max(env(safe-area-inset-left), 3rem);
     padding-right: max(env(safe-area-inset-right), 3rem);
@@ -134,3 +135,9 @@ body {
 :not(pre) > code {
   white-space: nowrap;
 }
+
+/* Utility class for tables to prevent word wrapping in the first column. */
+.no-wrap-first-col td:first-child,
+.no-wrap-first-col th:first-child {
+  white-space: nowrap;
+}

docs/assets/js/alpinejs/stores/nav.js

@@ -31,6 +31,16 @@ export const navStore = (Alpine) => ({
 		atTop: true,
 	},
 
+	mobileMenu: {
+		open: false,
+		toggle() {
+			this.open = !this.open;
+		},
+		close() {
+			this.open = false;
+		},
+	},
+
 	userSettings: {
 		// settings gets persisted between page navigations.
 		settings: Alpine.$persist({

docs/content/en/_common/functions/hugo/sites-collection.md

@@ -0,0 +1,9 @@
+---
+_comment: Do not remove front matter.
+---
+
+The returned collection follows a hierarchical sort where each subsequent dimension acts as a tie-breaker for the one above it.
+
+1. [Language](g) is sorted by [weight](g) in ascending order, falling back to lexicographical order if weights are tied or undefined.
+1. [Version](g) is then sorted by weight in ascending order, with Hugo defaulting to a descending semantic sort for any ties.
+1. [Role](g) is finally sorted by weight in ascending order, using lexicographical order as the final fallback.

docs/content/en/_common/functions/js/options.md

@@ -84,11 +84,9 @@ sourcesContent
 : (`bool`) Whether to include the content of the source files in the source map. By default, this is `true`.
 
 JSX
-: {{< new-in 0.124.0 />}}
 : (`string`) How to handle/transform JSX syntax. One of: `transform`, `preserve`, `automatic`. Default is `transform`. Notably, the `automatic` transform was introduced in React 17+ and will cause the necessary JSX helper functions to be imported automatically. See <https://esbuild.github.io/api/#jsx>.
 
 JSXImportSource
-: {{< new-in 0.124.0 />}}
 : (`string`) Which library to use to automatically import its JSX helper functions from. This only works if `JSX` is set to `automatic`. The specified library needs to be installed through npm and expose certain exports. See <https://esbuild.github.io/api/#jsx-import-source>.
 
   The combination of `JSX` and `JSXImportSource` is helpful if you want to use a non-React JSX library like Preact, e.g.:

docs/content/en/_common/installation/01-editions.md

@@ -2,15 +2,17 @@
 _comment: Do not remove front matter.
 ---
 
-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.
+## Editions
+
+Hugo offers a standard edition with core features, plus extended and extended/deploy editions with more. Use the standard edition unless you need the features below.
+
+<!-- TODO Remove the transpiler row somewhere around v0.166.0 -->
 
 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:
+[Transpile Sass to CSS] via embedded LibSass. Note that embedded LibSass was deprecated in v0.153.0 and will be removed in a future release. Use the [Dart Sass] transpiler instead, which is compatible with any edition.|: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]: /functions/css/sass/#dart-sass
-[processing images]: /content-management/image-processing/
 [transpile sass to css]: /functions/css/sass/
 [details]: /host-and-deploy/deploy-with-hugo-deploy/

docs/content/en/_common/installation/02-prerequisites.md

@@ -12,7 +12,7 @@ Git is required to:
 - Use the [Hugo Modules] feature
 - Install a theme as a Git submodule
 - Access [commit information] from a local Git repository
-- Host your site with services such as [CloudCannon], [Cloudflare Pages], [GitHub Pages], [GitLab Pages], and [Netlify]
+- Host your site on [CI/CD](g) platforms such as [Cloudflare][], [GitHub Pages][], [GitLab Pages][], [Netlify][], [Render][], or [Vercel][]
 
 Go is required to:
 
@@ -27,16 +27,17 @@ Please refer to the relevant documentation for installation instructions:
 - [Go][go install]
 - [Dart Sass][dart sass install]
 
-[cloudcannon]: https://cloudcannon.com/
-[cloudflare pages]: https://pages.cloudflare.com/
+[Cloudflare]: /host-and-deploy/host-on-cloudflare/
 [commit information]: /methods/page/GitInfo
 [dart sass install]: /functions/css/sass/#dart-sass
 [dart sass]: https://sass-lang.com/dart-sass
 [git install]: https://git-scm.com/book/en/v2/Getting-Started-Installing-Git
 [git]: https://git-scm.com/
-[github pages]: https://pages.github.com/
-[gitlab pages]: https://docs.gitlab.com/ee/user/project/pages/
+[GitHub Pages]: /host-and-deploy/host-on-github-pages/
+[GitLab Pages]: /host-and-deploy/host-on-gitlab-pages/
 [go install]: https://go.dev/doc/install
 [go]: https://go.dev/
 [hugo modules]: /hugo-modules/
-[netlify]: https://www.netlify.com/
+[Netlify]: /host-and-deploy/host-on-netlify/
+[Render]: /host-and-deploy/host-on-render/
+[Vercel]: /host-and-deploy/host-on-vercel/

docs/content/en/_common/menu-entries/pre-and-post.md

@@ -2,7 +2,7 @@
 _comment: Do not remove front matter.
 ---
 
-In this site configuration we enable rendering of [emoji shortcodes], and add emoji shortcodes before (pre) and after (post) each menu entry:
+In this project configuration we enable rendering of [emoji shortcodes], and add emoji shortcodes before (pre) and after (post) each menu entry:
 
 {{< code-toggle file=hugo >}}
 enableEmoji = true

docs/content/en/_common/methods/output-formats/to-use-this-method.md

@@ -0,0 +1,9 @@
+---
+_comment: Do not remove front matter.
+---
+
+To use this method you must first select a specific [output format](g) from a page's [`OutputFormats`][] collection using the [`Get`][] or [`Canonical`][] methods.
+
+[`Canonical`]: /methods/page/outputformats/#canonical
+[`Get`]: /methods/page/outputformats/#get
+[`OutputFormats`]: /methods/page/outputformats/

docs/content/en/_common/methods/page/next-and-prev.md

@@ -53,8 +53,8 @@ When you visit page-2:
 - The `Prev` method points to page-3
 - The `Next` method points to page-1
 
-To reverse the meaning of _next_ and _previous_ you can change the sort direction in your [site configuration], or use the [`Next`] and [`Prev`] methods on a `Pages` object for more flexibility.
+To reverse the meaning of _next_ and _previous_ you can change the sort direction in your [project configuration], or use the [`Next`] and [`Prev`] methods on a `Pages` object for more flexibility.
 
-[site configuration]: /configuration/page/
+[project configuration]: /configuration/page/
 [`Next`]: /methods/pages/prev
 [`Prev`]: /methods/pages/prev

docs/content/en/_common/methods/page/nextinsection-and-previnsection.md

@@ -53,9 +53,9 @@ When you visit page-2:
 - The `PrevInSection` method points to page-3
 - The `NextInSection` method points to page-1
 
-To reverse the meaning of _next_ and _previous_ you can change the sort direction in your [site configuration], or use the [`Next`] and [`Prev`] methods on a `Pages` object for more flexibility.
+To reverse the meaning of _next_ and _previous_ you can change the sort direction in your [project configuration], or use the [`Next`] and [`Prev`] methods on a `Pages` object for more flexibility.
 
-[site configuration]: /configuration/page/
+[project configuration]: /configuration/page/
 [`Next`]: /methods/pages/prev
 [`Prev`]: /methods/pages/prev
 

docs/content/en/_common/methods/page/output-format-methods.md

@@ -1,35 +0,0 @@
----
-_comment: Do not remove front matter.
----
-
-### Get IDENTIFIER
-
-(`any`) Returns the `OutputFormat` object with the given identifier.
-
-### MediaType
-
-(`media.Type`) Returns the media type of the output format.
-
-### MediaType.MainType
-
-(`string`) Returns the main type of the output format's media type.
-
-### MediaType.SubType
-
-(`string`) Returns the subtype of the current format's media type.
-
-### Name
-
-(`string`) Returns the output identifier of the output format.
-
-### Permalink
-
-(`string`) Returns the permalink of the page generated by the current output format.
-
-### Rel
-
-(`string`) Returns the `rel` value of the output format, either the default or as defined in the site configuration.
-
-### RelPermalink
-
-(`string`) Returns the relative permalink of the page generated by the current output format.

docs/content/en/_common/methods/resource/processing-spec.md

@@ -2,35 +2,72 @@
 _comment: Do not remove front matter.
 ---
 
-## Process specification
+## Processing specification
 
-The process specification is a space-delimited, case-insensitive list of one or more of the following in any sequence:
+The processing specification is a space-delimited, case-insensitive list containing one or more of the following options in any sequence:
 
 action
-: Applicable to the [`Process`](/methods/resource/process) method only. Specify zero or one of `crop`, `fill`, `fit`, or `resize`. If you specify an action you must also provide dimensions.
-
-dimensions
-: Provide width _or_ height when using the [`Resize`](/methods/resource/resize) method, else provide both width _and_ height. See [details](/content-management/image-processing/#dimensions).
+: Specify one of `crop`, `fill`, `fit`, or `resize`. This is applicable to the [`Process`][] method and the [`images.Process`][] filter. If you specify an action, you must also provide dimensions.
 
 anchor
-: Use with the [`Crop`](/methods/resource/crop) and [`Fill`](/methods/resource/fill) methods. Specify zero or one of `TopLeft`, `Top`, `TopRight`, `Left`, `Center`, `Right`, `BottomLeft`, `Bottom`, `BottomRight`, or `Smart`. Default is `Smart`. See [details](/content-management/image-processing/#anchor).
-
-rotation
-: Typically specify zero or one of `r90`, `r180`, or `r270`. Also supports arbitrary rotation angles. See [details](/content-management/image-processing/#rotation).
-
-target format
-: Specify zero or one of `gif`, `jpeg`, `png`, `tiff`, or `webp`. See [details](/content-management/image-processing/#target-format).
-
-quality
-: Applicable to JPEG and WebP images. Optionally specify `qN` where `N` is an integer in the range [0, 100]. Default is `75`. See [details](/content-management/image-processing/#quality).
-
-hint
-: Applicable to WebP images and equivalent to the `-preset` flag for the [`cwebp`] encoder. Specify zero or one of `drawing`, `icon`, `photo`, `picture`, or `text`. Default is `photo`. See [details](/content-management/image-processing/#hint).
-
-[`cwebp`]: https://developers.google.com/speed/webp/docs/cwebp
+: The focal point used when cropping or filling an image. Valid options include `TopLeft`, `Top`, `TopRight`, `Left`, `Center`, `Right`, `BottomLeft`, `Bottom`, `BottomRight`, or `Smart`. The `Smart` option utilizes the [`smartcrop.js`][] library to identify the most interesting area of the image. This defaults to the [`anchor`][] parameter in your project configuration.
 
 background color
-: When converting a PNG or WebP with transparency to a format that does not support transparency, optionally specify a background color using a 3-digit or a 6-digit hexadecimal color code. Default is `#ffffff` (white). See [details](/content-management/image-processing/#background-color).
+: The background color used when converting transparent images to formats that do not support transparency, such as PNG to JPEG. This color also fills the empty space created when rotating an image by a non-orthogonal angle if the space is not transparent and a background color is not specified in the  processing specification. The value must be an RGB [hexadecimal color][]. This defaults to the [`bgColor`][] parameter in your project configuration.
+
+compression
+: {{< new-in 0.153.5 />}}
+: The encoding strategy used for the image. Options are `lossy` or `lossless`. Note that `lossless` is only supported by the WebP format. This defaults to the [`compression`][] parameter in your project configuration.
+
+dimensions
+: The dimensions of the resulting image, in pixels. The format is `WIDTHxHEIGHT` where `WIDTH` and `HEIGHT` are whole numbers. When resizing an image, you may specify only the width (such as `600x`) or only the height (such as `x400`) for proportional scaling. Specifying both width and height when resizing an image may result in non-proportional scaling. When cropping, fitting, or filling, you must provide both width and height such as `600x400`.
+
+format
+: The format of the resulting image. Valid options include `bmp`, `gif`, `jpeg`, `png`, `tiff`, or `webp`. This defaults to the format of the source image.
+
+hint
+: The encoding preset used when processing WebP images, equivalent to the `-preset` flag for the [`cwebp`][] CLI. Valid options include `drawing`, `icon`, `photo`, `picture`, or `text`. This defaults to the [`hint`][] parameter in your project configuration.
+
+  Value|Example
+  :--|:--
+  `drawing`|Hand or line drawing with high-contrast details
+  `icon`|Small colorful image
+  `photo`|Outdoor photograph with natural lighting
+  `picture`|Indoor photograph such as a portrait
+  `text`|Image that is primarily text
+
+quality
+: The visual fidelity of the image, applicable to JPEG and WebP formats when using `lossy` compression. The format is `qQUALITY` where `QUALITY` is a whole number between `1` and `100`, inclusive. Lower numbers prioritize smaller file size, while higher numbers prioritize visual clarity. This defaults to the [`quality`][] parameter in your project configuration.
 
 resampling filter
-: Typically specify zero or one of `Box`, `Lanczos`, `CatmullRom`, `MitchellNetravali`, `Linear`, or `NearestNeighbor`. Other resampling filters are available. See&nbsp;[details](/content-management/image-processing/#resampling-filter).
+: The algorithm used to calculate new pixels when resizing, fitting, or filling an image. Common options include `box`, `lanczos`, `catmullRom`, `mitchellNetravali`, `linear`, or `nearestNeighbor`. This defaults to the [`resampleFilter`][] parameter in your project configuration.
+
+  Filter|Description
+  :--|:--
+  `box`|Simple and fast averaging filter appropriate for downscaling
+  `lanczos`|High-quality resampling filter for photographic images yielding sharp results
+  `catmullRom`|Sharp cubic filter that is faster than the Lanczos filter while providing similar results
+  `mitchellNetravali`|Cubic filter that produces smoother results with less ringing artifacts than CatmullRom
+  `linear`|Bilinear resampling filter, produces smooth output, faster than cubic filters
+  `nearestNeighbor`|Fastest resampling filter, no antialiasing
+
+  Refer to the [source documentation][] for a complete list of available resampling filters. If you wish to improve image quality at the expense of performance, you may wish to experiment with the alternative filters.
+
+rotation
+: The number of whole degrees to rotate an image counter-clockwise. The format is `rDEGREES` where `DEGREES` is a whole number. Hugo performs rotation before any other transformations, so your [target dimensions](#dimensions) and any [anchor](#anchor) should refer to the image orientation after rotation. Use `r90`, `r180`, or `r270` for orthogonal rotations, or arbitrary angles such as `r45`. To rotate clockwise, use a negative number such as `r-45`. To automatically rotate an image based on its Exif orientation tag, use the [`images.AutoOrient`][] filter instead of manual rotation.
+
+  Rotating by non-orthogonal values increases the image extents to fit the rotated corners. For formats supporting alpha channels such as PNG or WebP, this resulting empty space is transparent by default. If the target format does not support transparency such as JPEG, or if you explicitly specify a [background color](#background-color) in the processing specification, the space is filled. If a color is required but not specified in the processing string, it defaults to the [`bgColor`][] parameter in your project configuration.
+
+[`anchor`]: /configuration/imaging/#anchor
+[`bgcolor`]: /configuration/imaging/#bgcolor
+[`compression`]: /configuration/imaging/#compression
+[`cwebp`]: https://developers.google.com/speed/webp/docs/cwebp
+[`hint`]: /configuration/imaging/#hint
+[`images.AutoOrient`]: /functions/images/autoorient/
+[`images.Process`]: /functions/images/process/
+[`Process`]: /methods/resource/process
+[`quality`]: /configuration/imaging/#quality
+[`resampleFilter`]: /configuration/imaging/#resamplefilter
+[`smartcrop.js`]: https://github.com/jwagner/smartcrop.js
+[hexadecimal color]: https://developer.mozilla.org/en-US/docs/Web/CSS/hex-color
+[source documentation]: https://github.com/disintegration/imaging#image-resizing