Add upgrade migration for umbExternalBlockElement relation type

Provision umbExternalBlockElement relation type on fresh install
Add umbExternalBlockElement relation type constants
2026-06-19 16:13:15 +02:00 · 2026-06-19 16:06:13 +02:00 · 2026-06-19 15:58:13 +02:00 · 2026-06-19 14:22:01 +02:00 · 2026-06-19 14:02:27 +02:00 · 2026-06-19 13:43:29 +02:00
363 changed files with 4869 additions and 16316 deletions
@@ -70,6 +70,18 @@ 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
@@ -124,10 +136,6 @@ 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
@@ -1,81 +0,0 @@
-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"
@@ -1,7 +0,0 @@
-{
-  "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,8 +120,4 @@ 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,6 +48,7 @@ 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

@@ -64,14 +64,4 @@
      </_ProjectReferencesWithVersions>
    </ItemGroup>
  </Target>
-
-  <!-- Workaround for https://github.com/umbraco/Umbraco-CMS/issues/23018
-       Due to the amount of XML documentation in this solution, the OpenAPI XML documentation source generator produces
-       too many lines of code causing a StackOverflowException when running on IIS. For that reason we disable the analyzer.
-       See https://learn.microsoft.com/en-us/aspnet/core/fundamentals/openapi/openapi-comments?view=aspnetcore-10.0#disabling-xml-documentation-support -->
-  <Target Name="DisableCompileTimeOpenApiXmlGenerator" BeforeTargets="CoreCompile" Condition="'$(IsPackable)' != 'false' or '$(IsTestProject)' == 'true'">
-    <ItemGroup>
-      <Analyzer Remove="@(Analyzer)" Condition="'%(Filename)' == 'Microsoft.AspNetCore.OpenApi.SourceGenerators'" />
-    </ItemGroup>
-  </Target>
 </Project>
@@ -49,8 +49,8 @@
    <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.8.0" />
-    <PackageVersion Include="Examine.Core" Version="3.8.0" />
+    <PackageVersion Include="Examine" Version="3.7.1" />
+    <PackageVersion Include="Examine.Core" Version="3.7.1" />
    <PackageVersion Include="HtmlAgilityPack" Version="1.12.4" />
    <PackageVersion Include="JsonPatch.Net" Version="3.3.0" />
    <PackageVersion Include="K4os.Compression.LZ4" Version="1.3.8" />
@@ -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>
@@ -1,96 +0,0 @@
-# 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.
@@ -1,85 +0,0 @@
-# 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.
@@ -1,125 +0,0 @@
-# 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.
@@ -1,947 +0,0 @@
-# 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.
@@ -1,7 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
-using System.Text.Json.Nodes;
-using System.Text.Json.Schema;
 using System.Text.Json.Serialization.Metadata;
 using Microsoft.AspNetCore.Http.Json;
 using Microsoft.AspNetCore.OpenApi;
@@ -343,12 +341,6 @@ public sealed class ContentTypeSchemaTransformer : IOpenApiSchemaTransformer, IO

        var schemaId = GetSchemaId(jsonTypeInfo);

-        // Types that produce 'true' in JSON Schema (unconstrained: JsonNode, object, custom-converter types) should be inline {} rather than named components.
-        if (jsonTypeInfo.Kind == JsonTypeInfoKind.None && jsonTypeInfo.GetJsonSchemaAsNode().GetValueKind() == JsonValueKind.True)
-        {
-            return new OpenApiSchema();
-        }
-
        // If this is one of the types we handle, and we already started generating it, return a placeholder
        // to avoid circular reference issues.
        // In the document transformer, these placeholders will be replaced with the actual schemas.
@@ -2,7 +2,6 @@ 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;

@@ -33,13 +32,11 @@ 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)
    {
-        RedirectUrlOperationStatus status = _redirectUrlService.DeleteWithStatus(id);
-        return Task.FromResult(RedirectUrlOperationStatusResult(status));
+        _redirectUrlService.Delete(id);
+        return Task.FromResult<IActionResult>(Ok());
    }
 }
@@ -1,8 +1,6 @@
 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;
@@ -16,31 +14,4 @@ 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()),
-        });
 }
@@ -32,7 +32,6 @@ public class CreateTemporaryFileController : TemporaryFileControllerBase

    [HttpPost("")]
    [MapToApiVersion("1.0")]
-    [Consumes("multipart/form-data")]
    [ProducesResponseType(StatusCodes.Status201Created)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
    [EndpointSummary("Creates a temporary file.")]
@@ -1,53 +0,0 @@
-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 });
-    }
-}
@@ -1,16 +0,0 @@
-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
-{
-}
@@ -118,7 +118,7 @@ internal abstract class ContentTypeEditingPresentationFactory<TContentType>
        {
            Alias = property.Alias,
            Appearance =
-                new ContentTypeEditingModels.PropertyTypeAppearance { LabelOnTop = property.Appearance.LabelOnTop, EditableInVisualEditor = property.Appearance.EditableInVisualEditor },
+                new ContentTypeEditingModels.PropertyTypeAppearance { LabelOnTop = property.Appearance.LabelOnTop },
            Name = property.Name,
            Validation = new ContentTypeEditingModels.PropertyTypeValidation
            {
@@ -1,8 +1,5 @@
-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;
@@ -19,7 +16,6 @@ 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.
@@ -29,46 +25,18 @@ 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,
-        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>>())
    {
+        _dataTypeContainerService = dataTypeContainerService;
+        _propertyEditorCollection = propertyEditorCollection;
+        _dataValueEditorFactory = dataValueEditorFactory;
+        _configurationEditorJsonSerializer = configurationEditorJsonSerializer;
+        _timeProvider = timeProvider;
    }

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

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

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

                return parent is null
                    ? Attempt.FailWithStatus(DataTypeOperationStatus.ParentNotFound, 0)
@@ -128,7 +97,6 @@ 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))
@@ -136,7 +104,7 @@ public class DataTypePresentationFactory : IDataTypePresentationFactory
            return Task.FromResult(Attempt.FailWithStatus<IDataType, DataTypeOperationStatus>(DataTypeOperationStatus.PropertyEditorNotFound, new DataType(new VoidEditor(_dataValueEditorFactory), _configurationEditorJsonSerializer) ));
        }

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

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

    private ValueStorageType GetEditorValueStorageType(IDataEditor editor, IDictionary<string, object> configurationData)
    {
-        // 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
+        var configurationObject = editor.GetConfigurationEditor()
+            .ToConfigurationObject(configurationData, _configurationEditorJsonSerializer);
+
+        if (configurationObject is IConfigureValueType configureValueType)
        {
-            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);
+            return ValueTypes.ToStorageType(configureValueType.ValueType);
        }

        var valueType = editor.GetValueEditor().ValueType;
@@ -49,8 +49,7 @@ public abstract class ContentTypeMapDefinition<TContentType, TPropertyTypeModel,
                    },
                    Appearance = new PropertyTypeAppearance
                    {
-                        LabelOnTop = propertyType.LabelOnTop,
-                        EditableInVisualEditor = propertyType.EditableInVisualEditor,
+                        LabelOnTop = propertyType.LabelOnTop
                    }
                })
            .ToArray();
@@ -33430,7 +33430,7 @@
        "operationId": "PostTemporaryFile",
        "requestBody": {
          "content": {
-            "multipart/form-data": {
+            "application/x-www-form-urlencoded": {
              "schema": {
                "type": "object",
                "properties": {
@@ -38519,76 +38519,6 @@
        ]
      }
    },
-    "/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": [
@@ -49278,16 +49208,12 @@
      },
      "PropertyTypeAppearanceModel": {
        "required": [
-          "labelOnTop",
-          "editableInVisualEditor"
+          "labelOnTop"
        ],
        "type": "object",
        "properties": {
          "labelOnTop": {
            "type": "boolean"
-          },
-          "editableInVisualEditor": {
-            "type": "boolean"
          }
        }
      },
@@ -53208,72 +53134,6 @@
          }
        }
      },
-      "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|visual-editor|upgrade|install|oauth_complete|logout|error).*$" });
+            constraints: new { slug = @"^(section|preview|upgrade|install|oauth_complete|logout|error).*$" });
    }
 }
@@ -9,9 +9,4 @@ 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; }
 }
@@ -1,19 +0,0 @@
-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; }
-}
@@ -1,19 +0,0 @@
-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; } = [];
-}
@@ -1,10 +0,0 @@
-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,9 +15,8 @@ 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 (incl. transient-error retry)
+2. **Migration Provider Setup** - Configures DbContext to use SQLite
 3. **Migrations** - SQLite-specific migration files for OpenIddict tables
-4. **Retrying Execution Strategy** - Retries transient SQLite lock errors on EF Core operations

 ### Folder Structure

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

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

 ### SqliteMigrationProviderSetup (line 11-14)

-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).
+Configures `DbContextOptionsBuilder` with `UseSqlite` and migrations assembly.

 ---

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

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

 namespace Umbraco.Cms.Persistence.EFCore.Sqlite;
@@ -14,15 +15,6 @@ public class SqliteMigrationProviderSetup : IMigrationProviderSetup
    /// <inheritdoc />
    public void Setup(DbContextOptionsBuilder builder, string? connectionString)
    {
-        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));
-        });
+        builder.UseSqlite(connectionString, x => x.MigrationsAssembly(GetType().Assembly.FullName));
    }
 }
@@ -1,71 +0,0 @@
-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,11 +184,17 @@ internal sealed class SqliteEFCoreDistributedLockingMechanism<T> : IDistributedL
                        throw new ArgumentException($"LockObject with id={LockId} does not exist.");
                    }
                }
-                catch (SqliteException ex) when (ex.IsBusyOrLocked())
+                catch (SqliteException ex) when (IsBusyOrLocked(ex))
                {
                    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;
    }
 }
@@ -1,26 +0,0 @@
-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;
-}
@@ -21,7 +21,7 @@ public class ActionElementContainerDelete : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementContainerMove : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementContainerNew : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementContainerUpdate : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementCopy : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementDelete : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementMove : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementNew : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementPublish : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementRollback : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -21,7 +21,7 @@ public class ActionElementUpdate : IAction
    public string Alias => ActionAlias;

    /// <inheritdoc />
-    public bool ShowInNotifier => false;
+    public bool ShowInNotifier => true;

    /// <inheritdoc />
    public bool CanBePermissionAssigned => true;
@@ -368,17 +368,8 @@ public class ObjectCacheAppCache : IAppPolicyCache, IDisposable
        }

        // Ensure key is removed from set when evicted from cache
-        return options.RegisterPostEvictionCallback((key, _, reason, _) =>
+        return options.RegisterPostEvictionCallback((key, _, _, _) =>
        {
-            // 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)
@@ -9,6 +9,7 @@ namespace Umbraco.Cms.Core.Configuration.Models;
 public class IndexingSettings
 {
    private const bool StaticExplicitlyIndexEachNestedProperty = false;
+    private const bool StaticIndexExternalElements = false;
    private const int StaticBatchSize = 10000;

    /// <summary>
@@ -17,6 +18,12 @@ public class IndexingSettings
    [DefaultValue(StaticExplicitlyIndexEachNestedProperty)]
    public bool ExplicitlyIndexEachNestedProperty { get; set; } = StaticExplicitlyIndexEachNestedProperty;

+    /// <summary>
+    /// Gets or sets a value indicating whether the content of external elements referenced by block editors is flattened into the index entry of referencing documents. Requires a rebuild of indexes when changed.
+    /// </summary>
+    [DefaultValue(StaticIndexExternalElements)]
+    public bool IndexExternalElements { get; set; } = StaticIndexExternalElements;
+
    /// <summary>
    /// Gets or sets a value for how many items to index at a time.
    /// </summary>
@@ -357,6 +357,16 @@ public static partial class Constants
            /// </summary>
            public const string RelatedElementAlias = "umbElement";

+            /// <summary>
+            ///     Name for default relation type "External Block Element".
+            /// </summary>
+            public const string RelatedExternalBlockElementName = "External Block Element";
+
+            /// <summary>
+            ///     Alias for default relation type "External Block Element".
+            /// </summary>
+            public const string RelatedExternalBlockElementAlias = "umbExternalBlockElement";
+
            /// <summary>
            ///     Name for default relation type "Relate Document On Copy".
            /// </summary>
@@ -414,7 +424,7 @@ public static partial class Constants
            ///     Developers should not manually use these relation types since they will all be cleared whenever an entity
            ///     (content, media, member or element) is saved since they are auto-populated based on property values.
            /// </remarks>
-            public static string[] AutomaticRelationTypes { get; } = { RelatedMediaAlias, RelatedMemberAlias, RelatedDocumentAlias, RelatedElementAlias };
+            public static string[] AutomaticRelationTypes { get; } = { RelatedMediaAlias, RelatedMemberAlias, RelatedDocumentAlias, RelatedElementAlias, RelatedExternalBlockElementAlias };

            // TODO: return a list of built in types so we can use that to prevent deletion in the UI
        }
@@ -405,8 +405,7 @@
 	    0: Comma delimitted list of failed folder paths
  	-->
    <key alias="umbracoApplicationUrlCheckResultTrue"><![CDATA[AppSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' je postavljen na <strong>%0%</strong>.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultFalse"><![CDATA[AppSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' nije postavljen, pa će se URL aplikacije automatski otkriti iz dolaznih zahtjeva. Preporučuje se da ga postavite izričito.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultError"><![CDATA[AppSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' nije postavljen, a automatsko otkrivanje URL-a aplikacije je onemogućeno ('Umbraco:CMS:WebRouting:ApplicationUrlDetection' je 'None'). Značajke koje zahtijevaju apsolutni URL, poput e-pošte za poništavanje lozinke i pozivnica, neće raditi. Postavite URL aplikacije izričito ili omogućite automatsko otkrivanje.]]></key>
+    <key alias="umbracoApplicationUrlCheckResultFalse">AppSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' nije postavljen.</key>
    <!-- The following key get these tokens passed in:
 	    0: Comma delimitted list of headers found
  	-->
@@ -454,8 +454,7 @@
    <key alias="httpsCheckConfigurationRectifyNotPossible">Mae gosodiad ap 'Umbraco:CMS:Global:UseHttps' wedi'i osod i 'false' yn eich ffeil appSettings.json. Unwaith y byddwch yn cyrchu'r wefan hon gan ddefnyddio'r cynllun HTTPS, dylid gosod hwnnw i 'true'.</key>
    <key alias="httpsCheckConfigurationCheckResult">Mae'r gosodiad ap 'Umbraco:CMS:Global:UseHttps' wedi'i osod i '%0%' yn eich ffeil appSettings.json, mae eich cwcis %1% wedi'u marcio'n ddiogel.</key>
    <key alias="umbracoApplicationUrlCheckResultTrue">Mae gosodiad yr ap 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' wedi'i osod i <strong>%0%</strong>.</key>
-    <key alias="umbracoApplicationUrlCheckResultFalse"><![CDATA[Nid yw gosodiad ap 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' wedi'i osod, felly bydd URL y rhaglen yn cael ei ganfod yn awtomatig o geisiadau sy'n dod i mewn. Argymhellir ei osod yn benodol.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultError"><![CDATA[Nid yw gosodiad ap 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' wedi'i osod ac mae canfod URL y rhaglen yn awtomatig wedi'i analluogi (mae 'Umbraco:CMS:WebRouting:ApplicationUrlDetection' yn 'None'). Ni fydd nodweddion sydd angen URL absoliwt, fel e-byst ailosod cyfrinair a gwahoddiadau, yn gweithio. Gosodwch URL y rhaglen yn benodol, neu galluogwch ganfod yn awtomatig.]]></key>
+    <key alias="umbracoApplicationUrlCheckResultFalse">Nid yw gosodiad ap 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' wedi'i osod.</key>
    <key alias="smtpMailSettingsNotFound">Nid oedd modd dod o hyd i'r ffurfweddiad 'Umbraco:CMS:Global:Smtp'.</key>
    <key alias="smtpMailSettingsHostNotConfigured">Nid oedd modd dod o hyd i'r ffurfweddiad 'Umbraco:CMS:Global:Smtp:Host'.</key>
    <key alias="smtpMailSettingsConnectionFail">Methwyd cyrraedd y gweinydd SMTP a ffurfweddwyd gyda gwesteiwr '%0%' a phorth '%1%'. Gwiriwch i sicrhau bod y gosodiadau SMTP yn y ffurfweddiad 'Umbraco:CMS:Global:Smtp' yn gywir.</key>
@@ -463,8 +463,7 @@
 	    0: Comma delimitted list of failed folder paths
  	-->
    <key alias="umbracoApplicationUrlCheckResultTrue"><![CDATA[The appSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' is set to <strong>%0%</strong>.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultFalse"><![CDATA[The appSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' is not set, so the application URL will be auto-detected from incoming requests. Setting it explicitly is recommended.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultError"><![CDATA[The appSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' is not set and application URL auto-detection is disabled ('Umbraco:CMS:WebRouting:ApplicationUrlDetection' is 'None'). Features that require an absolute URL, such as password reset and invitation emails, will not work. Set the application URL explicitly, or enable auto-detection.]]></key>
+    <key alias="umbracoApplicationUrlCheckResultFalse">The appSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' is not set.</key>
    <!-- The following key get these tokens passed in:
 	    0: Comma delimitted list of headers found
  	-->
@@ -452,8 +452,7 @@
 	    0: Comma delimitted list of failed folder paths
  	-->
    <key alias="umbracoApplicationUrlCheckResultTrue"><![CDATA[The appSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' is set to <strong>%0%</strong>.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultFalse"><![CDATA[The appSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' is not set, so the application URL will be auto-detected from incoming requests. Setting it explicitly is recommended.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultError"><![CDATA[The appSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' is not set and application URL auto-detection is disabled ('Umbraco:CMS:WebRouting:ApplicationUrlDetection' is 'None'). Features that require an absolute URL, such as password reset and invitation emails, will not work. Set the application URL explicitly, or enable auto-detection.]]></key>
+    <key alias="umbracoApplicationUrlCheckResultFalse">The appSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' is not set.</key>
    <key alias="clickJackingCheckHeaderFound">
      <![CDATA[The header or meta-tag <strong>X-Frame-Options</strong> used to control whether a site can be IFRAMEd by another was found.]]></key>
    <key alias="clickJackingCheckHeaderNotFound">
@@ -403,8 +403,7 @@
 	    0: Comma delimitted list of failed folder paths
  	-->
    <key alias="umbracoApplicationUrlCheckResultTrue"><![CDATA[AppSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' je postavljen na <strong>%0%</strong>.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultFalse"><![CDATA[AppSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' nije postavljen, pa će se URL aplikacije automatski otkriti iz dolaznih zahtjeva. Preporučuje se da ga postavite izričito.]]></key>
-    <key alias="umbracoApplicationUrlCheckResultError"><![CDATA[AppSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' nije postavljen, a automatsko otkrivanje URL-a aplikacije je onemogućeno ('Umbraco:CMS:WebRouting:ApplicationUrlDetection' je 'None'). Značajke koje zahtijevaju apsolutni URL, poput e-pošte za poništavanje lozinke i pozivnica, neće raditi. Postavite URL aplikacije izričito ili omogućite automatsko otkrivanje.]]></key>
+    <key alias="umbracoApplicationUrlCheckResultFalse">AppSetting 'Umbraco:CMS:WebRouting:UmbracoApplicationUrl' nije postavljen.</key>
    <!-- The following key get these tokens passed in:
 	    0: Comma delimitted list of headers found
  	-->
@@ -316,8 +316,6 @@ 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))
        {
@@ -358,8 +356,6 @@ 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))
        {
@@ -377,23 +373,6 @@ 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,10 +730,6 @@ 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
@@ -44,34 +44,28 @@ public class UmbracoApplicationUrlCheck : HealthCheck

    private HealthCheckStatus CheckUmbracoApplicationUrl()
    {
-        WebRoutingSettings settings = _webRoutingSettings.CurrentValue;
-        var url = settings.UmbracoApplicationUrl;
+        var url = _webRoutingSettings.CurrentValue.UmbracoApplicationUrl;

        string resultMessage;
        StatusResultType resultType;
+        var success = false;

-        if (url.IsNullOrWhiteSpace() is false)
-        {
-            resultMessage = _textService.Localize("healthcheck", "umbracoApplicationUrlCheckResultTrue", [url]);
-            resultType = StatusResultType.Success;
-        }
-        else if (settings.ApplicationUrlDetection == ApplicationUrlDetection.None)
-        {
-            // No explicit URL and auto-detection is disabled, so the application URL can never be established.
-            // Features that require an absolute URL (e.g. password reset and invitation emails) will not work.
-            resultMessage = _textService.Localize("healthcheck", "umbracoApplicationUrlCheckResultError");
-            resultType = StatusResultType.Error;
-        }
-        else
+        if (url.IsNullOrWhiteSpace())
        {
            resultMessage = _textService.Localize("healthcheck", "umbracoApplicationUrlCheckResultFalse");
            resultType = StatusResultType.Warning;
        }
+        else
+        {
+            resultMessage = _textService.Localize("healthcheck", "umbracoApplicationUrlCheckResultTrue", new[] { url });
+            resultType = StatusResultType.Success;
+            success = true;
+        }

        return new HealthCheckStatus(resultMessage)
        {
            ResultType = resultType,
-            ReadMoreLink = resultType == StatusResultType.Success
+            ReadMoreLink = success
                ? null
                : Constants.HealthChecks.DocumentationLinks.Security.UmbracoApplicationUrlCheck,
        };
@@ -64,4 +64,8 @@ public class BlockGridLayoutItem : BlockLayoutItemBase
    /// <inheritdoc />
    public override bool ReferencesSetting(Guid key)
        => SettingsKey == key || Areas.Any(area => area.ContainsSetting(key));
+
+    /// <inheritdoc />
+    public override IEnumerable<IBlockLayoutItem> GetContainedLayouts()
+        => Areas.SelectMany(area => area.Items);
 }
@@ -5,12 +5,18 @@ namespace Umbraco.Cms.Core.Models.Blocks;
 /// </summary>
 public abstract class BlockLayoutItemBase : IBlockLayoutItem
 {
+    /// <inheritdoc />
+    public Guid Key { get; set; }
+
    /// <inheritdoc />
    public Guid ContentKey { get; set; }

    /// <inheritdoc />
    public Guid? SettingsKey { get; set; }

+    /// <inheritdoc />
+    public bool IsExternalContent { get; set; }
+
    /// <summary>
    ///     Initializes a new instance of the <see cref="BlockLayoutItemBase" /> class.
    /// </summary>
@@ -44,4 +50,7 @@ public abstract class BlockLayoutItemBase : IBlockLayoutItem
    /// <inheritdoc />
    public virtual bool ReferencesSetting(Guid key)
        => SettingsKey == key;
+
+    /// <inheritdoc />
+    public virtual IEnumerable<IBlockLayoutItem> GetContainedLayouts() => [];
 }
@@ -8,6 +8,18 @@ namespace Umbraco.Cms.Core.Models.Blocks;
 /// </summary>
 public interface IBlockLayoutItem
 {
+    /// <summary>
+    ///     Gets or sets the layout item key.
+    /// </summary>
+    /// <value>
+    ///     The layout item key.
+    /// </value>
+    /// <remarks>
+    ///     Uniquely identifies a layout item. Previously the <see cref="ContentKey"/> could be used for this, but
+    ///     with reusable elements, the same <see cref="ContentKey"/> can appear multiple times in one layout.
+    /// </remarks>
+    public Guid Key { get; set; }
+
    /// <summary>
    ///     Gets or sets the content key.
    /// </summary>
@@ -24,6 +36,11 @@ public interface IBlockLayoutItem
    /// </value>
    public Guid? SettingsKey { get; set; }

+    /// <summary>
+    ///     Indicates if the content source is local or originates from the element service.
+    /// </summary>
+    public bool IsExternalContent { get; set; }
+
    /// <summary>
    ///     Determines whether this layout item references the specified content key.
    /// </summary>
@@ -41,4 +58,10 @@ public interface IBlockLayoutItem
    ///     <c>true</c> if this layout item references the specified settings key; otherwise, <c>false</c>.
    /// </returns>
    public bool ReferencesSetting(Guid key) => SettingsKey == key;
+
+    /// <summary>
+    ///     Returns any nested layouts for this layout (e.g. area layouts for the Block Grid).
+    /// </summary>
+    /// <returns>The nested layouts.</returns>
+    public IEnumerable<IBlockLayoutItem> GetContainedLayouts();
 }
@@ -9,9 +9,4 @@ 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,11 +58,6 @@ 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,7 +21,6 @@ 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;
@@ -226,14 +225,6 @@ 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,11 +46,6 @@ 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,7 +37,6 @@ 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>
@@ -95,9 +94,6 @@ namespace Umbraco.Cms.Core.Models.PublishedContent
        /// <inheritdoc />
        public bool IsUserProperty { get; }

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

@@ -1,66 +0,0 @@
-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);
-}
@@ -1,30 +0,0 @@
-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)
-    {
-    }
-}
@@ -1,34 +0,0 @@
-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)
-    {
-    }
-}
@@ -1,30 +0,0 @@
-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)
-    {
-    }
-}
@@ -1,30 +0,0 @@
-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)
-    {
-    }
-}
@@ -1,12 +1,11 @@
 namespace Umbraco.Cms.Core.PropertyEditors;

 /// <summary>
-///     Represents a property index value factory specifically for block-based property values.
+///     Represents a property index value factory specifically for block grid properties.
 /// </summary>
 /// <remarks>
-///     This marker interface allows for specialized indexing of block content,
-///     such as Block List, Block Grid, and Rich Text block values.
+///     This marker interface allows for specialized indexing of block grid content.
 /// </remarks>
-public interface IBlockValuePropertyIndexValueFactory : IPropertyIndexValueFactory
+public interface IBlockGridPropertyIndexValueFactory : IPropertyIndexValueFactory
 {
 }
@@ -0,0 +1,11 @@
+namespace Umbraco.Cms.Core.PropertyEditors;
+
+/// <summary>
+///     Represents a property index value factory specifically for block list properties.
+/// </summary>
+/// <remarks>
+///     This marker interface allows for specialized indexing of block list content.
+/// </remarks>
+public interface IBlockListPropertyIndexValueFactory : IPropertyIndexValueFactory
+{
+}
@@ -0,0 +1,11 @@
+namespace Umbraco.Cms.Core.PropertyEditors;
+
+/// <summary>
+///     Represents a property index value factory specifically for single block properties.
+/// </summary>
+/// <remarks>
+///     This marker interface allows for specialized indexing of single block content.
+/// </remarks>
+public interface ISingleBlockPropertyIndexValueFactory : IPropertyIndexValueFactory
+{
+}
@@ -3,7 +3,17 @@ using Umbraco.Cms.Core.Models.PublishedContent;

 namespace Umbraco.Cms.Core.PublishedCache;

+/// <summary>
+/// A service for converting <see cref="BlockItemData"/> into <see cref="IPublishedElement"/>.
+/// </summary>
 public interface IBlockElementService
 {
-    Task<IPublishedElement?> BuildElementAsync(BlockItemData blockItemData, bool? preview = null);
+    /// <summary>
+    /// Creates an <see cref="IPublishedElement"/> instance from <see cref="BlockItemData"/>.
+    /// </summary>
+    /// <param name="owner">The <see cref="IPublishedElement"/> that contains the block property which is the origin to the <see cref="BlockItemData"/>.</param>
+    /// <param name="blockItemData">The <see cref="BlockItemData"/> containing the data to convert into an <see cref="IPublishedElement"/>.</param>
+    /// <param name="preview">Whether to perform the conversion for preview.</param>
+    /// <returns>The created <see cref="IPublishedElement"/>, or null if an element could not be created from the <see cref="BlockItemData"/>.</returns>
+    Task<IPublishedElement?> BuildElementAsync(IPublishedElement owner, BlockItemData blockItemData, bool? preview = null);
 }
@@ -1,25 +0,0 @@
-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);
-}
@@ -1,13 +0,0 @@
-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,7 +821,6 @@ 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
@@ -22,4 +22,11 @@ public interface IDeferredSearchReindexService
    /// </summary>
    /// <param name="memberTypeIds">The member type IDs to reindex.</param>
    void QueueMemberTypeReindex(IReadOnlyCollection<int> memberTypeIds);
+
+    /// <summary>
+    ///     Queues a set of element node ids whose change requires re-indexing the documents that
+    ///     (transitively) embed them via block editors.
+    /// </summary>
+    /// <param name="elementIds">The element node ids that changed.</param>
+    void QueueElementReindex(IReadOnlyCollection<int> elementIds);
 }
@@ -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,105 +15,26 @@ 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>
@@ -1,27 +0,0 @@
-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,10 +1,8 @@
 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;

@@ -27,141 +25,45 @@ 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(oldUrl, contentKey, culture);
+        IRedirectUrl? redir = _redirectUrlRepository.Get(url, contentKey, culture);
        if (redir != null)
        {
            redir.CreateDateUtc = DateTime.UtcNow;
        }
        else
        {
-            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);
+            redir = new RedirectUrl { Key = Guid.NewGuid(), Url = url, ContentKey = contentKey, Culture = culture };
        }

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

    /// <inheritdoc/>
-    [Obsolete("Use DeleteWithStatus(IRedirectUrl) instead. Scheduled for removal in Umbraco 20.")]
-    public void Delete(IRedirectUrl redirectUrl) => DeleteWithStatus(redirectUrl);
-
-    /// <inheritdoc/>
-    public RedirectUrlOperationStatus DeleteWithStatus(IRedirectUrl redirectUrl)
+    public void Delete(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/>
-    [Obsolete("Use DeleteWithStatus(Guid) instead. Scheduled for removal in Umbraco 20.")]
-    public void Delete(Guid id) => DeleteWithStatus(id);
-
-    /// <inheritdoc/>
-    public RedirectUrlOperationStatus DeleteWithStatus(Guid id)
+    public void Delete(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/>
-    [Obsolete("Use DeleteContentRedirectUrlsWithStatus instead. Scheduled for removal in Umbraco 20.")]
-    public void DeleteContentRedirectUrls(Guid contentKey) => DeleteContentRedirectUrlsWithStatus(contentKey);
-
-    /// <inheritdoc/>
-    public RedirectUrlOperationStatus DeleteContentRedirectUrlsWithStatus(Guid contentKey)
+    public void DeleteContentRedirectUrls(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/>
@@ -1,26 +0,0 @@
-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);
-}
@@ -84,19 +84,8 @@ public class TouchServerJob : RecurringBackgroundJobBase
        var serverAddress = _hostingEnvironment.ApplicationMainUrl?.ToString();
        if (string.IsNullOrWhiteSpace(serverAddress))
        {
-            // No application URL is known yet: either detection is off (WebRouting:ApplicationUrlDetection is
-            // None with no UmbracoApplicationUrl set), or detection is on but no request has been served yet.
-            // Register with the machine name as a placeholder so server-role election can still proceed (uniqueness
-            // comes from the server identity, not this address). If a URL is later detected from a request, the next
-            // touch overwrites the placeholder.
-            serverAddress = Environment.MachineName;
-            _logger.LogDebug(
-                "No application URL available; registering server with placeholder address {ServerAddress}.",
-                serverAddress);
-        }
-        else
-        {
-            _logger.LogDebug("Registering server with application URL {ServerAddress}.", serverAddress);
+            _logger.LogWarning("No umbracoApplicationUrl for service (yet), skip.");
+            return Task.CompletedTask;
        }

        try
@@ -285,7 +285,9 @@ public static partial class UmbracoBuilderExtensions
    /// <returns>The same <see cref="Umbraco.Cms.Core.DependencyInjection.IUmbracoBuilder"/> instance so that multiple calls can be chained.</returns>
    public static IUmbracoBuilder AddPropertyIndexValueFactories(this IUmbracoBuilder builder)
    {
-        builder.Services.AddSingleton<IBlockValuePropertyIndexValueFactory, BlockValuePropertyIndexValueFactory>();
+        builder.Services.AddSingleton<IBlockListPropertyIndexValueFactory, BlockListPropertyIndexValueFactory>();
+        builder.Services.AddSingleton<IBlockGridPropertyIndexValueFactory, BlockGridPropertyIndexValueFactory>();
+        builder.Services.AddSingleton<ISingleBlockPropertyIndexValueFactory, SingleBlockPropertyIndexValueFactory>();
        builder.Services.AddSingleton<ITagPropertyIndexValueFactory, TagPropertyIndexValueFactory>();
        builder.Services.AddSingleton<IRichTextPropertyIndexValueFactory, RichTextPropertyIndexValueFactory>();
        builder.Services.AddSingleton<IDateOnlyPropertyIndexValueFactory, DateOnlyPropertyIndexValueFactory>();
@@ -5,9 +5,9 @@ using Umbraco.Cms.Core.DeliveryApi;
 using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
-using Umbraco.Cms.Core.Security;
 using Umbraco.Cms.Core.PropertyEditors;
 using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Core.Security;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Strings;
 using Umbraco.Cms.Infrastructure.Examine;
@@ -86,6 +86,8 @@ public static partial class UmbracoBuilderExtensions
        builder.AddNotificationHandler<ContentCacheRefresherNotification, DeliveryApiContentIndexingNotificationHandler>();
        builder.AddNotificationHandler<ContentTypeCacheRefresherNotification, DeliveryApiContentIndexingNotificationHandler>();
        builder.AddNotificationHandler<PublicAccessCacheRefresherNotification, DeliveryApiContentIndexingNotificationHandler>();
+        builder.AddNotificationHandler<ElementSavedNotification, ElementIndexingNotificationHandler>();
+        builder.AddNotificationHandler<ElementPublishedNotification, ElementIndexingNotificationHandler>();
        builder.AddNotificationHandler<MediaCacheRefresherNotification, MediaIndexingNotificationHandler>();
        builder.AddNotificationHandler<MemberCacheRefresherNotification, MemberIndexingNotificationHandler>();
        builder.AddNotificationHandler<ExternalMemberCacheRefresherNotification, ExternalMemberIndexingNotificationHandler>();
@@ -2834,6 +2834,14 @@ internal sealed class DatabaseDataCreator
            Constants.ObjectTypes.ElementContainer,
            false,
            false);
+        CreateRelationTypeData(
+            10,
+            Constants.Conventions.RelationTypes.RelatedExternalBlockElementAlias,
+            Constants.Conventions.RelationTypes.RelatedExternalBlockElementName,
+            null,
+            null,
+            false,
+            true);
    }

    private void CreateRelationTypeData(
@@ -94,7 +94,6 @@ 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}");
@@ -104,6 +103,9 @@ public partial class UmbracoPlan : MigrationPlan
        To<V_18_0_0.AddElementContainerPermissions>("{D00BB11A-DDF8-47C4-B58E-150C123BB3BB}");
        To<V_18_0_0.MigrateSingleBlockList>("{74332C49-B279-4945-8943-F8F00B1F5949}");
        To<V_18_0_0.AddElementSectionForAdmins>("{6FE4656E-8B8D-452F-AE2A-438A615B61BC}");
+
+        // To 19.0.0
+        To<V_19_0_0.AddExternalBlockElementRelationType>("{2D8F1B6E-4C3A-4E7D-9A1B-5F0C7E2D8A93}");
    }

    /// <summary>
@@ -1,41 +0,0 @@
-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);
-    }
-}
@@ -76,7 +76,7 @@ public class MigrateSingleBlockList : AsyncMigrationBase
        SingleBlockListConfigurationCache blockListConfigurationCache,
        IDataValueEditorFactory dataValueEditorFactory,
        IIOHelper ioHelper,
-        IBlockValuePropertyIndexValueFactory blockValuePropertyIndexValueFactory,
+        ISingleBlockPropertyIndexValueFactory blockValuePropertyIndexValueFactory,
        IBlockEditorElementTypeCache elementTypeCache,
        AppCaches appCaches)
        : base(context)
@@ -0,0 +1,56 @@
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Infrastructure.Migrations.Install;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_19_0_0;
+
+/// <summary>
+/// Adds the "External Block Element" relation type used to track elements that are
+/// embedded as external (reusable) block content, so that only documents whose index
+/// includes the element's content are reindexed when the element changes.
+/// </summary>
+public class AddExternalBlockElementRelationType : AsyncMigrationBase
+{
+    private readonly IRelationService _relationService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AddExternalBlockElementRelationType"/> class.
+    /// </summary>
+    /// <param name="context">The migration context.</param>
+    /// <param name="relationService">The relation service used to create the relation type.</param>
+    public AddExternalBlockElementRelationType(IMigrationContext context, IRelationService relationService)
+        : base(context)
+        => _relationService = relationService;
+
+    /// <inheritdoc />
+    protected override Task MigrateAsync()
+    {
+        IRelationType? relationType = _relationService.GetRelationTypeByAlias(
+            Constants.Conventions.RelationTypes.RelatedExternalBlockElementAlias);
+        if (relationType != null)
+        {
+            return Task.CompletedTask;
+        }
+
+        // Generate the same unique key a fresh install would produce.
+        Guid key = DatabaseDataCreator.CreateUniqueRelationTypeId(
+            Constants.Conventions.RelationTypes.RelatedExternalBlockElementAlias,
+            Constants.Conventions.RelationTypes.RelatedExternalBlockElementName);
+
+        // Save via the service so the repository cache is updated as well.
+        relationType = new RelationType(
+            Constants.Conventions.RelationTypes.RelatedExternalBlockElementName,
+            Constants.Conventions.RelationTypes.RelatedExternalBlockElementAlias,
+            false,
+            parentObjectType: null,
+            childObjectType: null,
+            isDependency: true)
+        {
+            Key = key
+        };
+        _relationService.Save(relationType);
+
+        return Task.CompletedTask;
+    }
+}
@@ -114,13 +114,6 @@ 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,12 +90,6 @@ 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,7 +48,6 @@ internal static class PropertyGroupFactory
            UniqueId = propertyType.Key,
            Variations = (byte)propertyType.Variations,
            LabelOnTop = propertyType.LabelOnTop,
-            EditableInVisualEditor = propertyType.EditableInVisualEditor,
        };

        if (groupId != default)
@@ -34,7 +34,6 @@ 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,7 +440,6 @@ internal sealed class ContentTypeCommonRepository : IContentTypeCommonRepository
            ValidationRegExpMessage = dto.ValidationRegExpMessage,
            Variations = (ContentVariation)dto.Variations,
            LabelOnTop = dto.LabelOnTop,
-            EditableInVisualEditor = dto.EditableInVisualEditor,
        };
    }
 }
@@ -1,7 +1,6 @@
 using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Cache;
-using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Persistence.Repositories;
 using Umbraco.Cms.Infrastructure.Scoping;

@@ -35,27 +34,4 @@ internal sealed class ElementContainerRepository : EntityContainerRepository, IE
            cacheSyncService)
    {
    }
-
-    protected override void PersistDeletedItem(EntityContainer entity)
-    {
-        if (entity == null)
-        {
-            throw new ArgumentNullException(nameof(entity));
-        }
-
-        // Element containers can be referenced as start nodes on individual users (umbracoUserStartNode)
-        // and on user groups (umbracoUserGroup.startElementId). Both reference umbracoNode.id via FK,
-        // so we must clear those references before deleting the underlying node.
-        var args = new { id = entity.Id };
-        Database.Execute(
-            $"DELETE FROM {QuoteTableName(Constants.DatabaseSchema.Tables.UserStartNode)} WHERE {QuoteColumnName("startNode")} = @id",
-            args);
-        Database.Execute(
-            $@"UPDATE {QuoteTableName(Constants.DatabaseSchema.Tables.UserGroup)}
-               SET {QuoteColumnName("startElementId")} = NULL
-               WHERE {QuoteColumnName("startElementId")} = @id",
-            args);
-
-        base.PersistDeletedItem(entity);
-    }
 }
@@ -110,10 +110,10 @@ public abstract class BlockEditorPropertyNotificationHandlerBase<TBlockLayoutIte

    private void TraverseObject(JsonObject obj)
    {
-        // we'll assume that the object is a data representation of a block based editor if it contains "contentData" and "settingsData".
-        if (obj["contentData"] is JsonArray contentData && obj["settingsData"] is JsonArray settingsData)
+        // we'll assume that the object is a data representation of a block based editor if it contains "contentData", "settingsData" and "layout".
+        if (obj["contentData"] is JsonArray contentData && obj["settingsData"] is JsonArray settingsData && obj["layout"] is JsonObject layoutData)
        {
-            ParseKeys(contentData, settingsData);
+            ParseKeys(contentData, settingsData, layoutData);
            return;
        }

@@ -123,12 +123,46 @@ public abstract class BlockEditorPropertyNotificationHandlerBase<TBlockLayoutIte
        }
    }

-    private void ParseKeys(JsonArray contentData, JsonArray settingsData)
+    private void ParseKeys(JsonArray contentData, JsonArray settingsData, JsonObject layoutData)
    {
-        // grab all keys from the objects of contentData and settingsData
-        var keys = contentData.Select(c => c?["key"])
-            .Union(settingsData.Select(s => s?["key"]))
-            .Select(keyToken => keyToken?.GetValue<string>().NullOrWhiteSpaceAsNull())
+        // recurse a JSON object to find all contained block editor layouts
+        static List<JsonObject> GetLayoutItemsRecursively(JsonObject jsonObject)
+        {
+            var layoutItems = new List<JsonObject>();
+            if (jsonObject.ContainsKey("key") && jsonObject.ContainsKey("contentKey"))
+            {
+                // assume it's a layout if it has "key" and "contentKey"
+                layoutItems.Add(jsonObject);
+            }
+
+            foreach (JsonNode property in jsonObject.Select(v => v.Value).WhereNotNull())
+            {
+                IEnumerable<JsonObject> childrenToRecurse = property is JsonObject jsonObjectChild
+                    ? [jsonObjectChild]
+                    : property is JsonArray jsonArrayChild
+                        ? jsonArrayChild.OfType<JsonObject>()
+                        : [];
+                layoutItems.AddRange(childrenToRecurse.SelectMany(GetLayoutItemsRecursively));
+            }
+
+            return layoutItems;
+        }
+
+        // grab keys applicable for replacement from all the layouts - that is:
+        // - the key of the layout itself ("key").
+        // - the key of the content item ("contentKey").
+        //   - ONLY for local content; do NOT replace content item keys for external content.
+        // - the key of the settings item ("settingsKey") if present.
+        List<JsonObject> layoutItems = GetLayoutItemsRecursively(layoutData);
+        var keys = layoutItems.SelectMany(layoutItem => new[]
+            {
+                layoutItem["key"]?.GetValue<string>(),
+                layoutItem["isExternalContent"]?.GetValue<bool>() is not true
+                    ? layoutItem["contentKey"]?.GetValue<string>()
+                    : null,
+                layoutItem["settingsKey"]?.GetValue<string>(),
+            })
+            .WhereNotNull()
            .ToArray();

        // the following is solely for avoiding functionality wise breakage. we should consider removing it eventually, but for the time being it's harmless.
@@ -127,7 +127,7 @@ public abstract class BlockEditorPropertyValueEditor<TValue, TLayout> : BlockVal
    }

    private static bool IsBlockEditorDataEmpty([NotNullWhen(false)] BlockEditorData<TValue, TLayout>? editorData)
-        => editorData is null || editorData.BlockValue.ContentData.Count == 0;
+        => editorData is null || editorData.BlockValue.Layout.Count == 0;

    // We don't throw on error here because we want to be able to parse what we can, even if some of the data is invalid. In cases where migrating
    // from nested content to blocks, we don't want to trigger a fatal error for retrieving references, as this isn't vital to the operation.
@@ -63,13 +63,20 @@ public class BlockEditorValues<TValue, TLayout>

    private BlockEditorData<TValue, TLayout>? Clean(BlockEditorData<TValue, TLayout> blockEditorData)
    {
-        if (blockEditorData.BlockValue.ContentData.Count == 0)
+        if (blockEditorData.BlockValue.Layout.Count == 0)
        {
            // if there's no content ensure there's no settings too
            blockEditorData.BlockValue.SettingsData.Clear();
            return null;
        }

+        if (blockEditorData.BlockValue.ContentData.Count == 0
+            && blockEditorData.BlockValue.SettingsData.Count == 0)
+        {
+            // no local content or settings; the block editor must contain only global elements
+            return blockEditorData;
+        }
+
        var contentTypePropertyTypes = new Dictionary<string, Dictionary<string, IPropertyType>>();

        // filter out any content that isn't referenced in the layout references
@@ -26,7 +26,7 @@ public class BlockGridPropertyEditor : BlockGridPropertyEditorBase
    public BlockGridPropertyEditor(
        IDataValueEditorFactory dataValueEditorFactory,
        IIOHelper ioHelper,
-        IBlockValuePropertyIndexValueFactory blockValuePropertyIndexValueFactory)
+        IBlockGridPropertyIndexValueFactory blockValuePropertyIndexValueFactory)
        : base(dataValueEditorFactory, blockValuePropertyIndexValueFactory)
        => _ioHelper = ioHelper;

@@ -25,9 +25,9 @@ namespace Umbraco.Cms.Core.PropertyEditors;
 /// </summary>
 public abstract class BlockGridPropertyEditorBase : DataEditor, IValueSchemaProvider
 {
-    private readonly IBlockValuePropertyIndexValueFactory _blockValuePropertyIndexValueFactory;
+    private readonly IBlockGridPropertyIndexValueFactory _blockValuePropertyIndexValueFactory;

-    protected BlockGridPropertyEditorBase(IDataValueEditorFactory dataValueEditorFactory, IBlockValuePropertyIndexValueFactory blockValuePropertyIndexValueFactory)
+    protected BlockGridPropertyEditorBase(IDataValueEditorFactory dataValueEditorFactory, IBlockGridPropertyIndexValueFactory blockValuePropertyIndexValueFactory)
        : base(dataValueEditorFactory)
    {
        _blockValuePropertyIndexValueFactory = blockValuePropertyIndexValueFactory;
--- a/Show More
+++ b/Show More