releaser: Prepare repository for 0.153.0-DEV

[ci skip]

.circleci/config.yml

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

.github/workflows/image.yml

@@ -46,3 +46,4 @@ jobs:
           platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          build-args: HUGO_BUILD_TAGS=extended,withdeploy

.github/workflows/stale.yml

@@ -43,7 +43,7 @@ jobs:
           stale-pr-message: This PR has been automatically marked as stale because it has not had
             recent activity. The resources of the Hugo team are limited, and so we are asking for your help.
 
-            Please check https://github.com/gohugoio/hugo/blob/master/CONTRIBUTING.md#code-contribution and verify that this code contribution fits with the description. If yes, tell is in a comment.
+            Please check https://github.com/gohugoio/hugo/blob/master/CONTRIBUTING.md#code-contribution and verify that this code contribution fits with the description. If yes, tell us in a comment.
 
             This PR will automatically be closed in the near future if no further activity occurs. Thank you for all your contributions.
           stale-issue-label: 'Stale'

.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.23.x, 1.24.x]
+        go-version: [1.24.x, 1.25.x]
         os: [ubuntu-latest, windows-latest] # macos disabled for now because of disk space issues.
     runs-on: ${{ matrix.os }}
     steps:
@@ -45,7 +45,7 @@ jobs:
             **/go.sum
             **/go.mod
       - name: Install Ruby
-        uses: ruby/setup-ruby@a6e6f86333f0a2523ece813039b8b4be04560854 # v1.190.0
+        uses: ruby/setup-ruby@44511735964dcb71245e7e55f72539531f7bc0eb # v1.257.0
         with:
           ruby-version: "2.7"
           bundler-cache: true #

CONTRIBUTING.md

@@ -1,4 +1,4 @@
->**Note:** We would apprecitate if you hold on with any big refactorings (like renaming deprecated Go packages), mainly because of potential for extra merge work for future coming in in the near future.
+>**Note:** We would appreciate if you hold on with any big refactoring (like renaming deprecated Go packages), mainly because of potential for extra merge work for future coming in in the near future.
 
 # Contributing to Hugo
 

Dockerfile

@@ -2,8 +2,8 @@
 # Twitter:      https://twitter.com/gohugoio
 # Website:      https://gohugo.io/
 
-ARG GO_VERSION="1.23.2"
-ARG ALPINE_VERSION="3.20"
+ARG GO_VERSION="1.25"
+ARG ALPINE_VERSION="3.22"
 ARG DART_SASS_VERSION="1.79.3"
 
 FROM --platform=$BUILDPLATFORM tonistiigi/xx:1.5.0 AS xx
@@ -19,7 +19,7 @@ RUN apk add clang lld
 COPY --from=xx / /
 
 ARG TARGETPLATFORM
-RUN xx-apk add musl-dev gcc g++ 
+RUN xx-apk add musl-dev gcc g++
 
 # Optionally set HUGO_BUILD_TAGS to "none" or "withdeploy" when building like so:
 # docker build --build-arg HUGO_BUILD_TAGS=withdeploy .
@@ -72,7 +72,7 @@ RUN mkdir -p /var/hugo/bin /cache && \
     adduser -Sg hugo -u 1000 -h /var/hugo hugo && \
     chown -R hugo: /var/hugo /cache && \
     # For the Hugo's Git integration to work.
-    runuser -u hugo -- git config --global --add safe.directory /project && \ 
+    runuser -u hugo -- git config --global --add safe.directory /project && \
     # See https://github.com/gohugoio/hugo/issues/9810
     runuser -u hugo -- git config --global core.quotepath false
 

README.md

@@ -65,9 +65,11 @@ See the [features] section of the documentation for a comprehensive summary of H
 
 <p>&nbsp;</p>
 <p float="left">
-  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></a>
+  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></a>
 &nbsp;&nbsp;&nbsp;
-  <a href="https://www.jetbrains.com/go/?utm_source=OSS&utm_medium=referral&utm_campaign=hugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/goland.svg" width="200" alt="The complete IDE crafted for professional Go developers."></a>
+  <a href="https://www.jetbrains.com/go/?utm_source=OSS&utm_medium=referral&utm_campaign=hugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/goland.svg" width="200" alt="The complete IDE crafted for professional Go developers."></a>
+  &nbsp;&nbsp;&nbsp;
+    <a href="https://cloudcannon.com/hugo-cms/?utm_campaign=HugoSponsorship&utm_source=sponsor&utm_content=gohugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/hugoDocs/master/assets/images/sponsors/cloudcannon-cms-logo.svg" width="200" alt="CloudCannon"></a>
 </p>
 
 ## Editions
@@ -80,10 +82,10 @@ Encode to the WebP format when [processing images]. You can decode WebP images w
 [Transpile Sass to CSS] using the embedded LibSass transpiler. You can use the [Dart Sass] transpiler with any edition.|:heavy_check_mark:|:heavy_check_mark:
 Deploy your site directly to a Google Cloud Storage bucket, an AWS S3 bucket, or an Azure Storage container. See&nbsp;[details].|:x:|:heavy_check_mark:
 
-[dart sass]: /functions/css/sass/#dart-sass
-[processing images]: /content-management/image-processing/
-[transpile sass to css]: /functions/css/sass/
-[details]: /hosting-and-deployment/hugo-deploy/
+[dart sass]: https://gohugo.io/functions/css/sass/#dart-sass
+[processing images]: https://gohugo.io/content-management/image-processing/
+[transpile sass to css]: https://gohugo.io/functions/css/sass/
+[details]: https://gohugo.io/hosting-and-deployment/hugo-deploy/
 
 Unless your specific deployment needs require the extended/deploy edition, we recommend the extended edition.
 
@@ -100,9 +102,9 @@ Install Hugo from a [prebuilt binary], package manager, or package repository. P
 
 Prerequisites to build Hugo from source:
 
-- Standard edition: Go 1.23.0 or later
-- Extended edition: Go 1.23.0 or later, and GCC
-- Extended/deploy edition: Go 1.23.0 or later, and GCC
+- Standard edition: Go 1.24.0 or later
+- Extended edition: Go 1.24.0 or later, and GCC
+- Extended/deploy edition: Go 1.24.0 or later, and GCC
 
 Build the standard edition:
 
@@ -189,7 +191,6 @@ github.com/bep/simplecobra="v0.5.0"
 github.com/bep/tmc="v0.5.1"
 github.com/cespare/xxhash/v2="v2.3.0"
 github.com/clbanning/mxj/v2="v2.7.0"
-github.com/cli/safeexec="v1.0.1"
 github.com/cpuguy83/go-md2man/v2="v2.0.4"
 github.com/disintegration/gift="v1.2.1"
 github.com/dlclark/regexp2="v1.11.5"

cache/dynacache/dynacache_test.go

@@ -191,16 +191,16 @@ func TestPanicInCreate(t *testing.T) {
 		return err
 	}
 
-	for i := 0; i < 3; i++ {
-		for j := 0; j < 3; j++ {
+	for i := range 3 {
+		for range 3 {
 			c.Assert(willPanic(i), qt.PanicMatches, fmt.Sprintf("panic-%d", i))
 			c.Assert(willErr(i), qt.ErrorMatches, fmt.Sprintf("error-%d", i))
 		}
 	}
 
 	// Test the same keys again without the panic.
-	for i := 0; i < 3; i++ {
-		for j := 0; j < 3; j++ {
+	for i := range 3 {
+		for range 3 {
 			v, err := p1.GetOrCreate(fmt.Sprintf("panic-%d", i), func(key string) (testItem, error) {
 				return testItem{
 					name: key,

cache/filecache/filecache_pruner_test.go

@@ -59,7 +59,7 @@ dir = ":resourceDir/_gen"
 		caches, err := filecache.NewCaches(p)
 		c.Assert(err, qt.IsNil)
 		cache := caches[name]
-		for i := 0; i < 10; i++ {
+		for i := range 10 {
 			id := fmt.Sprintf("i%d", i)
 			cache.GetOrCreateBytes(id, func() ([]byte, error) {
 				return []byte("abc"), nil
@@ -74,7 +74,7 @@ dir = ":resourceDir/_gen"
 		c.Assert(err, qt.IsNil)
 		c.Assert(count, qt.Equals, 5, msg)
 
-		for i := 0; i < 10; i++ {
+		for i := range 10 {
 			id := fmt.Sprintf("i%d", i)
 			v := cache.GetString(id)
 			if i < 5 {
@@ -97,7 +97,7 @@ dir = ":resourceDir/_gen"
 		c.Assert(count, qt.Equals, 4)
 
 		// Now only the i5 should be left.
-		for i := 0; i < 10; i++ {
+		for i := range 10 {
 			id := fmt.Sprintf("i%d", i)
 			v := cache.GetString(id)
 			if i != 5 {

cache/filecache/filecache_test.go

@@ -105,7 +105,7 @@ dir = ":cacheDir/c"
 		}
 
 		for _, ca := range []*filecache.Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
-			for i := 0; i < 2; i++ {
+			for range 2 {
 				info, r, err := ca.GetOrCreate("a", rf("abc"))
 				c.Assert(err, qt.IsNil)
 				c.Assert(r, qt.Not(qt.IsNil))
@@ -193,11 +193,11 @@ dir = "/cache/c"
 
 	var wg sync.WaitGroup
 
-	for i := 0; i < 50; i++ {
+	for i := range 50 {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
-			for j := 0; j < 20; j++ {
+			for range 20 {
 				ca := caches.Get(cacheName)
 				c.Assert(ca, qt.Not(qt.IsNil))
 				filename, data := filenameData(i)

cache/httpcache/httpcache.go

@@ -25,6 +25,8 @@ import (
 
 // DefaultConfig holds the default configuration for the HTTP cache.
 var DefaultConfig = Config{
+	RespectCacheControlNoStoreInRequest:  true,
+	RespectCacheControlNoStoreInResponse: false,
 	Cache: Cache{
 		For: GlobMatcher{
 			Excludes: []string{"**"},
@@ -42,7 +44,13 @@ var DefaultConfig = Config{
 
 // Config holds the configuration for the HTTP cache.
 type Config struct {
-	// Configures the HTTP cache behaviour (RFC 9111).
+	// When enabled and there's a Cache-Control: no-store directive in the request, response will never be stored in disk cache.
+	RespectCacheControlNoStoreInRequest bool
+
+	// When enabled and there's a Cache-Control: no-store directive in the response, response will never be stored in disk cache.
+	RespectCacheControlNoStoreInResponse bool
+
+	// Enables HTTP cache behavior (RFC 9111) for these resources.
 	// When this is not enabled for a resource, Hugo will go straight to the file cache.
 	Cache Cache
 
@@ -52,12 +60,14 @@ type Config struct {
 }
 
 type Cache struct {
-	// Enable HTTP cache behaviour (RFC 9111) for these rsources.
+	// Enable HTTP cache behavior (RFC 9111) for these resources.
 	For GlobMatcher
 }
 
 func (c *Config) Compile() (ConfigCompiled, error) {
-	var cc ConfigCompiled
+	cc := ConfigCompiled{
+		Base: *c,
+	}
 
 	p, err := c.Cache.For.CompilePredicate()
 	if err != nil {
@@ -122,7 +132,12 @@ type GlobMatcher struct {
 	Includes []string
 }
 
+func (gm GlobMatcher) IsZero() bool {
+	return len(gm.Includes) == 0 && len(gm.Excludes) == 0
+}
+
 type ConfigCompiled struct {
+	Base        Config
 	For         predicate.P[string]
 	PollConfigs []PollConfigCompiled
 }
@@ -155,6 +170,9 @@ func (p PollConfigCompiled) IsZero() bool {
 }
 
 func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
+	if gm.IsZero() {
+		panic("no includes or excludes")
+	}
 	var p predicate.P[string]
 	for _, include := range gm.Includes {
 		g, err := glob.Compile(include, '/')
@@ -181,7 +199,7 @@ func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
 	return p, nil
 }
 
-func DecodeConfig(bcfg config.BaseConfig, m map[string]any) (Config, error) {
+func DecodeConfig(_ config.BaseConfig, m map[string]any) (Config, error) {
 	if len(m) == 0 {
 		return DefaultConfig, nil
 	}
@@ -203,5 +221,20 @@ func DecodeConfig(bcfg config.BaseConfig, m map[string]any) (Config, error) {
 		return c, err
 	}
 
+	if c.Cache.For.IsZero() {
+		c.Cache.For = DefaultConfig.Cache.For
+	}
+
+	for pci := range c.Polls {
+		if c.Polls[pci].For.IsZero() {
+			c.Polls[pci].For = DefaultConfig.Cache.For
+			c.Polls[pci].Disable = true
+		}
+	}
+
+	if len(c.Polls) == 0 {
+		c.Polls = DefaultConfig.Polls
+	}
+
 	return c, nil
 }

cache/httpcache/httpcache_integration_test.go

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

cache/httpcache/httpcache_test.go

@@ -17,6 +17,7 @@ import (
 	"testing"
 
 	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/config"
 )
 
 func TestGlobMatcher(t *testing.T) {
@@ -40,3 +41,33 @@ func TestGlobMatcher(t *testing.T) {
 	c.Assert(p("foo/bar/foo.css"), qt.IsFalse)
 	c.Assert(p("foo/bar/foo.xml"), qt.IsTrue)
 }
+
+func TestDefaultConfig(t *testing.T) {
+	c := qt.New(t)
+
+	_, err := DefaultConfig.Compile()
+	c.Assert(err, qt.IsNil)
+}
+
+func TestDecodeConfigInjectsDefaultAndCompiles(t *testing.T) {
+	c := qt.New(t)
+
+	cfg, err := DecodeConfig(config.BaseConfig{}, map[string]interface{}{})
+	c.Assert(err, qt.IsNil)
+	c.Assert(cfg, qt.DeepEquals, DefaultConfig)
+
+	_, err = cfg.Compile()
+	c.Assert(err, qt.IsNil)
+
+	cfg, err = DecodeConfig(config.BaseConfig{}, map[string]any{
+		"cache": map[string]any{
+			"polls": []map[string]any{
+				{"disable": true},
+			},
+		},
+	})
+	c.Assert(err, qt.IsNil)
+
+	_, err = cfg.Compile()
+	c.Assert(err, qt.IsNil)
+}

codegen/methods.go

@@ -26,6 +26,7 @@ import (
 	"path/filepath"
 	"reflect"
 	"regexp"
+	"slices"
 	"sort"
 	"strings"
 	"sync"
@@ -102,7 +103,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 	}
 
 	for _, t := range include {
-		for i := 0; i < t.NumMethod(); i++ {
+		for i := range t.NumMethod() {
 
 			m := t.Method(i)
 			if excludes[m.Name] || seen[m.Name] {
@@ -122,7 +123,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 
 			method := Method{Owner: t, OwnerName: ownerName, Name: m.Name}
 
-			for i := 0; i < numIn; i++ {
+			for i := range numIn {
 				in := m.Type.In(i)
 
 				name, pkg := nameAndPackage(in)
@@ -137,7 +138,7 @@ func (c *Inspector) MethodsFromTypes(include []reflect.Type, exclude []reflect.T
 			numOut := m.Type.NumOut()
 
 			if numOut > 0 {
-				for i := 0; i < numOut; i++ {
+				for i := range numOut {
 					out := m.Type.Out(i)
 					name, pkg := nameAndPackage(out)
 
@@ -304,7 +305,7 @@ func (m Method) inOutStr() string {
 	}
 
 	args := make([]string, len(m.In))
-	for i := 0; i < len(args); i++ {
+	for i := range args {
 		args[i] = fmt.Sprintf("arg%d", i)
 	}
 	return "(" + strings.Join(args, ", ") + ")"
@@ -316,7 +317,7 @@ func (m Method) inStr() string {
 	}
 
 	args := make([]string, len(m.In))
-	for i := 0; i < len(args); i++ {
+	for i := range args {
 		args[i] = fmt.Sprintf("arg%d %s", i, m.In[i])
 	}
 	return "(" + strings.Join(args, ", ") + ")"
@@ -339,7 +340,7 @@ func (m Method) outStrNamed() string {
 	}
 
 	outs := make([]string, len(m.Out))
-	for i := 0; i < len(outs); i++ {
+	for i := range outs {
 		outs[i] = fmt.Sprintf("o%d %s", i, m.Out[i])
 	}
 
@@ -435,7 +436,7 @@ func (m Methods) ToMarshalJSON(receiver, pkgPath string, excludes ...string) (st
 		// Exclude self
 		for i, pkgImp := range pkgImports {
 			if pkgImp == pkgPath {
-				pkgImports = append(pkgImports[:i], pkgImports[i+1:]...)
+				pkgImports = slices.Delete(pkgImports, i, i+1)
 			}
 		}
 	}

commands/commandeer.go

@@ -101,8 +101,8 @@ type configKey struct {
 
 // This is the root command.
 type rootCommand struct {
-	Printf  func(format string, v ...interface{})
-	Println func(a ...interface{})
+	Printf  func(format string, v ...any)
+	Println func(a ...any)
 	StdOut  io.Writer
 	StdErr  io.Writer
 
@@ -431,12 +431,12 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 	// Used by mkcert (server).
 	log.SetOutput(r.StdOut)
 
-	r.Printf = func(format string, v ...interface{}) {
+	r.Printf = func(format string, v ...any) {
 		if !r.quiet {
 			fmt.Fprintf(r.StdOut, format, v...)
 		}
 	}
-	r.Println = func(a ...interface{}) {
+	r.Println = func(a ...any) {
 		if !r.quiet {
 			fmt.Fprintln(r.StdOut, a...)
 		}

commands/config.go

@@ -90,7 +90,7 @@ func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 		os.Stdout.Write(buf.Bytes())
 	default:
 		// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
-		var m map[string]interface{}
+		var m map[string]any
 		if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
 			return err
 		}

commands/gen.go

@@ -28,6 +28,7 @@ import (
 	"github.com/alecthomas/chroma/v2/formatters/html"
 	"github.com/alecthomas/chroma/v2/styles"
 	"github.com/bep/simplecobra"
+	"github.com/goccy/go-yaml"
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/docshelper"
 	"github.com/gohugoio/hugo/helpers"
@@ -36,7 +37,6 @@ import (
 	"github.com/gohugoio/hugo/parser"
 	"github.com/spf13/cobra"
 	"github.com/spf13/cobra/doc"
-	"gopkg.in/yaml.v2"
 )
 
 func newGenCommand() *genCommand {
@@ -50,6 +50,8 @@ func newGenCommand() *genCommand {
 		highlightStyle         string
 		lineNumbersInlineStyle string
 		lineNumbersTableStyle  string
+		omitEmpty              bool
+		omitClassComments      bool
 	)
 
 	newChromaStyles := func() simplecobra.Commander {
@@ -79,7 +81,16 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				if err != nil {
 					return err
 				}
-				formatter := html.New(html.WithAllClasses(true))
+
+				if omitEmpty {
+					// See https://github.com/alecthomas/chroma/commit/5b2a4c5a26c503c79bc86ba3c4ae5b330028bd3d
+					hugo.Deprecate("--omitEmpty", "Flag is no longer needed, empty classes are now always omitted.", "v0.149.0")
+				}
+				options := []html.Option{
+					html.WithCSSComments(!omitClassComments),
+				}
+				formatter := html.New(options...)
+
 				w := os.Stdout
 				fmt.Fprintf(w, "/* Generated using: hugo %s */\n\n", strings.Join(os.Args[1:], " "))
 				formatter.WriteCSS(w, style)
@@ -95,6 +106,10 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				_ = cmd.RegisterFlagCompletionFunc("lineNumbersInlineStyle", cobra.NoFileCompletions)
 				cmd.PersistentFlags().StringVar(&lineNumbersTableStyle, "lineNumbersTableStyle", "", `foreground and background colors for table line numbers, e.g. --lineNumbersTableStyle "#fff000 bg:#000fff"`)
 				_ = cmd.RegisterFlagCompletionFunc("lineNumbersTableStyle", cobra.NoFileCompletions)
+				cmd.PersistentFlags().BoolVar(&omitEmpty, "omitEmpty", false, `omit empty CSS rules (deprecated, no longer needed)`)
+				_ = cmd.RegisterFlagCompletionFunc("omitEmpty", cobra.NoFileCompletions)
+				cmd.PersistentFlags().BoolVar(&omitClassComments, "omitClassComments", false, `omit CSS class comment prefixes in the generated CSS`)
+				_ = cmd.RegisterFlagCompletionFunc("omitClassComments", cobra.NoFileCompletions)
 			},
 		}
 	}
@@ -174,13 +189,13 @@ url: %s
 				prepender := func(filename string) string {
 					name := filepath.Base(filename)
 					base := strings.TrimSuffix(name, path.Ext(name))
-					url := "/commands/" + strings.ToLower(base) + "/"
+					url := "/docs/reference/commands/" + strings.ToLower(base) + "/"
 					return fmt.Sprintf(gendocFrontmatterTemplate, strings.Replace(base, "_", " ", -1), base, url)
 				}
 
 				linkHandler := func(name string) string {
 					base := strings.TrimSuffix(name, path.Ext(name))
-					return "/commands/" + strings.ToLower(base) + "/"
+					return "/docs/reference/commands/" + strings.ToLower(base) + "/"
 				}
 				r.Println("Generating Hugo command-line documentation in", gendocdir, "...")
 				doc.GenMarkdownTreeCustom(cd.CobraCommand.Root(), gendocdir, prepender, linkHandler)
@@ -222,7 +237,7 @@ url: %s
 				}
 
 				// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
-				var m map[string]interface{}
+				var m map[string]any
 				if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
 					return err
 				}

commands/helpers.go

@@ -76,7 +76,7 @@ func flagsToCfgWithAdditionalConfigBase(cd *simplecobra.Commandeer, cfg config.P
 
 	// Flags with a different name in the config.
 	keyMap := map[string]string{
-		"minify":      "minifyOutput",
+		"minify":      "minify.minifyOutput",
 		"destination": "publishDir",
 		"editor":      "newContentEditor",
 	}

commands/hugobuilder.go

@@ -27,6 +27,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/bep/debounce"
 	"github.com/bep/simplecobra"
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
@@ -515,6 +516,14 @@ func (c *hugoBuilder) doWithPublishDirs(f func(sourceFs *filesystems.SourceFiles
 	return langCount, nil
 }
 
+func (c *hugoBuilder) progressIntermediate() {
+	terminal.ReportProgress(c.r.StdOut, terminal.ProgressIntermediate, 0)
+}
+
+func (c *hugoBuilder) progressHidden() {
+	terminal.ReportProgress(c.r.StdOut, terminal.ProgressHidden, 0)
+}
+
 func (c *hugoBuilder) fullBuild(noBuildLock bool) error {
 	var (
 		g         errgroup.Group
@@ -962,7 +971,7 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 					lrl.Logf("no page to navigate to, force refresh")
 					livereload.ForceRefresh()
 				}
-			} else if len(otherChanges) > 0 {
+			} else if len(otherChanges) > 0 || len(cssChanges) > 0 {
 				if len(otherChanges) == 1 {
 					// Allow single changes to be refreshed without a full page reload.
 					pathToRefresh := h.PathSpec.RelURL(paths.ToSlashTrimLeading(otherChanges[0]), false)
@@ -972,6 +981,9 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 					lrl.Logf("force refresh")
 					livereload.ForceRefresh()
 				}
+			} else {
+				lrl.Logf("force refresh")
+				livereload.ForceRefresh()
 			}
 
 			if len(cssChanges) > 0 {
@@ -1024,6 +1036,17 @@ func (c *hugoBuilder) hugoTry() *hugolib.HugoSites {
 }
 
 func (c *hugoBuilder) loadConfig(cd *simplecobra.Commandeer, running bool) error {
+	if terminal.PrintANSIColors(os.Stdout) {
+		defer c.progressHidden()
+		// If the configuration takes a while to load, we want to show some progress.
+		// This is typically loading of external modules.
+		d := debounce.New(500 * time.Millisecond)
+		d(func() {
+			c.progressIntermediate()
+		})
+		defer d(func() {})
+	}
+
 	cfg := config.New()
 	cfg.Set("renderToMemory", c.r.renderToMemory)
 	watch := c.r.buildWatch || (c.s != nil && c.s.serverWatch)

commands/new.go

@@ -53,7 +53,9 @@ Ensure you run this within the root directory of your site.`,
 					if len(args) < 1 {
 						return newUserError("path needs to be provided")
 					}
-					h, err := r.Hugo(flagsToCfg(cd, nil))
+					cfg := flagsToCfg(cd, nil)
+					cfg.Set("BuildFuture", true)
+					h, err := r.Hugo(cfg)
 					if err != nil {
 						return err
 					}
@@ -76,10 +78,8 @@ Ensure you run this within the root directory of your site.`,
 			&simpleCommand{
 				name:  "site",
 				use:   "site [path]",
-				short: "Create a new site (skeleton)",
-				long: `Create a new site in the provided directory.
-The new site will have the correct structure, but no content or theme yet.
-Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
+				short: "Create a new site",
+				long:  `Create a new site at the specified path.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 1 {
 						return newUserError("path needs to be provided")
@@ -124,11 +124,9 @@ Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 			&simpleCommand{
 				name:  "theme",
 				use:   "theme [name]",
-				short: "Create a new theme (skeleton)",
-				long: `Create a new theme (skeleton) called [name] in ./themes.
-New theme is a skeleton. Please add content to the touched files. Add your
-name to the copyright line in the license and adjust the theme.toml file
-according to your needs.`,
+				short: "Create a new theme",
+				long: `Create a new theme with the specified name in the ./themes directory.
+This generates a functional theme including template examples and sample content.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					if len(args) < 1 {
 						return newUserError("theme name needs to be provided")
@@ -144,7 +142,7 @@ according to your needs.`,
 					createpath := paths.AbsPathify(conf.configs.Base.WorkingDir, filepath.Join(conf.configs.Base.ThemesDir, args[0]))
 					r.Println("Creating new theme in", createpath)
 
-					err = skeletons.CreateTheme(createpath, sourceFs)
+					err = skeletons.CreateTheme(createpath, sourceFs, format)
 					if err != nil {
 						return err
 					}
@@ -152,7 +150,14 @@ according to your needs.`,
 					return nil
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
-					cmd.ValidArgsFunction = cobra.NoFileCompletions
+					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+						if len(args) != 0 {
+							return []string{}, cobra.ShellCompDirectiveNoFileComp
+						}
+						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
+					}
+					cmd.Flags().StringVar(&format, "format", "toml", "preferred file format (toml, yaml or json)")
+					_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
 				},
 			},
 		},

commands/server.go

@@ -23,6 +23,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"maps"
 	"net"
 	"net/http"
 	_ "net/http/pprof"
@@ -48,6 +49,7 @@ import (
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/tpl/tplimpl"
 
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/common/urls"
@@ -57,7 +59,6 @@ import (
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/hugolib/filesystems"
 	"github.com/gohugoio/hugo/livereload"
-	"github.com/gohugoio/hugo/tpl"
 	"github.com/gohugoio/hugo/transform"
 	"github.com/gohugoio/hugo/transform/livereloadinject"
 	"github.com/spf13/afero"
@@ -195,9 +196,7 @@ func (f *fileChangeDetector) PrepareNew() {
 	}
 
 	f.prev = make(map[string]uint64)
-	for k, v := range f.current {
-		f.prev[k] = v
-	}
+	maps.Copy(f.prev, f.current)
 	f.current = make(map[string]uint64)
 }
 
@@ -628,7 +627,7 @@ func (c *serverCommand) setServerInfoInConfig() error {
 		panic("no server ports set")
 	}
 	return c.withConfE(func(conf *commonConfig) error {
-		for i, language := range conf.configs.Languages {
+		for i, language := range conf.configs.LanguagesDefaultFirst {
 			isMultihost := conf.configs.IsMultihost
 			var serverPort int
 			if isMultihost {
@@ -759,7 +758,7 @@ func (c *serverCommand) createServerPorts(cd *simplecobra.Commandeer) error {
 			c.serverPorts = make([]serverPortListener, len(conf.configs.Languages))
 		}
 		currentServerPort := c.serverPort
-		for i := 0; i < len(c.serverPorts); i++ {
+		for i := range c.serverPorts {
 			l, err := net.Listen("tcp", net.JoinHostPort(c.serverInterface, strconv.Itoa(currentServerPort)))
 			if err == nil {
 				c.serverPorts[i] = serverPortListener{ln: l, p: currentServerPort}
@@ -898,16 +897,16 @@ func (c *serverCommand) serve() error {
 	// To allow the en user to change the error template while the server is running, we use
 	// the freshest template we can provide.
 	var (
-		errTempl     tpl.Template
-		templHandler tpl.TemplateHandler
+		errTempl     *tplimpl.TemplInfo
+		templHandler *tplimpl.TemplateStore
 	)
-	getErrorTemplateAndHandler := func(h *hugolib.HugoSites) (tpl.Template, tpl.TemplateHandler) {
+	getErrorTemplateAndHandler := func(h *hugolib.HugoSites) (*tplimpl.TemplInfo, *tplimpl.TemplateStore) {
 		if h == nil {
 			return errTempl, templHandler
 		}
-		templHandler := h.Tmpl()
-		errTempl, found := templHandler.Lookup("_server/error.html")
-		if !found {
+		templHandler := h.GetTemplateStore()
+		errTempl := templHandler.LookupByPath("/_server/error.html")
+		if errTempl == nil {
 			panic("template server/error.html not found")
 		}
 		return errTempl, templHandler
@@ -1167,7 +1166,6 @@ func chmodFilter(dst, src os.FileInfo) bool {
 }
 
 func cleanErrorLog(content string) string {
-	content = strings.ReplaceAll(content, "\n", " ")
 	content = logReplacer.Replace(content)
 	content = logDuplicateTemplateExecuteRe.ReplaceAllString(content, "")
 	content = logDuplicateTemplateParseRe.ReplaceAllString(content, "")

common/collections/append.go

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

common/collections/append_test.go

@@ -15,6 +15,7 @@ package collections
 
 import (
 	"html/template"
+	"reflect"
 	"testing"
 
 	qt "github.com/frankban/quicktest"
@@ -77,6 +78,7 @@ func TestAppend(t *testing.T) {
 		{[]string{"a", "b"}, []any{nil}, []any{"a", "b", nil}},
 		{[]string{"a", "b"}, []any{nil, "d", nil}, []any{"a", "b", nil, "d", nil}},
 		{[]any{"a", nil, "c"}, []any{"d", nil, "f"}, []any{"a", nil, "c", "d", nil, "f"}},
+		{[]string{"a", "b"}, []any{}, []string{"a", "b"}},
 	} {
 
 		result, err := Append(test.start, test.addend...)
@@ -146,3 +148,66 @@ func TestAppendShouldMakeACopyOfTheInputSlice(t *testing.T) {
 	c.Assert(result, qt.DeepEquals, []string{"a", "b", "c"})
 	c.Assert(slice, qt.DeepEquals, []string{"d", "b"})
 }
+
+func TestIndirect(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	type testStruct struct {
+		Field string
+	}
+
+	var (
+		nilPtr      *testStruct
+		nilIface    interface{} = nil
+		nonNilIface interface{} = &testStruct{Field: "hello"}
+	)
+
+	tests := []struct {
+		name     string
+		input    any
+		wantKind reflect.Kind
+		wantNil  bool
+	}{
+		{
+			name:     "nil pointer",
+			input:    nilPtr,
+			wantKind: reflect.Ptr,
+			wantNil:  true,
+		},
+		{
+			name:     "nil interface",
+			input:    nilIface,
+			wantKind: reflect.Invalid,
+			wantNil:  false,
+		},
+		{
+			name:     "non-nil pointer to struct",
+			input:    &testStruct{Field: "abc"},
+			wantKind: reflect.Struct,
+			wantNil:  false,
+		},
+		{
+			name:     "non-nil interface holding pointer",
+			input:    nonNilIface,
+			wantKind: reflect.Struct,
+			wantNil:  false,
+		},
+		{
+			name:     "plain value",
+			input:    testStruct{Field: "xyz"},
+			wantKind: reflect.Struct,
+			wantNil:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := reflect.ValueOf(tt.input)
+			got, isNil := indirect(v)
+
+			c.Assert(got.Kind(), qt.Equals, tt.wantKind)
+			c.Assert(isNil, qt.Equals, tt.wantNil)
+		})
+	}
+}

common/collections/slice_test.go

@@ -136,3 +136,37 @@ func TestSortedStringSlice(t *testing.T) {
 	c.Assert(s.Count("z"), qt.Equals, 0)
 	c.Assert(s.Count("a"), qt.Equals, 1)
 }
+
+func TestStringSliceToInterfaceSlice(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	tests := []struct {
+		name string
+		in   []string
+		want []any
+	}{
+		{
+			name: "empty slice",
+			in:   []string{},
+			want: []any{},
+		},
+		{
+			name: "single element",
+			in:   []string{"hello"},
+			want: []any{"hello"},
+		},
+		{
+			name: "multiple elements",
+			in:   []string{"a", "b", "c"},
+			want: []any{"a", "b", "c"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := StringSliceToInterfaceSlice(tt.in)
+			c.Assert(got, qt.DeepEquals, tt.want)
+		})
+	}
+}

common/collections/stack.go

@@ -13,6 +13,8 @@
 
 package collections
 
+import "slices"
+
 import "sync"
 
 // Stack is a simple LIFO stack that is safe for concurrent use.
@@ -73,7 +75,7 @@ func (s *Stack[T]) DrainMatching(predicate func(T) bool) []T {
 	for i := len(s.items) - 1; i >= 0; i-- {
 		if predicate(s.items[i]) {
 			items = append(items, s.items[i])
-			s.items = append(s.items[:i], s.items[i+1:]...)
+			s.items = slices.Delete(s.items, i, i+1)
 		}
 	}
 	return items

common/collections/stack_test.go

@@ -0,0 +1,77 @@
+package collections
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestNewStack(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	s := NewStack[int]()
+
+	c.Assert(s, qt.IsNotNil)
+}
+
+func TestStackBasic(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	s := NewStack[int]()
+
+	c.Assert(s.Len(), qt.Equals, 0)
+
+	s.Push(1)
+	s.Push(2)
+	s.Push(3)
+
+	c.Assert(s.Len(), qt.Equals, 3)
+
+	top, ok := s.Peek()
+	c.Assert(ok, qt.Equals, true)
+	c.Assert(top, qt.Equals, 3)
+
+	popped, ok := s.Pop()
+	c.Assert(ok, qt.Equals, true)
+	c.Assert(popped, qt.Equals, 3)
+
+	c.Assert(s.Len(), qt.Equals, 2)
+
+	_, _ = s.Pop()
+	_, _ = s.Pop()
+	_, ok = s.Pop()
+
+	c.Assert(ok, qt.Equals, false)
+}
+
+func TestStackDrain(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	s := NewStack[string]()
+	s.Push("a")
+	s.Push("b")
+
+	got := s.Drain()
+
+	c.Assert(got, qt.DeepEquals, []string{"a", "b"})
+	c.Assert(s.Len(), qt.Equals, 0)
+}
+
+func TestStackDrainMatching(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	s := NewStack[int]()
+	s.Push(1)
+	s.Push(2)
+	s.Push(3)
+	s.Push(4)
+
+	got := s.DrainMatching(func(v int) bool { return v%2 == 0 })
+
+	c.Assert(got, qt.DeepEquals, []int{4, 2})
+	c.Assert(s.Drain(), qt.DeepEquals, []int{1, 3})
+}

common/constants/constants.go

@@ -23,6 +23,8 @@ const (
 	WarnFrontMatterParamsOverrides = "warning-frontmatter-params-overrides"
 	WarnRenderShortcodesInHTML     = "warning-rendershortcodes-in-html"
 	WarnGoldmarkRawHTML            = "warning-goldmark-raw-html"
+	WarnPartialSuperfluousPrefix   = "warning-partial-superfluous-prefix"
+	WarnHomePageIsLeafBundle       = "warning-home-page-is-leaf-bundle"
 )
 
 // Field/method names with special meaning.

common/hashing/hashing_test.go

@@ -37,12 +37,12 @@ func TestXxHashFromReaderPara(t *testing.T) {
 	c := qt.New(t)
 
 	var wg sync.WaitGroup
-	for i := 0; i < 10; i++ {
+	for i := range 10 {
 		i := i
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for j := 0; j < 100; j++ {
+			for j := range 100 {
 				s := strings.Repeat("Hello ", i+j+1*42)
 				r := strings.NewReader(s)
 				got, size, err := XXHashFromReader(r)
@@ -144,8 +144,8 @@ func BenchmarkHashString(b *testing.B) {
 }
 
 func BenchmarkHashMap(b *testing.B) {
-	m := map[string]interface{}{}
-	for i := 0; i < 1000; i++ {
+	m := map[string]any{}
+	for i := range 1000 {
 		m[fmt.Sprintf("key%d", i)] = i
 	}
 

common/hcontext/context.go

@@ -1,46 +0,0 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package hcontext
-
-import "context"
-
-// ContextDispatcher is a generic interface for setting and getting values from a context.
-type ContextDispatcher[T any] interface {
-	Set(ctx context.Context, value T) context.Context
-	Get(ctx context.Context) T
-}
-
-// NewContextDispatcher creates a new ContextDispatcher with the given key.
-func NewContextDispatcher[T any, R comparable](key R) ContextDispatcher[T] {
-	return keyInContext[T, R]{
-		id: key,
-	}
-}
-
-type keyInContext[T any, R comparable] struct {
-	zero T
-	id   R
-}
-
-func (f keyInContext[T, R]) Get(ctx context.Context) T {
-	v := ctx.Value(f.id)
-	if v == nil {
-		return f.zero
-	}
-	return v.(T)
-}
-
-func (f keyInContext[T, R]) Set(ctx context.Context, value T) context.Context {
-	return context.WithValue(ctx, f.id, value)
-}

common/hdebug/debug.go

@@ -0,0 +1,61 @@
+// Copyright 2025 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package hdebug
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gohugoio/hugo/common/types"
+	"github.com/gohugoio/hugo/htesting"
+)
+
+// Printf is a debug print function that should be removed before committing code to the repository.
+func Printf(format string, args ...any) {
+	panicIfRealCI()
+	if len(args) == 1 && !strings.Contains(format, "%") {
+		format = format + ": %v"
+	}
+	if !strings.HasSuffix(format, "\n") {
+		format = format + "\n"
+	}
+	fmt.Printf(format, args...)
+}
+
+func AssertNotNil(a ...any) {
+	panicIfRealCI()
+	for _, v := range a {
+		if types.IsNil(v) {
+			panic("hdebug.AssertNotNil: value is nil")
+		}
+	}
+}
+
+func Panicf(format string, args ...any) {
+	panicIfRealCI()
+	// fmt.Println(stack())
+	if len(args) == 1 && !strings.Contains(format, "%") {
+		format = format + ": %v"
+	}
+	if !strings.HasSuffix(format, "\n") {
+		format = format + "\n"
+	}
+	panic(fmt.Sprintf(format, args...))
+}
+
+func panicIfRealCI() {
+	if htesting.IsRealCI() {
+		panic("This debug statement should be removed before committing code!")
+	}
+}

common/herrors/error_locator.go

@@ -152,10 +152,7 @@ func locateError(r io.Reader, le FileError, matches LineMatcherFn) *ErrorContext
 	}
 
 	if ectx.Position.LineNumber > 0 {
-		low := ectx.Position.LineNumber - 3
-		if low < 0 {
-			low = 0
-		}
+		low := max(ectx.Position.LineNumber-3, 0)
 
 		if ectx.Position.LineNumber > 2 {
 			ectx.LinesPos = 2
@@ -163,10 +160,7 @@ func locateError(r io.Reader, le FileError, matches LineMatcherFn) *ErrorContext
 			ectx.LinesPos = ectx.Position.LineNumber - 1
 		}
 
-		high := ectx.Position.LineNumber + 2
-		if high > len(lines) {
-			high = len(lines)
-		}
+		high := min(ectx.Position.LineNumber+2, len(lines))
 
 		ectx.Lines = lines[low:high]
 

common/herrors/errors.go

@@ -17,22 +17,13 @@ package herrors
 import (
 	"errors"
 	"fmt"
-	"io"
 	"os"
 	"regexp"
-	"runtime"
 	"runtime/debug"
 	"strings"
 	"time"
 )
 
-// PrintStackTrace prints the current stacktrace to w.
-func PrintStackTrace(w io.Writer) {
-	buf := make([]byte, 1<<16)
-	runtime.Stack(buf, true)
-	fmt.Fprintf(w, "%s", buf)
-}
-
 // ErrorSender is a, typically, non-blocking error handler.
 type ErrorSender interface {
 	SendError(err error)

common/herrors/file_error.go

@@ -110,11 +110,11 @@ func (fe *fileError) UpdateContent(r io.Reader, linematcher LineMatcherFn) FileE
 
 	fe.errorContext = ectx
 
-	if ectx.Position.LineNumber > 0 {
+	if ectx.Position.LineNumber > 0 && ectx.Position.LineNumber > fe.position.LineNumber {
 		fe.position.LineNumber = ectx.Position.LineNumber
 	}
 
-	if ectx.Position.ColumnNumber > 0 {
+	if ectx.Position.ColumnNumber > 0 && ectx.Position.ColumnNumber > fe.position.ColumnNumber {
 		fe.position.ColumnNumber = ectx.Position.ColumnNumber
 	}
 
@@ -177,6 +177,7 @@ func NewFileErrorFromName(err error, name string) FileError {
 	// Filetype is used to determine the Chroma lexer to use.
 	fileType, pos := extractFileTypePos(err)
 	pos.Filename = name
+
 	if fileType == "" {
 		_, fileType = paths.FileAndExtNoDelimiter(filepath.Clean(name))
 	}
@@ -234,7 +235,9 @@ func NewFileErrorFromFile(err error, filename string, fs afero.Fs, linematcher L
 		return NewFileErrorFromName(err, realFilename)
 	}
 	defer f.Close()
-	return NewFileErrorFromName(err, realFilename).UpdateContent(f, linematcher)
+	fe := NewFileErrorFromName(err, realFilename)
+	fe = fe.UpdateContent(f, linematcher)
+	return fe
 }
 
 func openFile(filename string, fs afero.Fs) (afero.File, string, error) {
@@ -321,13 +324,9 @@ func extractFileTypePos(err error) (string, text.Position) {
 	}
 
 	// Look in the error message for the line number.
-	for _, handle := range lineNumberExtractors {
-		lno, col := handle(err)
-		if lno > 0 {
-			pos.ColumnNumber = col
-			pos.LineNumber = lno
-			break
-		}
+	if lno, col := commonLineNumberExtractor(err); lno > 0 {
+		pos.ColumnNumber = col
+		pos.LineNumber = lno
 	}
 
 	if fileType == "" && pos.Filename != "" {

common/herrors/line_number_extractors.go

@@ -19,17 +19,27 @@ import (
 )
 
 var lineNumberExtractors = []lineNumberExtractor{
+	// YAML parse errors.
+	newLineNumberErrHandlerFromRegexp(`\[(\d+):(\d+)\]`),
+
 	// Template/shortcode parse errors
 	newLineNumberErrHandlerFromRegexp(`:(\d+):(\d*):`),
 	newLineNumberErrHandlerFromRegexp(`:(\d+):`),
 
-	// YAML parse errors
-	newLineNumberErrHandlerFromRegexp(`line (\d+):`),
-
 	// i18n bundle errors
 	newLineNumberErrHandlerFromRegexp(`\((\d+),\s(\d*)`),
 }
 
+func commonLineNumberExtractor(e error) (int, int) {
+	for _, handler := range lineNumberExtractors {
+		lno, col := handler(e)
+		if lno > 0 {
+			return lno, col
+		}
+	}
+	return 0, 0
+}
+
 type lineNumberExtractor func(e error) (int, int)
 
 func newLineNumberErrHandlerFromRegexp(expression string) lineNumberExtractor {

common/herrors/line_number_extractors_test.go

@@ -1,4 +1,4 @@
-// Copyright 2019 The Hugo Authors. All rights reserved.
+// Copyright 2025 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,4 +11,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package tplimpl
+package herrors
+
+import (
+	"errors"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestCommonLineNumberExtractor(t *testing.T) {
+	t.Parallel()
+
+	c := qt.New(t)
+
+	lno, col := commonLineNumberExtractor(errors.New("[4:9] value is not allowed in this context"))
+	c.Assert(lno, qt.Equals, 4)
+	c.Assert(col, qt.Equals, 9)
+}

common/hexec/exec.go

@@ -27,7 +27,6 @@ import (
 	"sync"
 
 	"github.com/bep/logg"
-	"github.com/cli/safeexec"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/config"
@@ -113,18 +112,6 @@ func IsNotFound(err error) bool {
 	return errors.As(err, &notFoundErr)
 }
 
-// SafeCommand is a wrapper around os/exec Command which uses a LookPath
-// implementation that does not search in current directory before looking in PATH.
-// See https://github.com/cli/safeexec and the linked issues.
-func SafeCommand(name string, arg ...string) (*exec.Cmd, error) {
-	bin, err := safeexec.LookPath(name)
-	if err != nil {
-		return nil, err
-	}
-
-	return exec.Command(bin, arg...), nil
-}
-
 // Exec enforces a security policy for commands run via os/exec.
 type Exec struct {
 	sc         security.Config
@@ -197,7 +184,7 @@ func (e *Exec) Npx(name string, arg ...any) (Runner, error) {
 		tryFuncs := map[binaryLocation]tryFunc{
 			binaryLocationNodeModules: func() func(...any) (Runner, error) {
 				nodeBinFilename := filepath.Join(e.workingDir, nodeModulesBinPath, name)
-				_, err := safeexec.LookPath(nodeBinFilename)
+				_, err := exec.LookPath(nodeBinFilename)
 				if err != nil {
 					return nil
 				}
@@ -215,7 +202,7 @@ func (e *Exec) Npx(name string, arg ...any) (Runner, error) {
 				}
 			},
 			binaryLocationPath: func() func(...any) (Runner, error) {
-				if _, err := safeexec.LookPath(name); err != nil {
+				if _, err := exec.LookPath(name); err != nil {
 					return nil
 				}
 				return func(arg2 ...any) (Runner, error) {
@@ -346,7 +333,7 @@ func (c *commandeer) command(arg ...any) (*cmdWrapper, error) {
 		bin = c.fullyQualifiedName
 	} else {
 		var err error
-		bin, err = safeexec.LookPath(c.name)
+		bin, err = exec.LookPath(c.name)
 		if err != nil {
 			return nil, &NotFoundError{
 				name:   c.name,
@@ -384,7 +371,7 @@ func InPath(binaryName string) bool {
 	if strings.Contains(binaryName, "/") {
 		panic("binary name should not contain any slash")
 	}
-	_, err := safeexec.LookPath(binaryName)
+	_, err := exec.LookPath(binaryName)
 	return err == nil
 }
 
@@ -394,7 +381,7 @@ func LookPath(binaryName string) string {
 	if strings.Contains(binaryName, "/") {
 		panic("binary name should not contain any slash")
 	}
-	s, err := safeexec.LookPath(binaryName)
+	s, err := exec.LookPath(binaryName)
 	if err != nil {
 		return ""
 	}

common/hreflect/helpers.go

@@ -18,6 +18,7 @@ package hreflect
 
 import (
 	"context"
+	"math"
 	"reflect"
 	"sync"
 	"time"
@@ -86,6 +87,18 @@ func IsSlice(v any) bool {
 
 var zeroType = reflect.TypeOf((*types.Zeroer)(nil)).Elem()
 
+var isZeroCache sync.Map
+
+func implementsIsZero(tp reflect.Type) bool {
+	v, ok := isZeroCache.Load(tp)
+	if ok {
+		return v.(bool)
+	}
+	implements := tp.Implements(zeroType)
+	isZeroCache.Store(tp, implements)
+	return implements
+}
+
 // IsTruthfulValue returns whether the given value has a meaningful truth value.
 // This is based on template.IsTrue in Go's stdlib, but also considers
 // IsZero and any interface value will be unwrapped before it's considered
@@ -101,7 +114,11 @@ func IsTruthfulValue(val reflect.Value) (truth bool) {
 		return
 	}
 
-	if val.Type().Implements(zeroType) {
+	if val.Kind() == reflect.Pointer && val.IsNil() {
+		return
+	}
+
+	if implementsIsZero(val.Type()) {
 		return !val.Interface().(types.Zeroer).IsZero()
 	}
 
@@ -134,12 +151,7 @@ type methodKey struct {
 	name string
 }
 
-type methods struct {
-	sync.RWMutex
-	cache map[methodKey]int
-}
-
-var methodCache = &methods{cache: make(map[methodKey]int)}
+var methodCache sync.Map
 
 // GetMethodByName is the same as reflect.Value.MethodByName, but it caches the
 // type lookup.
@@ -157,22 +169,16 @@ func GetMethodByName(v reflect.Value, name string) reflect.Value {
 // -1 if no such method exists.
 func GetMethodIndexByName(tp reflect.Type, name string) int {
 	k := methodKey{tp, name}
-	methodCache.RLock()
-	index, found := methodCache.cache[k]
-	methodCache.RUnlock()
+	v, found := methodCache.Load(k)
 	if found {
-		return index
+		return v.(int)
 	}
-
-	methodCache.Lock()
-	defer methodCache.Unlock()
-
 	m, ok := tp.MethodByName(name)
-	index = m.Index
+	index := m.Index
 	if !ok {
 		index = -1
 	}
-	methodCache.cache[k] = index
+	methodCache.Store(k, index)
 
 	if !ok {
 		return -1
@@ -245,7 +251,7 @@ func ToSliceAny(v any) ([]any, bool) {
 		vvv := reflect.ValueOf(v)
 		if vvv.Kind() == reflect.Slice {
 			out := make([]any, vvv.Len())
-			for i := 0; i < vvv.Len(); i++ {
+			for i := range vvv.Len() {
 				out[i] = vvv.Index(i).Interface()
 			}
 			return out, true
@@ -304,3 +310,45 @@ func IsContextType(tp reflect.Type) bool {
 	})
 	return isContext
 }
+
+// ConvertIfPossible tries to convert val to typ if possible.
+// This is currently only implemented for int kinds,
+// added to handle the move to a new YAML library which produces uint64 for unsigned integers.
+// We can expand on this later if needed.
+// This conversion is lossless.
+// See Issue 14079.
+func ConvertIfPossible(val reflect.Value, typ reflect.Type) (reflect.Value, bool) {
+	if IsInt(typ.Kind()) {
+		if IsInt(val.Kind()) {
+			if typ.OverflowInt(val.Int()) {
+				return reflect.Value{}, false
+			}
+			return val.Convert(typ), true
+		}
+		if IsUint(val.Kind()) {
+			if val.Uint() > uint64(math.MaxInt64) {
+				return reflect.Value{}, false
+			}
+			if typ.OverflowInt(int64(val.Uint())) {
+				return reflect.Value{}, false
+			}
+			return val.Convert(typ), true
+		}
+		if IsFloat(val.Kind()) {
+			f := val.Float()
+			if f < float64(math.MinInt64) || f > float64(math.MaxInt64) {
+				return reflect.Value{}, false
+			}
+			i := int64(f)
+			if typ.OverflowInt(i) {
+				return reflect.Value{}, false
+			}
+			// Check for lossless conversion.
+			if float64(i) != f {
+				return reflect.Value{}, false
+			}
+			return val.Convert(typ), true
+		}
+	}
+	return reflect.Value{}, false
+}

common/hreflect/helpers_test.go

@@ -15,6 +15,7 @@ package hreflect
 
 import (
 	"context"
+	"math"
 	"reflect"
 	"testing"
 	"time"
@@ -22,13 +23,29 @@ import (
 	qt "github.com/frankban/quicktest"
 )
 
+type zeroStruct struct {
+	zero bool
+}
+
+func (z zeroStruct) IsZero() bool {
+	return z.zero
+}
+
 func TestIsTruthful(t *testing.T) {
 	c := qt.New(t)
 
+	var nilpointerZero *zeroStruct
+
 	c.Assert(IsTruthful(true), qt.Equals, true)
 	c.Assert(IsTruthful(false), qt.Equals, false)
 	c.Assert(IsTruthful(time.Now()), qt.Equals, true)
 	c.Assert(IsTruthful(time.Time{}), qt.Equals, false)
+	c.Assert(IsTruthful(&zeroStruct{zero: false}), qt.Equals, true)
+	c.Assert(IsTruthful(&zeroStruct{zero: true}), qt.Equals, false)
+	c.Assert(IsTruthful(zeroStruct{zero: false}), qt.Equals, true)
+	c.Assert(IsTruthful(zeroStruct{zero: true}), qt.Equals, false)
+	c.Assert(IsTruthful(nil), qt.Equals, false)
+	c.Assert(IsTruthful(nilpointerZero), qt.Equals, false)
 }
 
 func TestGetMethodByName(t *testing.T) {
@@ -90,14 +107,26 @@ func BenchmarkIsContextType(b *testing.B) {
 	})
 }
 
-func BenchmarkIsTruthFul(b *testing.B) {
-	v := reflect.ValueOf("Hugo")
+func BenchmarkIsTruthFulValue(b *testing.B) {
+	var (
+		stringHugo  = reflect.ValueOf("Hugo")
+		stringEmpty = reflect.ValueOf("")
+		zero        = reflect.ValueOf(time.Time{})
+		timeNow     = reflect.ValueOf(time.Now())
+		boolTrue    = reflect.ValueOf(true)
+		boolFalse   = reflect.ValueOf(false)
+		nilPointer  = reflect.ValueOf((*zeroStruct)(nil))
+	)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		if !IsTruthfulValue(v) {
-			b.Fatal("not truthful")
-		}
+		IsTruthfulValue(stringHugo)
+		IsTruthfulValue(stringEmpty)
+		IsTruthfulValue(zero)
+		IsTruthfulValue(timeNow)
+		IsTruthfulValue(boolTrue)
+		IsTruthfulValue(boolFalse)
+		IsTruthfulValue(nilPointer)
 	}
 }
 
@@ -134,3 +163,107 @@ func BenchmarkGetMethodByName(b *testing.B) {
 		}
 	}
 }
+
+func BenchmarkGetMethodByNamePara(b *testing.B) {
+	v := reflect.ValueOf(&testStruct{})
+	methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			for _, method := range methods {
+				_ = GetMethodByName(v, method)
+			}
+		}
+	})
+}
+
+func TestCastIfPossible(t *testing.T) {
+	c := qt.New(t)
+
+	for _, test := range []struct {
+		name     string
+		value    any
+		typ      any
+		expected any
+		ok       bool
+	}{
+		// From uint to int.
+		{
+			name:  "uint64(math.MaxUint64) to int16",
+			value: uint64(math.MaxUint64),
+			typ:   int16(0),
+			ok:    false, // overflow
+		},
+
+		{
+			name:  "uint64(math.MaxUint64) to int64",
+			value: uint64(math.MaxUint64),
+			typ:   int64(0),
+			ok:    false, // overflow
+		},
+		{
+			name:     "uint64(math.MaxInt16) to int16",
+			value:    uint64(math.MaxInt16),
+			typ:      int64(0),
+			ok:       true,
+			expected: int64(math.MaxInt16),
+		},
+		// From int to int.
+		{
+			name:  "int64(math.MaxInt64) to int16",
+			value: int64(math.MaxInt64),
+			typ:   int16(0),
+			ok:    false, // overflow
+		},
+		{
+			name:     "int64(math.MaxInt16) to int",
+			value:    int64(math.MaxInt16),
+			typ:      int(0),
+			ok:       true,
+			expected: int(math.MaxInt16),
+		},
+
+		{
+			name:     "int64(math.MaxInt16) to int",
+			value:    int64(math.MaxInt16),
+			typ:      int(0),
+			ok:       true,
+			expected: int(math.MaxInt16),
+		},
+		// From float to int.
+		{
+			name:  "float64(1.5) to int",
+			value: float64(1.5),
+			typ:   int(0),
+			ok:    false, // loss of precision
+		},
+		{
+			name:     "float64(1.0) to int",
+			value:    float64(1.0),
+			typ:      int(0),
+			ok:       true,
+			expected: int(1),
+		},
+		{
+			name:  "float64(math.MaxFloat64) to int16",
+			value: float64(math.MaxFloat64),
+			typ:   int16(0),
+			ok:    false, // overflow
+		},
+		{
+			name:     "float64(32767) to int16",
+			value:    float64(32767),
+			typ:      int16(0),
+			ok:       true,
+			expected: int16(32767),
+		},
+	} {
+
+		v, ok := ConvertIfPossible(reflect.ValueOf(test.value), reflect.TypeOf(test.typ))
+		c.Assert(ok, qt.Equals, test.ok, qt.Commentf("test case: %s", test.name))
+		if test.ok {
+			c.Assert(v.Interface(), qt.Equals, test.expected, qt.Commentf("test case: %s", test.name))
+		}
+	}
+}

common/hstrings/strings.go

@@ -16,6 +16,7 @@ package hstrings
 import (
 	"fmt"
 	"regexp"
+	"slices"
 	"strings"
 	"sync"
 
@@ -50,12 +51,7 @@ func (s StringEqualFold) Eq(s2 any) bool {
 
 // EqualAny returns whether a string is equal to any of the given strings.
 func EqualAny(a string, b ...string) bool {
-	for _, s := range b {
-		if a == s {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(b, a)
 }
 
 // regexpCache represents a cache of regexp objects protected by a mutex.
@@ -103,12 +99,7 @@ func GetOrCompileRegexp(pattern string) (re *regexp.Regexp, err error) {
 // InSlice checks if a string is an element of a slice of strings
 // and returns a boolean value.
 func InSlice(arr []string, el string) bool {
-	for _, v := range arr {
-		if v == el {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(arr, el)
 }
 
 // InSlicEqualFold checks if a string is an element of a slice of strings
@@ -137,7 +128,7 @@ func ToString(v any) (string, bool) {
 	return "", false
 }
 
-type Tuple struct {
-	First  string
-	Second string
-}
+type (
+	Strings2 [2]string
+	Strings3 [3]string
+)

common/hugio/hasBytesWriter_test.go

@@ -46,7 +46,7 @@ func TestHasBytesWriter(t *testing.T) {
 		return strings.Repeat("ab cfo", r.Intn(33))
 	}
 
-	for i := 0; i < 22; i++ {
+	for range 22 {
 		h, w := neww()
 		fmt.Fprint(w, rndStr()+"abc __foobar"+rndStr())
 		c.Assert(h.Patterns[0].Match, qt.Equals, true)

common/hugo/hugo.go

@@ -28,12 +28,13 @@ import (
 	"github.com/bep/logg"
 
 	"github.com/bep/godartsass/v2"
-	"github.com/gohugoio/hugo/common/hcontext"
+
 	"github.com/gohugoio/hugo/common/hexec"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/hugofs/files"
 
+	"github.com/bep/helpers/contexthelpers"
 	"github.com/spf13/afero"
 
 	iofs "io/fs"
@@ -139,9 +140,13 @@ func (i HugoInfo) IsMultilingual() bool {
 	return i.conf.IsMultilingual()
 }
 
-type contextKey string
+type contextKey uint8
 
-var markupScope = hcontext.NewContextDispatcher[string](contextKey("markupScope"))
+const (
+	contextKeyMarkupScope contextKey = iota
+)
+
+var markupScope = contexthelpers.NewContextDispatcher[string](contextKeyMarkupScope)
 
 type Context struct{}
 
@@ -411,20 +416,28 @@ func IsDartSassGeV2() bool {
 // 2. Their theme to work for at least the last few Hugo versions.
 func Deprecate(item, alternative string, version string) {
 	level := deprecationLogLevelFromVersion(version)
-	DeprecateLevel(item, alternative, version, level)
+	deprecateLevel(item, alternative, version, level)
+}
+
+// See Deprecate for details.
+func DeprecateWithLogger(item, alternative string, version string, log logg.Logger) {
+	level := deprecationLogLevelFromVersion(version)
+	deprecateLevelWithLogger(item, alternative, version, level, log)
 }
 
 // DeprecateLevelMin informs about a deprecation starting at the given version, but with a minimum log level.
 func DeprecateLevelMin(item, alternative string, version string, minLevel logg.Level) {
-	level := deprecationLogLevelFromVersion(version)
-	if level < minLevel {
-		level = minLevel
-	}
-	DeprecateLevel(item, alternative, version, level)
+	level := max(deprecationLogLevelFromVersion(version), minLevel)
+	deprecateLevel(item, alternative, version, level)
+}
+
+// deprecateLevel informs about a deprecation logging at the given level.
+func deprecateLevel(item, alternative, version string, level logg.Level) {
+	deprecateLevelWithLogger(item, alternative, version, level, loggers.Log().Logger())
 }
 
 // DeprecateLevel informs about a deprecation logging at the given level.
-func DeprecateLevel(item, alternative, version string, level logg.Level) {
+func deprecateLevelWithLogger(item, alternative, version string, level logg.Level, log logg.Logger) {
 	var msg string
 	if level == logg.LevelError {
 		msg = fmt.Sprintf("%s was deprecated in Hugo %s and subsequently removed. %s", item, version, alternative)
@@ -432,7 +445,7 @@ func DeprecateLevel(item, alternative, version string, level logg.Level) {
 		msg = fmt.Sprintf("%s was deprecated in Hugo %s and will be removed in a future release. %s", item, version, alternative)
 	}
 
-	loggers.Log().Logger().WithLevel(level).WithField(loggers.FieldNameCmd, "deprecated").Logf("%s", msg)
+	log.WithLevel(level).WithField(loggers.FieldNameCmd, "deprecated").Logf("%s", msg)
 }
 
 // We usually do about one minor version a month.

common/hugo/version_current.go

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

common/loggers/logger_test.go

@@ -37,7 +37,7 @@ func TestLogDistinct(t *testing.T) {
 
 	l := loggers.New(opts)
 
-	for i := 0; i < 10; i++ {
+	for range 10 {
 		l.Errorln("error 1")
 		l.Errorln("error 2")
 		l.Warnln("warn 1")
@@ -137,7 +137,7 @@ func TestReset(t *testing.T) {
 
 	l := loggers.New(opts)
 
-	for i := 0; i < 3; i++ {
+	for range 3 {
 		l.Errorln("error 1")
 		l.Errorln("error 2")
 		l.Errorln("error 1")

common/maps/cache.go

@@ -20,13 +20,27 @@ import (
 // Cache is a simple thread safe cache backed by a map.
 type Cache[K comparable, T any] struct {
 	m                  map[K]T
+	opts               CacheOptions
 	hasBeenInitialized bool
 	sync.RWMutex
 }
 
-// NewCache creates a new Cache.
+// CacheOptions are the options for the Cache.
+type CacheOptions struct {
+	// If set, the cache will not grow beyond this size.
+	Size uint64
+}
+
+var defaultCacheOptions = CacheOptions{}
+
+// NewCache creates a new Cache with default options.
 func NewCache[K comparable, T any]() *Cache[K, T] {
-	return &Cache[K, T]{m: make(map[K]T)}
+	return &Cache[K, T]{m: make(map[K]T), opts: defaultCacheOptions}
+}
+
+// NewCacheWithOptions creates a new Cache with the given options.
+func NewCacheWithOptions[K comparable, T any](opts CacheOptions) *Cache[K, T] {
+	return &Cache[K, T]{m: make(map[K]T), opts: opts}
 }
 
 // Delete deletes the given key from the cache.
@@ -65,10 +79,19 @@ func (c *Cache[K, T]) GetOrCreate(key K, create func() (T, error)) (T, error) {
 	if err != nil {
 		return v, err
 	}
+	c.clearIfNeeded()
 	c.m[key] = v
 	return v, nil
 }
 
+// Contains returns whether the given key exists in the cache.
+func (c *Cache[K, T]) Contains(key K) bool {
+	c.RLock()
+	_, found := c.m[key]
+	c.RUnlock()
+	return found
+}
+
 // InitAndGet initializes the cache if not already done and returns the value for the given key.
 // The init state will be reset on Reset or Drain.
 func (c *Cache[K, T]) InitAndGet(key K, init func(get func(key K) (T, bool), set func(key K, value T)) error) (T, error) {
@@ -108,7 +131,26 @@ func (c *Cache[K, T]) Set(key K, value T) {
 	c.Unlock()
 }
 
+// SetIfAbsent sets the given key to the given value if the key does not already exist in the cache.
+func (c *Cache[K, T]) SetIfAbsent(key K, value T) {
+	c.RLock()
+	if _, found := c.get(key); !found {
+		c.RUnlock()
+		c.Set(key, value)
+	} else {
+		c.RUnlock()
+	}
+}
+
+func (c *Cache[K, T]) clearIfNeeded() {
+	if c.opts.Size > 0 && uint64(len(c.m)) >= c.opts.Size {
+		// clear the map
+		clear(c.m)
+	}
+}
+
 func (c *Cache[K, T]) set(key K, value T) {
+	c.clearIfNeeded()
 	c.m[key] = value
 }
 
@@ -141,7 +183,7 @@ func (c *Cache[K, T]) Len() int {
 
 func (c *Cache[K, T]) Reset() {
 	c.Lock()
-	c.m = make(map[K]T)
+	clear(c.m)
 	c.hasBeenInitialized = false
 	c.Unlock()
 }

common/maps/cache_test.go

@@ -0,0 +1,57 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package maps
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestCacheSize(t *testing.T) {
+	c := qt.New(t)
+
+	cache := NewCacheWithOptions[string, string](CacheOptions{Size: 10})
+
+	for i := 0; i < 30; i++ {
+		cache.Set(string(rune('a'+i)), "value")
+	}
+
+	c.Assert(len(cache.m), qt.Equals, 10)
+
+	for i := 20; i < 50; i++ {
+		cache.GetOrCreate(string(rune('a'+i)), func() (string, error) {
+			return "value", nil
+		})
+	}
+
+	c.Assert(len(cache.m), qt.Equals, 10)
+
+	for i := 100; i < 200; i++ {
+		cache.SetIfAbsent(string(rune('a'+i)), "value")
+	}
+
+	c.Assert(len(cache.m), qt.Equals, 10)
+
+	cache.InitAndGet("foo", func(
+		get func(key string) (string, bool), set func(key string, value string),
+	) error {
+		for i := 50; i < 100; i++ {
+			set(string(rune('a'+i)), "value")
+		}
+		return nil
+	})
+
+	c.Assert(len(cache.m), qt.Equals, 10)
+}

common/maps/ordered.go

@@ -14,6 +14,8 @@
 package maps
 
 import (
+	"slices"
+
 	"github.com/gohugoio/hugo/common/hashing"
 )
 
@@ -56,6 +58,15 @@ func (m *Ordered[K, T]) Get(key K) (T, bool) {
 	return value, found
 }
 
+// Has returns whether the given key exists in the map.
+func (m *Ordered[K, T]) Has(key K) bool {
+	if m == nil {
+		return false
+	}
+	_, found := m.values[key]
+	return found
+}
+
 // Delete deletes the value for the given key.
 func (m *Ordered[K, T]) Delete(key K) {
 	if m == nil {
@@ -64,7 +75,7 @@ func (m *Ordered[K, T]) Delete(key K) {
 	delete(m.values, key)
 	for i, k := range m.keys {
 		if k == key {
-			m.keys = append(m.keys[:i], m.keys[i+1:]...)
+			m.keys = slices.Delete(m.keys, i, i+1)
 			break
 		}
 	}

common/maps/params.go

@@ -14,6 +14,7 @@
 package maps
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 
@@ -40,6 +41,14 @@ func (p Params) GetNested(indices ...string) any {
 // SetParams overwrites values in dst with values in src for common or new keys.
 // This is done recursively.
 func SetParams(dst, src Params) {
+	setParams(dst, src, 0)
+}
+
+func setParams(dst, src Params, depth int) {
+	const maxDepth = 1000
+	if depth > maxDepth {
+		panic(errors.New("max depth exceeded"))
+	}
 	for k, v := range src {
 		vv, found := dst[k]
 		if !found {
@@ -48,7 +57,7 @@ func SetParams(dst, src Params) {
 			switch vvv := vv.(type) {
 			case Params:
 				if pv, ok := v.(Params); ok {
-					SetParams(vvv, pv)
+					setParams(vvv, pv, depth+1)
 				} else {
 					dst[k] = v
 				}
@@ -101,7 +110,6 @@ func (p Params) merge(ps ParamsMergeStrategy, pp Params) {
 	noUpdate = noUpdate || (ps != "" && ps == ParamsMergeStrategyShallow)
 
 	for k, v := range pp {
-
 		if k == MergeStrategyKey {
 			continue
 		}
@@ -266,9 +274,17 @@ func CleanConfigStringMapString(m map[string]string) map[string]string {
 // CleanConfigStringMap is the same as CleanConfigStringMapString but for
 // map[string]any.
 func CleanConfigStringMap(m map[string]any) map[string]any {
+	return doCleanConfigStringMap(m, 0)
+}
+
+func doCleanConfigStringMap(m map[string]any, depth int) map[string]any {
 	if len(m) == 0 {
 		return m
 	}
+	const maxDepth = 1000
+	if depth > maxDepth {
+		panic(errors.New("max depth exceeded"))
+	}
 	if _, found := m[MergeStrategyKey]; !found {
 		return m
 	}
@@ -280,9 +296,9 @@ func CleanConfigStringMap(m map[string]any) map[string]any {
 		}
 		switch v2 := v.(type) {
 		case map[string]any:
-			m2[k] = CleanConfigStringMap(v2)
+			m2[k] = doCleanConfigStringMap(v2, depth+1)
 		case Params:
-			var p Params = CleanConfigStringMap(v2)
+			var p Params = doCleanConfigStringMap(v2, depth+1)
 			m2[k] = p
 		case map[string]string:
 			m2[k] = CleanConfigStringMapString(v2)
@@ -344,6 +360,29 @@ func PrepareParams(m Params) {
 	}
 }
 
+// CloneParamsDeep does a deep clone of the given Params,
+// meaning that any nested Params will be cloned as well.
+func CloneParamsDeep(m Params) Params {
+	return cloneParamsDeep(m, 0)
+}
+
+func cloneParamsDeep(m Params, depth int) Params {
+	const maxDepth = 1000
+	if depth > maxDepth {
+		panic(errors.New("max depth exceeded"))
+	}
+	m2 := make(Params)
+	for k, v := range m {
+		switch vv := v.(type) {
+		case Params:
+			m2[k] = cloneParamsDeep(vv, depth+1)
+		default:
+			m2[k] = v
+		}
+	}
+	return m2
+}
+
 // PrepareParamsClone is like PrepareParams, but it does not modify the input.
 func PrepareParamsClone(m Params) Params {
 	m2 := make(Params)

common/maps/scratch_test.go

@@ -140,7 +140,7 @@ func TestScratchInParallel(t *testing.T) {
 	for i := 1; i <= 10; i++ {
 		wg.Add(1)
 		go func(j int) {
-			for k := 0; k < 10; k++ {
+			for k := range 10 {
 				newVal := int64(k + j)
 
 				_, err := scratch.Add(key, newVal)

common/para/para_test.go

@@ -42,7 +42,7 @@ func TestPara(t *testing.T) {
 	c.Run("Order", func(c *qt.C) {
 		n := 500
 		ints := make([]int, n)
-		for i := 0; i < n; i++ {
+		for i := range n {
 			ints[i] = i
 		}
 
@@ -51,7 +51,7 @@ func TestPara(t *testing.T) {
 
 		var result []int
 		var mu sync.Mutex
-		for i := 0; i < n; i++ {
+		for i := range n {
 			i := i
 			r.Run(func() error {
 				mu.Lock()
@@ -78,7 +78,7 @@ func TestPara(t *testing.T) {
 
 		var counter int64
 
-		for i := 0; i < n; i++ {
+		for range n {
 			r.Run(func() error {
 				atomic.AddInt64(&counter, 1)
 				time.Sleep(1 * time.Millisecond)

common/paths/pathparser.go

@@ -23,6 +23,11 @@ import (
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/hugofs/files"
 	"github.com/gohugoio/hugo/identity"
+	"github.com/gohugoio/hugo/resources/kinds"
+)
+
+const (
+	identifierBaseof = "baseof"
 )
 
 // PathParser parses a path into a Path.
@@ -33,6 +38,10 @@ type PathParser struct {
 	// Reports whether the given language is disabled.
 	IsLangDisabled func(string) bool
 
+	// IsOutputFormat reports whether the given name is a valid output format.
+	// The second argument is optional.
+	IsOutputFormat func(name, ext string) bool
+
 	// Reports whether the given ext is a content file.
 	IsContentExt func(string) bool
 }
@@ -83,13 +92,10 @@ func (pp *PathParser) Parse(c, s string) *Path {
 }
 
 func (pp *PathParser) newPath(component string) *Path {
-	return &Path{
-		component:             component,
-		posContainerLow:       -1,
-		posContainerHigh:      -1,
-		posSectionHigh:        -1,
-		posIdentifierLanguage: -1,
-	}
+	p := &Path{}
+	p.reset()
+	p.component = component
+	return p
 }
 
 func (pp *PathParser) parse(component, s string) (*Path, error) {
@@ -114,10 +120,101 @@ func (pp *PathParser) parse(component, s string) (*Path, error) {
 	return p, nil
 }
 
-func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
-	hasLang := pp.LanguageIndex != nil
-	hasLang = hasLang && (component == files.ComponentFolderContent || component == files.ComponentFolderLayouts)
+func (pp *PathParser) parseIdentifier(component, s string, p *Path, i, lastDot, numDots int, isLast bool) {
+	if p.posContainerHigh != -1 {
+		return
+	}
+	mayHaveLang := numDots > 1 && p.posIdentifierLanguage == -1 && pp.LanguageIndex != nil
+	mayHaveLang = mayHaveLang && (component == files.ComponentFolderContent || component == files.ComponentFolderLayouts)
+	mayHaveOutputFormat := component == files.ComponentFolderLayouts
+	mayHaveKind := p.posIdentifierKind == -1 && mayHaveOutputFormat
+	var mayHaveLayout bool
+	if p.pathType == TypeShortcode {
+		mayHaveLayout = !isLast && component == files.ComponentFolderLayouts
+	} else {
+		mayHaveLayout = component == files.ComponentFolderLayouts
+	}
 
+	var found bool
+	var high int
+	if len(p.identifiersKnown) > 0 {
+		high = lastDot
+	} else {
+		high = len(p.s)
+	}
+	id := types.LowHigh[string]{Low: i + 1, High: high}
+	sid := p.s[id.Low:id.High]
+
+	if len(p.identifiersKnown) == 0 {
+		// The first is always the extension.
+		p.identifiersKnown = append(p.identifiersKnown, id)
+		found = true
+
+		// May also be the output format.
+		if mayHaveOutputFormat && pp.IsOutputFormat(sid, "") {
+			p.posIdentifierOutputFormat = 0
+		}
+	} else {
+
+		var langFound bool
+
+		if mayHaveLang {
+			var disabled bool
+			_, langFound = pp.LanguageIndex[sid]
+			if !langFound {
+				disabled = pp.IsLangDisabled != nil && pp.IsLangDisabled(sid)
+				if disabled {
+					p.disabled = true
+					langFound = true
+				}
+			}
+			found = langFound
+			if langFound {
+				p.identifiersKnown = append(p.identifiersKnown, id)
+				p.posIdentifierLanguage = len(p.identifiersKnown) - 1
+			}
+		}
+
+		if !found && mayHaveOutputFormat {
+			// At this point we may already have resolved an output format,
+			// but we need to keep looking for a more specific one, e.g. amp before html.
+			// Use both name and extension to prevent
+			// false positives on the form css.html.
+			if pp.IsOutputFormat(sid, p.Ext()) {
+				found = true
+				p.identifiersKnown = append(p.identifiersKnown, id)
+				p.posIdentifierOutputFormat = len(p.identifiersKnown) - 1
+			}
+		}
+
+		if !found && mayHaveKind {
+			if kinds.GetKindMain(sid) != "" {
+				found = true
+				p.identifiersKnown = append(p.identifiersKnown, id)
+				p.posIdentifierKind = len(p.identifiersKnown) - 1
+			}
+		}
+
+		if !found && sid == identifierBaseof {
+			found = true
+			p.identifiersKnown = append(p.identifiersKnown, id)
+			p.posIdentifierBaseof = len(p.identifiersKnown) - 1
+		}
+
+		if !found && mayHaveLayout {
+			p.identifiersKnown = append(p.identifiersKnown, id)
+			p.posIdentifierLayout = len(p.identifiersKnown) - 1
+			found = true
+		}
+
+		if !found {
+			p.identifiersUnknown = append(p.identifiersUnknown, id)
+		}
+
+	}
+}
+
+func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 	if runtime.GOOS == "windows" {
 		s = path.Clean(filepath.ToSlash(s))
 		if s == "." {
@@ -140,46 +237,26 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 
 	p.s = s
 	slashCount := 0
+	lastDot := 0
+	lastSlashIdx := strings.LastIndex(s, "/")
+	numDots := strings.Count(s[lastSlashIdx+1:], ".")
+	if strings.Contains(s, "/_shortcodes/") {
+		p.pathType = TypeShortcode
+	}
 
 	for i := len(s) - 1; i >= 0; i-- {
 		c := s[i]
 
 		switch c {
 		case '.':
-			if p.posContainerHigh == -1 {
-				var high int
-				if len(p.identifiers) > 0 {
-					high = p.identifiers[len(p.identifiers)-1].Low - 1
-				} else {
-					high = len(p.s)
-				}
-				id := types.LowHigh[string]{Low: i + 1, High: high}
-				if len(p.identifiers) == 0 {
-					p.identifiers = append(p.identifiers, id)
-				} else if len(p.identifiers) == 1 {
-					// Check for a valid language.
-					s := p.s[id.Low:id.High]
-
-					if hasLang {
-						var disabled bool
-						_, langFound := pp.LanguageIndex[s]
-						if !langFound {
-							disabled = pp.IsLangDisabled != nil && pp.IsLangDisabled(s)
-							if disabled {
-								p.disabled = true
-								langFound = true
-							}
-						}
-						if langFound {
-							p.posIdentifierLanguage = 1
-							p.identifiers = append(p.identifiers, id)
-						}
-					}
-				}
-			}
+			pp.parseIdentifier(component, s, p, i, lastDot, numDots, false)
+			lastDot = i
 		case '/':
 			slashCount++
 			if p.posContainerHigh == -1 {
+				if lastDot > 0 {
+					pp.parseIdentifier(component, s, p, i, lastDot, numDots, true)
+				}
 				p.posContainerHigh = i + 1
 			} else if p.posContainerLow == -1 {
 				p.posContainerLow = i + 1
@@ -190,26 +267,52 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 		}
 	}
 
-	if len(p.identifiers) > 0 {
+	if len(p.identifiersKnown) > 0 {
 		isContentComponent := p.component == files.ComponentFolderContent || p.component == files.ComponentFolderArchetypes
 		isContent := isContentComponent && pp.IsContentExt(p.Ext())
-		id := p.identifiers[len(p.identifiers)-1]
-		b := p.s[p.posContainerHigh : id.Low-1]
-		if isContent {
-			switch b {
-			case "index":
-				p.bundleType = PathTypeLeaf
-			case "_index":
-				p.bundleType = PathTypeBranch
-			default:
-				p.bundleType = PathTypeContentSingle
-			}
+		id := p.identifiersKnown[len(p.identifiersKnown)-1]
 
-			if slashCount == 2 && p.IsLeafBundle() {
-				p.posSectionHigh = 0
+		if id.Low > p.posContainerHigh {
+			b := p.s[p.posContainerHigh : id.Low-1]
+			if isContent {
+				switch b {
+				case "index":
+					p.pathType = TypeLeaf
+				case "_index":
+					p.pathType = TypeBranch
+				default:
+					p.pathType = TypeContentSingle
+				}
+
+				if slashCount == 2 && p.IsLeafBundle() {
+					p.posSectionHigh = 0
+				}
+			} else if b == files.NameContentData && files.IsContentDataExt(p.Ext()) {
+				p.pathType = TypeContentData
 			}
-		} else if b == files.NameContentData && files.IsContentDataExt(p.Ext()) {
-			p.bundleType = PathTypeContentData
+		}
+	}
+
+	if p.pathType < TypeMarkup && component == files.ComponentFolderLayouts {
+		if p.posIdentifierBaseof != -1 {
+			p.pathType = TypeBaseof
+		} else {
+			pth := p.Path()
+			if strings.Contains(pth, "/_shortcodes/") {
+				p.pathType = TypeShortcode
+			} else if strings.Contains(pth, "/_markup/") {
+				p.pathType = TypeMarkup
+			} else if strings.HasPrefix(pth, "/_partials/") {
+				p.pathType = TypePartial
+			}
+		}
+	}
+
+	if p.pathType == TypeShortcode && p.posIdentifierLayout != -1 {
+		id := p.identifiersKnown[p.posIdentifierLayout]
+		if id.Low == p.posContainerHigh {
+			// First identifier is shortcode name.
+			p.posIdentifierLayout = -1
 		}
 	}
 
@@ -218,35 +321,44 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 
 func ModifyPathBundleTypeResource(p *Path) {
 	if p.IsContent() {
-		p.bundleType = PathTypeContentResource
+		p.pathType = TypeContentResource
 	} else {
-		p.bundleType = PathTypeFile
+		p.pathType = TypeFile
 	}
 }
 
-type PathType int
+//go:generate stringer -type Type
+
+type Type int
 
 const (
+
 	// A generic resource, e.g. a JSON file.
-	PathTypeFile PathType = iota
+	TypeFile Type = iota
 
 	// All below are content files.
 	// A resource of a content type with front matter.
-	PathTypeContentResource
+	TypeContentResource
 
 	// E.g. /blog/my-post.md
-	PathTypeContentSingle
+	TypeContentSingle
 
 	// All below are bundled content files.
 
 	// Leaf bundles, e.g. /blog/my-post/index.md
-	PathTypeLeaf
+	TypeLeaf
 
 	// Branch bundles, e.g. /blog/_index.md
-	PathTypeBranch
+	TypeBranch
 
 	// Content data file, _content.gotmpl.
-	PathTypeContentData
+	TypeContentData
+
+	// Layout types.
+	TypeMarkup
+	TypeShortcode
+	TypePartial
+	TypeBaseof
 )
 
 type Path struct {
@@ -257,13 +369,18 @@ type Path struct {
 	posContainerHigh int
 	posSectionHigh   int
 
-	component  string
-	bundleType PathType
+	component string
+	pathType  Type
 
-	identifiers []types.LowHigh[string]
+	identifiersKnown   []types.LowHigh[string]
+	identifiersUnknown []types.LowHigh[string]
 
-	posIdentifierLanguage int
-	disabled              bool
+	posIdentifierLanguage     int
+	posIdentifierOutputFormat int
+	posIdentifierKind         int
+	posIdentifierLayout       int
+	posIdentifierBaseof       int
+	disabled                  bool
 
 	trimLeadingSlash bool
 
@@ -293,9 +410,13 @@ func (p *Path) reset() {
 	p.posContainerHigh = -1
 	p.posSectionHigh = -1
 	p.component = ""
-	p.bundleType = 0
-	p.identifiers = p.identifiers[:0]
+	p.pathType = 0
+	p.identifiersKnown = p.identifiersKnown[:0]
 	p.posIdentifierLanguage = -1
+	p.posIdentifierOutputFormat = -1
+	p.posIdentifierKind = -1
+	p.posIdentifierLayout = -1
+	p.posIdentifierBaseof = -1
 	p.disabled = false
 	p.trimLeadingSlash = false
 	p.unnormalized = nil
@@ -316,6 +437,9 @@ func (p *Path) norm(s string) string {
 
 // IdentifierBase satisfies identity.Identity.
 func (p *Path) IdentifierBase() string {
+	if p.Component() == files.ComponentFolderLayouts {
+		return p.Path()
+	}
 	return p.Base()
 }
 
@@ -332,6 +456,13 @@ func (p *Path) Container() string {
 	return p.norm(p.s[p.posContainerLow : p.posContainerHigh-1])
 }
 
+func (p *Path) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return p.Path()
+}
+
 // ContainerDir returns the container directory for this path.
 // For content bundles this will be the parent directory.
 func (p *Path) ContainerDir() string {
@@ -352,13 +483,13 @@ func (p *Path) Section() string {
 // IsContent returns true if the path is a content file (e.g. mypost.md).
 // Note that this will also return true for content files in a bundle.
 func (p *Path) IsContent() bool {
-	return p.BundleType() >= PathTypeContentResource
+	return p.Type() >= TypeContentResource && p.Type() <= TypeContentData
 }
 
 // isContentPage returns true if the path is a content file (e.g. mypost.md),
 // but nof if inside a leaf bundle.
 func (p *Path) isContentPage() bool {
-	return p.BundleType() >= PathTypeContentSingle
+	return p.Type() >= TypeContentSingle && p.Type() <= TypeContentData
 }
 
 // Name returns the last element of path.
@@ -372,7 +503,7 @@ func (p *Path) Name() string {
 // Name returns the last element of path without any extension.
 func (p *Path) NameNoExt() string {
 	if i := p.identifierIndex(0); i != -1 {
-		return p.s[p.posContainerHigh : p.identifiers[i].Low-1]
+		return p.s[p.posContainerHigh : p.identifiersKnown[i].Low-1]
 	}
 	return p.s[p.posContainerHigh:]
 }
@@ -384,7 +515,7 @@ func (p *Path) NameNoLang() string {
 		return p.Name()
 	}
 
-	return p.s[p.posContainerHigh:p.identifiers[i].Low-1] + p.s[p.identifiers[i].High:]
+	return p.s[p.posContainerHigh:p.identifiersKnown[i].Low-1] + p.s[p.identifiersKnown[i].High:]
 }
 
 // BaseNameNoIdentifier returns the logical base name for a resource without any identifier (e.g. no extension).
@@ -398,10 +529,26 @@ func (p *Path) BaseNameNoIdentifier() string {
 
 // NameNoIdentifier returns the last element of path without any identifier (e.g. no extension).
 func (p *Path) NameNoIdentifier() string {
-	if len(p.identifiers) > 0 {
-		return p.s[p.posContainerHigh : p.identifiers[len(p.identifiers)-1].Low-1]
+	lowHigh := p.nameLowHigh()
+	return p.s[lowHigh.Low:lowHigh.High]
+}
+
+func (p *Path) nameLowHigh() types.LowHigh[string] {
+	if len(p.identifiersKnown) > 0 {
+		lastID := p.identifiersKnown[len(p.identifiersKnown)-1]
+		if p.posContainerHigh == lastID.Low {
+			// The last identifier is the name.
+			return lastID
+		}
+		return types.LowHigh[string]{
+			Low:  p.posContainerHigh,
+			High: p.identifiersKnown[len(p.identifiersKnown)-1].Low - 1,
+		}
+	}
+	return types.LowHigh[string]{
+		Low:  p.posContainerHigh,
+		High: len(p.s),
 	}
-	return p.s[p.posContainerHigh:]
 }
 
 // Dir returns all but the last element of path, typically the path's directory.
@@ -421,6 +568,11 @@ func (p *Path) Path() (d string) {
 	return p.norm(p.s)
 }
 
+// PathNoLeadingSlash returns the full path without the leading slash.
+func (p *Path) PathNoLeadingSlash() string {
+	return p.Path()[1:]
+}
+
 // Unnormalized returns the Path with the original case preserved.
 func (p *Path) Unnormalized() *Path {
 	return p.unnormalized
@@ -436,6 +588,28 @@ func (p *Path) PathNoIdentifier() string {
 	return p.base(false, false)
 }
 
+// PathBeforeLangAndOutputFormatAndExt returns the path up to the first identifier that is not a language or output format.
+func (p *Path) PathBeforeLangAndOutputFormatAndExt() string {
+	if len(p.identifiersKnown) == 0 {
+		return p.norm(p.s)
+	}
+	i := p.identifierIndex(0)
+
+	if j := p.posIdentifierOutputFormat; i == -1 || (j != -1 && j < i) {
+		i = j
+	}
+	if j := p.posIdentifierLanguage; i == -1 || (j != -1 && j < i) {
+		i = j
+	}
+
+	if i == -1 {
+		return p.norm(p.s)
+	}
+
+	id := p.identifiersKnown[i]
+	return p.norm(p.s[:id.Low-1])
+}
+
 // PathRel returns the path relative to the given owner.
 func (p *Path) PathRel(owner *Path) string {
 	ob := owner.Base()
@@ -462,26 +636,42 @@ func (p *Path) Base() string {
 	return p.base(!p.isContentPage(), p.IsBundle())
 }
 
+// Used in template lookups.
+// For pages with Type set, we treat that as the section.
+func (p *Path) BaseReTyped(typ string) (d string) {
+	base := p.Base()
+	if typ == "" || p.Section() == typ {
+		return base
+	}
+	d = "/" + typ
+	if p.posSectionHigh != -1 {
+		d += base[p.posSectionHigh:]
+	}
+	d = p.norm(d)
+	return
+}
+
 // BaseNoLeadingSlash returns the base path without the leading slash.
 func (p *Path) BaseNoLeadingSlash() string {
 	return p.Base()[1:]
 }
 
 func (p *Path) base(preserveExt, isBundle bool) string {
-	if len(p.identifiers) == 0 {
+	if len(p.identifiersKnown) == 0 {
 		return p.norm(p.s)
 	}
 
-	if preserveExt && len(p.identifiers) == 1 {
+	if preserveExt && len(p.identifiersKnown) == 1 {
 		// Preserve extension.
 		return p.norm(p.s)
 	}
 
-	id := p.identifiers[len(p.identifiers)-1]
-	high := id.Low - 1
+	var high int
 
 	if isBundle {
 		high = p.posContainerHigh - 1
+	} else {
+		high = p.nameLowHigh().High
 	}
 
 	if high == 0 {
@@ -493,7 +683,7 @@ func (p *Path) base(preserveExt, isBundle bool) string {
 	}
 
 	// For txt files etc. we want to preserve the extension.
-	id = p.identifiers[0]
+	id := p.identifiersKnown[0]
 
 	return p.norm(p.s[:high] + p.s[id.Low-1:id.High])
 }
@@ -502,8 +692,20 @@ func (p *Path) Ext() string {
 	return p.identifierAsString(0)
 }
 
+func (p *Path) OutputFormat() string {
+	return p.identifierAsString(p.posIdentifierOutputFormat)
+}
+
+func (p *Path) Kind() string {
+	return p.identifierAsString(p.posIdentifierKind)
+}
+
+func (p *Path) Layout() string {
+	return p.identifierAsString(p.posIdentifierLayout)
+}
+
 func (p *Path) Lang() string {
-	return p.identifierAsString(1)
+	return p.identifierAsString(p.posIdentifierLanguage)
 }
 
 func (p *Path) Identifier(i int) string {
@@ -515,35 +717,43 @@ func (p *Path) Disabled() bool {
 }
 
 func (p *Path) Identifiers() []string {
-	ids := make([]string, len(p.identifiers))
-	for i, id := range p.identifiers {
+	ids := make([]string, len(p.identifiersKnown))
+	for i, id := range p.identifiersKnown {
 		ids[i] = p.s[id.Low:id.High]
 	}
 	return ids
 }
 
-func (p *Path) BundleType() PathType {
-	return p.bundleType
+func (p *Path) IdentifiersUnknown() []string {
+	ids := make([]string, len(p.identifiersUnknown))
+	for i, id := range p.identifiersUnknown {
+		ids[i] = p.s[id.Low:id.High]
+	}
+	return ids
+}
+
+func (p *Path) Type() Type {
+	return p.pathType
 }
 
 func (p *Path) IsBundle() bool {
-	return p.bundleType >= PathTypeLeaf
+	return p.pathType >= TypeLeaf && p.pathType <= TypeContentData
 }
 
 func (p *Path) IsBranchBundle() bool {
-	return p.bundleType == PathTypeBranch
+	return p.pathType == TypeBranch
 }
 
 func (p *Path) IsLeafBundle() bool {
-	return p.bundleType == PathTypeLeaf
+	return p.pathType == TypeLeaf
 }
 
 func (p *Path) IsContentData() bool {
-	return p.bundleType == PathTypeContentData
+	return p.pathType == TypeContentData
 }
 
-func (p Path) ForBundleType(t PathType) *Path {
-	p.bundleType = t
+func (p Path) ForType(t Type) *Path {
+	p.pathType = t
 	return &p
 }
 
@@ -553,12 +763,12 @@ func (p *Path) identifierAsString(i int) string {
 		return ""
 	}
 
-	id := p.identifiers[i]
+	id := p.identifiersKnown[i]
 	return p.s[id.Low:id.High]
 }
 
 func (p *Path) identifierIndex(i int) int {
-	if i < 0 || i >= len(p.identifiers) {
+	if i < 0 || i >= len(p.identifiersKnown) {
 		return -1
 	}
 	return i

common/paths/pathparser_test.go

@@ -18,6 +18,7 @@ import (
 	"testing"
 
 	"github.com/gohugoio/hugo/hugofs/files"
+	"github.com/gohugoio/hugo/resources/kinds"
 
 	qt "github.com/frankban/quicktest"
 )
@@ -26,10 +27,18 @@ var testParser = &PathParser{
 	LanguageIndex: map[string]int{
 		"no": 0,
 		"en": 1,
+		"fr": 2,
 	},
 	IsContentExt: func(ext string) bool {
 		return ext == "md"
 	},
+	IsOutputFormat: func(name, ext string) bool {
+		switch name {
+		case "html", "amp", "csv", "rss":
+			return true
+		}
+		return false
+	},
 }
 
 func TestParse(t *testing.T) {
@@ -105,17 +114,19 @@ func TestParse(t *testing.T) {
 			"Basic Markdown file",
 			"/a/b/c.md",
 			func(c *qt.C, p *Path) {
+				c.Assert(p.Ext(), qt.Equals, "md")
+				c.Assert(p.Type(), qt.Equals, TypeContentSingle)
 				c.Assert(p.IsContent(), qt.IsTrue)
 				c.Assert(p.IsLeafBundle(), qt.IsFalse)
 				c.Assert(p.Name(), qt.Equals, "c.md")
 				c.Assert(p.Base(), qt.Equals, "/a/b/c")
+				c.Assert(p.BaseReTyped("foo"), qt.Equals, "/foo/b/c")
 				c.Assert(p.Section(), qt.Equals, "a")
 				c.Assert(p.BaseNameNoIdentifier(), qt.Equals, "c")
 				c.Assert(p.Path(), qt.Equals, "/a/b/c.md")
 				c.Assert(p.Dir(), qt.Equals, "/a/b")
 				c.Assert(p.Container(), qt.Equals, "b")
 				c.Assert(p.ContainerDir(), qt.Equals, "/a/b")
-				c.Assert(p.Ext(), qt.Equals, "md")
 			},
 		},
 		{
@@ -130,7 +141,7 @@ func TestParse(t *testing.T) {
 
 				// Reclassify it as a content resource.
 				ModifyPathBundleTypeResource(p)
-				c.Assert(p.BundleType(), qt.Equals, PathTypeContentResource)
+				c.Assert(p.Type(), qt.Equals, TypeContentResource)
 				c.Assert(p.IsContent(), qt.IsTrue)
 				c.Assert(p.Name(), qt.Equals, "b.md")
 				c.Assert(p.Base(), qt.Equals, "/a/b.md")
@@ -163,8 +174,10 @@ func TestParse(t *testing.T) {
 				c.Assert(p.NameNoIdentifier(), qt.Equals, "b.a.b")
 				c.Assert(p.NameNoLang(), qt.Equals, "b.a.b.txt")
 				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"txt", "no"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{"b", "a", "b"})
 				c.Assert(p.Base(), qt.Equals, "/a/b.a.b.txt")
 				c.Assert(p.BaseNoLeadingSlash(), qt.Equals, "a/b.a.b.txt")
+				c.Assert(p.Path(), qt.Equals, "/a/b.a.b.no.txt")
 				c.Assert(p.PathNoLang(), qt.Equals, "/a/b.a.b.txt")
 				c.Assert(p.Ext(), qt.Equals, "txt")
 				c.Assert(p.PathNoIdentifier(), qt.Equals, "/a/b.a.b")
@@ -174,7 +187,11 @@ func TestParse(t *testing.T) {
 			"Home branch cundle",
 			"/_index.md",
 			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"md"})
+				c.Assert(p.IsBranchBundle(), qt.IsTrue)
+				c.Assert(p.IsBundle(), qt.IsTrue)
 				c.Assert(p.Base(), qt.Equals, "/")
+				c.Assert(p.BaseReTyped("foo"), qt.Equals, "/foo")
 				c.Assert(p.Path(), qt.Equals, "/_index.md")
 				c.Assert(p.Container(), qt.Equals, "")
 				c.Assert(p.ContainerDir(), qt.Equals, "/")
@@ -185,12 +202,14 @@ func TestParse(t *testing.T) {
 			"/a/index.md",
 			func(c *qt.C, p *Path) {
 				c.Assert(p.Base(), qt.Equals, "/a")
+				c.Assert(p.BaseReTyped("foo"), qt.Equals, "/foo/a")
 				c.Assert(p.BaseNameNoIdentifier(), qt.Equals, "a")
 				c.Assert(p.Container(), qt.Equals, "a")
 				c.Assert(p.Container(), qt.Equals, "a")
 				c.Assert(p.ContainerDir(), qt.Equals, "")
 				c.Assert(p.Dir(), qt.Equals, "/a")
 				c.Assert(p.Ext(), qt.Equals, "md")
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{"index"})
 				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"md"})
 				c.Assert(p.IsBranchBundle(), qt.IsFalse)
 				c.Assert(p.IsBundle(), qt.IsTrue)
@@ -208,6 +227,7 @@ func TestParse(t *testing.T) {
 			func(c *qt.C, p *Path) {
 				c.Assert(p.Base(), qt.Equals, "/a/b")
 				c.Assert(p.BaseNameNoIdentifier(), qt.Equals, "b")
+				c.Assert(p.BaseReTyped("foo"), qt.Equals, "/foo/b")
 				c.Assert(p.Container(), qt.Equals, "b")
 				c.Assert(p.ContainerDir(), qt.Equals, "/a")
 				c.Assert(p.Dir(), qt.Equals, "/a/b")
@@ -220,6 +240,7 @@ func TestParse(t *testing.T) {
 				c.Assert(p.NameNoExt(), qt.Equals, "index.no")
 				c.Assert(p.NameNoIdentifier(), qt.Equals, "index")
 				c.Assert(p.NameNoLang(), qt.Equals, "index.md")
+				c.Assert(p.Path(), qt.Equals, "/a/b/index.no.md")
 				c.Assert(p.PathNoLang(), qt.Equals, "/a/b/index.md")
 				c.Assert(p.Section(), qt.Equals, "a")
 			},
@@ -355,11 +376,225 @@ func TestParse(t *testing.T) {
 	}
 	for _, test := range tests {
 		c.Run(test.name, func(c *qt.C) {
+			if test.name != "Home branch cundle" {
+				// return
+			}
 			test.assert(c, testParser.Parse(files.ComponentFolderContent, test.path))
 		})
 	}
 }
 
+func TestParseLayouts(t *testing.T) {
+	c := qt.New(t)
+
+	tests := []struct {
+		name   string
+		path   string
+		assert func(c *qt.C, p *Path)
+	}{
+		{
+			"Basic",
+			"/list.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Base(), qt.Equals, "/list.html")
+				c.Assert(p.OutputFormat(), qt.Equals, "html")
+			},
+		},
+		{
+			"Lang",
+			"/list.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "no", "list"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Base(), qt.Equals, "/list.html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+			},
+		},
+		{
+			"Kind",
+			"/section.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Kind(), qt.Equals, kinds.KindSection)
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "no", "section"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Base(), qt.Equals, "/section.html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+			},
+		},
+		{
+			"Layout",
+			"/list.section.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Layout(), qt.Equals, "list")
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "no", "section", "list"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Base(), qt.Equals, "/list.html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+			},
+		},
+		{
+			"Layout multiple",
+			"/mylayout.list.section.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Layout(), qt.Equals, "mylayout")
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "no", "section", "list", "mylayout"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Base(), qt.Equals, "/mylayout.html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+			},
+		},
+		{
+			"Layout shortcode",
+			"/_shortcodes/myshort.list.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Layout(), qt.Equals, "list")
+			},
+		},
+		{
+			"Layout baseof",
+			"/baseof.list.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Layout(), qt.Equals, "list")
+			},
+		},
+		{
+			"Lang and output format",
+			"/list.no.amp.not.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "not", "amp", "no", "list"})
+				c.Assert(p.OutputFormat(), qt.Equals, "amp")
+				c.Assert(p.Ext(), qt.Equals, "html")
+				c.Assert(p.Lang(), qt.Equals, "no")
+				c.Assert(p.Base(), qt.Equals, "/list.html")
+			},
+		},
+		{
+			"Term",
+			"/term.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Base(), qt.Equals, "/term.html")
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "term"})
+				c.Assert(p.PathNoIdentifier(), qt.Equals, "/term")
+				c.Assert(p.PathBeforeLangAndOutputFormatAndExt(), qt.Equals, "/term")
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.Kind(), qt.Equals, "term")
+				c.Assert(p.OutputFormat(), qt.Equals, "html")
+			},
+		},
+		{
+			"Shortcode with layout",
+			"/_shortcodes/myshortcode.list.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Base(), qt.Equals, "/_shortcodes/myshortcode.html")
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "list"})
+				c.Assert(p.Layout(), qt.Equals, "list")
+				c.Assert(p.PathNoIdentifier(), qt.Equals, "/_shortcodes/myshortcode")
+				c.Assert(p.PathBeforeLangAndOutputFormatAndExt(), qt.Equals, "/_shortcodes/myshortcode.list")
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.Kind(), qt.Equals, "")
+				c.Assert(p.OutputFormat(), qt.Equals, "html")
+			},
+		},
+		{
+			"Sub dir",
+			"/pages/home.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "home"})
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.Kind(), qt.Equals, "home")
+				c.Assert(p.OutputFormat(), qt.Equals, "html")
+				c.Assert(p.Dir(), qt.Equals, "/pages")
+			},
+		},
+		{
+			"Baseof",
+			"/pages/baseof.list.section.fr.amp.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "amp", "fr", "section", "list", "baseof"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{})
+				c.Assert(p.Kind(), qt.Equals, kinds.KindSection)
+				c.Assert(p.Lang(), qt.Equals, "fr")
+				c.Assert(p.OutputFormat(), qt.Equals, "amp")
+				c.Assert(p.Dir(), qt.Equals, "/pages")
+				c.Assert(p.NameNoIdentifier(), qt.Equals, "baseof")
+				c.Assert(p.Type(), qt.Equals, TypeBaseof)
+				c.Assert(p.IdentifierBase(), qt.Equals, "/pages/baseof.list.section.fr.amp.html")
+			},
+		},
+		{
+			"Markup",
+			"/_markup/render-link.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeMarkup)
+			},
+		},
+		{
+			"Markup nested",
+			"/foo/_markup/render-link.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeMarkup)
+			},
+		},
+		{
+			"Shortcode",
+			"/_shortcodes/myshortcode.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+			},
+		},
+		{
+			"Shortcode nested",
+			"/foo/_shortcodes/myshortcode.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+			},
+		},
+		{
+			"Shortcode nested sub",
+			"/foo/_shortcodes/foo/myshortcode.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+			},
+		},
+		{
+			"Partials",
+			"/_partials/foo.bar",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypePartial)
+			},
+		},
+		{
+			"Shortcode lang in root",
+			"/_shortcodes/no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.NameNoIdentifier(), qt.Equals, "no")
+			},
+		},
+		{
+			"Shortcode lang layout",
+			"/_shortcodes/myshortcode.no.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Type(), qt.Equals, TypeShortcode)
+				c.Assert(p.Lang(), qt.Equals, "no")
+				c.Assert(p.Layout(), qt.Equals, "")
+				c.Assert(p.NameNoIdentifier(), qt.Equals, "myshortcode")
+			},
+		},
+	}
+
+	for _, test := range tests {
+		c.Run(test.name, func(c *qt.C) {
+			if test.name != "Shortcode lang layout" {
+				// return
+			}
+			test.assert(c, testParser.Parse(files.ComponentFolderLayouts, test.path))
+		})
+	}
+}
+
 func TestHasExt(t *testing.T) {
 	c := qt.New(t)
 

common/paths/paths_integration_test.go

@@ -78,3 +78,26 @@ disablePathToLower = true
 	b.AssertFileContent("public/en/mysection/mybundle/index.html", "en|Single")
 	b.AssertFileContent("public/fr/MySection/MyBundle/index.html", "fr|Single")
 }
+
+func TestIssue13596(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['home','rss','section','sitemap','taxonomy','term']
+-- content/p1/index.md --
+---
+title: p1
+---
+-- content/p1/a.1.txt --
+-- content/p1/a.2.txt --
+-- layouts/all.html --
+{{ range .Resources.Match "*" }}{{ .Name }}|{{ end }}
+`
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/p1/index.html", "a.1.txt|a.2.txt|")
+	b.AssertFileExists("public/p1/a.1.txt", true)
+	b.AssertFileExists("public/p1/a.2.txt", true) // fails
+}

common/paths/pathtype_string.go

@@ -1,27 +0,0 @@
-// Code generated by "stringer -type=PathType"; DO NOT EDIT.
-
-package paths
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[PathTypeFile-0]
-	_ = x[PathTypeContentResource-1]
-	_ = x[PathTypeContentSingle-2]
-	_ = x[PathTypeLeaf-3]
-	_ = x[PathTypeBranch-4]
-}
-
-const _PathType_name = "PathTypeFilePathTypeContentResourcePathTypeContentSinglePathTypeLeafPathTypeBranch"
-
-var _PathType_index = [...]uint8{0, 12, 35, 56, 68, 82}
-
-func (i PathType) String() string {
-	if i < 0 || i >= PathType(len(_PathType_index)-1) {
-		return "PathType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _PathType_name[_PathType_index[i]:_PathType_index[i+1]]
-}

common/paths/type_string.go

@@ -0,0 +1,32 @@
+// Code generated by "stringer -type Type"; DO NOT EDIT.
+
+package paths
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[TypeFile-0]
+	_ = x[TypeContentResource-1]
+	_ = x[TypeContentSingle-2]
+	_ = x[TypeLeaf-3]
+	_ = x[TypeBranch-4]
+	_ = x[TypeContentData-5]
+	_ = x[TypeMarkup-6]
+	_ = x[TypeShortcode-7]
+	_ = x[TypePartial-8]
+	_ = x[TypeBaseof-9]
+}
+
+const _Type_name = "TypeFileTypeContentResourceTypeContentSingleTypeLeafTypeBranchTypeContentDataTypeMarkupTypeShortcodeTypePartialTypeBaseof"
+
+var _Type_index = [...]uint8{0, 8, 27, 44, 52, 62, 77, 87, 100, 111, 121}
+
+func (i Type) String() string {
+	if i < 0 || i >= Type(len(_Type_index)-1) {
+		return "Type(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _Type_name[_Type_index[i]:_Type_index[i+1]]
+}

common/rungroup/rungroup.go

@@ -51,7 +51,7 @@ func Run[T any](ctx context.Context, cfg Config[T]) Group[T] {
 	// Buffered for performance.
 	ch := make(chan T, cfg.NumWorkers)
 
-	for i := 0; i < cfg.NumWorkers; i++ {
+	for range cfg.NumWorkers {
 		g.Go(func() error {
 			for {
 				select {

common/tasks/tasks.go

@@ -103,10 +103,7 @@ func (r *RunEvery) Add(name string, f Func) {
 		f.IntervalHigh = 20 * time.Second
 	}
 
-	start := f.IntervalHigh / 3
-	if start < f.IntervalLow {
-		start = f.IntervalLow
-	}
+	start := max(f.IntervalHigh/3, f.IntervalLow)
 	f.interval = start
 	f.last = time.Now()
 

common/terminal/colors.go

@@ -16,8 +16,8 @@ package terminal
 
 import (
 	"fmt"
+	"io"
 	"os"
-	"runtime"
 	"strings"
 
 	isatty "github.com/mattn/go-isatty"
@@ -41,10 +41,6 @@ func PrintANSIColors(f *os.File) bool {
 // IsTerminal return true if the file descriptor is terminal and the TERM
 // environment variable isn't a dumb one.
 func IsTerminal(f *os.File) bool {
-	if runtime.GOOS == "windows" {
-		return false
-	}
-
 	fd := f.Fd()
 	return os.Getenv("TERM") != "dumb" && (isatty.IsTerminal(fd) || isatty.IsCygwinTerminal(fd))
 }
@@ -77,3 +73,27 @@ func doublePercent(str string) string {
 func singlePercent(str string) string {
 	return strings.Replace(str, "%%", "%", -1)
 }
+
+type ProgressState int
+
+const (
+	ProgressHidden ProgressState = iota
+	ProgressNormal
+	ProgressError
+	ProgressIntermediate
+	ProgressWarning
+)
+
+// ReportProgress writes OSC 9;4 sequence to w.
+func ReportProgress(w io.Writer, state ProgressState, progress float64) {
+	if progress < 0 {
+		progress = 0.0
+	}
+	if progress > 1 {
+		progress = 1.0
+	}
+
+	pi := int(progress * 100)
+
+	fmt.Fprintf(w, "\033]9;4;%d;%d\007", state, pi)
+}

common/types/convert.go

@@ -69,7 +69,7 @@ func ToStringSlicePreserveStringE(v any) ([]string, error) {
 	switch vv.Kind() {
 	case reflect.Slice, reflect.Array:
 		result = make([]string, vv.Len())
-		for i := 0; i < vv.Len(); i++ {
+		for i := range vv.Len() {
 			s, err := cast.ToStringE(vv.Index(i).Interface())
 			if err != nil {
 				return nil, err

common/types/evictingqueue.go

@@ -15,6 +15,7 @@
 package types
 
 import (
+	"slices"
 	"sync"
 )
 
@@ -45,7 +46,7 @@ func (q *EvictingQueue[T]) Add(v T) *EvictingQueue[T] {
 	if len(q.set) == q.size {
 		// Full
 		delete(q.set, q.vals[0])
-		q.vals = append(q.vals[:0], q.vals[1:]...)
+		q.vals = slices.Delete(q.vals, 0, 1)
 	}
 	q.set[v] = true
 	q.vals = append(q.vals, v)

common/types/evictingqueue_test.go

@@ -55,7 +55,7 @@ func TestEvictingStringQueueConcurrent(t *testing.T) {
 
 	queue := NewEvictingQueue[string](3)
 
-	for j := 0; j < 100; j++ {
+	for range 100 {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()

common/types/types.go

@@ -28,6 +28,16 @@ type RLocker interface {
 	RUnlock()
 }
 
+type Locker interface {
+	Lock()
+	Unlock()
+}
+
+type RWLocker interface {
+	RLocker
+	Locker
+}
+
 // KeyValue is a interface{} tuple.
 type KeyValue struct {
 	Key   any
@@ -59,7 +69,7 @@ func (k KeyValues) String() string {
 // KeyValues struct.
 func NewKeyValuesStrings(key string, values ...string) KeyValues {
 	iv := make([]any, len(values))
-	for i := 0; i < len(values); i++ {
+	for i := range values {
 		iv[i] = values[i]
 	}
 	return KeyValues{Key: key, Values: iv}

config/allconfig/allconfig.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"reflect"
 	"regexp"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -32,7 +33,6 @@ import (
 	"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/common/urls"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/privacy"
@@ -42,6 +42,7 @@ import (
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugolib/segments"
 	"github.com/gohugoio/hugo/langs"
+	gc "github.com/gohugoio/hugo/markup/goldmark/goldmark_config"
 	"github.com/gohugoio/hugo/markup/markup_config"
 	"github.com/gohugoio/hugo/media"
 	"github.com/gohugoio/hugo/minifiers"
@@ -54,8 +55,6 @@ import (
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/resources/page/pagemeta"
 	"github.com/spf13/afero"
-
-	xmaps "golang.org/x/exp/maps"
 )
 
 // InternalConfig is the internal configuration for Hugo, not read from any user provided config file.
@@ -82,7 +81,7 @@ func init() {
 	}
 	configLanguageKeys = make(map[string]bool)
 	addKeys := func(v reflect.Value) {
-		for i := 0; i < v.NumField(); i++ {
+		for i := range v.NumField() {
 			name := strings.ToLower(v.Type().Field(i).Name)
 			if skip[name] {
 				continue
@@ -146,7 +145,7 @@ type Config struct {
 
 	// The cascade configuration section contains the top level front matter cascade configuration options,
 	// a slice of page matcher and params to apply to those pages.
-	Cascade *config.ConfigNamespace[[]page.PageMatcherParamsConfig, *maps.Ordered[page.PageMatcher, maps.Params]] `mapstructure:"-"`
+	Cascade *config.ConfigNamespace[[]page.PageMatcherParamsConfig, *maps.Ordered[page.PageMatcher, page.PageMatcherParamsConfig]] `mapstructure:"-"`
 
 	// The segments defines segments for the site. Used for partial/segmented builds.
 	Segments *config.ConfigNamespace[map[string]segments.SegmentConfig, segments.Segments] `mapstructure:"-"`
@@ -396,44 +395,80 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 
 	// Legacy paginate values.
 	if c.Paginate != 0 {
-		hugo.Deprecate("site config key paginate", "Use pagination.pagerSize instead.", "v0.128.0")
+		hugo.DeprecateWithLogger("site config key paginate", "Use pagination.pagerSize instead.", "v0.128.0", logger.Logger())
 		c.Pagination.PagerSize = c.Paginate
 	}
-
 	if c.PaginatePath != "" {
-		hugo.Deprecate("site config key paginatePath", "Use pagination.path instead.", "v0.128.0")
+		hugo.DeprecateWithLogger("site config key paginatePath", "Use pagination.path instead.", "v0.128.0", logger.Logger())
 		c.Pagination.Path = c.PaginatePath
 	}
 
 	// Legacy privacy values.
 	if c.Privacy.Twitter.Disable {
-		hugo.Deprecate("site config key privacy.twitter.disable", "Use privacy.x.disable instead.", "v0.141.0")
+		hugo.DeprecateWithLogger("site config key privacy.twitter.disable", "Use privacy.x.disable instead.", "v0.141.0", logger.Logger())
 		c.Privacy.X.Disable = c.Privacy.Twitter.Disable
 	}
-
 	if c.Privacy.Twitter.EnableDNT {
-		hugo.Deprecate("site config key privacy.twitter.enableDNT", "Use privacy.x.enableDNT instead.", "v0.141.0")
+		hugo.DeprecateWithLogger("site config key privacy.twitter.enableDNT", "Use privacy.x.enableDNT instead.", "v0.141.0", logger.Logger())
 		c.Privacy.X.EnableDNT = c.Privacy.Twitter.EnableDNT
 	}
-
 	if c.Privacy.Twitter.Simple {
-		hugo.Deprecate("site config key privacy.twitter.simple", "Use privacy.x.simple instead.", "v0.141.0")
+		hugo.DeprecateWithLogger("site config key privacy.twitter.simple", "Use privacy.x.simple instead.", "v0.141.0", logger.Logger())
 		c.Privacy.X.Simple = c.Privacy.Twitter.Simple
 	}
 
 	// Legacy services values.
 	if c.Services.Twitter.DisableInlineCSS {
-		hugo.Deprecate("site config key services.twitter.disableInlineCSS", "Use services.x.disableInlineCSS instead.", "v0.141.0")
+		hugo.DeprecateWithLogger("site config key services.twitter.disableInlineCSS", "Use services.x.disableInlineCSS instead.", "v0.141.0", logger.Logger())
 		c.Services.X.DisableInlineCSS = c.Services.Twitter.DisableInlineCSS
 	}
 
 	// Legacy permalink tokens
 	vs := fmt.Sprintf("%v", c.Permalinks)
 	if strings.Contains(vs, ":filename") {
-		hugo.Deprecate("the \":filename\" permalink token", "Use \":contentbasename\" instead.", "0.144.0")
+		hugo.DeprecateWithLogger("the \":filename\" permalink token", "Use \":contentbasename\" instead.", "0.144.0", logger.Logger())
 	}
 	if strings.Contains(vs, ":slugorfilename") {
-		hugo.Deprecate("the \":slugorfilename\" permalink token", "Use \":slugorcontentbasename\" instead.", "0.144.0")
+		hugo.DeprecateWithLogger("the \":slugorfilename\" permalink token", "Use \":slugorcontentbasename\" instead.", "0.144.0", logger.Logger())
+	}
+
+	// Legacy render hook values.
+	alternativeDetails := fmt.Sprintf(
+		"Set to %q if previous value was false, or set to %q if previous value was true.",
+		gc.RenderHookUseEmbeddedNever,
+		gc.RenderHookUseEmbeddedFallback,
+	)
+	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())
+		if *c.Markup.Goldmark.RenderHooks.Image.EnableDefault {
+			c.Markup.Goldmark.RenderHooks.Image.UseEmbedded = gc.RenderHookUseEmbeddedFallback
+		} else {
+			c.Markup.Goldmark.RenderHooks.Image.UseEmbedded = gc.RenderHookUseEmbeddedNever
+		}
+	}
+	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())
+		if *c.Markup.Goldmark.RenderHooks.Link.EnableDefault {
+			c.Markup.Goldmark.RenderHooks.Link.UseEmbedded = gc.RenderHookUseEmbeddedFallback
+		} else {
+			c.Markup.Goldmark.RenderHooks.Link.UseEmbedded = gc.RenderHookUseEmbeddedNever
+		}
+	}
+
+	// Validate render hook configuration.
+	renderHookUseEmbeddedModes := []string{
+		gc.RenderHookUseEmbeddedAlways,
+		gc.RenderHookUseEmbeddedAuto,
+		gc.RenderHookUseEmbeddedFallback,
+		gc.RenderHookUseEmbeddedNever,
+	}
+	if !slices.Contains(renderHookUseEmbeddedModes, c.Markup.Goldmark.RenderHooks.Image.UseEmbedded) {
+		return fmt.Errorf("site config markup.goldmark.renderHooks.image 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 must be one of %s", helpers.StringSliceToList(renderHookUseEmbeddedModes, "or"))
 	}
 
 	c.C = &ConfigCompiled{
@@ -776,7 +811,7 @@ type Configs struct {
 }
 
 func (c *Configs) Validate(logger loggers.Logger) error {
-	c.Base.Cascade.Config.Range(func(p page.PageMatcher, params maps.Params) bool {
+	c.Base.Cascade.Config.Range(func(p page.PageMatcher, cfg page.PageMatcherParamsConfig) bool {
 		page.CheckCascadePattern(logger, p)
 		return true
 	})
@@ -800,30 +835,58 @@ func (c *Configs) IsZero() bool {
 
 func (c *Configs) Init() error {
 	var languages langs.Languages
-	defaultContentLanguage := c.Base.DefaultContentLanguage
-	for k, v := range c.LanguageConfigMap {
+
+	var langKeys []string
+	var hasEn bool
+
+	const en = "en"
+
+	for k := range c.LanguageConfigMap {
+		langKeys = append(langKeys, k)
+		if k == en {
+			hasEn = true
+		}
+	}
+
+	// Sort the LanguageConfigSlice by language weight (if set) or lang.
+	sort.Slice(langKeys, func(i, j int) bool {
+		ki := langKeys[i]
+		kj := langKeys[j]
+		lki := c.LanguageConfigMap[ki]
+		lkj := c.LanguageConfigMap[kj]
+		li := lki.Languages[ki]
+		lj := lkj.Languages[kj]
+		if li.Weight != lj.Weight {
+			return li.Weight < lj.Weight
+		}
+		return ki < kj
+	})
+
+	// See issue #13646.
+	defaultConfigLanguageFallback := en
+	if !hasEn {
+		// Pick the first one.
+		defaultConfigLanguageFallback = langKeys[0]
+	}
+
+	if c.Base.DefaultContentLanguage == "" {
+		c.Base.DefaultContentLanguage = defaultConfigLanguageFallback
+	}
+
+	for _, k := range langKeys {
+		v := c.LanguageConfigMap[k]
+		if v.DefaultContentLanguage == "" {
+			v.DefaultContentLanguage = defaultConfigLanguageFallback
+		}
+		c.LanguageConfigSlice = append(c.LanguageConfigSlice, v)
 		languageConf := v.Languages[k]
-		language, err := langs.NewLanguage(k, defaultContentLanguage, v.TimeZone, languageConf)
+		language, err := langs.NewLanguage(k, c.Base.DefaultContentLanguage, v.TimeZone, languageConf)
 		if err != nil {
 			return err
 		}
 		languages = append(languages, language)
 	}
 
-	// Sort the sites by language weight (if set) or lang.
-	sort.Slice(languages, func(i, j int) bool {
-		li := languages[i]
-		lj := languages[j]
-		if li.Weight != lj.Weight {
-			return li.Weight < lj.Weight
-		}
-		return li.Lang < lj.Lang
-	})
-
-	for _, l := range languages {
-		c.LanguageConfigSlice = append(c.LanguageConfigSlice, c.LanguageConfigMap[l.Lang])
-	}
-
 	// Filter out disabled languages.
 	var n int
 	for _, l := range languages {
@@ -836,12 +899,12 @@ func (c *Configs) Init() error {
 
 	var languagesDefaultFirst langs.Languages
 	for _, l := range languages {
-		if l.Lang == defaultContentLanguage {
+		if l.Lang == c.Base.DefaultContentLanguage {
 			languagesDefaultFirst = append(languagesDefaultFirst, l)
 		}
 	}
 	for _, l := range languages {
-		if l.Lang != defaultContentLanguage {
+		if l.Lang != c.Base.DefaultContentLanguage {
 			languagesDefaultFirst = append(languagesDefaultFirst, l)
 		}
 	}
@@ -849,7 +912,24 @@ func (c *Configs) Init() error {
 	c.Languages = languages
 	c.LanguagesDefaultFirst = languagesDefaultFirst
 
-	c.ContentPathParser = &paths.PathParser{LanguageIndex: languagesDefaultFirst.AsIndexSet(), IsLangDisabled: c.Base.IsLangDisabled, IsContentExt: c.Base.ContentTypes.Config.IsContentSuffix}
+	c.ContentPathParser = &paths.PathParser{
+		LanguageIndex:  languagesDefaultFirst.AsIndexSet(),
+		IsLangDisabled: c.Base.IsLangDisabled,
+		IsContentExt:   c.Base.ContentTypes.Config.IsContentSuffix,
+		IsOutputFormat: func(name, ext string) bool {
+			if name == "" {
+				return false
+			}
+
+			if of, ok := c.Base.OutputFormats.Config.GetByName(name); ok {
+				if ext != "" && !of.MediaType.HasSuffix(ext) {
+					return false
+				}
+				return true
+			}
+			return false
+		},
+	}
 
 	c.configLangs = make([]config.AllProvider, len(c.Languages))
 	for i, l := range c.LanguagesDefaultFirst {
@@ -910,17 +990,48 @@ func (c Configs) GetByLang(lang string) config.AllProvider {
 	return nil
 }
 
+func newDefaultConfig() *Config {
+	return &Config{
+		Taxonomies: map[string]string{"tag": "tags", "category": "categories"},
+		Sitemap:    config.SitemapConfig{Priority: -1, Filename: "sitemap.xml"},
+		RootConfig: RootConfig{
+			Environment:          hugo.EnvironmentProduction,
+			TitleCaseStyle:       "AP",
+			PluralizeListTitles:  true,
+			CapitalizeListTitles: true,
+			StaticDir:            []string{"static"},
+			SummaryLength:        70,
+			Timeout:              "60s",
+
+			CommonDirs: config.CommonDirs{
+				ArcheTypeDir: "archetypes",
+				ContentDir:   "content",
+				ResourceDir:  "resources",
+				PublishDir:   "public",
+				ThemesDir:    "themes",
+				AssetDir:     "assets",
+				LayoutDir:    "layouts",
+				I18nDir:      "i18n",
+				DataDir:      "data",
+			},
+		},
+	}
+}
+
 // fromLoadConfigResult creates a new Config from res.
 func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadConfigResult) (*Configs, error) {
 	if !res.Cfg.IsSet("languages") {
 		// We need at least one
 		lang := res.Cfg.GetString("defaultContentLanguage")
+		if lang == "" {
+			lang = "en"
+		}
 		res.Cfg.Set("languages", maps.Params{lang: maps.Params{}})
 	}
 	bcfg := res.BaseConfig
 	cfg := res.Cfg
 
-	all := &Config{}
+	all := newDefaultConfig()
 
 	err := decodeConfigFromParams(fs, logger, bcfg, cfg, all, nil)
 	if err != nil {
@@ -930,6 +1041,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 	langConfigMap := make(map[string]*Config)
 
 	languagesConfig := cfg.GetStringMap("languages")
+
 	var isMultihost bool
 
 	if err := all.CompileConfig(logger); err != nil {
@@ -940,6 +1052,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 		mergedConfig := config.New()
 		var differentRootKeys []string
 		switch x := v.(type) {
+		case nil:
 		case maps.Params:
 			_, found := x["params"]
 			if !found {
@@ -956,6 +1069,14 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 					// baseURL configure don the language level is a multihost setup.
 					isMultihost = true
 				}
+
+				if p, ok := vv.(maps.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)
+				}
+
 				mergedConfig.Set(kk, vv)
 				rootv := cfg.Get(kk)
 				if rootv != nil && cfg.IsSet(kk) {
@@ -966,7 +1087,8 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 							differentRootKeys = append(differentRootKeys, kk)
 
 							// Use the language value as base.
-							mergedConfigEntry := xmaps.Clone(vvv)
+							// Note that this is already cloned above.
+							mergedConfigEntry := vvv
 							// Merge in the root value.
 							maps.MergeParams(mergedConfigEntry, rootv.(maps.Params))
 
@@ -1005,18 +1127,17 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 
 			// Adjust Goldmark config defaults for multilingual, single-host sites.
 			if len(languagesConfig) > 1 && !isMultihost && !clone.Markup.Goldmark.DuplicateResourceFiles {
-				if !clone.Markup.Goldmark.DuplicateResourceFiles {
-					if clone.Markup.Goldmark.RenderHooks.Link.EnableDefault == nil {
-						clone.Markup.Goldmark.RenderHooks.Link.EnableDefault = types.NewBool(true)
-					}
-					if clone.Markup.Goldmark.RenderHooks.Image.EnableDefault == nil {
-						clone.Markup.Goldmark.RenderHooks.Image.EnableDefault = types.NewBool(true)
-					}
+				if clone.Markup.Goldmark.RenderHooks.Image.UseEmbedded == gc.RenderHookUseEmbeddedAuto {
+					clone.Markup.Goldmark.RenderHooks.Image.UseEmbedded = gc.RenderHookUseEmbeddedFallback
+				}
+				if clone.Markup.Goldmark.RenderHooks.Link.UseEmbedded == gc.RenderHookUseEmbeddedAuto {
+					clone.Markup.Goldmark.RenderHooks.Link.UseEmbedded = gc.RenderHookUseEmbeddedFallback
 				}
 			}
 
 			langConfigMap[k] = clone
 		case maps.ParamsMergeStrategy:
+
 		default:
 			panic(fmt.Sprintf("unknown type in languages config: %T", v))
 

config/allconfig/allconfig_integration_test.go

@@ -2,11 +2,14 @@ package allconfig_test
 
 import (
 	"path/filepath"
+	"strings"
 	"testing"
 
 	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/hugolib"
+	gc "github.com/gohugoio/hugo/markup/goldmark/goldmark_config"
 	"github.com/gohugoio/hugo/media"
 )
 
@@ -234,3 +237,172 @@ baseURL = "https://example.com"
 	b.Assert(c.IsContentFile("foo.md"), qt.Equals, true)
 	b.Assert(len(s), qt.Equals, 6)
 }
+
+func TestMergeDeep(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+theme = ["theme1", "theme2"]
+_merge = "deep"
+-- themes/theme1/hugo.toml --
+[sitemap]
+filename = 'mysitemap.xml'
+[services]
+[services.googleAnalytics]
+id = 'foo bar'
+[taxonomies]
+  foo = 'bars'
+-- themes/theme2/config/_default/hugo.toml --
+[taxonomies]
+  bar = 'baz'
+-- layouts/home.html --
+GA ID: {{ site.Config.Services.GoogleAnalytics.ID }}.
+
+`
+
+	b := hugolib.Test(t, files)
+
+	conf := b.H.Configs
+	base := conf.Base
+
+	b.Assert(base.Environment, qt.Equals, hugo.EnvironmentProduction)
+	b.Assert(base.BaseURL, qt.Equals, "https://example.com")
+	b.Assert(base.Sitemap.Filename, qt.Equals, "mysitemap.xml")
+	b.Assert(base.Taxonomies, qt.DeepEquals, map[string]string{"bar": "baz", "foo": "bars"})
+
+	b.AssertFileContent("public/index.html", "GA ID: foo bar.")
+}
+
+func TestMergeDeepBuildStats(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+title = "Theme 1"
+_merge = "deep"
+[module]
+[module.hugoVersion]
+[[module.imports]]
+path = "theme1"
+-- themes/theme1/hugo.toml --
+[build]
+[build.buildStats]
+disableIDs = true
+enable     = true
+-- layouts/home.html --
+Home.
+
+`
+
+	b := hugolib.Test(t, files, hugolib.TestOptOsFs())
+
+	conf := b.H.Configs
+	base := conf.Base
+
+	b.Assert(base.Title, qt.Equals, "Theme 1")
+	b.Assert(len(base.Module.Imports), qt.Equals, 1)
+	b.Assert(base.Build.BuildStats.Enable, qt.Equals, true)
+	b.AssertFileExists("/hugo_stats.json", true)
+}
+
+func TestMergeDeepBuildStatsTheme(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+_merge = "deep"
+theme = ["theme1"]
+-- themes/theme1/hugo.toml --
+title = "Theme 1"
+[build]
+[build.buildStats]
+disableIDs = true
+enable     = true
+-- layouts/home.html --
+Home.
+
+`
+
+	b := hugolib.Test(t, files, hugolib.TestOptOsFs())
+
+	conf := b.H.Configs
+	base := conf.Base
+
+	b.Assert(base.Title, qt.Equals, "Theme 1")
+	b.Assert(len(base.Module.Imports), qt.Equals, 1)
+	b.Assert(base.Build.BuildStats.Enable, qt.Equals, true)
+	b.AssertFileExists("/hugo_stats.json", true)
+}
+
+func TestDefaultConfigLanguageBlankWhenNoEnglishExists(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+[languages]
+[languages.nn]
+weight = 20
+[languages.sv]
+weight = 10
+[languages.sv.taxonomies]
+  tag = "taggar"
+-- layouts/all.html --
+All.
+`
+
+	b := hugolib.Test(t, files)
+
+	b.Assert(b.H.Conf.DefaultContentLanguage(), qt.Equals, "sv")
+}
+
+func TestDefaultConfigEnvDisableLanguagesIssue13707(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableLanguages = []
+[languages]
+[languages.en]
+weight = 1
+[languages.nn]
+weight = 2
+[languages.sv]
+weight = 3
+`
+
+	b := hugolib.Test(t, files, hugolib.TestOptWithConfig(func(conf *hugolib.IntegrationTestConfig) {
+		conf.Environ = []string{`HUGO_DISABLELANGUAGES=sv nn`}
+	}))
+
+	b.Assert(len(b.H.Sites), qt.Equals, 1)
+}
+
+// Issue 13535
+// We changed enablement of the embedded link and image render hooks from
+// booleans to enums in v0.148.0.
+func TestLegacyEmbeddedRenderHookEnablement(t *testing.T) {
+	files := `
+-- hugo.toml --
+[markup.goldmark.renderHooks.image]
+#KEY_VALUE
+
+[markup.goldmark.renderHooks.link]
+#KEY_VALUE
+`
+	f := strings.ReplaceAll(files, "#KEY_VALUE", "enableDefault = false")
+	b := hugolib.Test(t, f)
+	c := b.H.Configs.Base.Markup.Goldmark.RenderHooks
+	b.Assert(c.Link.UseEmbedded, qt.Equals, gc.RenderHookUseEmbeddedNever)
+	b.Assert(c.Image.UseEmbedded, qt.Equals, gc.RenderHookUseEmbeddedNever)
+
+	f = strings.ReplaceAll(files, "#KEY_VALUE", "enableDefault = true")
+	b = hugolib.Test(t, f)
+	c = b.H.Configs.Base.Markup.Goldmark.RenderHooks
+	b.Assert(c.Link.UseEmbedded, qt.Equals, gc.RenderHookUseEmbeddedFallback)
+	b.Assert(c.Image.UseEmbedded, qt.Equals, gc.RenderHookUseEmbeddedFallback)
+}

config/allconfig/alldecoders.go

@@ -249,14 +249,18 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "sitemap",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			p.c.Sitemap, err = config.DecodeSitemap(config.SitemapConfig{Priority: -1, Filename: "sitemap.xml"}, p.p.GetStringMap(d.key))
+			if p.p.IsSet(d.key) {
+				p.c.Sitemap, err = config.DecodeSitemap(p.c.Sitemap, p.p.GetStringMap(d.key))
+			}
 			return err
 		},
 	},
 	"taxonomies": {
 		key: "taxonomies",
 		decode: func(d decodeWeight, p decodeConfig) error {
-			p.c.Taxonomies = maps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
+			if p.p.IsSet(d.key) {
+				p.c.Taxonomies = maps.CleanConfigStringMapString(p.p.GetStringMapString(d.key))
+			}
 			return nil
 		},
 	},
@@ -306,15 +310,17 @@ var allDecoderSetups = map[string]decodeWeight{
 			}
 
 			// Validate defaultContentLanguage.
-			var found bool
-			for lang := range p.c.Languages {
-				if lang == p.c.DefaultContentLanguage {
-					found = true
-					break
+			if p.c.DefaultContentLanguage != "" {
+				var found bool
+				for lang := range p.c.Languages {
+					if lang == p.c.DefaultContentLanguage {
+						found = true
+						break
+					}
+				}
+				if !found {
+					return fmt.Errorf("config value %q for defaultContentLanguage does not match any language definition", p.c.DefaultContentLanguage)
 				}
-			}
-			if !found {
-				return fmt.Errorf("config value %q for defaultContentLanguage does not match any language definition", p.c.DefaultContentLanguage)
 			}
 
 			return nil
@@ -324,7 +330,7 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "cascade",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			p.c.Cascade, err = page.DecodeCascadeConfig(nil, p.p.Get(d.key))
+			p.c.Cascade, err = page.DecodeCascadeConfig(nil, true, p.p.Get(d.key))
 			return err
 		},
 	},

config/allconfig/load.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime/debug"
 	"strings"
 
 	"github.com/gobwas/glob"
@@ -40,7 +41,14 @@ 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")
 
-func LoadConfig(d ConfigSourceDescriptor) (*Configs, error) {
+func LoadConfig(d ConfigSourceDescriptor) (configs *Configs, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("failed to load config: %v", r)
+			debug.PrintStack()
+		}
+	}()
+
 	if len(d.Environ) == 0 && !hugo.IsRunningAsTest() {
 		d.Environ = os.Environ()
 	}
@@ -59,7 +67,7 @@ func LoadConfig(d ConfigSourceDescriptor) (*Configs, error) {
 		return nil, fmt.Errorf("failed to load config: %w", err)
 	}
 
-	configs, err := fromLoadConfigResult(d.Fs, d.Logger, res)
+	configs, err = fromLoadConfigResult(d.Fs, d.Logger, res)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create config from result: %w", err)
 	}
@@ -93,7 +101,7 @@ func LoadConfig(d ConfigSourceDescriptor) (*Configs, error) {
 
 	loggers.SetGlobalLogger(d.Logger)
 
-	return configs, nil
+	return
 }
 
 // ConfigSourceDescriptor describes where to find the config (e.g. config.toml etc.).
@@ -159,63 +167,9 @@ func (l configLoader) applyConfigAliases() error {
 
 func (l configLoader) applyDefaultConfig() error {
 	defaultSettings := maps.Params{
-		"baseURL":                              "",
-		"cleanDestinationDir":                  false,
-		"watch":                                false,
-		"contentDir":                           "content",
-		"resourceDir":                          "resources",
-		"publishDir":                           "public",
-		"publishDirOrig":                       "public",
-		"themesDir":                            "themes",
-		"assetDir":                             "assets",
-		"layoutDir":                            "layouts",
-		"i18nDir":                              "i18n",
-		"dataDir":                              "data",
-		"archetypeDir":                         "archetypes",
-		"configDir":                            "config",
-		"staticDir":                            "static",
-		"buildDrafts":                          false,
-		"buildFuture":                          false,
-		"buildExpired":                         false,
-		"params":                               maps.Params{},
-		"environment":                          hugo.EnvironmentProduction,
-		"uglyURLs":                             false,
-		"verbose":                              false,
-		"ignoreCache":                          false,
-		"canonifyURLs":                         false,
-		"relativeURLs":                         false,
-		"removePathAccents":                    false,
-		"titleCaseStyle":                       "AP",
-		"taxonomies":                           maps.Params{"tag": "tags", "category": "categories"},
-		"permalinks":                           maps.Params{},
-		"sitemap":                              maps.Params{"priority": -1, "filename": "sitemap.xml"},
-		"menus":                                maps.Params{},
-		"disableLiveReload":                    false,
-		"pluralizeListTitles":                  true,
-		"capitalizeListTitles":                 true,
-		"forceSyncStatic":                      false,
-		"footnoteAnchorPrefix":                 "",
-		"footnoteReturnLinkContents":           "",
-		"newContentEditor":                     "",
-		"paginate":                             0,  // Moved into the paginator struct in Hugo v0.128.0.
-		"paginatePath":                         "", // Moved into the paginator struct in Hugo v0.128.0.
-		"summaryLength":                        70,
-		"rssLimit":                             -1,
-		"sectionPagesMenu":                     "",
-		"disablePathToLower":                   false,
-		"hasCJKLanguage":                       false,
-		"enableEmoji":                          false,
-		"defaultContentLanguage":               "en",
-		"defaultContentLanguageInSubdir":       false,
-		"enableMissingTranslationPlaceholders": false,
-		"enableGitInfo":                        false,
-		"ignoreFiles":                          make([]string, 0),
-		"disableAliases":                       false,
-		"debug":                                false,
-		"disableFastRender":                    false,
-		"timeout":                              "30s",
-		"timeZone":                             "",
-		"enableInlineShortcodes":               false,
+		// These dirs are used early/before we build the config struct.
+		"themesDir": "themes",
+		"configDir": "config",
 	}
 
 	l.cfg.SetDefaults(defaultSettings)
@@ -224,10 +178,16 @@ func (l configLoader) applyDefaultConfig() error {
 }
 
 func (l configLoader) normalizeCfg(cfg config.Provider) error {
-	if b, ok := cfg.Get("minifyOutput").(bool); ok && b {
-		cfg.Set("minify.minifyOutput", true)
-	} else if b, ok := cfg.Get("minify").(bool); ok && b {
-		cfg.Set("minify", maps.Params{"minifyOutput": true})
+	if b, ok := cfg.Get("minifyOutput").(bool); ok {
+		hugo.Deprecate("site 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")
+		if b {
+			cfg.Set("minify", maps.Params{"minifyOutput": true})
+		}
 	}
 
 	return nil
@@ -287,43 +247,61 @@ func (l configLoader) applyOsEnvOverrides(environ []string) error {
 
 		if existing != nil {
 			val, err := metadecoders.Default.UnmarshalStringTo(env.Value, existing)
-			if err != nil {
+			if err == nil {
+				val = l.envValToVal(env.Key, val)
+				if owner != nil {
+					owner[nestedKey] = val
+				} else {
+					l.cfg.Set(env.Key, val)
+				}
 				continue
 			}
-
-			if owner != nil {
-				owner[nestedKey] = val
-			} else {
-				l.cfg.Set(env.Key, val)
-			}
-		} else {
-			if nestedKey != "" {
-				owner[nestedKey] = env.Value
-			} else {
-				var val any
-				key := strings.ReplaceAll(env.Key, delim, ".")
-				_, ok := allDecoderSetups[key]
-				if ok {
-					// A map.
-					if v, err := metadecoders.Default.UnmarshalStringTo(env.Value, map[string]interface{}{}); err == nil {
-						val = v
-					}
-				}
-				if val == nil {
-					// A string.
-					val = l.envStringToVal(key, env.Value)
-				}
-				l.cfg.Set(key, val)
-			}
 		}
+
+		if owner != nil && nestedKey != "" {
+			owner[nestedKey] = env.Value
+		} else {
+			var val any
+			key := strings.ReplaceAll(env.Key, delim, ".")
+			_, ok := allDecoderSetups[key]
+			if ok {
+				// A map.
+				if v, err := metadecoders.Default.UnmarshalStringTo(env.Value, map[string]any{}); err == nil {
+					val = v
+				}
+			}
+
+			if val == nil {
+				// A string.
+				val = l.envStringToVal(key, env.Value)
+			}
+			l.cfg.Set(key, val)
+		}
+
 	}
 
 	return nil
 }
 
+func (l *configLoader) envValToVal(k string, v any) any {
+	switch v := v.(type) {
+	case string:
+		return l.envStringToVal(k, v)
+	default:
+		return v
+	}
+}
+
 func (l *configLoader) envStringToVal(k, v string) any {
 	switch k {
-	case "disablekinds", "disablelanguages":
+	case "disablekinds", "disablelanguages", "ignorefiles", "ignorelogs":
+		v = strings.TrimSpace(v)
+		if strings.HasPrefix(v, "[") && strings.HasSuffix(v, "]") {
+			if parsed, err := metadecoders.Default.UnmarshalStringTo(v, []any{}); err == nil {
+				return parsed
+			}
+		}
+
 		if strings.Contains(v, ",") {
 			return strings.Split(v, ",")
 		} else {
@@ -568,11 +546,12 @@ func (l configLoader) loadConfig(configName string) (string, error) {
 	return filename, nil
 }
 
-func (l configLoader) deleteMergeStrategies() {
+func (l configLoader) deleteMergeStrategies() (err error) {
 	l.cfg.WalkParams(func(params ...maps.KeyParams) bool {
 		params[len(params)-1].Params.DeleteMergeStrategy()
 		return false
 	})
+	return
 }
 
 func (l configLoader) wrapFileError(err error, filename string) error {

config/commonConfig.go

@@ -17,6 +17,7 @@ import (
 	"fmt"
 	"net/http"
 	"regexp"
+	"slices"
 	"sort"
 	"strings"
 
@@ -128,7 +129,7 @@ func (w BuildStats) Enabled() bool {
 }
 
 func (b BuildConfig) clone() BuildConfig {
-	b.CacheBusters = append([]CacheBuster{}, b.CacheBusters...)
+	b.CacheBusters = slices.Clone(b.CacheBusters)
 	return b
 }
 

config/commonConfig_test.go

@@ -166,7 +166,7 @@ func TestBuildConfigCacheBusters(t *testing.T) {
 func TestBuildConfigCacheBusterstTailwindSetup(t *testing.T) {
 	c := qt.New(t)
 	cfg := New()
-	cfg.Set("build", map[string]interface{}{
+	cfg.Set("build", map[string]any{
 		"cacheBusters": []map[string]string{
 			{
 				"source": "assets/watching/hugo_stats\\.json",

config/configLoader_test.go

@@ -14,6 +14,7 @@
 package config
 
 import (
+	"regexp"
 	"strings"
 	"testing"
 
@@ -32,3 +33,13 @@ func TestIsValidConfigFileName(t *testing.T) {
 	c.Assert(IsValidConfigFilename(""), qt.Equals, false)
 	c.Assert(IsValidConfigFilename("config.toml.swp"), qt.Equals, false)
 }
+
+func TestFromTOMLConfigString(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(
+		func() { FromTOMLConfigString("cfg") },
+		qt.PanicMatches,
+		regexp.MustCompile("_stream.toml:.*"),
+	)
+}

config/configProvider.go

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

config/defaultConfigProvider.go

@@ -14,11 +14,13 @@
 package config
 
 import (
+	"errors"
 	"fmt"
+	"slices"
 	"strings"
 	"sync"
 
-	xmaps "golang.org/x/exp/maps"
+	xmaps "maps"
 
 	"github.com/spf13/cast"
 
@@ -237,12 +239,16 @@ func (c *defaultConfigProvider) Merge(k string, v any) {
 func (c *defaultConfigProvider) Keys() []string {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
-	return xmaps.Keys(c.root)
+	return slices.Collect(xmaps.Keys(c.root))
 }
 
 func (c *defaultConfigProvider) WalkParams(walkFn func(params ...maps.KeyParams) bool) {
-	var walk func(params ...maps.KeyParams)
-	walk = func(params ...maps.KeyParams) {
+	maxDepth := 1000
+	var walk func(depth int, params ...maps.KeyParams)
+	walk = func(depth int, params ...maps.KeyParams) {
+		if depth > maxDepth {
+			panic(errors.New("max depth exceeded"))
+		}
 		if walkFn(params...) {
 			return
 		}
@@ -253,11 +259,11 @@ func (c *defaultConfigProvider) WalkParams(walkFn func(params ...maps.KeyParams)
 				paramsplus1 := make([]maps.KeyParams, i+1)
 				copy(paramsplus1, params)
 				paramsplus1[i] = maps.KeyParams{Key: k, Params: p2}
-				walk(paramsplus1...)
+				walk(depth+1, paramsplus1...)
 			}
 		}
 	}
-	walk(maps.KeyParams{Key: "", Params: c.root})
+	walk(0, maps.KeyParams{Key: "", Params: c.root})
 }
 
 func (c *defaultConfigProvider) determineMergeStrategy(params ...maps.KeyParams) maps.ParamsMergeStrategy {
@@ -345,7 +351,7 @@ func (c *defaultConfigProvider) getNestedKeyAndMap(key string, create bool) (str
 		c.keyCache.Store(key, parts)
 	}
 	current := c.root
-	for i := 0; i < len(parts)-1; i++ {
+	for i := range len(parts) - 1 {
 		next, found := current[parts[i]]
 		if !found {
 			if create {

config/defaultConfigProvider_test.go

@@ -17,6 +17,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"slices"
 	"strconv"
 	"strings"
 	"testing"
@@ -332,7 +333,7 @@ func TestDefaultConfigProvider(t *testing.T) {
 			return nil
 		}
 
-		for i := 0; i < 20; i++ {
+		for i := range 20 {
 			i := i
 			r.Run(func() error {
 				const v = 42
@@ -353,6 +354,90 @@ func TestDefaultConfigProvider(t *testing.T) {
 
 		c.Assert(r.Wait(), qt.IsNil)
 	})
+
+	c.Run("GetBool", func(c *qt.C) {
+		cfg := New()
+
+		var k string
+		var v bool
+
+		k, v = "foo", true
+
+		cfg.Set(k, v)
+		c.Assert(cfg.Get(k), qt.Equals, v)
+		c.Assert(cfg.GetBool(k), qt.Equals, v)
+	})
+
+	c.Run("GetParams", func(c *qt.C) {
+		cfg := New()
+		k := "foo"
+
+		cfg.Set(k, maps.Params{k: true})
+		c.Assert(cfg.GetParams(k), qt.DeepEquals, maps.Params{
+			k: true,
+		})
+
+		c.Assert(cfg.GetParams("bar"), qt.IsNil)
+	})
+
+	c.Run("Keys", func(c *qt.C) {
+		cfg := New()
+		k := "foo"
+		k2 := "bar"
+
+		cfg.Set(k, maps.Params{k: struct{}{}})
+		cfg.Set(k2, maps.Params{k2: struct{}{}})
+
+		c.Assert(len(cfg.Keys()), qt.Equals, 2)
+
+		got := cfg.Keys()
+		slices.Sort(got)
+
+		want := []string{k, k2}
+		slices.Sort(want)
+
+		c.Assert(got, qt.DeepEquals, want)
+	})
+
+	c.Run("WalkParams", func(c *qt.C) {
+		cfg := New()
+
+		cfg.Set("x", maps.Params{})
+		cfg.Set("y", maps.Params{})
+
+		var got []string
+		cfg.WalkParams(func(params ...maps.KeyParams) bool {
+			got = append(got, params[len(params)-1].Key)
+			return false
+		})
+
+		want := []string{"", "x", "y"}
+		slices.Sort(got)
+		slices.Sort(want)
+
+		c.Assert(got, qt.DeepEquals, want)
+
+		cfg = New()
+		cfg.WalkParams(func(params ...maps.KeyParams) bool {
+			return true
+		})
+
+		got = []string{""}
+		want = []string{""}
+		c.Assert(got, qt.DeepEquals, want)
+	})
+
+	c.Run("SetDefaults", func(c *qt.C) {
+		cfg := New()
+
+		cfg.SetDefaults(maps.Params{
+			"foo": "bar",
+			"bar": "baz",
+		})
+
+		c.Assert(cfg.Get("foo"), qt.Equals, "bar")
+		c.Assert(cfg.Get("bar"), qt.Equals, "baz")
+	})
 }
 
 func BenchmarkDefaultConfigProvider(b *testing.B) {

config/namespace_test.go

@@ -29,7 +29,7 @@ func TestNamespace(t *testing.T) {
 	// ns, err := config.DecodeNamespace[map[string]DocsMediaTypeConfig](in, defaultMediaTypesConfig, buildConfig)
 
 	ns, err := DecodeNamespace[[]*tstNsExt](
-		map[string]interface{}{"foo": "bar"},
+		map[string]any{"foo": "bar"},
 		func(v any) (*tstNsExt, any, error) {
 			t := &tstNsExt{}
 			m, err := maps.ToStringMapE(v)
@@ -42,7 +42,7 @@ func TestNamespace(t *testing.T) {
 
 	c.Assert(err, qt.IsNil)
 	c.Assert(ns, qt.Not(qt.IsNil))
-	c.Assert(ns.SourceStructure, qt.DeepEquals, map[string]interface{}{"foo": "bar"})
+	c.Assert(ns.SourceStructure, qt.DeepEquals, map[string]any{"foo": "bar"})
 	c.Assert(ns.SourceHash, qt.Equals, "1420f6c7782f7459")
 	c.Assert(ns.Config, qt.DeepEquals, &tstNsExt{Foo: "bar"})
 	c.Assert(ns.Signature(), qt.DeepEquals, []*tstNsExt(nil))

config/security/securityConfig.go

@@ -44,7 +44,7 @@ var DefaultConfig = Config{
 		),
 		// These have been tested to work with Hugo's external programs
 		// on Windows, Linux and MacOS.
-		OsEnv: MustNewWhitelist(`(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\w+|(XDG_CONFIG_)?HOME|USERPROFILE|SSH_AUTH_SOCK|DISPLAY|LANG|SYSTEMDRIVE)$`),
+		OsEnv: MustNewWhitelist(`(?i)^((HTTPS?|NO)_PROXY|PATH(EXT)?|APPDATA|TE?MP|TERM|GO\w+|(XDG_CONFIG_)?HOME|USERPROFILE|SSH_AUTH_SOCK|DISPLAY|LANG|SYSTEMDRIVE|PROGRAMDATA)$`),
 	},
 	Funcs: Funcs{
 		Getenv: MustNewWhitelist("^HUGO_", "^CI$"),

config/security/securityConfig_test.go

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

config/security/whitelist.go

@@ -73,7 +73,7 @@ func NewWhitelist(patterns ...string) (Whitelist, error) {
 
 	var patternsr []*regexp.Regexp
 
-	for i := 0; i < len(patterns); i++ {
+	for i := range patterns {
 		p := strings.TrimSpace(patterns[i])
 		if p == "" {
 			continue

config/services/servicesConfig.go

@@ -101,6 +101,9 @@ func DecodeConfig(cfg config.Provider) (c Config, err error) {
 
 	if c.RSS.Limit == 0 {
 		c.RSS.Limit = cfg.GetInt(rssLimitKey)
+		if c.RSS.Limit == 0 {
+			c.RSS.Limit = -1
+		}
 	}
 
 	return

create/content.go

@@ -291,7 +291,7 @@ func (b *contentBuilder) applyArcheType(contentFilename string, archetypeFi hugo
 func (b *contentBuilder) mapArcheTypeDir() error {
 	var m archetypeMap
 
-	seen := map[hstrings.Tuple]bool{}
+	seen := map[hstrings.Strings2]bool{}
 
 	walkFn := func(path string, fim hugofs.FileMetaInfo) error {
 		if fim.IsDir() {
@@ -301,7 +301,7 @@ func (b *contentBuilder) mapArcheTypeDir() error {
 		pi := fim.Meta().PathInfo
 
 		if pi.IsContent() {
-			pathLang := hstrings.Tuple{First: pi.PathNoIdentifier(), Second: fim.Meta().Lang}
+			pathLang := hstrings.Strings2{pi.PathBeforeLangAndOutputFormatAndExt(), fim.Meta().Lang}
 			if seen[pathLang] {
 				// Duplicate content file, e.g. page.md and page.html.
 				// In the regular build, we will filter out the duplicates, but

create/content_test.go

@@ -129,7 +129,7 @@ site RegularPages: {{ len site.RegularPages  }}
 
 `
 
-	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0o755), qt.IsNil)
+	c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.md"), fmt.Appendf(nil, contentFile, "index.md"), 0o755), qt.IsNil)
 	c.Assert(afero.WriteFile(mm, filepath.Join(defaultArchetypeDir, "index.md"), []byte("default archetype index.md"), 0o755), qt.IsNil)
 
 	c.Assert(initFs(mm), qt.IsNil)

create/skeletons/skeletons.go

@@ -34,10 +34,60 @@ var siteFs embed.FS
 var themeFs embed.FS
 
 // CreateTheme creates a theme skeleton.
-func CreateTheme(createpath string, sourceFs afero.Fs) error {
+func CreateTheme(createpath string, sourceFs afero.Fs, format string) error {
 	if exists, _ := helpers.Exists(createpath, sourceFs); exists {
 		return errors.New(createpath + " already exists")
 	}
+
+	format = strings.ToLower(format)
+
+	siteConfig := map[string]any{
+		"baseURL":      "https://example.org/",
+		"languageCode": "en-US",
+		"title":        "My New Hugo Site",
+		"menus": map[string]any{
+			"main": []any{
+				map[string]any{
+					"name":    "Home",
+					"pageRef": "/",
+					"weight":  10,
+				},
+				map[string]any{
+					"name":    "Posts",
+					"pageRef": "/posts",
+					"weight":  20,
+				},
+				map[string]any{
+					"name":    "Tags",
+					"pageRef": "/tags",
+					"weight":  30,
+				},
+			},
+		},
+		"module": map[string]any{
+			"hugoVersion": map[string]any{
+				"extended": false,
+				"min":      "0.146.0",
+			},
+		},
+	}
+
+	err := createSiteConfig(sourceFs, createpath, siteConfig, format)
+	if err != nil {
+		return err
+	}
+
+	defaultArchetype := map[string]any{
+		"title": "{{ replace .File.ContentBaseName \"-\" \" \" | title }}",
+		"date":  "{{ .Date }}",
+		"draft": true,
+	}
+
+	err = createDefaultArchetype(sourceFs, createpath, defaultArchetype, format)
+	if err != nil {
+		return err
+	}
+
 	return copyFiles(createpath, sourceFs, themeFs)
 }
 
@@ -71,12 +121,24 @@ func CreateSite(createpath string, sourceFs afero.Fs, force bool, format string)
 		}
 	}
 
-	err := newSiteCreateConfig(sourceFs, createpath, format)
+	siteConfig := map[string]any{
+		"baseURL":      "https://example.org/",
+		"title":        "My New Hugo Site",
+		"languageCode": "en-us",
+	}
+
+	err := createSiteConfig(sourceFs, createpath, siteConfig, format)
 	if err != nil {
 		return err
 	}
 
-	err = newSiteCreateArchetype(sourceFs, createpath, format)
+	defaultArchetype := map[string]any{
+		"title": "{{ replace .File.ContentBaseName \"-\" \" \" | title }}",
+		"date":  "{{ .Date }}",
+		"draft": true,
+	}
+
+	err = createDefaultArchetype(sourceFs, createpath, defaultArchetype, format)
 	if err != nil {
 		return err
 	}
@@ -99,13 +161,7 @@ func copyFiles(createpath string, sourceFs afero.Fs, skeleton embed.FS) error {
 	})
 }
 
-func newSiteCreateConfig(fs afero.Fs, createpath string, format string) (err error) {
-	in := map[string]string{
-		"baseURL":      "https://example.org/",
-		"title":        "My New Hugo Site",
-		"languageCode": "en-us",
-	}
-
+func createSiteConfig(fs afero.Fs, createpath string, in map[string]any, format string) (err error) {
 	var buf bytes.Buffer
 	err = parser.InterfaceToConfig(in, metadecoders.FormatFromString(format), &buf)
 	if err != nil {
@@ -115,13 +171,7 @@ func newSiteCreateConfig(fs afero.Fs, createpath string, format string) (err err
 	return helpers.WriteToDisk(filepath.Join(createpath, "hugo."+format), &buf, fs)
 }
 
-func newSiteCreateArchetype(fs afero.Fs, createpath string, format string) (err error) {
-	in := map[string]any{
-		"title": "{{ replace .File.ContentBaseName \"-\" \" \" | title }}",
-		"date":  "{{ .Date }}",
-		"draft": true,
-	}
-
+func createDefaultArchetype(fs afero.Fs, createpath string, in map[string]any, format string) (err error) {
 	var buf bytes.Buffer
 	err = parser.InterfaceToFrontMatter(in, metadecoders.FormatFromString(format), &buf)
 	if err != nil {

create/skeletons/theme/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) [year] [fullname]
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

create/skeletons/theme/README.md

@@ -1,7 +0,0 @@
-# Theme Name
-
-## Features
-
-## Installation
-
-## Configuration

create/skeletons/theme/archetypes/default.md

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

create/skeletons/theme/hugo.toml

@@ -1,23 +0,0 @@
-baseURL = 'https://example.org/'
-languageCode = 'en-US'
-title = 'My New Hugo Site'
-
-[[menus.main]]
-name = 'Home'
-pageRef = '/'
-weight = 10
-
-[[menus.main]]
-name = 'Posts'
-pageRef = '/posts'
-weight = 20
-
-[[menus.main]]
-name = 'Tags'
-pageRef = '/tags'
-weight = 30
-
-[module]
-  [module.hugoVersion]
-    extended = false
-    min = "0.116.0"

create/skeletons/theme/layouts/_partials/head/css.html

@@ -1,5 +1,5 @@
 {{- with resources.Get "css/main.css" }}
-  {{- if eq hugo.Environment "development" }}
+  {{- if hugo.IsDevelopment }}
     <link rel="stylesheet" href="{{ .RelPermalink }}">
   {{- else }}
     {{- with . | minify | fingerprint }}

create/skeletons/theme/layouts/_partials/head/js.html

@@ -0,0 +1,16 @@
+{{- with resources.Get "js/main.js" }}
+  {{- $opts := dict
+    "minify" (not hugo.IsDevelopment)
+    "sourceMap" (cond hugo.IsDevelopment "external" "")
+    "targetPath" "js/main.js"
+  }}
+  {{- with . | js.Build $opts }}
+    {{- if hugo.IsDevelopment }}
+      <script src="{{ .RelPermalink }}"></script>
+    {{- else }}
+      {{- with . | fingerprint }}
+        <script src="{{ .RelPermalink }}" integrity="{{ .Data.Integrity }}" crossorigin="anonymous"></script>
+      {{- end }}
+    {{- end }}
+  {{- end }}
+{{- end }}

create/skeletons/theme/layouts/_partials/menu.html

@@ -18,7 +18,7 @@ Renders a menu for the given menu ID.
   </nav>
 {{- end }}
 
-{{- define "partials/inline/menu/walk.html" }}
+{{- define "_partials/inline/menu/walk.html" }}
   {{- $page := .page }}
   {{- range .menuEntries }}
     {{- $attrs := dict "href" .URL }}

create/skeletons/theme/layouts/home.html

@@ -0,0 +1,9 @@
+{{ define "main" }}
+  {{ .Content }}
+  {{ range site.RegularPages }}
+    <section>
+      <h2><a href="{{ .RelPermalink }}">{{ .LinkTitle }}</a></h2>
+      {{ .Summary }}
+    </section>
+  {{ end }}
+{{ end }}

create/skeletons/theme/layouts/partials/head/js.html

@@ -1,12 +0,0 @@
-{{- with resources.Get "js/main.js" }}
-  {{- if eq hugo.Environment "development" }}
-    {{- with . | js.Build }}
-      <script src="{{ .RelPermalink }}"></script>
-    {{- end }}
-  {{- else }}
-    {{- $opts := dict "minify" true }}
-    {{- with . | js.Build $opts | fingerprint }}
-      <script src="{{ .RelPermalink }}" integrity="{{- .Data.Integrity }}" crossorigin="anonymous"></script>
-    {{- end }}
-  {{- end }}
-{{- end }}

create/skeletons/theme/layouts/section.html

@@ -0,0 +1,10 @@
+{{ define "main" }}
+  <h1>{{ .Title }}</h1>
+  {{ .Content }}
+  {{ range .Pages }}
+    <section>
+      <h2><a href="{{ .RelPermalink }}">{{ .LinkTitle }}</a></h2>
+      {{ .Summary }}
+    </section>
+  {{ end }}
+{{ end }}

create/skeletons/theme/layouts/taxonomy.html

@@ -3,6 +3,5 @@
   {{ .Content }}
   {{ range .Pages }}
     <h2><a href="{{ .RelPermalink }}">{{ .LinkTitle }}</a></h2>
-    {{ .Summary }}
   {{ end }}
 {{ end }}

create/skeletons/theme/layouts/term.html

@@ -1,7 +1,7 @@
 {{ define "main" }}
+  <h1>{{ .Title }}</h1>
   {{ .Content }}
-  {{ range site.RegularPages }}
+  {{ range .Pages }}
     <h2><a href="{{ .RelPermalink }}">{{ .LinkTitle }}</a></h2>
-    {{ .Summary }}
   {{ end }}
 {{ end }}

create/skeletons/theme/theme.toml

@@ -1,31 +0,0 @@
-name = 'Theme name'
-license = 'MIT'
-licenselink = 'https://github.com/owner/repo/LICENSE'
-description = 'Theme description'
-
-# The home page of the theme, where the source can be found
-homepage = 'https://github.com/owner/repo'
-
-# If you have a running demo of the theme
-demosite = 'https://owner.github.io/repo'
-
-# Taxonomy terms
-tags = ['blog', 'company']
-features = ['some', 'awesome', 'features']
-
-# If the theme has multiple authors
-authors = [
-  {name = 'Name of author', homepage = 'Website of author'},
-  {name = 'Name of author', homepage = 'Website of author'}
-]
-
-# If the theme has a single author
-[author]
-  name = 'Your name'
-  homepage = 'Your website'
-
-# If porting an existing theme
-[original]
-  author = 'Name of original author'
-  homepage = 'Website of original author'
-  repo = 'https://github.com/owner/repo'

deploy/deploy.go

@@ -36,6 +36,7 @@ import (
 	"github.com/dustin/go-humanize"
 	"github.com/gobwas/glob"
 	"github.com/gohugoio/hugo/common/loggers"
+	"github.com/gohugoio/hugo/common/para"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/deploy/deployconfig"
 	"github.com/gohugoio/hugo/media"
@@ -487,7 +488,12 @@ func knownHiddenDirectory(name string) bool {
 // walkLocal walks the source directory and returns a flat list of files,
 // using localFile.SlashPath as the map keys.
 func (d *Deployer) walkLocal(fs afero.Fs, matchers []*deployconfig.Matcher, include, exclude glob.Glob, mediaTypes media.Types, mappath func(string) string) (map[string]*localFile, error) {
-	retval := map[string]*localFile{}
+	retval := make(map[string]*localFile)
+	var mu sync.Mutex
+
+	workers := para.New(d.cfg.Workers)
+	g, _ := workers.Start(context.Background())
+
 	err := afero.Walk(fs, "", func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
@@ -508,45 +514,54 @@ func (d *Deployer) walkLocal(fs afero.Fs, matchers []*deployconfig.Matcher, incl
 			return nil
 		}
 
-		// When a file system is HFS+, its filepath is in NFD form.
-		if runtime.GOOS == "darwin" {
-			path = norm.NFC.String(path)
-		}
-
-		// Check include/exclude matchers.
-		slashpath := filepath.ToSlash(path)
-		if include != nil && !include.Match(slashpath) {
-			d.logger.Infof("  dropping %q due to include\n", slashpath)
-			return nil
-		}
-		if exclude != nil && exclude.Match(slashpath) {
-			d.logger.Infof("  dropping %q due to exclude\n", slashpath)
-			return nil
-		}
-
-		// Find the first matching matcher (if any).
-		var m *deployconfig.Matcher
-		for _, cur := range matchers {
-			if cur.Matches(slashpath) {
-				m = cur
-				break
+		// Process each file in a worker
+		g.Run(func() error {
+			// When a file system is HFS+, its filepath is in NFD form.
+			if runtime.GOOS == "darwin" {
+				path = norm.NFC.String(path)
 			}
-		}
-		// Apply any additional modifications to the local path, to map it to
-		// the remote path.
-		if mappath != nil {
-			slashpath = mappath(slashpath)
-		}
-		lf, err := newLocalFile(fs, path, slashpath, m, mediaTypes)
-		if err != nil {
-			return err
-		}
-		retval[lf.SlashPath] = lf
+
+			// Check include/exclude matchers.
+			slashpath := filepath.ToSlash(path)
+			if include != nil && !include.Match(slashpath) {
+				d.logger.Infof("  dropping %q due to include\n", slashpath)
+				return nil
+			}
+			if exclude != nil && exclude.Match(slashpath) {
+				d.logger.Infof("  dropping %q due to exclude\n", slashpath)
+				return nil
+			}
+
+			// Find the first matching matcher (if any).
+			var m *deployconfig.Matcher
+			for _, cur := range matchers {
+				if cur.Matches(slashpath) {
+					m = cur
+					break
+				}
+			}
+			// Apply any additional modifications to the local path, to map it to
+			// the remote path.
+			if mappath != nil {
+				slashpath = mappath(slashpath)
+			}
+			lf, err := newLocalFile(fs, path, slashpath, m, mediaTypes)
+			if err != nil {
+				return err
+			}
+			mu.Lock()
+			retval[lf.SlashPath] = lf
+			mu.Unlock()
+			return nil
+		})
 		return nil
 	})
 	if err != nil {
 		return nil, err
 	}
+	if err := g.Wait(); err != nil {
+		return nil, err
+	}
 	return retval, nil
 }
 

deploy/deploy_test.go

@@ -623,7 +623,7 @@ func TestEndToEndSync(t *testing.T) {
 				localFs:    test.fs,
 				bucket:     test.bucket,
 				mediaTypes: media.DefaultTypes,
-				cfg:        deployconfig.DeployConfig{MaxDeletes: -1},
+				cfg:        deployconfig.DeployConfig{Workers: 2, MaxDeletes: -1},
 			}
 
 			// Initial deployment should sync remote with local.
@@ -706,7 +706,7 @@ func TestMaxDeletes(t *testing.T) {
 				localFs:    test.fs,
 				bucket:     test.bucket,
 				mediaTypes: media.DefaultTypes,
-				cfg:        deployconfig.DeployConfig{MaxDeletes: -1},
+				cfg:        deployconfig.DeployConfig{Workers: 2, MaxDeletes: -1},
 			}
 
 			// Sync remote with local.
@@ -836,7 +836,7 @@ func TestIncludeExclude(t *testing.T) {
 			}
 			deployer := &Deployer{
 				localFs: fsTest.fs,
-				cfg:     deployconfig.DeployConfig{MaxDeletes: -1}, bucket: fsTest.bucket,
+				cfg:     deployconfig.DeployConfig{Workers: 2, MaxDeletes: -1}, bucket: fsTest.bucket,
 				target:     tgt,
 				mediaTypes: media.DefaultTypes,
 			}
@@ -893,7 +893,7 @@ func TestIncludeExcludeRemoteDelete(t *testing.T) {
 			}
 			deployer := &Deployer{
 				localFs: fsTest.fs,
-				cfg:     deployconfig.DeployConfig{MaxDeletes: -1}, bucket: fsTest.bucket,
+				cfg:     deployconfig.DeployConfig{Workers: 2, MaxDeletes: -1}, bucket: fsTest.bucket,
 				mediaTypes: media.DefaultTypes,
 			}
 
@@ -945,7 +945,7 @@ func TestCompression(t *testing.T) {
 			deployer := &Deployer{
 				localFs:    test.fs,
 				bucket:     test.bucket,
-				cfg:        deployconfig.DeployConfig{MaxDeletes: -1, Matchers: []*deployconfig.Matcher{{Pattern: ".*", Gzip: true, Re: regexp.MustCompile(".*")}}},
+				cfg:        deployconfig.DeployConfig{Workers: 2, MaxDeletes: -1, Matchers: []*deployconfig.Matcher{{Pattern: ".*", Gzip: true, Re: regexp.MustCompile(".*")}}},
 				mediaTypes: media.DefaultTypes,
 			}
 
@@ -1000,7 +1000,7 @@ func TestMatching(t *testing.T) {
 			deployer := &Deployer{
 				localFs:    test.fs,
 				bucket:     test.bucket,
-				cfg:        deployconfig.DeployConfig{MaxDeletes: -1, Matchers: []*deployconfig.Matcher{{Pattern: "^subdir/aaa$", Force: true, Re: regexp.MustCompile("^subdir/aaa$")}}},
+				cfg:        deployconfig.DeployConfig{Workers: 2, MaxDeletes: -1, Matchers: []*deployconfig.Matcher{{Pattern: "^subdir/aaa$", Force: true, Re: regexp.MustCompile("^subdir/aaa$")}}},
 				mediaTypes: media.DefaultTypes,
 			}
 
@@ -1097,5 +1097,6 @@ func verifyRemote(ctx context.Context, bucket *blob.Bucket, local []*fileData) (
 func newDeployer() *Deployer {
 	return &Deployer{
 		logger: loggers.NewDefault(),
+		cfg:    deployconfig.DeployConfig{Workers: 2},
 	}
 }