js/esbuild: Add an integration test for multiple options for the same input JS file

See #14254

.circleci/config.yml

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

.gemini/config.yaml

@@ -0,0 +1,13 @@
+have_fun: false
+memory_config:
+  disabled: false
+code_review:
+  disable: false
+  comment_severity_threshold: HIGH
+  max_review_comments: -1
+  pull_request_opened:
+    help: true
+    summary: false
+    code_review: false
+    include_drafts: false
+ignore_patterns: []

.github/pull_request_template.md

@@ -0,0 +1,10 @@
+🛑 Before submitting this PR
+
+All PRs must be linked to an Issue in this repository, and that Issue must be approved by a project maintainer:
+
+- For a bug, approval means that the "needs triage" label is removed.
+- For a proposal, approval means that the "proposal" label is replaced by an "enhancement" label.
+
+PRs without a linked, approved Issue will be closed immediately.
+
+Please review the contribution guide (CONTRIBUTING.md) to understand commit message guidelines and AI assistance disclosures.

.github/workflows/aiwatchdog.yml

@@ -0,0 +1,22 @@
+name: AI Detection
+on:
+  # Use pull_request_target instead of pull_request (we need the secrets.OPENAI_API_KEY to be available for forks)
+  pull_request_target:
+    types: [opened, ready_for_review]
+permissions:
+  contents: read
+  pull-requests: write
+jobs:
+  detect-ai:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.pull_request.draft }}
+    steps:
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+      - name: AI Watchdog
+        uses: bep/ai-watchdog@995475dd81767f8035dc2c943e9230918d06caca # temporary fork (probably)
+        with:
+          openai-api-key: ${{ secrets.OPENAI_API_KEY }}
+          pr-label: AI Suspect
+          fail-when-confident: false
+          # CSV list.
+          pr-user-logins-skip: dependabot[bot]

.github/workflows/image.yml

@@ -16,20 +16,20 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Docker meta
         id: meta
-        uses: docker/metadata-action@8e5442c4ef9f78752691e2d8f8d19755c6f78e81 # v5.5.1
+        uses: docker/metadata-action@318604b99e75e41977312d83839a89be02ca4893 # v5.9.0
         with:
           images: ${{ env.REGISTRY_IMAGE }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db # v3.6.1
+        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
 
       - name: Login to GHCR
         # Login is only needed when the image is pushed
-        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3.3.0
+        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -37,7 +37,7 @@ jobs:
 
       - name: Build and push
         id: build
-        uses: docker/build-push-action@16ebe778df0e7752d2cfcbd924afdbbd89c1a755 # v6.6.1
+        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
         with:
           context: .
           provenance: mode=max

.github/workflows/stale.yml

@@ -24,7 +24,7 @@ jobs:
             This pull request has been automatically locked since there
             has not been any recent activity after it was closed.
             Please open a new issue for related bugs.
-      - uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9.0.0
+      - uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
         with:
           operations-per-run: 999
           days-before-issue-stale: 365

.github/workflows/test.yml

@@ -24,9 +24,7 @@ jobs:
         name: Free Disk Space (Ubuntu)
         uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be # v1.3.1
         with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: false
+          tool-cache: true
           android: true
           dotnet: true
           haskell: true
@@ -34,9 +32,9 @@ jobs:
           docker-images: true
           swap-storage: true
       - name: Checkout code
-        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Install Go
-        uses: actions/setup-go@0a12ed9d6a96ab950c8f026ed9f722fe0da7ef32 # v5.0.2
+        uses: actions/setup-go@44694675825211faa026b3c33043df3e48a5fa00 # v6.0.0
         with:
           go-version: ${{ matrix.go-version }}
           check-latest: true
@@ -45,18 +43,21 @@ jobs:
             **/go.sum
             **/go.mod
       - name: Install Ruby
-        uses: ruby/setup-ruby@44511735964dcb71245e7e55f72539531f7bc0eb # v1.257.0
+        uses: ruby/setup-ruby@8aeb6ff8030dd539317f8e1769a044873b56ea71 # v1.268.0
         with:
-          ruby-version: "2.7"
-          bundler-cache: true #
+          ruby-version: "3.4.5"
+      - name: Install Ruby gems
+        run: |
+          gem install asciidoctor -v "2.0.26"
+          gem install asciidoctor-diagram -v "3.1.0"
+      - name: Install GoAT
+        run: go install github.com/blampe/goat/cmd/goat@177de93b192b8ffae608e5d9ec421cc99bf68402
       - name: Install Python
-        uses: actions/setup-python@39cd14951b08e74b54015e9e001cdefcf80e669f # v5.1.1
+        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
         with:
           python-version: "3.x"
       - name: Install Mage
         run: go install github.com/magefile/mage@v1.15.0
-      - name: Install asciidoctor
-        uses: reitzig/actions-asciidoctor@c642db5eedd1d729bb8c92034770d0b2f769eda6 # v2.0.2
       - name: Install docutils
         run: |
           pip install docutils

CONTRIBUTING.md

@@ -19,6 +19,7 @@ The Hugo community and maintainers are [very active](https://github.com/gohugoio
 * [Reporting Issues](#reporting-issues)
 * [Submitting Patches](#submitting-patches)
   * [Code Contribution Guidelines](#code-contribution-guidelines)
+  * [AI Assistance Notice](#ai-assistance-notice)
   * [Git Commit Message Guidelines](#git-commit-message-guidelines)
   * [Fetching the Sources From GitHub](#fetching-the-sources-from-github)
   * [Building Hugo with Your Changes](#building-hugo-with-your-changes)
@@ -54,7 +55,7 @@ If it is of some complexity, the contributor is expected to maintain and support
 
 Any non-trivial code change needs to update an open [issue](https://github.com/gohugoio/hugo/issues). A non-trivial code change without an issue reference with one of the labels `bug` or `enhancement` will not be merged.
 
-Note that we do not accept new features that require [CGO](https://github.com/golang/go/wiki/cgo).
+Note that we do not accept new features that require [CGO](https://go.dev/wiki/cgo).
 We have one exception to this rule which is LibSASS.
 
 **Bug fixes are, of course, always welcome.**
@@ -79,6 +80,16 @@ To make the contribution process as seamless as possible, we ask for the followi
     * Ensure that `mage check` succeeds. [Travis CI](https://travis-ci.org/gohugoio/hugo) (Windows, Linux and macOS) will fail the build if `mage check` fails.
     * Follow the **Git Commit Message Guidelines** below.
 
+## AI Assistance Notice
+
+If a substantial part of your contribution is autogenerated with AI, **this must be disclosed in the pull request**, along with the extent to which AI assistance was used.
+
+An example disclosure:
+
+> This PR was written primarily by Claude Code.
+
+When using AI assistance, we expect contributors to understand the code that is produced and be able to answer critical questions about it.
+
 ### Git Commit Message Guidelines
 
 This [blog article](https://cbea.ms/git-commit/) is a good resource for learning how to write good commit messages,

cache/dynacache/dynacache.go

@@ -340,7 +340,7 @@ func GetOrCreatePartition[K comparable, V any](c *Cache, name string, opts Optio
 		panic("invalid Weight, must be between 1 and 100")
 	}
 
-	if partitionNameRe.FindString(name) != name {
+	if !partitionNameRe.MatchString(name) {
 		panic(fmt.Sprintf("invalid partition name %q", name))
 	}
 

cache/filecache/filecache_config.go

@@ -51,11 +51,18 @@ const (
 
 type Configs map[string]FileCacheConfig
 
+// CacheDirModules returns the compiled path to the modules cache.
 // For internal use.
 func (c Configs) CacheDirModules() string {
 	return c[CacheKeyModules].DirCompiled
 }
 
+// CacheDirMisc returns the compiled path to the misc cache.
+// For internal use.
+func (c Configs) CacheDirMisc() string {
+	return c[CacheKeyMisc].DirCompiled
+}
+
 var defaultCacheConfigs = Configs{
 	CacheKeyModules: {
 		MaxAge: -1,

cache/filecache/filecache_integration_test.go

@@ -67,7 +67,7 @@ title: "Home"
 ---
 -- assets/a/pixel.png --
 iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
--- layouts/index.html --
+-- layouts/home.html --
 {{ warnf "HOME!" }}
 {{ $img := resources.GetMatch "**.png" }}
 {{ $img = $img.Resize "3x3" }}

cache/filecache/filecache_test.go

@@ -270,7 +270,7 @@ func newPathsSpec(t *testing.T, fs afero.Fs, configStr string) *helpers.PathSpec
 	cfg, err := config.FromConfigString(configStr, "toml")
 	c.Assert(err, qt.IsNil)
 	acfg := testconfig.GetTestConfig(fs, cfg)
-	p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, acfg.BaseConfig()), acfg, nil)
+	p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, acfg.BaseConfig()), acfg, nil, nil)
 	c.Assert(err, qt.IsNil)
 	return p
 }

cache/httpcache/httpcache.go

@@ -173,16 +173,16 @@ func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
 	if gm.IsZero() {
 		panic("no includes or excludes")
 	}
-	var p predicate.P[string]
+	var b predicate.PR[string]
 	for _, include := range gm.Includes {
 		g, err := glob.Compile(include, '/')
 		if err != nil {
 			return nil, err
 		}
-		fn := func(s string) bool {
-			return g.Match(s)
+		fn := func(s string) predicate.Match {
+			return predicate.BoolMatch(g.Match(s))
 		}
-		p = p.Or(fn)
+		b = b.Or(fn)
 	}
 
 	for _, exclude := range gm.Excludes {
@@ -190,13 +190,13 @@ func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
 		if err != nil {
 			return nil, err
 		}
-		fn := func(s string) bool {
-			return !g.Match(s)
+		fn := func(s string) predicate.Match {
+			return predicate.BoolMatch(!g.Match(s))
 		}
-		p = p.And(fn)
+		b = b.And(fn)
 	}
 
-	return p, nil
+	return b.BoolFunc(), nil
 }
 
 func DecodeConfig(_ config.BaseConfig, m map[string]any) (Config, error) {

cache/httpcache/httpcache_test.go

@@ -52,7 +52,7 @@ func TestDefaultConfig(t *testing.T) {
 func TestDecodeConfigInjectsDefaultAndCompiles(t *testing.T) {
 	c := qt.New(t)
 
-	cfg, err := DecodeConfig(config.BaseConfig{}, map[string]interface{}{})
+	cfg, err := DecodeConfig(config.BaseConfig{}, map[string]any{})
 	c.Assert(err, qt.IsNil)
 	c.Assert(cfg, qt.DeepEquals, DefaultConfig)
 

commands/commandeer.go

@@ -401,9 +401,7 @@ func (r *rootCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args
 
 	watchGroups := helpers.ExtractAndGroupRootPaths(watchDirs)
 
-	for _, group := range watchGroups {
-		r.Printf("Watching for changes in %s\n", group)
-	}
+	r.Printf("Watching for changes in %s\n", strings.Join(watchGroups, ", "))
 	watcher, err := b.newWatcher(r.poll, watchDirs...)
 	if err != nil {
 		return err

commands/config.go

@@ -25,6 +25,7 @@ import (
 	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/config/allconfig"
+	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
 	"github.com/gohugoio/hugo/modules"
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
@@ -71,7 +72,7 @@ func (c *configCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 			return fmt.Errorf("language %q not found", c.lang)
 		}
 	} else {
-		config = conf.configs.LanguageConfigSlice[0]
+		config = conf.configs.LanguageConfigMap[conf.configs.Base.DefaultContentLanguage]
 	}
 
 	var buf bytes.Buffer
@@ -128,9 +129,9 @@ func (c *configCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 }
 
 type configModMount struct {
-	Source string `json:"source"`
-	Target string `json:"target"`
-	Lang   string `json:"lang,omitempty"`
+	Source string            `json:"source"`
+	Target string            `json:"target"`
+	Sites  sitesmatrix.Sites `json:"sites,omitzero"`
 }
 
 type configModMounts struct {
@@ -146,7 +147,7 @@ func (m *configModMounts) MarshalJSON() ([]byte, error) {
 		mounts = append(mounts, configModMount{
 			Source: mount.Source,
 			Target: mount.Target,
-			Lang:   mount.Lang,
+			Sites:  mount.Sites,
 		})
 	}
 

commands/gen.go

@@ -249,7 +249,7 @@ url: %s
 					return err
 				}
 				defer f.Close()
-				yamlEnc := yaml.NewEncoder(f)
+				yamlEnc := yaml.NewEncoder(f, yaml.UseSingleQuote(true), yaml.AutoInt())
 				if err := yamlEnc.Encode(m); err != nil {
 					return err
 				}

commands/hugobuilder.go

@@ -31,6 +31,7 @@ import (
 	"github.com/bep/simplecobra"
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/common/hstrings"
 	"github.com/gohugoio/hugo/common/htime"
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
@@ -143,7 +144,7 @@ func (c *hugoBuilder) getDirList() ([]string, error) {
 		return nil, err
 	}
 
-	return helpers.UniqueStringsSorted(h.PathSpec.BaseFs.WatchFilenames()), nil
+	return hstrings.UniqueStringsSorted(h.PathSpec.BaseFs.WatchFilenames()), nil
 }
 
 func (c *hugoBuilder) initCPUProfile() (func(), error) {
@@ -463,7 +464,15 @@ func (c *hugoBuilder) copyStaticTo(sourceFs *filesystems.SourceFilesystem) (uint
 		infol.Logf("removing all files from destination that don't exist in static dirs")
 
 		syncer.DeleteFilter = func(f fsync.FileInfo) bool {
-			return f.IsDir() && strings.HasPrefix(f.Name(), ".")
+			name := f.Name()
+
+			// Keep .gitignore and .gitattributes anywhere
+			if name == ".gitignore" || name == ".gitattributes" {
+				return true
+			}
+
+			// Keep Hugo's original dot-directory behavior
+			return f.IsDir() && strings.HasPrefix(name, ".")
 		}
 	}
 	start := time.Now()
@@ -827,7 +836,7 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 			continue
 		}
 
-		walkAdder := func(path string, f hugofs.FileMetaInfo) error {
+		walkAdder := func(ctx context.Context, path string, f hugofs.FileMetaInfo) error {
 			if f.IsDir() {
 				c.r.logger.Println("adding created directory to watchlist", path)
 				if err := watcher.Add(path); err != nil {

commands/import.go

@@ -427,7 +427,7 @@ func (c *importCommand) importFromJekyll(args []string) error {
 	c.r.Println("Importing...")
 
 	fileCount := 0
-	callback := func(path string, fi hugofs.FileMetaInfo) error {
+	callback := func(ctx context.Context, path string, fi hugofs.FileMetaInfo) error {
 		if fi.IsDir() {
 			return nil
 		}

commands/release.go

@@ -28,13 +28,14 @@ func newReleaseCommand() simplecobra.Commander {
 		step     int
 		skipPush bool
 		try      bool
+		version  string
 	)
 
 	return &simpleCommand{
 		name:  "release",
 		short: "Release a new version of Hugo",
 		run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-			rel, err := releaser.New(skipPush, try, step)
+			rel, err := releaser.New(skipPush, try, step, version)
 			if err != nil {
 				return err
 			}
@@ -47,6 +48,7 @@ func newReleaseCommand() simplecobra.Commander {
 			cmd.PersistentFlags().BoolVarP(&skipPush, "skip-push", "", false, "skip pushing to remote")
 			cmd.PersistentFlags().BoolVarP(&try, "try", "", false, "no changes")
 			cmd.PersistentFlags().IntVarP(&step, "step", "", 0, "step to run (1: set new version 2: prepare next dev version)")
+			cmd.PersistentFlags().StringVarP(&version, "version", "", "", "version to release (derived from branch name if not set)")
 			_ = cmd.RegisterFlagCompletionFunc("step", cobra.FixedCompletions([]string{"1", "2"}, cobra.ShellCompDirectiveNoFileComp))
 		},
 	}

commands/server.go

@@ -49,6 +49,8 @@ import (
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/gohugoio/hugo/common/paths"
+	"github.com/gohugoio/hugo/langs"
 	"github.com/gohugoio/hugo/tpl/tplimpl"
 
 	"github.com/gohugoio/hugo/common/types"
@@ -369,6 +371,12 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string
 
 			if f.c.fastRenderMode && f.c.errState.buildErr() == nil {
 				if isNavigation(requestURI, r) {
+					// See issue 14240.
+					// Hugo escapes the URL paths when generating them,
+					// that may not be the case when we receive it back from the browser.
+					// PathEscape will escape if it is not already escaped.
+					requestURI = paths.PathEscape(requestURI)
+
 					if !f.c.visitedURLs.Contains(requestURI) {
 						// If not already on stack, re-render that single page.
 						if err := f.c.partialReRender(requestURI); err != nil {
@@ -491,9 +499,7 @@ func (c *serverCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, arg
 
 		watchGroups := helpers.ExtractAndGroupRootPaths(watchDirs)
 
-		for _, group := range watchGroups {
-			c.r.Printf("Watching for changes in %s\n", group)
-		}
+		c.r.Printf("Watching for changes in %s\n", strings.Join(watchGroups, ", "))
 		watcher, err := c.newWatcher(c.r.poll, watchDirs...)
 		if err != nil {
 			return err
@@ -627,7 +633,7 @@ func (c *serverCommand) setServerInfoInConfig() error {
 		panic("no server ports set")
 	}
 	return c.withConfE(func(conf *commonConfig) error {
-		for i, language := range conf.configs.LanguagesDefaultFirst {
+		for i, language := range conf.configs.Languages {
 			isMultihost := conf.configs.IsMultihost
 			var serverPort int
 			if isMultihost {
@@ -879,7 +885,7 @@ func (c *serverCommand) serve() error {
 		if isMultihost {
 			for _, l := range conf.configs.ConfigLangs() {
 				baseURLs = append(baseURLs, l.BaseURL())
-				roots = append(roots, l.Language().Lang)
+				roots = append(roots, l.Language().(*langs.Language).Lang)
 			}
 		} else {
 			l := conf.configs.GetFirstLanguageConfig()
@@ -1034,7 +1040,6 @@ func (c *serverCommand) serve() error {
 	defer cancel()
 	wg2, ctx := errgroup.WithContext(ctx)
 	for _, srv := range servers {
-		srv := srv
 		wg2.Go(func() error {
 			return srv.Shutdown(ctx)
 		})

common/collections/append.go

@@ -16,6 +16,8 @@ package collections
 import (
 	"fmt"
 	"reflect"
+
+	"github.com/gohugoio/hugo/common/hreflect"
 )
 
 // Append appends from to a slice to and returns the resulting slice.
@@ -25,7 +27,7 @@ func Append(to any, from ...any) (any, error) {
 	if len(from) == 0 {
 		return to, nil
 	}
-	tov, toIsNil := indirect(reflect.ValueOf(to))
+	tov, toIsNil := hreflect.Indirect(reflect.ValueOf(to))
 
 	toIsNil = toIsNil || to == nil
 	var tot reflect.Type
@@ -100,7 +102,7 @@ func Append(to any, from ...any) (any, error) {
 		fv := reflect.ValueOf(f)
 		if !fv.IsValid() || !fv.Type().AssignableTo(tot) {
 			// Fall back to a []interface{} slice.
-			tov, _ := indirect(reflect.ValueOf(to))
+			tov, _ := hreflect.Indirect(reflect.ValueOf(to))
 			return appendToInterfaceSlice(tov, from...)
 		}
 		tov = reflect.Append(tov, fv)
@@ -136,17 +138,3 @@ func appendToInterfaceSlice(tov reflect.Value, from ...any) ([]any, error) {
 
 	return tos, nil
 }
-
-// indirect is borrowed from the Go stdlib: 'text/template/exec.go'
-// TODO(bep) consolidate
-func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
-	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
-		if v.IsNil() {
-			return v, true
-		}
-		if v.Kind() == reflect.Interface && v.NumMethod() > 0 {
-			break
-		}
-	}
-	return v, false
-}

common/collections/append_test.go

@@ -15,7 +15,6 @@ package collections
 
 import (
 	"html/template"
-	"reflect"
 	"testing"
 
 	qt "github.com/frankban/quicktest"
@@ -148,66 +147,3 @@ 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/stack.go

@@ -13,9 +13,13 @@
 
 package collections
 
-import "slices"
+import (
+	"iter"
+	"slices"
+	"sync"
 
-import "sync"
+	"github.com/gohugoio/hugo/common/hiter"
+)
 
 // Stack is a simple LIFO stack that is safe for concurrent use.
 type Stack[T any] struct {
@@ -60,6 +64,11 @@ func (s *Stack[T]) Len() int {
 	return len(s.items)
 }
 
+// All returns all items in the stack, from bottom to top.
+func (s *Stack[T]) All() iter.Seq2[int, T] {
+	return hiter.Lock2(slices.All(s.items), s.mu.RLock, s.mu.RUnlock)
+}
+
 func (s *Stack[T]) Drain() []T {
 	s.mu.Lock()
 	defer s.mu.Unlock()

common/hashing/hashing.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/cespare/xxhash/v2"
 	"github.com/gohugoio/hashstructure"
+	"github.com/gohugoio/hugo/common/hugio"
 	"github.com/gohugoio/hugo/identity"
 )
 
@@ -38,6 +39,34 @@ func XXHashFromReader(r io.Reader) (uint64, int64, error) {
 	return h.Sum64(), size, nil
 }
 
+type Hasher interface {
+	io.StringWriter
+	io.Writer
+	io.ReaderFrom
+	Sum64() uint64
+}
+
+type HashCloser interface {
+	Hasher
+	io.Closer
+}
+
+// XxHasher returns a Hasher that uses xxHash.
+// Remember to call Close when done.
+func XxHasher() HashCloser {
+	h := getXxHashReadFrom()
+	return struct {
+		Hasher
+		io.Closer
+	}{
+		Hasher: h,
+		Closer: hugio.CloserFunc(func() error {
+			putXxHashReadFrom(h)
+			return nil
+		}),
+	}
+}
+
 // XxHashFromReaderHexEncoded calculates the xxHash for the given reader
 // and returns the hash as a hex encoded string.
 func XxHashFromReaderHexEncoded(r io.Reader) (string, error) {

common/hashing/hashing_test.go

@@ -38,7 +38,6 @@ func TestXxHashFromReaderPara(t *testing.T) {
 
 	var wg sync.WaitGroup
 	for i := range 10 {
-		i := i
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
@@ -75,8 +74,8 @@ func TestXxHashFromStringHexEncoded(t *testing.T) {
 
 func BenchmarkXXHashFromReader(b *testing.B) {
 	r := strings.NewReader("Hello World")
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+
+	for b.Loop() {
 		XXHashFromReader(r)
 		r.Seek(0, 0)
 	}
@@ -84,16 +83,16 @@ func BenchmarkXXHashFromReader(b *testing.B) {
 
 func BenchmarkXXHashFromString(b *testing.B) {
 	s := "Hello World"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+
+	for b.Loop() {
 		XXHashFromString(s)
 	}
 }
 
 func BenchmarkXXHashFromStringHexEncoded(b *testing.B) {
 	s := "The quick brown fox jumps over the lazy dog"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+
+	for b.Loop() {
 		XxHashFromStringHexEncoded(s)
 	}
 }
@@ -136,7 +135,7 @@ func BenchmarkHashString(b *testing.B) {
 
 	for _, test := range tests {
 		b.Run(fmt.Sprintf("n%d", len(test)), func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
+			for b.Loop() {
 				HashString(test)
 			}
 		})
@@ -149,9 +148,7 @@ func BenchmarkHashMap(b *testing.B) {
 		m[fmt.Sprintf("key%d", i)] = i
 	}
 
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		HashString(m)
 	}
 }

common/herrors/errors.go

@@ -19,7 +19,7 @@ import (
 	"fmt"
 	"os"
 	"regexp"
-	"runtime/debug"
+	"runtime"
 	"strings"
 	"time"
 )
@@ -36,7 +36,9 @@ type ErrorSender interface {
 func Recover(args ...any) {
 	if r := recover(); r != nil {
 		fmt.Println("ERR:", r)
-		args = append(args, "stacktrace from panic: \n"+string(debug.Stack()), "\n")
+		buf := make([]byte, 64<<10)
+		buf = buf[:runtime.Stack(buf, false)]
+		args = append(args, "stacktrace from panic: \n"+string(buf), "\n")
 		fmt.Println(args...)
 	}
 }

common/hiter/iter.go

@@ -0,0 +1,66 @@
+package hiter
+
+// Common iterator functions.
+// Some of these are are based on this discsussion: https://github.com/golang/go/issues/61898
+
+import "iter"
+
+// Concat returns an iterator over the concatenation of the sequences.
+// Any nil sequences are ignored.
+func Concat[V any](seqs ...iter.Seq[V]) iter.Seq[V] {
+	return func(yield func(V) bool) {
+		for _, seq := range seqs {
+			if seq == nil {
+				continue
+			}
+			for e := range seq {
+				if !yield(e) {
+					return
+				}
+			}
+		}
+	}
+}
+
+// Concat2 returns an iterator over the concatenation of the sequences.
+// Any nil sequences are ignored.
+func Concat2[K, V any](seqs ...iter.Seq2[K, V]) iter.Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		for _, seq := range seqs {
+			if seq == nil {
+				continue
+			}
+			for k, v := range seq {
+				if !yield(k, v) {
+					return
+				}
+			}
+		}
+	}
+}
+
+// Lock returns an iterator that locks before iterating and unlocks after.
+func Lock[V any](seq iter.Seq[V], lock, unlock func()) iter.Seq[V] {
+	return func(yield func(V) bool) {
+		lock()
+		defer unlock()
+		for e := range seq {
+			if !yield(e) {
+				return
+			}
+		}
+	}
+}
+
+// Lock2 returns an iterator that locks before iterating and unlocks after.
+func Lock2[K, V any](seq iter.Seq2[K, V], lock, unlock func()) iter.Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		lock()
+		defer unlock()
+		for k, v := range seq {
+			if !yield(k, v) {
+				return
+			}
+		}
+	}
+}

common/hreflect/convert.go

@@ -0,0 +1,222 @@
+// 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 hreflect
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+)
+
+var (
+	typeInt64   = reflect.TypeFor[int64]()
+	typeFloat64 = reflect.TypeFor[float64]()
+	typeString  = reflect.TypeFor[string]()
+)
+
+// ToInt64 converts v to int64 if possible, returning an error if not.
+func ToInt64E(v reflect.Value) (int64, error) {
+	if v, ok := ConvertIfPossible(v, typeInt64); ok {
+		return v.Int(), nil
+	}
+	return 0, errConvert(v, "int64")
+}
+
+// ToInt64 converts v to int64 if possible. It panics if the conversion is not possible.
+func ToInt64(v reflect.Value) int64 {
+	vv, err := ToInt64E(v)
+	if err != nil {
+		panic(err)
+	}
+	return vv
+}
+
+// ToFloat64E converts v to float64 if possible, returning an error if not.
+func ToFloat64E(v reflect.Value) (float64, error) {
+	if v, ok := ConvertIfPossible(v, typeFloat64); ok {
+		return v.Float(), nil
+	}
+	return 0, errConvert(v, "float64")
+}
+
+// ToFloat64 converts v to float64 if possible, panicking if not.
+func ToFloat64(v reflect.Value) float64 {
+	vv, err := ToFloat64E(v)
+	if err != nil {
+		panic(err)
+	}
+	return vv
+}
+
+// ToStringE converts v to string if possible, returning an error if not.
+func ToStringE(v reflect.Value) (string, error) {
+	vv, err := ToStringValueE(v)
+	if err != nil {
+		return "", err
+	}
+	return vv.String(), nil
+}
+
+func ToStringValueE(v reflect.Value) (reflect.Value, error) {
+	if v, ok := ConvertIfPossible(v, typeString); ok {
+		return v, nil
+	}
+	return reflect.Value{}, errConvert(v, "string")
+}
+
+// ToString converts v to string if possible, panicking if not.
+func ToString(v reflect.Value) string {
+	vv, err := ToStringE(v)
+	if err != nil {
+		panic(err)
+	}
+	return vv
+}
+
+func errConvert(v reflect.Value, s string) error {
+	return fmt.Errorf("unable to convert value of type %q to %q", v.Type().String(), s)
+}
+
+// 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) {
+	switch val.Kind() {
+	case reflect.Ptr, reflect.Interface:
+		if val.IsNil() {
+			// Return typ's zero value.
+			return reflect.Zero(typ), true
+		}
+		val = val.Elem()
+	}
+
+	if val.Type().AssignableTo(typ) {
+		// No conversion needed.
+		return val, true
+	}
+
+	if IsInt(typ.Kind()) {
+		return convertToIntIfPossible(val, typ)
+	}
+	if IsFloat(typ.Kind()) {
+		return convertToFloatIfPossible(val, typ)
+	}
+	if IsUint(typ.Kind()) {
+		return convertToUintIfPossible(val, typ)
+	}
+	if IsString(typ.Kind()) && IsString(val.Kind()) {
+		return val.Convert(typ), true
+	}
+
+	return reflect.Value{}, false
+}
+
+func convertToUintIfPossible(val reflect.Value, typ reflect.Type) (reflect.Value, bool) {
+	if IsInt(val.Kind()) {
+		i := val.Int()
+		if i < 0 {
+			return reflect.Value{}, false
+		}
+		u := uint64(i)
+		if typ.OverflowUint(u) {
+			return reflect.Value{}, false
+		}
+		return reflect.ValueOf(u).Convert(typ), true
+	}
+	if IsUint(val.Kind()) {
+		if typ.OverflowUint(val.Uint()) {
+			return reflect.Value{}, false
+		}
+		return val.Convert(typ), true
+	}
+	if IsFloat(val.Kind()) {
+		f := val.Float()
+		if f < 0 || f > float64(math.MaxUint64) {
+			return reflect.Value{}, false
+		}
+		if f != math.Trunc(f) {
+			return reflect.Value{}, false
+		}
+		u := uint64(f)
+		if typ.OverflowUint(u) {
+			return reflect.Value{}, false
+		}
+		return reflect.ValueOf(u).Convert(typ), true
+	}
+	return reflect.Value{}, false
+}
+
+func convertToFloatIfPossible(val reflect.Value, typ reflect.Type) (reflect.Value, bool) {
+	if IsInt(val.Kind()) {
+		i := val.Int()
+		f := float64(i)
+		if typ.OverflowFloat(f) {
+			return reflect.Value{}, false
+		}
+		return reflect.ValueOf(f).Convert(typ), true
+	}
+	if IsUint(val.Kind()) {
+		u := val.Uint()
+		f := float64(u)
+		if typ.OverflowFloat(f) {
+			return reflect.Value{}, false
+		}
+		return reflect.ValueOf(f).Convert(typ), true
+	}
+	if IsFloat(val.Kind()) {
+		if typ.OverflowFloat(val.Float()) {
+			return reflect.Value{}, false
+		}
+		return val.Convert(typ), true
+	}
+
+	return reflect.Value{}, false
+}
+
+func convertToIntIfPossible(val reflect.Value, typ reflect.Type) (reflect.Value, bool) {
+	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
+		}
+		if f != math.Trunc(f) {
+			return reflect.Value{}, false
+		}
+		if typ.OverflowInt(int64(f)) {
+			return reflect.Value{}, false
+		}
+		return reflect.ValueOf(int64(f)).Convert(typ), true
+
+	}
+
+	return reflect.Value{}, false
+}

common/hreflect/convert_test.go

@@ -0,0 +1,284 @@
+// 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 hreflect
+
+import (
+	"math"
+	"reflect"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/htesting/hqt"
+)
+
+func TestToFuncs(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(ToInt64(reflect.ValueOf(int(42))), qt.Equals, int64(42))
+	c.Assert(ToFloat64(reflect.ValueOf(float32(3.14))), hqt.IsSameFloat64, float64(3.14))
+	c.Assert(ToString(reflect.ValueOf("hello")), qt.Equals, "hello")
+}
+
+func TestConvertIfPossible(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 float64 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.MaxInt16+1) to int16",
+			value: float64(math.MaxInt16 + 1),
+			typ:   int16(0),
+			ok:    false, // overflow
+		},
+		{
+			name:  "float64(math.MaxFloat64) to int64",
+			value: float64(math.MaxFloat64),
+			typ:   int64(0),
+			ok:    false, // overflow
+		},
+		{
+			name:     "float64(32767) to int16",
+			value:    float64(32767),
+			typ:      int16(0),
+			ok:       true,
+			expected: int16(32767),
+		},
+		// From float32 to int.
+		{
+			name:  "float32(1.5) to int",
+			value: float32(1.5),
+			typ:   int(0),
+			ok:    false, // loss of precision
+		},
+		{
+			name:     "float32(1.0) to int",
+			value:    float32(1.0),
+			typ:      int(0),
+			ok:       true,
+			expected: int(1),
+		},
+		{
+			name:  "float32(math.MaxFloat32) to int16",
+			value: float32(math.MaxFloat32),
+			typ:   int16(0),
+			ok:    false, // overflow
+		},
+		{
+			name:  "float32(math.MaxFloat32) to int64",
+			value: float32(math.MaxFloat32),
+			typ:   int64(0),
+			ok:    false, // overflow
+		},
+		{
+			name:     "float32(math.MaxInt16) to int16",
+			value:    float32(math.MaxInt16),
+			typ:      int16(0),
+			ok:       true,
+			expected: int16(32767),
+		},
+		{
+			name:  "float32(math.MaxInt16+1) to int16",
+			value: float32(math.MaxInt16 + 1),
+			typ:   int16(0),
+			ok:    false, // overflow
+		},
+		// Int to float.
+		{
+			name:     "int16(32767) to float32",
+			value:    int16(32767),
+			typ:      float32(0),
+			ok:       true,
+			expected: float32(32767),
+		},
+		{
+			name:     "int64(32767) to float32",
+			value:    int64(32767),
+			typ:      float32(0),
+			ok:       true,
+			expected: float32(32767),
+		},
+		{
+			name:     "int64(math.MaxInt64) to float32",
+			value:    int64(math.MaxInt64),
+			typ:      float32(0),
+			ok:       true,
+			expected: float32(math.MaxInt64),
+		},
+		{
+			name:     "int64(math.MaxInt64) to float64",
+			value:    int64(math.MaxInt64),
+			typ:      float64(0),
+			ok:       true,
+			expected: float64(math.MaxInt64),
+		},
+		// Int to uint.
+		{
+			name:     "int16(32767) to uint16",
+			value:    int16(32767),
+			typ:      uint16(0),
+			ok:       true,
+			expected: uint16(32767),
+		},
+		{
+			name:  "int16(32767) to uint8",
+			value: int16(32767),
+			typ:   uint8(0),
+			ok:    false,
+		},
+		{
+			name:  "float64(3.14) to uint64",
+			value: float64(3.14),
+			typ:   uint64(0),
+			ok:    false,
+		},
+		{
+			name:     "float64(3.0) to uint64",
+			value:    float64(3.0),
+			typ:      uint64(0),
+			ok:       true,
+			expected: uint64(3),
+		},
+		// From uint to float.
+		{
+			name:     "uint64(math.MaxInt16) to float64",
+			value:    uint64(math.MaxInt16),
+			typ:      float64(0),
+			ok:       true,
+			expected: float64(math.MaxInt16),
+		},
+		// Float to float.
+		{
+			name:     "float64(3.14) to float32",
+			value:    float64(3.14),
+			typ:      float32(0),
+			ok:       true,
+			expected: float32(3.14),
+		},
+		{
+			name:     "float32(3.14) to float64",
+			value:    float32(3.14),
+			typ:      float64(0),
+			ok:       true,
+			expected: float64(3.14),
+		},
+		{
+			name:     "float64(3.14) to float64",
+			value:    float64(3.14),
+			typ:      float64(0),
+			ok:       true,
+			expected: float64(3.14),
+		},
+	} {
+
+		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(), hqt.IsSameNumber, test.expected, qt.Commentf("test case: %s", test.name))
+		}
+	}
+}
+
+func TestConvertIfPossibleMisc(t *testing.T) {
+	c := qt.New(t)
+	type s string
+
+	var (
+		i          = int32(42)
+		i64        = int64(i)
+		iv     any = i
+		ip         = &i
+		inil   any = (*int32)(nil)
+		shello     = s("hello")
+	)
+
+	convertOK := func(v any, typ any) any {
+		rv, ok := ConvertIfPossible(reflect.ValueOf(v), reflect.TypeOf(typ))
+		c.Assert(ok, qt.IsTrue)
+		return rv.Interface()
+	}
+
+	c.Assert(convertOK(shello, ""), qt.Equals, "hello")
+	c.Assert(convertOK(ip, int64(0)), qt.Equals, i64)
+	c.Assert(convertOK(iv, int64(0)), qt.Equals, i64)
+	c.Assert(convertOK(inil, int64(0)), qt.Equals, int64(0))
+}
+
+func BenchmarkToInt64(b *testing.B) {
+	v := reflect.ValueOf(int(42))
+	for b.Loop() {
+		ToInt64(v)
+	}
+}

common/hreflect/helpers.go

@@ -1,6 +1,4 @@
-// Copyright 2024 The Hugo Authors. All rights reserved.
-// Some functions in this file (see comments) is based on the Go source code,
-// copyright The Go Authors and  governed by a BSD-style license.
+// 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.
@@ -18,7 +16,6 @@ package hreflect
 
 import (
 	"context"
-	"math"
 	"reflect"
 	"sync"
 	"time"
@@ -28,6 +25,11 @@ import (
 	"github.com/gohugoio/hugo/common/types"
 )
 
+// IsInterfaceOrPointer returns whether the given kind is an interface or a pointer.
+func IsInterfaceOrPointer(kind reflect.Kind) bool {
+	return kind == reflect.Interface || kind == reflect.Ptr
+}
+
 // TODO(bep) replace the private versions in /tpl with these.
 // IsNumber returns whether the given kind is a number.
 func IsNumber(kind reflect.Kind) bool {
@@ -64,6 +66,11 @@ func IsFloat(kind reflect.Kind) bool {
 	}
 }
 
+// IsString returns whether the given kind is a string.
+func IsString(kind reflect.Kind) bool {
+	return kind == reflect.String
+}
+
 // IsTruthful returns whether in represents a truthful value.
 // See IsTruthfulValue
 func IsTruthful(in any) bool {
@@ -107,14 +114,14 @@ func implementsIsZero(tp reflect.Type) bool {
 // Based on:
 // https://github.com/golang/go/blob/178a2c42254166cffed1b25fb1d3c7a5727cada6/src/text/template/exec.go#L306
 func IsTruthfulValue(val reflect.Value) (truth bool) {
-	val = indirectInterface(val)
+	val, isNil := Indirect(val)
 
 	if !val.IsValid() {
-		// Something like var x interface{}, never set. It's a form of nil.
+		// Something like: var x any, never set. It's a form of nil.
 		return
 	}
 
-	if val.Kind() == reflect.Pointer && val.IsNil() {
+	if val.Kind() == reflect.Pointer && isNil {
 		return
 	}
 
@@ -151,10 +158,31 @@ type methodKey struct {
 	name string
 }
 
-var methodCache sync.Map
+var (
+	methodIndexCache sync.Map
+	methodCache      sync.Map
+)
 
-// GetMethodByName is the same as reflect.Value.MethodByName, but it caches the
-// type lookup.
+// GetMethodByNameForType returns the method with the given name for the given type,
+// or a zero Method if no such method exists.
+// It panics if tp is an interface type.
+// It caches the lookup.
+func GetMethodByNameForType(tp reflect.Type, name string) reflect.Method {
+	if tp.Kind() == reflect.Interface {
+		// Func field is nil for interface types.
+		panic("not supported for interface types")
+	}
+	k := methodKey{tp, name}
+	v, found := methodCache.Load(k)
+	if found {
+		return v.(reflect.Method)
+	}
+	m, _ := tp.MethodByName(name)
+	methodCache.Store(k, m)
+	return m
+}
+
+// GetMethodByName is the same as reflect.Value.MethodByName, but it caches the lookup.
 func GetMethodByName(v reflect.Value, name string) reflect.Value {
 	index := GetMethodIndexByName(v.Type(), name)
 
@@ -169,7 +197,7 @@ 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}
-	v, found := methodCache.Load(k)
+	v, found := methodIndexCache.Load(k)
 	if found {
 		return v.(int)
 	}
@@ -178,7 +206,7 @@ func GetMethodIndexByName(tp reflect.Type, name string) int {
 	if !ok {
 		index = -1
 	}
-	methodCache.Store(k, index)
+	methodIndexCache.Store(k, index)
 
 	if !ok {
 		return -1
@@ -260,6 +288,7 @@ func ToSliceAny(v any) ([]any, bool) {
 	return nil, false
 }
 
+// CallMethodByName calls the method with the given name on v.
 func CallMethodByName(cxt context.Context, name string, v reflect.Value) []reflect.Value {
 	fn := v.MethodByName(name)
 	var args []reflect.Value
@@ -277,15 +306,51 @@ func CallMethodByName(cxt context.Context, name string, v reflect.Value) []refle
 	return fn.Call(args)
 }
 
-// Based on: https://github.com/golang/go/blob/178a2c42254166cffed1b25fb1d3c7a5727cada6/src/text/template/exec.go#L931
-func indirectInterface(v reflect.Value) reflect.Value {
-	if v.Kind() != reflect.Interface {
-		return v
+// Indirect unwraps interfaces and pointers until it finds a non-interface/pointer value.
+// If a nil is encountered, the second return value is true.
+// If a pointer to a struct is encountered, it is not unwrapped.
+func Indirect(v reflect.Value) (vv reflect.Value, isNil bool) {
+	for ; IsInterfaceOrPointer(v.Kind()); v = v.Elem() {
+		if IsNil(v) {
+			return v, true
+		}
+		if v.Kind() != reflect.Interface {
+			// A pointer.
+			if v.NumMethod() > 0 {
+				break
+			}
+			if v.Elem().Kind() == reflect.Struct {
+				// Avoid unwrapping pointers to structs.
+				break
+			}
+		}
 	}
-	if v.IsNil() {
-		return reflect.Value{}
+	return v, false
+}
+
+// IndirectElem is like Indirect, but if the final value is a pointer, it unwraps it.
+func IndirectElem(v reflect.Value) (vv reflect.Value, isNil bool) {
+	vv, isNil = Indirect(v)
+	if isNil {
+		return vv, isNil
 	}
-	return v.Elem()
+	if vv.Kind() == reflect.Pointer {
+		vv = vv.Elem()
+	}
+	return vv, isNil
+}
+
+// IsNil reports whether v is nil.
+// Based on reflect.Value.IsNil, but also considers invalid values as nil.
+func IsNil(v reflect.Value) bool {
+	if !v.IsValid() {
+		return true
+	}
+	switch v.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return v.IsNil()
+	}
+	return false
 }
 
 var contextInterface = reflect.TypeOf((*context.Context)(nil)).Elem()
@@ -310,45 +375,3 @@ 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

@@ -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.
@@ -15,12 +15,12 @@ package hreflect
 
 import (
 	"context"
-	"math"
 	"reflect"
 	"testing"
 	"time"
 
 	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/htesting/hqt"
 )
 
 type zeroStruct struct {
@@ -80,18 +80,90 @@ func TestToSliceAny(t *testing.T) {
 	checkOK([]int{1, 2, 3}, []any{1, 2, 3})
 }
 
+type testIndirectStruct struct {
+	S string
+}
+
+func (t *testIndirectStruct) GetS() string {
+	return t.S
+}
+
+func (t testIndirectStruct) Foo() string {
+	return "bar"
+}
+
+type testIndirectStructNoMethods struct {
+	S string
+}
+
+func TestIsNil(t *testing.T) {
+	c := qt.New(t)
+
+	var (
+		nilPtr      *testIndirectStruct
+		nilIface    any = nil
+		nonNilIface any = &testIndirectStruct{S: "hello"}
+	)
+
+	c.Assert(IsNil(reflect.ValueOf(nilPtr)), qt.Equals, true)
+	c.Assert(IsNil(reflect.ValueOf(nilIface)), qt.Equals, true)
+	c.Assert(IsNil(reflect.ValueOf(nonNilIface)), qt.Equals, false)
+}
+
+func TestIndirectInterface(t *testing.T) {
+	c := qt.New(t)
+
+	var (
+		structWithMethods               = testIndirectStruct{S: "hello"}
+		structWithMethodsPointer        = &testIndirectStruct{S: "hello"}
+		structWithMethodsPointerAny any = structWithMethodsPointer
+		structPointerToPointer          = &structWithMethodsPointer
+		structNoMethodsPtr              = &testIndirectStructNoMethods{S: "no methods"}
+		structNoMethods                 = testIndirectStructNoMethods{S: "no methods"}
+		intValue                        = 32
+		intPtr                          = &intValue
+		nilPtr                      *testIndirectStruct
+		nilIface                    any = nil
+	)
+
+	ind := func(v any) any {
+		c.Helper()
+		vv, isNil := Indirect(reflect.ValueOf(v))
+		c.Assert(isNil, qt.IsFalse)
+		return vv.Interface()
+	}
+
+	c.Assert(ind(intValue), hqt.IsSameType, 32)
+	c.Assert(ind(intPtr), hqt.IsSameType, 32)
+	c.Assert(ind(structNoMethodsPtr), hqt.IsSameType, structNoMethodsPtr)
+	c.Assert(ind(structWithMethods), hqt.IsSameType, structWithMethods)
+	c.Assert(ind(structNoMethods), hqt.IsSameType, structNoMethods)
+	c.Assert(ind(structPointerToPointer), hqt.IsSameType, &testIndirectStruct{})
+	c.Assert(ind(structWithMethodsPointer), hqt.IsSameType, &testIndirectStruct{})
+	c.Assert(ind(structWithMethodsPointerAny), hqt.IsSameType, structWithMethodsPointer)
+
+	vv, isNil := Indirect(reflect.ValueOf(nilPtr))
+	c.Assert(isNil, qt.IsTrue)
+	c.Assert(vv, qt.Equals, reflect.ValueOf(nilPtr))
+
+	vv, isNil = Indirect(reflect.ValueOf(nilIface))
+	c.Assert(isNil, qt.IsFalse)
+	c.Assert(vv, qt.Equals, reflect.ValueOf(nilIface))
+}
+
 func BenchmarkIsContextType(b *testing.B) {
+	const size = 1000
 	type k string
 	b.Run("value", func(b *testing.B) {
 		ctx := context.Background()
-		ctxs := make([]reflect.Type, b.N)
-		for i := 0; i < b.N; i++ {
+		ctxs := make([]reflect.Type, size)
+		for i := range size {
 			ctxs[i] = reflect.TypeOf(context.WithValue(ctx, k("key"), i))
 		}
 
-		b.ResetTimer()
-		for i := 0; i < b.N; i++ {
-			if !IsContextType(ctxs[i]) {
+		for i := 0; b.Loop(); i++ {
+			idx := i % size
+			if !IsContextType(ctxs[idx]) {
 				b.Fatal("not context")
 			}
 		}
@@ -99,7 +171,7 @@ func BenchmarkIsContextType(b *testing.B) {
 
 	b.Run("background", func(b *testing.B) {
 		var ctxt reflect.Type = reflect.TypeOf(context.Background())
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			if !IsContextType(ctxt) {
 				b.Fatal("not context")
 			}
@@ -118,8 +190,7 @@ func BenchmarkIsTruthFulValue(b *testing.B) {
 		nilPointer  = reflect.ValueOf((*zeroStruct)(nil))
 	)
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		IsTruthfulValue(stringHugo)
 		IsTruthfulValue(stringEmpty)
 		IsTruthfulValue(zero)
@@ -152,12 +223,22 @@ func (t *testStruct) Method5() string {
 	return "Hugo"
 }
 
+func BenchmarkGetMethodByNameForType(b *testing.B) {
+	tp := reflect.TypeFor[*testStruct]()
+	methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
+
+	for b.Loop() {
+		for _, method := range methods {
+			_ = GetMethodByNameForType(tp, method)
+		}
+	}
+}
+
 func BenchmarkGetMethodByName(b *testing.B) {
 	v := reflect.ValueOf(&testStruct{})
 	methods := []string{"Method1", "Method2", "Method3", "Method4", "Method5"}
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		for _, method := range methods {
 			_ = GetMethodByName(v, method)
 		}
@@ -177,93 +258,3 @@ func BenchmarkGetMethodByNamePara(b *testing.B) {
 		}
 	})
 }
-
-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/hstore/scratch.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,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hstore
 
 import (
 	"reflect"

common/hstore/scratch_test.go

@@ -1,4 +1,4 @@
-// Copyright 2018 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,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package maps
+package hstore
 
 import (
 	"reflect"
@@ -214,8 +214,8 @@ func TestScratchGetSortedMapValues(t *testing.T) {
 func BenchmarkScratchGet(b *testing.B) {
 	scratch := NewScratch()
 	scratch.Add("A", 1)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+
+	for b.Loop() {
 		scratch.Get("A")
 	}
 }

common/hstrings/strings.go

@@ -17,6 +17,7 @@ import (
 	"fmt"
 	"regexp"
 	"slices"
+	"sort"
 	"strings"
 	"sync"
 
@@ -96,6 +97,16 @@ func GetOrCompileRegexp(pattern string) (re *regexp.Regexp, err error) {
 	return reCache.getOrCompileRegexp(pattern)
 }
 
+// HasAnyPrefix checks if the string s has any of the prefixes given.
+func HasAnyPrefix(s string, prefixes ...string) bool {
+	for _, p := range prefixes {
+		if strings.HasPrefix(s, p) {
+			return true
+		}
+	}
+	return false
+}
+
 // 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 {
@@ -128,7 +139,61 @@ func ToString(v any) (string, bool) {
 	return "", false
 }
 
-type (
-	Strings2 [2]string
-	Strings3 [3]string
-)
+// UniqueStrings returns a new slice with any duplicates removed.
+func UniqueStrings(s []string) []string {
+	unique := make([]string, 0, len(s))
+	for i, val := range s {
+		var seen bool
+		for j := range i {
+			if s[j] == val {
+				seen = true
+				break
+			}
+		}
+		if !seen {
+			unique = append(unique, val)
+		}
+	}
+	return unique
+}
+
+// UniqueStringsReuse returns a slice with any duplicates removed.
+// It will modify the input slice.
+func UniqueStringsReuse(s []string) []string {
+	result := s[:0]
+	for i, val := range s {
+		var seen bool
+
+		for j := range i {
+			if s[j] == val {
+				seen = true
+				break
+			}
+		}
+
+		if !seen {
+			result = append(result, val)
+		}
+	}
+	return result
+}
+
+// UniqueStringsSorted returns a sorted slice with any duplicates removed.
+// It will modify the input slice.
+func UniqueStringsSorted(s []string) []string {
+	if len(s) == 0 {
+		return nil
+	}
+	ss := sort.StringSlice(s)
+	ss.Sort()
+	i := 0
+	for j := 1; j < len(s); j++ {
+		if !ss.Less(i, j) {
+			continue
+		}
+		i++
+		s[i] = s[j]
+	}
+
+	return s[:i+1]
+}

common/hstrings/strings_test.go

@@ -1,4 +1,4 @@
-// Copyright 2024 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.
@@ -14,6 +14,7 @@
 package hstrings
 
 import (
+	"reflect"
 	"regexp"
 	"testing"
 
@@ -43,14 +44,91 @@ func TestGetOrCompileRegexp(t *testing.T) {
 	c.Assert(re.MatchString("123"), qt.Equals, true)
 }
 
+func TestUniqueStrings(t *testing.T) {
+	in := []string{"a", "b", "a", "b", "c", "", "a", "", "d"}
+	output := UniqueStrings(in)
+	expected := []string{"a", "b", "c", "", "d"}
+	if !reflect.DeepEqual(output, expected) {
+		t.Errorf("Expected %#v, got %#v\n", expected, output)
+	}
+}
+
+func TestUniqueStringsReuse(t *testing.T) {
+	in := []string{"a", "b", "a", "b", "c", "", "a", "", "d"}
+	output := UniqueStringsReuse(in)
+	expected := []string{"a", "b", "c", "", "d"}
+	if !reflect.DeepEqual(output, expected) {
+		t.Errorf("Expected %#v, got %#v\n", expected, output)
+	}
+}
+
+func TestUniqueStringsSorted(t *testing.T) {
+	c := qt.New(t)
+	in := []string{"a", "a", "b", "c", "b", "", "a", "", "d"}
+	output := UniqueStringsSorted(in)
+	expected := []string{"", "a", "b", "c", "d"}
+	c.Assert(output, qt.DeepEquals, expected)
+	c.Assert(UniqueStringsSorted(nil), qt.IsNil)
+}
+
+// Note that these cannot use b.Loop() because of golang/go#27217.
+func BenchmarkUniqueStrings(b *testing.B) {
+	input := []string{"a", "b", "d", "e", "d", "h", "a", "i"}
+
+	b.Run("Safe", func(b *testing.B) {
+		for b.Loop() {
+			result := UniqueStrings(input)
+			if len(result) != 6 {
+				b.Fatalf("invalid count: %d", len(result))
+			}
+		}
+	})
+
+	b.Run("Reuse slice", func(b *testing.B) {
+		inputs := make([][]string, b.N)
+		for i := 0; i < b.N; i++ {
+			inputc := make([]string, len(input))
+			copy(inputc, input)
+			inputs[i] = inputc
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			inputc := inputs[i]
+
+			result := UniqueStringsReuse(inputc)
+			if len(result) != 6 {
+				b.Fatalf("invalid count: %d", len(result))
+			}
+		}
+	})
+
+	b.Run("Reuse slice sorted", func(b *testing.B) {
+		inputs := make([][]string, b.N)
+		for i := 0; i < b.N; i++ {
+			inputc := make([]string, len(input))
+			copy(inputc, input)
+			inputs[i] = inputc
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			inputc := inputs[i]
+
+			result := UniqueStringsSorted(inputc)
+			if len(result) != 6 {
+				b.Fatalf("invalid count: %d", len(result))
+			}
+		}
+	})
+}
+
 func BenchmarkGetOrCompileRegexp(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		GetOrCompileRegexp(`\d+`)
 	}
 }
 
 func BenchmarkCompileRegexp(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		regexp.MustCompile(`\d+`)
 	}
 }

common/hsync/oncemore.go

@@ -0,0 +1,162 @@
+// 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 hsync
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+)
+
+// OnceMore is similar to sync.Once.
+//
+// Additional features are:
+// * it can be reset, so the action can be repeated if needed
+// * it has methods to check if it's done or in progress
+type OnceMore struct {
+	_    doNotCopy
+	done atomic.Bool
+	mu   sync.Mutex
+}
+
+func (t *OnceMore) Do(f func()) {
+	if t.Done() {
+		return
+	}
+
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	// Double check
+	if t.Done() {
+		return
+	}
+
+	defer t.done.Store(true)
+	f()
+}
+
+func (t *OnceMore) Done() bool {
+	return t.done.Load()
+}
+
+func (t *OnceMore) Reset() {
+	t.mu.Lock()
+	t.done.Store(false)
+	t.mu.Unlock()
+}
+
+type ValueResetter[T any] struct {
+	reset func()
+	f     func(context.Context) T
+}
+
+func (v *ValueResetter[T]) Value(ctx context.Context) T {
+	return v.f(ctx)
+}
+
+func (v *ValueResetter[T]) Reset() {
+	v.reset()
+}
+
+// OnceMoreValue returns a function that invokes f only once and returns the value
+// returned by f. The returned function may be called concurrently.
+//
+// If f panics, the returned function will panic with the same value on every call.
+func OnceMoreValue[T any](f func(context.Context) T) ValueResetter[T] {
+	v := struct {
+		f      func(context.Context) T
+		once   OnceMore
+		ok     bool
+		p      any
+		result T
+	}{
+		f: f,
+	}
+	ff := func(ctx context.Context) T {
+		v.once.Do(func() {
+			v.ok = false
+			defer func() {
+				v.p = recover()
+				if !v.ok {
+					panic(v.p)
+				}
+			}()
+			v.result = v.f(ctx)
+			v.ok = true
+		})
+		if !v.ok {
+			panic(v.p)
+		}
+		return v.result
+	}
+
+	return ValueResetter[T]{
+		reset: v.once.Reset,
+		f:     ff,
+	}
+}
+
+type FuncResetter struct {
+	f     func(context.Context) error
+	reset func()
+}
+
+func (v *FuncResetter) Do(ctx context.Context) error {
+	return v.f(ctx)
+}
+
+func (v *FuncResetter) Reset() {
+	v.reset()
+}
+
+func OnceMoreFunc(f func(context.Context) error) FuncResetter {
+	v := struct {
+		f    func(context.Context) error
+		once OnceMore
+		ok   bool
+		err  error
+		p    any
+	}{
+		f: f,
+	}
+	ff := func(ctx context.Context) error {
+		v.once.Do(func() {
+			v.ok = false
+			defer func() {
+				v.p = recover()
+				if !v.ok {
+					panic(v.p)
+				}
+			}()
+			v.err = v.f(ctx)
+			v.ok = true
+		})
+		if !v.ok {
+			panic(v.p)
+		}
+		return v.err
+	}
+
+	return FuncResetter{
+		f:     ff,
+		reset: v.once.Reset,
+	}
+}
+
+type doNotCopy struct{}
+
+// Lock is a no-op used by -copylocks checker from `go vet`.
+func (*doNotCopy) Lock()   {}
+func (*doNotCopy) Unlock() {}

common/hsync/oncemore_test.go

@@ -0,0 +1,80 @@
+// 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 hsync
+
+import (
+	"context"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestOnceMoreValue(t *testing.T) {
+	c := qt.New(t)
+
+	var counter int
+	f := func(context.Context) int {
+		counter++
+		return counter
+	}
+
+	omf := OnceMoreValue(f)
+	for range 10 {
+		c.Assert(omf.Value(context.Background()), qt.Equals, 1)
+	}
+	omf.Reset()
+	for range 10 {
+		c.Assert(omf.Value(context.Background()), qt.Equals, 2)
+	}
+}
+
+func TestOnceMoreFunc(t *testing.T) {
+	c := qt.New(t)
+
+	var counter int
+	f := func(context.Context) error {
+		counter++
+		return nil
+	}
+
+	omf := OnceMoreFunc(f)
+	for range 10 {
+		c.Assert(omf.Do(context.Background()), qt.IsNil)
+		c.Assert(counter, qt.Equals, 1)
+	}
+	omf.Reset()
+	for range 10 {
+		c.Assert(omf.Do(context.Background()), qt.IsNil)
+		c.Assert(counter, qt.Equals, 2)
+	}
+}
+
+func BenchmarkOnceMoreValue(b *testing.B) {
+	var counter int
+	f := func(context.Context) int {
+		counter++
+		return counter
+	}
+
+	for b.Loop() {
+		omf := OnceMoreValue(f)
+		for range 10 {
+			omf.Value(context.Background())
+		}
+		omf.Reset()
+		for range 10 {
+			omf.Value(context.Background())
+		}
+	}
+}

common/htime/htime_integration_test.go

@@ -24,9 +24,9 @@ func TestApplyWithContext(t *testing.T) {
 	t.Parallel()
 
 	files := `
--- config.toml --
+-- hugo.toml --
 defaultContentLanguage = 'it'
--- layouts/index.html --
+-- layouts/home.html --
 {{ $dates := slice
   "2022-01-03"
   "2022-02-01"

common/htime/time_test.go

@@ -112,7 +112,7 @@ func BenchmarkTimeFormatter(b *testing.B) {
 	june06, _ := time.Parse("2006-Jan-02", "2018-Jun-06")
 
 	b.Run("Native", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			got := june06.Format("Monday Jan 2 2006")
 			if got != "Wednesday Jun 6 2018" {
 				b.Fatalf("invalid format, got %q", got)
@@ -123,7 +123,7 @@ func BenchmarkTimeFormatter(b *testing.B) {
 	b.Run("Localized", func(b *testing.B) {
 		f := NewTimeFormatter(translators.GetTranslator("nn"))
 		b.ResetTimer()
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			got := f.Format(june06, "Monday Jan 2 2006")
 			if got != "onsdag juni 6 2018" {
 				b.Fatalf("invalid format, got %q", got)
@@ -134,7 +134,7 @@ func BenchmarkTimeFormatter(b *testing.B) {
 	b.Run("Localized Custom", func(b *testing.B) {
 		f := NewTimeFormatter(translators.GetTranslator("nn"))
 		b.ResetTimer()
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			got := f.Format(june06, ":date_medium")
 			if got != "6. juni 2018" {
 				b.Fatalf("invalid format, got %q", got)

common/hugio/readers.go

@@ -32,6 +32,13 @@ type ReadSeekCloser interface {
 	io.Closer
 }
 
+// CloserFunc is an adapter to allow the use of ordinary functions as io.Closers.
+type CloserFunc func() error
+
+func (f CloserFunc) Close() error {
+	return f()
+}
+
 // ReadSeekCloserProvider provides a ReadSeekCloser.
 type ReadSeekCloserProvider interface {
 	ReadSeekCloser() (ReadSeekCloser, error)

common/hugo/hugo.go

@@ -30,8 +30,9 @@ import (
 	"github.com/bep/godartsass/v2"
 
 	"github.com/gohugoio/hugo/common/hexec"
+	"github.com/gohugoio/hugo/common/hstore"
 	"github.com/gohugoio/hugo/common/loggers"
-	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/version"
 	"github.com/gohugoio/hugo/hugofs/files"
 
 	"github.com/bep/helpers/contexthelpers"
@@ -55,7 +56,7 @@ var (
 	vendorInfo string
 )
 
-var _ maps.StoreProvider = (*HugoInfo)(nil)
+var _ hstore.StoreProvider = (*HugoInfo)(nil)
 
 // HugoInfo contains information about the current Hugo environment
 type HugoInfo struct {
@@ -74,14 +75,14 @@ type HugoInfo struct {
 	conf ConfigProvider
 	deps []*Dependency
 
-	store *maps.Scratch
+	store *hstore.Scratch
 
 	// Context gives access to some of the context scoped variables.
 	Context Context
 }
 
 // Version returns the current version as a comparable version string.
-func (i HugoInfo) Version() VersionString {
+func (i HugoInfo) Version() version.VersionString {
 	return CurrentVersion.Version()
 }
 
@@ -120,7 +121,7 @@ func (i HugoInfo) Deps() []*Dependency {
 	return i.deps
 }
 
-func (i HugoInfo) Store() *maps.Scratch {
+func (i HugoInfo) Store() *hstore.Scratch {
 	return i.store
 }
 
@@ -197,7 +198,7 @@ func NewInfo(conf ConfigProvider, deps []*Dependency) HugoInfo {
 		Environment: conf.Environment(),
 		conf:        conf,
 		deps:        deps,
-		store:       maps.NewScratch(),
+		store:       hstore.NewScratch(),
 		GoVersion:   goVersion,
 	}
 }
@@ -452,7 +453,7 @@ func deprecateLevelWithLogger(item, alternative, version string, level logg.Leve
 // We want people to run at least the current and previous version without any warnings.
 // We want people who don't update Hugo that often to see the warnings and errors before we remove the feature.
 func deprecationLogLevelFromVersion(ver string) logg.Level {
-	from := MustParseVersion(ver)
+	from := version.MustParseVersion(ver)
 	to := CurrentVersion
 	minorDiff := to.Minor - from.Minor
 	switch {
@@ -466,3 +467,46 @@ func deprecationLogLevelFromVersion(ver string) logg.Level {
 		return logg.LevelInfo
 	}
 }
+
+// BuildVersionString creates a version string. This is what you see when
+// running "hugo version".
+func BuildVersionString() string {
+	// program := "Hugo Static Site Generator"
+	program := "hugo"
+
+	version := "v" + CurrentVersion.String()
+
+	bi := getBuildInfo()
+	if bi == nil {
+		return version
+	}
+	if bi.Revision != "" {
+		version += "-" + bi.Revision
+	}
+	if IsExtended {
+		version += "+extended"
+	}
+	if IsWithdeploy {
+		version += "+withdeploy"
+	}
+
+	osArch := bi.GoOS + "/" + bi.GoArch
+
+	date := bi.RevisionTime
+	if date == "" {
+		// Accept vendor-specified build date if .git/ is unavailable.
+		date = buildDate
+	}
+	if date == "" {
+		date = "unknown"
+	}
+
+	versionString := fmt.Sprintf("%s %s %s BuildDate=%s",
+		program, version, osArch, date)
+
+	if vendorInfo != "" {
+		versionString += " VendorInfo=" + vendorInfo
+	}
+
+	return versionString
+}

common/hugo/hugo_integration_test.go

@@ -35,7 +35,7 @@ baseURL = 'https://en.example.org/'
 ---
 title: home
 ---
--- layouts/index.html --
+-- layouts/home.html --
 multilingual={{ hugo.IsMultilingual }}
 multihost={{ hugo.IsMultihost }}
   `

common/hugo/hugo_test.go

@@ -20,6 +20,7 @@ import (
 
 	"github.com/bep/logg"
 	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/common/version"
 )
 
 func TestHugoInfo(t *testing.T) {
@@ -29,7 +30,7 @@ func TestHugoInfo(t *testing.T) {
 	hugoInfo := NewInfo(conf, nil)
 
 	c.Assert(hugoInfo.Version(), qt.Equals, CurrentVersion.Version())
-	c.Assert(fmt.Sprintf("%T", VersionString("")), qt.Equals, fmt.Sprintf("%T", hugoInfo.Version()))
+	c.Assert(fmt.Sprintf("%T", version.VersionString("")), qt.Equals, fmt.Sprintf("%T", hugoInfo.Version()))
 	c.Assert(hugoInfo.WorkingDir(), qt.Equals, "/mywork")
 
 	bi := getBuildInfo()

common/hugo/version_current.go

@@ -1,4 +1,4 @@
-// Copyright 2018 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.
@@ -13,9 +13,11 @@
 
 package hugo
 
+import "github.com/gohugoio/hugo/common/version"
+
 // CurrentVersion represents the current build version.
 // This should be the only one.
-var CurrentVersion = Version{
+var CurrentVersion = version.Version{
 	Major:      0,
 	Minor:      153,
 	PatchLevel: 0,

common/maps/cache_test.go

@@ -1,4 +1,4 @@
-// Copyright 2024 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.
@@ -24,7 +24,7 @@ func TestCacheSize(t *testing.T) {
 
 	cache := NewCacheWithOptions[string, string](CacheOptions{Size: 10})
 
-	for i := 0; i < 30; i++ {
+	for i := range 30 {
 		cache.Set(string(rune('a'+i)), "value")
 	}
 

common/maps/map.go

@@ -0,0 +1,117 @@
+// 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 maps
+
+import (
+	"iter"
+	"sync"
+)
+
+func NewMap[K comparable, T any]() *Map[K, T] {
+	return &Map[K, T]{
+		m: make(map[K]T),
+	}
+}
+
+// Map is a thread safe map backed by a Go map.
+type Map[K comparable, T any] struct {
+	m  map[K]T
+	mu sync.RWMutex
+}
+
+// Get gets the value for the given key.
+// It returns the zero value of T if the key is not found.
+func (m *Map[K, T]) Get(key K) T {
+	v, _ := m.Lookup(key)
+	return v
+}
+
+// Lookup looks up the given key in the map.
+// It returns the value and a boolean indicating whether the key was found.
+func (m *Map[K, T]) Lookup(key K) (T, bool) {
+	m.mu.RLock()
+	v, found := m.m[key]
+	m.mu.RUnlock()
+	return v, found
+}
+
+// GetOrCreate gets the value for the given key if it exists, or creates it if not.
+func (m *Map[K, T]) GetOrCreate(key K, create func() (T, error)) (T, error) {
+	v, found := m.Lookup(key)
+	if found {
+		return v, nil
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	v, found = m.m[key]
+	if found {
+		return v, nil
+	}
+	v, err := create()
+	if err != nil {
+		return v, err
+	}
+	m.m[key] = v
+	return v, nil
+}
+
+// Set sets the given key to the given value.
+func (m *Map[K, T]) Set(key K, value T) {
+	m.mu.Lock()
+	m.m[key] = value
+	m.mu.Unlock()
+}
+
+// WithWriteLock executes the given function with a write lock on the map.
+func (m *Map[K, T]) WithWriteLock(f func(m map[K]T)) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	f(m.m)
+}
+
+// SetIfAbsent sets the given key to the given value if the key does not already exist in the map.
+// It returns true if the value was set, false otherwise.
+func (m *Map[K, T]) SetIfAbsent(key K, value T) bool {
+	m.mu.RLock()
+	if _, found := m.m[key]; !found {
+		m.mu.RUnlock()
+		return m.doSetIfAbsent(key, value)
+	}
+	m.mu.RUnlock()
+	return false
+}
+
+func (m *Map[K, T]) doSetIfAbsent(key K, value T) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if _, found := m.m[key]; !found {
+		m.m[key] = value
+		return true
+	}
+	return false
+}
+
+// All returns an iterator over all key/value pairs in the map.
+// A read lock is held during the iteration.
+func (m *Map[K, T]) All() iter.Seq2[K, T] {
+	return func(yield func(K, T) bool) {
+		m.mu.RLock()
+		defer m.mu.RUnlock()
+		for k, v := range m.m {
+			if !yield(k, v) {
+				return
+			}
+		}
+	}
+}

common/maps/map_test.go

@@ -0,0 +1,71 @@
+// 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 maps
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestMap(t *testing.T) {
+	c := qt.New(t)
+
+	m := NewMap[string, int]()
+
+	m.Set("b", 42)
+	v, found := m.Lookup("b")
+	c.Assert(found, qt.Equals, true)
+	c.Assert(v, qt.Equals, 42)
+	v = m.Get("b")
+	c.Assert(v, qt.Equals, 42)
+	v, found = m.Lookup("c")
+	c.Assert(found, qt.Equals, false)
+	c.Assert(v, qt.Equals, 0)
+	v = m.Get("c")
+	c.Assert(v, qt.Equals, 0)
+	v, err := m.GetOrCreate("d", func() (int, error) {
+		return 100, nil
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.Equals, 100)
+	v, found = m.Lookup("d")
+	c.Assert(found, qt.Equals, true)
+	c.Assert(v, qt.Equals, 100)
+
+	v, err = m.GetOrCreate("d", func() (int, error) {
+		return 200, nil
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(v, qt.Equals, 100)
+
+	wasSet := m.SetIfAbsent("e", 300)
+	c.Assert(wasSet, qt.Equals, true)
+	v, found = m.Lookup("e")
+	c.Assert(found, qt.Equals, true)
+	c.Assert(v, qt.Equals, 300)
+
+	wasSet = m.SetIfAbsent("e", 400)
+	c.Assert(wasSet, qt.Equals, false)
+	v, found = m.Lookup("e")
+	c.Assert(found, qt.Equals, true)
+	c.Assert(v, qt.Equals, 300)
+
+	m.WithWriteLock(func(m map[string]int) {
+		m["f"] = 500
+	})
+	v, found = m.Lookup("f")
+	c.Assert(found, qt.Equals, true)
+	c.Assert(v, qt.Equals, 500)
+}

common/maps/maps.go

@@ -98,6 +98,8 @@ func ToSliceStringMap(in any) ([]map[string]any, error) {
 		return v, nil
 	case Params:
 		return []map[string]any{v}, nil
+	case map[string]any:
+		return []map[string]any{v}, nil
 	case []any:
 		var s []map[string]any
 		for _, entry := range v {

common/maps/orderedintset.go

@@ -0,0 +1,154 @@
+// 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 maps
+
+import (
+	"fmt"
+	"slices"
+
+	"github.com/bits-and-blooms/bitset"
+)
+
+type OrderedIntSet struct {
+	keys   []int
+	values *bitset.BitSet
+}
+
+// NewOrderedIntSet creates a new OrderedIntSet.
+// Note that this is backed by https://github.com/bits-and-blooms/bitset
+func NewOrderedIntSet(vals ...int) *OrderedIntSet {
+	m := &OrderedIntSet{
+		keys:   make([]int, 0, len(vals)),
+		values: bitset.New(uint(len(vals))),
+	}
+	for _, v := range vals {
+		m.Set(v)
+	}
+	return m
+}
+
+// Set sets the value for the given key.
+// Note that insertion order is not affected if a key is re-inserted into the set.
+func (m *OrderedIntSet) Set(key int) {
+	if m == nil {
+		panic("nil OrderedIntSet")
+	}
+	keyu := uint(key)
+	if m.values.Test(keyu) {
+		return
+	}
+	m.values.Set(keyu)
+	m.keys = append(m.keys, key)
+}
+
+// SetFrom sets the values from another OrderedIntSet.
+func (m *OrderedIntSet) SetFrom(other *OrderedIntSet) {
+	if m == nil || other == nil {
+		return
+	}
+	for _, key := range other.keys {
+		m.Set(key)
+	}
+}
+
+func (m *OrderedIntSet) Clone() *OrderedIntSet {
+	if m == nil {
+		return nil
+	}
+	newSet := &OrderedIntSet{
+		keys:   slices.Clone(m.keys),
+		values: m.values.Clone(),
+	}
+	return newSet
+}
+
+// Next returns the next key in the set possibly including the given key.
+// It returns -1 if the key is not found or if there are no keys greater than the given key.
+func (m *OrderedIntSet) Next(i int) int {
+	n, ok := m.values.NextSet(uint(i))
+	if !ok {
+		return -1
+	}
+	return int(n)
+}
+
+// The reason we don't use iter.Seq is https://github.com/golang/go/issues/69015
+// This is 70% faster than using iter.Seq2[int, int] for the keys.
+// It returns false if the iteration was stopped early.
+func (m *OrderedIntSet) ForEachKey(yield func(int) bool) bool {
+	if m == nil {
+		return true
+	}
+	for _, key := range m.keys {
+		if !yield(key) {
+			return false
+		}
+	}
+	return true
+}
+
+func (m *OrderedIntSet) Has(key int) bool {
+	if m == nil {
+		return false
+	}
+	return m.values.Test(uint(key))
+}
+
+func (m *OrderedIntSet) Len() int {
+	if m == nil {
+		return 0
+	}
+	return len(m.keys)
+}
+
+// KeysSorted returns the keys in sorted order.
+func (m *OrderedIntSet) KeysSorted() []int {
+	if m == nil {
+		return nil
+	}
+	keys := slices.Clone(m.keys)
+	slices.Sort(keys)
+	return m.keys
+}
+
+func (m *OrderedIntSet) String() string {
+	if m == nil {
+		return "[]"
+	}
+	return fmt.Sprintf("%v", m.keys)
+}
+
+func (m *OrderedIntSet) Values() *bitset.BitSet {
+	if m == nil {
+		return nil
+	}
+	return m.values
+}
+
+func (m *OrderedIntSet) IsSuperSet(other *OrderedIntSet) bool {
+	if m == nil || other == nil {
+		return false
+	}
+	return m.values.IsSuperSet(other.values)
+}
+
+// Words returns the bitset as array of 64-bit words, giving direct access to the internal representation.
+// It is not a copy, so changes to the returned slice will affect the bitset.
+// It is meant for advanced users.
+func (m *OrderedIntSet) Words() []uint64 {
+	if m == nil {
+		return nil
+	}
+	return m.values.Words()
+}

common/maps/orderedintset_test.go

@@ -0,0 +1,117 @@
+// 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 maps
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestOrderedIntSet(t *testing.T) {
+	c := qt.New(t)
+
+	m := NewOrderedIntSet(2, 1, 3, 7)
+
+	c.Assert(m.Len(), qt.Equals, 4)
+	c.Assert(m.Has(1), qt.Equals, true)
+	c.Assert(m.Has(4), qt.Equals, false)
+	c.Assert(m.String(), qt.Equals, "[2 1 3 7]")
+	m.Set(4)
+	c.Assert(m.Len(), qt.Equals, 5)
+	c.Assert(m.Has(4), qt.Equals, true)
+	c.Assert(m.Next(0), qt.Equals, 1)
+	c.Assert(m.Next(1), qt.Equals, 1)
+	c.Assert(m.Next(2), qt.Equals, 2)
+	c.Assert(m.Next(3), qt.Equals, 3)
+	c.Assert(m.Next(4), qt.Equals, 4)
+	c.Assert(m.Next(7), qt.Equals, 7)
+	c.Assert(m.Next(8), qt.Equals, -1)
+	c.Assert(m.String(), qt.Equals, "[2 1 3 7 4]")
+
+	var nilset *OrderedIntSet
+	c.Assert(nilset.Len(), qt.Equals, 0)
+	c.Assert(nilset.Has(1), qt.Equals, false)
+	c.Assert(nilset.String(), qt.Equals, "[]")
+
+	var collected []int
+	m.ForEachKey(func(key int) bool {
+		collected = append(collected, key)
+		return true
+	})
+	c.Assert(collected, qt.DeepEquals, []int{2, 1, 3, 7, 4})
+}
+
+func BenchmarkOrderedIntSet(b *testing.B) {
+	smallSet := NewOrderedIntSet()
+	for i := range 8 {
+		smallSet.Set(i)
+	}
+	mediumSet := NewOrderedIntSet()
+	for i := range 64 {
+		mediumSet.Set(i)
+	}
+	largeSet := NewOrderedIntSet()
+	for i := range 1024 {
+		largeSet.Set(i)
+	}
+
+	b.Run("New", func(b *testing.B) {
+		for b.Loop() {
+			NewOrderedIntSet(1, 2, 3, 4, 5, 6, 7, 8)
+		}
+	})
+
+	b.Run("Has small", func(b *testing.B) {
+		for i := 0; b.Loop(); i++ {
+			smallSet.Has(i % 32)
+		}
+	})
+
+	b.Run("Has medium", func(b *testing.B) {
+		for i := 0; b.Loop(); i++ {
+			mediumSet.Has(i % 32)
+		}
+	})
+
+	b.Run("Next", func(b *testing.B) {
+		for i := 0; b.Loop(); i++ {
+			mediumSet.Next(i % 32)
+		}
+	})
+
+	b.Run("ForEachKey small", func(b *testing.B) {
+		for b.Loop() {
+			smallSet.ForEachKey(func(key int) bool {
+				return true
+			})
+		}
+	})
+
+	b.Run("ForEachKey medium", func(b *testing.B) {
+		for b.Loop() {
+			mediumSet.ForEachKey(func(key int) bool {
+				return true
+			})
+		}
+	})
+
+	b.Run("ForEachKey large", func(b *testing.B) {
+		for b.Loop() {
+			largeSet.ForEachKey(func(key int) bool {
+				return true
+			})
+		}
+	})
+}

common/maps/params.go

@@ -187,6 +187,56 @@ func getNested(m map[string]any, indices []string) (any, string, map[string]any)
 	}
 }
 
+// CreateNestedParamsFromSegements creates empty nested maps for the given keySegments in the target map.
+func CreateNestedParamsFromSegements(target Params, keySegments ...string) Params {
+	if len(keySegments) == 0 {
+		return target
+	}
+
+	m := target
+	for i, key := range keySegments {
+		v, found := m[key]
+		if !found {
+			nm := Params{}
+			m[key] = nm
+			m = nm
+			if i == len(keySegments)-1 {
+				return nm
+			}
+			continue
+		}
+		m = v.(Params)
+	}
+
+	return m
+}
+
+// CreateNestedParamsSepString creates empty nested maps for the given keyStr in the target map
+// It returns the last map created.
+func CreateNestedParamsSepString(keyStr, separator string, target Params) Params {
+	keySegments := strings.Split(keyStr, separator)
+	return CreateNestedParamsFromSegements(target, keySegments...)
+}
+
+// SetNestedParamIfNotSet sets the value for the given keyStr in the target map if it does not exist.
+// It assumes that all but the last key in keyStr is a Params map or should be one.
+func SetNestedParamIfNotSet(keyStr, separator string, value any, target Params) Params {
+	keySegments := strings.Split(keyStr, separator)
+	if len(keySegments) == 0 {
+		return target
+	}
+	base := keySegments[:len(keySegments)-1]
+	last := keySegments[len(keySegments)-1]
+
+	m := CreateNestedParamsFromSegements(target, base...)
+
+	if _, ok := m[last]; !ok {
+		m[last] = value
+	}
+
+	return target
+}
+
 // GetNestedParam gets the first match of the keyStr in the candidates given.
 // It will first try the exact match and then try to find it as a nested map value,
 // using the given separator, e.g. "mymap.name".

common/maps/params_test.go

@@ -167,3 +167,35 @@ func TestParamsIsZero(t *testing.T) {
 	c.Assert(Params{"_merge": "foo", "foo": "bar"}.IsZero(), qt.IsFalse)
 	c.Assert(Params{"_merge": "foo"}.IsZero(), qt.IsTrue)
 }
+
+func TestSetNestedParamIfNotSet(t *testing.T) {
+	c := qt.New(t)
+
+	m := Params{}
+
+	SetNestedParamIfNotSet("a.b.c", ".", "value", m)
+	c.Assert(m, qt.DeepEquals, Params{
+		"a": Params{
+			"b": Params{
+				"c": "value",
+			},
+		},
+	})
+
+	m = Params{
+		"a": Params{
+			"b": Params{
+				"c": "existingValue",
+			},
+		},
+	}
+
+	SetNestedParamIfNotSet("a.b.c", ".", "value", m)
+	c.Assert(m, qt.DeepEquals, Params{
+		"a": Params{
+			"b": Params{
+				"c": "existingValue",
+			},
+		},
+	})
+}

common/para/para_test.go

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

common/paths/path.go

@@ -115,8 +115,8 @@ func ReplaceExtension(path string, newExt string) string {
 
 func makePathRelative(inPath string, possibleDirectories ...string) (string, error) {
 	for _, currentPath := range possibleDirectories {
-		if strings.HasPrefix(inPath, currentPath) {
-			return strings.TrimPrefix(inPath, currentPath), nil
+		if after, ok := strings.CutPrefix(inPath, currentPath); ok {
+			return after, nil
 		}
 	}
 	return inPath, errors.New("can't extract relative path, unknown prefix")

common/paths/path_test.go

@@ -225,7 +225,7 @@ func BenchmarkSanitize(b *testing.B) {
 
 	// This should not allocate any memory.
 	b.Run("All allowed", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			got := Sanitize(allAlowedPath)
 			if got != allAlowedPath {
 				b.Fatal(got)
@@ -235,7 +235,7 @@ func BenchmarkSanitize(b *testing.B) {
 
 	// This will allocate some memory.
 	b.Run("Spaces", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			got := Sanitize(spacePath)
 			if got != "foo-bar" {
 				b.Fatal(got)
@@ -311,3 +311,61 @@ func TestIsSameFilePath(t *testing.T) {
 		c.Assert(IsSameFilePath(filepath.FromSlash(this.a), filepath.FromSlash(this.b)), qt.Equals, this.expected, qt.Commentf("a: %s b: %s", this.a, this.b))
 	}
 }
+
+func BenchmarkAddLeadingSlash(b *testing.B) {
+	const (
+		noLeadingSlash   = "a/b/c"
+		withLeadingSlash = "/a/b/c"
+	)
+
+	// This should not allocate any memory.
+	b.Run("With leading slash", func(b *testing.B) {
+		for b.Loop() {
+			got := AddLeadingSlash(withLeadingSlash)
+			if got != withLeadingSlash {
+				b.Fatal(got)
+			}
+		}
+	})
+
+	// This will allocate some memory.
+	b.Run("Without leading slash", func(b *testing.B) {
+		for b.Loop() {
+			got := AddLeadingSlash(noLeadingSlash)
+			if got != "/a/b/c" {
+				b.Fatal(got)
+			}
+		}
+	})
+
+	b.Run("Blank string", func(b *testing.B) {
+		for b.Loop() {
+			got := AddLeadingSlash("")
+			if got != "/" {
+				b.Fatal(got)
+			}
+		}
+	})
+}
+
+func TestPathEscape(t *testing.T) {
+	c := qt.New(t)
+
+	for _, this := range []struct {
+		input    string
+		expected string
+	}{
+		{"/tags/欢迎", "/tags/%E6%AC%A2%E8%BF%8E"},
+		{"/path with spaces", "/path%20with%20spaces"},
+		{"/simple-path", "/simple-path"},
+		{"/path/with/slash", "/path/with/slash"},
+		{"/path/with special&chars", "/path/with%20special&chars"},
+	} {
+		in := this.input
+		for range 2 {
+			result := PathEscape(in)
+			c.Assert(result, qt.Equals, this.expected, qt.Commentf("input: %q", this.input))
+			in = result // test idempotency
+		}
+	}
+}

common/paths/pathparser.go

@@ -14,23 +14,27 @@
 package paths
 
 import (
+	"fmt"
 	"path"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"sync"
 
+	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/hugofs/files"
+	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
 	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/resources/kinds"
 )
 
 const (
-	identifierBaseof = "baseof"
+	identifierBaseof         = "baseof"
+	identifierCurstomWrapper = "_"
 )
 
-// PathParser parses a path into a Path.
+// PathParser parses and manages paths.
 type PathParser struct {
 	// Maps the language code to its index in the languages/sites slice.
 	LanguageIndex map[string]int
@@ -44,6 +48,19 @@ type PathParser struct {
 
 	// Reports whether the given ext is a content file.
 	IsContentExt func(string) bool
+
+	// The configured sites matrix.
+	ConfiguredDimensions *sitesmatrix.ConfiguredDimensions
+
+	// Below gets created on demand.
+	initOnce         sync.Once
+	sitesMatrixCache *maps.Cache[string, sitesmatrix.VectorStore] // Maps language index to sites matrix vector store.
+}
+
+func (pp *PathParser) init() {
+	pp.initOnce.Do(func() {
+		pp.sitesMatrixCache = maps.NewCache[string, sitesmatrix.VectorStore]()
+	})
 }
 
 // NormalizePathString returns a normalized path string using the very basic Hugo rules.
@@ -57,6 +74,32 @@ func NormalizePathStringBasic(s string) string {
 	return s
 }
 
+func (pp *PathParser) SitesMatrixFromPath(p *Path) sitesmatrix.VectorStore {
+	pp.init()
+	lang := p.Lang()
+	v, _ := pp.sitesMatrixCache.GetOrCreate(lang, func() (sitesmatrix.VectorStore, error) {
+		builder := sitesmatrix.NewIntSetsBuilder(pp.ConfiguredDimensions)
+		if lang != "" {
+			if idx, ok := pp.LanguageIndex[lang]; ok {
+				builder.WithLanguageIndices(idx)
+			}
+		}
+
+		switch p.Component() {
+		case files.ComponentFolderContent:
+			builder.WithDefaultsIfNotSet()
+		case files.ComponentFolderLayouts:
+			builder.WithAllIfNotSet()
+		case files.ComponentFolderStatic:
+			builder.WithDefaultsAndAllLanguagesIfNotSet()
+		}
+
+		return builder.Build(), nil
+	})
+
+	return v
+}
+
 // ParseIdentity parses component c with path s into a StringIdentity.
 func (pp *PathParser) ParseIdentity(c, s string) identity.StringIdentity {
 	p := pp.parsePooled(c, s)
@@ -145,6 +188,12 @@ func (pp *PathParser) parseIdentifier(component, s string, p *Path, i, lastDot,
 	id := types.LowHigh[string]{Low: i + 1, High: high}
 	sid := p.s[id.Low:id.High]
 
+	if strings.HasPrefix(sid, identifierCurstomWrapper) && strings.HasSuffix(sid, identifierCurstomWrapper) {
+		p.identifiersKnown = append(p.identifiersKnown, id)
+		p.posIdentifierCustom = len(p.identifiersKnown) - 1
+		found = true
+	}
+
 	if len(p.identifiersKnown) == 0 {
 		// The first is always the extension.
 		p.identifiersKnown = append(p.identifiersKnown, id)
@@ -155,12 +204,12 @@ func (pp *PathParser) parseIdentifier(component, s string, p *Path, i, lastDot,
 			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 {
@@ -173,6 +222,7 @@ func (pp *PathParser) parseIdentifier(component, s string, p *Path, i, lastDot,
 				p.identifiersKnown = append(p.identifiersKnown, id)
 				p.posIdentifierLanguage = len(p.identifiersKnown) - 1
 			}
+
 		}
 
 		if !found && mayHaveOutputFormat {
@@ -202,8 +252,14 @@ func (pp *PathParser) parseIdentifier(component, s string, p *Path, i, lastDot,
 		}
 
 		if !found && mayHaveLayout {
-			p.identifiersKnown = append(p.identifiersKnown, id)
-			p.posIdentifierLayout = len(p.identifiersKnown) - 1
+			if p.posIdentifierLayout != -1 {
+				// Move it to identifiersUnknown.
+				p.identifiersUnknown = append(p.identifiersUnknown, p.identifiersKnown[p.posIdentifierLayout])
+				p.identifiersKnown[p.posIdentifierLayout] = id
+			} else {
+				p.identifiersKnown = append(p.identifiersKnown, id)
+				p.posIdentifierLayout = len(p.identifiersKnown) - 1
+			}
 			found = true
 		}
 
@@ -333,7 +389,7 @@ type Type int
 
 const (
 
-	// A generic resource, e.g. a JSON file.
+	// A generic file, e.g. a JSON file.
 	TypeFile Type = iota
 
 	// All below are content files.
@@ -380,6 +436,7 @@ type Path struct {
 	posIdentifierKind         int
 	posIdentifierLayout       int
 	posIdentifierBaseof       int
+	posIdentifierCustom       int
 	disabled                  bool
 
 	trimLeadingSlash bool
@@ -417,6 +474,7 @@ func (p *Path) reset() {
 	p.posIdentifierKind = -1
 	p.posIdentifierLayout = -1
 	p.posIdentifierBaseof = -1
+	p.posIdentifierCustom = -1
 	p.disabled = false
 	p.trimLeadingSlash = false
 	p.unnormalized = nil
@@ -580,6 +638,9 @@ func (p *Path) Unnormalized() *Path {
 
 // PathNoLang returns the Path but with any language identifier removed.
 func (p *Path) PathNoLang() string {
+	if p.identifierIndex(p.posIdentifierLanguage) == -1 {
+		return p.Path()
+	}
 	return p.base(true, false)
 }
 
@@ -633,7 +694,12 @@ func (p *Path) BaseRel(owner *Path) string {
 //
 // For other files (Resources), any extension is kept.
 func (p *Path) Base() string {
-	return p.base(!p.isContentPage(), p.IsBundle())
+	s := p.base(!p.isContentPage(), p.IsBundle())
+	if s == "/" && p.isContentPage() {
+		// The content home page is represented as "".
+		s = ""
+	}
+	return s
 }
 
 // Used in template lookups.
@@ -708,6 +774,10 @@ func (p *Path) Lang() string {
 	return p.identifierAsString(p.posIdentifierLanguage)
 }
 
+func (p *Path) Custom() string {
+	return strings.TrimSuffix(strings.TrimPrefix(p.identifierAsString(p.posIdentifierCustom), identifierCurstomWrapper), identifierCurstomWrapper)
+}
+
 func (p *Path) Identifier(i int) string {
 	return p.identifierAsString(i)
 }
@@ -786,3 +856,12 @@ func HasExt(p string) bool {
 	}
 	return false
 }
+
+// ValidateIdentifier returns true if the given string is a valid identifier according
+// to Hugo's basic path normalization rules.
+func ValidateIdentifier(s string) error {
+	if s == NormalizePathStringBasic(s) {
+		return nil
+	}
+	return fmt.Errorf("must be all lower case and no spaces")
+}

common/paths/pathparser_test.go

@@ -18,27 +18,33 @@ import (
 	"testing"
 
 	"github.com/gohugoio/hugo/hugofs/files"
+	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
 	"github.com/gohugoio/hugo/resources/kinds"
 
 	qt "github.com/frankban/quicktest"
 )
 
-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 newTestParser() *PathParser {
+	dims := sitesmatrix.NewTestingDimensions([]string{"en", "no", "fr"}, []string{"v1", "v2", "v3"}, []string{"admin", "editor", "viewer", "guest"})
+
+	return &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
+		},
+		ConfiguredDimensions: dims,
+	}
 }
 
 func TestParse(t *testing.T) {
@@ -190,7 +196,7 @@ func TestParse(t *testing.T) {
 				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.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, "")
@@ -266,7 +272,7 @@ func TestParse(t *testing.T) {
 			"Index root no slash",
 			"_index.md",
 			func(c *qt.C, p *Path) {
-				c.Assert(p.Base(), qt.Equals, "/")
+				c.Assert(p.Base(), qt.Equals, "")
 				c.Assert(p.Ext(), qt.Equals, "md")
 				c.Assert(p.Name(), qt.Equals, "_index.md")
 			},
@@ -275,7 +281,7 @@ func TestParse(t *testing.T) {
 			"Index root",
 			"/_index.md",
 			func(c *qt.C, p *Path) {
-				c.Assert(p.Base(), qt.Equals, "/")
+				c.Assert(p.Base(), qt.Equals, "")
 				c.Assert(p.Ext(), qt.Equals, "md")
 				c.Assert(p.Name(), qt.Equals, "_index.md")
 			},
@@ -373,13 +379,24 @@ func TestParse(t *testing.T) {
 				c.Assert(p.IsContentData(), qt.IsFalse)
 			},
 		},
+		{
+			"Custom identifier",
+			"/a/b/p1._myid_.no.md",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Base(), qt.Equals, "/a/b/p1")
+				c.Assert(p.Lang(), qt.Equals, "no")
+				c.Assert(p.Ext(), qt.Equals, "md")
+				c.Assert(p.Custom(), qt.Equals, "myid")
+			},
+		},
 	}
+	parser := newTestParser()
 	for _, test := range tests {
 		c.Run(test.name, func(c *qt.C) {
-			if test.name != "Home branch cundle" {
-				// return
+			if test.name != "Caret up identifier" {
+				//	return
 			}
-			test.assert(c, testParser.Parse(files.ComponentFolderContent, test.path))
+			test.assert(c, parser.Parse(files.ComponentFolderContent, test.path))
 		})
 	}
 }
@@ -437,8 +454,8 @@ func TestParseLayouts(t *testing.T) {
 			"/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.Identifiers(), qt.DeepEquals, []string{"html", "no", "section", "mylayout"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{"list"})
 				c.Assert(p.Base(), qt.Equals, "/mylayout.html")
 				c.Assert(p.Lang(), qt.Equals, "no")
 			},
@@ -461,7 +478,8 @@ func TestParseLayouts(t *testing.T) {
 			"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.Identifiers(), qt.DeepEquals, []string{"html", "list", "amp", "no"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{"not"})
 				c.Assert(p.OutputFormat(), qt.Equals, "amp")
 				c.Assert(p.Ext(), qt.Equals, "html")
 				c.Assert(p.Lang(), qt.Equals, "no")
@@ -583,14 +601,27 @@ func TestParseLayouts(t *testing.T) {
 				c.Assert(p.NameNoIdentifier(), qt.Equals, "myshortcode")
 			},
 		},
+		{
+			"Not lang",
+			"/foo/index.xy.html",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Lang(), qt.Equals, "")
+				c.Assert(p.Layout(), qt.Equals, "index")
+				c.Assert(p.NameNoLang(), qt.Equals, "index.xy.html")
+				c.Assert(p.PathNoLang(), qt.Equals, "/foo/index.xy.html")
+				c.Assert(p.Identifiers(), qt.DeepEquals, []string{"html", "index"})
+				c.Assert(p.IdentifiersUnknown(), qt.DeepEquals, []string{"xy"})
+			},
+		},
 	}
 
+	parser := newTestParser()
 	for _, test := range tests {
 		c.Run(test.name, func(c *qt.C) {
-			if test.name != "Shortcode lang layout" {
-				// return
+			if test.name != "Not lang" {
+				return
 			}
-			test.assert(c, testParser.Parse(files.ComponentFolderLayouts, test.path))
+			test.assert(c, parser.Parse(files.ComponentFolderLayouts, test.path))
 		})
 	}
 }
@@ -605,7 +636,27 @@ func TestHasExt(t *testing.T) {
 }
 
 func BenchmarkParseIdentity(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		testParser.ParseIdentity(files.ComponentFolderAssets, "/a/b.css")
+	parser := newTestParser()
+	for b.Loop() {
+		parser.ParseIdentity(files.ComponentFolderAssets, "/a/b.css")
+	}
+}
+
+func TestSitesMatrixFromPath(t *testing.T) {
+	c := qt.New(t)
+
+	parser := newTestParser()
+	p := parser.Parse(files.ComponentFolderContent, "/a/b/c.fr.md")
+	v := parser.SitesMatrixFromPath(p)
+	c.Assert(v.HasLanguage(2), qt.IsTrue)
+	c.Assert(v.LenVectors(), qt.Equals, 1)
+	c.Assert(v.VectorSample(), qt.Equals, sitesmatrix.Vector{2, 0, 0})
+}
+
+func BenchmarkSitesMatrixFromPath(b *testing.B) {
+	parser := newTestParser()
+	p := parser.Parse(files.ComponentFolderContent, "/a/b/c.fr.md")
+	for b.Loop() {
+		parser.SitesMatrixFromPath(p)
 	}
 }

common/paths/paths_integration_test.go

@@ -35,9 +35,9 @@ weight = 2
 removePathAccents = true
 -- content/διακριτικός.md --
 -- content/διακριτικός.fr.md --
--- layouts/_default/single.html --
+-- layouts/single.html --
 {{ .Language.Lang }}|Single.
--- layouts/_default/list.html --
+-- layouts/list.html --
 List
 `
 	b := hugolib.Test(t, files)
@@ -64,9 +64,9 @@ disablePathToLower = true
 -- content/MySection/MyPage.fr.md --
 -- content/MySection/MyBundle/index.md --
 -- content/MySection/MyBundle/index.fr.md --
--- layouts/_default/single.html --
+-- layouts/single.html --
 {{ .Language.Lang }}|Single.
--- layouts/_default/list.html --
+-- layouts/list.html --
 {{ .Language.Lang }}|List.
 `
 	b := hugolib.Test(t, files)

common/predicate/predicate.go

@@ -1,4 +1,4 @@
-// Copyright 2024 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.
@@ -13,52 +13,128 @@
 
 package predicate
 
+import (
+	"iter"
+	"strings"
+
+	"github.com/gobwas/glob"
+	"github.com/gohugoio/hugo/hugofs/hglob"
+)
+
+// Match represents the result of a predicate evaluation.
+type Match interface {
+	OK() bool
+}
+
+var (
+	// Predefined Match values for common cases.
+	True  = BoolMatch(true)
+	False = BoolMatch(false)
+)
+
+// BoolMatch is a simple Match implementation based on a boolean value.
+type BoolMatch bool
+
+func (b BoolMatch) OK() bool {
+	return bool(b)
+}
+
+// breakMatch is a Match implementation that always returns false for OK() and signals to break evaluation.
+type breakMatch struct{}
+
+func (b breakMatch) OK() bool {
+	return false
+}
+
+var matchBreak = breakMatch{}
+
 // P is a predicate function that tests whether a value of type T satisfies some condition.
 type P[T any] func(T) bool
 
-// And returns a predicate that is a short-circuiting logical AND of this and the given predicates.
-func (p P[T]) And(ps ...P[T]) P[T] {
-	return func(v T) bool {
-		for _, pp := range ps {
-			if !pp(v) {
-				return false
-			}
-		}
-		if p == nil {
-			return true
-		}
-		return p(v)
-	}
-}
-
 // Or returns a predicate that is a short-circuiting logical OR of this and the given predicates.
+// Note that P[T] only supports Or. For chained AND/OR logic, use PR[T].
 func (p P[T]) Or(ps ...P[T]) P[T] {
 	return func(v T) bool {
+		if p != nil && p(v) {
+			return true
+		}
 		for _, pp := range ps {
 			if pp(v) {
 				return true
 			}
 		}
-		if p == nil {
-			return false
-		}
-		return p(v)
+		return false
 	}
 }
 
-// Negate returns a predicate that is a logical negation of this predicate.
-func (p P[T]) Negate() P[T] {
+// PR is a predicate function that tests whether a value of type T satisfies some condition and returns a Match result.
+type PR[T any] func(T) Match
+
+// BoolFunc returns a P[T] version of this predicate.
+func (p PR[T]) BoolFunc() P[T] {
 	return func(v T) bool {
-		return !p(v)
+		if p == nil {
+			return false
+		}
+		return p(v).OK()
 	}
 }
 
+// And returns a predicate that is a short-circuiting logical AND of this and the given predicates.
+func (p PR[T]) And(ps ...PR[T]) PR[T] {
+	return func(v T) Match {
+		if p != nil {
+			m := p(v)
+			if !m.OK() || shouldBreak(m) {
+				return matchBreak
+			}
+		}
+		for _, pp := range ps {
+			m := pp(v)
+			if !m.OK() || shouldBreak(m) {
+				return matchBreak
+			}
+		}
+		return BoolMatch(true)
+	}
+}
+
+// Or returns a predicate that is a short-circuiting logical OR of this and the given predicates.
+func (p PR[T]) Or(ps ...PR[T]) PR[T] {
+	return func(v T) Match {
+		if p != nil {
+			m := p(v)
+			if m.OK() {
+				return m
+			}
+			if shouldBreak(m) {
+				return matchBreak
+			}
+		}
+		for _, pp := range ps {
+			m := pp(v)
+			if m.OK() {
+				return m
+			}
+			if shouldBreak(m) {
+				return matchBreak
+			}
+		}
+		return BoolMatch(false)
+	}
+}
+
+func shouldBreak(m Match) bool {
+	_, ok := m.(breakMatch)
+	return ok
+}
+
 // Filter returns a new slice holding only the elements of s that satisfy p.
 // Filter modifies the contents of the slice s and returns the modified slice, which may have a smaller length.
-func (p P[T]) Filter(s []T) []T {
+func (p PR[T]) Filter(s []T) []T {
 	var n int
 	for _, v := range s {
-		if p(v) {
+		if p(v).OK() {
 			s[n] = v
 			n++
 		}
@@ -67,12 +143,50 @@ func (p P[T]) Filter(s []T) []T {
 }
 
 // FilterCopy returns a new slice holding only the elements of s that satisfy p.
-func (p P[T]) FilterCopy(s []T) []T {
+func (p PR[T]) FilterCopy(s []T) []T {
 	var result []T
 	for _, v := range s {
-		if p(v) {
+		if p(v).OK() {
 			result = append(result, v)
 		}
 	}
 	return result
 }
+
+// NewStringPredicateFromGlobs creates a string predicate from the given glob patterns.
+// A glob pattern starting with "!" is a negation pattern which will be ANDed with the rest.
+func NewStringPredicateFromGlobs(patterns []string, getGlob func(pattern string) (glob.Glob, error)) (P[string], error) {
+	var p PR[string]
+	for _, pattern := range patterns {
+		pattern = strings.TrimSpace(pattern)
+		if pattern == "" {
+			continue
+		}
+		negate := strings.HasPrefix(pattern, hglob.NegationPrefix)
+		if negate {
+			pattern = pattern[2:]
+			g, err := getGlob(pattern)
+			if err != nil {
+				return nil, err
+			}
+			p = p.And(func(s string) Match {
+				return BoolMatch(!g.Match(s))
+			})
+		} else {
+			g, err := getGlob(pattern)
+			if err != nil {
+				return nil, err
+			}
+			p = p.Or(func(s string) Match {
+				return BoolMatch(g.Match(s))
+			})
+
+		}
+	}
+
+	return p.BoolFunc(), nil
+}
+
+type IndexMatcher interface {
+	IndexMatch(match P[string]) (iter.Seq[int], error)
+}

common/predicate/predicate_test.go

@@ -17,38 +17,66 @@ import (
 	"testing"
 
 	qt "github.com/frankban/quicktest"
+	"github.com/gobwas/glob"
 	"github.com/gohugoio/hugo/common/predicate"
 )
 
-func TestAdd(t *testing.T) {
+func TestPredicate(t *testing.T) {
 	c := qt.New(t)
 
-	var p predicate.P[int] = intP1
+	n := func() predicate.PR[int] {
+		var pr predicate.PR[int]
+		return pr
+	}
 
-	c.Assert(p(1), qt.IsTrue)
+	var pr predicate.PR[int]
+	p := pr.BoolFunc()
+	c.Assert(p(1), qt.IsFalse)
+
+	pr = n().Or(intP1).Or(intP2)
+	p = pr.BoolFunc()
+	c.Assert(p(1), qt.IsTrue)  // true || false
+	c.Assert(p(2), qt.IsTrue)  // false || true
+	c.Assert(p(3), qt.IsFalse) // false || false
+
+	pr = pr.And(intP3)
+	p = pr.BoolFunc()
+	c.Assert(p(2), qt.IsFalse)  // true || true && false
+	c.Assert(pr(10), qt.IsTrue) // true || true && true
+
+	pr = pr.And(intP4)
+	p = pr.BoolFunc()
+	c.Assert(p(10), qt.IsTrue)  // true || true && true && true
+	c.Assert(p(2), qt.IsFalse)  // true || true && false && false
+	c.Assert(p(1), qt.IsFalse)  // true || false && false && false
+	c.Assert(p(3), qt.IsFalse)  // false || false && false && false
+	c.Assert(p(4), qt.IsFalse)  // false || false && false && false
+	c.Assert(p(42), qt.IsFalse) // false || false && false && false
+
+	pr = n().And(intP1).And(intP2).And(intP3).And(intP4)
+	p = pr.BoolFunc()
+	c.Assert(p(1), qt.IsFalse)
 	c.Assert(p(2), qt.IsFalse)
+	c.Assert(p(10), qt.IsTrue)
 
-	neg := p.Negate()
-	c.Assert(neg(1), qt.IsFalse)
-	c.Assert(neg(2), qt.IsTrue)
+	pr = n().And(intP1).And(intP2).And(intP3).And(intP4)
+	p = pr.BoolFunc()
+	c.Assert(p(1), qt.IsFalse)
+	c.Assert(p(2), qt.IsFalse)
+	c.Assert(p(10), qt.IsTrue)
 
-	and := p.And(intP2)
-	c.Assert(and(1), qt.IsFalse)
-	c.Assert(and(2), qt.IsFalse)
-	c.Assert(and(10), qt.IsTrue)
-
-	or := p.Or(intP2)
-	c.Assert(or(1), qt.IsTrue)
-	c.Assert(or(2), qt.IsTrue)
-	c.Assert(or(10), qt.IsTrue)
-	c.Assert(or(11), qt.IsFalse)
+	pr = n().Or(intP1).Or(intP2).Or(intP3)
+	p = pr.BoolFunc()
+	c.Assert(p(1), qt.IsTrue)
+	c.Assert(p(10), qt.IsTrue)
+	c.Assert(p(4), qt.IsFalse)
 }
 
 func TestFilter(t *testing.T) {
 	c := qt.New(t)
 
-	var p predicate.P[int] = intP1
-	p = p.Or(intP2)
+	var p predicate.PR[int]
+	p = p.Or(intP1).Or(intP2)
 
 	ints := []int{1, 2, 3, 4, 1, 6, 7, 8, 2}
 
@@ -59,8 +87,8 @@ func TestFilter(t *testing.T) {
 func TestFilterCopy(t *testing.T) {
 	c := qt.New(t)
 
-	var p predicate.P[int] = intP1
-	p = p.Or(intP2)
+	var p predicate.PR[int]
+	p = p.Or(intP1).Or(intP2)
 
 	ints := []int{1, 2, 3, 4, 1, 6, 7, 8, 2}
 
@@ -68,16 +96,86 @@ func TestFilterCopy(t *testing.T) {
 	c.Assert(ints, qt.DeepEquals, []int{1, 2, 3, 4, 1, 6, 7, 8, 2})
 }
 
-var intP1 = func(i int) bool {
+var intP1 = func(i int) predicate.Match {
 	if i == 10 {
-		return true
+		return predicate.True
 	}
-	return i == 1
+	return predicate.BoolMatch(i == 1)
 }
 
-var intP2 = func(i int) bool {
+var intP2 = func(i int) predicate.Match {
 	if i == 10 {
-		return true
+		return predicate.True
 	}
-	return i == 2
+	return predicate.BoolMatch(i == 2)
+}
+
+var intP3 = func(i int) predicate.Match {
+	if i == 10 {
+		return predicate.True
+	}
+	return predicate.BoolMatch(i == 3)
+}
+
+var intP4 = func(i int) predicate.Match {
+	if i == 10 {
+		return predicate.True
+	}
+	return predicate.BoolMatch(i == 4)
+}
+
+func TestNewStringPredicateFromGlobs(t *testing.T) {
+	c := qt.New(t)
+
+	getGlob := func(pattern string) (glob.Glob, error) {
+		return glob.Compile(pattern)
+	}
+
+	n := func(patterns ...string) predicate.P[string] {
+		p, err := predicate.NewStringPredicateFromGlobs(patterns, getGlob)
+		c.Assert(err, qt.IsNil)
+		return p
+	}
+
+	m := n("a", "! ab*", "abc")
+	c.Assert(m("a"), qt.IsTrue)
+	c.Assert(m("ab"), qt.IsFalse)
+	c.Assert(m("abc"), qt.IsFalse)
+
+	m = n()
+	c.Assert(m("anything"), qt.IsFalse)
+}
+
+func BenchmarkPredicate(b *testing.B) {
+	b.Run("and or no match", func(b *testing.B) {
+		var p predicate.PR[int] = intP1
+		p = p.And(intP2).Or(intP3)
+		for b.Loop() {
+			_ = p(3).OK()
+		}
+	})
+
+	b.Run("and and no match", func(b *testing.B) {
+		var p predicate.PR[int] = intP1
+		p = p.And(intP2)
+		for b.Loop() {
+			_ = p(3).OK()
+		}
+	})
+
+	b.Run("and and match", func(b *testing.B) {
+		var p predicate.PR[int] = intP1
+		p = p.And(intP2)
+		for b.Loop() {
+			_ = p(10).OK()
+		}
+	})
+
+	b.Run("or or match", func(b *testing.B) {
+		var p predicate.PR[int] = intP1
+		p = p.Or(intP2).Or(intP3)
+		for b.Loop() {
+			_ = p(2).OK()
+		}
+	})
 }

common/text/transform_test.go

@@ -65,7 +65,7 @@ func BenchmarkVisitLinesAfter(b *testing.B) {
 	
 	line 3`
 
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		VisitLinesAfter(lines, func(s string) {
 		})
 	}

common/types/types.go

@@ -139,7 +139,25 @@ func NewBool(b bool) *bool {
 	return &b
 }
 
+// WeightProvider provides a weight.
+type WeightProvider interface {
+	Weight() int
+}
+
+// Weight0Provider provides a weight that's considered before the WeightProvider in sorting.
+// This allows the weight set on a given term to win.
+type Weight0Provider interface {
+	Weight0() int
+}
+
 // PrintableValueProvider is implemented by types that can provide a printable value.
 type PrintableValueProvider interface {
 	PrintableValue() any
 }
+
+type (
+	Strings2 [2]string
+	Strings3 [3]string
+	Ints2    [2]int
+	Ints3    [3]int
+)

common/version/version.go

@@ -1,4 +1,4 @@
-// Copyright 2018 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,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package hugo
+package version
 
 import (
 	"fmt"
@@ -44,6 +44,13 @@ var (
 	_ compare.Comparer = (*VersionString)(nil)
 )
 
+// IsAlphaBetaOrRC returns whether this version is an alpha, beta, or release candidate.
+func (v Version) IsAlphaBetaOrRC() bool {
+	s := strings.ToLower(v.Suffix)
+	// e.g. "alpha.1", "beta.2", "rc.3"
+	return strings.Contains(s, "alpha.") || strings.Contains(s, "beta.") || strings.Contains(s, "rc.")
+}
+
 func (v Version) String() string {
 	return version(v.Major, v.Minor, v.PatchLevel, v.Suffix)
 }
@@ -55,7 +62,7 @@ func (v Version) Version() VersionString {
 
 // Compare implements the compare.Comparer interface.
 func (h Version) Compare(other any) int {
-	return compareVersions(h, other)
+	return CompareVersions(h, other)
 }
 
 // VersionString represents a Hugo version string.
@@ -67,7 +74,7 @@ func (h VersionString) String() string {
 
 // Compare implements the compare.Comparer interface.
 func (h VersionString) Compare(other any) int {
-	return compareVersions(h.Version(), other)
+	return CompareVersions(h.Version(), other)
 }
 
 func (h VersionString) Version() Version {
@@ -83,18 +90,24 @@ func (h VersionString) Eq(other any) bool {
 	return s == h.String()
 }
 
-var versionSuffixes = []string{"-test", "-DEV"}
-
 // ParseVersion parses a version string.
 func ParseVersion(s string) (Version, error) {
+	s = strings.TrimPrefix(strings.TrimSpace(s), "v")
 	var vv Version
-	for _, suffix := range versionSuffixes {
-		if strings.HasSuffix(s, suffix) {
-			vv.Suffix = suffix
-			s = strings.TrimSuffix(s, suffix)
+	hyphen := strings.Index(s, "-")
+	if hyphen > 0 {
+		suffix := s[hyphen:]
+		if len(suffix) > 1 {
+			if suffix[0] == '-' {
+				suffix = suffix[1:]
+			}
+			if len(suffix) > 0 {
+				vv.Suffix = suffix
+				s = s[:hyphen]
+			}
 		}
+		vv.Suffix = suffix
 	}
-
 	vv.Major, vv.Minor, vv.PatchLevel = parseVersion(s)
 
 	return vv, nil
@@ -134,98 +147,55 @@ func (v Version) NextPatchLevel(level int) Version {
 	return prev
 }
 
-// BuildVersionString creates a version string. This is what you see when
-// running "hugo version".
-func BuildVersionString() string {
-	// program := "Hugo Static Site Generator"
-	program := "hugo"
-
-	version := "v" + CurrentVersion.String()
-
-	bi := getBuildInfo()
-	if bi == nil {
-		return version
-	}
-	if bi.Revision != "" {
-		version += "-" + bi.Revision
-	}
-	if IsExtended {
-		version += "+extended"
-	}
-	if IsWithdeploy {
-		version += "+withdeploy"
-	}
-
-	osArch := bi.GoOS + "/" + bi.GoArch
-
-	date := bi.RevisionTime
-	if date == "" {
-		// Accept vendor-specified build date if .git/ is unavailable.
-		date = buildDate
-	}
-	if date == "" {
-		date = "unknown"
-	}
-
-	versionString := fmt.Sprintf("%s %s %s BuildDate=%s",
-		program, version, osArch, date)
-
-	if vendorInfo != "" {
-		versionString += " VendorInfo=" + vendorInfo
-	}
-
-	return versionString
-}
-
 func version(major, minor, patch int, suffix string) string {
+	if suffix != "" {
+		if suffix[0] != '-' {
+			suffix = "-" + suffix
+		}
+	}
 	if patch > 0 || minor > 53 {
 		return fmt.Sprintf("%d.%d.%d%s", major, minor, patch, suffix)
 	}
 	return fmt.Sprintf("%d.%d%s", major, minor, suffix)
 }
 
-// CompareVersion compares the given version string or number against the
-// running Hugo version.
-// It returns -1 if the given version is less than, 0 if equal and 1 if greater than
-// the running version.
-func CompareVersion(version any) int {
-	return compareVersions(CurrentVersion, version)
-}
-
-func compareVersions(inVersion Version, in any) int {
+// CompareVersion compares v1 with v2.
+// It returns -1 if the v2 is less than, 0 if equal and 1 if greater than
+// v1.
+func CompareVersions(v1 Version, v2 any) int {
 	var c int
-	switch d := in.(type) {
+	switch d := v2.(type) {
 	case float64:
-		c = compareFloatWithVersion(d, inVersion)
+		c = compareFloatWithVersion(d, v1)
 	case float32:
-		c = compareFloatWithVersion(float64(d), inVersion)
+		c = compareFloatWithVersion(float64(d), v1)
 	case int:
-		c = compareFloatWithVersion(float64(d), inVersion)
+		c = compareFloatWithVersion(float64(d), v1)
 	case int32:
-		c = compareFloatWithVersion(float64(d), inVersion)
+		c = compareFloatWithVersion(float64(d), v1)
 	case int64:
-		c = compareFloatWithVersion(float64(d), inVersion)
+		c = compareFloatWithVersion(float64(d), v1)
 	case Version:
-		if d.Major == inVersion.Major && d.Minor == inVersion.Minor && d.PatchLevel == inVersion.PatchLevel {
-			return strings.Compare(inVersion.Suffix, d.Suffix)
+		if d.Major == v1.Major && d.Minor == v1.Minor && d.PatchLevel == v1.PatchLevel {
+			return strings.Compare(v1.Suffix, d.Suffix)
 		}
-		if d.Major > inVersion.Major {
+		if d.Major > v1.Major {
 			return 1
-		} else if d.Major < inVersion.Major {
+		} else if d.Major < v1.Major {
 			return -1
 		}
-		if d.Minor > inVersion.Minor {
+		if d.Minor > v1.Minor {
 			return 1
-		} else if d.Minor < inVersion.Minor {
+		} else if d.Minor < v1.Minor {
 			return -1
 		}
-		if d.PatchLevel > inVersion.PatchLevel {
+		if d.PatchLevel > v1.PatchLevel {
 			return 1
-		} else if d.PatchLevel < inVersion.PatchLevel {
+		} else if d.PatchLevel < v1.PatchLevel {
 			return -1
 		}
 	default:
-		s, err := cast.ToStringE(in)
+		s, err := cast.ToStringE(v2)
 		if err != nil {
 			return -1
 		}
@@ -234,7 +204,7 @@ func compareVersions(inVersion Version, in any) int {
 		if err != nil {
 			return -1
 		}
-		return inVersion.Compare(v)
+		return v1.Compare(v)
 
 	}
 

common/version/version_test.go

@@ -1,4 +1,4 @@
-// Copyright 2015 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,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package hugo
+package version
 
 import (
 	"testing"
@@ -50,30 +50,31 @@ func TestHugoVersion(t *testing.T) {
 func TestCompareVersions(t *testing.T) {
 	c := qt.New(t)
 
-	c.Assert(compareVersions(MustParseVersion("0.20.0"), 0.20), qt.Equals, 0)
-	c.Assert(compareVersions(MustParseVersion("0.20.0"), float32(0.20)), qt.Equals, 0)
-	c.Assert(compareVersions(MustParseVersion("0.20.0"), float64(0.20)), qt.Equals, 0)
-	c.Assert(compareVersions(MustParseVersion("0.19.1"), 0.20), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.19.3"), "0.20.2"), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.1"), 3), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.1"), int32(3)), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.1"), int64(3)), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.20"), "0.20"), qt.Equals, 0)
-	c.Assert(compareVersions(MustParseVersion("0.20.1"), "0.20.1"), qt.Equals, 0)
-	c.Assert(compareVersions(MustParseVersion("0.20.1"), "0.20"), qt.Equals, -1)
-	c.Assert(compareVersions(MustParseVersion("0.20.0"), "0.20.1"), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.20.1"), "0.20.2"), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.21.1"), "0.22.1"), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.22.0"), "0.22-DEV"), qt.Equals, -1)
-	c.Assert(compareVersions(MustParseVersion("0.22.0"), "0.22.1-DEV"), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.22.0-DEV"), "0.22"), qt.Equals, 1)
-	c.Assert(compareVersions(MustParseVersion("0.22.1-DEV"), "0.22"), qt.Equals, -1)
-	c.Assert(compareVersions(MustParseVersion("0.22.1-DEV"), "0.22.1-DEV"), qt.Equals, 0)
+	c.Assert(CompareVersions(MustParseVersion("0.20.0"), 0.20), qt.Equals, 0)
+	c.Assert(CompareVersions(MustParseVersion("0.20.0"), float32(0.20)), qt.Equals, 0)
+	c.Assert(CompareVersions(MustParseVersion("0.20.0"), float64(0.20)), qt.Equals, 0)
+	c.Assert(CompareVersions(MustParseVersion("0.19.1"), 0.20), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.19.3"), "0.20.2"), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.1"), 3), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.1"), int32(3)), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.1"), int64(3)), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.20"), "0.20"), qt.Equals, 0)
+	c.Assert(CompareVersions(MustParseVersion("0.20.1"), "0.20.1"), qt.Equals, 0)
+	c.Assert(CompareVersions(MustParseVersion("0.20.1"), "0.20"), qt.Equals, -1)
+	c.Assert(CompareVersions(MustParseVersion("0.20.0"), "0.20.1"), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.20.1"), "0.20.2"), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.21.1"), "0.22.1"), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.22.0"), "0.22-DEV"), qt.Equals, -1)
+	c.Assert(CompareVersions(MustParseVersion("0.22.0"), "0.22.1-DEV"), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.22.0-DEV"), "0.22"), qt.Equals, 1)
+	c.Assert(CompareVersions(MustParseVersion("0.22.1-DEV"), "0.22"), qt.Equals, -1)
+	c.Assert(CompareVersions(MustParseVersion("0.22.1-DEV"), "0.22.1-DEV"), qt.Equals, 0)
 }
 
 func TestParseHugoVersion(t *testing.T) {
 	c := qt.New(t)
 
+	c.Assert(MustParseVersion("v2.3.2").String(), qt.Equals, "2.3.2")
 	c.Assert(MustParseVersion("0.25").String(), qt.Equals, "0.25")
 	c.Assert(MustParseVersion("0.25.2").String(), qt.Equals, "0.25.2")
 	c.Assert(MustParseVersion("0.25-test").String(), qt.Equals, "0.25-test")

compare/compare.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.

compare/compare_strings_test.go

@@ -63,6 +63,7 @@ func TestLexicographicSort(t *testing.T) {
 	c.Assert(s, qt.DeepEquals, []string{"A", "b", "Ba", "ba", "ba", "Bz"})
 }
 
+// // Note that this cannot use b.Loop() because of golang/go#27217.
 func BenchmarkStringSort(b *testing.B) {
 	prototype := []string{"b", "Bz", "zz", "ba", "αβδ αβδ αβδ", "A", "Ba", "ba", "nnnnasdfnnn", "AAgæåz", "αβδC"}
 	b.Run("LessStrings", func(b *testing.B) {

compare/compare_test.go

@@ -0,0 +1,14 @@
+// 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 compare

config/allconfig/allconfig.go

@@ -29,6 +29,7 @@ import (
 
 	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/cache/httpcache"
+	"github.com/gohugoio/hugo/common/hstrings"
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/maps"
@@ -40,7 +41,10 @@ import (
 	"github.com/gohugoio/hugo/config/services"
 	"github.com/gohugoio/hugo/deploy/deployconfig"
 	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugolib/roles"
 	"github.com/gohugoio/hugo/hugolib/segments"
+	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
+	"github.com/gohugoio/hugo/hugolib/versions"
 	"github.com/gohugoio/hugo/langs"
 	gc "github.com/gohugoio/hugo/markup/goldmark/goldmark_config"
 	"github.com/gohugoio/hugo/markup/markup_config"
@@ -99,7 +103,8 @@ type Config struct {
 	// For internal use only.
 	Internal InternalConfig `mapstructure:"-" json:"-"`
 	// For internal use only.
-	C *ConfigCompiled `mapstructure:"-" json:"-"`
+	C               *ConfigCompiled `mapstructure:"-" json:"-"`
+	isLanguageClone bool
 
 	RootConfig
 
@@ -139,16 +144,25 @@ type Config struct {
 	// The outputformats configuration sections maps a format name (a string) to a configuration object for that format.
 	OutputFormats *config.ConfigNamespace[map[string]output.OutputFormatConfig, output.Formats] `mapstructure:"-"`
 
+	// The languages configuration sections maps a language code (a string) to a configuration object for that language.
+	Languages *config.ConfigNamespace[map[string]langs.LanguageConfig, langs.LanguagesInternal] `mapstructure:"-"`
+
+	// The versions configuration section contains the top level versions configuration options.
+	Versions *config.ConfigNamespace[map[string]versions.VersionConfig, versions.VersionsInternal] `mapstructure:"-"`
+
+	// The roles configuration section contains the top level roles configuration options.
+	Roles *config.ConfigNamespace[map[string]roles.RoleConfig, roles.RolesInternal] `mapstructure:"-"`
+
 	// The outputs configuration section maps a Page Kind (a string) to a slice of output formats.
 	// This can be overridden in the front matter.
 	Outputs map[string][]string `mapstructure:"-"`
 
 	// 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, page.PageMatcherParamsConfig]] `mapstructure:"-"`
+	Cascade *page.PageMatcherParamsConfigs `mapstructure:"-"`
 
 	// The segments defines segments for the site. Used for partial/segmented builds.
-	Segments *config.ConfigNamespace[map[string]segments.SegmentConfig, segments.Segments] `mapstructure:"-"`
+	Segments *config.ConfigNamespace[map[string]segments.SegmentConfig, *segments.Segments] `mapstructure:"-"`
 
 	// Menu configuration.
 	// <docsmeta>{"refs": ["config:languages:menus"] }</docsmeta>
@@ -200,19 +214,23 @@ type Config struct {
 	// <docsmeta>{"refs": ["config:languages:params"] }</docsmeta>
 	Params maps.Params `mapstructure:"-"`
 
-	// The languages configuration sections maps a language code (a string) to a configuration object for that language.
-	Languages map[string]langs.LanguageConfig `mapstructure:"-"`
-
 	// UglyURLs configuration. Either a boolean or a sections map.
 	UglyURLs any `mapstructure:"-"`
 }
 
+// Early initialization of config.
 type configCompiler interface {
 	CompileConfig(logger loggers.Logger) error
 }
 
+// Late initialization of config.
+type configInitializer interface {
+	InitConfig(logger loggers.Logger, defaultSitesMatrix sitesmatrix.VectorStore, configuredDimensions *sitesmatrix.ConfiguredDimensions) error
+}
+
 func (c Config) cloneForLang() *Config {
 	x := c
+	x.isLanguageClone = true
 	x.C = nil
 	copyStringSlice := func(in []string) []string {
 		if in == nil {
@@ -319,18 +337,6 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 	for _, lang := range c.DisableLanguages {
 		disabledLangs[lang] = true
 	}
-	for lang, language := range c.Languages {
-		if !language.Disabled && disabledLangs[lang] {
-			language.Disabled = true
-			c.Languages[lang] = language
-		}
-		if language.Disabled {
-			disabledLangs[lang] = true
-			if lang == c.DefaultContentLanguage {
-				return fmt.Errorf("cannot disable default content language %q", lang)
-			}
-		}
-	}
 
 	for i, s := range c.IgnoreLogs {
 		c.IgnoreLogs[i] = strings.ToLower(s)
@@ -483,7 +489,6 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		CreateTitle:         helpers.GetTitleFunc(c.TitleCaseStyle),
 		IsUglyURLSection:    isUglyURL,
 		IgnoreFile:          ignoreFile,
-		SegmentFilter:       c.Segments.Config.Get(func(s string) { logger.Warnf("Render segment %q not found in configuration", s) }, c.RootConfig.RenderSegments...),
 		MainSections:        c.MainSections,
 		Clock:               clock,
 		HTTPCache:           httpCache,
@@ -523,7 +528,6 @@ type ConfigCompiled struct {
 	CreateTitle         func(s string) string
 	IsUglyURLSection    func(section string) bool
 	IgnoreFile          func(filename string) bool
-	SegmentFilter       segments.SegmentFilter
 	MainSections        []string
 	Clock               time.Time
 	HTTPCache           httpcache.ConfigCompiled
@@ -586,6 +590,18 @@ type RootConfig struct {
 	// Set this to true to put all languages below their language ID.
 	DefaultContentLanguageInSubdir bool
 
+	// The default content role to use for the site.
+	DefaultContentRole string
+
+	// Set this to true to put the default role in a subdirectory.
+	DefaultContentRoleInSubdir bool
+
+	// The default content version to use for the site.
+	DefaultContentVersion string
+
+	// Set to true to render the default version in a subdirectory.
+	DefaultContentVersionInSubdir bool
+
 	// The default output format to use for the site.
 	// If not set, we will use the first output format.
 	DefaultOutputFormat string
@@ -788,14 +804,13 @@ func (c RootConfig) staticDirs() []string {
 	dirs = append(dirs, c.StaticDir8...)
 	dirs = append(dirs, c.StaticDir9...)
 	dirs = append(dirs, c.StaticDir10...)
-	return helpers.UniqueStringsReuse(dirs)
+	return hstrings.UniqueStringsReuse(dirs)
 }
 
 type Configs struct {
-	Base                *Config
-	LoadingInfo         config.LoadConfigResult
-	LanguageConfigMap   map[string]*Config
-	LanguageConfigSlice []*Config
+	Base              *Config
+	LoadingInfo       config.LoadConfigResult
+	LanguageConfigMap map[string]*Config
 
 	IsMultihost bool
 
@@ -803,18 +818,16 @@ type Configs struct {
 	ModulesClient *modules.Client
 
 	// All below is set in Init.
-	Languages             langs.Languages
-	LanguagesDefaultFirst langs.Languages
-	ContentPathParser     *paths.PathParser
+	Languages                 langs.Languages
+	ContentPathParser         *paths.PathParser
+	ConfiguredDimensions      *sitesmatrix.ConfiguredDimensions
+	DefaultContentSitesMatrix *sitesmatrix.IntSets
+	AllSitesMatrix            *sitesmatrix.IntSets
 
 	configLangs []config.AllProvider
 }
 
 func (c *Configs) Validate(logger loggers.Logger) error {
-	c.Base.Cascade.Config.Range(func(p page.PageMatcher, cfg page.PageMatcherParamsConfig) bool {
-		page.CheckCascadePattern(logger, p)
-		return true
-	})
 	return nil
 }
 
@@ -833,54 +846,15 @@ func (c *Configs) IsZero() bool {
 	return c == nil || len(c.Languages) == 0
 }
 
-func (c *Configs) Init() error {
+func (c *Configs) Init(logger loggers.Logger) error {
 	var languages langs.Languages
 
-	var langKeys []string
-	var hasEn bool
-
-	const en = "en"
-
-	for k := range c.LanguageConfigMap {
-		langKeys = append(langKeys, k)
-		if k == en {
-			hasEn = true
+	for _, f := range c.Base.Languages.Config.Sorted {
+		v, found := c.LanguageConfigMap[f.Name]
+		if !found {
+			return fmt.Errorf("invalid language configuration for %q", f.Name)
 		}
-	}
-
-	// 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, c.Base.DefaultContentLanguage, v.TimeZone, languageConf)
+		language, err := langs.NewLanguage(f.Name, c.Base.DefaultContentLanguage, v.TimeZone, f.LanguageConfig)
 		if err != nil {
 			return err
 		}
@@ -897,25 +871,29 @@ func (c *Configs) Init() error {
 	}
 	languages = languages[:n]
 
-	var languagesDefaultFirst langs.Languages
-	for _, l := range languages {
-		if l.Lang == c.Base.DefaultContentLanguage {
-			languagesDefaultFirst = append(languagesDefaultFirst, l)
-		}
-	}
-	for _, l := range languages {
-		if l.Lang != c.Base.DefaultContentLanguage {
-			languagesDefaultFirst = append(languagesDefaultFirst, l)
-		}
+	c.Languages = languages
+	c.ConfiguredDimensions = &sitesmatrix.ConfiguredDimensions{
+		ConfiguredLanguages: c.Base.Languages.Config,
+		ConfiguredVersions:  c.Base.Versions.Config,
+		ConfiguredRoles:     c.Base.Roles.Config,
 	}
 
-	c.Languages = languages
-	c.LanguagesDefaultFirst = languagesDefaultFirst
+	if err := c.ConfiguredDimensions.Init(); err != nil {
+		return err
+	}
+
+	intSetsCfg := sitesmatrix.IntSetsConfig{
+		ApplyDefaults: sitesmatrix.IntSetsConfigApplyDefaultsIfNotSet,
+	}
+	matrix := sitesmatrix.NewIntSetsBuilder(c.ConfiguredDimensions).WithConfig(intSetsCfg)
+	c.DefaultContentSitesMatrix = matrix.Build()
+	c.AllSitesMatrix = sitesmatrix.NewIntSetsBuilder(c.ConfiguredDimensions).WithAllIfNotSet().Build()
 
 	c.ContentPathParser = &paths.PathParser{
-		LanguageIndex:  languagesDefaultFirst.AsIndexSet(),
-		IsLangDisabled: c.Base.IsLangDisabled,
-		IsContentExt:   c.Base.ContentTypes.Config.IsContentSuffix,
+		ConfiguredDimensions: c.ConfiguredDimensions,
+		LanguageIndex:        languages.AsIndexSet(),
+		IsLangDisabled:       c.Base.IsLangDisabled,
+		IsContentExt:         c.Base.ContentTypes.Config.IsContentSuffix,
 		IsOutputFormat: func(name, ext string) bool {
 			if name == "" {
 				return false
@@ -932,12 +910,26 @@ func (c *Configs) Init() error {
 	}
 
 	c.configLangs = make([]config.AllProvider, len(c.Languages))
-	for i, l := range c.LanguagesDefaultFirst {
+
+	// Config can be shared between languages,
+	// avoid initializing the same config more than once.
+	for i, l := range c.Languages {
+		langConfig := c.LanguageConfigMap[l.Lang]
+		sitesMatrix := sitesmatrix.NewIntSetsBuilder(c.ConfiguredDimensions).WithLanguageIndices(i).WithAllIfNotSet().Build()
+		for _, s := range allDecoderSetups {
+			if getInitializer := s.getInitializer; getInitializer != nil {
+				if err := getInitializer(langConfig).InitConfig(logger, sitesMatrix, c.ConfiguredDimensions); err != nil {
+					return err
+				}
+			}
+		}
+
 		c.configLangs[i] = ConfigLanguage{
-			m:          c,
-			config:     c.LanguageConfigMap[l.Lang],
-			baseConfig: c.LoadingInfo.BaseConfig,
-			language:   l,
+			m:             c,
+			config:        langConfig,
+			baseConfig:    c.LoadingInfo.BaseConfig,
+			language:      l,
+			languageIndex: i,
 		}
 	}
 
@@ -946,7 +938,7 @@ func (c *Configs) Init() error {
 	}
 
 	// Apply default project mounts.
-	if err := modules.ApplyProjectConfigDefaults(c.Modules[0], c.configLangs...); err != nil {
+	if err := modules.ApplyProjectConfigDefaults(logger.Logger(), c.Modules[0], c.configLangs...); err != nil {
 		return err
 	}
 
@@ -955,7 +947,7 @@ func (c *Configs) Init() error {
 	for _, m := range c.Modules[0].Mounts() {
 		var found bool
 		for _, cm := range c.Base.Module.Mounts {
-			if cm.Source == m.Source && cm.Target == m.Target && cm.Lang == m.Lang {
+			if cm.Equal(m) {
 				found = true
 				break
 			}
@@ -966,7 +958,7 @@ func (c *Configs) Init() error {
 	}
 
 	// Transfer the changed mounts to the language versions (all share the same mount set, but can be displayed in different languages).
-	for _, l := range c.LanguageConfigSlice {
+	for _, l := range c.LanguageConfigMap {
 		l.Module.Mounts = c.Base.Module.Mounts
 	}
 
@@ -983,7 +975,7 @@ func (c Configs) GetFirstLanguageConfig() config.AllProvider {
 
 func (c Configs) GetByLang(lang string) config.AllProvider {
 	for _, l := range c.configLangs {
-		if l.Language().Lang == lang {
+		if l.Language().(*langs.Language).Lang == lang {
 			return l
 		}
 	}
@@ -1060,7 +1052,6 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 					maps.MergeStrategyKey: maps.ParamsMergeStrategyDeep,
 				}
 			}
-
 			for kk, vv := range x {
 				if kk == "_merge" {
 					continue
@@ -1077,6 +1068,13 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 					vv = maps.CloneParamsDeep(p)
 				}
 
+				if kk == "cascade" {
+					// If not set, add the current language to make sure it does not get applied to other languages.
+					page.AddLangToCascadeTargetMap(k, vv.(maps.Params))
+					// Always clone cascade config to get the sites matrix right.
+					differentRootKeys = append(differentRootKeys, kk)
+				}
+
 				mergedConfig.Set(kk, vv)
 				rootv := cfg.Get(kk)
 				if rootv != nil && cfg.IsSet(kk) {
@@ -1108,7 +1106,7 @@ func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadCon
 					}
 				}
 			}
-			differentRootKeys = helpers.UniqueStringsSorted(differentRootKeys)
+			differentRootKeys = hstrings.UniqueStringsSorted(differentRootKeys)
 
 			if len(differentRootKeys) == 0 {
 				langConfigMap[k] = all
@@ -1188,7 +1186,7 @@ func decodeConfigFromParams(fs afero.Fs, logger loggers.Logger, bcfg config.Base
 	})
 
 	for _, v := range decoderSetups {
-		p := decodeConfig{p: p, c: target, fs: fs, bcfg: bcfg}
+		p := decodeConfig{p: p, c: target, fs: fs, bcfg: bcfg, logger: logger}
 		if err := v.decode(v, p); err != nil {
 			return fmt.Errorf("failed to decode %q: %w", v.key, err)
 		}

config/allconfig/allconfig_integration_test.go

@@ -39,7 +39,7 @@ title: "p1"
 ---
 title: "p1"
 ---
--- layouts/_default/single.html --
+-- layouts/single.html --
 Title: {{ .Title }}
 	`
 
@@ -66,10 +66,12 @@ Title: {{ .Title }}
 	b.Assert(modConf.Mounts, qt.HasLen, 8)
 	b.Assert(modConf.Mounts[0].Source, qt.Equals, filepath.FromSlash("content/en"))
 	b.Assert(modConf.Mounts[0].Target, qt.Equals, "content")
-	b.Assert(modConf.Mounts[0].Lang, qt.Equals, "en")
+	b.Assert(modConf.Mounts[0].Lang, qt.Equals, "")
+	b.Assert(modConf.Mounts[0].Sites.Matrix.Languages, qt.DeepEquals, []string{"en"})
 	b.Assert(modConf.Mounts[1].Source, qt.Equals, filepath.FromSlash("content/sv"))
 	b.Assert(modConf.Mounts[1].Target, qt.Equals, "content")
-	b.Assert(modConf.Mounts[1].Lang, qt.Equals, "sv")
+	b.Assert(modConf.Mounts[1].Lang, qt.Equals, "")
+	b.Assert(modConf.Mounts[1].Sites.Matrix.Languages, qt.DeepEquals, []string{"sv"})
 }
 
 func TestConfigAliases(t *testing.T) {
@@ -139,7 +141,7 @@ disableKinds = ["taxonomy", "term"]
 [pagination]
 disableAliases = true
 pagerSize = 2
--- layouts/_default/list.html --
+-- layouts/list.html --
 {{ $paginator := .Paginate  site.RegularPages }}
 {{ template "_internal/pagination.html" . }}
 {{ range $paginator.Pages }}
@@ -189,7 +191,7 @@ func TestInvalidOutputFormat(t *testing.T) {
 disableKinds = ['page','rss','section','sitemap','taxonomy','term']
 [outputs]
 home = ['html','foo']
--- layouts/index.html --
+-- layouts/home.html --
 x
 `
 
@@ -198,28 +200,6 @@ x
 	b.Assert(err.Error(), qt.Contains, `failed to create config: unknown output format "foo" for kind "home"`)
 }
 
-// Issue 13201
-func TestLanguageConfigSlice(t *testing.T) {
-	t.Parallel()
-
-	files := `
--- hugo.toml --
-disableKinds = ['page','rss','section','sitemap','taxonomy','term']
-[languages.en]
-title = 'TITLE_EN'
-weight = 2
-[languages.de]
-title = 'TITLE_DE'
-weight = 1
-[languages.fr]
-title = 'TITLE_FR'
-weight = 3
-`
-
-	b := hugolib.Test(t, files)
-	b.Assert(b.H.Configs.LanguageConfigSlice[0].Title, qt.Equals, `TITLE_DE`)
-}
-
 func TestContentTypesDefault(t *testing.T) {
 	files := `
 -- hugo.toml --

config/allconfig/alldecoders.go

@@ -15,11 +15,15 @@ package allconfig
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/gohugoio/hugo/cache/filecache"
+	"github.com/gohugoio/hugo/langs"
 
 	"github.com/gohugoio/hugo/cache/httpcache"
+	"github.com/gohugoio/hugo/common/hstrings"
+	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
@@ -27,8 +31,9 @@ import (
 	"github.com/gohugoio/hugo/config/security"
 	"github.com/gohugoio/hugo/config/services"
 	"github.com/gohugoio/hugo/deploy/deployconfig"
+	"github.com/gohugoio/hugo/hugolib/roles"
 	"github.com/gohugoio/hugo/hugolib/segments"
-	"github.com/gohugoio/hugo/langs"
+	"github.com/gohugoio/hugo/hugolib/versions"
 	"github.com/gohugoio/hugo/markup/markup_config"
 	"github.com/gohugoio/hugo/media"
 	"github.com/gohugoio/hugo/minifiers"
@@ -46,16 +51,18 @@ import (
 )
 
 type decodeConfig struct {
-	p    config.Provider
-	c    *Config
-	fs   afero.Fs
-	bcfg config.BaseConfig
+	p      config.Provider
+	c      *Config
+	fs     afero.Fs
+	bcfg   config.BaseConfig
+	logger loggers.Logger
 }
 
 type decodeWeight struct {
 	key                  string
 	decode               func(decodeWeight, decodeConfig) error
 	getCompiler          func(c *Config) configCompiler
+	getInitializer       func(c *Config) configInitializer
 	weight               int
 	internalOrDeprecated bool // Hide it from the docs.
 }
@@ -69,8 +76,10 @@ var allDecoderSetups = map[string]decodeWeight{
 				return err
 			}
 
-			// This need to match with Lang which is always lower case.
+			// This need to match with the map keys, always lower case.
 			p.c.RootConfig.DefaultContentLanguage = strings.ToLower(p.c.RootConfig.DefaultContentLanguage)
+			p.c.RootConfig.DefaultContentRole = strings.ToLower(p.c.RootConfig.DefaultContentRole)
+			p.c.RootConfig.DefaultContentVersion = strings.ToLower(p.c.RootConfig.DefaultContentVersion)
 
 			return nil
 		},
@@ -140,9 +149,12 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "segments",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			p.c.Segments, err = segments.DecodeSegments(p.p.GetStringMap(d.key))
+			p.c.Segments, err = segments.DecodeSegments(p.p.GetStringMap(d.key), p.c.RenderSegments, p.logger)
 			return err
 		},
+		getInitializer: func(c *Config) configInitializer {
+			return c.Segments.Config
+		},
 	},
 	"server": {
 		key: "server",
@@ -210,6 +222,70 @@ var allDecoderSetups = map[string]decodeWeight{
 			return err
 		},
 	},
+	"languages": {
+		key: "languages",
+		decode: func(d decodeWeight, p decodeConfig) error {
+			m := maps.CleanConfigStringMap(p.p.GetStringMap(d.key))
+			if len(m) == 1 {
+				// In v0.112.4 we moved this to the language config, but it's very commmon for mono language sites to have this at the top level.
+				var first maps.Params
+				var ok bool
+				for _, v := range m {
+					first, ok = v.(maps.Params)
+					if ok {
+						break
+					}
+				}
+				if first != nil {
+					if _, found := first["languagecode"]; !found {
+						first["languagecode"] = p.p.GetString("languagecode")
+					}
+				}
+			}
+			var (
+				err                    error
+				defaultContentLanguage string
+			)
+			p.c.Languages, defaultContentLanguage, err = langs.DecodeConfig(p.c.RootConfig.DefaultContentLanguage, p.c.RootConfig.DisableLanguages, m)
+			if err != nil {
+				return fmt.Errorf("failed to decode languages config: %w", err)
+			}
+			for k, v := range p.c.Languages.Config.LanguageConfigs {
+				if v.Disabled {
+					p.c.RootConfig.DisableLanguages = append(p.c.RootConfig.DisableLanguages, k)
+				}
+			}
+
+			p.c.RootConfig.DisableLanguages = hstrings.UniqueStringsReuse(p.c.RootConfig.DisableLanguages)
+			sort.Strings(p.c.RootConfig.DisableLanguages)
+			p.c.RootConfig.DefaultContentLanguage = defaultContentLanguage
+			return nil
+		},
+	},
+	"versions": {
+		key: "versions",
+		decode: func(d decodeWeight, p decodeConfig) error {
+			var err error
+			m := maps.CleanConfigStringMap(p.p.GetStringMap(d.key))
+			p.c.Versions, err = versions.DecodeConfig(p.c.RootConfig.DefaultContentVersion, m)
+			return err
+		},
+	},
+	"roles": {
+		key: "roles",
+		decode: func(d decodeWeight, p decodeConfig) error {
+			var (
+				err                error
+				defaultContentRole string
+			)
+			m := maps.CleanConfigStringMap(p.p.GetStringMap(d.key))
+			p.c.Roles, defaultContentRole, err = roles.DecodeConfig(p.c.RootConfig.DefaultContentRole, m)
+			p.c.RootConfig.DefaultContentRole = defaultContentRole
+
+			return err
+		},
+	},
+
 	"params": {
 		key: "params",
 		decode: func(d decodeWeight, p decodeConfig) error {
@@ -233,7 +309,7 @@ var allDecoderSetups = map[string]decodeWeight{
 		key: "module",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			p.c.Module, err = modules.DecodeConfig(p.p)
+			p.c.Module, err = modules.DecodeConfig(p.logger.Logger(), p.p)
 			return err
 		},
 	},
@@ -283,56 +359,15 @@ var allDecoderSetups = map[string]decodeWeight{
 			return nil
 		},
 	},
-	"languages": {
-		key: "languages",
-		decode: func(d decodeWeight, p decodeConfig) error {
-			var err error
-			m := p.p.GetStringMap(d.key)
-			if len(m) == 1 {
-				// In v0.112.4 we moved this to the language config, but it's very commmon for mono language sites to have this at the top level.
-				var first maps.Params
-				var ok bool
-				for _, v := range m {
-					first, ok = v.(maps.Params)
-					if ok {
-						break
-					}
-				}
-				if first != nil {
-					if _, found := first["languagecode"]; !found {
-						first["languagecode"] = p.p.GetString("languagecode")
-					}
-				}
-			}
-			p.c.Languages, err = langs.DecodeConfig(m)
-			if err != nil {
-				return err
-			}
 
-			// Validate defaultContentLanguage.
-			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)
-				}
-			}
-
-			return nil
-		},
-	},
 	"cascade": {
 		key: "cascade",
 		decode: func(d decodeWeight, p decodeConfig) error {
 			var err error
-			p.c.Cascade, err = page.DecodeCascadeConfig(nil, true, p.p.Get(d.key))
+			p.c.Cascade, err = page.DecodeCascadeConfig(p.p.Get(d.key))
 			return err
 		},
+		getInitializer: func(c *Config) configInitializer { return c.Cascade },
 	},
 	"menus": {
 		key: "menus",

config/allconfig/configlanguage.go

@@ -19,6 +19,7 @@ import (
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/urls"
 	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
 	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/langs"
 )
@@ -27,20 +28,21 @@ type ConfigLanguage struct {
 	config     *Config
 	baseConfig config.BaseConfig
 
-	m        *Configs
-	language *langs.Language
+	m             *Configs
+	language      *langs.Language
+	languageIndex int
 }
 
-func (c ConfigLanguage) Language() *langs.Language {
+func (c ConfigLanguage) Language() any {
 	return c.language
 }
 
-func (c ConfigLanguage) Languages() langs.Languages {
-	return c.m.Languages
+func (c ConfigLanguage) LanguageIndex() int {
+	return c.languageIndex
 }
 
-func (c ConfigLanguage) LanguagesDefaultFirst() langs.Languages {
-	return c.m.LanguagesDefaultFirst
+func (c ConfigLanguage) Languages() any {
+	return c.m.Languages
 }
 
 func (c ConfigLanguage) PathParser() *paths.PathParser {
@@ -48,14 +50,14 @@ func (c ConfigLanguage) PathParser() *paths.PathParser {
 }
 
 func (c ConfigLanguage) LanguagePrefix() string {
-	if c.DefaultContentLanguageInSubdir() && c.DefaultContentLanguage() == c.Language().Lang {
-		return c.Language().Lang
+	if c.DefaultContentLanguageInSubdir() && c.DefaultContentLanguage() == c.language.Lang {
+		return c.language.Lang
 	}
 
-	if !c.IsMultilingual() || c.DefaultContentLanguage() == c.Language().Lang {
+	if !c.IsMultilingual() || c.DefaultContentLanguage() == c.language.Lang {
 		return ""
 	}
-	return c.Language().Lang
+	return c.language.Lang
 }
 
 func (c ConfigLanguage) BaseURL() urls.BaseURL {
@@ -97,6 +99,10 @@ func (c ConfigLanguage) IsLangDisabled(lang string) bool {
 	return c.config.C.DisabledLanguages[lang]
 }
 
+func (c ConfigLanguage) IsKindEnabled(kind string) bool {
+	return !c.config.C.DisabledKinds[kind]
+}
+
 func (c ConfigLanguage) IgnoredLogs() map[string]bool {
 	return c.config.C.IgnoredLogs
 }
@@ -129,6 +135,10 @@ func (c ConfigLanguage) WorkingDir() string {
 	return c.m.Base.WorkingDir
 }
 
+func (c ConfigLanguage) CacheDirMisc() string {
+	return c.config.Caches.CacheDirMisc()
+}
+
 func (c ConfigLanguage) Quiet() bool {
 	return c.m.Base.Internal.Quiet
 }
@@ -137,11 +147,11 @@ func (c ConfigLanguage) Watching() bool {
 	return c.m.Base.Internal.Watch
 }
 
-func (c ConfigLanguage) NewIdentityManager(name string, opts ...identity.ManagerOption) identity.Manager {
+func (c ConfigLanguage) NewIdentityManager(opts ...identity.ManagerOption) identity.Manager {
 	if !c.Watching() {
 		return identity.NopManager
 	}
-	return identity.NewManager(name, opts...)
+	return identity.NewManager(opts...)
 }
 
 func (c ConfigLanguage) ContentTypes() config.ContentTypesProvider {
@@ -155,16 +165,24 @@ func (c ConfigLanguage) GetConfigSection(s string) any {
 		return c.config.Security
 	case "build":
 		return c.config.Build
+	case "cascade":
+		return c.config.Cascade
 	case "frontmatter":
 		return c.config.Frontmatter
 	case "caches":
 		return c.config.Caches
 	case "markup":
 		return c.config.Markup
+	case "module":
+		return c.config.Module
 	case "mediaTypes":
 		return c.config.MediaTypes.Config
 	case "outputFormats":
 		return c.config.OutputFormats.Config
+	case "roles":
+		return c.config.Roles.Config
+	case "versions":
+		return c.config.Versions.Config
 	case "permalinks":
 		return c.config.Permalinks
 	case "minify":
@@ -212,6 +230,14 @@ func (c ConfigLanguage) DefaultContentLanguageInSubdir() bool {
 	return c.config.DefaultContentLanguageInSubdir
 }
 
+func (c ConfigLanguage) DefaultContentRoleInSubdir() bool {
+	return c.config.DefaultContentRoleInSubdir
+}
+
+func (c ConfigLanguage) DefaultContentVersionInSubdir() bool {
+	return c.config.DefaultContentVersionInSubdir
+}
+
 func (c ConfigLanguage) SummaryLength() int {
 	return c.config.SummaryLength
 }
@@ -259,3 +285,15 @@ func (c ConfigLanguage) StaticDirs() []string {
 func (c ConfigLanguage) EnableEmoji() bool {
 	return c.config.EnableEmoji
 }
+
+func (c ConfigLanguage) ConfiguredDimensions() *sitesmatrix.ConfiguredDimensions {
+	return c.m.ConfiguredDimensions
+}
+
+func (c ConfigLanguage) DefaultContentsitesMatrix() *sitesmatrix.IntSets {
+	return c.m.DefaultContentSitesMatrix
+}
+
+func (c ConfigLanguage) AllSitesMatrix() *sitesmatrix.IntSets {
+	return c.m.AllSitesMatrix
+}

config/allconfig/load.go

@@ -32,7 +32,7 @@ import (
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/helpers"
-	hglob "github.com/gohugoio/hugo/hugofs/glob"
+	hglob "github.com/gohugoio/hugo/hugofs/hglob"
 	"github.com/gohugoio/hugo/modules"
 	"github.com/gohugoio/hugo/parser/metadecoders"
 	"github.com/spf13/afero"
@@ -95,7 +95,7 @@ func LoadConfig(d ConfigSourceDescriptor) (configs *Configs, err error) {
 	configs.Modules = moduleConfig.AllModules
 	configs.ModulesClient = modulesClient
 
-	if err := configs.Init(); err != nil {
+	if err := configs.Init(d.Logger); err != nil {
 		return nil, fmt.Errorf("failed to init config: %w", err)
 	}
 
@@ -220,8 +220,8 @@ func (l configLoader) applyOsEnvOverrides(environ []string) error {
 	var hugoEnv []types.KeyValueStr
 	for _, v := range environ {
 		key, val := config.SplitEnvVar(v)
-		if strings.HasPrefix(key, hugoEnvPrefix) {
-			delimiterAndKey := strings.TrimPrefix(key, hugoEnvPrefix)
+		if after, ok := strings.CutPrefix(key, hugoEnvPrefix); ok {
+			delimiterAndKey := after
 			if len(delimiterAndKey) < 2 {
 				continue
 			}

config/allconfig/load_test.go

@@ -58,7 +58,7 @@ weight = 4
 		Filename: configFilename,
 	}
 
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		_, err := LoadConfig(d)
 		if err != nil {
 			b.Fatal(err)

config/configLoader.go

@@ -1,4 +1,4 @@
-// Copyright 2018 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.
@@ -20,6 +20,7 @@ import (
 	"strings"
 
 	"github.com/gohugoio/hugo/common/herrors"
+	"github.com/gohugoio/hugo/parser"
 
 	"github.com/gohugoio/hugo/common/paths"
 
@@ -57,6 +58,7 @@ func IsValidConfigFilename(filename string) bool {
 	return validConfigFileExtensionsMap[ext]
 }
 
+// FromTOMLConfigString creates a config from the given TOML config. This is useful in tests.
 func FromTOMLConfigString(config string) Provider {
 	cfg, err := FromConfigString(config, "toml")
 	if err != nil {
@@ -65,6 +67,16 @@ func FromTOMLConfigString(config string) Provider {
 	return cfg
 }
 
+// FromMapToTOMLString converts the given map to a TOML string. This is useful in tests.
+func FromMapToTOMLString(v map[string]any) string {
+	var sb strings.Builder
+	err := parser.InterfaceToConfig(v, metadecoders.TOML, &sb)
+	if err != nil {
+		panic(err)
+	}
+	return sb.String()
+}
+
 // FromConfigString creates a config from the given YAML, JSON or TOML config. This is useful in tests.
 func FromConfigString(config, configType string) (Provider, error) {
 	m, err := readConfig(metadecoders.FormatFromString(configType), []byte(config))
@@ -218,7 +230,6 @@ func init() {
 		// Before 0.53 we used singular for "menu".
 		"{menu,languages/*/menu}", "menus",
 	)
-
 	if err != nil {
 		panic(err)
 	}

config/configProvider.go

@@ -20,15 +20,15 @@ import (
 	"github.com/gohugoio/hugo/common/paths"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/common/urls"
+	"github.com/gohugoio/hugo/hugolib/sitesmatrix"
 	"github.com/gohugoio/hugo/identity"
-	"github.com/gohugoio/hugo/langs"
 )
 
 // AllProvider is a sub set of all config settings.
 type AllProvider interface {
-	Language() *langs.Language
-	Languages() langs.Languages
-	LanguagesDefaultFirst() langs.Languages
+	Language() any
+	LanguageIndex() int
+	Languages() any
 	LanguagePrefix() string
 	BaseURL() urls.BaseURL
 	BaseURLLiveReload() urls.BaseURL
@@ -50,6 +50,11 @@ type AllProvider interface {
 	IsUglyURLs(section string) bool
 	DefaultContentLanguage() string
 	DefaultContentLanguageInSubdir() bool
+	DefaultContentRoleInSubdir() bool
+	DefaultContentVersionInSubdir() bool
+	DefaultContentsitesMatrix() *sitesmatrix.IntSets
+	AllSitesMatrix() *sitesmatrix.IntSets
+	IsKindEnabled(string) bool
 	IsLangDisabled(string) bool
 	SummaryLength() int
 	Pagination() Pagination
@@ -58,7 +63,7 @@ type AllProvider interface {
 	BuildDrafts() bool
 	Running() bool
 	Watching() bool
-	NewIdentityManager(name string, opts ...identity.ManagerOption) identity.Manager
+	NewIdentityManager(opts ...identity.ManagerOption) identity.Manager
 	FastRenderMode() bool
 	PrintUnusedTemplates() bool
 	EnableMissingTranslationPlaceholders() bool
@@ -73,6 +78,8 @@ type AllProvider interface {
 	IgnoredLogs() map[string]bool
 	WorkingDir() string
 	EnableEmoji() bool
+	ConfiguredDimensions() *sitesmatrix.ConfiguredDimensions
+	CacheDirMisc() string
 }
 
 // We cannot import the media package as that would create a circular dependency.
@@ -110,3 +117,6 @@ func GetStringSlicePreserveString(cfg Provider, key string) []string {
 	sd := cfg.Get(key)
 	return types.ToStringSlicePreserveString(sd)
 }
+
+/*func (cd ConfiguredDimensions) Language(v sitesmatrix.Vector) ConfiguredDimension {
+}*/

config/defaultConfigProvider.go

@@ -16,12 +16,10 @@ package config
 import (
 	"errors"
 	"fmt"
-	"slices"
+	"sort"
 	"strings"
 	"sync"
 
-	xmaps "maps"
-
 	"github.com/spf13/cast"
 
 	"github.com/gohugoio/hugo/common/maps"
@@ -239,7 +237,12 @@ func (c *defaultConfigProvider) Merge(k string, v any) {
 func (c *defaultConfigProvider) Keys() []string {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
-	return slices.Collect(xmaps.Keys(c.root))
+	var keys []string
+	for k := range c.root {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
 }
 
 func (c *defaultConfigProvider) WalkParams(walkFn func(params ...maps.KeyParams) bool) {

config/defaultConfigProvider_test.go

@@ -334,7 +334,6 @@ func TestDefaultConfigProvider(t *testing.T) {
 		}
 
 		for i := range 20 {
-			i := i
 			r.Run(func() error {
 				const v = 42
 				k := fmt.Sprintf("k%d", i)
@@ -478,7 +477,7 @@ func BenchmarkDefaultConfigProvider(b *testing.B) {
 
 	b.Run("Custom", func(b *testing.B) {
 		cfg := New()
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			runMethods(b, cfg)
 		}
 	})

config/privacy/privacyConfig.go

@@ -30,7 +30,7 @@ type Config struct {
 	Disqus          Disqus
 	GoogleAnalytics GoogleAnalytics
 	Instagram       Instagram
-	Twitter         Twitter // deprecated in favor of X in v0.141.0
+	Twitter         Twitter `json:"-"` // deprecated in favor of X in v0.141.0
 	Vimeo           Vimeo
 	YouTube         YouTube
 	X               X
@@ -112,12 +112,8 @@ type X struct {
 
 // DecodeConfig creates a privacy Config from a given Hugo configuration.
 func DecodeConfig(cfg config.Provider) (pc Config, err error) {
-	if !cfg.IsSet(privacyConfigKey) {
-		return
-	}
-
+	pc.GoogleAnalytics.RespectDoNotTrack = true
 	m := cfg.GetStringMap(privacyConfigKey)
-
 	err = mapstructure.WeakDecode(m, &pc)
 
 	return

config/services/servicesConfig.go

@@ -26,12 +26,12 @@ const (
 	rssLimitKey        = "rssLimit"
 )
 
-// Config is a privacy configuration for all the relevant services in Hugo.
+// Config is a services configuration for all the relevant services in Hugo.
 type Config struct {
 	Disqus          Disqus
 	GoogleAnalytics GoogleAnalytics
-	Instagram       Instagram
-	Twitter         Twitter // deprecated in favor of X in v0.141.0
+	Instagram       Instagram `json:"-"` // the embedded instagram shortcode no longer uses this
+	Twitter         Twitter   `json:"-"` // deprecated in favor of X in v0.141.0
 	X               X
 	RSS             RSS
 }
@@ -53,12 +53,12 @@ type Instagram struct {
 	// The Simple variant of the Instagram is decorated with Bootstrap 4 card classes.
 	// This means that if you use Bootstrap 4 or want to provide your own CSS, you want
 	// to disable the inline CSS provided by Hugo.
-	DisableInlineCSS bool
+	DisableInlineCSS bool // this is no longer used by the embedded instagram shortcode
 
 	// App or Client Access Token.
 	// If you are using a Client Access Token, remember that you must combine it with your App ID
 	// using a pipe symbol (<APPID>|<CLIENTTOKEN>) otherwise the request will fail.
-	AccessToken string
+	AccessToken string // this is no longer used by the embedded instagram shortcode
 }
 
 // Twitter holds the functional configuration settings related to the Twitter shortcodes.

create/content.go

@@ -16,6 +16,7 @@ package create
 
 import (
 	"bytes"
+	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -23,11 +24,9 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/gohugoio/hugo/hugofs/glob"
-
 	"github.com/gohugoio/hugo/common/hexec"
-	"github.com/gohugoio/hugo/common/hstrings"
 	"github.com/gohugoio/hugo/common/paths"
+	"github.com/gohugoio/hugo/hugofs/hglob"
 
 	"github.com/gohugoio/hugo/hugofs"
 
@@ -159,10 +158,10 @@ func (b *contentBuilder) buildDir() error {
 		contentTargetFilenames = append(contentTargetFilenames, abs)
 	}
 
-	var contentInclusionFilter *glob.FilenameFilter
+	var contentInclusionFilter *hglob.FilenameFilter
 	if !b.dirMap.siteUsed {
 		// We don't need to build everything.
-		contentInclusionFilter = glob.NewFilenameFilterForInclusionFunc(func(filename string) bool {
+		contentInclusionFilter = hglob.NewFilenameFilterForInclusionFunc(func(filename string) bool {
 			filename = strings.TrimPrefix(filename, string(os.PathSeparator))
 			for _, cn := range contentTargetFilenames {
 				if strings.Contains(cn, filename) {
@@ -228,10 +227,10 @@ func (b *contentBuilder) buildFile() (string, error) {
 		return "", err
 	}
 
-	var contentInclusionFilter *glob.FilenameFilter
+	var contentInclusionFilter *hglob.FilenameFilter
 	if !usesSite {
 		// We don't need to build everything.
-		contentInclusionFilter = glob.NewFilenameFilterForInclusionFunc(func(filename string) bool {
+		contentInclusionFilter = hglob.NewFilenameFilterForInclusionFunc(func(filename string) bool {
 			filename = strings.TrimPrefix(filename, string(os.PathSeparator))
 			return strings.Contains(contentPlaceholderAbsFilename, filename)
 		})
@@ -291,9 +290,7 @@ func (b *contentBuilder) applyArcheType(contentFilename string, archetypeFi hugo
 func (b *contentBuilder) mapArcheTypeDir() error {
 	var m archetypeMap
 
-	seen := map[hstrings.Strings2]bool{}
-
-	walkFn := func(path string, fim hugofs.FileMetaInfo) error {
+	walkFn := func(ctx context.Context, path string, fim hugofs.FileMetaInfo) error {
 		if fim.IsDir() {
 			return nil
 		}
@@ -301,15 +298,6 @@ func (b *contentBuilder) mapArcheTypeDir() error {
 		pi := fim.Meta().PathInfo
 
 		if pi.IsContent() {
-			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
-				// for archetype folders these are ambiguous and we need to
-				// fail.
-				return fmt.Errorf("duplicate content file found in archetype folder: %q; having both e.g. %s.md and %s.html is ambigous", path, pi.BaseNameNoIdentifier(), pi.BaseNameNoIdentifier())
-			}
-			seen[pathLang] = true
 			m.contentFiles = append(m.contentFiles, fim)
 			if !m.siteUsed {
 				var err error

create/content_test.go

@@ -74,7 +74,6 @@ func TestNewContentFromFile(t *testing.T) {
 	c := qt.New(t)
 
 	for i, cas := range cases {
-		cas := cas
 
 		c.Run(cas.name, func(c *qt.C) {
 			c.Parallel()
@@ -136,23 +135,27 @@ site RegularPages: {{ len site.RegularPages  }}
 	cfg, fs := newTestCfg(c, mm)
 
 	conf := testconfig.GetTestConfigs(fs.Source, cfg)
-	h, err := hugolib.NewHugoSites(deps.DepsCfg{Configs: conf, Fs: fs})
-	c.Assert(err, qt.IsNil)
-	c.Assert(len(h.Sites), qt.Equals, 2)
 
-	c.Assert(create.NewContent(h, "my-bundle", "post/my-post", false), qt.IsNil)
+	h := func() *hugolib.HugoSites {
+		h, err := hugolib.NewHugoSites(deps.DepsCfg{Configs: conf, Fs: fs})
+		c.Assert(err, qt.IsNil)
+		c.Assert(len(h.Sites), qt.Equals, 2)
+		return h
+	}
+
+	c.Assert(create.NewContent(h(), "my-bundle", "post/my-post", false), qt.IsNil)
 	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post/index.md")), `site RegularPages: 10`)
 
 	// Default bundle archetype
-	c.Assert(create.NewContent(h, "", "post/my-post2", false), qt.IsNil)
+	c.Assert(create.NewContent(h(), "", "post/my-post2", false), qt.IsNil)
 	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-post2/index.md")), `default archetype index.md`)
 
 	// Regular file with bundle kind.
-	c.Assert(create.NewContent(h, "my-bundle", "post/foo.md", false), qt.IsNil)
+	c.Assert(create.NewContent(h(), "my-bundle", "post/foo.md", false), qt.IsNil)
 	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/foo.md")), `draft: true`)
 
 	// Regular files should fall back to the default archetype (we have no regular file archetype).
-	c.Assert(create.NewContent(h, "my-bundle", "mypage.md", false), qt.IsNil)
+	c.Assert(create.NewContent(h(), "my-bundle", "mypage.md", false), qt.IsNil)
 	cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "mypage.md")), `draft: true`)
 }
 

deploy/deployconfig/deployConfig.go

@@ -20,7 +20,7 @@ import (
 
 	"github.com/gobwas/glob"
 	"github.com/gohugoio/hugo/config"
-	hglob "github.com/gohugoio/hugo/hugofs/glob"
+	hglob "github.com/gohugoio/hugo/hugofs/hglob"
 	"github.com/mitchellh/mapstructure"
 )
 

deps/deps.go

@@ -217,14 +217,14 @@ func (d *Deps) Init() error {
 			[]byte(tpl.HugoDeferredTemplatePrefix),
 			[]byte(postpub.PostProcessPrefix))
 
-		pathSpec, err := helpers.NewPathSpec(d.Fs, d.Conf, d.Log)
+		pathSpec, err := helpers.NewPathSpec(d.Fs, d.Conf, d.Log, nil)
 		if err != nil {
 			return err
 		}
 		d.PathSpec = pathSpec
 	} else {
 		var err error
-		d.PathSpec, err = helpers.NewPathSpecWithBaseBaseFsProvided(d.Fs, d.Conf, d.Log, d.PathSpec.BaseFs)
+		d.PathSpec, err = helpers.NewPathSpec(d.Fs, d.Conf, d.Log, d.PathSpec.BaseFs)
 		if err != nil {
 			return err
 		}
@@ -417,6 +417,9 @@ type DepsCfg struct {
 	// i18n handling.
 	TranslationProvider ResourceProvider
 
+	// Build triggered by the IntegrationTest framework.
+	IsIntegrationTest bool
+
 	// ChangesFromBuild for changes passed back to the server/watch process.
 	ChangesFromBuild chan []identity.Identity
 }

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

@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v3

docs/.github/workflows/markdownlint.yml

@@ -7,9 +7,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v5
+      uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
     - name: Run Markdown linter
-      uses: DavidAnson/markdownlint-cli2-action@v20
+      uses: DavidAnson/markdownlint-cli2-action@30a0e04f1870d58f8d717450cc6134995f993c63 # v21.0.0
       with:
         globs: # set to null to override default of *.{md,markdown}
       continue-on-error: false

docs/.github/workflows/spellcheck.yml

@@ -12,13 +12,13 @@ jobs:
   spellcheck:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
-      - uses: streetsidesoftware/cspell-action@v7
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+      - uses: streetsidesoftware/cspell-action@3294df585d3d639e30f3bc019cb11940b9866e95 # v8.0.0
         with:
           incremental_files_only: true
           strict: true
           # cspell uses the .cspell.json configuration file
-      - uses: codespell-project/actions-codespell@v2
+      - uses: codespell-project/actions-codespell@8f01853be192eb0f849a5c7d721450e7a467c579 # v2.2
         with:
           check_filenames: true
           check_hidden: true

docs/.github/workflows/stale.yml

@@ -13,7 +13,7 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
         with:
           days-before-stale: 90 # default is 60
           days-before-close: 14 # default is 7

go.mod

@@ -2,11 +2,10 @@ module github.com/gohugoio/hugo
 
 require (
 	github.com/BurntSushi/locker v0.0.0-20171006230638-a6e239ea1c69
-	github.com/JohannesKaufmann/html-to-markdown/v2 v2.4.0
+	github.com/JohannesKaufmann/html-to-markdown/v2 v2.5.0
 	github.com/alecthomas/chroma/v2 v2.20.0
-	github.com/armon/go-radix v1.0.1-0.20221118154546-54df44f2176c
-	github.com/aws/aws-sdk-go-v2 v1.39.2
-	github.com/aws/aws-sdk-go-v2/service/cloudfront v1.54.4
+	github.com/aws/aws-sdk-go-v2 v1.40.1
+	github.com/aws/aws-sdk-go-v2/service/cloudfront v1.58.2
 	github.com/bep/clocks v0.5.0
 	github.com/bep/debounce v1.2.0
 	github.com/bep/gitmap v1.9.0
@@ -23,11 +22,12 @@ require (
 	github.com/bep/overlayfs v0.10.0
 	github.com/bep/simplecobra v0.6.1
 	github.com/bep/tmc v0.5.1
+	github.com/bits-and-blooms/bitset v1.24.4
 	github.com/cespare/xxhash/v2 v2.3.0
 	github.com/clbanning/mxj/v2 v2.7.0
 	github.com/disintegration/gift v1.2.1
 	github.com/dustin/go-humanize v1.0.1
-	github.com/evanw/esbuild v0.25.11
+	github.com/evanw/esbuild v0.27.1
 	github.com/fatih/color v1.18.0
 	github.com/fortytw2/leaktest v1.3.0
 	github.com/frankban/quicktest v1.14.6
@@ -35,15 +35,15 @@ require (
 	github.com/getkin/kin-openapi v0.133.0
 	github.com/gobuffalo/flect v1.0.3
 	github.com/gobwas/glob v0.2.3
-	github.com/goccy/go-yaml v1.18.0
+	github.com/goccy/go-yaml v1.19.0
 	github.com/gohugoio/go-i18n/v2 v2.1.3-0.20251018145728-cfcc22d823c6
+	github.com/gohugoio/go-radix v1.2.0
 	github.com/gohugoio/hashstructure v0.6.0
 	github.com/gohugoio/httpcache v0.8.0
 	github.com/gohugoio/hugo-goldmark-extensions/extras v0.5.0
 	github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.3.1
 	github.com/gohugoio/locales v0.14.0
 	github.com/gohugoio/localescompressed v1.0.1
-	github.com/gohugoio/testmodBuilder/mods v0.0.0-20190520184928-c56af20f2e95
 	github.com/google/go-cmp v0.7.0
 	github.com/gorilla/websocket v1.5.3
 	github.com/hairyhenderson/go-codeowners v0.7.0
@@ -57,43 +57,42 @@ require (
 	github.com/mitchellh/mapstructure v1.5.1-0.20231216201459-8508981c8b6c
 	github.com/muesli/smartcrop v0.3.0
 	github.com/niklasfasching/go-org v1.9.1
-	github.com/olekukonko/tablewriter v1.1.0
+	github.com/olekukonko/tablewriter v1.1.2
 	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58
 	github.com/pelletier/go-toml/v2 v2.2.4
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
 	github.com/rogpeppe/go-internal v1.14.1
-	github.com/sanity-io/litter v1.5.8
 	github.com/spf13/afero v1.15.0
 	github.com/spf13/cast v1.10.0
-	github.com/spf13/cobra v1.9.1
+	github.com/spf13/cobra v1.10.2
 	github.com/spf13/fsync v0.10.1
-	github.com/spf13/pflag v1.0.7
-	github.com/tdewolff/minify/v2 v2.24.5
-	github.com/tdewolff/parse/v2 v2.8.5-0.20251020133559-0efcf90bef1a
-	github.com/tetratelabs/wazero v1.9.0
+	github.com/spf13/pflag v1.0.9
+	github.com/tdewolff/minify/v2 v2.24.8
+	github.com/tdewolff/parse/v2 v2.8.5
+	github.com/tetratelabs/wazero v1.10.1
 	github.com/yuin/goldmark v1.7.13
 	github.com/yuin/goldmark-emoji v1.0.6
 	go.uber.org/automaxprocs v1.5.3
-	gocloud.dev v0.43.0
-	golang.org/x/image v0.32.0
-	golang.org/x/mod v0.29.0
-	golang.org/x/net v0.46.0
-	golang.org/x/sync v0.17.0
-	golang.org/x/text v0.30.0
-	golang.org/x/tools v0.38.0
-	google.golang.org/api v0.251.0
+	gocloud.dev v0.44.0
+	golang.org/x/image v0.34.0
+	golang.org/x/mod v0.31.0
+	golang.org/x/net v0.48.0
+	golang.org/x/sync v0.19.0
+	golang.org/x/text v0.32.0
+	golang.org/x/tools v0.40.0
+	google.golang.org/api v0.255.0
 	rsc.io/qr v0.2.0
 )
 
 require (
 	cel.dev/expr v0.24.0 // indirect
-	cloud.google.com/go v0.121.4 // indirect
-	cloud.google.com/go/auth v0.16.5 // indirect
+	cloud.google.com/go v0.121.6 // indirect
+	cloud.google.com/go/auth v0.17.0 // indirect
 	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
 	cloud.google.com/go/compute/metadata v0.9.0 // indirect
 	cloud.google.com/go/iam v1.5.2 // indirect
 	cloud.google.com/go/monitoring v1.24.2 // indirect
-	cloud.google.com/go/storage v1.55.0 // indirect
+	cloud.google.com/go/storage v1.56.0 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.1 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.10.1 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1 // indirect
@@ -105,33 +104,35 @@ require (
 	github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0 // indirect
 	github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0 // indirect
 	github.com/JohannesKaufmann/dom v0.2.0 // indirect
-	github.com/aws/aws-sdk-go v1.55.7 // indirect
-	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.11 // indirect
-	github.com/aws/aws-sdk-go-v2/config v1.29.17 // indirect
-	github.com/aws/aws-sdk-go-v2/credentials v1.17.70 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.84 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.9 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.9 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.36 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.4 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.17 // indirect
-	github.com/aws/aws-sdk-go-v2/service/s3 v1.84.0 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sso v1.25.5 // indirect
-	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.34.0 // indirect
-	github.com/aws/smithy-go v1.23.0 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.3 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.31.17 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.18.21 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.13 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.20.3 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.15 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.15 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.13 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.13 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.13 // indirect
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.89.2 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.30.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.5 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.39.1 // indirect
+	github.com/aws/smithy-go v1.24.0 // indirect
 	github.com/aymerick/douceur v0.2.0 // indirect
+	github.com/clipperhouse/displaywidth v0.6.0 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
 	github.com/cncf/xds/go v0.0.0-20250501225837-2ac532fd4443 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
 	github.com/dlclark/regexp2 v1.11.5 // indirect
 	github.com/envoyproxy/go-control-plane/envoy v1.32.4 // indirect
 	github.com/envoyproxy/protoc-gen-validate v1.2.1 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/go-jose/go-jose/v4 v4.1.1 // indirect
+	github.com/go-jose/go-jose/v4 v4.1.2 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-openapi/jsonpointer v0.21.0 // indirect
@@ -139,30 +140,29 @@ require (
 	github.com/golang-jwt/jwt/v5 v5.2.3 // indirect
 	github.com/google/s2a-go v0.1.9 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/google/wire v0.6.0 // indirect
+	github.com/google/wire v0.7.0 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.6 // indirect
 	github.com/googleapis/gax-go/v2 v2.15.0 // indirect
 	github.com/gorilla/css v1.0.1 // indirect
 	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
 	github.com/kylelemons/godebug v1.1.0 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/mattn/go-runewidth v0.0.19 // indirect
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
 	github.com/oasdiff/yaml v0.0.0-20250309154309-f31be36b4037 // indirect
 	github.com/oasdiff/yaml3 v0.0.0-20250309153720-d2182401db90 // indirect
+	github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
-	github.com/olekukonko/ll v0.0.9 // indirect
+	github.com/olekukonko/ll v0.1.3 // indirect
 	github.com/perimeterx/marshmallow v1.1.5 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/spiffe/go-spiffe/v2 v2.5.0 // indirect
 	github.com/woodsbury/decimal128 v1.3.0 // indirect
@@ -176,16 +176,17 @@ require (
 	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
 	go.opentelemetry.io/otel/sdk/metric v1.37.0 // indirect
 	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/crypto v0.43.0 // indirect
-	golang.org/x/oauth2 v0.31.0 // indirect
-	golang.org/x/sys v0.37.0 // indirect
-	golang.org/x/time v0.13.0 // indirect
+	go.yaml.in/yaml/v3 v3.0.4 // indirect
+	golang.org/x/crypto v0.46.0 // indirect
+	golang.org/x/oauth2 v0.32.0 // indirect
+	golang.org/x/sys v0.39.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
 	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
 	google.golang.org/genproto v0.0.0-20250715232539-7130f93afb79 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20250715232539-7130f93afb79 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 // indirect
-	google.golang.org/grpc v1.75.1 // indirect
-	google.golang.org/protobuf v1.36.9 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250818200422-3122310a409c // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda // indirect
+	google.golang.org/grpc v1.76.0 // indirect
+	google.golang.org/protobuf v1.36.10 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	howett.net/plist v1.0.0 // indirect

go.sum

@@ -19,10 +19,10 @@ cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHOb
 cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
 cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
 cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY=
-cloud.google.com/go v0.121.4 h1:cVvUiY0sX0xwyxPwdSU2KsF9knOVmtRyAMt8xou0iTs=
-cloud.google.com/go v0.121.4/go.mod h1:XEBchUiHFJbz4lKBZwYBDHV/rSyfFktk737TLDU089s=
-cloud.google.com/go/auth v0.16.5 h1:mFWNQ2FEVWAliEQWpAdH80omXFokmrnbDhUS9cBywsI=
-cloud.google.com/go/auth v0.16.5/go.mod h1:utzRfHMP+Vv0mpOkTRQoWD2q3BatTOoWbA7gCc2dUhQ=
+cloud.google.com/go v0.121.6 h1:waZiuajrI28iAf40cWgycWNgaXPO06dupuS+sgibK6c=
+cloud.google.com/go v0.121.6/go.mod h1:coChdst4Ea5vUpiALcYKXEpR1S9ZgXbhEzzMcMR66vI=
+cloud.google.com/go/auth v0.17.0 h1:74yCm7hCj2rUyyAocqnFzsAYXgJhrG26XCFimrc/Kz4=
+cloud.google.com/go/auth v0.17.0/go.mod h1:6wv/t5/6rOPAX4fJiRjKkJCvswLwdet7G8+UGXt7nCQ=
 cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc=
 cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c=
 cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
@@ -53,8 +53,8 @@ cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohl
 cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
 cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
 cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo=
-cloud.google.com/go/storage v1.55.0 h1:NESjdAToN9u1tmhVqhXCaCwYBuvEhZLLv0gBr+2znf0=
-cloud.google.com/go/storage v1.55.0/go.mod h1:ztSmTTwzsdXe5syLVS0YsbFxXuvEmEyZj7v7zChEmuY=
+cloud.google.com/go/storage v1.56.0 h1:iixmq2Fse2tqxMbWhLWC9HfBj1qdxqAmiK8/eqtsLxI=
+cloud.google.com/go/storage v1.56.0/go.mod h1:Tpuj6t4NweCLzlNbw9Z9iwxEkrSem20AetIeH/shgVU=
 cloud.google.com/go/trace v1.11.6 h1:2O2zjPzqPYAHrn3OKl029qlqG6W8ZdYaOWRyr8NgMT4=
 cloud.google.com/go/trace v1.11.6/go.mod h1:GA855OeDEBiBMzcckLPE2kDunIpC72N+Pq8WFieFjnI=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
@@ -94,58 +94,54 @@ github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapp
 github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0/go.mod h1:cSgYe11MCNYunTnRXrKiR/tHc0eoKjICUuWpNZoVCOo=
 github.com/JohannesKaufmann/dom v0.2.0 h1:1bragmEb19K8lHAqgFgqCpiPCFEZMTXzOIEjuxkUfLQ=
 github.com/JohannesKaufmann/dom v0.2.0/go.mod h1:57iSUl5RKric4bUkgos4zu6Xt5LMHUnw3TF1l5CbGZo=
-github.com/JohannesKaufmann/html-to-markdown/v2 v2.4.0 h1:C0/TerKdQX9Y9pbYi1EsLr5LDNANsqunyI/btpyfCg8=
-github.com/JohannesKaufmann/html-to-markdown/v2 v2.4.0/go.mod h1:OLaKh+giepO8j7teevrNwiy/fwf8LXgoc9g7rwaE1jk=
+github.com/JohannesKaufmann/html-to-markdown/v2 v2.5.0 h1:mklaPbT4f/EiDr1Q+zPrEt9lgKAkVrIBtWf33d9GpVA=
+github.com/JohannesKaufmann/html-to-markdown/v2 v2.5.0/go.mod h1:D56Cl9r8M5i3UwAchE+LlLc5hPN3kJtdZNVJn06lSHU=
 github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
 github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
 github.com/alecthomas/chroma/v2 v2.20.0 h1:sfIHpxPyR07/Oylvmcai3X/exDlE8+FA820NTz+9sGw=
 github.com/alecthomas/chroma/v2 v2.20.0/go.mod h1:e7tViK0xh/Nf4BYHl00ycY6rV7b8iXBksI9E359yNmA=
 github.com/alecthomas/repr v0.5.1 h1:E3G4t2QbHTSNpPKBgMTln5KLkZHLOcU7r37J4pXBuIg=
 github.com/alecthomas/repr v0.5.1/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/armon/go-radix v1.0.1-0.20221118154546-54df44f2176c h1:651/eoCRnQ7YtSjAnSzRucrJz+3iGEFt+ysraELS81M=
-github.com/armon/go-radix v1.0.1-0.20221118154546-54df44f2176c/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
-github.com/aws/aws-sdk-go v1.55.7 h1:UJrkFq7es5CShfBwlWAC8DA077vp8PyVbQd3lqLiztE=
-github.com/aws/aws-sdk-go v1.55.7/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
-github.com/aws/aws-sdk-go-v2 v1.39.2 h1:EJLg8IdbzgeD7xgvZ+I8M1e0fL0ptn/M47lianzth0I=
-github.com/aws/aws-sdk-go-v2 v1.39.2/go.mod h1:sDioUELIUO9Znk23YVmIk86/9DOpkbyyVb1i/gUNFXY=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.11 h1:12SpdwU8Djs+YGklkinSSlcrPyj3H4VifVsKf78KbwA=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.11/go.mod h1:dd+Lkp6YmMryke+qxW/VnKyhMBDTYP41Q2Bb+6gNZgY=
-github.com/aws/aws-sdk-go-v2/config v1.29.17 h1:jSuiQ5jEe4SAMH6lLRMY9OVC+TqJLP5655pBGjmnjr0=
-github.com/aws/aws-sdk-go-v2/config v1.29.17/go.mod h1:9P4wwACpbeXs9Pm9w1QTh6BwWwJjwYvJ1iCt5QbCXh8=
-github.com/aws/aws-sdk-go-v2/credentials v1.17.70 h1:ONnH5CM16RTXRkS8Z1qg7/s2eDOhHhaXVd72mmyv4/0=
-github.com/aws/aws-sdk-go-v2/credentials v1.17.70/go.mod h1:M+lWhhmomVGgtuPOhO85u4pEa3SmssPTdcYpP/5J/xc=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32 h1:KAXP9JSHO1vKGCr5f4O6WmlVKLFFXgWYAGoJosorxzU=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32/go.mod h1:h4Sg6FQdexC1yYG9RDnOvLbW1a/P986++/Y/a+GyEM8=
-github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.84 h1:cTXRdLkpBanlDwISl+5chq5ui1d1YWg4PWMR9c3kXyw=
-github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.84/go.mod h1:kwSy5X7tfIHN39uucmjQVs2LvDdXEjQucgQQEqCggEo=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.9 h1:se2vOWGD3dWQUtfn4wEjRQJb1HK1XsNIt825gskZ970=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.9/go.mod h1:hijCGH2VfbZQxqCDN7bwz/4dzxV+hkyhjawAtdPWKZA=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.9 h1:6RBnKZLkJM4hQ+kN6E7yWFveOTg8NLPHAkqrs4ZPlTU=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.9/go.mod h1:V9rQKRmK7AWuEsOMnHzKj8WyrIir1yUJbZxDuZLFvXI=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.36 h1:GMYy2EOWfzdP3wfVAGXBNKY5vK4K8vMET4sYOYltmqs=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.36/go.mod h1:gDhdAV6wL3PmPqBhiPbnlS447GoWs8HTTOYef9/9Inw=
-github.com/aws/aws-sdk-go-v2/service/cloudfront v1.54.4 h1:tVpbQcr1A0c+VTqtKEN9vfB0qer2SjfxX3LYojSGUq0=
-github.com/aws/aws-sdk-go-v2/service/cloudfront v1.54.4/go.mod h1:dYwFVhUsRZt7COcGP23ei0lY8gX8ZSHrbyX49VB93MA=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4 h1:CXV68E2dNqhuynZJPB80bhPQwAKqBWVer887figW6Jc=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4/go.mod h1:/xFi9KtvBXP97ppCz1TAEvU1Uf66qvid89rbem3wCzQ=
-github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.4 h1:nAP2GYbfh8dd2zGZqFRSMlq+/F6cMPBUuCsGAMkN074=
-github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.7.4/go.mod h1:LT10DsiGjLWh4GbjInf9LQejkYEhBgBCjLG5+lvk4EE=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17 h1:t0E6FzREdtCsiLIoLCWsYliNsRBgyGD/MCK571qk4MI=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17/go.mod h1:ygpklyoaypuyDvOM5ujWGrYWpAK3h7ugnmKCU/76Ys4=
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.17 h1:qcLWgdhq45sDM9na4cvXax9dyLitn8EYBRl8Ak4XtG4=
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.17/go.mod h1:M+jkjBFZ2J6DJrjMv2+vkBbuht6kxJYtJiwoVgX4p4U=
-github.com/aws/aws-sdk-go-v2/service/s3 v1.84.0 h1:0reDqfEN+tB+sozj2r92Bep8MEwBZgtAXTND1Kk9OXg=
-github.com/aws/aws-sdk-go-v2/service/s3 v1.84.0/go.mod h1:kUklwasNoCn5YpyAqC/97r6dzTA1SRKJfKq16SXeoDU=
-github.com/aws/aws-sdk-go-v2/service/sso v1.25.5 h1:AIRJ3lfb2w/1/8wOOSqYb9fUKGwQbtysJ2H1MofRUPg=
-github.com/aws/aws-sdk-go-v2/service/sso v1.25.5/go.mod h1:b7SiVprpU+iGazDUqvRSLf5XmCdn+JtT1on7uNL6Ipc=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3 h1:BpOxT3yhLwSJ77qIY3DoHAQjZsc4HEGfMCE4NGy3uFg=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3/go.mod h1:vq/GQR1gOFLquZMSrxUK/cpvKCNVYibNyJ1m7JrU88E=
-github.com/aws/aws-sdk-go-v2/service/sts v1.34.0 h1:NFOJ/NXEGV4Rq//71Hs1jC/NvPs1ezajK+yQmkwnPV0=
-github.com/aws/aws-sdk-go-v2/service/sts v1.34.0/go.mod h1:7ph2tGpfQvwzgistp2+zga9f+bCjlQJPkPUmMgDSD7w=
-github.com/aws/smithy-go v1.23.0 h1:8n6I3gXzWJB2DxBDnfxgBaSX6oe0d/t10qGz7OKqMCE=
-github.com/aws/smithy-go v1.23.0/go.mod h1:t1ufH5HMublsJYulve2RKmHDC15xu1f26kHCp/HgceI=
+github.com/aws/aws-sdk-go-v2 v1.40.1 h1:difXb4maDZkRH0x//Qkwcfpdg1XQVXEAEs2DdXldFFc=
+github.com/aws/aws-sdk-go-v2 v1.40.1/go.mod h1:MayyLB8y+buD9hZqkCW3kX1AKq07Y5pXxtgB+rRFhz0=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.3 h1:DHctwEM8P8iTXFxC/QK0MRjwEpWQeM9yzidCRjldUz0=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.3/go.mod h1:xdCzcZEtnSTKVDOmUZs4l/j3pSV6rpo1WXl5ugNsL8Y=
+github.com/aws/aws-sdk-go-v2/config v1.31.17 h1:QFl8lL6RgakNK86vusim14P2k8BFSxjvUkcWLDjgz9Y=
+github.com/aws/aws-sdk-go-v2/config v1.31.17/go.mod h1:V8P7ILjp/Uef/aX8TjGk6OHZN6IKPM5YW6S78QnRD5c=
+github.com/aws/aws-sdk-go-v2/credentials v1.18.21 h1:56HGpsgnmD+2/KpG0ikvvR8+3v3COCwaF4r+oWwOeNA=
+github.com/aws/aws-sdk-go-v2/credentials v1.18.21/go.mod h1:3YELwedmQbw7cXNaII2Wywd+YY58AmLPwX4LzARgmmA=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.13 h1:T1brd5dR3/fzNFAQch/iBKeX07/ffu/cLu+q+RuzEWk=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.13/go.mod h1:Peg/GBAQ6JDt+RoBf4meB1wylmAipb7Kg2ZFakZTlwk=
+github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.20.3 h1:4GNV1lhyELGjMz5ILMRxDvxvOaeo3Ux9Z69S1EgVMMQ=
+github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.20.3/go.mod h1:br7KA6edAAqDGUYJ+zVVPAyMrPhnN+zdt17yTUT6FPw=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.15 h1:Y5YXgygXwDI5P4RkteB5yF7v35neH7LfJKBG+hzIons=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.15/go.mod h1:K+/1EpG42dFSY7CBj+Fruzm8PsCGWTXJ3jdeJ659oGQ=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.15 h1:AvltKnW9ewxX2hFmQS0FyJH93aSvJVUEFvXfU+HWtSE=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.15/go.mod h1:3I4oCdZdmgrREhU74qS1dK9yZ62yumob+58AbFR4cQA=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4 h1:WKuaxf++XKWlHWu9ECbMlha8WOEGm0OUEZqm4K/Gcfk=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4/go.mod h1:ZWy7j6v1vWGmPReu0iSGvRiise4YI5SkR3OHKTZ6Wuc=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.13 h1:eg/WYAa12vqTphzIdWMzqYRVKKnCboVPRlvaybNCqPA=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.13/go.mod h1:/FDdxWhz1486obGrKKC1HONd7krpk38LBt+dutLcN9k=
+github.com/aws/aws-sdk-go-v2/service/cloudfront v1.58.2 h1:Sm/sQAe/54oCaXj5/xOtMkMvpDafNZhQ38DsyarIBR0=
+github.com/aws/aws-sdk-go-v2/service/cloudfront v1.58.2/go.mod h1:SxEwhpfvzjK0vR8LfHeOkHeIcpaFU5ZgVbuBo3J4w2A=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.3 h1:x2Ibm/Af8Fi+BH+Hsn9TXGdT+hKbDd5XOTZxTMxDk7o=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.3/go.mod h1:IW1jwyrQgMdhisceG8fQLmQIydcT/jWY21rFhzgaKwo=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.4 h1:NvMjwvv8hpGUILarKw7Z4Q0w1H9anXKsesMxtw++MA4=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.4/go.mod h1:455WPHSwaGj2waRSpQp7TsnpOnBfw8iDfPfbwl7KPJE=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.13 h1:kDqdFvMY4AtKoACfzIGD8A0+hbT41KTKF//gq7jITfM=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.13/go.mod h1:lmKuogqSU3HzQCwZ9ZtcqOc5XGMqtDK7OIc2+DxiUEg=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.13 h1:zhBJXdhWIFZ1acfDYIhu4+LCzdUS2Vbcum7D01dXlHQ=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.13/go.mod h1:JaaOeCE368qn2Hzi3sEzY6FgAZVCIYcC2nwbro2QCh8=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.89.2 h1:xgBWsgaeUESl8A8k80p6yBdexMWDVeiDmJ/pkjohJ7c=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.89.2/go.mod h1:+wArOOrcHUevqdto9k1tKOF5++YTe9JEcPSc9Tx2ZSw=
+github.com/aws/aws-sdk-go-v2/service/sso v1.30.1 h1:0JPwLz1J+5lEOfy/g0SURC9cxhbQ1lIMHMa+AHZSzz0=
+github.com/aws/aws-sdk-go-v2/service/sso v1.30.1/go.mod h1:fKvyjJcz63iL/ftA6RaM8sRCtN4r4zl4tjL3qw5ec7k=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.5 h1:OWs0/j2UYR5LOGi88sD5/lhN6TDLG6SfA7CqsQO9zF0=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.5/go.mod h1:klO+ejMvYsB4QATfEOIXk8WAEwN4N0aBfJpvC+5SZBo=
+github.com/aws/aws-sdk-go-v2/service/sts v1.39.1 h1:mLlUgHn02ue8whiR4BmxxGJLR2gwU6s6ZzJ5wDamBUs=
+github.com/aws/aws-sdk-go-v2/service/sts v1.39.1/go.mod h1:E19xDjpzPZC7LS2knI9E6BaRFDK43Eul7vd6rSq2HWk=
+github.com/aws/smithy-go v1.24.0 h1:LpilSUItNPFr1eY85RYgTIg5eIEPtvFbskaFcmmIUnk=
+github.com/aws/smithy-go v1.24.0/go.mod h1:LEj2LM3rBRQJxPZTB4KuzZkaZYnZPnvgIhb4pu07mx0=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
 github.com/bep/clocks v0.5.0 h1:hhvKVGLPQWRVsBP/UB7ErrHYIO42gINVbvqxvYTPVps=
@@ -182,6 +178,8 @@ github.com/bep/tmc v0.5.1 h1:CsQnSC6MsomH64gw0cT5f+EwQDcvZz4AazKunFwTpuI=
 github.com/bep/tmc v0.5.1/go.mod h1:tGYHN8fS85aJPhDLgXETVKp+PR382OvFi2+q2GkGsq0=
 github.com/bep/workers v1.0.0 h1:U+H8YmEaBCEaFZBst7GcRVEoqeRC9dzH2dWOwGmOchg=
 github.com/bep/workers v1.0.0/go.mod h1:7kIESOB86HfR2379pwoMWNy8B50D7r99fRLUyPSNyCs=
+github.com/bits-and-blooms/bitset v1.24.4 h1:95H15Og1clikBrKr/DuzMXkQzECs1M6hhoGXLwLQOZE=
+github.com/bits-and-blooms/bitset v1.24.4/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
@@ -191,6 +189,12 @@ github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMn
 github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
 github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/clipperhouse/displaywidth v0.6.0 h1:k32vueaksef9WIKCNcoqRNyKbyvkvkysNYnAWz2fN4s=
+github.com/clipperhouse/displaywidth v0.6.0/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o=
+github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
+github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
+github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4=
+github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
@@ -199,7 +203,6 @@ github.com/cncf/xds/go v0.0.0-20250501225837-2ac532fd4443/go.mod h1:W+zGtBO5Y1Ig
 github.com/cpuguy83/go-md2man/v2 v2.0.6 h1:XJtiaUW6dEEqVuZiMTn1ldk455QWwEIsMIJlo5vtkx0=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v0.0.0-20161028175848-04cdfd42973b/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
@@ -226,8 +229,8 @@ github.com/envoyproxy/go-control-plane/ratelimit v0.1.0/go.mod h1:Wk+tMFAFbCXaJP
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/envoyproxy/protoc-gen-validate v1.2.1 h1:DEo3O99U8j4hBFwbJfrz9VtgcDfUKS7KJ7spH3d86P8=
 github.com/envoyproxy/protoc-gen-validate v1.2.1/go.mod h1:d/C80l/jxXLdfEIhX1W2TmLfsJ31lvEjwamM4DxlWXU=
-github.com/evanw/esbuild v0.25.11 h1:NGtezc+xk+Mti4fgWaoD3dncZNCzcTA+r0BxMV3Koyw=
-github.com/evanw/esbuild v0.25.11/go.mod h1:D2vIQZqV/vIf/VRHtViaUtViZmG7o+kKmlBfVQuRi48=
+github.com/evanw/esbuild v0.27.1 h1:SkYgb1wrwJkJYwBp5hjmQGm3riUHbCdfViyEvjAA/KA=
+github.com/evanw/esbuild v0.27.1/go.mod h1:D2vIQZqV/vIf/VRHtViaUtViZmG7o+kKmlBfVQuRi48=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
@@ -246,8 +249,8 @@ github.com/getkin/kin-openapi v0.133.0/go.mod h1:boAciF6cXk5FhPqe/NQeBTeenbjqU4L
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-jose/go-jose/v4 v4.1.1 h1:JYhSgy4mXXzAdF3nUx3ygx347LRXJRrpgyU3adRmkAI=
-github.com/go-jose/go-jose/v4 v4.1.1/go.mod h1:BdsZGqgdO3b6tTc6LSE56wcDbMMLuPsw5d4ZD5f94kA=
+github.com/go-jose/go-jose/v4 v4.1.2 h1:TK/7NqRQZfgAh+Td8AlsrvtPoUyiHh0LqVvokh+1vHI=
+github.com/go-jose/go-jose/v4 v4.1.2/go.mod h1:22cg9HWM1pOlnRiY+9cQYJ9XHmya1bYW8OeDM6Ku6Oo=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
 github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
@@ -265,10 +268,12 @@ github.com/gobuffalo/flect v1.0.3 h1:xeWBM2nui+qnVvNM4S3foBhCAL2XgPU+a7FdpelbTq4
 github.com/gobuffalo/flect v1.0.3/go.mod h1:A5msMlrHtLqh9umBSnvabjsMrCcCpAyzglnDvkbYKHs=
 github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
 github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
-github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
-github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/goccy/go-yaml v1.19.0 h1:EmkZ9RIsX+Uq4DYFowegAuJo8+xdX3T/2dwNPXbxEYE=
+github.com/goccy/go-yaml v1.19.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 github.com/gohugoio/go-i18n/v2 v2.1.3-0.20251018145728-cfcc22d823c6 h1:pxlAea9eRwuAnt/zKbGqlFO2ZszpIe24YpOVLf+N+4I=
 github.com/gohugoio/go-i18n/v2 v2.1.3-0.20251018145728-cfcc22d823c6/go.mod h1:m5hu1im5Qc7LDycVLvee6MPobJiRLBYHklypFJR0/aE=
+github.com/gohugoio/go-radix v1.2.0 h1:D5GTk8jIoeXirBSc2P4E4NdHKDrenk9k9N0ctU5Yrhg=
+github.com/gohugoio/go-radix v1.2.0/go.mod h1:k6vDa0ebpbpgtzSj9lPGJcA4AZwJ9xUNObUy2vczPFM=
 github.com/gohugoio/hashstructure v0.6.0 h1:7wMB/2CfXoThFYhdWRGv3u3rUM761Cq29CxUW+NltUg=
 github.com/gohugoio/hashstructure v0.6.0/go.mod h1:lapVLk9XidheHG1IQ4ZSbyYrXcaILU1ZEP/+vno5rBQ=
 github.com/gohugoio/httpcache v0.8.0 h1:hNdsmGSELztetYCsPVgjA960zSa4dfEqqF/SficorCU=
@@ -281,8 +286,6 @@ github.com/gohugoio/locales v0.14.0 h1:Q0gpsZwfv7ATHMbcTNepFd59H7GoykzWJIxi113XG
 github.com/gohugoio/locales v0.14.0/go.mod h1:ip8cCAv/cnmVLzzXtiTpPwgJ4xhKZranqNqtoIu0b/4=
 github.com/gohugoio/localescompressed v1.0.1 h1:KTYMi8fCWYLswFyJAeOtuk/EkXR/KPTHHNN9OS+RTxo=
 github.com/gohugoio/localescompressed v1.0.1/go.mod h1:jBF6q8D7a0vaEmcWPNcAjUZLJaIVNiwvM3WlmTvooB0=
-github.com/gohugoio/testmodBuilder/mods v0.0.0-20190520184928-c56af20f2e95 h1:sgew0XCnZwnzpWxTt3V8LLiCO7OQi3C6dycaE67wfkU=
-github.com/gohugoio/testmodBuilder/mods v0.0.0-20190520184928-c56af20f2e95/go.mod h1:bOlVlCa1/RajcHpXkrUXPSHB/Re1UnlXxD1Qp8SKOd8=
 github.com/golang-jwt/jwt/v5 v5.2.3 h1:kkGXqQOBSDDWRhWNXTFpqGSCMyh/PLnqUvMGJPDJDs0=
 github.com/golang-jwt/jwt/v5 v5.2.3/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -350,12 +353,11 @@ github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLe
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0=
 github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM=
-github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/wire v0.6.0 h1:HBkoIh4BdSxoyo9PveV8giw7ZsaBOvzWKfcg/6MrVwI=
-github.com/google/wire v0.6.0/go.mod h1:F4QhpQ9EDIdJ1Mbop/NZBRB+5yrR6qg3BnctaoUk6NA=
+github.com/google/wire v0.7.0 h1:JxUKI6+CVBgCO2WToKy/nQk0sS+amI9z9EjVmdaocj4=
+github.com/google/wire v0.7.0/go.mod h1:n6YbUQD9cPKTnHXEBN2DXlOp/mVADhVErcMFb0v3J18=
 github.com/googleapis/enterprise-certificate-proxy v0.3.6 h1:GW/XbdyBFQ8Qe+YAmFU9uHLo7OnF5tL52HFAgMmyrf4=
 github.com/googleapis/enterprise-certificate-proxy v0.3.6/go.mod h1:MkHOF77EYAE7qfSuSS9PU6g4Nt4e11cnsDUowfwewLA=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
@@ -382,10 +384,6 @@ github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLf
 github.com/jdkato/prose v1.2.1 h1:Fp3UnJmLVISmlc57BgKUzdjr0lOtjqTZicL3PaYy6cU=
 github.com/jdkato/prose v1.2.1/go.mod h1:AiRHgVagnEx2JbQRQowVBKjG0bcs/vtkGCH1dYAL1rA=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
-github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
-github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
-github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
@@ -419,8 +417,8 @@ github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovk
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
+github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
 github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
 github.com/mitchellh/mapstructure v1.5.1-0.20231216201459-8508981c8b6c h1:cqn374mizHuIWj+OSJCajGr/phAmuMug9qIX3l9CflE=
@@ -439,12 +437,14 @@ github.com/oasdiff/yaml v0.0.0-20250309154309-f31be36b4037 h1:G7ERwszslrBzRxj//J
 github.com/oasdiff/yaml v0.0.0-20250309154309-f31be36b4037/go.mod h1:2bpvgLBZEtENV5scfDFEtB/5+1M4hkQhDQrccEJ/qGw=
 github.com/oasdiff/yaml3 v0.0.0-20250309153720-d2182401db90 h1:bQx3WeLcUWy+RletIKwUIt4x3t8n2SxavmoclizMb8c=
 github.com/oasdiff/yaml3 v0.0.0-20250309153720-d2182401db90/go.mod h1:y5+oSEHCPT/DGrS++Wc/479ERge0zTFxaF8PbGKcg2o=
+github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6 h1:zrbMGy9YXpIeTnGj4EljqMiZsIcE09mmF8XsD5AYOJc=
+github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6/go.mod h1:rEKTHC9roVVicUIfZK7DYrdIoM0EOr8mK1Hj5s3JjH0=
 github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
-github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
-github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
-github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/ll v0.1.3 h1:sV2jrhQGq5B3W0nENUISCR6azIPf7UBUpVq0x/y70Fg=
+github.com/olekukonko/ll v0.1.3/go.mod h1:b52bVQRRPObe+yyBl0TxNfhesL0nedD4Cht0/zx55Ew=
+github.com/olekukonko/tablewriter v1.1.2 h1:L2kI1Y5tZBct/O/TyZK1zIE9GlBj/TVs+AY5tZDCDSc=
+github.com/olekukonko/tablewriter v1.1.2/go.mod h1:z7SYPugVqGVavWoA2sGsFIoOVNmEHxUAAMrhXONtfkg=
 github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 h1:onHthvaw9LFnH4t2DcNVpwGmV9E1BkGknEliJkfwQj0=
 github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y=
 github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
@@ -459,7 +459,6 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE
 github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg=
 github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo=
 github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
-github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -468,9 +467,6 @@ github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/redis/go-redis/v9 v9.8.0 h1:q3nRvjrlge/6UD7eTu/DSg2uYiU2mCL0G/uzBWqhicI=
 github.com/redis/go-redis/v9 v9.8.0/go.mod h1:huWgSWd8mW6+m0VPhJjSSQ+d6Nh1VICQ6Q5lHuCH/Iw=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
@@ -479,10 +475,8 @@ github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd h1:CmH9+J6ZSsIjUK3dcGsnCnO41eRBOnY12zwkn5qVwgc=
 github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd/go.mod h1:hPqNNc0+uJM6H+SuU8sEs5K5IQeKccPqeSjfgcKGgPk=
-github.com/sanity-io/litter v1.5.8 h1:uM/2lKrWdGbRXDrIq08Lh9XtVYoeGtcQxk9rtQ7+rYg=
-github.com/sanity-io/litter v1.5.8/go.mod h1:9gzJgR2i4ZpjZHsKvUXIRQVk7P+yM3e+jAF7bU2UI5U=
-github.com/sebdah/goldie/v2 v2.7.1 h1:PkBHymaYdtvEkZV7TmyqKxdmn5/Vcj+8TpATWZjnG5E=
-github.com/sebdah/goldie/v2 v2.7.1/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
+github.com/sebdah/goldie/v2 v2.8.0 h1:dZb9wR8q5++oplmEiJT+U/5KyotVD+HNGCAc5gNr8rc=
+github.com/sebdah/goldie/v2 v2.8.0/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
 github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
 github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
 github.com/shogo82148/go-shuffle v0.0.0-20180218125048-27e6095f230d/go.mod h1:2htx6lmL0NGLHlO8ZCf+lQBGBHIbEujyywxJArf+2Yc=
@@ -491,19 +485,17 @@ github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
 github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
 github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
 github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
-github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo=
-github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0=
+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/spf13/fsync v0.10.1 h1:JRnB7G72b+gIBaBcpn5ibJSd7ww1iEahXSX2B8G6dSE=
 github.com/spf13/fsync v0.10.1/go.mod h1:y+B41vYq5i6Boa3Z+BVoPbDeOvxVkNU5OBXhoT8i4TQ=
-github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/pflag v1.0.7 h1:vN6T9TfwStFPFM5XzjsvmzZkLuaLX+HS+0SeFLRgU6M=
-github.com/spf13/pflag v1.0.7/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spiffe/go-spiffe/v2 v2.5.0 h1:N2I01KCUkv1FAjZXJMwh95KK1ZIQLYbPfhaxw8WS0hE=
 github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v0.0.0-20161117074351-18a02ba4a312/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -513,14 +505,14 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tdewolff/minify/v2 v2.24.5 h1:ytxthX3xSxrK3Xx5B38flg5moCKs/dB8VwiD/RzJViU=
-github.com/tdewolff/minify/v2 v2.24.5/go.mod h1:q09KtNnVai7TyEzGEZeWPAnK+c8Z+NI8prCXZW652bo=
-github.com/tdewolff/parse/v2 v2.8.5-0.20251020133559-0efcf90bef1a h1:Rmq+utdraciok/97XHRweYdsAo/M4LOswpCboo3yvN4=
-github.com/tdewolff/parse/v2 v2.8.5-0.20251020133559-0efcf90bef1a/go.mod h1:Hwlni2tiVNKyzR1o6nUs4FOF07URA+JLBLd6dlIXYqo=
+github.com/tdewolff/minify/v2 v2.24.8 h1:58/VjsbevI4d5FGV0ZSuBrHMSSkH4MCH0sIz/eKIauE=
+github.com/tdewolff/minify/v2 v2.24.8/go.mod h1:0Ukj0CRpo/sW/nd8uZ4ccXaV1rEVIWA3dj8U7+Shhfw=
+github.com/tdewolff/parse/v2 v2.8.5 h1:ZmBiA/8Do5Rpk7bDye0jbbDUpXXbCdc3iah4VeUvwYU=
+github.com/tdewolff/parse/v2 v2.8.5/go.mod h1:Hwlni2tiVNKyzR1o6nUs4FOF07URA+JLBLd6dlIXYqo=
 github.com/tdewolff/test v1.0.11 h1:FdLbwQVHxqG16SlkGveC0JVyrJN62COWTRyUFzfbtBE=
 github.com/tdewolff/test v1.0.11/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8=
-github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
-github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
+github.com/tetratelabs/wazero v1.10.1 h1:2DugeJf6VVk58KTPszlNfeeN8AhhpwcZqkJj2wwFuH8=
+github.com/tetratelabs/wazero v1.10.1/go.mod h1:DRm5twOQ5Gr1AoEdSi0CLjDQF1J9ZAuyqFIjl1KKfQU=
 github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0=
 github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=
 github.com/woodsbury/decimal128 v1.3.0 h1:8pffMNWIlC0O5vbyHWFZAt5yWvWcrHA+3ovIIjVWss0=
@@ -530,7 +522,6 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/yuin/goldmark v1.7.13 h1:GPddIs617DnBLFFVJFgpo1aBfe/4xcvMc3SB5t/D0pA=
 github.com/yuin/goldmark v1.7.13/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
 github.com/yuin/goldmark-emoji v1.0.6 h1:QWfF2FYaXwL74tfGOW5izeiZepUDroDJfWubQI9HTHs=
@@ -567,21 +558,20 @@ go.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8=
 go.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-gocloud.dev v0.43.0 h1:aW3eq4RMyehbJ54PMsh4hsp7iX8cO/98ZRzJJOzN/5M=
-gocloud.dev v0.43.0/go.mod h1:eD8rkg7LhKUHrzkEdLTZ+Ty/vgPHPCd+yMQdfelQVu4=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+gocloud.dev v0.44.0 h1:iVyMAqFl2r6xUy7M4mfqwlN+21UpJoEtgHEcfiLMUXs=
+gocloud.dev v0.44.0/go.mod h1:ZmjROXGdC/eKZLF1N+RujDlFRx3D+4Av2thREKDMVxY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220331220935-ae2d96664a29/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
-golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
-golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
-golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
+golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU=
+golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -595,8 +585,8 @@ golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMk
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/image v0.0.0-20210220032944-ac19c3e999fb/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.32.0 h1:6lZQWq75h7L5IWNk0r+SCpUJ6tUVd3v4ZHnbRKLkUDQ=
-golang.org/x/image v0.32.0/go.mod h1:/R37rrQmKXtO6tYXAjtDLwQgFLHmhW+V6ayXlxzP2Pc=
+golang.org/x/image v0.34.0 h1:33gCkyw9hmwbZJeZkct8XyR11yH889EQt/QH4VmXMn8=
+golang.org/x/image v0.34.0/go.mod h1:2RNFBZRB+vnwwFil8GkMdRvrJOFd1AzdZI6vOY+eJVU=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -619,12 +609,8 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA=
-golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w=
+golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
+golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -658,13 +644,8 @@ golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
-golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
-golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
-golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
+golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
+golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -674,8 +655,8 @@ golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ
 golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.31.0 h1:8Fq0yVZLh4j4YA47vHKFTa9Ew5XIrCP8LC6UeNZnLxo=
-golang.org/x/oauth2 v0.31.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
+golang.org/x/oauth2 v0.32.0 h1:jsCblLleRMDrxMN29H3z/k1KliIvpLgCkE6R8FXXNgY=
+golang.org/x/oauth2 v0.32.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -687,12 +668,8 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
-golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -730,24 +707,13 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
-golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
-golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -755,18 +721,13 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
-golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
+golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.13.0 h1:eUlYslOIt32DgYD6utsuUeHs4d7AsEYLuIAdg7FlYgI=
-golang.org/x/time v0.13.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
@@ -815,12 +776,8 @@ golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4f
 golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
-golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps=
-golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ=
-golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs=
+golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
+golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -848,8 +805,8 @@ google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz513
 google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
 google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
 google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
-google.golang.org/api v0.251.0 h1:6lea5nHRT8RUmpy9kkC2PJYnhnDAB13LqrLSVQlMIE8=
-google.golang.org/api v0.251.0/go.mod h1:Rwy0lPf/TD7+T2VhYcffCHhyyInyuxGjICxdfLqT7KI=
+google.golang.org/api v0.255.0 h1:OaF+IbRwOottVCYV2wZan7KUq7UeNUQn1BcPc4K7lE4=
+google.golang.org/api v0.255.0/go.mod h1:d1/EtvCLdtiWEV4rAEHDHGh2bCnqsWhw+M8y2ECN4a8=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
@@ -895,10 +852,10 @@ google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6D
 google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20250715232539-7130f93afb79 h1:Nt6z9UHqSlIdIGJdz6KhTIs2VRx/iOsA5iE8bmQNcxs=
 google.golang.org/genproto v0.0.0-20250715232539-7130f93afb79/go.mod h1:kTmlBHMPqR5uCZPBvwa2B18mvubkjyY3CRLI0c6fj0s=
-google.golang.org/genproto/googleapis/api v0.0.0-20250715232539-7130f93afb79 h1:iOye66xuaAK0WnkPuhQPUFy8eJcmwUXqGGP3om6IxX8=
-google.golang.org/genproto/googleapis/api v0.0.0-20250715232539-7130f93afb79/go.mod h1:HKJDgKsFUnv5VAGeQjz8kxcgDP0HoE0iZNp0OdZNlhE=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 h1:i8QOKZfYg6AbGVZzUAY3LrNWCKF8O6zFisU9Wl9RER4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4/go.mod h1:HSkG/KdJWusxU1F6CNrwNDjBMgisKxGnc5dAZfT0mjQ=
+google.golang.org/genproto/googleapis/api v0.0.0-20250818200422-3122310a409c h1:AtEkQdl5b6zsybXcbz00j1LwNodDuH6hVifIaNqk7NQ=
+google.golang.org/genproto/googleapis/api v0.0.0-20250818200422-3122310a409c/go.mod h1:ea2MjsO70ssTfCjiwHgI0ZFqcw45Ksuk2ckf9G468GA=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda h1:i/Q+bfisr7gq6feoJnS/DlpdwEL4ihp41fvRiM3Ork0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
@@ -915,8 +872,8 @@ google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM
 google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
 google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
 google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.75.1 h1:/ODCNEuf9VghjgO3rqLcfg8fiOP0nSluljWFlDxELLI=
-google.golang.org/grpc v1.75.1/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
+google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A=
+google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -927,8 +884,8 @@ google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw=
-google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
@@ -937,7 +894,6 @@ gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/neurosnap/sentences.v1 v1.0.6/go.mod h1:YlK+SN+fLQZj+kY3r8DkGDhDr91+S3JmTb5LSxFRQo0=
 gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

helpers/content_test.go

@@ -54,8 +54,8 @@ func TestTrimShortHTML(t *testing.T) {
 
 func BenchmarkTrimShortHTML(b *testing.B) {
 	c := newTestContentSpec(nil)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+
+	for b.Loop() {
 		c.TrimShortHTML([]byte("<p>Simple paragraph</p>"), "markdown")
 	}
 }
@@ -134,8 +134,8 @@ func TestTotalWords(t *testing.T) {
 }
 
 func BenchmarkTotalWords(b *testing.B) {
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+
+	for b.Loop() {
 		wordCount := helpers.TotalWords(totalWordsBenchmarkString)
 		if wordCount != 400 {
 			b.Fatal("Wordcount error")

helpers/general.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
-	"sort"
 	"strings"
 	"unicode"
 	"unicode/utf8"
@@ -59,65 +58,6 @@ func FirstUpper(s string) string {
 	return string(unicode.ToUpper(r)) + s[n:]
 }
 
-// UniqueStrings returns a new slice with any duplicates removed.
-func UniqueStrings(s []string) []string {
-	unique := make([]string, 0, len(s))
-	for i, val := range s {
-		var seen bool
-		for j := range i {
-			if s[j] == val {
-				seen = true
-				break
-			}
-		}
-		if !seen {
-			unique = append(unique, val)
-		}
-	}
-	return unique
-}
-
-// UniqueStringsReuse returns a slice with any duplicates removed.
-// It will modify the input slice.
-func UniqueStringsReuse(s []string) []string {
-	result := s[:0]
-	for i, val := range s {
-		var seen bool
-
-		for j := range i {
-			if s[j] == val {
-				seen = true
-				break
-			}
-		}
-
-		if !seen {
-			result = append(result, val)
-		}
-	}
-	return result
-}
-
-// UniqueStringsSorted returns a sorted slice with any duplicates removed.
-// It will modify the input slice.
-func UniqueStringsSorted(s []string) []string {
-	if len(s) == 0 {
-		return nil
-	}
-	ss := sort.StringSlice(s)
-	ss.Sort()
-	i := 0
-	for j := 1; j < len(s); j++ {
-		if !ss.Less(i, j) {
-			continue
-		}
-		i++
-		s[i] = s[j]
-	}
-
-	return s[:i+1]
-}
-
 // ReaderToBytes takes an io.Reader argument, reads from it
 // and returns bytes.
 func ReaderToBytes(lines io.Reader) []byte {

helpers/general_test.go

@@ -14,7 +14,6 @@
 package helpers_test
 
 import (
-	"reflect"
 	"strings"
 	"testing"
 
@@ -215,8 +214,8 @@ func TestGetTitleFunc(t *testing.T) {
 }
 
 func BenchmarkReaderContains(b *testing.B) {
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+
+	for b.Loop() {
 		for i, this := range containsBenchTestData {
 			result := helpers.ReaderContains(strings.NewReader(this.v1), this.v2)
 			if result != this.expect {
@@ -226,84 +225,6 @@ func BenchmarkReaderContains(b *testing.B) {
 	}
 }
 
-func TestUniqueStrings(t *testing.T) {
-	in := []string{"a", "b", "a", "b", "c", "", "a", "", "d"}
-	output := helpers.UniqueStrings(in)
-	expected := []string{"a", "b", "c", "", "d"}
-	if !reflect.DeepEqual(output, expected) {
-		t.Errorf("Expected %#v, got %#v\n", expected, output)
-	}
-}
-
-func TestUniqueStringsReuse(t *testing.T) {
-	in := []string{"a", "b", "a", "b", "c", "", "a", "", "d"}
-	output := helpers.UniqueStringsReuse(in)
-	expected := []string{"a", "b", "c", "", "d"}
-	if !reflect.DeepEqual(output, expected) {
-		t.Errorf("Expected %#v, got %#v\n", expected, output)
-	}
-}
-
-func TestUniqueStringsSorted(t *testing.T) {
-	c := qt.New(t)
-	in := []string{"a", "a", "b", "c", "b", "", "a", "", "d"}
-	output := helpers.UniqueStringsSorted(in)
-	expected := []string{"", "a", "b", "c", "d"}
-	c.Assert(output, qt.DeepEquals, expected)
-	c.Assert(helpers.UniqueStringsSorted(nil), qt.IsNil)
-}
-
-func BenchmarkUniqueStrings(b *testing.B) {
-	input := []string{"a", "b", "d", "e", "d", "h", "a", "i"}
-
-	b.Run("Safe", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			result := helpers.UniqueStrings(input)
-			if len(result) != 6 {
-				b.Fatalf("invalid count: %d", len(result))
-			}
-		}
-	})
-
-	b.Run("Reuse slice", func(b *testing.B) {
-		b.StopTimer()
-		inputs := make([][]string, b.N)
-		for i := 0; i < b.N; i++ {
-			inputc := make([]string, len(input))
-			copy(inputc, input)
-			inputs[i] = inputc
-		}
-		b.StartTimer()
-		for i := 0; i < b.N; i++ {
-			inputc := inputs[i]
-
-			result := helpers.UniqueStringsReuse(inputc)
-			if len(result) != 6 {
-				b.Fatalf("invalid count: %d", len(result))
-			}
-		}
-	})
-
-	b.Run("Reuse slice sorted", func(b *testing.B) {
-		b.StopTimer()
-		inputs := make([][]string, b.N)
-		for i := 0; i < b.N; i++ {
-			inputc := make([]string, len(input))
-			copy(inputc, input)
-			inputs[i] = inputc
-		}
-		b.StartTimer()
-		for i := 0; i < b.N; i++ {
-			inputc := inputs[i]
-
-			result := helpers.UniqueStringsSorted(inputc)
-			if len(result) != 6 {
-				b.Fatalf("invalid count: %d", len(result))
-			}
-		}
-	})
-}
-
 func TestStringSliceToList(t *testing.T) {
 	for _, tt := range []struct {
 		slice       []string

helpers/path.go

@@ -21,9 +21,11 @@ import (
 	"path"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"sort"
 	"strings"
 
+	"github.com/gohugoio/go-radix"
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/text"
 	"github.com/gohugoio/hugo/htesting"
@@ -72,8 +74,8 @@ func MakeTitle(inpath string) string {
 // MakeTitleInPath converts the path given to a suitable title, trimming whitespace
 func MakePathRelative(inPath string, possibleDirectories ...string) (string, error) {
 	for _, currentPath := range possibleDirectories {
-		if strings.HasPrefix(inPath, currentPath) {
-			return strings.TrimPrefix(inPath, currentPath), nil
+		if after, ok := strings.CutPrefix(inPath, currentPath); ok {
+			return after, nil
 		}
 	}
 	return inPath, errors.New("can't extract relative path, unknown prefix")
@@ -128,113 +130,63 @@ func (n NamedSlice) String() string {
 	return fmt.Sprintf("%s%s{%s}", n.Name, FilePathSeparator, strings.Join(n.Slice, ","))
 }
 
-func ExtractAndGroupRootPaths(paths []string) []NamedSlice {
-	if len(paths) == 0 {
+// ExtractAndGroupRootPaths extracts and groups root paths from the supplied list of paths.
+// Note that the in slice will be sorted in place.
+func ExtractAndGroupRootPaths(in []string) []string {
+	if len(in) == 0 {
 		return nil
 	}
+	const maxGroups = 5
+	sort.Strings(in)
+	var groups []string
+	tree := radix.New[[]string]()
 
-	pathsCopy := make([]string, len(paths))
-	hadSlashPrefix := strings.HasPrefix(paths[0], FilePathSeparator)
-
-	for i, p := range paths {
-		pathsCopy[i] = strings.Trim(filepath.ToSlash(p), "/")
-	}
-
-	sort.Strings(pathsCopy)
-
-	pathsParts := make([][]string, len(pathsCopy))
-
-	for i, p := range pathsCopy {
-		pathsParts[i] = strings.Split(p, "/")
-	}
-
-	var groups [][]string
-
-	for i, p1 := range pathsParts {
-		c1 := -1
-
-		for j, p2 := range pathsParts {
-			if i == j {
-				continue
+LOOP:
+	for _, s := range in {
+		s = filepath.ToSlash(s)
+		if ss, g, found := tree.LongestPrefix(s); found {
+			if len(g) > maxGroups {
+				continue LOOP
+			}
+			parts := strings.Split(strings.TrimPrefix(strings.TrimPrefix(s, ss), "/"), "/")
+			if len(parts) > 0 && parts[0] != "" && !slices.Contains(g, parts[0]) {
+				g = append(g, parts[0])
+				tree.Insert(ss, g)
 			}
 
-			c2 := -1
-
-			for i, v := range p1 {
-				if i >= len(p2) {
-					break
-				}
-				if v != p2[i] {
-					break
-				}
-
-				c2 = i
-			}
-
-			if c1 == -1 || (c2 != -1 && c2 < c1) {
-				c1 = c2
-			}
-		}
-
-		if c1 != -1 {
-			groups = append(groups, p1[:c1+1])
 		} else {
-			groups = append(groups, p1)
+			tree.Insert(s, []string{})
 		}
 	}
 
-	groupsStr := make([]string, len(groups))
-	for i, g := range groups {
-		groupsStr[i] = strings.Join(g, "/")
+	var collect radix.WalkFn[[]string] = func(s string, g []string) (radix.WalkFlag, []string, error) {
+		if len(g) == 0 {
+			groups = append(groups, s)
+			return radix.WalkContinue, nil, nil
+		}
+		if len(g) == 1 {
+			groups = append(groups, path.Join(s, g[0]))
+			return radix.WalkContinue, nil, nil
+		}
+		var sb strings.Builder
+		sb.WriteString(s)
+		// This is used to print "Watching for changes in /Users/bep/dev/sites/hugotestsites/60k/content/{section0,section1,section10..."
+		// Having too many groups here is not helpful.
+		if len(g) > maxGroups {
+			// This will modify the slice in the tree, but that is OK since we are done with it.
+			g = g[:maxGroups]
+			g = append(g, "...")
+		}
+		sb.WriteString("/{")
+		sb.WriteString(strings.Join(g, ","))
+		sb.WriteString("}")
+		groups = append(groups, sb.String())
+		return radix.WalkContinue, nil, nil
 	}
 
-	groupsStr = UniqueStringsSorted(groupsStr)
+	tree.Walk(collect)
 
-	var result []NamedSlice
-
-	for _, g := range groupsStr {
-		name := filepath.FromSlash(g)
-		if hadSlashPrefix {
-			name = FilePathSeparator + name
-		}
-		ns := NamedSlice{Name: name}
-		for _, p := range pathsCopy {
-			if !strings.HasPrefix(p, g) {
-				continue
-			}
-
-			p = strings.TrimPrefix(p, g)
-			if p != "" {
-				ns.Slice = append(ns.Slice, p)
-			}
-		}
-
-		ns.Slice = UniqueStrings(ExtractRootPaths(ns.Slice))
-
-		result = append(result, ns)
-	}
-
-	return result
-}
-
-// ExtractRootPaths extracts the root paths from the supplied list of paths.
-// The resulting root path will not contain any file separators, but there
-// may be duplicates.
-// So "/content/section/" becomes "content"
-func ExtractRootPaths(paths []string) []string {
-	r := make([]string, len(paths))
-	for i, p := range paths {
-		root := filepath.ToSlash(p)
-		sections := strings.Split(root, "/")
-		for _, section := range sections {
-			if section != "" {
-				root = section
-				break
-			}
-		}
-		r[i] = root
-	}
-	return r
+	return groups
 }
 
 // FindCWD returns the current working directory from where the Hugo

helpers/path_test.go

@@ -17,7 +17,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"reflect"
 	"runtime"
 	"strconv"
 	"strings"
@@ -355,36 +354,24 @@ func TestExtractAndGroupRootPaths(t *testing.T) {
 		filepath.FromSlash("/c/d/e"),
 	}
 
-	inCopy := make([]string, len(in))
-	copy(inCopy, in)
-
 	result := helpers.ExtractAndGroupRootPaths(in)
 
 	c := qt.New(t)
-	c.Assert(fmt.Sprint(result), qt.Equals, filepath.FromSlash("[/a/b/{c,e} /c/d/e]"))
-
-	// Make sure the original is preserved
-	c.Assert(in, qt.DeepEquals, inCopy)
+	c.Assert(result, qt.DeepEquals, []string{"/a/b/{c,e}", "/c/d/e"})
 }
 
-func TestExtractRootPaths(t *testing.T) {
-	tests := []struct {
-		input    []string
-		expected []string
-	}{{
-		[]string{
-			filepath.FromSlash("a/b"), filepath.FromSlash("a/b/c/"), "b",
-			filepath.FromSlash("/c/d"), filepath.FromSlash("d/"), filepath.FromSlash("//e//"),
-		},
-		[]string{"a", "a", "b", "c", "d", "e"},
-	}}
-
-	for _, test := range tests {
-		output := helpers.ExtractRootPaths(test.input)
-		if !reflect.DeepEqual(output, test.expected) {
-			t.Errorf("Expected %#v, got %#v\n", test.expected, output)
+func BenchmarkExtractAndGroupRootPaths(b *testing.B) {
+	in := []string{}
+	for i := 0; i < 10; i++ {
+		for j := 0; j < 1000; j++ {
+			in = append(in, fmt.Sprintf("/a/b/c/s%d/p%d", i, j))
 		}
 	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		helpers.ExtractAndGroupRootPaths(in)
+	}
 }
 
 func TestFindCWD(t *testing.T) {

helpers/pathspec.go

@@ -32,19 +32,11 @@ type PathSpec struct {
 
 	// The file systems to use
 	Fs *hugofs.Fs
-
-	// The config provider to use
-	Cfg config.AllProvider
 }
 
 // NewPathSpec creates a new PathSpec from the given filesystems and language.
-func NewPathSpec(fs *hugofs.Fs, cfg config.AllProvider, logger loggers.Logger) (*PathSpec, error) {
-	return NewPathSpecWithBaseBaseFsProvided(fs, cfg, logger, nil)
-}
-
-// NewPathSpecWithBaseBaseFsProvided creates a new PathSpec from the given filesystems and language.
 // If an existing BaseFs is provided, parts of that is reused.
-func NewPathSpecWithBaseBaseFsProvided(fs *hugofs.Fs, cfg config.AllProvider, logger loggers.Logger, baseBaseFs *filesystems.BaseFs) (*PathSpec, error) {
+func NewPathSpec(fs *hugofs.Fs, cfg config.AllProvider, logger loggers.Logger, baseBaseFs *filesystems.BaseFs) (*PathSpec, error) {
 	p, err := paths.New(fs, cfg)
 	if err != nil {
 		return nil, err
@@ -65,7 +57,6 @@ func NewPathSpecWithBaseBaseFsProvided(fs *hugofs.Fs, cfg config.AllProvider, lo
 		Paths:           p,
 		BaseFs:          bfs,
 		Fs:              fs,
-		Cfg:             cfg,
 		ProcessingStats: NewProcessingStats(p.Lang()),
 	}
 

helpers/testhelpers_test.go

@@ -23,7 +23,7 @@ func newTestPathSpecFromCfgAndLang(cfg config.Provider, lang string) *helpers.Pa
 		}
 	}
 	fs := hugofs.NewFrom(mfs, conf.BaseConfig())
-	ps, err := helpers.NewPathSpec(fs, conf, loggers.NewDefault())
+	ps, err := helpers.NewPathSpec(fs, conf, loggers.NewDefault(), nil)
 	if err != nil {
 		panic(err)
 	}

helpers/url_test.go

@@ -259,8 +259,8 @@ func BenchmarkRelURL(b *testing.B) {
 	v := config.New()
 	v.Set("baseURL", "https://base/")
 	p := newTestPathSpecFromCfgAndLang(v, "")
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+
+	for b.Loop() {
 		_ = p.RelURL("https://base/foo/bar", false)
 	}
 }
@@ -271,12 +271,12 @@ func BenchmarkAbsURL(b *testing.B) {
 	p := newTestPathSpecFromCfgAndLang(v, "")
 	b.ResetTimer()
 	b.Run("relurl", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			_ = p.AbsURL("foo/bar", false)
 		}
 	})
 	b.Run("absurl", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			_ = p.AbsURL("https://base/foo/bar", false)
 		}
 	})

htesting/hqt/checkers.go

@@ -44,6 +44,46 @@ var IsSameFloat64 = qt.CmpEquals(cmp.Comparer(func(a, b float64) bool {
 	return math.Abs(a-b) < 0.0001
 }))
 
+// IsSameNumber asserts that two number values are equal within a small delta.
+var IsSameNumber = qt.CmpEquals(
+	cmp.Comparer(func(a, b float64) bool {
+		return math.Abs(a-b) < 0.0001
+	}),
+	cmp.Comparer(func(a, b float32) bool {
+		return math.Abs(float64(a)-float64(b)) < 0.0001
+	}),
+	cmp.Comparer(func(a, b int) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b int8) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b int16) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b int32) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b int64) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b uint) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b uint8) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b uint16) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b uint32) bool {
+		return a == b
+	}),
+	cmp.Comparer(func(a, b uint64) bool {
+		return a == b
+	}),
+)
+
 type argNames []string
 
 func (a argNames) ArgNames() []string {