chore: incidental working-tree changes (starter kit 18.0.0-rc, regenerated lockfile/mock worker)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
feat(visual-editor): framework-emit empty-block add-content affordance
2026-06-12 14:48:17 +01:00 · 2026-06-12 14:48:05 +01:00 · 2026-06-12 11:00:07 +01:00 · 2026-06-12 10:46:26 +01:00 · 2026-06-12 10:42:16 +01:00 · 2026-06-12 10:26:50 +01:00
607 changed files with 25609 additions and 5568 deletions
@@ -70,18 +70,6 @@ trim_trailing_whitespace = true
 [*.less]
 trim_trailing_whitespace = false

-##########################################
-# File Header (Uncomment to support file headers)
-# https://docs.microsoft.com/visualstudio/ide/reference/add-file-header
-##########################################
-
-# [*.{cs,csx,cake,vb,vbx}]
-file_header_template = Copyright (c) Umbraco.\nSee LICENSE for more details.
-
-# SA1636: File header copyright text should match
-# Justification: .editorconfig supports file headers. If this is changed to a value other than "none", a stylecop.json file will need to added to the project.
-# dotnet_diagnostic.SA1636.severity = none
-
 ##########################################
 # .NET Language Conventions
 # https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions
@@ -136,6 +124,10 @@ dotnet_code_quality_unused_parameters = all:warning
 dotnet_style_operator_placement_when_wrapping = end_of_line
 # https://github.com/dotnet/roslyn/pull/40070
 dotnet_style_prefer_simplified_interpolation = true:warning
+# File header preferences
+file_header_template = Copyright (c) Umbraco.\nSee LICENSE for more details.
+dotnet_diagnostic.SA1633.severity = none # Suppressed until we decide to enforce it
+dotnet_diagnostic.SA1636.severity = none # Suppressed since we are using StyleCop

 # C# Code Style Settings
 # https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-code-style-settings
@@ -7,7 +7,7 @@ body:
  id: "version"
  attributes:
    label: "Which Umbraco version are you using?"
-    description: "Please write the *exact* version, example: `10.1.0`. Use the help icon in the Umbraco backoffice to find the version you're using"
+    description: "Please write the *exact* version, example: `10.1.0`. Click the Umbraco logo in the top left corner of the backoffice to find the version you're using."
  validations:
    required: true
 - type: textarea
@@ -0,0 +1,81 @@
+name: "SonarQube Cloud - Analysis"
+
+# This workflow runs the full SonarCloud analysis with the SONAR_TOKEN secret.
+# It is skipped for fork PRs since secrets are not available in that context.
+
+on:
+  push:
+    branches:
+      - main
+      - "v*/dev"
+      - "v*/main"
+      - "release/*"
+  pull_request:
+    types: [opened, synchronize, reopened]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  SONAR_PROJECT_KEY: umbraco_Umbraco-CMS
+  SONAR_ORGANIZATION: umbraco
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  analyze:
+    name: Build and analyze
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork != true
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET from global.json
+        uses: actions/setup-dotnet@v5
+
+      - name: Cache SonarQube packages
+        uses: actions/cache@v5
+        with:
+          path: ~/.sonar/cache
+          key: ${{ runner.os }}-sonar
+          restore-keys: ${{ runner.os }}-sonar
+
+      - name: Install tools
+        run: |
+          dotnet tool install --global dotnet-sonarscanner
+          dotnet tool install --global dotnet-coverage
+
+      - name: Load sonar params
+        run: echo "SONARQUBE_SCANNER_PARAMS=$(jq -c . .github/workflows/sonarcloud/sonar-params.json)" >> $GITHUB_ENV
+
+      - name: Begin analysis
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        run: |
+          dotnet-sonarscanner begin \
+            /k:"$SONAR_PROJECT_KEY" \
+            /o:"$SONAR_ORGANIZATION" \
+            /d:sonar.token="$SONAR_TOKEN"
+
+      - name: Restore
+        run: dotnet restore umbraco.sln
+
+      - name: Build solution
+        run: GITHUB_ENV=/dev/null dotnet build umbraco.sln --no-restore -clp:ErrorsOnly # prevent sonar MSBuild integration from writing malformed values to $GITHUB_ENV
+
+      - name: Run unit tests with coverage
+        run: |
+          dotnet-coverage collect \
+            "dotnet test tests/Umbraco.Tests.UnitTests/Umbraco.Tests.UnitTests.csproj --no-build" \
+            --output TestResults/coverage.xml \
+            --output-format xml
+
+      - name: End analysis
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        run: dotnet-sonarscanner end /d:sonar.token="$SONAR_TOKEN"
@@ -0,0 +1,7 @@
+{
+  "sonar.cs.vscoveragexml.reportsPaths": "TestResults/coverage.xml",
+  "sonar.inclusions": "src/**,templates/**,tools/**,tests/**,.github/**,build/**",
+  "sonar.exclusions": "**/bin/**,**/obj/**,**/node_modules/**,**/lang/*.ts,**/mocks/**,**/wwwroot/**,**/dist-cms/**,**/*.generated.cs,src/Umbraco.Web.UI/umbraco/**,src/Umbraco.Cms.Persistence.EFCore.*/Migrations/**,src/Umbraco.Web.UI.Client/src/packages/core/backend-api/**,**/.nuget/**",
+  "sonar.test.inclusions": "tests/**,**/*.test.ts,**/*.spec.ts",
+  "sonar.typescript.tsconfigPaths": "src/Umbraco.Web.UI.Client/tsconfig.json,src/Umbraco.Web.UI.Client/tsconfig.node.json,src/Umbraco.Web.UI.Login/tsconfig.json"
+}
@@ -120,4 +120,8 @@ trace.zip
 /tests/Umbraco.Tests.Integration/appsettings-schema.*.json
 /tests/Umbraco.Tests.Integration/umbraco-package-schema.json
 /src/Umbraco.Cms/appsettings-schema.json
+.worktrees
 .playwright-mcp/
+
+# SonarQube local analysis cache
+.sonarqube/
@@ -48,7 +48,6 @@ dotnet_analyzer_diagnostic.category-StyleCop.CSharp.OrderingRules.severity = sug
 dotnet_analyzer_diagnostic.category-StyleCop.CSharp.MaintainabilityRules.severity = suggestion
 dotnet_analyzer_diagnostic.category-StyleCop.CSharp.LayoutRules.severity = suggestion

-dotnet_diagnostic.SA1636.severity = none # SA1636: File header copyright text should match
 dotnet_diagnostic.SA1101.severity = none # PrefixLocalCallsWithThis - stylecop appears to be ignoring dotnet_style_qualification_for_*
 dotnet_diagnostic.SA1309.severity = none # FieldNamesMustNotBeginWithUnderscore

@@ -448,6 +448,14 @@ When a PR changes Management API controllers or models, the `OpenApi.json` file

 The backoffice is published to npm as `@umbraco-cms/backoffice`. Runtime dependencies are provided via importmap; npm peerDependencies provide types only. For full details on dependency hoisting, version range logic, and plugin development, see `/src/Umbraco.Web.UI.Client/CLAUDE.md` → "npm Package Publishing".

+### SQL Server 2100-parameter limit
+
+Any `WHERE IN (@0, @1, ...)` built from a runtime-sized collection risks hitting SQL Server's 2100-parameter ceiling and throwing `SqlException` 8003 in production.
+
+Batch with `IEnumerable<T>.InGroupsOf(Constants.Sql.MaxParameterCount)` or `Database.FetchByGroups(...)` whenever the collection size is driven by user data — not just when it currently fits. Watch for products of two scaling dimensions (documents × languages, properties × versions) and config-tunable batch sizes whose defaults are safe but ceilings aren't.
+
+Full guidance, safe patterns and decision rule: see `/src/Umbraco.Infrastructure/CLAUDE.md` → "Avoiding the SQL Server 2100-parameter limit".
+
 ### Known Limitations

 1. **Circular Dependencies**: Avoided via `Lazy<T>` or event notifications
@@ -544,6 +552,14 @@ Allowed, but cheap to write and cheaper to leave behind. Keep them short and tra

 ---

+## 9. Testing Practices
+
+### Tests for a bug fix must fail before the fix
+
+Verify any test you add for a bug fix actually catches the bug: either write the failing test first (TDD), or temporarily revert the production change and confirm the test fails before re-applying. A test that passes both ways proves nothing. Watch for coincidental passes — default seed/sort orders can make a buggy path produce the right answer for the test's specific inputs; construct inputs so the broken and fixed behaviours give visibly different results.
+
+---
+
 ## Quick Reference

 ### Essential Commands
@@ -49,15 +49,15 @@
    <PackageVersion Include="Asp.Versioning.Mvc" Version="10.0.0" />
    <PackageVersion Include="Asp.Versioning.Mvc.ApiExplorer" Version="10.0.0" />
    <PackageVersion Include="Dazinator.Extensions.FileProviders" Version="2.0.0" />
-    <PackageVersion Include="Examine" Version="3.7.1" />
-    <PackageVersion Include="Examine.Core" Version="3.7.1" />
+    <PackageVersion Include="Examine" Version="3.8.0" />
+    <PackageVersion Include="Examine.Core" Version="3.8.0" />
    <PackageVersion Include="HtmlAgilityPack" Version="1.12.4" />
    <PackageVersion Include="JsonPatch.Net" Version="3.3.0" />
    <PackageVersion Include="K4os.Compression.LZ4" Version="1.3.8" />
    <PackageVersion Include="MailKit" Version="4.16.0" />
    <PackageVersion Include="Markdig" Version="1.1.3" />
    <PackageVersion Include="Markdown" Version="2.2.1" />
-    <PackageVersion Include="MessagePack" Version="3.1.7" />
+    <PackageVersion Include="MessagePack" Version="3.1.4" />
    <PackageVersion Include="MiniProfiler.AspNetCore.Mvc" Version="4.5.4" />
    <PackageVersion Include="MiniProfiler.Shared" Version="4.5.4" />
    <PackageVersion Include="ncrontab" Version="3.4.0" />
@@ -95,4 +95,4 @@
    <!-- TODO: Remove this pinned dependency when Examine updates its Microsoft.AspNetCore.DataProtection reference. -->
    <PackageVersion Include="System.Security.Cryptography.Xml" Version="10.0.7" />
  </ItemGroup>
-</Project>
+</Project>
@@ -45,7 +45,7 @@ parameters:
  - name: integrationNonReleaseTestFilter
    displayName: TestFilter used for non-release type builds
    type: string
-    default: "--filter TestCategory!=LongRunning&TestCategory!=NonCritical"
+    default: "TestCategory!=LongRunning&TestCategory!=NonCritical"
  - name: integrationReleaseTestFilter
    displayName: TestFilter used for release type builds
    type: string
@@ -53,7 +53,7 @@ parameters:
  - name: nonWindowsIntegrationNonReleaseTestFilter
    displayName: TestFilter used for non-release type builds on non Windows agents
    type: string
-    default: "--filter TestCategory!=LongRunning&TestCategory!=NonCritical"
+    default: "TestCategory!=LongRunning&TestCategory!=NonCritical"
  - name: nonWindowsIntegrationReleaseTestFilter
    displayName: TestFilter used for release type builds on non Windows agents
    type: string
@@ -455,13 +455,13 @@ stages:
              projects: "tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj"
              testRunTitle: Integration Tests SQLite - $(Agent.OS)
              ${{ if and(eq(variables['Agent.OS'],'Windows_NT'), or(variables.releaseTestFilter, parameters.forceReleaseTestFilter)) }}:
-                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build ${{parameters.integrationReleaseTestFilter}}'
+                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build'
              ${{ elseif eq(variables['Agent.OS'],'Windows_NT') }}:
-                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build ${{parameters.integrationNonReleaseTestFilter}}'
+                arguments: '--filter "$(testFilter) & ${{parameters.integrationNonReleaseTestFilter}}" --configuration $(buildConfiguration) --no-build'
              ${{ elseif or(variables.releaseTestFilter, parameters.forceReleaseTestFilter) }}:
-                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build ${{parameters.nonWindowsIntegrationReleaseTestFilter}}'
+                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build'
              ${{ else }}:
-                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build ${{parameters.nonWindowsIntegrationNonReleaseTestFilter}}'
+                arguments: '--filter "$(testFilter) & ${{parameters.nonWindowsIntegrationNonReleaseTestFilter}}" --configuration $(buildConfiguration) --no-build'
      # Integration Tests (SQL Server)
      - job:
        timeoutInMinutes: 180
@@ -569,13 +569,13 @@ stages:
              projects: "tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj"
              testRunTitle: Integration Tests SQL Server - $(Agent.OS)
              ${{ if and(eq(variables['Agent.OS'],'Windows_NT'), or(variables.releaseTestFilter, parameters.forceReleaseTestFilter)) }}:
-                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build ${{parameters.integrationReleaseTestFilter}}'
+                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build'
              ${{ elseif eq(variables['Agent.OS'],'Windows_NT') }}:
-                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build ${{parameters.integrationNonReleaseTestFilter}}'
+                arguments: '--filter "$(testFilter) & ${{parameters.integrationNonReleaseTestFilter}}" --configuration $(buildConfiguration) --no-build'
              ${{ elseif or(variables.releaseTestFilter, parameters.forceReleaseTestFilter) }}:
-                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build ${{parameters.nonWindowsIntegrationReleaseTestFilter}}'
+                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build'
              ${{ else }}:
-                arguments: '--filter "$(testFilter)" --configuration $(buildConfiguration) --no-build ${{parameters.nonWindowsIntegrationNonReleaseTestFilter}}'
+                arguments: '--filter "$(testFilter) & ${{parameters.nonWindowsIntegrationNonReleaseTestFilter}}" --configuration $(buildConfiguration) --no-build'

          # Stop SQL Server
          - pwsh: docker stop mssql
@@ -825,31 +825,74 @@ stages:
                publishFeedCredentials: "MyGet - Umbraco Nightly"
              ${{ else }}:
                publishFeedCredentials: "MyGet - Pre-releases"
-      # Pre-release/nightly feeds: keep the `latest` dist-tag default (no `next` split).
      - job:
        displayName: Push to pre-release feed (npm)
        steps:
-          - template: templates/npm-publish.yml
-            parameters:
-              artifactName: npm
+          - checkout: none
+          - download: current
+            artifact: npm
+          - bash: |
+              # Check if we are on a nightly build
+              if [ $isNightly = "False" ]; then
+                  echo "##[debug]Prerelease build detected"
+                  registry="https://www.myget.org/F/umbracoprereleases/npm/"
+              else
+                  echo "##[debug]Nightly build detected"
+                  registry="https://www.myget.org/F/umbraconightly/npm/"
+              fi
+              echo "@umbraco-cms:registry=$registry" >> .npmrc
+            env:
+              isNightly: ${{parameters.isNightly}}
+            workingDirectory: $(Pipeline.Workspace)/npm
+            displayName: Add scoped registry to .npmrc
+          - task: npmAuthenticate@0
+            displayName: Authenticate with npm (MyGet)
+            inputs:
+              workingFile: "$(Pipeline.Workspace)/npm/.npmrc"
              customEndpoint: "MyGet (npm) - Umbracoprereleases, MyGet (npm) - Umbraconightly"
-              displayName: Push to npm (MyGet)
-              ${{ if eq(parameters.isNightly, true) }}:
-                registry: https://www.myget.org/F/umbraconightly/npm/
-              ${{ else }}:
-                registry: https://www.myget.org/F/umbracoprereleases/npm/
+          - bash: |
+              # Setup temp npm project to load in defaults from the local .npmrc
+              npm init -y
+
+              # Find the first .tgz file in the current directory and publish it
+              files=( ./*.tgz )
+              npm publish "${files[0]}"
+            displayName: Push to npm (MyGet)
+            workingDirectory: $(Pipeline.Workspace)/npm
      - job: PublishTestHelpersNpm
        displayName: Push TestHelpers to pre-release feed (npm)
        steps:
-          - template: templates/npm-publish.yml
-            parameters:
-              artifactName: npm-testhelpers
+          - checkout: none
+          - download: current
+            artifact: npm-testhelpers
+          - bash: |
+              # Check if we are on a nightly build
+              if [ $isNightly = "False" ]; then
+                  echo "##[debug]Prerelease build detected"
+                  registry="https://www.myget.org/F/umbracoprereleases/npm/"
+              else
+                  echo "##[debug]Nightly build detected"
+                  registry="https://www.myget.org/F/umbraconightly/npm/"
+              fi
+              echo "@umbraco-cms:registry=$registry" >> .npmrc
+            env:
+              isNightly: ${{parameters.isNightly}}
+            workingDirectory: $(Pipeline.Workspace)/npm-testhelpers
+            displayName: Add scoped registry to .npmrc
+          - task: npmAuthenticate@0
+            displayName: Authenticate with npm (MyGet)
+            inputs:
+              workingFile: "$(Pipeline.Workspace)/npm-testhelpers/.npmrc"
              customEndpoint: "MyGet (npm) - Umbracoprereleases, MyGet (npm) - Umbraconightly"
-              displayName: Push test helpers to npm (MyGet)
-              ${{ if eq(parameters.isNightly, true) }}:
-                registry: https://www.myget.org/F/umbraconightly/npm/
-              ${{ else }}:
-                registry: https://www.myget.org/F/umbracoprereleases/npm/
+          - bash: |
+              # Setup temp npm project to load in defaults from the local .npmrc
+              npm init -y
+
+              # Find the first .tgz file in the current directory and publish it
+              files=( ./*.tgz )
+              npm publish "${files[0]}"
+            displayName: Push test helpers to npm (MyGet)
+            workingDirectory: $(Pipeline.Workspace)/npm-testhelpers

  - stage: Deploy_NuGet
    displayName: NuGet release
@@ -862,10 +905,10 @@ stages:
      - job: WaitForApproval
        displayName: Wait for manual approval
        pool: server
-        timeoutInMinutes: 4320 # 3 days
        steps:
          - task: ManualValidation@0
            displayName: Manual approval to push to NuGet
+            timeoutInMinutes: 4320 # 3 days
            inputs:
              notifyUsers: ''
              instructions: 'Approve to push the NuGet release.'
@@ -898,30 +941,53 @@ stages:
    condition: and(in(dependencies.Deploy_NuGet.result, 'Succeeded', 'SucceededWithIssues'), or(eq(dependencies.Build.outputs['A.build.NBGV_PublicRelease'], 'True'), ${{parameters.npmDeploy}}))
    dependsOn:
      - Deploy_NuGet
-    variables:
-      # `latest` for stable releases, `next` for prereleases.
-      npmDistTag: $[ iif(eq(stageDependencies.Build.A.outputs['build.NBGV_PrereleaseVersionNoLeadingHyphen'], ''), 'latest', 'next') ]
    jobs:
      - job: Publish
        displayName: Push to NPM
        steps:
-          - template: templates/npm-publish.yml
-            parameters:
-              artifactName: npm
-              registry: https://registry.npmjs.org/
+          - checkout: none
+          - download: current
+            artifact: npm
+          - bash: echo "@umbraco-cms:registry=https://registry.npmjs.org" >> .npmrc
+            workingDirectory: $(Pipeline.Workspace)/npm
+            displayName: Add scoped registry to .npmrc
+          - task: npmAuthenticate@0
+            displayName: Authenticate with npm
+            inputs:
+              workingFile: $(Pipeline.Workspace)/npm/.npmrc
              customEndpoint: "NPM - Umbraco Backoffice"
-              displayName: Push to npm
-              npmTag: $(npmDistTag)
+          - script: |
+              # Setup temp npm project to load in defaults from the local .npmrc
+              npm init -y
+
+              # Find the first .tgz file in the current directory and publish it
+              files=( ./*.tgz )
+              npm publish "${files[0]}"
+            displayName: Push to npm
+            workingDirectory: $(Pipeline.Workspace)/npm
      - job: PublishTestHelpers
        displayName: Push Test Helpers to NPM
        steps:
-          - template: templates/npm-publish.yml
-            parameters:
-              artifactName: npm-testhelpers
-              registry: https://registry.npmjs.org/
+          - checkout: none
+          - download: current
+            artifact: npm-testhelpers
+          - bash: echo "@umbraco-cms:registry=https://registry.npmjs.org" >> .npmrc
+            workingDirectory: $(Pipeline.Workspace)/npm-testhelpers
+            displayName: Add scoped registry to .npmrc
+          - task: npmAuthenticate@0
+            displayName: Authenticate with npm
+            inputs:
+              workingFile: $(Pipeline.Workspace)/npm-testhelpers/.npmrc
              customEndpoint: "NPM - Umbraco Backoffice"
-              displayName: Push test helpers to npm
-              npmTag: $(npmDistTag)
+          - script: |
+              # Setup temp npm project to load in defaults from the local .npmrc
+              npm init -y
+
+              # Find the first .tgz file in the current directory and publish it
+              files=( ./*.tgz )
+              npm publish "${files[0]}"
+            displayName: Push test helpers to npm
+            workingDirectory: $(Pipeline.Workspace)/npm-testhelpers

  - stage: Upload_API_Docs
    pool:
@@ -4,11 +4,11 @@ pr: none
 trigger: none

 schedules:
-  - cron: '0 6 * * *'
-    displayName: Daily 6AM build (v18/dev)
+  - cron: '0 0 * * *'
+    displayName: Daily 0AM build (main)
    branches:
      include:
-        - v18/dev
+        - main

 parameters:
  - name: skipIntegrationTests
@@ -1,28 +0,0 @@
-parameters:
-  - name: artifactName # "npm" or "npm-testhelpers"
-    type: string
-  - name: registry # scoped-registry URL to publish to
-    type: string
-  - name: customEndpoint # npmAuthenticate service connection(s)
-    type: string
-  - name: displayName # label for the publish step
-    type: string
-  - name: npmTag # dist-tag to publish under
-    type: string
-    default: latest
-
-steps:
-  - checkout: none
-  - download: current
-    artifact: ${{ parameters.artifactName }}
-  - script: npm config set @umbraco-cms:registry ${{ parameters.registry }} --location=project
-    displayName: Add scoped registry to .npmrc
-    workingDirectory: $(Pipeline.Workspace)/${{ parameters.artifactName }}
-  - task: npmAuthenticate@0
-    displayName: Authenticate with npm
-    inputs:
-      workingFile: $(Pipeline.Workspace)/${{ parameters.artifactName }}/.npmrc
-      customEndpoint: ${{ parameters.customEndpoint }}
-  - script: npm publish *.tgz --tag ${{ parameters.npmTag }}
-    displayName: ${{ parameters.displayName }}
-    workingDirectory: $(Pipeline.Workspace)/${{ parameters.artifactName }}
@@ -0,0 +1,96 @@
+# Visual Editor — Partial Re-render (Phase 3 remainder) — Design
+
+**Status**: Implemented (spike passed 2026-06-11; see `2026-06-11-visual-editor-partial-rerender-plan.md`). Built via cache-node override + `IPublishedContentFactory` rather than a decorator — see the plan's "Deliberate deviation" note.
+**Date**: 2026-06-11
+**Author**: Rick Butterfield + Claude
+**Scope**: The "Still to build" items of Phase 3 in `docs/plans/visual-page-builder.md` — server-side partial re-render with unsaved values, and client-side DOM patching. Block manipulation itself is already done.
+**Relates to**: `docs/plans/visual-page-builder.md` §4.4 (original endpoint sketch), §2.3 (BlockPreview pattern); supersedes the isolated-region endpoint idea in §4.4 in favour of full-page render + client morph.
+
+---
+
+## Goal
+
+Make partial re-render the **single, universal mechanism** for reflecting edits in the visual editor preview, retiring both the optimistic-text-only path and the save-and-full-reload path. Every edit — plain text, RTE/Markdown/media, block content/settings, and structural block add/delete/move/reorder — is reflected by re-rendering the page server-side with the workspace's unsaved values and morphing the live iframe DOM in place (no reload, scroll/selection preserved).
+
+## Decisions locked
+
+| Decision | Outcome |
+|---|---|
+| Trigger scope | **All** edit types route through re-render: block content/settings, block add/delete/move/reorder, RTE/Markdown/transformed properties, and plain text. |
+| Feedback model | **Optimistic + authoritative**: instant optimistic `textContent` paint for plain text on keystroke; a debounced (~500ms) server re-render then replaces the region with true Razor output. Blocks/RTE show a subtle pending state (no meaningful optimistic paint) until the render returns. |
+| Rendering approach | **A — full-page render + client DOM morph.** One endpoint renders the whole page via the existing preview path with unsaved values injected; guest morphs the live DOM. Chosen over isolated-region (B) because only a full-page render covers arbitrary-template property placement with guaranteed fidelity, and over hybrid (C) for single-path simplicity. |
+| DOM patch | Bundle **morphdom** in the guest bundle; morph `<body>`, touching only changed nodes; preserves scroll. |
+| Failure mode | **Keep last good DOM + quiet notice.** Leave current DOM untouched, log, transient non-blocking indicator; the workspace already holds the edit so the next successful render reconciles. Never silently swallow. |
+| Save + SignalR | **Suppress self-reload, keep as multi-user net.** After a local save, a short-lived guard makes the editor ignore its own `refreshed` SignalR event (DOM already authoritative — no flicker). Refreshes not caused by this editor still reload. |
+
+## Architecture & data flow
+
+```
+edit (property / block / structural)
+  → element updates workspace value (source of truth)  [+ optimistic textContent for plain text]
+  → UmbVisualEditorRenderController: debounce ~500ms, latest-wins (AbortController cancels in-flight)
+  → POST /umbraco/management/api/v1/visual-editor/render
+        body: { unique, culture?, segment?, values: [{ alias, value, culture?, segment? }] }
+  → server:
+        EnsureUmbracoContext + force preview mode + VisualEditorPropertyTracker.Enable() for the render scope
+        base = DRAFT content from the published cache (preview read — same as the iframe shows)
+        wrap in PropertyOverridePublishedContent(unsaved values)
+        render the assigned template → HTML string (data-umb-* annotations emitted)
+        → { html }
+  → element posts umb:ve:render to the guest with the HTML
+  → guest morphs <body> (morphdom) → re-runs initRegions() → restores selection highlight
+```
+
+The base is the **draft** content the iframe already renders (preview-mode cache read); the override layer is the workspace's even-newer unsaved edits on top.
+
+## Server components (new)
+
+| Unit | Project | Responsibility |
+|---|---|---|
+| Override-content builder (conversion) | `Umbraco.PublishedCache.HybridCache` (or a public seam exposed from it) | Produce an `IPublishedContent` representing the draft + unsaved overrides. **Approach proven by the spike** (and mirroring the in-tree `BlockElementService.BuildElementAsync`): for each overridden alias, run the editor-format value through `dataType.Editor.GetValueEditor().FromEditor(new ContentPropertyData(value, dataType.ConfigurationObject), null)` to get the source value; reuse the existing saved source values (`property.GetValue(published)`) for non-overridden aliases; assemble `PropertyData[]` → `ContentData` → `ContentCacheNode` → `IPublishedContentFactory.ToIPublishedContent(node, preview: true).CreateModel(...)`. Threads `Culture`/`Segment` onto `PropertyData` and sets `ContentData.CultureInfos` for variant content. **Not** a `GetProperty` decorator — a cache-node rebuild. (`IPublishedContentFactory` is `internal` to HybridCache, hence this unit lives there or a small public seam is added — resolved in the plan.) |
+| `IVisualEditorRenderService` + impl | `Umbraco.Web.Common` | Renders a supplied `IPublishedContent` to an HTML string. Modeled on `TemplateRenderer` (`src/Umbraco.Web.Common/Templates/TemplateRenderer.cs`): build an `IPublishedRequest` via `IPublishedRouter`, `SetPublishedContent(overriddenContent)`, set culture/segment + template, swap onto `UmbracoContext.PublishedRequest`, render the template view to a `StringWriter`, restore. Forces preview mode + enables `VisualEditorPropertyTracker` for the render scope so annotations are emitted. RTE-embedded blocks render via the partial-view block engine, which this render context satisfies. |
+| `RenderVisualEditorController` | `Umbraco.Cms.Api.Management` | `POST /umbraco/management/api/v1/visual-editor/render`, `[Authorize(Policy = BackOfficeAccess)]`. Ensures an `UmbracoContext`, resolves the draft content for `unique`, builds the override content from the request `values`, calls the render service, returns `{ html }`. |
+
+**Value conversion — DE-RISKED by the spike (2026-06-11).** All three property kinds convert correctly via `IPublishedContentFactory.ToIPublishedContent`:
+- **TextBox** — `FromEditor` → string source → published string. Clean.
+- **Rich Text** — `FromEditor` → source JSON → `RteBlockRenderingValueConverter`; all link/url/image parsing happens at value-conversion time (no `IPublishedRequest` needed). RTE-*embedded blocks* additionally use the partial-view block engine at render time (covered by the full-page render context — smoke-test specifically).
+- **Block List** — `FromEditor` source IS the block JSON; the converter resolves element types from the published content-type cache (no parent content / `IPublishedRequest` needed). Blocks need an `Expose` entry for the relevant culture/segment to surface.
+
+Recommended primitive: reuse `IPublishedContentFactory` rather than hand-assembling per property. Variant content must populate `PropertyData` per culture/segment + `ContentData.CultureInfos`, and read-time resolution depends on the ambient `IVariationContextAccessor`.
+
+## Client components
+
+| Unit | Responsibility |
+|---|---|
+| `UmbVisualEditorRenderController` (new sibling, follows the SignalR/router/resolver extraction pattern) | Debounce (~500ms) + latest-wins cancellation via `AbortController`. Collects the active variant's current values from the workspace, calls the endpoint, posts `umb:ve:render` to the guest with the returned HTML. On failure: keep DOM, log, transient notice. Invoked from every mutation site (property submit, block submit, add/move/delete/reorder, and the debounced optimistic text input). |
+| guest `injected.ts` | Bundle **morphdom**. Refactor the one-shot init (default outlines, drag-sort setup, add-button insertion, region discovery) into a re-runnable `initRegions()`. On `umb:ve:render`: morph `document.body` to the new HTML, then run `initRegions()` and restore the selection highlight. Delegated document-level listeners (click capture, mouseover) survive the morph; per-node styles/attributes are re-applied by `initRegions()`. |
+| element SignalR (`visual-editor-signalr.controller.ts` + element) | Reintroduce a short-lived **suppress-self-reload** guard set when this editor saves, so the `refreshed` event for our own document key is ignored. Refreshes outside the guard window still reload (multi-user / external cache changes). |
+
+## Error handling
+
+- Render failure (network/500/timeout): keep last good DOM, log, show a transient non-blocking "preview out of date" indicator. The edit is already in the workspace; a later successful render reconciles. No silent swallow.
+- Latest-wins: a newer edit aborts the in-flight render so stale HTML never overwrites newer DOM.
+
+## Out of scope
+
+- Render caching / output pooling beyond debounce + concurrency cap.
+- Headless / Delivery-API rendering in the iframe.
+- Surfacing validation state in the preview.
+- Server-side sub-region extraction (full-page render + client morph already delivers partial DOM updates).
+- Inline (`contenteditable`) editing — that is Phase 4 and now has its server-rendered source of truth from this phase.
+
+## Testing
+
+- **Backend integration test** (the riskiest, and testable C#, unlike the UI surface): the spike's throwaway test at `tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/VisualEditorConversionSpikeTests.cs` (uncommitted) is the basis — the plan's first task formalizes it into a real test of the override-content builder for TextBox, RTE, and Block List (assert converted-without-saving == save-then-read). A second test renders a seeded document through the render service and asserts the HTML reflects overridden values and carries `data-umb-*` annotations.
+- **Frontend**: `npm run build` + `npm run lint` + manual smoke (no VE test harness exists; consistent with the prior phase).
+
+## Spike outcome (2026-06-11) — PASSED
+
+A throwaway integration test (`VisualEditorConversionSpikeTests`, uncommitted) booted Umbraco on SQLite, seeded a doc with TextBox + Rich Text + Block List, and proved that each property's editor-format value converts to the correct published value **without saving**, via `FromEditor` + `IPublishedContentFactory.ToIPublishedContent`. All 3 assertions passed (convert-without-saving == save-then-read). Findings folded into "Server components" above:
+
+- Conversion primitive: `IPublishedContentFactory` (HybridCache, `internal`) — plan must resolve the access seam.
+- Approach is a cache-node rebuild, **not** a `GetProperty` decorator (in-tree precedent: `BlockElementService`).
+- Variants: thread `Culture`/`Segment` + `ContentData.CultureInfos`; read-time needs `IVariationContextAccessor`.
+- Render-to-string is independently de-risked by the existing `TemplateRenderer`; RTE-embedded-block partials are the one spot needing the render context (not the value conversion).
+
+No design fallback required — the approach is viable as chosen.
@@ -0,0 +1,85 @@
+# Visual Editor Tidy-Up — Design
+
+**Status**: Implemented (manual smoke pass pending)
+**Date**: 2026-06-11
+**Author**: Rick Butterfield + Claude
+**Scope**: Tidy-up round on `feature/visual-editor` after merging `main` — no new feature phases.
+**Relates to**: `docs/plans/visual-page-builder.md` (the feature plan; updated as part of this round)
+
+---
+
+## Decisions locked in this round
+
+| Decision | Outcome |
+|---|---|
+| Architecture | **Embedded document-workspace view** is the current direction. The standalone-window evolution (plan doc §10, Open Q11) is **deferred**, not the next step. |
+| Round scope | **Tidy-up only** — security, semantics, refactor, docs. No partial re-render API, no inline editing. |
+| Editability semantics | **Strict opt-in everywhere** for document properties: a property is annotated/editable only when `appearance.editableInVisualEditor === true`. The frontend opt-out fallback is removed. |
+| Block modal properties | **No filter**: the block editing modal shows all of the element type's content/settings properties. The `EditableInVisualEditor` setting governs document property annotation only. |
+
+## Why
+
+The branch is functionally far ahead of its plan doc (Phases 1–2 complete plus most block manipulation), but an audit found:
+
+1. **Security**: the guest script (`src/Umbraco.Web.UI.Client/src/apps/visual-editor/injected.ts:540`) accepts `message` events with no `evt.origin` check, and posts with target `'*'`. The backoffice-side listener also lacks source/origin validation.
+2. **Semantic mismatch**: backend tracking is strict opt-in (`PublishedContentExtensions.TrackVisualEditorAccess` checks `EditableInVisualEditor`), while the frontend had a conflicting "if none opt in, include all" fallback — dead code for properties, but confusing and wrong.
+3. **Maintainability**: `document-workspace-view-visual-editor.element.ts` is 1,210 lines with ~11 responsibilities.
+4. **Gap**: root-level empty Block Lists cannot offer "Add content" (container lacks a property-alias annotation; `injected.ts:1040` TODO).
+5. **Stale docs**: `visual-page-builder.md` predates the `EditableInVisualEditor` setting and records "standalone window" as decided.
+
+## Changes
+
+### 1. Security hardening
+
+**Guest script** (`injected.ts`):
+- Derive `PARENT_ORIGIN` once: `document.referrer ? new URL(document.referrer).origin : window.location.origin`.
+- Incoming handler: drop messages where `evt.origin !== PARENT_ORIGIN`.
+- Outgoing: `window.parent.postMessage(msg, PARENT_ORIGIN)` instead of `'*'`.
+- Referrer-based derivation keeps cross-origin dev (Vite 5173 → server 44339) working.
+
+**Workspace view element**: the `message` listener accepts only events where `evt.source === iframe.contentWindow` **and** `evt.origin` equals the server origin from `UMB_SERVER_CONTEXT`.
+
+### 2. Strict opt-in semantics
+
+In the element's property-structure resolution:
+- Remove the `anyExplicitlyEnabled` hybrid entirely.
+- Document property METADATA stays unfiltered (it doubles as block-config lookup for `#getBlocksConfig`); enforcement is at the interaction points instead: `#onPropertyClicked` and the property modal `onSetup` both require `editableInVisualEditor === true` (defense-in-depth on top of server-side annotation gating).
+- Remove the filter entirely from block content/settings structure resolution (blocks show all fields).
+- Drop the `as { editableInVisualEditor?: boolean }` casts — the generated API types carry `appearance.editableInVisualEditor` natively; the resolver maps it onto `UmbVisualEditorPropertyInfo.editableInVisualEditor`.
+
+Backend is already strict — no backend change.
+
+### 3. Element refactor (extraction-only)
+
+Extract from `document-workspace-view-visual-editor.element.ts` into sibling files; no behavior change:
+
+| New file | Responsibility |
+|---|---|
+| `visual-editor-signalr.controller.ts` | `HubConnection` lifecycle, `refreshed` event, refresh-suppression guard |
+| `visual-editor-property-structure.resolver.ts` | Document/block/settings property-structure resolution incl. composition-chain fetch and caching; `Map`-indexed by alias (replaces 6× O(n) `find()`); sole home of the opt-in filter |
+| `visual-editor-message-router.ts` | Typed message-map routing of guest messages (replaces 7-case switch); performs the origin/source validation from §1 |
+
+The element keeps iframe lifecycle, modal registrations, selection state and preview URL — target ≤ ~600 lines. Also: `Object.keys(pastedBlocks.layout)[0]` → `Object.values(pastedBlocks.layout)[0]` (line 972).
+
+### 4. Root-level empty block lists
+
+- `BlockListTemplateExtensions` passes the property alias to the partial via `ViewData` (alias-aware overloads; empty models no longer short-circuit so the partial can render an annotated empty container in preview mode).
+- `Views/Partials/blocklist/default.cshtml` emits `data-umb-block-property="<alias>"` on the list container — a distinct attribute, because `data-umb-property` is the guest script's property-region selector and would turn the whole list into a clickable property region.
+- `injected.ts` resolves the alias from the container for empty root-level lists and renders the existing "Add content" button via a new `umb:ve:block-add-to-property` message (closes the `injected.ts:1040` TODO).
+
+### 5. Docs & polish
+
+- XML docs: class-level summary on `VisualEditorPropertyTracker`; `<param>` tags on `VisualEditorGuestScript.GetScriptTag()`.
+- `docs/plans/visual-page-builder.md`: refresh status header and phase statuses; close Open Q5 (setting shipped, strict opt-in); mark §10/Q11 standalone window **Deferred** with embedded view as current; update Appendix B attribute table.
+
+## Out of scope
+
+- Partial re-render API (Phase 3 remainder), inline editing (Phase 4), headless rendering, validation surfaced in preview, scroll retention.
+- Moving the visual editor to its own package / lifting block-manipulation logic to library level — revisit with Phase 3.
+- Automated tests for the visual editor (no harness exists for this surface yet; E2E coverage noted in the plan doc as future work).
+
+## Verification
+
+1. `npm run build` and `npm run lint` in `src/Umbraco.Web.UI.Client`.
+2. `dotnet build umbraco.sln` — zero errors, no new warnings.
+3. Manual smoke in the visual editor tab: property edit (flagged + unflagged property), block add/edit/settings/move/delete, empty root-level block list "Add content", save → SignalR refresh → selection restore, postMessage still works in dev (Vite) and built modes.
@@ -0,0 +1,125 @@
+# Visual Editor — Framework-Emitted Empty-Block Affordance — Design
+
+**Status**: Implemented
+**Date**: 2026-06-12
+**Author**: Rick Butterfield + Claude
+**Scope**: Move the "empty editable block property" visual-editor affordance (the annotated container that lets the guest offer an "Add content" button) out of per-view template code and into the framework block-rendering helpers, so it works automatically for every template — including custom ones — with zero template boilerplate.
+**Supersedes**: the per-view empty-state edits to `blockgrid/blocklist/singleblock/default.cshtml` (sample site) and `EmbeddedResources/BlockGrid/default.cshtml`, plus the `PropertyAliasViewDataKey` ViewData plumbing in `BlockListTemplateExtensions`/`BlockGridTemplateExtensions`.
+
+---
+
+## Problem
+
+The visual editor needs a DOM anchor for empty, editable block properties so the guest can render an "Add content" affordance (it has no blocks to attach inter-block "+" buttons to). The current implementation puts this in the Razor templates:
+
+- `GetBlock{List,Grid}HtmlAsync` short-circuits empty models to `HtmlString.Empty`.
+- Each `default.cshtml` was patched to read a `PropertyAliasViewDataKey` from ViewData and render an annotated empty `<div ... data-umb-block-property="{alias}">` in visual-editor mode.
+
+This is unfriendly and incomplete:
+- Every block template (block list, block grid, single block — default **and** any custom template) must carry framework annotation boilerplate.
+- Custom templates that don't include it silently lose the feature.
+- It contrasts with regular property annotation, which is fully automatic (`UmbracoViewPage` wraps editable property output in `data-umb-property` spans with no template code).
+
+## Goal
+
+Make the empty-block affordance **fully automatic**: no template code, working for the default templates and any custom template, gated on the property's `EditableInVisualEditor` opt-in and on visual-editor/preview mode. Revert all per-view edits and the ViewData plumbing.
+
+## Why not the obvious alternatives
+
+- **Emit it from `UmbracoViewPage` (like `data-umb-property`)**: the automatic span is only emitted when the property is accessed via the tracked `IPublishedContent.Value()` path; the block helpers read the value via `GetProperty().GetValue()`, which bypasses the tracker. Making block access reliably tracked and anchoring an affordance on an empty span touches the core annotation pipeline — bigger and riskier (this is the deferred "unify all property annotation" direction).
+- **Emit HTML from the Core block model**: `BlockListModel`/`BlockGridModel` live in `Umbraco.Core`, which has no web/HTML concern — emitting annotation markup from the model crosses a layer boundary.
+
+## Approach (chosen)
+
+The block-rendering helpers in `Umbraco.Web.Common` are the web-layer choke point essentially all block rendering flows through. Move the empty-state emission there.
+
+### Component 1 — Helpers emit the annotated container
+
+In `BlockListTemplateExtensions`, `BlockGridTemplateExtensions`, and the single-block rendering helper:
+
+- When the model is **empty** AND `VisualEditorPropertyTracker.IsEnabled` AND the property's `PropertyType.EditableInVisualEditor` is `true`, return a minimal annotated container as an `HtmlString`:
+  - Block list: `<div class="umb-block-list" data-umb-block-property="{alias}"></div>`
+  - Block grid: `<div class="umb-block-grid" data-umb-block-property="{alias}"></div>` (with the existing `data-grid-columns`/`--umb-block-grid--grid-columns` styling, defaulting columns to `12`)
+  - Single block: an analogous annotated empty container (see Component 3)
+- Otherwise return `HtmlString.Empty` exactly as today. Non-empty models render their partial unchanged.
+
+The helper builds this small fixed container directly (no partial, no ViewData). The `PropertyAliasViewDataKey` constant, the `WithPropertyAlias` helper, and the alias-via-ViewData private overloads are **removed** from both extensions.
+
+Gating predicate (shared intent across all three helpers): `model is empty && VisualEditorPropertyTracker.IsEnabled && propertyType?.EditableInVisualEditor == true`.
+
+### Component 2 — Emission lives in the alias-bearing overloads only (no model metadata)
+
+The helpers have three call styles:
+
+| Overload | Has alias + editable flag? |
+|---|---|
+| `GetBlock*HtmlAsync(IPublishedContent content, string alias[, template])` | Yes — resolves the `IPublishedProperty` (`alias`, `PropertyType.EditableInVisualEditor`) |
+| `GetBlock*HtmlAsync(IPublishedProperty property[, template])` | Yes — `property.Alias`, `property.PropertyType.EditableInVisualEditor` |
+| `GetBlock*HtmlAsync(BlockListModel/BlockGridModel model[, template])` | **No** |
+
+The empty-state container is emitted **only by the two alias-bearing overloads**, because they carry the alias and editable flag regardless of whether the value is empty.
+
+**Why not "alias on the model" (rejected):** empty block values resolve to a process-wide **singleton** — the value creators return `BlockListModel.Empty` / `BlockGridModel.Empty` (`public static`), and an empty single block converts to `null`. There is no per-property instance to carry an alias for the empty case, and setting a mutable alias on the shared singleton would corrupt every empty block property on the site. The alias is also unavailable where the model is built (the value *creators* don't receive `IPublishedPropertyType` — only the *converters* do). So model metadata is out; **no changes to Core models, value creators, or converters.**
+
+**Consequence for the model-only overload:** `GetBlock*HtmlAsync(Model.BlockProperty)` (model-only, including the bare ModelsBuilder property) keeps its current behaviour — empty renders nothing, no affordance. The alias-bearing overload (`GetBlock*HtmlAsync(Model, "alias")` / `(IPublishedProperty)`) is the documented, default pattern used by all sample templates (and `Home.cshtml` was aligned to it), so "fully automatic" holds for the standard pattern. The model-only gap is in the same class as fully hand-rolled rendering — see Out of scope.
+
+### Component 3 — Single block
+
+The single-block helper is `SingleBlockTemplateExtensions.GetBlockHtmlAsync`; an empty single-block property surfaces as a **null** `BlockListItem` (the helper already returns `HtmlString.Empty` for null). Emit an annotated empty container when the value is null/empty + `VisualEditorPropertyTracker.IsEnabled` + the property is `EditableInVisualEditor`.
+
+Consistent with Component 2: annotation comes only from the **alias-bearing overloads** — `GetBlockHtmlAsync(IPublishedProperty)` and `GetBlockHtmlAsync(IPublishedContent, alias)` — which expose `property.Alias` and `property.PropertyType.EditableInVisualEditor` even when `property.GetValue()` is null. The model-only `GetBlockHtmlAsync(BlockListItem? model)` overload, given a null model, has no alias and cannot annotate (documented gap; the sample/default and documented usage use the alias-bearing overloads).
+
+"Add content" reuses the existing `umb:ve:block-add-to-property` message (single-block semantics: one block, `insertIndex 0`). The guest gains a single-block empty-container branch mirroring the list/grid ones (or a shared selector). Exact container markup + the guest branch are finalized in the plan.
+
+### Component 4 — Guest + element (mostly unchanged)
+
+- The guest already attaches the "Add content" placeholder to empty `.umb-block-list` / `.umb-block-grid` containers carrying `data-umb-block-property`, and the element's grid-aware add (`#resolveBlockSchemaAlias`) already produces the correct list/grid value shape. These are unchanged.
+- The only guest addition is the single-block empty-container handling.
+- The `data-umb-block-property` attribute and the `umb:ve:block-add-to-property` postMessage protocol are retained — the helper now emits the attribute that the templates previously emitted.
+
+### Component 5 — Revert the per-view changes
+
+Revert to original form (removing the empty-state boilerplate and ViewData reads):
+- `src/Umbraco.Web.UI/Views/Partials/blockgrid/default.cshtml`
+- `src/Umbraco.Web.UI/Views/Partials/blocklist/default.cshtml`
+- `src/Umbraco.Web.UI/Views/Partials/singleblock/default.cshtml` (unchanged from original — never modified, but confirm it needs no edit under the new mechanism)
+- `src/Umbraco.Core/EmbeddedResources/BlockGrid/default.cshtml`
+
+`Home.cshtml`'s switch to the alias-aware overload (`GetBlockGridHtmlAsync(Model, "bodyText")`) may be **kept or reverted** — under Component 2 the model-only overload also works, so reverting it is safe; keeping it is harmless. The plan picks one (default: keep, as the alias-aware overload is the documented norm).
+
+## Data flow (after)
+
+```
+template: @await Html.GetBlockGridHtmlAsync(Model, "bodyText")   (or Model.BodyText, or an IPublishedProperty)
+  → helper resolves model + property alias + EditableInVisualEditor
+  → model non-empty?  → render partial as today (unchanged)
+  → model empty?
+       → VisualEditorPropertyTracker.IsEnabled && EditableInVisualEditor?
+            → return <div class="umb-block-grid" data-umb-block-property="bodyText"></div>
+            → else HtmlString.Empty   (production: nothing, as today)
+  → guest sees the empty annotated container → renders "Add content" → umb:ve:block-add-to-property
+  → element #onBlockAddToProperty → grid/list-aware value creation (unchanged)
+```
+
+## Error handling / edge cases
+
+- Not in VE/preview, or property not editable, or model non-empty → byte-for-byte the same output as before this change (no behavioural change to production rendering).
+- Property alias unknown on the model-only overload (metadata not populated, e.g. a model constructed outside the value creators) → no annotation (graceful: treated as "alias unknown", returns empty as today). Not silent in a harmful way — it just falls back to current behaviour.
+- A custom template that hand-renders blocks without any `GetBlock*HtmlAsync` helper → no affordance. Documented as the one uncovered path (the helper is the documented rendering API).
+
+## Testing
+
+- **Backend (unit/integration)**: the block helpers return an annotated container for an empty editable block property when `VisualEditorPropertyTracker.IsEnabled`, and `HtmlString.Empty` when (a) the tracker is disabled, (b) the property is not `EditableInVisualEditor`, or (c) the model is non-empty. Cover all three overloads (content+alias, property, model-only) — the model-only case asserts the `PropertyAlias` metadata path.
+- **Value-creator test**: the produced block model carries the correct `PropertyAlias` / `EditableInVisualEditor` metadata.
+- **Frontend/guest**: `npm run build` + `npm run lint` + manual smoke (no VE guest test harness; consistent with the feature's established posture). Manual smoke covers empty list, empty grid, empty single block in the visual editor.
+
+## Out of scope
+
+- Unifying all property annotation under a single `data-umb-property` mechanism (the deferred Approach 2).
+- Shipping a default block-list render template (block list intentionally ships none).
+- Covering hand-rolled block rendering that bypasses the `GetBlock*HtmlAsync` helpers.
+- Covering the **model-only** helper overload (`GetBlock*HtmlAsync(Model.BlockProperty)`): empty values resolve to the shared `.Empty` singleton (or `null` for single block), which has no per-property identity to annotate. Use the alias-bearing overload (`GetBlock*HtmlAsync(Model, "alias")`) — the documented default — to get the empty-state affordance.
+
+## Implementation note
+
+This change **reverts** the prior per-view empty-state commits and the ViewData plumbing in favour of the helper-based mechanism. Those commits remain in history as superseded steps; the revert is part of this work, not a separate cleanup.
@@ -0,0 +1,947 @@
+# Visual Editor — Framework-Emitted Empty-Block Affordance — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make the visual-editor empty-block "Add content" affordance fully automatic via the block-rendering helpers, removing the per-view template boilerplate and the ViewData plumbing.
+
+**Architecture:** The block helpers (`BlockListTemplateExtensions`, `BlockGridTemplateExtensions`, `SingleBlockTemplateExtensions` in `Umbraco.Web.Common`) emit an annotated empty container `<div class="umb-block-{list,grid,single}" data-umb-block-property="{alias}">` themselves — but only from the **alias-bearing overloads** (which carry the alias + `PropertyType.EditableInVisualEditor` even when the value is empty), and only when `VisualEditorPropertyTracker.IsEnabled` and the property is editable-in-VE. A shared `BlockEmptyState` helper DRYs the gating + markup. The default views revert to their plain form, and the ViewData plumbing is deleted. No changes to Core models / value creators / converters.
+
+**Tech Stack:** C# / ASP.NET Core Razor helpers (`Umbraco.Web.Common`), Razor views (`Umbraco.Web.UI`, embedded `Umbraco.Core`), TypeScript guest (`injected.ts`) + Lit element (backoffice client). Working dir for ALL tasks: `D:/CMS/Umbraco-CMS/.worktrees/feature-visual-editor`.
+
+**Spec:** `docs/plans/2026-06-12-visual-editor-block-empty-state-design.md`
+
+**Standing instruction:** the user asked for **no commits yet**. Implement and verify each task; leave changes in the working tree **uncommitted**. The "Commit" steps below are written for completeness but are GATED — do not run them until the user approves committing. Report each task's diff for review instead.
+
+**Verified facts:**
+- Empty block values resolve to the shared singletons `BlockListModel.Empty` / `BlockGridModel.Empty`; an empty single block converts to `null`. Hence the alias can only come from the alias-bearing overloads, not the model. (No model/creator/converter changes.)
+- `IPublishedPropertyType` exposes `string Alias` and `bool EditableInVisualEditor` (default `false`) — `src/Umbraco.Core/Models/PublishedContent/IPublishedPropertyType.cs:27,52`.
+- `VisualEditorPropertyTracker.IsEnabled` is a public static in `Umbraco.Cms.Core.Models.PublishedContent`.
+- `SingleBlockValue : BlockValue<SingleBlockLayoutItem>` with `PropertyEditorAlias => Constants.PropertyEditors.Aliases.SingleBlock` — so single-block add reuses `addBlockToValue` with the single-block schema alias.
+- The guest already has empty-container branches for `.umb-block-list` and `.umb-block-grid` reading `dataset.umbBlockProperty`; there is **no** single-block handling.
+
+---
+
+### Task 1: Shared empty-state helper
+
+**Files:**
+- Create: `src/Umbraco.Web.Common/Extensions/BlockEmptyState.cs`
+- Test: `tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockEmptyStateTests.cs`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockEmptyStateTests.cs`:
+
+```csharp
+using Microsoft.AspNetCore.Html;
+using NUnit.Framework;
+using System.IO;
+using System.Text.Encodings.Web;
+using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.Common.Extensions;
+
+[TestFixture]
+public class BlockEmptyStateTests
+{
+    [TearDown]
+    public void TearDown() => VisualEditorPropertyTracker.Disable();
+
+    private static string Render(IHtmlContent content)
+    {
+        using var writer = new StringWriter();
+        content.WriteTo(writer, HtmlEncoder.Default);
+        return writer.ToString();
+    }
+
+    [Test]
+    public void Returns_Annotated_Container_When_Enabled_And_Editable()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = BlockEmptyState.Container("umb-block-list", "bodyText", editableInVisualEditor: true);
+        var html = Render(result);
+        Assert.That(html, Does.Contain("class=\"umb-block-list\""));
+        Assert.That(html, Does.Contain("data-umb-block-property=\"bodyText\""));
+    }
+
+    [Test]
+    public void Returns_Empty_When_Tracker_Disabled()
+    {
+        VisualEditorPropertyTracker.Disable();
+        IHtmlContent result = BlockEmptyState.Container("umb-block-list", "bodyText", editableInVisualEditor: true);
+        Assert.That(Render(result), Is.Empty);
+    }
+
+    [Test]
+    public void Returns_Empty_When_Not_Editable()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = BlockEmptyState.Container("umb-block-grid", "bodyText", editableInVisualEditor: false);
+        Assert.That(Render(result), Is.Empty);
+    }
+
+    [Test]
+    public void Returns_Empty_When_Alias_Missing()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = BlockEmptyState.Container("umb-block-list", string.Empty, editableInVisualEditor: true);
+        Assert.That(Render(result), Is.Empty);
+    }
+
+    [Test]
+    public void Encodes_Alias_And_Class()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = BlockEmptyState.Container("umb-block-list", "a\"b", editableInVisualEditor: true);
+        var html = Render(result);
+        Assert.That(html, Does.Not.Contain("a\"b"));
+        Assert.That(html, Does.Contain("a&quot;b").Or.Contain("a&#x22;b"));
+    }
+}
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~BlockEmptyStateTests"`
+Expected: FAIL (build error — `BlockEmptyState` does not exist).
+
+- [ ] **Step 3: Implement `BlockEmptyState`**
+
+Create `src/Umbraco.Web.Common/Extensions/BlockEmptyState.cs`:
+
+```csharp
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Html;
+using Umbraco.Cms.Core.Models.PublishedContent;
+
+namespace Umbraco.Extensions;
+
+/// <summary>
+/// Produces the annotated empty container the visual editor uses to offer an "add content"
+/// affordance on an empty, editable block property. Returns empty content outside the visual editor.
+/// </summary>
+internal static class BlockEmptyState
+{
+    /// <summary>
+    /// Returns an annotated empty container (<c>&lt;div class="{cssClass}" data-umb-block-property="{alias}"&gt;</c>)
+    /// when the property is editable in the visual editor and the visual editor is active; otherwise empty content.
+    /// </summary>
+    public static IHtmlContent Container(string cssClass, string propertyAlias, bool editableInVisualEditor)
+    {
+        if (!editableInVisualEditor
+            || string.IsNullOrEmpty(propertyAlias)
+            || !VisualEditorPropertyTracker.IsEnabled)
+        {
+            return HtmlString.Empty;
+        }
+
+        var encodedClass = HtmlEncoder.Default.Encode(cssClass);
+        var encodedAlias = HtmlEncoder.Default.Encode(propertyAlias);
+        return new HtmlString($"<div class=\"{encodedClass}\" data-umb-block-property=\"{encodedAlias}\"></div>");
+    }
+}
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~BlockEmptyStateTests"`
+Expected: PASS (5 passed).
+
+- [ ] **Step 5: Commit (GATED — only if the user has approved committing)**
+
+```bash
+git add src/Umbraco.Web.Common/Extensions/BlockEmptyState.cs tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockEmptyStateTests.cs
+git commit -m "feat(visual-editor): shared empty-state container helper for block properties"
+```
+
+---
+
+### Task 2: Block list helper emits the affordance; remove ViewData plumbing
+
+**Files:**
+- Modify: `src/Umbraco.Web.Common/Extensions/BlockListTemplateExtensions.cs`
+- Test: `tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockListTemplateExtensionsTests.cs`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockListTemplateExtensionsTests.cs`:
+
+```csharp
+using System.IO;
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Models.Blocks;
+using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.Common.Extensions;
+
+[TestFixture]
+public class BlockListTemplateExtensionsTests
+{
+    [TearDown]
+    public void TearDown() => VisualEditorPropertyTracker.Disable();
+
+    private static string Render(IHtmlContent content)
+    {
+        using var writer = new StringWriter();
+        content.WriteTo(writer, HtmlEncoder.Default);
+        return writer.ToString();
+    }
+
+    private static IPublishedProperty EmptyEditableProperty(string alias, bool editable)
+    {
+        var propertyType = new Mock<IPublishedPropertyType>();
+        propertyType.SetupGet(x => x.Alias).Returns(alias);
+        propertyType.SetupGet(x => x.EditableInVisualEditor).Returns(editable);
+
+        var property = new Mock<IPublishedProperty>();
+        property.SetupGet(x => x.Alias).Returns(alias);
+        property.SetupGet(x => x.PropertyType).Returns(propertyType.Object);
+        property.Setup(x => x.GetValue(null, null)).Returns(BlockListModel.Empty);
+        return property.Object;
+    }
+
+    [Test]
+    public async Task Empty_Editable_Property_In_VisualEditor_Emits_Annotated_Container()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockListHtmlAsync(EmptyEditableProperty("bodyText", editable: true));
+        var html = Render(result);
+        Assert.That(html, Does.Contain("class=\"umb-block-list\""));
+        Assert.That(html, Does.Contain("data-umb-block-property=\"bodyText\""));
+    }
+
+    [Test]
+    public async Task Empty_NonEditable_Property_Emits_Nothing()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockListHtmlAsync(EmptyEditableProperty("bodyText", editable: false));
+        Assert.That(Render(result), Is.Empty);
+    }
+
+    [Test]
+    public async Task Empty_Property_Outside_VisualEditor_Emits_Nothing()
+    {
+        VisualEditorPropertyTracker.Disable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockListHtmlAsync(EmptyEditableProperty("bodyText", editable: true));
+        Assert.That(Render(result), Is.Empty);
+    }
+}
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~BlockListTemplateExtensionsTests"`
+Expected: FAIL — the current helper short-circuits empty to `HtmlString.Empty` (no container), so the first test fails.
+
+- [ ] **Step 3: Rewrite `BlockListTemplateExtensions.cs`**
+
+Replace the full contents of `src/Umbraco.Web.Common/Extensions/BlockListTemplateExtensions.cs` with:
+
+```csharp
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Umbraco.Cms.Core.Models.Blocks;
+using Umbraco.Cms.Core.Models.PublishedContent;
+
+namespace Umbraco.Extensions;
+
+public static class BlockListTemplateExtensions
+{
+    public const string DefaultFolder = "blocklist/";
+    public const string DefaultTemplate = "default";
+
+    #region Async
+
+    public static async Task<IHtmlContent> GetBlockListHtmlAsync(this IHtmlHelper html, BlockListModel? model, string template = DefaultTemplate)
+    {
+        if (model?.Count == 0)
+        {
+            return HtmlString.Empty;
+        }
+
+        return await html.PartialAsync(DefaultFolderTemplate(template), model);
+    }
+
+    public static async Task<IHtmlContent> GetBlockListHtmlAsync(this IHtmlHelper html, IPublishedProperty property, string template = DefaultTemplate)
+        => await GetBlockListHtmlAsync(html, property.GetValue() as BlockListModel, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+
+    public static async Task<IHtmlContent> GetBlockListHtmlAsync(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias)
+        => await GetBlockListHtmlAsync(html, contentItem, propertyAlias, DefaultTemplate);
+
+    public static async Task<IHtmlContent> GetBlockListHtmlAsync(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias, string template)
+    {
+        IPublishedProperty property = GetRequiredProperty(contentItem, propertyAlias);
+        return await GetBlockListHtmlAsync(html, property.GetValue() as BlockListModel, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+    }
+
+    private static async Task<IHtmlContent> GetBlockListHtmlAsync(IHtmlHelper html, BlockListModel? model, string template, string propertyAlias, bool editableInVisualEditor)
+    {
+        if (model is null || model.Count == 0)
+        {
+            return BlockEmptyState.Container("umb-block-list", propertyAlias, editableInVisualEditor);
+        }
+
+        return await html.PartialAsync(DefaultFolderTemplate(template), model);
+    }
+
+    #endregion
+
+    #region Sync
+
+    public static IHtmlContent GetBlockListHtml(this IHtmlHelper html, BlockListModel? model, string template = DefaultTemplate)
+    {
+        if (model?.Count == 0)
+        {
+            return HtmlString.Empty;
+        }
+
+        return html.Partial(DefaultFolderTemplate(template), model);
+    }
+
+    public static IHtmlContent GetBlockListHtml(this IHtmlHelper html, IPublishedProperty property, string template = DefaultTemplate)
+        => GetBlockListHtml(html, property.GetValue() as BlockListModel, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+
+    public static IHtmlContent GetBlockListHtml(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias)
+        => GetBlockListHtml(html, contentItem, propertyAlias, DefaultTemplate);
+
+    public static IHtmlContent GetBlockListHtml(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias, string template)
+    {
+        IPublishedProperty property = GetRequiredProperty(contentItem, propertyAlias);
+        return GetBlockListHtml(html, property.GetValue() as BlockListModel, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+    }
+
+    private static IHtmlContent GetBlockListHtml(IHtmlHelper html, BlockListModel? model, string template, string propertyAlias, bool editableInVisualEditor)
+    {
+        if (model is null || model.Count == 0)
+        {
+            return BlockEmptyState.Container("umb-block-list", propertyAlias, editableInVisualEditor);
+        }
+
+        return html.Partial(DefaultFolderTemplate(template), model);
+    }
+
+    #endregion
+
+    private static string DefaultFolderTemplate(string template) => $"{DefaultFolder}{template}";
+
+    private static IPublishedProperty GetRequiredProperty(IPublishedContent contentItem, string propertyAlias)
+    {
+        ArgumentNullException.ThrowIfNull(propertyAlias);
+
+        if (string.IsNullOrWhiteSpace(propertyAlias))
+        {
+            throw new ArgumentException(
+                "Value can't be empty or consist only of white-space characters.",
+                nameof(propertyAlias));
+        }
+
+        IPublishedProperty? property = contentItem.GetProperty(propertyAlias);
+        if (property == null)
+        {
+            throw new InvalidOperationException("No property type found with alias " + propertyAlias);
+        }
+
+        return property;
+    }
+}
+```
+
+This removes `PropertyAliasViewDataKey`, `WithPropertyAlias`, the `Microsoft.AspNetCore.Mvc.ViewFeatures` using, and the old alias-via-ViewData private overloads.
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~BlockListTemplateExtensionsTests"`
+Expected: PASS (3 passed).
+
+- [ ] **Step 5: Build Web.Common**
+
+Run: `dotnet build src/Umbraco.Web.Common/Umbraco.Web.Common.csproj`
+Expected: 0 errors.
+
+- [ ] **Step 6: Commit (GATED)**
+
+```bash
+git add src/Umbraco.Web.Common/Extensions/BlockListTemplateExtensions.cs tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockListTemplateExtensionsTests.cs
+git commit -m "feat(visual-editor): block list helper emits empty-state affordance, drop ViewData plumbing"
+```
+
+---
+
+### Task 3: Block grid helper emits the affordance; remove ViewData plumbing
+
+**Files:**
+- Modify: `src/Umbraco.Web.Common/Extensions/BlockGridTemplateExtensions.cs`
+- Test: `tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockGridTemplateExtensionsTests.cs`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockGridTemplateExtensionsTests.cs`:
+
+```csharp
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Models.Blocks;
+using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.Common.Extensions;
+
+[TestFixture]
+public class BlockGridTemplateExtensionsTests
+{
+    [TearDown]
+    public void TearDown() => VisualEditorPropertyTracker.Disable();
+
+    private static string Render(IHtmlContent content)
+    {
+        using var writer = new StringWriter();
+        content.WriteTo(writer, HtmlEncoder.Default);
+        return writer.ToString();
+    }
+
+    private static IPublishedProperty EmptyEditableProperty(string alias, bool editable)
+    {
+        var emptyGrid = new BlockGridModel(new List<BlockGridItem>(), null);
+
+        var propertyType = new Mock<IPublishedPropertyType>();
+        propertyType.SetupGet(x => x.Alias).Returns(alias);
+        propertyType.SetupGet(x => x.EditableInVisualEditor).Returns(editable);
+
+        var property = new Mock<IPublishedProperty>();
+        property.SetupGet(x => x.Alias).Returns(alias);
+        property.SetupGet(x => x.PropertyType).Returns(propertyType.Object);
+        property.Setup(x => x.GetValue(null, null)).Returns(emptyGrid);
+        return property.Object;
+    }
+
+    [Test]
+    public async Task Empty_Editable_Property_In_VisualEditor_Emits_Annotated_Container()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockGridHtmlAsync(EmptyEditableProperty("bodyText", editable: true));
+        var html = Render(result);
+        Assert.That(html, Does.Contain("class=\"umb-block-grid\""));
+        Assert.That(html, Does.Contain("data-umb-block-property=\"bodyText\""));
+    }
+
+    [Test]
+    public async Task Empty_NonEditable_Property_Emits_Nothing()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockGridHtmlAsync(EmptyEditableProperty("bodyText", editable: false));
+        Assert.That(Render(result), Is.Empty);
+    }
+
+    [Test]
+    public async Task Empty_Property_Outside_VisualEditor_Emits_Nothing()
+    {
+        VisualEditorPropertyTracker.Disable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockGridHtmlAsync(EmptyEditableProperty("bodyText", editable: true));
+        Assert.That(Render(result), Is.Empty);
+    }
+}
+```
+
+(Note: `new BlockGridModel(new List<BlockGridItem>(), null)` is used instead of `BlockGridModel.Empty` because `Empty` has `Count == 0` and either works; the explicit list keeps the test independent of the singleton.)
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~BlockGridTemplateExtensionsTests"`
+Expected: FAIL (no container emitted by current helper).
+
+- [ ] **Step 3: Edit `BlockGridTemplateExtensions.cs`**
+
+In `src/Umbraco.Web.Common/Extensions/BlockGridTemplateExtensions.cs`:
+
+(a) Remove the `using Microsoft.AspNetCore.Mvc.ViewFeatures;` line.
+
+(b) Remove the `PropertyAliasViewDataKey` const + its XML doc (lines 20-24).
+
+(c) Replace the async property/content overloads + private method (lines 51-66) — change the property overloads to pass the alias **and** editable flag, and rewrite the private method to emit the empty-state:
+
+```csharp
+    /// <inheritdoc cref="GetBlockGridHtmlAsync(Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper,Umbraco.Cms.Core.Models.Blocks.BlockGridModel?,string)"/>
+    public static async Task<IHtmlContent> GetBlockGridHtmlAsync(this IHtmlHelper html, IPublishedProperty property, string template = DefaultTemplate)
+        => await GetBlockGridHtmlAsync(html, property.GetValue() as BlockGridModel, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+
+    /// <inheritdoc cref="GetBlockGridHtmlAsync(Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper,Umbraco.Cms.Core.Models.Blocks.BlockGridModel?,string)"/>
+    public static async Task<IHtmlContent> GetBlockGridHtmlAsync(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias)
+        => await GetBlockGridHtmlAsync(html, contentItem, propertyAlias, DefaultTemplate);
+
+    public static async Task<IHtmlContent> GetBlockGridHtmlAsync(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias, string template)
+    {
+        IPublishedProperty prop = GetRequiredProperty(contentItem, propertyAlias);
+        return await GetBlockGridHtmlAsync(html, prop.GetValue() as BlockGridModel, template, prop.Alias, prop.PropertyType.EditableInVisualEditor);
+    }
+
+    private static async Task<IHtmlContent> GetBlockGridHtmlAsync(IHtmlHelper html, BlockGridModel? model, string template, string propertyAlias, bool editableInVisualEditor)
+    {
+        if (model is null || model.Count == 0)
+        {
+            return BlockEmptyState.Container("umb-block-grid", propertyAlias, editableInVisualEditor);
+        }
+
+        return await html.PartialAsync(DefaultFolderTemplate(template), model);
+    }
+```
+
+(d) Mirror the same change in the sync region (lines 104-118):
+
+```csharp
+    /// <inheritdoc cref="GetBlockGridHtmlAsync(Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper,Umbraco.Cms.Core.Models.Blocks.BlockGridModel?,string)"/>
+    public static IHtmlContent GetBlockGridHtml(this IHtmlHelper html, IPublishedProperty property, string template = DefaultTemplate)
+        => GetBlockGridHtml(html, property.GetValue() as BlockGridModel, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+
+    /// <inheritdoc cref="GetBlockGridHtmlAsync(Microsoft.AspNetCore.Mvc.Rendering.IHtmlHelper,Umbraco.Cms.Core.Models.Blocks.BlockGridModel?,string)"/>
+    public static IHtmlContent GetBlockGridHtml(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias)
+        => GetBlockGridHtml(html, contentItem, propertyAlias, DefaultTemplate);
+
+    public static IHtmlContent GetBlockGridHtml(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias, string template)
+    {
+        IPublishedProperty prop = GetRequiredProperty(contentItem, propertyAlias);
+        return GetBlockGridHtml(html, prop.GetValue() as BlockGridModel, template, prop.Alias, prop.PropertyType.EditableInVisualEditor);
+    }
+
+    private static IHtmlContent GetBlockGridHtml(IHtmlHelper html, BlockGridModel? model, string template, string propertyAlias, bool editableInVisualEditor)
+    {
+        if (model is null || model.Count == 0)
+        {
+            return BlockEmptyState.Container("umb-block-grid", propertyAlias, editableInVisualEditor);
+        }
+
+        return html.Partial(DefaultFolderTemplate(template), model);
+    }
+```
+
+(e) Remove the now-unused `WithPropertyAlias` private method (lines 139-140). Leave `GetBlockGridItemsHtmlAsync`/`GetBlockGridItemAreasHtmlAsync`/etc. and `GetRequiredProperty` unchanged. The model-only `GetBlockGridHtmlAsync(BlockGridModel? model, ...)` overload (lines 41-49) keeps its `model?.Count == 0 → HtmlString.Empty` form unchanged.
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~BlockGridTemplateExtensionsTests"`
+Expected: PASS (3 passed).
+
+- [ ] **Step 5: Build Web.Common**
+
+Run: `dotnet build src/Umbraco.Web.Common/Umbraco.Web.Common.csproj`
+Expected: 0 errors.
+
+- [ ] **Step 6: Commit (GATED)**
+
+```bash
+git add src/Umbraco.Web.Common/Extensions/BlockGridTemplateExtensions.cs tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/BlockGridTemplateExtensionsTests.cs
+git commit -m "feat(visual-editor): block grid helper emits empty-state affordance, drop ViewData plumbing"
+```
+
+---
+
+### Task 4: Single block helper emits the affordance
+
+**Files:**
+- Modify: `src/Umbraco.Web.Common/Extensions/SingleBlockTemplateExtensions.cs`
+- Test: `tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/SingleBlockTemplateExtensionsTests.cs`
+
+The single-block value is a `BlockListItem?`; empty = `null`. The alias-bearing overloads have the property even when the value is null.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/SingleBlockTemplateExtensionsTests.cs`:
+
+```csharp
+using System.IO;
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Models.Blocks;
+using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.Common.Extensions;
+
+[TestFixture]
+public class SingleBlockTemplateExtensionsTests
+{
+    [TearDown]
+    public void TearDown() => VisualEditorPropertyTracker.Disable();
+
+    private static string Render(IHtmlContent content)
+    {
+        using var writer = new StringWriter();
+        content.WriteTo(writer, HtmlEncoder.Default);
+        return writer.ToString();
+    }
+
+    private static IPublishedProperty NullEditableProperty(string alias, bool editable)
+    {
+        var propertyType = new Mock<IPublishedPropertyType>();
+        propertyType.SetupGet(x => x.Alias).Returns(alias);
+        propertyType.SetupGet(x => x.EditableInVisualEditor).Returns(editable);
+
+        var property = new Mock<IPublishedProperty>();
+        property.SetupGet(x => x.Alias).Returns(alias);
+        property.SetupGet(x => x.PropertyType).Returns(propertyType.Object);
+        property.Setup(x => x.GetValue(null, null)).Returns((object?)null);
+        return property.Object;
+    }
+
+    [Test]
+    public async Task Empty_Editable_Single_Block_In_VisualEditor_Emits_Annotated_Container()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockHtmlAsync(NullEditableProperty("hero", editable: true));
+        var html = Render(result);
+        Assert.That(html, Does.Contain("class=\"umb-single-block\""));
+        Assert.That(html, Does.Contain("data-umb-block-property=\"hero\""));
+    }
+
+    [Test]
+    public async Task Empty_NonEditable_Single_Block_Emits_Nothing()
+    {
+        VisualEditorPropertyTracker.Enable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockHtmlAsync(NullEditableProperty("hero", editable: false));
+        Assert.That(Render(result), Is.Empty);
+    }
+
+    [Test]
+    public async Task Empty_Single_Block_Outside_VisualEditor_Emits_Nothing()
+    {
+        VisualEditorPropertyTracker.Disable();
+        IHtmlContent result = await Mock.Of<IHtmlHelper>().GetBlockHtmlAsync(NullEditableProperty("hero", editable: true));
+        Assert.That(Render(result), Is.Empty);
+    }
+}
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~SingleBlockTemplateExtensionsTests"`
+Expected: FAIL (current helper returns `HtmlString.Empty` for null model).
+
+- [ ] **Step 3: Edit `SingleBlockTemplateExtensions.cs`**
+
+Change the alias-bearing overloads to pass the alias + editable flag through to a private method that emits the empty-state. The model-only overloads keep their `model is null → HtmlString.Empty` behaviour.
+
+Replace the async property/content overloads (lines 27-37) with:
+
+```csharp
+    public static async Task<IHtmlContent> GetBlockHtmlAsync(this IHtmlHelper html, IPublishedProperty property, string template = DefaultTemplate)
+        => await GetBlockHtmlAsync(html, property.GetValue() as BlockListItem, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+
+    public static async Task<IHtmlContent> GetBlockHtmlAsync(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias)
+        => await GetBlockHtmlAsync(html, contentItem, propertyAlias, DefaultTemplate);
+
+    public static async Task<IHtmlContent> GetBlockHtmlAsync(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias, string template)
+    {
+        IPublishedProperty property = GetRequiredProperty(contentItem, propertyAlias);
+        return await GetBlockHtmlAsync(html, property.GetValue() as BlockListItem, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+    }
+
+    private static async Task<IHtmlContent> GetBlockHtmlAsync(IHtmlHelper html, BlockListItem? model, string template, string propertyAlias, bool editableInVisualEditor)
+    {
+        if (model is null)
+        {
+            return BlockEmptyState.Container("umb-single-block", propertyAlias, editableInVisualEditor);
+        }
+
+        return await html.PartialAsync(DefaultFolderTemplate(template), model);
+    }
+```
+
+Replace the sync property/content overloads (lines 52-62) with:
+
+```csharp
+    public static IHtmlContent GetBlockHtml(this IHtmlHelper html, IPublishedProperty property, string template = DefaultTemplate)
+        => GetBlockHtml(html, property.GetValue() as BlockListItem, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+
+    public static IHtmlContent GetBlockHtml(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias)
+        => GetBlockHtml(html, contentItem, propertyAlias, DefaultTemplate);
+
+    public static IHtmlContent GetBlockHtml(this IHtmlHelper html, IPublishedContent contentItem, string propertyAlias, string template)
+    {
+        IPublishedProperty property = GetRequiredProperty(contentItem, propertyAlias);
+        return GetBlockHtml(html, property.GetValue() as BlockListItem, template, property.Alias, property.PropertyType.EditableInVisualEditor);
+    }
+
+    private static IHtmlContent GetBlockHtml(IHtmlHelper html, BlockListItem? model, string template, string propertyAlias, bool editableInVisualEditor)
+    {
+        if (model is null)
+        {
+            return BlockEmptyState.Container("umb-single-block", propertyAlias, editableInVisualEditor);
+        }
+
+        return html.Partial(DefaultFolderTemplate(template), model);
+    }
+```
+
+Leave the model-only `GetBlockHtmlAsync(BlockListItem? model, ...)` / `GetBlockHtml(BlockListItem? model, ...)` overloads (lines 17-25, 42-50), `SingleBlockPartialWithFallback`, `DefaultFolderTemplate`, and `GetRequiredProperty` unchanged.
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~SingleBlockTemplateExtensionsTests"`
+Expected: PASS (3 passed).
+
+- [ ] **Step 5: Build + commit (GATED)**
+
+```bash
+dotnet build src/Umbraco.Web.Common/Umbraco.Web.Common.csproj
+git add src/Umbraco.Web.Common/Extensions/SingleBlockTemplateExtensions.cs tests/Umbraco.Tests.UnitTests/Umbraco.Web.Common/Extensions/SingleBlockTemplateExtensionsTests.cs
+git commit -m "feat(visual-editor): single block helper emits empty-state affordance"
+```
+
+---
+
+### Task 5: Revert the views to their plain form
+
+**Files:**
+- Modify: `src/Umbraco.Web.UI/Views/Partials/blocklist/default.cshtml`
+- Modify: `src/Umbraco.Web.UI/Views/Partials/blockgrid/default.cshtml`
+- Modify: `src/Umbraco.Core/EmbeddedResources/BlockGrid/default.cshtml`
+
+These no longer carry empty-state logic — the helper handles it. (The `singleblock/default.cshtml` was never modified and stays as-is: the helper now handles the empty/null case before the partial is invoked, so the partial only ever renders a non-null block.)
+
+- [ ] **Step 1: Revert `blocklist/default.cshtml`**
+
+Replace the full contents of `src/Umbraco.Web.UI/Views/Partials/blocklist/default.cshtml` with:
+
+```razor
+@inherits Umbraco.Cms.Web.Common.Views.UmbracoViewPage<Umbraco.Cms.Core.Models.Blocks.BlockListModel>
+@{
+    if (Model?.Any() != true) { return; }
+}
+<div class="umb-block-list">
+    @foreach (var block in Model)
+    {
+        if (block?.ContentKey == null) { continue; }
+        var data = block.Content;
+
+        <div data-umb-block-key="@block.ContentKey" data-umb-content-type="@data.ContentType.Alias">
+            @await Html.PartialAsync("blocklist/Components/" + data.ContentType.Alias, block)
+        </div>
+    }
+</div>
+```
+
+(Note: the per-block `data-umb-block-key`/`data-umb-content-type` annotations on populated blocks are retained — they were present before the empty-state work and are needed for selecting existing blocks. Only the empty-state `data-umb-block-property` + ViewData read are removed.)
+
+- [ ] **Step 2: Revert `blockgrid/default.cshtml`**
+
+Replace the full contents of `src/Umbraco.Web.UI/Views/Partials/blockgrid/default.cshtml` with:
+
+```razor
+@using Umbraco.Extensions
+@inherits Umbraco.Cms.Web.Common.Views.UmbracoViewPage<Umbraco.Cms.Core.Models.Blocks.BlockGridModel>
+@{
+    if (Model?.Any() != true) { return; }
+    var gridColumns = Model.GridColumns?.ToString() ?? "12";
+}
+
+<div class="umb-block-grid" data-grid-columns="@(gridColumns)" style="--umb-block-grid--grid-columns: @(gridColumns);">
+    @await Html.GetBlockGridItemsHtmlAsync(Model)
+</div>
+```
+
+- [ ] **Step 3: Revert embedded `BlockGrid/default.cshtml`**
+
+Replace the full contents of `src/Umbraco.Core/EmbeddedResources/BlockGrid/default.cshtml` with the identical plain form:
+
+```razor
+@using Umbraco.Extensions
+@inherits Umbraco.Cms.Web.Common.Views.UmbracoViewPage<Umbraco.Cms.Core.Models.Blocks.BlockGridModel>
+@{
+    if (Model?.Any() != true) { return; }
+    var gridColumns = Model.GridColumns?.ToString() ?? "12";
+}
+
+<div class="umb-block-grid" data-grid-columns="@(gridColumns)" style="--umb-block-grid--grid-columns: @(gridColumns);">
+    @await Html.GetBlockGridItemsHtmlAsync(Model)
+</div>
+```
+
+- [ ] **Step 4: Confirm no remaining references to the removed ViewData keys**
+
+Run: `grep -rn "PropertyAliasViewDataKey\|umbBlockListPropertyAlias\|umbBlockGridPropertyAlias" src/`
+Expected: zero hits (the consts were removed in Tasks 2-3 and the views no longer read them).
+
+- [ ] **Step 5: Build Web.UI (validates compile; Razor is runtime-compiled)**
+
+Run: `dotnet build src/Umbraco.Web.UI/Umbraco.Web.UI.csproj`
+Expected: 0 errors. (Stop any running dev instance first to avoid DLL file-locks.)
+
+- [ ] **Step 6: Commit (GATED)**
+
+```bash
+git add src/Umbraco.Web.UI/Views/Partials/blocklist/default.cshtml src/Umbraco.Web.UI/Views/Partials/blockgrid/default.cshtml src/Umbraco.Core/EmbeddedResources/BlockGrid/default.cshtml
+git commit -m "refactor(visual-editor): revert block view empty-state boilerplate (now framework-emitted)"
+```
+
+---
+
+### Task 6: Guest — single-block empty-container branch
+
+**Files:**
+- Modify: `src/Umbraco.Web.UI.Client/src/apps/visual-editor/injected.ts`
+
+The guest already handles empty `.umb-block-list` and `.umb-block-grid` containers (unchanged — the helper now emits the same `data-umb-block-property` markup). Add a parallel branch for the single-block container class `umb-single-block`.
+
+- [ ] **Step 1: Add the single-block empty-container branch**
+
+In `insertAddButtons()`, immediately after the existing empty `.umb-block-grid` branch (the block that does `document.querySelectorAll<HTMLElement>('.umb-block-grid').forEach(...)`), add:
+
+```typescript
+		// Empty single block at root level. The container carries data-umb-block-property
+		// (emitted by the single block helper in visual-editor mode).
+		document.querySelectorAll<HTMLElement>('.umb-single-block').forEach((single) => {
+			if (single.querySelector(BLOCK_SELECTOR)) return; // Has a block
+			if (single.querySelector(`[${ADD_BTN_ATTR}]`)) return; // Already handled
+
+			const propertyAlias = single.dataset.umbBlockProperty || '';
+			if (!propertyAlias) return;
+
+			single.appendChild(
+				createEmptyPlaceholder(() => {
+					send({ type: 'umb:ve:block-add-to-property', propertyAlias, insertIndex: 0 });
+				}),
+			);
+		});
+```
+
+Also update the file-header doc comment line for `data-umb-block-property` to read: `Property alias on a block list, block grid, or single block container (empty-state block creation)`.
+
+- [ ] **Step 2: Build the client**
+
+Run: `cd src/Umbraco.Web.UI.Client && npm run build`
+Expected: tsc exits 0. (Allow up to 600000ms.)
+
+- [ ] **Step 3: Commit (GATED)**
+
+```bash
+git add src/Umbraco.Web.UI.Client/src/apps/visual-editor/injected.ts
+git commit -m "feat(visual-editor): single block empty-state add-content affordance (guest)"
+```
+
+---
+
+### Task 7: Element — single-block-aware add
+
+**Files:**
+- Modify: `src/Umbraco.Web.UI.Client/src/packages/documents/documents/workspace/views/visual-editor/document-workspace-view-visual-editor.element.ts`
+
+When the guest sends `umb:ve:block-add-to-property` for a single-block property, the element must create a single-block-shaped value (layout key `Umbraco.SingleBlock`). Today `#resolveBlockSchemaAlias` only maps grid vs list; extend it for single block so `addBlockToValue` writes the right layout key.
+
+- [ ] **Step 1: Confirm the single-block client constants**
+
+Run: `grep -rn "PROPERTY_EDITOR_SCHEMA_ALIAS\|PROPERTY_EDITOR_UI_ALIAS" src/Umbraco.Web.UI.Client/src/packages/block/block-single/`
+Expected: find the exported constants for the single block editor — the schema alias (value `Umbraco.SingleBlock`) and the UI alias (value `Umb.PropertyEditorUi.BlockSingle` or similar). Note their exact exported names and the import path (`@umbraco-cms/backoffice/block-single`). If the names differ from those used below, substitute the real names.
+
+- [ ] **Step 2: Extend `#resolveBlockSchemaAlias`**
+
+Add the import (next to the existing block-grid import):
+
+```typescript
+import {
+	UMB_BLOCK_SINGLE_PROPERTY_EDITOR_SCHEMA_ALIAS,
+	UMB_BLOCK_SINGLE_PROPERTY_EDITOR_UI_ALIAS,
+} from '@umbraco-cms/backoffice/block-single';
+```
+
+Replace `#resolveBlockSchemaAlias` with:
+
+```typescript
+	#resolveBlockSchemaAlias(propertyAlias: string): string {
+		const editorUiAlias = this.#structures.getDocumentProperty(propertyAlias)?.editorUiAlias ?? '';
+		if (editorUiAlias === UMB_BLOCK_GRID_PROPERTY_EDITOR_UI_ALIAS) {
+			return UMB_BLOCK_GRID_PROPERTY_EDITOR_SCHEMA_ALIAS;
+		}
+		if (editorUiAlias === UMB_BLOCK_SINGLE_PROPERTY_EDITOR_UI_ALIAS) {
+			return UMB_BLOCK_SINGLE_PROPERTY_EDITOR_SCHEMA_ALIAS;
+		}
+		return UMB_BLOCK_LIST_PROPERTY_EDITOR_SCHEMA_ALIAS;
+	}
+```
+
+(`addBlockToValue` keys its grid-specific layout logic on `UMB_BLOCK_GRID_PROPERTY_EDITOR_SCHEMA_ALIAS`; for the single-block alias it falls through to the plain list-shaped layout item, which matches `SingleBlockValue`'s `BlockValue<SingleBlockLayoutItem>` structure — one block under the `Umbraco.SingleBlock` layout key, no columnSpan/rowSpan.)
+
+- [ ] **Step 3: Build the client**
+
+Run: `cd src/Umbraco.Web.UI.Client && npm run build`
+Expected: tsc exits 0. (Allow up to 600000ms.) If the single-block constant names differ, fix the import to the real names found in Step 1.
+
+- [ ] **Step 4: Commit (GATED)**
+
+```bash
+git add src/Umbraco.Web.UI.Client/src/packages/documents/documents/workspace/views/visual-editor/document-workspace-view-visual-editor.element.ts
+git commit -m "feat(visual-editor): single-block-aware add for empty single block properties"
+```
+
+---
+
+### Task 8: Final verification + mark spec implemented
+
+- [ ] **Step 1: Unit tests**
+
+Run: `dotnet test tests/Umbraco.Tests.UnitTests --filter "FullyQualifiedName~TemplateExtensionsTests|FullyQualifiedName~BlockEmptyStateTests"`
+Expected: all helper + empty-state tests pass.
+
+- [ ] **Step 2: Full client build + lint**
+
+```bash
+cd src/Umbraco.Web.UI.Client
+npm run build
+npm run lint
+```
+Expected: build exits 0; lint reports no NEW errors in the visual-editor files (the `umb:ve:*` keys are already lint-exempt).
+
+- [ ] **Step 3: Full solution build**
+
+Run: `dotnet build umbraco.sln`
+Expected: 0 errors (pre-existing StyleCop warnings out of scope).
+
+- [ ] **Step 4: Manual smoke** (run the site, backoffice at https://localhost:44339/umbraco)
+
+1. Empty editable block **list** property → preview shows the annotated empty container with an "Add content" button; clicking it adds a block.
+2. Empty editable block **grid** property (e.g. Blogpost `bodyText`) → same.
+3. Empty editable **single block** property → same; clicking adds exactly one block.
+4. A **non-editable** empty block property → renders nothing, no affordance.
+5. A custom template that renders a block property via `@Html.GetBlock*HtmlAsync(Model, "alias")` → affordance appears with **no template code** for the empty state.
+6. Non-empty block properties render unchanged.
+
+- [ ] **Step 5: Update the design doc status**
+
+In `docs/plans/2026-06-12-visual-editor-block-empty-state-design.md` replace:
+
+```markdown
+**Status**: Approved design, pending implementation plan
+```
+
+with:
+
+```markdown
+**Status**: Implemented
+```
+
+- [ ] **Step 6: Commit (GATED)**
+
+```bash
+git add docs/plans/2026-06-12-visual-editor-block-empty-state-design.md
+git commit -m "docs(visual-editor): mark framework-emitted empty-block affordance implemented"
+```
+
+---
+
+## Self-review notes
+
+- **Spec coverage:** Component 1 (helper emits container) → Tasks 2-4 + the `BlockEmptyState` helper (Task 1); Component 2 (alias-bearing overloads only, no model metadata) → Tasks 2-4 pass alias + `EditableInVisualEditor` from the property; Component 3 (single block) → Tasks 4, 6, 7; Component 4 (guest/element) → Tasks 6-7; Component 5 (revert views) → Task 5; Testing → unit tests in Tasks 1-4 + manual in Task 8.
+- **Verify-at-execution (not placeholders):** the single-block client constant names (Task 7 Step 1) — exact exported names confirmed by grep before use.
+- **No model/creator/converter changes** — consistent with the singleton finding.
+- **Commits are GATED** per the user's "no commits yet" instruction — execute and review; commit only on approval.
@@ -53,11 +53,14 @@ public class SearchDataTypeItemController : DatatypeItemControllerBase
            return Ok(new PagedModel<DataTypeItemResponseModel> { Total = searchResult.Total });
        }

-        IEnumerable<IDataType> dataTypes = await _dataTypeService.GetAllAsync(searchResult.Items.Select(item => item.Key).ToArray());
+        Guid[] keys = searchResult.Items.Select(x => x.Key).ToArray();
+        IEnumerable<IDataType> dataTypes = await _dataTypeService.GetAllAsync(keys);
+        IEnumerable<IDataType> orderedDataTypes = OrderByRequestedIds(dataTypes, keys);
+
        var result = new PagedModel<DataTypeItemResponseModel>
        {
-            Items = _mapper.MapEnumerable<IDataType, DataTypeItemResponseModel>(dataTypes),
-            Total = searchResult.Total
+            Items = _mapper.MapEnumerable<IDataType, DataTypeItemResponseModel>(orderedDataTypes),
+            Total = searchResult.Total,
        };

        return Ok(result);
@@ -61,8 +61,9 @@ public class SearchElementItemController : ElementItemControllerBase
            .GetAll(UmbracoObjectTypes.Element, keys)
            .OfType<IElementEntitySlim>()
            .ToArray();
+        List<IElementEntitySlim> orderedElements = OrderByRequestedIds(elements, keys);

-        ElementItemResponseModel[] items = await Task.WhenAll(elements.Select(_elementPresentationFactory.CreateItemResponseModelAsync));
+        ElementItemResponseModel[] items = await Task.WhenAll(orderedElements.Select(_elementPresentationFactory.CreateItemResponseModelAsync));

        return Ok(
            new PagedModel<ElementItemResponseModel>
@@ -54,11 +54,14 @@ public class SearchMediaTypeItemController : MediaTypeItemControllerBase
            return Task.FromResult<IActionResult>(Ok(new PagedModel<MediaTypeItemResponseModel> { Total = searchResult.Total }));
        }

-        IEnumerable<IMediaType> mediaTypes = _mediaTypeService.GetMany(searchResult.Items.Select(item => item.Key).ToArray().EmptyNull());
+        Guid[] keys = searchResult.Items.Select(item => item.Key).ToArray();
+        IEnumerable<IMediaType> mediaTypes = _mediaTypeService.GetMany(keys.EmptyNull());
+        IEnumerable<IMediaType> orderedMediaTypes = OrderByRequestedIds(mediaTypes, keys);
+
        var result = new PagedModel<MediaTypeItemResponseModel>
        {
-            Items = _mapper.MapEnumerable<IMediaType, MediaTypeItemResponseModel>(mediaTypes),
-            Total = searchResult.Total
+            Items = _mapper.MapEnumerable<IMediaType, MediaTypeItemResponseModel>(orderedMediaTypes),
+            Total = searchResult.Total,
        };

        return Task.FromResult<IActionResult>(Ok(result));
@@ -32,6 +32,14 @@ public class SearchMemberTypeItemController : MemberTypeItemControllerBase
        _mapper = mapper;
    }

+    /// <summary>
+    /// Searches for member type items matching the specified query, with support for pagination.
+    /// </summary>
+    /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+    /// <param name="query">The search query used to filter member type items.</param>
+    /// <param name="skip">The number of items to skip before starting to collect the result set (used for pagination).</param>
+    /// <param name="take">The maximum number of items to return in the result set (used for pagination).</param>
+    /// <returns>A task representing the asynchronous operation. The task result contains an <see cref="IActionResult"/> with a <see cref="PagedModel{MemberTypeItemResponseModel}"/> containing the search results.</returns>
    [HttpGet("search")]
    [MapToApiVersion("1.0")]
    [ProducesResponseType(typeof(PagedModel<MemberTypeItemResponseModel>), StatusCodes.Status200OK)]
@@ -45,11 +53,14 @@ public class SearchMemberTypeItemController : MemberTypeItemControllerBase
            return Task.FromResult<IActionResult>(Ok(new PagedModel<MemberTypeItemResponseModel> { Total = searchResult.Total }));
        }

-        IEnumerable<IMemberType> memberTypes = _memberTypeService.GetMany(searchResult.Items.Select(item => item.Key).ToArray());
+        Guid[] keys = searchResult.Items.Select(item => item.Key).ToArray();
+        IEnumerable<IMemberType> memberTypes = _memberTypeService.GetMany(keys);
+        IEnumerable<IMemberType> orderedMemberTypes = OrderByRequestedIds(memberTypes, keys);
+
        var result = new PagedModel<MemberTypeItemResponseModel>
        {
-            Items = _mapper.MapEnumerable<IMemberType, MemberTypeItemResponseModel>(memberTypes),
-            Total = searchResult.Total
+            Items = _mapper.MapEnumerable<IMemberType, MemberTypeItemResponseModel>(orderedMemberTypes),
+            Total = searchResult.Total,
        };

        return Task.FromResult<IActionResult>(Ok(result));
@@ -2,6 +2,7 @@ using Asp.Versioning;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;

 namespace Umbraco.Cms.Api.Management.Controllers.RedirectUrlManagement;

@@ -32,11 +33,13 @@ public class DeleteByKeyRedirectUrlManagementController : RedirectUrlManagementC
    [MapToApiVersion("1.0")]
    [HttpDelete("{id:guid}")]
    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    [EndpointSummary("Deletes a redirect URL.")]
    [EndpointDescription("Deletes a redirect URL identified by the provided Id.")]
    public Task<IActionResult> DeleteByKey(CancellationToken cancellationToken, Guid id)
    {
-        _redirectUrlService.Delete(id);
-        return Task.FromResult<IActionResult>(Ok());
+        RedirectUrlOperationStatus status = _redirectUrlService.DeleteWithStatus(id);
+        return Task.FromResult(RedirectUrlOperationStatusResult(status));
    }
 }
@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Core.Services.OperationStatus;
 using Umbraco.Cms.Web.Common.Authorization;

 namespace Umbraco.Cms.Api.Management.Controllers.RedirectUrlManagement;
@@ -14,4 +16,31 @@ namespace Umbraco.Cms.Api.Management.Controllers.RedirectUrlManagement;
 [Authorize(Policy = AuthorizationPolicies.SectionAccessContent)]
 public class RedirectUrlManagementControllerBase : ManagementApiControllerBase
 {
+    /// <summary>
+    /// Maps a <see cref="RedirectUrlOperationStatus"/> to an appropriate <see cref="IActionResult"/>.
+    /// </summary>
+    /// <param name="status">The operation status to map.</param>
+    /// <returns>An <see cref="IActionResult"/> describing the outcome of the operation.</returns>
+    protected IActionResult RedirectUrlOperationStatusResult(RedirectUrlOperationStatus status) =>
+        OperationStatusResult(status, problemDetailsBuilder => status switch
+        {
+            RedirectUrlOperationStatus.Success => Ok(),
+            RedirectUrlOperationStatus.NotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The redirect URL could not be found")
+                .Build()),
+            RedirectUrlOperationStatus.CancelledByNotification => BadRequest(problemDetailsBuilder
+                .WithTitle("Cancelled by notification")
+                .WithDetail("A notification handler prevented the redirect URL operation.")
+                .Build()),
+            RedirectUrlOperationStatus.Unknown => StatusCode(
+                StatusCodes.Status500InternalServerError,
+                problemDetailsBuilder
+                    .WithTitle("Unknown error. Please see the log for more details.")
+                    .Build()),
+            _ => StatusCode(
+                StatusCodes.Status500InternalServerError,
+                problemDetailsBuilder
+                    .WithTitle("Unknown redirect URL operation status.")
+                    .Build()),
+        });
 }
@@ -8,67 +8,38 @@ using Umbraco.Cms.Core.Security;
 namespace Umbraco.Cms.Api.Management.Controllers.RedirectUrlManagement;

 /// <summary>
-/// Controller for setting the redirect URL tracking status.
+/// Controller for setting the redirect URL tracking status. Retained for backwards compatibility only;
+/// the endpoint no longer modifies any configuration.
 /// </summary>
 [ApiVersion("1.0")]
+[Obsolete("This controller is deprecated and no longer modifies the configuration. Set the Umbraco:CMS:WebRouting:DisableRedirectUrlTracking configuration key instead. Scheduled for removal in Umbraco 19.")]
 public class SetStatusRedirectUrlManagementController : RedirectUrlManagementControllerBase
 {
-    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
-    private readonly IConfigManipulator _configManipulator;
-
    /// <summary>
    /// Initializes a new instance of the <see cref="SetStatusRedirectUrlManagementController"/> class.
    /// </summary>
-    /// <param name="backOfficeSecurityAccessor">The back office security accessor.</param>
-    /// <param name="configManipulator">The configuration manipulator.</param>
+    /// <param name="backOfficeSecurityAccessor">Ignored. Retained for binary compatibility.</param>
+    /// <param name="configManipulator">Ignored. Retained for binary compatibility.</param>
    public SetStatusRedirectUrlManagementController(
+#pragma warning disable IDE0060 // Remove unused parameter
        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
        IConfigManipulator configManipulator)
+#pragma warning restore IDE0060 // Remove unused parameter
    {
-        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
-        _configManipulator = configManipulator;
    }

-    // TODO: Consider if we should even allow this, or only allow using the appsettings
-    // We generally don't want to edit the appsettings from our code.
-    // But maybe there is a valid use case for doing it on the fly.
    /// <summary>
-    /// Sets the redirect URL tracking status.
+    /// Deprecated. Returns an OK response without modifying any configuration. To toggle redirect URL tracking,
+    /// set the <c>Umbraco:CMS:WebRouting:DisableRedirectUrlTracking</c> configuration key instead.
    /// </summary>
    /// <param name="cancellationToken">The cancellation token for the HTTP request.</param>
-    /// <param name="status">The redirect status to set.</param>
-    /// <returns>An OK result if successful.</returns>
+    /// <param name="status">The redirect status (ignored).</param>
+    /// <returns>An OK result.</returns>
    [HttpPost("status")]
-    [EndpointSummary("Sets the redirect URL tracking status.")]
-    [EndpointDescription("Updates the redirect URL tracking configuration according to the provided status.")]
+    [EndpointSummary("Deprecated. No longer changes the redirect URL tracking status.")]
+    [EndpointDescription("This endpoint is deprecated and no longer modifies the configuration. To toggle redirect URL tracking, set the Umbraco:CMS:WebRouting:DisableRedirectUrlTracking configuration key instead.")]
    [MapToApiVersion("1.0")]
-    public async Task<IActionResult> SetStatus(CancellationToken cancellationToken, [FromQuery] RedirectStatus status)
-    {
-        // TODO: uncomment this when auth is implemented.
-        // var userIsAdmin = _backOfficeSecurityAccessor.BackOfficeSecurity?.CurrentUser?.IsAdmin();
-        // if (userIsAdmin is null or false)
-        // {
-        //     return Unauthorized();
-        // }
-
-        var enable = status switch
-        {
-            RedirectStatus.Enabled => true,
-            RedirectStatus.Disabled => false,
-            _ => throw new ArgumentOutOfRangeException(nameof(status), status, "Unknown redirect status")
-        };
-
-        // For now I'm not gonna change this to limit breaking, but it's weird to have a "disabled" switch,
-        // since you're essentially negating the boolean from the get go,
-        // it's much easier to reason with enabled = false == disabled.
-        await _configManipulator.SaveDisableRedirectUrlTrackingAsync(!enable);
-
-        // Taken from the existing implementation in RedirectUrlManagementController
-        // TODO this is ridiculous, but we need to ensure the configuration is reloaded, before this request is ended.
-        // otherwise we can read the old value in GetEnableState.
-        // The value is equal to JsonConfigurationSource.ReloadDelay
-        Thread.Sleep(250);
-
-        return Ok();
-    }
+    [Obsolete("This endpoint is deprecated and no longer modifies the configuration. Set the Umbraco:CMS:WebRouting:DisableRedirectUrlTracking configuration key instead. Scheduled for removal in Umbraco 19.")]
+    public Task<IActionResult> SetStatus(CancellationToken cancellationToken, [FromQuery] RedirectStatus status)
+        => Task.FromResult<IActionResult>(Ok());
 }
@@ -32,6 +32,14 @@ public class SearchTemplateItemController : TemplateItemControllerBase
        _mapper = mapper;
    }

+    /// <summary>
+    /// Searches for template items matching the specified query, with support for pagination.
+    /// </summary>
+    /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+    /// <param name="query">The search query used to filter template items.</param>
+    /// <param name="skip">The number of items to skip before starting to collect the result set (used for pagination).</param>
+    /// <param name="take">The maximum number of items to return in the result set (used for pagination).</param>
+    /// <returns>A task representing the asynchronous operation. The task result contains an <see cref="IActionResult"/> with a <see cref="PagedModel{TemplateItemResponseModel}"/> containing the search results.</returns>
    [HttpGet("search")]
    [MapToApiVersion("1.0")]
    [ProducesResponseType(typeof(PagedModel<TemplateItemResponseModel>), StatusCodes.Status200OK)]
@@ -45,11 +53,14 @@ public class SearchTemplateItemController : TemplateItemControllerBase
            return Ok(new PagedModel<TemplateItemResponseModel> { Total = searchResult.Total });
        }

-        IEnumerable<ITemplate> templates = await _templateService.GetAllAsync(searchResult.Items.Select(item => item.Key).ToArray());
+        Guid[] keys = searchResult.Items.Select(x => x.Key).ToArray();
+        IEnumerable<ITemplate> templates = await _templateService.GetAllAsync(keys);
+        IEnumerable<ITemplate> orderedTemplates = OrderByRequestedIds(templates, keys);
+
        var result = new PagedModel<TemplateItemResponseModel>
        {
-            Items = _mapper.MapEnumerable<ITemplate, TemplateItemResponseModel>(templates),
-            Total = searchResult.Total
+            Items = _mapper.MapEnumerable<ITemplate, TemplateItemResponseModel>(orderedTemplates),
+            Total = searchResult.Total,
        };

        return Ok(result);
@@ -0,0 +1,53 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.VisualEditor;
+using Umbraco.Cms.Core.PublishedCache;
+using Umbraco.Cms.Core.Templates;
+
+namespace Umbraco.Cms.Api.Management.Controllers.VisualEditor;
+
+/// <summary>
+/// Renders a document's template with the visual editor's unsaved values for live preview.
+/// </summary>
+[ApiVersion("1.0")]
+public class RenderVisualEditorController : VisualEditorControllerBase
+{
+    private readonly IVisualEditorRenderService _renderService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RenderVisualEditorController"/> class.
+    /// </summary>
+    /// <param name="renderService">The <see cref="IVisualEditorRenderService"/> used to render document templates with visual editor overrides.</param>
+    public RenderVisualEditorController(IVisualEditorRenderService renderService)
+        => _renderService = renderService;
+
+    /// <summary>
+    /// Renders a document's template with the unsaved property values supplied by the visual editor.
+    /// </summary>
+    /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+    /// <param name="requestModel">The model containing the document key, culture, segment, and property value overrides to render.</param>
+    /// <returns>
+    /// An <see cref="IActionResult"/> containing a <see cref="VisualEditorRenderResponseModel"/> with the rendered HTML on success.
+    /// </returns>
+    [HttpPost("render")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(VisualEditorRenderResponseModel), StatusCodes.Status200OK)]
+    [EndpointSummary("Renders a document with unsaved visual editor values.")]
+    public async Task<IActionResult> Render(
+        CancellationToken cancellationToken,
+        VisualEditorRenderRequestModel requestModel)
+    {
+        var overrides = requestModel.Values
+            .Select(v => new VisualEditorPropertyOverride(v.Alias, v.Value, v.Culture, v.Segment))
+            .ToList();
+
+        var html = await _renderService.RenderAsync(
+            requestModel.Unique,
+            requestModel.Culture,
+            requestModel.Segment,
+            overrides);
+
+        return Ok(new VisualEditorRenderResponseModel { Html = html });
+    }
+}
@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.VisualEditor;
+
+/// <summary>
+/// Base controller for visual editor management API endpoints.
+/// </summary>
+[VersionedApiBackOfficeRoute("visual-editor")]
+[ApiExplorerSettings(GroupName = "Visual Editor")]
+[Authorize(Policy = AuthorizationPolicies.BackOfficeAccess)]
+public abstract class VisualEditorControllerBase : ManagementApiControllerBase
+{
+}
@@ -5,6 +5,7 @@ using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Hosting;
 using Umbraco.Cms.Core.IO;
 using Umbraco.Cms.Web.Common.Hosting;
+using Umbraco.Cms.Web.Common.Middleware;

 namespace Umbraco.Extensions;

@@ -68,6 +69,10 @@ public static partial class UmbracoBuilderExtensions
        builder.Services.AddSingleton<IBackOfficeEnabledMarker, BackOfficeEnabledMarker>();

        builder.Services.AddUnique<IBackOfficePathGenerator, UmbracoBackOfficePathGenerator>();
+        // Registered here rather than in AddWebComponents because the middleware depends on
+        // IBackOfficePathGenerator (registered just above). DI scope validation would otherwise
+        // fail in Delivery-only/Website-only bootstraps that never call AddBackOffice().
+        builder.Services.AddSingleton<UmbracoBackOfficeCacheHeadersMiddleware>();
        builder.Services.AddUnique<IPhysicalFileSystem>(factory =>
        {
            var path = "~/";
@@ -118,7 +118,7 @@ internal abstract class ContentTypeEditingPresentationFactory<TContentType>
        {
            Alias = property.Alias,
            Appearance =
-                new ContentTypeEditingModels.PropertyTypeAppearance { LabelOnTop = property.Appearance.LabelOnTop },
+                new ContentTypeEditingModels.PropertyTypeAppearance { LabelOnTop = property.Appearance.LabelOnTop, EditableInVisualEditor = property.Appearance.EditableInVisualEditor },
            Name = property.Name,
            Validation = new ContentTypeEditingModels.PropertyTypeValidation
            {
@@ -1,5 +1,8 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Api.Management.ViewModels.DataType;
 using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.PropertyEditors;
 using Umbraco.Cms.Core.Serialization;
@@ -16,6 +19,7 @@ public class DataTypePresentationFactory : IDataTypePresentationFactory
    private readonly IDataValueEditorFactory _dataValueEditorFactory;
    private readonly IConfigurationEditorJsonSerializer _configurationEditorJsonSerializer;
    private readonly TimeProvider _timeProvider;
+    private readonly ILogger<DataTypePresentationFactory> _logger;

    /// <summary>
    /// Initializes a new instance of the <see cref="DataTypePresentationFactory"/> class, which is responsible for creating data type presentation models.
@@ -25,18 +29,46 @@ public class DataTypePresentationFactory : IDataTypePresentationFactory
    /// <param name="dataValueEditorFactory">Factory for creating data value editors.</param>
    /// <param name="configurationEditorJsonSerializer">Serializer for configuration editor JSON data.</param>
    /// <param name="timeProvider">Provides the current time for time-dependent operations.</param>
+    /// <param name="logger">The logger.</param>
    public DataTypePresentationFactory(
        IDataTypeContainerService dataTypeContainerService,
        PropertyEditorCollection propertyEditorCollection,
        IDataValueEditorFactory dataValueEditorFactory,
        IConfigurationEditorJsonSerializer configurationEditorJsonSerializer,
-        TimeProvider timeProvider)
+        TimeProvider timeProvider,
+        ILogger<DataTypePresentationFactory> logger)
    {
        _dataTypeContainerService = dataTypeContainerService;
        _propertyEditorCollection = propertyEditorCollection;
        _dataValueEditorFactory = dataValueEditorFactory;
        _configurationEditorJsonSerializer = configurationEditorJsonSerializer;
        _timeProvider = timeProvider;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DataTypePresentationFactory"/> class, which is responsible for creating data type presentation models.
+    /// </summary>
+    /// <param name="dataTypeContainerService">Service used to manage data type containers.</param>
+    /// <param name="propertyEditorCollection">A collection containing all available property editors.</param>
+    /// <param name="dataValueEditorFactory">Factory for creating data value editors.</param>
+    /// <param name="configurationEditorJsonSerializer">Serializer for configuration editor JSON data.</param>
+    /// <param name="timeProvider">Provides the current time for time-dependent operations.</param>
+    [Obsolete("Please use the constructor that takes all parameters. Scheduled for removal in Umbraco 19.")]
+    public DataTypePresentationFactory(
+        IDataTypeContainerService dataTypeContainerService,
+        PropertyEditorCollection propertyEditorCollection,
+        IDataValueEditorFactory dataValueEditorFactory,
+        IConfigurationEditorJsonSerializer configurationEditorJsonSerializer,
+        TimeProvider timeProvider)
+        : this(
+            dataTypeContainerService,
+            propertyEditorCollection,
+            dataValueEditorFactory,
+            configurationEditorJsonSerializer,
+            timeProvider,
+            StaticServiceProvider.Instance.GetRequiredService<ILogger<DataTypePresentationFactory>>())
+    {
    }

    /// <inheritdoc />
@@ -72,7 +104,6 @@ public class DataTypePresentationFactory : IDataTypePresentationFactory
            dataType.Key = requestModel.Id.Value;
        }

-
        return Attempt.SucceedWithStatus<IDataType, DataTypeOperationStatus>(DataTypeOperationStatus.Success, dataType);
    }

@@ -82,7 +113,7 @@ public class DataTypePresentationFactory : IDataTypePresentationFactory
        {
            try
            {
-                var parent = await _dataTypeContainerService.GetAsync(requestModel.Parent.Id);
+                EntityContainer? parent = await _dataTypeContainerService.GetAsync(requestModel.Parent.Id);

                return parent is null
                    ? Attempt.FailWithStatus(DataTypeOperationStatus.ParentNotFound, 0)
@@ -97,6 +128,7 @@ public class DataTypePresentationFactory : IDataTypePresentationFactory
        return Attempt.SucceedWithStatus(DataTypeOperationStatus.Success, Constants.System.Root);
    }

+    /// <inheritdoc/>
    public Task<Attempt<IDataType, DataTypeOperationStatus>> CreateAsync(UpdateDataTypeRequestModel requestModel, IDataType current)
    {
        if (!_propertyEditorCollection.TryGet(requestModel.EditorAlias, out IDataEditor? editor))
@@ -104,7 +136,7 @@ public class DataTypePresentationFactory : IDataTypePresentationFactory
            return Task.FromResult(Attempt.FailWithStatus<IDataType, DataTypeOperationStatus>(DataTypeOperationStatus.PropertyEditorNotFound, new DataType(new VoidEditor(_dataValueEditorFactory), _configurationEditorJsonSerializer) ));
        }

-        IDataType dataType = (IDataType)current.DeepClone();
+        var dataType = (IDataType)current.DeepClone();

        IDictionary<string, object> configurationData = MapConfigurationData(requestModel, editor);
        dataType.Name = requestModel.Name;
@@ -119,12 +151,26 @@ public class DataTypePresentationFactory : IDataTypePresentationFactory

    private ValueStorageType GetEditorValueStorageType(IDataEditor editor, IDictionary<string, object> configurationData)
    {
-        var configurationObject = editor.GetConfigurationEditor()
-            .ToConfigurationObject(configurationData, _configurationEditorJsonSerializer);
-
-        if (configurationObject is IConfigureValueType configureValueType)
+        // Only editors whose configuration object implements IConfigureValueType derive their storage
+        // type from the configuration. Building the typed configuration object can throw for editors
+        // whose stored configuration doesn't cleanly deserialize into their configuration type; that
+        // must not fail the save, so fall back to the value editor's value type in that case.
+        try
        {
-            return ValueTypes.ToStorageType(configureValueType.ValueType);
+            if (editor.GetConfigurationEditor().ToConfigurationObject(configurationData, _configurationEditorJsonSerializer)
+                is IConfigureValueType configureValueType)
+            {
+                return ValueTypes.ToStorageType(configureValueType.ValueType);
+            }
+        }
+        catch (Exception)
+        {
+            // Configuration editors are third-party and can throw anything when the stored configuration
+            // doesn't deserialize into their configuration type. Fall back to the value editor's value type
+            // rather than failing the save, but log so the misconfiguration remains observable.
+            _logger.LogError(
+                "Could not build the configuration object for editor {EditorAlias} to determine its value storage type; falling back to the value editor's value type.",
+                editor.Alias);
        }

        var valueType = editor.GetValueEditor().ValueType;
@@ -49,7 +49,8 @@ public abstract class ContentTypeMapDefinition<TContentType, TPropertyTypeModel,
                    },
                    Appearance = new PropertyTypeAppearance
                    {
-                        LabelOnTop = propertyType.LabelOnTop
+                        LabelOnTop = propertyType.LabelOnTop,
+                        EditableInVisualEditor = propertyType.EditableInVisualEditor,
                    }
                })
            .ToArray();
@@ -28924,8 +28924,8 @@
        "tags": [
          "Redirect Management"
        ],
-        "summary": "Sets the redirect URL tracking status.",
-        "description": "Updates the redirect URL tracking configuration according to the provided status.",
+        "summary": "Deprecated. No longer changes the redirect URL tracking status.",
+        "description": "This endpoint is deprecated and no longer modifies the configuration. To toggle redirect URL tracking, set the Umbraco:CMS:WebRouting:DisableRedirectUrlTracking configuration key instead.",
        "operationId": "PostRedirectManagementStatus",
        "parameters": [
          {
@@ -38519,6 +38519,76 @@
        ]
      }
    },
+    "/umbraco/management/api/v1/visual-editor/render": {
+      "post": {
+        "tags": [
+          "Visual Editor"
+        ],
+        "summary": "Renders a document with unsaved visual editor values.",
+        "operationId": "PostVisualEditorRender",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/VisualEditorRenderRequestModel"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "OK",
+            "headers": {
+              "Umb-Notifications": {
+                "description": "The list of notifications produced during the request.",
+                "schema": {
+                  "type": [
+                    "null",
+                    "array"
+                  ],
+                  "items": {
+                    "$ref": "#/components/schemas/NotificationHeaderModel"
+                  }
+                }
+              }
+            },
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/VisualEditorRenderResponseModel"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "The resource is protected and requires an authentication token"
+          },
+          "403": {
+            "description": "The authenticated user does not have access to this resource",
+            "headers": {
+              "Umb-Notifications": {
+                "description": "The list of notifications produced during the request.",
+                "schema": {
+                  "type": [
+                    "null",
+                    "array"
+                  ],
+                  "items": {
+                    "$ref": "#/components/schemas/NotificationHeaderModel"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "security": [
+          {
+            "Backoffice-User": []
+          }
+        ]
+      }
+    },
    "/umbraco/management/api/v1/item/webhook": {
      "get": {
        "tags": [
@@ -49208,12 +49278,16 @@
      },
      "PropertyTypeAppearanceModel": {
        "required": [
-          "labelOnTop"
+          "labelOnTop",
+          "editableInVisualEditor"
        ],
        "type": "object",
        "properties": {
          "labelOnTop": {
            "type": "boolean"
+          },
+          "editableInVisualEditor": {
+            "type": "boolean"
          }
        }
      },
@@ -53134,6 +53208,72 @@
          }
        }
      },
+      "VisualEditorPropertyValueModel": {
+        "required": [
+          "alias"
+        ],
+        "type": "object",
+        "properties": {
+          "alias": {
+            "type": "string"
+          },
+          "value": {},
+          "culture": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "segment": {
+            "type": [
+              "null",
+              "string"
+            ]
+          }
+        }
+      },
+      "VisualEditorRenderRequestModel": {
+        "required": [
+          "unique",
+          "values"
+        ],
+        "type": "object",
+        "properties": {
+          "unique": {
+            "type": "string",
+            "format": "uuid"
+          },
+          "culture": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "segment": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "values": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/VisualEditorPropertyValueModel"
+            }
+          }
+        }
+      },
+      "VisualEditorRenderResponseModel": {
+        "required": [
+          "html"
+        ],
+        "type": "object",
+        "properties": {
+          "html": {
+            "type": "string"
+          }
+        }
+      },
      "WebhookEventModel": {
        "required": [
          "eventName",
@@ -73,6 +73,6 @@ public sealed class BackOfficeAreaRoutes : SignalRRoutesBase, IAreaRoutes
                Controller = ControllerExtensions.GetControllerName<BackOfficeDefaultController>(),
                Action = nameof(BackOfficeDefaultController.Index),
            },
-            constraints: new { slug = @"^(section|preview|upgrade|install|oauth_complete|logout|error).*$" });
+            constraints: new { slug = @"^(section|preview|visual-editor|upgrade|install|oauth_complete|logout|error).*$" });
    }
 }
@@ -9,4 +9,9 @@ public class PropertyTypeAppearance
    /// Gets or sets a value indicating whether the label for the property type is displayed above the input.
    /// </summary>
    public bool LabelOnTop { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether this property type is editable in the visual editor.
+    /// </summary>
+    public bool EditableInVisualEditor { get; set; }
 }
@@ -0,0 +1,19 @@
+namespace Umbraco.Cms.Api.Management.ViewModels.VisualEditor;
+
+/// <summary>
+/// A single unsaved property value submitted for a visual editor preview render.
+/// </summary>
+public class VisualEditorPropertyValueModel
+{
+    /// <summary>Gets or sets the property alias.</summary>
+    public required string Alias { get; set; }
+
+    /// <summary>Gets or sets the editor-format value (raw string for simple editors, JSON for complex editors).</summary>
+    public object? Value { get; set; }
+
+    /// <summary>Gets or sets the culture this value applies to, or <c>null</c> for invariant.</summary>
+    public string? Culture { get; set; }
+
+    /// <summary>Gets or sets the segment this value applies to, or <c>null</c> for none.</summary>
+    public string? Segment { get; set; }
+}
@@ -0,0 +1,19 @@
+namespace Umbraco.Cms.Api.Management.ViewModels.VisualEditor;
+
+/// <summary>
+/// Request to render a document's template with unsaved visual editor values overlaid.
+/// </summary>
+public class VisualEditorRenderRequestModel
+{
+    /// <summary>Gets or sets the document key to render.</summary>
+    public Guid Unique { get; set; }
+
+    /// <summary>Gets or sets the culture to render, or <c>null</c> for the default/invariant.</summary>
+    public string? Culture { get; set; }
+
+    /// <summary>Gets or sets the segment to render, or <c>null</c> for none.</summary>
+    public string? Segment { get; set; }
+
+    /// <summary>Gets or sets the unsaved property values to overlay onto the draft content.</summary>
+    public IEnumerable<VisualEditorPropertyValueModel> Values { get; set; } = [];
+}
@@ -0,0 +1,10 @@
+namespace Umbraco.Cms.Api.Management.ViewModels.VisualEditor;
+
+/// <summary>
+/// The rendered HTML for a visual editor preview render request.
+/// </summary>
+public class VisualEditorRenderResponseModel
+{
+    /// <summary>Gets or sets the rendered page HTML.</summary>
+    public required string Html { get; set; }
+}
@@ -15,8 +15,9 @@ SQLite-specific EF Core provider for Umbraco CMS. Contains SQLite migrations and
 This is a thin provider project that implements SQLite-specific functionality for the EF Core persistence layer:

 1. **Migration Provider** - Executes SQLite-specific migrations
-2. **Migration Provider Setup** - Configures DbContext to use SQLite
+2. **Migration Provider Setup** - Configures DbContext to use SQLite (incl. transient-error retry)
 3. **Migrations** - SQLite-specific migration files for OpenIddict tables
+4. **Retrying Execution Strategy** - Retries transient SQLite lock errors on EF Core operations

 ### Folder Structure

@@ -30,7 +31,8 @@ Umbraco.Cms.Persistence.EFCore.Sqlite/
 │   └── UmbracoDbContextModelSnapshot.cs         # Current model state
 ├── EFCoreSqliteComposer.cs                       # DI registration
 ├── SqliteMigrationProvider.cs                    # IMigrationProvider impl
-└── SqliteMigrationProviderSetup.cs               # IMigrationProviderSetup impl
+├── SqliteMigrationProviderSetup.cs               # IMigrationProviderSetup impl
+└── SqliteRetryingExecutionStrategy.cs            # IExecutionStrategy for transient lock errors
 ```

 ### Relationship with Parent Project
@@ -65,7 +67,19 @@ Registers `IMigrationProvider` and `IMigrationProviderSetup` for SQLite.

 ### SqliteMigrationProviderSetup (line 11-14)

-Configures `DbContextOptionsBuilder` with `UseSqlite` and migrations assembly.
+Configures `DbContextOptionsBuilder` with `UseSqlite`, the migrations assembly, and the
+`SqliteRetryingExecutionStrategy` (see below). Invoked from
+`UmbracoDbContext.ConfigureOptions` for every `UmbracoDbContext` instance, so all EF Core
+access to the Umbraco database (including OpenIddict's token store) inherits the retry.
+
+### SqliteRetryingExecutionStrategy
+
+Custom `Microsoft.EntityFrameworkCore.Storage.ExecutionStrategy` that retries on transient
+SQLite errors (`SQLITE_BUSY`, `SQLITE_LOCKED`) using `SqliteExceptionExtensions.IsBusyOrLocked`
+from the parent project. Defaults inherit `ExecutionStrategy.DefaultMaxRetryCount` (6) and
+`ExecutionStrategy.DefaultMaxDelay` (30s), giving a ~56-second retry budget — see the class's
+XML doc for the rationale and the unattended-upgrade escape hatch for very long migrations.
+Added to resolve issue #22939 (OpenIddict token reads failing during long migrations).

 ---

@@ -122,7 +136,8 @@ All tables prefixed with `umbraco`:
 | File | Purpose |
 |------|---------|
 | `SqliteMigrationProvider.cs` | Migration execution |
-| `SqliteMigrationProviderSetup.cs` | DbContext configuration |
+| `SqliteMigrationProviderSetup.cs` | DbContext configuration (UseSqlite + retry strategy) |
+| `SqliteRetryingExecutionStrategy.cs` | Retry on transient SQLite BUSY/LOCKED errors |
 | `EFCoreSqliteComposer.cs` | DI registration |
 | `Migrations/*.cs` | Migration files |

@@ -1,5 +1,4 @@
 using Microsoft.EntityFrameworkCore;
-using Umbraco.Cms.Core;
 using Umbraco.Cms.Persistence.EFCore.Migrations;

 namespace Umbraco.Cms.Persistence.EFCore.Sqlite;
@@ -15,6 +14,15 @@ public class SqliteMigrationProviderSetup : IMigrationProviderSetup
    /// <inheritdoc />
    public void Setup(DbContextOptionsBuilder builder, string? connectionString)
    {
-        builder.UseSqlite(connectionString, x => x.MigrationsAssembly(GetType().Assembly.FullName));
+        builder.UseSqlite(connectionString, x =>
+        {
+            x.MigrationsAssembly(GetType().Assembly.FullName);
+
+            // Retry transient SQLite errors (BUSY / LOCKED). See SqliteRetryingExecutionStrategy
+            // for the rationale — long-running migrations or schema-modifying operations can
+            // briefly lock the database in a way that surfaces as a hard error to concurrent
+            // EF Core readers (notably OpenIddict token validation). See issue #22939.
+            x.ExecutionStrategy(deps => new SqliteRetryingExecutionStrategy(deps));
+        });
    }
 }
@@ -0,0 +1,71 @@
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace Umbraco.Cms.Persistence.EFCore.Sqlite;
+
+/// <summary>
+/// EF Core execution strategy that retries on transient SQLite errors (BUSY / LOCKED).
+/// </summary>
+/// <remarks>
+/// <para>
+/// SQLite serialises writers at the database level, and schema-modifying statements briefly
+/// block readers — even in WAL mode. Without retries, concurrent EF Core reads (for example
+/// OpenIddict's token validation against <c>umbracoOpenIddictTokens</c>) surface those
+/// transient locks as <see cref="SqliteException"/> and fail the caller's request.
+/// </para>
+/// <para>
+/// Microsoft does not ship a built-in execution strategy for SQLite (only the SQL Server
+/// equivalent), so we provide this one. It piggy-backs on <see cref="ExecutionStrategy"/>'s
+/// default exponential backoff and re-uses its inherited
+/// <see cref="ExecutionStrategy.DefaultMaxRetryCount"/> (6) and
+/// <see cref="ExecutionStrategy.DefaultMaxDelay"/> (30 seconds), which produce a delay
+/// schedule of roughly 0s, 1s, 3s, 7s, 15s, 30s — a ~56-second retry window.
+/// </para>
+/// <para>
+/// On top of those EF Core delays, <c>SQLITE_BUSY</c> (error 5) is also retried internally
+/// by Microsoft.Data.Sqlite for up to the connection's <c>Default Timeout</c> (30 seconds
+/// by default) per attempt. <c>SQLITE_LOCKED</c> (error 6) is not — it returns immediately,
+/// so EF Core's retry budget is the only buffer.
+/// </para>
+/// </remarks>
+public class SqliteRetryingExecutionStrategy : ExecutionStrategy
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SqliteRetryingExecutionStrategy"/> class
+    /// with default retry settings inherited from <see cref="ExecutionStrategy"/>.
+    /// </summary>
+    /// <param name="dependencies">Parameter object containing service dependencies.</param>
+    public SqliteRetryingExecutionStrategy(ExecutionStrategyDependencies dependencies)
+        : this(dependencies, DefaultMaxRetryCount, DefaultMaxDelay)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SqliteRetryingExecutionStrategy"/> class.
+    /// </summary>
+    /// <param name="dependencies">Parameter object containing service dependencies.</param>
+    /// <param name="maxRetryCount">The maximum number of retry attempts.</param>
+    /// <param name="maxRetryDelay">The maximum delay between retries.</param>
+    public SqliteRetryingExecutionStrategy(
+        ExecutionStrategyDependencies dependencies,
+        int maxRetryCount,
+        TimeSpan maxRetryDelay)
+        : base(dependencies, maxRetryCount, maxRetryDelay)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override bool ShouldRetryOn(Exception exception)
+    {
+        // EF Core wraps provider exceptions, so walk the inner-exception chain.
+        for (Exception? current = exception; current is not null; current = current.InnerException)
+        {
+            if (current is SqliteException sqlite && sqlite.IsBusyOrLocked())
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
@@ -184,17 +184,11 @@ internal sealed class SqliteEFCoreDistributedLockingMechanism<T> : IDistributedL
                        throw new ArgumentException($"LockObject with id={LockId} does not exist.");
                    }
                }
-                catch (SqliteException ex) when (IsBusyOrLocked(ex))
+                catch (SqliteException ex) when (ex.IsBusyOrLocked())
                {
                    throw new DistributedWriteLockTimeoutException(LockId);
                }
            });
        }
-
-        private static bool IsBusyOrLocked(SqliteException ex) =>
-            ex.SqliteErrorCode
-                is raw.SQLITE_BUSY
-                or raw.SQLITE_LOCKED
-                or raw.SQLITE_LOCKED_SHAREDCACHE;
    }
 }
@@ -0,0 +1,26 @@
+using Microsoft.Data.Sqlite;
+using SQLitePCL;
+
+namespace Umbraco.Cms.Persistence.EFCore;
+
+/// <summary>
+/// SQLite-specific exception helpers for code running on the EF Core persistence stack.
+/// </summary>
+/// <remarks>
+/// A parallel helper exists at <c>Umbraco.Cms.Persistence.Sqlite.Services.SqliteExceptionExtensions</c>
+/// for the NPoco stack. Both stacks are independent (neither references the other) so the small
+/// duplication is intentional — keeps the layering clean.
+/// </remarks>
+public static class SqliteExceptionExtensions
+{
+    /// <summary>
+    /// Determines if the SQLite exception is a BUSY or LOCKED error.
+    /// </summary>
+    /// <param name="ex">The SQLite exception to check.</param>
+    /// <returns><c>true</c> if the error is BUSY, LOCKED, or LOCKED_SHAREDCACHE; otherwise <c>false</c>.</returns>
+    public static bool IsBusyOrLocked(this SqliteException ex) =>
+        ex.SqliteErrorCode
+            is raw.SQLITE_BUSY
+            or raw.SQLITE_LOCKED
+            or raw.SQLITE_LOCKED_SHAREDCACHE;
+}
@@ -306,6 +306,8 @@ public class MyEntityCacheRefresher : CacheRefresherBase<MyEntityCacheRefresher>
   - `Attempt.Succeed(value)` / `Attempt.Fail<T>()`
   - `Attempt<Content, ContentEditingOperationStatus>` - typed result with status

+> Writing or reviewing a query with a `WHERE IN` on a runtime-sized collection? See "Avoiding the SQL Server 2100-parameter limit" in `/src/Umbraco.Infrastructure/CLAUDE.md` — that's where the full helper list (`Constants.Sql.MaxParameterCount`, `InGroupsOf`, NPoco's `FetchByGroups`) and the decision rules live.
+
 ### Configuration

 Configuration models in `/Configuration/Models`:
@@ -467,20 +467,6 @@ public static class DistributedCacheExtensions

    #endregion

-    #region ElementContainerCacheRefresher
-
-    /// <summary>
-    ///     Invalidates the id/key map for the specified deleted element containers (folders).
-    /// </summary>
-    /// <param name="dc">The distributed cache.</param>
-    /// <param name="deletedContainers">The element containers that were deleted.</param>
-    public static void RemoveElementContainerCache(this DistributedCache dc, IEnumerable<EntityContainer> deletedContainers)
-        => dc.RefreshByPayload(
-            ElementContainerCacheRefresher.UniqueId,
-            deletedContainers.Select(container => new ElementContainerCacheRefresher.JsonPayload(container.Id, container.Key)));
-
-    #endregion
-
    #region Published Snapshot

    /// <summary>
@@ -1,43 +0,0 @@
-using Umbraco.Cms.Core.Models;
-using Umbraco.Cms.Core.Notifications;
-using Umbraco.Extensions;
-
-namespace Umbraco.Cms.Core.Cache;
-
-/// <summary>
-/// Invalidates element caches when an element container (folder) is deleted, so that its key→id mapping
-/// is evicted from <see cref="Services.IIdKeyMap"/> on every server.
-/// </summary>
-/// <remarks>
-/// Element container deletions only publish <see cref="EntityContainerDeletedNotification"/> and an
-/// <see cref="ElementTreeChangeNotification"/> for the contained elements - never for the container node
-/// itself, so without this handler the container's stale id/key mapping survives until the next app
-/// restart (see #23072).
-/// </remarks>
-public sealed class ElementContainerDeletedDistributedCacheNotificationHandler
-    : DeletedDistributedCacheNotificationHandlerBase<EntityContainer, EntityContainerDeletedNotification>
-{
-    private readonly DistributedCache _distributedCache;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ElementContainerDeletedDistributedCacheNotificationHandler"/> class.
-    /// </summary>
-    /// <param name="distributedCache">The distributed cache.</param>
-    public ElementContainerDeletedDistributedCacheNotificationHandler(DistributedCache distributedCache)
-        => _distributedCache = distributedCache;
-
-    /// <inheritdoc />
-    protected override void Handle(IEnumerable<EntityContainer> entities, IDictionary<string, object?> state)
-    {
-        EntityContainer[] elementContainers = entities
-            .Where(container => container.ContainerObjectType == Constants.ObjectTypes.ElementContainer)
-            .ToArray();
-
-        if (elementContainers.Length == 0)
-        {
-            return;
-        }
-
-        _distributedCache.RemoveElementContainerCache(elementContainers);
-    }
-}
@@ -368,8 +368,17 @@ public class ObjectCacheAppCache : IAppPolicyCache, IDisposable
        }

        // Ensure key is removed from set when evicted from cache
-        return options.RegisterPostEvictionCallback((key, _, _, _) =>
+        return options.RegisterPostEvictionCallback((key, _, reason, _) =>
        {
+            // Removed and Replaced evictions don't need pruning here: the Remove/Clear call sites already
+            // prune the tracking set synchronously under the write lock, and a Replaced key still has a
+            // live entry (the synchronous Set re-added it). Pruning here instead runs on a background
+            // thread and races with that re-add, dropping a key whose entry is still cached. (#23064)
+            if (reason is EvictionReason.Removed or EvictionReason.Replaced)
+            {
+                return;
+            }
+
            try
            {
                if (_locker.TryEnterWriteLock(_writeLockTimeout) is false)
@@ -1,109 +0,0 @@
-using Umbraco.Cms.Core.Events;
-using Umbraco.Cms.Core.Notifications;
-using Umbraco.Cms.Core.Serialization;
-using Umbraco.Cms.Core.Services;
-
-namespace Umbraco.Cms.Core.Cache;
-
-/// <summary>
-/// Provides cache refresh functionality for element containers (folders).
-/// </summary>
-/// <remarks>
-/// A deleted container's node id is never reused, so its key→id mapping in <see cref="IIdKeyMap"/> must be
-/// evicted on every server. Otherwise a container recreated under the same key resolves to the stale id and
-/// the element tree's children query returns nothing until the next app restart. This refresher only evicts
-/// the id/key map - element data is unaffected by container changes, so it deliberately avoids the broader
-/// invalidation performed by <see cref="ElementCacheRefresher"/>.
-/// </remarks>
-public sealed class ElementContainerCacheRefresher : PayloadCacheRefresherBase<ElementContainerCacheRefresherNotification, ElementContainerCacheRefresher.JsonPayload>
-{
-    private readonly IIdKeyMap _idKeyMap;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ElementContainerCacheRefresher"/> class.
-    /// </summary>
-    public ElementContainerCacheRefresher(
-        AppCaches appCaches,
-        IJsonSerializer serializer,
-        IIdKeyMap idKeyMap,
-        IEventAggregator eventAggregator,
-        ICacheRefresherNotificationFactory factory)
-        : base(appCaches, serializer, eventAggregator, factory)
-        => _idKeyMap = idKeyMap;
-
-    #region Json
-
-    /// <summary>
-    /// Represents a JSON-serializable payload identifying an element container that changed.
-    /// </summary>
-    public class JsonPayload
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="JsonPayload"/> class.
-        /// </summary>
-        /// <param name="id">The unique integer identifier for the container.</param>
-        /// <param name="key">The unique GUID key associated with the container.</param>
-        public JsonPayload(int id, Guid key)
-        {
-            Id = id;
-            Key = key;
-        }
-
-        /// <summary>
-        /// Gets the unique integer identifier for the container.
-        /// </summary>
-        public int Id { get; }
-
-        /// <summary>
-        /// Gets the unique GUID key associated with the container.
-        /// </summary>
-        public Guid Key { get; }
-    }
-
-    #endregion
-
-    #region Define
-
-    /// <summary>
-    /// Represents a unique identifier for the cache refresher.
-    /// </summary>
-    public static readonly Guid UniqueId = Guid.Parse("9C9D8B0E-2F1A-4D63-9C2E-7E6B5A4F3C21");
-
-    /// <inheritdoc/>
-    public override Guid RefresherUniqueId => UniqueId;
-
-    /// <inheritdoc/>
-    public override string Name => "Element Container Cache Refresher";
-
-    #endregion
-
-    #region Refresher
-
-    /// <inheritdoc/>
-    public override void Refresh(JsonPayload[] payloads)
-    {
-        foreach (JsonPayload payload in payloads)
-        {
-            // Clearing by id also evicts the key→id direction, as the id/key map keeps both in sync.
-            _idKeyMap.ClearCache(payload.Id);
-        }
-
-        base.Refresh(payloads);
-    }
-
-    // These events should never trigger. Everything should be PAYLOAD/JSON.
-
-    /// <inheritdoc/>
-    public override void RefreshAll() => throw new NotSupportedException();
-
-    /// <inheritdoc/>
-    public override void Refresh(int id) => throw new NotSupportedException();
-
-    /// <inheritdoc/>
-    public override void Refresh(Guid id) => throw new NotSupportedException();
-
-    /// <inheritdoc/>
-    public override void Remove(int id) => throw new NotSupportedException();
-
-    #endregion
-}
@@ -36,6 +36,7 @@ public interface IConfigManipulator
    /// </summary>
    /// <param name="disable">The value to save.</param>
    /// <returns></returns>
+    [Obsolete("This method is no longer used by Umbraco. Set the Umbraco:CMS:WebRouting:DisableRedirectUrlTracking configuration key instead. Scheduled for removal in Umbraco 19.")]
    Task SaveDisableRedirectUrlTrackingAsync(bool disable);

    /// <summary>
@@ -316,6 +316,8 @@ public static class PublishedContentExtensions
    {
        IPublishedProperty? property = content.GetProperty(alias);

+        TrackVisualEditorAccess(property, alias, content.Key);
+
        // if we have a property, and it has a value, return that value
        if (property != null && property.HasValue(culture, segment))
        {
@@ -356,6 +358,8 @@ public static class PublishedContentExtensions
    {
        IPublishedProperty? property = content.GetProperty(alias);

+        TrackVisualEditorAccess(property, alias, content.Key);
+
        // if we have a property, and it has a value, return that value
        if (property != null && property.HasValue(culture, segment))
        {
@@ -373,6 +377,23 @@ public static class PublishedContentExtensions
        return property == null ? default : property.Value<T>(publishedValueFallback, culture, segment, fallback);
    }

+    /// <summary>
+    /// Records a visual editor property access for property types
+    /// that have been marked as editable in the visual editor.
+    /// </summary>
+    private static void TrackVisualEditorAccess(IPublishedProperty? property, string alias, Guid contentKey)
+    {
+        if (property is null || !VisualEditorPropertyTracker.IsEnabled)
+        {
+            return;
+        }
+
+        if (property.PropertyType.EditableInVisualEditor)
+        {
+            VisualEditorPropertyTracker.RecordAccess(alias, contentKey);
+        }
+    }
+
    #endregion

    #region IsSomething: misc.
@@ -730,6 +730,10 @@ public static partial class StringExtensions
    /// </summary>
    /// <param name="fileName">The file name to convert.</param>
    /// <returns>A friendly name with the extension stripped, underscores and dashes converted to spaces, and title case applied.</returns>
+    /// <remarks>
+    /// Mirrored client-side in <c>src/Umbraco.Web.UI.Client/src/packages/media/media/utils/to-friendly-name.function.ts</c>;
+    /// keep the two implementations in sync.
+    /// </remarks>
    public static string ToFriendlyName(this string fileName)
    {
        // strip the file extension
@@ -106,7 +106,7 @@ public interface IHostingEnvironment
    ///     content root are the same, however
    ///     in netcore the web root is /www therefore this will Map to a physical path within www.
    /// </remarks>
-    [Obsolete("Please use the MapPathWebRoot extension method on an instance of IWebHostEnvironment instead")]
+    [Obsolete("Please use the MapPathWebRoot extension method on an instance of IWebHostEnvironment instead. Scheduled for removal in Umbraco 20.")]
    string MapPathWebRoot(string path);

    /// <summary>
@@ -118,7 +118,7 @@ public interface IHostingEnvironment
    ///     in netcore the web root is /www therefore this will Map to a physical path within www.
    /// </remarks>
    [Obsolete(
-        "Please use the MapPathContentRoot extension method on an instance of IHostEnvironment (or IWebHostEnvironment) instead")]
+        "Please use the MapPathContentRoot extension method on an instance of IHostEnvironment (or IWebHostEnvironment) instead. Scheduled for removal in Umbraco 20.")]
    string MapPathContentRoot(string path);

    /// <summary>
@@ -9,4 +9,9 @@ public class PropertyTypeAppearance
    ///     Gets or sets a value indicating whether the label should be displayed above the property editor.
    /// </summary>
    public bool LabelOnTop { get; set; }
+
+    /// <summary>
+    ///     Gets or sets a value indicating whether this property type is editable in the visual editor.
+    /// </summary>
+    public bool EditableInVisualEditor { get; set; }
 }
@@ -58,6 +58,11 @@ public interface IPropertyType : IEntity, IRememberBeingDirty
    /// </summary>
    bool LabelOnTop { get; set; }

+    /// <summary>
+    ///     Gets or sets a value indicating whether this property type is editable in the visual editor.
+    /// </summary>
+    bool EditableInVisualEditor { get; set; }
+
    /// <summary>
    ///     Gets of sets the sort order of the property type.
    /// </summary>
@@ -21,6 +21,7 @@ public class PropertyType : EntityBase, IPropertyType, IEquatable<PropertyType>
    private Guid _dataTypeKey;
    private string? _description;
    private bool _labelOnTop;
+    private bool _editableInVisualEditor;
    private bool _mandatory;
    private string? _mandatoryMessage;
    private string _name;
@@ -225,6 +226,14 @@ public class PropertyType : EntityBase, IPropertyType, IEquatable<PropertyType>
        set => SetPropertyValueAndDetectChanges(value, ref _labelOnTop, nameof(LabelOnTop));
    }

+    /// <inheritdoc />
+    [DataMember]
+    public bool EditableInVisualEditor
+    {
+        get => _editableInVisualEditor;
+        set => SetPropertyValueAndDetectChanges(value, ref _editableInVisualEditor, nameof(EditableInVisualEditor));
+    }
+
    /// <inheritdoc />
    [DataMember]
    public int SortOrder
@@ -46,6 +46,11 @@ public interface IPublishedPropertyType
    /// </remarks>
    bool IsUserProperty { get; }

+    /// <summary>
+    ///     Gets a value indicating whether this property type is editable in the visual editor.
+    /// </summary>
+    bool EditableInVisualEditor => false;
+
    /// <summary>
    ///     Gets the content variations of the property type.
    /// </summary>
@@ -37,6 +37,7 @@ namespace Umbraco.Cms.Core.Models.PublishedContent
            : this(propertyType.Alias, propertyType.DataTypeId, true, propertyType.Variations, propertyValueConverters, publishedModelFactory, factory)
        {
            ContentType = contentType ?? throw new ArgumentNullException(nameof(contentType));
+            EditableInVisualEditor = propertyType.EditableInVisualEditor;
        }

        /// <summary>
@@ -94,6 +95,9 @@ namespace Umbraco.Cms.Core.Models.PublishedContent
        /// <inheritdoc />
        public bool IsUserProperty { get; }

+        /// <inheritdoc />
+        public bool EditableInVisualEditor { get; }
+
        /// <inheritdoc />
        public ContentVariation Variations { get; }

@@ -0,0 +1,66 @@
+namespace Umbraco.Cms.Core.Models.PublishedContent;
+
+/// <summary>
+/// Tracks property accesses during Razor rendering so that the visual editor
+/// can automatically wrap property output with annotation attributes.
+///
+/// <para>
+/// When <c>@Model.Title</c> or <c>@Model.Value("title")</c> is evaluated in a Razor view,
+/// the <c>Value()</c> extension method records the property alias and content key here.
+/// When Razor subsequently calls <c>Write()</c>, the recorded access is consumed and the output
+/// is wrapped with <c>data-umb-property</c> attributes.
+/// </para>
+/// </summary>
+public static class VisualEditorPropertyTracker
+{
+    private static readonly AsyncLocal<PropertyAccess?> _lastAccess = new();
+    private static readonly AsyncLocal<bool> _enabled = new();
+
+    /// <summary>
+    /// Enables tracking for the current async context.
+    /// Should be called when the request is in visual edit / preview mode.
+    /// </summary>
+    public static void Enable() => _enabled.Value = true;
+
+    /// <summary>
+    /// Disables tracking for the current async context. Pair with <see cref="Enable"/> in a finally block.
+    /// </summary>
+    public static void Disable() => _enabled.Value = false;
+
+    /// <summary>
+    /// Whether tracking is currently enabled for this async context.
+    /// </summary>
+    public static bool IsEnabled => _enabled.Value;
+
+    /// <summary>
+    /// Records a property access. Called from <c>Value()</c> / <c>Value&lt;T&gt;()</c> extension methods.
+    /// </summary>
+    public static void RecordAccess(string alias, Guid contentKey)
+    {
+        if (_enabled.Value)
+        {
+            _lastAccess.Value = new PropertyAccess(alias, contentKey);
+        }
+    }
+
+    /// <summary>
+    /// Consumes the last recorded access, returning it and clearing the state.
+    /// </summary>
+    public static PropertyAccess? ConsumeAccess()
+    {
+        PropertyAccess? access = _lastAccess.Value;
+        _lastAccess.Value = null;
+        return access;
+    }
+
+    /// <summary>
+    /// Clears any pending recorded access without consuming it.
+    /// </summary>
+    public static void Clear()
+        => _lastAccess.Value = null;
+
+    /// <summary>
+    /// Represents a recorded property access.
+    /// </summary>
+    public readonly record struct PropertyAccess(string Alias, Guid ContentKey);
+}
@@ -24,9 +24,4 @@ public enum TaggableObjectTypes
    /// Represents member entities (user accounts).
    /// </summary>
    Member,
-
-    /// <summary>
-    /// Represents element entities.
-    /// </summary>
-    Element,
 }
@@ -1,19 +0,0 @@
-using Umbraco.Cms.Core.Sync;
-
-namespace Umbraco.Cms.Core.Notifications;
-
-/// <summary>
-/// A notification that is used to trigger the Element Container Cache Refresher.
-/// </summary>
-public class ElementContainerCacheRefresherNotification : CacheRefresherNotification
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ElementContainerCacheRefresherNotification"/> class.
-    /// </summary>
-    /// <param name="messageObject">The refresher payload.</param>
-    /// <param name="messageType">Type of the cache refresher message, <see cref="MessageType"/>.</param>
-    public ElementContainerCacheRefresherNotification(object messageObject, MessageType messageType)
-        : base(messageObject, messageType)
-    {
-    }
-}
@@ -0,0 +1,30 @@
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Models;
+
+namespace Umbraco.Cms.Core.Notifications;
+
+/// <summary>
+///     Notification published after one or more redirect URLs have been deleted.
+/// </summary>
+public class RedirectUrlDeletedNotification : DeletedNotification<IRedirectUrl>
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="RedirectUrlDeletedNotification" /> class with a single redirect URL.
+    /// </summary>
+    /// <param name="target">The redirect URL that was deleted.</param>
+    /// <param name="messages">The event messages collection.</param>
+    public RedirectUrlDeletedNotification(IRedirectUrl target, EventMessages messages)
+        : base(target, messages)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="RedirectUrlDeletedNotification" /> class with multiple redirect URLs.
+    /// </summary>
+    /// <param name="target">The redirect URLs that were deleted.</param>
+    /// <param name="messages">The event messages collection.</param>
+    public RedirectUrlDeletedNotification(IEnumerable<IRedirectUrl> target, EventMessages messages)
+        : base(target, messages)
+    {
+    }
+}
@@ -0,0 +1,34 @@
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Models;
+
+namespace Umbraco.Cms.Core.Notifications;
+
+/// <summary>
+///     Notification published before one or more redirect URLs are deleted.
+/// </summary>
+/// <remarks>
+///     This notification is cancelable, allowing handlers to prevent the delete operation
+///     by setting <see cref="ICancelableNotification.Cancel" /> to <c>true</c>.
+/// </remarks>
+public class RedirectUrlDeletingNotification : DeletingNotification<IRedirectUrl>
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="RedirectUrlDeletingNotification" /> class with a single redirect URL.
+    /// </summary>
+    /// <param name="target">The redirect URL being deleted.</param>
+    /// <param name="messages">The event messages collection.</param>
+    public RedirectUrlDeletingNotification(IRedirectUrl target, EventMessages messages)
+        : base(target, messages)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="RedirectUrlDeletingNotification" /> class with multiple redirect URLs.
+    /// </summary>
+    /// <param name="target">The redirect URLs being deleted.</param>
+    /// <param name="messages">The event messages collection.</param>
+    public RedirectUrlDeletingNotification(IEnumerable<IRedirectUrl> target, EventMessages messages)
+        : base(target, messages)
+    {
+    }
+}
@@ -0,0 +1,30 @@
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Models;
+
+namespace Umbraco.Cms.Core.Notifications;
+
+/// <summary>
+///     Notification published after a redirect URL has been saved.
+/// </summary>
+public class RedirectUrlSavedNotification : SavedNotification<IRedirectUrl>
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="RedirectUrlSavedNotification" /> class.
+    /// </summary>
+    /// <param name="target">The redirect URL that was saved.</param>
+    /// <param name="messages">The event messages collection.</param>
+    public RedirectUrlSavedNotification(IRedirectUrl target, EventMessages messages)
+        : base(target, messages)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="RedirectUrlSavedNotification" /> class.
+    /// </summary>
+    /// <param name="target">The redirect URLs that were saved.</param>
+    /// <param name="messages">The event messages collection.</param>
+    public RedirectUrlSavedNotification(IEnumerable<IRedirectUrl> target, EventMessages messages)
+        : base(target, messages)
+    {
+    }
+}
@@ -0,0 +1,30 @@
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Models;
+
+namespace Umbraco.Cms.Core.Notifications;
+
+/// <summary>
+///     Notification published before a redirect URL is saved.
+/// </summary>
+public class RedirectUrlSavingNotification : SavingNotification<IRedirectUrl>
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="RedirectUrlSavingNotification" /> class.
+    /// </summary>
+    /// <param name="target">The redirect URL being saved.</param>
+    /// <param name="messages">The event messages collection.</param>
+    public RedirectUrlSavingNotification(IRedirectUrl target, EventMessages messages)
+        : base(target, messages)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="RedirectUrlSavingNotification" /> class.
+    /// </summary>
+    /// <param name="target">The redirect URLs being saved.</param>
+    /// <param name="messages">The event messages collection.</param>
+    public RedirectUrlSavingNotification(IEnumerable<IRedirectUrl> target, EventMessages messages)
+        : base(target, messages)
+    {
+    }
+}
@@ -0,0 +1,25 @@
+using Umbraco.Cms.Core.Models.PublishedContent;
+
+namespace Umbraco.Cms.Core.PublishedCache;
+
+/// <summary>
+/// Builds an <see cref="IPublishedContent"/> for the visual editor preview: the requested document's
+/// draft content with a set of unsaved property values overlaid on top, converted to their published form.
+/// </summary>
+public interface IVisualEditorContentFactory
+{
+    /// <summary>
+    /// Resolves the draft content for <paramref name="documentKey"/> and returns a preview
+    /// <see cref="IPublishedContent"/> whose overridden aliases yield the converted unsaved values.
+    /// Returns <c>null</c> if the document does not exist.
+    /// </summary>
+    /// <param name="documentKey">The key of the document whose draft content will be used as the base.</param>
+    /// <param name="overrides">The unsaved property values to overlay on top of the draft content.</param>
+    /// <returns>
+    /// A preview <see cref="IPublishedContent"/> with the overrides applied,
+    /// or <c>null</c> if the document cannot be resolved.
+    /// </returns>
+    Task<IPublishedContent?> CreateWithOverridesAsync(
+        Guid documentKey,
+        IReadOnlyCollection<VisualEditorPropertyOverride> overrides);
+}
@@ -0,0 +1,13 @@
+namespace Umbraco.Cms.Core.PublishedCache;
+
+/// <summary>
+/// A single unsaved property value to overlay onto draft content when rendering the visual editor preview.
+/// </summary>
+/// <param name="Alias">The property alias to override.</param>
+/// <param name="EditorValue">
+/// The editor-format value as held by the backoffice workspace. Complex editors (rich text, block list)
+/// expect their serialized JSON; plain editors (e.g. text box) expect the raw value.
+/// </param>
+/// <param name="Culture">The culture the override applies to, or <c>null</c> for invariant.</param>
+/// <param name="Segment">The segment the override applies to, or <c>null</c> for none.</param>
+public readonly record struct VisualEditorPropertyOverride(string Alias, object? EditorValue, string? Culture, string? Segment);
@@ -821,6 +821,7 @@ internal abstract class ContentTypeEditingServiceBase<TContentType, TContentType
        propertyType.Description = property.Description;
        propertyType.SortOrder = property.SortOrder;
        propertyType.LabelOnTop = property.Appearance.LabelOnTop;
+        propertyType.EditableInVisualEditor = property.Appearance.EditableInVisualEditor;

        propertyType.PropertyGroupId = propertyGroup is null
            ? null
@@ -1,5 +1,5 @@
-using System.Threading.Tasks;
 using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services.OperationStatus;

 namespace Umbraco.Cms.Core.Services;

@@ -15,26 +15,105 @@ public interface IRedirectUrlService : IService
    /// <param name="contentKey">The content unique key.</param>
    /// <param name="culture">The culture.</param>
    /// <remarks>Is a proper Umbraco route eg /path/to/foo or 123/path/tofoo.</remarks>
+    [Obsolete("Use RegisterWithStatus to support cancellation via notifications. Scheduled for removal in Umbraco 20.")]
    void Register(string url, Guid contentKey, string? culture = null);

+    /// <summary>
+    ///     Registers a redirect URL.
+    /// </summary>
+    /// <param name="oldUrl">The previous Umbraco URL route the redirect is being created from.</param>
+    /// <param name="contentKey">The content unique key.</param>
+    /// <param name="culture">The culture.</param>
+    /// <returns>
+    ///     An <see cref="Attempt{TResult,TStatus}" /> containing the registered redirect URL on success, or
+    ///     <see cref="RedirectUrlOperationStatus.CancelledByNotification" /> if a notification handler
+    ///     canceled the operation.
+    /// </returns>
+    // TODO (V20): Remove the default implementation, and rename this back to "Register" when the obsolete Register overload is removed.
+    Attempt<IRedirectUrl?, RedirectUrlOperationStatus> RegisterWithStatus(string oldUrl, Guid contentKey, string? culture = null)
+    {
+#pragma warning disable CS0618 // Type or member is obsolete
+        Register(oldUrl, contentKey, culture);
+#pragma warning restore CS0618 // Type or member is obsolete
+        return Attempt.SucceedWithStatus<IRedirectUrl?, RedirectUrlOperationStatus>(RedirectUrlOperationStatus.Success, null);
+    }
+
    /// <summary>
    ///     Deletes all redirect URLs for a given content.
    /// </summary>
    /// <param name="contentKey">The content unique key.</param>
+    [Obsolete("Use DeleteContentRedirectUrlsWithStatus to support cancellation via notifications. Scheduled for removal in Umbraco 20.")]
    void DeleteContentRedirectUrls(Guid contentKey);

+    /// <summary>
+    ///     Deletes all redirect URLs for a given content, returning the operation status.
+    /// </summary>
+    /// <param name="contentKey">The content unique key.</param>
+    /// <returns>
+    ///     <see cref="RedirectUrlOperationStatus.Success" /> on success, or
+    ///     <see cref="RedirectUrlOperationStatus.CancelledByNotification" /> if a notification handler
+    ///     canceled the operation.
+    /// </returns>
+    // TODO (V20): Remove the default implementation when the obsolete DeleteContentRedirectUrls overload is removed.
+    RedirectUrlOperationStatus DeleteContentRedirectUrlsWithStatus(Guid contentKey)
+    {
+#pragma warning disable CS0618 // Type or member is obsolete
+        DeleteContentRedirectUrls(contentKey);
+#pragma warning restore CS0618 // Type or member is obsolete
+        return RedirectUrlOperationStatus.Success;
+    }
+
    /// <summary>
    ///     Deletes a redirect URL.
    /// </summary>
    /// <param name="redirectUrl">The redirect URL to delete.</param>
+    [Obsolete("Use DeleteWithStatus(IRedirectUrl) to support cancellation via notifications. Scheduled for removal in Umbraco 20.")]
    void Delete(IRedirectUrl redirectUrl);

+    /// <summary>
+    ///     Deletes a redirect URL, returning the operation status.
+    /// </summary>
+    /// <param name="redirectUrl">The redirect URL to delete.</param>
+    /// <returns>
+    ///     <see cref="RedirectUrlOperationStatus.Success" /> on success, or
+    ///     <see cref="RedirectUrlOperationStatus.CancelledByNotification" /> if a notification handler
+    ///     canceled the operation.
+    /// </returns>
+    // TODO (V20): Remove the default implementation when the obsolete Delete(IRedirectUrl) overload is removed.
+    RedirectUrlOperationStatus DeleteWithStatus(IRedirectUrl redirectUrl)
+    {
+#pragma warning disable CS0618 // Type or member is obsolete
+        Delete(redirectUrl);
+#pragma warning restore CS0618 // Type or member is obsolete
+        return RedirectUrlOperationStatus.Success;
+    }
+
    /// <summary>
    ///     Deletes a redirect URL.
    /// </summary>
    /// <param name="id">The redirect URL identifier.</param>
+    [Obsolete("Use DeleteWithStatus(Guid) to support cancellation via notifications. Scheduled for removal in Umbraco 20.")]
    void Delete(Guid id);

+    /// <summary>
+    ///     Deletes a redirect URL by its identifier, returning the operation status.
+    /// </summary>
+    /// <param name="id">The redirect URL identifier.</param>
+    /// <returns>
+    ///     <see cref="RedirectUrlOperationStatus.Success" /> on success,
+    ///     <see cref="RedirectUrlOperationStatus.NotFound" /> if no redirect URL with the given identifier exists, or
+    ///     <see cref="RedirectUrlOperationStatus.CancelledByNotification" /> if a notification handler
+    ///     canceled the operation.
+    /// </returns>
+    // TODO (V20): Remove the default implementation when the obsolete Delete(Guid) overload is removed.
+    RedirectUrlOperationStatus DeleteWithStatus(Guid id)
+    {
+#pragma warning disable CS0618 // Type or member is obsolete
+        Delete(id);
+#pragma warning restore CS0618 // Type or member is obsolete
+        return RedirectUrlOperationStatus.Success;
+    }
+
    /// <summary>
    ///     Deletes all redirect URLs.
    /// </summary>
@@ -54,18 +54,6 @@ public interface ITagService : IService
    /// </summary>
    IEnumerable<TaggedEntity> GetTaggedMembersByTag(string tag, string? group = null, string? culture = null);

-    /// <summary>
-    ///     Gets all elements tagged with any tag in the specified group.
-    /// </summary>
-    // TODO (V19): Remove the default implementation from this interface.
-    IEnumerable<TaggedEntity> GetTaggedElementsByTagGroup(string group, string? culture = null) => [];
-
-    /// <summary>
-    ///     Gets all elements tagged with the specified tag.
-    /// </summary>
-    // TODO (V19): Remove the default implementation from this interface.
-    IEnumerable<TaggedEntity> GetTaggedElementsByTag(string tag, string? group = null, string? culture = null) => [];
-
    /// <summary>
    ///     Gets all tags.
    /// </summary>
@@ -112,12 +100,6 @@ public interface ITagService : IService
    /// </summary>
    IEnumerable<ITag> GetAllMemberTags(string? group = null, string? culture = null);

-    /// <summary>
-    ///     Gets all element tags.
-    /// </summary>
-    // TODO (V19): Remove the default implementation from this interface.
-    IEnumerable<ITag> GetAllElementTags(string? group = null, string? culture = null) => [];
-
    /// <summary>
    ///     Gets all tags attached to an entity via a property.
    /// </summary>
@@ -0,0 +1,27 @@
+namespace Umbraco.Cms.Core.Services.OperationStatus;
+
+/// <summary>
+///     Represents the status of a redirect URL operation.
+/// </summary>
+public enum RedirectUrlOperationStatus
+{
+    /// <summary>
+    ///     The operation completed successfully.
+    /// </summary>
+    Success,
+
+    /// <summary>
+    ///     The operation was cancelled by a notification handler.
+    /// </summary>
+    CancelledByNotification,
+
+    /// <summary>
+    ///     The operation failed because the redirect URL could not be found.
+    /// </summary>
+    NotFound,
+
+    /// <summary>
+    ///     An unknown error occurred during the operation.
+    /// </summary>
+    Unknown,
+}
@@ -1,8 +1,10 @@
 using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Persistence.Repositories;
 using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Core.Services.OperationStatus;

 namespace Umbraco.Cms.Core.Services;

@@ -25,45 +27,141 @@ internal sealed class RedirectUrlService : RepositoryService, IRedirectUrlServic
        _redirectUrlRepository = redirectUrlRepository;

    /// <inheritdoc/>
+    [Obsolete("Use RegisterWithStatus instead. Scheduled for removal in Umbraco 20.")]
    public void Register(string url, Guid contentKey, string? culture = null)
+        => RegisterWithStatus(url, contentKey, culture);
+
+    /// <inheritdoc/>
+    public Attempt<IRedirectUrl?, RedirectUrlOperationStatus> RegisterWithStatus(string oldUrl, Guid contentKey, string? culture = null)
    {
        using ICoreScope scope = ScopeProvider.CreateCoreScope();
-        IRedirectUrl? redir = _redirectUrlRepository.Get(url, contentKey, culture);
+        IRedirectUrl? redir = _redirectUrlRepository.Get(oldUrl, contentKey, culture);
        if (redir != null)
        {
            redir.CreateDateUtc = DateTime.UtcNow;
        }
        else
        {
-            redir = new RedirectUrl { Key = Guid.NewGuid(), Url = url, ContentKey = contentKey, Culture = culture };
+            redir = new RedirectUrl { Key = Guid.NewGuid(), Url = oldUrl, ContentKey = contentKey, Culture = culture };
+        }
+
+        // Use a detached EventMessages instance so a handler cancelling the save does not surface a
+        // notification in the backoffice. Redirect creation is a silent side-effect of publishing, so a
+        // cancellation is not something the editor triggered or can act on - unlike deletion (an explicit
+        // editor action), where the sibling methods deliberately use EventMessagesFactory.Get() instead.
+        var eventMessages = new EventMessages();
+        var savingNotification = new RedirectUrlSavingNotification(redir, eventMessages);
+
+        if (scope.Notifications.PublishCancelable(savingNotification))
+        {
+            scope.Complete();
+            return Attempt.FailWithStatus<IRedirectUrl?, RedirectUrlOperationStatus>(RedirectUrlOperationStatus.CancelledByNotification, redir);
        }

        _redirectUrlRepository.Save(redir);
+
+        scope.Notifications.Publish(new RedirectUrlSavedNotification(redir, eventMessages)
+                .WithStateFrom(savingNotification));
+
        scope.Complete();
+        return Attempt.SucceedWithStatus<IRedirectUrl?, RedirectUrlOperationStatus>(RedirectUrlOperationStatus.Success, redir);
    }

    /// <inheritdoc/>
-    public void Delete(IRedirectUrl redirectUrl)
+    [Obsolete("Use DeleteWithStatus(IRedirectUrl) instead. Scheduled for removal in Umbraco 20.")]
+    public void Delete(IRedirectUrl redirectUrl) => DeleteWithStatus(redirectUrl);
+
+    /// <inheritdoc/>
+    public RedirectUrlOperationStatus DeleteWithStatus(IRedirectUrl redirectUrl)
    {
        using ICoreScope scope = ScopeProvider.CreateCoreScope();
+        EventMessages eventMessages = EventMessagesFactory.Get();
+
+        var deletingNotification = new RedirectUrlDeletingNotification(redirectUrl, eventMessages);
+
+        if (scope.Notifications.PublishCancelable(deletingNotification))
+        {
+            scope.Complete();
+            return RedirectUrlOperationStatus.CancelledByNotification;
+        }
+
        _redirectUrlRepository.Delete(redirectUrl);
+
+        scope.Notifications.Publish(new RedirectUrlDeletedNotification(redirectUrl, eventMessages)
+            .WithStateFrom(deletingNotification));
+
        scope.Complete();
+        return RedirectUrlOperationStatus.Success;
    }

    /// <inheritdoc/>
-    public void Delete(Guid id)
+    [Obsolete("Use DeleteWithStatus(Guid) instead. Scheduled for removal in Umbraco 20.")]
+    public void Delete(Guid id) => DeleteWithStatus(id);
+
+    /// <inheritdoc/>
+    public RedirectUrlOperationStatus DeleteWithStatus(Guid id)
    {
        using ICoreScope scope = ScopeProvider.CreateCoreScope();
+
+        IRedirectUrl? redirectUrl = _redirectUrlRepository.Get(id);
+
+        if (redirectUrl is null)
+        {
+            scope.Complete();
+            return RedirectUrlOperationStatus.NotFound;
+        }
+
+        EventMessages eventMessages = EventMessagesFactory.Get();
+        var deletingNotification = new RedirectUrlDeletingNotification(redirectUrl, eventMessages);
+
+        if (scope.Notifications.PublishCancelable(deletingNotification))
+        {
+            scope.Complete();
+            return RedirectUrlOperationStatus.CancelledByNotification;
+        }
+
        _redirectUrlRepository.Delete(id);
+
+        scope.Notifications.Publish(new RedirectUrlDeletedNotification(redirectUrl, eventMessages)
+            .WithStateFrom(deletingNotification));
+
        scope.Complete();
+        return RedirectUrlOperationStatus.Success;
    }

    /// <inheritdoc/>
-    public void DeleteContentRedirectUrls(Guid contentKey)
+    [Obsolete("Use DeleteContentRedirectUrlsWithStatus instead. Scheduled for removal in Umbraco 20.")]
+    public void DeleteContentRedirectUrls(Guid contentKey) => DeleteContentRedirectUrlsWithStatus(contentKey);
+
+    /// <inheritdoc/>
+    public RedirectUrlOperationStatus DeleteContentRedirectUrlsWithStatus(Guid contentKey)
    {
        using ICoreScope scope = ScopeProvider.CreateCoreScope();
+
+        IRedirectUrl[] redirectUrls = _redirectUrlRepository.GetContentUrls(contentKey).ToArray();
+
+        if (redirectUrls.Length == 0)
+        {
+            scope.Complete();
+            return RedirectUrlOperationStatus.Success;
+        }
+
+        EventMessages eventMessages = EventMessagesFactory.Get();
+        var deletingNotification = new RedirectUrlDeletingNotification(redirectUrls, eventMessages);
+
+        if (scope.Notifications.PublishCancelable(deletingNotification))
+        {
+            scope.Complete();
+            return RedirectUrlOperationStatus.CancelledByNotification;
+        }
+
        _redirectUrlRepository.DeleteContentUrls(contentKey);
+
+        scope.Notifications.Publish(new RedirectUrlDeletedNotification(redirectUrls, eventMessages)
+            .WithStateFrom(deletingNotification));
+
        scope.Complete();
+        return RedirectUrlOperationStatus.Success;
    }

    /// <inheritdoc/>
@@ -101,24 +101,6 @@ public class TagService : RepositoryService, ITagService
        }
    }

-    /// <inheritdoc />
-    public IEnumerable<TaggedEntity> GetTaggedElementsByTagGroup(string group, string? culture = null)
-    {
-        using (ScopeProvider.CreateCoreScope(autoComplete: true))
-        {
-            return _tagRepository.GetTaggedEntitiesByTagGroup(TaggableObjectTypes.Element, group, culture);
-        }
-    }
-
-    /// <inheritdoc />
-    public IEnumerable<TaggedEntity> GetTaggedElementsByTag(string tag, string? group = null, string? culture = null)
-    {
-        using (ScopeProvider.CreateCoreScope(autoComplete: true))
-        {
-            return _tagRepository.GetTaggedEntitiesByTag(TaggableObjectTypes.Element, tag, group, culture);
-        }
-    }
-
    /// <inheritdoc />
    public IEnumerable<ITag> GetAllTags(string? group = null, string? culture = null)
    {
@@ -180,15 +162,6 @@ public class TagService : RepositoryService, ITagService
        }
    }

-    /// <inheritdoc />
-    public IEnumerable<ITag> GetAllElementTags(string? group = null, string? culture = null)
-    {
-        using (ScopeProvider.CreateCoreScope(autoComplete: true))
-        {
-            return _tagRepository.GetTagsForEntityType(TaggableObjectTypes.Element, group, culture);
-        }
-    }
-
    /// <inheritdoc />
    public IEnumerable<ITag> GetTagsForProperty(int contentId, string propertyTypeAlias, string? group = null, string? culture = null)
    {
@@ -0,0 +1,26 @@
+using Umbraco.Cms.Core.PublishedCache;
+
+namespace Umbraco.Cms.Core.Templates;
+
+/// <summary>
+/// Renders a document's assigned template to an HTML string using the visual editor's unsaved values,
+/// with property-access tracking enabled so the output carries <c>data-umb-*</c> annotations.
+/// </summary>
+public interface IVisualEditorRenderService
+{
+    /// <summary>
+    /// Renders the document identified by <paramref name="documentKey"/> with the supplied unsaved
+    /// <paramref name="overrides"/> overlaid. Returns the rendered HTML, or an empty string if the
+    /// document or its template cannot be resolved.
+    /// </summary>
+    /// <param name="documentKey">The key of the document to render.</param>
+    /// <param name="culture">The culture to render, or <c>null</c> for the default/invariant.</param>
+    /// <param name="segment">The segment to render, or <c>null</c> for none.</param>
+    /// <param name="overrides">The unsaved editor values to overlay onto the draft content.</param>
+    /// <returns>The rendered page HTML, or an empty string if the document or template is unavailable.</returns>
+    Task<string> RenderAsync(
+        Guid documentKey,
+        string? culture,
+        string? segment,
+        IReadOnlyCollection<VisualEditorPropertyOverride> overrides);
+}
@@ -54,7 +54,7 @@ public static class UmbracoBuilderExtensions
                .DeliveryApiContentIndexName)
            .ConfigureOptions<ConfigureIndexOptions>();

-        services.AddSingleton<IApplicationRoot, UmbracoApplicationRoot>();
+        services.AddSingleton<IApplicationRoot>(sp => ActivatorUtilities.CreateInstance<UmbracoApplicationRoot>(sp));
        services.AddSingleton<ILockFactory, UmbracoLockFactory>();
        services.AddSingleton<ConfigurationEnabledDirectoryFactory>();

@@ -55,7 +55,9 @@ public class LuceneIndexDiagnostics : IIndexDiagnostics
            Directory luceneDir = Index.GetLuceneDirectory();
            var d = new Dictionary<string, object?>
            {
+#pragma warning disable CS0618 // CommitCount is obsolete and reported unused, but retained to avoid any risk of change to existing behaviour. Remove this entry when a future Examine upgrade removes the underlying field.
                [nameof(UmbracoExamineIndex.CommitCount)] = Index.CommitCount,
+#pragma warning restore CS0618
                [nameof(UmbracoExamineIndex.DefaultAnalyzer)] = Index.DefaultAnalyzer.GetType().Name,
                ["LuceneDirectory"] = luceneDir.GetType().Name
            };
@@ -1,6 +1,10 @@
 using Examine;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 using Umbraco.Cms.Core;
-using Umbraco.Cms.Core.Hosting;
+using Umbraco.Cms.Core.DependencyInjection;
+using Umbraco.Cms.Core.Extensions;
+using IHostingEnvironment = Umbraco.Cms.Core.Hosting.IHostingEnvironment;

 namespace Umbraco.Cms.Infrastructure.Examine;

@@ -9,14 +13,24 @@ namespace Umbraco.Cms.Infrastructure.Examine;
 /// </summary>
 public class UmbracoApplicationRoot : IApplicationRoot
 {
-    private readonly IHostingEnvironment _hostingEnvironment;
+    private readonly IHostEnvironment _hostEnvironment;

+    // TODO (V20): Remove this obsolete constructor and the [ActivatorUtilitiesConstructor] attribute below.
+    // Also revert the registration in UmbracoBuilderExtensions to:
+    //   services.AddSingleton<IApplicationRoot, UmbracoApplicationRoot>();
+    // (the factory form is required so [ActivatorUtilitiesConstructor] is honored).
+    [Obsolete("Use the constructor accepting IHostEnvironment. Scheduled for removal in Umbraco 20.")]
    public UmbracoApplicationRoot(IHostingEnvironment hostingEnvironment)
-        => _hostingEnvironment = hostingEnvironment;
+        : this(StaticServiceProvider.Instance.GetRequiredService<IHostEnvironment>())
+    {
+    }
+
+    [ActivatorUtilitiesConstructor]
+    public UmbracoApplicationRoot(IHostEnvironment hostEnvironment)
+        => _hostEnvironment = hostEnvironment;

    public DirectoryInfo ApplicationRoot
-        => new(
-            Path.Combine(
-                _hostingEnvironment.MapPathContentRoot(Constants.SystemDirectories.TempData),
-                "ExamineIndexes"));
+        => new(Path.Combine(
+            _hostEnvironment.MapPathContentRoot(Constants.SystemDirectories.TempData),
+            "ExamineIndexes"));
 }
@@ -1,5 +1,9 @@
 using Examine;
+using Examine.Lucene;
 using Examine.Lucene.Directories;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.DependencyInjection;
 using IHostingEnvironment = Umbraco.Cms.Core.Hosting.IHostingEnvironment;

 namespace Umbraco.Cms.Infrastructure.Examine
@@ -9,11 +13,25 @@ namespace Umbraco.Cms.Infrastructure.Examine
    /// </summary>
    public class UmbracoTempEnvFileSystemDirectoryFactory : FileSystemDirectoryFactory
    {
+        [Obsolete("Use the constructor accepting IOptionsMonitor<LuceneDirectoryIndexOptions>. Scheduled for removal in Umbraco 20.")]
        public UmbracoTempEnvFileSystemDirectoryFactory(
            IApplicationIdentifier applicationIdentifier,
            ILockFactory lockFactory,
            IHostingEnvironment hostingEnvironment)
-            : base(new DirectoryInfo(GetTempPath(applicationIdentifier, hostingEnvironment)), lockFactory)
+            : this(
+                applicationIdentifier,
+                lockFactory,
+                hostingEnvironment,
+                StaticServiceProvider.Instance.GetRequiredService<IOptionsMonitor<LuceneDirectoryIndexOptions>>())
+        {
+        }
+
+        public UmbracoTempEnvFileSystemDirectoryFactory(
+            IApplicationIdentifier applicationIdentifier,
+            ILockFactory lockFactory,
+            IHostingEnvironment hostingEnvironment,
+            IOptionsMonitor<LuceneDirectoryIndexOptions> indexOptions)
+            : base(new DirectoryInfo(GetTempPath(applicationIdentifier, hostingEnvironment)), lockFactory, indexOptions)
        {
        }

@@ -384,6 +384,57 @@ using (ICoreScope scope = ScopeProvider.CreateCoreScope())
 3. **Lazy loading outside scope** - NPoco relationships must load within scope
 4. **Large migrations** - Split into multiple steps if > 1000 lines
 5. **Repository logic in services** - Keep repos thin, logic in services
+6. **Unbatched `WHERE IN` on user-sized collections** - See "Avoiding the SQL Server 2100-parameter limit" below
+
+### Avoiding the SQL Server 2100-parameter limit
+
+SQL Server caps a single statement at 2100 parameters. When an `IN` clause is built from a collection sized by user data, that cap can be hit — and the symptom is a runtime `SqlException` (error 8003) on customer installs that nobody hit in dev.
+
+**The constant and helpers**:
+- `Constants.Sql.MaxParameterCount = 2000` (in `Umbraco.Core`, `Constants-Sql.cs`) — the ceiling we target (2100 minus headroom for joined predicates already in the SQL).
+- `IEnumerable<T>.InGroupsOf(groupSize)` (in `Umbraco.Core`, `Extensions/EnumerableExtensions.cs`) — extension method to batch a collection.
+- `Database.FetchByGroups<TResult, TSource>(source, groupSize, sqlFactory)` (in `Umbraco.Infrastructure`, `Persistence/NPocoDatabaseExtensions.cs`) — NPoco helper that batches a fetch.
+
+**The safe patterns** (use one of these any time the collection size is user-driven):
+
+```csharp
+// Pattern 1: batch a DeleteMany / Execute / Fetch by looping.
+foreach (IEnumerable<int> group in ids.InGroupsOf(Constants.Sql.MaxParameterCount))
+{
+    Database.DeleteMany<FooDto>().Where(x => group.Contains(x.Id)).Execute();
+}
+
+// Pattern 2: batched fetch with NPoco helper.
+List<FooDto> dtos = Database.FetchByGroups<FooDto, int>(
+    ids,
+    Constants.Sql.MaxParameterCount,
+    batch => Sql().Select<FooDto>().From<FooDto>().WhereIn<FooDto>(x => x.Id, batch));
+
+// Pattern 3: reserve headroom for other parameters in the same statement.
+foreach (IEnumerable<int> group in entityIds.InGroupsOf(Constants.Sql.MaxParameterCount - userGroupIds.Length))
+{
+    // statement uses entityIds + userGroupIds, so subtract the other predicate's parameter count from the budget
+}
+```
+
+**Decision rule when writing or reviewing a `WHERE IN`-style query**:
+
+Look at what drives the size of the collection feeding the `IN`. Ask: *could this realistically exceed 2000 on a large install?* Risky drivers — batch any query backed by these:
+- All content / media / member nodes (or descendants of a deep tree).
+- A product of two scaling dimensions, e.g. `documents × languages`, `properties × versions`, `relations × endpoints`.
+- Configuration-tunable batch sizes (`CacheSettings.DocumentSeedBatchSize`, `NuCacheSettings.SqlPageSize`, etc.). The default may be safe but the customer can raise it.
+- Anything that scans property data, version history, relations, or audit logs across many nodes.
+
+Safe drivers — don't bother batching:
+- Languages / content types / member groups / user groups — bounded by install configuration, typically <100.
+- "Per single content item" collections — properties on one document, versions of one document, tokens for one external login.
+- IDs supplied directly by a user action through the UI (picker selections, bulk actions on a page of results).
+
+If you're not sure, batch — the cost is one loop and an `IEnumerable<T>` allocation per batch; the cost of being wrong is a SqlException on a customer's biggest site.
+
+**For new public APIs** that take an `IEnumerable<int>`/`IEnumerable<Guid>` and feed it into a query, batch internally even if no current caller is large — package authors and future callers will not know about the 2000-limit ceiling.
+
+**Don't** rely on `if (ids.Length > MaxParameterCount) throw` as a substitute for batching. Throwing only moves the problem; the caller has no obvious way to recover and will most likely just fail in production.

 ---

@@ -104,6 +104,7 @@ internal sealed class JsonConfigManipulator : IConfigManipulator
    }

    /// <inheritdoc />
+    [Obsolete("This method is no longer used by Umbraco. Set the Umbraco:CMS:WebRouting:DisableRedirectUrlTracking configuration key instead. Scheduled for removal in Umbraco 19.")]
    public async Task SaveDisableRedirectUrlTrackingAsync(bool disable)
        => await CreateOrUpdateConfigValueAsync(DisableRedirectUrlTrackingPath, disable);

@@ -466,7 +466,6 @@ public static partial class UmbracoBuilderExtensions
            .AddNotificationHandler<MemberTypeChangedNotification, MemberTypeChangedDistributedCacheNotificationHandler>()
            .AddNotificationHandler<ContentTreeChangeNotification, ContentTreeChangeDistributedCacheNotificationHandler>()
            .AddNotificationHandler<ElementTreeChangeNotification, ElementTreeChangeDistributedCacheNotificationHandler>()
-            .AddNotificationHandler<EntityContainerDeletedNotification, ElementContainerDeletedDistributedCacheNotificationHandler>()
            ;

        // add notification handlers for auditing
@@ -52,8 +52,8 @@ internal sealed class DatabaseDataCreator
        },
        new()
        {
-            Name = "Find all logs that are from the namespace 'Umbraco.Core'",
-            Query = "StartsWith(SourceContext, 'Umbraco.Core')",
+            Name = "Find all logs that are within the namespace 'Umbraco.Cms'",
+            Query = "StartsWith(SourceContext, 'Umbraco.Cms')",
        },
        new()
        {
@@ -94,6 +94,7 @@ public partial class UmbracoPlan : MigrationPlan
        To<V_17_3_0.PopulateSortableValueForDatePropertyData>("{6748CB56-CC16-49F0-BA91-B8ECE31BF456}");

        // To 17.4.0
+        To<V_17_4_0.AddEditableInVisualEditorToPropertyType>("{C3D4E5F6-A7B8-49C0-D1E2-F3A4B5C6D7E8}");
        To<V_17_4_0.AddContentVersionDateIndex>("{D4E5F6A7-B8C9-4D0E-A1F2-3B4C5D6E7F80}");
        To<V_17_4_0.AddDimensionsToSvg>("{72970B86-59D8-403C-B322-FFF43F9DB199}");
        To<V_17_4_0.AddExternalMemberTables>("{D7E8F9A0-B1C2-4D3E-A5F6-7890ABCDEF12}");
@@ -0,0 +1,41 @@
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_17_4_0;
+
+/// <summary>
+/// Migration to add the editableInVisualEditor column to the cmsPropertyType table.
+/// </summary>
+public class AddEditableInVisualEditorToPropertyType : AsyncMigrationBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AddEditableInVisualEditorToPropertyType"/> class.
+    /// </summary>
+    /// <param name="context">The migration context.</param>
+    public AddEditableInVisualEditorToPropertyType(IMigrationContext context)
+        : base(context)
+    {
+    }
+
+    /// <inheritdoc/>
+    protected override async Task MigrateAsync()
+    {
+        if (TableExists(Constants.DatabaseSchema.Tables.PropertyType) is false)
+        {
+            return;
+        }
+
+        const string columnName = "editableInVisualEditor";
+        var hasColumn = Context.SqlContext.SqlSyntax.GetColumnsInSchema(Context.Database)
+            .Any(c =>
+                c.TableName == Constants.DatabaseSchema.Tables.PropertyType &&
+                c.ColumnName == columnName);
+
+        if (hasColumn)
+        {
+            return;
+        }
+
+        AddColumn<PropertyTypeDto>(Constants.DatabaseSchema.Tables.PropertyType, columnName);
+    }
+}
@@ -7,6 +7,7 @@ namespace Umbraco.Cms.Infrastructure.Notifications
    /// <summary>
    /// Notification that is raised when a recurring background job is triggered or executed.
    /// </summary>
+    // TODO (V19): Mark this class as abstract.
    public class RecurringBackgroundJobNotification : ObjectNotification<IRecurringBackgroundJob>
    {
        /// <summary>
@@ -114,6 +114,13 @@ internal class PropertyTypeDto
    [Constraint(Default = "0")]
    public bool LabelOnTop { get; set; }

+    /// <summary>
+    /// Gets or sets a value indicating whether this property type is editable in the visual editor.
+    /// </summary>
+    [Column("editableInVisualEditor")]
+    [Constraint(Default = "0")]
+    public bool EditableInVisualEditor { get; set; }
+
    /// <summary>
    /// Gets or sets the variation flags for the property type, indicating whether the property supports culture, segment, or invariant variations.
    /// The value corresponds to the <c>ContentVariation</c> enum.
@@ -90,6 +90,12 @@ internal sealed class PropertyTypeReadOnlyDto
    [Column("labelOnTop")]
    public bool LabelOnTop { get; set; }

+    /// <summary>
+    /// Gets or sets a value indicating whether this property type is editable in the visual editor.
+    /// </summary>
+    [Column("editableInVisualEditor")]
+    public bool EditableInVisualEditor { get; set; }
+
    /* cmsMemberType */

    /// <summary>
@@ -48,6 +48,7 @@ internal static class PropertyGroupFactory
            UniqueId = propertyType.Key,
            Variations = (byte)propertyType.Variations,
            LabelOnTop = propertyType.LabelOnTop,
+            EditableInVisualEditor = propertyType.EditableInVisualEditor,
        };

        if (groupId != default)
@@ -34,6 +34,7 @@ public sealed class PropertyTypeMapper : BaseMapper
        DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.ValidationRegExp), nameof(PropertyTypeDto.ValidationRegExp));
        DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.ValidationRegExpMessage), nameof(PropertyTypeDto.ValidationRegExpMessage));
        DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.LabelOnTop), nameof(PropertyTypeDto.LabelOnTop));
+        DefineMap<PropertyType, PropertyTypeDto>(nameof(PropertyType.EditableInVisualEditor), nameof(PropertyTypeDto.EditableInVisualEditor));
        DefineMap<PropertyType, DataTypeDto>(nameof(PropertyType.PropertyEditorAlias), nameof(DataTypeDto.EditorAlias));
        DefineMap<PropertyType, DataTypeDto>(nameof(PropertyType.ValueStorageType), nameof(DataTypeDto.DbType));
    }
@@ -440,6 +440,7 @@ internal sealed class ContentTypeCommonRepository : IContentTypeCommonRepository
            ValidationRegExpMessage = dto.ValidationRegExpMessage,
            Variations = (ContentVariation)dto.Variations,
            LabelOnTop = dto.LabelOnTop,
+            EditableInVisualEditor = dto.EditableInVisualEditor,
        };
    }
 }
@@ -249,14 +249,24 @@ internal sealed class RedirectUrlRepository : EntityRepositoryBase<Guid, IRedire

    protected override IEnumerable<IRedirectUrl> PerformGetAll(params Guid[]? ids)
    {
-        if (ids?.Length > Constants.Sql.MaxParameterCount)
+        if (ids is null || ids.Length == 0)
        {
-            throw new NotSupportedException(
-                $"This repository does not support more than {Constants.Sql.MaxParameterCount} ids.");
+            return Database.Fetch<RedirectUrlDto>(GetBaseQuery(false))
+                .WhereNotNull()
+                .Select(Map)
+                .WhereNotNull();
+        }
+
+        // Batch the WhereIn fetch so we never exceed SQL Server's 2100 parameter limit.
+        // EntityRepositoryBase.GetMany already groups IDs, but we keep the batching here as
+        // a defensive measure for safety and consistency at the repository boundary.
+        var dtos = new List<RedirectUrlDto>(ids.Length);
+        foreach (IEnumerable<Guid> group in ids.InGroupsOf(Constants.Sql.MaxParameterCount))
+        {
+            Sql<ISqlContext> sql = GetBaseQuery(false).WhereIn<RedirectUrlDto>(x => x.Id, group);
+            dtos.AddRange(Database.Fetch<RedirectUrlDto>(sql));
        }

-        Sql<ISqlContext> sql = GetBaseQuery(false).WhereIn<RedirectUrlDto>(x => x.Id, ids);
-        List<RedirectUrlDto> dtos = Database.Fetch<RedirectUrlDto>(sql);
        return dtos.WhereNotNull().Select(Map).WhereNotNull();
    }

@@ -647,8 +647,6 @@ ON (tagset.tag = {cmsTags}.tag AND tagset.{group} = {cmsTags}.{group} AND COALES
                return Constants.ObjectTypes.Media;
            case TaggableObjectTypes.Member:
                return Constants.ObjectTypes.Member;
-            case TaggableObjectTypes.Element:
-                return Constants.ObjectTypes.Element;
            default:
                throw new ArgumentOutOfRangeException(nameof(type));
        }
@@ -75,6 +75,7 @@ namespace Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement
            [
                sx.ColumnWithAlias("x", "otherId", "nodeId"),
                sx.ColumnWithAlias("n", "uniqueId", "nodeKey"),
+                sx.ColumnWithAlias("n", "text", "nodeName"),
                sx.ColumnWithAlias("n", "nodeObjectType", "nodeObjectType"),
                $"COALESCE({sx.ColumnWithAlias("d", "published")}, {sx.ColumnWithAlias("e", "published")}) AS nodePublished",
                sx.ColumnWithAlias("ctn", "uniqueId", "contentTypeKey"),
@@ -309,7 +309,7 @@ internal sealed class RedirectTracker : IRedirectTracker
                // to the original. We resolve this by removing any existing redirect that points to the new route.
                RemoveSelfReferencingRedirect(contentKey, newRoute);

-                _redirectUrlService.Register(oldRoute, contentKey, culture);
+                _redirectUrlService.RegisterWithStatus(oldRoute, contentKey, culture);
            }
            catch (Exception ex)
            {
@@ -341,7 +341,7 @@ internal sealed class RedirectTracker : IRedirectTracker
        {
            if (redirectUrl.Url == route)
            {
-                _redirectUrlService.Delete(redirectUrl.Key);
+                _redirectUrlService.DeleteWithStatus(redirectUrl.Key);
            }
        }
    }
@@ -122,11 +122,30 @@ internal sealed class IndexedEntitySearchService : IIndexedEntitySearchService
            .Where(key => key != Guid.Empty)
            .ToArray();

+        // EntityService.GetAll returns entities in database (not Lucene score) order, which
+        // would discard the relevance ranking. Re-order to match the search result sequence.
+        IEnumerable<IEntitySlim> orderedItems;
+        if (keys.Length > 0)
+        {
+            var keyOrder = new Dictionary<Guid, int>(keys.Length);
+            for (var i = 0; i < keys.Length; i++)
+            {
+                keyOrder.TryAdd(keys[i], i);
+            }
+
+            orderedItems = _entityService
+                .GetAll(objectType, keys)
+                .OrderBy(entity => keyOrder.TryGetValue(entity.Key, out var index) ? index : int.MaxValue)
+                .ToArray();
+        }
+        else
+        {
+            orderedItems = [];
+        }
+
        return Task.FromResult(new PagedModel<IEntitySlim>
        {
-            Items = keys.Any()
-                ? _entityService.GetAll(objectType, keys)
-                : Enumerable.Empty<IEntitySlim>(),
+            Items = orderedItems,
            Total = totalFound
        });
    }
@@ -47,30 +47,21 @@ public class LogViewerRepository : LogViewerRepositoryBase

            var filesForCurrentDay = Directory.GetFiles(_loggingConfiguration.LogDirectory, filesToFind);

-            // Foreach file we find - open it
+            // Foreach file we find - open it. Any failure reading a single file (open error,
+            // unrecoverable parse error, etc.) should not prevent the remaining files for the
+            // day or date range from being read.
            foreach (var filePath in filesForCurrentDay)
            {
-                // Open log file & add contents to the log collection
-                // Which we then use LINQ to page over
-                using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+                try
                {
-                    using (var stream = new StreamReader(fs))
-                    {
-                        var reader = new LogEventReader(stream);
-                        while (TryRead(reader, out LogEvent? evt))
-                        {
-                            // We may get a null if log line is malformed
-                            if (evt == null)
-                            {
-                                continue;
-                            }
-
-                            if (logFilter.TakeLogEvent(evt))
-                            {
-                                logs.Add(evt);
-                            }
-                        }
-                    }
+                    ReadLogFile(filePath, logFilter, logs);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(
+                        ex,
+                        "Skipped log file {FilePath} after a file-level error; the file may be inaccessible or unreadable.",
+                        filePath);
                }
            }
        }
@@ -88,6 +79,63 @@ public class LogViewerRepository : LogViewerRepositoryBase
            }).ToArray();
    }

+    private void ReadLogFile(string filePath, ILogFilter logFilter, List<LogEvent> logs)
+    {
+        using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+        using var stream = new StreamReader(fs);
+        var reader = new LogEventReader(stream);
+
+        var errorCount = 0;
+        Exception? firstError = null;
+
+        while (true)
+        {
+            LogEvent? evt;
+            try
+            {
+                if (!reader.TryRead(out evt))
+                {
+                    break;
+                }
+            }
+            catch (Exception ex) when (ex is Newtonsoft.Json.JsonException or InvalidDataException)
+            {
+                // Serilog.Formatting.Compact.Reader uses Newtonsoft.Json internally and surfaces
+                // its exceptions (Umbraco's own serialization is on System.Text.Json, but that
+                // doesn't apply here — we have to catch what the reader actually throws).
+                // JsonException covers parse failures (e.g. an unterminated string in a truncated
+                // entry); InvalidDataException covers structurally-valid JSON that isn't a valid
+                // Serilog Compact event. Either way the offending line has been consumed from the
+                // underlying StreamReader and the next TryRead call advances. Anything else
+                // (IOException, decoder failures, etc.) is propagated to the file-level catch in
+                // GetLogs so we don't risk a tight loop or silently swallow a more serious failure.
+                errorCount++;
+                firstError ??= ex;
+                continue;
+            }
+
+            // LogEventReader may return true with a null event for a benign skip.
+            if (evt is null)
+            {
+                continue;
+            }
+
+            if (logFilter.TakeLogEvent(evt))
+            {
+                logs.Add(evt);
+            }
+        }
+
+        if (errorCount > 0)
+        {
+            _logger.LogWarning(
+                firstError,
+                "Encountered {ErrorCount} unreadable line(s) while reading log file {FilePath}. The file may contain partially-written or corrupt entries; affected lines were skipped.",
+                errorCount,
+                filePath);
+        }
+    }
+
    private IReadOnlyDictionary<string, string?> MapLogMessageProperties(IReadOnlyDictionary<string, LogEventPropertyValue>? properties)
    {
        var result = new Dictionary<string, string?>();
@@ -121,21 +169,4 @@ public class LogViewerRepository : LogViewerRepositoryBase
    }

    private static string GetSearchPattern(DateTime day) => $"*{day:yyyyMMdd}*.json";
-
-    private bool TryRead(LogEventReader reader, out LogEvent? evt)
-    {
-        try
-        {
-            return reader.TryRead(out evt);
-        }
-        catch (Exception ex)
-        {
-            // As we are reading/streaming one line at a time in the JSON file
-            // Thus we can not report the line number, as it will always be 1
-            _logger.LogError(ex, "Unable to parse a line in the JSON log file");
-
-            evt = null;
-            return true;
-        }
-    }
 }
@@ -52,6 +52,7 @@ public static class UmbracoBuilderExtensions
        builder.Services.AddSingleton<IDomainCacheService, DomainCacheService>();
        builder.Services.AddSingleton<IPublishedContentFactory, PublishedContentFactory>();
        builder.Services.AddSingleton<ICacheNodeFactory, CacheNodeFactory>();
+        builder.Services.AddSingleton<IVisualEditorContentFactory, VisualEditorContentFactory>();
        builder.Services.AddSingleton<ICacheManager, CacheManager>();
        builder.Services.AddSingleton<IDatabaseCacheRebuilder, DatabaseCacheRebuilder>();
        builder.Services.AddSingleton<IDeferredCacheRebuildService, DeferredCacheRebuildService>();
@@ -317,21 +317,28 @@ internal sealed class DatabaseCacheRepository : RepositoryBase, IDatabaseCacheRe
    /// <inheritdoc/>
    public async Task<IEnumerable<ContentCacheNode>> GetDocumentSourcesAsync(IEnumerable<Guid> keys, bool preview = false)
    {
-        Sql<ISqlContext>? sql = SqlContentSourcesSelect()
-            .Append(SqlObjectTypeNotTrashed(SqlContext, Constants.ObjectTypes.Document))
-            .WhereIn<NodeDto>(x => x.UniqueId, keys)
-            .Append(SqlOrderByLevelIdSortOrder(SqlContext));
+        // Batch the WHERE IN to stay within SQL Server's parameter limit.
+        // The configurable document seed batch size is applied upstream; this method only enforces MaxParameterCount.
+        Guid[] keysArray = keys as Guid[] ?? keys.ToArray();
+        var dtos = new List<ContentSourceDto>(keysArray.Length);
+        foreach (IEnumerable<Guid> group in keysArray.InGroupsOf(Constants.Sql.MaxParameterCount))
+        {
+            Sql<ISqlContext>? sql = SqlContentSourcesSelect()
+                .Append(SqlObjectTypeNotTrashed(SqlContext, Constants.ObjectTypes.Document))
+                .WhereIn<NodeDto>(x => x.UniqueId, group)
+                .Append(SqlOrderByLevelIdSortOrder(SqlContext));

-        List<ContentSourceDto> dtos = await Database.FetchAsync<ContentSourceDto>(sql);
+            dtos.AddRange(await Database.FetchAsync<ContentSourceDto>(sql));
+        }

-        dtos = dtos
+        var filtered = dtos
            .Where(x => x is not null)
            .Where(x => preview || ((x.PubDataRaw is not null || x.PubData is not null) && (!x.Published || x.PubName is not null)))
            .ToList();

        IContentCacheDataSerializer serializer =
            _contentCacheDataSerializerFactory.Create(ContentCacheDataSerializerEntityType.Document);
-        return dtos
+        return filtered
            .Select(x => CreateContentNodeKit(x, serializer, preview))
            .OfType<ContentCacheNode>();
    }
@@ -496,20 +503,27 @@ internal sealed class DatabaseCacheRepository : RepositoryBase, IDatabaseCacheRe
    /// <inheritdoc/>
    public async Task<IEnumerable<ContentCacheNode>> GetMediaSourcesAsync(IEnumerable<Guid> keys)
    {
-        Sql<ISqlContext>? sql = SqlMediaSourcesSelect()
-            .Append(SqlObjectTypeNotTrashed(SqlContext, Constants.ObjectTypes.Media))
-            .WhereIn<NodeDto>(x => x.UniqueId, keys)
-            .Append(SqlOrderByLevelIdSortOrder(SqlContext));
+        // Batch the WHERE IN by Constants.Sql.MaxParameterCount so callers configuring
+        // CacheSettings.MediaSeedBatchSize above that limit do not hit SQL Server's 2100 parameter limit.
+        Guid[] keysArray = keys as Guid[] ?? keys.ToArray();
+        var dtos = new List<ContentSourceDto>(keysArray.Length);
+        foreach (IEnumerable<Guid> group in keysArray.InGroupsOf(Constants.Sql.MaxParameterCount))
+        {
+            Sql<ISqlContext>? sql = SqlMediaSourcesSelect()
+                .Append(SqlObjectTypeNotTrashed(SqlContext, Constants.ObjectTypes.Media))
+                .WhereIn<NodeDto>(x => x.UniqueId, group)
+                .Append(SqlOrderByLevelIdSortOrder(SqlContext));

-        List<ContentSourceDto> dtos = await Database.FetchAsync<ContentSourceDto>(sql);
+            dtos.AddRange(await Database.FetchAsync<ContentSourceDto>(sql));
+        }

-        dtos = dtos
+        var filtered = dtos
            .Where(x => x is not null)
            .ToList();

        IContentCacheDataSerializer serializer =
            _contentCacheDataSerializerFactory.Create(ContentCacheDataSerializerEntityType.Media);
-        return dtos
+        return filtered
            .Select(x => CreateMediaNodeKit(x, serializer));
    }

@@ -729,107 +743,135 @@ internal sealed class DatabaseCacheRepository : RepositoryBase, IDatabaseCacheRe
    /// </summary>
    private List<CacheRebuildPublishableContentDto> GetDocumentMetadataForNodes(List<int> nodeIds)
    {
-        // Query content metadata with both edit and published version info
+        // Query content metadata with both edit and published version info.
        // Uses nested join pattern to ensure we only get the published ContentVersion
-        // (where a DocumentVersionDto with Published=true exists)
-        Sql<ISqlContext> sql = Sql()
-            .Select<NodeDto>(
-                x => x.NodeId,
-                x => x.UniqueId,
-                x => x.Text,
-                x => x.Path,
-                x => x.Level,
-                x => x.ParentId,
-                x => x.SortOrder,
-                x => x.CreateDate,
-                x => Alias(x.UserId, "CreatorId"))
-            .AndSelect<ContentDto>(x => x.ContentTypeId)
-            .AndSelect<DocumentDto>(x => x.Published)
-            .AndSelect<ContentVersionDto>(
-                x => Alias(x.Id, "EditVersionId"),
-                x => Alias(x.Text, "EditName"),
-                x => Alias(x.VersionDate, "EditVersionDate"),
-                x => Alias(x.UserId, "EditWriterId"))
-            .AndSelect<ContentVersionDto>(
-                "pcv",
-                x => Alias(x.Id, "PublishedVersionId"),
-                x => Alias(x.Text, "PublishedName"),
-                x => Alias(x.VersionDate, "PublishedVersionDate"),
-                x => Alias(x.UserId, "PublishedWriterId"))
-            .From<NodeDto>()
-            .InnerJoin<ContentDto>().On<NodeDto, ContentDto>((n, c) => n.NodeId == c.NodeId)
-            .InnerJoin<DocumentDto>().On<NodeDto, DocumentDto>((n, d) => n.NodeId == d.NodeId)
-            .InnerJoin<ContentVersionDto>().On<NodeDto, ContentVersionDto>((n, cv) => n.NodeId == cv.NodeId && cv.Current)
+        // (where a DocumentVersionDto with Published=true exists).
+        // Batched on nodeIds so a NuCacheSettings.SqlPageSize larger than MaxParameterCount still works.
+        var results = new List<CacheRebuildPublishableContentDto>(nodeIds.Count);
+        foreach (IEnumerable<int> group in nodeIds.InGroupsOf(Constants.Sql.MaxParameterCount))
+        {
+            Sql<ISqlContext> sql = Sql()
+                .Select<NodeDto>(
+                    x => x.NodeId,
+                    x => x.UniqueId,
+                    x => x.Text,
+                    x => x.Path,
+                    x => x.Level,
+                    x => x.ParentId,
+                    x => x.SortOrder,
+                    x => x.CreateDate,
+                    x => Alias(x.UserId, "CreatorId"))
+                .AndSelect<ContentDto>(x => x.ContentTypeId)
+                .AndSelect<DocumentDto>(x => x.Published)
+                .AndSelect<ContentVersionDto>(
+                    x => Alias(x.Id, "EditVersionId"),
+                    x => Alias(x.Text, "EditName"),
+                    x => Alias(x.VersionDate, "EditVersionDate"),
+                    x => Alias(x.UserId, "EditWriterId"))
+                .AndSelect<ContentVersionDto>(
+                    "pcv",
+                    x => Alias(x.Id, "PublishedVersionId"),
+                    x => Alias(x.Text, "PublishedName"),
+                    x => Alias(x.VersionDate, "PublishedVersionDate"),
+                    x => Alias(x.UserId, "PublishedWriterId"))
+                .From<NodeDto>()
+                .InnerJoin<ContentDto>().On<NodeDto, ContentDto>((n, c) => n.NodeId == c.NodeId)
+                .InnerJoin<DocumentDto>().On<NodeDto, DocumentDto>((n, d) => n.NodeId == d.NodeId)
+                .InnerJoin<ContentVersionDto>().On<NodeDto, ContentVersionDto>((n, cv) => n.NodeId == cv.NodeId && cv.Current)

-            // Nested join: ContentVersionDto "pcv" INNER JOIN DocumentVersionDto "pdv" ON published=true
-            // This ensures pcv only includes rows where there's a published DocumentVersion
-            .LeftJoin<ContentVersionDto>(
-                j => j.InnerJoin<DocumentVersionDto>("pdv")
-                      .On<ContentVersionDto, DocumentVersionDto>(
-                          (left, right) => left.Id == right.Id && right.Published == true, "pcv", "pdv"),
-                "pcv")
+                // Nested join: ContentVersionDto "pcv" INNER JOIN DocumentVersionDto "pdv" ON published=true.
+                // This ensures pcv only includes rows where there's a published DocumentVersion.
+                .LeftJoin<ContentVersionDto>(
+                    j => j.InnerJoin<DocumentVersionDto>("pdv")
+                          .On<ContentVersionDto, DocumentVersionDto>(
+                              (left, right) => left.Id == right.Id && right.Published == true, "pcv", "pdv"),
+                    "pcv")

-            .On<NodeDto, ContentVersionDto>((n, cv) => n.NodeId == cv.NodeId, aliasRight: "pcv")
-            .WhereIn<NodeDto>(x => x.NodeId, nodeIds);
+                .On<NodeDto, ContentVersionDto>((n, cv) => n.NodeId == cv.NodeId, aliasRight: "pcv")
+                .WhereIn<NodeDto>(x => x.NodeId, group);

-        return Database.Fetch<CacheRebuildPublishableContentDto>(sql);
+            results.AddRange(Database.Fetch<CacheRebuildPublishableContentDto>(sql));
+        }
+
+        return results;
    }

    /// <summary>
    /// Gets property data for the specified node IDs using efficient JOIN on nodeId.
    /// This avoids the expensive WHERE IN on versionId that causes index scans.
+    /// Batched on nodeIds so a NuCacheSettings.SqlPageSize larger than MaxParameterCount still works.
    /// </summary>
    private List<CacheRebuildPropertyDto> GetPropertyDataForNodes(List<int> nodeIds)
    {
-        // JOIN through nodeId → versionId path for efficient query plan
-        Sql<ISqlContext> sql = Sql()
-            .Select<PropertyDataDto>(
-                x => x.VersionId,
-                x => x.LanguageId,
-                x => x.Segment,
-                x => x.IntegerValue,
-                x => x.DecimalValue,
-                x => x.DateValue,
-                x => x.VarcharValue,
-                x => x.TextValue)
-            .AndSelect<PropertyTypeDto>(x => Alias(x.Alias, "PropertyAlias"))
-            .From<PropertyDataDto>()
-            .InnerJoin<PropertyTypeDto>().On<PropertyDataDto, PropertyTypeDto>((pd, pt) => pd.PropertyTypeId == pt.Id)
-            .InnerJoin<ContentVersionDto>().On<PropertyDataDto, ContentVersionDto>((pd, cv) => pd.VersionId == cv.Id)
-            .WhereIn<ContentVersionDto>(x => x.NodeId, nodeIds);
+        var results = new List<CacheRebuildPropertyDto>();
+        foreach (IEnumerable<int> group in nodeIds.InGroupsOf(Constants.Sql.MaxParameterCount))
+        {
+            // JOIN through nodeId → versionId path for efficient query plan.
+            Sql<ISqlContext> sql = Sql()
+                .Select<PropertyDataDto>(
+                    x => x.VersionId,
+                    x => x.LanguageId,
+                    x => x.Segment,
+                    x => x.IntegerValue,
+                    x => x.DecimalValue,
+                    x => x.DateValue,
+                    x => x.VarcharValue,
+                    x => x.TextValue)
+                .AndSelect<PropertyTypeDto>(x => Alias(x.Alias, "PropertyAlias"))
+                .From<PropertyDataDto>()
+                .InnerJoin<PropertyTypeDto>().On<PropertyDataDto, PropertyTypeDto>((pd, pt) => pd.PropertyTypeId == pt.Id)
+                .InnerJoin<ContentVersionDto>().On<PropertyDataDto, ContentVersionDto>((pd, cv) => pd.VersionId == cv.Id)
+                .WhereIn<ContentVersionDto>(x => x.NodeId, group);

-        return Database.Fetch<CacheRebuildPropertyDto>(sql);
+            results.AddRange(Database.Fetch<CacheRebuildPropertyDto>(sql));
+        }
+
+        return results;
    }

    /// <summary>
    /// Gets culture variation data for the specified node IDs.
+    /// Batched on nodeIds so a NuCacheSettings.SqlPageSize larger than MaxParameterCount still works.
    /// </summary>
    private List<CacheRebuildCultureDto> GetCultureDataForNodes(List<int> nodeIds)
    {
-        Sql<ISqlContext> sql = Sql()
-            .Select<ContentVersionCultureVariationDto>(x => x.VersionId, x => x.Name, x => x.UpdateDate)
-            .AndSelect<LanguageDto>(x => Alias(x.IsoCode, "IsoCode"))
-            .From<ContentVersionCultureVariationDto>()
-            .InnerJoin<LanguageDto>().On<ContentVersionCultureVariationDto, LanguageDto>((cv, l) => cv.LanguageId == l.Id)
-            .InnerJoin<ContentVersionDto>().On<ContentVersionCultureVariationDto, ContentVersionDto>((ccv, cv) => ccv.VersionId == cv.Id)
-            .WhereIn<ContentVersionDto>(x => x.NodeId, nodeIds);
+        var results = new List<CacheRebuildCultureDto>();
+        foreach (IEnumerable<int> group in nodeIds.InGroupsOf(Constants.Sql.MaxParameterCount))
+        {
+            Sql<ISqlContext> sql = Sql()
+                .Select<ContentVersionCultureVariationDto>(x => x.VersionId, x => x.Name, x => x.UpdateDate)
+                .AndSelect<LanguageDto>(x => Alias(x.IsoCode, "IsoCode"))
+                .From<ContentVersionCultureVariationDto>()
+                .InnerJoin<LanguageDto>().On<ContentVersionCultureVariationDto, LanguageDto>((cv, l) => cv.LanguageId == l.Id)
+                .InnerJoin<ContentVersionDto>().On<ContentVersionCultureVariationDto, ContentVersionDto>((ccv, cv) => ccv.VersionId == cv.Id)
+                .WhereIn<ContentVersionDto>(x => x.NodeId, group);

-        return Database.Fetch<CacheRebuildCultureDto>(sql);
+            results.AddRange(Database.Fetch<CacheRebuildCultureDto>(sql));
+        }
+
+        return results;
    }

    /// <summary>
    /// Gets document culture variation data (edited status per culture) for the specified node IDs. Used for documents.
+    /// Batched on nodeIds so a NuCacheSettings.SqlPageSize larger than MaxParameterCount still works.
    /// </summary>
    private List<CacheRebuildPublishableCultureDto> GetDocumentCultureDataForNodes(List<int> nodeIds)
    {
-        Sql<ISqlContext> sql = Sql()
-            .Select<DocumentCultureVariationDto>(x => x.NodeId, x => x.Edited)
-            .AndSelect<LanguageDto>(x => Alias(x.IsoCode, "IsoCode"))
-            .From<DocumentCultureVariationDto>()
-            .InnerJoin<LanguageDto>().On<DocumentCultureVariationDto, LanguageDto>((dcv, l) => dcv.LanguageId == l.Id)
-            .WhereIn<DocumentCultureVariationDto>(x => x.NodeId, nodeIds);
+        var results = new List<CacheRebuildPublishableCultureDto>();
+        foreach (IEnumerable<int> group in nodeIds.InGroupsOf(Constants.Sql.MaxParameterCount))
+        {
+            Sql<ISqlContext> sql = Sql()
+                .Select<DocumentCultureVariationDto>(x => x.NodeId, x => x.Edited)
+                .AndSelect<LanguageDto>(x => Alias(x.IsoCode, "IsoCode"))
+                .From<DocumentCultureVariationDto>()
+                .InnerJoin<LanguageDto>().On<DocumentCultureVariationDto, LanguageDto>((dcv, l) => dcv.LanguageId == l.Id)
+                .WhereIn<DocumentCultureVariationDto>(x => x.NodeId, group);

-        return Database.Fetch<CacheRebuildPublishableCultureDto>(sql);
+            results.AddRange(Database.Fetch<CacheRebuildPublishableCultureDto>(sql));
+        }
+
+        return results;
    }

    /// <summary>
@@ -1358,31 +1400,38 @@ internal sealed class DatabaseCacheRepository : RepositoryBase, IDatabaseCacheRe

    /// <summary>
    /// Gets content metadata for the specified node IDs using efficient JOIN. Used for media and members.
+    /// Batched on nodeIds so a NuCacheSettings.SqlPageSize larger than MaxParameterCount still works.
    /// </summary>
    private List<CacheRebuildContentDto> GetContentMetadataForNodes(List<int> nodeIds)
    {
-        Sql<ISqlContext> sql = Sql()
-            .Select<NodeDto>(
-                x => x.NodeId,
-                x => x.UniqueId,
-                x => x.Text,
-                x => x.Path,
-                x => x.Level,
-                x => x.ParentId,
-                x => x.SortOrder,
-                x => x.CreateDate,
-                x => Alias(x.UserId, "CreatorId"))
-            .AndSelect<ContentDto>(x => x.ContentTypeId)
-            .AndSelect<ContentVersionDto>(
-                x => Alias(x.Id, "VersionId"),
-                x => Alias(x.VersionDate, "VersionDate"),
-                x => Alias(x.UserId, "WriterId"))
-            .From<NodeDto>()
-            .InnerJoin<ContentDto>().On<NodeDto, ContentDto>((n, c) => n.NodeId == c.NodeId)
-            .InnerJoin<ContentVersionDto>().On<NodeDto, ContentVersionDto>((n, cv) => n.NodeId == cv.NodeId && cv.Current)
-            .WhereIn<NodeDto>(x => x.NodeId, nodeIds);
+        var results = new List<CacheRebuildContentDto>(nodeIds.Count);
+        foreach (IEnumerable<int> group in nodeIds.InGroupsOf(Constants.Sql.MaxParameterCount))
+        {
+            Sql<ISqlContext> sql = Sql()
+                .Select<NodeDto>(
+                    x => x.NodeId,
+                    x => x.UniqueId,
+                    x => x.Text,
+                    x => x.Path,
+                    x => x.Level,
+                    x => x.ParentId,
+                    x => x.SortOrder,
+                    x => x.CreateDate,
+                    x => Alias(x.UserId, "CreatorId"))
+                .AndSelect<ContentDto>(x => x.ContentTypeId)
+                .AndSelect<ContentVersionDto>(
+                    x => Alias(x.Id, "VersionId"),
+                    x => Alias(x.VersionDate, "VersionDate"),
+                    x => Alias(x.UserId, "WriterId"))
+                .From<NodeDto>()
+                .InnerJoin<ContentDto>().On<NodeDto, ContentDto>((n, c) => n.NodeId == c.NodeId)
+                .InnerJoin<ContentVersionDto>().On<NodeDto, ContentVersionDto>((n, cv) => n.NodeId == cv.NodeId && cv.Current)
+                .WhereIn<NodeDto>(x => x.NodeId, group);

-        return Database.Fetch<CacheRebuildContentDto>(sql);
+            results.AddRange(Database.Fetch<CacheRebuildContentDto>(sql));
+        }
+
+        return results;
    }

    /// <summary>
@@ -0,0 +1,144 @@
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Editors;
+using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Cms.Core.PublishedCache;
+using Umbraco.Cms.Core.Serialization;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Infrastructure.HybridCache.Factories;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Infrastructure.HybridCache.Services;
+
+internal sealed class VisualEditorContentFactory : IVisualEditorContentFactory
+{
+    private readonly IIdKeyMap _idKeyMap;
+    private readonly IContentService _contentService;
+    private readonly IDataTypeService _dataTypeService;
+    private readonly ICacheNodeFactory _cacheNodeFactory;
+    private readonly IPublishedContentFactory _publishedContentFactory;
+    private readonly IJsonSerializer _jsonSerializer;
+    private readonly IPublishedModelFactory _publishedModelFactory;
+
+    public VisualEditorContentFactory(
+        IIdKeyMap idKeyMap,
+        IContentService contentService,
+        IDataTypeService dataTypeService,
+        ICacheNodeFactory cacheNodeFactory,
+        IPublishedContentFactory publishedContentFactory,
+        IJsonSerializer jsonSerializer,
+        IPublishedModelFactory publishedModelFactory)
+    {
+        _idKeyMap = idKeyMap;
+        _contentService = contentService;
+        _dataTypeService = dataTypeService;
+        _cacheNodeFactory = cacheNodeFactory;
+        _publishedContentFactory = publishedContentFactory;
+        _jsonSerializer = jsonSerializer;
+        _publishedModelFactory = publishedModelFactory;
+    }
+
+    public async Task<IPublishedContent?> CreateWithOverridesAsync(
+        Guid documentKey,
+        IReadOnlyCollection<VisualEditorPropertyOverride> overrides)
+    {
+        Attempt<int> idAttempt = _idKeyMap.GetIdForKey(documentKey, UmbracoObjectTypes.Document);
+        if (idAttempt.Success is false)
+        {
+            return null;
+        }
+
+        IContent? content = _contentService.GetById(idAttempt.Result);
+        if (content is null)
+        {
+            return null;
+        }
+
+        ContentCacheNode baseNode = _cacheNodeFactory.ToContentCacheNode(content, preview: true);
+        if (baseNode.Data is null)
+        {
+            return null;
+        }
+
+        var properties = new Dictionary<string, PropertyData[]>(baseNode.Data.Properties);
+
+        foreach (VisualEditorPropertyOverride @override in overrides)
+        {
+            (IDataValueEditor valueEditor, object? configuration)? resolved = await ResolveEditorAsync(content, @override);
+            if (resolved is null)
+            {
+                continue;
+            }
+
+            var editorValue = @override.EditorValue is string s ? s : _jsonSerializer.Serialize(@override.EditorValue);
+            object? source = resolved.Value.valueEditor.FromEditor(
+                new ContentPropertyData(editorValue, resolved.Value.configuration),
+                null);
+
+            string overrideCulture = @override.Culture ?? string.Empty;
+            string overrideSegment = @override.Segment ?? string.Empty;
+
+            var overrideEntry = new PropertyData
+            {
+                Culture = overrideCulture,
+                Segment = overrideSegment,
+                Value = source,
+            };
+
+            if (properties.TryGetValue(@override.Alias, out PropertyData[]? existing))
+            {
+                PropertyData[] merged = existing
+                    .Where(p => !(p.Culture == overrideCulture && p.Segment == overrideSegment))
+                    .Append(overrideEntry)
+                    .ToArray();
+                properties[@override.Alias] = merged;
+            }
+            else
+            {
+                properties[@override.Alias] = [overrideEntry];
+            }
+        }
+
+#pragma warning disable CS0618 // ContentData ctor obsolete usage mirrored from the cache node source
+        var overriddenNode = new ContentCacheNode
+        {
+            Id = baseNode.Id,
+            Key = baseNode.Key,
+            SortOrder = baseNode.SortOrder,
+            CreateDate = baseNode.CreateDate,
+            CreatorId = baseNode.CreatorId,
+            ContentTypeId = baseNode.ContentTypeId,
+            IsDraft = true,
+            Data = new ContentData(
+                name: baseNode.Data.Name,
+                urlSegment: baseNode.Data.UrlSegment,
+                versionId: baseNode.Data.VersionId,
+                versionDate: baseNode.Data.VersionDate,
+                writerId: baseNode.Data.WriterId,
+                templateId: baseNode.Data.TemplateId,
+                published: baseNode.Data.Published,
+                properties: properties,
+                cultureInfos: baseNode.Data.CultureInfos),
+        };
+#pragma warning restore CS0618
+
+        return _publishedContentFactory.ToIPublishedContent(overriddenNode, preview: true).CreateModel(_publishedModelFactory);
+    }
+
+    private async Task<(IDataValueEditor, object? configuration)?> ResolveEditorAsync(IContent content, VisualEditorPropertyOverride @override)
+    {
+        IProperty? property = content.Properties[@override.Alias];
+        if (property is null)
+        {
+            return null;
+        }
+
+        IDataType? dataType = await _dataTypeService.GetAsync(property.PropertyType.DataTypeKey);
+        if (dataType?.Editor is null)
+        {
+            return null;
+        }
+
+        return (dataType.Editor.GetValueEditor(), dataType.ConfigurationObject);
+    }
+}
@@ -77,6 +77,8 @@ public class UmbracoApplicationBuilder : IUmbracoApplicationBuilder, IUmbracoEnd
        // Only use backoffice rewrites if backoffice is enabled
        if (ApplicationServices.GetService<IBackOfficeEnabledMarker>() is not null)
        {
+            // Must run before the rewriter so the cache-bust hash is still present on the request path.
+            AppBuilder.UseUmbracoBackOfficeCacheHeaders();
            AppBuilder.UseUmbracoBackOfficeRewrites();
        }

@@ -62,7 +62,8 @@ Umbraco.Web.Common/
 │   └── UmbracoPublishedContentCultureProvider.cs
 ├── Middleware/
 │   ├── BootFailedMiddleware.cs                # Startup failure handling (81 lines)
-│   └── PreviewAuthenticationMiddleware.cs     # Preview mode auth (84 lines)
+│   ├── PreviewAuthenticationMiddleware.cs     # Preview mode auth (84 lines)
+│   └── UmbracoBackOfficeCacheHeadersMiddleware.cs  # Cache-Control on cache-busted backoffice asset path
 ├── Routing/
 │   ├── IAreaRoutes.cs                         # Area routing interface
 │   ├── IRoutableDocumentFilter.cs             # Content routing filter
@@ -256,6 +257,8 @@ ASP.NET Core Identity sign-in manager for members.

 ### Middleware

+**Convention**: middleware lives in `Middleware/` as a class implementing `IMiddleware`, registered as a singleton next to its dependencies' registration (generic middleware in `AddWebComponents`; feature-specific middleware where the feature's services are added, e.g. backoffice middleware in `AddBackOfficeCore`), and wired into the pipeline via `app.UseMiddleware<TMiddleware>()`. Companion `IApplicationBuilder` extension methods are thin one-line `UseMiddleware<T>()` wrappers — inline `builder.Use(async …)` lambdas bypass DI and are harder to test; `CspNonceExtensions` and `Web.UI/WebApplicationExtensions` are tiny pre-existing exceptions, not a precedent for new work.
+
 **BootFailedMiddleware** (lines 17-81):
 - Intercepts requests when `RuntimeLevel == BootFailed`
 - Debug mode: Rethrows exception for stack trace
@@ -266,6 +269,11 @@ ASP.NET Core Identity sign-in manager for members.
 - Skips client-side requests and backoffice paths
 - Uses `IPreviewService.TryGetPreviewClaimsIdentityAsync()`

+**UmbracoBackOfficeCacheHeadersMiddleware**:
+- Sets `Cache-Control: public, max-age=31536000, immutable` on responses under the cache-busted backoffice asset prefix (`/umbraco/backoffice/<hash>/…`); `no-cache` in debug mode
+- Runs before `UseUmbracoBackOfficeRewrites` so the original (hash-bearing) path can be matched
+- Non-destructive: uses `Response.OnStarting` + `ContainsKey` guard so any consumer override wins
+
 ---

 ## 4. Routing
--- a/Show More
+++ b/Show More