Misc remote HTTP/content adapter enhancements

* Recover from server errors * Improve go adapter rebuilds when adding new content See #12502 Fixes #12570
resources: Fix spelling
2026-08-31 10:42:38 +00:00 · 2024-06-05 11:14:22 +02:00 · 2024-06-04 18:48:39 +02:00 · 2024-06-04 18:32:02 +02:00 · 2024-06-04 16:07:39 +02:00 · 2024-06-02 13:15:24 +00:00
204 changed files with 11036 additions and 1660 deletions
@@ -4,7 +4,7 @@ parameters:
 defaults: &defaults
  resource_class: large
  docker:
-      - image: bepsays/ci-hugoreleaser:1.22200.20100
+      - image: bepsays/ci-hugoreleaser:1.22200.20201
 environment: &buildenv
      GOMODCACHE: /root/project/gomodcache
 version: 2
@@ -60,7 +60,7 @@ jobs:
    environment:
        <<: [*buildenv]
    docker:
-    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22200.20100
+    - image: bepsays/ci-hugoreleaser-linux-arm64:1.22200.20201
    steps:
      - *restore-cache
      - &attach-workspace
@@ -1,73 +0,0 @@
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-name: TestDartSassV1
-env:
-    GOPROXY: https://proxy.golang.org
-    GO111MODULE: on
-    DART_SASS_VERSION: 1.62.1
-    DART_SASS_SHA_LINUX: 3574da75a7322a539034648b8ff84ff2cca162eb924d72b663d718cd3936f075
-permissions:
-  contents: read
-jobs:
-  test:
-    strategy:
-      matrix:
-        go-version: [1.22.x]
-        os: [ubuntu-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
-    - name: Install Go
-      uses: actions/setup-go@fac708d6674e30b6ba41289acaab6d4b75aa0753
-      with:
-        go-version: ${{ matrix.go-version }}
-        check-latest: true
-        cache: true
-        cache-dependency-path: |
-          **/go.sum
-          **/go.mod
-    - name: Install Ruby
-      uses: ruby/setup-ruby@036ef458ddccddb148a2b9fb67e95a22fdbf728b
-      with:
-        ruby-version: '2.7' 
-        bundler-cache: true #
-    - name: Install Python
-      uses: actions/setup-python@3105fb18c05ddd93efea5f9e0bef7a03a6e9e7df
-      with:
-        python-version: '3.x'
-    - name: Install Mage
-      run: go install github.com/magefile/mage@v1.15.0
-    - name: Install asciidoctor
-      uses: reitzig/actions-asciidoctor@7570212ae20b63653481675fb1ff62d1073632b0
-    - name: Install docutils
-      run: |
-        pip install docutils
-        rst2html.py --version
-    - if: matrix.os == 'ubuntu-latest'
-      name: Install pandoc on Linux
-      run: |
-          sudo apt-get update -y
-          sudo apt-get install -y pandoc
-    - if: matrix.os == 'macos-latest'
-      run: |
-        brew install pandoc
-    - if: matrix.os == 'windows-latest'
-      run: |
-        Choco-Install -PackageName pandoc
-    - run: pandoc -v
-    - name: Install dart-sass-embedded Linux
-      run: |
-        echo "Install Dart Sass version ${DART_SASS_VERSION} ..."
-        curl -LJO "https://github.com/sass/dart-sass-embedded/releases/download/${DART_SASS_VERSION}/sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz";
-        echo "${DART_SASS_SHA_LINUX}  sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
-        tar -xvf "sass_embedded-${DART_SASS_VERSION}-linux-x64.tar.gz";
-        echo "$GITHUB_WORKSPACE/sass_embedded/" >> $GITHUB_PATH
-    - name: Check
-      run: |
-        dart-sass-embedded --version
-        mage -v check;
-      env:
-        HUGO_BUILD_TAGS: extended
@@ -1,119 +1,132 @@
 on:
  push:
-    branches: [ master ]
+    branches: [master]
  pull_request:
 name: Test
 env:
-    GOPROXY: https://proxy.golang.org
-    GO111MODULE: on
-    SASS_VERSION: 1.63.2
-    DART_SASS_SHA_LINUX: 3ea33c95ad5c35fda6e9a0956199eef38a398f496cfb8750e02479d7d1dd42af
-    DART_SASS_SHA_MACOS: 11c70f259836b250b44a9cb57fed70e030f21f45069b467d371685855f1eb4f0
-    DART_SASS_SHA_WINDOWS: cd8cd36a619dd8e27f93d3186c52d70eb7d69472aa6c85f5094b29693e773f64
+  GOPROXY: https://proxy.golang.org
+  GO111MODULE: on
+  SASS_VERSION: 1.63.2
+  DART_SASS_SHA_LINUX: 3ea33c95ad5c35fda6e9a0956199eef38a398f496cfb8750e02479d7d1dd42af
+  DART_SASS_SHA_MACOS: 11c70f259836b250b44a9cb57fed70e030f21f45069b467d371685855f1eb4f0
+  DART_SASS_SHA_WINDOWS: cd8cd36a619dd8e27f93d3186c52d70eb7d69472aa6c85f5094b29693e773f64
 permissions:
  contents: read
 jobs:
  test:
    strategy:
      matrix:
-        go-version: [1.21.x,1.22.x]
+        go-version: [1.21.x, 1.22.x]
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
-    - name: Checkout code
-      uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
-    - name: Install Go
-      uses: actions/setup-go@fac708d6674e30b6ba41289acaab6d4b75aa0753
-      with:
-        go-version: ${{ matrix.go-version }}
-        check-latest: true
-        cache: true
-        cache-dependency-path: |
-          **/go.sum
-          **/go.mod
-    - name: Install Ruby
-      uses: ruby/setup-ruby@036ef458ddccddb148a2b9fb67e95a22fdbf728b
-      with:
-        ruby-version: '2.7'
-        bundler-cache: true #
-    - name: Install Python
-      uses: actions/setup-python@3105fb18c05ddd93efea5f9e0bef7a03a6e9e7df
-      with:
-        python-version: '3.x'
-    - name: Install Mage
-      run: go install github.com/magefile/mage@v1.15.0
-    - name: Install asciidoctor
-      uses: reitzig/actions-asciidoctor@7570212ae20b63653481675fb1ff62d1073632b0
-    - name: Install docutils
-      run: |
-        pip install docutils
-        rst2html.py --version
-    - if: matrix.os == 'ubuntu-latest'
-      name: Install pandoc on Linux
-      run: |
+      - if: matrix.os == 'ubuntu-latest'
+        name: Free Disk Space (Ubuntu)
+        uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be
+        with:
+          # this might remove tools that are actually needed,
+          # if set to "true" but frees about 6 GB
+          tool-cache: false
+          android: true
+          dotnet: true
+          haskell: true
+          large-packages: true
+          docker-images: true
+          swap-storage: true
+      - name: Checkout code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
+      - name: Install Go
+        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491
+        with:
+          go-version: ${{ matrix.go-version }}
+          check-latest: true
+          cache: true
+          cache-dependency-path: |
+            **/go.sum
+            **/go.mod
+      - name: Install Ruby
+        uses: ruby/setup-ruby@5f19ec79cedfadb78ab837f95b87734d0003c899
+        with:
+          ruby-version: "2.7"
+          bundler-cache: true #
+      - name: Install Python
+        uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d
+        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@03fcc74cd74880b697950c4930c9ec8a67c69ecc
+      - name: Install docutils
+        run: |
+          pip install docutils
+          rst2html --version
+      - if: matrix.os == 'ubuntu-latest'
+        name: Install pandoc on Linux
+        run: |
          sudo apt-get update -y
          sudo apt-get install -y pandoc
-    - if: matrix.os == 'macos-latest'
-      run: |
-        brew install pandoc
-    - if: matrix.os == 'windows-latest'
-      run: |
-        choco install pandoc
-    - run: pandoc -v
-    - if: matrix.os == 'windows-latest'
-      run: |
-        choco install mingw
-    - if: matrix.os == 'ubuntu-latest'
-      name: Install dart-sass Linux
-      run: |
-        echo "Install Dart Sass version ${SASS_VERSION} ..."
-        curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
-        echo "${DART_SASS_SHA_LINUX}  dart-sass-${SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
-        tar -xvf "dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
-        echo "$GOBIN"
-        echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
-    - if: matrix.os == 'macos-latest'
-      name: Install dart-sass MacOS
-      run: |
-        echo "Install Dart Sass version ${SASS_VERSION} ..."
-        curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
-        echo "${DART_SASS_SHA_MACOS}  dart-sass-${SASS_VERSION}-macos-x64.tar.gz" | shasum -a 256 -c;
-        tar -xvf "dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
-        echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
-    - if: matrix.os == 'windows-latest'
-      name: Install dart-sass Windows
-      run: |
-        echo "Install Dart Sass version ${env:SASS_VERSION} ..."
-        curl -LJO "https://github.com/sass/dart-sass/releases/download/${env:SASS_VERSION}/dart-sass-${env:SASS_VERSION}-windows-x64.zip";
-        Expand-Archive -Path "dart-sass-${env:SASS_VERSION}-windows-x64.zip" -DestinationPath .;
-        echo  "$env:GITHUB_WORKSPACE/dart-sass/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
-    - if: matrix.os == 'ubuntu-latest'
-      name: Install staticcheck
-      run: go install honnef.co/go/tools/cmd/staticcheck@latest
-    - if: matrix.os == 'ubuntu-latest'
-      name: Run staticcheck
-      run: staticcheck ./...
-    - if: matrix.os != 'windows-latest'
-      name: Check
-      run: |
-        sass --version;
-        mage -v check;
-      env:
-        HUGO_BUILD_TAGS: extended
-    - if: matrix.os == 'windows-latest'
-      # See issue #11052. We limit the build to regular test (no -race flag) on Windows for now.
-      name: Test
-      run: |
-        mage -v test;
-      env:
-        HUGO_BUILD_TAGS: extended
-    - name: Build tags
-      run: |
-        go install -tags extended,nodeploy
-    - if: matrix.os == 'ubuntu-latest'
-      name: Build for dragonfly
-      run: |
-        go install
-      env:
-        GOARCH: amd64
-        GOOS: dragonfly
+      - if: matrix.os == 'macos-latest'
+        run: |
+          brew install pandoc
+      - if: matrix.os == 'windows-latest'
+        run: |
+          choco install pandoc
+      - run: pandoc -v
+      - if: matrix.os == 'windows-latest'
+        run: |
+          choco install mingw
+      - if: matrix.os == 'ubuntu-latest'
+        name: Install dart-sass Linux
+        run: |
+          echo "Install Dart Sass version ${SASS_VERSION} ..."
+          curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
+          echo "${DART_SASS_SHA_LINUX}  dart-sass-${SASS_VERSION}-linux-x64.tar.gz" | sha256sum -c;
+          tar -xvf "dart-sass-${SASS_VERSION}-linux-x64.tar.gz";
+          echo "$GOBIN"
+          echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
+      - if: matrix.os == 'macos-latest'
+        name: Install dart-sass MacOS
+        run: |
+          echo "Install Dart Sass version ${SASS_VERSION} ..."
+          curl -LJO "https://github.com/sass/dart-sass/releases/download/${SASS_VERSION}/dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
+          echo "${DART_SASS_SHA_MACOS}  dart-sass-${SASS_VERSION}-macos-x64.tar.gz" | shasum -a 256 -c;
+          tar -xvf "dart-sass-${SASS_VERSION}-macos-x64.tar.gz";
+          echo "$GITHUB_WORKSPACE/dart-sass/" >> $GITHUB_PATH
+      - if: matrix.os == 'windows-latest'
+        name: Install dart-sass Windows
+        run: |
+          echo "Install Dart Sass version ${env:SASS_VERSION} ..."
+          curl -LJO "https://github.com/sass/dart-sass/releases/download/${env:SASS_VERSION}/dart-sass-${env:SASS_VERSION}-windows-x64.zip";
+          Expand-Archive -Path "dart-sass-${env:SASS_VERSION}-windows-x64.zip" -DestinationPath .;
+          echo  "$env:GITHUB_WORKSPACE/dart-sass/" | Out-File -FilePath $Env:GITHUB_PATH -Encoding utf-8 -Append
+      - if: matrix.os == 'ubuntu-latest'
+        name: Install staticcheck
+        run: go install honnef.co/go/tools/cmd/staticcheck@latest
+      - if: matrix.os == 'ubuntu-latest'
+        name: Run staticcheck
+        run: staticcheck ./...
+      - if: matrix.os != 'windows-latest'
+        name: Check
+        run: |
+          sass --version;
+          mage -v check;
+        env:
+          HUGO_BUILD_TAGS: extended
+      - if: matrix.os == 'windows-latest'
+        # See issue #11052. We limit the build to regular test (no -race flag) on Windows for now.
+        name: Test
+        run: |
+          mage -v test;
+        env:
+          HUGO_BUILD_TAGS: extended
+      - name: Build tags
+        run: |
+          go install -tags extended,nodeploy
+      - if: matrix.os == 'ubuntu-latest'
+        name: Build for dragonfly
+        run: |
+          go install
+        env:
+          GOARCH: amd64
+          GOOS: dragonfly
@@ -186,7 +186,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

-   Copyright 2022 The Hugo Authors.
+   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -62,8 +62,7 @@ And with [Hugo Modules], you can share content, assets, data, translations, them

 <p>&nbsp;</p>
 <p float="left">
-  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
-  <a href="https://cloudcannon.com/hugo-cms/?utm_campaign=HugoSponsorship&utm_source=sponsor&utm_content=gohugo" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/cloudcannon-blue.svg" width="220" alt="CloudCannon"></a>
+  <a href="https://www.linode.com/?utm_campaign=hugosponsor&utm_medium=banner&utm_source=hugogithub" target="_blank"><img src="https://raw.githubusercontent.com/gohugoio/gohugoioTheme/master/assets/images/sponsors/linode-logo_standard_light_medium.png" width="200" alt="Linode"></a>
 <p>&nbsp;</p>

 ## Installation
@@ -4,4 +4,4 @@

 Please report (suspected) security vulnerabilities to **[bjorn.erik.pedersen@gmail.com](mailto:bjorn.erik.pedersen@gmail.com)**. You will receive a response from us within 48 hours. If we can confirm the issue, we will release a patch as soon as possible depending on the complexity of the issue but historically within days.

-Also see [Hugo's Security Model](https://gohugo.io/about/security-model/).
+Also see [Hugo's Security Model](https://gohugo.io/about/security/).
@@ -67,7 +67,7 @@ func New(opts Options) *Cache {
 	evictedIdentities := collections.NewStack[identity.Identity]()

 	onEvict := func(k, v any) {
-		if !opts.Running {
+		if !opts.Watching {
 			return
 		}
 		identity.WalkIdentitiesShallow(v, func(level int, id identity.Identity) bool {
@@ -97,7 +97,7 @@ type Options struct {
 	CheckInterval time.Duration
 	MaxSize       int
 	MinMaxSize    int
-	Running       bool
+	Watching      bool
 }

 // Options for a partition.
@@ -140,16 +140,25 @@ func (c *Cache) DrainEvictedIdentities() []identity.Identity {
 }

 // ClearMatching clears all partition for which the predicate returns true.
-func (c *Cache) ClearMatching(predicate func(k, v any) bool) {
+func (c *Cache) ClearMatching(predicatePartition func(k string, p PartitionManager) bool, predicateValue func(k, v any) bool) {
+	if predicatePartition == nil {
+		predicatePartition = func(k string, p PartitionManager) bool { return true }
+	}
+	if predicateValue == nil {
+		panic("nil predicateValue")
+	}
 	g := rungroup.Run[PartitionManager](context.Background(), rungroup.Config[PartitionManager]{
 		NumWorkers: len(c.partitions),
 		Handle: func(ctx context.Context, partition PartitionManager) error {
-			partition.clearMatching(predicate)
+			partition.clearMatching(predicateValue)
 			return nil
 		},
 	})

-	for _, p := range c.partitions {
+	for k, p := range c.partitions {
+		if !predicatePartition(k, p) {
+			continue
+		}
 		g.Enqueue(p)
 	}

@@ -340,7 +349,7 @@ func GetOrCreatePartition[K comparable, V any](c *Cache, name string, opts Optio
 		return p.(*Partition[K, V])
 	}

-	// At this point, we don't know the the number of partitions or their configuration, but
+	// At this point, we don't know the number of partitions or their configuration, but
 	// this will be re-adjusted later.
 	const numberOfPartitionsEstimate = 10
 	maxSize := opts.CalculateMaxSize(c.opts.MaxSize / numberOfPartitionsEstimate)
@@ -356,6 +365,7 @@ func GetOrCreatePartition[K comparable, V any](c *Cache, name string, opts Optio
 		trace:   c.opts.Log.Logger().WithLevel(logg.LevelTrace).WithField("partition", name),
 		opts:    opts,
 	}
+
 	c.partitions[name] = partition

 	return partition
@@ -375,13 +385,37 @@ type Partition[K comparable, V any] struct {

 // GetOrCreate gets or creates a value for the given key.
 func (p *Partition[K, V]) GetOrCreate(key K, create func(key K) (V, error)) (V, error) {
+	v, err := p.doGetOrCreate(key, create)
+	if err != nil {
+		return p.zero, err
+	}
+	if resource.StaleVersion(v) > 0 {
+		p.c.Delete(key)
+		return p.doGetOrCreate(key, create)
+	}
+	return v, err
+}
+
+func (p *Partition[K, V]) doGetOrCreate(key K, create func(key K) (V, error)) (V, error) {
 	v, _, err := p.c.GetOrCreate(key, create)
 	return v, err
 }

+func (p *Partition[K, V]) GetOrCreateWitTimeout(key K, duration time.Duration, create func(key K) (V, error)) (V, error) {
+	v, err := p.doGetOrCreateWitTimeout(key, duration, create)
+	if err != nil {
+		return p.zero, err
+	}
+	if resource.StaleVersion(v) > 0 {
+		p.c.Delete(key)
+		return p.doGetOrCreateWitTimeout(key, duration, create)
+	}
+	return v, err
+}
+
 // GetOrCreateWitTimeout gets or creates a value for the given key and times out if the create function
 // takes too long.
-func (p *Partition[K, V]) GetOrCreateWitTimeout(key K, duration time.Duration, create func(key K) (V, error)) (V, error) {
+func (p *Partition[K, V]) doGetOrCreateWitTimeout(key K, duration time.Duration, create func(key K) (V, error)) (V, error) {
 	resultch := make(chan V, 1)
 	errch := make(chan error, 1)

@@ -438,7 +472,7 @@ func (p *Partition[K, V]) clearOnRebuild(changeset ...identity.Identity) {

 	shouldDelete := func(key K, v V) bool {
 		// We always clear elements marked as stale.
-		if resource.IsStaleAny(v) {
+		if resource.StaleVersion(v) > 0 {
 			return true
 		}

@@ -493,8 +527,8 @@ func (p *Partition[K, V]) Keys() []K {

 func (p *Partition[K, V]) clearStale() {
 	p.c.DeleteFunc(func(key K, v V) bool {
-		isStale := resource.IsStaleAny(v)
-		if isStale {
+		staleVersion := resource.StaleVersion(v)
+		if staleVersion > 0 {
 			p.trace.Log(
 				logg.StringFunc(
 					func() string {
@@ -504,7 +538,7 @@ func (p *Partition[K, V]) clearStale() {
 			)
 		}

-		return isStale
+		return staleVersion > 0
 	})
 }

@@ -29,12 +29,12 @@ var (
 )

 type testItem struct {
-	name    string
-	isStale bool
+	name         string
+	staleVersion uint32
 }

-func (t testItem) IsStale() bool {
-	return t.isStale
+func (t testItem) StaleVersion() uint32 {
+	return t.staleVersion
 }

 func (t testItem) IdentifierBase() string {
@@ -109,7 +109,7 @@ func newTestCache(t *testing.T) *Cache {

 	p2.GetOrCreate("clearBecauseStale", func(string) (testItem, error) {
 		return testItem{
-			isStale: true,
+			staleVersion: 32,
 		}, nil
 	})

@@ -121,7 +121,7 @@ func newTestCache(t *testing.T) *Cache {

 	p2.GetOrCreate("clearNever", func(string) (testItem, error) {
 		return testItem{
-			isStale: false,
+			staleVersion: 0,
 		}, nil
 	})

@@ -156,7 +156,7 @@ func TestClear(t *testing.T) {

 	cache = newTestCache(t)

-	cache.ClearMatching(func(k, v any) bool {
+	cache.ClearMatching(nil, func(k, v any) bool {
 		return k.(string) == "clearOnRebuild"
 	})

@@ -1,4 +1,4 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
+// Copyright 2024 The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ import (
 	"sync"
 	"time"

+	"github.com/gohugoio/httpcache"
 	"github.com/gohugoio/hugo/common/hugio"
 	"github.com/gohugoio/hugo/hugofs"

@@ -182,6 +183,15 @@ func (c *Cache) ReadOrCreate(id string,
 	return
 }

+// NamedLock locks the given id. The lock is released when the returned function is called.
+func (c *Cache) NamedLock(id string) func() {
+	id = cleanID(id)
+	c.nlocker.Lock(id)
+	return func() {
+		c.nlocker.Unlock(id)
+	}
+}
+
 // GetOrCreate tries to get the file with the given id from cache. If not found or expired, create will
 // be invoked and the result cached.
 // This method is protected by a named lock using the given id as identifier.
@@ -218,7 +228,23 @@ func (c *Cache) GetOrCreate(id string, create func() (io.ReadCloser, error)) (It
 	var buff bytes.Buffer
 	return info,
 		hugio.ToReadCloser(&buff),
-		afero.WriteReader(c.Fs, id, io.TeeReader(r, &buff))
+		c.writeReader(id, io.TeeReader(r, &buff))
+}
+
+func (c *Cache) writeReader(id string, r io.Reader) error {
+	dir := filepath.Dir(id)
+	if dir != "" {
+		_ = c.Fs.MkdirAll(dir, 0o777)
+	}
+	f, err := c.Fs.Create(id)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	_, _ = io.Copy(f, r)
+
+	return nil
 }

 // GetOrCreateBytes is the same as GetOrCreate, but produces a byte slice.
@@ -253,9 +279,10 @@ func (c *Cache) GetOrCreateBytes(id string, create func() ([]byte, error)) (Item
 		return info, b, nil
 	}

-	if err := afero.WriteReader(c.Fs, id, bytes.NewReader(b)); err != nil {
+	if err := c.writeReader(id, bytes.NewReader(b)); err != nil {
 		return info, nil, err
 	}
+
 	return info, b, nil
 }

@@ -305,16 +332,8 @@ func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
 		return nil
 	}

-	if c.maxAge > 0 {
-		fi, err := c.Fs.Stat(id)
-		if err != nil {
-			return nil
-		}
-
-		if c.isExpired(fi.ModTime()) {
-			c.Fs.Remove(id)
-			return nil
-		}
+	if removed, err := c.removeIfExpired(id); err != nil || removed {
+		return nil
 	}

 	f, err := c.Fs.Open(id)
@@ -325,6 +344,49 @@ func (c *Cache) getOrRemove(id string) hugio.ReadSeekCloser {
 	return f
 }

+func (c *Cache) getBytesAndRemoveIfExpired(id string) ([]byte, bool) {
+	if c.maxAge == 0 {
+		// No caching.
+		return nil, false
+	}
+
+	f, err := c.Fs.Open(id)
+	if err != nil {
+		return nil, false
+	}
+	defer f.Close()
+
+	b, err := io.ReadAll(f)
+	if err != nil {
+		return nil, false
+	}
+
+	removed, err := c.removeIfExpired(id)
+	if err != nil {
+		return nil, false
+	}
+
+	return b, removed
+}
+
+func (c *Cache) removeIfExpired(id string) (bool, error) {
+	if c.maxAge <= 0 {
+		return false, nil
+	}
+
+	fi, err := c.Fs.Stat(id)
+	if err != nil {
+		return false, err
+	}
+
+	if c.isExpired(fi.ModTime()) {
+		c.Fs.Remove(id)
+		return true, nil
+	}
+
+	return false, nil
+}
+
 func (c *Cache) isExpired(modTime time.Time) bool {
 	if c.maxAge < 0 {
 		return false
@@ -398,3 +460,37 @@ func NewCaches(p *helpers.PathSpec) (Caches, error) {
 func cleanID(name string) string {
 	return strings.TrimPrefix(filepath.Clean(name), helpers.FilePathSeparator)
 }
+
+// AsHTTPCache returns an httpcache.Cache implementation for this file cache.
+// Note that none of the methods are protected by named locks, so you need to make sure
+// to do that in your own code.
+func (c *Cache) AsHTTPCache() httpcache.Cache {
+	return &httpCache{c: c}
+}
+
+type httpCache struct {
+	c *Cache
+}
+
+func (h *httpCache) Get(id string) (resp []byte, ok bool) {
+	id = cleanID(id)
+	b, removed := h.c.getBytesAndRemoveIfExpired(id)
+
+	return b, !removed
+}
+
+func (h *httpCache) Set(id string, resp []byte) {
+	if h.c.maxAge == 0 {
+		return
+	}
+
+	id = cleanID(id)
+
+	if err := h.c.writeReader(id, bytes.NewReader(resp)); err != nil {
+		panic(err)
+	}
+}
+
+func (h *httpCache) Delete(key string) {
+	h.c.Fs.Remove(key)
+}
@@ -0,0 +1,208 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package httpcache
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/gobwas/glob"
+	"github.com/gohugoio/hugo/common/predicate"
+	"github.com/gohugoio/hugo/config"
+	"github.com/mitchellh/mapstructure"
+)
+
+// DefaultConfig holds the default configuration for the HTTP cache.
+var DefaultConfig = Config{
+	Cache: Cache{
+		For: GlobMatcher{
+			Excludes: []string{"**"},
+		},
+	},
+	Polls: []PollConfig{
+		{
+			For: GlobMatcher{
+				Includes: []string{"**"},
+			},
+			Disable: true,
+		},
+	},
+}
+
+// Config holds the configuration for the HTTP cache.
+type Config struct {
+	// Configures the HTTP cache behaviour (RFC 9111).
+	// When this is not enabled for a resource, Hugo will go straight to the file cache.
+	Cache Cache
+
+	// Polls holds a list of configurations for polling remote resources to detect changes in watch mode.
+	// This can be disabled for some resources, typically if they are known to not change.
+	Polls []PollConfig
+}
+
+type Cache struct {
+	// Enable HTTP cache behaviour (RFC 9111) for these rsources.
+	For GlobMatcher
+}
+
+func (c *Config) Compile() (ConfigCompiled, error) {
+	var cc ConfigCompiled
+
+	p, err := c.Cache.For.CompilePredicate()
+	if err != nil {
+		return cc, err
+	}
+
+	cc.For = p
+
+	for _, pc := range c.Polls {
+
+		p, err := pc.For.CompilePredicate()
+		if err != nil {
+			return cc, err
+		}
+
+		cc.PollConfigs = append(cc.PollConfigs, PollConfigCompiled{
+			For:    p,
+			Config: pc,
+		})
+	}
+
+	return cc, nil
+}
+
+// PollConfig holds the configuration for polling remote resources to detect changes in watch mode.
+// TODO1 make sure this enabled only in watch mode.
+type PollConfig struct {
+	// What remote resources to apply this configuration to.
+	For GlobMatcher
+
+	// Disable polling for this configuration.
+	Disable bool
+
+	// Low is the lower bound for the polling interval.
+	// This is the starting point when the resource has recently changed,
+	// if that resource stops changing, the polling interval will gradually increase towards High.
+	Low time.Duration
+
+	// High is the upper bound for the polling interval.
+	// This is the interval used when the resource is stable.
+	High time.Duration
+}
+
+func (c PollConfig) MarshalJSON() (b []byte, err error) {
+	// Marshal the durations as strings.
+	type Alias PollConfig
+	return json.Marshal(&struct {
+		Low  string
+		High string
+		Alias
+	}{
+		Low:   c.Low.String(),
+		High:  c.High.String(),
+		Alias: (Alias)(c),
+	})
+}
+
+type GlobMatcher struct {
+	// Excludes holds a list of glob patterns that will be excluded.
+	Excludes []string
+
+	// Includes holds a list of glob patterns that will be included.
+	Includes []string
+}
+
+type ConfigCompiled struct {
+	For         predicate.P[string]
+	PollConfigs []PollConfigCompiled
+}
+
+func (c *ConfigCompiled) PollConfigFor(s string) PollConfigCompiled {
+	for _, pc := range c.PollConfigs {
+		if pc.For(s) {
+			return pc
+		}
+	}
+	return PollConfigCompiled{}
+}
+
+func (c *ConfigCompiled) IsPollingDisabled() bool {
+	for _, pc := range c.PollConfigs {
+		if !pc.Config.Disable {
+			return false
+		}
+	}
+	return true
+}
+
+type PollConfigCompiled struct {
+	For    predicate.P[string]
+	Config PollConfig
+}
+
+func (p PollConfigCompiled) IsZero() bool {
+	return p.For == nil
+}
+
+func (gm *GlobMatcher) CompilePredicate() (func(string) bool, error) {
+	var p predicate.P[string]
+	for _, include := range gm.Includes {
+		g, err := glob.Compile(include, '/')
+		if err != nil {
+			return nil, err
+		}
+		fn := func(s string) bool {
+			return g.Match(s)
+		}
+		p = p.Or(fn)
+	}
+
+	for _, exclude := range gm.Excludes {
+		g, err := glob.Compile(exclude, '/')
+		if err != nil {
+			return nil, err
+		}
+		fn := func(s string) bool {
+			return !g.Match(s)
+		}
+		p = p.And(fn)
+	}
+
+	return p, nil
+}
+
+func DecodeConfig(bcfg config.BaseConfig, m map[string]any) (Config, error) {
+	if len(m) == 0 {
+		return DefaultConfig, nil
+	}
+
+	var c Config
+
+	dc := &mapstructure.DecoderConfig{
+		Result:           &c,
+		DecodeHook:       mapstructure.StringToTimeDurationHookFunc(),
+		WeaklyTypedInput: true,
+	}
+
+	decoder, err := mapstructure.NewDecoder(dc)
+	if err != nil {
+		return c, err
+	}
+
+	if err := decoder.Decode(m); err != nil {
+		return c, err
+	}
+
+	return c, nil
+}
@@ -0,0 +1,64 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package httpcache_test
+
+import (
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/hugolib"
+)
+
+func TestConfigCustom(t *testing.T) {
+	files := `
+-- hugo.toml --
+[httpcache]
+[httpcache.cache.for]
+includes = ["**gohugo.io**"]
+[[httpcache.polls]]
+low = "5s"
+high = "32s"
+[httpcache.polls.for]
+includes = ["**gohugo.io**"]
+		
+	
+`
+
+	b := hugolib.Test(t, files)
+
+	httpcacheConf := b.H.Configs.Base.HTTPCache
+	compiled := b.H.Configs.Base.C.HTTPCache
+
+	b.Assert(httpcacheConf.Cache.For.Includes, qt.DeepEquals, []string{"**gohugo.io**"})
+	b.Assert(httpcacheConf.Cache.For.Excludes, qt.IsNil)
+
+	pc := compiled.PollConfigFor("https://gohugo.io/foo.jpg")
+	b.Assert(pc.Config.Low, qt.Equals, 5*time.Second)
+	b.Assert(pc.Config.High, qt.Equals, 32*time.Second)
+	b.Assert(compiled.PollConfigFor("https://example.com/foo.jpg").IsZero(), qt.IsTrue)
+}
+
+func TestConfigDefault(t *testing.T) {
+	files := `
+-- hugo.toml --
+`
+	b := hugolib.Test(t, files)
+
+	compiled := b.H.Configs.Base.C.HTTPCache
+
+	b.Assert(compiled.For("https://gohugo.io/posts.json"), qt.IsFalse)
+	b.Assert(compiled.For("https://gohugo.io/foo.jpg"), qt.IsFalse)
+	b.Assert(compiled.PollConfigFor("https://gohugo.io/foo.jpg").Config.Disable, qt.IsTrue)
+}
@@ -0,0 +1,42 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package httpcache
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestGlobMatcher(t *testing.T) {
+	c := qt.New(t)
+
+	g := GlobMatcher{
+		Includes: []string{"**/*.jpg", "**.png", "**/bar/**"},
+		Excludes: []string{"**/foo.jpg", "**.css"},
+	}
+
+	p, err := g.CompilePredicate()
+	c.Assert(err, qt.IsNil)
+
+	c.Assert(p("foo.jpg"), qt.IsFalse)
+	c.Assert(p("foo.png"), qt.IsTrue)
+	c.Assert(p("foo/bar.jpg"), qt.IsTrue)
+	c.Assert(p("foo/bar.png"), qt.IsTrue)
+	c.Assert(p("foo/bar/foo.jpg"), qt.IsFalse)
+	c.Assert(p("foo/bar/foo.css"), qt.IsFalse)
+	c.Assert(p("foo.css"), qt.IsFalse)
+	c.Assert(p("foo/bar/foo.css"), qt.IsFalse)
+	c.Assert(p("foo/bar/foo.xml"), qt.IsTrue)
+}
@@ -48,6 +48,8 @@ import (
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/identity"
+	"github.com/gohugoio/hugo/resources/kinds"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 )
@@ -102,6 +104,9 @@ type rootCommand struct {
 	commonConfigs *lazycache.Cache[int32, *commonConfig]
 	hugoSites     *lazycache.Cache[int32, *hugolib.HugoSites]

+	// changesFromBuild received from Hugo in watch mode.
+	changesFromBuild chan []identity.Identity
+
 	commands []simplecobra.Commander

 	// Flags
@@ -127,6 +132,7 @@ type rootCommand struct {
 	verbose bool
 	debug   bool
 	quiet   bool
+	devMode bool // Hidden flag.

 	renderToMemory bool

@@ -302,7 +308,7 @@ func (r *rootCommand) ConfigFromProvider(key int32, cfg config.Provider) (*commo

 func (r *rootCommand) HugFromConfig(conf *commonConfig) (*hugolib.HugoSites, error) {
 	h, _, err := r.hugoSites.GetOrCreate(r.configVersionID.Load(), func(key int32) (*hugolib.HugoSites, error) {
-		depsCfg := deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level()}
+		depsCfg := r.newDepsConfig(conf)
 		return hugolib.NewHugoSites(depsCfg)
 	})
 	return h, err
@@ -314,23 +320,27 @@ func (r *rootCommand) Hugo(cfg config.Provider) (*hugolib.HugoSites, error) {
 		if err != nil {
 			return nil, err
 		}
-		depsCfg := deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level()}
+		depsCfg := r.newDepsConfig(conf)
 		return hugolib.NewHugoSites(depsCfg)
 	})
 	return h, err
 }

+func (r *rootCommand) newDepsConfig(conf *commonConfig) deps.DepsCfg {
+	return deps.DepsCfg{Configs: conf.configs, Fs: conf.fs, LogOut: r.logger.Out(), LogLevel: r.logger.Level(), ChangesFromBuild: r.changesFromBuild}
+}
+
 func (r *rootCommand) Name() string {
 	return "hugo"
 }

 func (r *rootCommand) Run(ctx context.Context, cd *simplecobra.Commandeer, args []string) error {
-	if !r.buildWatch {
-		defer r.timeTrack(time.Now(), "Total")
-	}
-
 	b := newHugoBuilder(r, nil)

+	if !r.buildWatch {
+		defer b.postBuild("Total", time.Now())
+	}
+
 	if err := b.loadConfig(cd, false); err != nil {
 		return err
 	}
@@ -406,6 +416,8 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 		return err
 	}

+	r.changesFromBuild = make(chan []identity.Identity, 10)
+
 	r.commonConfigs = lazycache.New(lazycache.Options[int32, *commonConfig]{MaxEntries: 5})
 	// We don't want to keep stale HugoSites in memory longer than needed.
 	r.hugoSites = lazycache.New(lazycache.Options[int32, *hugolib.HugoSites]{
@@ -422,29 +434,33 @@ func (r *rootCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 func (r *rootCommand) createLogger(running bool) (loggers.Logger, error) {
 	level := logg.LevelWarn

-	if r.logLevel != "" {
-		switch strings.ToLower(r.logLevel) {
-		case "debug":
-			level = logg.LevelDebug
-		case "info":
-			level = logg.LevelInfo
-		case "warn", "warning":
-			level = logg.LevelWarn
-		case "error":
-			level = logg.LevelError
-		default:
-			return nil, fmt.Errorf("invalid log level: %q, must be one of debug, warn, info or error", r.logLevel)
-		}
+	if r.devMode {
+		level = logg.LevelTrace
 	} else {
-		if r.verbose {
-			hugo.Deprecate("--verbose", "use --logLevel info", "v0.114.0")
-			hugo.Deprecate("--verbose", "use --logLevel info", "v0.114.0")
-			level = logg.LevelInfo
-		}
+		if r.logLevel != "" {
+			switch strings.ToLower(r.logLevel) {
+			case "debug":
+				level = logg.LevelDebug
+			case "info":
+				level = logg.LevelInfo
+			case "warn", "warning":
+				level = logg.LevelWarn
+			case "error":
+				level = logg.LevelError
+			default:
+				return nil, fmt.Errorf("invalid log level: %q, must be one of debug, warn, info or error", r.logLevel)
+			}
+		} else {
+			if r.verbose {
+				hugo.Deprecate("--verbose", "use --logLevel info", "v0.114.0")
+				hugo.Deprecate("--verbose", "use --logLevel info", "v0.114.0")
+				level = logg.LevelInfo
+			}

-		if r.debug {
-			hugo.Deprecate("--debug", "use --logLevel debug", "v0.114.0")
-			level = logg.LevelDebug
+			if r.debug {
+				hugo.Deprecate("--debug", "use --logLevel debug", "v0.114.0")
+				level = logg.LevelDebug
+			}
 		}
 	}

@@ -482,47 +498,50 @@ Complete documentation is available at https://gohugo.io/.`

 	// Configure persistent flags
 	cmd.PersistentFlags().StringVarP(&r.source, "source", "s", "", "filesystem path to read files relative from")
-	cmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.MarkFlagDirname("source")
 	cmd.PersistentFlags().StringP("destination", "d", "", "filesystem path to write files to")
-	cmd.PersistentFlags().SetAnnotation("destination", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.MarkFlagDirname("destination")

 	cmd.PersistentFlags().StringVarP(&r.environment, "environment", "e", "", "build environment")
+	_ = cmd.RegisterFlagCompletionFunc("environment", cobra.NoFileCompletions)
 	cmd.PersistentFlags().StringP("themesDir", "", "", "filesystem path to themes directory")
+	_ = cmd.MarkFlagDirname("themesDir")
 	cmd.PersistentFlags().StringP("ignoreVendorPaths", "", "", "ignores any _vendor for module paths matching the given Glob pattern")
+	_ = cmd.RegisterFlagCompletionFunc("ignoreVendorPaths", cobra.NoFileCompletions)
 	cmd.PersistentFlags().String("clock", "", "set the clock used by Hugo, e.g. --clock 2021-11-06T22:30:00.00+09:00")
+	_ = cmd.RegisterFlagCompletionFunc("clock", cobra.NoFileCompletions)

 	cmd.PersistentFlags().StringVar(&r.cfgFile, "config", "", "config file (default is hugo.yaml|json|toml)")
+	_ = cmd.MarkFlagFilename("config", config.ValidConfigFileExtensions...)
 	cmd.PersistentFlags().StringVar(&r.cfgDir, "configDir", "config", "config dir")
+	_ = cmd.MarkFlagDirname("configDir")
 	cmd.PersistentFlags().BoolVar(&r.quiet, "quiet", false, "build in quiet mode")
-	cmd.PersistentFlags().BoolVar(&r.renderToMemory, "renderToMemory", false, "render to memory (mostly useful when running the server)")
-
-	// Set bash-completion
-	_ = cmd.PersistentFlags().SetAnnotation("config", cobra.BashCompFilenameExt, config.ValidConfigFileExtensions)
+	cmd.PersistentFlags().BoolVarP(&r.renderToMemory, "renderToMemory", "M", false, "render to memory (mostly useful when running the server)")

 	cmd.PersistentFlags().BoolVarP(&r.verbose, "verbose", "v", false, "verbose output")
 	cmd.PersistentFlags().BoolVarP(&r.debug, "debug", "", false, "debug output")
+	cmd.PersistentFlags().BoolVarP(&r.devMode, "devMode", "", false, "only used for internal testing, flag hidden.")
 	cmd.PersistentFlags().StringVar(&r.logLevel, "logLevel", "", "log level (debug|info|warn|error)")
+	_ = cmd.RegisterFlagCompletionFunc("logLevel", cobra.FixedCompletions([]string{"debug", "info", "warn", "error"}, cobra.ShellCompDirectiveNoFileComp))
 	cmd.Flags().BoolVarP(&r.buildWatch, "watch", "w", false, "watch filesystem for changes and recreate as needed")

+	cmd.PersistentFlags().MarkHidden("devMode")
+
 	// Configure local flags
 	applyLocalFlagsBuild(cmd, r)

-	// Set bash-completion.
-	// Each flag must first be defined before using the SetAnnotation() call.
-	_ = cmd.Flags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
-
 	return nil
 }

 // A sub set of the complete build flags. These flags are used by new and mod.
 func applyLocalFlagsBuildConfig(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().StringSliceP("theme", "t", []string{}, "themes to use (located in /themes/THEMENAME/)")
+	_ = cmd.MarkFlagDirname("theme")
 	cmd.Flags().StringVarP(&r.baseURL, "baseURL", "b", "", "hostname (and path) to the root, e.g. https://spf13.com/")
 	cmd.Flags().StringP("cacheDir", "", "", "filesystem path to cache directory")
-	_ = cmd.Flags().SetAnnotation("cacheDir", cobra.BashCompSubdirsInDir, []string{})
+	_ = cmd.MarkFlagDirname("cacheDir")
 	cmd.Flags().StringP("contentDir", "c", "", "filesystem path to content directory")
 	cmd.Flags().StringSliceP("renderSegments", "", []string{}, "named segments to render (configured in the segments config)")
-	_ = cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
 }

 // Flags needed to do a build (used by hugo and hugo server commands)
@@ -535,8 +554,10 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().BoolP("ignoreCache", "", false, "ignores the cache directory")
 	cmd.Flags().Bool("enableGitInfo", false, "add Git revision, date, author, and CODEOWNERS info to the pages")
 	cmd.Flags().StringP("layoutDir", "l", "", "filesystem path to layout directory")
+	_ = cmd.MarkFlagDirname("layoutDir")
 	cmd.Flags().BoolVar(&r.gc, "gc", false, "enable to run some cleanup tasks (remove unused cache files) after the build")
 	cmd.Flags().StringVar(&r.poll, "poll", "", "set this to a poll interval, e.g --poll 700ms, to use a poll based approach to watch for file system changes")
+	_ = cmd.RegisterFlagCompletionFunc("poll", cobra.NoFileCompletions)
 	cmd.Flags().Bool("panicOnWarning", false, "panic on first WARNING log")
 	cmd.Flags().Bool("templateMetrics", false, "display metrics about template executions")
 	cmd.Flags().Bool("templateMetricsHints", false, "calculate some improvement hints when combined with --templateMetrics")
@@ -559,8 +580,8 @@ func applyLocalFlagsBuild(cmd *cobra.Command, r *rootCommand) {
 	cmd.Flags().MarkHidden("profile-mutex")

 	cmd.Flags().StringSlice("disableKinds", []string{}, "disable different kind of pages (home, RSS etc.)")
+	_ = cmd.RegisterFlagCompletionFunc("disableKinds", cobra.FixedCompletions(kinds.AllKinds, cobra.ShellCompDirectiveNoFileComp))
 	cmd.Flags().Bool("minify", false, "minify any supported output format (HTML, XML etc.)")
-	_ = cmd.Flags().SetAnnotation("destination", cobra.BashCompSubdirsInDir, []string{})
 }

 func (r *rootCommand) timeTrack(start time.Time, name string) {
@@ -28,6 +28,7 @@ import (
 	"github.com/gohugoio/hugo/modules"
 	"github.com/gohugoio/hugo/parser"
 	"github.com/gohugoio/hugo/parser/metadecoders"
+	"github.com/spf13/cobra"
 )

 // newConfigCommand creates a new config command and its subcommands.
@@ -112,7 +113,9 @@ func (c *configCommand) Init(cd *simplecobra.Commandeer) error {
 	cmd.Short = "Print the site configuration"
 	cmd.Long = `Print the site configuration, both default and custom settings.`
 	cmd.Flags().StringVar(&c.format, "format", "toml", "preferred file format (toml, yaml or json)")
+	_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
 	cmd.Flags().StringVar(&c.lang, "lang", "", "the language to display config for. Defaults to the first language defined.")
+	_ = cmd.RegisterFlagCompletionFunc("lang", cobra.NoFileCompletions)
 	applyLocalFlagsBuildConfig(cmd, c.r)

 	return nil
@@ -223,6 +226,7 @@ func (c *configMountsCommand) Init(cd *simplecobra.Commandeer) error {
 	c.r = cd.Root.Command.(*rootCommand)
 	cmd := cd.CobraCommand
 	cmd.Short = "Print the configured file mounts"
+	cmd.ValidArgsFunction = cobra.NoFileCompletions
 	applyLocalFlagsBuildConfig(cmd, c.r)
 	return nil
 }
@@ -46,6 +46,7 @@ to use JSON for the front matter.`,
 					return c.convertContents(metadecoders.JSON)
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 				},
 			},
 			&simpleCommand{
@@ -57,6 +58,7 @@ to use TOML for the front matter.`,
 					return c.convertContents(metadecoders.TOML)
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 				},
 			},
 			&simpleCommand{
@@ -68,6 +70,7 @@ to use YAML for the front matter.`,
 					return c.convertContents(metadecoders.YAML)
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 				},
 			},
 		},
@@ -108,6 +111,7 @@ func (c *convertCommand) Init(cd *simplecobra.Commandeer) error {
 See convert's subcommands toJSON, toTOML and toYAML for more information.`

 	cmd.PersistentFlags().StringVarP(&c.outputDir, "output", "o", "", "filesystem path to write files to")
+	_ = cmd.MarkFlagDirname("output")
 	cmd.PersistentFlags().BoolVar(&c.unsafe, "unsafe", false, "enable less safe operations, please backup first")

 	cmd.RunE = nil
@@ -60,13 +60,17 @@ documentation.
 			return deployer.Deploy(ctx)
 		},
 		withc: func(cmd *cobra.Command, r *rootCommand) {
+			cmd.ValidArgsFunction = cobra.NoFileCompletions
 			cmd.Flags().String("target", "", "target deployment from deployments section in config file; defaults to the first one")
+			_ = cmd.RegisterFlagCompletionFunc("target", cobra.NoFileCompletions)
 			cmd.Flags().Bool("confirm", false, "ask for confirmation before making changes to the target")
 			cmd.Flags().Bool("dryRun", false, "dry run")
 			cmd.Flags().Bool("force", false, "force upload of all files")
 			cmd.Flags().Bool("invalidateCDN", deployconfig.DefaultConfig.InvalidateCDN, "invalidate the CDN cache listed in the deployment target")
 			cmd.Flags().Int("maxDeletes", deployconfig.DefaultConfig.MaxDeletes, "maximum # of files to delete, or -1 to disable")
+			_ = cmd.RegisterFlagCompletionFunc("maxDeletes", cobra.NoFileCompletions)
 			cmd.Flags().Int("workers", deployconfig.DefaultConfig.Workers, "number of workers to transfer files. defaults to 10")
+			_ = cmd.RegisterFlagCompletionFunc("workers", cobra.NoFileCompletions)
 		},
 	}
 }
@@ -19,6 +19,7 @@ import (

 	"github.com/bep/simplecobra"
 	"github.com/gohugoio/hugo/common/hugo"
+	"github.com/spf13/cobra"
 )

 func newEnvCommand() simplecobra.Commander {
@@ -47,6 +48,9 @@ func newEnvCommand() simplecobra.Commander {
 			}
 			return nil
 		},
+		withc: func(cmd *cobra.Command, r *rootCommand) {
+			cmd.ValidArgsFunction = cobra.NoFileCompletions
+		},
 	}
 }

@@ -59,5 +63,8 @@ func newVersionCmd() simplecobra.Commander {
 		},
 		short: "Print Hugo version and environment info",
 		long:  "Print Hugo version and environment info. This is useful in Hugo bug reports.",
+		withc: func(cmd *cobra.Command, r *rootCommand) {
+			cmd.ValidArgsFunction = cobra.NoFileCompletions
+		},
 	}
 }
@@ -45,9 +45,10 @@ func newGenCommand() *genCommand {
 		genmandir string

 		// Chroma flags.
-		style          string
-		highlightStyle string
-		linesStyle     string
+		style                  string
+		highlightStyle         string
+		lineNumbersInlineStyle string
+		lineNumbersTableStyle  string
 	)

 	newChromaStyles := func() simplecobra.Commander {
@@ -63,8 +64,11 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				if highlightStyle != "" {
 					builder.Add(chroma.LineHighlight, highlightStyle)
 				}
-				if linesStyle != "" {
-					builder.Add(chroma.LineNumbers, linesStyle)
+				if lineNumbersInlineStyle != "" {
+					builder.Add(chroma.LineNumbers, lineNumbersInlineStyle)
+				}
+				if lineNumbersTableStyle != "" {
+					builder.Add(chroma.LineNumbersTable, lineNumbersTableStyle)
 				}
 				style, err := builder.Build()
 				if err != nil {
@@ -75,9 +79,15 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				return nil
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
+				cmd.ValidArgsFunction = cobra.NoFileCompletions
 				cmd.PersistentFlags().StringVar(&style, "style", "friendly", "highlighter style (see https://xyproto.github.io/splash/docs/)")
-				cmd.PersistentFlags().StringVar(&highlightStyle, "highlightStyle", "", "style used for highlighting lines (see https://github.com/alecthomas/chroma)")
-				cmd.PersistentFlags().StringVar(&linesStyle, "linesStyle", "", "style used for line numbers (see https://github.com/alecthomas/chroma)")
+				_ = cmd.RegisterFlagCompletionFunc("style", cobra.NoFileCompletions)
+				cmd.PersistentFlags().StringVar(&highlightStyle, "highlightStyle", "", `foreground and background colors for highlighted lines, e.g. --highlightStyle "#fff000 bg:#000fff"`)
+				_ = cmd.RegisterFlagCompletionFunc("highlightStyle", cobra.NoFileCompletions)
+				cmd.PersistentFlags().StringVar(&lineNumbersInlineStyle, "lineNumbersInlineStyle", "", `foreground and background colors for inline line numbers, e.g. --lineNumbersInlineStyle "#fff000 bg:#000fff"`)
+				_ = cmd.RegisterFlagCompletionFunc("lineNumbersInlineStyle", cobra.NoFileCompletions)
+				cmd.PersistentFlags().StringVar(&lineNumbersTableStyle, "lineNumbersTableStyle", "", `foreground and background colors for table line numbers, e.g. --lineNumbersTableStyle "#fff000 bg:#000fff"`)
+				_ = cmd.RegisterFlagCompletionFunc("lineNumbersTableStyle", cobra.NoFileCompletions)
 			},
 		}
 	}
@@ -115,9 +125,9 @@ See https://xyproto.github.io/splash/docs/all.html for a preview of the availabl
 				return nil
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
+				cmd.ValidArgsFunction = cobra.NoFileCompletions
 				cmd.PersistentFlags().StringVar(&genmandir, "dir", "man/", "the directory to write the man pages.")
-				// For bash-completion
-				cmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
+				_ = cmd.MarkFlagDirname("dir")
 			},
 		}
 	}
@@ -172,9 +182,9 @@ url: %s
 				return nil
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
+				cmd.ValidArgsFunction = cobra.NoFileCompletions
 				cmd.PersistentFlags().StringVar(&gendocdir, "dir", "/tmp/hugodoc/", "the directory to write the doc.")
-				// For bash-completion
-				cmd.PersistentFlags().SetAnnotation("dir", cobra.BashCompSubdirsInDir, []string{})
+				_ = cmd.MarkFlagDirname("dir")
 			},
 		}
 	}
@@ -227,6 +237,7 @@ url: %s
 			},
 			withc: func(cmd *cobra.Command, r *rootCommand) {
 				cmd.Hidden = true
+				cmd.ValidArgsFunction = cobra.NoFileCompletions
 				cmd.PersistentFlags().StringVarP(&docsHelperTarget, "dir", "", "docs/data", "data dir")
 			},
 		}
@@ -43,6 +43,7 @@ import (
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/hugolib/filesystems"
+	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/livereload"
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/watcher"
@@ -75,9 +76,14 @@ type hugoBuilder struct {
 	errState hugoBuilderErrState
 }

+var errConfigNotSet = errors.New("config not set")
+
 func (c *hugoBuilder) withConfE(fn func(conf *commonConfig) error) error {
 	c.confmu.Lock()
 	defer c.confmu.Unlock()
+	if c.conf == nil {
+		return errConfigNotSet
+	}
 	return fn(c.conf)
 }

@@ -338,6 +344,27 @@ func (c *hugoBuilder) newWatcher(pollIntervalStr string, dirList ...string) (*wa
 	go func() {
 		for {
 			select {
+			case changes := <-c.r.changesFromBuild:
+				c.errState.setBuildErr(nil)
+				unlock, err := h.LockBuild()
+				if err != nil {
+					c.r.logger.Errorln("Failed to acquire a build lock: %s", err)
+					return
+				}
+				c.changeDetector.PrepareNew()
+				err = c.rebuildSitesForChanges(changes)
+				if err != nil {
+					c.r.logger.Errorln("Error while watching:", err)
+				}
+				if c.s != nil && c.s.doLiveReload {
+					doReload := c.changeDetector == nil || len(c.changeDetector.changed()) > 0
+					doReload = doReload || c.showErrorInBrowser && c.errCount() > 0
+					if doReload {
+						livereload.ForceRefresh()
+					}
+				}
+				unlock()
+
 			case evs := <-watcher.Events:
 				unlock, err := h.LockBuild()
 				if err != nil {
@@ -585,7 +612,7 @@ func (c *hugoBuilder) fullRebuild(changeType string) {
 			time.Sleep(2 * time.Second)
 		}()

-		defer c.r.timeTrack(time.Now(), "Rebuilt")
+		defer c.postBuild("Rebuilt", time.Now())

 		err := c.reloadConfig()
 		if err != nil {
@@ -849,13 +876,13 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 			h.BaseFs.SourceFilesystems,
 			dynamicEvents)

-		onePageName := pickOneWriteOrCreatePath(partitionedEvents.ContentEvents)
+		onePageName := pickOneWriteOrCreatePath(h.Conf.ContentTypes(), partitionedEvents.ContentEvents)

 		c.printChangeDetected("")
 		c.changeDetector.PrepareNew()

 		func() {
-			defer c.r.timeTrack(time.Now(), "Total")
+			defer c.postBuild("Total", time.Now())
 			if err := c.rebuildSites(dynamicEvents); err != nil {
 				c.handleBuildErr(err, "Rebuild failed")
 			}
@@ -901,6 +928,13 @@ func (c *hugoBuilder) handleEvents(watcher *watcher.Batcher,
 	}
 }

+func (c *hugoBuilder) postBuild(what string, start time.Time) {
+	if h, err := c.hugo(); err == nil && h.Conf.Running() {
+		h.LogServerAddresses()
+	}
+	c.r.timeTrack(start, what)
+}
+
 func (c *hugoBuilder) hugo() (*hugolib.HugoSites, error) {
 	var h *hugolib.HugoSites
 	if err := c.withConfE(func(conf *commonConfig) error {
@@ -1007,6 +1041,19 @@ func (c *hugoBuilder) rebuildSites(events []fsnotify.Event) error {
 	return h.Build(hugolib.BuildCfg{NoBuildLock: true, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()}, events...)
 }

+func (c *hugoBuilder) rebuildSitesForChanges(ids []identity.Identity) error {
+	c.errState.setBuildErr(nil)
+	h, err := c.hugo()
+	if err != nil {
+		return err
+	}
+	whatChanged := &hugolib.WhatChanged{}
+	whatChanged.Add(ids...)
+	err = h.Build(hugolib.BuildCfg{NoBuildLock: true, WhatChanged: whatChanged, RecentlyVisited: c.visitedURLs, ErrRecovery: c.errState.wasErr()})
+	c.errState.setBuildErr(err)
+	return err
+}
+
 func (c *hugoBuilder) reloadConfig() error {
 	c.r.Reset()
 	c.r.configVersionID.Add(1)
@@ -58,6 +58,7 @@ Import from Jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root
 					return c.importFromJekyll(args)
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					cmd.Flags().BoolVar(&c.force, "force", false, "allow import into non-empty target directory")
 				},
 			},
@@ -26,6 +26,7 @@ import (
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/resources/resource"
+	"github.com/spf13/cobra"
 )

 // newListCommand creates a new list command and its subcommands.
@@ -40,6 +41,8 @@ func newListCommand() *listCommand {
 			p.PublishDate().Format(time.RFC3339),
 			strconv.FormatBool(p.Draft()),
 			p.Permalink(),
+			p.Kind(),
+			p.Section(),
 		}
 	}

@@ -66,6 +69,8 @@ func newListCommand() *listCommand {
 			"publishDate",
 			"draft",
 			"permalink",
+			"kind",
+			"section",
 		})

 		for _, p := range h.Pages() {
@@ -74,9 +79,6 @@ func newListCommand() *listCommand {
 				if err := writer.Write(record); err != nil {
 					return err
 				}
-				if err != nil {
-					return err
-				}
 			}
 		}

@@ -87,8 +89,8 @@ func newListCommand() *listCommand {
 		commands: []simplecobra.Commander{
 			&simpleCommand{
 				name:  "drafts",
-				short: "List all drafts",
-				long:  `List all of the drafts in your content directory.`,
+				short: "List draft content",
+				long:  `List draft content.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					shouldInclude := func(p page.Page) bool {
 						if !p.Draft() || p.File() == nil {
@@ -102,11 +104,14 @@ func newListCommand() *listCommand {
 						"buildExpired", true,
 					)
 				},
+				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
+				},
 			},
 			&simpleCommand{
 				name:  "future",
-				short: "List all posts dated in the future",
-				long:  `List all of the posts in your content directory which will be posted in the future.`,
+				short: "List future content",
+				long:  `List content with a future publication date.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					shouldInclude := func(p page.Page) bool {
 						if !resource.IsFuture(p) || p.File() == nil {
@@ -119,11 +124,14 @@ func newListCommand() *listCommand {
 						"buildDrafts", true,
 					)
 				},
+				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
+				},
 			},
 			&simpleCommand{
 				name:  "expired",
-				short: "List all posts already expired",
-				long:  `List all of the posts in your content directory which has already expired.`,
+				short: "List expired content",
+				long:  `List content with a past expiration date.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					shouldInclude := func(p page.Page) bool {
 						if !resource.IsExpired(p) || p.File() == nil {
@@ -136,17 +144,37 @@ func newListCommand() *listCommand {
 						"buildDrafts", true,
 					)
 				},
+				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
+				},
 			},
 			&simpleCommand{
 				name:  "all",
-				short: "List all posts",
-				long:  `List all of the posts in your content directory, include drafts, future and expired pages.`,
+				short: "List all content",
+				long:  `List all content including draft, future, and expired.`,
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					shouldInclude := func(p page.Page) bool {
 						return p.File() != nil
 					}
 					return list(cd, r, shouldInclude, "buildDrafts", true, "buildFuture", true, "buildExpired", true)
 				},
+				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
+				},
+			},
+			&simpleCommand{
+				name:  "published",
+				short: "List published content",
+				long:  `List content that is not draft, future, or expired.`,
+				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
+					shouldInclude := func(p page.Page) bool {
+						return !p.Draft() && !resource.IsFuture(p) && !resource.IsExpired(p) && p.File() != nil
+					}
+					return list(cd, r, shouldInclude)
+				},
+				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
+				},
 			},
 		},
 	}
@@ -62,6 +62,7 @@ removed from Hugo, but we need to test this out in "real life" to get a feel of
 so this may/will change in future versions of Hugo.
 `,
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					applyLocalFlagsBuildConfig(cmd, r)
 				},
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
@@ -89,6 +90,7 @@ so this may/will change in future versions of Hugo.
 	inside a subfolder on GitHub, as one example.
 	`,
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					applyLocalFlagsBuildConfig(cmd, r)
 				},
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
@@ -108,6 +110,7 @@ so this may/will change in future versions of Hugo.
 				short: "Verify dependencies.",
 				long:  `Verify checks that the dependencies of the current module, which are stored in a local downloaded source cache, have not been modified since being downloaded.`,
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					applyLocalFlagsBuildConfig(cmd, r)
 					cmd.Flags().BoolVarP(&clean, "clean", "", false, "delete module cache for dependencies that fail verification")
 				},
@@ -127,6 +130,7 @@ so this may/will change in future versions of Hugo.
 Note that for vendored modules, that is the version listed and not the one from go.mod.
 `,
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					applyLocalFlagsBuildConfig(cmd, r)
 					cmd.Flags().BoolVarP(&clean, "clean", "", false, "delete module cache for dependencies that fail verification")
 				},
@@ -144,8 +148,10 @@ Note that for vendored modules, that is the version listed and not the one from
 				short: "Delete the Hugo Module cache for the current project.",
 				long:  `Delete the Hugo Module cache for the current project.`,
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					applyLocalFlagsBuildConfig(cmd, r)
 					cmd.Flags().StringVarP(&pattern, "pattern", "", "", `pattern matching module paths to clean (all if not set), e.g. "**hugo*"`)
+					_ = cmd.RegisterFlagCompletionFunc("pattern", cobra.NoFileCompletions)
 					cmd.Flags().BoolVarP(&all, "all", "", false, "clean entire module cache")
 				},
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
@@ -167,6 +173,7 @@ Note that for vendored modules, that is the version listed and not the one from
 				name:  "tidy",
 				short: "Remove unused entries in go.mod and go.sum.",
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					applyLocalFlagsBuildConfig(cmd, r)
 				},
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
@@ -184,6 +191,7 @@ Note that for vendored modules, that is the version listed and not the one from
 	If a module is vendored, that is where Hugo will look for it's dependencies.
 	`,
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					applyLocalFlagsBuildConfig(cmd, r)
 				},
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
@@ -225,6 +233,7 @@ Run "go help get" for more information. All flags available for "go get" is also
 ` + commonUsageMod,
 				withc: func(cmd *cobra.Command, r *rootCommand) {
 					cmd.DisableFlagParsing = true
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 				},
 				run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
 					// We currently just pass on the flags we get to Go and
@@ -60,8 +60,15 @@ Ensure you run this within the root directory of your site.`,
 					return create.NewContent(h, contentType, args[0], force)
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+						if len(args) != 0 {
+							return []string{}, cobra.ShellCompDirectiveNoFileComp
+						}
+						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
+					}
 					cmd.Flags().StringVarP(&contentType, "kind", "k", "", "content type to create")
 					cmd.Flags().String("editor", "", "edit new content with this editor, if provided")
+					_ = cmd.RegisterFlagCompletionFunc("editor", cobra.NoFileCompletions)
 					cmd.Flags().BoolVarP(&force, "force", "f", false, "overwrite file if it already exists")
 					applyLocalFlagsBuildConfig(cmd, r)
 				},
@@ -103,8 +110,15 @@ Use ` + "`hugo new [contentPath]`" + ` to create new content.`,
 					return nil
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+						if len(args) != 0 {
+							return []string{}, cobra.ShellCompDirectiveNoFileComp
+						}
+						return []string{}, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveFilterDirs
+					}
 					cmd.Flags().BoolVarP(&force, "force", "f", false, "init inside non-empty directory")
 					cmd.Flags().StringVar(&format, "format", "toml", "preferred file format (toml, yaml or json)")
+					_ = cmd.RegisterFlagCompletionFunc("format", cobra.FixedCompletions([]string{"toml", "yaml", "json"}, cobra.ShellCompDirectiveNoFileComp))
 				},
 			},
 			&simpleCommand{
@@ -137,6 +151,9 @@ according to your needs.`,

 					return nil
 				},
+				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
+				},
 			},
 		},
 	}
@@ -192,7 +209,7 @@ func (c *newCommand) newSiteNextStepsText(path string, format string) string {
 1. Change the current directory to ` + path + `.
 2. Create or install a theme:
   - Create a new theme with the command "hugo new theme <THEMENAME>"
-   - Install a theme from https://themes.gohugo.io/
+   - Or, install a theme from https://themes.gohugo.io/
 3. Edit hugo.` + format + `, setting the "theme" property to the theme name.
 4. Create new content with the command "hugo new content `)

@@ -43,9 +43,11 @@ func newReleaseCommand() simplecobra.Commander {
 		},
 		withc: func(cmd *cobra.Command, r *rootCommand) {
 			cmd.Hidden = true
+			cmd.ValidArgsFunction = cobra.NoFileCompletions
 			cmd.PersistentFlags().BoolVarP(&skipPush, "skip-push", "", false, "skip pushing to remote")
 			cmd.PersistentFlags().BoolVarP(&try, "try", "", false, "no changes")
 			cmd.PersistentFlags().IntVarP(&step, "step", "", 0, "step to run (1: set new version 2: prepare next dev version)")
+			_ = cmd.RegisterFlagCompletionFunc("step", cobra.FixedCompletions([]string{"1", "2"}, cobra.ShellCompDirectiveNoFileComp))
 		},
 	}
 }
@@ -46,12 +46,12 @@ import (
 	"github.com/fsnotify/fsnotify"
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/hugo"
+
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/common/urls"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
-	"github.com/gohugoio/hugo/hugofs/files"
 	"github.com/gohugoio/hugo/hugolib"
 	"github.com/gohugoio/hugo/hugolib/filesystems"
 	"github.com/gohugoio/hugo/livereload"
@@ -123,6 +123,7 @@ func newServerCommand() *serverCommand {
 					return mclib.RunMain()
 				},
 				withc: func(cmd *cobra.Command, r *rootCommand) {
+					cmd.ValidArgsFunction = cobra.NoFileCompletions
 					cmd.Flags().BoolVar(&uninstall, "uninstall", false, "Uninstall the local CA (but do not delete it).")
 				},
 			},
@@ -236,9 +237,8 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string
 	listener := f.c.serverPorts[i].ln
 	logger := f.c.r.logger

-	r.Printf("Environment: %q\n", f.c.hugoTry().Deps.Site.Hugo().Environment)
-
 	if i == 0 {
+		r.Printf("Environment: %q\n", f.c.hugoTry().Deps.Site.Hugo().Environment)
 		mainTarget := "disk"
 		if f.c.r.renderToMemory {
 			mainTarget = "memory"
@@ -307,7 +307,7 @@ func (f *fileServer) createEndpoint(i int) (*http.ServeMux, net.Listener, string
 			if redirect := serverConfig.MatchRedirect(requestURI); !redirect.IsZero() {
 				// fullName := filepath.Join(dir, filepath.FromSlash(path.Clean("/"+name)))
 				doRedirect := true
-				// This matches Netlify's behaviour and is needed for SPA behaviour.
+				// This matches Netlify's behavior and is needed for SPA behavior.
 				// See https://docs.netlify.com/routing/redirects/rewrites-proxies/
 				if !redirect.Force {
 					path := filepath.Clean(strings.TrimPrefix(requestURI, baseURL.Path()))
@@ -523,24 +523,26 @@ of a second, you will be able to save and see your changes nearly instantly.`
 	cmd.Aliases = []string{"serve"}

 	cmd.Flags().IntVarP(&c.serverPort, "port", "p", 1313, "port on which the server will listen")
+	_ = cmd.RegisterFlagCompletionFunc("port", cobra.NoFileCompletions)
 	cmd.Flags().IntVar(&c.liveReloadPort, "liveReloadPort", -1, "port for live reloading (i.e. 443 in HTTPS proxy situations)")
+	_ = cmd.RegisterFlagCompletionFunc("liveReloadPort", cobra.NoFileCompletions)
 	cmd.Flags().StringVarP(&c.serverInterface, "bind", "", "127.0.0.1", "interface to which the server will bind")
+	_ = cmd.RegisterFlagCompletionFunc("bind", cobra.NoFileCompletions)
 	cmd.Flags().StringVarP(&c.tlsCertFile, "tlsCertFile", "", "", "path to TLS certificate file")
+	_ = cmd.MarkFlagFilename("tlsCertFile", "pem")
 	cmd.Flags().StringVarP(&c.tlsKeyFile, "tlsKeyFile", "", "", "path to TLS key file")
+	_ = cmd.MarkFlagFilename("tlsKeyFile", "pem")
 	cmd.Flags().BoolVar(&c.tlsAuto, "tlsAuto", false, "generate and use locally-trusted certificates.")
 	cmd.Flags().BoolVar(&c.pprof, "pprof", false, "enable the pprof server (port 8080)")
 	cmd.Flags().BoolVarP(&c.serverWatch, "watch", "w", true, "watch filesystem for changes and recreate as needed")
 	cmd.Flags().BoolVar(&c.noHTTPCache, "noHTTPCache", false, "prevent HTTP caching")
 	cmd.Flags().BoolVarP(&c.serverAppend, "appendPort", "", true, "append port to baseURL")
 	cmd.Flags().BoolVar(&c.disableLiveReload, "disableLiveReload", false, "watch without enabling live browser reload on rebuild")
-	cmd.Flags().BoolVar(&c.navigateToChanged, "navigateToChanged", false, "navigate to changed content file on live browser reload")
+	cmd.Flags().BoolVarP(&c.navigateToChanged, "navigateToChanged", "N", false, "navigate to changed content file on live browser reload")
 	cmd.Flags().BoolVar(&c.renderStaticToDisk, "renderStaticToDisk", false, "serve static files from disk and dynamic files from memory")
 	cmd.Flags().BoolVar(&c.disableFastRender, "disableFastRender", false, "enables full re-renders on changes")
 	cmd.Flags().BoolVar(&c.disableBrowserError, "disableBrowserError", false, "do not show build errors in the browser")

-	cmd.Flags().SetAnnotation("tlsCertFile", cobra.BashCompSubdirsInDir, []string{})
-	cmd.Flags().SetAnnotation("tlsKeyFile", cobra.BashCompSubdirsInDir, []string{})
-
 	r := cd.Root.Command.(*rootCommand)
 	applyLocalFlagsBuild(cmd, r)

@@ -566,7 +568,7 @@ func (c *serverCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 				}
 			}

-			if err := c.setBaseURLsInConfig(); err != nil {
+			if err := c.setServerInfoInConfig(); err != nil {
 				return err
 			}

@@ -611,7 +613,7 @@ func (c *serverCommand) PreRun(cd, runner *simplecobra.Commandeer) error {
 	return nil
 }

-func (c *serverCommand) setBaseURLsInConfig() error {
+func (c *serverCommand) setServerInfoInConfig() error {
 	if len(c.serverPorts) == 0 {
 		panic("no server ports set")
 	}
@@ -638,7 +640,8 @@ func (c *serverCommand) setBaseURLsInConfig() error {
 			if c.liveReloadPort != -1 {
 				baseURLLiveReload, _ = baseURLLiveReload.WithPort(c.liveReloadPort)
 			}
-			langConfig.C.SetBaseURL(baseURL, baseURLLiveReload)
+			langConfig.C.SetServerInfo(baseURL, baseURLLiveReload, c.serverInterface)
+
 		}
 		return nil
 	})
@@ -1185,16 +1188,16 @@ func partitionDynamicEvents(sourceFs *filesystems.SourceFilesystems, events []fs
 	return
 }

-func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
+func pickOneWriteOrCreatePath(contentTypes config.ContentTypesProvider, events []fsnotify.Event) string {
 	name := ""

 	for _, ev := range events {
 		if ev.Op&fsnotify.Write == fsnotify.Write || ev.Op&fsnotify.Create == fsnotify.Create {
-			if files.IsIndexContentFile(ev.Name) {
+			if contentTypes.IsIndexContentFile(ev.Name) {
 				return ev.Name
 			}

-			if files.IsContentFile(ev.Name) {
+			if contentTypes.IsContentFile(ev.Name) {
 				name = ev.Name
 			}

@@ -123,6 +123,20 @@ func InSlicEqualFold(arr []string, el string) bool {
 	return false
 }

+// ToString converts the given value to a string.
+// Note that this is a more strict version compared to cast.ToString,
+// as it will not try to convert numeric values to strings,
+// but only accept strings or fmt.Stringer.
+func ToString(v any) (string, bool) {
+	switch vv := v.(type) {
+	case string:
+		return vv, true
+	case fmt.Stringer:
+		return vv.String(), true
+	}
+	return "", false
+}
+
 type Tuple struct {
 	First  string
 	Second string
@@ -17,7 +17,7 @@ package hugo
 // This should be the only one.
 var CurrentVersion = Version{
 	Major:      0,
-	Minor:      124,
-	PatchLevel: 1,
-	Suffix:     "",
+	Minor:      127,
+	PatchLevel: 0,
+	Suffix:     "-DEV",
 }
@@ -27,7 +27,12 @@ func NewCache[K comparable, T any]() *Cache[K, T] {
 }

 // Delete deletes the given key from the cache.
+// If c is nil, this method is a no-op.
 func (c *Cache[K, T]) Get(key K) (T, bool) {
+	if c == nil {
+		var zero T
+		return zero, false
+	}
 	c.RLock()
 	v, found := c.m[key]
 	c.RUnlock()
@@ -60,6 +65,15 @@ func (c *Cache[K, T]) Set(key K, value T) {
 	c.Unlock()
 }

+// ForEeach calls the given function for each key/value pair in the cache.
+func (c *Cache[K, T]) ForEeach(f func(K, T)) {
+	c.RLock()
+	defer c.RUnlock()
+	for k, v := range c.m {
+		f(k, v)
+	}
+}
+
 // SliceCache is a simple thread safe cache backed by a map.
 type SliceCache[T any] struct {
 	m map[string][]T
@@ -112,17 +112,17 @@ func ToSliceStringMap(in any) ([]map[string]any, error) {
 }

 // LookupEqualFold finds key in m with case insensitive equality checks.
-func LookupEqualFold[T any | string](m map[string]T, key string) (T, bool) {
+func LookupEqualFold[T any | string](m map[string]T, key string) (T, string, bool) {
 	if v, found := m[key]; found {
-		return v, true
+		return v, key, true
 	}
 	for k, v := range m {
 		if strings.EqualFold(k, key) {
-			return v, true
+			return v, k, true
 		}
 	}
 	var s T
-	return s, false
+	return s, "", false
 }

 // MergeShallow merges src into dst, but only if the key does not already exist in dst.
@@ -180,16 +180,18 @@ func TestLookupEqualFold(t *testing.T) {
 		"B": "bv",
 	}

-	v, found := LookupEqualFold(m1, "b")
+	v, k, found := LookupEqualFold(m1, "b")
 	c.Assert(found, qt.IsTrue)
 	c.Assert(v, qt.Equals, "bv")
+	c.Assert(k, qt.Equals, "B")

 	m2 := map[string]string{
 		"a": "av",
 		"B": "bv",
 	}

-	v, found = LookupEqualFold(m2, "b")
+	v, k, found = LookupEqualFold(m2, "b")
 	c.Assert(found, qt.IsTrue)
+	c.Assert(k, qt.Equals, "B")
 	c.Assert(v, qt.Equals, "bv")
 }
@@ -25,8 +25,6 @@ import (
 	"github.com/gohugoio/hugo/identity"
 )

-var defaultPathParser PathParser
-
 // PathParser parses a path into a Path.
 type PathParser struct {
 	// Maps the language code to its index in the languages/sites slice.
@@ -34,11 +32,9 @@ type PathParser struct {

 	// Reports whether the given language is disabled.
 	IsLangDisabled func(string) bool
-}

-// Parse parses component c with path s into Path using the default path parser.
-func Parse(c, s string) *Path {
-	return defaultPathParser.Parse(c, s)
+	// Reports whether the given ext is a content file.
+	IsContentExt func(string) bool
 }

 // NormalizePathString returns a normalized path string using the very basic Hugo rules.
@@ -108,7 +104,6 @@ func (pp *PathParser) parse(component, s string) (*Path, error) {
 		var err error
 		// Preserve the original case for titles etc.
 		p.unnormalized, err = pp.doParse(component, s, pp.newPath(component))
-
 		if err != nil {
 			return nil, err
 		}
@@ -195,23 +190,26 @@ func (pp *PathParser) doParse(component, s string, p *Path) (*Path, error) {
 		}
 	}

-	isContentComponent := p.component == files.ComponentFolderContent || p.component == files.ComponentFolderArchetypes
-	isContent := isContentComponent && files.IsContentExt(p.Ext())
-
-	if isContent {
+	if len(p.identifiers) > 0 {
+		isContentComponent := p.component == files.ComponentFolderContent || p.component == files.ComponentFolderArchetypes
+		isContent := isContentComponent && pp.IsContentExt(p.Ext())
 		id := p.identifiers[len(p.identifiers)-1]
 		b := p.s[p.posContainerHigh : id.Low-1]
-		switch b {
-		case "index":
-			p.bundleType = PathTypeLeaf
-		case "_index":
-			p.bundleType = PathTypeBranch
-		default:
-			p.bundleType = PathTypeContentSingle
-		}
+		if isContent {
+			switch b {
+			case "index":
+				p.bundleType = PathTypeLeaf
+			case "_index":
+				p.bundleType = PathTypeBranch
+			default:
+				p.bundleType = PathTypeContentSingle
+			}

-		if slashCount == 2 && p.IsLeafBundle() {
-			p.posSectionHigh = 0
+			if slashCount == 2 && p.IsLeafBundle() {
+				p.posSectionHigh = 0
+			}
+		} else if b == files.NameContentData && files.IsContentDataExt(p.Ext()) {
+			p.bundleType = PathTypeContentData
 		}
 	}

@@ -246,6 +244,9 @@ const (

 	// Branch bundles, e.g. /blog/_index.md
 	PathTypeBranch
+
+	// Content data file, _content.gotmpl.
+	PathTypeContentData
 )

 type Path struct {
@@ -521,10 +522,6 @@ func (p *Path) Identifiers() []string {
 	return ids
 }

-func (p *Path) IsHTML() bool {
-	return files.IsHTML(p.Ext())
-}
-
 func (p *Path) BundleType() PathType {
 	return p.bundleType
 }
@@ -541,6 +538,10 @@ func (p *Path) IsLeafBundle() bool {
 	return p.bundleType == PathTypeLeaf
 }

+func (p *Path) IsContentData() bool {
+	return p.bundleType == PathTypeContentData
+}
+
 func (p Path) ForBundleType(t PathType) *Path {
 	p.bundleType = t
 	return &p
@@ -27,6 +27,9 @@ var testParser = &PathParser{
 		"no": 0,
 		"en": 1,
 	},
+	IsContentExt: func(ext string) bool {
+		return ext == "md"
+	},
 }

 func TestParse(t *testing.T) {
@@ -333,6 +336,22 @@ func TestParse(t *testing.T) {
 				c.Assert(p.Path(), qt.Equals, "/a/b/c.txt")
 			},
 		},
+		{
+			"Content data file gotmpl",
+			"/a/b/_content.gotmpl",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.Path(), qt.Equals, "/a/b/_content.gotmpl")
+				c.Assert(p.Ext(), qt.Equals, "gotmpl")
+				c.Assert(p.IsContentData(), qt.IsTrue)
+			},
+		},
+		{
+			"Content data file yaml",
+			"/a/b/_content.yaml",
+			func(c *qt.C, p *Path) {
+				c.Assert(p.IsContentData(), qt.IsFalse)
+			},
+		},
 	}
 	for _, test := range tests {
 		c.Run(test.name, func(c *qt.C) {
@@ -24,6 +24,9 @@ func (p P[T]) And(ps ...P[T]) P[T] {
 				return false
 			}
 		}
+		if p == nil {
+			return true
+		}
 		return p(v)
 	}
 }
@@ -36,6 +39,9 @@ func (p P[T]) Or(ps ...P[T]) P[T] {
 				return true
 			}
 		}
+		if p == nil {
+			return false
+		}
 		return p(v)
 	}
 }
@@ -0,0 +1,153 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package tasks
+
+import (
+	"sync"
+	"time"
+)
+
+// RunEvery runs a function at intervals defined by the function itself.
+// Functions can be added and removed while running.
+type RunEvery struct {
+	// Any error returned from the function will be passed to this function.
+	HandleError func(string, error)
+
+	// If set, the function will be run immediately.
+	RunImmediately bool
+
+	// The named functions to run.
+	funcs map[string]*Func
+
+	mu      sync.Mutex
+	started bool
+	closed  bool
+	quit    chan struct{}
+}
+
+type Func struct {
+	// The shortest interval between each run.
+	IntervalLow time.Duration
+
+	// The longest interval between each run.
+	IntervalHigh time.Duration
+
+	// The function to run.
+	F func(interval time.Duration) (time.Duration, error)
+
+	interval time.Duration
+	last     time.Time
+}
+
+func (r *RunEvery) Start() error {
+	if r.started {
+		return nil
+	}
+
+	r.started = true
+	r.quit = make(chan struct{})
+
+	go func() {
+		if r.RunImmediately {
+			r.run()
+		}
+		ticker := time.NewTicker(500 * time.Millisecond)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-r.quit:
+				return
+			case <-ticker.C:
+				r.run()
+			}
+		}
+	}()
+
+	return nil
+}
+
+// Close stops the RunEvery from running.
+func (r *RunEvery) Close() error {
+	if r.closed {
+		return nil
+	}
+	r.closed = true
+	if r.quit != nil {
+		close(r.quit)
+	}
+	return nil
+}
+
+// Add adds a function to the RunEvery.
+func (r *RunEvery) Add(name string, f Func) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.funcs == nil {
+		r.funcs = make(map[string]*Func)
+	}
+	if f.IntervalLow == 0 {
+		f.IntervalLow = 500 * time.Millisecond
+	}
+	if f.IntervalHigh <= f.IntervalLow {
+		f.IntervalHigh = 20 * time.Second
+	}
+
+	start := f.IntervalHigh / 3
+	if start < f.IntervalLow {
+		start = f.IntervalLow
+	}
+	f.interval = start
+	f.last = time.Now()
+
+	r.funcs[name] = &f
+}
+
+// Remove removes a function from the RunEvery.
+func (r *RunEvery) Remove(name string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	delete(r.funcs, name)
+}
+
+// Has returns whether the RunEvery has a function with the given name.
+func (r *RunEvery) Has(name string) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	_, found := r.funcs[name]
+	return found
+}
+
+func (r *RunEvery) run() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	for name, f := range r.funcs {
+		if time.Now().Before(f.last.Add(f.interval)) {
+			continue
+		}
+		f.last = time.Now()
+		interval, err := f.F(f.interval)
+		if err != nil && r.HandleError != nil {
+			r.HandleError(name, err)
+		}
+
+		if interval < f.IntervalLow {
+			interval = f.IntervalLow
+		}
+
+		if interval > f.IntervalHigh {
+			interval = f.IntervalHigh
+		}
+		f.interval = interval
+	}
+}
@@ -0,0 +1,47 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import "sync"
+
+type Closer interface {
+	Close() error
+}
+
+type CloseAdder interface {
+	Add(Closer)
+}
+
+type Closers struct {
+	mu sync.Mutex
+	cs []Closer
+}
+
+func (cs *Closers) Add(c Closer) {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+	cs.cs = append(cs.cs, c)
+}
+
+func (cs *Closers) Close() error {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+	for _, c := range cs.cs {
+		c.Close()
+	}
+
+	cs.cs = cs.cs[:0]
+
+	return nil
+}
@@ -27,6 +27,7 @@ import (
 	"time"

 	"github.com/gohugoio/hugo/cache/filecache"
+	"github.com/gohugoio/hugo/cache/httpcache"
 	"github.com/gohugoio/hugo/common/hugo"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/maps"
@@ -119,6 +120,10 @@ type Config struct {
 	// <docsmeta>{"identifiers": ["caches"] }</docsmeta>
 	Caches filecache.Configs `mapstructure:"-"`

+	// The httpcache configuration section contains HTTP-cache-related configuration options.
+	// <docsmeta>{"identifiers": ["httpcache"] }</docsmeta>
+	HTTPCache httpcache.Config `mapstructure:"-"`
+
 	// The markup configuration section contains markup-related configuration options.
 	// <docsmeta>{"identifiers": ["markup"] }</docsmeta>
 	Markup markup_config.Config `mapstructure:"-"`
@@ -359,6 +364,11 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		}
 	}

+	httpCache, err := c.HTTPCache.Compile()
+	if err != nil {
+		return err
+	}
+
 	c.C = &ConfigCompiled{
 		Timeout:           timeout,
 		BaseURL:           baseURL,
@@ -367,12 +377,14 @@ func (c *Config) CompileConfig(logger loggers.Logger) error {
 		DisabledLanguages: disabledLangs,
 		IgnoredLogs:       ignoredLogIDs,
 		KindOutputFormats: kindOutputFormats,
+		ContentTypes:      media.DefaultContentTypes.FromTypes(c.MediaTypes.Config),
 		CreateTitle:       helpers.GetTitleFunc(c.TitleCaseStyle),
 		IsUglyURLSection:  isUglyURL,
 		IgnoreFile:        ignoreFile,
 		SegmentFilter:     c.Segments.Config.Get(func(s string) { logger.Warnf("Render segment %q not found in configuration", s) }, c.RootConfig.RenderSegments...),
 		MainSections:      c.MainSections,
 		Clock:             clock,
+		HTTPCache:         httpCache,
 		transientErr:      transientErr,
 	}

@@ -400,7 +412,9 @@ type ConfigCompiled struct {
 	Timeout           time.Duration
 	BaseURL           urls.BaseURL
 	BaseURLLiveReload urls.BaseURL
+	ServerInterface   string
 	KindOutputFormats map[string]output.Formats
+	ContentTypes      media.ContentTypes
 	DisabledKinds     map[string]bool
 	DisabledLanguages map[string]bool
 	IgnoredLogs       map[string]bool
@@ -410,6 +424,7 @@ type ConfigCompiled struct {
 	SegmentFilter     segments.SegmentFilter
 	MainSections      []string
 	Clock             time.Time
+	HTTPCache         httpcache.ConfigCompiled

 	// This is set to the last transient error found during config compilation.
 	// With themes/modules we compute the configuration in multiple passes, and
@@ -434,9 +449,10 @@ func (c *ConfigCompiled) IsMainSectionsSet() bool {
 }

 // This is set after the config is compiled by the server command.
-func (c *ConfigCompiled) SetBaseURL(baseURL, baseURLLiveReload urls.BaseURL) {
+func (c *ConfigCompiled) SetServerInfo(baseURL, baseURLLiveReload urls.BaseURL, serverInterface string) {
 	c.BaseURL = baseURL
 	c.BaseURLLiveReload = baseURLLiveReload
+	c.ServerInterface = serverInterface
 }

 // RootConfig holds all the top-level configuration options in Hugo
@@ -757,7 +773,7 @@ func (c *Configs) Init() error {
 	c.Languages = languages
 	c.LanguagesDefaultFirst = languagesDefaultFirst

-	c.ContentPathParser = &paths.PathParser{LanguageIndex: languagesDefaultFirst.AsIndexSet(), IsLangDisabled: c.Base.IsLangDisabled}
+	c.ContentPathParser = &paths.PathParser{LanguageIndex: languagesDefaultFirst.AsIndexSet(), IsLangDisabled: c.Base.IsLangDisabled, IsContentExt: c.Base.C.ContentTypes.IsContentSuffix}

 	c.configLangs = make([]config.AllProvider, len(c.Languages))
 	for i, l := range c.LanguagesDefaultFirst {
@@ -84,3 +84,21 @@ logPathWarnings = true
 	b.Assert(conf.PrintI18nWarnings, qt.Equals, true)
 	b.Assert(conf.PrintPathWarnings, qt.Equals, true)
 }
+
+func TestRedefineContentTypes(t *testing.T) {
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+[mediaTypes]
+[mediaTypes."text/html"]
+suffixes = ["html", "xhtml"]
+`
+
+	b := hugolib.Test(t, files)
+
+	conf := b.H.Configs.Base
+	contentTypes := conf.C.ContentTypes
+
+	b.Assert(contentTypes.HTML.Suffixes(), qt.DeepEquals, []string{"html", "xhtml"})
+	b.Assert(contentTypes.Markdown.Suffixes(), qt.DeepEquals, []string{"md", "mdown", "markdown"})
+}
@@ -18,6 +18,8 @@ import (
 	"strings"

 	"github.com/gohugoio/hugo/cache/filecache"
+
+	"github.com/gohugoio/hugo/cache/httpcache"
 	"github.com/gohugoio/hugo/common/maps"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
@@ -96,6 +98,18 @@ var allDecoderSetups = map[string]decodeWeight{
 			return err
 		},
 	},
+	"httpcache": {
+		key: "httpcache",
+		decode: func(d decodeWeight, p decodeConfig) error {
+			var err error
+			p.c.HTTPCache, err = httpcache.DecodeConfig(p.bcfg, p.p.GetStringMap(d.key))
+			if p.c.IgnoreCache {
+				p.c.HTTPCache.Cache.For.Excludes = []string{"**"}
+				p.c.HTTPCache.Cache.For.Includes = []string{}
+			}
+			return err
+		},
+	},
 	"build": {
 		key: "build",
 		decode: func(d decodeWeight, p decodeConfig) error {
@@ -71,6 +71,9 @@ func (c ConfigLanguage) Environment() string {
 }

 func (c ConfigLanguage) IsMultihost() bool {
+	if len(c.m.Languages)-len(c.config.C.DisabledLanguages) <= 1 {
+		return false
+	}
 	return c.m.IsMultihost
 }

@@ -141,6 +144,10 @@ func (c ConfigLanguage) NewIdentityManager(name string) identity.Manager {
 	return identity.NewManager(name)
 }

+func (c ConfigLanguage) ContentTypes() config.ContentTypesProvider {
+	return c.config.C.ContentTypes
+}
+
 // GetConfigSection is mostly used in tests. The switch statement isn't complete, but what's in use.
 func (c ConfigLanguage) GetConfigSection(s string) any {
 	switch s {
@@ -166,6 +173,8 @@ func (c ConfigLanguage) GetConfigSection(s string) any {
 		return c.m.Modules
 	case "deployment":
 		return c.config.Deployment
+	case "httpCacheCompiled":
+		return c.config.C.HTTPCache
 	default:
 		panic("not implemented: " + s)
 	}
@@ -98,10 +98,6 @@ type BuildConfig struct {
 	// One of never, fallback, always. Default is fallback
 	UseResourceCacheWhen string

-	// When enabled, will duplicate bundled resource files across languages that
-	// doesn't have a translated version.
-	DuplicateResourceFiles bool
-
 	// When enabled, will collect and write a hugo_stats.json with some build
 	// related aggregated data (e.g. CSS class names).
 	// Note that this was a bool <= v0.115.0.
@@ -215,6 +211,8 @@ type SitemapConfig struct {
 	Priority float64
 	// The sitemap filename.
 	Filename string
+	// Whether to disable page inclusion.
+	Disable bool
 }

 func DecodeSitemap(prototype SitemapConfig, input map[string]any) (SitemapConfig, error) {
@@ -41,6 +41,7 @@ type AllProvider interface {
 	Dirs() CommonDirs
 	Quiet() bool
 	DirsBase() CommonDirs
+	ContentTypes() ContentTypesProvider
 	GetConfigSection(string) any
 	GetConfig() any
 	CanonifyURLs() bool
@@ -75,6 +76,15 @@ type AllProvider interface {
 	EnableEmoji() bool
 }

+// We cannot import the media package as that would create a circular dependency.
+// This interface defineds a sub set of what media.ContentTypes provides.
+type ContentTypesProvider interface {
+	IsContentSuffix(suffix string) bool
+	IsContentFile(filename string) bool
+	IsIndexContentFile(filename string) bool
+	IsHTMLSuffix(suffix string) bool
+}
+
 // Provider provides the configuration settings for Hugo.
 type Provider interface {
 	GetString(key string) string
@@ -44,15 +44,9 @@ type Disqus struct {
 type GoogleAnalytics struct {
 	Service `mapstructure:",squash"`

-	// Enabling this will disable the use of Cookies and use Session Storage to Store the GA Client ID.
-	UseSessionStorage bool
-
 	// Enabling this will make the GA templates respect the
 	// "Do Not Track" HTTP header. See  https://www.paulfurley.com/google-analytics-dnt/.
 	RespectDoNotTrack bool
-
-	// Enabling this will make it so the users' IP addresses are anonymized within Google Analytics.
-	AnonymizeIP bool
 }

 // Instagram holds the privacy configuration settings related to the Instagram shortcode.
@@ -33,8 +33,6 @@ disable = true
 [privacy.googleAnalytics]
 disable = true
 respectDoNotTrack = true
-anonymizeIP = true
-useSessionStorage = true
 [privacy.instagram]
 disable = true
 simple = true
@@ -60,8 +58,7 @@ simple = true

 	got := []bool{
 		pc.Disqus.Disable, pc.GoogleAnalytics.Disable,
-		pc.GoogleAnalytics.RespectDoNotTrack, pc.GoogleAnalytics.AnonymizeIP,
-		pc.GoogleAnalytics.UseSessionStorage, pc.Instagram.Disable,
+		pc.GoogleAnalytics.RespectDoNotTrack, pc.Instagram.Disable,
 		pc.Instagram.Simple, pc.Twitter.Disable, pc.Twitter.EnableDNT,
 		pc.Twitter.Simple, pc.Vimeo.Disable, pc.Vimeo.EnableDNT, pc.Vimeo.Simple,
 		pc.YouTube.PrivacyEnhanced, pc.YouTube.Disable,
@@ -29,8 +29,6 @@ import (
 	"github.com/gohugoio/hugo/common/hstrings"
 	"github.com/gohugoio/hugo/common/paths"

-	"github.com/gohugoio/hugo/hugofs/files"
-
 	"github.com/gohugoio/hugo/hugofs"

 	"github.com/gohugoio/hugo/helpers"
@@ -98,7 +96,7 @@ func NewContent(h *hugolib.HugoSites, kind, targetPath string, force bool) error
 			return "", fmt.Errorf("failed to resolve %q to an archetype template", targetPath)
 		}

-		if !files.IsContentFile(b.targetPath) {
+		if !h.Conf.ContentTypes().IsContentFile(b.targetPath) {
 			return "", fmt.Errorf("target path %q is not a known content format", b.targetPath)
 		}

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="{{ or site.Language.LanguageCode site.Language.Lang }}" dir="{{ or site.Language.LanguageDirection `ltr` }}">
+<html lang="{{ or site.Language.LanguageCode }}" dir="{{ or site.Language.LanguageDirection `ltr` }}">
 <head>
  {{ partial "head.html" . }}
 </head>
@@ -15,11 +15,13 @@ import (
 	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/common/hexec"
 	"github.com/gohugoio/hugo/common/loggers"
+	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/config/security"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/media"
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/resources/postpub"
@@ -85,7 +87,7 @@ type Deps struct {
 	BuildEndListeners *Listeners

 	// Resources that gets closed when the build is done or the server shuts down.
-	BuildClosers *Closers
+	BuildClosers *types.Closers

 	// This is common/global for all sites.
 	BuildState *BuildState
@@ -143,7 +145,7 @@ func (d *Deps) Init() error {
 	}

 	if d.BuildClosers == nil {
-		d.BuildClosers = &Closers{}
+		d.BuildClosers = &types.Closers{}
 	}

 	if d.Metrics == nil && d.Conf.TemplateMetrics() {
@@ -155,7 +157,7 @@ func (d *Deps) Init() error {
 	}

 	if d.MemCache == nil {
-		d.MemCache = dynacache.New(dynacache.Options{Running: d.Conf.Running(), Log: d.Log})
+		d.MemCache = dynacache.New(dynacache.Options{Watching: d.Conf.Watching(), Log: d.Log})
 	}

 	if d.PathSpec == nil {
@@ -208,7 +210,7 @@ func (d *Deps) Init() error {
 		return fmt.Errorf("failed to create file caches from configuration: %w", err)
 	}

-	resourceSpec, err := resources.NewSpec(d.PathSpec, common, fileCaches, d.MemCache, d.BuildState, d.Log, d, d.ExecHelper)
+	resourceSpec, err := resources.NewSpec(d.PathSpec, common, fileCaches, d.MemCache, d.BuildState, d.Log, d, d.ExecHelper, d.BuildClosers, d.BuildState)
 	if err != nil {
 		return fmt.Errorf("failed to create resource spec: %w", err)
 	}
@@ -353,6 +355,9 @@ type DepsCfg struct {

 	// i18n handling.
 	TranslationProvider ResourceProvider
+
+	// ChangesFromBuild for changes passed back to the server/watch process.
+	ChangesFromBuild chan []identity.Identity
 }

 // BuildState are state used during a build.
@@ -361,11 +366,19 @@ type BuildState struct {

 	mu sync.Mutex // protects state below.

+	OnSignalRebuild func(ids ...identity.Identity)
+
 	// A set of filenames in /public that
 	// contains a post-processing prefix.
 	filenamesWithPostPrefix map[string]bool
 }

+var _ identity.SignalRebuilder = (*BuildState)(nil)
+
+func (b *BuildState) SignalRebuild(ids ...identity.Identity) {
+	b.OnSignalRebuild(ids...)
+}
+
 func (b *BuildState) AddFilenameWithPostPrefix(filename string) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
@@ -389,30 +402,3 @@ func (b *BuildState) GetFilenamesWithPostPrefix() []string {
 func (b *BuildState) Incr() int {
 	return int(atomic.AddUint64(&b.counter, uint64(1)))
 }
-
-type Closer interface {
-	Close() error
-}
-
-type Closers struct {
-	mu sync.Mutex
-	cs []Closer
-}
-
-func (cs *Closers) Add(c Closer) {
-	cs.mu.Lock()
-	defer cs.mu.Unlock()
-	cs.cs = append(cs.cs, c)
-}
-
-func (cs *Closers) Close() error {
-	cs.mu.Lock()
-	defer cs.mu.Unlock()
-	for _, c := range cs.cs {
-		c.Close()
-	}
-
-	cs.cs = cs.cs[:0]
-
-	return nil
-}
@@ -20,10 +20,11 @@ hugo gen chromastyles [flags] [args]
 ### Options

 ```
-  -h, --help                    help for chromastyles
-      --highlightStyle string   style used for highlighting lines (see https://github.com/alecthomas/chroma)
-      --linesStyle string       style used for line numbers (see https://github.com/alecthomas/chroma)
-      --style string            highlighter style (see https://xyproto.github.io/splash/docs/) (default "friendly")
+  -h, --help                            help for chromastyles
+      --highlightStyle string           foreground and background colors for highlighted lines, e.g. --highlightStyle "#fff000 bg:#000fff"
+      --lineNumbersInlineStyle string   foreground and background colors for inline line numbers, e.g. --lineNumbersInlineStyle "#fff000 bg:#000fff"
+      --lineNumbersTableStyle string    foreground and background colors for table line numbers, e.g. --lineNumbersTableStyle "#fff000 bg:#000fff"
+      --style string                    highlighter style (see https://xyproto.github.io/splash/docs/) (default "friendly")
 ```

 ### Options inherited from parent commands
@@ -939,7 +939,6 @@ config:
    cacheBusters:
    - source: (postcss|tailwind)\.config\.js
      target: (css|styles|scss|sass)
-    duplicateResourceFiles: false
    noJSConfigInAssets: false
    useResourceCacheWhen: fallback
  buildDrafts: false
@@ -1065,6 +1064,15 @@ config:
          enable: false
          escapedSpace: false
        definitionList: true
+        extras:
+          insert:
+            enable: false
+          mark:
+            enable: false
+          subscript:
+            enable: false
+          superscript:
+            enable: false
        footnote: true
        linkify: true
        linkifyProtocol: https
@@ -1200,6 +1208,12 @@ config:
      delimiter: .
      suffixes:
      - webp
+    text/asciidoc:
+      delimiter: .
+      suffixes:
+      - adoc
+      - asciidoc
+      - ad
    text/calendar:
      delimiter: .
      suffixes:
@@ -1216,6 +1230,7 @@ config:
      delimiter: .
      suffixes:
      - html
+      - htm
    text/javascript:
      delimiter: .
      suffixes:
@@ -1230,11 +1245,25 @@ config:
      delimiter: .
      suffixes:
      - md
+      - mdown
      - markdown
+    text/org:
+      delimiter: .
+      suffixes:
+      - org
+    text/pandoc:
+      delimiter: .
+      suffixes:
+      - pandoc
+      - pdc
    text/plain:
      delimiter: .
      suffixes:
      - txt
+    text/rst:
+      delimiter: .
+      suffixes:
+      - rst
    text/tsx:
      delimiter: .
      suffixes:
@@ -1557,10 +1586,8 @@ config:
    disqus:
      disable: false
    googleAnalytics:
-      anonymizeIP: false
      disable: false
      respectDoNotTrack: false
-      useSessionStorage: false
    instagram:
      disable: false
      simple: false
@@ -1651,6 +1678,7 @@ config:
      disableInlineCSS: false
  sitemap:
    changeFreq: ""
+    disable: false
    filename: sitemap.xml
    priority: -1
  social: null
@@ -2799,8 +2827,8 @@ tpl:
            {{ $m.Set "Hugo" "Rocks!" }}
            {{ $m.Values | debug.Dump | safeHTML }}
          - |-
-            map[string]interface {}{
-              "Hugo": "Rocks!",
+            {
+              "Hugo": "Rocks!"
            }
      TestDeprecationErr:
        Aliases: null
@@ -4018,6 +4046,11 @@ tpl:
        - s
        Description: CountWords returns the approximate word count in s.
        Examples: []
+      Diff:
+        Aliases: null
+        Args: null
+        Description: ""
+        Examples: null
      FindRE:
        Aliases:
        - findRE
@@ -4582,5 +4615,5 @@ tpl:
        - urlize
        Args:
        - s
-        Description: URLize returns the the strings s formatted as an URL.
+        Description: URLize returns the strings s formatted as an URL.
        Examples: []
@@ -4,8 +4,8 @@ require (
 	github.com/BurntSushi/locker v0.0.0-20171006230638-a6e239ea1c69
 	github.com/alecthomas/chroma/v2 v2.13.0
 	github.com/armon/go-radix v1.0.1-0.20221118154546-54df44f2176c
-	github.com/aws/aws-sdk-go-v2 v1.24.1
-	github.com/aws/aws-sdk-go-v2/service/cloudfront v1.32.6
+	github.com/aws/aws-sdk-go-v2 v1.26.1
+	github.com/aws/aws-sdk-go-v2/service/cloudfront v1.35.4
 	github.com/bep/clocks v0.5.0
 	github.com/bep/debounce v1.2.0
 	github.com/bep/gitmap v1.1.2
@@ -35,6 +35,8 @@ require (
 	github.com/gobuffalo/flect v1.0.2
 	github.com/gobwas/glob v0.2.3
 	github.com/gohugoio/go-i18n/v2 v2.1.3-0.20230805085216-e63c13218d0e
+	github.com/gohugoio/httpcache v0.7.0
+	github.com/gohugoio/hugo-goldmark-extensions/extras v0.1.0
 	github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.2.0
 	github.com/gohugoio/locales v0.14.0
 	github.com/gohugoio/localescompressed v1.0.1
@@ -55,7 +57,7 @@ require (
 	github.com/niklasfasching/go-org v1.7.0
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58
-	github.com/pelletier/go-toml/v2 v2.1.1
+	github.com/pelletier/go-toml/v2 v2.2.2
 	github.com/rogpeppe/go-internal v1.12.0
 	github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd
 	github.com/sanity-io/litter v1.5.5
@@ -64,19 +66,19 @@ require (
 	github.com/spf13/cobra v1.8.0
 	github.com/spf13/fsync v0.10.1
 	github.com/spf13/pflag v1.0.5
-	github.com/tdewolff/minify/v2 v2.20.19
-	github.com/tdewolff/parse/v2 v2.7.12
-	github.com/yuin/goldmark v1.7.0
+	github.com/tdewolff/minify/v2 v2.20.20
+	github.com/tdewolff/parse/v2 v2.7.13
+	github.com/yuin/goldmark v1.7.1
 	github.com/yuin/goldmark-emoji v1.0.2
 	go.uber.org/automaxprocs v1.5.3
 	gocloud.dev v0.36.0
 	golang.org/x/exp v0.0.0-20221031165847-c99f073a8326
-	golang.org/x/image v0.15.0
-	golang.org/x/mod v0.16.0
-	golang.org/x/net v0.22.0
-	golang.org/x/sync v0.6.0
-	golang.org/x/text v0.14.0
-	golang.org/x/tools v0.19.0
+	golang.org/x/image v0.16.0
+	golang.org/x/mod v0.17.0
+	golang.org/x/net v0.25.0
+	golang.org/x/sync v0.7.0
+	golang.org/x/text v0.15.0
+	golang.org/x/tools v0.20.0
 	google.golang.org/api v0.152.0
 	gopkg.in/yaml.v2 v2.4.0
 )
@@ -100,8 +102,8 @@ require (
 	github.com/aws/aws-sdk-go-v2/credentials v1.16.12 // indirect
 	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.10 // indirect
 	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.15.7 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.7.2 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/v4a v1.2.9 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect
@@ -112,7 +114,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/sso v1.18.5 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.5 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sts v1.26.5 // indirect
-	github.com/aws/smithy-go v1.19.0 // indirect
+	github.com/aws/smithy-go v1.20.2 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
 	github.com/dlclark/regexp2 v1.11.0 // indirect
 	github.com/go-openapi/jsonpointer v0.20.2 // indirect
@@ -142,9 +144,9 @@ require (
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	go.opencensus.io v0.24.0 // indirect
-	golang.org/x/crypto v0.21.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
 	golang.org/x/oauth2 v0.15.0 // indirect
-	golang.org/x/sys v0.18.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
 	golang.org/x/time v0.5.0 // indirect
 	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect
 	google.golang.org/appengine v1.6.8 // indirect
@@ -152,7 +154,7 @@ require (
 	google.golang.org/genproto/googleapis/api v0.0.0-20231120223509-83a465c0220f // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20231120223509-83a465c0220f // indirect
 	google.golang.org/grpc v1.59.0 // indirect
-	google.golang.org/protobuf v1.31.0 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	howett.net/plist v1.0.0 // indirect
 	software.sslmate.com/src/go-pkcs12 v0.2.0 // indirect
@@ -53,6 +53,7 @@ github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.4.0/go.mod h1:1fXstnBMas5kzG
 github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.0 h1:d81/ng9rET2YqdVkVwkb6EXeRrLJIwyGnJcAlAWKwhs=
 github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.0/go.mod h1:s4kgfzA0covAXNicZHDMN58jExvcng2mC/DepXiF1EI=
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.2.0 h1:Ma67P/GGprNwsslzEH6+Kb8nybI8jpDTm4Wmzu2ReK8=
+github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.2.0/go.mod h1:c+Lifp3EDEamAkPVzMooRNOK6CZjNSdEnf1A7jsI9u4=
 github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.2.0 h1:gggzg0SUMs6SQbEw+3LoSsYf9YMjkupeAnHMX8O9mmY=
 github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.2.0/go.mod h1:+6KLcKIVgxoBDMqMO/Nvy7bZ9a0nbU3I1DtFQK3YvB4=
 github.com/Azure/go-autorest v14.2.0+incompatible h1:V5VMDjClD3GiElqLWO7mz2MxNAK/vTfRHdAubSIPRgs=
@@ -67,15 +68,17 @@ github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/alecthomas/assert/v2 v2.6.0 h1:o3WJwILtexrEUk3cUVal3oiQY2tfgr/FHWiz/v2n4FU=
+github.com/alecthomas/assert/v2 v2.6.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
 github.com/alecthomas/chroma/v2 v2.13.0 h1:VP72+99Fb2zEcYM0MeaWJmV+xQvz5v5cxRHd+ooU1lI=
 github.com/alecthomas/chroma/v2 v2.13.0/go.mod h1:BUGjjsD+ndS6eX37YgTchSEG+Jg9Jv1GiZs9sqPqztk=
 github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.4.0/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.50.7 h1:odKb+uneeGgF2jgAerKjFzpljiyZxleV4SHB7oBK+YA=
 github.com/aws/aws-sdk-go v1.50.7/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk=
-github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU=
-github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4=
+github.com/aws/aws-sdk-go-v2 v1.26.1 h1:5554eUqIYVWpU0YmeeYZ0wU64H2VLBs8TlhRB2L+EkA=
+github.com/aws/aws-sdk-go-v2 v1.26.1/go.mod h1:ffIFB97e2yNsv4aTSGkqtHnppsIJzw7G7BReUZ3jCXM=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.5.4 h1:OCs21ST2LrepDfD3lwlQiOqIGp6JiEUqG84GzTDoyJs=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.5.4/go.mod h1:usURWEKSNNAcAZuzRn/9ZYPT8aZQkR7xcCtunK/LkJo=
 github.com/aws/aws-sdk-go-v2/config v1.26.1 h1:z6DqMxclFGL3Zfo+4Q0rLnAZ6yVkzCRxhRMsiRQnD1o=
@@ -86,16 +89,16 @@ github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.10 h1:w98BT5w+ao1/r5sUuiH6Jk
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.10/go.mod h1:K2WGI7vUvkIv1HoNbfBA1bvIZ+9kL3YVmWxeKuLQsiw=
 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.15.7 h1:FnLf60PtjXp8ZOzQfhJVsqF0OtYKQZWQfqOLshh8YXg=
 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.15.7/go.mod h1:tDVvl8hyU6E9B8TrnNrZQEVkQlB8hjJwcgpPhgtlnNg=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 h1:vF+Zgd9s+H4vOXd5BMaPWykta2a6Ih0AKLq/X6NYKn4=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10/go.mod h1:6BkRjejp/GR4411UGqkX8+wFMbFbqsUIimfK4XjOKR4=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 h1:nYPe006ktcqUji8S2mqXf9c/7NdiKriOwMvWQHgYztw=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10/go.mod h1:6UV4SZkVvmODfXKql4LCbaZUpF7HO2BX38FgBf9ZOLw=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 h1:aw39xVGeRWlWx9EzGVnhOR4yOjQDHPQ6o6NmBlscyQg=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5/go.mod h1:FSaRudD0dXiMPK2UjknVwwTYyZMRsHv3TtkabsZih5I=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 h1:PG1F3OD1szkuQPzDw3CIQsRIrtTlUC3lP84taWzHlq0=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5/go.mod h1:jU1li6RFryMz+so64PpKtudI+QzbKoIEivqdf6LNpOc=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.7.2 h1:GrSw8s0Gs/5zZ0SX+gX4zQjRnRsMJDJ2sLur1gRBhEM=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.7.2/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.2.9 h1:ugD6qzjYtB7zM5PN/ZIeaAIyefPaD82G8+SJopgvUpw=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.2.9/go.mod h1:YD0aYBWCrPENpHolhKw2XDlTIWae2GKXT1T4o6N6hiM=
-github.com/aws/aws-sdk-go-v2/service/cloudfront v1.32.6 h1:xKbFXea2CIF/Wskauz1TMr//wZ6FyzEafMdSBIQqn80=
-github.com/aws/aws-sdk-go-v2/service/cloudfront v1.32.6/go.mod h1:iB6PQSb3ULRrrlEiuFfVE318JiBOdk4k46BbuzrrgXc=
+github.com/aws/aws-sdk-go-v2/service/cloudfront v1.35.4 h1:a4gfRHHCzvV0jEjOUdZOK0oJ4H21x5WT+E4ucWk4jeM=
+github.com/aws/aws-sdk-go-v2/service/cloudfront v1.35.4/go.mod h1:Pphkts8iBnexoEpcMti5fUvN3/yoGRLtl2heOeppF70=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 h1:/b31bi3YVNlkzkBrm9LfpaKoaYZUxIAj4sHfOTmLfqw=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4/go.mod h1:2aGXHFmbInwgP9ZfpmdIfOELL79zhdNYNmReK8qDfdQ=
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.2.9 h1:/90OR2XbSYfXucBMJ4U14wrjlfleq/0SB6dZDPncgmo=
@@ -112,8 +115,8 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.5 h1:2k9KmFawS63euAkY4/ixVNsY
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.5/go.mod h1:W+nd4wWDVkSUIox9bacmkBP5NMFQeTJ/xqNabpzSR38=
 github.com/aws/aws-sdk-go-v2/service/sts v1.26.5 h1:5UYvv8JUvllZsRnfrcMQ+hJ9jNICmcgKPAO1CER25Wg=
 github.com/aws/aws-sdk-go-v2/service/sts v1.26.5/go.mod h1:XX5gh4CB7wAs4KhcF46G6C8a2i7eupU19dcAAE+EydU=
-github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM=
-github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE=
+github.com/aws/smithy-go v1.20.2 h1:tbp628ireGtzcHDDmLT/6ADHidqnwgF57XOXZe6tp4Q=
+github.com/aws/smithy-go v1.20.2/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E=
 github.com/bep/clocks v0.5.0 h1:hhvKVGLPQWRVsBP/UB7ErrHYIO42gINVbvqxvYTPVps=
 github.com/bep/clocks v0.5.0/go.mod h1:SUq3q+OOq41y2lRQqH5fsOoxN8GbxSiT6jvoVVLCVhU=
 github.com/bep/debounce v1.2.0 h1:wXds8Kq8qRfwAOpAxHrJDbCXgC5aHSzgQb/0gKsHQqo=
@@ -171,6 +174,7 @@ github.com/disintegration/gift v1.2.1/go.mod h1:Jh2i7f7Q2BM7Ezno3PhfezbR1xpUg9dU
 github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
 github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dnaeon/go-vcr v1.2.0 h1:zHCHvJYTMh1N7xnV7zf1m1GPBF9Ad0Jk/whtQ1663qI=
+github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
@@ -205,12 +209,21 @@ github.com/go-openapi/jsonpointer v0.20.2/go.mod h1:bHen+N0u1KEO3YlmqOjTT9Adn1Rf
 github.com/go-openapi/swag v0.22.8 h1:/9RjDSQ0vbFR+NyjGMkFTsA1IA0fmhKSThmfGZjicbw=
 github.com/go-openapi/swag v0.22.8/go.mod h1:6QT22icPLEqAM/z/TChgb4WAveCHF92+2gF0CNjHpPI=
 github.com/go-test/deep v1.0.8 h1:TDsG77qcSprGbC6vTN8OuXp5g+J+b5Pcguhf7Zt61VM=
+github.com/go-test/deep v1.0.8/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE=
 github.com/gobuffalo/flect v1.0.2 h1:eqjPGSo2WmjgY2XlpGwo2NXgL3RucAKo4k4qQMNA5sA=
 github.com/gobuffalo/flect v1.0.2/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/gohugoio/go-i18n/v2 v2.1.3-0.20230805085216-e63c13218d0e h1:QArsSubW7eDh8APMXkByjQWvuljwPGAGQpJEFn0F0wY=
 github.com/gohugoio/go-i18n/v2 v2.1.3-0.20230805085216-e63c13218d0e/go.mod h1:3Ltoo9Banwq0gOtcOwxuHG6omk+AwsQPADyw2vQYOJQ=
+github.com/gohugoio/httpcache v0.5.0 h1:9xi4VuXd+KT3h0jOs8DlZxTMu5CtjDr0BvQMAuL/O5I=
+github.com/gohugoio/httpcache v0.5.0/go.mod h1:fMlPrdY/vVJhAriLZnrF5QpN3BNAcoBClgAyQd+lGFI=
+github.com/gohugoio/httpcache v0.6.0 h1:5pYJM43Yoc4uvIJ+/e770PS48srTumvuQZpuBfGFZV0=
+github.com/gohugoio/httpcache v0.6.0/go.mod h1:fMlPrdY/vVJhAriLZnrF5QpN3BNAcoBClgAyQd+lGFI=
+github.com/gohugoio/httpcache v0.7.0 h1:ukPnn04Rgvx48JIinZvZetBfHaWE7I01JR2Q2RrQ3Vs=
+github.com/gohugoio/httpcache v0.7.0/go.mod h1:fMlPrdY/vVJhAriLZnrF5QpN3BNAcoBClgAyQd+lGFI=
+github.com/gohugoio/hugo-goldmark-extensions/extras v0.1.0 h1:YhxZNU8y2vxV6Ibr7QJzzUlpr8oHHWX/l+Q1R/a5Zao=
+github.com/gohugoio/hugo-goldmark-extensions/extras v0.1.0/go.mod h1:0cuvOnGKW7WeXA3i7qK6IS07FH1bgJ2XzOjQ7BMJYH4=
 github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.2.0 h1:PCtO5l++psZf48yen2LxQ3JiOXxaRC6v0594NeHvGZg=
 github.com/gohugoio/hugo-goldmark-extensions/passthrough v0.2.0/go.mod h1:g9CCh+Ci2IMbPUrVJuXbBTrA+rIIx5+hDQ4EXYaQDoM=
 github.com/gohugoio/locales v0.14.0 h1:Q0gpsZwfv7ATHMbcTNepFd59H7GoykzWJIxi113XGDc=
@@ -270,12 +283,15 @@ github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeN
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-replayers/grpcreplay v1.1.0 h1:S5+I3zYyZ+GQz68OfbURDdt/+cSMqCK1wrvNx7WBzTE=
+github.com/google/go-replayers/grpcreplay v1.1.0/go.mod h1:qzAvJ8/wi57zq7gWqaE6AwLM6miiXUQwP1S+I9icmhk=
 github.com/google/go-replayers/httpreplay v1.2.0 h1:VM1wEyyjaoU53BwrOnaf9VhAyQQEEioJvFYxYcLRKzk=
+github.com/google/go-replayers/httpreplay v1.2.0/go.mod h1:WahEFFZZ7a1P4VM1qEeHy+tME4bwyqPcwWbNlUI1Mcg=
 github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
 github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
 github.com/google/martian/v3 v3.3.2 h1:IqNFLAmvJOgVlpdEBiQbDc2EwKW77amAycfTuWKdfvw=
+github.com/google/martian/v3 v3.3.2/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk=
 github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
@@ -311,6 +327,7 @@ github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ
 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -376,8 +393,8 @@ github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 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.1.1 h1:LWAJwfNvjQZCFIDKWYQaM62NcYeYViCmWIwmOStowAI=
-github.com/pelletier/go-toml/v2 v2.1.1/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s=
 github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw=
 github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8 h1:KoWmjvw+nsYOo29YJK9vDA65RGE3NrOnUtO7a+RF9HU=
@@ -390,6 +407,7 @@ github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=
+github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -417,6 +435,7 @@ github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An
 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/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 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=
@@ -425,15 +444,18 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/tdewolff/minify/v2 v2.20.19 h1:tX0SR0LUrIqGoLjXnkIzRSIbKJ7PaNnSENLD4CyH6Xo=
-github.com/tdewolff/minify/v2 v2.20.19/go.mod h1:ulkFoeAVWMLEyjuDz1ZIWOA31g5aWOawCFRp9R/MudM=
-github.com/tdewolff/parse/v2 v2.7.12 h1:tgavkHc2ZDEQVKy1oWxwIyh5bP4F5fEh/JmBwPP/3LQ=
-github.com/tdewolff/parse/v2 v2.7.12/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tdewolff/minify/v2 v2.20.20 h1:vhULb+VsW2twkplgsawAoUY957efb+EdiZ7zu5fUhhk=
+github.com/tdewolff/minify/v2 v2.20.20/go.mod h1:GYaLXFpIIwsX99apQHXfGdISUdlA98wmaoWxjT9C37k=
+github.com/tdewolff/parse/v2 v2.7.13 h1:iSiwOUkCYLNfapHoqdLcqZVgvQ0jrsao8YYKP/UJYTI=
+github.com/tdewolff/parse/v2 v2.7.13/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
 github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
 github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo=
+github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8=
 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/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -441,8 +463,8 @@ github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9dec
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.3.7/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.0 h1:EfOIvIMZIzHdB/R/zVrikYLPPwJlfMcNczJFMs1m6sA=
-github.com/yuin/goldmark v1.7.0/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
+github.com/yuin/goldmark v1.7.1 h1:3bajkSilaCbjdKVsKdZjZCLBNPL9pYzrCakKaf4U49U=
+github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
 github.com/yuin/goldmark-emoji v1.0.2 h1:c/RgTShNgHTtc6xdz2KKI74jJr6rWi7FPgnP9GAsO5s=
 github.com/yuin/goldmark-emoji v1.0.2/go.mod h1:RhP/RWpexdp+KHs7ghKnifRoIs/Bq4nDS7tRbCkOwKY=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
@@ -466,8 +488,8 @@ golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm
 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.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
-golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 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=
@@ -483,8 +505,8 @@ golang.org/x/exp v0.0.0-20221031165847-c99f073a8326/go.mod h1:CxIveKay+FTh1D0yPZ
 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.15.0 h1:kOELfmgrmJlw4Cdb7g/QGuB3CvDrXbqEIww/pNtNBm8=
-golang.org/x/image v0.15.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE=
+golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw=
+golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs=
 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=
@@ -508,8 +530,8 @@ 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.16.0 h1:QX4fJ0Rr5cPQCF7O9lh9Se4pmwfwskqZfq5moyldzic=
-golang.org/x/mod v0.16.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 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=
@@ -545,8 +567,8 @@ golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v
 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.22.0 h1:9sGLhx7iRIHEiX0oAJ3MRZMUCElJgy7Br1nO+AMN3Tc=
-golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 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=
@@ -570,8 +592,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ
 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.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 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=
@@ -615,8 +637,8 @@ golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBc
 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.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
-golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 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/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -628,8 +650,8 @@ 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.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 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=
@@ -685,8 +707,8 @@ golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4f
 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.19.0 h1:tfGCXNR1OsFG+sVdLAitlpjAvD/I6dHDKnYrpEZUHkw=
-golang.org/x/tools v0.19.0/go.mod h1:qoJWxmGSIBmAeriMx19ogtrEPrGtDbPK634QFIcLAhc=
+golang.org/x/tools v0.20.0 h1:hz/CVckiOxybQvFw6h7b/q80NTr9IUQb4s1IIzW7KNY=
+golang.org/x/tools v0.20.0/go.mod h1:WvitBU7JJf6A4jOdg4S1tviW9bhUxkgeCui/0JHctQg=
 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=
@@ -795,11 +817,12 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
-google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 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=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 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=
@@ -26,6 +26,7 @@ import (

 	"github.com/gohugoio/hugo/common/hexec"
 	"github.com/gohugoio/hugo/common/loggers"
+	"github.com/gohugoio/hugo/media"

 	"github.com/spf13/afero"

@@ -36,11 +37,6 @@ import (
 	"github.com/gohugoio/hugo/config"
 )

-var (
-	openingPTag = []byte("<p>")
-	closingPTag = []byte("</p>")
-)
-
 // ContentSpec provides functionality to render markdown content.
 type ContentSpec struct {
 	Converters          markup.ConverterProvider
@@ -140,20 +136,16 @@ func (c *ContentSpec) SanitizeAnchorName(s string) string {
 }

 func (c *ContentSpec) ResolveMarkup(in string) string {
-	if c == nil {
-		panic("nil ContentSpec")
-	}
 	in = strings.ToLower(in)
-	switch in {
-	case "md", "markdown", "mdown":
-		return "markdown"
-	case "html", "htm":
-		return "html"
-	default:
-		if conv := c.Converters.Get(in); conv != nil {
-			return conv.Name()
-		}
+
+	if mediaType, found := c.Cfg.ContentTypes().(media.ContentTypes).Types().GetBestMatch(markup.ResolveMarkup(in)); found {
+		return mediaType.SubType
 	}
+
+	if conv := c.Converters.Get(in); conv != nil {
+		return markup.ResolveMarkup(conv.Name())
+	}
+
 	return ""
 }

@@ -242,19 +234,26 @@ func (c *ContentSpec) TruncateWordsToWholeSentence(s string) (string, bool) {
 	return strings.TrimSpace(s[:endIndex]), endIndex < len(s)
 }

-// TrimShortHTML removes the <p>/</p> tags from HTML input in the situation
-// where said tags are the only <p> tags in the input and enclose the content
-// of the input (whitespace excluded).
-func (c *ContentSpec) TrimShortHTML(input []byte) []byte {
-	if bytes.Count(input, openingPTag) == 1 {
+// TrimShortHTML removes the outer tags from HTML input where (a) the opening
+// tag is present only once with the input, and (b) the opening and closing
+// tags wrap the input after white space removal.
+func (c *ContentSpec) TrimShortHTML(input []byte, markup string) []byte {
+	openingTag := []byte("<p>")
+	closingTag := []byte("</p>")
+
+	if markup == media.DefaultContentTypes.AsciiDoc.SubType {
+		openingTag = []byte("<div class=\"paragraph\">\n<p>")
+		closingTag = []byte("</p>\n</div>")
+	}
+
+	if bytes.Count(input, openingTag) == 1 {
 		input = bytes.TrimSpace(input)
-		if bytes.HasPrefix(input, openingPTag) && bytes.HasSuffix(input, closingPTag) {
-			input = bytes.TrimPrefix(input, openingPTag)
-			input = bytes.TrimSuffix(input, closingPTag)
+		if bytes.HasPrefix(input, openingTag) && bytes.HasSuffix(input, closingTag) {
+			input = bytes.TrimPrefix(input, openingTag)
+			input = bytes.TrimSuffix(input, closingTag)
 			input = bytes.TrimSpace(input)
 		}
 	}
-
 	return input
 }

@@ -26,30 +26,41 @@ import (

 func TestTrimShortHTML(t *testing.T) {
 	tests := []struct {
-		input, output []byte
+		markup string
+		input  []byte
+		output []byte
 	}{
-		{[]byte(""), []byte("")},
-		{[]byte("Plain text"), []byte("Plain text")},
-		// This seems wrong. Why touch it if it doesn't have p tag?
-		// {[]byte("  \t\n Whitespace text\n\n"), []byte("Whitespace text")},
-		{[]byte("<p>Simple paragraph</p>"), []byte("Simple paragraph")},
-		{[]byte("\n  \n \t  <p> \t Whitespace\nHTML  \n\t </p>\n\t"), []byte("Whitespace\nHTML")},
-		{[]byte("<p>Multiple</p><p>paragraphs</p>"), []byte("<p>Multiple</p><p>paragraphs</p>")},
-		{[]byte("<p>Nested<p>paragraphs</p></p>"), []byte("<p>Nested<p>paragraphs</p></p>")},
-		{[]byte("<p>Hello</p>\n<ul>\n<li>list1</li>\n<li>list2</li>\n</ul>"), []byte("<p>Hello</p>\n<ul>\n<li>list1</li>\n<li>list2</li>\n</ul>")},
-		// Issue #11698
-		{[]byte("<h2 id=`a`>b</h2>\n\n<p>c</p>"), []byte("<h2 id=`a`>b</h2>\n\n<p>c</p>")},
+		{"markdown", []byte(""), []byte("")},
+		{"markdown", []byte("Plain text"), []byte("Plain text")},
+		{"markdown", []byte("<p>Simple paragraph</p>"), []byte("Simple paragraph")},
+		{"markdown", []byte("\n  \n \t  <p> \t Whitespace\nHTML  \n\t </p>\n\t"), []byte("Whitespace\nHTML")},
+		{"markdown", []byte("<p>Multiple</p><p>paragraphs</p>"), []byte("<p>Multiple</p><p>paragraphs</p>")},
+		{"markdown", []byte("<p>Nested<p>paragraphs</p></p>"), []byte("<p>Nested<p>paragraphs</p></p>")},
+		{"markdown", []byte("<p>Hello</p>\n<ul>\n<li>list1</li>\n<li>list2</li>\n</ul>"), []byte("<p>Hello</p>\n<ul>\n<li>list1</li>\n<li>list2</li>\n</ul>")},
+		// Issue 11698
+		{"markdown", []byte("<h2 id=`a`>b</h2>\n\n<p>c</p>"), []byte("<h2 id=`a`>b</h2>\n\n<p>c</p>")},
+		// Issue 12369
+		{"markdown", []byte("<div class=\"paragraph\">\n<p>foo</p>\n</div>"), []byte("<div class=\"paragraph\">\n<p>foo</p>\n</div>")},
+		{"asciidoc", []byte("<div class=\"paragraph\">\n<p>foo</p>\n</div>"), []byte("foo")},
 	}

 	c := newTestContentSpec(nil)
 	for i, test := range tests {
-		output := c.TrimShortHTML(test.input)
+		output := c.TrimShortHTML(test.input, test.markup)
 		if !bytes.Equal(test.output, output) {
 			t.Errorf("Test %d failed. Expected %q got %q", i, test.output, output)
 		}
 	}
 }

+func BenchmarkTrimShortHTML(b *testing.B) {
+	c := newTestContentSpec(nil)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		c.TrimShortHTML([]byte("<p>Simple paragraph</p>"), "markdown")
+	}
+}
+
 func TestBytesToHTML(t *testing.T) {
 	c := qt.New(t)
 	c.Assert(helpers.BytesToHTML([]byte("dobedobedo")), qt.Equals, template.HTML("dobedobedo"))
@@ -35,9 +35,9 @@ func TestResolveMarkup(t *testing.T) {
 		{"md", "markdown"},
 		{"markdown", "markdown"},
 		{"mdown", "markdown"},
-		{"asciidocext", "asciidocext"},
-		{"adoc", "asciidocext"},
-		{"ad", "asciidocext"},
+		{"asciidocext", "asciidoc"},
+		{"adoc", "asciidoc"},
+		{"ad", "asciidoc"},
 		{"rst", "rst"},
 		{"pandoc", "pandoc"},
 		{"pdc", "pandoc"},
@@ -374,7 +374,7 @@ func cacheDirDefault(cacheDir string) string {
 	// Turns out that Cloudflare also sets NETLIFY=true in its build environment,
 	// but all of these 3 should not give any false positives.
 	if os.Getenv("NETLIFY") == "true" && os.Getenv("PULL_REQUEST") != "" && os.Getenv("DEPLOY_PRIME_URL") != "" {
-		// Netlify's cache behaviour is not documented, the currently best example
+		// Netlify's cache behavior is not documented, the currently best example
 		// is this project:
 		// https://github.com/philhawksworth/content-shards/blob/master/gulpfile.js
 		return "/opt/build/cache/hugo_cache/"
@@ -16,6 +16,7 @@ package hqt
 import (
 	"errors"
 	"fmt"
+	"math"
 	"reflect"
 	"strings"

@@ -38,6 +39,11 @@ var IsSameType qt.Checker = &typeChecker{
 	argNames: []string{"got", "want"},
 }

+// IsSameFloat64 asserts that two float64 values are equal within a small delta.
+var IsSameFloat64 = qt.CmpEquals(cmp.Comparer(func(a, b float64) bool {
+	return math.Abs(a-b) < 0.0001
+}))
+
 type argNames []string

 func (a argNames) ArgNames() []string {
@@ -29,57 +29,13 @@ const (
 	FilenameHugoStatsJSON = "hugo_stats.json"
 )

-var (
-	// This should be the only list of valid extensions for content files.
-	contentFileExtensions = []string{
-		"html", "htm",
-		"mdown", "markdown", "md",
-		"asciidoc", "adoc", "ad",
-		"rest", "rst",
-		"org",
-		"pandoc", "pdc",
-	}
-
-	contentFileExtensionsSet map[string]bool
-
-	htmlFileExtensions = []string{
-		"html", "htm",
-	}
-
-	htmlFileExtensionsSet map[string]bool
-)
-
-func init() {
-	contentFileExtensionsSet = make(map[string]bool)
-	for _, ext := range contentFileExtensions {
-		contentFileExtensionsSet[ext] = true
-	}
-	htmlFileExtensionsSet = make(map[string]bool)
-	for _, ext := range htmlFileExtensions {
-		htmlFileExtensionsSet[ext] = true
-	}
+func IsGoTmplExt(ext string) bool {
+	return ext == "gotmpl"
 }

-func IsContentFile(filename string) bool {
-	return contentFileExtensionsSet[strings.TrimPrefix(filepath.Ext(filename), ".")]
-}
-
-func IsIndexContentFile(filename string) bool {
-	if !IsContentFile(filename) {
-		return false
-	}
-
-	base := filepath.Base(filename)
-
-	return strings.HasPrefix(base, "index.") || strings.HasPrefix(base, "_index.")
-}
-
-func IsHTML(ext string) bool {
-	return htmlFileExtensionsSet[ext]
-}
-
-func IsContentExt(ext string) bool {
-	return contentFileExtensionsSet[ext]
+// Supported data file extensions for _content.* files.
+func IsContentDataExt(ext string) bool {
+	return IsGoTmplExt(ext)
 }

 const (
@@ -93,6 +49,8 @@ const (

 	FolderResources = "resources"
 	FolderJSConfig  = "_jsconfig" // Mounted below /assets with postcss.config.js etc.
+
+	NameContentData = "_content"
 )

 var (
@@ -14,22 +14,11 @@
 package files

 import (
-	"path/filepath"
 	"testing"

 	qt "github.com/frankban/quicktest"
 )

-func TestIsContentFile(t *testing.T) {
-	c := qt.New(t)
-
-	c.Assert(IsContentFile(filepath.FromSlash("my/file.md")), qt.Equals, true)
-	c.Assert(IsContentFile(filepath.FromSlash("my/file.ad")), qt.Equals, true)
-	c.Assert(IsContentFile(filepath.FromSlash("textfile.txt")), qt.Equals, false)
-	c.Assert(IsContentExt("md"), qt.Equals, true)
-	c.Assert(IsContentExt("json"), qt.Equals, false)
-}
-
 func TestComponentFolders(t *testing.T) {
 	c := qt.New(t)

@@ -23,6 +23,7 @@ import (
 	"github.com/gohugoio/hugo/common/herrors"
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/paths"
+	"github.com/gohugoio/hugo/media"

 	"github.com/spf13/afero"
 )
@@ -50,7 +51,8 @@ type WalkwayConfig struct {
 	Root string

 	// The logger to use.
-	Logger loggers.Logger
+	Logger     loggers.Logger
+	PathParser *paths.PathParser

 	// One or both of these may be pre-set.
 	Info       FileMetaInfo               // The start info.
@@ -72,6 +74,10 @@ func NewWalkway(cfg WalkwayConfig) *Walkway {
 		panic("fs must be set")
 	}

+	if cfg.PathParser == nil {
+		cfg.PathParser = media.DefaultPathParser
+	}
+
 	logger := cfg.Logger
 	if logger == nil {
 		logger = loggers.NewDefault()
@@ -161,7 +167,7 @@ func (w *Walkway) walk(path string, info FileMetaInfo, dirEntries []FileMetaInfo
 		dirEntries = DirEntriesToFileMetaInfos(fis)
 		for _, fi := range dirEntries {
 			if fi.Meta().PathInfo == nil {
-				fi.Meta().PathInfo = paths.Parse("", filepath.Join(pathRel, fi.Name()))
+				fi.Meta().PathInfo = w.cfg.PathParser.Parse("", filepath.Join(pathRel, fi.Name()))
 			}
 		}

@@ -329,7 +329,7 @@ cascade:

 		counters := &buildCounters{}
 		b.Build(BuildCfg{testCounters: counters})
-		b.Assert(int(counters.contentRenderCounter.Load()), qt.Equals, 2)
+		b.Assert(int(counters.contentRenderCounter.Load()), qt.Equals, 1)

 		b.AssertFileContent("public/post/index.html", `Banner: post.jpg|Layout: postlayout|Type: posttype|Content: <p>content edit</p>`)
 		b.AssertFileContent("public/post/dir/p1/index.html", `Banner: post.jpg|Layout: postlayout|`)
@@ -672,6 +672,55 @@ S1|p1:|p2:p2|
 	})
 }

+func TestCascadeEditIssue12449(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+disableKinds = ['sitemap','rss', 'home', 'taxonomy','term']
+disableLiveReload = true
+-- layouts/_default/list.html --
+Title: {{ .Title }}|{{ .Content }}|cascadeparam: {{ .Params.cascadeparam }}|
+-- layouts/_default/single.html --
+Title: {{ .Title }}|{{ .Content }}|cascadeparam: {{ .Params.cascadeparam }}|
+-- content/mysect/_index.md --
+---
+title: mysect
+cascade:
+  description: descriptionvalue
+  params:
+    cascadeparam: cascadeparamvalue
+---
+mysect-content|
+-- content/mysect/p1/index.md --
+---
+slug: p1
+---
+p1-content|
+-- content/mysect/subsect/_index.md --
+---
+slug: subsect
+---
+subsect-content|
+`
+
+	b := TestRunning(t, files)
+
+	// Make the cascade set the title.
+	b.EditFileReplaceAll("content/mysect/_index.md", "description: descriptionvalue", "title: cascadetitle").Build()
+	b.AssertFileContent("public/mysect/subsect/index.html", "Title: cascadetitle|")
+
+	// Edit cascade title.
+	b.EditFileReplaceAll("content/mysect/_index.md", "title: cascadetitle", "title: cascadetitle-edit").Build()
+	b.AssertFileContent("public/mysect/subsect/index.html", "Title: cascadetitle-edit|")
+
+	// Revert title change.
+	// The step below failed in #12449.
+	b.EditFileReplaceAll("content/mysect/_index.md", "title: cascadetitle-edit", "description: descriptionvalue").Build()
+	b.AssertFileContent("public/mysect/subsect/index.html", "Title: |")
+}
+
 // Issue 11977.
 func TestCascadeExtensionInPath(t *testing.T) {
 	t.Parallel()
@@ -490,11 +490,10 @@ name = "menu-theme"
 			got := b.Configs.Base

 			if mergeStrategy == "none" {
-				b.Assert(got.Sitemap, qt.DeepEquals, config.SitemapConfig{ChangeFreq: "", Priority: -1, Filename: "sitemap.xml"})
-
+				b.Assert(got.Sitemap, qt.DeepEquals, config.SitemapConfig{ChangeFreq: "", Disable: false, Priority: -1, Filename: "sitemap.xml"})
 				b.AssertFileContent("public/sitemap.xml", "schemas/sitemap")
 			} else {
-				b.Assert(got.Sitemap, qt.DeepEquals, config.SitemapConfig{ChangeFreq: "monthly", Priority: -1, Filename: "sitemap.xml"})
+				b.Assert(got.Sitemap, qt.DeepEquals, config.SitemapConfig{ChangeFreq: "monthly", Disable: false, Priority: -1, Filename: "sitemap.xml"})
 				b.AssertFileContent("public/sitemap.xml", "<changefreq>monthly</changefreq>")
 			}
 		})
@@ -1145,7 +1144,7 @@ Home.

 	enConfig := b.H.Sites[0].conf
 	m, _ := enConfig.MediaTypes.Config.GetByType("text/html")
-	b.Assert(m.Suffixes(), qt.DeepEquals, []string{"html"})
+	b.Assert(m.Suffixes(), qt.DeepEquals, []string{"html", "htm"})

 	svConfig := b.H.Sites[1].conf
 	f, _ := svConfig.OutputFormats.Config.GetByName("html")
@@ -14,6 +14,7 @@
 package hugolib

 import (
+	"context"
 	"fmt"
 	"path"
 	"path/filepath"
@@ -23,10 +24,13 @@ import (
 	"github.com/bep/logg"
 	"github.com/gohugoio/hugo/common/hugio"
 	"github.com/gohugoio/hugo/common/paths"
+	"github.com/gohugoio/hugo/hugofs/files"
+	"github.com/gohugoio/hugo/hugolib/pagesfromdata"
 	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/source"

 	"github.com/gohugoio/hugo/resources/page"
+	"github.com/gohugoio/hugo/resources/page/pagemeta"
 	"github.com/gohugoio/hugo/resources/resource"

 	"github.com/gohugoio/hugo/hugofs"
@@ -51,9 +55,11 @@ type contentMapConfig struct {
 var _ contentNodeI = (*resourceSource)(nil)

 type resourceSource struct {
-	path   *paths.Path
-	opener hugio.OpenReadSeekCloser
-	fi     hugofs.FileMetaInfo
+	langIndex int
+	path      *paths.Path
+	opener    hugio.OpenReadSeekCloser
+	fi        hugofs.FileMetaInfo
+	rc        *pagemeta.ResourceConfig

 	r resource.Resource
 }
@@ -64,11 +70,7 @@ func (r resourceSource) clone() *resourceSource {
 }

 func (r *resourceSource) LangIndex() int {
-	if r.r != nil && r.isPage() {
-		return r.r.(*pageState).s.languagei
-	}
-
-	return r.fi.Meta().LangIndex
+	return r.langIndex
 }

 func (r *resourceSource) MarkStale() {
@@ -162,12 +164,62 @@ func (cfg contentMapConfig) getTaxonomyConfig(s string) (v viewName) {
 	return
 }

-func (m *pageMap) AddFi(fi hugofs.FileMetaInfo) error {
+func (m *pageMap) insertPageWithLock(s string, p *pageState) (contentNodeI, contentNodeI, bool) {
+	u, n, replaced := m.treePages.InsertIntoValuesDimensionWithLock(s, p)
+
+	if replaced && !m.s.h.isRebuild() && m.s.conf.PrintPathWarnings {
+		var messageDetail string
+		if p1, ok := n.(*pageState); ok && p1.File() != nil {
+			messageDetail = fmt.Sprintf(" file: %q", p1.File().Filename())
+		}
+		if p2, ok := u.(*pageState); ok && p2.File() != nil {
+			messageDetail += fmt.Sprintf(" file: %q", p2.File().Filename())
+		}
+
+		m.s.Log.Warnf("Duplicate content path: %q%s", s, messageDetail)
+	}
+
+	return u, n, replaced
+}
+
+func (m *pageMap) insertResourceWithLock(s string, r contentNodeI) (contentNodeI, contentNodeI, bool) {
+	u, n, replaced := m.treeResources.InsertIntoValuesDimensionWithLock(s, r)
+	if replaced {
+		m.handleDuplicateResourcePath(s, r, n)
+	}
+	return u, n, replaced
+}
+
+func (m *pageMap) insertResource(s string, r contentNodeI) (contentNodeI, contentNodeI, bool) {
+	u, n, replaced := m.treeResources.InsertIntoValuesDimension(s, r)
+	if replaced {
+		m.handleDuplicateResourcePath(s, r, n)
+	}
+	return u, n, replaced
+}
+
+func (m *pageMap) handleDuplicateResourcePath(s string, updated, existing contentNodeI) {
+	if m.s.h.isRebuild() || !m.s.conf.PrintPathWarnings {
+		return
+	}
+	var messageDetail string
+	if r1, ok := existing.(*resourceSource); ok && r1.fi != nil {
+		messageDetail = fmt.Sprintf(" file: %q", r1.fi.Meta().Filename)
+	}
+	if r2, ok := updated.(*resourceSource); ok && r2.fi != nil {
+		messageDetail += fmt.Sprintf(" file: %q", r2.fi.Meta().Filename)
+	}
+
+	m.s.Log.Warnf("Duplicate resource path: %q%s", s, messageDetail)
+}
+
+func (m *pageMap) AddFi(fi hugofs.FileMetaInfo, buildConfig *BuildCfg) (pageCount uint64, resourceCount uint64, addErr error) {
 	if fi.IsDir() {
-		return nil
+		return
 	}

 	insertResource := func(fim hugofs.FileMetaInfo) error {
+		resourceCount++
 		pi := fi.Meta().PathInfo
 		key := pi.Base()
 		tree := m.treeResources
@@ -181,7 +233,7 @@ func (m *pageMap) AddFi(fi hugofs.FileMetaInfo) error {

 		var rs *resourceSource
 		if pi.IsContent() {
-			// Create the page now as we need it at assemembly time.
+			// Create the page now as we need it at assembly time.
 			// The other resources are created if needed.
 			pageResource, pi, err := m.s.h.newPage(
 				&pageMeta{
@@ -199,12 +251,12 @@ func (m *pageMap) AddFi(fi hugofs.FileMetaInfo) error {
 			}
 			key = pi.Base()

-			rs = &resourceSource{r: pageResource}
+			rs = &resourceSource{r: pageResource, langIndex: pageResource.s.languagei}
 		} else {
-			rs = &resourceSource{path: pi, opener: r, fi: fim}
+			rs = &resourceSource{path: pi, opener: r, fi: fim, langIndex: fim.Meta().LangIndex}
 		}

-		tree.InsertIntoValuesDimension(key, rs)
+		_, _, _ = m.insertResource(key, rs)

 		return nil
 	}
@@ -220,14 +272,27 @@ func (m *pageMap) AddFi(fi hugofs.FileMetaInfo) error {
 			},
 		))
 		if err := insertResource(fi); err != nil {
-			return err
+			addErr = err
+			return
 		}
+	case paths.PathTypeContentData:
+		pc, rc, err := m.addPagesFromGoTmplFi(fi, buildConfig)
+		pageCount += pc
+		resourceCount += rc
+		if err != nil {
+			addErr = err
+			return
+		}
+
 	default:
 		m.s.Log.Trace(logg.StringFunc(
 			func() string {
 				return fmt.Sprintf("insert bundle: %q", fi.Meta().Filename)
 			},
 		))
+
+		pageCount++
+
 		// A content file.
 		p, pi, err := m.s.h.newPage(
 			&pageMeta{
@@ -237,17 +302,173 @@ func (m *pageMap) AddFi(fi hugofs.FileMetaInfo) error {
 			},
 		)
 		if err != nil {
-			return err
+			addErr = err
+			return
 		}
 		if p == nil {
 			// Disabled page.
-			return nil
+			return
 		}

-		m.treePages.InsertWithLock(pi.Base(), p)
+		m.insertPageWithLock(pi.Base(), p)

 	}
-	return nil
+	return
+}
+
+func (m *pageMap) addPagesFromGoTmplFi(fi hugofs.FileMetaInfo, buildConfig *BuildCfg) (pageCount uint64, resourceCount uint64, addErr error) {
+	meta := fi.Meta()
+	pi := meta.PathInfo
+
+	m.s.Log.Trace(logg.StringFunc(
+		func() string {
+			return fmt.Sprintf("insert pages from data file: %q", fi.Meta().Filename)
+		},
+	))
+
+	if !files.IsGoTmplExt(pi.Ext()) {
+		addErr = fmt.Errorf("unsupported data file extension %q", pi.Ext())
+		return
+	}
+
+	s := m.s.h.resolveSite(fi.Meta().Lang)
+	f := source.NewFileInfo(fi)
+	h := s.h
+
+	contentAdapter := s.pageMap.treePagesFromTemplateAdapters.Get(pi.Base())
+	var rebuild bool
+	if contentAdapter != nil {
+		// Rebuild
+		contentAdapter = contentAdapter.CloneForGoTmpl(fi)
+		rebuild = true
+	} else {
+		contentAdapter = pagesfromdata.NewPagesFromTemplate(
+			pagesfromdata.PagesFromTemplateOptions{
+				GoTmplFi: fi,
+				Site:     s,
+				DepsFromSite: func(s page.Site) pagesfromdata.PagesFromTemplateDeps {
+					ss := s.(*Site)
+					return pagesfromdata.PagesFromTemplateDeps{
+						TmplFinder: ss.TextTmpl(),
+						TmplExec:   ss.Tmpl(),
+					}
+				},
+				DependencyManager: s.Conf.NewIdentityManager("pagesfromdata"),
+				Watching:          s.Conf.Watching(),
+				HandlePage: func(pt *pagesfromdata.PagesFromTemplate, pc *pagemeta.PageConfig) error {
+					s := pt.Site.(*Site)
+					if err := pc.Compile(pt.GoTmplFi.Meta().PathInfo.Base(), true, "", s.Log, s.conf.MediaTypes.Config); err != nil {
+						return err
+					}
+
+					ps, pi, err := h.newPage(
+						&pageMeta{
+							f: f,
+							s: s,
+							pageMetaParams: &pageMetaParams{
+								pageConfig: pc,
+							},
+						},
+					)
+					if err != nil {
+						return err
+					}
+
+					if ps == nil {
+						// Disabled page.
+						return nil
+					}
+
+					u, n, replaced := s.pageMap.insertPageWithLock(pi.Base(), ps)
+
+					if h.isRebuild() {
+						if replaced {
+							pt.AddChange(n.GetIdentity())
+						} else {
+							pt.AddChange(u.GetIdentity())
+							// New content not in use anywhere.
+							// To make sure that these gets listed in any site.RegularPages ranges or similar
+							// we could invalidate everything, but first try to collect a sample set
+							// from the surrounding pages.
+							var surroundingIDs []identity.Identity
+							ids := h.pageTrees.collectIdentitiesSurrounding(pi.Base(), 10)
+							if len(ids) > 0 {
+								surroundingIDs = append(surroundingIDs, ids...)
+							} else {
+								// No surrounding pages found, so invalidate everything.
+								surroundingIDs = []identity.Identity{identity.GenghisKhan}
+							}
+							for _, id := range surroundingIDs {
+								pt.AddChange(id)
+							}
+						}
+					}
+
+					return nil
+				},
+				HandleResource: func(pt *pagesfromdata.PagesFromTemplate, rc *pagemeta.ResourceConfig) error {
+					s := pt.Site.(*Site)
+					if err := rc.Compile(
+						pt.GoTmplFi.Meta().PathInfo.Base(),
+						s.Conf.PathParser(),
+						s.conf.MediaTypes.Config,
+					); err != nil {
+						return err
+					}
+
+					rs := &resourceSource{path: rc.PathInfo, rc: rc, opener: nil, fi: pt.GoTmplFi, langIndex: s.languagei}
+
+					_, n, replaced := s.pageMap.insertResourceWithLock(rc.PathInfo.Base(), rs)
+
+					if h.isRebuild() && replaced {
+						pt.AddChange(n.GetIdentity())
+					}
+					return nil
+				},
+			},
+		)
+
+		s.pageMap.treePagesFromTemplateAdapters.Insert(pi.Base(), contentAdapter)
+
+	}
+
+	handleBuildInfo := func(s *Site, bi pagesfromdata.BuildInfo) {
+		resourceCount += bi.NumResourcesAdded
+		pageCount += bi.NumPagesAdded
+		s.handleContentAdapterChanges(bi, buildConfig)
+	}
+
+	bi, err := contentAdapter.Execute(context.Background())
+	if err != nil {
+		addErr = err
+		return
+	}
+	handleBuildInfo(s, bi)
+
+	if !rebuild && bi.EnableAllLanguages {
+		// Clone and insert the adapter for the other sites.
+		for _, ss := range s.h.Sites {
+			if s == ss {
+				continue
+			}
+
+			clone := contentAdapter.CloneForSite(ss)
+
+			// Make sure it gets executed for the first time.
+			bi, err := clone.Execute(context.Background())
+			if err != nil {
+				addErr = err
+				return
+			}
+			handleBuildInfo(ss, bi)
+
+			// Insert into the correct language tree so it get rebuilt on changes.
+			ss.pageMap.treePagesFromTemplateAdapters.Insert(pi.Base(), clone)
+
+		}
+	}
+
+	return
 }

 // The home page is represented with the zero string.
@@ -34,7 +34,9 @@ import (
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/hugofs/files"
 	"github.com/gohugoio/hugo/hugolib/doctree"
+	"github.com/gohugoio/hugo/hugolib/pagesfromdata"
 	"github.com/gohugoio/hugo/identity"
+	"github.com/gohugoio/hugo/media"
 	"github.com/gohugoio/hugo/output"
 	"github.com/gohugoio/hugo/resources"
 	"github.com/spf13/cast"
@@ -100,6 +102,8 @@ type pageMap struct {
 	cacheContentPlain      *dynacache.Partition[string, *resources.StaleValue[contentPlainPlainWords]]
 	contentTableOfContents *dynacache.Partition[string, *resources.StaleValue[contentTableOfContents]]

+	contentDataFileSeenItems *maps.Cache[string, map[uint64]bool]
+
 	cfg contentMapConfig
 }

@@ -122,6 +126,10 @@ type pageTrees struct {
 	// This tree contains all taxonomy entries, e.g "/tags/blue/page1"
 	treeTaxonomyEntries *doctree.TreeShiftTree[*weightedContentNode]

+	// Stores the state for _content.gotmpl files.
+	// Mostly releveant for rebuilds.
+	treePagesFromTemplateAdapters *doctree.TreeShiftTree[*pagesfromdata.PagesFromTemplate]
+
 	// A slice of the resource trees.
 	resourceTrees doctree.MutableTrees
 }
@@ -133,7 +141,7 @@ type pageTrees struct {
 func (t *pageTrees) collectAndMarkStaleIdentities(p *paths.Path) []identity.Identity {
 	key := p.Base()
 	var ids []identity.Identity
-	// We need only one identity sample per dimensio.
+	// We need only one identity sample per dimension.
 	nCount := 0
 	cb := func(n contentNodeI) bool {
 		if n == nil {
@@ -222,6 +230,7 @@ func (t pageTrees) Shape(d, v int) *pageTrees {
 	t.treePages = t.treePages.Shape(d, v)
 	t.treeResources = t.treeResources.Shape(d, v)
 	t.treeTaxonomyEntries = t.treeTaxonomyEntries.Shape(d, v)
+	t.treePagesFromTemplateAdapters = t.treePagesFromTemplateAdapters.Shape(d, v)
 	t.createMutableTrees()

 	return &t
@@ -489,12 +498,17 @@ func (m *pageMap) forEachResourceInPage(

 	rw.Handle = func(resourceKey string, n contentNodeI, match doctree.DimensionFlag) (bool, error) {
 		if isBranch {
-			ownerKey, _ := m.treePages.LongestPrefixAll(resourceKey)
-			if ownerKey != keyPage && path.Dir(ownerKey) != path.Dir(resourceKey) {
+			// A resourceKey always represents a filename with extension.
+			// A page key points to the logical path of a page, which when sourced from the filesystem
+			// may represent a directory (bundles) or a single content file (e.g. p1.md).
+			// So, to avoid any overlapping ambiguity, we start looking from the owning directory.
+			ownerKey, _ := m.treePages.LongestPrefixAll(path.Dir(resourceKey))
+			if ownerKey != keyPage {
 				// Stop walking downwards, someone else owns this resource.
 				rw.SkipPrefix(ownerKey + "/")
 				return false, nil
 			}
+
 		}
 		return handle(resourceKey, n, match)
 	}
@@ -582,9 +596,9 @@ func (m *pageMap) getOrCreateResourcesForPage(ps *pageState) resource.Resources

 		sort.SliceStable(res, lessFunc)

-		if len(ps.m.pageConfig.Resources) > 0 {
+		if len(ps.m.pageConfig.ResourcesMeta) > 0 {
 			for i, r := range res {
-				res[i] = resources.CloneWithMetadataIfNeeded(ps.m.pageConfig.Resources, r)
+				res[i] = resources.CloneWithMetadataFromMapIfNeeded(ps.m.pageConfig.ResourcesMeta, r)
 			}
 			sort.SliceStable(res, lessFunc)
 		}
@@ -662,12 +676,13 @@ type contentNodeShifter struct {
 	numLanguages int
 }

-func (s *contentNodeShifter) Delete(n contentNodeI, dimension doctree.Dimension) (bool, bool) {
+func (s *contentNodeShifter) Delete(n contentNodeI, dimension doctree.Dimension) (contentNodeI, bool, bool) {
 	lidx := dimension[0]
 	switch v := n.(type) {
 	case contentNodeIs:
-		resource.MarkStale(v[lidx])
-		wasDeleted := v[lidx] != nil
+		deleted := v[lidx]
+		resource.MarkStale(deleted)
+		wasDeleted := deleted != nil
 		v[lidx] = nil
 		isEmpty := true
 		for _, vv := range v {
@@ -676,10 +691,11 @@ func (s *contentNodeShifter) Delete(n contentNodeI, dimension doctree.Dimension)
 				break
 			}
 		}
-		return wasDeleted, isEmpty
+		return deleted, wasDeleted, isEmpty
 	case resourceSources:
-		resource.MarkStale(v[lidx])
-		wasDeleted := v[lidx] != nil
+		deleted := v[lidx]
+		resource.MarkStale(deleted)
+		wasDeleted := deleted != nil
 		v[lidx] = nil
 		isEmpty := true
 		for _, vv := range v {
@@ -688,19 +704,19 @@ func (s *contentNodeShifter) Delete(n contentNodeI, dimension doctree.Dimension)
 				break
 			}
 		}
-		return wasDeleted, isEmpty
+		return deleted, wasDeleted, isEmpty
 	case *resourceSource:
 		if lidx != v.LangIndex() {
-			return false, false
+			return nil, false, false
 		}
 		resource.MarkStale(v)
-		return true, true
+		return v, true, true
 	case *pageState:
 		if lidx != v.s.languagei {
-			return false, false
+			return nil, false, false
 		}
 		resource.MarkStale(v)
-		return true, true
+		return v, true, true
 	default:
 		panic(fmt.Sprintf("unknown type %T", n))
 	}
@@ -773,7 +789,7 @@ func (s *contentNodeShifter) ForEeachInDimension(n contentNodeI, d int, f func(c
 	}
 }

-func (s *contentNodeShifter) InsertInto(old, new contentNodeI, dimension doctree.Dimension) contentNodeI {
+func (s *contentNodeShifter) InsertInto(old, new contentNodeI, dimension doctree.Dimension) (contentNodeI, contentNodeI, bool) {
 	langi := dimension[doctree.DimensionLanguage.Index()]
 	switch vv := old.(type) {
 	case *pageState:
@@ -782,37 +798,39 @@ func (s *contentNodeShifter) InsertInto(old, new contentNodeI, dimension doctree
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
 		if vv.s.languagei == newp.s.languagei && newp.s.languagei == langi {
-			return new
+			return new, vv, true
 		}
 		is := make(contentNodeIs, s.numLanguages)
 		is[vv.s.languagei] = old
 		is[langi] = new
-		return is
+		return is, old, false
 	case contentNodeIs:
+		oldv := vv[langi]
 		vv[langi] = new
-		return vv
+		return vv, oldv, oldv != nil
 	case resourceSources:
+		oldv := vv[langi]
 		vv[langi] = new.(*resourceSource)
-		return vv
+		return vv, oldv, oldv != nil
 	case *resourceSource:
 		newp, ok := new.(*resourceSource)
 		if !ok {
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
 		if vv.LangIndex() == newp.LangIndex() && newp.LangIndex() == langi {
-			return new
+			return new, vv, true
 		}
 		rs := make(resourceSources, s.numLanguages)
 		rs[vv.LangIndex()] = vv
 		rs[langi] = newp
-		return rs
+		return rs, vv, false

 	default:
 		panic(fmt.Sprintf("unknown type %T", old))
 	}
 }

-func (s *contentNodeShifter) Insert(old, new contentNodeI) contentNodeI {
+func (s *contentNodeShifter) Insert(old, new contentNodeI) (contentNodeI, contentNodeI, bool) {
 	switch vv := old.(type) {
 	case *pageState:
 		newp, ok := new.(*pageState)
@@ -820,40 +838,52 @@ func (s *contentNodeShifter) Insert(old, new contentNodeI) contentNodeI {
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
 		if vv.s.languagei == newp.s.languagei {
-			return new
+			if newp != old {
+				resource.MarkStale(old)
+			}
+			return new, vv, true
 		}
 		is := make(contentNodeIs, s.numLanguages)
 		is[newp.s.languagei] = new
 		is[vv.s.languagei] = old
-		return is
+		return is, old, false
 	case contentNodeIs:
 		newp, ok := new.(*pageState)
 		if !ok {
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
-		resource.MarkStale(vv[newp.s.languagei])
+		oldp := vv[newp.s.languagei]
+		if oldp != newp {
+			resource.MarkStale(oldp)
+		}
 		vv[newp.s.languagei] = new
-		return vv
+		return vv, oldp, oldp != nil
 	case *resourceSource:
 		newp, ok := new.(*resourceSource)
 		if !ok {
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
 		if vv.LangIndex() == newp.LangIndex() {
-			return new
+			if vv != newp {
+				resource.MarkStale(vv)
+			}
+			return new, vv, true
 		}
 		rs := make(resourceSources, s.numLanguages)
 		rs[newp.LangIndex()] = newp
 		rs[vv.LangIndex()] = vv
-		return rs
+		return rs, vv, false
 	case resourceSources:
 		newp, ok := new.(*resourceSource)
 		if !ok {
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
-		resource.MarkStale(vv[newp.LangIndex()])
+		oldp := vv[newp.LangIndex()]
+		if oldp != newp {
+			resource.MarkStale(oldp)
+		}
 		vv[newp.LangIndex()] = newp
-		return vv
+		return vv, oldp, oldp != nil
 	default:
 		panic(fmt.Sprintf("unknown type %T", old))
 	}
@@ -873,6 +903,8 @@ func newPageMap(i int, s *Site, mcache *dynacache.Cache, pageTrees *pageTrees) *
 		cacheContentPlain:      dynacache.GetOrCreatePartition[string, *resources.StaleValue[contentPlainPlainWords]](mcache, fmt.Sprintf("/cont/pla/%d", i), dynacache.OptionsPartition{Weight: 70, ClearWhen: dynacache.ClearOnChange}),
 		contentTableOfContents: dynacache.GetOrCreatePartition[string, *resources.StaleValue[contentTableOfContents]](mcache, fmt.Sprintf("/cont/toc/%d", i), dynacache.OptionsPartition{Weight: 70, ClearWhen: dynacache.ClearOnChange}),

+		contentDataFileSeenItems: maps.NewCache[string, map[uint64]bool](),
+
 		cfg: contentMapConfig{
 			lang:                 s.Lang(),
 			taxonomyConfig:       taxonomiesConfig.Values(),
@@ -900,8 +932,8 @@ func newPageMap(i int, s *Site, mcache *dynacache.Cache, pageTrees *pageTrees) *
 				LockType: doctree.LockTypeRead,
 				Handle: func(s string, n contentNodeI, match doctree.DimensionFlag) (bool, error) {
 					p := n.(*pageState)
-					if p.File() != nil {
-						add(p.File().FileInfo().Meta().PathInfo.BaseNameNoIdentifier(), p)
+					if p.PathInfo() != nil {
+						add(p.PathInfo().BaseNameNoIdentifier(), p)
 					}
 					return false, nil
 				},
@@ -943,9 +975,7 @@ type contentTreeReverseIndexMap struct {

 type sitePagesAssembler struct {
 	*Site
-	watching        bool
-	incomingChanges *whatChanged
-	assembleChanges *whatChanged
+	assembleChanges *WhatChanged
 	ctx             context.Context
 }

@@ -1049,7 +1079,7 @@ func (h *HugoSites) resolveAndClearStateForIdentities(
 	)

 	for _, id := range changes {
-		if staler, ok := id.(resource.Staler); ok && !staler.IsStale() {
+		if staler, ok := id.(resource.Staler); ok {
 			var msgDetail string
 			if p, ok := id.(*pageState); ok && p.File() != nil {
 				msgDetail = fmt.Sprintf(" (%s)", p.File().Filename())
@@ -1063,6 +1093,7 @@ func (h *HugoSites) resolveAndClearStateForIdentities(
 	// 1. Handle the cache busters first, as those may produce identities for the page reset step.
 	// 2. Then reset the page outputs, which may mark some resources as stale.
 	// 3. Then GC the cache.
+	// TOOD1
 	if cachebuster != nil {
 		if err := loggers.TimeTrackfn(func() (logg.LevelLogger, error) {
 			ll := l.WithField("substep", "gc dynacache cachebuster")
@@ -1079,7 +1110,7 @@ func (h *HugoSites) resolveAndClearStateForIdentities(
 				return b
 			}

-			h.MemCache.ClearMatching(shouldDelete)
+			h.MemCache.ClearMatching(nil, shouldDelete)

 			return ll, nil
 		}); err != nil {
@@ -1087,7 +1118,7 @@ func (h *HugoSites) resolveAndClearStateForIdentities(
 		}
 	}

-	// Drain the the cache eviction stack.
+	// Drain the cache eviction stack.
 	evicted := h.Deps.MemCache.DrainEvictedIdentities()
 	if len(evicted) < 200 {
 		changes = append(changes, evicted...)
@@ -1108,6 +1139,33 @@ func (h *HugoSites) resolveAndClearStateForIdentities(
 	}
 	changes = changes[:n]

+	if h.pageTrees.treePagesFromTemplateAdapters.LenRaw() > 0 {
+		if err := loggers.TimeTrackfn(func() (logg.LevelLogger, error) {
+			ll := l.WithField("substep", "resolve content adapter change set").WithField("changes", len(changes))
+			checkedCount := 0
+			matchCount := 0
+			depsFinder := identity.NewFinder(identity.FinderConfig{})
+
+			h.pageTrees.treePagesFromTemplateAdapters.WalkPrefixRaw(doctree.LockTypeRead, "",
+				func(s string, n *pagesfromdata.PagesFromTemplate) (bool, error) {
+					for _, id := range changes {
+						checkedCount++
+						if r := depsFinder.Contains(id, n.DependencyManager, 2); r > identity.FinderNotFound {
+							n.MarkStale()
+							matchCount++
+							break
+						}
+					}
+					return false, nil
+				})
+
+			ll = ll.WithField("checked", checkedCount).WithField("matches", matchCount)
+			return ll, nil
+		}); err != nil {
+			return err
+		}
+	}
+
 	if err := loggers.TimeTrackfn(func() (logg.LevelLogger, error) {
 		// changesLeft: The IDs that the pages is dependent on.
 		// changesRight: The IDs that the pages depend on.
@@ -1252,6 +1310,7 @@ func (sa *sitePagesAssembler) applyAggregates() error {
 	rw := pw.Extend()
 	rw.Tree = sa.pageMap.treeResources
 	sa.lastmod = time.Time{}
+	rebuild := sa.s.h.isRebuild()

 	pw.Handle = func(keyPage string, n contentNodeI, match doctree.DimensionFlag) (bool, error) {
 		pageBundle := n.(*pageState)
@@ -1272,7 +1331,7 @@ func (sa *sitePagesAssembler) applyAggregates() error {
 			// Home page gets it's cascade from the site config.
 			cascade = sa.conf.Cascade.Config

-			if pageBundle.m.pageConfig.Cascade == nil {
+			if pageBundle.m.pageConfig.CascadeCompiled == nil {
 				// Pass the site cascade downwards.
 				pw.WalkContext.Data().Insert(keyPage, cascade)
 			}
@@ -1283,18 +1342,20 @@ func (sa *sitePagesAssembler) applyAggregates() error {
 			}
 		}

-		if (pageBundle.IsHome() || pageBundle.IsSection()) && pageBundle.m.setMetaPostCount > 0 {
-			oldDates := pageBundle.m.pageConfig.Dates
+		if rebuild {
+			if (pageBundle.IsHome() || pageBundle.IsSection()) && pageBundle.m.setMetaPostCount > 0 {
+				oldDates := pageBundle.m.pageConfig.Dates

-			// We need to wait until after the walk to determine if any of the dates have changed.
-			pw.WalkContext.AddPostHook(
-				func() error {
-					if oldDates != pageBundle.m.pageConfig.Dates {
-						sa.assembleChanges.Add(pageBundle)
-					}
-					return nil
-				},
-			)
+				// We need to wait until after the walk to determine if any of the dates have changed.
+				pw.WalkContext.AddPostHook(
+					func() error {
+						if oldDates != pageBundle.m.pageConfig.Dates {
+							sa.assembleChanges.Add(pageBundle)
+						}
+						return nil
+					},
+				)
+			}
 		}

 		// Combine the cascade map with front matter.
@@ -1304,15 +1365,15 @@ func (sa *sitePagesAssembler) applyAggregates() error {

 		// We receive cascade values from above. If this leads to a change compared
 		// to the previous value, we need to mark the page and its dependencies as changed.
-		if pageBundle.m.setMetaPostCascadeChanged {
+		if rebuild && pageBundle.m.setMetaPostCascadeChanged {
 			sa.assembleChanges.Add(pageBundle)
 		}

 		const eventName = "dates"
 		if n.isContentNodeBranch() {
-			if pageBundle.m.pageConfig.Cascade != nil {
+			if pageBundle.m.pageConfig.CascadeCompiled != nil {
 				// Pass it down.
-				pw.WalkContext.Data().Insert(keyPage, pageBundle.m.pageConfig.Cascade)
+				pw.WalkContext.Data().Insert(keyPage, pageBundle.m.pageConfig.CascadeCompiled)
 			}

 			wasZeroDates := pageBundle.m.pageConfig.Dates.IsAllDatesZero()
@@ -1413,9 +1474,9 @@ func (sa *sitePagesAssembler) applyAggregatesToTaxonomiesAndTerms() error {
 				p := n.(*pageState)
 				if p.Kind() != kinds.KindTerm {
 					// The other kinds were handled in applyAggregates.
-					if p.m.pageConfig.Cascade != nil {
+					if p.m.pageConfig.CascadeCompiled != nil {
 						// Pass it down.
-						pw.WalkContext.Data().Insert(s, p.m.pageConfig.Cascade)
+						pw.WalkContext.Data().Insert(s, p.m.pageConfig.CascadeCompiled)
 					}
 				}

@@ -1536,7 +1597,7 @@ func (sa *sitePagesAssembler) assembleTermsAndTranslations() error {
 							singular: viewName.singular,
 							s:        sa.Site,
 							pathInfo: pi,
-							pageMetaParams: pageMetaParams{
+							pageMetaParams: &pageMetaParams{
 								pageConfig: &pagemeta.PageConfig{
 									Kind: kinds.KindTerm,
 								},
@@ -1598,13 +1659,13 @@ func (sa *sitePagesAssembler) assembleResources() error {
 			targetPaths := ps.targetPaths()
 			baseTarget := targetPaths.SubResourceBaseTarget
 			duplicateResourceFiles := true
-			if ps.s.ContentSpec.Converters.IsGoldmark(ps.m.pageConfig.Markup) {
+			if ps.m.pageConfig.ContentMediaType.IsMarkdown() {
 				duplicateResourceFiles = ps.s.ContentSpec.Converters.GetMarkupConfig().Goldmark.DuplicateResourceFiles
 			}

 			duplicateResourceFiles = duplicateResourceFiles || ps.s.Conf.IsMultihost()

-			sa.pageMap.forEachResourceInPage(
+			err := sa.pageMap.forEachResourceInPage(
 				ps, lockType,
 				!duplicateResourceFiles,
 				func(resourceKey string, n contentNodeI, match doctree.DimensionFlag) (bool, error) {
@@ -1630,6 +1691,23 @@ func (sa *sitePagesAssembler) assembleResources() error {

 					}

+					if rs.rc != nil && rs.rc.Content.IsResourceValue() {
+						if rs.rc.Name == "" {
+							rs.rc.Name = relPathOriginal
+						}
+						r, err := ps.m.s.ResourceSpec.NewResourceWrapperFromResourceConfig(rs.rc)
+						if err != nil {
+							return false, err
+						}
+						rs.r = r
+						return false, nil
+					}
+
+					var mt media.Type
+					if rs.rc != nil {
+						mt = rs.rc.ContentMediaType
+					}
+
 					rd := resources.ResourceSourceDescriptor{
 						OpenReadSeekCloser:   rs.opener,
 						Path:                 rs.path,
@@ -1640,8 +1718,23 @@ func (sa *sitePagesAssembler) assembleResources() error {
 						BasePathTargetPath:   baseTarget,
 						NameNormalized:       relPath,
 						NameOriginal:         relPathOriginal,
+						MediaType:            mt,
 						LazyPublish:          !ps.m.pageConfig.Build.PublishResources,
 					}
+
+					if rs.rc != nil {
+						rc := rs.rc
+						rd.OpenReadSeekCloser = rc.Content.ValueAsOpenReadSeekCloser()
+						if rc.Name != "" {
+							rd.NameNormalized = rc.Name
+							rd.NameOriginal = rc.Name
+						}
+						if rc.Title != "" {
+							rd.Title = rc.Title
+						}
+						rd.Params = rc.Params
+					}
+
 					r, err := ps.m.s.ResourceSpec.NewResource(rd)
 					if err != nil {
 						return false, err
@@ -1651,7 +1744,7 @@ func (sa *sitePagesAssembler) assembleResources() error {
 				},
 			)

-			return false, nil
+			return false, err
 		},
 	}

@@ -1758,7 +1851,7 @@ func (sa *sitePagesAssembler) addStandalonePages() error {
 		m := &pageMeta{
 			s:        s,
 			pathInfo: s.Conf.PathParser().Parse(files.ComponentFolderContent, key+f.MediaType.FirstSuffix.FullSuffix),
-			pageMetaParams: pageMetaParams{
+			pageMetaParams: &pageMetaParams{
 				pageConfig: &pagemeta.PageConfig{
 					Kind: kind,
 				},
@@ -1788,11 +1881,19 @@ func (sa *sitePagesAssembler) addStandalonePages() error {
 	}

 	if sitemapEnabled {
-		addStandalone("/_sitemap", kinds.KindSitemap, output.SitemapFormat)
-		skipSitemapIndex := s.Conf.IsMultihost() || !(s.Conf.DefaultContentLanguageInSubdir() || s.Conf.IsMultilingual())
+		of := output.SitemapFormat
+		if s.conf.Sitemap.Filename != "" {
+			of.BaseName = paths.Filename(s.conf.Sitemap.Filename)
+		}
+		addStandalone("/_sitemap", kinds.KindSitemap, of)

+		skipSitemapIndex := s.Conf.IsMultihost() || !(s.Conf.DefaultContentLanguageInSubdir() || s.Conf.IsMultilingual())
 		if !skipSitemapIndex {
-			addStandalone("/_sitemapindex", kinds.KindSitemapIndex, output.SitemapIndexFormat)
+			of = output.SitemapIndexFormat
+			if s.conf.Sitemap.Filename != "" {
+				of.BaseName = paths.Filename(s.conf.Sitemap.Filename)
+			}
+			addStandalone("/_sitemapindex", kinds.KindSitemapIndex, of)
 		}
 	}

@@ -1876,7 +1977,7 @@ func (sa *sitePagesAssembler) addMissingRootSections() error {
 		m := &pageMeta{
 			s:        sa.Site,
 			pathInfo: p,
-			pageMetaParams: pageMetaParams{
+			pageMetaParams: &pageMetaParams{
 				pageConfig: &pagemeta.PageConfig{
 					Kind: kinds.KindHome,
 				},
@@ -1886,7 +1987,7 @@ func (sa *sitePagesAssembler) addMissingRootSections() error {
 		if err != nil {
 			return err
 		}
-		w.Tree.InsertWithLock(p.Base(), n)
+		w.Tree.InsertIntoValuesDimensionWithLock(p.Base(), n)
 		sa.home = n
 	}

@@ -1909,7 +2010,7 @@ func (sa *sitePagesAssembler) addMissingTaxonomies() error {
 			m := &pageMeta{
 				s:        sa.Site,
 				pathInfo: sa.Conf.PathParser().Parse(files.ComponentFolderContent, key+"/_index.md"),
-				pageMetaParams: pageMetaParams{
+				pageMetaParams: &pageMetaParams{
 					pageConfig: &pagemeta.PageConfig{
 						Kind: kinds.KindTaxonomy,
 					},
@@ -16,6 +16,7 @@ package hugolib
 import (
 	"fmt"
 	"path/filepath"
+	"strings"
 	"testing"

 	qt "github.com/frankban/quicktest"
@@ -27,7 +28,7 @@ func TestContentMapSite(t *testing.T) {
 	pageTempl := `
 ---
 title: "Page %d"
-date: "2019-06-0%d"	
+date: "2019-06-0%d"
 lastMod: "2019-06-0%d"
 categories: [%q]
 ---
@@ -54,7 +55,7 @@ draft: true
 title: "Hugo Home"
 cascade:
    description: "Common Description"
-    
+
 ---

 Home Content.
@@ -110,7 +111,7 @@ IsDescendant overlap2: false: {{ $overlap2.IsDescendant $overlap1 }}
 IsAncestor overlap1: false: {{ $overlap1.IsAncestor $overlap2 }}
 IsAncestor overlap2: false: {{ $overlap2.IsAncestor $overlap1 }}
 FirstSection: {{ $blogSub.FirstSection.RelPermalink }} {{ $blog.FirstSection.RelPermalink }} {{ $home.FirstSection.RelPermalink }} {{ $page.FirstSection.RelPermalink }}
-InSection: true: {{ $page.InSection $blog }} false: {{ $page.InSection $blogSub }} 
+InSection: true: {{ $page.InSection $blog }} false: {{ $page.InSection $blogSub }}
 Next: {{ $page2.Next.RelPermalink }}
 NextInSection: {{ $page2.NextInSection.RelPermalink }}
 Pages: {{ range $blog.Pages }}{{ .RelPermalink }}|{{ end }}
@@ -140,11 +141,11 @@ Draft5: {{ if (.Site.GetPage "blog/draftsection/sub/page") }}FOUND{{ end }}|
 	 Num Regular: 9
        Main Sections: [blog]
        Pag Num Pages: 9
-        
-      Home: Hugo Home|/|2019-06-08|Current Section: /|Resources: 
-        Blog Section: Blogs|/blog/|2019-06-08|Current Section: /blog|Resources: 
+
+      Home: Hugo Home|/|2019-06-08|Current Section: /|Resources:
+        Blog Section: Blogs|/blog/|2019-06-08|Current Section: /blog|Resources:
        Blog Sub Section: Page 3|/blog/subsection/|2019-06-03|Current Section: /blog/subsection|Resources: application: /blog/subsection/subdata.json|
-        Page: Page 1|/blog/page1/|2019-06-01|Current Section: /blog|Resources: 
+        Page: Page 1|/blog/page1/|2019-06-01|Current Section: /blog|Resources:
        Bundle: Page 12|/blog/bundle/|0001-01-01|Current Section: /blog|Resources: application: /blog/bundle/data.json|page: |
        IsDescendant: true: true true: true true: true true: true true: true false: false false: false
        IsAncestor: true: true true: true true: true true: true true: true true: true false: false false: false false: false  false: false
@@ -153,7 +154,7 @@ Draft5: {{ if (.Site.GetPage "blog/draftsection/sub/page") }}FOUND{{ end }}|
        IsAncestor overlap1: false: false
        IsAncestor overlap2: false: false
        FirstSection: /blog/ /blog/ / /blog/
-        InSection: true: true false: false 
+        InSection: true: true false: false
        Next: /blog/page3/
        NextInSection: /blog/page3/
        Pages: /blog/page3/|/blog/subsection/|/blog/page2/|/blog/page1/|/blog/bundle/|
@@ -165,13 +166,13 @@ Draft5: {{ if (.Site.GetPage "blog/draftsection/sub/page") }}FOUND{{ end }}|
        Pag Blog Num Pages: 4
        Blog Num RegularPages: 4
        Blog Num Pages: 5
-        
+
        Draft1: |
        Draft2: FOUND|
        Draft3: FOUND|
        Draft4: FOUND|
        Draft5: FOUND|
-           
+
 `)
 }

@@ -185,7 +186,7 @@ title = "Integration Test"
 disableKinds=["page", "section", "taxonomy", "term", "sitemap", "robotsTXT", "RSS"]
 -- layouts/index.html --
 Home: {{ .Title }}|
-		
+
 	`

 	b := NewIntegrationTestBuilder(
@@ -358,3 +359,41 @@ p1-foo.txt
 	b.AssertFileExists("public/s1/p1-foo.txt", true) // failing test
 	b.AssertFileExists("public/s1/p1/index.html", true)
 }
+
+func TestSitemapOverrideFilename(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = 'https://example.org/'
+disableKinds = ['page','rss','section','taxonomy','term']
+defaultContentLanguage = 'de'
+defaultContentLanguageInSubdir = true
+[languages.de]
+[languages.en]
+[sitemap]
+filename = 'foo.xml'
+-- layouts/index.html --
+irrelevant
+`
+
+	b := Test(t, files)
+
+	b.AssertFileExists("public/de/foo.xml", true)
+	b.AssertFileExists("public/en/foo.xml", true)
+	b.AssertFileContent("public/foo.xml",
+		"<loc>https://example.org/de/foo.xml</loc>",
+		"<loc>https://example.org/en/foo.xml</loc>",
+	)
+
+	files = strings.ReplaceAll(files, "filename = 'foo.xml'", "")
+
+	b = Test(t, files)
+
+	b.AssertFileExists("public/de/sitemap.xml", true)
+	b.AssertFileExists("public/en/sitemap.xml", true)
+	b.AssertFileContent("public/sitemap.xml",
+		"<loc>https://example.org/de/sitemap.xml</loc>",
+		"<loc>https://example.org/en/sitemap.xml</loc>",
+	)
+}
@@ -14,6 +14,7 @@
 package hugolib

 import (
+	"fmt"
 	"strings"
 	"testing"
 )
@@ -241,3 +242,52 @@ iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAA
 			"p1|<p><a href=\"p2\">P2</a>", "<img src=\"pixel.png\" alt=\"Pixel\">")
 	})
 }
+
+func TestRenderHooksDefaultEscape(t *testing.T) {
+	files := `
+-- hugo.toml --
+[markup.goldmark.renderHooks]
+[markup.goldmark.renderHooks.image]
+  enableDefault = ENABLE
+[markup.goldmark.renderHooks.link]
+enableDefault = ENABLE
+[markup.goldmark.parser]
+wrapStandAloneImageWithinParagraph = false
+[markup.goldmark.parser.attribute]
+block = true
+title = true
+-- content/_index.md --
+---
+title: "Home"
+---
+Link: [text-"<>&](/destination-"<> 'title-"<>&')
+
+Image: ![alt-"<>&](/destination-"<> 'title-"<>&')
+{class="><script>alert()</script>" id="baz"}
+
+-- layouts/index.html --
+{{ .Content }}
+`
+
+	for _, enabled := range []bool{true, false} {
+		enabled := enabled
+		t.Run(fmt.Sprint(enabled), func(t *testing.T) {
+			t.Parallel()
+			b := Test(t, strings.ReplaceAll(files, "ENABLE", fmt.Sprint(enabled)))
+
+			// The escaping is slightly different between the two.
+			if enabled {
+				b.AssertFileContent("public/index.html",
+					"Link: <a href=\"/destination-%22%3C%3E\" title=\"title-&#34;&lt;&gt;&amp;\">text-&quot;&lt;&gt;&amp;</a>",
+					"img alt=\"alt-&quot;&lt;&gt;&amp;\" src=\"/destination-%22%3C%3E\" title=\"title-&#34;&lt;&gt;&amp;\">",
+					"&gt;&lt;script&gt;",
+				)
+			} else {
+				b.AssertFileContent("public/index.html",
+					"Link: <a href=\"/destination-%22%3C%3E\" title=\"title-&quot;&lt;&gt;&amp;\">text-&quot;&lt;&gt;&amp;</a>",
+					"Image: <img src=\"/destination-%22%3C%3E\" alt=\"alt-&quot;&lt;&gt;&amp;\" title=\"title-&quot;&lt;&gt;&amp;\">",
+				)
+			}
+		})
+	}
+}
@@ -173,7 +173,7 @@ func TestTreeInsert(t *testing.T) {
 	c.Assert(tree.Get("/notfound"), qt.IsNil)

 	ab2 := &testValue{ID: "/a/b", Lang: 0}
-	v, ok := tree.InsertIntoValuesDimension("/a/b", ab2)
+	v, _, ok := tree.InsertIntoValuesDimension("/a/b", ab2)
 	c.Assert(ok, qt.IsTrue)
 	c.Assert(v, qt.DeepEquals, ab2)

@@ -239,16 +239,16 @@ func (s *testShifter) ForEeachInDimension(n *testValue, d int, f func(n *testVal
 	f(n)
 }

-func (s *testShifter) Insert(old, new *testValue) *testValue {
-	return new
+func (s *testShifter) Insert(old, new *testValue) (*testValue, *testValue, bool) {
+	return new, old, true
 }

-func (s *testShifter) InsertInto(old, new *testValue, dimension doctree.Dimension) *testValue {
-	return new
+func (s *testShifter) InsertInto(old, new *testValue, dimension doctree.Dimension) (*testValue, *testValue, bool) {
+	return new, old, true
 }

-func (s *testShifter) Delete(n *testValue, dimension doctree.Dimension) (bool, bool) {
-	return true, true
+func (s *testShifter) Delete(n *testValue, dimension doctree.Dimension) (*testValue, bool, bool) {
+	return nil, true, true
 }

 func (s *testShifter) Shift(n *testValue, dimension doctree.Dimension, exact bool) (*testValue, bool, doctree.DimensionFlag) {
@@ -38,16 +38,18 @@ type (

 		// Insert inserts new into the tree into the dimension it provides.
 		// It may replace old.
-		// It returns a T (can be the same as old).
-		Insert(old, new T) T
+		// It returns the updated and existing T
+		// and a bool indicating if an existing record is updated.
+		Insert(old, new T) (T, T, bool)

 		// Insert inserts new into the given dimension.
 		// It may replace old.
-		// It returns a T (can be the same as old).
-		InsertInto(old, new T, dimension Dimension) T
+		// It returns the updated and existing T
+		// and a bool indicating if an existing record is updated.
+		InsertInto(old, new T, dimension Dimension) (T, T, bool)

-		// Delete deletes T from the given dimension and returns whether the dimension was deleted and if  it's empty after the delete.
-		Delete(v T, dimension Dimension) (bool, bool)
+		// Delete deletes T from the given dimension and returns the deleted T and whether the dimension was deleted and if  it's empty after the delete.
+		Delete(v T, dimension Dimension) (T, bool, bool)

 		// Shift shifts T into the given dimension
 		// and returns the shifted T and a bool indicating if the shift was successful and
@@ -81,7 +83,11 @@ func New[T any](cfg Config[T]) *NodeShiftTree[T] {
 	}
 }

-func (r *NodeShiftTree[T]) Delete(key string) {
+func (r *NodeShiftTree[T]) Delete(key string) (T, bool) {
+	return r.delete(key)
+}
+
+func (r *NodeShiftTree[T]) DeleteRaw(key string) {
 	r.delete(key)
 }

@@ -103,23 +109,24 @@ func (r *NodeShiftTree[T]) DeletePrefix(prefix string) int {
 		return false
 	})
 	for _, key := range keys {
-		if ok := r.delete(key); ok {
+		if _, ok := r.delete(key); ok {
 			count++
 		}
 	}
 	return count
 }

-func (r *NodeShiftTree[T]) delete(key string) bool {
+func (r *NodeShiftTree[T]) delete(key string) (T, bool) {
 	var wasDeleted bool
+	var deleted T
 	if v, ok := r.tree.Get(key); ok {
 		var isEmpty bool
-		wasDeleted, isEmpty = r.shifter.Delete(v.(T), r.dims)
+		deleted, wasDeleted, isEmpty = r.shifter.Delete(v.(T), r.dims)
 		if isEmpty {
 			r.tree.Delete(key)
 		}
 	}
-	return wasDeleted
+	return deleted, wasDeleted
 }

 func (t *NodeShiftTree[T]) DeletePrefixAll(prefix string) int {
@@ -141,22 +148,33 @@ func (t *NodeShiftTree[T]) Increment(d int) *NodeShiftTree[T] {
 	return t.Shape(d, t.dims[d]+1)
 }

-func (r *NodeShiftTree[T]) InsertIntoCurrentDimension(s string, v T) (T, bool) {
+func (r *NodeShiftTree[T]) InsertIntoCurrentDimension(s string, v T) (T, T, bool) {
 	s = mustValidateKey(cleanKey(s))
+	var (
+		updated  bool
+		existing T
+	)
 	if vv, ok := r.tree.Get(s); ok {
-		v = r.shifter.InsertInto(vv.(T), v, r.dims)
+		v, existing, updated = r.shifter.InsertInto(vv.(T), v, r.dims)
 	}
 	r.tree.Insert(s, v)
-	return v, true
+	return v, existing, updated
 }

-func (r *NodeShiftTree[T]) InsertIntoValuesDimension(s string, v T) (T, bool) {
+// InsertIntoValuesDimension inserts v into the tree at the given key and the
+// dimension defined by the value.
+// It returns the updated and existing T and a bool indicating if an existing record is updated.
+func (r *NodeShiftTree[T]) InsertIntoValuesDimension(s string, v T) (T, T, bool) {
 	s = mustValidateKey(cleanKey(s))
+	var (
+		updated  bool
+		existing T
+	)
 	if vv, ok := r.tree.Get(s); ok {
-		v = r.shifter.Insert(vv.(T), v)
+		v, existing, updated = r.shifter.Insert(vv.(T), v)
 	}
 	r.tree.Insert(s, v)
-	return v, true
+	return v, existing, updated
 }

 func (r *NodeShiftTree[T]) InsertRawWithLock(s string, v any) (any, bool) {
@@ -165,7 +183,8 @@ func (r *NodeShiftTree[T]) InsertRawWithLock(s string, v any) (any, bool) {
 	return r.tree.Insert(s, v)
 }

-func (r *NodeShiftTree[T]) InsertWithLock(s string, v T) (T, bool) {
+// It returns the updated and existing T and a bool indicating if an existing record is updated.
+func (r *NodeShiftTree[T]) InsertIntoValuesDimensionWithLock(s string, v T) (T, T, bool) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	return r.InsertIntoValuesDimension(s, v)
@@ -28,12 +28,12 @@ type Tree[T any] interface {
 }

 // NewSimpleTree creates a new SimpleTree.
-func NewSimpleTree[T any]() *SimpleTree[T] {
+func NewSimpleTree[T comparable]() *SimpleTree[T] {
 	return &SimpleTree[T]{tree: radix.New()}
 }

 // SimpleTree is a thread safe radix tree that holds T.
-type SimpleTree[T any] struct {
+type SimpleTree[T comparable] struct {
 	mu   sync.RWMutex
 	tree *radix.Tree
 	zero T
@@ -67,16 +67,23 @@ func (tree *SimpleTree[T]) Insert(s string, v T) T {
 	return v
 }

-func (tree *SimpleTree[T]) WalkPrefix(lockType LockType, s string, f func(s string, v T) (bool, error)) error {
+func (tree *SimpleTree[T]) Lock(lockType LockType) func() {
 	switch lockType {
 	case LockTypeNone:
+		return func() {}
 	case LockTypeRead:
 		tree.mu.RLock()
-		defer tree.mu.RUnlock()
+		return tree.mu.RUnlock
 	case LockTypeWrite:
 		tree.mu.Lock()
-		defer tree.mu.Unlock()
+		return tree.mu.Unlock
 	}
+	return func() {}
+}
+
+func (tree *SimpleTree[T]) WalkPrefix(lockType LockType, s string, f func(s string, v T) (bool, error)) error {
+	commit := tree.Lock(lockType)
+	defer commit()
 	var err error
 	tree.tree.WalkPrefix(s, func(s string, v any) bool {
 		var b bool
@@ -113,7 +113,7 @@ type LockType int

 // MutableTree is a tree that can be modified.
 type MutableTree interface {
-	Delete(key string)
+	DeleteRaw(key string)
 	DeleteAll(key string)
 	DeletePrefix(prefix string) int
 	DeletePrefixAll(prefix string) int
@@ -140,9 +140,9 @@ var _ MutableTree = MutableTrees(nil)

 type MutableTrees []MutableTree

-func (t MutableTrees) Delete(key string) {
+func (t MutableTrees) DeleteRaw(key string) {
 	for _, tree := range t {
-		tree.Delete(key)
+		tree.DeleteRaw(key)
 	}
 }

@@ -15,18 +15,21 @@ package doctree

 var _ Tree[string] = (*TreeShiftTree[string])(nil)

-type TreeShiftTree[T any] struct {
+type TreeShiftTree[T comparable] struct {
 	// This tree is shiftable in one dimension.
 	d int

 	// The value of the current dimension.
 	v int

+	// The zero value of T.
+	zero T
+
 	// Will be of length equal to the length of the dimension.
 	trees []*SimpleTree[T]
 }

-func NewTreeShiftTree[T any](d, length int) *TreeShiftTree[T] {
+func NewTreeShiftTree[T comparable](d, length int) *TreeShiftTree[T] {
 	if length <= 0 {
 		panic("length must be > 0")
 	}
@@ -52,6 +55,17 @@ func (t *TreeShiftTree[T]) Get(s string) T {
 	return t.trees[t.v].Get(s)
 }

+func (t *TreeShiftTree[T]) DeleteAllFunc(s string, f func(s string, v T) bool) {
+	for _, tt := range t.trees {
+		if v := tt.Get(s); v != t.zero {
+			if f(s, v) {
+				// Delete.
+				tt.tree.Delete(s)
+			}
+		}
+	}
+}
+
 func (t *TreeShiftTree[T]) LongestPrefix(s string) (string, T) {
 	return t.trees[t.v].LongestPrefix(s)
 }
@@ -60,10 +74,31 @@ func (t *TreeShiftTree[T]) Insert(s string, v T) T {
 	return t.trees[t.v].Insert(s, v)
 }

+func (t *TreeShiftTree[T]) Lock(lockType LockType) func() {
+	return t.trees[t.v].Lock(lockType)
+}
+
 func (t *TreeShiftTree[T]) WalkPrefix(lockType LockType, s string, f func(s string, v T) (bool, error)) error {
 	return t.trees[t.v].WalkPrefix(lockType, s, f)
 }

+func (t *TreeShiftTree[T]) WalkPrefixRaw(lockType LockType, s string, f func(s string, v T) (bool, error)) error {
+	for _, tt := range t.trees {
+		if err := tt.WalkPrefix(lockType, s, f); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *TreeShiftTree[T]) LenRaw() int {
+	var count int
+	for _, tt := range t.trees {
+		count += tt.tree.Len()
+	}
+	return count
+}
+
 func (t *TreeShiftTree[T]) Delete(key string) {
 	for _, tt := range t.trees {
 		tt.tree.Delete(key)
@@ -77,25 +112,3 @@ func (t *TreeShiftTree[T]) DeletePrefix(prefix string) int {
 	}
 	return count
 }
-
-func (t *TreeShiftTree[T]) Lock(writable bool) (commit func()) {
-	if writable {
-		for _, tt := range t.trees {
-			tt.mu.Lock()
-		}
-		return func() {
-			for _, tt := range t.trees {
-				tt.mu.Unlock()
-			}
-		}
-	}
-
-	for _, tt := range t.trees {
-		tt.mu.RLock()
-	}
-	return func() {
-		for _, tt := range t.trees {
-			tt.mu.RUnlock()
-		}
-	}
-}
@@ -67,7 +67,7 @@ package main

 ## YouTube

-{{< youtube PArFPgHrNZM >}}
+{{< youtube 0RKpf3rK57I >}}

 ## Param

@@ -83,7 +83,7 @@ Content: {{ .Content }}|
 https://gist.github.com/spf13/7896402.js
 <span style="color:#a6e22e">main</span></span>
 https://t.co/X94FmYDEZJ
-https://www.youtube.com/embed/PArFPgHrNZM
+https://www.youtube.com/embed/0RKpf3rK57I
 Foo: bar


@@ -15,8 +15,6 @@ package hugolib

 import (
 	"testing"
-
-	qt "github.com/frankban/quicktest"
 )

 func TestInternalTemplatesImage(t *testing.T) {
@@ -62,78 +60,41 @@ title: My Site
 	b.Build(BuildCfg{})

 	b.AssertFileContent("public/mybundle/index.html", `
-<meta name="twitter:image" content="https://example.org/mybundle/featured-sunset.jpg" />
-<meta name="twitter:title" content="My Bundle"/>
-<meta property="og:title" content="My Bundle" />
-<meta property="og:url" content="https://example.org/mybundle/" />
-<meta property="og:image" content="https://example.org/mybundle/featured-sunset.jpg" />
-<meta property="article:published_time" content="2021-02-26T18:02:00-01:00" />
-<meta property="article:modified_time" content="2021-05-22T19:25:00-01:00" />
+<meta name="twitter:image" content="https://example.org/mybundle/featured-sunset.jpg">
+<meta name="twitter:title" content="My Bundle">
+<meta property="og:title" content="My Bundle">
+<meta property="og:url" content="https://example.org/mybundle/">
+<meta property="og:image" content="https://example.org/mybundle/featured-sunset.jpg">
+<meta property="article:published_time" content="2021-02-26T18:02:00-01:00">
+<meta property="article:modified_time" content="2021-05-22T19:25:00-01:00">
 <meta itemprop="name" content="My Bundle">
-<meta itemprop="image" content="https://example.org/mybundle/featured-sunset.jpg" />
-<meta itemprop="datePublished" content="2021-02-26T18:02:00-01:00" />
-<meta itemprop="dateModified" content="2021-05-22T19:25:00-01:00" />
+<meta itemprop="image" content="https://example.org/mybundle/featured-sunset.jpg">
+<meta itemprop="datePublished" content="2021-02-26T18:02:00-01:00">
+<meta itemprop="dateModified" content="2021-05-22T19:25:00-01:00">

 `)
 	b.AssertFileContent("public/mypage/index.html", `
-<meta name="twitter:image" content="https://example.org/pageimg1.jpg" />
-<meta property="og:image" content="https://example.org/pageimg1.jpg" />
-<meta property="og:image" content="https://example.org/pageimg2.jpg" />
-<meta property="og:image" content="https://example.local/logo.png" />
-<meta property="og:image" content="https://example.org/mypage/sample.jpg" />
-<meta property="article:published_time" content="2021-02-26T18:02:00+01:00" />
-<meta property="article:modified_time" content="2021-05-22T19:25:00+01:00" />
-<meta itemprop="image" content="https://example.org/pageimg1.jpg" />
-<meta itemprop="image" content="https://example.org/pageimg2.jpg" />
-<meta itemprop="image" content="https://example.local/logo.png" />
-<meta itemprop="image" content="https://example.org/mypage/sample.jpg" />
-<meta itemprop="datePublished" content="2021-02-26T18:02:00+01:00" />
-<meta itemprop="dateModified" content="2021-05-22T19:25:00+01:00" />
+<meta name="twitter:image" content="https://example.org/pageimg1.jpg">
+<meta property="og:image" content="https://example.org/pageimg1.jpg">
+<meta property="og:image" content="https://example.org/pageimg2.jpg">
+<meta property="og:image" content="https://example.local/logo.png">
+<meta property="og:image" content="https://example.org/mypage/sample.jpg">
+<meta property="article:published_time" content="2021-02-26T18:02:00+01:00">
+<meta property="article:modified_time" content="2021-05-22T19:25:00+01:00">
+<meta itemprop="image" content="https://example.org/pageimg1.jpg">
+<meta itemprop="image" content="https://example.org/pageimg2.jpg">
+<meta itemprop="image" content="https://example.local/logo.png">
+<meta itemprop="image" content="https://example.org/mypage/sample.jpg">
+<meta itemprop="datePublished" content="2021-02-26T18:02:00+01:00">
+<meta itemprop="dateModified" content="2021-05-22T19:25:00+01:00">
 `)
 	b.AssertFileContent("public/mysite/index.html", `
-<meta name="twitter:image" content="https://example.org/siteimg1.jpg" />
-<meta property="og:image" content="https://example.org/siteimg1.jpg" />
-<meta itemprop="image" content="https://example.org/siteimg1.jpg" />
+<meta name="twitter:image" content="https://example.org/siteimg1.jpg">
+<meta property="og:image" content="https://example.org/siteimg1.jpg">
+<meta itemprop="image" content="https://example.org/siteimg1.jpg">
 `)
 }

-// Just some simple test of the embedded templates to avoid
-// https://github.com/gohugoio/hugo/issues/4757 and similar.
-func TestEmbeddedTemplates(t *testing.T) {
-	t.Parallel()
-
-	c := qt.New(t)
-	c.Assert(true, qt.Equals, true)
-
-	home := []string{"index.html", `
-GA:
-{{ template "_internal/google_analytics.html" . }}
-
-GA async:
-
-{{ template "_internal/google_analytics_async.html" . }}
-
-Disqus:
-
-{{ template "_internal/disqus.html" . }}
-
-`}
-
-	b := newTestSitesBuilder(t)
-	b.WithSimpleConfigFile().WithTemplatesAdded(home...)
-
-	b.Build(BuildCfg{})
-
-	// Gheck GA regular and async
-	b.AssertFileContent("public/index.html",
-		"'anonymizeIp', true",
-		"'script','https://www.google-analytics.com/analytics.js','ga');\n\tga('create', 'UA-ga_id', 'auto')",
-		"<script async src='https://www.google-analytics.com/analytics.js'>")
-
-	// Disqus
-	b.AssertFileContent("public/index.html", "\"disqus_shortname\" + '.disqus.com/embed.js';")
-}
-
 func TestEmbeddedPaginationTemplate(t *testing.T) {
 	t.Parallel()

@@ -111,6 +111,24 @@ func (h *HugoSites) ShouldSkipFileChangeEvent(ev fsnotify.Event) bool {
 	return h.skipRebuildForFilenames[ev.Name]
 }

+func (h *HugoSites) isRebuild() bool {
+	return h.buildCounter.Load() > 0
+}
+
+func (h *HugoSites) resolveSite(lang string) *Site {
+	if lang == "" {
+		lang = h.Conf.DefaultContentLanguage()
+	}
+
+	for _, s := range h.Sites {
+		if s.Lang() == lang {
+			return s
+		}
+	}
+
+	return nil
+}
+
 // Only used in tests.
 type buildCounters struct {
 	contentRenderCounter atomic.Uint64
@@ -387,8 +405,9 @@ func (h *HugoSites) withPage(fn func(s string, p *pageState) bool) {
 type BuildCfg struct {
 	// Skip rendering. Useful for testing.
 	SkipRender bool
+
 	// Use this to indicate what changed (for rebuilds).
-	whatChanged *whatChanged
+	WhatChanged *WhatChanged

 	// This is a partial re-render of some selected pages.
 	PartialReRender bool
@@ -479,6 +498,7 @@ func (h *HugoSites) loadData() error {
 		hugofs.WalkwayConfig{
 			Fs:         h.PathSpec.BaseFs.Data.Fs,
 			IgnoreFile: h.SourceSpec.IgnoreFile,
+			PathParser: h.Conf.PathParser(),
 			WalkFn: func(path string, fi hugofs.FileMetaInfo) error {
 				if fi.IsDir() {
 					return nil
@@ -26,11 +26,12 @@ import (
 	"time"

 	"github.com/bep/logg"
-	"github.com/gohugoio/hugo/cache/dynacache"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/hugofs"
 	"github.com/gohugoio/hugo/hugofs/files"
 	"github.com/gohugoio/hugo/hugofs/glob"
+	"github.com/gohugoio/hugo/hugolib/doctree"
+	"github.com/gohugoio/hugo/hugolib/pagesfromdata"
 	"github.com/gohugoio/hugo/hugolib/segments"
 	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/output"
@@ -42,6 +43,7 @@ import (
 	"github.com/gohugoio/hugo/common/loggers"
 	"github.com/gohugoio/hugo/common/para"
 	"github.com/gohugoio/hugo/common/paths"
+	"github.com/gohugoio/hugo/common/rungroup"
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/resources/page"
 	"github.com/gohugoio/hugo/resources/page/siteidentities"
@@ -97,6 +99,10 @@ func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error {
 		close(to)
 	}(errCollector, errs)

+	for _, s := range h.Sites {
+		s.state = siteStateInit
+	}
+
 	if h.Metrics != nil {
 		h.Metrics.Reset()
 	}
@@ -108,9 +114,9 @@ func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error {

 	// Need a pointer as this may be modified.
 	conf := &config
-	if conf.whatChanged == nil {
+	if conf.WhatChanged == nil {
 		// Assume everything has changed
-		conf.whatChanged = &whatChanged{contentChanged: true}
+		conf.WhatChanged = &WhatChanged{needsPagesAssembly: true}
 	}

 	var prepareErr error
@@ -122,7 +128,7 @@ func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error {
 					s.Deps.BuildStartListeners.Notify()
 				}

-				if len(events) > 0 {
+				if len(events) > 0 || len(conf.WhatChanged.Changes()) > 0 {
 					// Rebuild
 					if err := h.initRebuild(conf); err != nil {
 						return fmt.Errorf("initRebuild: %w", err)
@@ -154,6 +160,10 @@ func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error {
 		}
 	}

+	for _, s := range h.Sites {
+		s.state = siteStateReady
+	}
+
 	if prepareErr == nil {
 		if err := h.render(infol, conf); err != nil {
 			h.SendError(fmt.Errorf("render: %w", err))
@@ -214,7 +224,7 @@ func (h *HugoSites) initRebuild(config *BuildCfg) error {
 	})

 	for _, s := range h.Sites {
-		s.resetBuildState(config.whatChanged.contentChanged)
+		s.resetBuildState(config.WhatChanged.needsPagesAssembly)
 	}

 	h.reset(config)
@@ -229,11 +239,21 @@ func (h *HugoSites) process(ctx context.Context, l logg.LevelLogger, config *Bui
 	l = l.WithField("step", "process")
 	defer loggers.TimeTrackf(l, time.Now(), nil, "")

-	if len(events) > 0 {
-		// This is a rebuild
-		return h.processPartial(ctx, l, config, init, events)
+	if _, err := h.init.layouts.Do(ctx); err != nil {
+		return err
 	}
-	return h.processFull(ctx, l, *config)
+
+	if len(events) > 0 {
+		// This is a rebuild triggered from file events.
+		return h.processPartialFileEvents(ctx, l, config, init, events)
+	} else if len(config.WhatChanged.Changes()) > 0 {
+		// Rebuild triggered from remote events.
+		if err := init(config); err != nil {
+			return err
+		}
+		return h.processPartialRebuildChanges(ctx, l, config)
+	}
+	return h.processFull(ctx, l, config)
 }

 // assemble creates missing sections, applies aggregate values (e.g. dates, cascading params),
@@ -242,22 +262,24 @@ func (h *HugoSites) assemble(ctx context.Context, l logg.LevelLogger, bcfg *Buil
 	l = l.WithField("step", "assemble")
 	defer loggers.TimeTrackf(l, time.Now(), nil, "")

-	if !bcfg.whatChanged.contentChanged {
+	if !bcfg.WhatChanged.needsPagesAssembly {
+		changes := bcfg.WhatChanged.Drain()
+		if len(changes) > 0 {
+			if err := h.resolveAndClearStateForIdentities(ctx, l, nil, changes); err != nil {
+				return err
+			}
+		}
 		return nil
 	}

 	h.translationKeyPages.Reset()
 	assemblers := make([]*sitePagesAssembler, len(h.Sites))
 	// Changes detected during assembly (e.g. aggregate date changes)
-	assembleChanges := &whatChanged{
-		identitySet: make(map[identity.Identity]bool),
-	}
+
 	for i, s := range h.Sites {
 		assemblers[i] = &sitePagesAssembler{
 			Site:            s,
-			watching:        s.watching(),
-			incomingChanges: bcfg.whatChanged,
-			assembleChanges: assembleChanges,
+			assembleChanges: bcfg.WhatChanged,
 			ctx:             ctx,
 		}
 	}
@@ -273,9 +295,9 @@ func (h *HugoSites) assemble(ctx context.Context, l logg.LevelLogger, bcfg *Buil
 		return err
 	}

-	changes := assembleChanges.Changes()
+	changes := bcfg.WhatChanged.Drain()

-	// Changes from the assemble step (e.g. lastMod, cascase) needs a re-calculation
+	// Changes from the assemble step (e.g. lastMod, cascade) needs a re-calculation
 	// of what needs to be re-built.
 	if len(changes) > 0 {
 		if err := h.resolveAndClearStateForIdentities(ctx, l, nil, changes); err != nil {
@@ -312,10 +334,6 @@ func (h *HugoSites) render(l logg.LevelLogger, config *BuildCfg) error {
 		loggers.TimeTrackf(l, start, h.buildCounters.loggFields(), "")
 	}()

-	if _, err := h.init.layouts.Do(context.Background()); err != nil {
-		return err
-	}
-
 	siteRenderContext := &siteRenderContext{cfg: config, multihost: h.Configs.IsMultihost}

 	i := 0
@@ -596,8 +614,23 @@ type pathChange struct {
 	isDir bool
 }

-// processPartial prepares the Sites' sources for a partial rebuild.
-func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, config *BuildCfg, init func(config *BuildCfg) error, events []fsnotify.Event) error {
+func (p pathChange) isStructuralChange() bool {
+	return p.delete || p.isDir
+}
+
+func (h *HugoSites) processPartialRebuildChanges(ctx context.Context, l logg.LevelLogger, config *BuildCfg) error {
+	if err := h.resolveAndClearStateForIdentities(ctx, l, nil, config.WhatChanged.Drain()); err != nil {
+		return err
+	}
+
+	if err := h.processContentAdaptersOnRebuild(ctx, config); err != nil {
+		return err
+	}
+	return nil
+}
+
+// processPartialFileEvents prepares the Sites' sources for a partial rebuild.
+func (h *HugoSites) processPartialFileEvents(ctx context.Context, l logg.LevelLogger, config *BuildCfg, init func(config *BuildCfg) error, events []fsnotify.Event) error {
 	h.Log.Trace(logg.StringFunc(func() string {
 		var sb strings.Builder
 		sb.WriteString("File events:\n")
@@ -610,16 +643,16 @@ func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, conf

 	// For a list of events for the different OSes, see the test output in https://github.com/bep/fsnotifyeventlister/.
 	events = h.fileEventsFilter(events)
-	events = h.fileEventsTranslate(events)
+	events = h.fileEventsTrim(events)
 	eventInfos := h.fileEventsApplyInfo(events)

 	logger := h.Log

 	var (
-		tmplAdded      bool
-		tmplChanged    bool
-		i18nChanged    bool
-		contentChanged bool
+		tmplAdded          bool
+		tmplChanged        bool
+		i18nChanged        bool
+		needsPagesAssemble bool
 	)

 	changedPaths := struct {
@@ -693,11 +726,33 @@ func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, conf
 		switch pathInfo.Component() {
 		case files.ComponentFolderContent:
 			logger.Println("Source changed", pathInfo.Path())
-			if ids := h.pageTrees.collectAndMarkStaleIdentities(pathInfo); len(ids) > 0 {
-				changes = append(changes, ids...)
+			isContentDataFile := pathInfo.IsContentData()
+			if !isContentDataFile {
+				if ids := h.pageTrees.collectAndMarkStaleIdentities(pathInfo); len(ids) > 0 {
+					changes = append(changes, ids...)
+				}
+			} else {
+				h.pageTrees.treePagesFromTemplateAdapters.DeleteAllFunc(pathInfo.Base(),
+					func(s string, n *pagesfromdata.PagesFromTemplate) bool {
+						changes = append(changes, n.DependencyManager)
+
+						// Try to open the file to see if has been deleted.
+						f, err := n.GoTmplFi.Meta().Open()
+						if err == nil {
+							f.Close()
+						}
+						if err != nil {
+							// Remove all pages and resources below.
+							prefix := pathInfo.Base() + "/"
+							h.pageTrees.treePages.DeletePrefixAll(prefix)
+							h.pageTrees.resourceTrees.DeletePrefixAll(prefix)
+							changes = append(changes, identity.NewGlobIdentity(prefix+"*"))
+						}
+						return err != nil
+					})
 			}

-			contentChanged = true
+			needsPagesAssemble = true

 			if config.RecentlyVisited != nil {
 				// Fast render mode. Adding them to the visited queue
@@ -711,7 +766,7 @@ func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, conf

 			h.pageTrees.treeTaxonomyEntries.DeletePrefix("")

-			if delete {
+			if delete && !isContentDataFile {
 				_, ok := h.pageTrees.treePages.LongestPrefixAll(pathInfo.Base())
 				if ok {
 					h.pageTrees.treePages.DeleteAll(pathInfo.Base())
@@ -759,17 +814,7 @@ func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, conf
 			}
 		case files.ComponentFolderAssets:
 			logger.Println("Asset changed", pathInfo.Path())
-
-			var hasID bool
-			r, _ := h.ResourceSpec.ResourceCache.Get(context.Background(), dynacache.CleanKey(pathInfo.Base()))
-			identity.WalkIdentitiesShallow(r, func(level int, rid identity.Identity) bool {
-				hasID = true
-				changes = append(changes, rid)
-				return false
-			})
-			if !hasID {
-				changes = append(changes, pathInfo)
-			}
+			changes = append(changes, pathInfo)
 		case files.ComponentFolderData:
 			logger.Println("Data changed", pathInfo.Path())

@@ -859,13 +904,13 @@ func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, conf

 	resourceFiles := h.fileEventsContentPaths(addedOrChangedContent)

-	changed := &whatChanged{
-		contentChanged: contentChanged,
-		identitySet:    make(identity.Identities),
+	changed := &WhatChanged{
+		needsPagesAssembly: needsPagesAssemble,
+		identitySet:        make(identity.Identities),
 	}
 	changed.Add(changes...)

-	config.whatChanged = changed
+	config.WhatChanged = changed

 	if err := init(config); err != nil {
 		return err
@@ -883,17 +928,13 @@ func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, conf
 		}
 	}

-	// Removes duplicates.
-	changes = changed.identitySet.AsSlice()
-
-	if err := h.resolveAndClearStateForIdentities(ctx, l, cacheBusterOr, changes); err != nil {
+	if err := h.resolveAndClearStateForIdentities(ctx, l, cacheBusterOr, changed.Drain()); err != nil {
 		return err
 	}

 	if tmplChanged || i18nChanged {
 		// TODO(bep) we should split this, but currently the loading of i18n and layout files are tied together. See #12048.
 		h.init.layouts.Reset()
-
 		if err := loggers.TimeTrackfn(func() (logg.LevelLogger, error) {
 			// TODO(bep) this could probably be optimized to somehow
 			// only load the changed templates and its dependencies, but that is non-trivial.
@@ -914,7 +955,13 @@ func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, conf
 	}

 	if resourceFiles != nil {
-		if err := h.processFiles(ctx, l, *config, resourceFiles...); err != nil {
+		if err := h.processFiles(ctx, l, config, resourceFiles...); err != nil {
+			return err
+		}
+	}
+
+	if h.isRebuild() {
+		if err := h.processContentAdaptersOnRebuild(ctx, config); err != nil {
 			return err
 		}
 	}
@@ -922,7 +969,18 @@ func (h *HugoSites) processPartial(ctx context.Context, l logg.LevelLogger, conf
 	return nil
 }

-func (h *HugoSites) processFull(ctx context.Context, l logg.LevelLogger, config BuildCfg) (err error) {
+func (h *HugoSites) LogServerAddresses() {
+	if h.hugoInfo.IsMultihost() {
+		for _, s := range h.Sites {
+			h.Log.Printf("Web Server is available at %s (bind address %s) %s\n", s.conf.C.BaseURL, s.conf.C.ServerInterface, s.Language().Lang)
+		}
+	} else {
+		s := h.Sites[0]
+		h.Log.Printf("Web Server is available at %s (bind address %s)\n", s.conf.C.BaseURL, s.conf.C.ServerInterface)
+	}
+}
+
+func (h *HugoSites) processFull(ctx context.Context, l logg.LevelLogger, config *BuildCfg) (err error) {
 	if err = h.processFiles(ctx, l, config); err != nil {
 		err = fmt.Errorf("readAndProcessContent: %w", err)
 		return
@@ -930,7 +988,53 @@ func (h *HugoSites) processFull(ctx context.Context, l logg.LevelLogger, config
 	return err
 }

-func (s *HugoSites) processFiles(ctx context.Context, l logg.LevelLogger, buildConfig BuildCfg, filenames ...pathChange) error {
+func (s *Site) handleContentAdapterChanges(bi pagesfromdata.BuildInfo, buildConfig *BuildCfg) {
+	if !s.h.isRebuild() {
+		return
+	}
+
+	if len(bi.ChangedIdentities) > 0 {
+		buildConfig.WhatChanged.Add(bi.ChangedIdentities...)
+		buildConfig.WhatChanged.needsPagesAssembly = true
+	}
+
+	for _, p := range bi.DeletedPaths {
+		pp := path.Join(bi.Path.Base(), p)
+		if v, ok := s.pageMap.treePages.Delete(pp); ok {
+			buildConfig.WhatChanged.Add(v.GetIdentity())
+		}
+	}
+}
+
+func (h *HugoSites) processContentAdaptersOnRebuild(ctx context.Context, buildConfig *BuildCfg) error {
+	// Make sure the layouts are initialized.
+	if _, err := h.init.layouts.Do(context.Background()); err != nil {
+		return err
+	}
+	g := rungroup.Run[*pagesfromdata.PagesFromTemplate](ctx, rungroup.Config[*pagesfromdata.PagesFromTemplate]{
+		NumWorkers: h.numWorkers,
+		Handle: func(ctx context.Context, p *pagesfromdata.PagesFromTemplate) error {
+			bi, err := p.Execute(ctx)
+			if err != nil {
+				return err
+			}
+			s := p.Site.(*Site)
+			s.handleContentAdapterChanges(bi, buildConfig)
+			return nil
+		},
+	})
+
+	h.pageTrees.treePagesFromTemplateAdapters.WalkPrefixRaw(doctree.LockTypeRead, "", func(key string, p *pagesfromdata.PagesFromTemplate) (bool, error) {
+		if p.StaleVersion() > 0 {
+			g.Enqueue(p)
+		}
+		return false, nil
+	})
+
+	return g.Wait()
+}
+
+func (s *HugoSites) processFiles(ctx context.Context, l logg.LevelLogger, buildConfig *BuildCfg, filenames ...pathChange) error {
 	if s.Deps == nil {
 		panic("nil deps on site")
 	}
@@ -940,7 +1044,7 @@ func (s *HugoSites) processFiles(ctx context.Context, l logg.LevelLogger, buildC
 	// For inserts, we can pick an arbitrary pageMap.
 	pageMap := s.Sites[0].pageMap

-	c := newPagesCollector(ctx, s.h, sourceSpec, s.Log, l, pageMap, filenames)
+	c := newPagesCollector(ctx, s.h, sourceSpec, s.Log, l, pageMap, buildConfig, filenames)

 	if err := c.Collect(); err != nil {
 		return err
@@ -252,3 +252,31 @@ Files: {{ range $files }}{{ .Permalink }}|{{ end }}$
 	b.AssertFileContent("public/en/enpages/mybundle-en/file2.txt", "File 2 en.")
 	b.AssertFileContent("public/fr/section/mybundle/file2.txt", "File 2 en.")
 }
+
+func TestMultihostAllButOneLanguageDisabledIssue12288(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+defaultContentLanguage = "en"
+disableLanguages = ["fr"]
+#baseURL = "https://example.com"
+[languages]
+[languages.en]
+baseURL = "https://example.en"
+weight = 1
+[languages.fr]
+baseURL = "https://example.fr"
+weight = 2
+--  assets/css/main.css --
+body { color: red; }
+-- layouts/index.html --
+{{ $css := resources.Get "css/main.css" | minify }}
+CSS: {{ $css.Permalink }}|{{ $css.RelPermalink }}|
+`
+
+	b := Test(t, files)
+
+	b.AssertFileContent("public/css/main.min.css", "body{color:red}")
+	b.AssertFileContent("public/index.html", "CSS: https://example.en/css/main.min.css|/css/main.min.css|")
+}
@@ -41,7 +41,7 @@ Home: {{ .Title }}
 		IntegrationTestConfig{
 			T:           t,
 			TxtarString: files,
-			LogLevel:    logg.LevelTrace,
+			// LogLevel:    logg.LevelTrace,
 		},
 	).Build()

@@ -10,6 +10,7 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"runtime"
 	"sort"
 	"strings"
 	"sync"
@@ -37,12 +38,20 @@ import (

 type TestOpt func(*IntegrationTestConfig)

+// TestOptRunning will enable running in integration tests.
 func TestOptRunning() TestOpt {
 	return func(c *IntegrationTestConfig) {
 		c.Running = true
 	}
 }

+// TestOptWatching will enable watching in integration tests.
+func TestOptWatching() TestOpt {
+	return func(c *IntegrationTestConfig) {
+		c.Watching = true
+	}
+}
+
 // Enable tracing in integration tests.
 // THis should only be used during development and not committed to the repo.
 func TestOptTrace() TestOpt {
@@ -569,6 +578,10 @@ func (s *IntegrationTestBuilder) initBuilder() error {
 				"running": s.Cfg.Running,
 				"watch":   s.Cfg.Running,
 			})
+		} else if s.Cfg.Watching {
+			flags.Set("internal", maps.Params{
+				"watch": s.Cfg.Watching,
+			})
 		}

 		if s.Cfg.WorkingDir != "" {
@@ -685,8 +698,17 @@ func (s *IntegrationTestBuilder) build(cfg BuildCfg) error {
 	return nil
 }

+// We simulate the fsnotify events.
+// See the test output in https://github.com/bep/fsnotifyeventlister for what events gets produced
+// by the different OSes.
 func (s *IntegrationTestBuilder) changeEvents() []fsnotify.Event {
-	var events []fsnotify.Event
+	var (
+		events    []fsnotify.Event
+		isLinux   = runtime.GOOS == "linux"
+		isMacOs   = runtime.GOOS == "darwin"
+		isWindows = runtime.GOOS == "windows"
+	)
+
 	for _, v := range s.removedFiles {
 		events = append(events, fsnotify.Event{
 			Name: v,
@@ -713,12 +735,32 @@ func (s *IntegrationTestBuilder) changeEvents() []fsnotify.Event {
 			Name: v,
 			Op:   fsnotify.Write,
 		})
+		if isLinux || isWindows {
+			// Duplicate write events, for some reason.
+			events = append(events, fsnotify.Event{
+				Name: v,
+				Op:   fsnotify.Write,
+			})
+		}
+		if isMacOs {
+			events = append(events, fsnotify.Event{
+				Name: v,
+				Op:   fsnotify.Chmod,
+			})
+		}
 	}
 	for _, v := range s.createdFiles {
 		events = append(events, fsnotify.Event{
 			Name: v,
 			Op:   fsnotify.Create,
 		})
+		if isLinux || isWindows {
+			events = append(events, fsnotify.Event{
+				Name: v,
+				Op:   fsnotify.Write,
+			})
+		}
+
 	}

 	// Shuffle events.
@@ -787,6 +829,11 @@ type IntegrationTestConfig struct {
 	// Whether to simulate server mode.
 	Running bool

+	// Watch for changes.
+	// This is (currently) always set to true when Running is set.
+	// Note that the CLI for the server does allow for --watch=false, but that is not used in these test.
+	Watching bool
+
 	// Will print the log buffer after the build
 	Verbose bool

@@ -636,3 +636,77 @@ Menu Item: {{ $i }}|{{ .URL }}|
 Menu Item: 0|/foo/posts|
 `)
 }
+
+func TestSectionPagesMenuMultilingualWarningIssue12306(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['section','rss','sitemap','taxonomy','term']
+defaultContentLanguageInSubdir = true
+sectionPagesMenu = "main"
+[languages.en]
+[languages.fr]
+-- layouts/_default/home.html --
+{{- range site.Menus.main -}}
+  <a href="{{ .URL }}">{{ .Name }}</a>
+{{- end -}}
+-- layouts/_default/single.html --
+{{ .Title }}
+-- content/p1.en.md --
+---
+title: p1
+menu: main
+---
+-- content/p1.fr.md --
+---
+title: p1
+menu: main
+---
+-- content/p2.en.md --
+---
+title: p2
+menu: main
+---
+`
+
+	b := Test(t, files, TestOptWarn())
+
+	b.AssertFileContent("public/en/index.html", `<a href="/en/p1/">p1</a><a href="/en/p2/">p2</a>`)
+	b.AssertFileContent("public/fr/index.html", `<a href="/fr/p1/">p1</a>`)
+	b.AssertLogNotContains("WARN")
+}
+
+func TestSectionPagesIssue12399(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['rss','sitemap','taxonomy','term']
+capitalizeListTitles = false
+pluralizeListTitles = false
+sectionPagesMenu = 'main'
+-- content/p1.md --
+---
+title: p1
+---
+-- content/s1/p2.md --
+---
+title: p2
+menus: main
+---
+-- content/s1/p3.md --
+---
+title: p3
+---
+-- layouts/_default/list.html --
+{{ range site.Menus.main }}<a href="{{ .URL }}">{{ .Name }}</a>{{ end }}
+-- layouts/_default/single.html --
+{{ .Title }}
+`
+
+	b := Test(t, files)
+
+	b.AssertFileExists("public/index.html", true)
+	b.AssertFileContent("public/index.html", `<a href="/s1/p2/">p2</a><a href="/s1/">s1</a>`)
+}
@@ -510,9 +510,15 @@ func (p *pageState) renderResources() error {
 				continue
 			}

+			if _, isWrapper := r.(resource.ResourceWrapper); isWrapper {
+				// Skip resources that are wrapped.
+				// These gets published on its own.
+				continue
+			}
+
 			src, ok := r.(resource.Source)
 			if !ok {
-				initErr = fmt.Errorf("resource %T does not support resource.Source", src)
+				initErr = fmt.Errorf("resource %T does not support resource.Source", r)
 				return
 			}

@@ -581,7 +587,11 @@ func (p *pageState) getPageInfoForError() string {
 func (p *pageState) getContentConverter() converter.Converter {
 	var err error
 	p.contentConverterInit.Do(func() {
-		markup := p.m.pageConfig.Markup
+		if p.m.pageConfig.ContentMediaType.IsZero() {
+			panic("ContentMediaType not set")
+		}
+		markup := p.m.pageConfig.ContentMediaType.SubType
+
 		if markup == "html" {
 			// Only used for shortcode inner content.
 			markup = "markdown"
@@ -67,6 +67,7 @@ type pageCommon struct {
 	page.InSectionPositioner
 	page.OutputFormatsProvider
 	page.PageMetaProvider
+	page.PageMetaInternalProvider
 	page.Positioner
 	page.RawContentProvider
 	page.RelatedKeywordsProvider
@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"html/template"
 	"io"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"unicode/utf8"
@@ -54,21 +55,31 @@ type pageContentReplacement struct {
 	source pageparser.Item
 }

-func (m *pageMeta) parseFrontMatter(h *HugoSites, pid uint64, sourceKey string) (*contentParseInfo, error) {
-	var openSource hugio.OpenReadSeekCloser
-	if m.f != nil {
-		meta := m.f.FileInfo().Meta()
-		openSource = func() (hugio.ReadSeekCloser, error) {
-			r, err := meta.Open()
-			if err != nil {
-				return nil, fmt.Errorf("failed to open file %q: %w", meta.Filename, err)
+func (m *pageMeta) parseFrontMatter(h *HugoSites, pid uint64) (*contentParseInfo, error) {
+	var (
+		sourceKey            string
+		openSource           hugio.OpenReadSeekCloser
+		isFromContentAdapter = m.pageConfig.IsFromContentAdapter
+	)
+
+	if m.f != nil && !isFromContentAdapter {
+		sourceKey = filepath.ToSlash(m.f.Filename())
+		if !isFromContentAdapter {
+			meta := m.f.FileInfo().Meta()
+			openSource = func() (hugio.ReadSeekCloser, error) {
+				r, err := meta.Open()
+				if err != nil {
+					return nil, fmt.Errorf("failed to open file %q: %w", meta.Filename, err)
+				}
+				return r, nil
 			}
-			return r, nil
 		}
+	} else if isFromContentAdapter {
+		openSource = m.pageConfig.Content.ValueAsOpenReadSeekCloser()
 	}

 	if sourceKey == "" {
-		sourceKey = strconv.Itoa(int(pid))
+		sourceKey = strconv.FormatUint(pid, 10)
 	}

 	pi := &contentParseInfo{
@@ -85,7 +96,9 @@ func (m *pageMeta) parseFrontMatter(h *HugoSites, pid uint64, sourceKey string)

 	items, err := pageparser.ParseBytes(
 		source,
-		pageparser.Config{},
+		pageparser.Config{
+			NoFrontMatter: isFromContentAdapter,
+		},
 	)
 	if err != nil {
 		return nil, err
@@ -93,6 +106,11 @@ func (m *pageMeta) parseFrontMatter(h *HugoSites, pid uint64, sourceKey string)

 	pi.itemsStep1 = items

+	if isFromContentAdapter {
+		// No front matter.
+		return pi, nil
+	}
+
 	if err := pi.mapFrontMatter(source); err != nil {
 		return nil, err
 	}
@@ -418,6 +436,8 @@ func (c *cachedContent) mustSource() []byte {

 func (c *contentParseInfo) contentSource(s resource.StaleInfo) ([]byte, error) {
 	key := c.sourceKey
+	versionv := s.StaleVersion()
+
 	v, err := c.h.cacheContentSource.GetOrCreate(key, func(string) (*resources.StaleValue[[]byte], error) {
 		b, err := c.readSourceAll()
 		if err != nil {
@@ -426,8 +446,8 @@ func (c *contentParseInfo) contentSource(s resource.StaleInfo) ([]byte, error) {

 		return &resources.StaleValue[[]byte]{
 			Value: b,
-			IsStaleFunc: func() bool {
-				return s.IsStale()
+			StaleVersionFunc: func() uint32 {
+				return s.StaleVersion() - versionv
 			},
 		}, nil
 	})
@@ -487,7 +507,7 @@ type contentPlainPlainWords struct {
 func (c *cachedContent) contentRendered(ctx context.Context, cp *pageContentOutput) (contentSummary, error) {
 	ctx = tpl.Context.DependencyScope.Set(ctx, pageDependencyScopeGlobal)
 	key := c.pi.sourceKey + "/" + cp.po.f.Name
-	versionv := cp.contentRenderedVersion
+	versionv := c.version(cp)

 	v, err := c.pm.cacheContentRendered.GetOrCreate(key, func(string) (*resources.StaleValue[contentSummary], error) {
 		cp.po.p.s.Log.Trace(logg.StringFunc(func() string {
@@ -504,8 +524,8 @@ func (c *cachedContent) contentRendered(ctx context.Context, cp *pageContentOutp
 		}

 		rs := &resources.StaleValue[contentSummary]{
-			IsStaleFunc: func() bool {
-				return c.IsStale() || cp.contentRenderedVersion != versionv
+			StaleVersionFunc: func() uint32 {
+				return c.version(cp) - versionv
 			},
 		}

@@ -522,6 +542,7 @@ func (c *cachedContent) contentRendered(ctx context.Context, cp *pageContentOutp
 			if err != nil {
 				return nil, err
 			}
+
 			if !ok {
 				return nil, errors.New("invalid state: astDoc is set but RenderContent returned false")
 			}
@@ -564,15 +585,14 @@ func (c *cachedContent) contentRendered(ctx context.Context, cp *pageContentOutp
 		var result contentSummary // hasVariants bool

 		if c.pi.hasSummaryDivider {
-			isHTML := cp.po.p.m.pageConfig.Markup == "html"
-			if isHTML {
+			if cp.po.p.m.pageConfig.ContentMediaType.IsHTML() {
 				// Use the summary sections as provided by the user.
 				i := bytes.Index(b, internalSummaryDividerPre)
 				result.summary = helpers.BytesToHTML(b[:i])
 				b = b[i+len(internalSummaryDividerPre):]

 			} else {
-				summary, content, err := splitUserDefinedSummaryAndContent(cp.po.p.m.pageConfig.Markup, b)
+				summary, content, err := splitUserDefinedSummaryAndContent(cp.po.p.m.pageConfig.Content.Markup, b)
 				if err != nil {
 					cp.po.p.s.Log.Errorf("Failed to set user defined summary for page %q: %s", cp.po.p.pathOrTitle(), err)
 				} else {
@@ -606,7 +626,7 @@ var setGetContentCallbackInContext = hcontext.NewContextDispatcher[func(*pageCon

 func (c *cachedContent) contentToC(ctx context.Context, cp *pageContentOutput) (contentTableOfContents, error) {
 	key := c.pi.sourceKey + "/" + cp.po.f.Name
-	versionv := cp.contentRenderedVersion
+	versionv := c.version(cp)

 	v, err := c.pm.contentTableOfContents.GetOrCreate(key, func(string) (*resources.StaleValue[contentTableOfContents], error) {
 		source, err := c.pi.contentSource(c)
@@ -626,8 +646,10 @@ func (c *cachedContent) contentToC(ctx context.Context, cp *pageContentOutput) (
 			return nil, err
 		}

-		// Callback called from above (e.g. in .RenderString)
+		// Callback called from below (e.g. in .RenderString)
 		ctxCallback := func(cp2 *pageContentOutput, ct2 contentTableOfContents) {
+			cp.otherOutputs[cp2.po.p.pid] = cp2
+
 			// Merge content placeholders
 			for k, v := range ct2.contentPlaceholders {
 				ct.contentPlaceholders[k] = v
@@ -660,7 +682,7 @@ func (c *cachedContent) contentToC(ctx context.Context, cp *pageContentOutput) (
 			p.pageOutputTemplateVariationsState.Add(1)
 		}

-		isHTML := cp.po.p.m.pageConfig.Markup == "html"
+		isHTML := cp.po.p.m.pageConfig.ContentMediaType.IsHTML()

 		if !isHTML {
 			createAndSetToC := func(tocProvider converter.TableOfContentsProvider) {
@@ -710,8 +732,8 @@ func (c *cachedContent) contentToC(ctx context.Context, cp *pageContentOutput) (

 		return &resources.StaleValue[contentTableOfContents]{
 			Value: ct,
-			IsStaleFunc: func() bool {
-				return c.IsStale() || cp.contentRenderedVersion != versionv
+			StaleVersionFunc: func() uint32 {
+				return c.version(cp) - versionv
 			},
 		}, nil
 	})
@@ -722,16 +744,21 @@ func (c *cachedContent) contentToC(ctx context.Context, cp *pageContentOutput) (
 	return v.Value, nil
 }

+func (c *cachedContent) version(cp *pageContentOutput) uint32 {
+	// Both of these gets incremented on change.
+	return c.StaleVersion() + cp.contentRenderedVersion
+}
+
 func (c *cachedContent) contentPlain(ctx context.Context, cp *pageContentOutput) (contentPlainPlainWords, error) {
 	key := c.pi.sourceKey + "/" + cp.po.f.Name

-	versionv := cp.contentRenderedVersion
+	versionv := c.version(cp)

 	v, err := c.pm.cacheContentPlain.GetOrCreateWitTimeout(key, cp.po.p.s.Conf.Timeout(), func(string) (*resources.StaleValue[contentPlainPlainWords], error) {
 		var result contentPlainPlainWords
 		rs := &resources.StaleValue[contentPlainPlainWords]{
-			IsStaleFunc: func() bool {
-				return c.IsStale() || cp.contentRenderedVersion != versionv
+			StaleVersionFunc: func() uint32 {
+				return c.version(cp) - versionv
 			},
 		}

@@ -770,7 +797,7 @@ func (c *cachedContent) contentPlain(ctx context.Context, cp *pageContentOutput)
 			result.readingTime = (result.wordCount + 212) / 213
 		}

-		if rendered.summary != "" {
+		if c.pi.hasSummaryDivider || rendered.summary != "" {
 			result.summary = rendered.summary
 			result.summaryTruncated = rendered.summaryTruncated
 		} else if cp.po.p.m.pageConfig.Summary != "" {
@@ -778,7 +805,7 @@ func (c *cachedContent) contentPlain(ctx context.Context, cp *pageContentOutput)
 			if err != nil {
 				return nil, err
 			}
-			html := cp.po.p.s.ContentSpec.TrimShortHTML(b.Bytes())
+			html := cp.po.p.s.ContentSpec.TrimShortHTML(b.Bytes(), cp.po.p.m.pageConfig.Content.Markup)
 			result.summary = helpers.BytesToHTML(html)
 		} else {
 			var summary string
@@ -62,8 +62,22 @@ func (p *pageMenus) init() {
 			p.p,
 		)

+		params := p.p.Params()
+
+		var menus any
+		var ok bool
+
+		if p.p.m.pageConfig.Menus != nil {
+			menus = p.p.m.pageConfig.Menus
+		} else {
+			menus, ok = params["menus"]
+			if !ok {
+				menus = params["menu"]
+			}
+		}
+
 		var err error
-		p.pm, err = navigation.PageMenusFromPage(p.p)
+		p.pm, err = navigation.PageMenusFromPage(menus, p.p)
 		if err != nil {
 			p.p.s.Log.Errorln(p.p.wrapError(err))
 		}
@@ -54,7 +54,7 @@ type pageMeta struct {
 	singular string // Set for kind == KindTerm and kind == KindTaxonomy.

 	resource.Staler
-	pageMetaParams
+	*pageMetaParams
 	pageMetaFrontMatter

 	// Set for standalone pages, e.g. robotsTXT.
@@ -74,7 +74,9 @@ type pageMeta struct {
 // Prepare for a rebuild of the data passed in from front matter.
 func (m *pageMeta) setMetaPostPrepareRebuild() {
 	params := xmaps.Clone[map[string]any](m.paramsOriginal)
-	m.pageMetaParams.pageConfig.Params = params
+	m.pageMetaParams.pageConfig = &pagemeta.PageConfig{
+		Params: params,
+	}
 	m.pageMetaFrontMatter = pageMetaFrontMatter{}
 }

@@ -98,7 +100,7 @@ type pageMetaFrontMatter struct {
 func (m *pageMetaParams) init(preserveOringal bool) {
 	if preserveOringal {
 		m.paramsOriginal = xmaps.Clone[maps.Params](m.pageConfig.Params)
-		m.cascadeOriginal = xmaps.Clone[map[page.PageMatcher]maps.Params](m.pageConfig.Cascade)
+		m.cascadeOriginal = xmaps.Clone[map[page.PageMatcher]maps.Params](m.pageConfig.CascadeCompiled)
 	}
 }

@@ -135,19 +137,19 @@ func (p *pageMeta) BundleType() string {
 }

 func (p *pageMeta) Date() time.Time {
-	return p.pageConfig.Date
+	return p.pageConfig.Dates.Date
 }

 func (p *pageMeta) PublishDate() time.Time {
-	return p.pageConfig.PublishDate
+	return p.pageConfig.Dates.PublishDate
 }

 func (p *pageMeta) Lastmod() time.Time {
-	return p.pageConfig.Lastmod
+	return p.pageConfig.Dates.Lastmod
 }

 func (p *pageMeta) ExpiryDate() time.Time {
-	return p.pageConfig.ExpiryDate
+	return p.pageConfig.Dates.ExpiryDate
 }

 func (p *pageMeta) Description() string {
@@ -275,11 +277,9 @@ func (p *pageMeta) Weight() int {

 func (p *pageMeta) setMetaPre(pi *contentParseInfo, logger loggers.Logger, conf config.AllProvider) error {
 	frontmatter := pi.frontMatter
+
 	if frontmatter != nil {
 		pcfg := p.pageConfig
-		if pcfg == nil {
-			panic("pageConfig not set")
-		}
 		// Needed for case insensitive fetching of params values
 		maps.PrepareParams(frontmatter)
 		pcfg.Params = frontmatter
@@ -290,7 +290,7 @@ func (p *pageMeta) setMetaPre(pi *contentParseInfo, logger loggers.Logger, conf
 			if err != nil {
 				return err
 			}
-			pcfg.Cascade = cascade
+			pcfg.CascadeCompiled = cascade
 		}

 		// Look for path, lang and kind, all of which values we need early on.
@@ -328,18 +328,18 @@ func (ps *pageState) setMetaPost(cascade map[page.PageMatcher]maps.Params) error
 	ps.m.setMetaPostCount++
 	var cascadeHashPre uint64
 	if ps.m.setMetaPostCount > 1 {
-		cascadeHashPre = identity.HashUint64(ps.m.pageConfig.Cascade)
-		ps.m.pageConfig.Cascade = xmaps.Clone[map[page.PageMatcher]maps.Params](ps.m.cascadeOriginal)
+		cascadeHashPre = identity.HashUint64(ps.m.pageConfig.CascadeCompiled)
+		ps.m.pageConfig.CascadeCompiled = xmaps.Clone[map[page.PageMatcher]maps.Params](ps.m.cascadeOriginal)

 	}

 	// Apply cascades first so they can be overridden later.
 	if cascade != nil {
-		if ps.m.pageConfig.Cascade != nil {
+		if ps.m.pageConfig.CascadeCompiled != nil {
 			for k, v := range cascade {
-				vv, found := ps.m.pageConfig.Cascade[k]
+				vv, found := ps.m.pageConfig.CascadeCompiled[k]
 				if !found {
-					ps.m.pageConfig.Cascade[k] = v
+					ps.m.pageConfig.CascadeCompiled[k] = v
 				} else {
 					// Merge
 					for ck, cv := range v {
@@ -349,19 +349,20 @@ func (ps *pageState) setMetaPost(cascade map[page.PageMatcher]maps.Params) error
 					}
 				}
 			}
-			cascade = ps.m.pageConfig.Cascade
+			cascade = ps.m.pageConfig.CascadeCompiled
 		} else {
-			ps.m.pageConfig.Cascade = cascade
+			ps.m.pageConfig.CascadeCompiled = cascade
 		}
 	}

 	if cascade == nil {
-		cascade = ps.m.pageConfig.Cascade
+		cascade = ps.m.pageConfig.CascadeCompiled
 	}

 	if ps.m.setMetaPostCount > 1 {
-		ps.m.setMetaPostCascadeChanged = cascadeHashPre != identity.HashUint64(ps.m.pageConfig.Cascade)
+		ps.m.setMetaPostCascadeChanged = cascadeHashPre != identity.HashUint64(ps.m.pageConfig.CascadeCompiled)
 		if !ps.m.setMetaPostCascadeChanged {
+
 			// No changes, restore any value that may be changed by aggregation.
 			ps.m.pageConfig.Dates = ps.m.datesOriginal
 			return nil
@@ -400,11 +401,17 @@ func (p *pageState) setMetaPostParams() error {
 	pm := p.m
 	var mtime time.Time
 	var contentBaseName string
+	var ext string
+	var isContentAdapter bool
 	if p.File() != nil {
+		isContentAdapter = p.File().IsContentAdapter()
 		contentBaseName = p.File().ContentBaseName()
 		if p.File().FileInfo() != nil {
 			mtime = p.File().FileInfo().ModTime()
 		}
+		if !isContentAdapter {
+			ext = p.File().Ext()
+		}
 	}

 	var gitAuthorDate time.Time
@@ -428,6 +435,11 @@ func (p *pageState) setMetaPostParams() error {
 		p.s.Log.Errorf("Failed to handle dates for page %q: %s", p.pathOrTitle(), err)
 	}

+	if isContentAdapter {
+		// Done.
+		return nil
+	}
+
 	var buildConfig any
 	var isNewBuildKeyword bool
 	if v, ok := pm.pageConfig.Params["_build"]; ok {
@@ -456,8 +468,10 @@ params:
 	var sitemapSet bool

 	pcfg := pm.pageConfig
-
 	params := pcfg.Params
+	if params == nil {
+		panic("params not set for " + p.Title())
+	}

 	var draft, published, isCJKLanguage *bool
 	var userParams map[string]any
@@ -550,8 +564,8 @@ params:
 			pcfg.Layout = cast.ToString(v)
 			params[loki] = pcfg.Layout
 		case "markup":
-			pcfg.Markup = cast.ToString(v)
-			params[loki] = pcfg.Markup
+			pcfg.Content.Markup = cast.ToString(v)
+			params[loki] = pcfg.Content.Markup
 		case "weight":
 			pcfg.Weight = cast.ToInt(v)
 			params[loki] = pcfg.Weight
@@ -601,7 +615,7 @@ params:
 			}

 			if handled {
-				pcfg.Resources = resources
+				pcfg.ResourcesMeta = resources
 				break
 			}
 			fallthrough
@@ -648,8 +662,6 @@ params:
 		pcfg.Sitemap = p.s.conf.Sitemap
 	}

-	pcfg.Markup = p.s.ContentSpec.ResolveMarkup(pcfg.Markup)
-
 	if draft != nil && published != nil {
 		pcfg.Draft = *draft
 		p.m.s.Log.Warnf("page %q has both draft and published settings in its frontmatter. Using draft.", p.File().Filename())
@@ -672,11 +684,19 @@ params:

 	params["iscjklanguage"] = pcfg.IsCJKLanguage

+	if err := pcfg.Validate(false); err != nil {
+		return err
+	}
+
+	if err := pcfg.Compile("", false, ext, p.s.Log, p.s.conf.MediaTypes.Config); err != nil {
+		return err
+	}
+
 	return nil
 }

 // shouldList returns whether this page should be included in the list of pages.
-// glogal indicates site.Pages etc.
+// global indicates site.Pages etc.
 func (p *pageMeta) shouldList(global bool) bool {
 	if p.isStandalone() {
 		// Never list 404, sitemap and similar.
@@ -727,13 +747,13 @@ func (p *pageMeta) applyDefaultValues() error {
 		(&p.pageConfig.Build).Disable()
 	}

-	if p.pageConfig.Markup == "" {
+	if p.pageConfig.Content.Markup == "" {
 		if p.File() != nil {
 			// Fall back to file extension
-			p.pageConfig.Markup = p.s.ContentSpec.ResolveMarkup(p.File().Ext())
+			p.pageConfig.Content.Markup = p.s.ContentSpec.ResolveMarkup(p.File().Ext())
 		}
-		if p.pageConfig.Markup == "" {
-			p.pageConfig.Markup = "markdown"
+		if p.pageConfig.Content.Markup == "" {
+			p.pageConfig.Content.Markup = "markdown"
 		}
 	}

@@ -794,12 +814,26 @@ func (p *pageMeta) newContentConverter(ps *pageState, markup string) (converter.
 		path = p.Path()
 	}

+	doc := newPageForRenderHook(ps)
+
+	documentLookup := func(id uint64) any {
+		if id == ps.pid {
+			// This prevents infinite recursion in some cases.
+			return doc
+		}
+		if v, ok := ps.pageOutput.pco.otherOutputs[id]; ok {
+			return v.po.p
+		}
+		return nil
+	}
+
 	cpp, err := cp.New(
 		converter.DocumentContext{
-			Document:     newPageForRenderHook(ps),
-			DocumentID:   id,
-			DocumentName: path,
-			Filename:     filename,
+			Document:       doc,
+			DocumentLookup: documentLookup,
+			DocumentID:     id,
+			DocumentName:   path,
+			Filename:       filename,
 		},
 	)
 	if err != nil {
@@ -15,7 +15,6 @@ package hugolib

 import (
 	"fmt"
-	"path/filepath"
 	"sync"
 	"sync/atomic"

@@ -36,21 +35,17 @@ var pageIDCounter atomic.Uint64

 func (h *HugoSites) newPage(m *pageMeta) (*pageState, *paths.Path, error) {
 	m.Staler = &resources.AtomicStaler{}
-	if m.pageConfig == nil {
-		m.pageMetaParams = pageMetaParams{
-			pageConfig: &pagemeta.PageConfig{
-				Params: maps.Params{},
-			},
+	if m.pageMetaParams == nil {
+		m.pageMetaParams = &pageMetaParams{
+			pageConfig: &pagemeta.PageConfig{},
 		}
 	}
-
-	var sourceKey string
-	if m.f != nil {
-		sourceKey = filepath.ToSlash(m.f.Filename())
+	if m.pageConfig.Params == nil {
+		m.pageConfig.Params = maps.Params{}
 	}

 	pid := pageIDCounter.Add(1)
-	pi, err := m.parseFrontMatter(h, pid, sourceKey)
+	pi, err := m.parseFrontMatter(h, pid)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -67,30 +62,43 @@ func (h *HugoSites) newPage(m *pageMeta) (*pageState, *paths.Path, error) {

 	if pcfg.Path != "" {
 		s := m.pageConfig.Path
-		if !paths.HasExt(s) {
+		// Paths from content adapters should never have any extension.
+		if pcfg.IsFromContentAdapter || !paths.HasExt(s) {
 			var (
-				isBranch bool
-				ext      string = "md"
+				isBranch    bool
+				isBranchSet bool
+				ext         string = m.pageConfig.ContentMediaType.FirstSuffix.Suffix
 			)
 			if pcfg.Kind != "" {
 				isBranch = kinds.IsBranch(pcfg.Kind)
-			} else if m.pathInfo != nil {
-				isBranch = m.pathInfo.IsBranchBundle()
-				if m.pathInfo.Ext() != "" {
-					ext = m.pathInfo.Ext()
-				}
-			} else if m.f != nil {
-				pi := m.f.FileInfo().Meta().PathInfo
-				isBranch = pi.IsBranchBundle()
-				if pi.Ext() != "" {
-					ext = pi.Ext()
+				isBranchSet = true
+			}
+
+			if !pcfg.IsFromContentAdapter {
+				if m.pathInfo != nil {
+					if !isBranchSet {
+						isBranch = m.pathInfo.IsBranchBundle()
+					}
+					if m.pathInfo.Ext() != "" {
+						ext = m.pathInfo.Ext()
+					}
+				} else if m.f != nil {
+					pi := m.f.FileInfo().Meta().PathInfo
+					if !isBranchSet {
+						isBranch = pi.IsBranchBundle()
+					}
+					if pi.Ext() != "" {
+						ext = pi.Ext()
+					}
 				}
 			}
+
 			if isBranch {
 				s += "/_index." + ext
 			} else {
 				s += "/index." + ext
 			}
+
 		}
 		m.pathInfo = h.Conf.PathParser().Parse(files.ComponentFolderContent, s)
 	} else if m.pathInfo == nil {
@@ -112,23 +120,13 @@ func (h *HugoSites) newPage(m *pageMeta) (*pageState, *paths.Path, error) {
 			} else if m.f != nil {
 				meta := m.f.FileInfo().Meta()
 				lang = meta.Lang
-				m.s = h.Sites[meta.LangIndex]
 			} else {
 				lang = m.pathInfo.Lang()
 			}
-			if lang == "" {
-				lang = h.Conf.DefaultContentLanguage()
-			}
-			var found bool
-			for _, ss := range h.Sites {
-				if ss.Lang() == lang {
-					m.s = ss
-					found = true
-					break
-				}
-			}

-			if !found {
+			m.s = h.resolveSite(lang)
+
+			if m.s == nil {
 				return nil, fmt.Errorf("no site found for language %q", lang)
 			}
 		}
@@ -184,6 +182,7 @@ func (h *HugoSites) newPage(m *pageMeta) (*pageState, *paths.Path, error) {
 				ResourceNameTitleProvider: m,
 				ResourceParamsProvider:    m,
 				PageMetaProvider:          m,
+				PageMetaInternalProvider:  m,
 				RelatedKeywordsProvider:   m,
 				OutputFormatsProvider:     page.NopPage,
 				ResourceTypeProvider:      pageTypesProvider,
@@ -25,11 +25,14 @@ import (
 	"github.com/gohugoio/hugo/common/text"
 	"github.com/gohugoio/hugo/common/types/hstring"
 	"github.com/gohugoio/hugo/identity"
+	"github.com/gohugoio/hugo/markup"
+	"github.com/gohugoio/hugo/media"
 	"github.com/gohugoio/hugo/parser/pageparser"
 	"github.com/mitchellh/mapstructure"
 	"github.com/spf13/cast"

 	"github.com/gohugoio/hugo/markup/converter/hooks"
+	"github.com/gohugoio/hugo/markup/goldmark/hugocontext"
 	"github.com/gohugoio/hugo/markup/highlight/chromalexers"
 	"github.com/gohugoio/hugo/markup/tableofcontents"

@@ -68,8 +71,9 @@ var (

 func newPageContentOutput(po *pageOutput) (*pageContentOutput, error) {
 	cp := &pageContentOutput{
-		po:          po,
-		renderHooks: &renderHooks{},
+		po:           po,
+		renderHooks:  &renderHooks{},
+		otherOutputs: make(map[uint64]*pageContentOutput),
 	}
 	return cp, nil
 }
@@ -83,8 +87,12 @@ type renderHooks struct {
 type pageContentOutput struct {
 	po *pageOutput

-	contentRenderedVersion int  // Incremented on reset.
-	contentRendered        bool // Set on content render.
+	// Other pages involved in rendering of this page,
+	// typically included with .RenderShortcodes.
+	otherOutputs map[uint64]*pageContentOutput
+
+	contentRenderedVersion uint32 // Incremented on reset.
+	contentRendered        bool   // Set on content render.

 	// Renders Markdown hooks.
 	renderHooks *renderHooks
@@ -165,6 +173,13 @@ func (pco *pageContentOutput) RenderShortcodes(ctx context.Context) (template.HT
 		cb(pco, ct)
 	}

+	if tpl.Context.IsInGoldmark.Get(ctx) {
+		// This content will be parsed and rendered by Goldmark.
+		// Wrap it in a special Hugo markup to assign the correct Page from
+		// the stack.
+		return template.HTML(hugocontext.Wrap(c, pco.po.p.pid)), nil
+	}
+
 	return helpers.BytesToHTML(c), nil
 }

@@ -249,6 +264,9 @@ func (pco *pageContentOutput) RenderString(ctx context.Context, args ...any) (te
 		if err := mapstructure.WeakDecode(m, &opts); err != nil {
 			return "", fmt.Errorf("failed to decode options: %w", err)
 		}
+		if opts.Markup != "" {
+			opts.Markup = markup.ResolveMarkup(opts.Markup)
+		}
 	}

 	contentToRenderv := args[sidx]
@@ -270,7 +288,8 @@ func (pco *pageContentOutput) RenderString(ctx context.Context, args ...any) (te
 	}

 	conv := pco.po.p.getContentConverter()
-	if opts.Markup != "" && opts.Markup != pco.po.p.m.pageConfig.Markup {
+
+	if opts.Markup != "" && opts.Markup != pco.po.p.m.pageConfig.ContentMediaType.SubType {
 		var err error
 		conv, err = pco.po.p.m.newContentConverter(pco.po.p, opts.Markup)
 		if err != nil {
@@ -288,7 +307,10 @@ func (pco *pageContentOutput) RenderString(ctx context.Context, args ...any) (te
 	if pageparser.HasShortcode(contentToRender) {
 		contentToRenderb := []byte(contentToRender)
 		// String contains a shortcode.
-		parseInfo.itemsStep1, err = pageparser.ParseBytesMain(contentToRenderb, pageparser.Config{})
+		parseInfo.itemsStep1, err = pageparser.ParseBytes(contentToRenderb, pageparser.Config{
+			NoFrontMatter:    true,
+			NoSummaryDivider: true,
+		})
 		if err != nil {
 			return "", err
 		}
@@ -363,9 +385,11 @@ func (pco *pageContentOutput) RenderString(ctx context.Context, args ...any) (te
 	}

 	if opts.Display == "inline" {
-		// We may have to rethink this in the future when we get other
-		// renderers.
-		rendered = pco.po.p.s.ContentSpec.TrimShortHTML(rendered)
+		markup := pco.po.p.m.pageConfig.Content.Markup
+		if opts.Markup != "" {
+			markup = pco.po.p.s.ContentSpec.ResolveMarkup(opts.Markup)
+		}
+		rendered = pco.po.p.s.ContentSpec.TrimShortHTML(rendered, markup)
 	}

 	return template.HTML(string(rendered)), nil
@@ -642,7 +666,7 @@ func splitUserDefinedSummaryAndContent(markup string, c []byte) (summary []byte,

 	startTag := "p"
 	switch markup {
-	case "asciidocext":
+	case media.DefaultContentTypes.AsciiDoc.SubType:
 		startTag = "div"
 	}

@@ -63,6 +63,15 @@ Summary Next Line

 <!--more-->
 Some more text
+`
+
+	simplePageWithBlankSummary = `---
+title: SimpleWithBlankSummary
+---
+
+<!--more-->
+
+Some text.
 `

 	simplePageWithSummaryParameter = `---
@@ -351,6 +360,9 @@ func normalizeExpected(ext, str string) string {

 		return expected
 	case "rst":
+		if str == "" {
+			return "<div class=\"document\"></div>"
+		}
 		return fmt.Sprintf("<div class=\"document\">\n\n\n%s</div>", str)
 	}
 }
@@ -630,6 +642,19 @@ func TestPageWithDelimiter(t *testing.T) {
 	testAllMarkdownEnginesForPages(t, assertFunc, nil, simplePageWithSummaryDelimiter)
 }

+func TestPageWithBlankSummary(t *testing.T) {
+	t.Parallel()
+	assertFunc := func(t *testing.T, ext string, pages page.Pages) {
+		p := pages[0]
+		checkPageTitle(t, p, "SimpleWithBlankSummary")
+		checkPageContent(t, p, normalizeExpected(ext, "<p>Some text.</p>\n"), ext)
+		checkPageSummary(t, p, normalizeExpected(ext, ""), ext)
+		checkPageType(t, p, "page")
+	}
+
+	testAllMarkdownEnginesForPages(t, assertFunc, nil, simplePageWithBlankSummary)
+}
+
 func TestPageWithSummaryParameter(t *testing.T) {
 	t.Parallel()
 	assertFunc := func(t *testing.T, ext string, pages page.Pages) {
@@ -919,3 +919,42 @@ GetMatch: {{ with .Resources.GetMatch "f1.*" }}{{ .Name }}: {{ .Content }}|{{ en

 	b.AssertFileContent("public/mybundle/index.html", "GetMatch: f1.en.txt: F1.|")
 }
+
+func TestBundleBranchIssue12320(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['rss','sitemap','taxonomy','term']
+defaultContentLanguage = 'en'
+defaultContentLanguageInSubdir = true
+[languages.en]
+baseURL = "https://en.example.org/"
+contentDir = "content/en"
+[languages.fr]
+baseURL = "https://fr.example.org/"
+contentDir = "content/fr"
+-- content/en/s1/p1.md --
+---
+title: p1
+---
+-- content/en/s1/p1.txt --
+---
+p1.txt
+---
+-- layouts/_default/single.html --
+{{ .Title }}|
+-- layouts/_default/list.html --
+{{ .Title }}|
+`
+
+	b := Test(t, files)
+
+	b.AssertFileExists("public/en/s1/index.html", true)
+	b.AssertFileExists("public/en/s1/p1/index.html", true)
+	b.AssertFileExists("public/en/s1/p1.txt", true)
+
+	b.AssertFileExists("public/fr/s1/index.html", false)
+	b.AssertFileExists("public/fr/s1/p1/index.html", false)
+	b.AssertFileExists("public/fr/s1/p1.txt", false) // failing test
+}
@@ -693,3 +693,36 @@ draft: true
 	b.AssertFileContent("public/s1-foo/index.html", "/s1-foo/: Pages: /s1-foo/p2/|/s1-foo/s2-foo/|/s1-foo/s2/|$")
 	b.AssertFileContent("public/s1-foo/s2/index.html", "/s1-foo/s2/: Pages: /s1-foo/s2/p3/|$")
 }
+
+func TestGetPageContentAdapterBaseIssue12561(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['rss','section','sitemap','taxonomy','term']
+-- layouts/index.html --
+Test A: {{ (site.GetPage "/s1/p1").Title }}
+Test B: {{ (site.GetPage "p1").Title }}
+Test C: {{ (site.GetPage "/s2/p2").Title }}
+Test D: {{ (site.GetPage "p2").Title }}
+-- layouts/_default/single.html --
+{{ .Title }}
+-- content/s1/p1.md --
+---
+title: p1
+---
+-- content/s2/_content.gotmpl --
+{{ .AddPage (dict "path" "p2" "title" "p2") }}
+`
+
+	b := Test(t, files)
+
+	b.AssertFileExists("public/s1/p1/index.html", true)
+	b.AssertFileExists("public/s2/p2/index.html", true)
+	b.AssertFileContent("public/index.html",
+		"Test A: p1",
+		"Test B: p1",
+		"Test C: p2",
+		"Test D: p2", // fails
+	)
+}
@@ -42,18 +42,20 @@ func newPagesCollector(
 	logger loggers.Logger,
 	infoLogger logg.LevelLogger,
 	m *pageMap,
+	buildConfig *BuildCfg,
 	ids []pathChange,
 ) *pagesCollector {
 	return &pagesCollector{
-		ctx:        ctx,
-		h:          h,
-		fs:         sp.BaseFs.Content.Fs,
-		m:          m,
-		sp:         sp,
-		logger:     logger,
-		infoLogger: infoLogger,
-		ids:        ids,
-		seenDirs:   make(map[string]bool),
+		ctx:         ctx,
+		h:           h,
+		fs:          sp.BaseFs.Content.Fs,
+		m:           m,
+		sp:          sp,
+		logger:      logger,
+		infoLogger:  infoLogger,
+		buildConfig: buildConfig,
+		ids:         ids,
+		seenDirs:    make(map[string]bool),
 	}
 }

@@ -68,6 +70,8 @@ type pagesCollector struct {

 	fs afero.Fs

+	buildConfig *BuildCfg
+
 	// List of paths that have changed. Used in partial builds.
 	ids      []pathChange
 	seenDirs map[string]bool
@@ -82,6 +86,8 @@ func (c *pagesCollector) Collect() (collectErr error) {
 	var (
 		numWorkers             = c.h.numWorkers
 		numFilesProcessedTotal atomic.Uint64
+		numPagesProcessedTotal atomic.Uint64
+		numResourcesProcessed  atomic.Uint64
 		numFilesProcessedLast  uint64
 		fileBatchTimer         = time.Now()
 		fileBatchTimerMu       sync.Mutex
@@ -98,6 +104,8 @@ func (c *pagesCollector) Collect() (collectErr error) {
 				logg.Fields{
 					logg.Field{Name: "files", Value: numFilesProcessedBatch},
 					logg.Field{Name: "files_total", Value: numFilesProcessedTotal.Load()},
+					logg.Field{Name: "pages_total", Value: numPagesProcessedTotal.Load()},
+					logg.Field{Name: "resources_total", Value: numResourcesProcessed.Load()},
 				},
 				"",
 			)
@@ -113,10 +121,13 @@ func (c *pagesCollector) Collect() (collectErr error) {
 	c.g = rungroup.Run[hugofs.FileMetaInfo](c.ctx, rungroup.Config[hugofs.FileMetaInfo]{
 		NumWorkers: numWorkers,
 		Handle: func(ctx context.Context, fi hugofs.FileMetaInfo) error {
-			if err := c.m.AddFi(fi); err != nil {
+			numPages, numResources, err := c.m.AddFi(fi, c.buildConfig)
+			if err != nil {
 				return hugofs.AddFileInfoToError(err, fi, c.fs)
 			}
 			numFilesProcessedTotal.Add(1)
+			numPagesProcessedTotal.Add(numPages)
+			numResourcesProcessed.Add(numResources)
 			if numFilesProcessedTotal.Load()%1000 == 0 {
 				logFilesProcessed(false)
 			}
@@ -147,7 +158,7 @@ func (c *pagesCollector) Collect() (collectErr error) {
 					false,
 					func(fim hugofs.FileMetaInfo) bool {
 						if fim.IsDir() {
-							return true
+							return id.isStructuralChange()
 						}
 						fimp := fim.Meta().PathInfo
 						if fimp == nil {
@@ -160,7 +171,7 @@ func (c *pagesCollector) Collect() (collectErr error) {
 			} else {
 				// We always start from a directory.
 				collectErr = c.collectDir(id.p, id.isDir, func(fim hugofs.FileMetaInfo) bool {
-					if id.delete || id.isDir {
+					if id.isStructuralChange() {
 						if id.isDir && fim.Meta().PathInfo.IsLeafBundle() {
 							return strings.HasPrefix(fim.Meta().PathInfo.Path(), paths.AddTrailingSlash(id.p.Path()))
 						}
@@ -243,6 +254,21 @@ func (c *pagesCollector) collectDirDir(path string, root hugofs.FileMetaInfo, in
 			return nil, nil
 		}

+		n := 0
+		for _, fi := range readdir {
+			if fi.Meta().PathInfo.IsContentData() {
+				// _content.json
+				// These are not part of any bundle, so just add them directly and remove them from the readdir slice.
+				if err := c.g.Enqueue(fi); err != nil {
+					return nil, err
+				}
+			} else {
+				readdir[n] = fi
+				n++
+			}
+		}
+		readdir = readdir[:n]
+
 		// Pick the first regular file.
 		var first hugofs.FileMetaInfo
 		for _, fi := range readdir {
@@ -260,6 +286,7 @@ func (c *pagesCollector) collectDirDir(path string, root hugofs.FileMetaInfo, in

 		// Any bundle file will always be first.
 		firstPi := first.Meta().PathInfo
+
 		if firstPi == nil {
 			panic(fmt.Sprintf("collectDirDir: no path info for %q", first.Meta().Filename))
 		}
@@ -320,6 +347,7 @@ func (c *pagesCollector) collectDirDir(path string, root hugofs.FileMetaInfo, in
 			Info:       root,
 			Fs:         c.fs,
 			IgnoreFile: c.h.SourceSpec.IgnoreFile,
+			PathParser: c.h.Conf.PathParser(),
 			HookPre:    preHook,
 			HookPost:   postHook,
 			WalkFn:     wfn,
@@ -370,6 +398,7 @@ func (c *pagesCollector) handleBundleLeaf(dir, bundle hugofs.FileMetaInfo, inPat
 			Info:       dir,
 			DirEntries: readdir,
 			IgnoreFile: c.h.SourceSpec.IgnoreFile,
+			PathParser: c.h.Conf.PathParser(),
 			WalkFn:     walk,
 		})

@@ -68,7 +68,7 @@ func TestMergeLanguages(t *testing.T) {

 	firstNN := nnSite.RegularPages()[0]
 	c.Assert(len(firstNN.Sites()), qt.Equals, 4)
-	c.Assert(firstNN.Sites().First().Language().Lang, qt.Equals, "en")
+	c.Assert(firstNN.Sites().Default().Language().Lang, qt.Equals, "en")

 	nnBundle := nnSite.getPageOldVersion("page", "bundle")
 	enBundle := enSite.getPageOldVersion("page", "bundle")
@@ -0,0 +1,331 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagesfromdata
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/common/maps"
+	"github.com/gohugoio/hugo/common/paths"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/identity"
+	"github.com/gohugoio/hugo/resources/page"
+	"github.com/gohugoio/hugo/resources/page/pagemeta"
+	"github.com/gohugoio/hugo/resources/resource"
+	"github.com/gohugoio/hugo/tpl"
+	"github.com/mitchellh/mapstructure"
+	"github.com/spf13/cast"
+)
+
+type PagesFromDataTemplateContext interface {
+	// AddPage adds a new page to the site.
+	// The first return value will always be an empty string.
+	AddPage(any) (string, error)
+
+	// AddResource adds a new resource to the site.
+	// The first return value will always be an empty string.
+	AddResource(any) (string, error)
+
+	// The site to which the pages will be added.
+	Site() page.Site
+
+	// The same template may be executed multiple times for multiple languages.
+	// The Store can be used to store state between these invocations.
+	Store() *maps.Scratch
+
+	// By default, the template will be executed for the language
+	// defined by the _content.gotmpl file (e.g. its mount definition).
+	// This method can be used to activate the template for all languages.
+	// The return value will always be an empty string.
+	EnableAllLanguages() string
+}
+
+var _ PagesFromDataTemplateContext = (*pagesFromDataTemplateContext)(nil)
+
+type pagesFromDataTemplateContext struct {
+	p *PagesFromTemplate
+}
+
+func (p *pagesFromDataTemplateContext) toPathMap(v any) (string, map[string]any, error) {
+	m, err := maps.ToStringMapE(v)
+	if err != nil {
+		return "", nil, err
+	}
+	pathv, ok := m["path"]
+	if !ok {
+		return "", nil, fmt.Errorf("path not set")
+	}
+	path, err := cast.ToStringE(pathv)
+	if err != nil || path == "" {
+		return "", nil, fmt.Errorf("invalid path %q", path)
+	}
+	return path, m, nil
+}
+
+func (p *pagesFromDataTemplateContext) AddPage(v any) (string, error) {
+	path, m, err := p.toPathMap(v)
+	if err != nil {
+		return "", err
+	}
+
+	if !p.p.buildState.checkHasChangedAndSetSourceInfo(path, m) {
+		return "", nil
+	}
+
+	pd := pagemeta.DefaultPageConfig
+	pd.IsFromContentAdapter = true
+
+	if err := mapstructure.WeakDecode(m, &pd); err != nil {
+		return "", fmt.Errorf("failed to decode page map: %w", err)
+	}
+
+	p.p.buildState.NumPagesAdded++
+
+	if err := pd.Validate(true); err != nil {
+		return "", err
+	}
+
+	return "", p.p.HandlePage(p.p, &pd)
+}
+
+func (p *pagesFromDataTemplateContext) AddResource(v any) (string, error) {
+	path, m, err := p.toPathMap(v)
+	if err != nil {
+		return "", err
+	}
+
+	if !p.p.buildState.checkHasChangedAndSetSourceInfo(path, m) {
+		return "", nil
+	}
+
+	var rd pagemeta.ResourceConfig
+	if err := mapstructure.WeakDecode(m, &rd); err != nil {
+		return "", err
+	}
+
+	p.p.buildState.NumResourcesAdded++
+
+	if err := rd.Validate(); err != nil {
+		return "", err
+	}
+
+	return "", p.p.HandleResource(p.p, &rd)
+}
+
+func (p *pagesFromDataTemplateContext) Site() page.Site {
+	return p.p.Site
+}
+
+func (p *pagesFromDataTemplateContext) Store() *maps.Scratch {
+	return p.p.store
+}
+
+func (p *pagesFromDataTemplateContext) EnableAllLanguages() string {
+	p.p.buildState.EnableAllLanguages = true
+	return ""
+}
+
+func NewPagesFromTemplate(opts PagesFromTemplateOptions) *PagesFromTemplate {
+	return &PagesFromTemplate{
+		PagesFromTemplateOptions: opts,
+		PagesFromTemplateDeps:    opts.DepsFromSite(opts.Site),
+		buildState: &BuildState{
+			sourceInfosCurrent: maps.NewCache[string, *sourceInfo](),
+		},
+		store: maps.NewScratch(),
+	}
+}
+
+type PagesFromTemplateOptions struct {
+	Site         page.Site
+	DepsFromSite func(page.Site) PagesFromTemplateDeps
+
+	DependencyManager identity.Manager
+
+	Watching bool
+
+	HandlePage     func(pt *PagesFromTemplate, p *pagemeta.PageConfig) error
+	HandleResource func(pt *PagesFromTemplate, p *pagemeta.ResourceConfig) error
+
+	GoTmplFi hugofs.FileMetaInfo
+}
+
+type PagesFromTemplateDeps struct {
+	TmplFinder tpl.TemplateParseFinder
+	TmplExec   tpl.TemplateExecutor
+}
+
+var _ resource.Staler = (*PagesFromTemplate)(nil)
+
+type PagesFromTemplate struct {
+	PagesFromTemplateOptions
+	PagesFromTemplateDeps
+	buildState *BuildState
+	store      *maps.Scratch
+}
+
+func (b *PagesFromTemplate) AddChange(id identity.Identity) {
+	b.buildState.ChangedIdentities = append(b.buildState.ChangedIdentities, id)
+}
+
+func (b *PagesFromTemplate) MarkStale() {
+	b.buildState.StaleVersion++
+}
+
+func (b *PagesFromTemplate) StaleVersion() uint32 {
+	return b.buildState.StaleVersion
+}
+
+type BuildInfo struct {
+	NumPagesAdded      uint64
+	NumResourcesAdded  uint64
+	EnableAllLanguages bool
+	ChangedIdentities  []identity.Identity
+	DeletedPaths       []string
+	Path               *paths.Path
+}
+
+type BuildState struct {
+	StaleVersion uint32
+
+	EnableAllLanguages bool
+
+	// Paths deleted in the current build.
+	DeletedPaths []string
+
+	// Changed identities in the current build.
+	ChangedIdentities []identity.Identity
+
+	NumPagesAdded     uint64
+	NumResourcesAdded uint64
+
+	sourceInfosCurrent  *maps.Cache[string, *sourceInfo]
+	sourceInfosPrevious *maps.Cache[string, *sourceInfo]
+}
+
+func (b *BuildState) hash(v any) uint64 {
+	return identity.HashUint64(v)
+}
+
+func (b *BuildState) checkHasChangedAndSetSourceInfo(changedPath string, v any) bool {
+	h := b.hash(v)
+	si, found := b.sourceInfosPrevious.Get(changedPath)
+	if found {
+		b.sourceInfosCurrent.Set(changedPath, si)
+		if si.hash == h {
+			return false
+		}
+	} else {
+		si = &sourceInfo{}
+		b.sourceInfosCurrent.Set(changedPath, si)
+	}
+	si.hash = h
+	return true
+}
+
+func (b *BuildState) resolveDeletedPaths() {
+	if b.sourceInfosPrevious == nil {
+		b.DeletedPaths = nil
+		return
+	}
+	var paths []string
+	b.sourceInfosPrevious.ForEeach(func(k string, _ *sourceInfo) {
+		if _, found := b.sourceInfosCurrent.Get(k); !found {
+			paths = append(paths, k)
+		}
+	})
+
+	b.DeletedPaths = paths
+}
+
+func (b *BuildState) PrepareNextBuild() {
+	b.sourceInfosPrevious = b.sourceInfosCurrent
+	b.sourceInfosCurrent = maps.NewCache[string, *sourceInfo]()
+	b.StaleVersion = 0
+	b.DeletedPaths = nil
+	b.ChangedIdentities = nil
+	b.NumPagesAdded = 0
+	b.NumResourcesAdded = 0
+}
+
+type sourceInfo struct {
+	hash uint64
+}
+
+func (p PagesFromTemplate) CloneForSite(s page.Site) *PagesFromTemplate {
+	// We deliberately make them share the same DepenencyManager and Store.
+	p.PagesFromTemplateOptions.Site = s
+	p.PagesFromTemplateDeps = p.PagesFromTemplateOptions.DepsFromSite(s)
+	p.buildState = &BuildState{
+		sourceInfosCurrent: maps.NewCache[string, *sourceInfo](),
+	}
+	return &p
+}
+
+func (p PagesFromTemplate) CloneForGoTmpl(fi hugofs.FileMetaInfo) *PagesFromTemplate {
+	p.PagesFromTemplateOptions.GoTmplFi = fi
+	return &p
+}
+
+func (p *PagesFromTemplate) GetDependencyManagerForScope(scope int) identity.Manager {
+	return p.DependencyManager
+}
+
+func (p *PagesFromTemplate) Execute(ctx context.Context) (BuildInfo, error) {
+	defer func() {
+		p.buildState.PrepareNextBuild()
+	}()
+
+	f, err := p.GoTmplFi.Meta().Open()
+	if err != nil {
+		return BuildInfo{}, err
+	}
+	defer f.Close()
+
+	tmpl, err := p.TmplFinder.Parse(filepath.ToSlash(p.GoTmplFi.Meta().Filename), helpers.ReaderToString(f))
+	if err != nil {
+		return BuildInfo{}, err
+	}
+
+	data := &pagesFromDataTemplateContext{
+		p: p,
+	}
+
+	ctx = tpl.Context.DependencyManagerScopedProvider.Set(ctx, p)
+
+	if err := p.TmplExec.ExecuteWithContext(ctx, tmpl, io.Discard, data); err != nil {
+		return BuildInfo{}, err
+	}
+
+	if p.Watching {
+		p.buildState.resolveDeletedPaths()
+	}
+
+	bi := BuildInfo{
+		NumPagesAdded:      p.buildState.NumPagesAdded,
+		NumResourcesAdded:  p.buildState.NumResourcesAdded,
+		EnableAllLanguages: p.buildState.EnableAllLanguages,
+		ChangedIdentities:  p.buildState.ChangedIdentities,
+		DeletedPaths:       p.buildState.DeletedPaths,
+		Path:               p.GoTmplFi.Meta().PathInfo,
+	}
+
+	return bi, nil
+}
+
+//////////////
@@ -0,0 +1,680 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagesfromdata_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/gohugoio/hugo/markup/asciidocext"
+	"github.com/gohugoio/hugo/markup/pandoc"
+	"github.com/gohugoio/hugo/markup/rst"
+)
+
+const filesPagesFromDataTempleBasic = `
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+disableLiveReload = true
+-- assets/a/pixel.png --
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
+-- assets/mydata.yaml --
+p1: "p1"
+draft: false
+-- layouts/partials/get-value.html --
+{{ $val := "p1" }}
+{{ return $val }}
+-- layouts/_default/baseof.html --
+Baseof:
+{{ block "main" . }}{{ end }}
+-- layouts/_default/single.html --
+{{ define "main" }}
+Single: {{ .Title }}|{{ .Content }}|Params: {{ .Params.param1 }}|Path: {{ .Path }}|
+Dates: Date: {{ .Date.Format "2006-01-02" }}|Lastmod: {{ .Lastmod.Format "2006-01-02" }}|PublishDate: {{ .PublishDate.Format "2006-01-02" }}|ExpiryDate: {{ .ExpiryDate.Format "2006-01-02" }}|
+Len Resources: {{ .Resources | len }}
+Resources: {{ range .Resources }}RelPermalink: {{ .RelPermalink }}|Name: {{ .Name }}|Title: {{ .Title }}|Params: {{ .Params }}|{{ end }}$
+{{ with .Resources.Get "featured.png" }}
+Featured Image: {{ .RelPermalink }}|{{ .Name }}|
+{{ with .Resize "10x10" }}
+Resized Featured Image: {{ .RelPermalink }}|{{ .Width }}|
+{{ end}}
+{{ end }}
+{{ end }}
+-- layouts/_default/list.html --
+List: {{ .Title }}|{{ .Content }}|
+RegularPagesRecursive: {{ range .RegularPagesRecursive }}{{ .Title }}:{{ .Path }}|{{ end }}$
+Sections: {{ range .Sections }}{{ .Title }}:{{ .Path }}|{{ end }}$
+-- content/docs/pfile.md --
+---
+title: "pfile"
+date: 2023-03-01
+---
+Pfile Content
+-- content/docs/_content.gotmpl --
+{{ $pixel := resources.Get "a/pixel.png" }}
+{{ $dataResource := resources.Get "mydata.yaml" }}
+{{ $data := $dataResource | transform.Unmarshal }}
+{{ $pd := $data.p1 }}
+{{ $pp := partial "get-value.html" }}
+{{ $title := printf "%s:%s" $pd $pp }}
+{{ $date := "2023-03-01" | time.AsTime }}
+{{ $dates := dict "date" $date }}
+{{ $contentMarkdown := dict "value" "**Hello World**"  "mediaType" "text/markdown" }}
+{{ $contentMarkdownDefault := dict "value" "**Hello World Default**" }}
+{{ $contentHTML := dict "value" "<b>Hello World!</b> No **markdown** here." "mediaType" "text/html" }}
+{{ $.AddPage  (dict "kind" "page" "path" "P1" "title" $title "dates" $dates "content" $contentMarkdown "params" (dict "param1" "param1v" ) ) }}
+{{ $.AddPage  (dict "kind" "page" "path" "p2" "title" "p2title" "dates" $dates "content" $contentHTML ) }}
+{{ $.AddPage  (dict "kind" "page" "path" "p3" "title" "p3title" "dates" $dates "content" $contentMarkdownDefault "draft" false ) }}
+{{ $.AddPage  (dict "kind" "page" "path" "p4" "title" "p4title" "dates" $dates "content" $contentMarkdownDefault "draft" $data.draft ) }}
+ADD_MORE_PLACEHOLDER
+
+
+{{ $resourceContent := dict "value" $dataResource }}
+{{ $.AddResource (dict "path" "p1/data1.yaml" "content" $resourceContent) }}
+{{ $.AddResource (dict "path" "p1/mytext.txt" "content" (dict "value" "some text") "name" "textresource" "title" "My Text Resource" "params" (dict "param1" "param1v") )}}
+{{ $.AddResource (dict "path" "p1/sub/mytex2.txt" "content" (dict "value" "some text") "title" "My Text Sub Resource" ) }}
+{{ $.AddResource (dict "path" "P1/Sub/MyMixCaseText2.txt" "content" (dict "value" "some text") "title" "My Text Sub Mixed Case Path Resource" ) }}
+{{ $.AddResource (dict "path" "p1/sub/data1.yaml" "content" $resourceContent "title" "Sub data") }}
+{{ $resourceParams := dict "data2ParaM1" "data2Param1v" }}
+{{ $.AddResource (dict "path" "p1/data2.yaml" "name" "data2.yaml" "title" "My data 2" "params" $resourceParams "content" $resourceContent) }}
+{{ $.AddResource (dict "path" "p1/featuredimage.png" "name" "featured.png" "title" "My Featured Image" "params" $resourceParams "content" (dict "value" $pixel ))}}
+`
+
+func TestPagesFromGoTmplMisc(t *testing.T) {
+	t.Parallel()
+	b := hugolib.Test(t, filesPagesFromDataTempleBasic)
+	b.AssertPublishDir(`
+docs/p1/mytext.txt
+docs/p1/sub/mytex2.tx
+docs/p1/sub/mymixcasetext2.txt
+	`)
+
+	// Page from markdown file.
+	b.AssertFileContent("public/docs/pfile/index.html", "Dates: Date: 2023-03-01|Lastmod: 2023-03-01|PublishDate: 2023-03-01|ExpiryDate: 0001-01-01|")
+	// Pages from gotmpl.
+	b.AssertFileContent("public/docs/p1/index.html",
+		"Single: p1:p1|",
+		"Path: /docs/p1|",
+		"<strong>Hello World</strong>",
+		"Params: param1v|",
+		"Len Resources: 7",
+		"RelPermalink: /mydata.yaml|Name: data1.yaml|Title: data1.yaml|Params: map[]|",
+		"RelPermalink: /mydata.yaml|Name: data2.yaml|Title: My data 2|Params: map[data2param1:data2Param1v]|",
+		"RelPermalink: /a/pixel.png|Name: featured.png|Title: My Featured Image|Params: map[data2param1:data2Param1v]|",
+		"RelPermalink: /docs/p1/sub/mytex2.txt|Name: sub/mytex2.txt|",
+		"RelPermalink: /docs/p1/sub/mymixcasetext2.txt|Name: sub/mymixcasetext2.txt|",
+		"RelPermalink: /mydata.yaml|Name: sub/data1.yaml|Title: Sub data|Params: map[]|",
+		"Featured Image: /a/pixel.png|featured.png|",
+		"Resized Featured Image: /a/pixel_hu8aa3346827e49d756ff4e630147c42b5_70_10x10_resize_box_3.png|10|",
+		// Resource from string
+		"RelPermalink: /docs/p1/mytext.txt|Name: textresource|Title: My Text Resource|Params: map[param1:param1v]|",
+		// Dates
+		"Dates: Date: 2023-03-01|Lastmod: 2023-03-01|PublishDate: 2023-03-01|ExpiryDate: 0001-01-01|",
+	)
+	b.AssertFileContent("public/docs/p2/index.html", "Single: p2title|", "<b>Hello World!</b> No **markdown** here.")
+	b.AssertFileContent("public/docs/p3/index.html", "<strong>Hello World Default</strong>")
+}
+
+func TestPagesFromGoTmplAsciidocAndSimilar(t *testing.T) {
+	files := `
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+[security]
+[security.exec]
+allow = ['asciidoctor', 'pandoc','rst2html', 'python']
+-- layouts/_default/single.html --
+|Content: {{ .Content }}|Title: {{ .Title }}|Path: {{ .Path }}|
+-- content/docs/_content.gotmpl --
+{{ $.AddPage (dict "path" "asciidoc" "content" (dict "value" "Mark my words, #automation is essential#." "mediaType" "text/asciidoc" )) }}
+{{ $.AddPage (dict "path" "pandoc" "content" (dict "value" "This ~~is deleted text.~~" "mediaType" "text/pandoc" )) }}
+{{ $.AddPage (dict "path" "rst" "content" (dict "value" "This is *bold*." "mediaType" "text/rst" )) }}
+{{ $.AddPage (dict "path" "org" "content" (dict "value" "the ability to use +strikethrough+ is a plus" "mediaType" "text/org" )) }}
+{{ $.AddPage (dict "path" "nocontent" "title" "No Content" ) }}
+
+	`
+
+	b := hugolib.Test(t, files)
+
+	if asciidocext.Supports() {
+		b.AssertFileContent("public/docs/asciidoc/index.html",
+			"Mark my words, <mark>automation is essential</mark>",
+			"Path: /docs/asciidoc|",
+		)
+	}
+	if pandoc.Supports() {
+		b.AssertFileContent("public/docs/pandoc/index.html",
+			"This <del>is deleted text.</del>",
+			"Path: /docs/pandoc|",
+		)
+	}
+
+	if rst.Supports() {
+		b.AssertFileContent("public/docs/rst/index.html",
+			"This is <em>bold</em>",
+			"Path: /docs/rst|",
+		)
+	}
+
+	b.AssertFileContent("public/docs/org/index.html",
+		"the ability to use <del>strikethrough</del> is a plus",
+		"Path: /docs/org|",
+	)
+
+	b.AssertFileContent("public/docs/nocontent/index.html", "|Content: |Title: No Content|Path: /docs/nocontent|")
+}
+
+func TestPagesFromGoTmplAddPageErrors(t *testing.T) {
+	filesTemplate := `
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+-- content/docs/_content.gotmpl --
+{{ $.AddPage  DICT }}
+`
+
+	t.Run("AddPage, missing Path", func(t *testing.T) {
+		files := strings.ReplaceAll(filesTemplate, "DICT", `(dict "kind" "page" "title" "p1")`)
+		b, err := hugolib.TestE(t, files)
+		b.Assert(err, qt.IsNotNil)
+		b.Assert(err.Error(), qt.Contains, "_content.gotmpl:1:4")
+		b.Assert(err.Error(), qt.Contains, "error calling AddPage: path not set")
+	})
+
+	t.Run("AddPage, path starting with slash", func(t *testing.T) {
+		files := strings.ReplaceAll(filesTemplate, "DICT", `(dict "kind" "page" "title" "p1" "path" "/foo")`)
+		b, err := hugolib.TestE(t, files)
+		b.Assert(err, qt.IsNotNil)
+		b.Assert(err.Error(), qt.Contains, `path "/foo" must not start with a /`)
+	})
+
+	t.Run("AddPage, lang set", func(t *testing.T) {
+		files := strings.ReplaceAll(filesTemplate, "DICT", `(dict "kind" "page" "path" "p1" "lang" "en")`)
+		b, err := hugolib.TestE(t, files)
+		b.Assert(err, qt.IsNotNil)
+		b.Assert(err.Error(), qt.Contains, "_content.gotmpl:1:4")
+		b.Assert(err.Error(), qt.Contains, "error calling AddPage: lang must not be set")
+	})
+
+	t.Run("Site methods not ready", func(t *testing.T) {
+		filesTemplate := `
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+-- content/docs/_content.gotmpl --
+{{ .Site.METHOD }}
+`
+
+		for _, method := range []string{"RegularPages", "Pages", "AllPages", "AllRegularPages", "Home", "Sections", "GetPage", "Menus", "MainSections", "Taxonomies"} {
+			t.Run(method, func(t *testing.T) {
+				files := strings.ReplaceAll(filesTemplate, "METHOD", method)
+				b, err := hugolib.TestE(t, files)
+				b.Assert(err, qt.IsNotNil)
+				b.Assert(err.Error(), qt.Contains, fmt.Sprintf("error calling %s: this method cannot be called before the site is fully initialized", method))
+			})
+		}
+	})
+}
+
+func TestPagesFromGoTmplAddResourceErrors(t *testing.T) {
+	filesTemplate := `
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+-- content/docs/_content.gotmpl --
+{{ $.AddResource  DICT }}
+`
+
+	t.Run("missing Path", func(t *testing.T) {
+		files := strings.ReplaceAll(filesTemplate, "DICT", `(dict "name" "r1")`)
+		b, err := hugolib.TestE(t, files)
+		b.Assert(err, qt.IsNotNil)
+		b.Assert(err.Error(), qt.Contains, "error calling AddResource: path not set")
+	})
+}
+
+func TestPagesFromGoTmplEditGoTmpl(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.EditFileReplaceAll("content/docs/_content.gotmpl", `"title" "p2title"`, `"title" "p2titleedited"`).Build()
+	b.AssertFileContent("public/docs/p2/index.html", "Single: p2titleedited|")
+	b.AssertFileContent("public/docs/index.html", "p2titleedited")
+}
+
+func TestPagesFromGoTmplEditDataResource(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.AssertRenderCountPage(7)
+	b.EditFileReplaceAll("assets/mydata.yaml", "p1: \"p1\"", "p1: \"p1edited\"").Build()
+	b.AssertFileContent("public/docs/p1/index.html", "Single: p1edited:p1|")
+	b.AssertFileContent("public/docs/index.html", "p1edited")
+	b.AssertRenderCountPage(3)
+}
+
+func TestPagesFromGoTmplEditPartial(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.EditFileReplaceAll("layouts/partials/get-value.html", "p1", "p1edited").Build()
+	b.AssertFileContent("public/docs/p1/index.html", "Single: p1:p1edited|")
+	b.AssertFileContent("public/docs/index.html", "p1edited")
+}
+
+func TestPagesFromGoTmplRemovePage(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.EditFileReplaceAll("content/docs/_content.gotmpl", `{{ $.AddPage  (dict "kind" "page" "path" "p2" "title" "p2title" "dates" $dates "content" $contentHTML ) }}`, "").Build()
+	b.AssertFileContent("public/index.html", "RegularPagesRecursive: p1:p1:/docs/p1|p3title:/docs/p3|p4title:/docs/p4|pfile:/docs/pfile|$")
+}
+
+func TestPagesFromGoTmplAddPage(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.EditFileReplaceAll("content/docs/_content.gotmpl", "ADD_MORE_PLACEHOLDER", `{{ $.AddPage  (dict "kind" "page" "path" "page_added" "title" "page_added_title" "dates" $dates "content" $contentHTML ) }}`).Build()
+	b.AssertFileExists("public/docs/page_added/index.html", true)
+	b.AssertFileContent("public/index.html", "RegularPagesRecursive: p1:p1:/docs/p1|p2title:/docs/p2|p3title:/docs/p3|p4title:/docs/p4|page_added_title:/docs/page_added|pfile:/docs/pfile|$")
+}
+
+func TestPagesFromGoTmplDraftPage(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.EditFileReplaceAll("content/docs/_content.gotmpl", `"draft" false`, `"draft" true`).Build()
+	b.AssertFileContent("public/index.html", "RegularPagesRecursive: p1:p1:/docs/p1|p2title:/docs/p2|p4title:/docs/p4|pfile:/docs/pfile|$")
+}
+
+func TestPagesFromGoTmplDraftFlagFromResource(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.EditFileReplaceAll("assets/mydata.yaml", `draft: false`, `draft: true`).Build()
+	b.AssertFileContent("public/index.html", "RegularPagesRecursive: p1:p1:/docs/p1|p2title:/docs/p2|p3title:/docs/p3|pfile:/docs/pfile|$")
+	b.EditFileReplaceAll("assets/mydata.yaml", `draft: true`, `draft: false`).Build()
+	b.AssertFileContent("public/index.html", "RegularPagesRecursive: p1:p1:/docs/p1|p2title:/docs/p2|p3title:/docs/p3|p4title:/docs/p4|pfile:/docs/pfile|$")
+}
+
+func TestPagesFromGoTmplMovePage(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.AssertFileContent("public/index.html", "RegularPagesRecursive: p1:p1:/docs/p1|p2title:/docs/p2|p3title:/docs/p3|p4title:/docs/p4|pfile:/docs/pfile|$")
+	b.EditFileReplaceAll("content/docs/_content.gotmpl", `"path" "p2"`, `"path" "p2moved"`).Build()
+	b.AssertFileContent("public/index.html", "RegularPagesRecursive: p1:p1:/docs/p1|p2title:/docs/p2moved|p3title:/docs/p3|p4title:/docs/p4|pfile:/docs/pfile|$")
+}
+
+func TestPagesFromGoTmplRemoveGoTmpl(t *testing.T) {
+	t.Parallel()
+	b := hugolib.TestRunning(t, filesPagesFromDataTempleBasic)
+	b.AssertFileContent("public/index.html",
+		"RegularPagesRecursive: p1:p1:/docs/p1|p2title:/docs/p2|p3title:/docs/p3|p4title:/docs/p4|pfile:/docs/pfile|$",
+		"Sections: Docs:/docs|",
+	)
+	b.AssertFileContent("public/docs/index.html", "RegularPagesRecursive: p1:p1:/docs/p1|p2title:/docs/p2|p3title:/docs/p3|p4title:/docs/p4|pfile:/docs/pfile|$")
+	b.RemoveFiles("content/docs/_content.gotmpl").Build()
+	// One regular page left.
+	b.AssertFileContent("public/index.html",
+		"RegularPagesRecursive: pfile:/docs/pfile|$",
+		"Sections: Docs:/docs|",
+	)
+	b.AssertFileContent("public/docs/index.html", "RegularPagesRecursive: pfile:/docs/pfile|$")
+}
+
+func TestPagesFromGoTmplLanguagePerFile(t *testing.T) {
+	filesTemplate := `
+-- hugo.toml --
+defaultContentLanguage = "en"
+defaultContentLanguageInSubdir = true
+[languages]
+[languages.en]
+weight = 1
+title = "Title"
+[languages.fr]
+weight = 2
+title = "Titre"
+disabled = DISABLE
+-- layouts/_default/single.html --
+Single: {{ .Title }}|{{ .Content }}|
+-- content/docs/_content.gotmpl --
+{{ $.AddPage  (dict "kind" "page" "path" "p1" "title" "Title" ) }}
+-- content/docs/_content.fr.gotmpl --
+{{ $.AddPage  (dict "kind" "page" "path" "p1" "title" "Titre" ) }}
+`
+
+	for _, disable := range []bool{false, true} {
+		t.Run(fmt.Sprintf("disable=%t", disable), func(t *testing.T) {
+			b := hugolib.Test(t, strings.ReplaceAll(filesTemplate, "DISABLE", fmt.Sprintf("%t", disable)))
+			b.AssertFileContent("public/en/docs/p1/index.html", "Single: Title||")
+			b.AssertFileExists("public/fr/docs/p1/index.html", !disable)
+			if !disable {
+				b.AssertFileContent("public/fr/docs/p1/index.html", "Single: Titre||")
+			}
+		})
+	}
+}
+
+func TestPagesFromGoTmplEnableAllLanguages(t *testing.T) {
+	t.Parallel()
+
+	filesTemplate := `
+-- hugo.toml --
+defaultContentLanguage = "en"
+defaultContentLanguageInSubdir = true
+[languages]
+[languages.en]
+weight = 1
+title = "Title"
+[languages.fr]
+title = "Titre"
+weight = 2
+disabled = DISABLE
+-- i18n/en.yaml --
+title: Title
+-- i18n/fr.yaml --
+title: Titre
+-- content/docs/_content.gotmpl --
+{{ .EnableAllLanguages }}
+{{ $titleFromStore := .Store.Get "title" }}
+{{ if not $titleFromStore }}
+	{{ $titleFromStore = "notfound"}}
+	{{ .Store.Set "title" site.Title }}
+{{ end }}
+{{ $title := printf "%s:%s:%s" site.Title (i18n "title") $titleFromStore }}
+{{ $.AddPage  (dict "kind" "page" "path" "p1" "title" $title ) }}
+--  layouts/_default/single.html --
+Single: {{ .Title }}|{{ .Content }}|
+
+`
+
+	for _, disable := range []bool{false, true} {
+		t.Run(fmt.Sprintf("disable=%t", disable), func(t *testing.T) {
+			b := hugolib.Test(t, strings.ReplaceAll(filesTemplate, "DISABLE", fmt.Sprintf("%t", disable)))
+			b.AssertFileExists("public/fr/docs/p1/index.html", !disable)
+			if !disable {
+				b.AssertFileContent("public/en/docs/p1/index.html", "Single: Title:Title:notfound||")
+				b.AssertFileContent("public/fr/docs/p1/index.html", "Single: Titre:Titre:Title||")
+			}
+		})
+	}
+}
+
+func TestPagesFromGoTmplMarkdownify(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+-- layouts/_default/single.html --
+|Content: {{ .Content }}|Title: {{ .Title }}|Path: {{ .Path }}|
+-- content/docs/_content.gotmpl --
+{{ $content := "**Hello World**" | markdownify }}
+{{ $.AddPage (dict "path" "p1" "content" (dict "value" $content "mediaType" "text/html" )) }}
+`
+
+	b, err := hugolib.TestE(t, files)
+
+	// This currently fails. We should fix this, but that is not a trivial task, so do it later.
+	b.Assert(err, qt.IsNotNil)
+	b.Assert(err.Error(), qt.Contains, "error calling markdownify: this method cannot be called before the site is fully initialized")
+}
+
+func TestPagesFromGoTmplResourceWithoutExtensionWithMediaTypeProvided(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+-- layouts/_default/single.html --
+|Content: {{ .Content }}|Title: {{ .Title }}|Path: {{ .Path }}|
+{{ range .Resources }}
+|RelPermalink: {{ .RelPermalink }}|Name: {{ .Name }}|Title: {{ .Title }}|Params: {{ .Params }}|MediaType: {{ .MediaType }}|
+{{ end }}
+-- content/docs/_content.gotmpl --
+{{ $.AddPage (dict "path" "p1" "content" (dict "value" "**Hello World**" "mediaType" "text/markdown" )) }}
+{{ $.AddResource (dict "path" "p1/myresource" "content" (dict "value" "abcde" "mediaType" "text/plain" )) }}
+`
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/docs/p1/index.html", "RelPermalink: /docs/p1/myresource|Name: myresource|Title: myresource|Params: map[]|MediaType: text/plain|")
+}
+
+func TestPagesFromGoTmplCascade(t *testing.T) {
+	t.Parallel()
+
+	files := ` 
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+-- layouts/_default/single.html --
+|Content: {{ .Content }}|Title: {{ .Title }}|Path: {{ .Path }}|Params: {{ .Params }}|
+-- content/_content.gotmpl --
+{{ $cascade := dict "params" (dict "cascadeparam1" "cascadeparam1value" ) }}
+{{ $.AddPage (dict "path" "docs" "kind" "section" "cascade" $cascade ) }}
+{{ $.AddPage (dict "path" "docs/p1" "content" (dict "value" "**Hello World**" "mediaType" "text/markdown" )) }}
+
+`
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/docs/p1/index.html", "|Path: /docs/p1|Params: map[cascadeparam1:cascadeparam1value")
+}
+
+func TestPagesFromGoBuildOptions(t *testing.T) {
+	t.Parallel()
+
+	files := ` 
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+baseURL = "https://example.com"
+-- layouts/_default/single.html --
+|Content: {{ .Content }}|Title: {{ .Title }}|Path: {{ .Path }}|Params: {{ .Params }}|
+-- content/_content.gotmpl --
+{{ $.AddPage (dict "path" "docs/p1" "content" (dict "value" "**Hello World**" "mediaType" "text/markdown" )) }}
+{{ $never := dict "list" "never"  "publishResources" false "render" "never"  }}
+{{ $.AddPage (dict "path" "docs/p2" "content" (dict "value" "**Hello World**" "mediaType" "text/markdown" ) "build" $never ) }}
+
+
+`
+	b := hugolib.Test(t, files)
+
+	b.AssertFileExists("public/docs/p1/index.html", true)
+	b.AssertFileExists("public/docs/p2/index.html", false)
+}
+
+func TestPagesFromGoPathsWithDotsIssue12493(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['home','section','rss','sitemap','taxonomy','term']
+-- content/_content.gotmpl --
+{{ .AddPage (dict "path" "s-1.2.3/p-4.5.6" "title" "p-4.5.6") }}
+-- layouts/_default/single.html --
+{{ .Title }}
+`
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileExists("public/s-1.2.3/p-4.5.6/index.html", true)
+}
+
+func TestPagesFromGoParamsIssue12497(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['home','section','rss','sitemap','taxonomy','term']
+-- content/_content.gotmpl --
+{{ .AddPage (dict "path" "p1" "title" "p1" "params" (dict "paraM1" "param1v" )) }}
+{{ .AddResource (dict "path" "p1/data1.yaml" "content" (dict "value" "data1" ) "params" (dict "paraM1" "param1v" )) }}
+-- layouts/_default/single.html --
+{{ .Title }}|{{ .Params.paraM1 }}
+{{ range .Resources }}
+{{ .Name }}|{{ .Params.paraM1 }}
+{{ end }}
+`
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/p1/index.html",
+		"p1|param1v",
+		"data1.yaml|param1v",
+	)
+}
+
+func TestPagesFromGoTmplPathWarningsPathPage(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+disableKinds = ['home','section','rss','sitemap','taxonomy','term']
+printPathWarnings = true
+-- content/_content.gotmpl --
+{{ .AddPage (dict "path" "p1" "title" "p1" ) }}
+{{ .AddPage (dict "path" "p2" "title" "p2" ) }}
+-- content/p1.md --
+---
+title: "p1"
+---
+-- layouts/_default/single.html --
+{{ .Title }}|
+`
+
+	b := hugolib.Test(t, files, hugolib.TestOptWarn())
+
+	b.AssertFileContent("public/p1/index.html", "p1|")
+
+	b.AssertLogContains("Duplicate content path")
+
+	files = strings.ReplaceAll(files, `"path" "p1"`, `"path" "p1new"`)
+
+	b = hugolib.Test(t, files, hugolib.TestOptWarn())
+
+	b.AssertLogNotContains("WARN")
+}
+
+func TestPagesFromGoTmplPathWarningsPathResource(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+disableKinds = ['home','section','rss','sitemap','taxonomy','term']
+printPathWarnings = true
+-- content/_content.gotmpl --
+{{ .AddResource (dict "path" "p1/data1.yaml" "content" (dict "value" "data1" ) ) }}
+{{ .AddResource (dict "path" "p1/data2.yaml" "content" (dict "value" "data2" ) ) }}
+
+-- content/p1/index.md --
+---
+title: "p1"
+---
+-- content/p1/data1.yaml --
+value: data1
+-- layouts/_default/single.html --
+{{ .Title }}|
+`
+
+	b := hugolib.Test(t, files, hugolib.TestOptWarn())
+
+	b.AssertFileContent("public/p1/index.html", "p1|")
+
+	b.AssertLogContains("Duplicate resource path")
+
+	files = strings.ReplaceAll(files, `"path" "p1/data1.yaml"`, `"path" "p1/data1new.yaml"`)
+
+	b = hugolib.Test(t, files, hugolib.TestOptWarn())
+
+	b.AssertLogNotContains("WARN")
+}
+
+func TestPagesFromGoTmplShortcodeNoPreceddingCharacterIssue12544(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['home','rss','section','sitemap','taxonomy','term']
+-- content/_content.gotmpl --
+{{ $content := dict "mediaType" "text/html" "value" "x{{< sc >}}" }}
+{{ .AddPage (dict "content" $content "path" "a") }}
+
+{{ $content := dict "mediaType" "text/html" "value" "{{< sc >}}" }}
+{{ .AddPage (dict "content" $content "path" "b") }}
+-- layouts/_default/single.html --
+|{{ .Content }}|
+-- layouts/shortcodes/sc.html --
+foo
+{{- /**/ -}}
+`
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/a/index.html", "|xfoo|")
+	b.AssertFileContent("public/b/index.html", "|foo|") // fails
+}
+
+func TestPagesFromGoTmplMenus(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['rss','section','sitemap','taxonomy','term']
+
+[menus]
+[[menus.main]]
+name = "Main"
+[[menus.footer]]
+name = "Footer"
+-- content/_content.gotmpl --
+{{ .AddPage (dict "path" "p1" "title" "p1" "menus" "main" ) }}
+{{ .AddPage (dict "path" "p2" "title" "p2" "menus" (slice "main" "footer")) }}
+-- layouts/index.html --
+Main: {{ range index site.Menus.main }}{{ .Name }}|{{ end }}|
+Footer: {{ range index site.Menus.footer }}{{ .Name }}|{{ end }}|
+
+`
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/index.html",
+		"Main: Main|p1|p2||",
+		"Footer: Footer|p2||",
+	)
+}
+
+func TestPagesFromGoTmplMore(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['home','rss','section','sitemap','taxonomy','term']
+[markup.goldmark.renderer]
+unsafe = true
+-- content/s1/_content.gotmpl --
+{{ $page := dict
+	"content" (dict "mediaType" "text/markdown" "value" "aaa <!--more--> bbb")
+	"title" "p1"
+	"path" "p1"
+  }}
+  {{ .AddPage $page }}
+-- layouts/_default/single.html --
+summary: {{ .Summary }}|content: {{ .Content}}
+`
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/s1/p1/index.html",
+		"<p>aaa</p>|content: <p>aaa</p>\n<p>bbb</p>",
+	)
+}
@@ -0,0 +1,32 @@
+// Copyright 2024 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pagesfromdata
+
+import "testing"
+
+func BenchmarkHash(b *testing.B) {
+	m := map[string]any{
+		"foo":         "bar",
+		"bar":         "foo",
+		"stringSlice": []any{"a", "b", "c"},
+		"intSlice":    []any{1, 2, 3},
+		"largeText":   "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante hendrerit.",
+	}
+
+	bs := BuildState{}
+
+	for i := 0; i < b.N; i++ {
+		bs.hash(m)
+	}
+}
@@ -11,6 +11,7 @@ import (
 	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/common/types"
 	"github.com/gohugoio/hugo/htesting"
+	"github.com/gohugoio/hugo/markup/asciidocext"
 	"github.com/gohugoio/hugo/resources/resource_transformers/tocss/dartsass"
 	"github.com/gohugoio/hugo/resources/resource_transformers/tocss/scss"
 )
@@ -52,6 +53,11 @@ title: "Home"
 Home Content.
 -- content/hometext.txt --
 Home Text Content.
+-- content/myothersection/myothersectionpage.md --
+---
+title: "myothersectionpage"
+---
+myothersectionpage Content.
 -- layouts/_default/single.html --
 Single: {{ .Title }}|{{ .Content }}$
 Resources: {{ range $i, $e := .Resources }}{{ $i }}:{{ .RelPermalink }}|{{ .Content }}|{{ end }}$
@@ -120,14 +126,23 @@ func TestRebuildEditTextFileInBranchBundle(t *testing.T) {
 	b.AssertRenderCountContent(1)
 }

-func TestRebuildRenameTextFileInLeafBundle(t *testing.T) {
-	b := TestRunning(t, rebuildFilesSimple)
-	b.AssertFileContent("public/mysection/mysectionbundle/index.html", "My Section Bundle Text 2 Content.", "Len Resources: 2|")
+func testRebuildBothWatchingAndRunning(t *testing.T, files string, withB func(b *IntegrationTestBuilder)) {
+	t.Helper()
+	for _, opt := range []TestOpt{TestOptWatching(), TestOptRunning()} {
+		b := Test(t, files, opt)
+		withB(b)
+	}
+}

-	b.RenameFile("content/mysection/mysectionbundle/mysectionbundletext.txt", "content/mysection/mysectionbundle/mysectionbundletext2.txt").Build()
-	b.AssertFileContent("public/mysection/mysectionbundle/index.html", "mysectionbundletext2", "My Section Bundle Text 2 Content.", "Len Resources: 2|")
-	b.AssertRenderCountPage(3)
-	b.AssertRenderCountContent(3)
+func TestRebuildRenameTextFileInLeafBundle(t *testing.T) {
+	testRebuildBothWatchingAndRunning(t, rebuildFilesSimple, func(b *IntegrationTestBuilder) {
+		b.AssertFileContent("public/mysection/mysectionbundle/index.html", "My Section Bundle Text 2 Content.", "Len Resources: 2|")
+
+		b.RenameFile("content/mysection/mysectionbundle/mysectionbundletext.txt", "content/mysection/mysectionbundle/mysectionbundletext2.txt").Build()
+		b.AssertFileContent("public/mysection/mysectionbundle/index.html", "mysectionbundletext2", "My Section Bundle Text 2 Content.", "Len Resources: 2|")
+		b.AssertRenderCountPage(5)
+		b.AssertRenderCountContent(6)
+	})
 }

 func TestRebuilEditContentFileInLeafBundle(t *testing.T) {
@@ -137,6 +152,19 @@ func TestRebuilEditContentFileInLeafBundle(t *testing.T) {
 	b.AssertFileContent("public/mysection/mysectionbundle/index.html", "My Section Bundle Content Content Edited.")
 }

+func TestRebuilEditContentFileThenAnother(t *testing.T) {
+	b := TestRunning(t, rebuildFilesSimple)
+	b.EditFileReplaceAll("content/mysection/mysectionbundle/mysectionbundlecontent.md", "Content Content.", "Content Content Edited.").Build()
+	b.AssertFileContent("public/mysection/mysectionbundle/index.html", "My Section Bundle Content Content Edited.")
+	b.AssertRenderCountPage(1)
+	b.AssertRenderCountContent(2)
+
+	b.EditFileReplaceAll("content/myothersection/myothersectionpage.md", "myothersectionpage Content.", "myothersectionpage Content Edited.").Build()
+	b.AssertFileContent("public/myothersection/myothersectionpage/index.html", "myothersectionpage Content Edited")
+	b.AssertRenderCountPage(1)
+	b.AssertRenderCountContent(1)
+}
+
 func TestRebuildRenameTextFileInBranchBundle(t *testing.T) {
 	b := TestRunning(t, rebuildFilesSimple)
 	b.AssertFileContent("public/mysection/index.html", "My Section")
@@ -153,7 +181,7 @@ func TestRebuildRenameTextFileInHomeBundle(t *testing.T) {

 	b.RenameFile("content/hometext.txt", "content/hometext2.txt").Build()
 	b.AssertFileContent("public/index.html", "hometext2", "Home Text Content.")
-	b.AssertRenderCountPage(2)
+	b.AssertRenderCountPage(3)
 }

 func TestRebuildRenameDirectoryWithLeafBundle(t *testing.T) {
@@ -169,7 +197,7 @@ func TestRebuildRenameDirectoryWithBranchBundle(t *testing.T) {
 	b.AssertFileContent("public/mysectionrenamed/index.html", "My Section")
 	b.AssertFileContent("public/mysectionrenamed/mysectionbundle/index.html", "My Section Bundle")
 	b.AssertFileContent("public/mysectionrenamed/mysectionbundle/mysectionbundletext.txt", "My Section Bundle Text 2 Content.")
-	b.AssertRenderCountPage(2)
+	b.AssertRenderCountPage(3)
 }

 func TestRebuildRenameDirectoryWithRegularPageUsedInHome(t *testing.T) {
@@ -268,7 +296,7 @@ func TestRebuildRenameDirectoryWithBranchBundleFastRender(t *testing.T) {
 	b.AssertFileContent("public/mysectionrenamed/index.html", "My Section")
 	b.AssertFileContent("public/mysectionrenamed/mysectionbundle/index.html", "My Section Bundle")
 	b.AssertFileContent("public/mysectionrenamed/mysectionbundle/mysectionbundletext.txt", "My Section Bundle Text 2 Content.")
-	b.AssertRenderCountPage(2)
+	b.AssertRenderCountPage(3)
 }

 func TestRebuilErrorRecovery(t *testing.T) {
@@ -366,8 +394,6 @@ My short.
 }

 func TestRebuildBaseof(t *testing.T) {
-	t.Parallel()
-
 	files := `
 -- hugo.toml --
 title = "Hugo Site"
@@ -382,12 +408,13 @@ Baseof: {{ .Title }}|
 Home: {{ .Title }}|{{ .Content }}|
 {{ end }}
 `
-	b := Test(t, files, TestOptRunning())
-	b.AssertFileContent("public/index.html", "Baseof: Hugo Site|", "Home: Hugo Site||")
-	b.EditFileReplaceFunc("layouts/_default/baseof.html", func(s string) string {
-		return strings.Replace(s, "Baseof", "Baseof Edited", 1)
-	}).Build()
-	b.AssertFileContent("public/index.html", "Baseof Edited: Hugo Site|", "Home: Hugo Site||")
+	testRebuildBothWatchingAndRunning(t, files, func(b *IntegrationTestBuilder) {
+		b.AssertFileContent("public/index.html", "Baseof: Hugo Site|", "Home: Hugo Site||")
+		b.EditFileReplaceFunc("layouts/_default/baseof.html", func(s string) string {
+			return strings.Replace(s, "Baseof", "Baseof Edited", 1)
+		}).Build()
+		b.AssertFileContent("public/index.html", "Baseof Edited: Hugo Site|", "Home: Hugo Site||")
+	})
 }

 func TestRebuildSingleWithBaseof(t *testing.T) {
@@ -1514,3 +1541,103 @@ MyTemplate: {{ partial "MyTemplate.html" . }}|

 	b.AssertFileContent("public/index.html", "MyTemplate: MyTemplate Edited")
 }
+
+func TestRebuildEditAsciidocContentFile(t *testing.T) {
+	if !asciidocext.Supports() {
+		t.Skip("skip asciidoc")
+	}
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+disableLiveReload = true
+disableKinds = ["taxonomy", "term", "sitemap", "robotsTXT", "404", "rss", "home", "section"]
+[security]
+[security.exec]
+allow = ['^python$', '^rst2html.*', '^asciidoctor$']
+-- content/posts/p1.adoc --
+---
+title: "P1"
+---
+P1 Content.
+-- content/posts/p2.adoc --
+---
+title: "P2"
+---
+P2 Content.
+-- layouts/_default/single.html --
+Single: {{ .Title }}|{{ .Content }}|
+`
+	b := TestRunning(t, files)
+	b.AssertFileContent("public/posts/p1/index.html",
+		"Single: P1|<div class=\"paragraph\">\n<p>P1 Content.</p>\n</div>\n|")
+	b.AssertRenderCountPage(2)
+	b.AssertRenderCountContent(2)
+
+	b.EditFileReplaceAll("content/posts/p1.adoc", "P1 Content.", "P1 Content Edited.").Build()
+
+	b.AssertFileContent("public/posts/p1/index.html", "Single: P1|<div class=\"paragraph\">\n<p>P1 Content Edited.</p>\n</div>\n|")
+	b.AssertRenderCountPage(1)
+	b.AssertRenderCountContent(1)
+}
+
+func TestRebuildEditSingleListChangeUbuntuIssue12362(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ['rss','section','sitemap','taxonomy','term']
+disableLiveReload = true
+-- layouts/_default/list.html --
+{{ range .Pages }}{{ .Title }}|{{ end }}
+-- layouts/_default/single.html --
+{{ .Title }}
+-- content/p1.md --
+---
+title: p1
+---
+`
+
+	b := TestRunning(t, files)
+	b.AssertFileContent("public/index.html", "p1|")
+
+	b.AddFiles("content/p2.md", "---\ntitle: p2\n---").Build()
+	b.AssertFileContent("public/index.html", "p1|p2|") // this test passes, which doesn't match reality
+}
+
+func TestRebuildHomeThenPageIssue12436(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+baseURL = "https://example.com"
+disableKinds = ['sitemap','taxonomy','term']
+disableLiveReload = true
+-- layouts/_default/list.html --
+{{ .Content }}
+-- layouts/_default/single.html --
+{{ .Content }}
+-- content/_index.md --
+---
+title: home
+---
+home-content|
+-- content/p1/index.md --
+---
+title: p1
+---
+p1-content|
+`
+
+	b := TestRunning(t, files)
+
+	b.AssertFileContent("public/index.html", "home-content|")
+	b.AssertFileContent("public/p1/index.html", "p1-content|")
+	b.AssertRenderCountPage(3)
+
+	b.EditFileReplaceAll("content/_index.md", "home-content", "home-content-foo").Build()
+	b.AssertFileContent("public/index.html", "home-content-foo")
+	b.AssertRenderCountPage(2) // Home page rss + html
+
+	b.EditFileReplaceAll("content/p1/index.md", "p1-content", "p1-content-foo").Build()
+	b.AssertFileContent("public/p1/index.html", "p1-content-foo")
+}
@@ -200,3 +200,136 @@ Myshort Original.
 	b.Build()
 	b.AssertFileContent("public/p1/index.html", "Edited")
 }
+
+func TestRenderShortcodesEditSectionContentWithShortcodeInIncludedPageIssue12458(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableLiveReload = true
+disableKinds = ["home", "taxonomy", "term", "rss", "sitemap", "robotsTXT", "404"]
+-- content/mysection/_index.md --
+---
+title: "My Section"
+---
+## p1-h1
+{{% include "p2" %}}
+-- content/mysection/p2.md --
+---
+title: "p2"
+---
+### Original
+{{% myshort %}}
+-- layouts/shortcodes/include.html --
+{{ $p := .Page.GetPage (.Get 0) }}
+{{ $p.RenderShortcodes }}
+-- layouts/shortcodes/myshort.html --
+Myshort Original.
+-- layouts/_default/list.html --
+ {{ .Content }}
+
+
+
+`
+	b := TestRunning(t, files)
+
+	b.AssertFileContent("public/mysection/index.html", "p1-h1")
+	b.EditFileReplaceAll("content/mysection/_index.md", "p1-h1", "p1-h1 Edited").Build()
+	b.AssertFileContent("public/mysection/index.html", "p1-h1 Edited")
+}
+
+func TestRenderShortcodesNestedPageContextIssue12356(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+disableKinds = ["taxonomy", "term", "rss", "sitemap", "robotsTXT", "404"]
+-- layouts/_default/_markup/render-image.html --
+{{- with .PageInner.Resources.Get .Destination -}}Image: {{ .RelPermalink }}|{{- end -}}
+-- layouts/_default/_markup/render-link.html --
+{{- with .PageInner.GetPage .Destination -}}Link: {{ .RelPermalink }}|{{- end -}}
+-- layouts/_default/_markup/render-heading.html --
+Heading: {{ .PageInner.Title }}: {{ .PlainText }}|
+-- layouts/_default/_markup/render-codeblock.html --
+CodeBlock: {{ .PageInner.Title }}: {{ .Type }}|
+-- layouts/_default/list.html --
+Content:{{ .Content }}|
+Fragments: {{ with .Fragments }}{{.Identifiers }}{{ end }}|
+-- layouts/_default/single.html --
+Content:{{ .Content }}|
+-- layouts/shortcodes/include.html --
+{{ with site.GetPage (.Get 0) }}
+  {{ .RenderShortcodes }}
+{{ end }}
+-- content/markdown/_index.md --
+---
+title: "Markdown"
+---
+# H1
+|{{% include "/posts/p1" %}}|
+![kitten](pixel3.png "Pixel 3")
+
+§§§go
+fmt.Println("Hello")
+§§§
+
+-- content/markdown2/_index.md --
+---
+title: "Markdown 2"
+---
+|{{< include "/posts/p1" >}}|
+-- content/html/_index.html --
+---
+title: "HTML"
+---
+|{{% include "/posts/p1" %}}|
+
+-- content/posts/p1/index.md --
+---
+title: "p1"
+---
+## H2-p1
+![kitten](pixel1.png "Pixel 1")
+![kitten](pixel2.png "Pixel 2")
+[p2](p2)
+
+§§§bash
+echo "Hello"
+§§§
+
+-- content/posts/p2/index.md --
+---
+title: "p2"
+---
+-- content/posts/p1/pixel1.png --
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
+-- content/posts/p1/pixel2.png --
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
+-- content/markdown/pixel3.png --
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
+-- content/html/pixel4.png --
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==
+
+`
+
+	b := Test(t, files)
+
+	b.AssertFileContent("public/markdown/index.html",
+		// Images.
+		"Image: /posts/p1/pixel1.png|\nImage: /posts/p1/pixel2.png|\n|\nImage: /markdown/pixel3.png|</p>\n|",
+		// Links.
+		"Link: /posts/p2/|",
+		// Code blocks
+		"CodeBlock: p1: bash|", "CodeBlock: Markdown: go|",
+		// Headings.
+		"Heading: Markdown: H1|", "Heading: p1: H2-p1|",
+		// Fragments.
+		"Fragments: [h1 h2-p1]|",
+		// Check that the special context markup is not rendered.
+		"! hugo_ctx",
+	)
+
+	b.AssertFileContent("public/markdown2/index.html", "! hugo_ctx", "Content:<p>|\n  ![kitten](pixel1.png \"Pixel 1\")\n![kitten](pixel2.png \"Pixel 2\")\n|</p>\n|")
+
+	b.AssertFileContent("public/html/index.html", "! hugo_ctx")
+}
@@ -321,10 +321,16 @@ func prepareShortcode(

 	// Allow the caller to delay the rendering of the shortcode if needed.
 	var fn shortcodeRenderFunc = func(ctx context.Context) ([]byte, bool, error) {
+		if p.m.pageConfig.ContentMediaType.IsMarkdown() && sc.doMarkup {
+			// Signal downwards that the content rendered will be
+			// parsed and rendered by Goldmark.
+			ctx = tpl.Context.IsInGoldmark.Set(ctx, true)
+		}
 		r, err := doRenderShortcode(ctx, level, s, tplVariants, sc, parent, p, isRenderString)
 		if err != nil {
 			return nil, false, toParseErr(err)
 		}
+
 		b, hasVariants, err := r.renderShortcode(ctx)
 		if err != nil {
 			return nil, false, toParseErr(err)
@@ -443,7 +449,7 @@ func doRenderShortcode(
 			//     unchanged.
 			// 2   If inner does not have a newline, strip the wrapping <p> block and
 			//     the newline.
-			switch p.m.pageConfig.Markup {
+			switch p.m.pageConfig.Content.Markup {
 			case "", "markdown":
 				if match, _ := regexp.MatchString(innerNewlineRegexp, inner); !match {
 					cleaner, err := regexp.Compile(innerCleanupRegexp)
@@ -62,6 +62,7 @@ import (
 )

 func (s *Site) Taxonomies() page.TaxonomyList {
+	s.checkReady()
 	s.init.taxonomies.Do(context.Background())
 	return s.taxonomies
 }
@@ -204,6 +205,7 @@ type siteRenderingContext struct {
 }

 func (s *Site) Menus() navigation.Menus {
+	s.checkReady()
 	s.init.menus.Do(context.Background())
 	return s.menus
 }
@@ -369,29 +371,51 @@ func (s *Site) watching() bool {
 	return s.h != nil && s.h.Configs.Base.Internal.Watch
 }

-type whatChanged struct {
+type WhatChanged struct {
 	mu sync.Mutex

-	contentChanged bool
-	identitySet    identity.Identities
+	needsPagesAssembly bool
+	identitySet        identity.Identities
 }

-func (w *whatChanged) Add(ids ...identity.Identity) {
+func (w *WhatChanged) Add(ids ...identity.Identity) {
 	w.mu.Lock()
 	defer w.mu.Unlock()

+	if w.identitySet == nil {
+		w.identitySet = make(identity.Identities)
+	}
+
 	for _, id := range ids {
 		w.identitySet[id] = true
 	}
 }

-func (w *whatChanged) Changes() []identity.Identity {
+func (w *WhatChanged) Clear() {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.clear()
+}
+
+func (w *WhatChanged) clear() {
+	w.identitySet = identity.Identities{}
+}
+
+func (w *WhatChanged) Changes() []identity.Identity {
 	if w == nil || w.identitySet == nil {
 		return nil
 	}
 	return w.identitySet.AsSlice()
 }

+func (w *WhatChanged) Drain() []identity.Identity {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	ids := w.identitySet.AsSlice()
+	w.clear()
+	return ids
+}
+
 // RegisterMediaTypes will register the Site's media types in the mime
 // package, so it will behave correctly with Hugo's built-in server.
 func (s *Site) RegisterMediaTypes() {
@@ -424,7 +448,35 @@ func (h *HugoSites) fileEventsFilter(events []fsnotify.Event) []fsnotify.Event {
 		events[n] = ev
 		n++
 	}
-	return events[:n]
+	events = events[:n]
+
+	eventOrdinal := func(e fsnotify.Event) int {
+		// Pull the structural changes to the top.
+		if e.Op.Has(fsnotify.Create) {
+			return 1
+		}
+		if e.Op.Has(fsnotify.Remove) {
+			return 2
+		}
+		if e.Op.Has(fsnotify.Rename) {
+			return 3
+		}
+		if e.Op.Has(fsnotify.Write) {
+			return 4
+		}
+		return 5
+	}
+
+	sort.Slice(events, func(i, j int) bool {
+		// First sort by event type.
+		if eventOrdinal(events[i]) != eventOrdinal(events[j]) {
+			return eventOrdinal(events[i]) < eventOrdinal(events[j])
+		}
+		// Then sort by name.
+		return events[i].Name < events[j].Name
+	})
+
+	return events
 }

 type fileEventInfo struct {
@@ -494,41 +546,17 @@ func (h *HugoSites) fileEventsApplyInfo(events []fsnotify.Event) []fileEventInfo
 	return infos
 }

-func (h *HugoSites) fileEventsTranslate(events []fsnotify.Event) []fsnotify.Event {
-	eventMap := make(map[string][]fsnotify.Event)
-
-	// We often get a Remove etc. followed by a Create, a Create followed by a Write.
-	// Remove the superfluous events to make the update logic simpler.
-	for _, ev := range events {
-		eventMap[ev.Name] = append(eventMap[ev.Name], ev)
-	}
-
+func (h *HugoSites) fileEventsTrim(events []fsnotify.Event) []fsnotify.Event {
+	seen := make(map[string]bool)
 	n := 0
 	for _, ev := range events {
-		mapped := eventMap[ev.Name]
-
-		// Keep one
-		found := false
-		var kept fsnotify.Event
-		for i, ev2 := range mapped {
-			if i == 0 {
-				kept = ev2
-			}
-
-			if ev2.Op&fsnotify.Write == fsnotify.Write {
-				kept = ev2
-				found = true
-			}
-
-			if !found && ev2.Op&fsnotify.Create == fsnotify.Create {
-				kept = ev2
-			}
+		if seen[ev.Name] {
+			continue
 		}
-
-		events[n] = kept
+		seen[ev.Name] = true
+		events[n] = ev
 		n++
 	}
-
 	return events
 }

@@ -655,11 +683,16 @@ func (s *Site) assembleMenus() error {

 	if sectionPagesMenu != "" {
 		if err := s.pageMap.forEachPage(pagePredicates.ShouldListGlobal, func(p *pageState) (bool, error) {
-			if p.IsHome() || !p.m.shouldBeCheckedForMenuDefinitions() {
+			if p.Kind() != kinds.KindSection || !p.m.shouldBeCheckedForMenuDefinitions() {
 				return false, nil
 			}
+
 			// The section pages menus are attached to the top level section.
 			id := p.Section()
+			if id == "" {
+				id = "/"
+			}
+
 			if _, ok := flat[twoD{sectionPagesMenu, id}]; ok {
 				return false, nil
 			}
@@ -671,6 +704,7 @@ func (s *Site) assembleMenus() error {
 				},
 				Page: p,
 			}
+
 			navigation.SetPageValues(&me, p)
 			flat[twoD{sectionPagesMenu, me.KeyName()}] = &me
 			return false, nil
@@ -678,6 +712,7 @@ func (s *Site) assembleMenus() error {
 			return err
 		}
 	}
+
 	// Add menu entries provided by pages
 	if err := s.pageMap.forEachPage(pagePredicates.ShouldListGlobal, func(p *pageState) (bool, error) {
 		for name, me := range p.pageMenus.menus() {
@@ -775,6 +810,7 @@ func (s *Site) errorCollator(results <-chan error, errs chan<- error) {
 // as possible for existing sites. Most sites will use {{ .Site.GetPage "section" "my/section" }},
 // i.e. 2 arguments, so we test for that.
 func (s *Site) GetPage(ref ...string) (page.Page, error) {
+	s.checkReady()
 	p, err := s.s.getPageForRefs(ref...)

 	if p == nil {
@@ -32,6 +32,7 @@ import (
 	"github.com/gohugoio/hugo/config/allconfig"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/hugolib/doctree"
+	"github.com/gohugoio/hugo/hugolib/pagesfromdata"
 	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/langs"
 	"github.com/gohugoio/hugo/langs/i18n"
@@ -51,7 +52,15 @@ import (

 var _ page.Site = (*Site)(nil)

+type siteState int
+
+const (
+	siteStateInit siteState = iota
+	siteStateReady
+)
+
 type Site struct {
+	state     siteState
 	conf      *allconfig.Config
 	language  *langs.Language
 	languagei int
@@ -123,19 +132,32 @@ func NewHugoSites(cfg deps.DepsCfg) (*HugoSites, error) {
 			HandlerPost:        logHookLast,
 			Stdout:             cfg.LogOut,
 			Stderr:             cfg.LogOut,
-			StoreErrors:        conf.Running(),
+			StoreErrors:        conf.Watching(),
 			SuppressStatements: conf.IgnoredLogs(),
 		}
 		logger = loggers.New(logOpts)

 	}

-	memCache := dynacache.New(dynacache.Options{Running: conf.Running(), Log: logger})
+	memCache := dynacache.New(dynacache.Options{Watching: conf.Watching(), Log: logger})
+
+	var h *HugoSites
+	onSignalRebuild := func(ids ...identity.Identity) {
+		// This channel is buffered, but make sure we do this in a non-blocking way.
+		if cfg.ChangesFromBuild != nil {
+			go func() {
+				cfg.ChangesFromBuild <- ids
+			}()
+		}
+	}

 	firstSiteDeps := &deps.Deps{
-		Fs:                  cfg.Fs,
-		Log:                 logger,
-		Conf:                conf,
+		Fs:   cfg.Fs,
+		Log:  logger,
+		Conf: conf,
+		BuildState: &deps.BuildState{
+			OnSignalRebuild: onSignalRebuild,
+		},
 		MemCache:            memCache,
 		TemplateProvider:    tplimpl.DefaultTemplateProvider,
 		TranslationProvider: i18n.NewTranslationProvider(),
@@ -166,7 +188,8 @@ func NewHugoSites(cfg deps.DepsCfg) (*HugoSites, error) {
 		treeResources: doctree.New(
 			treeConfig,
 		),
-		treeTaxonomyEntries: doctree.NewTreeShiftTree[*weightedContentNode](doctree.DimensionLanguage.Index(), len(confm.Languages)),
+		treeTaxonomyEntries:           doctree.NewTreeShiftTree[*weightedContentNode](doctree.DimensionLanguage.Index(), len(confm.Languages)),
+		treePagesFromTemplateAdapters: doctree.NewTreeShiftTree[*pagesfromdata.PagesFromTemplate](doctree.DimensionLanguage.Index(), len(confm.Languages)),
 	}

 	pageTrees.createMutableTrees()
@@ -251,7 +274,8 @@ func NewHugoSites(cfg deps.DepsCfg) (*HugoSites, error) {
 		return li.Lang < lj.Lang
 	})

-	h, err := newHugoSites(cfg, firstSiteDeps, pageTrees, sites)
+	var err error
+	h, err = newHugoSites(cfg, firstSiteDeps, pageTrees, sites)
 	if err == nil && h == nil {
 		panic("hugo: newHugoSitesNew returned nil error and nil HugoSites")
 	}
@@ -415,6 +439,7 @@ func (s *Site) Current() page.Site {

 // MainSections returns the list of main sections.
 func (s *Site) MainSections() []string {
+	s.checkReady()
 	return s.conf.C.MainSections
 }

@@ -433,6 +458,7 @@ func (s *Site) BaseURL() string {

 // Deprecated: Use .Site.Lastmod instead.
 func (s *Site) LastChange() time.Time {
+	s.checkReady()
 	hugo.Deprecate(".Site.LastChange", "Use .Site.Lastmod instead.", "v0.123.0")
 	return s.lastmod
 }
@@ -449,7 +475,9 @@ func (s *Site) Params() maps.Params {

 // Deprecated: Use taxonomies instead.
 func (s *Site) Author() map[string]any {
-	hugo.Deprecate(".Site.Author", "Use taxonomies instead.", "v0.124.0")
+	if len(s.conf.Author) != 0 {
+		hugo.Deprecate(".Site.Author", "Use taxonomies instead.", "v0.124.0")
+	}
 	return s.conf.Author
 }

@@ -519,6 +547,7 @@ func (s *Site) ForEeachIdentityByName(name string, f func(identity.Identity) boo
 // Pages returns all pages.
 // This is for the current language only.
 func (s *Site) Pages() page.Pages {
+	s.checkReady()
 	return s.pageMap.getPagesInSection(
 		pageMapQueryPagesInSection{
 			pageMapQueryPagesBelowPath: pageMapQueryPagesBelowPath{
@@ -535,6 +564,7 @@ func (s *Site) Pages() page.Pages {
 // RegularPages returns all the regular pages.
 // This is for the current language only.
 func (s *Site) RegularPages() page.Pages {
+	s.checkReady()
 	return s.pageMap.getPagesInSection(
 		pageMapQueryPagesInSection{
 			pageMapQueryPagesBelowPath: pageMapQueryPagesBelowPath{
@@ -549,10 +579,18 @@ func (s *Site) RegularPages() page.Pages {

 // AllPages returns all pages for all sites.
 func (s *Site) AllPages() page.Pages {
+	s.checkReady()
 	return s.h.Pages()
 }

 // AllRegularPages returns all regular pages for all sites.
 func (s *Site) AllRegularPages() page.Pages {
+	s.checkReady()
 	return s.h.RegularPages()
 }
+
+func (s *Site) checkReady() {
+	if s.state != siteStateReady {
+		panic("this method cannot be called before the site is fully initialized")
+	}
+}
@@ -19,10 +19,12 @@ import (

 // Sections returns the top level sections.
 func (s *Site) Sections() page.Pages {
+	s.checkReady()
 	return s.Home().Sections()
 }

 // Home is a shortcut to the home page, equivalent to .Site.GetPage "home".
 func (s *Site) Home() page.Page {
+	s.checkReady()
 	return s.s.home
 }
@@ -108,11 +108,12 @@ outputs: [ "html", "amp" ]

 func TestParseSitemap(t *testing.T) {
 	t.Parallel()
-	expected := config.SitemapConfig{Priority: 3.0, Filename: "doo.xml", ChangeFreq: "3"}
+	expected := config.SitemapConfig{ChangeFreq: "3", Disable: true, Filename: "doo.xml", Priority: 3.0}
 	input := map[string]any{
 		"changefreq": "3",
-		"priority":   3.0,
+		"disable":    true,
 		"filename":   "doo.xml",
+		"priority":   3.0,
 		"unknown":    "ignore",
 	}
 	result, err := config.DecodeSitemap(config.SitemapConfig{}, input)
@@ -258,7 +258,6 @@ id = "UA-ga_id"
 disable = false
 [privacy.googleAnalytics]
 respectDoNotTrack = true
-anonymizeIP = true
 [privacy.instagram]
 simple = true
 [privacy.twitter]
--- a/Show More
+++ b/Show More