diff --git a/THIRD-PARTY-NOTICES.md b/THIRD-PARTY-NOTICES.md
index fae64574..e177eee6 100644
--- a/THIRD-PARTY-NOTICES.md
+++ b/THIRD-PARTY-NOTICES.md
@@ -66,6 +66,8 @@ Copied into the VSIX at `bin/all/` alongside the sidecar executable.
 | Serilog | 4.4.0 | Apache-2.0 | Serilog Contributors |
 | Serilog.Sinks.File | 7.0.0 | Apache-2.0 | Serilog Contributors |
 | Outcome | 1.0.0 | MIT | Christian Findlay |
+| Microsoft.CodeAnalysis.Razor.Compiler and Microsoft.AspNetCore.Razor.Utilities.Shared (the Razor compiler, copied from the .NET SDK) | 10.0.0-preview.26377.103 (SDK 10.0.303) | MIT | .NET Foundation and Contributors |
+| Microsoft.Extensions.ObjectPool (copied from the .NET SDK with the Razor compiler) | 10.0.1 | MIT | .NET Foundation and Contributors |
 
 > `Microsoft.Build`, `Microsoft.Build.Framework`, and `Microsoft.NET.StringTools`
 > are referenced **compile-time only** (`ExcludeAssets="runtime"`); MSBuildLocator
diff --git a/coverage-thresholds.json b/coverage-thresholds.json
index ffb1b25d..89bada40 100644
--- a/coverage-thresholds.json
+++ b/coverage-thresholds.json
@@ -12,7 +12,7 @@
       "language": "dotnet"
     },
     "sharplsp-sidecar-csharp": {
-      "threshold": 95,
+      "threshold": 95.39,
       "language": "dotnet"
     },
     "sharplsp-sidecar-fsharp": {
diff --git a/docs/plans/RAZOR-PLAN.md b/docs/plans/RAZOR-PLAN.md
new file mode 100644
index 00000000..66e28729
--- /dev/null
+++ b/docs/plans/RAZOR-PLAN.md
@@ -0,0 +1,89 @@
+# Razor and Blazor Implementation Plan
+
+**Spec:** [RAZOR-SPEC.md](../specs/RAZOR-SPEC.md)
+
+## Context
+
+SharpLsp has not supported `.razor` or `.cshtml` files until now. Research confirmed three things ([RAZOR-RESEARCH]):
+
+- The SDK's own Razor source generator already runs inside the C# sidecar's design-time workspace.
+- Its enhanced `#line` directives map every C# fragment back to Razor.
+- The public compiler IR supplies everything the mapping misses.
+
+So the C# sidecar owns Razor end to end, the host routes the documents to it, and the editors sync and forward HTML.
+
+The phases below are in dependency order. Each item is checked only when a test that exercises it passes.
+
+## TODO
+
+### Phase 1: Foundation
+
+- [x] Fixture solution `src/sharplsp/tests/fixtures/razor/` with `BlazorApp`, `Widgets` (RCL), `PagesApp` (Pages + MVC) and `Domain` (F#), isolated by its own `Directory.Build.props` ([RAZOR-TESTING])
+- [x] Host: add `LangId::Razor` for `.razor` and `.cshtml`, owned by the C# sidecar ([RAZOR-ARCHITECTURE-ROUTING])
+- [x] Host: route `documentSymbol`, `foldingRange` and `linkedEditingRange` for Razor to the sidecar, and answer `selectionRange` empty
+- [x] Host: add `<` and `@` completion triggers, and short-circuit them for C# and F# documents
+- [x] Host: publish Razor diagnostics under the source `sharplsp-razor`
+- [x] Sidecar: bundle the Razor compiler from the build SDK, and list it in `THIRD-PARTY-NOTICES.md` ([RAZOR-ARCHITECTURE-ENGINE])
+- [x] Sidecar: find Razor files as additional documents, and sync their text in every framework context, including the pending-edit replay ([RAZOR-ARCHITECTURE-DOCUMENTS])
+- [x] Sidecar: build the C# projection — find the generated document by its checksum pragma, and build the verified span map in both directions ([RAZOR-ARCHITECTURE-PROJECTION])
+  - [x] Verify the checksum lookup, the mappings that never map (hidden, fileless, foreign, outside either text), carets at a fragment's end, and rename's check that a span holds the old name — `RazorProjectionTests`: 6 passing cases over hand-written generator output
+- [x] Sidecar: build the Razor engine per project — configuration from the analyzer and parse options, an in-memory file system, tag helpers per compilation, the capture pass and markup facts
+  - [x] Verify configuration fallbacks, target-path metadata, current file/import reads, missing files, missing paths, cancellation and failure recovery — `RazorEngineSettingsTests`: 12 passing cases; settings, filesystem and engine each have 100% line coverage
+- [x] Sidecar: build the HTML projection and the markup-context tokenizer ([RAZOR-ARCHITECTURE-HTML])
+  - [x] HTML projection from compiler IR, preserving offsets/newlines and current unsaved text — `RazorHtmlProjectionTests`: 19 passing fixture cases (Blazor and MVC, comments, UTF-16, incomplete tags, unsaved edits)
+  - [x] HTML markup-context tokenizer — `HtmlMarkupContextTests`: 36 passing cases with 100% line coverage, including malformed start/end tag recovery; the three character-reconsumption regressions were verified failing before the fix and pass unchanged afterward
+  - [x] Host: `sharplsp/razor/htmlProjection` answers `{ text }`, or `null` for a file no project lists — `test_full_stack_razor_routing_session`
+  - [x] Verify `sharplsp/razor/htmlProjection` through editor integration — `razor-lsp.test.ts`: the projection keeps the editor's offsets, line breaks and unsaved text, and feeds VS Code's HTML completion and hover
+
+**Validation (2026-10-20):** the Release sidecar solution builds with zero warnings and errors; 671 C#, 440 F# and 125 Common tests pass, and all three coverage gates pass. C# coverage is 96.39%, with all 1,530 new C# executable lines covered. `RazorSidecarTests` exercises the real IPC contract and malformed-request recovery; `RazorCompletionEditsTests` covers mapped edits, import deduplication, aliases, static imports and LF/CRLF insertion.
+
+**Editor validation (2026-10-20):** the final Razor chunk passes all 6 cases, the workspace chunk passes all 446 cases (including server-start lifecycle), the debugger chunk passes all 80 cases, and editor lint and formatting pass. The debugger group-outcome test that previously timed out passes unchanged in the full chunk in 6.5 seconds.
+
+**Template validation (2026-10-20):** the real host and sidecars run over a fresh `dotnet new blazor` app (.NET 10). Its files report no errors and keep their shape in the HTML projection. Hover, definition, references, member completion and signature help answer on its real code: layouts, `@inherits`, `@Body`, `NavLinkMatch`, `@Assets`, `typeof(Program)`. The one false report found was usings marked unnecessary: every using in `_Imports.razor`, and, as review showed, a component's usings that only its markup needs. Razor files no longer report unnecessary usings (`Import_files_never_report_their_usings_as_unnecessary`, `Components_never_report_a_using_their_markup_may_need_as_unnecessary`).
+
+### Phase 2: C# Inside Razor
+
+- [ ] Diagnostics: C# diagnostics from projections, `RZ` diagnostics from facts, and Razor files in solution-wide diagnostics ([RAZOR-FEATURES-DIAGNOSTICS])
+- [x] Hover at mapped positions ([RAZOR-FEATURES-HOVER])
+- [ ] Definition, type definition, declaration and implementation from mapped positions, with generated component classes landing in their `.razor` file ([RAZOR-FEATURES-DEFINITION])
+- [x] References and document highlights across projections, with hidden scaffolding dropped ([RAZOR-FEATURES-REFERENCES])
+- [x] C# completion, with mapped edits and `using` → `@using` ([RAZOR-FEATURES-COMPLETION])
+- [x] Signature help ([RAZOR-FEATURES-SIGNATURE-HELP])
+- [x] Semantic tokens for C# fragments ([RAZOR-FEATURES-SEMANTIC-TOKENS])
+- [ ] Rename and prepareRename — Razor usages and `@code` declarations, from `.cs` and `.razor` origins ([RAZOR-FEATURES-RENAME])
+
+### Phase 3: Blazor Markup
+
+- [ ] Component tags: hover, definition, references, highlights and linked editing
+- [ ] Component attributes and `@bind-X`: hover, definition, references and rename
+- [ ] Directive attributes and directives: hover
+- [ ] Completion: components, parameters (with `[EditorRequired]` first), `@bind-X`, directive attributes and their parameters, and directives
+- [ ] Semantic tokens for markup: component tags, attributes, directive attributes and directives
+- [ ] Folding ranges and document symbols ([RAZOR-FEATURES-STRUCTURE])
+
+### Phase 4: Razor Pages and MVC
+
+- [ ] `@model`, `@inject`, `@section` and `@functions` through the projection ([RAZOR-MVC])
+- [ ] Tag helper elements and attributes: hover and completion
+- [ ] `_ViewImports.cshtml` imports resolved by the engine
+
+### Phase 5: Editors
+
+- [x] VS Code: sync `razor` and `aspnetcorerazor` documents, and activate on `onLanguage:razor` ([RAZOR-EDITORS]) — `razor-lsp.test.ts`: a Razor file opens as Razor, and its unsaved edits reach the server
+- [x] VS Code: forward HTML completion and hover over `sharplsp/razor/htmlProjection` ([RAZOR-FEATURES-HTML]) — `razor-lsp.test.ts`: element names and HTML hovers in markup, C# completion and hover in code
+- [x] VS Code: add a `razor` end-to-end chunk on both platforms — `test-chunks.json`, in both matrices
+- [x] Zed: Razor language registration (Zed has no built-in Razor grammar) — `the_server_attaches_to_the_csharp_fsharp_and_razor_languages`
+
+### Phase 6: F#
+
+- [ ] Hover, completion and definition from Razor into F# types of a referenced F# project ([RAZOR-FSHARP])
+- [ ] F#-origin rename that includes Razor usages, mapped back from the projections
+
+### Deferred ([RAZOR-FEATURES-DEFERRED])
+
+- [ ] Razor formatting
+- [ ] Selection ranges
+- [ ] Code actions: extract a block to code-behind, extract a component, generate an event handler, add `@using`
+- [ ] Inlay hints, code lens, and call and type hierarchy from Razor positions
+- [ ] `.razor.css` and `.razor.js` collocation awareness
+- [ ] Blazor WebAssembly debugging and Razor Hot Reload
diff --git a/docs/specs/DESIGN-SYSTEM.md b/docs/specs/DESIGN-SYSTEM.md
index 2cf5196c..61b5471c 100644
--- a/docs/specs/DESIGN-SYSTEM.md
+++ b/docs/specs/DESIGN-SYSTEM.md
@@ -137,9 +137,26 @@ Screenshots and video of a SharpLsp feature show the real extension, never a moc
   - Every autoplaying video pauses and shows its controls under `prefers-reduced-motion: reduce`.
   - Every video ships a WebP poster, the films and the recordings alike.
 - **Narration.** A walkthrough may be narrated (`kit/sound/`). Its reviewed script (`films/<film>.narration.json`) is spoken by Kokoro-82M through `kokoro-js` on the capturing machine, never by a speech service or the operating system's voices, whose licences forbid publishing. Each line starts just after its scene's cut, and a scene holds its last frame until its line ends. The music is an original score synthesised from code (`kit/sound/score.mjs`), so no film carries licensed or sampled music, and it ducks under the voice. A narrated film ships AAC in its MP4 and Opus in its WebM, plays unmuted with controls, and carries WebVTT captions in every site language (`<id>.<lang>.vtt`, the page's own language shown by default), listed under `captions` in the catalogue.
-- **One catalogue.** Every video on the site is declared once in `src/website/src/_data/videos.json`: encodings, size, length, upload date, and its label and caption in each language. Pages place a video with the `{% video "<id>" %}` shortcode (`src/website/video-figure.js`) and never repeat `<video>` markup. The shortcode renders in the page's language and emits a schema.org `VideoObject` whose name is the player's label, so search results describe exactly what a reader hears.
+- **One catalogue.** Every video on the site is declared once in `src/website/src/_data/videos.json`: encodings, size, length, upload date, the `page` that explains it, and its label and caption in each language. Every video also ships a 1200x630 JPEG social card, `<id>-card.jpg`, cut from its poster frame by `kit/encode.mjs`. Pages place a video with the `{% video "<id>" %}` shortcode (`src/website/video-figure.js`) and never repeat `<video>` markup. The shortcode renders in the page's language and emits a schema.org `VideoObject` whose name is the player's label, so search results describe exactly what a reader hears.
 - **Placement.** A video goes wherever a page talks about what it shows: the home page (the profiler film autoplaying in the hero, the CPU recording in the profiler section), every docs page with a feature to show (its own narrated walkthrough, after the page's introduction; the profiler docs add both recordings, the F# language page the F# profiling walkthrough too), and every blog post that discusses the profiler or the editor experience, in every language the page is published in. The Zed page has no film: Zed is a native application, and filming it would mean recording the real desktop.
 
+## [WEB-DESIGN-MEDIA-DISCOVERY] Video Search and Sharing
+
+Every catalogued video can be found in Google's video results and plays in social previews. The rules follow Google's [video SEO best practices](https://developers.google.com/search/docs/appearance/video), [VideoObject structured data](https://developers.google.com/search/docs/appearance/structured-data/video) and [video sitemaps](https://developers.google.com/search/docs/crawling-indexing/sitemaps/video-sitemaps).
+
+- **Watch pages.** Google only shows a video in video results from a page where it is the main content, and a docs page is not one. Each video therefore has a watch page per site language at `/videos/<id>/` (`/<lang>/videos/<id>/`), generated from the catalogue. It holds the video's label as the title and heading, the player, a link to the `page` that explains it, and the narration's transcript, read from its captions. It is dated by its video's upload, in its `datePublished` and its sitemap `lastmod`, never by a build. Docs and article figures link to their video's watch page.
+- **Embed pages.** `/videos/<id>/embed/` is the bare player and nothing else (`noindex`). It is the `embedUrl` in structured data, the `player_loc` in the sitemap, and the `twitter:player` an X card frames.
+- **Structured data.** Every figure's `VideoObject` carries `name`, `description`, `thumbnailUrl` (the WebP poster, the one thumbnail per video everywhere), `contentUrl` (the MP4), `embedUrl`, `uploadDate` with its time zone, `duration`, `width` and `height`, which must match the real files. A watch page adds `transcript` and a `SeekToAction` whose `?t=<seconds>` deep link starts the film at that second (`custom.js`), so Google can offer key moments.
+- **Sitemap.** `sitemap.xml` lists every page, including every docs page, and every watch page carries a `<video:video>` entry: thumbnail, title, description, content and player locations, duration in seconds and publication date. It is the site's own template (`overrides/sitemap.njk`).
+- **Crawling.** `robots.txt` never disallows `/assets/`: Google must fetch video files and thumbnails, and X, LinkedIn and Slack read the generic `User-agent: *` group before fetching card images and videos.
+- **Social previews.** A docs page previews the first catalogued video whose `page` it is, and a watch page previews its own video. The preview uses:
+  - `og:image` and `twitter:image`: the 1200x630 card, with its alt text;
+  - `og:video`: the MP4, with its type and size, for networks that play it inline;
+  - an X `player` card: the embed page, with the MP4 as its stream.
+
+  A watch page is `og:type` `video.other`, with `video:duration` and `video:release_date`. A page without a film shares the site's `og-image.png`, with its alt text.
+- **Docs metadata.** Every docs page has its own `description` in every language, and its `<title>` ends in `| SharpLsp`.
+
 ## [WEB-DESIGN-RESPONSIVE] Responsive Behavior
 
 Design mobile-first: content order, meaning, and actions must work in a single column without hover. `768px` is the primary responsive boundary; at and below it:
diff --git a/docs/specs/DISTRIBUTION-SPEC.md b/docs/specs/DISTRIBUTION-SPEC.md
index 2524895f..03728857 100644
--- a/docs/specs/DISTRIBUTION-SPEC.md
+++ b/docs/specs/DISTRIBUTION-SPEC.md
@@ -685,9 +685,12 @@ Every rule below binds the upstream server option and the dev extension alike.
 1. **A language server and nothing else.** The server id is `sharplsp` in both
    extensions, so `lsp.sharplsp.*` settings are the same in either. It declares
    no grammar: the C# and F# extensions define the `CSharp` and `FSharp`
-   languages it attaches to, with LSP language ids `csharp` and `fsharp`. Users
-   choose it with Zed's per-language `language_servers` setting. Zed has
-   removed extension slash commands, so it declares none.
+   languages it attaches to, with LSP language ids `csharp` and `fsharp`. It
+   also attaches to `Razor`, with LSP language id `razor`: Zed has no built-in
+   Razor language, and the community Razor extensions all name theirs `Razor`
+   ([RAZOR-EDITORS]). Users choose it with Zed's per-language
+   `language_servers` setting. Zed has removed extension slash commands, so it
+   declares none.
 2. **Never bundled.** The server resolves from `lsp.sharplsp.binary.path`, then
    `sharplsp` on the worktree's PATH, then a download: the latest stable release's
    [DIST-ARCHIVE] asset for this platform, unpacked into the extension's work
diff --git a/docs/specs/RAZOR-SPEC.md b/docs/specs/RAZOR-SPEC.md
new file mode 100644
index 00000000..f8cfed01
--- /dev/null
+++ b/docs/specs/RAZOR-SPEC.md
@@ -0,0 +1,424 @@
+# [RAZOR-SPEC] Razor: Blazor Components, Razor Pages and MVC Views
+
+**Parent:** [SHARPLSP-SPEC.md](SHARPLSP-SPEC.md) · **Plan:** [RAZOR-PLAN.md](../plans/RAZOR-PLAN.md)
+
+## [RAZOR-OVERVIEW] Overview
+
+SharpLsp edits Razor files with the same compiler-backed intelligence it gives C#. That covers `.razor` Blazor components, and `.cshtml` Razor Pages and MVC views.
+
+Blazor support is complete, not a subset. Every component construct answers through the same features:
+
+- **Constructs:** components and their parameters, generic components, child content, cascading values, event callbacks, two-way binding, directive attributes, render modes, and the C# inside all of them.
+- **Features:** hover, navigation, completion, references, rename, diagnostics and highlighting.
+
+Razor's semantics belong to the Razor compiler. SharpLsp never re-implements Razor parsing or code generation. It runs the compiler that ships in the .NET SDK and reads that compiler's public outputs.
+
+## [RAZOR-SCOPE] Scope
+
+### [RAZOR-SCOPE-VERSIONS] Versions
+
+Only the latest release is supported: ASP.NET Core 10 on the .NET 10 SDK. Its projects compile Razor through the source generator at Razor language version 10.0, with the Roslyn tokenizer turned on.
+
+- **net8.0 and net9.0:** these projects compile Razor through the same source generator, so they work too, but they are not verified.
+- **Before net6.0:** these projects compile Razor without a source generator, so there is no C# projection ([RAZOR-ARCHITECTURE-PROJECTION]). They are out of scope.
+- **Other out-of-scope tooling:** ASP.NET MVC 5 and Web Pages Razor on .NET Framework (`System.Web.Razor`), Web Forms (`.aspx`, `.ascx`) and Razor runtime compilation.
+
+### [RAZOR-SCOPE-FILES] File Kinds
+
+| File | Razor kind | Role |
+|---|---|---|
+| `*.razor` | Component | A Blazor component |
+| `_Imports.razor` | Component import | `@using`, `@inject`, `@layout`, … applied to every component in its folder and below |
+| `*.cshtml` | Legacy | A Razor Page (`@page`), MVC view, partial view or layout |
+| `_ViewImports.cshtml` | Legacy import | Directives applied to every view and page in its folder and below |
+| `_ViewStart.cshtml` | Legacy | The code that runs before each view |
+
+The supported project SDKs are `Microsoft.NET.Sdk.Web`, `Microsoft.NET.Sdk.Razor` (Razor class libraries) and `Microsoft.NET.Sdk.BlazorWebAssembly`.
+
+### [RAZOR-SCOPE-LANGUAGE] Code Language
+
+Razor's code language is C#, because the Razor compiler generates only C#. [RAZOR-FSHARP] states what F# gets.
+
+## [RAZOR-RESEARCH] How the Razor Toolchain Works
+
+These findings come from research against SDK 10.0.303 in October 2026. They are the facts this design rests on.
+
+1. **The compiler ships as a source generator.** It is `sdk/<version>/Sdks/Microsoft.NET.Sdk.Razor/source-generators/Microsoft.CodeAnalysis.Razor.Compiler.dll`, a netstandard2.0 Roslyn generator; SDK 10.0.303's copy is built against Roslyn 5.5. No current NuGet package carries it: `Microsoft.AspNetCore.Razor.Language` stops at 6.0.36, and `Microsoft.Net.Compilers.Razor.Toolset` only has a few old previews.
+2. **A design-time build already runs it.** The SDK target `_PrepareRazorSourceGenerators` wires the generator in:
+   - It adds the generator as an `Analyzer`.
+   - It passes every Razor file as an `AdditionalFiles` item. Each item carries `TargetPath` metadata (base64-encoded) and `CssScope` metadata.
+   - It exposes `RazorLangVersion`, `RootNamespace`, `SupportLocalizedComponentNames`, `GenerateRazorMetadataSourceChecksumAttributes` and `MSBuildProjectDirectory` as `build_property.*` analyzer options.
+   - For net10.0 it adds `use-roslyn-tokenizer=true` to the C# parse options' `Features`.
+
+   No switch suppresses the generator. A design-time build through `MSBuildWorkspace` gives a project whose compilation runs it, just as `dotnet build` does.
+3. **Every C# fragment is mapped back to its Razor source.** Each Razor file gets one generated file, named after its target path, such as `Pages/Board_razor.g.cs`. That file opens with `#pragma checksum "<razor path>"`. The C# in each fragment is copied verbatim and wrapped in an enhanced `#line (line,col)-(line,col) [offset] "<razor path>"` directive:
+
+   | Mapped to C# | Not mapped |
+   |---|---|
+   | `@using`, `@page` route, `@inherits`, `@implements`, `@inject` type and name, `@model`, `@typeparam`, `@rendermode`, `@attribute` | component tag names (`<Counter>`) |
+   | implicit `@expr` and explicit `@(expr)` expressions | `@bind-X` and directive attribute names (`@onclick`) |
+   | code blocks `@{ }`, control flow `@if/@foreach/…`, `@code` and `@functions` blocks | HTML, Razor comments, transitions |
+   | component parameter names (as `nameof(Component.Param)`) and values | the `Changed`/setter half of `@bind` |
+   | event handler expressions, `@ref` targets, `@key` values, generic type arguments | tag helper element and attribute names (`asp-for`) |
+   | tag helper attribute values (`asp-for="Title"` → `__model => __model.Title`) | |
+
+4. **Roslyn reads those directives through public APIs.** `SyntaxTree.GetLineMappings()` exposes each directive, and `Location.GetMappedLineSpan()` maps any generated location back to the Razor file. Roslyn reports a mapped span's end one character past the fragment, so SharpLsp measures each fragment by comparing the source text with the generated text instead.
+5. **Roslyn's IDE services work on generated documents.** Completion, symbol lookup, references and classification all work on a `SourceGeneratedDocument`. A reference that Roslyn finds in generated code carries the Razor path through the mapping. A reference inside hidden scaffolding, such as `__builder` calls and `@bind` setters, has no mapped path.
+6. **The compiler's public API covers what the C# mapping misses.**
+   - **Public:** `RazorProjectEngine` and its configuration; parser options that list the directives active for a file kind; the intermediate representation (`Microsoft.AspNetCore.Razor.Language.Intermediate`); the `IntermediateNodePassBase` extension point; tag-helper descriptors; and `CompilationTagHelperFeature`.
+   - **Internal:** the syntax tree nodes and the generated C# document.
+   - **What the IR carries:** component tag names (`ComponentIntermediateNode.StartTagSpan`), attribute name spans (`OriginalAttributeSpan`), `@bind-X` pairs, elements, directives and Razor diagnostics.
+7. **Microsoft's own tooling is not used.** Its Razor language server, now cohosted inside Roslyn's language server, depends on internal compiler APIs. SharpLsp reimplements from the public surface above ([SHARPLSP-MISSION-PRINCIPLES]).
+8. **VS Code already knows Razor files.** It ships a built-in `razor` language for `.cshtml` and `.razor` with a TextMate grammar. HTML language features reach embedded HTML through request forwarding, as described in the VS Code guide [Embedded Programming Languages](https://code.visualstudio.com/api/language-extensions/embedded-languages).
+
+## [RAZOR-ARCHITECTURE] Architecture
+
+```mermaid
+flowchart LR
+    Editor -- "LSP (razor, aspnetcorerazor)" --> Host["Rust host<br/>LangId::Razor"]
+    Host -- "MessagePack IPC" --> Sidecar["C# sidecar"]
+    subgraph Sidecar["C# sidecar"]
+        Additional["Razor file<br/>(AdditionalDocument)"] --> Generator["SDK Razor source generator<br/>(run by Roslyn)"]
+        Generator --> Projection["C# projection<br/>(SourceGeneratedDocument + #line map)"]
+        Additional --> Engine["Bundled Razor engine<br/>(IR capture pass)"]
+        Compilation["Project compilation"] --> Engine
+        Engine --> Facts["Markup facts<br/>(components, attributes, directives, diagnostics)"]
+    end
+    Projection --> Answers["C# answers mapped to Razor"]
+    Facts --> Answers2["Markup answers"]
+```
+
+### [RAZOR-ARCHITECTURE-ROUTING] Host Routing
+
+- **Ownership:** `.razor` and `.cshtml` URIs are `LangId::Razor`, and the C# sidecar owns them. It receives their `didOpen` and `didChange` text and their diagnostics pulls, and it answers every request about them.
+- **Syntax requests:** for C#, the host answers `documentSymbol`, `foldingRange`, `selectionRange` and `linkedEditingRange` from tree-sitter. For a Razor file it forwards `documentSymbol`, `foldingRange` and `linkedEditingRange` to the sidecar instead, because the Razor compiler is the parser and no tree-sitter Razor grammar is trusted. `selectionRange` on a Razor file answers empty until it is implemented ([RAZOR-FEATURES-DEFERRED]).
+- **Completion triggers:** the server adds `<` and `@` as completion triggers. A C# or F# document triggered by one of these two characters answers `null` at once, without reaching a sidecar.
+- **Diagnostic source:** Razor diagnostics publish under the source `sharplsp-razor`.
+
+### [RAZOR-ARCHITECTURE-DOCUMENTS] Razor Documents in the Workspace
+
+- **Where a Razor file lives:** it is an `AdditionalDocument` of every project that lists it, with one copy per target framework.
+- **Edits:** `didOpen` and `didChange` text replaces that additional document's text in every framework context, just as for C# documents ([NETFX-CONTEXT]). An edit that arrives before the workspace loads is replayed once it does.
+- **Which context answers:** a Razor file answers from the project context that is active ([NETFX-PROJECTS-CSHARP]).
+- **Unlisted files:** a Razor file that no project lists has no semantics, so every request about it answers empty.
+
+### [RAZOR-ARCHITECTURE-PROJECTION] C# Projection
+
+- **The projection:** a Razor file's projection is the generated document whose `#pragma checksum` names that file. `_Imports.razor` `@using` lines also appear in every component's generated document, but only `_Imports.razor`'s own generated document is its projection.
+- **The map:** the map is built from the projection's line mappings whose path is the Razor file. Each entry pairs a Razor span with a generated span. Both spans hold the same text, and SharpLsp measures each one by comparing that text.
+- **Razor to C#:** a Razor offset `o` is C# when some entry's Razor span contains `o` or ends at `o`. A caret just after `@curr` is C#, so completion works while typing. The generated offset is `generatedStart + (o − razorStart)`. When `o` ends one entry and starts the next, the entry that contains `o` wins.
+- **C# to Razor:**
+  - A location maps through `Location.GetMappedLineSpan()` when the result has a mapped path.
+  - A location inside a projection with no mapped path is hidden scaffolding and is dropped.
+  - There is one exception. The declaration of a component's own generated class maps to the start of its Razor file, because a component *is* its file.
+- **Text edits:**
+  - An edit computed on a projection maps back only when it lies entirely inside one entry.
+  - An edit that adds a C# `using` becomes an `@using` line in the Razor file ([RAZOR-FEATURES-COMPLETION]).
+  - Any other edit that cannot be mapped drops the item or action that carries it.
+
+### [RAZOR-ARCHITECTURE-ENGINE] The Razor Engine
+
+- **The bundled compiler:** SharpLsp bundles the Razor compiler assemblies from the SDK that builds it: `Microsoft.CodeAnalysis.Razor.Compiler`, `Microsoft.AspNetCore.Razor.Utilities.Shared` and `Microsoft.Extensions.ObjectPool`, all MIT-licensed.
+- **Two compilers, two jobs:** the project's own SDK generator still produces the C# projection, so C# answers always match the user's build. The bundled engine reads markup structure only, and a newer or older SDK cannot break it.
+- **Configuration:** each project's engine reads the same inputs the generator reads:
+  - the analyzer options `build_property.RazorLangVersion`, `RootNamespace` and `SupportLocalizedComponentNames`;
+  - the C# parse options: language version, preprocessor symbols and the `use-roslyn-tokenizer` feature;
+  - each file's decoded `TargetPath`.
+- **Features:**
+  - `CompilerFeatures.Register` provides components;
+  - MVC's `RazorExtensions.Register` provides pages, views and tag helpers;
+  - tag helpers are discovered by `CompilationTagHelperFeature` over the project's compilation, generated components included, and over every reference of that compilation, project references included;
+  - capture passes read the IR while the compiler builds it ([RAZOR-ARCHITECTURE-ENGINE-CAPTURE]).
+- **File system:** the engine reads files through an in-memory Razor file system over the project's Razor documents. Imports therefore resolve as the compiler resolves them: the default imports, then hierarchical `_Imports.razor` or `_ViewImports.cshtml`, all from the workspace's current text.
+- **Markup facts:** processing a file returns its markup facts ([RAZOR-ARCHITECTURE-ENGINE-FACTS]).
+- **State lifetime:** tag helpers are compiler state derived from one Roslyn compilation, and they are held only as long as that compilation lives (keyed to its instance). They are never held per request, and they are never feature results ([SHARPLSP-ARCHITECTURE-CACHING]).
+
+#### [RAZOR-ARCHITECTURE-ENGINE-CAPTURE] Capture Passes
+
+Later passes rewrite the IR, so each capture pass copies what it needs the moment it runs:
+
+| Pass | Runs | Reads |
+|---|---|---|
+| Directives | First in the directive-classifier phase, before `@code` becomes plain C# | Directives, `@using` included, and the HTML projection |
+| Tags | First in the optimization phase, before components are lowered and attribute names lose their spans | Elements, attributes, and the namespaces `@using` imports |
+| Diagnostics | Last in the optimization phase | `RZ` diagnostics |
+
+- **Spans:** every span comes from the compiler. Where a node has no span for a part (an end tag's name, a directive's name, a directive attribute's `@`), the part's span is derived from the node's span and kept only when the text there is that part.
+- **Imports:** directives and tags of imported files are skipped. A diagnostic is kept only when it lies in the processed file.
+
+#### [RAZOR-ARCHITECTURE-ENGINE-FACTS] Markup Facts
+
+```typediagram
+typeDiagram
+
+# A Razor file's markup facts, read from the compiler's IR.
+type RazorMarkup {
+  file_kind: RazorFileKind
+  # The namespace the file's class is generated in.
+  namespace: Option<String>
+  # Namespaces the file and its imports bring in with `@using`.
+  imported_namespaces: List<String>
+  tags: List<MarkupTag>
+  attributes: List<MarkupAttribute>
+  directives: List<MarkupDirective>
+  diagnostics: List<MarkupDiagnostic>
+  # Directives the file kind accepts.
+  available_directives: List<DirectiveDescriptor>
+  # Every tag helper the project's compilation provides, components included.
+  tag_helpers: List<TagHelperDescriptor>
+  # The HTML projection ([RAZOR-ARCHITECTURE-HTML]).
+  html_text: String
+}
+
+# An element bound to tag helpers, or any element of a component file.
+type MarkupTag {
+  name: String
+  element: TextSpan
+  start_name: TextSpan
+  # Absent for a self-closing or unclosed element.
+  end_name: Option<TextSpan>
+  # The component, child content and MVC tag helpers bound to the element.
+  tag_helpers: List<TagHelperDescriptor>
+}
+
+union MarkupAttributeKind {
+  # A component parameter or tag helper property: `Title="…"`, `asp-for="…"`.
+  Property
+  # A directive attribute: `@onclick`, `@bind-Value`, `@ref`.
+  Directive
+  # A directive attribute parameter: `@bind:event`, `@onclick:preventDefault`.
+  DirectiveParameter
+  # An attribute no tag helper binds.
+  Html
+}
+
+type MarkupAttribute {
+  kind: MarkupAttributeKind
+  name: String
+  name_span: Option<TextSpan>
+  owner: MarkupTag
+  tag_helper: Option<TagHelperDescriptor>
+  bound: Option<BoundAttributeDescriptor>
+  parameter: Option<BoundAttributeParameterDescriptor>
+}
+
+# A directive the file declares: `@page`, `@inject`, `@code`, `@using`.
+type MarkupDirective {
+  name: String
+  span: TextSpan
+  name_span: TextSpan
+  descriptor: Option<DirectiveDescriptor>
+}
+
+type MarkupDiagnostic {
+  # The `RZ` code.
+  id: String
+  message: String
+  severity: RazorDiagnosticSeverity
+  span: TextSpan
+}
+
+# A span of the file's text in UTF-16 code units (Roslyn's `TextSpan`).
+type TextSpan {
+  start: Int
+  length: Int
+}
+
+union RazorFileKind {
+  # A `.razor` component.
+  Component
+  # An `_Imports.razor` file.
+  ComponentImport
+  # A `.cshtml` page, view or `_ViewImports.cshtml`.
+  Legacy
+}
+
+union RazorDiagnosticSeverity {
+  Warning
+  Error
+}
+
+# The Razor compiler's descriptors, opaque here.
+type TagHelperDescriptor {}
+type BoundAttributeDescriptor {}
+type BoundAttributeParameterDescriptor {}
+type DirectiveDescriptor {}
+```
+
+The facts hold no C# fragment spans: C# positions come from the projection's map ([RAZOR-ARCHITECTURE-PROJECTION]).
+
+### [RAZOR-ARCHITECTURE-HTML] HTML Projection
+
+- **What it is:** the HTML projection is the Razor text with every non-HTML character replaced by a space, newlines kept, so offsets and positions are unchanged. The replaced characters are C# fragments with their transitions and delimiters, directives, and Razor comments.
+- **HTML comments:** a component's IR drops HTML comments. The engine therefore parses a component a second time with component parsing off, which keeps each comment's `<!--` and `-->` tokens, and copies those comment spans back into the projection.
+- **How it is served:** `sharplsp/razor/htmlProjection` (`{ textDocument }` → `{ text }`) returns the projection for the document's current text.
+- **Markup context:** the server finds the markup context at a caret by running an HTML tokenizer over the projection. The tokenizer follows the WHATWG tokenizer states. The possible contexts are a tag name, an attribute name, an attribute value, or content.
+
+## [RAZOR-FEATURES] Features
+
+### [RAZOR-FEATURES-DIAGNOSTICS] Diagnostics
+
+- **C#:** every diagnostic of the file's projection whose mapped path is the Razor file. Diagnostics in hidden scaffolding are dropped. A Razor file never calls a using unnecessary (`CS8019`, `IDE0005`), because Roslyn sees only the projection. Markup resolves component tags through usings that the generated C# never needs, since it names each component in full. An import file's (`_Imports.razor`, `_ViewImports.cshtml`) usings serve the files beside and below it.
+- **Razor:** the `RZ` diagnostics among the file's markup facts. Razor's error severity maps to LSP Error and its warning severity to LSP Warning.
+- **Solution-wide:** `workspace/diagnostics/all` reports Razor files as well.
+
+### [RAZOR-FEATURES-HOVER] Hover
+
+| Position | Answer |
+|---|---|
+| C# fragment | The C# hover at the mapped position, with its range mapped |
+| Component tag (start or end) | The component type's hover, ranged on the tag name |
+| Component attribute, `@bind-X` | The bound parameter property's hover |
+| Directive attribute (`@onclick`, `@bind`, `@key`, `@ref`, `@rendermode`, `@formname`, `@attributes`) | The descriptor's documentation |
+| Directive name (`@page`, `@inject`, …) | The directive's description |
+| MVC tag helper element or attribute | The tag helper type's or property's hover |
+| HTML | Nothing from the server. Clients forward HTML ([RAZOR-FEATURES-HTML]) |
+
+### [RAZOR-FEATURES-DEFINITION] Definition
+
+- **C# symbols:** resolved as in C#, with every result mapped back.
+- **Component tags, start or end:**
+  - A component authored in Razor goes to its `.razor` file, plus any code-behind partial class.
+  - A component from metadata goes to decompiled source ([DEFINITION-CSHARP]).
+- **Component attributes and `@bind-X`:** go to the parameter property.
+- **From C#:** `typeof(Counter)` or `new Counter()` also lands in `Counter.razor`, not in the generated file.
+
+### [RAZOR-FEATURES-REFERENCES] References and Highlights
+
+- **C# symbols:** references include every Razor usage through the projections, mapped back, with hidden scaffolding dropped and duplicates removed. This holds for requests from `.cs` files too.
+- **Component types:** references also include every start and end tag that instantiates the component, in every Razor file of the solution.
+- **Parameter properties:** references also include every `@bind-X` attribute that names the property.
+- **Document highlights:** the same rules, kept to the file. On a component tag, the start and end tag names highlight together.
+
+### [RAZOR-FEATURES-COMPLETION] Completion
+
+| Context at the caret | Items |
+|---|---|
+| C# fragment, or the end of one | Roslyn completion at the mapped position. Edits are mapped back, and an added `using` becomes an `@using` line |
+| After `<` in markup | Components in scope, each by its short name when its namespace is imported and by its full name otherwise, with documentation. Inside a component, its child-content parameters (`<ChildContent>`) |
+| Attribute name in a component start tag | Parameters not yet set, with `[EditorRequired]` ones first and marked; `@bind-X` for each bindable pair; directive attributes |
+| Attribute name in an element start tag | Directive attributes: `@on{event}`, `@bind`, `@bind-value`, `@key`, `@ref`, `@attributes`, `@rendermode`, `@formname` |
+| `@bind:` and `@on{event}:` | Parameters: `event`, `format`, `culture`, `get`, `set`, `after`, `preventDefault`, `stopPropagation` |
+| `@` at the start of a markup line | The directives active for the file kind, from the parser options |
+| MVC element start tag | Tag helper attributes (`asp-for`, `asp-page`, …) |
+
+The client adds HTML element and attribute names ([RAZOR-FEATURES-HTML]). The host's postfix templates (`.if`, `.foreach`, …) never apply in a Razor file, where the same text can be markup.
+
+### [RAZOR-FEATURES-SIGNATURE-HELP] Signature Help
+
+Signature help in a C# fragment is computed at the mapped position.
+
+### [RAZOR-FEATURES-RENAME] Rename
+
+- **C# symbols:**
+  - C# documents take Roslyn's rename edits.
+  - Each Razor usage takes an edit at its mapped span, and a declaration in an `@code` block is edited in the Razor file.
+  - A `@bind-Old` attribute becomes `@bind-New`.
+- **prepareRename:**
+  - On a C# fragment it answers the mapped identifier range.
+  - On markup it refuses with a message.
+  - A component type is renamed by renaming its file, so prepareRename refuses on a component tag.
+- **Cross-language:** renaming an F# symbol renames its Razor usages, and renaming a C# symbol from a Razor file renames its F# usages ([RAZOR-FSHARP], [RENAME-CROSSLANGUAGE]).
+
+### [RAZOR-FEATURES-SEMANTIC-TOKENS] Semantic Tokens
+
+- **C# fragments:** Roslyn's classification of the projection, mapped back.
+- **Markup tokens:**
+  - component and child-content tag names are `class`;
+  - component attribute names are `property`;
+  - directive attribute names (`@onclick`, `@bind-Value`) are `decorator`;
+  - directive names (`@page`, `@code`) are `keyword`.
+- **Everything else:** the client's TextMate grammar colors the rest.
+
+### [RAZOR-FEATURES-STRUCTURE] Folding, Symbols and Linked Editing
+
+- **Folding:** elements that span lines, `@code` and `@functions` blocks, C# code blocks, and `@section` blocks. A fold ends on the line before its last line, so the closing tag or brace stays visible.
+- **Document symbols:**
+  - directives (`@page`, `@inject`, `@code`, …) are `Key` symbols, named with their `@`;
+  - elements bound to components or tag helpers are `Class` symbols, named by their tag;
+  - symbols nest by containment, so a component inside another nests under it;
+  - the methods, properties and fields declared in `@code` and `@functions` nest under their block, and an `@inject` property under its directive.
+- **Linked editing:** the start and end tag names of a component, a tag helper element, or any element of a component file. A plain HTML element of a `.cshtml` file is not an element in the compiler's IR, so it does not link.
+
+### [RAZOR-FEATURES-HTML] HTML in Editors
+
+- **VS Code:** completion and hover in markup are forwarded to the built-in HTML language service over the HTML projection, following VS Code's request-forwarding pattern. The server's items come first and the HTML service's items are appended. Hover uses the HTML service only when the server has no answer.
+- **Other editors:** they attach their own HTML language server to `razor` files.
+
+### [RAZOR-FEATURES-DEFERRED] Not Yet Supported
+
+- **Editing features:** formatting; selection ranges; code actions (extract a block to code-behind, extract a component, generate an event handler, add `@using`); inlay hints; code lens; call and type hierarchy from Razor positions.
+- **Collocated files:** awareness of `.razor.css` CSS isolation and `.razor.js` collocated JavaScript.
+- **Runtime features:** Blazor WebAssembly debugging and Razor Hot Reload.
+
+Each of these is a separate plan item.
+
+## [RAZOR-BLAZOR] Blazor Coverage
+
+| Construct | Hover | Definition | Completion | References / rename | Diagnostics |
+|---|---|---|---|---|---|
+| `<Component>` tags | ✓ | ✓ | ✓ | ✓ / file rename | RZ10012 unknown element |
+| Parameters (`Param="…"`) | ✓ | ✓ | ✓ | ✓ / ✓ | RZ2012 missing `[EditorRequired]` |
+| Parameter values, event handlers, lambdas | ✓ (C#) | ✓ | ✓ | ✓ / ✓ | C# |
+| Generic components (`@typeparam`, `TItem="int"`) | ✓ | ✓ | ✓ | ✓ / ✓ | C# |
+| `@bind`, `@bind-X`, `@bind:event/format/get/set/after` | ✓ | ✓ | ✓ | ✓ / ✓ | RZ |
+| `@on{event}`, `:preventDefault`, `:stopPropagation` | ✓ | — | ✓ | — | RZ |
+| `@key`, `@ref`, `@attributes`, `@rendermode`, `@formname` | ✓ | ✓ (C# value) | ✓ | ✓ (C# value) | RZ |
+| Child content, `RenderFragment<T>`, `Context=` | ✓ | ✓ | ✓ | ✓ | C# |
+| Cascading values and parameters | ✓ (C#) | ✓ | ✓ | ✓ / ✓ | C# |
+| Directives (`@page`, `@using`, `@inject`, `@inherits`, `@implements`, `@layout`, `@attribute`, `@namespace`, `@preservewhitespace`, `@rendermode`, `@typeparam`, `@code`) | ✓ | ✓ (C# tokens) | ✓ | ✓ (C# tokens) | RZ |
+| `_Imports.razor` | ✓ | ✓ | ✓ | ✓ | C# |
+| Code-behind partial classes (`.razor.cs`) | ✓ | ✓ | ✓ | ✓ / ✓ | C# |
+| Razor class libraries | ✓ | ✓ | ✓ | ✓ | C# |
+
+## [RAZOR-MVC] Razor Pages and MVC Views
+
+- **Directives:** `@page`, `@model`, `@inject`, `@inherits`, `@functions`, `@section`, `@namespace`, `@addTagHelper`, `@removeTagHelper` and `@tagHelperPrefix` follow the directive rows above. `@model`'s type is C#, and so is `Model.X`.
+- **Tag helpers:** a tag helper element or attribute (`<partial>`, `asp-for`, `asp-page`, `asp-route-*`) answers hover and completion from its descriptor. An `asp-for` value is a model expression, so it gets C# features.
+- **Imports:** `_ViewImports.cshtml` is an import. `_ViewStart.cshtml`, layouts and partials are ordinary legacy files.
+
+## [RAZOR-FSHARP] F# in Razor Solutions
+
+Blazor front ends often sit over F# domain libraries. A Razor project that references an F# project reads it as its built DLL, like any C# project does ([DEFINITION-CROSSLANG]).
+
+- **Hover, completion and signature help:** these work on F# types and members used in Razor through that metadata.
+- **Definition:** definition on an F# symbol from Razor lands where it lands from C#: in decompiled metadata-as-source for the symbol's type ([DEFINITION-CROSSLANG]).
+- **Rename from F#:** renaming an F# symbol renames its Razor usages too. The Rust host asks the C# sidecar for the C# usages of the symbol ([RENAME-CROSSLANGUAGE]). Those usages include the projections, and each one is mapped back to its Razor file, never edited in generated code.
+- **References from F#:** references that start in F# reach C# and Razor usages only where they reach C# usages today ([DEFINITION-CROSSLANG]).
+- **No F# Razor:** F# is not a Razor code language. A Razor `@code` block is C#.
+
+## [RAZOR-EDITORS] Editors
+
+- **VS Code:**
+  - The client syncs `razor` documents (VS Code's built-in id) and `aspnetcorerazor` documents (the C# extension's id).
+  - The extension activates on `onLanguage:razor`.
+  - It forwards HTML requests ([RAZOR-FEATURES-HTML]).
+- **Zed:** Zed has no built-in Razor language. The server attaches to `Razor`, the language community Razor extensions define, with language id `razor` ([DIST-ZED-REGISTRY]).
+- **Other LSP clients:** the language id is `razor`, and the file types are `.razor` and `.cshtml`.
+
+## [RAZOR-ERRORS] Degradation
+
+- **Engine unavailable:** if the bundled engine fails to load or to process a file, markup features answer empty and the C# projection features keep working. The failure is logged once per project, with the project name and the exception type.
+- **No projection:** a file whose project does not run the generator has no projection, so its C# features answer empty. Its markup facts still answer.
+- **SDK newer than the sidecar's Roslyn:** the generator comes from the SDK that resolves for the project, which is the newest installed SDK when no `global.json` pins one. Roslyn does not load a generator built against a newer Roslyn than the sidecar bundles, so the project's Razor files have no projection, as above. The tests keep the repository's pin in their fixture copies. GitHub issue #399 tracks making the generator load with any SDK.
+- **Nothing at the position:** a position that is neither in a C# fragment nor on a markup fact answers `null` or an empty list, never an error.
+- **No content logged:** no Razor or generated text is ever logged. Logs carry only paths, spans and lengths.
+
+## [RAZOR-TESTING] Tests
+
+- **Fixture:** `src/sharplsp/tests/fixtures/razor/RazorFixtures.slnx` is a real solution of net10.0 projects, all of them buildable offline:
+
+  | Project | What it is |
+  |---|---|
+  | `BlazorApp` | Components, generic components, binding, code-behind |
+  | `Widgets` | A Razor class library used by `BlazorApp` |
+  | `PagesApp` | Razor Pages, an MVC view and tag helpers |
+  | `Domain` | An F# library used by `BlazorApp` |
+
+  The C# projects use framework references only. `Domain` restores only `FSharp.Core`, from the local NuGet cache in CI as every F# fixture does. The folder's own `Directory.Build.props` and `Directory.Build.targets` shield it from the repository's build settings.
+- **Sidecar tests:**
+  - map unit tests over real generator output;
+  - engine facts;
+  - every feature in [RAZOR-FEATURES] against the fixture.
+- **Rust end-to-end tests:** the full stack over the fixture: open, edit, diagnostics, hover, definition, references, completion and rename.
+- **VS Code end-to-end tests:** a `razor` chunk that drives the real extension through the same features, including HTML forwarding.
diff --git a/lspkit b/lspkit
index ccc59bfc..e6e41727 160000
--- a/lspkit
+++ b/lspkit
@@ -1 +1 @@
-Subproject commit ccc59bfc42eaa62980578317c749251098f2338b
+Subproject commit e6e417275a76568d559ef26f9f68752f7a0f4454
diff --git a/src/editors/vscode/package.json b/src/editors/vscode/package.json
index 4ece2a0b..dcfa9613 100644
--- a/src/editors/vscode/package.json
+++ b/src/editors/vscode/package.json
@@ -40,6 +40,7 @@
     "workspaceContains:**/*.slnx",
     "workspaceContains:**/*.csproj",
     "workspaceContains:**/*.fsproj",
+    "onLanguage:razor",
     "onDebugResolve:sharplsp-coreclr",
     "onDebugDynamicConfigurations:sharplsp-coreclr"
   ],
diff --git a/src/editors/vscode/src/client.ts b/src/editors/vscode/src/client.ts
index a1fc5a43..ec83bc3e 100644
--- a/src/editors/vscode/src/client.ts
+++ b/src/editors/vscode/src/client.ts
@@ -23,6 +23,7 @@ import { getErrorMessage } from './utils.js';
 import * as config from './config.js';
 import * as log from './log.js';
 import { createOpenSync, type OpenSync } from './open-sync.js';
+import { createRazorHtml, RAZOR_LANGUAGES, serverProjection } from './razor-html.js';
 import { createAnsiStrippingChannel } from './output-filter.js';
 import { serverStdioOptions } from './server-stderr.js';
 import { detectRuntimePlatform } from './platform.js';
@@ -53,12 +54,16 @@ class SharpLspClient extends LanguageClient {
   }
 }
 
-/** The documents the client syncs to the server, and holds requests about. */
+/**
+ * The documents the client syncs to the server, and holds requests about. A Razor
+ * file is only ever a file: one no project lists has no semantics ([RAZOR-EDITORS]).
+ */
 export const DOCUMENT_SELECTOR = [
   { scheme: 'file', language: 'csharp' },
   { scheme: 'file', language: 'fsharp' },
   { scheme: 'untitled', language: 'csharp' },
   { scheme: 'untitled', language: 'fsharp' },
+  ...RAZOR_LANGUAGES.map((language) => ({ scheme: 'file', language })),
 ];
 
 export interface DeploymentPaths {
@@ -101,6 +106,9 @@ export async function start(
 
   const serverOptions: ServerOptions = { run, debug: run };
   const openSync = createOpenSync(DOCUMENT_SELECTOR);
+  // The middleware is built before the client it forwards for, and asks it for
+  // projections only once requests flow through it. [RAZOR-FEATURES-HTML]
+  const razorHtml = createRazorHtml(serverProjection(() => client));
 
   const clientOptions: LanguageClientOptions = {
     documentSelector: DOCUMENT_SELECTOR,
@@ -127,8 +135,9 @@ export async function start(
     traceOutputChannel: log.trace(),
     errorHandler: makeErrorHandler(statusBar),
     // After every (re)start a request waits for its document's didOpen, so it
-    // never reaches a fresh server ahead of the document it is about.
-    middleware: openSync.middleware,
+    // never reaches a fresh server ahead of the document it is about. Razor
+    // markup adds the HTML service's completion and hover answers.
+    middleware: { ...openSync.middleware, ...razorHtml.middleware },
   };
 
   const client = new SharpLspClient(EXTENSION_ID, EXTENSION_NAME, serverOptions, clientOptions);
@@ -136,7 +145,14 @@ export async function start(
   wireClientState(client, statusBar, openSync, context);
 
   statusBar.setState(ServerState.Starting);
-  await client.start();
+  try {
+    await client.start();
+  } catch (error: unknown) {
+    // A server that never started serves no projections. [RAZOR-FEATURES-HTML]
+    razorHtml.provider.dispose();
+    throw error;
+  }
+  context.subscriptions.push(razorHtml.provider);
   return client;
 }
 
diff --git a/src/editors/vscode/src/paths.ts b/src/editors/vscode/src/paths.ts
index c5e8752a..cb4cc648 100644
--- a/src/editors/vscode/src/paths.ts
+++ b/src/editors/vscode/src/paths.ts
@@ -10,6 +10,15 @@ export function fileUri(value: string): Uri {
   return Uri.file(value);
 }
 
+/**
+ * The address of a virtual document embedded in `host`: under `scheme`, named after the
+ * host's whole URI with `extension`, so VS Code reads it as that language, and told
+ * apart by `query`. [SHARPLSP-ARCHITECTURE-PATHS] [RAZOR-FEATURES-HTML]
+ */
+export function embeddedUri(scheme: string, host: Uri, extension: string, query: string): Uri {
+  return Uri.from({ scheme, path: `/${encodeURIComponent(host.toString())}${extension}`, query });
+}
+
 /** The platform's directory separator. [SHARPLSP-ARCHITECTURE-PATHS] */
 export const pathSeparator = nodePath.sep;
 
diff --git a/src/editors/vscode/src/razor-html.ts b/src/editors/vscode/src/razor-html.ts
new file mode 100644
index 00000000..14f6d782
--- /dev/null
+++ b/src/editors/vscode/src/razor-html.ts
@@ -0,0 +1,160 @@
+// Implements [RAZOR-FEATURES-HTML] and [RAZOR-EDITORS]. HTML completion and hover in
+// Razor markup come from VS Code's built-in HTML language service, which reads the
+// server's HTML projection of the Razor file: the same text with every non-HTML
+// character blanked, so a Razor position is the same position in the projection.
+// This follows VS Code's request-forwarding pattern for embedded languages:
+// https://code.visualstudio.com/api/language-extensions/embedded-languages
+import {
+  CompletionList,
+  Disposable,
+  commands,
+  workspace,
+  type CompletionItem,
+  type Hover,
+  type Position,
+  type TextDocument,
+  type Uri,
+} from 'vscode';
+import { State, type LanguageClient, type Middleware } from 'vscode-languageclient/node';
+import * as log from './log.js';
+import { embeddedUri } from './paths.js';
+import { isRecord } from './utils.js';
+
+/** Razor's language ids: VS Code's built-in `razor`, and the C# extension's own. */
+export const RAZOR_LANGUAGES: readonly string[] = ['razor', 'aspnetcorerazor'];
+
+/** The scheme of the projections the HTML service reads. */
+const PROJECTION_SCHEME = 'sharplsp-razor-html';
+
+/** The server request that answers a Razor document's HTML projection. */
+const PROJECTION_REQUEST = 'sharplsp/razor/htmlProjection';
+
+/** The server's HTML projection of the document at `uri`; undefined when it has none. */
+export type ProjectionSource = (uri: string) => Promise<string | undefined>;
+
+/**
+ * Projections from the running server. A server that cannot project the document
+ * answers null; one that fails is logged and treated the same, so the server's own
+ * completion and hover answers still reach the editor.
+ */
+export function serverProjection(client: () => LanguageClient | undefined): ProjectionSource {
+  return async (uri) => {
+    const running = client();
+    if (running?.state !== State.Running) return undefined;
+    try {
+      const answer: unknown = await running.sendRequest(PROJECTION_REQUEST, {
+        textDocument: { uri },
+      });
+      return isRecord(answer) && typeof answer.text === 'string' ? answer.text : undefined;
+    } catch (error) {
+      log.warn(
+        JSON.stringify({ event: 'razor_html_projection_failed', uri, errorKind: typeof error }),
+      );
+      return undefined;
+    }
+  };
+}
+
+/** The forwarding middleware, and the provider that serves the projections. */
+export interface RazorHtml {
+  readonly middleware: Pick<Middleware, 'provideCompletionItem' | 'provideHover'>;
+  readonly provider: Disposable;
+}
+
+/** What a completion provider answers. */
+type Completions = CompletionItem[] | CompletionList | null | undefined;
+
+/**
+ * The HTML forwarding for Razor documents. The server answers first; HTML completion
+ * items are appended to its own, and an HTML hover answers only when the server has none.
+ */
+export function createRazorHtml(source: ProjectionSource): RazorHtml {
+  // Each Razor document's latest projection, by the projection's address.
+  const projections = new Map<string, { readonly address: string; readonly text: string }>();
+  const provider = Disposable.from(
+    workspace.registerTextDocumentContentProvider(PROJECTION_SCHEME, {
+      provideTextDocumentContent: (uri) =>
+        [...projections.values()].find((entry) => entry.address === uri.toString())?.text ?? '',
+    }),
+    // A closed document's projection is never asked for again.
+    workspace.onDidCloseTextDocument((document) => projections.delete(document.uri.toString())),
+  );
+  const project = async (document: TextDocument): Promise<Uri | undefined> => {
+    const text = await source(document.uri.toString());
+    if (text === undefined) return undefined;
+    const uri = projectionUri(document);
+    projections.set(document.uri.toString(), { address: uri.toString(), text });
+    return uri;
+  };
+  return { middleware: forwardingMiddleware(project), provider };
+}
+
+/** The middleware that adds the HTML service's answers to the server's. */
+function forwardingMiddleware(
+  project: (document: TextDocument) => Promise<Uri | undefined>,
+): RazorHtml['middleware'] {
+  return {
+    provideCompletionItem: async (document, position, context, token, next) => {
+      const own = await next(document, position, context, token);
+      if (!isRazor(document)) return own;
+      const uri = await project(document);
+      return uri === undefined
+        ? own
+        : appended(own, await htmlCompletions(uri, position, context.triggerCharacter));
+    },
+    provideHover: async (document, position, token, next) => {
+      const own = await next(document, position, token);
+      if (own !== null && own !== undefined) return own;
+      const uri = isRazor(document) ? await project(document) : undefined;
+      return uri === undefined ? own : await htmlHover(uri, position);
+    },
+  };
+}
+
+/** Whether `document` is a Razor file. */
+function isRazor(document: TextDocument): boolean {
+  return RAZOR_LANGUAGES.includes(document.languageId);
+}
+
+/**
+ * The projection's address: an `.html` path, so VS Code reads it as HTML, carrying the
+ * Razor URI it projects and the version it projects, so no answer reads stale text.
+ */
+export function projectionUri(document: TextDocument): Uri {
+  return embeddedUri(PROJECTION_SCHEME, document.uri, '.html', `v=${document.version.toString()}`);
+}
+
+/**
+ * The HTML service's completion items at `position` in the projection. The command
+ * always resolves to a list, an empty one when no provider answers.
+ */
+async function htmlCompletions(
+  uri: Uri,
+  position: Position,
+  trigger: string | undefined,
+): Promise<CompletionItem[]> {
+  const list = await commands.executeCommand<CompletionList>(
+    'vscode.executeCompletionItemProvider',
+    uri,
+    position,
+    trigger,
+  );
+  return list.items;
+}
+
+/** The HTML service's hover at `position` in the projection, if it has one. */
+async function htmlHover(uri: Uri, position: Position): Promise<Hover | undefined> {
+  const hovers = await commands.executeCommand<Hover[] | undefined>(
+    'vscode.executeHoverProvider',
+    uri,
+    position,
+  );
+  return hovers?.[0];
+}
+
+/** The server's items first, then `extra`, keeping the server's incompleteness. */
+function appended(own: Completions, extra: CompletionItem[]): CompletionList {
+  const items = Array.isArray(own) ? own : (own?.items ?? []);
+  const incomplete = !Array.isArray(own) && own?.isIncomplete === true;
+  return new CompletionList([...items, ...extra], incomplete);
+}
diff --git a/src/editors/vscode/src/test/suite/razor-kit.ts b/src/editors/vscode/src/test/suite/razor-kit.ts
new file mode 100644
index 00000000..d5f39aee
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/razor-kit.ts
@@ -0,0 +1,76 @@
+// The Razor fixture solution ([RAZOR-TESTING]) for the VS Code Razor suite: the
+// repository's src/sharplsp/tests/fixtures/razor, copied without its build output
+// to a scratch root, built so the SDK's Razor generator has run, and loaded
+// through the real extension.
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type * as vscode from 'vscode';
+import { findGlobalJson } from '../../global-json.js';
+import { serverProjection } from '../../razor-html.js';
+import { dotnet } from './dotnet-project-kit';
+import { type LoadedFixture, useLoadedFixture } from './netfx-language-kit';
+import { lspClient } from './profiler-kit';
+
+/** The fixture in the repository. */
+const SOURCE = path.resolve(__dirname, '../../../../../sharplsp/tests/fixtures/razor');
+
+/** Build output a copy leaves behind: a copied `obj` would point back at the source. */
+const BUILD_OUTPUT = new Set(['bin', 'obj']);
+
+/** The Razor files the suite opens, relative to the fixture root. */
+export const RAZOR_FILES = {
+  counter: 'BlazorApp/Components/Pages/Counter.razor',
+  board: 'BlazorApp/Components/Pages/Board.razor',
+} as const;
+
+/** The Razor file the suite writes where no project lists it. */
+export const STRAY_RAZOR = 'Stray.razor';
+
+/**
+ * Pin `root` to the SDK the fixture has in the repository. A scratch copy has no
+ * `global.json` above it, so it would build and load with the newest installed SDK,
+ * whose Razor generator can need a newer Roslyn than the sidecar's.
+ */
+function keepSdkPin(root: string): void {
+  const pin = findGlobalJson(SOURCE);
+  assert.ok(pin, 'the repository pins the fixture SDK in a global.json');
+  fs.copyFileSync(pin, path.join(root, 'global.json'));
+}
+
+/** Copy the fixture to `root`, with its SDK pin, and build it. */
+async function writeRazorFixture(root: string): Promise<LoadedFixture> {
+  fs.cpSync(SOURCE, root, {
+    recursive: true,
+    filter: (source) => !BUILD_OUTPUT.has(path.basename(source)),
+  });
+  keepSdkPin(root);
+  const solution = path.join(root, 'RazorFixtures.slnx');
+  await dotnet(['build', solution], root);
+  return {
+    root,
+    solution,
+    ready: { file: RAZOR_FILES.counter, anchor: ['Current count: @currentCount', 'currentCount'] },
+  };
+}
+
+/** The Razor fixture, built and loaded for the suite that calls this. */
+export function useRazorFixture(): () => LoadedFixture {
+  return useLoadedFixture('sharplsp-razor-', writeRazorFixture);
+}
+
+/**
+ * Write `text` as a Razor file that no project lists: alone in a scratch folder, outside
+ * the fixture and every workspace folder, so no watcher reloads a project. Returns the folder.
+ */
+export function writeStrayRazor(text: string): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sharplsp-razor-stray-'));
+  fs.writeFileSync(path.join(root, STRAY_RAZOR), text);
+  return root;
+}
+
+/** The server's HTML projection of `uri`, asked for as the extension asks. [RAZOR-FEATURES-HTML] */
+export function htmlProjection(uri: vscode.Uri): Promise<string | undefined> {
+  return serverProjection(lspClient)(uri.toString());
+}
diff --git a/src/editors/vscode/src/test/suite/razor-lsp.test.ts b/src/editors/vscode/src/test/suite/razor-lsp.test.ts
new file mode 100644
index 00000000..3daf7a96
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/razor-lsp.test.ts
@@ -0,0 +1,281 @@
+// End-to-end tests for Razor in VS Code ([RAZOR-EDITORS], [RAZOR-FEATURES-HTML]), over
+// the real Razor fixture solution ([RAZOR-TESTING]). The extension activates on and
+// syncs Razor documents; the C# sidecar answers the C# inside them; and markup gets
+// the built-in HTML service's completion and hover over the server's HTML projection
+// (`sharplsp/razor/htmlProjection`, [RAZOR-ARCHITECTURE-HTML]).
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as vscode from 'vscode';
+import { DOCUMENT_SELECTOR } from '../../client.js';
+import { logFilePath } from '../../log.js';
+import { projectionUri, serverProjection } from '../../razor-html.js';
+import { completionList, hoverText } from './filebased-package-kit';
+import { lspClient } from './profiler-kit';
+import { openRepoFile, positionOf } from './real-repo-helpers';
+import { completionLabels } from './real-repo-kit';
+import {
+  htmlProjection,
+  RAZOR_FILES,
+  STRAY_RAZOR,
+  useRazorFixture,
+  writeStrayRazor,
+} from './razor-kit';
+import { packageJson } from './run-debug-kit';
+import {
+  closeAllEditors,
+  pollProvider,
+  pollUntilResult,
+  removeDirRecursive,
+  waitForHoverResult,
+} from './test-helpers';
+import { LSP_RESPONSE_MS } from './test-timeouts';
+
+/** The C# expression the Counter page shows, and the field it reads. */
+const COUNT: readonly [string, string] = ['Current count: @currentCount', 'currentCount'];
+
+/**
+ * Elements the HTML service offers at any tag name that no fixture file holds as a
+ * word, so VS Code's word-based suggestions can never supply them.
+ */
+const HTML_ONLY: readonly string[] = ['blockquote', 'figcaption', 'fieldset'];
+
+/** The line the log holds for `uri`, once it holds one. */
+function loggedLine(uri: string): Promise<string | undefined> {
+  return pollUntilResult(
+    async () =>
+      (await fs.promises.readFile(logFilePath(), 'utf8'))
+        .split('\n')
+        .find((line) => line.includes(uri)),
+    (line) => line !== undefined,
+    LSP_RESPONSE_MS,
+    undefined,
+    `a log line naming ${uri}`,
+  );
+}
+
+/** Hover text at `position`, once it satisfies `until`. */
+async function hoverWhen(
+  uri: vscode.Uri,
+  position: vscode.Position,
+  until: (text: string) => boolean,
+): Promise<string> {
+  const hovers = await pollProvider<vscode.Hover>(
+    'vscode.executeHoverProvider',
+    [uri, position],
+    (reply) => until(hoverText(reply)),
+  );
+  return hoverText(hovers);
+}
+
+suite('Razor in VS Code', () => {
+  const fixture = useRazorFixture();
+
+  teardown(async () => {
+    await closeAllEditors();
+  });
+
+  test('a Razor file opens as Razor, and its unsaved edits reach the server', async function () {
+    this.timeout(LSP_RESPONSE_MS * 3);
+    // Interaction 1 — the manifest activates on Razor, and the client syncs both of
+    // Razor's language ids: VS Code's own and the C# extension's.
+    const events: string[] = packageJson().activationEvents ?? [];
+    assert.ok(events.includes('onLanguage:razor'), 'activates on Razor');
+    const synced = DOCUMENT_SELECTOR.filter((entry) => entry.scheme === 'file').map(
+      (entry) => entry.language,
+    );
+    assert.ok(synced.includes('razor'), 'syncs VS Code’s razor documents');
+    assert.ok(synced.includes('aspnetcorerazor'), 'syncs the C# extension’s Razor documents');
+
+    // Interaction 2 — a component opens as Razor, and the C# sidecar answers the
+    // C# inside it at the Razor position.
+    const { doc, uri } = await openRepoFile(fixture().root, RAZOR_FILES.counter);
+    assert.equal(doc.languageId, 'razor', 'a .razor file is VS Code’s razor language');
+    const hover = hoverText(await waitForHoverResult(uri, positionOf(doc, ...COUNT)));
+    assert.match(hover, /\bint\b/, 'the field’s C# type');
+    assert.match(hover, /currentCount/, 'the field’s name');
+
+    // Interaction 3 — an unsaved line above moves the field down one line: the
+    // server's hover and projection both follow the editor's text.
+    const edit = new vscode.WorkspaceEdit();
+    edit.insert(uri, new vscode.Position(6, 0), '<p>Edited</p>\n');
+    assert.ok(await vscode.workspace.applyEdit(edit), 'the edit applies');
+    const moved = positionOf(doc, ...COUNT);
+    assert.equal(moved.line, 8, 'the field moved down a line');
+    assert.match(await hoverWhen(uri, moved, (text) => text.includes('currentCount')), /\bint\b/);
+    const projection = (await htmlProjection(uri)) ?? '';
+    assert.ok(projection.includes('<p>Edited</p>'), 'the projection holds the unsaved line');
+    assert.equal(projection.length, doc.getText().length, 'and the unsaved length');
+    await vscode.commands.executeCommand('workbench.action.files.revert');
+  });
+
+  test('the server projects Razor as HTML of the same shape', async function () {
+    this.timeout(LSP_RESPONSE_MS * 2);
+    const { doc, uri } = await openRepoFile(fixture().root, RAZOR_FILES.counter);
+    const text = doc.getText();
+    const projection = await htmlProjection(uri);
+    assert.ok(projection !== undefined, 'a listed Razor file has an HTML projection');
+
+    // Interaction 1 — every offset and line break is where the Razor file has it,
+    // so a Razor position is the same position in the projection.
+    assert.equal(projection.length, text.length, 'the same UTF-16 length');
+    assert.deepEqual(
+      projection.split('\n').map((line) => line.length),
+      text.split('\n').map((line) => line.length),
+    );
+
+    // Interaction 2 — markup stays, at its own offset.
+    const heading = text.indexOf('<h1>Counter</h1>');
+    assert.ok(heading > 0, 'the fixture has its heading');
+    assert.equal(projection.indexOf('<h1>Counter</h1>'), heading, 'markup keeps its offset');
+    assert.ok(projection.includes('<p role="status">Current count: '), 'markup around C# stays');
+
+    // Interaction 3 — C# is blanked: the implicit expression and the @code block.
+    const count = text.indexOf(COUNT[0]) + 'Current count: '.length;
+    assert.equal(
+      projection.slice(count, count + '@currentCount'.length).trim(),
+      '',
+      'an expression',
+    );
+    assert.ok(!projection.includes('currentCount++'), 'a @code statement');
+    assert.ok(!projection.includes('private int'), 'a @code field');
+  });
+
+  test('markup completes from the HTML service, and C# from the server', async function () {
+    this.timeout(LSP_RESPONSE_MS * 3);
+    const { doc, uri } = await openRepoFile(fixture().root, RAZOR_FILES.counter);
+
+    // Interaction 1 — in a tag name, the HTML service's element names arrive through
+    // the projection, and no C# member does.
+    const tag = completionLabels(
+      await completionList(uri, positionOf(doc, '<h1>Counter', 'h1'), 'div'),
+    );
+    for (const element of ['div', 'span', 'h1']) assert.ok(tag.has(element), `offers <${element}>`);
+    assert.ok(!tag.has('currentCount'), 'markup offers no C# member');
+
+    // Interaction 2 — in @code, the server's C# members answer, and the HTML
+    // service adds no element name: the projection blanks the C#.
+    const code = completionLabels(
+      await completionList(uri, positionOf(doc, 'currentCount++;', 'currentCount'), 'currentCount'),
+    );
+    assert.ok(code.has('currentCount'), 'the field');
+    assert.ok(code.has('IncrementCount'), 'the method');
+    assert.ok(!code.has('div'), 'C# offers no HTML element');
+  });
+
+  test('markup hovers come from the HTML service when the server has none', async function () {
+    this.timeout(LSP_RESPONSE_MS * 3);
+    const { doc, uri } = await openRepoFile(fixture().root, RAZOR_FILES.counter);
+    const fromMdn = (text: string): boolean => text.includes('developer.mozilla.org');
+
+    // Interaction 1 — an HTML element: the HTML service describes the heading.
+    const heading = await hoverWhen(uri, positionOf(doc, '<h1>Counter', 'h1'), fromMdn);
+    assert.match(heading, /heading/i, 'the element’s description');
+    assert.ok(fromMdn(heading), 'with its MDN reference');
+
+    // Interaction 2 — an HTML attribute: the HTML service describes `class`.
+    const attribute = await hoverWhen(uri, positionOf(doc, '<button class=', 'class'), fromMdn);
+    assert.match(attribute, /class/i, 'the attribute’s description');
+    assert.ok(!attribute.includes('IncrementCount'), 'not the C# beside it');
+
+    // Interaction 3 — C# keeps the server's hover: the field, never HTML.
+    const csharp = hoverText(await waitForHoverResult(uri, positionOf(doc, ...COUNT)));
+    assert.match(csharp, /\bint\b/, 'the field’s type');
+    assert.ok(!fromMdn(csharp), 'no HTML documentation on C#');
+  });
+
+  test('markup without a projection keeps the server’s answers alone', async function () {
+    this.timeout(LSP_RESPONSE_MS * 4);
+    const root = writeStrayRazor('<h2>Stray</h2>\n<p>No project lists this file.</p>\n');
+    try {
+      const listed = await openRepoFile(fixture().root, RAZOR_FILES.counter);
+      const stray = await openRepoFile(root, STRAY_RAZOR);
+      const heading = positionOf(stray.doc, '<h2>Stray', 'h2');
+
+      // Interaction 1 — at a tag name, a listed file gets the HTML service's elements;
+      // a file no project lists has no projection, so the server's items stand alone.
+      const offered = completionLabels(
+        await completionList(listed.uri, positionOf(listed.doc, '<h1>Counter', 'h1'), 'fieldset'),
+      );
+      for (const element of HTML_ONLY) assert.ok(offered.has(element), `listed: <${element}>`);
+      assert.equal(
+        await htmlProjection(stray.uri),
+        undefined,
+        'an unlisted file has no projection',
+      );
+      const own = completionLabels(
+        await vscode.commands.executeCommand<vscode.CompletionList>(
+          'vscode.executeCompletionItemProvider',
+          stray.uri,
+          heading,
+        ),
+      );
+      for (const element of HTML_ONLY) assert.ok(!own.has(element), `unlisted: no <${element}>`);
+
+      // Interaction 2 — hover: the server has none there, and the HTML service is never
+      // asked; the address the file's projection would have reads as empty HTML.
+      const hovers = await vscode.commands.executeCommand<vscode.Hover[]>(
+        'vscode.executeHoverProvider',
+        stray.uri,
+        heading,
+      );
+      assert.equal(hoverText(hovers), '', 'no hover from the server or the HTML service');
+      const address = await vscode.workspace.openTextDocument(projectionUri(stray.doc));
+      assert.equal(address.languageId, 'html', 'a projection address reads as HTML');
+      assert.equal(address.getText(), '', 'and holds nothing for a file never projected');
+
+      // Interaction 3 — the server refuses a URI that names no file: the refusal is
+      // logged and answers no projection, as a stopped client does, while the running
+      // server still projects the listed file.
+      const unreadable = `untitled:Stray-${Date.now()}.razor`;
+      assert.equal(await serverProjection(lspClient)(unreadable), undefined, 'a refusal');
+      assert.match(
+        (await loggedLine(unreadable)) ?? '',
+        /\[WARN\] \{"event":"razor_html_projection_failed","uri":"untitled:/,
+        'is logged as a warning, by event and URI',
+      );
+      assert.equal(await serverProjection(() => undefined)(listed.uri.toString()), undefined);
+      const projection = await serverProjection(lspClient)(listed.uri.toString());
+      assert.ok(projection?.includes('<h1>Counter</h1>'), 'the running server projects');
+    } finally {
+      await closeAllEditors();
+      removeDirRecursive(root);
+    }
+  });
+
+  test('references to a field in Razor land in its Razor file, never generated code', async function () {
+    this.timeout(LSP_RESPONSE_MS * 2);
+    const { doc, uri } = await openRepoFile(fixture().root, RAZOR_FILES.board);
+    const usages = ['@bind-Label="caption"', 'Text="@caption"', '@bind="caption"'];
+    const lines = usages.map((usage) => positionOf(doc, usage, 'caption').line);
+    const declaration = positionOf(doc, 'private string caption', 'caption');
+
+    // Interaction 1 — from the @code declaration: the declaration, a component
+    // parameter, a bound attribute and a two-way binding.
+    const references = await pollProvider<vscode.Location>(
+      'vscode.executeReferenceProvider',
+      [uri, declaration],
+      (found) =>
+        lines.every((line) => found.some((location) => location.range.start.line === line)),
+    );
+    for (const location of references) {
+      assert.equal(location.uri.toString(), uri.toString(), 'every usage is in Board.razor');
+      assert.equal(doc.getText(location.range), 'caption', 'and spans the name');
+    }
+    assert.ok(
+      references.some((location) => location.range.start.line === declaration.line),
+      'the declaration',
+    );
+
+    // Interaction 2 — from a usage in markup, the same set.
+    const fromUsage = await pollProvider<vscode.Location>(
+      'vscode.executeReferenceProvider',
+      [uri, positionOf(doc, 'Text="@caption"', 'caption')],
+      (found) => found.length === references.length,
+    );
+    assert.deepEqual(
+      fromUsage.map((location) => location.range.start.line).sort((a, b) => a - b),
+      references.map((location) => location.range.start.line).sort((a, b) => a - b),
+      'every usage finds the same references',
+    );
+  });
+});
diff --git a/src/editors/vscode/test-chunks.json b/src/editors/vscode/test-chunks.json
index 4a2c60fb..57db9df9 100644
--- a/src/editors/vscode/test-chunks.json
+++ b/src/editors/vscode/test-chunks.json
@@ -48,6 +48,12 @@
         "fsharp-lsp-cross-language-rename.test.js"
       ]
     },
+    "razor": {
+      "description": "Razor and Blazor over the real Razor fixture solution, built once per job ([RAZOR-EDITORS], [RAZOR-TESTING]): Razor documents activate the extension and sync, unsaved edits included; the C# sidecar answers the C# inside them at Razor positions, references landing in the Razor file and never in generated code; and markup gets the built-in HTML service's completion and hover over the server's HTML projection ([RAZOR-FEATURES-HTML]).",
+      "files": [
+        "razor-lsp.test.js"
+      ]
+    },
     "debug": {
       "description": "Getting a program to START, and nothing about what happens once it has: the F5 / no-launch.json resolve contract, launchSettings.json + <app>.run.json profile parsing, the netcoredbg adapter factory, manifest conformance for the debugger, breakpoint, task-definition, command and menu contributions, the [SCRIPT-CONE] launch-target walk with MSBuild output resolution, and the F5 / Ctrl+F5 / sharplsp.runProgram gestures over real projects, C# file-based apps and .fsx scripts.",
       "files": [
diff --git a/src/editors/zed/extension.toml b/src/editors/zed/extension.toml
index 07f1a753..f3e352f3 100644
--- a/src/editors/zed/extension.toml
+++ b/src/editors/zed/extension.toml
@@ -6,15 +6,17 @@ schema_version = 1
 authors = ["SharpLsp <sharplsp@users.noreply.github.com>"]
 repository = "https://github.com/Nimblesite/SharpLsp"
 
-# Pair with the C# and F# extensions, which define these languages and their
-# grammars. [DIST-ZED-REGISTRY]
+# Pair with the C# and F# extensions and a Razor extension, which define these
+# languages and their grammars. Zed has no built-in Razor language, and the
+# community Razor extensions all name theirs `Razor`. [DIST-ZED-REGISTRY]
 [language_servers.sharplsp]
 name = "SharpLsp"
-languages = ["CSharp", "FSharp"]
+languages = ["CSharp", "FSharp", "Razor"]
 
 [language_servers.sharplsp.language_ids]
 CSharp = "csharp"
 FSharp = "fsharp"
+Razor = "razor"
 
 # The server is never bundled: absent from PATH, the extension downloads the
 # release archive for this platform from this repository only.
diff --git a/src/editors/zed/src/lib.rs b/src/editors/zed/src/lib.rs
index 18bf0e2e..14109507 100644
--- a/src/editors/zed/src/lib.rs
+++ b/src/editors/zed/src/lib.rs
@@ -232,10 +232,12 @@ mod manifest_tests {
         );
     }
 
-    /// Zed matches servers to languages by the names the C# and F# extensions define:
-    /// `CSharp` and `FSharp`. `C#` or `F#` silently attaches to nothing.
+    /// Zed matches servers to languages by the names the language extensions define:
+    /// `CSharp`, `FSharp`, and `Razor` from the Razor extensions, since Zed has no
+    /// Razor of its own. `C#` or `F#` silently attaches to nothing.
+    /// [DIST-ZED-REGISTRY] [RAZOR-EDITORS]
     #[test]
-    fn the_server_attaches_to_the_csharp_and_fsharp_languages() {
+    fn the_server_attaches_to_the_csharp_fsharp_and_razor_languages() {
         let manifest = manifest();
         let server = &manifest["language_servers"][LANGUAGE_SERVER];
 
@@ -243,9 +245,10 @@ mod manifest_tests {
             .as_array()
             .map(|names| names.iter().filter_map(toml::Value::as_str).collect())
             .unwrap_or_default();
-        assert_eq!(languages, ["CSharp", "FSharp"]);
+        assert_eq!(languages, ["CSharp", "FSharp", "Razor"]);
         assert_eq!(server["language_ids"]["CSharp"].as_str(), Some("csharp"));
         assert_eq!(server["language_ids"]["FSharp"].as_str(), Some("fsharp"));
+        assert_eq!(server["language_ids"]["Razor"].as_str(), Some("razor"));
         assert_eq!(server["name"].as_str(), Some("SharpLsp"));
     }
 
diff --git a/src/sharplsp/src/diagnostics.rs b/src/sharplsp/src/diagnostics.rs
index e59eb6e8..04955440 100644
--- a/src/sharplsp/src/diagnostics.rs
+++ b/src/sharplsp/src/diagnostics.rs
@@ -277,14 +277,21 @@ async fn publish_once(
 fn source_tag_for_uri(uri: &Uri) -> String {
     match crate::tree_sitter_parse::LangId::from_uri(uri) {
         Some(crate::tree_sitter_parse::LangId::FSharp) => "sharplsp-fsharp".to_string(),
+        Some(crate::tree_sitter_parse::LangId::Razor) => RAZOR_SOURCE.to_string(),
         _ => "sharplsp-csharp".to_string(),
     }
 }
 
+/// The diagnostic source of every Razor diagnostic, C# and `RZ` alike.
+/// [RAZOR-ARCHITECTURE-ROUTING]
+const RAZOR_SOURCE: &str = "sharplsp-razor";
+
 /// Determine the diagnostic source tag from a native document path.
 fn source_tag_for_path(file_path: &str) -> &'static str {
     if crate::paths::has_extension(file_path, &["fs", "fsx", "fsi", "fsscript"]) {
         "sharplsp-fsharp"
+    } else if crate::paths::has_extension(file_path, &["razor", "cshtml"]) {
+        RAZOR_SOURCE
     } else {
         "sharplsp-csharp"
     }
@@ -623,6 +630,28 @@ fn map_severity(severity: &str) -> DiagnosticSeverity {
 mod tests {
     use super::*;
 
+    /// Razor diagnostics publish under their own source, whether the file is
+    /// named by URI (push) or by path (pull and solution-wide).
+    /// [RAZOR-ARCHITECTURE-ROUTING]
+    #[test]
+    fn razor_files_publish_under_the_razor_source() {
+        let component: Uri = "file:///c:/app/Board.razor".parse().unwrap();
+        let view: Uri = "file:///c:/app/Index.cshtml".parse().unwrap();
+        let code: Uri = "file:///c:/app/Program.cs".parse().unwrap();
+        assert_eq!(source_tag_for_uri(&component), "sharplsp-razor");
+        assert_eq!(source_tag_for_uri(&view), "sharplsp-razor");
+        assert_eq!(source_tag_for_uri(&code), "sharplsp-csharp");
+        assert_eq!(
+            source_tag_for_path("/app/Pages/Board.razor"),
+            "sharplsp-razor"
+        );
+        assert_eq!(
+            source_tag_for_path("/app/Views/Index.CSHTML"),
+            "sharplsp-razor"
+        );
+        assert_eq!(source_tag_for_path("/app/Library.fs"), "sharplsp-fsharp");
+    }
+
     #[test]
     fn map_severity_error() {
         assert_eq!(map_severity("Error"), DiagnosticSeverity::ERROR);
diff --git a/src/sharplsp/src/document_symbols.rs b/src/sharplsp/src/document_symbols.rs
index 9f672e29..ec932fce 100644
--- a/src/sharplsp/src/document_symbols.rs
+++ b/src/sharplsp/src/document_symbols.rs
@@ -1,10 +1,11 @@
-//! F# document symbols (`textDocument/documentSymbol`).
+//! Sidecar document symbols (`textDocument/documentSymbol`) for F# and Razor.
 //!
 //! C# document symbols are answered syntactically by tree-sitter in
-//! [`crate::handlers::handle_document_symbols`]. F# has no tree-sitter grammar
-//! in the host, so F# symbols are sourced from the sidecar's FCS navigation
-//! items and mapped here into nested LSP [`DocumentSymbol`]s. The extraction
-//! contract is `[SE-FSHARP-SYMBOLS]`.
+//! [`crate::handlers::handle_document_symbols`]. F# symbols are sourced from the
+//! sidecar's FCS navigation items (`[SE-FSHARP-SYMBOLS]`), and Razor symbols
+//! from the C# sidecar's Razor compiler (`[RAZOR-FEATURES-STRUCTURE]`); both
+//! arrive in one wire shape and are mapped here into nested LSP
+//! [`DocumentSymbol`]s.
 
 use std::sync::Arc;
 
@@ -16,18 +17,19 @@ use tracing::warn;
 use crate::sidecar::manager::SidecarManager;
 use crate::utils::SidecarFileReq;
 
-/// Handle `textDocument/documentSymbol` for an F# file via the sidecar. `[FS-DOCSYMBOL]`
-pub fn handle_fsharp(
+/// Handle `textDocument/documentSymbol` for an F# or Razor file via the sidecar
+/// that owns it. `[FS-DOCSYMBOL]` `[RAZOR-ARCHITECTURE-ROUTING]`
+pub fn handle_via_sidecar(
     req: Request,
     runtime: &tokio::runtime::Runtime,
     sidecar: Option<&Arc<SidecarManager>>,
 ) -> Result<serde_json::Value> {
-    // F# has no host tree-sitter grammar; symbols are only available when the
-    // FCS sidecar is running. With no sidecar (F# disabled / no workspace root)
-    // the request cannot be served — surface that as an error rather than a
-    // misleading empty outline. [SE-FSHARP-SYMBOLS]
+    // F# and Razor have no host tree-sitter grammar; symbols are only available
+    // when the owning sidecar is running. With no sidecar (language disabled / no
+    // workspace root) the request cannot be served — surface that as an error
+    // rather than a misleading empty outline. [SE-FSHARP-SYMBOLS]
     let Some(sidecar) = sidecar else {
-        anyhow::bail!("F# sidecar unavailable; cannot compute document symbols");
+        anyhow::bail!("sidecar unavailable; cannot compute document symbols");
     };
     let params: DocumentSymbolParams = serde_json::from_value(req.params)?;
     let file_path = crate::paths::uri_to_path(params.text_document.uri.as_str())?;
@@ -161,6 +163,8 @@ fn parse_document_symbol_kind(kind: &str) -> SymbolKind {
         "EnumMember" => SymbolKind::ENUM_MEMBER,
         "Constructor" => SymbolKind::CONSTRUCTOR,
         "Function" => SymbolKind::FUNCTION,
+        "Method" => SymbolKind::METHOD,
+        "Key" => SymbolKind::KEY,
         "Property" => SymbolKind::PROPERTY,
         "Constant" => SymbolKind::CONSTANT,
         "Variable" => SymbolKind::VARIABLE,
@@ -241,6 +245,9 @@ mod tests {
         assert_eq!(parse_document_symbol_kind("Function"), SymbolKind::FUNCTION);
         assert_eq!(parse_document_symbol_kind("Property"), SymbolKind::PROPERTY);
         assert_eq!(parse_document_symbol_kind("Field"), SymbolKind::FIELD);
+        // Razor outline kinds: `@code` methods and directives. [RAZOR-FEATURES-STRUCTURE]
+        assert_eq!(parse_document_symbol_kind("Method"), SymbolKind::METHOD);
+        assert_eq!(parse_document_symbol_kind("Key"), SymbolKind::KEY);
     }
 
     #[test]
@@ -295,14 +302,14 @@ mod tests {
     }
 
     #[test]
-    fn handle_fsharp_without_sidecar_errors() {
+    fn handle_via_sidecar_without_sidecar_errors() {
         let req = Request {
             id: lsp_server::RequestId::from(1),
             method: "textDocument/documentSymbol".to_string(),
             params: serde_json::Value::Null,
         };
         let runtime = tokio::runtime::Runtime::new().unwrap();
-        // No sidecar → F# symbols cannot be computed → error (not empty).
-        assert!(handle_fsharp(req, &runtime, None).is_err());
+        // No sidecar → F# or Razor symbols cannot be computed → error (not empty).
+        assert!(handle_via_sidecar(req, &runtime, None).is_err());
     }
 }
diff --git a/src/sharplsp/src/main.rs b/src/sharplsp/src/main.rs
index f409ef15..99ba9ab8 100644
--- a/src/sharplsp/src/main.rs
+++ b/src/sharplsp/src/main.rs
@@ -25,6 +25,7 @@ mod paths;
 mod postfix_completion;
 mod profiler;
 mod pull_diagnostics;
+mod razor;
 mod semantic;
 mod semantic_tokens;
 mod sidecar;
@@ -386,8 +387,14 @@ fn build_capabilities(client: &lsp_types::ClientCapabilities) -> ServerCapabilit
             resolve_provider: Some(true),
             // `.` must be advertised so editors auto-send textDocument/completion
             // on member access (e.g. `this.`). Without it the popup never appears
-            // after a dot. Applies to both C# and F# member access.
-            trigger_characters: Some(vec![".".to_string()]),
+            // after a dot. Applies to both C# and F# member access. `<` and `@`
+            // complete Razor markup. [RAZOR-ARCHITECTURE-ROUTING]
+            trigger_characters: Some(
+                std::iter::once(".")
+                    .chain(razor::MARKUP_TRIGGERS)
+                    .map(str::to_string)
+                    .collect(),
+            ),
             ..lsp_types::CompletionOptions::default()
         }),
         hover_provider: Some(HoverProviderCapability::Simple(true)),
@@ -802,15 +809,24 @@ fn handle_request(
         // deliberately served by the sidecar's FCS items (richer symbol data
         // than a syntax tree can give). The other syntax features —
         // foldingRange, selectionRange, linkedEditingRange — run on the F#
-        // tree-sitter grammar for both languages.
-        // [SHARPLSP-FEATURES-NAVIGATION]
-        DocumentSymbolRequest::METHOD => {
-            if is_fsharp_request(&req) {
+        // tree-sitter grammar for both languages. Razor has no grammar, so the
+        // C# sidecar answers its syntax requests, and selection ranges are not
+        // served yet. [SHARPLSP-FEATURES-NAVIGATION] [RAZOR-ARCHITECTURE-ROUTING]
+        DocumentSymbolRequest::METHOD => match request_lang(&req) {
+            Some(LangId::FSharp | LangId::Razor) => {
                 let sidecar = pick_sidecar(&req, csharp_sidecar, fsharp_sidecar);
-                document_symbols::handle_fsharp(req, runtime, sidecar)
-            } else {
-                handlers::handle_document_symbols(req, vfs, parsers, trees)
+                document_symbols::handle_via_sidecar(req, runtime, sidecar)
             }
+            _ => handlers::handle_document_symbols(req, vfs, parsers, trees),
+        },
+        FoldingRangeRequest::METHOD if request_lang(&req) == Some(LangId::Razor) => {
+            razor::handle_folding_ranges(req, runtime, csharp_sidecar)
+        }
+        SelectionRangeRequest::METHOD if request_lang(&req) == Some(LangId::Razor) => {
+            Ok(serde_json::json!([]))
+        }
+        LinkedEditingRange::METHOD if request_lang(&req) == Some(LangId::Razor) => {
+            razor::handle_linked_editing_range(req, runtime, csharp_sidecar)
         }
         FoldingRangeRequest::METHOD => handlers::handle_folding_ranges(req, vfs, parsers, trees),
         SelectionRangeRequest::METHOD => {
@@ -821,8 +837,14 @@ fn handle_request(
         }
         // Semantic (sidecar)
         Completion::METHOD => {
-            let sidecar = pick_sidecar(&req, csharp_sidecar, fsharp_sidecar);
-            semantic::handle_completion(req, runtime, sidecar, vfs)
+            if serde_json::from_value(req.params.clone())
+                .is_ok_and(|params| razor::is_markup_trigger_outside_razor(&params))
+            {
+                Ok(serde_json::Value::Null)
+            } else {
+                let sidecar = pick_sidecar(&req, csharp_sidecar, fsharp_sidecar);
+                semantic::handle_completion(req, runtime, sidecar, vfs)
+            }
         }
         ResolveCompletionItem::METHOD => {
             let sidecar = pick_sidecar(&req, csharp_sidecar, fsharp_sidecar);
@@ -1142,6 +1164,7 @@ fn handle_custom_request(
         "sharplsp/sortMembers" => handle_sort_members(req, parsers, vfs),
         "sharplsp/statementStop" => handle_statement_stop(req, parsers, vfs),
         "sharplsp/hotReload" => hot_reload::handle(req, runtime, csharp_sidecar),
+        razor::HTML_PROJECTION => razor::handle_html_projection(req, runtime, csharp_sidecar),
         // NuGet package management
         "sharplsp/nuget/targets" => nuget::handlers::handle_targets(req),
         "sharplsp/nuget/search" => nuget::handlers::handle_search(req, runtime),
@@ -1228,9 +1251,9 @@ fn extract_document_uri(req: &Request) -> Option<Uri> {
         .or_else(|| nested_uri(&req.params, "data"))
 }
 
-/// Whether a request targets an F# document (by file extension).
-fn is_fsharp_request(req: &Request) -> bool {
-    extract_document_uri(req).and_then(|uri| LangId::from_uri(&uri)) == Some(LangId::FSharp)
+/// The language of the document a request targets (by file extension).
+fn request_lang(req: &Request) -> Option<LangId> {
+    extract_document_uri(req).and_then(|uri| LangId::from_uri(&uri))
 }
 
 /// Parse `params.<outer>.uri` into a [`Uri`], if present and valid.
@@ -1342,7 +1365,7 @@ fn handle_standard_workspace_symbol(
     let mut symbols = Vec::new();
     for entry in vfs.iter() {
         let uri = entry.key().clone();
-        let Some(lang) = LangId::from_uri(&uri) else {
+        let Some(lang) = LangId::from_uri(&uri).filter(|lang| lang.has_grammar()) else {
             continue;
         };
         if matches!(lang, LangId::FSharp) {
@@ -1664,7 +1687,7 @@ fn trigger_diagnostics(
 /// (index out of bounds) for shorter content.
 #[expect(clippy::mutable_key_type, reason = "see main_loop")]
 fn reparse(parsers: &TsParsers, trees: &mut HashMap<Uri, Tree>, uri: &Uri, source: &str) {
-    let Some(lang) = LangId::from_uri(uri) else {
+    let Some(lang) = LangId::from_uri(uri).filter(|lang| lang.has_grammar()) else {
         return;
     };
     match parsers.parse(lang, source, None) {
diff --git a/src/sharplsp/src/postfix_completion.rs b/src/sharplsp/src/postfix_completion.rs
index 4e6282b3..24eee8cf 100644
--- a/src/sharplsp/src/postfix_completion.rs
+++ b/src/sharplsp/src/postfix_completion.rs
@@ -250,6 +250,7 @@ pub fn get_postfix_completions(
             let snippet = match lang {
                 LangId::CSharp => t.csharp_snippet,
                 LangId::FSharp => t.fsharp_snippet,
+                LangId::Razor => None,
             }?;
 
             let expanded = snippet.replace("{expr}", &expr_text);
@@ -345,6 +346,30 @@ mod tests {
         assert!(text.contains("if (foo)"));
     }
 
+    /// Postfix templates never expand in Razor files, where `foo.if` can be
+    /// markup text; C# there completes from the projection.
+    /// [RAZOR-FEATURES-COMPLETION]
+    #[test]
+    fn razor_documents_get_no_postfix_templates() {
+        assert!(
+            get_postfix_completions("foo.if", 0, 6, LangId::Razor).is_empty(),
+            "a C# template stays out of Razor"
+        );
+        assert!(
+            get_postfix_completions("xs.match", 0, 8, LangId::Razor).is_empty(),
+            "an F# template stays out of Razor"
+        );
+        assert!(
+            get_postfix_completions("items.", 0, 6, LangId::Razor).is_empty(),
+            "a bare dot lists no templates in Razor"
+        );
+        assert_eq!(
+            get_postfix_completions("foo.if", 0, 6, LangId::CSharp).len(),
+            1,
+            "the same text in C# offers the template"
+        );
+    }
+
     #[test]
     fn generates_fsharp_match_postfix() {
         let items = get_postfix_completions("xs.match", 0, 8, LangId::FSharp);
diff --git a/src/sharplsp/src/razor.rs b/src/sharplsp/src/razor.rs
new file mode 100644
index 00000000..7be98729
--- /dev/null
+++ b/src/sharplsp/src/razor.rs
@@ -0,0 +1,265 @@
+//! Razor documents (`.razor`, `.cshtml`) in the host.
+//!
+//! The host has no Razor grammar, so the syntax requests it answers from
+//! tree-sitter for C# go to the C# sidecar for Razor, whose Razor compiler is
+//! the parser. The two Razor completion triggers are useless in C# and F#
+//! documents, so those answer at once. Implements [RAZOR-ARCHITECTURE-ROUTING].
+
+use std::sync::Arc;
+
+use anyhow::Result;
+use lsp_server::Request;
+use lsp_types::{
+    CompletionParams, FoldingRange, FoldingRangeParams, LinkedEditingRangeParams,
+    LinkedEditingRanges, Position, Range, TextDocumentIdentifier, Uri,
+};
+
+use crate::semantic::SidecarLocationListResult;
+use crate::sidecar::manager::SidecarManager;
+use crate::tree_sitter_parse::LangId;
+use crate::utils::{SidecarFileReq, SidecarPositionReq};
+
+/// Completion trigger characters that only Razor markup uses.
+pub const MARKUP_TRIGGERS: [&str; 2] = ["<", "@"];
+
+/// The request that answers a Razor document's HTML projection.
+pub const HTML_PROJECTION: &str = "sharplsp/razor/htmlProjection";
+
+/// Params of [`HTML_PROJECTION`]: the Razor document.
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct HtmlProjectionParams {
+    /// The Razor document to project.
+    text_document: TextDocumentIdentifier,
+}
+
+/// Whether `uri` names a Razor document.
+pub fn is_razor(uri: &Uri) -> bool {
+    LangId::from_uri(uri) == Some(LangId::Razor)
+}
+
+/// Whether a completion request was triggered by a Razor-only character in a
+/// document that is not Razor, so it can answer `null` without a sidecar.
+pub fn is_markup_trigger_outside_razor(params: &CompletionParams) -> bool {
+    let triggered_by_markup = params
+        .context
+        .as_ref()
+        .and_then(|context| context.trigger_character.as_deref())
+        .is_some_and(|character| MARKUP_TRIGGERS.contains(&character));
+    triggered_by_markup && !is_razor(&params.text_document_position.text_document.uri)
+}
+
+/// Handle `textDocument/foldingRange` for a Razor document via the C# sidecar.
+pub fn handle_folding_ranges(
+    req: Request,
+    runtime: &tokio::runtime::Runtime,
+    sidecar: Option<&Arc<SidecarManager>>,
+) -> Result<serde_json::Value> {
+    let params: FoldingRangeParams = serde_json::from_value(req.params)?;
+    let request = file_request(&params.text_document.uri)?;
+    let folds: Vec<(u32, u32)> = fetch(runtime, sidecar, "textDocument/foldingRange", &request)?;
+    let ranges: Vec<FoldingRange> = folds.into_iter().map(to_folding_range).collect();
+    Ok(serde_json::to_value(ranges)?)
+}
+
+/// Handle [`HTML_PROJECTION`] via the C# sidecar: `{ text }`, the document's
+/// text with every non-HTML character blanked, or `null` when no project
+/// lists the document. Implements [RAZOR-ARCHITECTURE-HTML].
+pub fn handle_html_projection(
+    req: Request,
+    runtime: &tokio::runtime::Runtime,
+    sidecar: Option<&Arc<SidecarManager>>,
+) -> Result<serde_json::Value> {
+    let params: HtmlProjectionParams = serde_json::from_value(req.params)?;
+    let request = file_request(&params.text_document.uri)?;
+    let projection: Option<(String,)> = fetch(runtime, sidecar, HTML_PROJECTION, &request)?;
+    Ok(projection_answer(projection))
+}
+
+/// The wire answer for a sidecar projection: `{ text }`, or `null` for none.
+fn projection_answer(projection: Option<(String,)>) -> serde_json::Value {
+    projection.map_or(
+        serde_json::Value::Null,
+        |(text,)| serde_json::json!({ "text": text }),
+    )
+}
+
+/// The sidecar request naming the document at `uri`.
+fn file_request(uri: &Uri) -> Result<SidecarFileReq> {
+    Ok(SidecarFileReq {
+        file_path: crate::paths::uri_to_path(uri.as_str())?,
+    })
+}
+
+/// Handle `textDocument/linkedEditingRange` for a Razor document via the C#
+/// sidecar: the start and end tag names of the element at the position.
+pub fn handle_linked_editing_range(
+    req: Request,
+    runtime: &tokio::runtime::Runtime,
+    sidecar: Option<&Arc<SidecarManager>>,
+) -> Result<serde_json::Value> {
+    let params: LinkedEditingRangeParams = serde_json::from_value(req.params)?;
+    let at = &params.text_document_position_params;
+    let request = SidecarPositionReq::at(&at.text_document.uri, at.position)?;
+    let found: SidecarLocationListResult = fetch(
+        runtime,
+        sidecar,
+        "textDocument/linkedEditingRange",
+        &request,
+    )?;
+    linked_ranges(&found)
+}
+
+/// The linked ranges of a sidecar answer, or `null` when it found none.
+fn linked_ranges(found: &SidecarLocationListResult) -> Result<serde_json::Value> {
+    let ranges: Vec<Range> = found.locations.iter().map(to_range).collect();
+    Ok(if ranges.is_empty() {
+        serde_json::Value::Null
+    } else {
+        serde_json::to_value(LinkedEditingRanges {
+            ranges,
+            word_pattern: None,
+        })?
+    })
+}
+
+/// Send one request to the sidecar that owns Razor and decode its answer.
+fn fetch<T: serde::de::DeserializeOwned>(
+    runtime: &tokio::runtime::Runtime,
+    sidecar: Option<&Arc<SidecarManager>>,
+    method: &str,
+    request: &impl serde::Serialize,
+) -> Result<T> {
+    let Some(sidecar) = sidecar else {
+        anyhow::bail!("C# sidecar unavailable; cannot answer {method} for a Razor document");
+    };
+    let payload = rmp_serde::to_vec(request)?;
+    let bytes = runtime.block_on(sidecar.request(method, payload))?;
+    Ok(rmp_serde::from_slice(&bytes)?)
+}
+
+/// A sidecar fold `(start_line, end_line)` as an LSP folding range.
+const fn to_folding_range((start_line, end_line): (u32, u32)) -> FoldingRange {
+    FoldingRange {
+        start_line,
+        start_character: None,
+        end_line,
+        end_character: None,
+        kind: None,
+        collapsed_text: None,
+    }
+}
+
+/// A sidecar location's range.
+fn to_range(location: &crate::semantic::SidecarLocationResult) -> Range {
+    Range::new(
+        Position::new(location.line, location.character),
+        Position::new(location.end_line, location.end_character),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    #![expect(
+        clippy::expect_used,
+        reason = "test code — panics are the correct failure mode"
+    )]
+    use super::*;
+
+    fn completion(uri: &str, trigger: Option<&str>) -> CompletionParams {
+        serde_json::from_value(serde_json::json!({
+            "textDocument": { "uri": uri },
+            "position": { "line": 0, "character": 1 },
+            "context": { "triggerKind": 2, "triggerCharacter": trigger },
+        }))
+        .expect("valid completion params")
+    }
+
+    /// `<` and `@` complete markup only in Razor documents; C# and F#
+    /// documents answer at once. [RAZOR-ARCHITECTURE-ROUTING]
+    #[test]
+    fn markup_triggers_short_circuit_only_outside_razor() {
+        assert!(is_markup_trigger_outside_razor(&completion(
+            "file:///a/Program.cs",
+            Some("<")
+        )));
+        assert!(is_markup_trigger_outside_razor(&completion(
+            "file:///a/Lib.fs",
+            Some("@")
+        )));
+        assert!(!is_markup_trigger_outside_razor(&completion(
+            "file:///a/Board.razor",
+            Some("<")
+        )));
+        assert!(!is_markup_trigger_outside_razor(&completion(
+            "file:///a/Index.cshtml",
+            Some("@")
+        )));
+        assert!(!is_markup_trigger_outside_razor(&completion(
+            "file:///a/Program.cs",
+            Some(".")
+        )));
+        assert!(!is_markup_trigger_outside_razor(&completion(
+            "file:///a/Program.cs",
+            None
+        )));
+    }
+
+    /// A projection answers `{ text }`; a document no project lists answers
+    /// `null`. [RAZOR-ARCHITECTURE-HTML]
+    #[test]
+    fn projections_answer_text_or_null() {
+        assert_eq!(
+            projection_answer(Some(("<p>   </p>".to_string(),))),
+            serde_json::json!({ "text": "<p>   </p>" })
+        );
+        assert_eq!(projection_answer(None), serde_json::Value::Null);
+    }
+
+    /// Without the C# sidecar the projection request fails and names itself,
+    /// rather than answering an empty projection.
+    #[test]
+    fn html_projection_without_sidecar_errors() {
+        let req = Request::new(
+            1.into(),
+            HTML_PROJECTION.into(),
+            serde_json::json!({ "textDocument": { "uri": "file:///a/Board.razor" } }),
+        );
+        let runtime = tokio::runtime::Runtime::new().expect("runtime");
+        let error = handle_html_projection(req, &runtime, None).expect_err("no sidecar");
+        assert!(error.to_string().contains(HTML_PROJECTION), "{error}");
+    }
+
+    /// Without the C# sidecar the structure requests fail and name themselves,
+    /// rather than answering that a file has no folds or linked tags.
+    /// [RAZOR-FEATURES-STRUCTURE]
+    #[test]
+    fn structure_requests_without_sidecar_error() {
+        let runtime = tokio::runtime::Runtime::new().expect("runtime");
+        let board = serde_json::json!({ "uri": "file:///a/Board.razor" });
+        let linked = Request::new(
+            1.into(),
+            "textDocument/linkedEditingRange".into(),
+            serde_json::json!({ "textDocument": board, "position": { "line": 6, "character": 2 } }),
+        );
+        let error = handle_linked_editing_range(linked, &runtime, None).expect_err("no sidecar");
+        assert!(error.to_string().contains("linkedEditingRange"), "{error}");
+
+        let folds = Request::new(
+            2.into(),
+            "textDocument/foldingRange".into(),
+            serde_json::json!({ "textDocument": board }),
+        );
+        let error = handle_folding_ranges(folds, &runtime, None).expect_err("no sidecar");
+        assert!(error.to_string().contains("foldingRange"), "{error}");
+    }
+
+    /// A sidecar fold keeps its lines and claims no characters or kind.
+    #[test]
+    fn sidecar_folds_become_line_folding_ranges() {
+        let fold = to_folding_range((6, 9));
+        assert_eq!((fold.start_line, fold.end_line), (6, 9));
+        assert_eq!((fold.start_character, fold.end_character), (None, None));
+        assert!(fold.kind.is_none());
+    }
+}
diff --git a/src/sharplsp/src/semantic.rs b/src/sharplsp/src/semantic.rs
index 4070e504..d7c01b71 100644
--- a/src/sharplsp/src/semantic.rs
+++ b/src/sharplsp/src/semantic.rs
@@ -752,24 +752,24 @@ struct SidecarHoverResult {
 
 /// A single location result from the sidecar (definition, references, etc.).
 #[derive(serde::Deserialize)]
-struct SidecarLocationResult {
+pub(crate) struct SidecarLocationResult {
     /// Absolute filesystem path of the target file.
     file_path: String,
     /// Start line of the target range.
-    line: u32,
+    pub(crate) line: u32,
     /// Start character of the target range.
-    character: u32,
+    pub(crate) character: u32,
     /// End line of the target range.
-    end_line: u32,
+    pub(crate) end_line: u32,
     /// End character of the target range.
-    end_character: u32,
+    pub(crate) end_character: u32,
 }
 
 /// Sidecar response containing a list of locations.
 #[derive(serde::Deserialize)]
-struct SidecarLocationListResult {
+pub(crate) struct SidecarLocationListResult {
     /// The resolved locations.
-    locations: Vec<SidecarLocationResult>,
+    pub(crate) locations: Vec<SidecarLocationResult>,
 }
 
 /// Sidecar request for find-references at a given position.
diff --git a/src/sharplsp/src/tree_sitter_parse.rs b/src/sharplsp/src/tree_sitter_parse.rs
index da0ae1dd..14021dd4 100644
--- a/src/sharplsp/src/tree_sitter_parse.rs
+++ b/src/sharplsp/src/tree_sitter_parse.rs
@@ -15,6 +15,10 @@ pub enum LangId {
     CSharp,
     /// F# (.fs, .fsx, .fsi files).
     FSharp,
+    /// Razor (.razor components, .cshtml pages and views). The C# sidecar owns
+    /// it, and its Razor compiler is the only parser: there is no tree-sitter
+    /// Razor grammar. Implements [RAZOR-ARCHITECTURE-ROUTING].
+    Razor,
 }
 
 impl LangId {
@@ -36,9 +40,16 @@ impl LangId {
         match crate::paths::extension_key(path)?.as_str() {
             "CS" => Some(Self::CSharp),
             "FS" | "FSX" | "FSI" => Some(Self::FSharp),
+            "RAZOR" | "CSHTML" => Some(Self::Razor),
             _ => None,
         }
     }
+
+    /// Whether the host parses this language with tree-sitter. Razor has no
+    /// grammar, so its syntax features come from the sidecar instead.
+    pub const fn has_grammar(self) -> bool {
+        !matches!(self, Self::Razor)
+    }
 }
 
 /// Manages tree-sitter parsers and parse trees.
@@ -74,6 +85,7 @@ impl TsParsers {
                     .set_language(&self.fsharp_language)
                     .context("failed to set F# language")?;
             }
+            LangId::Razor => anyhow::bail!("Razor has no tree-sitter grammar"),
         }
         parser
             .parse(source, old_tree)
@@ -117,4 +129,25 @@ mod tests {
         let unknown: Uri = "file:///c:/dir/readme.txt".parse().expect("valid uri");
         assert_eq!(LangId::from_uri(&unknown), None);
     }
+
+    /// Razor components and Razor pages and views are one language, owned by the
+    /// C# sidecar and never parsed by tree-sitter. [RAZOR-ARCHITECTURE-ROUTING]
+    #[test]
+    fn razor_and_cshtml_files_are_razor_without_a_grammar() {
+        let component: Uri = "file:///c:/app/Pages/Counter.razor"
+            .parse()
+            .expect("valid uri");
+        let view: Uri = "file:///c:/app/Views/Home/Index.CSHTML"
+            .parse()
+            .expect("valid uri");
+        assert_eq!(LangId::from_uri(&component), Some(LangId::Razor));
+        assert_eq!(LangId::from_uri(&view), Some(LangId::Razor));
+        assert!(!LangId::Razor.has_grammar());
+        assert!(LangId::CSharp.has_grammar() && LangId::FSharp.has_grammar());
+        let parsed = TsParsers::new().parse(LangId::Razor, "<p>@x</p>", None);
+        assert!(
+            parsed.is_err(),
+            "Razor must never reach a tree-sitter parser"
+        );
+    }
 }
diff --git a/src/sharplsp/tests/e2e_modules/fixtures_razor.rs b/src/sharplsp/tests/e2e_modules/fixtures_razor.rs
new file mode 100644
index 00000000..36ab569d
--- /dev/null
+++ b/src/sharplsp/tests/e2e_modules/fixtures_razor.rs
@@ -0,0 +1,77 @@
+//! The Razor fixture solution (`tests/fixtures/razor`): a Blazor app, a Razor
+//! class library, a Razor Pages and MVC app and an F# library, copied to a
+//! temp directory and restored so the SDK's Razor generator runs in the
+//! sidecar's design-time build. [RAZOR-TESTING]
+
+use super::*;
+use std::path::{Path, PathBuf};
+
+/// A restored copy of the Razor fixture solution.
+pub struct RazorWorkspace {
+    /// Owns the temp directory; dropping it deletes the copy.
+    pub dir: tempfile::TempDir,
+}
+
+impl RazorWorkspace {
+    /// The copy's root directory, which holds `RazorFixtures.slnx`.
+    pub fn root(&self) -> &Path {
+        self.dir.path()
+    }
+
+    /// A file in the copy, by its path segments under the root.
+    pub fn file(&self, segments: &[&str]) -> PathBuf {
+        segments
+            .iter()
+            .fold(self.root().to_path_buf(), |path, segment| {
+                path.join(segment)
+            })
+    }
+
+    /// The `vscode`-shaped URI of a file in the copy.
+    pub fn uri(&self, segments: &[&str]) -> String {
+        path_to_vscode_uri(&self.file(segments))
+    }
+
+    /// The text of a file in the copy.
+    pub fn text(&self, segments: &[&str]) -> String {
+        std::fs::read_to_string(self.file(segments)).expect("read Razor fixture file")
+    }
+}
+
+/// Copy the Razor fixture solution to a temp directory, with the repository's SDK
+/// pin, and restore it.
+pub fn create_razor_workspace() -> RazorWorkspace {
+    let source = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/razor");
+    let dir = tempfile::tempdir().expect("create Razor temp dir");
+    copy_fixture_tree(&source, dir.path());
+    keep_sdk_pin(dir.path());
+    restore_project(dir.path());
+    RazorWorkspace { dir }
+}
+
+/// Pin `destination` to the SDK the repository builds with. A copy under the temp
+/// root has no `global.json` above it, so it would restore and load with the newest
+/// installed SDK, whose Razor generator can need a newer Roslyn than the sidecar
+/// bundles. [RAZOR-TESTING]
+fn keep_sdk_pin(destination: &Path) {
+    let pin = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../global.json");
+    let _ = std::fs::copy(&pin, destination.join("global.json"))
+        .expect("copy the repository's global.json into the Razor fixture");
+}
+
+/// Copy a fixture tree, leaving out build output (`bin`, `obj`).
+fn copy_fixture_tree(source: &Path, destination: &Path) {
+    std::fs::create_dir_all(destination).expect("create fixture directory");
+    for entry in std::fs::read_dir(source).expect("read fixture directory") {
+        let entry = entry.expect("read fixture entry");
+        let name = entry.file_name();
+        let target = destination.join(&name);
+        if entry.file_type().expect("fixture entry type").is_dir() {
+            if name != "bin" && name != "obj" {
+                copy_fixture_tree(&entry.path(), &target);
+            }
+        } else {
+            let _ = std::fs::copy(entry.path(), &target).expect("copy fixture file");
+        }
+    }
+}
diff --git a/src/sharplsp/tests/e2e_modules/mod.rs b/src/sharplsp/tests/e2e_modules/mod.rs
index d8c0cb5c..40451186 100644
--- a/src/sharplsp/tests/e2e_modules/mod.rs
+++ b/src/sharplsp/tests/e2e_modules/mod.rs
@@ -35,6 +35,7 @@ pub use built_binary::built_sharplsp;
 pub mod fixtures;
 pub mod fixtures_cross_language;
 pub mod fixtures_medium;
+pub mod fixtures_razor;
 pub mod nav_helpers;
 pub mod session_helpers;
 
@@ -66,6 +67,7 @@ pub mod multi_solution;
 pub mod nuget_unused_full_stack;
 pub mod profiler_shared;
 pub mod pull_diagnostics;
+pub mod razor;
 pub mod references;
 pub mod selection;
 pub mod semantic_coverage;
@@ -89,6 +91,7 @@ pub mod workspace_symbols_selection;
 pub use fixtures::*;
 pub use fixtures_cross_language::*;
 pub use fixtures_medium::*;
+pub use fixtures_razor::*;
 pub use nav_helpers::*;
 pub use session_helpers::*;
 
diff --git a/src/sharplsp/tests/e2e_modules/razor.rs b/src/sharplsp/tests/e2e_modules/razor.rs
new file mode 100644
index 00000000..90b34ec1
--- /dev/null
+++ b/src/sharplsp/tests/e2e_modules/razor.rs
@@ -0,0 +1,223 @@
+//! Full-stack Razor session against the real fixture solution: the host
+//! routes a `.razor` file to the C# sidecar, forwards the syntax requests it
+//! cannot parse, short-circuits markup triggers elsewhere, and publishes
+//! Razor diagnostics under their own source. [RAZOR-ARCHITECTURE-ROUTING]
+
+use super::*;
+
+/// `Board.razor`, the fixture's richest component.
+const BOARD: &[&str] = &["BlazorApp", "Components", "Pages", "Board.razor"];
+
+/// `SymbolKind.Class` and `SymbolKind.Key` on the wire.
+const CLASS: u64 = 5;
+const KEY: u64 = 20;
+
+#[test]
+fn test_full_stack_razor_routing_session() {
+    require_dotnet();
+    let ws = create_razor_workspace();
+    let mut client = LspClient::start_verbose();
+    let init = client.initialize_with_root(json!(path_to_file_uri(ws.root())));
+    let triggers = &init["result"]["capabilities"]["completionProvider"]["triggerCharacters"];
+    assert_eq!(
+        triggers,
+        &json!([".", "<", "@"]),
+        "Razor triggers advertised"
+    );
+
+    let board = ws.uri(BOARD);
+    let board_text = ws.text(BOARD);
+    client.open_document(&board, &board_text);
+
+    // ── Readiness: a C# fragment's hover arrives through the projection ──
+    let hover = poll_hover_until_ready(&mut client, &board, 11, 16, Duration::from_mins(3));
+    let markdown = hover["contents"]["value"].as_str().unwrap_or_default();
+    assert!(
+        markdown.contains("caption") && markdown.contains("string"),
+        "hover on `caption` in `@bind` must show the field: {markdown}"
+    );
+
+    assert_syntax_requests_reach_the_sidecar(&mut client, &board);
+    assert_html_projection(&mut client, &ws, &board, &board_text);
+    assert_markup_triggers_only_complete_razor(&mut client, &ws);
+    assert_diagnostics_publish_as_razor(&mut client, &board, &board_text);
+
+    client.shutdown_and_exit();
+    client.wait_with_timeout();
+}
+
+/// documentSymbol, foldingRange and linkedEditingRange come from the sidecar's
+/// Razor compiler; selectionRange answers empty. [RAZOR-FEATURES-STRUCTURE]
+fn assert_syntax_requests_reach_the_sidecar(client: &mut LspClient, board: &str) {
+    let symbols = document_request(client, "textDocument/documentSymbol", board);
+    assert_rpc_ok(&symbols, "documentSymbol(Board.razor)");
+    let names: Vec<&str> = symbols["result"]
+        .as_array()
+        .expect("nested symbols")
+        .iter()
+        .filter_map(|symbol| symbol["name"].as_str())
+        .collect();
+    assert_eq!(
+        names,
+        [
+            "@page",
+            "@implements",
+            "@inject",
+            "PageTitle",
+            "Panel",
+            "input",
+            "button",
+            "@code"
+        ]
+    );
+    let panel = find_symbol(&symbols["result"], "Panel").expect("Panel symbol");
+    assert_eq!(panel["kind"], CLASS);
+    assert_eq!(
+        panel["selectionRange"]["start"],
+        json!({ "line": 6, "character": 1 })
+    );
+    assert_eq!(
+        find_symbol(&symbols["result"], "@code").expect("@code")["kind"],
+        KEY
+    );
+    assert!(
+        find_symbol(&panel["children"], "Badge").is_some(),
+        "Badge nests in Tally"
+    );
+    assert_eq!(
+        find_symbol(&symbols["result"], "Add").expect("Add")["kind"],
+        6
+    );
+
+    let folds = document_request(client, "textDocument/foldingRange", board);
+    assert_rpc_ok(&folds, "foldingRange(Board.razor)");
+    let lines: Vec<(u64, u64)> = folds["result"]
+        .as_array()
+        .expect("folding ranges")
+        .iter()
+        .map(|fold| {
+            (
+                fold["startLine"].as_u64().unwrap(),
+                fold["endLine"].as_u64().unwrap(),
+            )
+        })
+        .collect();
+    assert_eq!(lines, [(6, 9), (7, 8), (14, 24)]);
+
+    let linked = position_request(client, "textDocument/linkedEditingRange", board, (6, 3));
+    assert_rpc_ok(&linked, "linkedEditingRange(<Panel)");
+    assert_eq!(
+        linked["result"]["ranges"],
+        json!([
+            { "start": { "line": 6, "character": 1 }, "end": { "line": 6, "character": 6 } },
+            { "start": { "line": 10, "character": 2 }, "end": { "line": 10, "character": 7 } }
+        ])
+    );
+    let none = position_request(client, "textDocument/linkedEditingRange", board, (8, 10));
+    assert_eq!(
+        none["result"],
+        Value::Null,
+        "a self-closing tag links nothing"
+    );
+
+    let selection = client.request(
+        "textDocument/selectionRange",
+        json!({ "textDocument": { "uri": board }, "positions": [{ "line": 6, "character": 3 }] }),
+    );
+    assert_rpc_ok(&selection, "selectionRange(Board.razor)");
+    assert_eq!(selection["result"], json!([]));
+}
+
+/// The HTML projection keeps markup at its own positions and blanks Razor; a
+/// C# file has none. [RAZOR-ARCHITECTURE-HTML]
+fn assert_html_projection(client: &mut LspClient, ws: &RazorWorkspace, board: &str, text: &str) {
+    let answer = document_request(client, "sharplsp/razor/htmlProjection", board);
+    assert_rpc_ok(&answer, "htmlProjection(Board.razor)");
+    let html = answer["result"]["text"].as_str().expect("projection text");
+    let widths = |source: &str| source.lines().map(str::len).collect::<Vec<_>>();
+    assert_eq!(widths(html), widths(text), "every line keeps its width");
+    let lines: Vec<&str> = html.lines().collect();
+    assert_eq!(
+        lines[4], "<PageTitle>Board    </PageTitle>",
+        "`@Id` is blanked"
+    );
+    assert!(lines[6].starts_with("<Panel"), "markup stays: {}", lines[6]);
+    assert_eq!(lines[10], "</Panel>");
+    assert!(
+        lines[0].trim().is_empty() && lines[14].trim().is_empty(),
+        "`@page` and `@code {{` are blanked"
+    );
+
+    let program = ws.uri(&["BlazorApp", "Program.cs"]);
+    let none = document_request(client, "sharplsp/razor/htmlProjection", &program);
+    assert_rpc_ok(&none, "htmlProjection(Program.cs)");
+    assert_eq!(none["result"], Value::Null, "a C# file has no projection");
+}
+
+/// `<` and `@` complete in Razor but answer `null` at once in C#.
+fn assert_markup_triggers_only_complete_razor(client: &mut LspClient, ws: &RazorWorkspace) {
+    let program = ws.uri(&["BlazorApp", "Program.cs"]);
+    client.open_document(&program, &ws.text(&["BlazorApp", "Program.cs"]));
+    for trigger in ["<", "@"] {
+        let completion = client.request(
+            "textDocument/completion",
+            json!({
+                "textDocument": { "uri": program },
+                "position": { "line": 0, "character": 0 },
+                "context": { "triggerKind": 2, "triggerCharacter": trigger }
+            }),
+        );
+        assert_rpc_ok(&completion, "completion(Program.cs, markup trigger)");
+        assert_eq!(
+            completion["result"],
+            Value::Null,
+            "`{trigger}` in C# answers null"
+        );
+    }
+    let counter = ws.uri(&["BlazorApp", "Components", "Pages", "Counter.razor"]);
+    client.open_document(
+        &counter,
+        &ws.text(&["BlazorApp", "Components", "Pages", "Counter.razor"]),
+    );
+    let at = client.request(
+        "textDocument/completion",
+        json!({
+            "textDocument": { "uri": counter },
+            "position": { "line": 0, "character": 1 },
+            "context": { "triggerKind": 2, "triggerCharacter": "@" }
+        }),
+    );
+    assert_rpc_ok(&at, "completion(Counter.razor, @)");
+}
+
+/// A C# error in a Razor file publishes under `sharplsp-razor`, and clears.
+fn assert_diagnostics_publish_as_razor(client: &mut LspClient, board: &str, text: &str) {
+    let broken = text.replace("score + Id)", "score + Idd)");
+    client.change_document(board, 2, &broken);
+    let errors = poll_error_diagnostics_until(
+        client,
+        board,
+        "diagnostics(Board.razor)",
+        Duration::from_mins(2),
+        |errors| errors.iter().any(|d| d["code"] == "CS0103"),
+    );
+    let unknown = errors
+        .iter()
+        .find(|d| d["code"] == "CS0103")
+        .expect("CS0103");
+    assert_eq!(unknown["source"], "sharplsp-razor");
+    assert_eq!(unknown["range"]["start"]["line"], 22);
+    assert!(unknown["message"]
+        .as_str()
+        .unwrap_or_default()
+        .contains("Idd"));
+
+    client.change_document(board, 3, text);
+    let _ = poll_error_diagnostics_until(
+        client,
+        board,
+        "diagnostics(Board.razor) after the fix",
+        Duration::from_mins(2),
+        <[Value]>::is_empty,
+    );
+}
diff --git a/src/sharplsp/tests/fixtures/razor/.editorconfig b/src/sharplsp/tests/fixtures/razor/.editorconfig
new file mode 100644
index 00000000..dc74dd92
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/.editorconfig
@@ -0,0 +1,4 @@
+# Stops the repository's .editorconfig, which raises every analyzer diagnostic to an
+# error, from reaching the Razor fixtures. With Directory.Build.props they build as a
+# user's projects would. [RAZOR-TESTING]
+root = true
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/BlazorApp.csproj b/src/sharplsp/tests/fixtures/razor/BlazorApp/BlazorApp.csproj
new file mode 100644
index 00000000..8d76db6b
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/BlazorApp.csproj
@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../Domain/Domain.fsproj" />
+    <ProjectReference Include="../Widgets/Widgets.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/App.razor b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/App.razor
new file mode 100644
index 00000000..3b7bb3e1
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/App.razor
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <base href="/" />
+    <HeadOutlet />
+</head>
+<body>
+    <Routes />
+    <script src="_framework/blazor.web.js"></script>
+</body>
+</html>
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Board.razor b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Board.razor
new file mode 100644
index 00000000..622811d0
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Board.razor
@@ -0,0 +1,26 @@
+@page "/board/{Id:int}"
+@implements IDisposable
+@inject NavigationManager Navigation
+
+<PageTitle>Board @Id</PageTitle>
+
+<Panel Title="Scores">
+    <Tally TItem="int" Items="scores" Format="@(score => $"#{score}")" @bind-Label="caption" @ref="tally">
+        <Badge Text="@caption" />
+    </Tally>
+</Panel>
+<input @bind="caption" @bind:event="oninput" />
+<button @onclick="() => Add(1)" disabled="@(scores.Count > 9)">Add</button>
+
+@code {
+    /// <summary>The board's number, from the route.</summary>
+    [Parameter] public int Id { get; set; }
+
+    private readonly List<int> scores = [];
+    private string caption = "Board";
+    private Tally<int>? tally;
+
+    private void Add(int score) => scores.Add(score + Id);
+
+    public void Dispose() => scores.Clear();
+}
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Counter.razor b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Counter.razor
new file mode 100644
index 00000000..0d9d43ad
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Counter.razor
@@ -0,0 +1,19 @@
+@page "/counter"
+@rendermode InteractiveServer
+
+<PageTitle>Counter</PageTitle>
+
+<h1>Counter</h1>
+
+<p role="status">Current count: @currentCount</p>
+
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+
+@code {
+    private int currentCount = 0;
+
+    private void IncrementCount()
+    {
+        currentCount++;
+    }
+}
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Leaders.razor b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Leaders.razor
new file mode 100644
index 00000000..46d61fd9
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Pages/Leaders.razor
@@ -0,0 +1,14 @@
+@page "/leaders"
+@using Domain
+
+<ul>
+    @foreach (var player in players)
+    {
+        <li>@player.Name: @player.Score</li>
+    }
+</ul>
+<p>Total: @Scoring.total(players)</p>
+
+@code {
+    private readonly Player[] players = [new Player("Ada", 3), new Player("Grace", 5)];
+}
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Routes.razor b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Routes.razor
new file mode 100644
index 00000000..06570ce6
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Routes.razor
@@ -0,0 +1,5 @@
+<Router AppAssembly="typeof(Program).Assembly">
+    <Found Context="routeData">
+        <RouteView RouteData="routeData" />
+    </Found>
+</Router>
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Badge.razor b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Badge.razor
new file mode 100644
index 00000000..98c2475f
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Badge.razor
@@ -0,0 +1 @@
+<span class="badge">@Text</span>
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Badge.razor.cs b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Badge.razor.cs
new file mode 100644
index 00000000..e77a66dd
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Badge.razor.cs
@@ -0,0 +1,10 @@
+using Microsoft.AspNetCore.Components;
+
+namespace BlazorApp.Components.Shared;
+
+/// <summary>A small label beside a tally.</summary>
+public partial class Badge
+{
+    /// <summary>The badge's text.</summary>
+    [Parameter] public string Text { get; set; } = "";
+}
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Tally.razor b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Tally.razor
new file mode 100644
index 00000000..9b9c2045
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/Shared/Tally.razor
@@ -0,0 +1,27 @@
+@typeparam TItem
+
+<ul class="tally">
+    @foreach (var item in Items)
+    {
+        <li @key="item">@Format(item)</li>
+    }
+</ul>
+<span class="caption">@Label</span>
+@ChildContent
+
+@code {
+    /// <summary>The items to tally.</summary>
+    [Parameter, EditorRequired] public IReadOnlyList<TItem> Items { get; set; } = [];
+
+    /// <summary>How each item renders.</summary>
+    [Parameter] public Func<TItem, string> Format { get; set; } = item => item?.ToString() ?? "";
+
+    /// <summary>The tally's caption.</summary>
+    [Parameter] public string Label { get; set; } = "";
+
+    /// <summary>Raised when the caption changes.</summary>
+    [Parameter] public EventCallback<string> LabelChanged { get; set; }
+
+    /// <summary>Content under the tally.</summary>
+    [Parameter] public RenderFragment? ChildContent { get; set; }
+}
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/_Imports.razor b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/_Imports.razor
new file mode 100644
index 00000000..27a50d73
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Components/_Imports.razor
@@ -0,0 +1,6 @@
+@using Microsoft.AspNetCore.Components.Forms
+@using Microsoft.AspNetCore.Components.Routing
+@using Microsoft.AspNetCore.Components.Web
+@using static Microsoft.AspNetCore.Components.Web.RenderMode
+@using BlazorApp.Components.Shared
+@using Widgets
diff --git a/src/sharplsp/tests/fixtures/razor/BlazorApp/Program.cs b/src/sharplsp/tests/fixtures/razor/BlazorApp/Program.cs
new file mode 100644
index 00000000..965fe901
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/BlazorApp/Program.cs
@@ -0,0 +1,9 @@
+using BlazorApp.Components;
+
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddRazorComponents().AddInteractiveServerComponents();
+
+var app = builder.Build();
+app.UseAntiforgery();
+app.MapRazorComponents<App>().AddInteractiveServerRenderMode();
+app.Run();
diff --git a/src/sharplsp/tests/fixtures/razor/Directory.Build.props b/src/sharplsp/tests/fixtures/razor/Directory.Build.props
new file mode 100644
index 00000000..37008cbc
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/Directory.Build.props
@@ -0,0 +1,5 @@
+<Project>
+    <!-- Intentionally empty: this file shadows the repository-wide Directory.Build.props so
+         SharpLsp's C# analyzers, package references and warnings-as-errors settings do not
+         reach the Razor fixtures. They build as a user's projects would. [RAZOR-TESTING] -->
+</Project>
diff --git a/src/sharplsp/tests/fixtures/razor/Directory.Build.targets b/src/sharplsp/tests/fixtures/razor/Directory.Build.targets
new file mode 100644
index 00000000..05d7b527
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/Directory.Build.targets
@@ -0,0 +1,3 @@
+<Project>
+    <!-- The Directory.Build.targets twin of this folder's Directory.Build.props: stop the upward search. -->
+</Project>
diff --git a/src/sharplsp/tests/fixtures/razor/Domain/Domain.fsproj b/src/sharplsp/tests/fixtures/razor/Domain/Domain.fsproj
new file mode 100644
index 00000000..d3ff295d
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/Domain/Domain.fsproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Scores.fs" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/sharplsp/tests/fixtures/razor/Domain/Scores.fs b/src/sharplsp/tests/fixtures/razor/Domain/Scores.fs
new file mode 100644
index 00000000..11578364
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/Domain/Scores.fs
@@ -0,0 +1,9 @@
+namespace Domain
+
+/// A player on the leader board.
+type Player = { Name: string; Score: int }
+
+/// Scoring rules for the leader board.
+module Scoring =
+    /// The sum of every player's score.
+    let total (players: seq<Player>) = players |> Seq.sumBy (fun player -> player.Score)
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/Controllers/HomeController.cs b/src/sharplsp/tests/fixtures/razor/PagesApp/Controllers/HomeController.cs
new file mode 100644
index 00000000..ad308667
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/Controllers/HomeController.cs
@@ -0,0 +1,11 @@
+using Microsoft.AspNetCore.Mvc;
+using PagesApp.Models;
+
+namespace PagesApp.Controllers;
+
+/// <summary>Serves the home page.</summary>
+public class HomeController : Controller
+{
+    /// <summary>Shows the featured item.</summary>
+    public IActionResult Index() => View(new Item("Lamp", 12.5m));
+}
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/Models/Item.cs b/src/sharplsp/tests/fixtures/razor/PagesApp/Models/Item.cs
new file mode 100644
index 00000000..de185bb1
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/Models/Item.cs
@@ -0,0 +1,4 @@
+namespace PagesApp.Models;
+
+/// <summary>An item the home page shows.</summary>
+public record Item(string Name, decimal Price);
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/Edit.cshtml b/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/Edit.cshtml
new file mode 100644
index 00000000..f1eafe4e
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/Edit.cshtml
@@ -0,0 +1,15 @@
+@page "{id:int}"
+@model EditModel
+@inject ILogger<EditModel> Log
+
+<form method="post">
+    <label asp-for="Title"></label>
+    <input asp-for="Title" class="form-control" />
+    <span asp-validation-for="Title"></span>
+    <a asp-page="/Edit" asp-route-id="@Model.Id">Reload</a>
+</form>
+<p>@Shout(Model.Title)</p>
+
+@functions {
+    string Shout(string text) => text.ToUpperInvariant();
+}
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/Edit.cshtml.cs b/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/Edit.cshtml.cs
new file mode 100644
index 00000000..fd292929
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/Edit.cshtml.cs
@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace PagesApp.Pages;
+
+/// <summary>Edits one item.</summary>
+public class EditModel : PageModel
+{
+    /// <summary>The item's id.</summary>
+    public int Id { get; set; }
+
+    /// <summary>The item's title.</summary>
+    [Required]
+    public string Title { get; set; } = "";
+
+    /// <summary>Loads the item.</summary>
+    public void OnGet(int id) => Id = id;
+}
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/_ViewImports.cshtml b/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/_ViewImports.cshtml
new file mode 100644
index 00000000..708c8ee1
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/Pages/_ViewImports.cshtml
@@ -0,0 +1,3 @@
+@using PagesApp
+@namespace PagesApp.Pages
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/PagesApp.csproj b/src/sharplsp/tests/fixtures/razor/PagesApp/PagesApp.csproj
new file mode 100644
index 00000000..a3a34b64
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/PagesApp.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/Program.cs b/src/sharplsp/tests/fixtures/razor/PagesApp/Program.cs
new file mode 100644
index 00000000..2e184d93
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/Program.cs
@@ -0,0 +1,8 @@
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddRazorPages();
+builder.Services.AddControllersWithViews();
+
+var app = builder.Build();
+app.MapRazorPages();
+app.MapDefaultControllerRoute();
+app.Run();
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/Views/Home/Index.cshtml b/src/sharplsp/tests/fixtures/razor/PagesApp/Views/Home/Index.cshtml
new file mode 100644
index 00000000..371b4305
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/Views/Home/Index.cshtml
@@ -0,0 +1,8 @@
+@model Item
+@{
+    ViewData["Title"] = Model.Name;
+}
+
+<h1>@Model.Name</h1>
+<p>@Model.Price.ToString("C")</p>
+<a asp-controller="Home" asp-action="Index">Home</a>
diff --git a/src/sharplsp/tests/fixtures/razor/PagesApp/Views/_ViewImports.cshtml b/src/sharplsp/tests/fixtures/razor/PagesApp/Views/_ViewImports.cshtml
new file mode 100644
index 00000000..4f8ab5b7
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/PagesApp/Views/_ViewImports.cshtml
@@ -0,0 +1,2 @@
+@using PagesApp.Models
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
diff --git a/src/sharplsp/tests/fixtures/razor/RazorFixtures.slnx b/src/sharplsp/tests/fixtures/razor/RazorFixtures.slnx
new file mode 100644
index 00000000..52d17369
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/RazorFixtures.slnx
@@ -0,0 +1,6 @@
+<Solution>
+  <Project Path="BlazorApp/BlazorApp.csproj" />
+  <Project Path="Domain/Domain.fsproj" />
+  <Project Path="PagesApp/PagesApp.csproj" />
+  <Project Path="Widgets/Widgets.csproj" />
+</Solution>
diff --git a/src/sharplsp/tests/fixtures/razor/Widgets/Panel.razor b/src/sharplsp/tests/fixtures/razor/Widgets/Panel.razor
new file mode 100644
index 00000000..740c0f38
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/Widgets/Panel.razor
@@ -0,0 +1,12 @@
+<section class="panel">
+    <h2>@Title</h2>
+    @ChildContent
+</section>
+
+@code {
+    /// <summary>The panel's heading.</summary>
+    [Parameter, EditorRequired] public string Title { get; set; } = "";
+
+    /// <summary>What the panel shows.</summary>
+    [Parameter] public RenderFragment? ChildContent { get; set; }
+}
diff --git a/src/sharplsp/tests/fixtures/razor/Widgets/Widgets.csproj b/src/sharplsp/tests/fixtures/razor/Widgets/Widgets.csproj
new file mode 100644
index 00000000..c9a32e66
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/Widgets/Widgets.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk.Razor">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/sharplsp/tests/fixtures/razor/Widgets/_Imports.razor b/src/sharplsp/tests/fixtures/razor/Widgets/_Imports.razor
new file mode 100644
index 00000000..66ebfa5d
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/razor/Widgets/_Imports.razor
@@ -0,0 +1 @@
+@using Microsoft.AspNetCore.Components.Web
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/AdhocRazorProject.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/AdhocRazorProject.cs
new file mode 100644
index 00000000..ee9b0cc5
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/AdhocRazorProject.cs
@@ -0,0 +1,144 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// An in-memory C# project for Razor unit tests, shaped the way MSBuild hands a project to the
+/// sidecar: Razor files as additional documents, MSBuild properties and file metadata in a
+/// global analyzer config, and generated sources standing in for the SDK's Razor generator.
+/// Implements [RAZOR-TESTING].
+/// </summary>
+internal static class AdhocRazorProject
+{
+    /// <summary>The project's directory.</summary>
+    public static string Directory { get; } = NativePaths.Temp("AdhocRazor");
+
+    /// <summary>A path inside the project's directory.</summary>
+    public static string PathOf(params string[] segments)
+    {
+        return NativePaths.Resolve(Directory, segments);
+    }
+
+    /// <summary>
+    /// The project <c>App</c>: <paramref name="files"/> are its additional documents,
+    /// <paramref name="globalConfig"/> its MSBuild analyzer options, and
+    /// <paramref name="generated"/> what its generator adds.
+    /// </summary>
+    public static Project Create(
+        AdhocWorkspace workspace,
+        IEnumerable<(string Path, string Text)> files,
+        string globalConfig = "",
+        IReadOnlyList<(string Hint, string Source)>? generated = null
+    )
+    {
+        var id = ProjectId.CreateNewId();
+        var solution = workspace
+            .CurrentSolution.AddProject(Info(id, generated ?? []))
+            .AddAnalyzerConfigDocument(
+                DocumentId.CreateNewId(id),
+                ".globalconfig",
+                SourceText.From("is_global = true\n" + globalConfig),
+                filePath: PathOf(".globalconfig")
+            );
+        return files
+            .Aggregate(solution, (current, file) => WithFile(current, id, file))
+            .GetProject(id)!;
+    }
+
+    /// <summary>The additional document at <paramref name="path"/>.</summary>
+    public static TextDocument Additional(Project project, string path)
+    {
+        return project.AdditionalDocuments.Single(document =>
+            NativePaths.AreEqual(document.FilePath, path)
+        );
+    }
+
+    private static ProjectInfo Info(
+        ProjectId id,
+        IReadOnlyList<(string Hint, string Source)> generated
+    )
+    {
+        return ProjectInfo.Create(
+            id,
+            VersionStamp.Default,
+            "App",
+            "App",
+            LanguageNames.CSharp,
+            filePath: PathOf("App.csproj"),
+            analyzerReferences: [new GeneratorReference(new FixedSources(generated))]
+        );
+    }
+
+    private static Solution WithFile(
+        Solution solution,
+        ProjectId id,
+        (string Path, string Text) file
+    )
+    {
+        return solution.AddAdditionalDocument(
+            DocumentId.CreateNewId(id),
+            NativePaths.NameOf(file.Path),
+            SourceText.From(file.Text),
+            filePath: file.Path
+        );
+    }
+}
+
+/// <summary>An analyzer reference that supplies <paramref name="generators"/>.</summary>
+internal sealed class GeneratorReference(params IIncrementalGenerator[] generators)
+    : AnalyzerReference
+{
+    private readonly ImmutableArray<ISourceGenerator> _generators =
+    [
+        .. generators.Select(GeneratorExtensions.AsSourceGenerator),
+    ];
+
+    /// <inheritdoc />
+    public override string FullPath => "";
+
+    /// <inheritdoc />
+    public override object Id { get; } = Guid.NewGuid();
+
+    /// <inheritdoc />
+    public override ImmutableArray<DiagnosticAnalyzer> GetAnalyzers(string language)
+    {
+        return [];
+    }
+
+    /// <inheritdoc />
+    public override ImmutableArray<DiagnosticAnalyzer> GetAnalyzersForAllLanguages()
+    {
+        return [];
+    }
+
+    /// <inheritdoc />
+    public override ImmutableArray<ISourceGenerator> GetGenerators(string language)
+    {
+        return _generators;
+    }
+}
+
+/// <summary>
+/// A generator that adds the same sources every run, as the SDK's Razor generator adds one
+/// projection per Razor file. With no sources it stands for a project's other generators,
+/// which add nothing but still make Roslyn compile the project to run them.
+/// </summary>
+internal sealed class FixedSources(IReadOnlyList<(string Hint, string Source)> sources)
+    : IIncrementalGenerator
+{
+    /// <inheritdoc />
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        context.RegisterPostInitializationOutput(output =>
+        {
+            foreach (var (hint, source) in sources)
+            {
+                output.AddSource(hint, source);
+            }
+        });
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/HtmlMarkupContextTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/HtmlMarkupContextTests.cs
new file mode 100644
index 00000000..c266559e
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/HtmlMarkupContextTests.cs
@@ -0,0 +1,285 @@
+#pragma warning disable CA1515 // Public xUnit discovery type
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+
+using SharpLsp.Sidecar.CSharp.Razor;
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// The markup context at carets across projected HTML: complete and incomplete tags, quoted and
+/// unquoted attributes, comments, declarations and raw text. Implements [RAZOR-TESTING] for
+/// [RAZOR-ARCHITECTURE-HTML].
+/// </summary>
+public sealed class HtmlMarkupContextTests
+{
+    [Fact]
+    public void Text_between_and_around_complete_tags_is_content()
+    {
+        Assert.Equal(MarkupContext.Content, Of("|<p>Hello</p>"));
+        Assert.Equal(MarkupContext.TagName, Of("<|p>Hello</p>"));
+        Assert.Equal(MarkupContext.Content, Of("<p>|Hello</p>"));
+        Assert.Equal(MarkupContext.Content, Of("<p>Hello|</p>"));
+        Assert.Equal(MarkupContext.Content, Of("<p>a</p>|<b>b</b>"));
+        Assert.Equal(MarkupContext.Content, Of("<p>a</p><b>|b</b>"));
+        Assert.Equal(MarkupContext.Content, Of("<p>a</p><b>b</b>|"));
+    }
+
+    [Fact]
+    public void Tag_name_runs_from_the_open_bracket_to_the_first_break()
+    {
+        Assert.Equal(MarkupContext.TagName, Of("<|"));
+        Assert.Equal(MarkupContext.TagName, Of("<d|iv"));
+        Assert.Equal(MarkupContext.TagName, Of("<div|"));
+        Assert.Equal(MarkupContext.TagName, Of("<DIV|"));
+        Assert.Equal(MarkupContext.TagName, Of("<div| class=\"x\">"));
+        Assert.Equal(MarkupContext.TagName, Of("</|"));
+        Assert.Equal(MarkupContext.TagName, Of("</d|iv>"));
+        Assert.Equal(MarkupContext.TagName, Of("</div|>"));
+        Assert.Equal(MarkupContext.Content, Of("<div>|"));
+        Assert.Equal(MarkupContext.Content, Of("<br/>|"));
+    }
+
+    [Fact]
+    public void A_space_after_the_tag_name_opens_the_attribute_area()
+    {
+        Assert.Equal(MarkupContext.AttributeName, Of("<div |"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div c|lass=\"x\">"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div class|=\"x\">"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div class | = \"x\">"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div a='1' |"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div a='1' b|>"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div a=\"1\"|>"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div a=\"1\" /|>"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<br /|>"));
+    }
+
+    [Fact]
+    public void Attribute_values_hold_quoted_and_unquoted_forms()
+    {
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=|"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=|\"x\">"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=\"|\""));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=\"a|b\""));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class='a|'"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=a|"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=a| b>"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=\"http://a?b|\">"));
+    }
+
+    [Fact]
+    public void A_greater_than_inside_a_quoted_value_does_not_close_the_tag()
+    {
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=\"a > b|\""));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div title=\"</scr|ipt>\">"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div class=\"a > b\"|>"));
+        Assert.Equal(MarkupContext.Content, Of("<div class=\"a > b\">|"));
+    }
+
+    [Fact]
+    public void Incomplete_tags_keep_their_context_at_the_end_of_the_projection()
+    {
+        Assert.Equal(MarkupContext.TagName, Of("<div|"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div |"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div class|"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=|"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div class=\"x|"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div class='x'|"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div class='x' |"));
+    }
+
+    [Fact]
+    public void Stray_less_than_signs_stay_content()
+    {
+        Assert.Equal(MarkupContext.Content, Of("1 < 2|"));
+        Assert.Equal(MarkupContext.Content, Of("1<2|"));
+        Assert.Equal(MarkupContext.Content, Of("x <3| and y > 2"));
+        Assert.Equal(MarkupContext.Content, Of("< |div"));
+        Assert.Equal(MarkupContext.TagName, Of("a <|b"));
+        Assert.Equal(MarkupContext.TagName, Of("a <|"));
+    }
+
+    [Fact]
+    public void Comments_hold_content_until_their_close()
+    {
+        Assert.Equal(MarkupContext.Content, Of("<!--|"));
+        Assert.Equal(MarkupContext.Content, Of("<!-- <div class=|\"x\"> -->"));
+        Assert.Equal(MarkupContext.Content, Of("<!-- a > b| -->"));
+        Assert.Equal(MarkupContext.Content, Of("<!-- x <div|"));
+        Assert.Equal(MarkupContext.Content, Of("<!-- a > b -->|"));
+        Assert.Equal(MarkupContext.Content, Of("<!-- a > b -->|<div "));
+        Assert.Equal(MarkupContext.TagName, Of("<!-- a > b --><|div "));
+    }
+
+    [Fact]
+    public void Abrupt_and_bang_comments_close_like_the_tokenizer_closes_them()
+    {
+        Assert.Equal(MarkupContext.Content, Of("<!-->|<div "));
+        Assert.Equal(MarkupContext.AttributeName, Of("<!--><div |"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<!---><div |"));
+        Assert.Equal(MarkupContext.TagName, Of("<!-- x --!><p|>"));
+        Assert.Equal(MarkupContext.Content, Of("<!-- x -- |-->|"));
+    }
+
+    [Fact]
+    public void Declarations_and_processing_instructions_stay_content()
+    {
+        Assert.Equal(MarkupContext.Content, Of("<!DOCTYPE html|>"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<!DOCTYPE html><div |"));
+        Assert.Equal(MarkupContext.Content, Of("<?xml |"));
+        Assert.Equal(MarkupContext.Content, Of("<?xml version=\"1.0\"?>|"));
+        Assert.Equal(MarkupContext.TagName, Of("<?p?><b|r>"));
+        Assert.Equal(MarkupContext.Content, Of("<![CDATA[ x < y |]]>"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<![CDATA[x]]><div |"));
+    }
+
+    [Fact]
+    public void Raw_text_hides_markup_until_its_own_end_tag()
+    {
+        Assert.Equal(MarkupContext.Content, Of("<script>var a = \"<div class=|'x'>\";</script>"));
+        Assert.Equal(MarkupContext.Content, Of("<script>if (a < b && c > d) { }|</script>"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<script>if (a < b) {}</script><div |"));
+        Assert.Equal(MarkupContext.Content, Of("<style>p > q| { }</style>"));
+        Assert.Equal(MarkupContext.TagName, Of("<style>p{}</style><h|1>"));
+        Assert.Equal(MarkupContext.Content, Of("<textarea><div|</textarea>"));
+        Assert.Equal(MarkupContext.Content, Of("<title>a < b|</title>"));
+        Assert.Equal(MarkupContext.Content, Of("<iframe><div|</iframe>"));
+        Assert.Equal(MarkupContext.Content, Of("<xmp><b|</xmp>"));
+    }
+
+    [Fact]
+    public void Raw_text_matches_its_end_tag_case_insensitively()
+    {
+        Assert.Equal(MarkupContext.Content, Of("<SCRIPT>x|</SCRIPT>"));
+        Assert.Equal(MarkupContext.TagName, Of("<SCRIPT>x</SCR|IPT>"));
+        Assert.Equal(MarkupContext.Content, Of("<SCRIPT>x</SCRIPT>|"));
+    }
+
+    [Fact]
+    public void Raw_text_end_tag_names_flip_to_tag_name_only_when_appropriate()
+    {
+        Assert.Equal(MarkupContext.TagName, Of("<script>x</script|"));
+        Assert.Equal(MarkupContext.TagName, Of("<script>x</script|>"));
+        Assert.Equal(MarkupContext.TagName, Of("<textarea>a</textarea|"));
+        Assert.Equal(MarkupContext.TagName, Of("<script>x</script></|"));
+        // The full projection determines whether the closing tag is appropriate; the caret
+        // may sit partway through its name ([RAZOR-ARCHITECTURE-HTML]).
+        Assert.Equal(MarkupContext.TagName, Of("<script>x</scr|ipt>"));
+        Assert.Equal(MarkupContext.Content, Of("<script>x</scripty|>"));
+        Assert.Equal(MarkupContext.Content, Of("<script>var s = \"</scr\" + \"ipt>\";</scr|"));
+    }
+
+    [Fact]
+    public void A_self_closed_script_still_reads_raw_text_like_the_tokenizer()
+    {
+        Assert.Equal(MarkupContext.Content, Of("<script/><div|"));
+        Assert.Equal(MarkupContext.Content, Of("<script />if (a < b)|"));
+    }
+
+    [Fact]
+    public void Malformed_self_closing_syntax_reconsumes_the_following_attribute()
+    {
+        Assert.Equal(MarkupContext.AttributeName, Of("<div /x|"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div /x=|"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div /x=1|"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<div /x='value|"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<div /x='value'|"));
+        Assert.Equal(MarkupContext.Content, Of("<div /x='value'>|"));
+    }
+
+    [Fact]
+    public void Stray_open_brackets_reconsume_the_next_tag_opening()
+    {
+        Assert.Equal(MarkupContext.TagName, Of("<<di|"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<<div |"));
+        Assert.Equal(MarkupContext.AttributeValue, Of("<<div x=|"));
+        Assert.Equal(MarkupContext.Content, Of("<<div x=1>|"));
+        Assert.Equal(MarkupContext.AttributeName, Of("<<<div |"));
+    }
+
+    [Fact]
+    public void Invalid_end_tag_openings_remain_comments_until_their_close()
+    {
+        Assert.Equal(MarkupContext.Content, Of("</? <div x=|"));
+        Assert.Equal(MarkupContext.Content, Of("</ <p |"));
+        Assert.Equal(MarkupContext.Content, Of("</? <div x=>|<p>"));
+        Assert.Equal(MarkupContext.AttributeName, Of("</? <div x=><p |"));
+    }
+
+    [Fact]
+    public void Offsets_outside_the_projection_clamp_into_range()
+    {
+        Assert.Equal(MarkupContext.Content, HtmlMarkupContext.At(string.Empty, 0));
+        Assert.Equal(MarkupContext.Content, HtmlMarkupContext.At(string.Empty, 5));
+        Assert.Equal(MarkupContext.Content, HtmlMarkupContext.At(string.Empty, -1));
+        Assert.Equal(MarkupContext.Content, HtmlMarkupContext.At("<div", -3));
+        Assert.Equal(MarkupContext.TagName, HtmlMarkupContext.At("<div", 99));
+        Assert.Equal(MarkupContext.AttributeValue, HtmlMarkupContext.At("<div a=x", 8));
+    }
+
+    [Fact]
+    public void Every_offset_of_a_document_maps_to_its_context()
+    {
+        const string html = "<div a=\"1\">x</div>";
+        Assert.Equal("CTTTTNNVVVNCCTTTTTC", Map(html));
+    }
+
+    [Theory]
+    [InlineData("<script type='text/javascript'><div|")]
+    [InlineData("<script type=text/javascript><div|")]
+    [InlineData("<script async><div|")]
+    [InlineData("<style media='screen'><div|")]
+    [InlineData("<!-- <div> hello <span| -->")]
+    public void Raw_text_attributes_and_nested_comment_markup_remain_content(string html)
+    {
+        Assert.Equal(MarkupContext.Content, Of(html));
+    }
+
+    [Theory]
+    [InlineData("<!DOCTYPE html PUBLIC \"x> <div|\">", "Content")]
+    [InlineData("<script><!--<script></script><div|--></script>", "Content")]
+    [InlineData("<script><!--<script></script>--></script><div|", "TagName")]
+    [InlineData("<script><!--<script>--></script><div|", "TagName")]
+    [InlineData("<script><!-- x </script><div|", "TagName")]
+    [InlineData("</>|", "Content")]
+    [InlineData("<div / >|", "Content")]
+    [InlineData("<div disabled/>|", "Content")]
+    [InlineData("<div value=>|", "Content")]
+    [InlineData("<div value='x'/>|", "Content")]
+    [InlineData("<style></styleX></style>|", "Content")]
+    [InlineData("<!DOCTYPE html PUBLIC 'unfinished|", "Content")]
+    public void Declaration_quotes_and_script_escape_states_follow_html_tokens(
+        string html,
+        string expected
+    )
+    {
+        Assert.Equal(expected, Of(html).ToString());
+    }
+
+    private static MarkupContext Of(string withCaret)
+    {
+        var at = withCaret.IndexOf('|', StringComparison.Ordinal);
+        return HtmlMarkupContext.At(withCaret.Remove(at, 1), at);
+    }
+
+    private static string Map(string html)
+    {
+        return string.Create(
+            html.Length + 1,
+            html,
+            static (span, text) =>
+            {
+                for (var i = 0; i <= text.Length; i++)
+                {
+                    span[i] = HtmlMarkupContext.At(text, i) switch
+                    {
+                        MarkupContext.Content => 'C',
+                        MarkupContext.TagName => 'T',
+                        MarkupContext.AttributeName => 'N',
+                        MarkupContext.AttributeValue => 'V',
+                        _ => '?',
+                    };
+                }
+            }
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorCSharpFeatureTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorCSharpFeatureTests.cs
new file mode 100644
index 00000000..cc2f66c0
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorCSharpFeatureTests.cs
@@ -0,0 +1,373 @@
+using SharpLsp.Sidecar.Common;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+#pragma warning disable RS1035 // Real-file reads are intentional in this end-to-end suite
+#pragma warning disable IDE0042 // Positions read better as (Line, Character) pairs
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// C# inside Razor, answered from the projection the SDK's Razor generator produces, against
+/// the real fixture solution. Implements [RAZOR-TESTING] for [RAZOR-ARCHITECTURE-PROJECTION],
+/// [RAZOR-FEATURES-HOVER], [RAZOR-FEATURES-DEFINITION], [RAZOR-FEATURES-REFERENCES],
+/// [RAZOR-FEATURES-SIGNATURE-HELP] and [RAZOR-FEATURES-DIAGNOSTICS].
+/// </summary>
+public sealed class RazorCSharpFeatureTests : IClassFixture<RazorFixture>
+{
+    private readonly RazorFixture _fixture;
+
+    public RazorCSharpFeatureTests(RazorFixture fixture)
+    {
+        _fixture = fixture;
+    }
+
+    private static readonly string[] CaptionUses =
+    [
+        "@bind-Label=",
+        "<Badge Text=",
+        "<input @bind=",
+        "private string caption",
+    ];
+
+    private string Board => _fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+
+    [Fact]
+    public async Task Hover_answers_csharp_fragments_with_ranges_in_the_razor_file()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+
+        var caption = RazorFixture.Locate(Board, "<input @bind=", "caption", 2);
+        var hover = RazorFixture.Ok(
+            await manager.GetHoverAsync(Board, caption.Line, caption.Character)
+        );
+        Assert.NotNull(hover);
+        Assert.Contains("caption", hover.Contents, StringComparison.Ordinal);
+        Assert.Contains("string", hover.Contents, StringComparison.Ordinal);
+        Assert.Equal(
+            (caption.Line, caption.Character - 2),
+            (hover.StartLine, hover.StartCharacter)
+        );
+        Assert.Equal(caption.Character - 2 + "caption".Length, hover.EndCharacter);
+
+        var id = RazorFixture.Locate(Board, "<PageTitle>", "@Id", 1);
+        var idHover = RazorFixture.Ok(await manager.GetHoverAsync(Board, id.Line, id.Character));
+        Assert.NotNull(idHover);
+        Assert.Contains("The board's number", idHover.Contents, StringComparison.Ordinal);
+        Assert.Contains("int", idHover.Contents, StringComparison.Ordinal);
+
+        var markup = RazorFixture.Locate(Board, "<button", "disabled");
+        Assert.Null(
+            RazorFixture.Ok(await manager.GetHoverAsync(Board, markup.Line, markup.Character))
+        );
+    }
+
+    [Fact]
+    public async Task Definition_lands_in_razor_files_from_razor_and_from_csharp()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+
+        var call = RazorFixture.Locate(Board, "() => Add(1)", "Add(1)");
+        var definition = RazorFixture.Ok(
+            await manager.GetDefinitionAsync(Board, call.Line, call.Character)
+        );
+        var declared = Assert.Single(definition.Locations);
+        Assert.True(NativePaths.AreEqual(Board, declared.FilePath), declared.FilePath);
+        Assert.Equal(
+            RazorFixture.Locate(Board, "private void Add", "Add"),
+            (declared.Line, declared.Character)
+        );
+        Assert.Equal("Add", TextAt(declared));
+
+        var program = _fixture.Path("BlazorApp", "Program.cs");
+        var app = RazorFixture.Locate(program, "MapRazorComponents<App>", "App>");
+        var component = RazorFixture.Ok(
+            await manager.GetDefinitionAsync(program, app.Line, app.Character)
+        );
+        var file = Assert.Single(component.Locations);
+        Assert.True(
+            NativePaths.AreEqual(
+                _fixture.Path("BlazorApp", "Components", "App.razor"),
+                file.FilePath
+            ),
+            file.FilePath
+        );
+        Assert.Equal((0, 0), (file.Line, file.Character));
+    }
+
+    [Fact]
+    public async Task References_and_highlights_cover_every_razor_use_and_drop_scaffolding()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var field = RazorFixture.Locate(Board, "private string caption", "caption");
+        var expected = CaptionPositions();
+
+        var references = RazorFixture.Ok(
+            await manager.GetReferencesAsync(Board, field.Line, field.Character, true)
+        );
+        Assert.All(references.Locations, location => Assert.Equal("caption", TextAt(location)));
+        Assert.Equal(expected, references.Locations.Select(At).Order());
+
+        var use = expected[1];
+        var highlights = RazorFixture.Ok(
+            await manager.GetDocumentHighlightsAsync(Board, use.Line, use.Character)
+        );
+        Assert.Equal(
+            expected,
+            highlights.Highlights.Select(h => (h.StartLine, h.StartCharacter)).Order()
+        );
+        Assert.All(
+            highlights.Highlights,
+            h => Assert.Equal("caption".Length, h.EndCharacter - h.StartCharacter)
+        );
+    }
+
+    [Fact]
+    public async Task Signature_help_answers_inside_a_razor_call()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var argument = RazorFixture.Locate(Board, "() => Add(1)", "1)");
+
+        var help = RazorFixture.Ok(
+            await manager.GetSignatureHelpAsync(Board, argument.Line, argument.Character)
+        );
+        Assert.NotNull(help);
+        var signature = Assert.Single(help.Signatures);
+        Assert.Contains("Add(int score)", signature.Label, StringComparison.Ordinal);
+        Assert.Equal(0, help.ActiveParameter);
+    }
+
+    [Fact]
+    public async Task Import_files_never_report_their_usings_as_unnecessary()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var imports = _fixture.Path("BlazorApp", "Components", "_Imports.razor");
+        var viewImports = _fixture.Path("PagesApp", "Pages", "_ViewImports.cshtml");
+
+        // An import file's usings serve the files beside and below it, which its own
+        // projection never sees. [RAZOR-FEATURES-DIAGNOSTICS]
+        Assert.DoesNotContain(
+            RazorFixture.Ok(await manager.GetDiagnosticsAsync(imports)),
+            Unnecessary
+        );
+        Assert.DoesNotContain(
+            RazorFixture.Ok(await manager.GetDiagnosticsAsync(viewImports)),
+            Unnecessary
+        );
+        var all = RazorFixture.Ok(await manager.GetAllDiagnosticsAsync([]));
+        Assert.DoesNotContain(
+            all,
+            entry => IsImportFile(entry.Key) && entry.Value.Any(Unnecessary)
+        );
+    }
+
+    [Fact]
+    public async Task Components_never_report_a_using_their_markup_may_need_as_unnecessary()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var original = await File.ReadAllTextAsync(Board);
+        // `<Virtualize>` resolves through the using, while the generated C# names the
+        // component by its full name, so Roslyn alone sees the using as unused.
+        // [RAZOR-FEATURES-DIAGNOSTICS]
+        const string markup =
+            "@using Microsoft.AspNetCore.Components.Web.Virtualization\n"
+            + "@using System.Text\n"
+            + "<Virtualize TItem=\"string\" ItemsProvider=\"null\" />\n";
+        _ = RazorFixture.Ok(await manager.UpdateDocumentTextAsync(Board, markup + original));
+
+        var diagnostics = RazorFixture.Ok(await manager.GetDiagnosticsAsync(Board));
+        Assert.DoesNotContain(diagnostics, Unnecessary);
+        Assert.DoesNotContain(diagnostics, diagnostic => diagnostic.Severity == "Error");
+        var all = RazorFixture.Ok(await manager.GetAllDiagnosticsAsync([]));
+        Assert.DoesNotContain(
+            all,
+            entry => NativePaths.AreEqual(entry.Key, Board) && entry.Value.Any(Unnecessary)
+        );
+        // The tag binds through that using, so removing it would unbind the component.
+        var facts = await manager.FindRazorMarkupAsync(Board, default);
+        Assert.NotNull(facts);
+        var virtualize = Assert.Single(facts.Tags, tag => tag.Name == "Virtualize");
+        Assert.Equal(
+            "Microsoft.AspNetCore.Components.Web.Virtualization",
+            virtualize.Component?.TypeNamespace
+        );
+
+        // A C# file, code-behind included, still reports an unused using.
+        var badge = _fixture.Path("BlazorApp", "Components", "Shared", "Badge.razor.cs");
+        var code = await File.ReadAllTextAsync(badge);
+        _ = RazorFixture.Ok(
+            await manager.UpdateDocumentTextAsync(badge, "using System.Text;\n" + code)
+        );
+        var unused = Assert.Single(
+            RazorFixture.Ok(await manager.GetDiagnosticsAsync(badge)),
+            Unnecessary
+        );
+        Assert.Equal((0, 0), (unused.StartLine, unused.StartCharacter));
+    }
+
+    private static bool Unnecessary(DiagnosticResult diagnostic)
+    {
+        return diagnostic.Code is "CS8019" or "IDE0005";
+    }
+
+    private static bool IsImportFile(string path)
+    {
+        return NativePaths.SameName(path, "_Imports.razor")
+            || NativePaths.SameName(path, "_ViewImports.cshtml");
+    }
+
+    [Fact]
+    public async Task Diagnostics_map_csharp_errors_into_the_razor_file_and_the_solution_scan()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        Assert.DoesNotContain(
+            RazorFixture.Ok(await manager.GetDiagnosticsAsync(Board)),
+            diagnostic => diagnostic.Severity == "Error"
+        );
+
+        var original = await File.ReadAllTextAsync(Board);
+        var broken = original.Replace("score + Id)", "score + Idd)", StringComparison.Ordinal);
+        _ = RazorFixture.Ok(await manager.UpdateDocumentTextAsync(Board, broken));
+
+        var error = Assert.Single(
+            RazorFixture.Ok(await manager.GetDiagnosticsAsync(Board)),
+            d => d.Code == "CS0103"
+        );
+        Assert.True(NativePaths.AreEqual(Board, error.FilePath), error.FilePath);
+        Assert.Equal(
+            RazorFixture.Locate(Board, "private void Add", "Id)"),
+            (error.StartLine, error.StartCharacter)
+        );
+        Assert.Equal(error.StartCharacter + "Idd".Length, error.EndCharacter);
+
+        var all = RazorFixture.Ok(await manager.GetAllDiagnosticsAsync([]));
+        var key = Assert.Single(all.Keys, path => NativePaths.AreEqual(path, Board));
+        Assert.Contains(all[key], d => d.Code == "CS0103" && d.StartLine == error.StartLine);
+        Assert.DoesNotContain(all.Keys, path => NativePaths.HasExtension(path, ".g.cs"));
+    }
+
+    [Fact]
+    public async Task Completion_in_an_expression_offers_members_with_edits_in_the_razor_file()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var counter = _fixture.Path("BlazorApp", "Components", "Pages", "Counter.razor");
+        var typed = RazorFixture.Locate(counter, "Current count:", "currentCount", 4);
+
+        var items = RazorFixture.Ok(
+            await manager.GetCompletionsAsync(counter, typed.Line, typed.Character)
+        );
+        var field = Assert.Single(items, item => item.Label == "currentCount");
+        Assert.NotNull(field.TextEdit);
+        Assert.Equal(
+            (typed.Line, typed.Character - 4),
+            (field.TextEdit.StartLine, field.TextEdit.StartCharacter)
+        );
+        Assert.Equal(typed.Character - 4 + "currentCount".Length, field.TextEdit.EndCharacter);
+        Assert.Contains(items, item => item.Label == "IncrementCount");
+        Assert.All(items, item => Assert.Equal(typed.Line, item.TextEdit?.StartLine ?? typed.Line));
+    }
+
+    [Fact]
+    public async Task Rename_of_a_code_block_field_edits_every_razor_use_and_prepares_its_range()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var use = RazorFixture.Locate(Board, "<Badge Text=", "caption");
+
+        var prepared = RazorFixture.Ok(
+            await manager.PrepareRenameAsync(Board, use.Line, use.Character)
+        );
+        Assert.True(prepared.CanRename);
+        Assert.Equal("caption", prepared.Placeholder);
+        Assert.Equal(
+            (use.Line, use.Character, use.Character + 7),
+            (prepared.StartLine, prepared.StartCharacter, prepared.EndCharacter)
+        );
+
+        var edit = RazorFixture.Ok(
+            await manager.RenameAsync(Board, use.Line, use.Character, "heading")
+        );
+        var document = Assert.Single(edit.DocumentChanges);
+        Assert.True(NativePaths.AreEqual(Board, document.FilePath), document.FilePath);
+        Assert.Equal(4, document.Edits.Count);
+        Assert.All(document.Edits, e => Assert.Equal("heading", e.NewText));
+        Assert.Equal(
+            CaptionPositions(),
+            document.Edits.Select(e => (e.StartLine, e.StartCharacter))
+        );
+
+        var markup = RazorFixture.Locate(Board, "<button", "disabled");
+        Assert.False(
+            RazorFixture
+                .Ok(await manager.PrepareRenameAsync(Board, markup.Line, markup.Character))
+                .CanRename
+        );
+    }
+
+    [Fact]
+    public async Task Semantic_tokens_classify_csharp_fragments_at_their_razor_positions()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var tokens = Decode(RazorFixture.Ok(await manager.GetSemanticTokensFullAsync(Board)).Data);
+
+        Assert.Contains(
+            tokens,
+            t => t == (RazorFixture.Locate(Board, "private readonly List", "private"), 7, 15)
+        );
+        Assert.Contains(
+            tokens,
+            t => t == (RazorFixture.Locate(Board, "private readonly List", "List"), 4, 2)
+        );
+        Assert.Contains(
+            tokens,
+            t => t == (RazorFixture.Locate(Board, "private void Add", "Add"), 3, 13)
+        );
+        Assert.Contains(tokens, t => t == (RazorFixture.Locate(Board, "<PageTitle>", "Id"), 2, 9));
+        Assert.DoesNotContain(
+            tokens,
+            t => t.At.Line == RazorFixture.Locate(Board, "</Panel>", "Panel").Line
+        );
+
+        var code = RazorFixture.Locate(Board, "private void Add", "private");
+        var range = Decode(
+            RazorFixture
+                .Ok(
+                    await manager.GetSemanticTokensRangeAsync(Board, code.Line, 0, code.Line + 1, 0)
+                )
+                .Data
+        );
+        Assert.NotEmpty(range);
+        Assert.All(range, t => Assert.Equal(code.Line, t.At.Line));
+    }
+
+    /// <summary>LSP semantic token data as absolute (position, length, type) triples.</summary>
+    private static List<((int Line, int Character) At, int Length, int Type)> Decode(int[] data)
+    {
+        var tokens = new List<((int, int), int, int)>();
+        var (line, character) = (0, 0);
+        for (var i = 0; i + 4 < data.Length; i += 5)
+        {
+            line += data[i];
+            character = data[i] == 0 ? character + data[i + 1] : data[i + 1];
+            tokens.Add(((line, character), data[i + 2], data[i + 3]));
+        }
+
+        return tokens;
+    }
+
+    /// <summary>Every place Board.razor names its <c>caption</c> field, in file order.</summary>
+    private (int Line, int Character)[] CaptionPositions()
+    {
+        return [.. CaptionUses.Select(anchor => RazorFixture.Locate(Board, anchor, "caption"))];
+    }
+
+    private static string TextAt(LocationResult location)
+    {
+        var line = File.ReadAllLines(location.FilePath)[location.Line];
+        return line[location.Character..location.EndCharacter];
+    }
+
+    private static (int Line, int Character) At(LocationResult location)
+    {
+        return (location.Line, location.Character);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorCompletionEditsTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorCompletionEditsTests.cs
new file mode 100644
index 00000000..8205b4ce
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorCompletionEditsTests.cs
@@ -0,0 +1,112 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.CSharp.Razor;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>Additional edits through real SDK projections; [RAZOR-ARCHITECTURE-PROJECTION], [RAZOR-FEATURES-COMPLETION], [RAZOR-TESTING].</summary>
+public sealed class RazorCompletionEditsTests(RazorFixture fixture) : IClassFixture<RazorFixture>
+{
+    private string Board => fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+
+    [Fact]
+    public async Task Additional_csharp_edits_map_back_to_the_original_fragment()
+    {
+        using var manager = await fixture.OpenManagerAsync().ConfigureAwait(true);
+        var projection = await manager
+            .FindRazorProjectionAsync(Board, default)
+            .ConfigureAwait(true);
+        Assert.NotNull(projection);
+        var declaration = projection
+            .GeneratedRoot.DescendantNodes()
+            .OfType<VariableDeclaratorSyntax>()
+            .Single(node => node.Identifier.ValueText == "caption");
+        var edit = Assert.Single(
+            RazorCompletionEdits.Map(
+                projection,
+                [new TextChange(declaration.Identifier.Span, "changed")]
+            )
+        );
+        var (expectedLine, expectedCharacter) = RazorFixture.Locate(
+            Board,
+            "private string caption",
+            "caption"
+        );
+        Assert.Equal("changed", edit.NewText);
+        Assert.Equal(
+            (expectedLine, expectedCharacter, expectedLine, expectedCharacter + 7),
+            (edit.StartLine, edit.StartCharacter, edit.EndLine, edit.EndCharacter)
+        );
+    }
+
+    [Fact]
+    public async Task Imports_keep_spelling_and_crlf_after_own_imports_without_duplicates()
+    {
+        using var manager = await fixture.OpenManagerAsync().ConfigureAwait(true);
+        const string text =
+            "@using System.Text\r\n@using static System.Math\r\n@using Alias = System.String\r\n<p>body</p>\r\n";
+        _ = RazorFixture.Ok(
+            await manager.UpdateDocumentTextAsync(Board, text).ConfigureAwait(true)
+        );
+        var projection = await manager
+            .FindRazorProjectionAsync(Board, default)
+            .ConfigureAwait(true);
+        Assert.NotNull(projection);
+        const string added =
+            "using System.Text; using System.Linq; using System.Linq; using static System.Math; using Alias = System.String; using NewAlias = System.Uri; using static System.Console;";
+        var edits = RazorCompletionEdits
+            .Map(projection, [new TextChange(new TextSpan(0, 0), added)])
+            .ToArray();
+        Assert.Equal(
+            [
+                "@using System.Linq\r\n",
+                "@using NewAlias = System.Uri\r\n",
+                "@using static System.Console\r\n",
+            ],
+            edits.Select(edit => edit.NewText)
+        );
+        Assert.All(
+            edits,
+            edit =>
+                Assert.Equal(
+                    (3, 0, 3, 0),
+                    (edit.StartLine, edit.StartCharacter, edit.EndLine, edit.EndCharacter)
+                )
+        );
+        Assert.Equal(3, edits.Length);
+    }
+
+    [Fact]
+    public async Task Non_using_generated_edits_are_dropped_and_new_imports_use_lf_fallback()
+    {
+        using var manager = await fixture.OpenManagerAsync().ConfigureAwait(true);
+        _ = RazorFixture.Ok(
+            await manager.UpdateDocumentTextAsync(Board, "<p>body</p>").ConfigureAwait(true)
+        );
+        var projection = await manager
+            .FindRazorProjectionAsync(Board, default)
+            .ConfigureAwait(true);
+        Assert.NotNull(projection);
+        var invalid = new[] { "class Extra {}", "[assembly: System.Obsolete]", "using ;", "" };
+        Assert.All(
+            invalid,
+            text =>
+                Assert.Empty(
+                    RazorCompletionEdits.Map(projection, [new TextChange(new TextSpan(0, 0), text)])
+                )
+        );
+        var edit = Assert.Single(
+            RazorCompletionEdits.Map(
+                projection,
+                [new TextChange(new TextSpan(0, 0), "using System.Text;")]
+            )
+        );
+        Assert.Equal("@using System.Text\n", edit.NewText);
+        Assert.Equal(
+            (0, 0, 0, 0),
+            (edit.StartLine, edit.StartCharacter, edit.EndLine, edit.EndCharacter)
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorEngineSettingsTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorEngineSettingsTests.cs
new file mode 100644
index 00000000..915b73c0
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorEngineSettingsTests.cs
@@ -0,0 +1,209 @@
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Razor;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>Configuration and failure contracts for [RAZOR-ARCHITECTURE-ENGINE] and [RAZOR-ERRORS].</summary>
+public sealed class RazorEngineSettingsTests : IDisposable
+{
+    private readonly AdhocWorkspace _workspace = new();
+    private static string Board => AdhocRazorProject.PathOf("Board.razor");
+
+    private static (string Path, string Text)[] Files =>
+        [
+            (Board, "<p>current</p>"),
+            (AdhocRazorProject.PathOf("_Imports.razor"), "@using System"),
+            (AdhocRazorProject.PathOf("Other.razor"), "<b>other</b>"),
+        ];
+
+    [Fact]
+    public void Missing_and_invalid_properties_fall_back_to_project_and_parse_settings()
+    {
+        var project = Create("build_property.RazorLangVersion = bad")
+            .WithDefaultNamespace("Fallback")
+            .WithParseOptions(
+                new CSharpParseOptions(LanguageVersion.CSharp13).WithPreprocessorSymbols("FEATURE")
+            );
+        var settings = RazorEngineSettings.Read(project);
+        Assert.Equal("Fallback", settings.RootNamespace);
+        Assert.Equal(RazorLanguageVersion.Latest, settings.Configuration.LanguageVersion);
+        Assert.Equal(LanguageVersion.CSharp13, settings.Configuration.CSharpLanguageVersion);
+        Assert.Contains("FEATURE", settings.Configuration.PreprocessorSymbols);
+        Assert.False(settings.LocalizedComponentNames);
+    }
+
+    [Fact]
+    public void Explicit_build_properties_override_project_defaults()
+    {
+        var project = Create(
+            "build_property.RootNamespace = Configured\nbuild_property.RazorLangVersion = 8.0\nbuild_property.SupportLocalizedComponentNames = TRUE"
+        );
+        var settings = RazorEngineSettings.Read(project);
+        Assert.Equal("Configured", settings.RootNamespace);
+        Assert.Equal(RazorLanguageVersion.Version_8_0, settings.Configuration.LanguageVersion);
+        Assert.True(settings.LocalizedComponentNames);
+    }
+
+    [Theory]
+    [InlineData(null, "/Board.razor")]
+    [InlineData("not-base64!", "/Board.razor")]
+    [InlineData("TGlua2VkL0JvYXJkLnJhem9y", "/Linked/Board.razor")]
+    public void Target_path_metadata_decodes_or_falls_back_to_the_document(
+        string? encoded,
+        string expected
+    )
+    {
+        var config = encoded is null ? "" : TargetConfig(encoded);
+        var project = Create(config);
+        var document = AdhocRazorProject.Additional(project, Board);
+        Assert.Equal(expected, RazorEngineSettings.Read(project).RazorPathOf(document));
+        Assert.Equal(Board, document.FilePath);
+        Assert.Equal(
+            AdhocRazorProject.Directory,
+            RazorEngineSettings.Read(project).ProjectDirectory
+        );
+    }
+
+    [Fact]
+    public async Task File_system_reads_current_target_and_imports()
+    {
+        var project = AdhocRazorProject.Create(_workspace, Files);
+        var system = await FileSystemAsync(project).ConfigureAwait(true);
+        Assert.Equal(2, system.EnumerateItems("/").Count());
+        var item = system.GetItem("/Board.razor", null);
+        Assert.Equal("/", item.BasePath);
+        Assert.Equal(Board, item.PhysicalPath);
+        Assert.True(item.Exists);
+        using var reader = new StreamReader(item.Read());
+        Assert.Equal("<p>current</p>", await reader.ReadToEndAsync().ConfigureAwait(true));
+    }
+
+    [Fact]
+    public async Task File_system_represents_missing_files_without_inventing_contents()
+    {
+        var system = await FileSystemAsync(Create()).ConfigureAwait(true);
+        var missing = system.GetItem("/Missing.razor", null);
+        Assert.False(missing.Exists);
+        Assert.Equal("/Missing.razor", missing.FilePath);
+        Assert.Equal("/", missing.BasePath);
+        using var absent = new StreamReader(missing.Read());
+        Assert.Equal("", await absent.ReadToEndAsync().ConfigureAwait(true));
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task Engine_rejects_unlocated_projects_and_documents(bool missingProject)
+    {
+        var project = Create();
+        var target = Unlocated(project, missingProject);
+        Assert.Null(await RazorMarkupEngine.ProcessAsync(target, default).ConfigureAwait(true));
+        var valid = await ProcessAsync(project).ConfigureAwait(true);
+        Assert.NotNull(valid);
+        Assert.Equal("<p>hello</p>", valid.HtmlText);
+    }
+
+    [Fact]
+    public async Task Engine_propagates_cancellation()
+    {
+        var project = Create();
+        var target = AdhocRazorProject.Additional(project, Board);
+        _ = await Assert
+            .ThrowsAnyAsync<OperationCanceledException>(() =>
+                RazorMarkupEngine.ProcessAsync(target, new CancellationToken(canceled: true))
+            )
+            .ConfigureAwait(true);
+        Assert.Equal("<p>hello</p>", (await target.GetTextAsync().ConfigureAwait(true)).ToString());
+        Assert.NotNull(await ProcessAsync(project).ConfigureAwait(true));
+    }
+
+    [Fact]
+    public async Task Unreadable_workspace_text_is_contained_and_does_not_poison_later_requests()
+    {
+        var project = Create();
+        var document = AdhocRazorProject.Additional(project, Board);
+        var failed = project
+            .Solution.WithAdditionalDocumentTextLoader(
+                document.Id,
+                new UnavailableTextLoader(),
+                PreservationMode.PreserveIdentity
+            )
+            .GetProject(project.Id)!;
+        Assert.Null(await ProcessAsync(failed).ConfigureAwait(true));
+        Assert.Null(await ProcessAsync(failed).ConfigureAwait(true));
+        var recovered = AdhocRazorProject.Create(_workspace, [(Board, "<p>recovered</p>")]);
+        var markup = await ProcessAsync(recovered).ConfigureAwait(true);
+        Assert.NotNull(markup);
+        Assert.Equal("<p>recovered</p>", markup.HtmlText);
+    }
+
+    private static string TargetConfig(string encoded)
+    {
+        return $"[{NativePaths.Slashed(Board)}]\nbuild_metadata.AdditionalFiles.TargetPath = {encoded}";
+    }
+
+    private static TextDocument Unlocated(Project project, bool missingProject)
+    {
+        return missingProject
+            ? AdhocRazorProject.Additional(
+                project.Solution.WithProjectFilePath(project.Id, null).GetProject(project.Id)!,
+                Board
+            )
+            : project.AddAdditionalDocument("Untitled.razor", SourceText.From("<p>hello</p>"));
+    }
+
+    [Fact]
+    public void Absent_namespace_and_language_options_use_assembly_name_and_latest_language()
+    {
+        var settings = RazorEngineSettings.Read(Create());
+        Assert.Equal("App", settings.RootNamespace);
+        Assert.Equal(RazorLanguageVersion.Latest, settings.Configuration.LanguageVersion);
+        Assert.False(settings.LocalizedComponentNames);
+    }
+
+    private Project Create(string config = "")
+    {
+        return AdhocRazorProject.Create(_workspace, [(Board, "<p>hello</p>")], config);
+    }
+
+    private static Task<RazorMarkup?> ProcessAsync(Project project)
+    {
+        return RazorMarkupEngine.ProcessAsync(
+            AdhocRazorProject.Additional(project, Board),
+            default
+        );
+    }
+
+    private static Task<WorkspaceRazorFileSystem> FileSystemAsync(Project project)
+    {
+        return WorkspaceRazorFileSystem.CreateAsync(
+            AdhocRazorProject.Additional(project, Board),
+            RazorEngineSettings.Read(project),
+            default
+        );
+    }
+
+    public void Dispose()
+    {
+        _workspace.Dispose();
+    }
+
+    private sealed class UnavailableTextLoader : TextLoader
+    {
+        public override Task<TextAndVersion> LoadTextAndVersionAsync(
+            LoadTextOptions options,
+            CancellationToken cancellationToken = default
+        )
+        {
+            return Task.FromException<TextAndVersion>(
+                new InvalidOperationException("Input unavailable")
+            );
+        }
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorFixture.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorFixture.cs
new file mode 100644
index 00000000..8481ae5f
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorFixture.cs
@@ -0,0 +1,124 @@
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Workspace;
+
+#pragma warning disable CA1515 // Public xUnit fixture type
+#pragma warning disable RS1035 // Real-process/temp-path use is intentional: the fixture is built for real
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+#pragma warning disable IDE0058 // Directory.CreateDirectory's result is not needed
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// A built copy of the Razor fixture solution ([RAZOR-TESTING]): BlazorApp, the Widgets
+/// Razor class library, PagesApp and the F# Domain library. Copied to a temp directory so
+/// tests can edit it, and built so the F# DLL that BlazorApp references exists.
+/// </summary>
+public sealed class RazorFixture : IDisposable
+{
+    private readonly string _root = NativePaths.Temp($"sharplsp-razor-{Guid.NewGuid():N}");
+
+    public RazorFixture()
+    {
+        CopyTree(FindRepositoryFixture(), _root);
+        SolutionPath = Path("RazorFixtures.slnx");
+        var (exitCode, output) = DotnetBuild.Run(SolutionPath);
+        Assert.True(exitCode == 0, $"Razor fixture build failed ({exitCode}):{output}");
+    }
+
+    /// <summary>The fixture's solution file.</summary>
+    public string SolutionPath { get; }
+
+    /// <summary>A fixture file by its path relative to the solution directory.</summary>
+    public string Path(params string[] relative)
+    {
+        return NativePaths.Join([_root, .. relative]);
+    }
+
+    /// <summary>A workspace manager with the fixture solution loaded.</summary>
+    internal async Task<WorkspaceManager> OpenManagerAsync()
+    {
+        var manager = new WorkspaceManager();
+#pragma warning disable CS0618 // OpenAsync remains the real workspace-loading boundary
+        var open = await manager.OpenAsync(SolutionPath);
+#pragma warning restore CS0618
+        Assert.False(open.IsError, open.Match(_ => "ok", error => error));
+        return manager;
+    }
+
+    /// <summary>
+    /// The position of <paramref name="token"/> on the first line of <paramref name="file"/>
+    /// holding <paramref name="anchor"/>, plus <paramref name="offset"/> characters.
+    /// </summary>
+    public static (int Line, int Character) Locate(
+        string file,
+        string anchor,
+        string token,
+        int offset = 0
+    )
+    {
+        var lines = File.ReadAllLines(file);
+        var line = Array.FindIndex(lines, text => text.Contains(anchor, StringComparison.Ordinal));
+        Assert.True(line >= 0, $"missing line anchor {anchor}");
+        var character = lines[line].IndexOf(token, StringComparison.Ordinal);
+        Assert.True(character >= 0, $"missing token {token}");
+        return (line, character + offset);
+    }
+
+    /// <summary>The value of a successful result; a failure fails the test with its message.</summary>
+    public static T Ok<T>(Outcome.Result<T, string> result)
+    {
+        return result.Match(value => value, error => throw new Xunit.Sdk.XunitException(error));
+    }
+
+    public void Dispose()
+    {
+        try
+        {
+            Directory.Delete(_root, true);
+        }
+        catch (IOException) { }
+    }
+
+    private static void CopyTree(string source, string destination)
+    {
+        foreach (var file in Directory.EnumerateFiles(source, "*", SearchOption.AllDirectories))
+        {
+            var relative = NativePaths.RelativeTo(source, file);
+            if (
+                NativePaths.HasDirectory(relative, "bin")
+                || NativePaths.HasDirectory(relative, "obj")
+            )
+            {
+                continue;
+            }
+
+            var target = NativePaths.Join(destination, relative);
+            Directory.CreateDirectory(NativePaths.DirectoryOf(target));
+            File.Copy(file, target);
+        }
+    }
+
+    private static string FindRepositoryFixture()
+    {
+        var directory = new DirectoryInfo(AppContext.BaseDirectory);
+        while (directory is not null)
+        {
+            var candidate = NativePaths.Join(
+                directory.FullName,
+                "src",
+                "sharplsp",
+                "tests",
+                "fixtures",
+                "razor"
+            );
+            if (File.Exists(NativePaths.Join(candidate, "RazorFixtures.slnx")))
+            {
+                return candidate;
+            }
+
+            directory = directory.Parent;
+        }
+
+        throw new DirectoryNotFoundException("The Razor fixture solution was not found");
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorHtmlProjectionTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorHtmlProjectionTests.cs
new file mode 100644
index 00000000..5024ee75
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorHtmlProjectionTests.cs
@@ -0,0 +1,159 @@
+using SharpLsp.Sidecar.CSharp.Razor;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>Real workspace coverage of [RAZOR-ARCHITECTURE-HTML] and [RAZOR-TESTING].</summary>
+public sealed class RazorHtmlProjectionTests(RazorFixture fixture) : IClassFixture<RazorFixture>
+{
+    [Fact]
+    public async Task Source_less_directive_names_have_no_invented_span()
+    {
+        using var manager = await fixture.OpenManagerAsync();
+        var path = fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+        var markup = await manager.FindRazorMarkupAsync(path, default);
+        Assert.NotNull(markup);
+        var click = Assert.Single(markup.Attributes, attribute => attribute.Name == "@onclick");
+        Assert.Null(RazorIr.DirectiveName(null, click.Name, markup.Text));
+        _ = Assert.NotNull(click.NameSpan);
+        Assert.Equal(click.Name, markup.Text.ToString(click.NameSpan.Value));
+    }
+
+    [Theory]
+    [InlineData("BlazorApp", "Components", "Pages", "Board.razor")]
+    [InlineData("PagesApp", "Views", "Home", "Index.cshtml")]
+    public async Task Projection_preserves_html_and_masks_razor_in_current_workspace_text(
+        string project,
+        string folder,
+        string subfolder,
+        string file
+    )
+    {
+        using var manager = await fixture.OpenManagerAsync();
+        var path = fixture.Path(project, folder, subfolder, file);
+        const string text =
+            "@using System\r\n@* hidden <fake> *@\r\n<div title=\"hello @DateTime.Now!\">@(1 + 2)<b>ok</b></div>\r\n@{ var number = 4; <p>@number</p> }";
+        _ = await manager.UpdateDocumentTextAsync(path, text);
+        var markup = await manager.FindRazorMarkupAsync(path, default);
+        Assert.NotNull(markup);
+        AssertMask(markup.HtmlText);
+        AssertOffsets(text, markup.HtmlText);
+        Assert.Equal(
+            MarkupContext.TagName,
+            markup.ContextAt(text.IndexOf("<div", StringComparison.Ordinal) + 2)
+        );
+        Assert.Equal(
+            MarkupContext.AttributeValue,
+            markup.ContextAt(text.IndexOf("hello", StringComparison.Ordinal) + 1)
+        );
+    }
+
+    private static void AssertMask(string html)
+    {
+        Assert.Contains("<div title=\"hello              !\">", html, StringComparison.Ordinal);
+        Assert.Contains("<b>ok</b></div>", html, StringComparison.Ordinal);
+        Assert.Contains("<p>       </p>", html, StringComparison.Ordinal);
+        Assert.DoesNotContain("fake", html, StringComparison.Ordinal);
+        Assert.DoesNotContain("using", html, StringComparison.Ordinal);
+    }
+
+    private static void AssertOffsets(string original, string html)
+    {
+        Assert.Equal(original.Length, html.Length);
+        Assert.All(
+            Enumerable.Range(0, original.Length).Where(i => original[i] is '\r' or '\n'),
+            i => Assert.Equal(original[i], html[i])
+        );
+    }
+
+    [Theory]
+    [InlineData("<p>😀 @DateTime.Now</p>", "<p>😀              </p>")]
+    [InlineData("<p>@@hello</p>", "<p> @hello</p>")]
+    [InlineData(
+        "<div title='@((1 > 0) ? \"yes\" : \"no\")'>ok</div>",
+        "<div title='                         '>ok</div>"
+    )]
+    [InlineData(
+        "<div><!-- static comment --><br /></div>",
+        "<div><!-- static comment --><br /></div>"
+    )]
+    [InlineData("<input disabled>", "<input disabled>")]
+    [InlineData("<div>ok</div >", "<div>ok</div >")]
+    [InlineData("<div>ok</DIV>", "<div>ok</DIV>")]
+    [InlineData("<div title", "<div title")]
+    [InlineData("<di", "<di")]
+    [InlineData("<div title='x", "<div title='x")]
+    [InlineData("<!-- @DateTime.Now -->", "<!-- @DateTime.Now -->")]
+    [InlineData("<!-- unfinished", "<!-- unfinished")]
+    [InlineData("@* <!-- hidden --> *@<!-- keep -->", "                     <!-- keep -->")]
+    public async Task Projection_query_preserves_html_and_utf16_offsets(
+        string text,
+        string expected
+    )
+    {
+        using var manager = await fixture.OpenManagerAsync();
+        var path = fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+        _ = RazorFixture.Ok(await manager.UpdateDocumentTextAsync(path, text));
+        var projection = RazorFixture.Ok(await manager.GetRazorHtmlProjectionAsync(path, default));
+        Assert.NotNull(projection);
+        Assert.Equal(text.Length, projection.Text.Length);
+        Assert.Equal(expected, projection.Text);
+    }
+
+    [Theory]
+    [InlineData("@code { string Hidden = \"<!-- hidden -->\"; }<!-- keep -->")]
+    [InlineData("@{ string hidden = \"<!-- hidden -->\"; }<!-- keep -->")]
+    public async Task Html_comments_inside_csharp_strings_stay_masked(string text)
+    {
+        using var manager = await fixture.OpenManagerAsync();
+        var path = fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+        _ = RazorFixture.Ok(await manager.UpdateDocumentTextAsync(path, text));
+        var projection = RazorFixture.Ok(await manager.GetRazorHtmlProjectionAsync(path, default));
+        Assert.NotNull(projection);
+        Assert.Equal(text.Length, projection.Text.Length);
+        Assert.DoesNotContain("hidden", projection.Text, StringComparison.Ordinal);
+        Assert.EndsWith("<!-- keep -->", projection.Text, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task Projection_query_returns_null_for_unlisted_and_non_razor_documents()
+    {
+        using var manager = await fixture.OpenManagerAsync();
+        foreach (
+            var path in new[]
+            {
+                fixture.Path("Absent.razor"),
+                fixture.Path("BlazorApp", "Program.cs"),
+            }
+        )
+        {
+            var projection = RazorFixture.Ok(
+                await manager.GetRazorHtmlProjectionAsync(path, default)
+            );
+            Assert.Null(projection);
+            Assert.Null(await manager.FindRazorMarkupAsync(path, default));
+        }
+    }
+
+    [Fact]
+    public async Task Projection_retains_component_tags_and_reacts_to_unsaved_edits()
+    {
+        using var manager = await fixture.OpenManagerAsync();
+        var path = fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+        var before = await manager.FindRazorMarkupAsync(path, default);
+        Assert.NotNull(before);
+        Assert.Contains("<Panel", before.HtmlText, StringComparison.Ordinal);
+        Assert.Contains("</Panel>", before.HtmlText, StringComparison.Ordinal);
+        Assert.DoesNotContain("@code", before.HtmlText, StringComparison.Ordinal);
+        _ = await manager.UpdateDocumentTextAsync(
+            path,
+            "<article data-test='changed'>@DateTime.Now</article>"
+        );
+        var after = await manager.FindRazorMarkupAsync(path, default);
+        Assert.NotNull(after);
+        Assert.Equal("<article data-test='changed'>             </article>", after.HtmlText);
+        Assert.DoesNotContain("Panel", after.HtmlText, StringComparison.Ordinal);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorLocationsTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorLocationsTests.cs
new file mode 100644
index 00000000..15112f77
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorLocationsTests.cs
@@ -0,0 +1,43 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Razor;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// A location outside the workspace's documents, such as decompiled source, is looked up as
+/// a Razor projection only in projects that list a Razor file, so navigating from a solution
+/// without Razor never compiles a project to run its generators. Implements [RAZOR-TESTING]
+/// for [RAZOR-ARCHITECTURE-PROJECTION].
+/// </summary>
+public sealed class RazorLocationsTests
+{
+    [Fact]
+    public async Task A_solution_without_razor_files_compiles_nothing_to_find_a_projection()
+    {
+        using var workspace = new AdhocWorkspace();
+        // Every SDK project carries source generators, and running them means compiling.
+        var solution = workspace
+            .CurrentSolution.AddProject("Plain", "Plain", LanguageNames.CSharp)
+            .AddAnalyzerReference(new GeneratorReference(new FixedSources([])))
+            .AddDocument("Program.cs", SourceText.From("class Program { }"))
+            .Project.Solution;
+
+        var projection = await RazorLocations.FindProjectionAsync(
+            solution,
+            NativePaths.Temp("Console.cs"),
+            default
+        );
+
+        Assert.Null(projection);
+        var project = Assert.Single(solution.Projects);
+        Assert.False(
+            project.TryGetCompilation(out _),
+            "no project compiles just to look for a Razor projection"
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorMarkupEngineTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorMarkupEngineTests.cs
new file mode 100644
index 00000000..e2be21c7
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorMarkupEngineTests.cs
@@ -0,0 +1,181 @@
+using Microsoft.AspNetCore.Razor.Language;
+using SharpLsp.Sidecar.CSharp.Razor;
+using SharpLsp.Sidecar.CSharp.Workspace;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+#pragma warning disable IDE0042 // Positions read better as (Line, Character) pairs
+#pragma warning disable RS1035 // Real-file reads are intentional in this end-to-end suite
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// The bundled engine's markup facts for the fixture's real files. Implements [RAZOR-TESTING]
+/// for [RAZOR-ARCHITECTURE-ENGINE].
+/// </summary>
+public sealed class RazorMarkupEngineTests : IClassFixture<RazorFixture>
+{
+    private readonly RazorFixture _fixture;
+
+    public RazorMarkupEngineTests(RazorFixture fixture)
+    {
+        _fixture = fixture;
+    }
+
+    private string Board => _fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+
+    [Fact]
+    public async Task Components_from_the_app_and_its_class_library_bind_with_name_spans()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var markup = await manager.FindRazorMarkupAsync(Board, default);
+        Assert.NotNull(markup);
+        Assert.Equal(RazorFileKind.Component, markup.FileKind);
+        Assert.Equal("BlazorApp.Components.Pages", markup.Namespace);
+        Assert.Contains("BlazorApp.Components.Shared", markup.ImportedNamespaces);
+        Assert.Contains("Widgets", markup.ImportedNamespaces);
+
+        var panel = Assert.Single(markup.Tags, tag => tag.Name == "Panel");
+        Assert.Equal("Widgets.Panel", panel.Component?.TypeName);
+        Assert.Equal("Panel", Slice(markup, panel.StartName));
+        Assert.Equal("Panel", Slice(markup, panel.EndName!.Value));
+        Assert.Equal(
+            RazorFixture.Locate(Board, "</Panel>", "Panel").Line,
+            Line(markup, panel.EndName.Value)
+        );
+
+        var tally = Assert.Single(markup.Tags, tag => tag.Name == "Tally");
+        Assert.Equal("BlazorApp.Components.Shared.Tally<TItem>", tally.Component?.TypeName);
+        var badge = Assert.Single(markup.Tags, tag => tag.Name == "Badge");
+        Assert.Null(badge.EndName);
+        Assert.Equal("Badge", Slice(markup, badge.StartName));
+    }
+
+    [Fact]
+    public async Task Attributes_directives_and_their_parameters_carry_their_descriptors()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var markup = await manager.FindRazorMarkupAsync(Board, default);
+        Assert.NotNull(markup);
+
+        var title = Assert.Single(markup.Attributes, a => a.Name == "Title");
+        Assert.Equal(MarkupAttributeKind.Property, title.Kind);
+        Assert.Equal("Title", title.Bound?.PropertyName);
+        Assert.Equal("Title", Slice(markup, title.NameSpan!.Value));
+
+        var bind = Assert.Single(
+            markup.Attributes,
+            a =>
+                a.Name == "@bind-Label"
+                && a.TagHelper?.Kind == TagHelperKind.Bind
+                && a.Owner.Name == "Tally"
+                && a.TagHelper.Name != "Bind"
+        );
+        Assert.Equal("@bind-Label", Slice(markup, bind.NameSpan!.Value));
+
+        var parameter = Assert.Single(
+            markup.Attributes,
+            a => a.Kind == MarkupAttributeKind.DirectiveParameter
+        );
+        Assert.Equal("@bind:event", parameter.Name);
+        Assert.Equal("event", parameter.Parameter?.Name);
+        Assert.Equal("input", parameter.Owner.Name);
+
+        var click = Assert.Single(markup.Attributes, a => a.Name == "@onclick");
+        Assert.Equal(TagHelperKind.EventHandler, click.TagHelper?.Kind);
+        Assert.Equal("@onclick", Slice(markup, click.NameSpan!.Value));
+        Assert.Contains(
+            markup.Attributes,
+            a => a.Name == "disabled" && a.Kind == MarkupAttributeKind.Html
+        );
+    }
+
+    [Fact]
+    public async Task Directives_and_razor_diagnostics_come_from_the_compiler()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var markup = await manager.FindRazorMarkupAsync(Board, default);
+        Assert.NotNull(markup);
+        Assert.Equal(
+            ["page", "implements", "inject", "code"],
+            markup.Directives.Where(d => d.Name != "using").Select(d => d.Name)
+        );
+        Assert.All(markup.Directives, d => Assert.Equal(d.Name, Slice(markup, d.NameSpan)));
+        Assert.Contains(markup.AvailableDirectives, d => d.Directive == "rendermode");
+        Assert.Empty(markup.Diagnostics);
+
+        var text = await File.ReadAllTextAsync(Board);
+        var broken = text.Replace("<Badge Text", "<Bdage Text", StringComparison.Ordinal);
+        _ = await manager.UpdateDocumentTextAsync(Board, broken);
+        var edited = await manager.FindRazorMarkupAsync(Board, default);
+        Assert.NotNull(edited);
+        var unknown = Assert.Single(edited.Diagnostics, d => d.Id == "RZ10012");
+        Assert.Equal(RazorDiagnosticSeverity.Warning, unknown.Severity);
+        Assert.Contains("Bdage", unknown.Message, StringComparison.Ordinal);
+        Assert.DoesNotContain(edited.Tags, tag => tag.Name == "Badge");
+    }
+
+    [Fact]
+    public async Task An_edit_that_arrives_before_the_workspace_loads_is_replayed_into_the_razor_file()
+    {
+        var text = await File.ReadAllTextAsync(Board);
+        var edited = text.Replace("<Badge Text", "<Bdage Text", StringComparison.Ordinal);
+        using var manager = new WorkspaceManager();
+        // No solution yet: the edit waits, and the load replays it. [RAZOR-ARCHITECTURE-DOCUMENTS]
+        Assert.False((await manager.UpdateDocumentTextAsync(Board, edited)).IsError);
+        Assert.Null(await manager.FindRazorMarkupAsync(Board, default));
+#pragma warning disable CS0618 // OpenAsync remains the real workspace-loading boundary
+        var open = await manager.OpenAsync(_fixture.SolutionPath);
+#pragma warning restore CS0618
+        Assert.False(open.IsError, open.Match(_ => "ok", error => error));
+
+        var markup = await manager.FindRazorMarkupAsync(Board, default);
+        Assert.NotNull(markup);
+        Assert.Equal(edited, markup.Text.ToString());
+        Assert.Contains(markup.Diagnostics, d => d.Id == "RZ10012");
+        var projection = await manager.FindRazorProjectionAsync(Board, default);
+        Assert.Equal(edited, projection?.RazorText.ToString());
+    }
+
+    [Fact]
+    public async Task Names_at_an_offset_find_their_tag_attribute_and_directive()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var markup = await manager.FindRazorMarkupAsync(Board, default);
+        Assert.NotNull(markup);
+
+        var title = Offset(markup, RazorFixture.Locate(Board, "<Panel", "Title", 2));
+        Assert.Equal("Title", markup.AttributeNamedAt(title)?.Name);
+        var click = Offset(markup, RazorFixture.Locate(Board, "<button", "@onclick", 1));
+        Assert.Equal("@onclick", markup.AttributeNamedAt(click)?.Name);
+        var inject = Offset(markup, RazorFixture.Locate(Board, "@inject", "inject", 3));
+        Assert.Equal("inject", markup.DirectiveNamedAt(inject)?.Name);
+        var end = Offset(markup, RazorFixture.Locate(Board, "</Panel>", "Panel", 1));
+        Assert.Equal("Panel", markup.TagNamedAt(end)?.Name);
+
+        // HTML attributes belong to the HTML server, and content names nothing.
+        var disabled = Offset(markup, RazorFixture.Locate(Board, "<button", "disabled", 1));
+        Assert.Null(markup.AttributeNamedAt(disabled));
+        var content = Offset(markup, RazorFixture.Locate(Board, "<button", ">Add<", 2));
+        Assert.Null(markup.AttributeNamedAt(content));
+        Assert.Null(markup.DirectiveNamedAt(content));
+        Assert.Null(markup.TagNamedAt(content));
+    }
+
+    private static int Offset(RazorMarkup markup, (int Line, int Character) at)
+    {
+        return markup.Text.Lines.GetPosition(
+            new Microsoft.CodeAnalysis.Text.LinePosition(at.Line, at.Character)
+        );
+    }
+
+    private static string Slice(RazorMarkup markup, Microsoft.CodeAnalysis.Text.TextSpan span)
+    {
+        return markup.Text.ToString(span);
+    }
+
+    private static int Line(RazorMarkup markup, Microsoft.CodeAnalysis.Text.TextSpan span)
+    {
+        return markup.Text.Lines.GetLineFromPosition(span.Start).LineNumber;
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorMarkupSymbolsTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorMarkupSymbolsTests.cs
new file mode 100644
index 00000000..8735c7d0
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorMarkupSymbolsTests.cs
@@ -0,0 +1,119 @@
+using Microsoft.CodeAnalysis;
+using SharpLsp.Sidecar.CSharp.Razor;
+using SharpLsp.Sidecar.CSharp.Workspace;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+#pragma warning disable RS1035 // Real-file reads are intentional in this end-to-end suite
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// The C# symbols behind the fixture's markup: the types its components instantiate and the
+/// properties its attributes set. Implements [RAZOR-TESTING] for [RAZOR-FEATURES-HOVER] and
+/// [RAZOR-FEATURES-DEFINITION].
+/// </summary>
+public sealed class RazorMarkupSymbolsTests : IClassFixture<RazorFixture>
+{
+    private readonly RazorFixture _fixture;
+
+    public RazorMarkupSymbolsTests(RazorFixture fixture)
+    {
+        _fixture = fixture;
+    }
+
+    private string Board => _fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+
+    [Fact]
+    public async Task Component_tags_resolve_to_their_types_from_the_app_and_its_library()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var (markup, compilation) = await ReadAsync(manager, Board);
+
+        var panel = RazorMarkupSymbols.TypeOf(compilation, Tag(markup, "Panel"));
+        Assert.Equal("Widgets.Panel", panel?.ToDisplayString());
+        Assert.Equal("Widgets", panel?.ContainingAssembly.Name);
+        var tally = RazorMarkupSymbols.TypeOf(compilation, Tag(markup, "Tally"));
+        Assert.Equal("BlazorApp.Components.Shared.Tally<TItem>", tally?.ToDisplayString());
+        Assert.Equal(1, tally?.Arity);
+        Assert.Null(RazorMarkupSymbols.TypeOf(compilation, Tag(markup, "input")));
+        Assert.Null(RazorMarkupSymbols.TypeOf(compilation, Tag(markup, "button")));
+
+        var inherited = RazorMarkupSymbols.PropertyOf(panel!, "RendererInfo");
+        Assert.Equal("ComponentBase", inherited?.ContainingType.Name);
+        Assert.Null(RazorMarkupSymbols.PropertyOf(panel!, "Missing"));
+    }
+
+    [Fact]
+    public async Task Parameters_and_bind_X_set_properties_and_other_attributes_set_none()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var (markup, compilation) = await ReadAsync(manager, Board);
+
+        var title = RazorMarkupSymbols.PropertyOf(compilation, Attribute(markup, "Title"));
+        Assert.Equal("Widgets.Panel.Title", title?.ToDisplayString());
+        var items = RazorMarkupSymbols.PropertyOf(compilation, Attribute(markup, "Items"));
+        Assert.Equal(("Items", "Tally"), (items?.Name, items?.ContainingType.Name));
+
+        // `@bind-Label` binds through Tally's own bind helper and the generic `@bind`
+        // helper; only Tally's sets a property, its Label parameter.
+        var binds = markup.Attributes.Where(a => a.Name == "@bind-Label").ToList();
+        Assert.True(binds.Count > 1, "both bind helpers see @bind-Label");
+        var bound = binds
+            .Select(a => RazorMarkupSymbols.PropertyOf(compilation, a))
+            .OfType<IPropertySymbol>();
+        var label = Assert.Single(bound);
+        Assert.Equal(("Label", "Tally"), (label.Name, label.ContainingType.Name));
+
+        Assert.Null(RazorMarkupSymbols.PropertyOf(compilation, Attribute(markup, "@onclick")));
+        Assert.Null(RazorMarkupSymbols.PropertyOf(compilation, Attribute(markup, "disabled")));
+        Assert.All(
+            markup.Attributes.Where(a => a.Owner.Name == "input"),
+            attribute => Assert.Null(RazorMarkupSymbols.PropertyOf(compilation, attribute))
+        );
+    }
+
+    [Fact]
+    public async Task A_child_content_tag_sets_the_parameter_of_its_enclosing_component()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var text = await File.ReadAllTextAsync(Board);
+        var edited = text.Replace(
+            "<PageTitle>Board @Id</PageTitle>",
+            "<PageTitle>Board @Id</PageTitle>\n<Panel Title=\"Notes\"><ChildContent>Kept</ChildContent></Panel>",
+            StringComparison.Ordinal
+        );
+        _ = await manager.UpdateDocumentTextAsync(Board, edited);
+        var (markup, compilation) = await ReadAsync(manager, Board);
+
+        var content = Tag(markup, "ChildContent");
+        Assert.NotNull(content.ChildContent);
+        var property = RazorMarkupSymbols.ChildContentOf(compilation, markup, content);
+        Assert.Equal("Widgets.Panel.ChildContent", property?.ToDisplayString());
+        // Badge's nearest enclosing component is Tally, which has no Badge parameter.
+        Assert.Null(RazorMarkupSymbols.ChildContentOf(compilation, markup, Tag(markup, "Badge")));
+    }
+
+    private static async Task<(RazorMarkup Markup, Compilation Compilation)> ReadAsync(
+        WorkspaceManager manager,
+        string path
+    )
+    {
+        var markup = await manager.FindRazorMarkupAsync(path, default);
+        var project = manager.FindRazorDocument(path)?.Project;
+        var compilation = project is null ? null : await project.GetCompilationAsync();
+        Assert.NotNull(markup);
+        Assert.NotNull(compilation);
+        return (markup, compilation);
+    }
+
+    private static MarkupTag Tag(RazorMarkup markup, string name)
+    {
+        return Assert.Single(markup.Tags, tag => tag.Name == name);
+    }
+
+    private static MarkupAttribute Attribute(RazorMarkup markup, string name)
+    {
+        return Assert.Single(markup.Attributes, attribute => attribute.Name == name);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorProjectionTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorProjectionTests.cs
new file mode 100644
index 00000000..72d09f25
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorProjectionTests.cs
@@ -0,0 +1,314 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.FindSymbols;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.CSharp.Razor;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// A Razor file's C# projection, read from generated sources written the way the SDK's Razor
+/// generator writes them: a <c>#pragma checksum</c> names the Razor file, and <c>#line</c>
+/// spans map each C# fragment back into it. Hidden lines, line numbers without a file,
+/// other files and spans outside the Razor text never map. Implements [RAZOR-TESTING] for
+/// [RAZOR-ARCHITECTURE-PROJECTION] and [RAZOR-FEATURES-RENAME].
+/// </summary>
+public sealed class RazorProjectionTests
+{
+    // `count` is used on line 0 at 4..9 and declared on line 2 at 15..20.
+    private const string CounterText = "<p>@count</p>\n@code {\n    public int count = 1;\n}\n";
+
+    private static readonly string Counter = AdhocRazorProject.PathOf("Counter.razor");
+    private static readonly string Stale = AdhocRazorProject.PathOf("Stale.razor");
+    private static readonly string Orphan = AdhocRazorProject.PathOf("Orphan.razor");
+    private static readonly string Notes = AdhocRazorProject.PathOf("Notes.txt");
+    private static readonly string Ghost = AdhocRazorProject.PathOf("Ghost.razor");
+
+    [Fact]
+    public async Task A_razor_file_projects_through_the_generated_document_its_checksum_names()
+    {
+        using var workspace = new AdhocWorkspace();
+        var razor = AdhocRazorProject.Additional(Create(workspace), Counter);
+
+        var projection = await RazorProjection.ForRazorAsync(razor, default);
+
+        Assert.NotNull(projection);
+        Assert.Equal(Counter, projection.RazorPath);
+        Assert.Equal("Counter.g.cs", projection.Generated.HintName);
+        Assert.Equal(CounterText, projection.RazorText.ToString());
+        Assert.Equal(CounterSource(), projection.GeneratedText.ToString());
+        // The use, the declaration and the closing brace map, in Razor order. Roslyn puts a
+        // mapped end one past the fragment, so an entry runs on through a line break both
+        // texts share, and the brace's end, past the Razor text, stops at the text's end.
+        Assert.Equal(
+            [(4, "count"), (26, "public int count = 1;\n"), (48, "}\n")],
+            projection.Map.Mappings.Select(entry =>
+                (entry.RazorStart, projection.RazorText.ToString(Razor(entry)))
+            )
+        );
+        Assert.All(
+            projection.Map.Mappings,
+            entry =>
+                Assert.Equal(
+                    projection.RazorText.ToString(Razor(entry)),
+                    projection.GeneratedText.ToString(Generated(entry))
+                )
+        );
+    }
+
+    [Fact]
+    public async Task Positions_map_inside_and_at_the_end_of_a_fragment_and_nowhere_else()
+    {
+        using var workspace = new AdhocWorkspace();
+        var razor = AdhocRazorProject.Additional(Create(workspace), Counter);
+        var projection = await RazorProjection.ForRazorAsync(razor, default);
+        Assert.NotNull(projection);
+        var use = UseLine(projection.GeneratedText);
+
+        Assert.Equal(new LinePosition(use, 0), projection.ToGenerated(new LinePosition(0, 4)));
+        Assert.Equal(new LinePosition(use, 2), projection.ToGenerated(new LinePosition(0, 6)));
+        // A caret just after `@count` still maps, to the end of the generated fragment.
+        Assert.Equal(new LinePosition(use, 5), projection.ToGenerated(new LinePosition(0, 9)));
+        Assert.Null(projection.ToGenerated(new LinePosition(0, 1)));
+        Assert.Null(projection.ToGenerated(new LinePosition(1, 3)));
+        Assert.Null(projection.ToGenerated(new LinePosition(9, 0)));
+
+        Assert.Equal(Span(0, 4, 0, 9), projection.ToRazor(Span(use, 0, use, 5)));
+        Assert.Equal(Span(0, 5, 0, 7), projection.ToRazor(Span(use, 1, use, 3)));
+        Assert.Null(projection.ToRazor(Span(use, 0, use + 1, 0)));
+        Assert.Null(projection.ToRazor(Span(0, 0, 0, 3)));
+        Assert.Null(projection.ToRazor(Span(use, 0, 999, 0)));
+    }
+
+    [Fact]
+    public async Task Only_a_listed_razor_file_that_a_checksum_names_has_a_projection()
+    {
+        using var workspace = new AdhocWorkspace();
+        var project = Create(workspace);
+        var generated = (await project.GetSourceGeneratedDocumentsAsync()).ToDictionary(document =>
+            document.HintName
+        );
+
+        Assert.Null(await RazorProjection.ForRazorAsync(Additional(project, Orphan), default));
+        Assert.Equal(Counter, (await ForGenerated(generated["Counter.g.cs"]))?.RazorPath);
+        Assert.Equal(Stale, (await ForGenerated(generated["Stale.g.cs"]))?.RazorPath);
+        // Ghost.razor is not in the project, Notes.txt is not Razor, and Plain names no file.
+        Assert.Null(await ForGenerated(generated["Ghost.g.cs"]));
+        Assert.Null(await ForGenerated(generated["Notes.g.cs"]));
+        Assert.Null(await ForGenerated(generated["Plain.g.cs"]));
+
+        Assert.Equal(Notes, RazorProjection.ChecksumPath(await Root(generated["Notes.g.cs"])));
+        Assert.Null(RazorProjection.ChecksumPath(await Root(generated["Plain.g.cs"])));
+        Assert.Null(RazorProjection.ChecksumPath(null));
+    }
+
+    [Fact]
+    public async Task A_project_whose_generators_add_nothing_projects_no_razor_file()
+    {
+        using var workspace = new AdhocWorkspace();
+        var project = AdhocRazorProject.Create(workspace, [(Orphan, "<p>orphan</p>\n")]);
+
+        var projection = await RazorProjection.ForRazorAsync(Additional(project, Orphan), default);
+
+        Assert.Null(projection);
+        Assert.Empty(await project.GetSourceGeneratedDocumentsAsync());
+        _ = Assert.Single(project.AdditionalDocuments);
+    }
+
+    [Fact]
+    public async Task Rename_edits_only_listed_razor_spans_that_hold_the_old_name()
+    {
+        using var workspace = new AdhocWorkspace();
+        var project = Create(workspace);
+        var compilation = await project.GetCompilationAsync();
+        var field = compilation!.GetTypeByMetadataName("App.Counter")!.GetMembers("count").Single();
+        var referenced = await SymbolFinder.FindReferencesAsync(field, project.Solution);
+
+        var edits = await RazorRenameEdits.FromReferencesAsync(
+            project.Solution,
+            referenced,
+            ("count", "total"),
+            default
+        );
+
+        // Ghost.razor is unlisted, Stale.razor's span holds `total`, and the hidden, unmapped,
+        // foreign and out-of-range uses map to no Razor text.
+        var edit = Assert.Single(edits);
+        Assert.Equal(Counter, edit.FilePath);
+        Assert.Equal(
+            [(0, 4, 0, 9), (2, 15, 2, 20)],
+            edit.Edits.Select(e => (e.StartLine, e.StartCharacter, e.EndLine, e.EndCharacter))
+        );
+        Assert.All(edit.Edits, e => Assert.Equal("total", e.NewText));
+        var found = await RazorRenameEdits.FindAsync(project.Solution, field, "total", default);
+        Assert.Equal(
+            edit.Edits.Select(e => (e.StartLine, e.StartCharacter)),
+            Assert.Single(found).Edits.Select(e => (e.StartLine, e.StartCharacter))
+        );
+    }
+
+    [Fact]
+    public void Mappings_that_start_outside_either_text_are_dropped()
+    {
+        var tree = CSharpSyntaxTree.ParseText(CounterSource());
+        var generated = tree.GetText();
+        var razor = SourceText.From(CounterText);
+        var use = UseLine(generated);
+        // The generated text ends just before the use's line, as a stale snapshot would.
+        var cut = SourceText.From(
+            generated.ToString(TextSpan.FromBounds(0, generated.Lines[use - 1].End))
+        );
+
+        Assert.Equal([4, 26, 48], Starts(RazorSpanMap.Build(tree, generated, razor, Counter)));
+        Assert.Equal([26], Starts(RazorSpanMap.Build(tree, cut, razor, Counter)));
+        Assert.Equal(
+            [4],
+            Starts(RazorSpanMap.Build(tree, generated, SourceText.From("<p>@count</p>\n"), Counter))
+        );
+        Assert.Empty(RazorSpanMap.Build(tree, generated, razor, Stale).Mappings);
+    }
+
+    private static Project Create(AdhocWorkspace workspace)
+    {
+        return AdhocRazorProject.Create(
+            workspace,
+            [
+                (Counter, CounterText),
+                (Stale, "<p>@total</p>\n"),
+                (Orphan, "<p>orphan</p>\n"),
+                (Notes, "notes\n"),
+            ],
+            generated:
+            [
+                ("Counter.g.cs", CounterSource()),
+                ("Stale.g.cs", ReaderSource("Stale", Stale)),
+                ("Ghost.g.cs", ReaderSource("Ghost", Ghost)),
+                ("Notes.g.cs", Lines(Checksum(Notes), "namespace App { partial class Notes { } }")),
+                ("Plain.g.cs", "namespace App { partial class Plain { } }"),
+            ]
+        );
+    }
+
+    /// <summary>Counter's projection: every kind of line mapping the generator can write.</summary>
+    private static string CounterSource()
+    {
+        return Lines(
+            Checksum(Counter),
+            "namespace App",
+            "{",
+            "    public partial class Counter",
+            "    {",
+            $"#line (3,5)-(3,26) \"{Counter}\"",
+            "public int count = 1;",
+            "#line default",
+            "        public object Render()",
+            "        {",
+            "            return",
+            $"#line (1,5)-(1,10) \"{Counter}\"",
+            "count",
+            "#line default",
+            "            ;",
+            "        }",
+            "#line hidden",
+            "        public int Hidden => count;",
+            "#line default",
+            "#line 7",
+            "        public int Unmapped => count;",
+            $"#line 9 \"{AdhocRazorProject.PathOf("Other.cs")}\"",
+            "        public int Elsewhere => count;",
+            $"#line (40,1)-(40,6) \"{Counter}\"",
+            "public int Far => count;",
+            $"#line (1,40)-(1,45) \"{Counter}\"",
+            "public int Wide => count;",
+            "#line default",
+            "        public void Block()",
+            "        {",
+            "            {",
+            $"#line (4,1)-(9,1) \"{Counter}\"",
+            "}",
+            "#line default",
+            "        }",
+            "    }",
+            "}"
+        );
+    }
+
+    /// <summary>A projection of <paramref name="razorPath"/> that reads Counter's field there.</summary>
+    private static string ReaderSource(string name, string razorPath)
+    {
+        return Lines(
+            Checksum(razorPath),
+            "namespace App",
+            "{",
+            $"    public partial class {name}",
+            "    {",
+            "        public int Read(Counter counter)",
+            "        {",
+            "            return counter.",
+            $"#line (1,5)-(1,10) \"{razorPath}\"",
+            "count",
+            "#line default",
+            "            ;",
+            "        }",
+            "    }",
+            "}"
+        );
+    }
+
+    private static string Checksum(string path)
+    {
+        return $"#pragma checksum \"{path}\" \"{{8829d00f-11b8-4213-878b-770e8597ac16}}\" \"00\"";
+    }
+
+    private static string Lines(params string[] lines)
+    {
+        return string.Join("\n", lines);
+    }
+
+    /// <summary>The generated line that holds Counter's mapped use of <c>count</c>.</summary>
+    private static int UseLine(SourceText generated)
+    {
+        return generated.Lines.Single(line => line.ToString() == "count").LineNumber;
+    }
+
+    private static TextDocument Additional(Project project, string path)
+    {
+        return AdhocRazorProject.Additional(project, path);
+    }
+
+    private static Task<RazorProjection?> ForGenerated(SourceGeneratedDocument generated)
+    {
+        return RazorProjection.ForGeneratedAsync(generated, default);
+    }
+
+    private static Task<SyntaxNode?> Root(SourceGeneratedDocument generated)
+    {
+        return generated.GetSyntaxRootAsync();
+    }
+
+    private static int[] Starts(RazorSpanMap map)
+    {
+        return [.. map.Mappings.Select(entry => entry.RazorStart)];
+    }
+
+    private static TextSpan Razor(RazorMapping entry)
+    {
+        return new TextSpan(entry.RazorStart, entry.Length);
+    }
+
+    private static TextSpan Generated(RazorMapping entry)
+    {
+        return new TextSpan(entry.GeneratedStart, entry.Length);
+    }
+
+    private static LinePositionSpan Span(int line, int character, int endLine, int endCharacter)
+    {
+        return new LinePositionSpan(
+            new LinePosition(line, character),
+            new LinePosition(endLine, endCharacter)
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorSidecarTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorSidecarTests.cs
new file mode 100644
index 00000000..849bb218
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorSidecarTests.cs
@@ -0,0 +1,120 @@
+using MessagePack;
+using SharpLsp.Sidecar.CSharp.Razor;
+
+#pragma warning disable CA1515 // Public xUnit discovery type
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>Real IPC coverage of [RAZOR-ARCHITECTURE-ROUTING], [RAZOR-ARCHITECTURE-HTML] and [RAZOR-TESTING].</summary>
+public sealed class RazorSidecarTests(CSharpSidecarFixture socket, RazorFixture files)
+    : IClassFixture<CSharpSidecarFixture>,
+        IClassFixture<RazorFixture>
+{
+    private string Board => files.Path("BlazorApp", "Components", "Pages", "Board.razor");
+
+    [Fact]
+    public async Task Projection_round_trips_current_text_and_returns_null_for_unlisted_files()
+    {
+        await OpenAsync().ConfigureAwait(true);
+        var before = await AtAsync<HtmlProjectionResult?>("sharplsp/razor/htmlProjection", Board)
+            .ConfigureAwait(true);
+        Assert.NotNull(before);
+        Assert.Contains("<Panel", before.Text, StringComparison.Ordinal);
+        Assert.DoesNotContain("@code", before.Text, StringComparison.Ordinal);
+        const string changed = "<p>@DateTime.Now</p>\r\n";
+        await socket
+            .SendAndAssertOkAsync(
+                "textDocument/didChange",
+                new DidChangeRequest { FilePath = Board, NewText = changed }
+            )
+            .ConfigureAwait(true);
+        var after = await AtAsync<HtmlProjectionResult?>("sharplsp/razor/htmlProjection", Board)
+            .ConfigureAwait(true);
+        Assert.NotNull(after);
+        Assert.Equal("<p>             </p>\r\n", after.Text);
+        Assert.Equal(changed.Length, after.Text.Length);
+        Assert.Null(
+            await AtAsync<HtmlProjectionResult?>(
+                    "sharplsp/razor/htmlProjection",
+                    files.Path("Missing.razor")
+                )
+                .ConfigureAwait(true)
+        );
+    }
+
+    [Fact]
+    public async Task Syntax_requests_keep_their_wire_shapes_and_source_ranges()
+    {
+        await OpenAsync().ConfigureAwait(true);
+        var folds = await AtAsync<List<FoldingRangeResult>>("textDocument/foldingRange", Board)
+            .ConfigureAwait(true);
+        Assert.Equal(
+            [(6, 9), (7, 8), (14, 24)],
+            folds.Select(fold => (fold.StartLine, fold.EndLine))
+        );
+        var symbols = await AtAsync<List<DocumentSymbolResult>>(
+                "textDocument/documentSymbol",
+                Board
+            )
+            .ConfigureAwait(true);
+        Assert.Equal(
+            "Tally",
+            Assert.Single(symbols.Single(symbol => symbol.Name == "Panel").Children).Name
+        );
+        Assert.Contains(
+            symbols.Single(symbol => symbol.Name == "@code").Children,
+            child => child.Name == "Add"
+        );
+        var linked = await AtAsync<LocationListResult>(
+                "textDocument/linkedEditingRange",
+                Board,
+                6,
+                3
+            )
+            .ConfigureAwait(true);
+        Assert.Equal(
+            [(6, 1, 6, 6), (10, 2, 10, 7)],
+            linked.Locations.Select(at => (at.Line, at.Character, at.EndLine, at.EndCharacter))
+        );
+        Assert.All(linked.Locations, at => Assert.Equal(Board, at.FilePath));
+    }
+
+    [Theory]
+    [InlineData("sharplsp/razor/htmlProjection")]
+    [InlineData("textDocument/documentSymbol")]
+    [InlineData("textDocument/foldingRange")]
+    [InlineData("textDocument/linkedEditingRange")]
+    public async Task Malformed_payloads_return_errors_and_keep_the_socket_healthy(string method)
+    {
+        var error = await socket.SendAsync(method, [0xC1]).ConfigureAwait(true);
+        Assert.NotNull(error.Error);
+        var pong = await socket.SendAndDeserializeAsync<string>("ping", []).ConfigureAwait(true);
+        Assert.Equal("pong", pong);
+    }
+
+    private Task OpenAsync()
+    {
+        return socket.SendAndAssertOkAsync(
+            "workspace/open",
+            MessagePackSerializer.Serialize(files.SolutionPath)
+        );
+    }
+
+    private Task<T> AtAsync<T>(string method, string path, int? line = null, int character = 0)
+    {
+        return line is { } at
+            ? socket.SendAndDeserializeAsync<PositionRequest, T>(
+                method,
+                new PositionRequest
+                {
+                    FilePath = path,
+                    Line = at,
+                    Character = character,
+                }
+            )
+            : socket.SendAndDeserializeAsync<T>(
+                method,
+                MessagePackSerializer.Serialize(new[] { path })
+            );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorStructureTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorStructureTests.cs
new file mode 100644
index 00000000..55913a0f
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/RazorStructureTests.cs
@@ -0,0 +1,140 @@
+#pragma warning disable CA1515 // Public xUnit discovery type
+#pragma warning disable CA2007 // xUnit executes without a synchronization context
+#pragma warning disable RS1035 // Real-file reads are intentional in this end-to-end suite
+
+using static SharpLsp.Sidecar.CSharp.Tests.RazorFixture;
+
+namespace SharpLsp.Sidecar.CSharp.Tests;
+
+/// <summary>
+/// Folding, outline and linked tag names for the fixture's real Razor files, the syntax
+/// requests the host forwards. Implements [RAZOR-TESTING] for [RAZOR-ARCHITECTURE-ROUTING]
+/// and [RAZOR-FEATURES-STRUCTURE].
+/// </summary>
+public sealed class RazorStructureTests : IClassFixture<RazorFixture>
+{
+    private readonly RazorFixture _fixture;
+
+    public RazorStructureTests(RazorFixture fixture)
+    {
+        _fixture = fixture;
+    }
+
+    private string Board => _fixture.Path("BlazorApp", "Components", "Pages", "Board.razor");
+
+    [Fact]
+    public async Task Multi_line_elements_and_the_code_block_fold_keeping_their_last_line()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var folds = Ok(await manager.GetFoldingRangesAsync(Board, default));
+        Assert.Equal(
+            [(6, 9), (7, 8), (14, 24)],
+            folds.Select(fold => (fold.StartLine, fold.EndLine))
+        );
+
+        var text = await File.ReadAllTextAsync(Board);
+        var grown = text.Replace("</Tally>", "</Tally>\n\n", StringComparison.Ordinal);
+        _ = Ok(await manager.UpdateDocumentTextAsync(Board, grown));
+        var edited = Ok(await manager.GetFoldingRangesAsync(Board, default));
+        Assert.Equal(
+            [(6, 11), (7, 8), (16, 26)],
+            edited.Select(fold => (fold.StartLine, fold.EndLine))
+        );
+        var outside = _fixture.Path("BlazorApp", "Program.cs");
+        Assert.Empty(Ok(await manager.GetFoldingRangesAsync(outside, default)));
+    }
+
+    [Fact]
+    public async Task Outline_nests_components_in_markup_and_members_in_their_directives()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var symbols = Ok(await manager.GetDocumentSymbolsAsync(Board, default));
+        Assert.Equal(
+            ["@page", "@implements", "@inject", "PageTitle", "Panel", "input", "button", "@code"],
+            symbols.Select(symbol => symbol.Name)
+        );
+
+        var inject = symbols.Single(symbol => symbol.Name == "@inject");
+        var navigation = Assert.Single(inject.Children);
+        Assert.Equal(
+            ("Navigation", "Property", 2),
+            (navigation.Name, navigation.Kind, navigation.SelectionStartLine)
+        );
+
+        var panel = symbols.Single(symbol => symbol.Name == "Panel");
+        Assert.Equal(
+            ("Class", 6, 1, 10, 8),
+            (
+                panel.Kind,
+                panel.StartLine,
+                panel.SelectionStartCharacter,
+                panel.EndLine,
+                panel.EndCharacter
+            )
+        );
+        var tally = Assert.Single(panel.Children);
+        Assert.Equal("Tally", tally.Name);
+        Assert.Equal("Badge", Assert.Single(tally.Children).Name);
+
+        var code = symbols.Single(symbol => symbol.Name == "@code");
+        Assert.Equal(
+            ("Key", 14, 1, 14, 5),
+            (
+                code.Kind,
+                code.SelectionStartLine,
+                code.SelectionStartCharacter,
+                code.SelectionEndLine,
+                code.SelectionEndCharacter
+            )
+        );
+        Assert.Equal(
+            [
+                ("Id", "Property"),
+                ("scores", "Field"),
+                ("caption", "Field"),
+                ("tally", "Field"),
+                ("Add", "Method"),
+                ("Dispose", "Method"),
+            ],
+            code.Children.Select(member => (member.Name, member.Kind))
+        );
+        var add = code.Children.Single(member => member.Name == "Add");
+        Assert.Equal(
+            (22, 4, 22, 17, 22),
+            (
+                add.StartLine,
+                add.StartCharacter,
+                add.SelectionStartLine,
+                add.SelectionStartCharacter,
+                add.SelectionEndLine
+            )
+        );
+    }
+
+    [Fact]
+    public async Task Start_and_end_tag_names_edit_together_and_self_closing_tags_have_none()
+    {
+        using var manager = await _fixture.OpenManagerAsync();
+        var panel = Ok(await manager.GetLinkedEditingRangesAsync(Board, (6, 3), default));
+        Assert.Equal(
+            [(6, 1, 6, 6), (10, 2, 10, 7)],
+            panel.Locations.Select(range =>
+                (range.Line, range.Character, range.EndLine, range.EndCharacter)
+            )
+        );
+        Assert.All(panel.Locations, range => Assert.Equal(Board, range.FilePath));
+
+        var fromEnd = Ok(await manager.GetLinkedEditingRangesAsync(Board, (10, 7), default));
+        Assert.Equal(
+            panel.Locations.Select(range => (range.Line, range.Character)),
+            fromEnd.Locations.Select(range => (range.Line, range.Character))
+        );
+
+        Assert.Empty(
+            Ok(await manager.GetLinkedEditingRangesAsync(Board, (8, 10), default)).Locations
+        );
+        Assert.Empty(
+            Ok(await manager.GetLinkedEditingRangesAsync(Board, (6, 10), default)).Locations
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/SharpLsp.Sidecar.CSharp.Tests.csproj b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/SharpLsp.Sidecar.CSharp.Tests.csproj
index df6bd517..e7607b26 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/SharpLsp.Sidecar.CSharp.Tests.csproj
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/SharpLsp.Sidecar.CSharp.Tests.csproj
@@ -44,4 +44,7 @@
     <ItemGroup>
         <ProjectReference Include="..\SharpLsp.Sidecar.CSharp\SharpLsp.Sidecar.CSharp.csproj" />
     </ItemGroup>
+
+    <!-- The tests read the engine's markup facts, which carry Razor compiler types. -->
+    <Import Project="..\SharpLsp.Sidecar.CSharp\RazorCompiler.props" />
 </Project>
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/CSharpSidecar.Razor.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/CSharpSidecar.Razor.cs
new file mode 100644
index 00000000..6cb68bbd
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/CSharpSidecar.Razor.cs
@@ -0,0 +1,55 @@
+using MessagePack;
+using ByteResult = Outcome.Result<byte[], string>;
+
+namespace SharpLsp.Sidecar.CSharp;
+
+internal sealed partial class CSharpSidecar
+{
+    // Implements [RAZOR-ARCHITECTURE-ROUTING].
+    private Task<ByteResult> HandleDocumentSymbolAsync(byte[] payload, CancellationToken ct)
+    {
+        return HandleRequestAsync(
+            payload,
+            (PositionRequest request) => _workspace.GetDocumentSymbolsAsync(request.FilePath, ct),
+            ct
+        );
+    }
+
+    private Task<ByteResult> HandleFoldingRangeAsync(byte[] payload, CancellationToken ct)
+    {
+        return HandleRequestAsync(
+            payload,
+            (PositionRequest request) => _workspace.GetFoldingRangesAsync(request.FilePath, ct),
+            ct
+        );
+    }
+
+    private Task<ByteResult> HandleLinkedEditingRangeAsync(byte[] payload, CancellationToken ct)
+    {
+        return HandlePositionRequestAsync(
+            payload,
+            (file, line, character, token) =>
+                _workspace.GetLinkedEditingRangesAsync(file, (line, character), token),
+            ct
+        );
+    }
+
+    // Implements [RAZOR-ARCHITECTURE-HTML].
+    private Task<ByteResult> HandleRazorHtmlProjectionAsync(byte[] payload, CancellationToken ct)
+    {
+        return HandleRequestAsync(
+            payload,
+            (PositionRequest request) =>
+                _workspace.GetRazorHtmlProjectionAsync(request.FilePath, ct),
+            ct
+        );
+    }
+}
+
+/// <summary>The position-preserving HTML projection, [RAZOR-ARCHITECTURE-HTML].</summary>
+[MessagePackObject(AllowPrivate = true)]
+internal sealed class HtmlProjectionResult
+{
+    [Key(0)]
+    public string Text { get; set; } = "";
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/CSharpSidecar.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/CSharpSidecar.cs
index 37ae1c6c..64758d9e 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/CSharpSidecar.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/CSharpSidecar.cs
@@ -25,6 +25,7 @@ public CSharpSidecar()
         Register("textDocument/completion", HandleCompletionAsync);
         Register("completionItem/resolve", HandleCompletionResolveAsync);
         Register("textDocument/hover", HandleHoverAsync);
+        Register("sharplsp/razor/htmlProjection", HandleRazorHtmlProjectionAsync);
         Register("textDocument/signatureHelp", HandleSignatureHelpAsync);
         Register("textDocument/definition", HandleDefinitionAsync);
         Register("textDocument/typeDefinition", HandleTypeDefinitionAsync);
@@ -44,6 +45,9 @@ public CSharpSidecar()
         Register("textDocument/formatting", HandleFormattingAsync);
         Register("textDocument/rangeFormatting", HandleRangeFormattingAsync);
         Register("textDocument/onTypeFormatting", HandleOnTypeFormattingAsync);
+        Register("textDocument/documentSymbol", HandleDocumentSymbolAsync);
+        Register("textDocument/foldingRange", HandleFoldingRangeAsync);
+        Register("textDocument/linkedEditingRange", HandleLinkedEditingRangeAsync);
         Register("textDocument/semanticTokens/full", HandleSemanticTokensFullAsync);
         Register("textDocument/semanticTokens/range", HandleSemanticTokensRangeAsync);
         Register("textDocument/inlayHint", HandleInlayHintAsync);
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/HtmlMarkupContext.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/HtmlMarkupContext.cs
new file mode 100644
index 00000000..00a7c86e
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/HtmlMarkupContext.cs
@@ -0,0 +1,395 @@
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Where the caret sits in projected HTML. Implements [RAZOR-ARCHITECTURE-HTML].
+/// </summary>
+internal enum MarkupContext
+{
+    /// <summary>Text between tags, inside comments or declarations, or raw text.</summary>
+    Content,
+
+    /// <summary>On a start or end tag's name, or right after <c>&lt;</c>.</summary>
+    TagName,
+
+    /// <summary>On an attribute's name, or where a new attribute may start.</summary>
+    AttributeName,
+
+    /// <summary>Inside a quoted or unquoted attribute value.</summary>
+    AttributeValue,
+}
+
+/// <summary>
+/// The HTML markup context at a caret: a WHATWG-style tokenizer folded over the projection's
+/// prefix up to the caret. Pure — every step maps an immutable state and an input character to
+/// the next state. Implements [RAZOR-ARCHITECTURE-HTML].
+/// </summary>
+internal static class HtmlMarkupContext
+{
+    /// <summary>The markup context at <paramref name="offset"/>; out-of-range offsets clamp.</summary>
+    public static MarkupContext At(string html, int offset)
+    {
+        return Context(ScanTo(html, Math.Clamp(offset, 0, html.Length)));
+    }
+
+    /// <summary>The tokenizer states the caret context derives from.</summary>
+    private enum Scanner
+    {
+        Data,
+        TagOpen,
+        EndTagOpen,
+        TagName,
+        BeforeAttribute,
+        Attribute,
+        AfterAttribute,
+        BeforeValue,
+        ValueDoubleQuoted,
+        ValueSingleQuoted,
+        ValueUnquoted,
+        AfterValue,
+        SelfClosing,
+        RawText,
+        ScriptEscaped,
+        ScriptDoubleEscaped,
+    }
+
+    /// <param name="State">The tokenizer state.</param>
+    /// <param name="Tag">The current start tag's name; the raw-text target while in <see cref="Scanner.RawText"/>.</param>
+    /// <param name="EndTag">Whether the current tag is an end tag.</param>
+    private readonly record struct Scan(Scanner State, string Tag, bool EndTag);
+
+    private static Scan ScanTo(string html, int end)
+    {
+        var scan = Data();
+        var i = 0;
+        while (i < end)
+        {
+            (scan, i) = Advance(scan, html, i, end);
+        }
+
+        return scan;
+    }
+
+    private static (Scan Next, int Index) Advance(Scan s, string html, int i, int end)
+    {
+        return (s.State, html[i]) switch
+        {
+            (Scanner.TagOpen, '!') => Declaration(html, i),
+            (Scanner.TagOpen, '?') => (Data(), Bogus(html, i + 1)),
+            (Scanner.EndTagOpen, var c) when c != '>' && !char.IsAsciiLetter(c) => (
+                Data(),
+                Bogus(html, i)
+            ),
+            (Scanner.RawText, _) when s.Tag == "script" => Script(s, html, i),
+            (Scanner.ScriptEscaped or Scanner.ScriptDoubleEscaped, _) => Script(s, html, i),
+            (Scanner.RawText, _) => RawText(s, html, i, end),
+            _ => (Step(s, html[i]), i + 1),
+        };
+    }
+
+    private static Scan Step(Scan s, char c)
+    {
+        return (s.State, c) switch
+        {
+            (Scanner.TagOpen, _) => TagOpen(s, c),
+            (Scanner.EndTagOpen, _) => EndTagOpen(s, c),
+            (Scanner.TagName, _) => TagName(s, c),
+            (Scanner.BeforeAttribute or Scanner.SelfClosing, _) => BeforeAttribute(s, c),
+            (Scanner.Attribute or Scanner.AfterAttribute, _) => Attribute(s, c),
+            (Scanner.BeforeValue, _) => BeforeValue(s, c),
+            (Scanner.ValueDoubleQuoted or Scanner.ValueSingleQuoted, _) => Quoted(s, c),
+            (Scanner.ValueUnquoted, _) => ValueUnquoted(s, c),
+            (Scanner.AfterValue, _) => AfterValue(s, c),
+            // Advance handles raw text separately; the remaining state is normal data.
+            _ => c == '<' ? Data(Scanner.TagOpen) : s,
+        };
+    }
+
+    private static Scan Quoted(Scan scan, char value)
+    {
+        return
+            (scan.State, value)
+                is
+                    (Scanner.ValueDoubleQuoted, '"')
+                    or
+                    (Scanner.ValueSingleQuoted, '\'')
+            ? Kept(Scanner.AfterValue, scan)
+            : scan;
+    }
+
+    private static Scan TagOpen(Scan s, char c)
+    {
+        return c switch
+        {
+            '/' => Data(Scanner.EndTagOpen),
+            '<' => Data(Scanner.TagOpen),
+            _ => char.IsAsciiLetter(c) ? Named(s, c, false) : Data(),
+        };
+    }
+
+    private static Scan EndTagOpen(Scan s, char c)
+    {
+        return c switch
+        {
+            '>' => Close(s),
+            _ => char.IsAsciiLetter(c) ? Named(s, c, true) : Data(),
+        };
+    }
+
+    private static Scan TagName(Scan s, char c)
+    {
+        return c switch
+        {
+            '>' => Close(s),
+            '/' => Kept(Scanner.SelfClosing, s),
+            _ => IsSpace(c) ? Kept(Scanner.BeforeAttribute, s) : Named(s, c, s.EndTag),
+        };
+    }
+
+    private static Scan BeforeAttribute(Scan s, char c)
+    {
+        return c switch
+        {
+            '>' => Close(s),
+            '/' => Kept(Scanner.SelfClosing, s),
+            _ => IsSpace(c) ? s : Kept(Scanner.Attribute, s),
+        };
+    }
+
+    private static Scan Attribute(Scan s, char c)
+    {
+        return c switch
+        {
+            '>' => Close(s),
+            '/' => Kept(Scanner.SelfClosing, s),
+            '=' => Kept(Scanner.BeforeValue, s),
+            _ => IsSpace(c) ? Kept(Scanner.AfterAttribute, s) : s,
+        };
+    }
+
+    private static Scan BeforeValue(Scan s, char c)
+    {
+        return c switch
+        {
+            '"' => Kept(Scanner.ValueDoubleQuoted, s),
+            '\'' => Kept(Scanner.ValueSingleQuoted, s),
+            '>' => Close(s),
+            _ => IsSpace(c) ? s : Kept(Scanner.ValueUnquoted, s),
+        };
+    }
+
+    private static Scan ValueUnquoted(Scan s, char c)
+    {
+        return c switch
+        {
+            '>' => Close(s),
+            _ => IsSpace(c) ? Kept(Scanner.BeforeAttribute, s) : s,
+        };
+    }
+
+    private static Scan AfterValue(Scan s, char c)
+    {
+        return c switch
+        {
+            '>' => Close(s),
+            '/' => Kept(Scanner.SelfClosing, s),
+            _ => IsSpace(c) ? Kept(Scanner.BeforeAttribute, s) : Kept(Scanner.Attribute, s),
+        };
+    }
+
+    /// <summary>A completed start tag of a raw-text element switches to its raw text.</summary>
+    private static Scan Close(Scan s)
+    {
+        return !s.EndTag && IsRawText(s.Tag) ? new Scan(Scanner.RawText, s.Tag, false) : Data();
+    }
+
+    /// <summary>
+    /// Raw text consumes everything until its appropriate end tag; the <c>&lt;/name</c> then
+    /// re-enters the normal tag states ([RAZOR-ARCHITECTURE-HTML]).
+    /// </summary>
+    private static (Scan Next, int Index) RawText(Scan s, string html, int i, int end)
+    {
+        if (html[i] != '<')
+        {
+            return (s, i + 1);
+        }
+
+        var close = "</" + s.Tag;
+        var j = html.IndexOf(close, i, StringComparison.OrdinalIgnoreCase);
+        while (j >= 0 && !EndsTag(html, j + close.Length, html.Length))
+        {
+            j = html.IndexOf(close, j + 1, StringComparison.OrdinalIgnoreCase);
+        }
+
+        return j < 0 ? (s, end) : (Data(), j);
+    }
+
+    private static (Scan Next, int Index) Script(Scan s, string html, int i)
+    {
+        return s switch
+        {
+            { State: Scanner.RawText } when IsAt(html, i, "<!--") => (
+                Kept(Scanner.ScriptEscaped, s),
+                i + 4
+            ),
+            { State: Scanner.ScriptEscaped or Scanner.ScriptDoubleEscaped }
+                when IsAt(html, i, "-->") => (Kept(Scanner.RawText, s), i + 3),
+            { State: Scanner.ScriptEscaped } when AtTag(html, i, "<script") => (
+                Kept(Scanner.ScriptDoubleEscaped, s),
+                i + 7
+            ),
+            _ => ScriptEnd(s, html, i),
+        };
+    }
+
+    private static (Scan Next, int Index) ScriptEnd(Scan s, string html, int i)
+    {
+        return !AtTag(html, i, "</script") ? (s, i + 1)
+            : s.State == Scanner.ScriptDoubleEscaped ? (Kept(Scanner.ScriptEscaped, s), i + 8)
+            : (Data(), i);
+    }
+
+    private static bool AtTag(string html, int i, string tag)
+    {
+        return i + tag.Length <= html.Length
+            && html.AsSpan(i, tag.Length).Equals(tag, StringComparison.OrdinalIgnoreCase)
+            && EndsTag(html, i + tag.Length, html.Length);
+    }
+
+    /// <summary>After <c>&lt;!</c>: comments end at <c>--&gt;</c> or <c>--!&gt;</c>, the rest at <c>&gt;</c>.</summary>
+    private static (Scan, int) Declaration(string html, int bang)
+    {
+        return IsAt(html, bang + 1, "--")
+            ? (Data(), SkipComment(html, bang + 3))
+            : (
+                Data(),
+                IsDoctype(html, bang + 1) ? DoctypeEnd(html, bang + 1) : Bogus(html, bang + 1)
+            );
+    }
+
+    private static bool IsDoctype(string html, int i)
+    {
+        return html.AsSpan(i).StartsWith("DOCTYPE", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static int DoctypeEnd(string html, int start)
+    {
+        var quote = '\0';
+        for (var i = start; i < html.Length; i++)
+        {
+            if (quote == '\0' && html[i] == '>')
+            {
+                return i + 1;
+            }
+
+            quote =
+                html[i] == quote ? '\0'
+                : quote == '\0' && html[i] is '\'' or '"' ? html[i]
+                : quote;
+        }
+        return html.Length;
+    }
+
+    private static int SkipComment(string html, int i)
+    {
+        if (Abrupt(html, i) is { } closed)
+        {
+            return closed;
+        }
+
+        for (var j = i; j < html.Length; j++)
+        {
+            if (IsAt(html, j, "-->") || IsAt(html, j, "--!>"))
+            {
+                return j + (html[j + 2] == '!' ? 4 : 3);
+            }
+        }
+
+        return html.Length;
+    }
+
+    // <!--> and <!---> close abruptly ([WHATWG]).
+    private static int? Abrupt(string html, int i)
+    {
+        return IsAt(html, i, ">") ? i + 1
+            : IsAt(html, i, "->") ? i + 2
+            : null;
+    }
+
+    private static int Bogus(string html, int i)
+    {
+        var close = html.IndexOf('>', i);
+        return close < 0 ? html.Length : close + 1;
+    }
+
+    private static MarkupContext Context(Scan scan)
+    {
+        return scan.State is Scanner.TagOpen or Scanner.EndTagOpen or Scanner.TagName
+                ? MarkupContext.TagName
+            : scan.State
+                is Scanner.SelfClosing
+                    or Scanner.BeforeAttribute
+                    or Scanner.Attribute
+                    or Scanner.AfterAttribute
+                    or Scanner.AfterValue
+                ? MarkupContext.AttributeName
+            : ValueContext(scan.State);
+    }
+
+    private static MarkupContext ValueContext(Scanner state)
+    {
+        return
+            state
+                is Scanner.BeforeValue
+                    or Scanner.ValueDoubleQuoted
+                    or Scanner.ValueSingleQuoted
+                    or Scanner.ValueUnquoted
+            ? MarkupContext.AttributeValue
+            : MarkupContext.Content;
+    }
+
+    private static Scan Data(Scanner state = Scanner.Data)
+    {
+        return new(state, string.Empty, false);
+    }
+
+    private static Scan Kept(Scanner state, Scan s)
+    {
+        return new(state, s.Tag, s.EndTag);
+    }
+
+    private static Scan Named(Scan s, char c, bool endTag)
+    {
+        return new(Scanner.TagName, s.Tag + char.ToLowerInvariant(c), endTag);
+    }
+
+    private static bool EndsTag(string html, int k, int end)
+    {
+        return k >= end || IsSpace(html[k]) || html[k] is '/' or '>';
+    }
+
+    private static bool IsSpace(char c)
+    {
+        return c is ' ' or '\t' or '\n' or '\f' or '\r';
+    }
+
+    private static bool IsAt(string html, int i, string text)
+    {
+        return i >= 0
+            && i + text.Length <= html.Length
+            && string.CompareOrdinal(html, i, text, 0, text.Length) == 0;
+    }
+
+    // Raw-text and RCDATA elements: markup inside them is text ([RAZOR-ARCHITECTURE-HTML]).
+    private static bool IsRawText(string tag)
+    {
+        return tag
+            is "script"
+                or "style"
+                or "textarea"
+                or "title"
+                or "xmp"
+                or "iframe"
+                or "noembed"
+                or "noframes";
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorCompletionEdits.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorCompletionEdits.cs
new file mode 100644
index 00000000..eccd1d7f
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorCompletionEdits.cs
@@ -0,0 +1,96 @@
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Workspace;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// A completion's additional edits, moved from a projection into its Razor file: an edit
+/// inside one C# fragment maps across, an added C# <c>using</c> becomes an <c>@using</c> line
+/// after the file's own, and anything else cannot be placed and is dropped.
+/// Implements [RAZOR-ARCHITECTURE-PROJECTION] and [RAZOR-FEATURES-COMPLETION].
+/// </summary>
+internal static class RazorCompletionEdits
+{
+    /// <summary>The Razor edits for <paramref name="changes"/> computed on <paramref name="origin"/>'s projection.</summary>
+    public static IEnumerable<TextEditResult> Map(
+        RazorProjection origin,
+        IEnumerable<TextChange> changes
+    )
+    {
+        var existing = OwnUsings(origin).Select(Spelling).ToHashSet(StringComparer.Ordinal);
+        foreach (var change in changes)
+        {
+            if (origin.Map.ToRazor(change.Span) is { } span)
+            {
+                yield return DocumentText.ToTextEdit(
+                    origin.RazorText,
+                    new TextChange(span, change.NewText ?? "")
+                );
+                continue;
+            }
+
+            foreach (var added in AddedUsings(change).Where(existing.Add))
+            {
+                yield return UsingLine(origin, added);
+            }
+        }
+    }
+
+    /// <summary>The using directives a change inserts: its whole text parses as usings and nothing else.</summary>
+    private static IEnumerable<string> AddedUsings(TextChange change)
+    {
+        var unit = SyntaxFactory.ParseCompilationUnit(change.NewText ?? "");
+        return unit.ContainsDiagnostics || unit.Members.Count > 0 || unit.AttributeLists.Count > 0
+            ? []
+            : unit.Usings.Select(Spelling);
+    }
+
+    /// <summary>The usings this Razor file declares itself, as its projection carries them.</summary>
+    private static IEnumerable<UsingDirectiveSyntax> OwnUsings(RazorProjection origin)
+    {
+        return origin
+            .GeneratedRoot.DescendantNodes()
+            .OfType<UsingDirectiveSyntax>()
+            .Where(directive => IsOwn(origin, directive));
+    }
+
+    private static bool IsOwn(RazorProjection origin, UsingDirectiveSyntax directive)
+    {
+        var mapped = directive.NamespaceOrType.GetLocation().GetMappedLineSpan();
+        return mapped.HasMappedPath && NativePaths.AreEqual(mapped.Path, origin.RazorPath);
+    }
+
+    /// <summary>A using directive as Razor spells it after <c>@using</c>.</summary>
+    private static string Spelling(UsingDirectiveSyntax directive)
+    {
+        var isStatic =
+            directive.StaticKeyword.RawKind == (int)SyntaxKind.StaticKeyword ? "static " : "";
+        var alias = directive.Alias is { } named ? named.Name.Identifier.ValueText + " = " : "";
+        return isStatic + alias + directive.NamespaceOrType.ToString();
+    }
+
+    /// <summary>An <c>@using</c> line inserted after the file's last own using, else at its start.</summary>
+    private static TextEditResult UsingLine(RazorProjection origin, string spelling)
+    {
+        var after = OwnUsings(origin)
+            .Select(directive => directive.NamespaceOrType.GetLocation().GetMappedLineSpan())
+            .Select(span => span.EndLinePosition.Line + 1)
+            .DefaultIfEmpty(0)
+            .Max();
+        var line = Math.Min(after, origin.RazorText.Lines.Count - 1);
+        var at = origin.RazorText.Lines[line].Start;
+        var text = "@using " + spelling + LineBreak(origin.RazorText);
+        return DocumentText.ToTextEdit(origin.RazorText, new TextChange(new TextSpan(at, 0), text));
+    }
+
+    private static string LineBreak(SourceText text)
+    {
+        var first = text.Lines[0];
+        return first.SpanIncludingLineBreak.Length > first.Span.Length
+            ? text.ToString(TextSpan.FromBounds(first.End, first.EndIncludingLineBreak))
+            : "\n";
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorEngineSettings.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorEngineSettings.cs
new file mode 100644
index 00000000..f5769ad5
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorEngineSettings.cs
@@ -0,0 +1,107 @@
+using System.Text;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using SharpLsp.Sidecar.Common;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// A project's Razor configuration, read from the same inputs the SDK's generator reads: the
+/// <c>build_property</c> analyzer options, the C# parse options, and each file's
+/// <c>TargetPath</c>. Implements [RAZOR-ARCHITECTURE-ENGINE].
+/// </summary>
+internal sealed record RazorEngineSettings(
+    RazorConfiguration Configuration,
+    string RootNamespace,
+    bool LocalizedComponentNames,
+    string ProjectDirectory
+)
+{
+    private const string TargetPathKey = "build_metadata.AdditionalFiles.TargetPath";
+
+    /// <summary>The settings of <paramref name="project"/>, which has a project file.</summary>
+    public static RazorEngineSettings Read(Project project)
+    {
+        var options = project.AnalyzerOptions.AnalyzerConfigOptionsProvider.GlobalOptions;
+        var parse = project.ParseOptions as CSharpParseOptions ?? CSharpParseOptions.Default;
+        var configuration = new RazorConfiguration(
+            LanguageVersion(options),
+            "default",
+            [],
+            parse.LanguageVersion,
+            UseConsolidatedMvcViews: true,
+            SuppressAddComponentParameter: false,
+            UseRoslynTokenizer: Flag(parse.Features, "use-roslyn-tokenizer"),
+            PreprocessorSymbols: [.. parse.PreprocessorSymbolNames]
+        );
+        return new RazorEngineSettings(
+            configuration,
+            Property(options, "RootNamespace") ?? project.DefaultNamespace ?? project.AssemblyName,
+            string.Equals(
+                Property(options, "SupportLocalizedComponentNames"),
+                "true",
+                StringComparison.OrdinalIgnoreCase
+            ),
+            NativePaths.DirectoryOf(project.FilePath ?? "")
+        );
+    }
+
+    /// <summary>
+    /// The Razor project path of <paramref name="razor"/>: its <c>TargetPath</c> when MSBuild
+    /// gave one, else its path inside the project directory.
+    /// </summary>
+    public string RazorPathOf(TextDocument razor)
+    {
+        var target = TargetPath(razor);
+        return target is null
+            ? NativePaths.ToRazorProjectPath(ProjectDirectory, razor.FilePath ?? "")
+            : NativePaths.ToRazorProjectPath(target);
+    }
+
+    private static string? TargetPath(TextDocument razor)
+    {
+        var options = razor.Project.AnalyzerOptions;
+        var additional = options.AdditionalFiles.FirstOrDefault(file =>
+            NativePaths.AreEqual(file.Path, razor.FilePath)
+        );
+        return
+            additional is not null
+            && options
+                .AnalyzerConfigOptionsProvider.GetOptions(additional)
+                .TryGetValue(TargetPathKey, out var encoded)
+            ? Decode(encoded)
+            : null;
+    }
+
+    private static string? Decode(string encoded)
+    {
+        var bytes = new byte[encoded.Length];
+        return Convert.TryFromBase64String(encoded, bytes, out var written)
+            ? Encoding.UTF8.GetString(bytes, 0, written)
+            : null;
+    }
+
+    private static RazorLanguageVersion LanguageVersion(AnalyzerConfigOptions options)
+    {
+        return
+            Property(options, "RazorLangVersion") is { } value
+            && RazorLanguageVersion.TryParse(value, out var version)
+            ? version
+            : RazorLanguageVersion.Latest;
+    }
+
+    private static string? Property(AnalyzerConfigOptions options, string name)
+    {
+        return options.TryGetValue("build_property." + name, out var value) && value.Length > 0
+            ? value
+            : null;
+    }
+
+    private static bool Flag(IReadOnlyDictionary<string, string> features, string name)
+    {
+        return features.TryGetValue(name, out var value)
+            && string.Equals(value, "true", StringComparison.OrdinalIgnoreCase);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorHtmlComments.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorHtmlComments.cs
new file mode 100644
index 00000000..a7ad53db
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorHtmlComments.cs
@@ -0,0 +1,116 @@
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.Intermediate;
+using Microsoft.CodeAnalysis.Razor;
+using Microsoft.CodeAnalysis.Text;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Component lowering discards HTML comments. A markup-only compiler pass retains their
+/// token boundaries; only those spans are restored. Implements [RAZOR-ARCHITECTURE-HTML].
+/// </summary>
+internal static class RazorHtmlComments
+{
+    public static RazorMarkup Restore(
+        RazorProjectEngine original,
+        RazorCodeDocument document,
+        RazorMarkup markup,
+        CancellationToken ct
+    )
+    {
+        if (!document.FileKind.IsComponent())
+        {
+            return markup;
+        }
+
+        var spans = ReadComments(original, document, ct);
+        return markup with
+        {
+            HtmlText = RestoreSpans(document.Source.Text, markup.HtmlText, spans),
+        };
+    }
+
+    private static List<TextSpan> ReadComments(
+        RazorProjectEngine original,
+        RazorCodeDocument document,
+        CancellationToken ct
+    )
+    {
+        var comments = new CommentPass();
+        var engine = CreateEngine(original, comments);
+        var input = RazorCodeDocument.Create(
+            document.Source,
+            document.Imports,
+            document.ParserOptions.WithFlags(allowComponentFileKind: false),
+            document.CodeGenerationOptions
+        );
+        _ = engine.Engine.Process(input, ct);
+        return comments.Spans;
+    }
+
+    private static string RestoreSpans(SourceText source, string html, IEnumerable<TextSpan> spans)
+    {
+        var chars = html.ToCharArray();
+        foreach (var span in spans)
+        {
+            source.CopyTo(span.Start, chars, span.Start, span.Length);
+        }
+        return new string(chars);
+    }
+
+    private static RazorProjectEngine CreateEngine(
+        RazorProjectEngine original,
+        CommentPass comments
+    )
+    {
+        return RazorProjectEngine.Create(
+            original.Configuration,
+            original.FileSystem,
+            builder =>
+            {
+                CompilerFeatures.Register(builder);
+                builder.Features.Add(comments);
+            }
+        );
+    }
+
+    private sealed class CommentPass : IntermediateNodePassBase, IRazorDirectiveClassifierPass
+    {
+        public override int Order => int.MinValue;
+        public List<TextSpan> Spans { get; } = [];
+
+        protected override void ExecuteCore(
+            RazorCodeDocument document,
+            DocumentIntermediateNode root,
+            CancellationToken ct
+        )
+        {
+            int? start = null;
+            foreach (var token in RazorIr.Descendants(root).OfType<HtmlIntermediateToken>())
+            {
+                start = ReadToken(token, start);
+            }
+            // Incomplete comments remain one HTML token, without a standalone opening delimiter.
+        }
+
+        private int? ReadToken(HtmlIntermediateToken token, int? start)
+        {
+            if (
+                token is { IsImported: false, Source: { } source, Content: "<!--" }
+                && start is null
+            )
+            {
+                return source.AbsoluteIndex;
+            }
+            if (
+                token is { IsImported: false, Source: { } end, Content: "-->" }
+                && start is { } first
+            )
+            {
+                Spans.Add(TextSpan.FromBounds(first, end.AbsoluteIndex + end.Length));
+                return null;
+            }
+            return start;
+        }
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorHtmlProjection.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorHtmlProjection.cs
new file mode 100644
index 00000000..7c8c88e7
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorHtmlProjection.cs
@@ -0,0 +1,169 @@
+using Microsoft.AspNetCore.Razor.Language.Intermediate;
+using Microsoft.CodeAnalysis.Text;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Keeps only compiler-owned HTML spans. Everything else starts blank, including Razor
+/// comments and C# transitions absent from the IR. Implements [RAZOR-ARCHITECTURE-HTML].
+/// </summary>
+internal static class RazorHtmlProjection
+{
+    public static string Create(SourceText text, DocumentIntermediateNode root)
+    {
+        var chars = text.ToString().Select(Blank).ToArray();
+        Write(root, text, chars);
+        return new string(chars);
+    }
+
+    private static void Write(IntermediateNode node, SourceText text, char[] chars)
+    {
+        if (node.IsImported)
+        {
+            return;
+        }
+
+        WriteNode(node, text, chars);
+        foreach (var child in node.Children)
+        {
+            Write(child, text, chars);
+        }
+    }
+
+    private static void WriteNode(IntermediateNode node, SourceText text, char[] chars)
+    {
+        if (RazorIr.Tag(node, text) is { } tag)
+        {
+            WriteTag(node, tag, text, chars);
+        }
+        else
+        {
+            WriteLiteral(node, text, chars);
+        }
+    }
+
+    private static void WriteLiteral(IntermediateNode node, SourceText text, char[] chars)
+    {
+        if (node.Source is not { } source)
+        {
+            return;
+        }
+
+        var span = new TextSpan(source.AbsoluteIndex, source.Length);
+        if (node is HtmlIntermediateToken or HtmlAttributeValueIntermediateNode)
+        {
+            Copy(text, chars, span);
+        }
+        else if (node is HtmlAttributeIntermediateNode attribute)
+        {
+            CopyAttribute(text, chars, span, attribute);
+        }
+    }
+
+    private static void CopyAttribute(
+        SourceText text,
+        char[] chars,
+        TextSpan span,
+        HtmlAttributeIntermediateNode attribute
+    )
+    {
+        var prefixLength = attribute.Prefix?.Length ?? 0;
+        var suffixLength = attribute.Suffix?.Length ?? 0;
+        Copy(text, chars, new TextSpan(span.Start, prefixLength));
+        Copy(text, chars, new TextSpan(span.End - suffixLength, suffixLength));
+    }
+
+    private static void WriteTag(
+        IntermediateNode node,
+        MarkupTag tag,
+        SourceText text,
+        char[] chars
+    )
+    {
+        var attributes = Attributes(node);
+        Copy(
+            text,
+            chars,
+            TextSpan.FromBounds(tag.Element.Start, OpeningEnd(text, tag.Element, attributes))
+        );
+        foreach (var attribute in attributes)
+        {
+            Clear(chars, attribute);
+        }
+
+        if (tag.EndName is { } end)
+        {
+            Copy(text, chars, TextSpan.FromBounds(end.Start - 2, tag.Element.End));
+        }
+    }
+
+    private static TextSpan[] Attributes(IntermediateNode node)
+    {
+        return
+        [
+            .. node
+                .Children.Where(IsAttribute)
+                .Where(child => child.Source is not null)
+                .Select(child => new TextSpan(
+                    child.Source!.Value.AbsoluteIndex,
+                    child.Source.Value.Length
+                )),
+        ];
+    }
+
+    private static bool IsAttribute(IntermediateNode node)
+    {
+        return node
+            is HtmlAttributeIntermediateNode
+                or TagHelperHtmlAttributeIntermediateNode
+                or TagHelperPropertyIntermediateNode
+                or TagHelperDirectiveAttributeIntermediateNode
+                or TagHelperDirectiveAttributeParameterIntermediateNode;
+    }
+
+    /// <summary>Tokenizes only an IR-owned opening tag; compiler attribute spans are opaque.</summary>
+    private static int OpeningEnd(SourceText text, TextSpan element, TextSpan[] attributes)
+    {
+        var quote = '\0';
+        foreach (
+            var offset in Enumerable
+                .Range(element.Start, element.Length)
+                .Where(index => !attributes.Any(span => span.Contains(index)))
+        )
+        {
+            var character = text[offset];
+            if (quote == '\0' && character == '>')
+            {
+                return offset + 1;
+            }
+
+            quote =
+                character == quote ? '\0'
+                : quote == '\0' && character is '\'' or '"' ? character
+                : quote;
+        }
+
+        return element.End;
+    }
+
+    private static void Copy(SourceText text, char[] chars, TextSpan span)
+    {
+        if (span.End <= text.Length)
+        {
+            text.CopyTo(span.Start, chars, span.Start, span.Length);
+        }
+    }
+
+    private static void Clear(char[] chars, TextSpan span)
+    {
+        for (var offset = span.Start; offset < span.End && offset < chars.Length; offset++)
+        {
+            chars[offset] = Blank(chars[offset]);
+        }
+    }
+
+    private static char Blank(char character)
+    {
+        return character is '\r' or '\n' ? character : ' ';
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorIr.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorIr.cs
new file mode 100644
index 00000000..297c2b60
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorIr.cs
@@ -0,0 +1,247 @@
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.Intermediate;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Facts read from single IR nodes. Every span comes from the compiler; where a node lacks
+/// one (an end tag's name, a directive's name) it is derived from the node's span and then
+/// verified against the text, so a span the compiler did not shape that way is never
+/// reported. Implements [RAZOR-ARCHITECTURE-ENGINE].
+/// </summary>
+internal static class RazorIr
+{
+    /// <summary>Every node under <paramref name="root"/>, parents before children.</summary>
+    public static IEnumerable<IntermediateNode> Descendants(IntermediateNode root)
+    {
+        var pending = new Stack<IntermediateNode>([root]);
+        while (pending.TryPop(out var node))
+        {
+            yield return node;
+            foreach (var child in node.Children.Reverse())
+            {
+                pending.Push(child);
+            }
+        }
+    }
+
+    /// <summary>The directive a node declares: a <c>DirectiveIntermediateNode</c> or an <c>@using</c>.</summary>
+    public static MarkupDirective? Directive(IntermediateNode node, SourceText text)
+    {
+        return node switch
+        {
+            DirectiveIntermediateNode { Source: { } source } directive => Named(
+                directive.DirectiveName,
+                Span(source),
+                1,
+                directive.Directive,
+                text
+            ),
+            UsingDirectiveIntermediateNode { Source: { } source } => Named(
+                "using",
+                Span(source),
+                0,
+                null,
+                text
+            ),
+            _ => null,
+        };
+    }
+
+    /// <summary>The namespace an <c>@using</c> imports, without a <c>global::</c> qualifier; null for an alias or static using.</summary>
+    public static string? Namespace(UsingDirectiveIntermediateNode use)
+    {
+        var name = SyntaxFactory.ParseName(use.Content ?? "");
+        if (name.ContainsDiagnostics || name.FullSpan.Length != (use.Content ?? "").Length)
+        {
+            return null;
+        }
+
+        var global = name.DescendantNodesAndSelf()
+            .OfType<AliasQualifiedNameSyntax>()
+            .FirstOrDefault();
+        return (global is null ? name : name.ReplaceNode(global, global.Name)).ToString();
+    }
+
+    /// <summary>The tag a node is: an element bound to tag helpers, or a plain component-file element.</summary>
+    public static MarkupTag? Tag(IntermediateNode node, SourceText text)
+    {
+        return node switch
+        {
+            TagHelperIntermediateNode { Source: { } source, StartTagSpan: { } start } bound =>
+                new MarkupTag(
+                    bound.TagName,
+                    Span(source),
+                    Span(start),
+                    bound.TagMode == TagMode.StartTagAndEndTag
+                        ? EndName(Span(source), bound.TagName, text)
+                        : null,
+                    [.. bound.TagHelpers]
+                ),
+            MarkupElementIntermediateNode { Source: { } source } element => PlainTag(
+                element.TagName,
+                Span(source),
+                text
+            ),
+            _ => null,
+        };
+    }
+
+    /// <summary>The attributes of a tag node, each with what binds it.</summary>
+    public static IEnumerable<MarkupAttribute> Attributes(
+        IntermediateNode node,
+        MarkupTag tag,
+        SourceText text
+    )
+    {
+        return node.Children.Select(child => Attribute(child, tag, text)).OfType<MarkupAttribute>();
+    }
+
+    /// <summary>Whether a diagnostic belongs to the processed file, not to one of its imports.</summary>
+    public static bool IsIn(RazorDiagnostic diagnostic, string? path, SourceText text)
+    {
+        var span = diagnostic.Span;
+        return span.AbsoluteIndex >= 0
+            && span.AbsoluteIndex + span.Length <= text.Length
+            && (string.IsNullOrEmpty(span.FilePath) || NativePaths.AreEqual(span.FilePath, path));
+    }
+
+    private static MarkupAttribute? Attribute(
+        IntermediateNode child,
+        MarkupTag tag,
+        SourceText text
+    )
+    {
+        return child switch
+        {
+            TagHelperPropertyIntermediateNode property => new MarkupAttribute(
+                MarkupAttributeKind.Property,
+                property.AttributeName,
+                property.OriginalAttributeSpan is { } span ? Span(span) : null,
+                tag,
+                property.TagHelper,
+                property.BoundAttribute,
+                null
+            ),
+            TagHelperDirectiveAttributeIntermediateNode directive => new MarkupAttribute(
+                MarkupAttributeKind.Directive,
+                directive.OriginalAttributeName,
+                DirectiveName(
+                    directive.OriginalAttributeSpan,
+                    directive.OriginalAttributeName,
+                    text
+                ),
+                tag,
+                directive.TagHelper,
+                directive.BoundAttribute,
+                null
+            ),
+            TagHelperDirectiveAttributeParameterIntermediateNode parameter => new MarkupAttribute(
+                MarkupAttributeKind.DirectiveParameter,
+                parameter.OriginalAttributeName,
+                DirectiveName(
+                    parameter.OriginalAttributeSpan,
+                    parameter.OriginalAttributeName,
+                    text
+                ),
+                tag,
+                parameter.TagHelper,
+                parameter.BoundAttribute,
+                parameter.BoundAttributeParameter
+            ),
+            TagHelperHtmlAttributeIntermediateNode html => Html(html.AttributeName, tag),
+            HtmlAttributeIntermediateNode html => Html(html.AttributeName, tag),
+            _ => null,
+        };
+    }
+
+    private static MarkupAttribute Html(string name, MarkupTag tag)
+    {
+        return new MarkupAttribute(MarkupAttributeKind.Html, name, null, tag, null, null, null);
+    }
+
+    private static MarkupTag? PlainTag(string name, TextSpan element, SourceText text)
+    {
+        var start = new TextSpan(element.Start + 1, name.Length);
+        return Holds(text, start, name)
+            ? new MarkupTag(
+                name,
+                element,
+                start,
+                EndName(element, name, text, StringComparison.OrdinalIgnoreCase),
+                []
+            )
+            : null;
+    }
+
+    /// <summary>A directive attribute's name, <c>@</c> included, from the span of what follows the <c>@</c>.</summary>
+    public static TextSpan? DirectiveName(SourceSpan? original, string name, SourceText text)
+    {
+        if (original is not { } span)
+        {
+            return null;
+        }
+
+        var withTransition = new TextSpan(span.AbsoluteIndex - 1, name.Length);
+        return withTransition.Start >= 0 && Holds(text, withTransition, name)
+            ? withTransition
+            : Span(span);
+    }
+
+    /// <summary>The name of an element's end tag, <c>&lt;/Name&gt;</c> closing <paramref name="element"/>.</summary>
+    private static TextSpan? EndName(
+        TextSpan element,
+        string name,
+        SourceText text,
+        StringComparison comparison = StringComparison.Ordinal
+    )
+    {
+        var nameEnd = element.End - 1;
+        while (nameEnd > element.Start && text[nameEnd - 1] is ' ' or '\t' or '\r' or '\n' or '\f')
+        {
+            nameEnd--;
+        }
+        var end = new TextSpan(nameEnd - name.Length, name.Length);
+        return
+            end.Start >= element.Start + 2
+            && Holds(text, new TextSpan(end.Start - 2, 2), "</")
+            && Holds(text, end, name, comparison)
+            && Holds(text, new TextSpan(element.End - 1, 1), ">")
+            ? end
+            : null;
+    }
+
+    private static MarkupDirective? Named(
+        string name,
+        TextSpan span,
+        int nameOffset,
+        DirectiveDescriptor? descriptor,
+        SourceText text
+    )
+    {
+        var nameSpan = new TextSpan(span.Start + nameOffset, name.Length);
+        return Holds(text, nameSpan, name)
+            ? new MarkupDirective(name, span, nameSpan, descriptor)
+            : null;
+    }
+
+    private static bool Holds(
+        SourceText text,
+        TextSpan span,
+        string expected,
+        StringComparison comparison = StringComparison.Ordinal
+    )
+    {
+        return span.End <= text.Length && string.Equals(text.ToString(span), expected, comparison);
+    }
+
+    private static TextSpan Span(SourceSpan span)
+    {
+        return new TextSpan(span.AbsoluteIndex, span.Length);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorLocations.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorLocations.cs
new file mode 100644
index 00000000..3a167f8d
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorLocations.cs
@@ -0,0 +1,132 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Workspace;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Moves C# answers out of Razor projections. Roslyn already maps a location inside a C#
+/// fragment to its Razor file; a location still in a projection is hidden scaffolding and is
+/// dropped, except a component's own class declaration, which lands at the start of its Razor
+/// file because a component is its file. Implements [RAZOR-ARCHITECTURE-PROJECTION].
+/// </summary>
+internal static class RazorLocations
+{
+    /// <summary><paramref name="result"/> with every projection location mapped or dropped.</summary>
+    public static async Task<LocationListResult> MapAsync(
+        Solution solution,
+        LocationListResult result,
+        CancellationToken ct
+    )
+    {
+        // One lookup per file this request touches, not per location.
+        var projections = new Dictionary<string, RazorProjection?>(NativePaths.Comparer);
+        var mapped = new List<LocationResult>();
+        foreach (var location in result.Locations)
+        {
+            if (!projections.TryGetValue(location.FilePath, out var projection))
+            {
+                projection = await FindProjectionAsync(solution, location.FilePath, ct)
+                    .ConfigureAwait(false);
+                projections[location.FilePath] = projection;
+            }
+
+            if (Map(projection, location) is { } kept)
+            {
+                mapped.Add(kept);
+            }
+        }
+
+        return new LocationListResult { Locations = [.. mapped.DistinctBy(Key)] };
+    }
+
+    /// <summary><paramref name="location"/> mapped out of a projection, or null when it is hidden scaffolding.</summary>
+    public static async Task<LocationResult?> MapAsync(
+        Solution solution,
+        LocationResult? location,
+        CancellationToken ct
+    )
+    {
+        if (location is null)
+        {
+            return null;
+        }
+
+        var projection = await FindProjectionAsync(solution, location.FilePath, ct)
+            .ConfigureAwait(false);
+        return Map(projection, location);
+    }
+
+    private static LocationResult? Map(RazorProjection? projection, LocationResult location)
+    {
+        return projection is null ? location : ComponentFileStart(projection, location);
+    }
+
+    /// <summary>
+    /// The projection whose generated document lives at <paramref name="path"/>; null for a
+    /// regular document, decompiled source, or a generated document that is not a projection.
+    /// Only projects that list a Razor file have projections, so no other project runs its
+    /// generators for the lookup.
+    /// </summary>
+    public static async Task<RazorProjection?> FindProjectionAsync(
+        Solution solution,
+        string path,
+        CancellationToken ct
+    )
+    {
+        if (SolutionPaths.FindDocument(solution, path) is not null)
+        {
+            return null;
+        }
+
+        foreach (var project in SolutionPaths.RazorProjects(solution))
+        {
+            var generated = await project
+                .GetSourceGeneratedDocumentsAsync(ct)
+                .ConfigureAwait(false);
+            if (
+                generated.FirstOrDefault(document =>
+                    NativePaths.AreEqual(document.FilePath, path)
+                ) is
+                { } found
+            )
+            {
+                return await RazorProjection.ForGeneratedAsync(found, ct).ConfigureAwait(false);
+            }
+        }
+
+        return null;
+    }
+
+    private static LocationResult? ComponentFileStart(
+        RazorProjection projection,
+        LocationResult location
+    )
+    {
+        var position = new LinePosition(location.Line, location.Character);
+        return
+            DocumentText.TryOffset(projection.GeneratedText, position) is { } offset
+            && DeclaresComponentClass(projection.GeneratedRoot.FindToken(offset))
+            ? new LocationResult { FilePath = projection.RazorPath }
+            : null;
+    }
+
+    private static bool DeclaresComponentClass(SyntaxToken token)
+    {
+        return token.Parent is ClassDeclarationSyntax declaration
+            && declaration.Identifier == token;
+    }
+
+    private static (string, int, int, int, int) Key(LocationResult location)
+    {
+        return (
+            NativePaths.IdentityOf(location.FilePath),
+            location.Line,
+            location.Character,
+            location.EndLine,
+            location.EndCharacter
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkup.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkup.cs
new file mode 100644
index 00000000..8ca7e5af
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkup.cs
@@ -0,0 +1,137 @@
+using System.Collections.Immutable;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis.Text;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>What a markup attribute is to the compiler.</summary>
+internal enum MarkupAttributeKind
+{
+    /// <summary>A component parameter or tag helper property: <c>Title="…"</c>, <c>asp-for="…"</c>.</summary>
+    Property,
+
+    /// <summary>A directive attribute: <c>@onclick</c>, <c>@bind-Value</c>, <c>@ref</c>.</summary>
+    Directive,
+
+    /// <summary>A directive attribute parameter: <c>@bind:event</c>, <c>@onclick:preventDefault</c>.</summary>
+    DirectiveParameter,
+
+    /// <summary>An attribute no tag helper binds.</summary>
+    Html,
+}
+
+/// <summary>An element of the file, with the tag helpers (components included) the compiler bound to it.</summary>
+internal sealed record MarkupTag(
+    string Name,
+    TextSpan Element,
+    TextSpan StartName,
+    TextSpan? EndName,
+    ImmutableArray<TagHelperDescriptor> TagHelpers
+)
+{
+    /// <summary>The component this tag instantiates, if any.</summary>
+    public TagHelperDescriptor? Component =>
+        TagHelpers.FirstOrDefault(helper => helper.Kind == TagHelperKind.Component);
+
+    /// <summary>The child-content parameter this tag sets, if any (<c>&lt;ChildContent&gt;</c>).</summary>
+    public TagHelperDescriptor? ChildContent =>
+        TagHelpers.FirstOrDefault(helper => helper.Kind == TagHelperKind.ChildContent);
+
+    /// <summary>The MVC tag helpers bound to this tag.</summary>
+    public IEnumerable<TagHelperDescriptor> MvcTagHelpers =>
+        TagHelpers.Where(helper =>
+            helper.Kind is TagHelperKind.ITagHelper or TagHelperKind.ViewComponent
+        );
+
+    /// <summary>Whether <paramref name="offset"/> lies on the start or end tag's name.</summary>
+    public bool NameContains(int offset)
+    {
+        return Touches(StartName, offset) || (EndName is { } end && Touches(end, offset));
+    }
+
+    private static bool Touches(TextSpan span, int offset)
+    {
+        return span.Start <= offset && offset <= span.End;
+    }
+}
+
+/// <summary>An attribute of a tag, with what binds it.</summary>
+internal sealed record MarkupAttribute(
+    MarkupAttributeKind Kind,
+    string Name,
+    TextSpan? NameSpan,
+    MarkupTag Owner,
+    TagHelperDescriptor? TagHelper,
+    BoundAttributeDescriptor? Bound,
+    BoundAttributeParameterDescriptor? Parameter
+);
+
+/// <summary>A directive the file declares: <c>@page</c>, <c>@inject</c>, <c>@code</c>, <c>@using</c>.</summary>
+internal sealed record MarkupDirective(
+    string Name,
+    TextSpan Span,
+    TextSpan NameSpan,
+    DirectiveDescriptor? Descriptor
+);
+
+/// <summary>A Razor (<c>RZ</c>) diagnostic of the file.</summary>
+internal sealed record MarkupDiagnostic(
+    string Id,
+    string Message,
+    RazorDiagnosticSeverity Severity,
+    TextSpan Span
+);
+
+/// <summary>
+/// A Razor file's markup facts, read from the compiler's intermediate representation.
+/// Implements [RAZOR-ARCHITECTURE-ENGINE].
+/// </summary>
+internal sealed record RazorMarkup(
+    SourceText Text,
+    RazorFileKind FileKind,
+    string? Namespace,
+    ImmutableArray<string> ImportedNamespaces,
+    ImmutableArray<MarkupTag> Tags,
+    ImmutableArray<MarkupAttribute> Attributes,
+    ImmutableArray<MarkupDirective> Directives,
+    ImmutableArray<MarkupDiagnostic> Diagnostics,
+    ImmutableArray<DirectiveDescriptor> AvailableDirectives,
+    TagHelperCollection TagHelpers
+)
+{
+    /// <summary>Position-preserving HTML for [RAZOR-ARCHITECTURE-HTML].</summary>
+    public string HtmlText { get; init; } = "";
+
+    /// <summary>The caret's HTML context, [RAZOR-ARCHITECTURE-HTML].</summary>
+    public MarkupContext ContextAt(int offset)
+    {
+        return HtmlMarkupContext.At(HtmlText, offset);
+    }
+
+    /// <summary>The innermost tag whose start or end name holds <paramref name="offset"/>.</summary>
+    public MarkupTag? TagNamedAt(int offset)
+    {
+        return Tags.Where(tag => tag.NameContains(offset))
+            .OrderBy(tag => tag.Element.Length)
+            .FirstOrDefault();
+    }
+
+    /// <summary>The bound attribute whose name holds <paramref name="offset"/>.</summary>
+    public MarkupAttribute? AttributeNamedAt(int offset)
+    {
+        return Attributes.FirstOrDefault(attribute =>
+            attribute.Kind != MarkupAttributeKind.Html
+            && attribute.NameSpan is { } name
+            && name.Start <= offset
+            && offset <= name.End
+        );
+    }
+
+    /// <summary>The directive whose name holds <paramref name="offset"/>.</summary>
+    public MarkupDirective? DirectiveNamedAt(int offset)
+    {
+        return Directives.FirstOrDefault(directive =>
+            directive.NameSpan.Start <= offset && offset <= directive.NameSpan.End
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupCapture.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupCapture.cs
new file mode 100644
index 00000000..1407fffc
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupCapture.cs
@@ -0,0 +1,149 @@
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.Intermediate;
+using Microsoft.CodeAnalysis.Text;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Reads markup facts out of the compiler's IR while it is built. Directives are read first
+/// in the directive-classifier phase, before <c>@code</c> becomes plain C#; tags and
+/// attributes first in the optimization phase, before components are lowered and attribute
+/// names lose their spans; diagnostics last. The IR is mutated after each read, so each
+/// pass copies what it needs at once. Implements [RAZOR-ARCHITECTURE-ENGINE].
+/// </summary>
+internal sealed class RazorMarkupCapture
+{
+    private readonly List<MarkupDirective> _directives = [];
+    private readonly List<MarkupTag> _tags = [];
+    private readonly List<MarkupAttribute> _attributes = [];
+    private readonly List<MarkupDiagnostic> _diagnostics = [];
+    private readonly List<string> _namespaces = [];
+    private RazorCodeDocument? _codeDocument;
+    private string _htmlText = "";
+
+    /// <summary>Add the capture passes to an engine.</summary>
+    public void Register(RazorProjectEngineBuilder builder)
+    {
+        builder.Features.Add(new DirectivePass(this));
+        builder.Features.Add(new TagPass(this));
+        builder.Features.Add(new DiagnosticPass(this));
+    }
+
+    /// <summary>The facts captured while the engine processed one file.</summary>
+    public RazorMarkup? ToMarkup(TagHelperCollection tagHelpers)
+    {
+        return _codeDocument is not { } document
+            ? null
+            : new RazorMarkup(
+                document.Source.Text,
+                document.FileKind,
+                document.TryGetNamespace(true, out var ns) ? ns : null,
+                [.. _namespaces.Distinct(StringComparer.Ordinal)],
+                [.. _tags],
+                [.. _attributes],
+                [.. _directives],
+                [.. _diagnostics.Distinct()],
+                document.ParserOptions.Directives,
+                tagHelpers
+            )
+            {
+                HtmlText = _htmlText,
+            };
+    }
+
+    private void ReadDirectives(RazorCodeDocument document, DocumentIntermediateNode root)
+    {
+        var text = document.Source.Text;
+        _htmlText = RazorHtmlProjection.Create(text, root);
+        foreach (var node in RazorIr.Descendants(root).Where(node => !node.IsImported))
+        {
+            if (RazorIr.Directive(node, text) is { } directive)
+            {
+                _directives.Add(directive);
+            }
+        }
+    }
+
+    private void ReadTags(RazorCodeDocument document, DocumentIntermediateNode root)
+    {
+        _codeDocument = document;
+        var text = document.Source.Text;
+        foreach (var node in RazorIr.Descendants(root))
+        {
+            if (node is UsingDirectiveIntermediateNode use && RazorIr.Namespace(use) is { } ns)
+            {
+                _namespaces.Add(ns);
+            }
+            else if (!node.IsImported && RazorIr.Tag(node, text) is { } tag)
+            {
+                _tags.Add(tag);
+                _attributes.AddRange(RazorIr.Attributes(node, tag, text));
+            }
+        }
+    }
+
+    private void ReadDiagnostics(RazorCodeDocument document, DocumentIntermediateNode root)
+    {
+        var path = document.Source.FilePath;
+        _diagnostics.AddRange(
+            RazorIr
+                .Descendants(root)
+                .SelectMany(node => node.Diagnostics)
+                .Where(diagnostic => RazorIr.IsIn(diagnostic, path, document.Source.Text))
+                .Select(diagnostic => new MarkupDiagnostic(
+                    diagnostic.Id,
+                    diagnostic.GetMessage(System.Globalization.CultureInfo.InvariantCulture),
+                    diagnostic.Severity,
+                    new TextSpan(diagnostic.Span.AbsoluteIndex, diagnostic.Span.Length)
+                ))
+        );
+    }
+
+    private sealed class DirectivePass(RazorMarkupCapture capture)
+        : IntermediateNodePassBase,
+            IRazorDirectiveClassifierPass
+    {
+        public override int Order => int.MinValue;
+
+        protected override void ExecuteCore(
+            RazorCodeDocument codeDocument,
+            DocumentIntermediateNode documentNode,
+            CancellationToken cancellationToken
+        )
+        {
+            capture.ReadDirectives(codeDocument, documentNode);
+        }
+    }
+
+    private sealed class TagPass(RazorMarkupCapture capture)
+        : IntermediateNodePassBase,
+            IRazorOptimizationPass
+    {
+        public override int Order => int.MinValue;
+
+        protected override void ExecuteCore(
+            RazorCodeDocument codeDocument,
+            DocumentIntermediateNode documentNode,
+            CancellationToken cancellationToken
+        )
+        {
+            capture.ReadTags(codeDocument, documentNode);
+        }
+    }
+
+    private sealed class DiagnosticPass(RazorMarkupCapture capture)
+        : IntermediateNodePassBase,
+            IRazorOptimizationPass
+    {
+        public override int Order => int.MaxValue - 1;
+
+        protected override void ExecuteCore(
+            RazorCodeDocument codeDocument,
+            DocumentIntermediateNode documentNode,
+            CancellationToken cancellationToken
+        )
+        {
+            capture.ReadDiagnostics(codeDocument, documentNode);
+        }
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupEngine.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupEngine.cs
new file mode 100644
index 00000000..c0bad4e3
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupEngine.cs
@@ -0,0 +1,101 @@
+using System.Collections.Concurrent;
+using Microsoft.AspNetCore.Mvc.Razor.Extensions;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Razor;
+using Serilog;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Runs the bundled Razor compiler over one file of a project and returns its markup facts.
+/// The project's own SDK generator still produces the C# projection; this engine only reads
+/// markup structure. A failure answers null, so markup features answer empty while C#
+/// features keep working, and is logged once per project. Implements
+/// [RAZOR-ARCHITECTURE-ENGINE] and [RAZOR-ERRORS].
+/// </summary>
+internal static class RazorMarkupEngine
+{
+    private static readonly ConcurrentDictionary<string, byte> LoggedProjects = new(
+        StringComparer.Ordinal
+    );
+
+    /// <summary>The markup facts of <paramref name="razor"/>, or null when the engine cannot read it.</summary>
+    public static async Task<RazorMarkup?> ProcessAsync(TextDocument razor, CancellationToken ct)
+    {
+        try
+        {
+            return await ProcessCoreAsync(razor, ct).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            LogOnce(razor.Project, ex);
+            return null;
+        }
+    }
+
+    private static async Task<RazorMarkup?> ProcessCoreAsync(
+        TextDocument razor,
+        CancellationToken ct
+    )
+    {
+        var compilation = await razor.Project.GetCompilationAsync(ct).ConfigureAwait(false);
+        if (compilation is null || razor.Project.FilePath is null || razor.FilePath is null)
+        {
+            return null;
+        }
+
+        var settings = RazorEngineSettings.Read(razor.Project);
+        var fileSystem = await WorkspaceRazorFileSystem
+            .CreateAsync(razor, settings, ct)
+            .ConfigureAwait(false);
+        var tagHelpers = RazorTagHelpers.Of(compilation);
+        var capture = new RazorMarkupCapture();
+        var engine = CreateEngine(settings, fileSystem, tagHelpers, capture);
+        var document = engine.Process(fileSystem.GetItem(settings.RazorPathOf(razor), null), ct);
+        return capture.ToMarkup(tagHelpers) is { } markup
+            ? RazorHtmlComments.Restore(engine, document, markup, ct)
+            : null;
+    }
+
+    private static RazorProjectEngine CreateEngine(
+        RazorEngineSettings settings,
+        RazorProjectFileSystem fileSystem,
+        TagHelperCollection tagHelpers,
+        RazorMarkupCapture capture
+    )
+    {
+        return RazorProjectEngine.Create(
+            settings.Configuration,
+            fileSystem,
+            builder =>
+            {
+                builder.Features.Add(new RazorTagHelpers.Feature(tagHelpers));
+                CompilerFeatures.Register(builder);
+                RazorExtensions.Register(builder);
+                capture.Register(builder);
+                _ = builder.SetRootNamespace(settings.RootNamespace);
+                _ = builder.SetCSharpLanguageVersion(settings.Configuration.CSharpLanguageVersion);
+                _ = settings.LocalizedComponentNames
+                    ? builder.SetSupportLocalizedComponentNames()
+                    : builder;
+            }
+        );
+    }
+
+    private static void LogOnce(Project project, Exception ex)
+    {
+        if (LoggedProjects.TryAdd(project.FilePath ?? project.Name, 0))
+        {
+            Log.Warning(
+                "[Razor] Markup engine unavailable for {Project}: {ExceptionType}",
+                project.Name,
+                ex.GetType().Name
+            );
+        }
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupSymbols.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupSymbols.cs
new file mode 100644
index 00000000..a0c5f372
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMarkupSymbols.cs
@@ -0,0 +1,92 @@
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// The C# symbols behind markup: the type a component or tag helper descriptor names, and
+/// the property a bound attribute sets. Implements [RAZOR-FEATURES-HOVER] and
+/// [RAZOR-FEATURES-DEFINITION].
+/// </summary>
+internal static class RazorMarkupSymbols
+{
+    /// <summary>The type <paramref name="descriptor"/> names in <paramref name="compilation"/>.</summary>
+    public static INamedTypeSymbol? TypeOf(Compilation compilation, TagHelperDescriptor descriptor)
+    {
+        // A generic component's type name ends in its type parameters: `Shared.Tally<TItem>`.
+        // A name's arity counts only its own, so a qualified name asks its rightmost part.
+        var name = SyntaxFactory.ParseName(descriptor.TypeName);
+        var arity = (name is QualifiedNameSyntax qualified ? qualified.Right : name).Arity;
+        var prefix = string.IsNullOrEmpty(descriptor.TypeNamespace)
+            ? ""
+            : descriptor.TypeNamespace + ".";
+        var suffix = arity > 0 ? "`" + arity : "";
+        return compilation.GetTypeByMetadataName(prefix + descriptor.TypeNameIdentifier + suffix);
+    }
+
+    /// <summary>The property named <paramref name="name"/> on <paramref name="type"/> or a base type.</summary>
+    public static IPropertySymbol? PropertyOf(INamedTypeSymbol type, string name)
+    {
+        for (var current = type; current is not null; current = current.BaseType)
+        {
+            if (current.GetMembers(name).OfType<IPropertySymbol>().FirstOrDefault() is { } found)
+            {
+                return found;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>The type a tag instantiates: its component, else its first MVC tag helper.</summary>
+    public static INamedTypeSymbol? TypeOf(Compilation compilation, MarkupTag tag)
+    {
+        var descriptor = tag.Component ?? tag.MvcTagHelpers.FirstOrDefault();
+        return descriptor is null ? null : TypeOf(compilation, descriptor);
+    }
+
+    /// <summary>
+    /// The property an attribute sets: a component parameter, a tag helper property, or the
+    /// parameter a <c>@bind-X</c> binds. Directive attributes such as <c>@onclick</c> set none.
+    /// </summary>
+    public static IPropertySymbol? PropertyOf(Compilation compilation, MarkupAttribute attribute)
+    {
+        var type = attribute.TagHelper is { } helper ? TypeOf(compilation, helper) : null;
+        return type is null || BoundProperty(attribute) is not { } name
+            ? null
+            : PropertyOf(type, name);
+    }
+
+    /// <summary>The parameter a <c>&lt;ChildContent&gt;</c>-style tag sets on its enclosing component.</summary>
+    public static IPropertySymbol? ChildContentOf(
+        Compilation compilation,
+        RazorMarkup markup,
+        MarkupTag tag
+    )
+    {
+        var parent = markup
+            .Tags.Where(candidate =>
+                candidate.Component is not null
+                && candidate.Element.Contains(tag.Element)
+                && candidate.Element != tag.Element
+            )
+            .OrderBy(candidate => candidate.Element.Length)
+            .FirstOrDefault();
+        var type = parent is null ? null : TypeOf(compilation, parent);
+        return type is null ? null : PropertyOf(type, tag.Name);
+    }
+
+    private static string? BoundProperty(MarkupAttribute attribute)
+    {
+        var binds =
+            attribute.Kind == MarkupAttributeKind.Property
+            || (
+                attribute.Kind == MarkupAttributeKind.Directive
+                && attribute.TagHelper is { Kind: TagHelperKind.Bind } helper
+                && helper.Name != "Bind"
+            );
+        return binds ? attribute.Bound?.PropertyName : null;
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMessages.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMessages.cs
new file mode 100644
index 00000000..4491668f
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorMessages.cs
@@ -0,0 +1,56 @@
+using MessagePack;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// A nested document symbol. Positionally identical to the F# sidecar's
+/// <c>DocumentSymbolResult</c>, so the host decodes both with one wire type.
+/// Implements [RAZOR-FEATURES-STRUCTURE].
+/// </summary>
+[MessagePackObject(AllowPrivate = true)]
+internal sealed class DocumentSymbolResult
+{
+    [Key(0)]
+    public string Name { get; set; } = "";
+
+    [Key(1)]
+    public string Kind { get; set; } = "";
+
+    [Key(2)]
+    public int StartLine { get; init; }
+
+    [Key(3)]
+    public int StartCharacter { get; init; }
+
+    [Key(4)]
+    public int EndLine { get; init; }
+
+    [Key(5)]
+    public int EndCharacter { get; init; }
+
+    [Key(6)]
+    public int SelectionStartLine { get; init; }
+
+    [Key(7)]
+    public int SelectionStartCharacter { get; init; }
+
+    [Key(8)]
+    public int SelectionEndLine { get; init; }
+
+    [Key(9)]
+    public int SelectionEndCharacter { get; init; }
+
+    [Key(10)]
+    public List<DocumentSymbolResult> Children { get; set; } = [];
+}
+
+/// <summary>A foldable line range. Implements [RAZOR-FEATURES-STRUCTURE].</summary>
+[MessagePackObject(AllowPrivate = true)]
+internal sealed class FoldingRangeResult
+{
+    [Key(0)]
+    public int StartLine { get; init; }
+
+    [Key(1)]
+    public int EndLine { get; init; }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorProjection.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorProjection.cs
new file mode 100644
index 00000000..b2eafaab
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorProjection.cs
@@ -0,0 +1,107 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Workspace;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// A Razor file and its C# projection: the source-generated document whose
+/// <c>#pragma checksum</c> names that file, with the verified map between the two.
+/// Implements [RAZOR-ARCHITECTURE-PROJECTION].
+/// </summary>
+internal sealed record RazorProjection(
+    TextDocument Razor,
+    SourceText RazorText,
+    SourceGeneratedDocument Generated,
+    SourceText GeneratedText,
+    SyntaxNode GeneratedRoot,
+    RazorSpanMap Map
+)
+{
+    /// <summary>The Razor file's path, which its projection's checksum names, so never null.</summary>
+    public string RazorPath => Razor.FilePath!;
+
+    /// <summary>The projection of <paramref name="razor"/>, or null when its project generates none.</summary>
+    public static async Task<RazorProjection?> ForRazorAsync(
+        TextDocument razor,
+        CancellationToken ct
+    )
+    {
+        var generatedDocuments = await razor
+            .Project.GetSourceGeneratedDocumentsAsync(ct)
+            .ConfigureAwait(false);
+        foreach (var generated in generatedDocuments)
+        {
+            var root = await generated.GetSyntaxRootAsync(ct).ConfigureAwait(false);
+            if (NativePaths.AreEqual(ChecksumPath(root), razor.FilePath))
+            {
+                return await CreateAsync(razor, generated, root!, ct).ConfigureAwait(false);
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>The projection that <paramref name="generated"/> is, or null when it names no Razor file.</summary>
+    public static async Task<RazorProjection?> ForGeneratedAsync(
+        SourceGeneratedDocument generated,
+        CancellationToken ct
+    )
+    {
+        var root = await generated.GetSyntaxRootAsync(ct).ConfigureAwait(false);
+        var path = ChecksumPath(root);
+        var razor = generated.Project.AdditionalDocuments.FirstOrDefault(document =>
+            NativePaths.IsRazor(path) && NativePaths.AreEqual(document.FilePath, path)
+        );
+        return razor is null
+            ? null
+            : await CreateAsync(razor, generated, root!, ct).ConfigureAwait(false);
+    }
+
+    /// <summary>The file a generated document's <c>#pragma checksum</c> names.</summary>
+    internal static string? ChecksumPath(SyntaxNode? root)
+    {
+        return
+            root is CSharpSyntaxNode node
+            && node.GetFirstDirective(directive => directive is PragmaChecksumDirectiveTriviaSyntax)
+                is PragmaChecksumDirectiveTriviaSyntax pragma
+            ? pragma.File.ValueText
+            : null;
+    }
+
+    /// <summary>The generated position of a Razor position inside a C# fragment.</summary>
+    public LinePosition? ToGenerated(LinePosition razorPosition)
+    {
+        return
+            DocumentText.TryOffset(RazorText, razorPosition) is { } offset
+            && Map.ToGenerated(offset) is { } generated
+            ? GeneratedText.Lines.GetLinePosition(generated)
+            : null;
+    }
+
+    /// <summary>The Razor range of a generated range that lies inside one fragment.</summary>
+    public LinePositionSpan? ToRazor(LinePositionSpan generatedSpan)
+    {
+        return
+            DocumentText.TrySpan(GeneratedText, generatedSpan) is { } span
+            && Map.ToRazor(span) is { } razor
+            ? RazorText.Lines.GetLinePositionSpan(razor)
+            : null;
+    }
+
+    private static async Task<RazorProjection> CreateAsync(
+        TextDocument razor,
+        SourceGeneratedDocument generated,
+        SyntaxNode root,
+        CancellationToken ct
+    )
+    {
+        var razorText = await razor.GetTextAsync(ct).ConfigureAwait(false);
+        var generatedText = await generated.GetTextAsync(ct).ConfigureAwait(false);
+        var map = RazorSpanMap.Build(root.SyntaxTree, generatedText, razorText, razor.FilePath!);
+        return new RazorProjection(razor, razorText, generated, generatedText, root, map);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorRenameEdits.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorRenameEdits.cs
new file mode 100644
index 00000000..c56164e9
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorRenameEdits.cs
@@ -0,0 +1,100 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.FindSymbols;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Workspace;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// The Razor half of a rename. Roslyn's renamer edits regular documents only, never the
+/// projections, so each declaration and use that Roslyn maps into a Razor file is edited
+/// there, at its mapped span, when that span holds the old name. Hidden scaffolding maps to
+/// no Razor span and is never edited. Implements [RAZOR-FEATURES-RENAME].
+/// </summary>
+internal static class RazorRenameEdits
+{
+    /// <summary>The Razor edits that rename <paramref name="symbol"/> to <paramref name="newName"/>.</summary>
+    public static async Task<List<DocumentEditResult>> FindAsync(
+        Solution solution,
+        ISymbol symbol,
+        string newName,
+        CancellationToken ct
+    )
+    {
+        // Without a Razor file there is no Razor use to edit, so a solution without one
+        // never pays for a second solution-wide search after the renamer's own.
+        if (!SolutionPaths.HasRazorDocuments(solution))
+        {
+            return [];
+        }
+
+        var referenced = await SymbolFinder
+            .FindReferencesAsync(symbol, solution, ct)
+            .ConfigureAwait(false);
+        return await FromReferencesAsync(solution, referenced, (symbol.Name, newName), ct)
+            .ConfigureAwait(false);
+    }
+
+    /// <summary>The Razor edits among <paramref name="referenced"/> that rewrite <c>names.Old</c>.</summary>
+    public static async Task<List<DocumentEditResult>> FromReferencesAsync(
+        Solution solution,
+        IEnumerable<ReferencedSymbol> referenced,
+        (string Old, string New) names,
+        CancellationToken ct
+    )
+    {
+        var spans = referenced
+            .SelectMany(reference =>
+                reference.Definition.Locations.Concat(
+                    reference.Locations.Select(use => use.Location)
+                )
+            )
+            .Where(location => location.IsInSource)
+            .Select(location => location.GetMappedLineSpan())
+            .Where(span => span.HasMappedPath && NativePaths.IsRazor(span.Path));
+        var edits = new List<DocumentEditResult>();
+        foreach (var file in spans.GroupBy(span => span.Path, NativePaths.Comparer))
+        {
+            if (await EditFileAsync(solution, file, names, ct).ConfigureAwait(false) is { } edit)
+            {
+                edits.Add(edit);
+            }
+        }
+
+        return edits;
+    }
+
+    private static async Task<DocumentEditResult?> EditFileAsync(
+        Solution solution,
+        IGrouping<string, FileLinePositionSpan> file,
+        (string Old, string New) names,
+        CancellationToken ct
+    )
+    {
+        var razor = SolutionPaths.AdditionalDocumentsAt(solution, file.Key).FirstOrDefault();
+        if (razor is null)
+        {
+            return null;
+        }
+
+        var text = await razor.GetTextAsync(ct).ConfigureAwait(false);
+        var edits = file.Select(span => span.Span)
+            .Distinct()
+            .Where(span => Holds(text, span, names.Old))
+            .OrderBy(span => span.Start)
+            .Select(span => RazorResults.Edit(span, names.New))
+            .ToList();
+        return edits.Count == 0
+            ? null
+            : new DocumentEditResult { FilePath = file.Key, Edits = edits };
+    }
+
+    /// <summary>Whether <paramref name="span"/> of <paramref name="text"/> is exactly <paramref name="name"/>.</summary>
+    private static bool Holds(SourceText text, LinePositionSpan span, string name)
+    {
+        return DocumentText.TrySpan(text, span) is { } found
+            && found.Length == name.Length
+            && string.Equals(text.ToString(found), name, StringComparison.Ordinal);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorResults.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorResults.cs
new file mode 100644
index 00000000..147ec9c5
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorResults.cs
@@ -0,0 +1,98 @@
+using Microsoft.CodeAnalysis.Text;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Maps answers computed on a projection back to its Razor file. A range that does not lie
+/// inside one C# fragment cannot be placed, so it is dropped with whatever carries it.
+/// Implements [RAZOR-ARCHITECTURE-PROJECTION].
+/// </summary>
+internal static class RazorResults
+{
+    /// <summary>Completion items whose edit maps into the Razor file; the rest are dropped.</summary>
+    public static List<CompletionItem> MapCompletions(
+        List<CompletionItem> items,
+        RazorProjection? origin
+    )
+    {
+        return origin is null
+            ? items
+            : [.. items.Select(item => MapCompletion(item, origin)).OfType<CompletionItem>()];
+    }
+
+    /// <summary>A text edit placed in the Razor file, or null when it crosses a fragment's edge.</summary>
+    public static TextEditResult? MapEdit(TextEditResult edit, RazorProjection origin)
+    {
+        return origin.ToRazor(SpanOf(edit)) is { } razor ? Edit(razor, edit.NewText) : null;
+    }
+
+    /// <summary>The prepared range in the Razor file; a range outside every fragment cannot be renamed there.</summary>
+    public static PrepareRenameResult MapPrepareRename(
+        PrepareRenameResult prepared,
+        RazorProjection? origin
+    )
+    {
+        if (origin is null || !prepared.CanRename)
+        {
+            return prepared;
+        }
+
+        var span = new LinePositionSpan(
+            new LinePosition(prepared.StartLine, prepared.StartCharacter),
+            new LinePosition(prepared.EndLine, prepared.EndCharacter)
+        );
+        return origin.ToRazor(span) is { } razor
+            ? Prepared(razor, prepared.Placeholder)
+            : new PrepareRenameResult { CanRename = false };
+    }
+
+    /// <summary>A text edit over <paramref name="span"/>.</summary>
+    public static TextEditResult Edit(LinePositionSpan span, string newText)
+    {
+        return new TextEditResult
+        {
+            StartLine = span.Start.Line,
+            StartCharacter = span.Start.Character,
+            EndLine = span.End.Line,
+            EndCharacter = span.End.Character,
+            NewText = newText,
+        };
+    }
+
+    private static CompletionItem? MapCompletion(CompletionItem item, RazorProjection origin)
+    {
+        return item.TextEdit is null ? item
+            : MapEdit(item.TextEdit, origin) is { } edit
+                ? new CompletionItem
+                {
+                    Label = item.Label,
+                    Kind = item.Kind,
+                    Detail = item.Detail,
+                    InsertText = item.InsertText,
+                    Index = item.Index,
+                    TextEdit = edit,
+                }
+            : null;
+    }
+
+    private static PrepareRenameResult Prepared(LinePositionSpan span, string placeholder)
+    {
+        return new PrepareRenameResult
+        {
+            CanRename = true,
+            StartLine = span.Start.Line,
+            StartCharacter = span.Start.Character,
+            EndLine = span.End.Line,
+            EndCharacter = span.End.Character,
+            Placeholder = placeholder,
+        };
+    }
+
+    private static LinePositionSpan SpanOf(TextEditResult edit)
+    {
+        return new LinePositionSpan(
+            new LinePosition(edit.StartLine, edit.StartCharacter),
+            new LinePosition(edit.EndLine, edit.EndCharacter)
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorSemanticTokens.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorSemanticTokens.cs
new file mode 100644
index 00000000..f1e060bf
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorSemanticTokens.cs
@@ -0,0 +1,45 @@
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.CSharp.Workspace;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// Semantic tokens for a Razor file's C# fragments: Roslyn's classification of each
+/// fragment in the projection, shifted to the fragment's place in the Razor file.
+/// Implements [RAZOR-FEATURES-SEMANTIC-TOKENS].
+/// </summary>
+internal static class RazorSemanticTokens
+{
+    /// <summary>The typed spans of every C# fragment of <paramref name="projection"/>, in Razor offsets.</summary>
+    public static async Task<List<SemanticSpan>> CSharpSpansAsync(
+        RazorProjection projection,
+        CancellationToken ct
+    )
+    {
+        var spans = new List<SemanticSpan>();
+        foreach (var mapping in projection.Map.Mappings.Where(mapping => mapping.Length > 0))
+        {
+            var generated = new TextSpan(mapping.GeneratedStart, mapping.Length);
+            var classified = await Classifier
+                .GetClassifiedSpansAsync(projection.Generated, generated, ct)
+                .ConfigureAwait(false);
+            spans.AddRange(classified.Select(span => Shift(span, mapping)).OfType<SemanticSpan>());
+        }
+
+        return spans;
+    }
+
+    /// <summary>A classified generated span moved into the Razor file, when it lies inside its fragment.</summary>
+    private static SemanticSpan? Shift(ClassifiedSpan span, RazorMapping mapping)
+    {
+        var start = Math.Max(span.TextSpan.Start, mapping.GeneratedStart);
+        var end = Math.Min(span.TextSpan.End, mapping.GeneratedEnd);
+        return end > start
+            ? new SemanticSpan(
+                new TextSpan(mapping.RazorStart + (start - mapping.GeneratedStart), end - start),
+                SemanticTokensResolver.MapClassification(span.ClassificationType)
+            )
+            : null;
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorSpanMap.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorSpanMap.cs
new file mode 100644
index 00000000..04118b10
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorSpanMap.cs
@@ -0,0 +1,145 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>One C# fragment: the same text at a Razor offset and at a generated offset.</summary>
+internal readonly record struct RazorMapping(int RazorStart, int GeneratedStart, int Length)
+{
+    public int RazorEnd => RazorStart + Length;
+
+    public int GeneratedEnd => GeneratedStart + Length;
+}
+
+/// <summary>
+/// The verified map between a Razor file and its C# projection, built from the projection's
+/// <c>#line</c> mappings. Every entry pairs two spans that hold the same text, measured by
+/// comparing that text, because Roslyn reports a mapped span's end one character past the
+/// fragment. Implements [RAZOR-ARCHITECTURE-PROJECTION].
+/// </summary>
+internal sealed class RazorSpanMap(ImmutableArray<RazorMapping> mappings)
+{
+    public ImmutableArray<RazorMapping> Mappings => mappings;
+
+    /// <summary>Build the map from the <paramref name="tree"/>'s mappings into <paramref name="razorPath"/>.</summary>
+    public static RazorSpanMap Build(
+        SyntaxTree tree,
+        SourceText generated,
+        SourceText razor,
+        string razorPath
+    )
+    {
+        return new([
+            .. tree.GetLineMappings()
+                .Where(mapping => Targets(mapping, razorPath))
+                .Select(mapping => Measure(mapping, generated, razor))
+                .OfType<RazorMapping>()
+                .OrderBy(mapping => mapping.RazorStart),
+        ]);
+    }
+
+    /// <summary>
+    /// The generated offset of a Razor offset that some entry contains or ends at; the
+    /// containing entry wins, so a caret just after <c>@curr</c> still maps.
+    /// </summary>
+    public int? ToGenerated(int razorOffset)
+    {
+        var containing = mappings.FirstOrDefault(entry =>
+            entry.RazorStart <= razorOffset && razorOffset < entry.RazorEnd
+        );
+        var entry = containing.Length > 0 ? containing : EndingAt(razorOffset);
+        return entry is { } found ? found.GeneratedStart + (razorOffset - found.RazorStart) : null;
+    }
+
+    /// <summary>The Razor span of a generated span that lies entirely inside one entry.</summary>
+    public TextSpan? ToRazor(TextSpan generated)
+    {
+        foreach (var entry in mappings)
+        {
+            if (entry.GeneratedStart <= generated.Start && generated.End <= entry.GeneratedEnd)
+            {
+                return new TextSpan(
+                    entry.RazorStart + (generated.Start - entry.GeneratedStart),
+                    generated.Length
+                );
+            }
+        }
+
+        return null;
+    }
+
+    private RazorMapping? EndingAt(int razorOffset)
+    {
+        foreach (var entry in mappings)
+        {
+            if (entry.RazorEnd == razorOffset)
+            {
+                return entry;
+            }
+        }
+
+        return null;
+    }
+
+    private static bool Targets(LineMapping mapping, string razorPath)
+    {
+        return !mapping.IsHidden
+            && mapping.MappedSpan.HasMappedPath
+            && NativePaths.AreEqual(mapping.MappedSpan.Path, razorPath);
+    }
+
+    private static RazorMapping? Measure(
+        LineMapping mapping,
+        SourceText generated,
+        SourceText razor
+    )
+    {
+        var razorSpan = mapping.MappedSpan.Span;
+        if (!Fits(razor, razorSpan.Start) || !Fits(generated, mapping.Span.Start))
+        {
+            return null;
+        }
+
+        var razorStart = razor.Lines.GetPosition(razorSpan.Start);
+        var generatedLine = generated.Lines[mapping.Span.Start.Line];
+        var generatedStart = generatedLine.Start + (mapping.CharacterOffset ?? 0);
+        var bound = Bound(razor, razorSpan.End) - razorStart;
+        var length = CommonLength(razor, razorStart, generated, generatedStart, bound);
+        return new RazorMapping(razorStart, generatedStart, length);
+    }
+
+    private static bool Fits(SourceText text, LinePosition position)
+    {
+        return position.Line < text.Lines.Count
+            && position.Character <= text.Lines[position.Line].SpanIncludingLineBreak.Length;
+    }
+
+    private static int Bound(SourceText razor, LinePosition end)
+    {
+        return Fits(razor, end) ? razor.Lines.GetPosition(end) : razor.Length;
+    }
+
+    private static int CommonLength(
+        SourceText razor,
+        int razorStart,
+        SourceText generated,
+        int generatedStart,
+        int bound
+    )
+    {
+        // The bound never runs past the Razor text, so only the generated end needs a check.
+        var length = 0;
+        while (
+            length < bound
+            && generatedStart + length < generated.Length
+            && razor[razorStart + length] == generated[generatedStart + length]
+        )
+        {
+            length++;
+        }
+
+        return length;
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorStructure.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorStructure.cs
new file mode 100644
index 00000000..eb3de084
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorStructure.cs
@@ -0,0 +1,153 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>One outline entry before nesting: what it is, where it is, and where its name is.</summary>
+internal readonly record struct RazorOutline(
+    string Name,
+    string Kind,
+    TextSpan Span,
+    TextSpan NameSpan
+);
+
+/// <summary>
+/// The structure of a Razor file — folding ranges, the document outline and linked tag
+/// names — read from its markup facts and its projection. Implements
+/// [RAZOR-FEATURES-STRUCTURE].
+/// </summary>
+internal static class RazorStructure
+{
+    /// <summary>Every element and directive that spans lines folds, keeping its last line visible.</summary>
+    public static List<FoldingRangeResult> Folds(RazorMarkup markup)
+    {
+        var lines = markup.Text.Lines;
+        return
+        [
+            .. markup
+                .Tags.Select(tag => tag.Element)
+                .Concat(markup.Directives.Select(directive => directive.Span))
+                .Select(lines.GetLinePositionSpan)
+                .Where(span => span.End.Line - 1 > span.Start.Line)
+                .Select(span => (Start: span.Start.Line, End: span.End.Line - 1))
+                .Distinct()
+                .Order()
+                .Select(fold => new FoldingRangeResult
+                {
+                    StartLine = fold.Start,
+                    EndLine = fold.End,
+                }),
+        ];
+    }
+
+    /// <summary>The start and end tag names of the element named at <paramref name="offset"/>, edited together.</summary>
+    public static IEnumerable<TextSpan> LinkedNames(RazorMarkup markup, int offset)
+    {
+        return markup.TagNamedAt(offset) is { EndName: { } end } tag ? [tag.StartName, end] : [];
+    }
+
+    /// <summary>
+    /// The outline: directives, elements bound to components or tag helpers, and the members
+    /// the file declares, each nested in the innermost entry that holds it.
+    /// </summary>
+    public static List<DocumentSymbolResult> Symbols(
+        RazorMarkup markup,
+        IEnumerable<RazorOutline> members
+    )
+    {
+        var directives = markup.Directives.Select(directive => new RazorOutline(
+            "@" + directive.Name,
+            "Key",
+            directive.Span,
+            directive.NameSpan
+        ));
+        var tags = markup
+            .Tags.Where(tag => !tag.TagHelpers.IsEmpty)
+            .Select(tag => new RazorOutline(tag.Name, "Class", tag.Element, tag.StartName));
+        return Nest(directives.Concat(tags).Concat(members), markup.Text);
+    }
+
+    /// <summary>The members <paramref name="projection"/> declares inside its Razor file: <c>@code</c> methods, properties and fields, and <c>@inject</c> properties.</summary>
+    public static IEnumerable<RazorOutline> Members(RazorProjection projection)
+    {
+        return projection
+            .GeneratedRoot.DescendantNodes()
+            .Select(Member)
+            .OfType<(SyntaxToken Name, string Kind, SyntaxNode Node)>()
+            .Select(member => Outline(projection.Map, member))
+            .OfType<RazorOutline>();
+    }
+
+    private static (SyntaxToken Name, string Kind, SyntaxNode Node)? Member(SyntaxNode node)
+    {
+        return node switch
+        {
+            MethodDeclarationSyntax method => (method.Identifier, "Method", method),
+            PropertyDeclarationSyntax property => (property.Identifier, "Property", property),
+            VariableDeclaratorSyntax { Parent.Parent: FieldDeclarationSyntax field } variable => (
+                variable.Identifier,
+                "Field",
+                field
+            ),
+            _ => null,
+        };
+    }
+
+    private static RazorOutline? Outline(
+        RazorSpanMap map,
+        (SyntaxToken Name, string Kind, SyntaxNode Node) member
+    )
+    {
+        return map.ToRazor(member.Name.Span) is { } name
+            ? new RazorOutline(
+                member.Name.ValueText,
+                member.Kind,
+                map.ToRazor(member.Node.Span) ?? name,
+                name
+            )
+            : null;
+    }
+
+    private static List<DocumentSymbolResult> Nest(IEnumerable<RazorOutline> items, SourceText text)
+    {
+        var roots = new List<DocumentSymbolResult>();
+        var open = new Stack<(TextSpan Span, DocumentSymbolResult Symbol)>();
+        foreach (
+            var item in items
+                .OrderBy(item => item.Span.Start)
+                .ThenByDescending(item => item.Span.Length)
+        )
+        {
+            while (open.TryPeek(out var top) && !top.Span.Contains(item.Span))
+            {
+                _ = open.Pop();
+            }
+
+            var symbol = ToResult(item, text.Lines);
+            (open.TryPeek(out var parent) ? parent.Symbol.Children : roots).Add(symbol);
+            open.Push((item.Span, symbol));
+        }
+
+        return roots;
+    }
+
+    private static DocumentSymbolResult ToResult(RazorOutline item, TextLineCollection lines)
+    {
+        var span = lines.GetLinePositionSpan(item.Span);
+        var name = lines.GetLinePositionSpan(item.NameSpan);
+        return new DocumentSymbolResult
+        {
+            Name = item.Name,
+            Kind = item.Kind,
+            StartLine = span.Start.Line,
+            StartCharacter = span.Start.Character,
+            EndLine = span.End.Line,
+            EndCharacter = span.End.Character,
+            SelectionStartLine = name.Start.Line,
+            SelectionStartCharacter = name.Start.Character,
+            SelectionEndLine = name.End.Line,
+            SelectionEndCharacter = name.End.Character,
+        };
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorTagHelpers.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorTagHelpers.cs
new file mode 100644
index 00000000..42cf09fc
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/RazorTagHelpers.cs
@@ -0,0 +1,60 @@
+using System.Runtime.CompilerServices;
+using Microsoft.AspNetCore.Mvc.Razor.Extensions;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Razor;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// The tag helpers a project can use, components included: discovered by the compiler's own
+/// <see cref="CompilationTagHelperFeature"/> over the project's compilation (its generated
+/// components among them) and every reference it compiles against, project references
+/// included. They are compiler state held only as long as that compilation instance lives,
+/// never a feature result. Implements [RAZOR-ARCHITECTURE-ENGINE].
+/// </summary>
+internal static class RazorTagHelpers
+{
+    private static readonly ConditionalWeakTable<Compilation, TagHelperCollection> ByCompilation =
+    [];
+
+    /// <summary>The tag helpers of <paramref name="compilation"/>.</summary>
+    public static TagHelperCollection Of(Compilation compilation)
+    {
+        return ByCompilation.GetValue(compilation, Discover);
+    }
+
+    private static TagHelperCollection Discover(Compilation compilation)
+    {
+        var references = new List<MetadataReference> { compilation.ToMetadataReference() };
+        references.AddRange(compilation.References);
+        var engine = RazorProjectEngine.Create(
+            RazorConfiguration.Default,
+            RazorProjectFileSystem.Empty,
+            builder =>
+            {
+                builder.Features.Add(
+                    new DefaultMetadataReferenceFeature { References = references }
+                );
+                builder.Features.Add(new CompilationTagHelperFeature());
+                CompilerFeatures.Register(builder);
+                RazorExtensions.Register(builder);
+            }
+        );
+        return engine
+            .Engine.GetFeatures<ITagHelperFeature>()[0]
+            .GetTagHelpers(CancellationToken.None);
+    }
+
+    /// <summary>Hands an engine tag helpers already discovered for its compilation.</summary>
+    internal sealed class Feature(TagHelperCollection tagHelpers)
+        : RazorEngineFeatureBase,
+            ITagHelperFeature
+    {
+        /// <inheritdoc />
+        public TagHelperCollection GetTagHelpers(CancellationToken cancellationToken)
+        {
+            return tagHelpers;
+        }
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/WorkspaceRazorFileSystem.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/WorkspaceRazorFileSystem.cs
new file mode 100644
index 00000000..6943f0a1
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Razor/WorkspaceRazorFileSystem.cs
@@ -0,0 +1,92 @@
+using System.Text;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+
+namespace SharpLsp.Sidecar.CSharp.Razor;
+
+/// <summary>
+/// The Razor engine's view of a project's files: the file being processed and every import
+/// file (<c>_Imports.razor</c>, <c>_ViewImports.cshtml</c>), all with the workspace's current
+/// text, so imports resolve as the compiler resolves them, unsaved edits included.
+/// Implements [RAZOR-ARCHITECTURE-ENGINE].
+/// </summary>
+internal sealed class WorkspaceRazorFileSystem : RazorProjectFileSystem
+{
+    private readonly Dictionary<string, WorkspaceRazorItem> _items;
+    private readonly string _projectDirectory;
+
+    private WorkspaceRazorFileSystem(
+        string projectDirectory,
+        Dictionary<string, WorkspaceRazorItem> items
+    )
+    {
+        _projectDirectory = projectDirectory;
+        _items = items;
+    }
+
+    /// <summary>The file system for processing <paramref name="target"/>.</summary>
+    public static async Task<WorkspaceRazorFileSystem> CreateAsync(
+        TextDocument target,
+        RazorEngineSettings settings,
+        CancellationToken ct
+    )
+    {
+        var items = new Dictionary<string, WorkspaceRazorItem>(NativePaths.Comparer);
+        var documents = target.Project.AdditionalDocuments.Where(document =>
+            document.Id == target.Id || NativePaths.IsRazorImport(document.FilePath)
+        );
+        foreach (var document in documents)
+        {
+            var text = await document.GetTextAsync(ct).ConfigureAwait(false);
+            var item = new WorkspaceRazorItem(
+                settings.RazorPathOf(document),
+                document.FilePath!,
+                text
+            );
+            items[NativePaths.FromRazorProjectPath(settings.ProjectDirectory, item.FilePath)] =
+                item;
+        }
+
+        return new WorkspaceRazorFileSystem(settings.ProjectDirectory, items);
+    }
+
+    /// <inheritdoc />
+    public override IEnumerable<RazorProjectItem> EnumerateItems(string basePath)
+    {
+        return _items.Values;
+    }
+
+    /// <inheritdoc />
+    public override RazorProjectItem GetItem(string path, RazorFileKind? fileKind)
+    {
+        var physical = NativePaths.FromRazorProjectPath(_projectDirectory, path);
+        return _items.TryGetValue(physical, out var item)
+            ? item
+            : new WorkspaceRazorItem(path, physical, null);
+    }
+}
+
+/// <summary>One Razor file as the engine reads it; <c>null</c> text is a file that does not exist.</summary>
+internal sealed class WorkspaceRazorItem(string filePath, string physicalPath, SourceText? text)
+    : RazorProjectItem
+{
+    /// <inheritdoc />
+    public override string BasePath => "/";
+
+    /// <inheritdoc />
+    public override string FilePath => filePath;
+
+    /// <inheritdoc />
+    public override string PhysicalPath => physicalPath;
+
+    /// <inheritdoc />
+    public override bool Exists => text is not null;
+
+    /// <inheritdoc />
+    public override Stream Read()
+    {
+        return new MemoryStream(Encoding.UTF8.GetBytes(text?.ToString() ?? ""), writable: false);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/RazorCompiler.props b/src/sidecars/SharpLsp.Sidecar.CSharp/RazorCompiler.props
new file mode 100644
index 00000000..6f9b45f1
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/RazorCompiler.props
@@ -0,0 +1,24 @@
+<Project>
+    <!-- Implements [RAZOR-ARCHITECTURE-ENGINE]. The Razor compiler ships only inside the .NET
+         SDK (no current NuGet package carries it), so the sidecar bundles the copy from the
+         SDK global.json pins. Private="true" copies it into the build, publish and tool
+         package output. The project's own SDK generator still produces the C# projection;
+         this copy only reads markup structure. Imported by the sidecar and its tests. -->
+    <PropertyGroup>
+        <RazorCompilerDirectory>$(MSBuildExtensionsPath)/Sdks/Microsoft.NET.Sdk.Razor/source-generators/</RazorCompilerDirectory>
+    </PropertyGroup>
+    <ItemGroup>
+        <Reference
+            Include="$(RazorCompilerDirectory)Microsoft.CodeAnalysis.Razor.Compiler.dll"
+            Private="true"
+        />
+        <Reference
+            Include="$(RazorCompilerDirectory)Microsoft.AspNetCore.Razor.Utilities.Shared.dll"
+            Private="true"
+        />
+        <Reference
+            Include="$(RazorCompilerDirectory)Microsoft.Extensions.ObjectPool.dll"
+            Private="true"
+        />
+    </ItemGroup>
+</Project>
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/SharpLsp.Sidecar.CSharp.csproj b/src/sidecars/SharpLsp.Sidecar.CSharp/SharpLsp.Sidecar.CSharp.csproj
index f5632c4c..04271bd7 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/SharpLsp.Sidecar.CSharp.csproj
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/SharpLsp.Sidecar.CSharp.csproj
@@ -77,4 +77,7 @@
         <PackageReference Include="ICSharpCode.Decompiler" Version="11.1.0.9782" />
         <PackageReference Include="MessagePack" Version="3.1.12" />
     </ItemGroup>
+
+    <!-- The Razor compiler, bundled from the SDK: [RAZOR-ARCHITECTURE-ENGINE]. -->
+    <Import Project="RazorCompiler.props" />
 </Project>
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/DocumentText.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/DocumentText.cs
index de28be8b..0fe6f789 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/DocumentText.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/DocumentText.cs
@@ -32,6 +32,32 @@ CancellationToken ct
         return (text, TextSpan.FromBounds(start, end));
     }
 
+    /// <summary>
+    /// The offset of <paramref name="position"/> in <paramref name="text"/>; null when the
+    /// line or character lies outside it, as a client position past a file's end does.
+    /// </summary>
+    public static int? TryOffset(SourceText text, LinePosition position)
+    {
+        return
+            position.Line >= 0
+            && position.Line < text.Lines.Count
+            && position.Character >= 0
+            && position.Character <= text.Lines[position.Line].Span.Length
+            ? text.Lines[position.Line].Start + position.Character
+            : null;
+    }
+
+    /// <summary>The span of <paramref name="span"/> in <paramref name="text"/>; null when either end lies outside it.</summary>
+    public static TextSpan? TrySpan(SourceText text, LinePositionSpan span)
+    {
+        return
+            TryOffset(text, span.Start) is { } start
+            && TryOffset(text, span.End) is { } end
+            && start <= end
+            ? TextSpan.FromBounds(start, end)
+            : null;
+    }
+
     /// <summary>
     /// Project a single <see cref="TextChange"/> into a <see cref="TextEditResult"/>,
     /// resolving its span to start/end (line, character) coordinates against
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/ReferenceResolver.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/ReferenceResolver.cs
index d4a601c5..24943642 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/ReferenceResolver.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/ReferenceResolver.cs
@@ -3,6 +3,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Serilog;
+using SharpLsp.Sidecar.Common;
 
 namespace SharpLsp.Sidecar.CSharp.Workspace;
 
@@ -67,16 +68,21 @@ await scope.FindReferencesAsync(symbol, ct).ConfigureAwait(false),
             .ConfigureAwait(false);
     }
 
-    /// <summary>Find document highlights for the symbol at a position: this document only.</summary>
+    /// <summary>
+    /// Find document highlights for the symbol at a position: this document only, and only
+    /// where its locations map to <paramref name="answerPath"/>. For a Razor file the document
+    /// is its projection and the answer path is the Razor file, so hidden scaffolding and
+    /// <c>_Imports.razor</c> lines drop out. [RAZOR-FEATURES-REFERENCES]
+    /// </summary>
     public static async Task<List<DocumentHighlightResult>> ResolveDocumentHighlightsAsync(
         Document document,
-        int line,
-        int character,
+        (int Line, int Character) at,
+        string answerPath,
         CancellationToken ct
     )
     {
         var symbol = await DefinitionResolver
-            .ResolveSymbolAsync(document, line, character, ct)
+            .ResolveSymbolAsync(document, at.Line, at.Character, ct)
             .ConfigureAwait(false);
         if (symbol is null)
         {
@@ -90,7 +96,7 @@ CancellationToken ct
         return
         [
             .. referenced
-                .SelectMany(reference => HighlightsIn(document, reference))
+                .SelectMany(reference => HighlightsIn(document, reference, answerPath))
                 .DistinctBy(highlight =>
                     (
                         highlight.StartLine,
@@ -214,7 +220,8 @@ .. locations.DistinctBy(location =>
     /// <summary>One referenced symbol's declaration (a write) and its uses in the document.</summary>
     private static IEnumerable<DocumentHighlightResult> HighlightsIn(
         Document document,
-        ReferencedSymbol reference
+        ReferencedSymbol reference,
+        string answerPath
     )
     {
         var declarations = reference
@@ -223,10 +230,12 @@ ReferencedSymbol reference
                 && location.IsInSource
                 && location.SourceTree?.FilePath == document.FilePath
             )
-            .Select(location => ToHighlight(location, WriteKind));
+            .Select(location => ToHighlight(location, WriteKind, answerPath));
         var uses = reference
             .Locations.Where(use => use.Document.Id == document.Id)
-            .Select(use => ToHighlight(use.Location, IsWriteReference(use) ? WriteKind : ReadKind));
+            .Select(use =>
+                ToHighlight(use.Location, IsWriteReference(use) ? WriteKind : ReadKind, answerPath)
+            );
         return declarations.Concat(uses).OfType<DocumentHighlightResult>();
     }
 
@@ -240,10 +249,14 @@ private static bool DeclaresItself(ReferencedSymbol reference)
         return reference.Definition is not IMethodSymbol { AssociatedSymbol: not null };
     }
 
-    private static DocumentHighlightResult? ToHighlight(Location location, int kind)
+    private static DocumentHighlightResult? ToHighlight(
+        Location location,
+        int kind,
+        string answerPath
+    )
     {
         var span = location.GetMappedLineSpan();
-        return span.IsValid
+        return span.IsValid && NativePaths.AreEqual(span.Path, answerPath)
             ? new DocumentHighlightResult
             {
                 StartLine = span.StartLinePosition.Line,
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/SemanticTokensResolver.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/SemanticTokensResolver.cs
index 03d43999..2c2b6649 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/SemanticTokensResolver.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/SemanticTokensResolver.cs
@@ -4,12 +4,27 @@
 
 namespace SharpLsp.Sidecar.CSharp.Workspace;
 
+/// <summary>A span of text and its token type, the legend index.</summary>
+internal readonly record struct SemanticSpan(TextSpan Span, int Type);
+
 /// <summary>
 /// Computes semantic tokens for a document using Roslyn's Classifier API.
 /// Returns LSP-encoded token data (relative line, char, length, type, modifiers).
 /// </summary>
 internal static class SemanticTokensResolver
 {
+    /// <summary>The legend index of the <c>class</c> token type.</summary>
+    internal const int ClassType = 2;
+
+    /// <summary>The legend index of the <c>property</c> token type.</summary>
+    internal const int PropertyType = 9;
+
+    /// <summary>The legend index of the <c>keyword</c> token type.</summary>
+    internal const int KeywordType = 15;
+
+    /// <summary>The legend index of the <c>decorator</c> token type.</summary>
+    internal const int DecoratorType = 22;
+
     // LSP semantic token types — index into this array is the token type ID.
     private static readonly string[] TokenTypes =
     [
@@ -93,23 +108,38 @@ CancellationToken ct
     }
 
     private static int[] EncodeTokens(IEnumerable<ClassifiedSpan> spans, SourceText text)
+    {
+        return Encode(
+            spans.Select(span => new SemanticSpan(
+                span.TextSpan,
+                MapClassification(span.ClassificationType)
+            )),
+            text
+        );
+    }
+
+    /// <summary>
+    /// LSP-encode typed spans of <paramref name="text"/> in document order. A span with no
+    /// token type (negative) is skipped. Shared by C# documents and Razor files.
+    /// </summary>
+    internal static int[] Encode(IEnumerable<SemanticSpan> spans, SourceText text)
     {
         var data = new List<int>();
         var prevLine = 0;
         var prevChar = 0;
 
-        foreach (var span in spans.OrderBy(s => s.TextSpan.Start))
+        foreach (var span in spans.OrderBy(s => s.Span.Start))
         {
-            var tokenType = MapClassification(span.ClassificationType);
+            var tokenType = span.Type;
             if (tokenType < 0)
             {
                 continue;
             }
 
-            var linePos = text.Lines.GetLinePosition(span.TextSpan.Start);
+            var linePos = text.Lines.GetLinePosition(span.Span.Start);
             var line = linePos.Line;
             var character = linePos.Character;
-            var length = span.TextSpan.Length;
+            var length = span.Span.Length;
 
             var deltaLine = line - prevLine;
             var deltaChar = deltaLine == 0 ? character - prevChar : character;
@@ -127,7 +157,8 @@ private static int[] EncodeTokens(IEnumerable<ClassifiedSpan> spans, SourceText
         return [.. data];
     }
 
-    private static int MapClassification(string classification)
+    /// <summary>The token type of a Roslyn classification; -1 when it has none.</summary>
+    internal static int MapClassification(string classification)
     {
         return classification switch
         {
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/SolutionPaths.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/SolutionPaths.cs
index 7c2d1dc7..3cf9a411 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/SolutionPaths.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/SolutionPaths.cs
@@ -29,6 +29,34 @@ internal static IEnumerable<Document> DocumentsAt(Solution solution, string file
             .Where(document => NativePaths.AreEqual(document.FilePath, filePath));
     }
 
+    /// <summary>
+    /// Every additional document at <paramref name="filePath"/>: a Razor file is one, once per
+    /// target framework of each project that lists it. [RAZOR-ARCHITECTURE-DOCUMENTS]
+    /// </summary>
+    internal static IEnumerable<TextDocument> AdditionalDocumentsAt(
+        Solution solution,
+        string filePath
+    )
+    {
+        return solution
+            .Projects.SelectMany(project => project.AdditionalDocuments)
+            .Where(document => NativePaths.AreEqual(document.FilePath, filePath));
+    }
+
+    /// <summary>The projects that list a Razor file. [RAZOR-ARCHITECTURE-DOCUMENTS]</summary>
+    internal static IEnumerable<Project> RazorProjects(Solution solution)
+    {
+        return solution.Projects.Where(project =>
+            project.AdditionalDocuments.Any(document => NativePaths.IsRazor(document.FilePath))
+        );
+    }
+
+    /// <summary>Whether any project lists a Razor file. [RAZOR-ARCHITECTURE-DOCUMENTS]</summary>
+    internal static bool HasRazorDocuments(Solution solution)
+    {
+        return RazorProjects(solution).Any();
+    }
+
     /// <summary>Find a loaded project by its project-file path.</summary>
     internal static Project? FindProject(Solution solution, string projectPath)
     {
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/TargetFrameworks.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/TargetFrameworks.cs
index 5810f9f7..0f5c7b86 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/TargetFrameworks.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/TargetFrameworks.cs
@@ -73,11 +73,55 @@ ConcurrentDictionary<string, string> chosen
         ConcurrentDictionary<string, string> chosen
     )
     {
-        var candidates = SolutionPaths.DocumentsAt(solution, filePath).ToList();
+        return FindActive(solution, SolutionPaths.DocumentsAt(solution, filePath), chosen);
+    }
+
+    /// <summary>
+    /// The additional document (a Razor file) at <paramref name="filePath"/> in its project's
+    /// active framework. [RAZOR-ARCHITECTURE-DOCUMENTS]
+    /// </summary>
+    internal static TextDocument? FindActiveAdditionalDocument(
+        Solution solution,
+        string filePath,
+        ConcurrentDictionary<string, string> chosen
+    )
+    {
+        return FindActive(
+            solution,
+            SolutionPaths.AdditionalDocumentsAt(solution, filePath),
+            chosen
+        );
+    }
+
+    private static T? FindActive<T>(
+        Solution solution,
+        IEnumerable<T> documents,
+        ConcurrentDictionary<string, string> chosen
+    )
+        where T : TextDocument
+    {
+        var candidates = documents.ToList();
         return candidates.Find(document => IsActive(solution, document.Project, chosen))
             ?? candidates.FirstOrDefault();
     }
 
+    /// <summary>
+    /// <paramref name="text"/> applied to EVERY framework's copy of the additional document
+    /// (a Razor file) at <paramref name="filePath"/>. [RAZOR-ARCHITECTURE-DOCUMENTS]
+    /// </summary>
+    internal static Solution WithAdditionalTextInEveryContext(
+        Solution solution,
+        string filePath,
+        SourceText text
+    )
+    {
+        return SolutionPaths
+            .AdditionalDocumentsAt(solution, filePath)
+            .Select(document => document.Id)
+            .ToList()
+            .Aggregate(solution, (current, id) => current.WithAdditionalDocumentText(id, text));
+    }
+
     /// <summary>
     /// <paramref name="text"/> applied to EVERY framework's copy of the document:
     /// an edit that reached only one context would leave the others stale.
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Diagnostics.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Diagnostics.cs
index 312d54f8..1026d920 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Diagnostics.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Diagnostics.cs
@@ -1,5 +1,6 @@
 using Microsoft.CodeAnalysis;
 using Serilog;
+using SharpLsp.Sidecar.Common;
 using DiagnosticsResult = Outcome.Result<
     System.Collections.Generic.List<SharpLsp.Sidecar.CSharp.DiagnosticResult>,
     string
@@ -44,8 +45,14 @@ public async Task<DiagnosticsResult> GetDiagnosticsAsync(
             // the same instant, or a slow semantic-model computation can pair a
             // pre-restore compilation with a post-restore notice state and present
             // phantom package errors as final. [SCRIPT-FILEBASED-REFERENCES-FALLBACK]
-            var state = await CaptureDiagnosticsStateAsync(filePath, ct).ConfigureAwait(false);
-            var diagnostics = await DiagnoseAsync(filePath, state, ct).ConfigureAwait(false);
+            var diagnostics = NativePaths.IsRazor(filePath)
+                ? await DiagnoseRazorAsync(filePath, ct).ConfigureAwait(false)
+                : await DiagnoseAsync(
+                        filePath,
+                        await CaptureDiagnosticsStateAsync(filePath, ct).ConfigureAwait(false),
+                        ct
+                    )
+                    .ConfigureAwait(false);
             return new DiagnosticsResult.Ok<List<DiagnosticResult>, string>(diagnostics);
         }
         catch (Exception ex)
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Features.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Features.cs
index 921b5b56..1c3feb9e 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Features.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Features.cs
@@ -1,3 +1,5 @@
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
 using CodeLensesResult = Outcome.Result<
     System.Collections.Generic.List<SharpLsp.Sidecar.CSharp.CodeLensResult>,
     string
@@ -101,17 +103,19 @@ public Task<SemanticTokensResultType> GetSemanticTokensFullAsync(
         CancellationToken ct = default
     )
     {
-        return RunDocumentQueryAsync(
-            filePath,
-            new SemanticTokensResult(),
-            async document => new SemanticTokensResult
-            {
-                Data = await SemanticTokensResolver
-                    .GetFullAsync(document, ct)
-                    .ConfigureAwait(false),
-            },
-            ct
-        );
+        return NativePaths.IsRazor(filePath)
+            ? GetRazorSemanticTokensAsync(filePath, null, ct)
+            : RunDocumentQueryAsync(
+                filePath,
+                new SemanticTokensResult(),
+                async document => new SemanticTokensResult
+                {
+                    Data = await SemanticTokensResolver
+                        .GetFullAsync(document, ct)
+                        .ConfigureAwait(false),
+                },
+                ct
+            );
     }
 
     /// <summary>Get semantic tokens for a range.</summary>
@@ -124,6 +128,15 @@ public Task<SemanticTokensResultType> GetSemanticTokensRangeAsync(
         CancellationToken ct = default
     )
     {
+        if (NativePaths.IsRazor(filePath))
+        {
+            var range = new LinePositionSpan(
+                new LinePosition(startLine, startCharacter),
+                new LinePosition(endLine, endCharacter)
+            );
+            return GetRazorSemanticTokensAsync(filePath, range, ct);
+        }
+
         return RunDocumentQueryAsync(
             filePath,
             new SemanticTokensResult(),
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.ForeignRename.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.ForeignRename.cs
index 3d475547..3b2c4ca2 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.ForeignRename.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.ForeignRename.cs
@@ -3,6 +3,7 @@
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.Text;
 using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Razor;
 using RenameEditResult = Outcome.Result<SharpLsp.Sidecar.CSharp.WorkspaceEditResult, string>;
 using RenameIdentityQueryResult = Outcome.Result<
     SharpLsp.Sidecar.CSharp.RenameIdentityResultWire,
@@ -144,7 +145,35 @@ ForeignRenameRequest request
                 request.CancellationToken
             )
             .ConfigureAwait(false);
-        return ForeignRenameSuccess(edits);
+        var razor = await ForeignRazorEditsAsync(request).ConfigureAwait(false);
+        return ForeignRenameSuccess([.. edits, .. razor]);
+    }
+
+    /// <summary>
+    /// The Razor usages of the foreign symbol, edited in their Razor files: its C# usages in
+    /// the projections are hidden from the editable references above. [RAZOR-FSHARP]
+    /// </summary>
+    private static async Task<List<DocumentEditResult>> ForeignRazorEditsAsync(
+        ForeignRenameRequest request
+    )
+    {
+        var edits = new List<DocumentEditResult>();
+        var symbols = await ResolveForeignSymbolsAsync(
+                request.Solution,
+                request.Identity,
+                request.CancellationToken
+            )
+            .ConfigureAwait(false);
+        foreach (var symbol in symbols)
+        {
+            edits.AddRange(
+                await RazorRenameEdits
+                    .FindAsync(request.Solution, symbol, request.NewName, request.CancellationToken)
+                    .ConfigureAwait(false)
+            );
+        }
+
+        return edits;
     }
 
     private static bool IsForeignRequestValid(string assemblyName, string xmlDocSig, string newName)
@@ -253,6 +282,7 @@ IEnumerable<ReferencedSymbol> found
     private static bool IsEditableReference(ReferenceLocation location)
     {
         return location.Location.IsInSource
+            && location.Document is not SourceGeneratedDocument
             && location.Location.SourceSpan.Length > 0
             && location.Document.FilePath is not null
             && IsCSharpProject(location.Document.Project);
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Helpers.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Helpers.cs
index 8f315619..009f1e02 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Helpers.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Helpers.cs
@@ -2,6 +2,7 @@
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Text;
 using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Razor;
 
 namespace SharpLsp.Sidecar.CSharp.Workspace;
 
@@ -12,6 +13,7 @@ internal sealed partial class WorkspaceManager
 {
     private CompletionList? _lastCompletionList;
     private Document? _lastCompletionDocument;
+    private RazorProjection? _lastCompletionOrigin;
 
     private static List<DiagnosticResult> MapDiagnostics(
         string filePath,
@@ -22,8 +24,14 @@ CancellationToken ct
         var results = new List<DiagnosticResult>();
         foreach (var diag in model.GetDiagnostics(cancellationToken: ct))
         {
+            // A diagnostic belongs to the file its location maps to: a projection's hidden
+            // scaffolding maps nowhere and drops out. [RAZOR-FEATURES-DIAGNOSTICS]
             var span = diag.Location.GetMappedLineSpan();
-            if (!span.IsValid)
+            if (
+                !span.IsValid
+                || !NativePaths.AreEqual(span.Path, filePath)
+                || MayServeMarkup(diag, filePath)
+            )
             {
                 continue;
             }
@@ -34,6 +42,17 @@ CancellationToken ct
         return results;
     }
 
+    /// <summary>
+    /// Whether <paramref name="diag"/> calls a using unnecessary in a Razor file, where Roslyn
+    /// sees only the projection: markup resolves component tags through usings that the
+    /// generated C# never needs, since it names each component in full, and an import file's
+    /// usings serve the files beside and below it. [RAZOR-FEATURES-DIAGNOSTICS]
+    /// </summary>
+    private static bool MayServeMarkup(Diagnostic diag, string filePath)
+    {
+        return diag.Id is "CS8019" or "IDE0005" && NativePaths.IsRazor(filePath);
+    }
+
     private static DiagnosticResult MapOneDiagnostic(
         string filePath,
         Diagnostic diag,
@@ -60,14 +79,17 @@ private async Task<List<CompletionItem>> GetCompletionsCoreAsync(
         CancellationToken ct
     )
     {
-        var document = await FindDocumentAsync(filePath, ct).ConfigureAwait(false);
-        if (document is null)
+        if (
+            await ResolveQueryTargetAsync(filePath, (line, character), ct).ConfigureAwait(false)
+            is not { } target
+        )
         {
             return [];
         }
 
+        var document = target.Document;
         var text = await document.GetTextAsync(ct).ConfigureAwait(false);
-        var position = text.Lines.GetPosition(new LinePosition(line, character));
+        var position = text.Lines.GetPosition(new LinePosition(target.Line, target.Character));
 
         var service = CompletionService.GetService(document);
         if (service is null)
@@ -85,8 +107,12 @@ CancellationToken ct
 
         _lastCompletionList = completions;
         _lastCompletionDocument = document;
+        _lastCompletionOrigin = target.Origin;
         var editSpan = ComputeCompletionEditSpan(service, text, position);
-        return MapCompletionItems(completions, editSpan);
+        return RazorResults.MapCompletions(
+            MapCompletionItems(completions, editSpan),
+            target.Origin
+        );
     }
 
     // Roslyn's default completion span covers the typed prefix to the LEFT of the
@@ -184,16 +210,14 @@ _lastCompletionList is null
         var text = await _lastCompletionDocument.GetTextAsync(ct).ConfigureAwait(false);
         var completionSpan = roslynItem.Span;
 
-        foreach (var textChange in change.TextChanges)
-        {
-            if (textChange.Span.IntersectsWith(completionSpan))
-            {
-                continue;
-            }
-
-            result.AdditionalEdits.Add(DocumentText.ToTextEdit(text, textChange));
-        }
-
+        var additional = change.TextChanges.Where(textChange =>
+            !textChange.Span.IntersectsWith(completionSpan)
+        );
+        result.AdditionalEdits.AddRange(
+            _lastCompletionOrigin is { } origin
+                ? RazorCompletionEdits.Map(origin, additional)
+                : additional.Select(textChange => DocumentText.ToTextEdit(text, textChange))
+        );
         return result;
     }
 
@@ -228,8 +252,8 @@ CancellationToken ct
         foreach (var tree in compilation.SyntaxTrees)
         {
             ct.ThrowIfCancellationRequested();
-            var filePath = tree.FilePath;
-            if (string.IsNullOrEmpty(filePath) || IsGeneratedBuildOutput(filePath))
+            var filePath = await AnswerPathAsync(tree, ct).ConfigureAwait(false);
+            if (filePath is null)
             {
                 continue;
             }
@@ -243,6 +267,20 @@ CancellationToken ct
         }
     }
 
+    /// <summary>
+    /// The file a tree's diagnostics belong to: the Razor file a projection names, else the
+    /// tree's own file; null for build output, whose diagnostics are never the user's.
+    /// [RAZOR-FEATURES-DIAGNOSTICS]
+    /// </summary>
+    private static async Task<string?> AnswerPathAsync(SyntaxTree tree, CancellationToken ct)
+    {
+        var root = await tree.GetRootAsync(ct).ConfigureAwait(false);
+        var razor = RazorProjection.ChecksumPath(root);
+        return NativePaths.IsRazor(razor) ? razor
+            : string.IsNullOrEmpty(tree.FilePath) || IsGeneratedBuildOutput(tree.FilePath) ? null
+            : tree.FilePath;
+    }
+
     /// <summary>
     /// MSBuild-generated files under <c>obj/</c> (AssemblyInfo, GlobalUsings,
     /// AssemblyAttributes) belong to the build system, not the user. Diagnostics
@@ -305,19 +343,32 @@ CancellationToken ct
     /// <paramref name="resolve"/> and wrap its payload in a success result. Any
     /// exception is mapped to a failure carrying its message.
     /// </summary>
-    private async Task<Outcome.Result<TValue, string>> RunDocumentQueryAsync<TValue>(
+    private Task<Outcome.Result<TValue, string>> RunDocumentQueryAsync<TValue>(
         string filePath,
         TValue emptyValue,
         Func<Document, Task<TValue>> resolve,
         CancellationToken ct
     )
+    {
+        return RunQueryAsync(() => FindDocumentAsync(filePath, ct), emptyValue, resolve);
+    }
+
+    /// <summary>
+    /// The skeleton every query shares: find what it runs on, answer <paramref name="empty"/>
+    /// when there is nothing, else run <paramref name="query"/>. Any exception becomes a
+    /// failure carrying its message.
+    /// </summary>
+    private static async Task<Outcome.Result<TValue, string>> RunQueryAsync<TSubject, TValue>(
+        Func<Task<TSubject?>> find,
+        TValue empty,
+        Func<TSubject, Task<TValue>> query
+    )
+        where TSubject : class
     {
         try
         {
-            var document = await FindDocumentAsync(filePath, ct).ConfigureAwait(false);
-            var value = document is null
-                ? emptyValue
-                : await resolve(document).ConfigureAwait(false);
+            var subject = await find().ConfigureAwait(false);
+            var value = subject is null ? empty : await query(subject).ConfigureAwait(false);
             return new Outcome.Result<TValue, string>.Ok<TValue, string>(value);
         }
         catch (Exception ex)
@@ -326,6 +377,34 @@ CancellationToken ct
         }
     }
 
+    /// <summary>
+    /// A position query that searches beyond the document: <paramref name="resolve"/> also
+    /// gets each project's active framework to search, and its locations come back mapped
+    /// out of Razor projections. [NETFX-PROJECTS-CSHARP] [RAZOR-FEATURES-REFERENCES]
+    /// </summary>
+    private Task<Outcome.Result<LocationListResult, string>> RunScopedLocationQueryAsync(
+        string filePath,
+        (int Line, int Character) at,
+        Func<QueryTarget, SearchScope, Task<LocationListResult>> resolve,
+        CancellationToken ct
+    )
+    {
+        return RunPositionQueryAsync(
+            filePath,
+            at,
+            new LocationListResult(),
+            async target =>
+            {
+                var scope = await SearchScope
+                    .OfAsync(target.Document, _activeFrameworks, ct)
+                    .ConfigureAwait(false);
+                var found = await resolve(target, scope).ConfigureAwait(false);
+                return await MapLocationsAsync(found, ct).ConfigureAwait(false);
+            },
+            ct
+        );
+    }
+
     /// <summary>
     /// <see cref="RunDocumentQueryAsync{TValue}"/> for a query that searches beyond the
     /// document: <paramref name="resolve"/> also gets each project's active framework to
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Razor.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Razor.cs
new file mode 100644
index 00000000..645b4529
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Razor.cs
@@ -0,0 +1,215 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Razor;
+
+namespace SharpLsp.Sidecar.CSharp.Workspace;
+
+/// <summary>
+/// Where a position query runs: a document, the position in it, and the Razor file the
+/// request named when the document is that file's projection.
+/// </summary>
+internal sealed record QueryTarget(
+    Document Document,
+    int Line,
+    int Character,
+    RazorProjection? Origin
+)
+{
+    /// <summary>The file the answer belongs to: the Razor file, else the document itself.</summary>
+    public string AnswerPath => Origin?.RazorPath ?? Document.FilePath ?? "";
+}
+
+/// <summary>
+/// Razor files in the workspace: their text, and position queries translated into their C#
+/// projections. Implements [RAZOR-ARCHITECTURE-DOCUMENTS] and [RAZOR-ARCHITECTURE-PROJECTION].
+/// </summary>
+internal sealed partial class WorkspaceManager
+{
+    /// <summary>The projection of the Razor file at <paramref name="razorPath"/> in its active framework.</summary>
+    internal async Task<RazorProjection?> FindRazorProjectionAsync(
+        string razorPath,
+        CancellationToken ct
+    )
+    {
+        var razor = FindRazorDocument(razorPath);
+        return razor is null
+            ? null
+            : await RazorProjection.ForRazorAsync(razor, ct).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// The markup facts of the Razor file at <paramref name="razorPath"/>; null when no project
+    /// lists it or the engine cannot read it. [RAZOR-ARCHITECTURE-ENGINE]
+    /// </summary>
+    internal async Task<RazorMarkup?> FindRazorMarkupAsync(string razorPath, CancellationToken ct)
+    {
+        var razor = FindRazorDocument(razorPath);
+        return razor is null
+            ? null
+            : await RazorMarkupEngine.ProcessAsync(razor, ct).ConfigureAwait(false);
+    }
+
+    /// <summary>The Razor file at <paramref name="razorPath"/> in its active framework; null when no project lists it.</summary>
+    internal TextDocument? FindRazorDocument(string razorPath)
+    {
+        return _solution is null
+            ? null
+            : TargetFrameworks.FindActiveAdditionalDocument(
+                _solution,
+                razorPath,
+                _activeFrameworks
+            );
+    }
+
+    /// <summary>
+    /// Run <paramref name="query"/> where the position lands: the document itself, or, for a
+    /// Razor file, its projection at the mapped position. A position outside every C#
+    /// fragment, or a file outside the workspace, answers <paramref name="empty"/>.
+    /// </summary>
+    private Task<Outcome.Result<T, string>> RunPositionQueryAsync<T>(
+        string filePath,
+        (int Line, int Character) at,
+        T empty,
+        Func<QueryTarget, Task<T>> query,
+        CancellationToken ct
+    )
+    {
+        return RunQueryAsync(() => ResolveQueryTargetAsync(filePath, at, ct), empty, query);
+    }
+
+    private async Task<QueryTarget?> ResolveQueryTargetAsync(
+        string filePath,
+        (int Line, int Character) at,
+        CancellationToken ct
+    )
+    {
+        if (!NativePaths.IsRazor(filePath))
+        {
+            var document = await FindDocumentAsync(filePath, ct).ConfigureAwait(false);
+            return document is null ? null : new QueryTarget(document, at.Line, at.Character, null);
+        }
+
+        var projection = await FindRazorProjectionAsync(filePath, ct).ConfigureAwait(false);
+        return projection?.ToGenerated(new LinePosition(at.Line, at.Character)) is { } mapped
+            ? new QueryTarget(projection.Generated, mapped.Line, mapped.Character, projection)
+            : null;
+    }
+
+    /// <summary>
+    /// Replace a Razor file's text in every framework context. Caller holds
+    /// <see cref="_solutionMutationLock"/>. A file no project lists has nothing to update.
+    /// </summary>
+    private void UpdateRazorText(string filePath, string newText)
+    {
+        _solution = TargetFrameworks.WithAdditionalTextInEveryContext(
+            _solution!,
+            filePath,
+            SourceText.From(newText)
+        );
+    }
+
+    /// <summary>
+    /// A Razor file's diagnostics: its projection's C# diagnostics that map into it.
+    /// [RAZOR-FEATURES-DIAGNOSTICS]
+    /// </summary>
+    private async Task<List<DiagnosticResult>> DiagnoseRazorAsync(
+        string filePath,
+        CancellationToken ct
+    )
+    {
+        var projection = await FindRazorProjectionAsync(filePath, ct).ConfigureAwait(false);
+        var model = projection is null
+            ? null
+            : await projection.Generated.GetSemanticModelAsync(ct).ConfigureAwait(false);
+        return model is null ? [] : MapDiagnostics(filePath, model, ct);
+    }
+
+    /// <summary>
+    /// A Razor file's semantic tokens, all of them or those that start in
+    /// <paramref name="range"/>. [RAZOR-FEATURES-SEMANTIC-TOKENS]
+    /// </summary>
+    private Task<Outcome.Result<SemanticTokensResult, string>> GetRazorSemanticTokensAsync(
+        string filePath,
+        LinePositionSpan? range,
+        CancellationToken ct
+    )
+    {
+        return RunQueryAsync(
+            () => FindRazorProjectionAsync(filePath, ct),
+            new SemanticTokensResult(),
+            async projection => new SemanticTokensResult
+            {
+                Data = await RazorTokensAsync(projection, range, ct).ConfigureAwait(false),
+            }
+        );
+    }
+
+    private static async Task<int[]> RazorTokensAsync(
+        RazorProjection projection,
+        LinePositionSpan? range,
+        CancellationToken ct
+    )
+    {
+        var text = projection.RazorText;
+        var window = range is { } requested ? DocumentText.TrySpan(text, requested) : null;
+        var spans = await RazorSemanticTokens
+            .CSharpSpansAsync(projection, ct)
+            .ConfigureAwait(false);
+        return SemanticTokensResolver.Encode(
+            spans
+                .Where(span => window is not { } inside || inside.Contains(span.Span.Start))
+                .Where(span => span.Type >= 0)
+                .DistinctBy(span => span.Span.Start),
+            text
+        );
+    }
+
+    /// <summary><paramref name="result"/> with projection locations mapped to Razor files or dropped.</summary>
+    private Task<LocationListResult> MapLocationsAsync(
+        LocationListResult result,
+        CancellationToken ct
+    )
+    {
+        return _solution is null
+            ? Task.FromResult(result)
+            : RazorLocations.MapAsync(_solution, result, ct);
+    }
+
+    /// <summary>
+    /// The location <paramref name="resolve"/> finds where the position lands, mapped to a
+    /// Razor file, or null when it is hidden scaffolding. [RAZOR-FEATURES-DEFINITION]
+    /// </summary>
+    private Task<Outcome.Result<LocationResult?, string>> RunLocationQueryAsync(
+        string filePath,
+        (int Line, int Character) at,
+        Func<Document, int, int, CancellationToken, Task<LocationResult?>> resolve,
+        CancellationToken ct
+    )
+    {
+        return RunPositionQueryAsync<LocationResult?>(
+            filePath,
+            at,
+            null,
+            async target =>
+                await MapLocationAsync(
+                        await resolve(target.Document, target.Line, target.Character, ct)
+                            .ConfigureAwait(false),
+                        ct
+                    )
+                    .ConfigureAwait(false),
+            ct
+        );
+    }
+
+    /// <summary><paramref name="location"/> mapped to a Razor file, or null when it is hidden scaffolding.</summary>
+    private async Task<LocationResult?> MapLocationAsync(
+        LocationResult? location,
+        CancellationToken ct
+    )
+    {
+        return _solution is null
+            ? location
+            : await RazorLocations.MapAsync(_solution, location, ct).ConfigureAwait(false);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.RazorHtml.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.RazorHtml.cs
new file mode 100644
index 00000000..5fa6a493
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.RazorHtml.cs
@@ -0,0 +1,18 @@
+namespace SharpLsp.Sidecar.CSharp.Workspace;
+
+internal sealed partial class WorkspaceManager
+{
+    /// <summary>Current HTML or null for an unlisted file; [RAZOR-ARCHITECTURE-HTML].</summary>
+    internal Task<Outcome.Result<HtmlProjectionResult?, string>> GetRazorHtmlProjectionAsync(
+        string filePath,
+        CancellationToken ct
+    )
+    {
+        return RunMarkupQueryAsync<HtmlProjectionResult?>(
+            filePath,
+            null,
+            markup => Task.FromResult<HtmlProjectionResult?>(new() { Text = markup.HtmlText }),
+            ct
+        );
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.RazorStructure.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.RazorStructure.cs
new file mode 100644
index 00000000..c10f17d8
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.RazorStructure.cs
@@ -0,0 +1,95 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.CSharp.Razor;
+
+namespace SharpLsp.Sidecar.CSharp.Workspace;
+
+/// <summary>
+/// Syntax requests for Razor files, which the host forwards because it has no Razor
+/// grammar. Implements [RAZOR-ARCHITECTURE-ROUTING] and [RAZOR-FEATURES-STRUCTURE].
+/// </summary>
+internal sealed partial class WorkspaceManager
+{
+    /// <summary>The folding ranges of a Razor file; empty for a file no project lists.</summary>
+    public Task<Outcome.Result<List<FoldingRangeResult>, string>> GetFoldingRangesAsync(
+        string filePath,
+        CancellationToken ct
+    )
+    {
+        return RunMarkupQueryAsync(
+            filePath,
+            [],
+            markup => Task.FromResult(RazorStructure.Folds(markup)),
+            ct
+        );
+    }
+
+    /// <summary>The outline of a Razor file; empty for a file no project lists.</summary>
+    public Task<Outcome.Result<List<DocumentSymbolResult>, string>> GetDocumentSymbolsAsync(
+        string filePath,
+        CancellationToken ct
+    )
+    {
+        return RunMarkupQueryAsync(
+            filePath,
+            [],
+            async markup =>
+            {
+                var projection = await FindRazorProjectionAsync(filePath, ct).ConfigureAwait(false);
+                var members = projection is null ? [] : RazorStructure.Members(projection);
+                return RazorStructure.Symbols(markup, members);
+            },
+            ct
+        );
+    }
+
+    /// <summary>The tag names edited together with the one at the position, or none.</summary>
+    public Task<Outcome.Result<LocationListResult, string>> GetLinkedEditingRangesAsync(
+        string filePath,
+        (int Line, int Character) at,
+        CancellationToken ct
+    )
+    {
+        return RunMarkupQueryAsync(
+            filePath,
+            new LocationListResult(),
+            markup => Task.FromResult(LinkedNames(filePath, markup, at)),
+            ct
+        );
+    }
+
+    private static LocationListResult LinkedNames(
+        string filePath,
+        RazorMarkup markup,
+        (int Line, int Character) at
+    )
+    {
+        var offset = DocumentText.TryOffset(markup.Text, new LinePosition(at.Line, at.Character));
+        var spans = offset is { } found ? RazorStructure.LinkedNames(markup, found) : [];
+        return new LocationListResult
+        {
+            Locations =
+            [
+                .. spans.Select(span =>
+                    DocumentPosition.ToLocationResult(
+                        new FileLinePositionSpan(
+                            filePath,
+                            markup.Text.Lines.GetLinePositionSpan(span)
+                        )
+                    )
+                ),
+            ],
+        };
+    }
+
+    /// <summary>Run <paramref name="query"/> on a Razor file's markup facts; <paramref name="empty"/> when it has none.</summary>
+    private Task<Outcome.Result<T, string>> RunMarkupQueryAsync<T>(
+        string filePath,
+        T empty,
+        Func<RazorMarkup, Task<T>> query,
+        CancellationToken ct
+    )
+    {
+        return RunQueryAsync(() => FindRazorMarkupAsync(filePath, ct), empty, query);
+    }
+}
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Rename.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Rename.cs
index b2ec115e..e2c31307 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Rename.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Rename.cs
@@ -1,6 +1,8 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Text;
+using SharpLsp.Sidecar.Common;
+using SharpLsp.Sidecar.CSharp.Razor;
 using PrepareRenameQueryResult = Outcome.Result<
     SharpLsp.Sidecar.CSharp.PrepareRenameResult,
     string
@@ -37,9 +39,9 @@ public async Task<PrepareRenameQueryResult> PrepareRenameAsync(
     {
         try
         {
-            var target = await FindRenameTargetAsync(filePath, line, character, ct)
+            var (target, origin) = await FindRenameTargetAsync(filePath, line, character, ct)
                 .ConfigureAwait(false);
-            return PrepareResult(target);
+            return PrepareSuccess(RazorResults.MapPrepareRename(PrepareResult(target), origin));
         }
         catch (Exception ex)
         {
@@ -76,7 +78,7 @@ private async Task<RenameEditResult> RenameCoreAsync(
         CancellationToken ct
     )
     {
-        var target = await FindRenameTargetAsync(filePath, line, character, ct)
+        var (target, _) = await FindRenameTargetAsync(filePath, line, character, ct)
             .ConfigureAwait(false);
         if (target is null || _solution is null || !CanUseNewName(target.Value, newName))
         {
@@ -85,20 +87,38 @@ CancellationToken ct
 
         var renamed = await RenameSolutionAsync(_solution, target.Value.Symbol, newName, ct)
             .ConfigureAwait(false);
-        return await BuildRenameResultAsync(_solution, renamed, newName, ct).ConfigureAwait(false);
+        var edits = await BuildRenameEditsAsync(_solution, renamed, newName, ct)
+            .ConfigureAwait(false);
+        var razor = await RazorRenameEdits
+            .FindAsync(_solution, target.Value.Symbol, newName, ct)
+            .ConfigureAwait(false);
+        return RenameSuccess(new WorkspaceEditResult { DocumentChanges = [.. edits, .. razor] });
     }
 
-    private async Task<RenameTarget?> FindRenameTargetAsync(
+    /// <summary>
+    /// The rename target at a position, and the Razor file it was asked from. A Razor position
+    /// outside every C# fragment has no target; any other file must be in the workspace.
+    /// [RAZOR-FEATURES-RENAME]
+    /// </summary>
+    private async Task<(RenameTarget? Target, RazorProjection? Origin)> FindRenameTargetAsync(
         string filePath,
         int line,
         int character,
         CancellationToken ct
     )
     {
-        var document =
-            await FindDocumentAsync(filePath, ct).ConfigureAwait(false)
-            ?? throw new InvalidOperationException("Document not found");
-        return await FindRenameTargetAsync(document, line, character, ct).ConfigureAwait(false);
+        var resolved = await ResolveQueryTargetAsync(filePath, (line, character), ct)
+            .ConfigureAwait(false);
+        if (resolved is not { } at)
+        {
+            return NativePaths.IsRazor(filePath)
+                ? (null, null)
+                : throw new InvalidOperationException("Document not found");
+        }
+
+        var target = await FindRenameTargetAsync(at.Document, at.Line, at.Character, ct)
+            .ConfigureAwait(false);
+        return (target, at.Origin);
     }
 
     private static async Task<RenameTarget?> FindRenameTargetAsync(
@@ -146,15 +166,15 @@ private static bool IsSourceSymbol(ISymbol symbol)
         return symbol.Locations.Any(location => location.IsInSource);
     }
 
-    private static PrepareRenameQueryResult PrepareResult(RenameTarget? target)
+    private static PrepareRenameResult PrepareResult(RenameTarget? target)
     {
         if (target is null)
         {
-            return PrepareSuccess(new PrepareRenameResult { CanRename = false });
+            return new PrepareRenameResult { CanRename = false };
         }
 
         var lineSpan = target.Value.Text.Lines.GetLinePositionSpan(target.Value.Token.Span);
-        return PrepareSuccess(CreatePrepareResult(target.Value.Token.Text, lineSpan));
+        return CreatePrepareResult(target.Value.Token.Text, lineSpan);
     }
 
     private static PrepareRenameResult CreatePrepareResult(
@@ -279,7 +299,7 @@ CancellationToken ct
         );
     }
 
-    private static async Task<RenameEditResult> BuildRenameResultAsync(
+    private static async Task<List<DocumentEditResult>> BuildRenameEditsAsync(
         Solution original,
         Solution renamed,
         string newName,
@@ -294,7 +314,7 @@ await AddChangedDocumentsAsync(solutions, projectChange, edits, ct)
                 .ConfigureAwait(false);
         }
 
-        return RenameSuccess(new WorkspaceEditResult { DocumentChanges = edits });
+        return edits;
     }
 
     private static async Task AddChangedDocumentsAsync(
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.SignatureHelp.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.SignatureHelp.cs
index 7e017f20..d5c2b55a 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.SignatureHelp.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.SignatureHelp.cs
@@ -9,7 +9,8 @@ internal sealed partial class WorkspaceManager
 {
     /// <summary>
     /// Signature help at a position: <see langword="null"/> when the caret is not
-    /// inside a call's argument list, or the file is not in the workspace.
+    /// inside a call's argument list, or the file is not in the workspace. A Razor position
+    /// answers from its projection ([RAZOR-FEATURES-SIGNATURE-HELP]).
     /// Implements [SHARPLSP-FEATURES-INTELLIGENCE-SIGNATURE-HELP] (GitHub #174).
     /// </summary>
     public Task<SignatureHelpQueryResult> GetSignatureHelpAsync(
@@ -19,10 +20,17 @@ public Task<SignatureHelpQueryResult> GetSignatureHelpAsync(
         CancellationToken ct = default
     )
     {
-        return RunDocumentQueryAsync<SignatureHelpResult?>(
+        return RunPositionQueryAsync<SignatureHelpResult?>(
             filePath,
+            (line, character),
             null,
-            document => SignatureHelpResolver.ResolveAsync(document, line, character, ct),
+            target =>
+                SignatureHelpResolver.ResolveAsync(
+                    target.Document,
+                    target.Line,
+                    target.Character,
+                    ct
+                ),
             ct
         );
     }
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.cs
index 3f8b797d..8451a168 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.cs
@@ -138,7 +138,7 @@ public async Task<VoidResult> UpdateDocumentTextAsync(
     {
         try
         {
-            if (_isProjectlessDirectory)
+            if (_isProjectlessDirectory && !NativePaths.IsRazor(filePath))
             {
                 await _projectlessLoadLock.WaitAsync(ct).ConfigureAwait(false);
                 try
@@ -171,6 +171,12 @@ public async Task<VoidResult> UpdateDocumentTextAsync(
                     return new VoidResult.Ok<Unit, string>(Unit.Value);
                 }
 
+                if (NativePaths.IsRazor(filePath))
+                {
+                    UpdateRazorText(filePath, newText);
+                    return new VoidResult.Ok<Unit, string>(Unit.Value);
+                }
+
                 var document = await FindDocumentAsync(filePath, ct).ConfigureAwait(false);
                 if (document is null)
                 {
@@ -297,44 +303,37 @@ public async Task<CompletionsResult> GetCompletionsAsync(
     }
 
     /// <summary>Get hover information at a position.</summary>
-    public async Task<HoverQueryResult> GetHoverAsync(
+    public Task<HoverQueryResult> GetHoverAsync(
         string filePath,
         int line,
         int character,
         CancellationToken ct = default
     )
     {
-        try
-        {
-            Log.Debug("[Hover] request {File}:{Line}:{Character}", filePath, line, character);
-            var document = await FindDocumentAsync(filePath, ct).ConfigureAwait(false);
-            if (document is null)
-            {
-                Log.Debug("[Hover] document not found: {File}", filePath);
-                return new HoverQueryResult.Ok<HoverResult?, string>(null);
-            }
-
-            var text = await document.GetTextAsync(ct).ConfigureAwait(false);
-            var position = text.Lines.GetPosition(new LinePosition(line, character));
-            var model = await document.GetSemanticModelAsync(ct).ConfigureAwait(false);
-            if (model is null)
-            {
-                Log.Debug("[Hover] semantic model is null: {File}", filePath);
-                return new HoverQueryResult.Ok<HoverResult?, string>(null);
-            }
+        Log.Debug("[Hover] request {File}:{Line}:{Character}", filePath, line, character);
+        return RunPositionQueryAsync<HoverResult?>(
+            filePath,
+            (line, character),
+            null,
+            target => HoverAtAsync(target, ct),
+            ct
+        );
+    }
 
-            var result = CSharpHoverBuilder.Build(model, position, ct);
-            var outcome = result is HoverQueryResult.Ok<HoverResult?, string> { Value: not null }
-                ? "content"
-                : "null";
-            Log.Debug("[Hover] result: {Outcome}", outcome);
-            return result;
-        }
-        catch (Exception ex)
-        {
-            Log.Debug(ex, "[Hover] request failed");
-            return HoverQueryResult.Failure(ex.Message);
-        }
+    private static async Task<HoverResult?> HoverAtAsync(QueryTarget target, CancellationToken ct)
+    {
+        var text = await target.Document.GetTextAsync(ct).ConfigureAwait(false);
+        // Every query target is a C# document, which always has a semantic model.
+        var model =
+            await target.Document.GetSemanticModelAsync(ct).ConfigureAwait(false)
+            ?? throw new InvalidOperationException("Hover found no semantic model");
+        var position = text.Lines.GetPosition(new LinePosition(target.Line, target.Character));
+        var built = CSharpHoverBuilder.Build(model, position, ct);
+        // The hover's range is the token's mapped span, already in the Razor file for a
+        // projection. [RAZOR-FEATURES-HOVER]
+        return built is HoverQueryResult.Ok<HoverResult?, string> { Value: var hover }
+            ? hover
+            : throw new InvalidOperationException(!built ?? "Hover failed");
     }
 
     /// <summary>Go to definition at a position (returns all locations for partial types).</summary>
@@ -345,11 +344,23 @@ public Task<ImplementationsResult> GetDefinitionAsync(
         CancellationToken ct = default
     )
     {
-        return RunDocumentQueryAsync(
+        return RunPositionQueryAsync(
             filePath,
+            (line, character),
             new LocationListResult(),
-            document =>
-                DefinitionResolver.ResolveDefinitionLocationsAsync(document, line, character, ct),
+            async target =>
+                await MapLocationsAsync(
+                        await DefinitionResolver
+                            .ResolveDefinitionLocationsAsync(
+                                target.Document,
+                                target.Line,
+                                target.Character,
+                                ct
+                            )
+                            .ConfigureAwait(false),
+                        ct
+                    )
+                    .ConfigureAwait(false),
             ct
         );
     }
@@ -362,11 +373,10 @@ public Task<DefinitionResult> GetTypeDefinitionAsync(
         CancellationToken ct = default
     )
     {
-        return RunDocumentQueryAsync<LocationResult?>(
+        return RunLocationQueryAsync(
             filePath,
-            null,
-            document =>
-                DefinitionResolver.ResolveTypeDefinitionAsync(document, line, character, ct),
+            (line, character),
+            DefinitionResolver.ResolveTypeDefinitionAsync,
             ct
         );
     }
@@ -379,10 +389,10 @@ public Task<DefinitionResult> GetDeclarationAsync(
         CancellationToken ct = default
     )
     {
-        return RunDocumentQueryAsync<LocationResult?>(
+        return RunLocationQueryAsync(
             filePath,
-            null,
-            document => DefinitionResolver.ResolveDeclarationAsync(document, line, character, ct),
+            (line, character),
+            DefinitionResolver.ResolveDeclarationAsync,
             ct
         );
     }
@@ -395,11 +405,17 @@ public Task<ImplementationsResult> GetImplementationsAsync(
         CancellationToken ct = default
     )
     {
-        return RunScopedQueryAsync(
+        return RunScopedLocationQueryAsync(
             filePath,
-            new LocationListResult(),
-            (document, scope) =>
-                ReferenceResolver.ResolveImplementationsAsync(document, scope, line, character, ct),
+            (line, character),
+            (target, scope) =>
+                ReferenceResolver.ResolveImplementationsAsync(
+                    target.Document,
+                    scope,
+                    target.Line,
+                    target.Character,
+                    ct
+                ),
             ct
         );
     }
@@ -412,15 +428,15 @@ public Task<ReferencesResult> GetReferencesAsync(
         CancellationToken ct = default
     )
     {
-        return RunScopedQueryAsync(
+        return RunScopedLocationQueryAsync(
             filePath,
-            new LocationListResult(),
-            (document, scope) =>
+            (line, character),
+            (target, scope) =>
                 ReferenceResolver.ResolveReferencesAsync(
-                    document,
+                    target.Document,
                     scope,
-                    line,
-                    character,
+                    target.Line,
+                    target.Character,
                     includeDeclaration,
                     ct
                 ),
@@ -488,13 +504,19 @@ public Task<HighlightsResult> GetDocumentHighlightsAsync(
         CancellationToken ct = default
     )
     {
-        return RunDocumentQueryAsync(
+        return RunPositionQueryAsync(
             filePath,
+            (line, character),
             new DocumentHighlightListResult(),
-            async document => new DocumentHighlightListResult
+            async target => new DocumentHighlightListResult
             {
                 Highlights = await ReferenceResolver
-                    .ResolveDocumentHighlightsAsync(document, line, character, ct)
+                    .ResolveDocumentHighlightsAsync(
+                        target.Document,
+                        (target.Line, target.Character),
+                        target.AnswerPath,
+                        ct
+                    )
                     .ConfigureAwait(false),
             },
             ct
@@ -612,6 +634,12 @@ private void ReplayPendingTextEdits()
 
         foreach (var (filePath, newText) in _pendingTextEdits)
         {
+            if (NativePaths.IsRazor(filePath))
+            {
+                UpdateRazorText(filePath, newText);
+                continue;
+            }
+
             var document = SolutionPaths.FindDocument(_solution, filePath);
             if (document is not null)
             {
diff --git a/src/sidecars/SharpLsp.Sidecar.Common/NativePaths.Razor.cs b/src/sidecars/SharpLsp.Sidecar.Common/NativePaths.Razor.cs
new file mode 100644
index 00000000..0c5fac11
--- /dev/null
+++ b/src/sidecars/SharpLsp.Sidecar.Common/NativePaths.Razor.cs
@@ -0,0 +1,43 @@
+namespace SharpLsp.Sidecar.Common;
+
+/// <summary>
+/// How the Razor compiler spells a file: rooted at its project directory, with forward
+/// slashes (<c>/Components/Pages/Board.razor</c>). Implements [RAZOR-SCOPE-FILES] and
+/// [RAZOR-ARCHITECTURE-ENGINE].
+/// </summary>
+public static partial class NativePaths
+{
+    /// <summary>Whether <paramref name="path"/> is a Razor file: a <c>.razor</c> component or a <c>.cshtml</c> page or view.</summary>
+    public static bool IsRazor(string? path)
+    {
+        return path is not null && (HasExtension(path, ".razor") || HasExtension(path, ".cshtml"));
+    }
+
+    /// <summary>
+    /// Whether <paramref name="path"/> is a Razor import file, whose directives apply to the
+    /// Razor files beside and below it: <c>_Imports.razor</c> or <c>_ViewImports.cshtml</c>.
+    /// </summary>
+    public static bool IsRazorImport(string? path)
+    {
+        return path is not null
+            && (SameName(path, "_Imports.razor") || SameName(path, "_ViewImports.cshtml"));
+    }
+
+    /// <summary><paramref name="path"/> as the Razor compiler names it inside <paramref name="projectDirectory"/>.</summary>
+    public static string ToRazorProjectPath(string projectDirectory, string path)
+    {
+        return ToRazorProjectPath(RelativeTo(projectDirectory, path));
+    }
+
+    /// <summary>A target path as the compiler's rooted, forward-slashed Razor project path.</summary>
+    public static string ToRazorProjectPath(string target)
+    {
+        return "/" + Slashed(target).TrimStart('/');
+    }
+
+    /// <summary>The file a Razor project path names inside <paramref name="projectDirectory"/>.</summary>
+    public static string FromRazorProjectPath(string projectDirectory, string razorPath)
+    {
+        return Resolve(projectDirectory, razorPath.TrimStart('/'));
+    }
+}
diff --git a/src/website/eleventy.config.js b/src/website/eleventy.config.js
index 2f3301e4..b3f914d3 100644
--- a/src/website/eleventy.config.js
+++ b/src/website/eleventy.config.js
@@ -5,7 +5,7 @@ import markdownIt from "markdown-it";
 import { existsSync, lstatSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { videoFigure } from "./video-figure.js";
+import { videoFigure, videoPlayer } from "./video-figure.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pluginLayouts = join(__dirname, "node_modules/eleventy-plugin-techdoc/templates/layouts");
@@ -39,18 +39,22 @@ for (const file of ["base.njk", "blog.njk", "docs.njk"]) {
   }
 }
 
-// Patch the virtual blog pages from stable, site-owned override files. Never
-// delete or move these sources: repeated builds must produce identical output.
+// Patch the virtual pages from stable, site-owned override files. Never delete
+// or move these sources: repeated builds must produce identical output.
+// [WEB-DESIGN-MEDIA-DISCOVERY] robots.txt and the sitemap are the site's own:
+// crawlers may fetch /assets/, and the sitemap lists every video.
 for (const [target, source] of [
-  ["index.njk", "blog-index.njk"],
-  ["tags.njk", "tags-index.njk"],
-  ["tags-pages.njk", "tags-pages.njk"],
-  ["categories.njk", "categories-index.njk"],
-  ["categories-pages.njk", "categories-pages.njk"],
+  ["blog/index.njk", "blog-index.njk"],
+  ["blog/tags.njk", "tags-index.njk"],
+  ["blog/tags-pages.njk", "tags-pages.njk"],
+  ["blog/categories.njk", "categories-index.njk"],
+  ["blog/categories-pages.njk", "categories-pages.njk"],
+  ["robots.txt.njk", "robots.txt.njk"],
+  ["sitemap.njk", "sitemap.njk"],
 ]) {
   const local = join(localOverrides, source);
   if (existsSync(local)) {
-    writeFileSync(join(pluginPages, "blog", target), readFileSync(local, "utf-8"));
+    writeFileSync(join(pluginPages, target), readFileSync(local, "utf-8"));
   }
 }
 
@@ -137,6 +141,8 @@ export default function (eleventyConfig) {
   eleventyConfig.addShortcode("video", function (id, options) {
     return videoFigure(id, this.ctx?.lang ?? "en", options);
   });
+  // [WEB-DESIGN-MEDIA-DISCOVERY] The bare player a video's embed page is made of.
+  eleventyConfig.addShortcode("videoPlayer", (id, lang) => videoPlayer(id, lang));
 
   eleventyConfig.addPassthroughCopy("src/assets");
   eleventyConfig.addPassthroughCopy("src/favicon.ico");
diff --git a/src/website/src/_data/eleventyComputed.js b/src/website/src/_data/eleventyComputed.js
new file mode 100644
index 00000000..e941d125
--- /dev/null
+++ b/src/website/src/_data/eleventyComputed.js
@@ -0,0 +1,13 @@
+// [WEB-DESIGN-MEDIA-DISCOVERY] The film a page shares as its social preview, if any:
+// base.njk turns it into og:video, the X player card and the page's card image.
+import { socialVideo } from "../../video-pages.js";
+
+export default {
+  socialVideo: (data) => socialVideo(data.page.url),
+  // When a page was published: a watch page when its video was uploaded, for it has
+  // no file of its own whose date means anything, and every other page on its own date.
+  published: (data) => {
+    const film = socialVideo(data.page.url);
+    return film?.watch === data.page.url ? film.uploadDate : data.page.date;
+  },
+};
diff --git a/src/website/src/_data/i18n.json b/src/website/src/_data/i18n.json
index 55dd931b..910eec99 100644
--- a/src/website/src/_data/i18n.json
+++ b/src/website/src/_data/i18n.json
@@ -189,6 +189,11 @@
         "semanticLatency": "semantic under 200ms"
       }
     },
+    "video": {
+      "watchPage": "Watch on its own page",
+      "transcript": "Transcript",
+      "guide": "Read the guide: "
+    },
     "footer": {
       "documentation": "Documentation",
       "features": "Features",
@@ -384,6 +389,11 @@
         "semanticLatency": "语义处理低于 200ms"
       }
     },
+    "video": {
+      "watchPage": "在单独页面观看",
+      "transcript": "文字稿",
+      "guide": "阅读指南："
+    },
     "footer": {
       "documentation": "文档",
       "features": "功能",
@@ -579,6 +589,11 @@
         "semanticLatency": "意味処理 200ms 未満"
       }
     },
+    "video": {
+      "watchPage": "単独のページで見る",
+      "transcript": "文字起こし",
+      "guide": "ガイドを読む："
+    },
     "footer": {
       "documentation": "ドキュメント",
       "features": "機能",
diff --git a/src/website/src/_data/site.json b/src/website/src/_data/site.json
index 932c68f6..a9adb0cd 100644
--- a/src/website/src/_data/site.json
+++ b/src/website/src/_data/site.json
@@ -11,6 +11,7 @@
   "ogImage": "/assets/images/og-image.png",
   "ogImageWidth": "1200",
   "ogImageHeight": "630",
+  "ogImageAlt": "SharpLsp: open-source C# and F# language server for every editor, built on Roslyn, FSharp.Compiler.Service and Rust",
   "searchUrl": "https://sharplsp.dev/blog",
   "organization": {
     "name": "SharpLsp",
diff --git a/src/website/src/_data/videoPages.js b/src/website/src/_data/videoPages.js
new file mode 100644
index 00000000..24f63583
--- /dev/null
+++ b/src/website/src/_data/videoPages.js
@@ -0,0 +1,4 @@
+// [WEB-DESIGN-MEDIA-DISCOVERY] Every video's watch page, in every site language.
+import { watchPages } from "../../video-pages.js";
+
+export default watchPages;
diff --git a/src/website/src/_data/videos.json b/src/website/src/_data/videos.json
index de623972..782ba46b 100644
--- a/src/website/src/_data/videos.json
+++ b/src/website/src/_data/videos.json
@@ -1,5 +1,6 @@
 {
   "profiler-film": {
+    "page": "/blog/dotnet-profiler-vs-code-csharp-fsharp/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1080,
@@ -20,7 +21,31 @@
       }
     }
   },
+  "profiler-csharp": {
+    "page": "/docs/profiler/",
+    "encodings": ["mp4", "webm"],
+    "width": 1920,
+    "height": 1200,
+    "duration": "PT2M16S",
+    "uploadDate": "2026-10-19T00:08:43+11:00",
+    "captions": ["en", "ja", "zh"],
+    "text": {
+      "en": {
+        "label": "Profiling a C# app in VS Code with SharpLsp: CPU heat on hot lines, the hottest functions, and a leaking static dictionary found and fixed",
+        "caption": "Narrated, with original music and captions. The C# loop on the Storefront demo, recorded in VS Code: Profile CPU and the heat map, Track Memory, the leak suspect, the retention graph rooted at a static field, the fix typed in, then a second run. Fast-forwarded stretches are marked on screen."
+      },
+      "zh": {
+        "label": "在 VS Code 中用 SharpLsp 分析 C# 应用：热点行的 CPU 热度、最热的函数，以及发现并修复一个泄漏的静态字典",
+        "caption": "带旁白、原创配乐和字幕。在 VS Code 中录制的 Storefront 演示 C# 完整流程：Profile CPU 和热力图、Track Memory、可疑泄漏、根为静态字段的保留图、输入修复代码，然后再次运行。快进的片段在画面上有标注。"
+      },
+      "ja": {
+        "label": "SharpLsp で VS Code の C# アプリをプロファイリング：ホットな行の CPU ヒート、最もホットな関数、リークする static な Dictionary の発見と修正",
+        "caption": "ナレーション、オリジナル音楽、字幕付き。VS Code で収録した Storefront デモでの C# の一連の流れ：Profile CPU とヒートマップ、Track Memory、リークの疑い、static フィールドをルートとする保持グラフ、修正の入力、そして再実行。早送りの部分は画面上に表示されます。"
+      }
+    }
+  },
   "profiler-cpu-recording": {
+    "page": "/docs/profiler/",
     "encodings": ["mp4"],
     "width": 1920,
     "height": 1200,
@@ -42,6 +67,7 @@
     }
   },
   "profiler-memory-timelapse": {
+    "page": "/docs/profiler/",
     "encodings": ["mp4"],
     "width": 1920,
     "height": 1200,
@@ -63,6 +89,7 @@
     }
   },
   "profiler-fix-memory-leak": {
+    "page": "/docs/memory-leaks/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -85,6 +112,7 @@
     "captions": ["en", "ja", "zh"]
   },
   "profiler-fsharp": {
+    "page": "/docs/fsharp-profiling/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -107,6 +135,7 @@
     }
   },
   "sharplsp-tour": {
+    "page": "/blog/editor-agnostic-dotnet-lsp/",
     "encodings": ["mp4", "webm"],
     "width": 1000,
     "height": 562,
@@ -128,6 +157,7 @@
     }
   },
   "getting-started": {
+    "page": "/docs/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -150,6 +180,7 @@
     }
   },
   "editor-setup": {
+    "page": "/docs/editors/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -172,6 +203,7 @@
     }
   },
   "configuration": {
+    "page": "/docs/configuration/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -194,6 +226,7 @@
     }
   },
   "fsharp-language": {
+    "page": "/docs/fsharp/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -216,6 +249,7 @@
     }
   },
   "code-completions": {
+    "page": "/docs/completions/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -238,6 +272,7 @@
     }
   },
   "hover": {
+    "page": "/docs/hover/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -260,6 +295,7 @@
     }
   },
   "navigation": {
+    "page": "/docs/go-to-definition/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -282,6 +318,7 @@
     }
   },
   "diagnostics": {
+    "page": "/docs/diagnostics/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -304,6 +341,7 @@
     }
   },
   "refactoring": {
+    "page": "/docs/refactoring/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -326,6 +364,7 @@
     }
   },
   "context-menus": {
+    "page": "/docs/context-menus/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -348,6 +387,7 @@
     }
   },
   "nuget": {
+    "page": "/docs/nuget/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -369,29 +409,8 @@
       }
     }
   },
-  "profiler-csharp": {
-    "encodings": ["mp4", "webm"],
-    "width": 1920,
-    "height": 1200,
-    "duration": "PT2M16S",
-    "uploadDate": "2026-10-19T00:08:43+11:00",
-    "captions": ["en", "ja", "zh"],
-    "text": {
-      "en": {
-        "label": "Profiling a C# app in VS Code with SharpLsp: CPU heat on hot lines, the hottest functions, and a leaking static dictionary found and fixed",
-        "caption": "Narrated, with original music and captions. The C# loop on the Storefront demo, recorded in VS Code: Profile CPU and the heat map, Track Memory, the leak suspect, the retention graph rooted at a static field, the fix typed in, then a second run. Fast-forwarded stretches are marked on screen."
-      },
-      "zh": {
-        "label": "在 VS Code 中用 SharpLsp 分析 C# 应用：热点行的 CPU 热度、最热的函数，以及发现并修复一个泄漏的静态字典",
-        "caption": "带旁白、原创配乐和字幕。在 VS Code 中录制的 Storefront 演示 C# 完整流程：Profile CPU 和热力图、Track Memory、可疑泄漏、根为静态字段的保留图、输入修复代码，然后再次运行。快进的片段在画面上有标注。"
-      },
-      "ja": {
-        "label": "SharpLsp で VS Code の C# アプリをプロファイリング：ホットな行の CPU ヒート、最もホットな関数、リークする static な Dictionary の発見と修正",
-        "caption": "ナレーション、オリジナル音楽、字幕付き。VS Code で収録した Storefront デモでの C# の一連の流れ：Profile CPU とヒートマップ、Track Memory、リークの疑い、static フィールドをルートとする保持グラフ、修正の入力、そして再実行。早送りの部分は画面上に表示されます。"
-      }
-    }
-  },
   "architecture": {
+    "page": "/docs/architecture/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
@@ -414,6 +433,7 @@
     }
   },
   "contributing": {
+    "page": "/docs/contributing/",
     "encodings": ["mp4", "webm"],
     "width": 1920,
     "height": 1200,
diff --git a/src/website/src/_includes/layouts/base.njk b/src/website/src/_includes/layouts/base.njk
index 3aa68406..93964187 100644
--- a/src/website/src/_includes/layouts/base.njk
+++ b/src/website/src/_includes/layouts/base.njk
@@ -1,5 +1,14 @@
 {% set pageLang = lang | default(defaultLanguage) %}
 {% set pageDescription = description | default(i18n[pageLang].home.lede) | default(site.description) %}
+{% set isDocs = page.url.startsWith('/docs/') or page.url.startsWith('/' + pageLang + '/docs/') %}
+{% set pageTitle = title | default(site.title) %}
+{# A docs page title names the product too, so a search result or a tab says whose docs these are. #}
+{% set documentTitle = pageTitle + ' | ' + site.title if isDocs and not (site.title in pageTitle) else pageTitle %}
+{# [WEB-DESIGN-MEDIA-DISCOVERY] A page with a film shares it: its card, og:video and the X player card. #}
+{% set film = socialVideo %}
+{% set isWatch = film and film.watch == page.url %}
+{% set shareImage = film.card if film else site.ogImage %}
+{% set shareImageAlt = film.label if film else site.ogImageAlt %}
 <!DOCTYPE html>
 <html lang="{{ pageLang }}">
 <head>
@@ -22,8 +31,8 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 
   <!-- Primary Meta Tags -->
-  <title>{{ title | default(site.title) }}</title>
-  <meta name="title" content="{{ title | default(site.title) }}">
+  <title>{{ documentTitle }}</title>
+  <meta name="title" content="{{ documentTitle }}">
   <meta name="description" content="{{ pageDescription }}">
   {% if site.author %}<meta name="author" content="{{ site.author }}">{% endif %}
   {% if site.keywords %}<meta name="keywords" content="{{ site.keywords }}">{% endif %}
@@ -45,7 +54,7 @@
   <link rel="alternate" hreflang="x-default" href="{{ site.url }}{{ page.url | altLangUrl(lang | default('en'), defaultLanguage) }}">
 
   <!-- Open Graph -->
-  <meta property="og:type" content="{% if (page.url.startsWith('/blog/') or page.url.startsWith('/' + pageLang + '/blog/')) and page.url != '/blog/' and page.url != '/' + pageLang + '/blog/' %}article{% else %}website{% endif %}">
+  <meta property="og:type" content="{% if isWatch %}video.other{% elif (page.url.startsWith('/blog/') or page.url.startsWith('/' + pageLang + '/blog/')) and page.url != '/blog/' and page.url != '/' + pageLang + '/blog/' %}article{% else %}website{% endif %}">
   <meta property="og:url" content="{{ site.url }}{{ page.url }}">
   <meta property="og:title" content="{{ title | default(site.title) }}">
   <meta property="og:description" content="{{ pageDescription }}">
@@ -54,20 +63,39 @@
   {% for langCode in supportedLanguages %}{% if langCode != (lang | default('en')) %}
   <meta property="og:locale:alternate" content="{{ langCode | toOgLocale }}">
   {% endif %}{% endfor %}
-  {% if site.ogImage %}
-  <meta property="og:image" content="{{ site.url }}{{ site.ogImage }}">
-  <meta property="og:image:width" content="{{ site.ogImageWidth | default('1200') }}">
-  <meta property="og:image:height" content="{{ site.ogImageHeight | default('630') }}">
+  <meta property="og:image" content="{{ site.url }}{{ shareImage }}">
+  <meta property="og:image:type" content="{{ 'image/jpeg' if film else 'image/png' }}">
+  <meta property="og:image:width" content="{{ site.ogImageWidth }}">
+  <meta property="og:image:height" content="{{ site.ogImageHeight }}">
+  <meta property="og:image:alt" content="{{ shareImageAlt }}">
+  {% if film %}
+  <meta property="og:video" content="{{ site.url }}{{ film.stream }}">
+  <meta property="og:video:secure_url" content="{{ site.url }}{{ film.stream }}">
+  <meta property="og:video:type" content="video/mp4">
+  <meta property="og:video:width" content="{{ film.width }}">
+  <meta property="og:video:height" content="{{ film.height }}">
+  {% endif %}
+  {% if isWatch %}
+  <meta property="video:duration" content="{{ film.seconds }}">
+  <meta property="video:release_date" content="{{ film.uploadDate }}">
   {% endif %}
 
   <!-- Twitter -->
-  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:card" content="{{ 'player' if film else 'summary_large_image' }}">
   <meta name="twitter:url" content="{{ site.url }}{{ page.url }}">
-  <meta name="twitter:title" content="{{ title | default(site.title) }}">
+  <meta name="twitter:title" content="{{ pageTitle }}">
   <meta name="twitter:description" content="{{ pageDescription }}">
   {% if site.twitterSite %}<meta name="twitter:site" content="{{ site.twitterSite }}">{% endif %}
   {% if site.twitterCreator %}<meta name="twitter:creator" content="{{ site.twitterCreator }}">{% endif %}
-  {% if site.ogImage %}<meta name="twitter:image" content="{{ site.url }}{{ site.ogImage }}">{% endif %}
+  <meta name="twitter:image" content="{{ site.url }}{{ shareImage }}">
+  <meta name="twitter:image:alt" content="{{ shareImageAlt }}">
+  {% if film %}
+  <meta name="twitter:player" content="{{ site.url }}{{ film.embed }}">
+  <meta name="twitter:player:width" content="{{ film.width }}">
+  <meta name="twitter:player:height" content="{{ film.height }}">
+  <meta name="twitter:player:stream" content="{{ site.url }}{{ film.stream }}">
+  <meta name="twitter:player:stream:content_type" content="video/mp4">
+  {% endif %}
 
   <!-- JSON-LD Structured Data -->
   <script type="application/ld+json">
@@ -88,14 +116,14 @@
         }{% endif %}
       },
       {
-        "@type": "{% if page.url.startsWith('/docs/') or page.url.startsWith('/' + pageLang + '/docs/') %}TechArticle{% elif (page.url.startsWith('/blog/') or page.url.startsWith('/' + pageLang + '/blog/')) and page.url != '/blog/' and page.url != '/' + pageLang + '/blog/' %}BlogPosting{% else %}WebPage{% endif %}",
+        "@type": "{% if isDocs %}TechArticle{% elif (page.url.startsWith('/blog/') or page.url.startsWith('/' + pageLang + '/blog/')) and page.url != '/blog/' and page.url != '/' + pageLang + '/blog/' %}BlogPosting{% else %}WebPage{% endif %}",
         "@id": "{{ site.url }}{{ page.url }}#webpage",
         "url": "{{ site.url }}{{ page.url }}",
         "name": "{{ title | default(site.title) }}",
         "description": {{ pageDescription | dump | safe }},
         "isPartOf": { "@id": "{{ site.url }}/#website" },
-        "inLanguage": "{{ lang | default('en') }}"{% if page.date %},
-        "datePublished": "{{ page.date | isoDate }}"{% endif %}{% if author %},
+        "inLanguage": "{{ lang | default('en') }}"{% if published %},
+        "datePublished": "{{ published | isoDate }}"{% endif %}{% if author %},
         "author": {
           "@type": "Person",
           "name": "{{ author }}"
diff --git a/src/website/src/_includes/overrides/robots.txt.njk b/src/website/src/_includes/overrides/robots.txt.njk
new file mode 100644
index 00000000..e7684f7a
--- /dev/null
+++ b/src/website/src/_includes/overrides/robots.txt.njk
@@ -0,0 +1,64 @@
+---json
+{
+  "permalink": "robots.txt",
+  "eleventyExcludeFromCollections": true
+}
+---
+# {{ site.title | default(site.name) }}
+# {{ site.url }}
+
+# Allow all crawlers. [WEB-DESIGN-MEDIA-DISCOVERY] /assets/ stays open: search
+# engines fetch video files and thumbnails from it, and social networks fetch
+# card images and videos (Twitterbot, LinkedInBot and Slackbot obey this group).
+User-agent: *
+Allow: /
+Disallow: /search?
+
+# AI Crawlers - Welcome!
+User-agent: GPTBot
+Allow: /
+
+User-agent: ChatGPT-User
+Allow: /
+
+User-agent: Google-Extended
+Allow: /
+
+User-agent: Googlebot
+Allow: /
+
+User-agent: Bingbot
+Allow: /
+
+User-agent: ClaudeBot
+Allow: /
+
+User-agent: Anthropic-AI
+Allow: /
+
+User-agent: PerplexityBot
+Allow: /
+
+User-agent: Cohere-ai
+Allow: /
+
+User-agent: Meta-ExternalAgent
+Allow: /
+
+User-agent: Meta-ExternalFetcher
+Allow: /
+
+User-agent: Bytespider
+Allow: /
+
+User-agent: CCBot
+Allow: /
+
+User-agent: Applebot
+Allow: /
+
+User-agent: Amazonbot
+Allow: /
+
+# Sitemaps
+Sitemap: {{ site.url }}/sitemap.xml
diff --git a/src/website/src/_includes/overrides/sitemap.njk b/src/website/src/_includes/overrides/sitemap.njk
new file mode 100644
index 00000000..7127b6f9
--- /dev/null
+++ b/src/website/src/_includes/overrides/sitemap.njk
@@ -0,0 +1,46 @@
+---json
+{
+  "permalink": "sitemap.xml",
+  "eleventyExcludeFromCollections": true
+}
+---
+<?xml version="1.0" encoding="utf-8"?>
+{# [WEB-DESIGN-MEDIA-DISCOVERY] Every page, and on each watch page Google's video sitemap entry for its video. -#}
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1">
+  {%- for page in collections.all %}
+  {%- if not page.data.eleventyExcludeFromCollections %}
+  {%- set film = page.data.socialVideo %}
+  <url>
+    <loc>{{ site.url }}{{ page.url }}</loc>
+    <lastmod>{{ page.data.published | isoDate }}</lastmod>
+    {%- if page.url == "/" or page.url == "/index.html" %}
+    <priority>1.0</priority>
+    <changefreq>weekly</changefreq>
+    {%- elif "/docs/" in page.url %}
+    <priority>0.8</priority>
+    <changefreq>monthly</changefreq>
+    {%- elif "/blog/" in page.url %}
+    <priority>0.7</priority>
+    <changefreq>monthly</changefreq>
+    {%- else %}
+    <priority>0.5</priority>
+    <changefreq>monthly</changefreq>
+    {%- endif %}
+    {%- if film and film.watch == page.url %}
+    <video:video>
+      <video:thumbnail_loc>{{ site.url }}{{ film.poster }}</video:thumbnail_loc>
+      <video:title>{{ film.label }}</video:title>
+      <video:description>{{ film.caption }}</video:description>
+      <video:content_loc>{{ site.url }}{{ film.stream }}</video:content_loc>
+      <video:player_loc>{{ site.url }}{{ film.embed }}</video:player_loc>
+      <video:duration>{{ film.seconds }}</video:duration>
+      <video:publication_date>{{ film.uploadDate }}</video:publication_date>
+      <video:family_friendly>yes</video:family_friendly>
+      <video:requires_subscription>no</video:requires_subscription>
+      <video:live>no</video:live>
+    </video:video>
+    {%- endif %}
+  </url>
+  {%- endif %}
+  {%- endfor %}
+</urlset>
diff --git a/src/website/src/assets/css/pages.css b/src/website/src/assets/css/pages.css
index 5700279c..66ebb9e5 100644
--- a/src/website/src/assets/css/pages.css
+++ b/src/website/src/assets/css/pages.css
@@ -38,6 +38,9 @@
 .trust-list li::before { color: var(--color-primary); content: "✓"; font-weight: 800; margin-right: 0.45rem; }
 
 .product-shot { margin: clamp(3rem, 7vw, 5.5rem) 0 0; }
+/* [WEB-DESIGN-MEDIA-DISCOVERY] An embed page is its player, letterboxed to fill whatever frames it. */
+.video-frame { background: var(--color-code); height: 100vh; margin: 0; }
+.video-frame video { display: block; height: 100%; object-fit: contain; width: 100%; }
 .product-shot img,
 .product-shot video { border: 1px solid var(--color-border-strong); border-radius: var(--radius-lg); box-shadow: var(--shadow-lg); display: block; height: auto; width: 100%; }
 .product-shot figcaption { color: var(--color-muted); font-size: 0.78rem; margin: 0.9rem auto 0; max-width: 48rem; text-align: center; }
diff --git a/src/website/src/assets/css/prose.css b/src/website/src/assets/css/prose.css
index dc5aeee3..ba54b20f 100644
--- a/src/website/src/assets/css/prose.css
+++ b/src/website/src/assets/css/prose.css
@@ -67,6 +67,8 @@
 .article-figure img { border: 0; margin: 0; }
 .article-figure video { border-radius: var(--radius-sm); display: block; height: auto; width: 100%; }
 .article-figure figcaption { color: var(--color-muted); font-size: 0.8rem; padding: 0.6rem 0.5rem 0.2rem; text-align: center; }
+/* [WEB-DESIGN-MEDIA-DISCOVERY] A watch page's heading is the video's full label, set at reading size under the player. */
+.prose .video-title { font-size: clamp(1.5rem, 3vw, 2.25rem); line-height: 1.2; margin: 0 0 1.5rem; }
 .article-note,
 .callout { background: var(--color-surface-subtle); border-left: 3px solid var(--color-primary); border-radius: var(--radius-sm); margin: 2rem 0; padding: 1.25rem; }
 .article-note h3,
diff --git a/src/website/src/assets/js/custom.js b/src/website/src/assets/js/custom.js
index ec4914c5..387d4b7e 100644
--- a/src/website/src/assets/js/custom.js
+++ b/src/website/src/assets/js/custom.js
@@ -6,8 +6,20 @@ document.addEventListener("DOMContentLoaded", () => {
   initLanguageSwitcher();
   initBlogSearch();
   initReducedMotionVideos();
+  initSeekToTime();
 });
 
+// Implements [WEB-DESIGN-MEDIA-DISCOVERY]: `?t=<seconds>` starts a watch page's film
+// there, the deep link Google's key moments (SeekToAction) open.
+function initSeekToTime() {
+  const start = Number(new URLSearchParams(window.location.search).get("t"));
+  const video = document.querySelector(".prose video");
+  if (!video || !(start > 0)) return;
+  const seek = () => { video.currentTime = start; };
+  if (video.readyState >= HTMLMediaElement.HAVE_METADATA) seek();
+  else video.addEventListener("loadedmetadata", seek, { once: true });
+}
+
 // Implements [WEB-DESIGN-MEDIA]: autoplaying films hold still for readers who ask for less motion.
 function initReducedMotionVideos() {
   if (!window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
diff --git a/src/website/src/assets/videos/architecture-card.jpg b/src/website/src/assets/videos/architecture-card.jpg
new file mode 100644
index 00000000..f1f42bbf
Binary files /dev/null and b/src/website/src/assets/videos/architecture-card.jpg differ
diff --git a/src/website/src/assets/videos/code-completions-card.jpg b/src/website/src/assets/videos/code-completions-card.jpg
new file mode 100644
index 00000000..cadc886c
Binary files /dev/null and b/src/website/src/assets/videos/code-completions-card.jpg differ
diff --git a/src/website/src/assets/videos/configuration-card.jpg b/src/website/src/assets/videos/configuration-card.jpg
new file mode 100644
index 00000000..a8064a25
Binary files /dev/null and b/src/website/src/assets/videos/configuration-card.jpg differ
diff --git a/src/website/src/assets/videos/context-menus-card.jpg b/src/website/src/assets/videos/context-menus-card.jpg
new file mode 100644
index 00000000..c309315d
Binary files /dev/null and b/src/website/src/assets/videos/context-menus-card.jpg differ
diff --git a/src/website/src/assets/videos/contributing-card.jpg b/src/website/src/assets/videos/contributing-card.jpg
new file mode 100644
index 00000000..72515c38
Binary files /dev/null and b/src/website/src/assets/videos/contributing-card.jpg differ
diff --git a/src/website/src/assets/videos/diagnostics-card.jpg b/src/website/src/assets/videos/diagnostics-card.jpg
new file mode 100644
index 00000000..2c35fd25
Binary files /dev/null and b/src/website/src/assets/videos/diagnostics-card.jpg differ
diff --git a/src/website/src/assets/videos/editor-setup-card.jpg b/src/website/src/assets/videos/editor-setup-card.jpg
new file mode 100644
index 00000000..b61e3c51
Binary files /dev/null and b/src/website/src/assets/videos/editor-setup-card.jpg differ
diff --git a/src/website/src/assets/videos/fsharp-language-card.jpg b/src/website/src/assets/videos/fsharp-language-card.jpg
new file mode 100644
index 00000000..b33ba56f
Binary files /dev/null and b/src/website/src/assets/videos/fsharp-language-card.jpg differ
diff --git a/src/website/src/assets/videos/getting-started-card.jpg b/src/website/src/assets/videos/getting-started-card.jpg
new file mode 100644
index 00000000..8fa5ac7b
Binary files /dev/null and b/src/website/src/assets/videos/getting-started-card.jpg differ
diff --git a/src/website/src/assets/videos/hover-card.jpg b/src/website/src/assets/videos/hover-card.jpg
new file mode 100644
index 00000000..347c49e7
Binary files /dev/null and b/src/website/src/assets/videos/hover-card.jpg differ
diff --git a/src/website/src/assets/videos/navigation-card.jpg b/src/website/src/assets/videos/navigation-card.jpg
new file mode 100644
index 00000000..cb196c63
Binary files /dev/null and b/src/website/src/assets/videos/navigation-card.jpg differ
diff --git a/src/website/src/assets/videos/nuget-card.jpg b/src/website/src/assets/videos/nuget-card.jpg
new file mode 100644
index 00000000..5ca1c5f0
Binary files /dev/null and b/src/website/src/assets/videos/nuget-card.jpg differ
diff --git a/src/website/src/assets/videos/profiler-cpu-recording-card.jpg b/src/website/src/assets/videos/profiler-cpu-recording-card.jpg
new file mode 100644
index 00000000..64cef368
Binary files /dev/null and b/src/website/src/assets/videos/profiler-cpu-recording-card.jpg differ
diff --git a/src/website/src/assets/videos/profiler-csharp-card.jpg b/src/website/src/assets/videos/profiler-csharp-card.jpg
new file mode 100644
index 00000000..833bb19a
Binary files /dev/null and b/src/website/src/assets/videos/profiler-csharp-card.jpg differ
diff --git a/src/website/src/assets/videos/profiler-film-card.jpg b/src/website/src/assets/videos/profiler-film-card.jpg
new file mode 100644
index 00000000..fd2c2878
Binary files /dev/null and b/src/website/src/assets/videos/profiler-film-card.jpg differ
diff --git a/src/website/src/assets/videos/profiler-fix-memory-leak-card.jpg b/src/website/src/assets/videos/profiler-fix-memory-leak-card.jpg
new file mode 100644
index 00000000..3123715d
Binary files /dev/null and b/src/website/src/assets/videos/profiler-fix-memory-leak-card.jpg differ
diff --git a/src/website/src/assets/videos/profiler-fsharp-card.jpg b/src/website/src/assets/videos/profiler-fsharp-card.jpg
new file mode 100644
index 00000000..89dda261
Binary files /dev/null and b/src/website/src/assets/videos/profiler-fsharp-card.jpg differ
diff --git a/src/website/src/assets/videos/profiler-memory-timelapse-card.jpg b/src/website/src/assets/videos/profiler-memory-timelapse-card.jpg
new file mode 100644
index 00000000..a8048e0b
Binary files /dev/null and b/src/website/src/assets/videos/profiler-memory-timelapse-card.jpg differ
diff --git a/src/website/src/assets/videos/refactoring-card.jpg b/src/website/src/assets/videos/refactoring-card.jpg
new file mode 100644
index 00000000..87082531
Binary files /dev/null and b/src/website/src/assets/videos/refactoring-card.jpg differ
diff --git a/src/website/src/assets/videos/sharplsp-tour-card.jpg b/src/website/src/assets/videos/sharplsp-tour-card.jpg
new file mode 100644
index 00000000..8fac3c21
Binary files /dev/null and b/src/website/src/assets/videos/sharplsp-tour-card.jpg differ
diff --git a/src/website/src/docs/architecture.md b/src/website/src/docs/architecture.md
index 70c3c6d5..493196f4 100644
--- a/src/website/src/docs/architecture.md
+++ b/src/website/src/docs/architecture.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Architecture
+description: "How SharpLsp works: a Rust LSP host with tree-sitter parsing routes C# requests to a Roslyn sidecar and F# requests to an F# Compiler Service sidecar."
 eleventyNavigation:
   key: Architecture
   order: 2
diff --git a/src/website/src/docs/completions.md b/src/website/src/docs/completions.md
index 624619e9..2bd09947 100644
--- a/src/website/src/docs/completions.md
+++ b/src/website/src/docs/completions.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Code Completions
+description: "C# and F# code completion in SharpLsp: Roslyn for C#, the F# Compiler Service for F#, with replacement edits and import completions that add the missing using."
 eleventyNavigation:
   key: Code Completions
   order: 4
diff --git a/src/website/src/docs/configuration.md b/src/website/src/docs/configuration.md
index a6795ca1..e4f4ef3f 100644
--- a/src/website/src/docs/configuration.md
+++ b/src/website/src/docs/configuration.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Configuration
+description: "Configure SharpLsp: workspace server settings in sharplsp.toml, client settings under sharplsp.* in VS Code, where the file lives, and monorepo mode."
 eleventyNavigation:
   key: Configuration
   order: 9
diff --git a/src/website/src/docs/context-menus.md b/src/website/src/docs/context-menus.md
index 6c76d1bf..886b2e9b 100644
--- a/src/website/src/docs/context-menus.md
+++ b/src/website/src/docs/context-menus.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Context Menus
+description: "The SharpLsp Solution Explorer context menus in VS Code: Build, Rebuild, Clean, package maintenance, Open Project File and Sort Members for each node."
 eleventyNavigation:
   key: Context Menus
   order: 9
diff --git a/src/website/src/docs/contributing.md b/src/website/src/docs/contributing.md
index 91aa0261..517f5b45 100644
--- a/src/website/src/docs/contributing.md
+++ b/src/website/src/docs/contributing.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Contributing
+description: "Build SharpLsp from source and contribute: the prerequisites (Rust, .NET 10, Node.js), the dev container, the repository layout, and how to build and test."
 eleventyNavigation:
   key: Contributing
   order: 13
diff --git a/src/website/src/docs/diagnostics.md b/src/website/src/docs/diagnostics.md
index 23d63e70..bafe1121 100644
--- a/src/website/src/docs/diagnostics.md
+++ b/src/website/src/docs/diagnostics.md
@@ -1,7 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Diagnostics
-eleventyExcludeFromCollections: true
+description: "C# and F# diagnostics in SharpLsp: Roslyn and F# Compiler Service errors on unsaved code, push and pull delivery, and SharpLsp's unused-open and dead-code analyzers."
 ---
 
 <img src="/assets/screenshots/docs/diagnostics.webp" alt="The Problems panel with an F# type error from the F# Compiler Service and a C# CS0029 error from Roslyn, both from unsaved edits" width="2400" height="1500">
diff --git a/src/website/src/docs/editors.md b/src/website/src/docs/editors.md
index 9dfbc04e..6df09f36 100644
--- a/src/website/src/docs/editors.md
+++ b/src/website/src/docs/editors.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Editor Setup
+description: "Set up SharpLsp in VS Code, Cursor, Windsurf and VSCodium, and see where the Rider plugin, the standalone server and other LSP clients such as Zed and Neovim stand."
 eleventyNavigation:
   key: Editor Setup
   order: 3
diff --git a/src/website/src/docs/fsharp-profiling.md b/src/website/src/docs/fsharp-profiling.md
index 72a639c5..ab76bd00 100644
--- a/src/website/src/docs/fsharp-profiling.md
+++ b/src/website/src/docs/fsharp-profiling.md
@@ -2,7 +2,6 @@
 layout: layouts/docs.njk
 title: Profiling F#
 description: "Profile F# CPU and memory in VS Code with SharpLsp: heat bars on .fs lines, closures and pipeline stages by name, records and union cases anchored on the line that builds them, and leaks traced to the module value that holds them."
-eleventyExcludeFromCollections: true
 ---
 
 # Profiling F#
diff --git a/src/website/src/docs/fsharp.md b/src/website/src/docs/fsharp.md
index 7afb9bee..024ecc65 100644
--- a/src/website/src/docs/fsharp.md
+++ b/src/website/src/docs/fsharp.md
@@ -1,7 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: F# Language Support
-eleventyExcludeFromCollections: true
+description: "F# in VS Code with SharpLsp, powered by the F# Compiler Service: IntelliSense, navigation, rename, quick fixes, analyzers, Fantomas formatting and F# Interactive."
 ---
 
 # F# Language Support
diff --git a/src/website/src/docs/go-to-definition.md b/src/website/src/docs/go-to-definition.md
index 839eb559..d3ad26f2 100644
--- a/src/website/src/docs/go-to-definition.md
+++ b/src/website/src/docs/go-to-definition.md
@@ -1,7 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Go to Definition
-eleventyExcludeFromCollections: true
+description: "Go to definition, find references, implementations and type definitions for C# and F# in SharpLsp, with framework types shown as decompiled source."
 ---
 
 <img src="/assets/screenshots/docs/navigation.webp" alt="Find All References on the Product record in CheckoutPipeline.cs, every use listed in a peek window" width="2400" height="1500">
diff --git a/src/website/src/docs/hover.md b/src/website/src/docs/hover.md
index deb0e295..be52b4aa 100644
--- a/src/website/src/docs/hover.md
+++ b/src/website/src/docs/hover.md
@@ -1,7 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Hover and Quick Info
-eleventyExcludeFromCollections: true
+description: "Hover in SharpLsp for C# and F#: signatures, doc comments, XML docs and inferred types from Roslyn and the F# Compiler Service, read from your unsaved code."
 ---
 
 <img src="/assets/screenshots/docs/hover.webp" alt="A C# hover on Catalog.Generate showing its signature and rendered XML documentation" width="2400" height="1500">
diff --git a/src/website/src/docs/index.md b/src/website/src/docs/index.md
index 60a0fcf2..b4544890 100644
--- a/src/website/src/docs/index.md
+++ b/src/website/src/docs/index.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Getting Started
+description: "Install SharpLsp in VS Code, Cursor, Windsurf or VSCodium: one extension bundles the Rust host plus the Roslyn and F# Compiler Service sidecars for C# and F#."
 eleventyNavigation:
   key: Getting Started
   order: 1
diff --git a/src/website/src/docs/memory-leaks.md b/src/website/src/docs/memory-leaks.md
index 1b1b4282..0f497244 100644
--- a/src/website/src/docs/memory-leaks.md
+++ b/src/website/src/docs/memory-leaks.md
@@ -2,7 +2,6 @@
 layout: layouts/docs.njk
 title: How to Fix a Memory Leak in C# and .NET
 description: "How to fix a memory leak in C# and .NET, step by step: memory leak detection with a free .NET memory profiler in VS Code, the retention path that names the cause, fixes for static caches, event handlers, Dispose, timers and dependency injection, and the dotnet-counters, dotnet-gcdump and dotnet-dump route."
-eleventyExcludeFromCollections: true
 ---
 
 # How to Fix a Memory Leak in C# and .NET
diff --git a/src/website/src/docs/nuget.md b/src/website/src/docs/nuget.md
index 43c2d4c9..137a64e1 100644
--- a/src/website/src/docs/nuget.md
+++ b/src/website/src/docs/nuget.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: NuGet Package Manager
+description: "Browse and install NuGet packages in VS Code with SharpLsp: search nuget.org, edit project files or Directory.Packages.props, remove unused packages and consolidate versions."
 eleventyNavigation:
   key: NuGet Package Manager
   order: 8
diff --git a/src/website/src/docs/profiler.md b/src/website/src/docs/profiler.md
index 266d2d38..36da3e2f 100644
--- a/src/website/src/docs/profiler.md
+++ b/src/website/src/docs/profiler.md
@@ -1,7 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Profiler
-eleventyExcludeFromCollections: true
+description: "Profile CPU and memory of any running .NET process in VS Code with SharpLsp: heat on hot lines, a flame graph, a live heap timeline and leak suspects."
 ---
 
 # Profiler
diff --git a/src/website/src/docs/refactoring.md b/src/website/src/docs/refactoring.md
index 2ba8b42b..c16b3e75 100644
--- a/src/website/src/docs/refactoring.md
+++ b/src/website/src/docs/refactoring.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: Refactoring & Code Actions
+description: "C# and F# code actions in SharpLsp: Roslyn code fixes and refactorings, F# quick fixes, rename, formatting and Sort Members, from the lightbulb or Ctrl+."
 eleventyNavigation:
   key: Refactoring & Code Actions
   order: 7
diff --git a/src/website/src/ja/docs/architecture.md b/src/website/src/ja/docs/architecture.md
index 2146b3b7..08fcbe41 100644
--- a/src/website/src/ja/docs/architecture.md
+++ b/src/website/src/ja/docs/architecture.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: アーキテクチャ
+description: "SharpLsp の仕組み：tree-sitter で解析する Rust の LSP ホストが、C# のリクエストを Roslyn のサイドカーへ、F# のリクエストを F# Compiler Service のサイドカーへ振り分けます。"
 lang: ja
 eleventyNavigation:
   key: アーキテクチャ（日本語）
diff --git a/src/website/src/ja/docs/completions.md b/src/website/src/ja/docs/completions.md
index 14298865..0482f83e 100644
--- a/src/website/src/ja/docs/completions.md
+++ b/src/website/src/ja/docs/completions.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: コード補完
+description: "SharpLsp の C# と F# のコード補完：C# は Roslyn、F# は F# Compiler Service。識別子を置き換える編集と、足りない using を追加するインポート補完。"
 lang: ja
 eleventyNavigation:
   key: コード補完（日本語）
diff --git a/src/website/src/ja/docs/configuration.md b/src/website/src/ja/docs/configuration.md
index 60e2e267..a41fd460 100644
--- a/src/website/src/ja/docs/configuration.md
+++ b/src/website/src/ja/docs/configuration.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 設定
+description: "SharpLsp の設定：sharplsp.toml のワークスペース用サーバー設定、VS Code の sharplsp.* クライアント設定、ファイルの置き場所、monorepo モード。"
 lang: ja
 eleventyNavigation:
   key: 設定（日本語）
diff --git a/src/website/src/ja/docs/context-menus.md b/src/website/src/ja/docs/context-menus.md
index 27c908b4..017ecc10 100644
--- a/src/website/src/ja/docs/context-menus.md
+++ b/src/website/src/ja/docs/context-menus.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: コンテキストメニュー
+description: "VS Code の SharpLsp ソリューションエクスプローラーのコンテキストメニュー：ビルド、リビルド、クリーン、パッケージの整理、プロジェクトファイルを開く、メンバーの並べ替え。"
 lang: ja
 eleventyNavigation:
   key: コンテキストメニュー（日本語）
diff --git a/src/website/src/ja/docs/contributing.md b/src/website/src/ja/docs/contributing.md
index 8d7df9d3..e76e39e0 100644
--- a/src/website/src/ja/docs/contributing.md
+++ b/src/website/src/ja/docs/contributing.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: コントリビュート
+description: "SharpLsp をソースからビルドして貢献する：前提条件（Rust、.NET 10、Node.js）、Dev Container、リポジトリの構成、ビルドとテストの方法。"
 lang: ja
 eleventyNavigation:
   key: コントリビュート（日本語）
diff --git a/src/website/src/ja/docs/diagnostics.md b/src/website/src/ja/docs/diagnostics.md
index da8ec7cd..f9519ad4 100644
--- a/src/website/src/ja/docs/diagnostics.md
+++ b/src/website/src/ja/docs/diagnostics.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: 診断
+description: "SharpLsp の C# と F# の診断：未保存のコードに対する Roslyn と F# Compiler Service のエラー、プッシュとプルの配信、未使用 open とデッドコードのアナライザー。"
 lang: ja
-eleventyExcludeFromCollections: true
 ---
 
 <img src="/assets/screenshots/docs/diagnostics.webp" alt="問題パネル：未保存の編集から、F# Compiler Service による F# の型エラーと、Roslyn による C# の CS0029 エラー" width="2400" height="1500">
diff --git a/src/website/src/ja/docs/editors.md b/src/website/src/ja/docs/editors.md
index 2c236d66..257bf4ef 100644
--- a/src/website/src/ja/docs/editors.md
+++ b/src/website/src/ja/docs/editors.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: エディター設定
+description: "VS Code、Cursor、Windsurf、VSCodium での SharpLsp のセットアップと、Rider プラグイン、スタンドアロンサーバー、Zed や Neovim などほかの LSP クライアントの現状。"
 lang: ja
 eleventyNavigation:
   key: エディター設定（日本語）
diff --git a/src/website/src/ja/docs/fsharp-profiling.md b/src/website/src/ja/docs/fsharp-profiling.md
index d5dfcb91..111fb713 100644
--- a/src/website/src/ja/docs/fsharp-profiling.md
+++ b/src/website/src/ja/docs/fsharp-profiling.md
@@ -3,7 +3,6 @@ layout: layouts/docs.njk
 title: F# のプロファイリング
 description: "SharpLsp で F# の CPU とメモリを VS Code でプロファイリング：.fs の行に付くヒートバー、名前で示されるクロージャーとパイプラインのステージ、組み立てた行に固定されるレコードと共用体ケース、リークを保持するモジュール値の特定。"
 lang: ja
-eleventyExcludeFromCollections: true
 ---
 
 # F# のプロファイリング
diff --git a/src/website/src/ja/docs/fsharp.md b/src/website/src/ja/docs/fsharp.md
index 4de9a246..cfa3cdc0 100644
--- a/src/website/src/ja/docs/fsharp.md
+++ b/src/website/src/ja/docs/fsharp.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: F# 言語サポート
+description: "F# Compiler Service による SharpLsp の F# サポート：IntelliSense、ナビゲーション、名前の変更、クイックフィックス、アナライザー、Fantomas の整形、F# Interactive。"
 lang: ja
-eleventyExcludeFromCollections: true
 ---
 
 # F# 言語サポート
diff --git a/src/website/src/ja/docs/go-to-definition.md b/src/website/src/ja/docs/go-to-definition.md
index d61e6cd8..63bca6ef 100644
--- a/src/website/src/ja/docs/go-to-definition.md
+++ b/src/website/src/ja/docs/go-to-definition.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: 定義へ移動
+description: "SharpLsp の C# と F# のナビゲーション：定義へ移動、参照の検索、実装と型定義へ移動。フレームワークの型は逆コンパイルしたソースで表示します。"
 lang: ja
-eleventyExcludeFromCollections: true
 ---
 
 <img src="/assets/screenshots/docs/navigation.webp" alt="CheckoutPipeline.cs の Product レコードに対するすべての参照の検索。ピークウィンドウにすべての使用箇所が並ぶ" width="2400" height="1500">
diff --git a/src/website/src/ja/docs/hover.md b/src/website/src/ja/docs/hover.md
index 1cfd8d8b..2abe960f 100644
--- a/src/website/src/ja/docs/hover.md
+++ b/src/website/src/ja/docs/hover.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: ホバーとクイック情報
+description: "SharpLsp の C# と F# のホバー：Roslyn と F# Compiler Service によるシグネチャー、ドキュメントコメント、XML ドキュメント、推論された型を未保存のコードから表示。"
 lang: ja
-eleventyExcludeFromCollections: true
 ---
 
 <img src="/assets/screenshots/docs/hover.webp" alt="Catalog.Generate に対する C# のホバー。シグネチャーと、整形された XML ドキュメント" width="2400" height="1500">
diff --git a/src/website/src/ja/docs/index.md b/src/website/src/ja/docs/index.md
index 295906a2..8a1f0215 100644
--- a/src/website/src/ja/docs/index.md
+++ b/src/website/src/ja/docs/index.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: はじめに
+description: "VS Code、Cursor、Windsurf、VSCodium に SharpLsp をインストール。1 つの拡張機能に Rust ホストと、C# 用の Roslyn・F# 用の F# Compiler Service のサイドカーが同梱されています。"
 lang: ja
 eleventyNavigation:
   key: はじめに（日本語）
diff --git a/src/website/src/ja/docs/memory-leaks.md b/src/website/src/ja/docs/memory-leaks.md
index debe904d..3e9f5149 100644
--- a/src/website/src/ja/docs/memory-leaks.md
+++ b/src/website/src/ja/docs/memory-leaks.md
@@ -3,7 +3,6 @@ layout: layouts/docs.njk
 title: C# と .NET のメモリリークを修正する方法
 description: "C# と .NET のメモリリークを修正する方法をステップバイステップで解説：VS Code の無料の .NET メモリプロファイラーによるメモリリーク検出、原因を示す保持パス、静的キャッシュ・イベントハンドラー・Dispose・タイマー・依存性の注入が原因のリークの直し方、そして dotnet-counters・dotnet-gcdump・dotnet-dump を使う方法。"
 lang: ja
-eleventyExcludeFromCollections: true
 ---
 
 # C# と .NET のメモリリークを修正する方法
diff --git a/src/website/src/ja/docs/nuget.md b/src/website/src/ja/docs/nuget.md
index 241d6810..c7a23173 100644
--- a/src/website/src/ja/docs/nuget.md
+++ b/src/website/src/ja/docs/nuget.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: NuGet パッケージマネージャー
+description: "SharpLsp で VS Code から NuGet パッケージを参照・インストール：nuget.org の検索、プロジェクトファイルや Directory.Packages.props の編集、未使用パッケージの削除とバージョンの統合。"
 lang: ja
 eleventyNavigation:
   key: NuGet パッケージマネージャー（日本語）
diff --git a/src/website/src/ja/docs/profiler.md b/src/website/src/ja/docs/profiler.md
index 51a8a9ba..1559714a 100644
--- a/src/website/src/ja/docs/profiler.md
+++ b/src/website/src/ja/docs/profiler.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: プロファイラー
+description: "SharpLsp で実行中の .NET プロセスの CPU とメモリを VS Code からプロファイリング：ホットな行のヒート、フレームグラフ、ライブのヒープタイムライン、リークの疑い。"
 lang: ja
-eleventyExcludeFromCollections: true
 ---
 
 # プロファイラー
diff --git a/src/website/src/ja/docs/refactoring.md b/src/website/src/ja/docs/refactoring.md
index 7bb4ea7e..a65d0665 100644
--- a/src/website/src/ja/docs/refactoring.md
+++ b/src/website/src/ja/docs/refactoring.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: リファクタリングとコードアクション
+description: "SharpLsp の C# と F# のコードアクション：Roslyn のコード修正とリファクタリング、F# のクイックフィックス、名前の変更、整形、メンバーの並べ替え。"
 lang: ja
 eleventyNavigation:
   key: リファクタリングとコードアクション（日本語）
diff --git a/src/website/src/videos/embed.njk b/src/website/src/videos/embed.njk
new file mode 100644
index 00000000..3f486ef1
--- /dev/null
+++ b/src/website/src/videos/embed.njk
@@ -0,0 +1,23 @@
+---
+pagination:
+  data: videoPages
+  size: 1
+  alias: watch
+permalink: "{{ watch.embed }}"
+eleventyExcludeFromCollections: true
+---
+<!DOCTYPE html>
+{# Implements [WEB-DESIGN-MEDIA-DISCOVERY]: the bare player that X's player card frames and Google's embedUrl names. #}
+<html lang="{{ lang }}">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="robots" content="noindex">
+  <title>{{ title }}</title>
+  <link rel="stylesheet" href="/assets/css/styles.css">
+  <link rel="stylesheet" href="/assets/css/pages.css">
+</head>
+<body class="video-frame">
+{% videoPlayer watch.id, lang %}
+</body>
+</html>
diff --git a/src/website/src/videos/videos.11tydata.js b/src/website/src/videos/videos.11tydata.js
new file mode 100644
index 00000000..2219445e
--- /dev/null
+++ b/src/website/src/videos/videos.11tydata.js
@@ -0,0 +1,9 @@
+// [WEB-DESIGN-MEDIA-DISCOVERY] A watch page and its embed take their language,
+// title and description from the video they show.
+export default {
+  eleventyComputed: {
+    lang: (data) => data.watch.lang,
+    title: (data) => data.watch.label,
+    description: (data) => data.watch.caption,
+  },
+};
diff --git a/src/website/src/videos/watch.njk b/src/website/src/videos/watch.njk
new file mode 100644
index 00000000..ed5d052c
--- /dev/null
+++ b/src/website/src/videos/watch.njk
@@ -0,0 +1,25 @@
+---
+pagination:
+  data: videoPages
+  size: 1
+  alias: watch
+  addAllPagesToCollections: true
+permalink: "{{ watch.watch }}"
+layout: layouts/prose.njk
+---
+{# Implements [WEB-DESIGN-MEDIA-DISCOVERY]: one video as the page's main content, the watch page Google indexes it from. #}
+{% set videoText = i18n[lang].video %}
+{# The player leads, above the fold on a phone too; the long label follows as the heading. #}
+{% video watch.id, { watch: true } %}
+<h1 class="video-title">{{ watch.label }}</h1>
+{% for guide in collections.all %}{% if guide.url == watch.page %}
+<p><a href="{{ watch.page }}">{{ videoText.guide }}{{ guide.data.title }}</a></p>
+{% endif %}{% endfor %}
+{% if watch.transcript.length %}
+<section>
+  <h2>{{ videoText.transcript }}</h2>
+  {% for line in watch.transcript %}
+  <p>{{ line }}</p>
+  {% endfor %}
+</section>
+{% endif %}
diff --git a/src/website/src/zh/docs/architecture.md b/src/website/src/zh/docs/architecture.md
index 4e168a68..cb437fc5 100644
--- a/src/website/src/zh/docs/architecture.md
+++ b/src/website/src/zh/docs/architecture.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 架构
+description: "SharpLsp 的工作原理：基于 tree-sitter 解析的 Rust LSP 宿主把 C# 请求路由到 Roslyn sidecar，把 F# 请求路由到 F# Compiler Service sidecar。"
 lang: zh
 eleventyNavigation:
   key: 架构（中文）
diff --git a/src/website/src/zh/docs/completions.md b/src/website/src/zh/docs/completions.md
index 0187c0f4..91ddca5a 100644
--- a/src/website/src/zh/docs/completions.md
+++ b/src/website/src/zh/docs/completions.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 代码补全
+description: "SharpLsp 的 C# 与 F# 代码补全：C# 由 Roslyn 提供，F# 由 F# Compiler Service 提供，支持替换标识符的编辑，以及自动添加 using 的导入补全。"
 lang: zh
 eleventyNavigation:
   key: 代码补全（中文）
diff --git a/src/website/src/zh/docs/configuration.md b/src/website/src/zh/docs/configuration.md
index e7eb4cba..03711a95 100644
--- a/src/website/src/zh/docs/configuration.md
+++ b/src/website/src/zh/docs/configuration.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 配置
+description: "配置 SharpLsp：sharplsp.toml 中的工作区服务器设置、VS Code 中的 sharplsp.* 客户端设置、文件位置，以及 monorepo 模式。"
 lang: zh
 eleventyNavigation:
   key: 配置（中文）
diff --git a/src/website/src/zh/docs/context-menus.md b/src/website/src/zh/docs/context-menus.md
index bc195ce8..fa963c3e 100644
--- a/src/website/src/zh/docs/context-menus.md
+++ b/src/website/src/zh/docs/context-menus.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 上下文菜单
+description: "VS Code 中 SharpLsp 解决方案资源管理器的上下文菜单：生成、重新生成、清理、包维护、打开项目文件和排序成员。"
 lang: zh
 eleventyNavigation:
   key: 上下文菜单（中文）
diff --git a/src/website/src/zh/docs/contributing.md b/src/website/src/zh/docs/contributing.md
index b22baa15..fb4d8f78 100644
--- a/src/website/src/zh/docs/contributing.md
+++ b/src/website/src/zh/docs/contributing.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 参与贡献
+description: "从源代码构建 SharpLsp 并参与贡献：前置条件（Rust、.NET 10、Node.js）、Dev Container、仓库结构，以及构建和测试方法。"
 lang: zh
 eleventyNavigation:
   key: 参与贡献（中文）
diff --git a/src/website/src/zh/docs/diagnostics.md b/src/website/src/zh/docs/diagnostics.md
index d1f65be7..98b0e6b1 100644
--- a/src/website/src/zh/docs/diagnostics.md
+++ b/src/website/src/zh/docs/diagnostics.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: 诊断
+description: "SharpLsp 的 C# 与 F# 诊断：Roslyn 和 F# Compiler Service 针对未保存代码的错误、推送与拉取两种模式，以及未使用 open 和死代码分析器。"
 lang: zh
-eleventyExcludeFromCollections: true
 ---
 
 <img src="/assets/screenshots/docs/diagnostics.webp" alt="问题面板：来自未保存编辑的 F# Compiler Service F# 类型错误和 Roslyn C# CS0029 错误" width="2400" height="1500">
diff --git a/src/website/src/zh/docs/editors.md b/src/website/src/zh/docs/editors.md
index 5d03969a..0a595ef1 100644
--- a/src/website/src/zh/docs/editors.md
+++ b/src/website/src/zh/docs/editors.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 编辑器配置
+description: "在 VS Code、Cursor、Windsurf 和 VSCodium 中设置 SharpLsp，并了解 Rider 插件、独立服务器以及 Zed、Neovim 等其他 LSP 客户端的现状。"
 lang: zh
 eleventyNavigation:
   key: 编辑器配置（中文）
diff --git a/src/website/src/zh/docs/fsharp-profiling.md b/src/website/src/zh/docs/fsharp-profiling.md
index a54e6af3..23186e8c 100644
--- a/src/website/src/zh/docs/fsharp-profiling.md
+++ b/src/website/src/zh/docs/fsharp-profiling.md
@@ -3,7 +3,6 @@ layout: layouts/docs.njk
 title: F# 性能分析
 description: "用 SharpLsp 在 VS Code 中分析 F# 的 CPU 和内存：.fs 行上的热力条、按名称显示的闭包和管道阶段、标在构造位置的记录和联合用例，以及追溯到持有泄漏的模块值。"
 lang: zh
-eleventyExcludeFromCollections: true
 ---
 
 # F# 性能分析
diff --git a/src/website/src/zh/docs/fsharp.md b/src/website/src/zh/docs/fsharp.md
index 95fec4ff..f7b70fc6 100644
--- a/src/website/src/zh/docs/fsharp.md
+++ b/src/website/src/zh/docs/fsharp.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: F# 语言支持
+description: "SharpLsp 基于 F# Compiler Service 的 F# 支持：IntelliSense、导航、重命名、快速修复、分析器、Fantomas 格式化和 F# Interactive。"
 lang: zh
-eleventyExcludeFromCollections: true
 ---
 
 # F# 语言支持
diff --git a/src/website/src/zh/docs/go-to-definition.md b/src/website/src/zh/docs/go-to-definition.md
index 0334a727..e7574745 100644
--- a/src/website/src/zh/docs/go-to-definition.md
+++ b/src/website/src/zh/docs/go-to-definition.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: 跳转到定义
+description: "SharpLsp 的 C# 与 F# 导航：转到定义、查找引用、转到实现和类型定义，框架类型以反编译源代码显示。"
 lang: zh
-eleventyExcludeFromCollections: true
 ---
 
 <img src="/assets/screenshots/docs/navigation.webp" alt="在 CheckoutPipeline.cs 中对 Product 记录查找所有引用，速览窗口列出了每一处使用" width="2400" height="1500">
diff --git a/src/website/src/zh/docs/hover.md b/src/website/src/zh/docs/hover.md
index 7320a37e..93a94319 100644
--- a/src/website/src/zh/docs/hover.md
+++ b/src/website/src/zh/docs/hover.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: 悬停与快速信息
+description: "SharpLsp 的 C# 与 F# 悬停：来自 Roslyn 和 F# Compiler Service 的签名、文档注释、XML 文档和推断类型，基于未保存的代码。"
 lang: zh
-eleventyExcludeFromCollections: true
 ---
 
 <img src="/assets/screenshots/docs/hover.webp" alt="在 Catalog.Generate 上的 C# 悬停，显示其签名和渲染后的 XML 文档" width="2400" height="1500">
diff --git a/src/website/src/zh/docs/index.md b/src/website/src/zh/docs/index.md
index 7a9fa1cf..d4910f5c 100644
--- a/src/website/src/zh/docs/index.md
+++ b/src/website/src/zh/docs/index.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 快速入门
+description: "在 VS Code、Cursor、Windsurf 或 VSCodium 中安装 SharpLsp：一个扩展即包含 Rust 宿主，以及用于 C# 的 Roslyn 和用于 F# 的 F# Compiler Service sidecar。"
 lang: zh
 eleventyNavigation:
   key: 快速入门（中文）
diff --git a/src/website/src/zh/docs/memory-leaks.md b/src/website/src/zh/docs/memory-leaks.md
index e4498f66..bcc06f44 100644
--- a/src/website/src/zh/docs/memory-leaks.md
+++ b/src/website/src/zh/docs/memory-leaks.md
@@ -3,7 +3,6 @@ layout: layouts/docs.njk
 title: 如何修复 C# 和 .NET 中的内存泄漏
 description: "逐步讲解如何修复 C# 和 .NET 中的内存泄漏：在 VS Code 中用免费的 .NET 内存分析器检测内存泄漏，用保留路径找出原因，修复静态缓存、事件处理程序、Dispose、计时器和依赖注入引起的泄漏，以及使用 dotnet-counters、dotnet-gcdump 和 dotnet-dump 的方法。"
 lang: zh
-eleventyExcludeFromCollections: true
 ---
 
 # 如何修复 C# 和 .NET 中的内存泄漏
diff --git a/src/website/src/zh/docs/nuget.md b/src/website/src/zh/docs/nuget.md
index 9ebf7b47..31f9c22b 100644
--- a/src/website/src/zh/docs/nuget.md
+++ b/src/website/src/zh/docs/nuget.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: NuGet 包管理器
+description: "在 VS Code 中用 SharpLsp 浏览和安装 NuGet 包：搜索 nuget.org，编辑项目文件或 Directory.Packages.props，移除未使用的包并统一版本。"
 lang: zh
 eleventyNavigation:
   key: NuGet 包管理器（中文）
diff --git a/src/website/src/zh/docs/profiler.md b/src/website/src/zh/docs/profiler.md
index c687fd19..6b14092a 100644
--- a/src/website/src/zh/docs/profiler.md
+++ b/src/website/src/zh/docs/profiler.md
@@ -1,8 +1,8 @@
 ---
 layout: layouts/docs.njk
 title: 性能分析器
+description: "在 VS Code 中用 SharpLsp 分析任意正在运行的 .NET 进程的 CPU 与内存：热点行热度、火焰图、实时堆时间线和可疑泄漏。"
 lang: zh
-eleventyExcludeFromCollections: true
 ---
 
 # 性能分析器
diff --git a/src/website/src/zh/docs/refactoring.md b/src/website/src/zh/docs/refactoring.md
index 5194770e..2992fc58 100644
--- a/src/website/src/zh/docs/refactoring.md
+++ b/src/website/src/zh/docs/refactoring.md
@@ -1,6 +1,7 @@
 ---
 layout: layouts/docs.njk
 title: 重构与代码操作
+description: "SharpLsp 的 C# 与 F# 代码操作：Roslyn 代码修复与重构、F# 快速修复、重命名、格式化和成员排序。"
 lang: zh
 eleventyNavigation:
   key: 重构与代码操作（中文）
diff --git a/src/website/tests/media.js b/src/website/tests/media.js
index 74ed62c1..7acd0b24 100644
--- a/src/website/tests/media.js
+++ b/src/website/tests/media.js
@@ -1,6 +1,15 @@
 // Shared probes for [WEB-DESIGN-MEDIA] tests: is a media URL really served, and
 // what does a page tell search engines about its videos?
 import { expect } from '@playwright/test';
+import { readFileSync } from 'node:fs';
+
+// [WEB-DESIGN-MEDIA-DISCOVERY] The catalogue, and the URLs the spec gives each video.
+export const SITE = 'https://sharplsp.dev';
+export const VIDEOS = JSON.parse(readFileSync(new URL('../src/_data/videos.json', import.meta.url), 'utf8'));
+export const LANGS = ['en', 'ja', 'zh'];
+export const local = (lang, path) => (lang === 'en' ? path : `/${lang}${path}`);
+export const watchOf = (id, lang) => local(lang, `/videos/${id}/`);
+export const embedOf = (id, lang) => `${watchOf(id, lang)}embed/`;
 
 /** Fetch the first bytes of a media URL; returns its status and content type. */
 async function probe(request, url) {
diff --git a/src/website/tests/video-discovery.spec.js b/src/website/tests/video-discovery.spec.js
new file mode 100644
index 00000000..ce4eb816
--- /dev/null
+++ b/src/website/tests/video-discovery.spec.js
@@ -0,0 +1,84 @@
+// Tests for [WEB-DESIGN-MEDIA-DISCOVERY]: every catalogued video has a watch page
+// Google can index it from, a bare embed player, a video sitemap entry and
+// structured data that match the real files, and every docs page shares its film
+// as a playable social preview.
+import { test, expect } from '@playwright/test';
+import { LANGS, SITE, VIDEOS, embedOf, expectPlayable, local } from './media.js';
+
+const cardOf = (id) => `/assets/videos/${id}-card.jpg`;
+const mp4Of = (id) => `/assets/videos/${id}.mp4`;
+
+// Each docs page's preview is the film it leads with. [WEB-DESIGN-MEDIA-DISCOVERY] Social previews
+const PREVIEWS = {
+  '/docs/': 'getting-started', '/docs/editors/': 'editor-setup', '/docs/configuration/': 'configuration',
+  '/docs/fsharp/': 'fsharp-language', '/docs/completions/': 'code-completions', '/docs/hover/': 'hover',
+  '/docs/go-to-definition/': 'navigation', '/docs/diagnostics/': 'diagnostics', '/docs/refactoring/': 'refactoring',
+  '/docs/context-menus/': 'context-menus', '/docs/nuget/': 'nuget', '/docs/profiler/': 'profiler-csharp',
+  '/docs/memory-leaks/': 'profiler-fix-memory-leak', '/docs/fsharp-profiling/': 'profiler-fsharp',
+  '/docs/architecture/': 'architecture', '/docs/contributing/': 'contributing',
+};
+const DOCS = [...Object.keys(PREVIEWS), '/docs/zed/'];
+
+const meta = (page, key) => page.locator(`meta[property="${key}"], meta[name="${key}"]`).getAttribute('content');
+
+/** The decoded size of the image at `src`, as a browser sees it. */
+const imageSize = (page, src) =>
+  page.evaluate(async (url) => {
+    const image = new Image();
+    image.src = url;
+    await image.decode();
+    return [image.naturalWidth, image.naturalHeight];
+  }, src);
+
+async function expectFilmPreview(page, request, id, lang) {
+  expect(await meta(page, 'og:image')).toBe(`${SITE}${cardOf(id)}`);
+  expect(await meta(page, 'twitter:image')).toBe(`${SITE}${cardOf(id)}`);
+  expect(await imageSize(page, cardOf(id)), 'the card is the 1200x630 social size').toEqual([1200, 630]);
+  expect(await meta(page, 'og:image:alt')).toBe(VIDEOS[id].text[lang].label);
+  expect(await meta(page, 'og:video')).toBe(`${SITE}${mp4Of(id)}`);
+  expect(await meta(page, 'og:video:type')).toBe('video/mp4');
+  expect(await meta(page, 'og:video:width')).toBe(String(VIDEOS[id].width));
+  expect(await meta(page, 'twitter:card')).toBe('player');
+  expect(await meta(page, 'twitter:player')).toBe(`${SITE}${embedOf(id, lang)}`);
+  expect(await meta(page, 'twitter:player:stream')).toBe(`${SITE}${mp4Of(id)}`);
+  await expectPlayable(request, [cardOf(id)], 'image/jpeg');
+  await expectPlayable(request, [mp4Of(id)], 'video/mp4');
+}
+
+for (const [path, id] of Object.entries(PREVIEWS)) {
+  test(`${path} shares ${id} as a playable social preview in every language`, async ({ page, request }) => {
+    for (const lang of LANGS) {
+      await page.goto(local(lang, path));
+      await expectFilmPreview(page, request, id, lang);
+      expect(await page.locator('figure video').first().getAttribute('aria-label'), 'the preview is the film the page leads with')
+        .toBe(VIDEOS[id].text[lang].label);
+      await expect(page).toHaveTitle(/ \| SharpLsp$/);
+    }
+  });
+}
+
+test('a page without a film shares the site card, described, as a large image', async ({ page, request }) => {
+  for (const path of ['/docs/zed/', '/ja/docs/zed/', '/']) {
+    await page.goto(path);
+    expect(await meta(page, 'og:image')).toBe(`${SITE}/assets/images/og-image.png`);
+    expect(await meta(page, 'twitter:card')).toBe('summary_large_image');
+    expect((await meta(page, 'og:image:alt')).length, 'the site card has alt text').toBeGreaterThan(20);
+    await expect(page.locator('meta[property="og:video"]')).toHaveCount(0);
+  }
+  await expectPlayable(request, ['/assets/images/og-image.png'], 'image/png');
+});
+
+for (const lang of LANGS) {
+  test(`every ${lang} docs page has its own description`, async ({ page }) => {
+    await page.goto(local(lang, '/'));
+    const homeDescription = await meta(page, 'description');
+    const descriptions = [];
+    for (const path of DOCS) {
+      await page.goto(local(lang, path));
+      descriptions.push(await meta(page, 'og:description'));
+      expect(await meta(page, 'description')).toBe(descriptions.at(-1));
+    }
+    expect(descriptions, 'no docs page borrows the home page description').not.toContain(homeDescription);
+    expect(new Set(descriptions).size, 'every description is unique').toBe(DOCS.length);
+  });
+}
diff --git a/src/website/tests/video-watch-pages.spec.js b/src/website/tests/video-watch-pages.spec.js
new file mode 100644
index 00000000..2c7c04ef
--- /dev/null
+++ b/src/website/tests/video-watch-pages.spec.js
@@ -0,0 +1,156 @@
+// Tests for [WEB-DESIGN-MEDIA-DISCOVERY]: Google indexes a video from a page where
+// it is the main content. Every catalogued video has a watch page per language,
+// whose metadata matches the real file, a bare embed player, an entry in the
+// video sitemap, and crawlers may fetch its files.
+import { test, expect } from '@playwright/test';
+import { seconds as secondsOf } from '../video-pages.js';
+import { LANGS, SITE, VIDEOS, embedOf, expectPlayable, local, videoObjects, watchOf } from './media.js';
+
+const DOC_SLUGS = ['', 'architecture/', 'completions/', 'configuration/', 'context-menus/', 'contributing/', 'diagnostics/',
+  'editors/', 'fsharp/', 'fsharp-profiling/', 'go-to-definition/', 'hover/', 'memory-leaks/', 'nuget/', 'profiler/',
+  'refactoring/', 'zed/'];
+
+/** The real file's length and frame size, once the browser has read its metadata. */
+async function loadedMetadata(video) {
+  await video.evaluate((v) => { v.preload = 'auto'; v.load(); });
+  await expect.poll(() => video.evaluate((v) => v.readyState), { timeout: 15000 }).toBeGreaterThanOrEqual(1);
+  return video.evaluate((v) => ({ duration: v.duration, width: v.videoWidth, height: v.videoHeight }));
+}
+
+async function expectWatchPage(page, id, lang) {
+  const { label } = VIDEOS[id].text[lang];
+  await expect(page.locator('main h1')).toHaveText(label);
+  await expect(page).toHaveTitle(label);
+  await expect(page.locator('main video')).toHaveCount(1);
+  await expect(page.locator('main video')).toHaveAttribute('aria-label', label);
+  const [player, heading] = [await page.locator('main video').boundingBox(), await page.locator('main h1').boundingBox()];
+  expect(player.y, 'the player is the main content, on the first screen').toBeLessThan(page.viewportSize().height / 2);
+  expect(player.y, 'the player leads, the long label follows').toBeLessThan(heading.y);
+  expect(await page.locator('meta[property="og:type"]').getAttribute('content')).toBe('video.other');
+  expect(await page.locator('meta[property="video:duration"]').getAttribute('content')).toBe(String(secondsOf(VIDEOS[id].duration)));
+  await expect(page.locator(`figcaption a[href="${watchOf(id, lang)}"]`), 'a watch page never links to itself').toHaveCount(0);
+  await expect(page.locator('link[rel="canonical"]')).toHaveAttribute('href', `${SITE}${watchOf(id, lang)}`);
+}
+
+async function expectWatchStructuredData(page, id, lang) {
+  const [described] = await videoObjects(page);
+  expect(described.name).toBe(VIDEOS[id].text[lang].label);
+  expect(described.embedUrl).toBe(`${SITE}${watchOf(id, lang)}embed/`);
+  expect(described.contentUrl).toBe(`${SITE}/assets/videos/${id}.mp4`);
+  expect(described.potentialAction['@type']).toBe('SeekToAction');
+  expect(described.potentialAction.target).toBe(`${SITE}${watchOf(id, lang)}?t={seek_to_second_number}`);
+  expect(described.potentialAction['startOffset-input']).toBe('required name=seek_to_second_number');
+  expect(Boolean(described.transcript), 'a narrated film carries its transcript').toBe((VIDEOS[id].captions ?? []).includes(lang));
+  const [webPage] = await page.locator('script[type="application/ld+json"]').evaluateAll((scripts) =>
+    scripts.flatMap((script) => JSON.parse(script.textContent)['@graph'] ?? []).filter((node) => node['@type'] === 'WebPage'));
+  expect(webPage.datePublished, 'the page is published when its video was').toBe(uploadedAt(id));
+}
+
+/** When video `id` was uploaded, as the ISO timestamp pages and the sitemap carry. */
+const uploadedAt = (id) => new Date(VIDEOS[id].uploadDate).toISOString();
+
+/** The narration as text: one paragraph per spoken cue, no sound cues. */
+async function expectTranscript(page, id, lang) {
+  const lines = page.locator('main section p');
+  if (!(VIDEOS[id].captions ?? []).includes(lang)) return expect(lines).toHaveCount(0);
+  expect(await lines.count(), `${id} transcript has its narration`).toBeGreaterThan(0);
+  expect((await lines.allTextContents()).some((line) => line.startsWith('[')), 'sound cues are not speech').toBe(false);
+  const [described] = await videoObjects(page);
+  expect(described.transcript).toBe((await lines.allTextContents()).join(' '));
+}
+
+for (const id of Object.keys(VIDEOS)) {
+  test(`${id} has a watch page in every language, described as its real file`, async ({ page, request }) => {
+    for (const lang of LANGS) {
+      await page.goto(watchOf(id, lang));
+      await expectWatchPage(page, id, lang);
+      await expectWatchStructuredData(page, id, lang);
+      await expectTranscript(page, id, lang);
+      const guide = page.locator('main p > a').last();
+      await expect(guide).toHaveAttribute('href', local(lang, VIDEOS[id].page));
+      expect((await request.get(local(lang, VIDEOS[id].page))).status(), 'the guide link resolves').toBe(200);
+    }
+    const real = await loadedMetadata(page.locator('main video'));
+    expect({ width: real.width, height: real.height }, 'the catalogue has the real frame size').toEqual({ width: VIDEOS[id].width, height: VIDEOS[id].height });
+    // The catalogue holds whole seconds; browsers differ by milliseconds on where a file ends.
+    expect(Math.abs(real.duration - secondsOf(VIDEOS[id].duration)), 'the catalogue has the real length').toBeLessThan(1);
+  });
+}
+
+test('docs figures link to their watch page, which opens at ?t= seconds', async ({ page }) => {
+  await page.goto('/docs/hover/');
+  const link = page.locator('figure figcaption a[href="/videos/hover/"]');
+  await expect(link).toHaveCount(1);
+  await link.click();
+  await expect(page).toHaveURL(/\/videos\/hover\/$/);
+  await page.goto('/videos/hover/?t=30');
+  const video = page.locator('main video');
+  await expect.poll(() => video.evaluate((v) => Math.floor(v.currentTime)), { timeout: 15000 }).toBe(30);
+  await expect(video).toHaveJSProperty('paused', true);
+  await page.goto('/ja/videos/hover/');
+  expect(await page.locator('main video').evaluate((v) => v.currentTime)).toBe(0);
+});
+
+for (const lang of LANGS) {
+  test(`every ${lang} embed page is the bare player, kept out of the index`, async ({ page, request }) => {
+    for (const id of Object.keys(VIDEOS)) {
+      await page.goto(embedOf(id, lang));
+      await expect(page.locator('meta[name="robots"]')).toHaveAttribute('content', 'noindex');
+      await expect(page.locator('header, nav, footer, h1')).toHaveCount(0);
+      const player = page.locator('body > video');
+      await expect(player).toHaveAttribute('aria-label', VIDEOS[id].text[lang].label);
+      await expect(player.locator('source').first()).toHaveAttribute('src', `/assets/videos/${id}.mp4`);
+      const box = await player.boundingBox();
+      expect(box.width, 'the player fills the frame').toBe(page.viewportSize().width);
+    }
+    await expectPlayable(request, [`${watchOf('hover', lang)}embed/`], 'text/html');
+  });
+}
+
+/** Each sitemap `<url>` as its location and its video entry's fields, parsed by the browser. */
+const sitemapEntries = (page, xml) =>
+  page.evaluate((text) => {
+    const doc = new DOMParser().parseFromString(text, 'application/xml');
+    const field = (node, name) => node.getElementsByTagName(`video:${name}`)[0]?.textContent ?? null;
+    return [...doc.getElementsByTagName('url')].map((url) => ({
+      loc: url.getElementsByTagName('loc')[0].textContent,
+      lastmod: url.getElementsByTagName('lastmod')[0]?.textContent ?? null,
+      videos: url.getElementsByTagName('video:video').length,
+      ...Object.fromEntries(['title', 'description', 'thumbnail_loc', 'content_loc', 'player_loc', 'duration', 'publication_date']
+        .map((name) => [name, field(url, name)])),
+    }));
+  }, xml);
+
+function expectVideoEntry(entry, id, lang) {
+  const { label, caption } = VIDEOS[id].text[lang];
+  expect(entry, `${id} (${lang}) has one video entry`).toMatchObject({ videos: 1, title: label, description: caption });
+  expect(entry.thumbnail_loc).toBe(`${SITE}/assets/videos/${id}-poster.webp`);
+  expect(entry.content_loc).toBe(`${SITE}/assets/videos/${id}.mp4`);
+  expect(entry.player_loc).toBe(`${SITE}${watchOf(id, lang)}embed/`);
+  expect(Number(entry.duration)).toBe(secondsOf(VIDEOS[id].duration));
+  expect(entry.publication_date).toBe(VIDEOS[id].uploadDate);
+  expect(entry.lastmod, 'a watch page changes when its video does, not with each build').toBe(uploadedAt(id));
+}
+
+test('the sitemap lists every docs page and every watch page with its video', async ({ page, request }) => {
+  const response = await request.get('/sitemap.xml');
+  expect(response.status()).toBe(200);
+  const byLoc = new Map((await sitemapEntries(page, await response.text())).map((entry) => [entry.loc, entry]));
+  for (const lang of LANGS) {
+    for (const slug of DOC_SLUGS) expect(byLoc.has(`${SITE}${local(lang, `/docs/${slug}`)}`), `docs/${slug} (${lang})`).toBe(true);
+    for (const id of Object.keys(VIDEOS)) expectVideoEntry(byLoc.get(`${SITE}${watchOf(id, lang)}`), id, lang);
+  }
+  expect([...byLoc.keys()].some((loc) => loc.endsWith('/embed/')), 'embed pages stay out').toBe(false);
+  const served = Object.keys(VIDEOS).flatMap((id) => [`/assets/videos/${id}-poster.webp`, `/assets/videos/${id}.mp4`]);
+  await expectPlayable(request, served.filter((url) => url.endsWith('.webp')), 'image/webp');
+  await expectPlayable(request, served.filter((url) => url.endsWith('.mp4')), 'video/mp4');
+});
+
+test('robots.txt lets every crawler fetch the media and points at the sitemap', async ({ request }) => {
+  const robots = await (await request.get('/robots.txt')).text();
+  const everyone = robots.split(/\n\s*\n/).find((group) => /^User-agent: \*$/m.test(group));
+  expect(everyone, 'a group for every crawler').toBeTruthy();
+  expect(everyone).toMatch(/^Allow: \/$/m);
+  expect(everyone, 'nothing under /assets/ is blocked').not.toMatch(/^Disallow: \/(assets)?\/?$/m);
+  expect(robots).toContain(`Sitemap: ${SITE}/sitemap.xml`);
+});
diff --git a/src/website/tools/profiler-film/kit/encode.mjs b/src/website/tools/profiler-film/kit/encode.mjs
index 0342e5fe..88ed5402 100644
--- a/src/website/tools/profiler-film/kit/encode.mjs
+++ b/src/website/tools/profiler-film/kit/encode.mjs
@@ -46,6 +46,17 @@ export function poster(video, at, name) {
   const frame = path.join(out, `${name}-poster.png`);
   ffmpeg(['-ss', String(at), '-i', video, '-frames:v', '1', frame], `${name} poster`);
   webp(frame, path.join(videos, `${name}-poster.webp`), 1920);
+  card(frame, name);
+}
+
+/**
+ * `<name>-card.jpg`: the poster frame filled and centre-cropped to 1200x630, the
+ * social preview size. JPEG, because not every network reads WebP.
+ * [WEB-DESIGN-MEDIA-DISCOVERY]
+ */
+export function card(frame, name) {
+  const fill = 'scale=1200:630:force_original_aspect_ratio=increase,crop=1200:630';
+  ffmpeg(['-i', frame, '-vf', fill, '-q:v', '3', path.join(videos, `${name}-card.jpg`)], `${name} card`);
 }
 
 /** Every PNG still under `dir`, as the site's 2400px WebP of the same name in `screenshots/<folder>`. */
diff --git a/src/website/video-figure.js b/src/website/video-figure.js
index b66af890..acdaa601 100644
--- a/src/website/video-figure.js
+++ b/src/website/video-figure.js
@@ -2,11 +2,11 @@
 // as a figure plus its schema.org VideoObject, so every page that shows a video
 // is also eligible for video results in search.
 //
-// The catalogue lists every video on the site once: its encodings, size, length
-// and the words that describe it in each language. A page names a video with
-// `{% video "<id>" %}` and never repeats its markup; files live at
-// /assets/videos/<id>.<encoding> beside /assets/videos/<id>-poster.webp, and a
-// narrated video's captions at /assets/videos/<id>.<lang>.vtt.
+// The catalogue lists every video on the site once: its encodings, size, length,
+// the page that explains it, and the words that describe it in each language. A
+// page names a video with `{% video "<id>" %}` and never repeats its markup; files
+// live at /assets/videos/<id>.<encoding> beside /assets/videos/<id>-poster.webp
+// and <id>-card.jpg, and a narrated video's captions at /assets/videos/<id>.<lang>.vtt.
 // The profiler media is shot and published by tools/profiler-film (film.mjs and
 // films/profiler/render.mjs). The tour is
 // the Marketplace GIF (assets/images/marketplace/sharplsp-tour.gif) re-encoded
@@ -14,14 +14,13 @@
 // MP4 comes first in the catalogue: Windows Chrome/Edge can accept the VP9
 // source then fail decoding it, without falling back to the next source.
 import markdownIt from "markdown-it";
+import i18n from "./src/_data/i18n.json" with { type: "json" };
 import languages from "./src/_data/languages.json" with { type: "json" };
 import site from "./src/_data/site.json" with { type: "json" };
-import videos from "./src/_data/videos.json" with { type: "json" };
+import { asset, catalogued, embedPath, textOf, transcript, watchPath } from "./video-pages.js";
 
 const { escapeHtml } = markdownIt().utils;
 
-const asset = (id, suffix) => `/assets/videos/${id}${suffix}`;
-
 /**
  * A narrated video's captions, one track per language its `captions` lists,
  * at /assets/videos/<id>.<lang>.vtt; the page's own language shows by default.
@@ -32,28 +31,59 @@ const tracks = (id, video, lang) =>
   );
 
 /**
- * Docs and articles get a still film with controls, its narration audible. A
- * marketing page may pass `autoplay` for a muted loop; custom.js stills it
- * under reduced motion.
+ * The `<video>` element alone: a figure's player, and the whole of a video's
+ * embed page. Docs and articles get a still film with controls, its narration
+ * audible. A marketing page may pass `autoplay` for a muted loop; custom.js
+ * stills it under reduced motion.
  */
-export function videoFigure(id, lang, { caption, autoplay = false } = {}) {
-  const video = videos[id];
-  if (!video) throw new Error(`No video "${id}" in src/_data/videos.json`);
-  const text = video.text[lang] ?? video.text.en;
+export function videoPlayer(id, lang, { autoplay = false } = {}) {
+  const video = catalogued(id);
   return [
-    `<figure class="${autoplay ? "product-shot" : "article-figure"}">`,
-    `<video ${autoplay ? "autoplay loop muted" : "controls"} playsinline preload="metadata" poster="${asset(id, "-poster.webp")}" width="${video.width}" height="${video.height}" aria-label="${escapeHtml(text.label)}">`,
+    `<video ${autoplay ? "autoplay loop muted" : "controls"} playsinline preload="metadata" poster="${asset(id, "-poster.webp")}" width="${video.width}" height="${video.height}" aria-label="${escapeHtml(textOf(video, lang).label)}">`,
     ...video.encodings.map((encoding) => `<source src="${asset(id, `.${encoding}`)}" type="video/${encoding}">`),
     ...tracks(id, video, lang),
     "</video>",
-    `<figcaption>${caption ?? escapeHtml(text.caption)}</figcaption>`,
+  ].join("\n");
+}
+
+/**
+ * A docs or article figure links to the video's own watch page
+ * ([WEB-DESIGN-MEDIA-DISCOVERY]); the watch page itself, and a marketing loop, do not.
+ */
+const watchLink = (id, lang, linked) =>
+  linked ? ` <a href="${watchPath(id, lang)}">${escapeHtml(i18n[lang].video.watchPage)}</a>` : "";
+
+export function videoFigure(id, lang, { caption, autoplay = false, watch = false } = {}) {
+  const video = catalogued(id);
+  const text = textOf(video, lang);
+  return [
+    `<figure class="${autoplay ? "product-shot" : "article-figure"}">`,
+    videoPlayer(id, lang, { autoplay }),
+    `<figcaption>${caption ?? escapeHtml(text.caption)}${watchLink(id, lang, !autoplay && !watch)}</figcaption>`,
     "</figure>",
-    `<script type="application/ld+json">${structuredData(id, video, text)}</script>`,
+    `<script type="application/ld+json">${structuredData(id, video, lang, watch)}</script>`,
   ].join("\n");
 }
 
+/**
+ * What only a watch page claims: Google's key moments, seeking through `?t=`
+ * (custom.js), and the narration as text.
+ */
+function watchOnly(id, lang) {
+  const spoken = transcript(id, lang);
+  return {
+    potentialAction: {
+      "@type": "SeekToAction",
+      target: `${site.url}${watchPath(id, lang)}?t={seek_to_second_number}`,
+      "startOffset-input": "required name=seek_to_second_number",
+    },
+    ...(spoken.length > 0 ? { transcript: spoken.join(" ") } : {}),
+  };
+}
+
 // `<` is escaped so no description can close the script element early.
-function structuredData(id, video, text) {
+function structuredData(id, video, lang, watch) {
+  const text = textOf(video, lang);
   return JSON.stringify({
     "@context": "https://schema.org",
     "@type": "VideoObject",
@@ -61,9 +91,11 @@ function structuredData(id, video, text) {
     description: text.caption,
     thumbnailUrl: `${site.url}${asset(id, "-poster.webp")}`,
     contentUrl: `${site.url}${asset(id, `.${video.encodings[0]}`)}`,
+    embedUrl: `${site.url}${embedPath(id, lang)}`,
     uploadDate: video.uploadDate,
     duration: video.duration,
     width: video.width,
     height: video.height,
+    ...(watch ? watchOnly(id, lang) : {}),
   }).replaceAll("<", "\\u003c");
 }
diff --git a/src/website/video-pages.js b/src/website/video-pages.js
new file mode 100644
index 00000000..d77f7409
--- /dev/null
+++ b/src/website/video-pages.js
@@ -0,0 +1,80 @@
+// Implements [WEB-DESIGN-MEDIA-DISCOVERY]. Where each catalogued video
+// (src/_data/videos.json) lives beyond the page that shows it: a watch page per
+// video and language at /videos/<id>/, the bare player at /videos/<id>/embed/
+// that X cards and Google's embedUrl load, its social card at
+// /assets/videos/<id>-card.jpg, and the transcript read from its captions.
+import { readFileSync } from "fs";
+import languages from "./src/_data/languages.json" with { type: "json" };
+import videos from "./src/_data/videos.json" with { type: "json" };
+
+export const asset = (id, suffix) => `/assets/videos/${id}${suffix}`;
+
+/** `path` in `lang`: English at the root, every other language under /<lang>. */
+export const localized = (lang, path) => (lang === "en" ? path : `/${lang}${path}`);
+
+export const watchPath = (id, lang) => localized(lang, `/videos/${id}/`);
+export const embedPath = (id, lang) => `${watchPath(id, lang)}embed/`;
+
+/** A catalogued video, or a build error naming the missing id. */
+export function catalogued(id) {
+  const video = videos[id];
+  if (!video) throw new Error(`No video "${id}" in src/_data/videos.json`);
+  return video;
+}
+
+/** The label and caption of `video` in `lang`, English when it has no translation. */
+export const textOf = (video, lang) => video.text[lang] ?? video.text.en;
+
+/** An ISO 8601 duration such as `PT1M4S`, in whole seconds. */
+export function seconds(duration) {
+  const [, minutes = "0", rest] = duration.match(/^PT(?:(\d+)M)?(\d+)S$/);
+  return Number(minutes) * 60 + Number(rest);
+}
+
+/** Everything a page needs to show, share and describe video `id` in `lang`. */
+export function videoMeta(id, lang) {
+  const video = catalogued(id);
+  const { label, caption } = textOf(video, lang);
+  return {
+    id, lang, label, caption,
+    width: video.width, height: video.height, uploadDate: video.uploadDate, seconds: seconds(video.duration),
+    poster: asset(id, "-poster.webp"), card: asset(id, "-card.jpg"), stream: asset(id, ".mp4"),
+    watch: watchPath(id, lang), embed: embedPath(id, lang), page: localized(lang, video.page),
+  };
+}
+
+/** One cue's spoken words; a sound cue such as `[Gentle music]` says nothing. */
+const cueText = (cue) =>
+  cue.split(/\r?\n/).filter((line) => !line.includes("-->") && !/^\[.*\]$/.test(line.trim())).join(" ").trim();
+
+/** The narration of `id` in `lang`, one entry per caption cue; empty when it has no captions there. */
+export function transcript(id, lang) {
+  if (!(catalogued(id).captions ?? []).includes(lang)) return [];
+  const vtt = readFileSync(new URL(`./src${asset(id, `.${lang}.vtt`)}`, import.meta.url), "utf8");
+  return vtt.split(/\r?\n\r?\n/).slice(1).map(cueText).filter(Boolean);
+}
+
+/** Every watch page: each catalogued video in each site language. */
+export const watchPages = () =>
+  Object.keys(languages).flatMap((lang) =>
+    Object.keys(videos).map((id) => ({ ...videoMeta(id, lang), transcript: transcript(id, lang) })),
+  );
+
+/**
+ * The film a page shares as its social preview: a watch page its own video, a
+ * docs page the first catalogued video whose `page` it is. The docs entries are
+ * reversed so that, as the Map keeps the last value per key, the first one wins.
+ */
+function previewEntries(lang) {
+  const docs = Object.entries(videos)
+    .filter(([, video]) => video.page.startsWith("/docs/"))
+    .map(([id, video]) => [localized(lang, video.page), id])
+    .reverse();
+  const watches = Object.keys(videos).map((id) => [watchPath(id, lang), id]);
+  return [...docs, ...watches].map(([url, id]) => [url, videoMeta(id, lang)]);
+}
+
+const previews = new Map(Object.keys(languages).flatMap(previewEntries));
+
+/** The social-preview film for the page at `url`, if it has one. */
+export const socialVideo = (url) => previews.get(url);