From d499e761d359f2753a51d012a4c592bfacc041b6 Mon Sep 17 00:00:00 2001
From: Joe DeCock <josephdecock@gmail.com>
Date: Wed, 23 Sep 2026 09:53:55 -0500
Subject: [PATCH 1/4] Fix RazorSlices TextWriter rendering of UTF-8 literals
 and ISpanFormattable values

WriteUtf8(TextWriter, ReadOnlySpan<byte>) decoded UTF-8 bytes with
Encoding.Unicode (UTF-16LE), so every static literal emitted via
WriteLiteral(ReadOnlySpan<byte>) rendered as garbage when a slice was
rendered to a TextWriter. Reachable since the .NET SDK 10.0.400 Razor
compiler emits "..."u8 literals for that overload (dotnet/razor#12848).

Also ports DamianEdwards/RazorSlices#136: HtmlEncodeAndWriteSpanFormattable
wrote the whole rented encode buffer instead of the filled portion (leaking
pooled memory into output), and the small fast path returned true without
writing anything.

Ports DamianEdwards/RazorSlices#127 and #136.
Relates to DuendeSoftware/products-private#3682.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../RazorSlices/TextWriterHtmlExtensions.cs   |  15 ++-
 .../TextWriterHtmlWritingTests.cs             | 125 ++++++++++++++++++
 2 files changed, 133 insertions(+), 7 deletions(-)
 create mode 100644 razor-slices/test/RazorSlices.Tests/TextWriterHtmlWritingTests.cs

diff --git a/razor-slices/src/RazorSlices/TextWriterHtmlExtensions.cs b/razor-slices/src/RazorSlices/TextWriterHtmlExtensions.cs
index ecfe9f37..cedefcb4 100644
--- a/razor-slices/src/RazorSlices/TextWriterHtmlExtensions.cs
+++ b/razor-slices/src/RazorSlices/TextWriterHtmlExtensions.cs
@@ -67,7 +67,7 @@ public static void HtmlEncodeAndWriteSpanFormattable<T>(this TextWriter textWrit
 
         if (waitingToWrite > 0)
         {
-            textWriter.Write(encodeBufferSpan);
+            textWriter.Write(encodeBuffer.AsSpan()[..waitingToWrite]);
         }
 
         ArrayPool<char>.Shared.Return(encodeBuffer);
@@ -85,8 +85,9 @@ private static bool TryHtmlEncodeAndWriteSpanFormattableSmall<T>(TextWriter text
             if ((charsWritten * BufferSizes.HtmlEncodeAllowanceRatio) < BufferSizes.SmallFormattableWriteCharSize)
             {
                 Span<char> encodedBuffer = stackalloc char[BufferSizes.SmallFormattableWriteCharSize];
-                if (htmlEncoder.Encode(formatBuffer, encodedBuffer, out var charsConsumed, out var charsEncoded) == OperationStatus.Done)
+                if (htmlEncoder.Encode(formatBuffer[..charsWritten], encodedBuffer, out var charsConsumed, out var charsEncoded) == OperationStatus.Done)
                 {
+                    textWriter.Write(encodedBuffer[..charsEncoded]);
                     return true;
                 }
             }
@@ -147,9 +148,9 @@ public static void HtmlEncodeAndWriteUtf8(this TextWriter textWriter, ReadOnlySp
     {
         var charCount = Encoding.UTF8.GetCharCount(value);
         var buffer = ArrayPool<char>.Shared.Rent(charCount);
-        var bytesDecoded = Encoding.UTF8.GetChars(value, buffer);
+        var charsWritten = Encoding.UTF8.GetChars(value, buffer);
 
-        Debug.Assert(bytesDecoded == value.Length, "Bad decoding when writing to TextWriter in HtmlEncodeAndWriteUtf8(ReadOnlySpan<byte>)");
+        Debug.Assert(charsWritten == charCount, "Bad decoding when writing to TextWriter in HtmlEncodeAndWriteUtf8(ReadOnlySpan<byte>)");
 
         htmlEncoder.Encode(textWriter, buffer, 0, charCount);
         ArrayPool<char>.Shared.Return(buffer);
@@ -157,11 +158,11 @@ public static void HtmlEncodeAndWriteUtf8(this TextWriter textWriter, ReadOnlySp
 
     public static void WriteUtf8(this TextWriter textWriter, ReadOnlySpan<byte> value)
     {
-        var charCount = Encoding.Unicode.GetCharCount(value);
+        var charCount = Encoding.UTF8.GetCharCount(value);
         var buffer = ArrayPool<char>.Shared.Rent(charCount);
-        var bytesDecoded = Encoding.Unicode.GetChars(value, buffer);
+        var charsWritten = Encoding.UTF8.GetChars(value, buffer);
 
-        Debug.Assert(bytesDecoded == value.Length, "Bad decoding when writing to TextWriter in WriteUtf8(ReadOnlySpan<byte>)");
+        Debug.Assert(charsWritten == charCount, "Bad decoding when writing to TextWriter in WriteUtf8(ReadOnlySpan<byte>)");
 
         textWriter.Write(buffer, 0, charCount);
         ArrayPool<char>.Shared.Return(buffer);
diff --git a/razor-slices/test/RazorSlices.Tests/TextWriterHtmlWritingTests.cs b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlWritingTests.cs
new file mode 100644
index 00000000..7c20fb95
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlWritingTests.cs
@@ -0,0 +1,125 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.Text.Encodings.Web;
+
+namespace Duende.RazorSlices.Tests;
+
+public class TextWriterHtmlWritingTests
+{
+    [Fact]
+    public async Task RenderAsync_TextWriter_WritesUtf8LiteralsAsText()
+    {
+        // The Razor compiler in .NET SDK 10.0.400+ emits WriteLiteral(ReadOnlySpan<byte>) with "..."u8 literals,
+        // so static markup takes this path regardless of which SDK compiled the template.
+        var slice = new Utf8LiteralSlice();
+        using var writer = new StringWriter();
+
+        await slice.RenderAsync(writer);
+
+        writer.ToString().ShouldBe("<p>hello</p><p>héllo wörld ✓</p>");
+    }
+
+    [Fact]
+    public async Task RenderAsync_PipeWriter_WritesUtf8LiteralsAsText()
+    {
+        var slice = new Utf8LiteralSlice();
+        using var stream = new MemoryStream();
+        var pipeWriter = System.IO.Pipelines.PipeWriter.Create(stream);
+
+        await slice.RenderAsync(pipeWriter);
+        await pipeWriter.FlushAsync();
+
+        System.Text.Encoding.UTF8.GetString(stream.ToArray()).ShouldBe("<p>hello</p><p>héllo wörld ✓</p>");
+    }
+
+    [Fact]
+    public void WriteUtf8_DecodesAsUtf8()
+    {
+        using var writer = new StringWriter();
+
+        writer.WriteUtf8("<p>héllo wörld ✓</p>"u8);
+
+        writer.ToString().ShouldBe("<p>héllo wörld ✓</p>");
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteUtf8_DecodesAsUtf8AndEncodesHtml()
+    {
+        using var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteUtf8("<p>héllo</p>"u8, HtmlEncoder.Default);
+
+        writer.ToString().ShouldBe("&lt;p&gt;h&#xE9;llo&lt;/p&gt;");
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_WritesOnlyTheFormattedChars()
+    {
+        using var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteSpanFormattable(SampleStatus.Open, HtmlEncoder.Default);
+
+        writer.ToString().ShouldBe("Open");
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_DoesNotLeakPreviousRenterContent()
+    {
+        // Dirty the shared pool with a long value first, then write a short one. Without slicing to the
+        // encoded length the short write carries the tail of the long one into the output.
+        using var warmup = new StringWriter();
+        warmup.HtmlEncodeAndWriteSpanFormattable(1234567890123456789L, HtmlEncoder.Default);
+
+        using var writer = new StringWriter();
+        writer.HtmlEncodeAndWriteSpanFormattable(SampleStatus.Posted, HtmlEncoder.Default);
+
+        writer.ToString().ShouldBe("Posted");
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_EncodesHtmlOnSmallPath()
+    {
+        using var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteSpanFormattable(new HtmlishFormattable(), HtmlEncoder.Default);
+
+        writer.ToString().ShouldBe("a&lt;b&gt;c");
+    }
+
+    private sealed class Utf8LiteralSlice : RazorSlice
+    {
+        public override Task ExecuteAsync()
+        {
+            WriteLiteral("<p>hello</p>"u8);
+            WriteLiteral("<p>héllo wörld ✓</p>"u8);
+            return Task.CompletedTask;
+        }
+    }
+
+    private enum SampleStatus
+    {
+        Open = 0,
+        Posted = 1
+    }
+
+    private readonly struct HtmlishFormattable : ISpanFormattable
+    {
+        private const string Value = "a<b>c";
+
+        public string ToString(string? format, IFormatProvider? formatProvider) => Value;
+
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            if (destination.Length < Value.Length)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            Value.AsSpan().CopyTo(destination);
+            charsWritten = Value.Length;
+            return true;
+        }
+    }
+}

From 4ac2121605d63b778d0ab29140522ef02a37c7e5 Mon Sep 17 00:00:00 2001
From: Joe DeCock <josephdecock@gmail.com>
Date: Wed, 23 Sep 2026 10:17:30 -0500
Subject: [PATCH 2/4] Sync RazorSlices to upstream c286ca0

Re-syncs the vendored Duende.RazorSlices component (library, source
generator, tests, samples) from upstream 640458f to c286ca0
(DamianEdwards/RazorSlices main as of 2026-09-19). Brings in #108, #111,
#113, #115, #117, #122, #127, #128, #130, #131, #134, #136, #139, #141,
#146.

Duende-specific transformations re-applied: Duende.RazorSlices namespace
(including the source generator's ModelTypeResolver namespace check),
license headers, LF line endings, dotnet format, and explicit
'using Duende.RazorSlices;' in samples. Build props/targets updated for
RazorSliceProxiesAsRecords (#117). README records the upstream sync point.

Adds RazorSliceUtf8LiteralTests as a slice-level regression test for the
TextWriter UTF-8 literal bug (DuendeSoftware/products-private#3682).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 razor-slices/README.md                        |   7 +
 .../PagesAndSlices/Pages/Index.cshtml.cs      |   3 +
 .../PagesAndSlices/Pages/_ViewImports.cshtml  |   2 +-
 .../PagesAndSlices/PagesAndSlices.csproj      |   4 +
 .../samples/PagesAndSlices/Program.cs         |   3 +
 .../PagesAndSlices/Slices/_Layout.cshtml      |   2 +-
 .../PagesAndSlices/Slices/_ViewImports.cshtml |   2 +-
 .../samples/RazorClassLibrary/MarkerClass.cs  |   3 +
 .../Slices/FromLibrary.cshtml                 |   2 +-
 .../Slices/FromLibrary.cshtml.cs              |   3 +
 .../RazorClassLibrary/_ViewImports.cshtml     |   2 +-
 .../WebApp/Alternate/Lorem/LoremExtra.cs      |   9 +
 razor-slices/samples/WebApp/AppJsonContext.cs |   3 +
 .../samples/WebApp/HtmlContentParams.cs       |   3 +
 razor-slices/samples/WebApp/LoremParams.cs    |   3 +
 razor-slices/samples/WebApp/MapSlices.cs      |  13 +-
 razor-slices/samples/WebApp/Models/Todo.cs    |  10 +-
 .../samples/WebApp/Program.Testing.cs         |   3 +
 razor-slices/samples/WebApp/Program.cs        |   6 +-
 ...ringEndpointConventionBuilderExtensions.cs |  14 +
 .../WebApp/ResponseBufferingMetadata.cs       |  13 +
 .../WebApp/ResponseBufferingMiddleware.cs     |  12 +-
 razor-slices/samples/WebApp/ResultDtos.cs     |   3 +
 .../samples/WebApp/Services/LoremService.cs   |   3 +
 .../WebApp/Slices/AttributeRendering.cshtml   |  17 +
 .../samples/WebApp/Slices/Encoding.cshtml     |   2 +-
 .../samples/WebApp/Slices/LayoutModel.cs      |   3 +
 .../Slices/Lorem/LoremHtmlContent.cshtml      |   3 +
 .../Lorem/LoremInjectableProperties.cshtml    |   3 +-
 .../WebApp/Slices/Lorem/PageContent.cs        |   3 +
 .../WebApp/Slices/Lorem/_LoremMenu.cshtml     |   2 +-
 .../WebApp/Slices/Lorem/_ViewImports.cshtml   |   2 +
 .../samples/WebApp/Slices/Nested.cshtml       |   5 +
 .../samples/WebApp/Slices/SliceBaseClasses.cs |  13 +
 .../samples/WebApp/Slices/Streaming.cshtml    |  32 ++
 .../samples/WebApp/Slices/Todo.cshtml         |   2 +-
 .../samples/WebApp/Slices/Todos.cshtml        |   2 +-
 .../samples/WebApp/Slices/UnicodeData.cs      |   3 +
 .../samples/WebApp/Slices/_FooterLinks.cshtml |   2 +
 .../samples/WebApp/Slices/_ViewImports.cshtml |   2 +-
 .../src/RazorSlices/IResultExtensions.cs      |   2 +-
 .../RazorSlices/RazorSlice.Formattables.cs    |   3 +
 .../RazorSlices/RazorSlice.Formattables.tt    |   5 +-
 .../RazorSlices/RazorSlice.HtmlAttributes.cs  |  35 +-
 .../src/RazorSlices/RazorSlice.IResult.cs     |   4 +-
 .../src/RazorSlices/RazorSlice.Write.cs       |  20 +-
 razor-slices/src/RazorSlices/RazorSlice.cs    |  31 +-
 .../src/RazorSlices/RazorSliceFactory.cs      | 240 ++++------
 .../src/RazorSlices/ReusableStringWriter.cs   |   3 +
 .../src/RazorSlices/SliceDefinition.cs        | 125 -----
 .../src/RazorSlices/TaskExtensions.cs         |   1 +
 .../build/Duende.RazorSlices.props            |   2 +-
 .../build/Duende.RazorSlices.targets          |   1 +
 .../src/SourceGenerator/ModelTypeResolver.cs  | 276 ++++++++++-
 razor-slices/src/SourceGenerator/PathUtils.cs |   4 +
 .../SourceGenerator/RazorDirectiveParser.cs   |  21 +
 .../RazorSliceProxyGenerator.cs               |  92 ++--
 .../SourceGenerator/ViewImportsResolver.cs    |  30 +-
 .../RazorSliceFactoryTests.cs                 | 254 ++++++++++
 .../RazorSliceHtmlAttributesTests.cs          |  39 ++
 .../RazorSliceIResultTests.cs                 |  51 ++
 .../RazorSliceUtf8LiteralTests.cs             |  48 ++
 .../RazorSliceWriteHtmlTests.cs               |  62 +++
 .../RazorSlices.Tests/RazorSliceWriteTests.cs |  31 ++
 .../TextWriterHtmlExtensionsTests.cs          | 213 +++++++++
 .../TextWriterHtmlWritingTests.cs             | 125 -----
 .../ModelTypeResolverTests.cs                 | 442 ++++++++++++++++++
 .../RazorDirectiveParserTests.cs              |  22 +
 .../RazorSliceProxyGeneratorTests.cs          | 144 ++++++
 69 files changed, 2071 insertions(+), 479 deletions(-)
 create mode 100644 razor-slices/samples/WebApp/Alternate/Lorem/LoremExtra.cs
 create mode 100644 razor-slices/samples/WebApp/ResponseBufferingEndpointConventionBuilderExtensions.cs
 create mode 100644 razor-slices/samples/WebApp/ResponseBufferingMetadata.cs
 create mode 100644 razor-slices/samples/WebApp/Slices/AttributeRendering.cshtml
 create mode 100644 razor-slices/samples/WebApp/Slices/Nested.cshtml
 create mode 100644 razor-slices/samples/WebApp/Slices/SliceBaseClasses.cs
 create mode 100644 razor-slices/samples/WebApp/Slices/Streaming.cshtml
 delete mode 100644 razor-slices/src/RazorSlices/SliceDefinition.cs
 create mode 100644 razor-slices/test/RazorSlices.Tests/RazorSliceFactoryTests.cs
 create mode 100644 razor-slices/test/RazorSlices.Tests/RazorSliceHtmlAttributesTests.cs
 create mode 100644 razor-slices/test/RazorSlices.Tests/RazorSliceIResultTests.cs
 create mode 100644 razor-slices/test/RazorSlices.Tests/RazorSliceUtf8LiteralTests.cs
 create mode 100644 razor-slices/test/RazorSlices.Tests/RazorSliceWriteHtmlTests.cs
 create mode 100644 razor-slices/test/RazorSlices.Tests/RazorSliceWriteTests.cs
 create mode 100644 razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsTests.cs
 delete mode 100644 razor-slices/test/RazorSlices.Tests/TextWriterHtmlWritingTests.cs
 create mode 100644 razor-slices/test/SourceGenerator.Tests/ModelTypeResolverTests.cs
 create mode 100644 razor-slices/test/SourceGenerator.Tests/RazorSliceProxyGeneratorTests.cs

diff --git a/razor-slices/README.md b/razor-slices/README.md
index 894b1084..dfeefc78 100644
--- a/razor-slices/README.md
+++ b/razor-slices/README.md
@@ -4,9 +4,16 @@ This is a vendored fork of [DamianEdwards/RazorSlices](https://github.com/Damian
 
 The upstream project is copyright Damian Edwards and licensed under the [Apache 2.0 license](../LICENSE). See [ThirdPartyNotices.txt](ThirdPartyNotices.txt) for the full attribution.
 
+## Upstream sync point
+
+Last synced to upstream commit [`c286ca0`](https://github.com/DamianEdwards/RazorSlices/commit/c286ca021b05345e74785364c4a14515b082c90b) (2026-09-19, `main` after DamianEdwards/RazorSlices#146). When re-syncing, copy upstream `src/`, `tests/`, and `samples/` source files, then apply the transformations listed below.
+
 ## Differences from upstream
 
 - Package ID, assembly name, and root namespace changed from `RazorSlices` to `Duende.RazorSlices`
 - Source generator package renamed from `RazorSlices.SourceGenerator` to `Duende.RazorSlices.SourceGenerator`
+- The source generator's model-type resolver matches the `Duende.RazorSlices` namespace when walking slice base types
+- Samples keep the upstream `RazorSlices.Samples.*` namespace and add explicit `using Duende.RazorSlices;` directives where needed
+- Duende license headers, LF line endings, and `dotnet format` applied
 - Target framework updated to `net10.0`
 - Strong-naming disabled (not required for vendored use)
diff --git a/razor-slices/samples/PagesAndSlices/Pages/Index.cshtml.cs b/razor-slices/samples/PagesAndSlices/Pages/Index.cshtml.cs
index 14ecc8da..e6291087 100644
--- a/razor-slices/samples/PagesAndSlices/Pages/Index.cshtml.cs
+++ b/razor-slices/samples/PagesAndSlices/Pages/Index.cshtml.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.RazorPages;
 
diff --git a/razor-slices/samples/PagesAndSlices/Pages/_ViewImports.cshtml b/razor-slices/samples/PagesAndSlices/Pages/_ViewImports.cshtml
index 1ec7a2f7..1c8a7552 100644
--- a/razor-slices/samples/PagesAndSlices/Pages/_ViewImports.cshtml
+++ b/razor-slices/samples/PagesAndSlices/Pages/_ViewImports.cshtml
@@ -1 +1 @@
-@using RazorSlices.Samples.PagesAndSlices.Pages
\ No newline at end of file
+@using RazorSlices.Samples.PagesAndSlices.Pages
diff --git a/razor-slices/samples/PagesAndSlices/PagesAndSlices.csproj b/razor-slices/samples/PagesAndSlices/PagesAndSlices.csproj
index 5167849f..733c4a35 100644
--- a/razor-slices/samples/PagesAndSlices/PagesAndSlices.csproj
+++ b/razor-slices/samples/PagesAndSlices/PagesAndSlices.csproj
@@ -11,6 +11,10 @@
     <EnableDefaultRazorSlices>false</EnableDefaultRazorSlices>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <RazorSliceProxiesAsRecords>true</RazorSliceProxiesAsRecords>
+  </PropertyGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\src\RazorSlices\RazorSlices.csproj" />
     <ProjectReference Include="..\..\src\SourceGenerator\SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
diff --git a/razor-slices/samples/PagesAndSlices/Program.cs b/razor-slices/samples/PagesAndSlices/Program.cs
index 90a0d4d2..5faeb19f 100644
--- a/razor-slices/samples/PagesAndSlices/Program.cs
+++ b/razor-slices/samples/PagesAndSlices/Program.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using RazorSlices.Samples.PagesAndSlices.Slices;
 
 var builder = WebApplication.CreateBuilder(args);
diff --git a/razor-slices/samples/PagesAndSlices/Slices/_Layout.cshtml b/razor-slices/samples/PagesAndSlices/Slices/_Layout.cshtml
index cf0dc2e4..bcd4cbc6 100644
--- a/razor-slices/samples/PagesAndSlices/Slices/_Layout.cshtml
+++ b/razor-slices/samples/PagesAndSlices/Slices/_Layout.cshtml
@@ -15,4 +15,4 @@
         </div>
     </main>
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/razor-slices/samples/PagesAndSlices/Slices/_ViewImports.cshtml b/razor-slices/samples/PagesAndSlices/Slices/_ViewImports.cshtml
index 01d1aa0b..8b56fc32 100644
--- a/razor-slices/samples/PagesAndSlices/Slices/_ViewImports.cshtml
+++ b/razor-slices/samples/PagesAndSlices/Slices/_ViewImports.cshtml
@@ -8,4 +8,4 @@
 @using RazorSlices.Samples.PagesAndSlices.Slices
 
 @tagHelperPrefix __disable_tagHelpers__:
-@removeTagHelper *, Microsoft.AspNetCore.Mvc.Razor
\ No newline at end of file
+@removeTagHelper *, Microsoft.AspNetCore.Mvc.Razor
diff --git a/razor-slices/samples/RazorClassLibrary/MarkerClass.cs b/razor-slices/samples/RazorClassLibrary/MarkerClass.cs
index 2fec60e4..9a1fc339 100644
--- a/razor-slices/samples/RazorClassLibrary/MarkerClass.cs
+++ b/razor-slices/samples/RazorClassLibrary/MarkerClass.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 namespace RazorSlices.Samples.RazorClassLibrary;
 
 internal class MarkerClass
diff --git a/razor-slices/samples/RazorClassLibrary/Slices/FromLibrary.cshtml b/razor-slices/samples/RazorClassLibrary/Slices/FromLibrary.cshtml
index 1c677377..88811f4a 100644
--- a/razor-slices/samples/RazorClassLibrary/Slices/FromLibrary.cshtml
+++ b/razor-slices/samples/RazorClassLibrary/Slices/FromLibrary.cshtml
@@ -33,4 +33,4 @@
         </div>
     </footer>
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/razor-slices/samples/RazorClassLibrary/Slices/FromLibrary.cshtml.cs b/razor-slices/samples/RazorClassLibrary/Slices/FromLibrary.cshtml.cs
index c8f80bde..626c24e0 100644
--- a/razor-slices/samples/RazorClassLibrary/Slices/FromLibrary.cshtml.cs
+++ b/razor-slices/samples/RazorClassLibrary/Slices/FromLibrary.cshtml.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using Duende.RazorSlices;
 
 namespace RazorSlices.Samples.RazorClassLibrary.Slices;
diff --git a/razor-slices/samples/RazorClassLibrary/_ViewImports.cshtml b/razor-slices/samples/RazorClassLibrary/_ViewImports.cshtml
index 0d061ec1..fa903157 100644
--- a/razor-slices/samples/RazorClassLibrary/_ViewImports.cshtml
+++ b/razor-slices/samples/RazorClassLibrary/_ViewImports.cshtml
@@ -8,4 +8,4 @@
 @using RazorSlices.Samples.RazorClassLibrary;
 
 @tagHelperPrefix __disable_tagHelpers__:
-@removeTagHelper *, Microsoft.AspNetCore.Mvc.Razor
\ No newline at end of file
+@removeTagHelper *, Microsoft.AspNetCore.Mvc.Razor
diff --git a/razor-slices/samples/WebApp/Alternate/Lorem/LoremExtra.cs b/razor-slices/samples/WebApp/Alternate/Lorem/LoremExtra.cs
new file mode 100644
index 00000000..11a88bb1
--- /dev/null
+++ b/razor-slices/samples/WebApp/Alternate/Lorem/LoremExtra.cs
@@ -0,0 +1,9 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace RazorSlices.Samples.WebApp.Alternate.Lorem;
+
+public static class LoremExtra
+{
+    public const string AdditionalContent = "<div>Additional content</div>";
+}
diff --git a/razor-slices/samples/WebApp/AppJsonContext.cs b/razor-slices/samples/WebApp/AppJsonContext.cs
index 79d85b69..9532d003 100644
--- a/razor-slices/samples/WebApp/AppJsonContext.cs
+++ b/razor-slices/samples/WebApp/AppJsonContext.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using System.Text.Json.Serialization;
 
 namespace RazorSlices.Samples.WebApp;
diff --git a/razor-slices/samples/WebApp/HtmlContentParams.cs b/razor-slices/samples/WebApp/HtmlContentParams.cs
index dafe872b..65c6a7dc 100644
--- a/razor-slices/samples/WebApp/HtmlContentParams.cs
+++ b/razor-slices/samples/WebApp/HtmlContentParams.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 namespace RazorSlices.Samples.WebApp;
 
 public struct HtmlContentParams
diff --git a/razor-slices/samples/WebApp/LoremParams.cs b/razor-slices/samples/WebApp/LoremParams.cs
index 9c3936c8..5e9f93d8 100644
--- a/razor-slices/samples/WebApp/LoremParams.cs
+++ b/razor-slices/samples/WebApp/LoremParams.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 namespace RazorSlices.Samples.WebApp;
 public struct LoremParams
 {
diff --git a/razor-slices/samples/WebApp/MapSlices.cs b/razor-slices/samples/WebApp/MapSlices.cs
index efcc82a3..e0440cf7 100644
--- a/razor-slices/samples/WebApp/MapSlices.cs
+++ b/razor-slices/samples/WebApp/MapSlices.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using Duende.RazorSlices;
 using LibrarySlices = RazorSlices.Samples.RazorClassLibrary.Slices;
 using Microsoft.AspNetCore.Http.HttpResults;
@@ -31,6 +34,9 @@ public static IEndpointRouteBuilder MapSlices(this IEndpointRouteBuilder endpoin
             await slice.RenderAsync(httpResponse.Body);
         });
         endpoints.MapGet("/encoding", () => Results.RazorSlice<Slices.Encoding>());
+        endpoints.MapGet("/attribute-rendering", () => Results.RazorSlice<Slices.AttributeRendering>());
+        endpoints.MapGet("/streaming", () => Results.RazorSlice<Slices.Streaming>())
+            .DisableResponseBuffering();
         endpoints.MapGet("/unicode", () => Results.RazorSlice<Slices.Unicode>());
         endpoints.MapGet("/templated", (bool async = false) => Results.RazorSlice<Slices.Templated, bool>(async));
         endpoints.MapGet("/library", () => Results.RazorSlice<LibrarySlices.FromLibrary>());
@@ -49,6 +55,7 @@ public static IEndpointRouteBuilder MapSlices(this IEndpointRouteBuilder endpoin
             return Results.Ok(new ResultDto(stringBuilder.ToString()));
         });
 
+        endpoints.MapGet("/nested", () => Results.RazorSlice<Slices.Nested, Models.Todo.Nested>(new Models.Todo.Nested { Extra = "Test" }));
         endpoints.MapGet("/", () => Results.RazorSlice<Slices.Todos, Models.Todo[]>(Models.Todos.AllTodos));
         endpoints.MapGet("/{id:int}", Results<RazorSlice, NotFound> (int id) =>
         {
@@ -58,7 +65,8 @@ public static IEndpointRouteBuilder MapSlices(this IEndpointRouteBuilder endpoin
                 : TypedResults.NotFound();
         });
 #else
-        endpoints.MapGet("/lorem-static", () => Results.Extensions.RazorSlice<Slices.Lorem.LoremStatic>());
+        endpoints.MapGet("/nested", () => Results.Extensions.RazorSlice<Slices.Nested, Models.Todo.Nested>(new Models.Todo.Nested { Extra = "Test" }));
+        endpoints.MapGet("/lorem-static",() => Results.Extensions.RazorSlice<Slices.Lorem.LoremStatic>());
         endpoints.MapGet("/lorem-dynamic", (int? paraCount, int? paraLength) =>
             Results.Extensions.RazorSlice<Slices.Lorem.LoremDynamic, LoremParams>(new LoremParams(paraCount, paraLength)));
         endpoints.MapGet("/lorem-formattable", (int? paraCount, int? paraLength) =>
@@ -76,6 +84,9 @@ public static IEndpointRouteBuilder MapSlices(this IEndpointRouteBuilder endpoin
             await slice.RenderAsync(httpResponse.Body);
         });
         endpoints.MapGet("/encoding", () => Results.Extensions.RazorSlice<Slices.Encoding>());
+        endpoints.MapGet("/attribute-rendering", () => Results.Extensions.RazorSlice<Slices.AttributeRendering>());
+        endpoints.MapGet("/streaming", () => Results.Extensions.RazorSlice<Slices.Streaming>())
+            .DisableResponseBuffering();
         endpoints.MapGet("/unicode", () => Results.Extensions.RazorSlice<Slices.Unicode>());
         endpoints.MapGet("/templated", (bool async = false) => Results.Extensions.RazorSlice<Slices.Templated, bool>(async));
         endpoints.MapGet("/library", () => Results.Extensions.RazorSlice<LibrarySlices.FromLibrary>());
diff --git a/razor-slices/samples/WebApp/Models/Todo.cs b/razor-slices/samples/WebApp/Models/Todo.cs
index 952db4c8..fcaf96e3 100644
--- a/razor-slices/samples/WebApp/Models/Todo.cs
+++ b/razor-slices/samples/WebApp/Models/Todo.cs
@@ -1,9 +1,17 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using System.Text;
 
 namespace RazorSlices.Samples.WebApp.Models;
 
 public class Todo
 {
+    public class Nested
+    {
+        public string? Extra { get; set; }
+    }
+
     public int Id { get; set; }
 
     private byte[] _titleUtf8 = [];
@@ -43,4 +51,4 @@ internal static class Todos
             new() { Id = 4, TitleUtf8 = "Walk the kangaroo."u8.ToArray(), DueBy = DateOnly.FromDateTime(DateTime.Now.AddDays(1)), IsComplete = false },
             new() { Id = 5, TitleUtf8 = "Call Grandma."u8.ToArray(), DueBy = DateOnly.FromDateTime(DateTime.Now.AddDays(1)), IsComplete = false },
         ];
-}
\ No newline at end of file
+}
diff --git a/razor-slices/samples/WebApp/Program.Testing.cs b/razor-slices/samples/WebApp/Program.Testing.cs
index 9f08e4f2..693b5783 100644
--- a/razor-slices/samples/WebApp/Program.Testing.cs
+++ b/razor-slices/samples/WebApp/Program.Testing.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 namespace RazorSlices.Samples.WebApp;
 
 public partial class Program
diff --git a/razor-slices/samples/WebApp/Program.cs b/razor-slices/samples/WebApp/Program.cs
index 7646b73e..86d9f313 100644
--- a/razor-slices/samples/WebApp/Program.cs
+++ b/razor-slices/samples/WebApp/Program.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using System.Runtime.CompilerServices;
 using RazorSlices.Samples.WebApp;
 using RazorSlices.Samples.WebApp.Services;
@@ -22,11 +25,12 @@
 
 app.UseStatusCodePages();
 app.UseStaticFiles();
+app.UseRouting();
 
 if (app.Environment.IsDevelopment())
 {
     app.UseDeveloperExceptionPage();
-    if (Environment.GetEnvironmentVariable("ENABLE_RESPONSE_BUFFERING") == "true")
+    if (builder.Configuration["ENABLE_RESPONSE_BUFFERING"] == "true")
     {
         // Enable response buffering middleware to allow for response interception during local development
         app.UseResponseBuffering();
diff --git a/razor-slices/samples/WebApp/ResponseBufferingEndpointConventionBuilderExtensions.cs b/razor-slices/samples/WebApp/ResponseBufferingEndpointConventionBuilderExtensions.cs
new file mode 100644
index 00000000..88350d9e
--- /dev/null
+++ b/razor-slices/samples/WebApp/ResponseBufferingEndpointConventionBuilderExtensions.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace RazorSlices.Samples.WebApp;
+
+public static class ResponseBufferingEndpointConventionBuilderExtensions
+{
+    public static TBuilder DisableResponseBuffering<TBuilder>(this TBuilder builder)
+        where TBuilder : IEndpointConventionBuilder
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        return builder.WithMetadata(new DisableResponseBufferingAttribute());
+    }
+}
diff --git a/razor-slices/samples/WebApp/ResponseBufferingMetadata.cs b/razor-slices/samples/WebApp/ResponseBufferingMetadata.cs
new file mode 100644
index 00000000..507e7f75
--- /dev/null
+++ b/razor-slices/samples/WebApp/ResponseBufferingMetadata.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace RazorSlices.Samples.WebApp;
+
+public interface IDisableResponseBufferingMetadata
+{
+}
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+public sealed class DisableResponseBufferingAttribute : Attribute, IDisableResponseBufferingMetadata
+{
+}
diff --git a/razor-slices/samples/WebApp/ResponseBufferingMiddleware.cs b/razor-slices/samples/WebApp/ResponseBufferingMiddleware.cs
index 018e9618..a7f6682c 100644
--- a/razor-slices/samples/WebApp/ResponseBufferingMiddleware.cs
+++ b/razor-slices/samples/WebApp/ResponseBufferingMiddleware.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 namespace RazorSlices.Samples.WebApp;
 
 using System.IO;
@@ -9,6 +12,12 @@ internal sealed class ResponseBufferingMiddleware(RequestDelegate next)
 {
     public async Task InvokeAsync(HttpContext context)
     {
+        if (context.GetEndpoint()?.Metadata.GetMetadata<IDisableResponseBufferingMetadata>() is not null)
+        {
+            await next(context);
+            return;
+        }
+
         // Save the original response body stream
         var originalBodyStream = context.Response.Body;
 
@@ -42,11 +51,10 @@ public async Task InvokeAsync(HttpContext context)
     }
 }
 
-internal static class ResponseBufferingMiddlewareExtensions
+public static class ResponseBufferingMiddlewareExtensions
 {
     public static IApplicationBuilder UseResponseBuffering(this IApplicationBuilder app)
     {
         return app.UseMiddleware<ResponseBufferingMiddleware>();
     }
 }
-
diff --git a/razor-slices/samples/WebApp/ResultDtos.cs b/razor-slices/samples/WebApp/ResultDtos.cs
index b8253150..2d1117c1 100644
--- a/razor-slices/samples/WebApp/ResultDtos.cs
+++ b/razor-slices/samples/WebApp/ResultDtos.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 namespace RazorSlices.Samples.WebApp;
 
 record ResultDto(string HtmlString);
diff --git a/razor-slices/samples/WebApp/Services/LoremService.cs b/razor-slices/samples/WebApp/Services/LoremService.cs
index efee4cee..0df17898 100644
--- a/razor-slices/samples/WebApp/Services/LoremService.cs
+++ b/razor-slices/samples/WebApp/Services/LoremService.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using RazorSlices.Samples.WebApp.Slices.Lorem;
 using System.Text;
 
diff --git a/razor-slices/samples/WebApp/Slices/AttributeRendering.cshtml b/razor-slices/samples/WebApp/Slices/AttributeRendering.cshtml
new file mode 100644
index 00000000..3f2f293c
--- /dev/null
+++ b/razor-slices/samples/WebApp/Slices/AttributeRendering.cshtml
@@ -0,0 +1,17 @@
+@inherits RazorSlice
+@implements IUsesLayout<_Layout, LayoutModel>
+
+<h1 class="mt-5">Attribute rendering</h1>
+
+<div class="@false">False</div>
+<div class="@null">Null</div>
+<div class="@("")">Empty</div>
+<div class="@("false")">False String</div>
+<div class="@("active")">String</div>
+<input type="checkbox" checked="@true" name="true" />
+<input type="checkbox" checked="@false" name="false" />
+<input type="checkbox" checked="@null" name="null" />
+
+@functions {
+    public LayoutModel LayoutModel => new() { Title = "Attribute rendering" };
+}
diff --git a/razor-slices/samples/WebApp/Slices/Encoding.cshtml b/razor-slices/samples/WebApp/Slices/Encoding.cshtml
index 0f926ee3..f9ae5799 100644
--- a/razor-slices/samples/WebApp/Slices/Encoding.cshtml
+++ b/razor-slices/samples/WebApp/Slices/Encoding.cshtml
@@ -9,4 +9,4 @@ Encoded:<br />
 
 @functions {
     public LayoutModel LayoutModel => new() { Title = "Encoding" };
-}
\ No newline at end of file
+}
diff --git a/razor-slices/samples/WebApp/Slices/LayoutModel.cs b/razor-slices/samples/WebApp/Slices/LayoutModel.cs
index 06f54711..79a59706 100644
--- a/razor-slices/samples/WebApp/Slices/LayoutModel.cs
+++ b/razor-slices/samples/WebApp/Slices/LayoutModel.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 namespace RazorSlices.Samples.WebApp.Slices;
 
 public class LayoutModel
diff --git a/razor-slices/samples/WebApp/Slices/Lorem/LoremHtmlContent.cshtml b/razor-slices/samples/WebApp/Slices/Lorem/LoremHtmlContent.cshtml
index 03fcac57..352b1990 100644
--- a/razor-slices/samples/WebApp/Slices/Lorem/LoremHtmlContent.cshtml
+++ b/razor-slices/samples/WebApp/Slices/Lorem/LoremHtmlContent.cshtml
@@ -1,3 +1,4 @@
+@namespace RazorSlices.Samples.WebApp.Alternate.Lorem
 @using System.IO
 @using System.Text.Encodings.Web
 
@@ -32,10 +33,12 @@
             if (HtmlEncode)
             {
                 writer.Write(encoder.Encode(PageContent.Html));
+                writer.Write(encoder.Encode(LoremExtra.AdditionalContent));
             }
             else
             {
                 writer.Write(PageContent.Html);
+                writer.Write(LoremExtra.AdditionalContent);
             }
         }
     }
diff --git a/razor-slices/samples/WebApp/Slices/Lorem/LoremInjectableProperties.cshtml b/razor-slices/samples/WebApp/Slices/Lorem/LoremInjectableProperties.cshtml
index 14cc2099..002665dd 100644
--- a/razor-slices/samples/WebApp/Slices/Lorem/LoremInjectableProperties.cshtml
+++ b/razor-slices/samples/WebApp/Slices/Lorem/LoremInjectableProperties.cshtml
@@ -1,3 +1,4 @@
+@namespace RazorSlices.Samples.WebApp.Slices.Lorem
 @inherits RazorSlice<LoremParams>
 @implements IUsesLayout<_LoremLayout, LayoutModel>
 
@@ -22,4 +23,4 @@
 
         return Task.CompletedTask;
     }
-}
\ No newline at end of file
+}
diff --git a/razor-slices/samples/WebApp/Slices/Lorem/PageContent.cs b/razor-slices/samples/WebApp/Slices/Lorem/PageContent.cs
index 8bdc7fde..241e06f0 100644
--- a/razor-slices/samples/WebApp/Slices/Lorem/PageContent.cs
+++ b/razor-slices/samples/WebApp/Slices/Lorem/PageContent.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 namespace RazorSlices.Samples.WebApp.Slices.Lorem;
 
 public static class PageContent
diff --git a/razor-slices/samples/WebApp/Slices/Lorem/_LoremMenu.cshtml b/razor-slices/samples/WebApp/Slices/Lorem/_LoremMenu.cshtml
index f6aa1e27..0ca7b245 100644
--- a/razor-slices/samples/WebApp/Slices/Lorem/_LoremMenu.cshtml
+++ b/razor-slices/samples/WebApp/Slices/Lorem/_LoremMenu.cshtml
@@ -1,5 +1,5 @@
 <!-- _LoremMenu.cshtml -->
-@inherits RazorSlice
+@inherits Duende.RazorSlices.RazorSlice
 
 <ul class="nav">
     <li class="nav-item">
diff --git a/razor-slices/samples/WebApp/Slices/Lorem/_ViewImports.cshtml b/razor-slices/samples/WebApp/Slices/Lorem/_ViewImports.cshtml
index cac7d825..cdb729ea 100644
--- a/razor-slices/samples/WebApp/Slices/Lorem/_ViewImports.cshtml
+++ b/razor-slices/samples/WebApp/Slices/Lorem/_ViewImports.cshtml
@@ -1,4 +1,6 @@
 @inherits RazorSlice
 
+@namespace RazorSlices.Samples.WebApp.Slices.Lorem
+
 @using RazorSlices.Samples.WebApp.Services
 @using RazorSlices.Samples.WebApp.Slices.Lorem
diff --git a/razor-slices/samples/WebApp/Slices/Nested.cshtml b/razor-slices/samples/WebApp/Slices/Nested.cshtml
new file mode 100644
index 00000000..177160a3
--- /dev/null
+++ b/razor-slices/samples/WebApp/Slices/Nested.cshtml
@@ -0,0 +1,5 @@
+@inherits RazorSlice<Models.Todo.Nested>
+
+<div>
+    Nested : @Model.Extra
+</div>
diff --git a/razor-slices/samples/WebApp/Slices/SliceBaseClasses.cs b/razor-slices/samples/WebApp/Slices/SliceBaseClasses.cs
new file mode 100644
index 00000000..2df95b39
--- /dev/null
+++ b/razor-slices/samples/WebApp/Slices/SliceBaseClasses.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using Duende.RazorSlices;
+using Models = RazorSlices.Samples.WebApp.Models;
+
+namespace RazorSlices.Samples.WebApp.Slices;
+
+public abstract class TodoSliceBase : RazorSlice<Models.Todo>;
+
+public abstract class GenericTodosSliceBase<TModel> : RazorSlice<TModel>;
+
+public abstract class DeepGenericTodosSliceBase<TModel> : GenericTodosSliceBase<TModel>;
diff --git a/razor-slices/samples/WebApp/Slices/Streaming.cshtml b/razor-slices/samples/WebApp/Slices/Streaming.cshtml
new file mode 100644
index 00000000..96a7885a
--- /dev/null
+++ b/razor-slices/samples/WebApp/Slices/Streaming.cshtml
@@ -0,0 +1,32 @@
+@inherits RazorSlice
+@implements IUsesLayout<_Layout, LayoutModel>
+
+<h1 class="mt-5">Streaming response</h1>
+
+<p>The server flushes this message immediately, then sends a script every second to update it without any JavaScript libraries.</p>
+<p id="countdown" role="status">Counting down... <span id="countdown-value">10</span></p>
+<noscript>Enable JavaScript to see the countdown updates.</noscript>
+
+@await FlushAsync()
+
+@for (var count = 9; count >= 0; count--)
+{
+    await Task.Delay(TimeSpan.FromSeconds(1), CancellationToken);
+    <script>
+        document.getElementById('countdown-value').textContent = '@count';
+    </script>
+    @await FlushAsync()
+}
+
+@{
+    // Leave zero visible for a second before replacing the message.
+    await Task.Delay(TimeSpan.FromSeconds(1), CancellationToken);
+}
+<script>
+    document.getElementById('countdown').textContent = 'Countdown complete!';
+</script>
+@await FlushAsync()
+
+@functions {
+    public LayoutModel LayoutModel => new() { Title = "Streaming response" };
+}
diff --git a/razor-slices/samples/WebApp/Slices/Todo.cshtml b/razor-slices/samples/WebApp/Slices/Todo.cshtml
index 6b449b99..aca9f708 100644
--- a/razor-slices/samples/WebApp/Slices/Todo.cshtml
+++ b/razor-slices/samples/WebApp/Slices/Todo.cshtml
@@ -1,6 +1,6 @@
 @using Microsoft.AspNetCore.Html
 
-@inherits RazorSlice<Models.Todo>
+@inherits TodoSliceBase
 @implements IUsesLayout<_Layout, LayoutModel>
 
 <a href="/">Back to all todos</a>
diff --git a/razor-slices/samples/WebApp/Slices/Todos.cshtml b/razor-slices/samples/WebApp/Slices/Todos.cshtml
index 49ee67bd..2b4fba0d 100644
--- a/razor-slices/samples/WebApp/Slices/Todos.cshtml
+++ b/razor-slices/samples/WebApp/Slices/Todos.cshtml
@@ -1,4 +1,4 @@
-@inherits RazorSlice<Models.Todo[]>
+@inherits DeepGenericTodosSliceBase<Models.Todo[]>
 @implements IUsesLayout<_Layout, LayoutModel>
 
 <h1 class="mt-5">Todos</h1>
diff --git a/razor-slices/samples/WebApp/Slices/UnicodeData.cs b/razor-slices/samples/WebApp/Slices/UnicodeData.cs
index 889ae494..ec24575c 100644
--- a/razor-slices/samples/WebApp/Slices/UnicodeData.cs
+++ b/razor-slices/samples/WebApp/Slices/UnicodeData.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 using System;
 
 namespace RazorSlices.Samples.WebApp.Slices;
diff --git a/razor-slices/samples/WebApp/Slices/_FooterLinks.cshtml b/razor-slices/samples/WebApp/Slices/_FooterLinks.cshtml
index 3b59cfee..b8f406a9 100644
--- a/razor-slices/samples/WebApp/Slices/_FooterLinks.cshtml
+++ b/razor-slices/samples/WebApp/Slices/_FooterLinks.cshtml
@@ -3,6 +3,8 @@
 <a href="/lorem"><span class="text-muted">Lorem</span></a> |
 <a href="/templated"><span class="text-muted">Templated</span></a> |
 <a href="/encoding"><span class="text-muted">Encoding</span></a> |
+<a href="/attribute-rendering"><span class="text-muted">Attribute rendering</span></a> |
+<a href="/streaming"><span class="text-muted">Streaming</span></a> |
 <a href="/unicode"><span class="text-muted">Unicode</span></a> |
 <a href="/render-to-string"><span class="text-muted">Render to string</span></a> |
 <a href="/render-to-stringbuilder"><span class="text-muted">Render to StringBuilder</span></a> |
diff --git a/razor-slices/samples/WebApp/Slices/_ViewImports.cshtml b/razor-slices/samples/WebApp/Slices/_ViewImports.cshtml
index a92abb58..c835ac3e 100644
--- a/razor-slices/samples/WebApp/Slices/_ViewImports.cshtml
+++ b/razor-slices/samples/WebApp/Slices/_ViewImports.cshtml
@@ -10,4 +10,4 @@
 @using Models = RazorSlices.Samples.WebApp.Models
 
 @tagHelperPrefix __disable_tagHelpers__:
-@removeTagHelper *, Microsoft.AspNetCore.Mvc.Razor
\ No newline at end of file
+@removeTagHelper *, Microsoft.AspNetCore.Mvc.Razor
diff --git a/razor-slices/src/RazorSlices/IResultExtensions.cs b/razor-slices/src/RazorSlices/IResultExtensions.cs
index 930316f8..f752324a 100644
--- a/razor-slices/src/RazorSlices/IResultExtensions.cs
+++ b/razor-slices/src/RazorSlices/IResultExtensions.cs
@@ -170,7 +170,7 @@ public static RazorSlice<TModel> RazorSlice<TSliceProxy, TModel>(TModel model, i
 #endif
 
 /// <summary>
-/// RazorSlices IResult extensions.
+/// Duende.RazorSlices IResult extensions.
 /// </summary>
 public static class RazorSlicesExtensions
 {
diff --git a/razor-slices/src/RazorSlices/RazorSlice.Formattables.cs b/razor-slices/src/RazorSlices/RazorSlice.Formattables.cs
index 9cdac164..c9685608 100644
--- a/razor-slices/src/RazorSlices/RazorSlice.Formattables.cs
+++ b/razor-slices/src/RazorSlices/RazorSlice.Formattables.cs
@@ -1,6 +1,9 @@
 // Copyright (c) Duende Software. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
 
+// DO NOT EDIT
+// THIS FILE IS GENERATED BY Duende.RazorSlices.Formattables.tt
+
 using System.CodeDom.Compiler;
 using System.Globalization;
 using System.Numerics;
diff --git a/razor-slices/src/RazorSlices/RazorSlice.Formattables.tt b/razor-slices/src/RazorSlices/RazorSlice.Formattables.tt
index 6bdbba1e..c424c6d7 100644
--- a/razor-slices/src/RazorSlices/RazorSlice.Formattables.tt
+++ b/razor-slices/src/RazorSlices/RazorSlice.Formattables.tt
@@ -1,3 +1,6 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
 <#@ template debug="false" hostspecific="false" language="C#" #>
 <#@ assembly name="System.Core" #>
 <#@ import namespace="System.Linq" #>
@@ -30,7 +33,7 @@
     };
 #>
 // DO NOT EDIT
-// THIS FILE IS GENERATED BY RazorSlices.Formattables.tt
+// THIS FILE IS GENERATED BY Duende.RazorSlices.Formattables.tt
 
 using System.CodeDom.Compiler;
 using System.Globalization;
diff --git a/razor-slices/src/RazorSlices/RazorSlice.HtmlAttributes.cs b/razor-slices/src/RazorSlices/RazorSlice.HtmlAttributes.cs
index 2d62d99b..46e75c8e 100644
--- a/razor-slices/src/RazorSlices/RazorSlice.HtmlAttributes.cs
+++ b/razor-slices/src/RazorSlices/RazorSlice.HtmlAttributes.cs
@@ -50,6 +50,27 @@ protected virtual void BeginWriteAttribute(
         }
     }
 
+    /// <summary>
+    /// Writes out a <see cref="bool"/> attribute value.
+    /// </summary>
+    /// <remarks>
+    /// You generally shouldn't call this method directly. The Razor compiler will emit the appropriate calls to this method for
+    /// all HTML attributes containing Razor expressions in your .cshtml file.
+    /// </remarks>
+    /// <param name="prefix">The prefix.</param>
+    /// <param name="prefixOffset">The prefix offset.</param>
+    /// <param name="value">The value.</param>
+    /// <param name="valueOffset">The value offset.</param>
+    /// <param name="valueLength">The value length.</param>
+    /// <param name="isLiteral">Whether the attribute is a literal.</param>
+    protected void WriteAttributeValue(
+        string prefix,
+        int prefixOffset,
+        bool value,
+        int valueOffset,
+        int valueLength,
+        bool isLiteral) => WriteAttributeValue(prefix, prefixOffset, (bool?)value, valueOffset, valueLength, isLiteral);
+
     /// <summary>
     /// Writes out a <see cref="bool"/> attribute value.
     /// </summary>
@@ -157,12 +178,14 @@ protected void WriteAttributeValue<TValue>(
 #pragma warning restore IDE0060 // Remove unused parameter
         bool isLiteral)
     {
+        if (value is bool boolValue)
+        {
+            WriteAttributeValue(prefix, prefixOffset, boolValue, valueOffset, valueLength, isLiteral);
+            return;
+        }
+
         if (_attributeInfo.AttributeValuesCount == 1)
         {
-            // NOTE: In some edge cases, 'value' could render an empty string, e.g. custom ISpanFormattable/IHtmlContent, and thus
-            //       this IsNullValue() check will fail, but we want to avoid any allocation here so we only check if the value is
-            //       null or is actually a string and is empty. In the edge case, the attribute will still be rendered with an
-            //       empty value.
             if (IsNullValue(prefix, value))
             {
                 // Value is null with no prefix; don't render the attribute.
@@ -196,9 +219,7 @@ protected void WriteAttributeValue<TValue>(
 
         static bool IsNullValue(string? prefix, TValue? value)
         {
-            return string.IsNullOrEmpty(prefix)
-                && (value is null
-                    || (value is string && string.IsNullOrEmpty((string)(object)value)));
+            return string.IsNullOrEmpty(prefix) && value is null;
         }
     }
 
diff --git a/razor-slices/src/RazorSlices/RazorSlice.IResult.cs b/razor-slices/src/RazorSlices/RazorSlice.IResult.cs
index 1e1d0a39..d136cd1b 100644
--- a/razor-slices/src/RazorSlices/RazorSlice.IResult.cs
+++ b/razor-slices/src/RazorSlices/RazorSlice.IResult.cs
@@ -18,9 +18,9 @@ public abstract partial class RazorSlice : IResult, IStatusCodeHttpResult, ICont
     int? IStatusCodeHttpResult.StatusCode => StatusCode;
 
     /// <summary>
-    /// Gets the content type: <c>text/html; charset=utf-8</c>
+    /// Gets or sets the HTTP response content type. Defaults to <c>text/html; charset=utf-8</c>.
     /// </summary>
-    public string ContentType => "text/html; charset=utf-8";
+    public string ContentType { get; set; } = "text/html; charset=utf-8";
 
     /// <summary>
     /// Gets or sets the <see cref="System.Text.Encodings.Web.HtmlEncoder" /> instance to use when rendering the template. If
diff --git a/razor-slices/src/RazorSlices/RazorSlice.Write.cs b/razor-slices/src/RazorSlices/RazorSlice.Write.cs
index 729a1565..cae248b1 100644
--- a/razor-slices/src/RazorSlices/RazorSlice.Write.cs
+++ b/razor-slices/src/RazorSlices/RazorSlice.Write.cs
@@ -56,6 +56,7 @@ protected void WriteLiteral<T>(T? value)
         WriteLiteral(value?.ToString());
     }
 
+#if !RAZOR_SLICES_DISABLE_UTF8_LITERAL_OVERLOAD
     /// <summary>
     /// Writes a buffer of UTF8 bytes to the output without HTML encoding it.
     /// </summary>
@@ -80,6 +81,7 @@ protected void WriteLiteral(ReadOnlySpan<byte> value)
         _pipeWriter?.Write(value);
         _textWriter?.WriteUtf8(value);
     }
+#endif
 
     /// <summary>
     /// Writes a <see cref="bool"/> value to the output.
@@ -106,6 +108,16 @@ protected void WriteLiteral(ReadOnlySpan<byte> value)
     /// <param name="value">The value to write to the output.</param>
     protected void Write(byte[] value) => Write(value.AsSpan());
 
+    /// <summary>
+    /// Writes a buffer of UTF8 bytes to the output after HTML encoding it.
+    /// </summary>
+    /// <remarks>
+    /// You generally shouldn't call this method directly. The Razor compiler will emit the appropriate calls to this method for
+    /// all matching Razor expressions in your .cshtml file.
+    /// </remarks>
+    /// <param name="value">The value to write to the output.</param>
+    protected void Write(ReadOnlyMemory<byte> value) => Write(value.Span);
+
     /// <summary>
     /// Writes a buffer of UTF8 bytes to the output after HTML encoding it.
     /// </summary>
@@ -167,7 +179,11 @@ protected void Write(string? value)
     {
         if (!string.IsNullOrEmpty(value))
         {
-            Write(value.AsSpan());
+            _pipeWriter?.HtmlEncodeAndWrite(value.AsSpan(), _htmlEncoder);
+            if (_textWriter is not null)
+            {
+                _htmlEncoder.Encode(_textWriter, value);
+            }
         }
     }
 
@@ -393,7 +409,7 @@ protected HtmlString WriteHtml(HtmlString htmlString)
     /// <returns><see cref="HtmlString.Empty"/> to allow for easy calling via a Razor expression, e.g. <c>@WriteHtml(Model.SomeHtml)</c></returns>
     protected HtmlString WriteHtml(string? htmlString)
     {
-        if (string.IsNullOrEmpty(htmlString))
+        if (!string.IsNullOrEmpty(htmlString))
         {
             _pipeWriter?.WriteHtml(htmlString.AsSpan());
             _textWriter?.Write(htmlString);
diff --git a/razor-slices/src/RazorSlices/RazorSlice.cs b/razor-slices/src/RazorSlices/RazorSlice.cs
index a4f50592..38479ec2 100644
--- a/razor-slices/src/RazorSlices/RazorSlice.cs
+++ b/razor-slices/src/RazorSlices/RazorSlice.cs
@@ -20,8 +20,6 @@ public abstract partial class RazorSlice : IDisposable
 {
     private const int _autoFlushThreshold = 1_024 * 16; // Auto-flush after each slice rendering if unflushed bytes is over 16 KB
 
-    private static readonly FlushResult _noFlushResult = new(false, false);
-
     // Used to support nested writers emitted by the Razor compiler when using templated razor delegates
     private Stack<(PipeWriter?, TextWriter?)>? _writerStack;
 
@@ -130,6 +128,19 @@ public ValueTask RenderAsync(PipeWriter pipeWriter, HtmlEncoder? htmlEncoder = n
 
         var pipe = FlushTrackingPipeWriter.Create(pipeWriter);
 
+        if (ReferenceEquals(pipe, pipeWriter))
+        {
+            var unwrappedRenderTask = RenderToPipeWriterAsync(pipe, htmlEncoder, cancellationToken);
+
+            if (!unwrappedRenderTask.IsCompletedSuccessfully)
+            {
+                // Go async
+                return unwrappedRenderTask;
+            }
+
+            return ValueTask.CompletedTask;
+        }
+
         ValueTask renderTask;
         try
         {
@@ -204,7 +215,7 @@ private ValueTask RenderToPipeWriterAsync(PipeWriter pipeWriter, HtmlEncoder? ht
 
         Dispose();
 
-        return AutoFlush().GetAsValueTask();
+        return AutoFlush();
     }
 
     [MemberNotNull(nameof(_textWriter))]
@@ -283,17 +294,17 @@ private void EnsureInitialized()
         }
     }
 
-    private ValueTask<FlushResult> AutoFlush()
+    private ValueTask AutoFlush()
     {
         Debug.Assert(_pipeWriter is null || _pipeWriter.CanGetUnflushedBytes, "PipeWriter must support unflushed bytes to auto-flush.");
 
         if (_pipeWriter is not null && _pipeWriter.UnflushedBytes >= _autoFlushThreshold)
         {
             Debug.WriteLine($"Auto-flushing slice of type '{GetType().Name}' to a PipeWriter");
-            return _pipeWriter.FlushAsync(CancellationToken);
+            return _pipeWriter.FlushAsync(CancellationToken).GetAsValueTask();
         }
 
-        return ValueTask.FromResult(_noFlushResult);
+        return ValueTask.CompletedTask;
     }
 
     private static async ValueTask AwaitOutputFlushTask(Task flushTask) => await flushTask.ConfigureAwait(false);
@@ -385,12 +396,4 @@ private void DisposeInternal()
 
         Debug.WriteLine($"Disposed slice of type '{GetType().Name}'");
     }
-
-    /// <summary>
-    /// Finalizer.
-    /// </summary>
-    ~RazorSlice()
-    {
-        DisposeInternal();
-    }
 }
diff --git a/razor-slices/src/RazorSlices/RazorSliceFactory.cs b/razor-slices/src/RazorSlices/RazorSliceFactory.cs
index 121e6d6c..4e7a6087 100644
--- a/razor-slices/src/RazorSlices/RazorSliceFactory.cs
+++ b/razor-slices/src/RazorSlices/RazorSliceFactory.cs
@@ -28,29 +28,99 @@ public static class RazorSliceFactory
     private static readonly MethodInfo _getRequiredServiceMethod = typeof(ServiceProviderServiceExtensions).GetMethod(nameof(ServiceProviderServiceExtensions.GetRequiredService), [typeof(IServiceProvider), typeof(Type)])
         ?? throw new InvalidOperationException("Could not find ServiceProviderServiceExtensions.GetRequirdService. Likely a bug in Razor Slices itself.");
 
-    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties)]
-    private static readonly Type _razorSliceType = typeof(RazorSlice);
-    private static readonly PropertyInfo _razorSliceInitializeProperty = _razorSliceType.GetProperty(nameof(RazorSlice.Initialize))
-        ?? throw new InvalidOperationException("Could not find RazorSlice.Initialize property. Likely a bug in Razor Slices itself.");
     private static readonly ConstructorInfo _ioeCtor = typeof(InvalidOperationException).GetConstructor([typeof(string)])!;
     private static readonly NullabilityInfoContext _nullabilityContext = new();
-    private static readonly Action<RazorSlice, IServiceProvider?, HttpContext?> _emptyInit = (_, __, ___) => { };
 
-    internal static bool IsModelSlice(Type sliceType)
+    /// <summary>
+    /// Creates a slice using its generated constructor callback and configures deferred property injection.
+    /// </summary>
+    /// <typeparam name="TSlice">The compiled Razor template type.</typeparam>
+    /// <param name="createSlice">A callback that directly constructs the template.</param>
+    /// <returns>A new slice, or its Hot Reload replacement.</returns>
+    public static RazorSlice Create<
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] TSlice>(Func<TSlice> createSlice)
+        where TSlice : RazorSlice
+    {
+        ArgumentNullException.ThrowIfNull(createSlice);
+        var activation = SliceCache<TSlice>.Current;
+        var slice = activation.CreateReplacement is { } createReplacement ? createReplacement() : createSlice();
+        slice.Initialize = activation.Initialize;
+        return slice;
+    }
+
+    /// <summary>
+    /// Creates a model slice using its generated constructor callback and configures deferred property injection.
+    /// </summary>
+    /// <typeparam name="TSlice">The compiled Razor template type.</typeparam>
+    /// <typeparam name="TModel">The model type.</typeparam>
+    /// <param name="model">The model for the slice.</param>
+    /// <param name="createSlice">A callback that directly constructs the template with its model.</param>
+    /// <returns>A new slice, or its Hot Reload replacement, with the specified model.</returns>
+    public static RazorSlice<TModel> Create<
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] TSlice, TModel>(
+        TModel model, Func<TModel, TSlice> createSlice)
+        where TSlice : RazorSlice<TModel>
+    {
+        ArgumentNullException.ThrowIfNull(createSlice);
+        var activation = SliceCache<TSlice>.Current;
+        RazorSlice<TModel> slice;
+        if (activation.CreateReplacement is { } createReplacement)
+        {
+            slice = (RazorSlice<TModel>)createReplacement();
+            slice.Model = model;
+        }
+        else
+        {
+            slice = createSlice(model);
+        }
+        slice.Initialize = activation.Initialize;
+        return slice;
+    }
+
+    internal sealed record SliceActivation(
+        Action<RazorSlice, IServiceProvider?, HttpContext?>? Initialize,
+        Func<RazorSlice>? CreateReplacement = null);
+
+    internal static class SliceCache<
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] TSlice>
+        where TSlice : RazorSlice
     {
-        var baseType = sliceType.BaseType;
+        internal static volatile SliceActivation Current = new(GetInitializer(typeof(TSlice)));
 
-        while (baseType is not null)
+        static SliceCache()
         {
-            if (baseType.IsGenericType && baseType.GetGenericTypeDefinition() == typeof(RazorSlice<>))
+            if (HotReloadService.IsSupported)
             {
-                return true;
+                HotReloadService.ClearCacheEvent += ReplaceSliceType;
             }
+        }
 
-            baseType = baseType.BaseType;
+        [UnconditionalSuppressMessage("Trimming", "IL2072",
+            Justification = "Replacement types are only used during Hot Reload, which is not supported in trimmed applications.")]
+        internal static void ReplaceSliceType(Type[]? changedTypes)
+        {
+            if (HotReloadService.TryGetUpdatedType(changedTypes, typeof(TSlice), out var updatedType))
+            {
+                // Publish construction and injection together so a render cannot mix two generations of the template.
+                Current = new(GetInitializer(updatedType), () => (RazorSlice)Activator.CreateInstance(updatedType)!);
+            }
         }
+    }
 
-        return false;
+    [UnconditionalSuppressMessage("AOT", "IL3050",
+        Justification = "Guarded by RuntimeFeature.IsDynamicCodeCompiled.")]
+    internal static Action<RazorSlice, IServiceProvider?, HttpContext?>? GetInitializer(
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type sliceType)
+    {
+        var properties = GetInjectableProperties(sliceType);
+        if (!properties.Any)
+        {
+            return null;
+        }
+
+        return RuntimeFeature.IsDynamicCodeCompiled
+            ? GetExpressionInitAction(sliceType, properties).Compile()
+            : GetReflectionInitAction(sliceType, properties);
     }
 
     internal static (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable) GetInjectableProperties(
@@ -83,32 +153,27 @@ internal static (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable)
                 nonNullable?.ToArray() ?? []);
     }
 
-    private static Action<RazorSlice, IServiceProvider?, HttpContext?> GetReflectionInitAction(SliceDefinition sliceDefinition) => sliceDefinition.InjectableProperties.Any
-            ? (slice, serviceProvider, httpContext) =>
-            {
-                var services = (serviceProvider ?? httpContext?.RequestServices)
-                    ?? throw new InvalidOperationException($"Cannot initialize @inject properties of slice {sliceDefinition.SliceType.Name} because the ServiceProvider property is null.");
+    internal static Action<RazorSlice, IServiceProvider?, HttpContext?> GetReflectionInitAction(
+        Type sliceType, (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable) properties) => (slice, serviceProvider, httpContext) =>
+                                                                                                            {
+                                                                                                                var services = (serviceProvider ?? httpContext?.RequestServices)
+                                                                                                                    ?? throw new InvalidOperationException($"Cannot initialize @inject properties of slice {sliceType.Name} because the ServiceProvider property is null.");
 
-                foreach (var pi in sliceDefinition.InjectableProperties.NonNullable)
-                {
-                    pi.SetValue(slice, services.GetRequiredService(pi.PropertyType));
-                }
+                                                                                                                foreach (var pi in properties.NonNullable)
+                                                                                                                {
+                                                                                                                    pi.SetValue(slice, services.GetRequiredService(pi.PropertyType));
+                                                                                                                }
 
-                foreach (var pi in sliceDefinition.InjectableProperties.Nullable)
-                {
-                    pi.SetValue(slice, services.GetService(pi.PropertyType));
-                }
-            }
-    : _emptyInit;
+                                                                                                                foreach (var pi in properties.Nullable)
+                                                                                                                {
+                                                                                                                    pi.SetValue(slice, services.GetService(pi.PropertyType));
+                                                                                                                }
+                                                                                                            };
 
     [RequiresDynamicCode("Uses System.Linq.Expressions to dynamically generate delegates for initializing slices")]
-    private static Expression<Action<RazorSlice, IServiceProvider?, HttpContext?>> GetExpressionInitAction(SliceDefinition sliceDefinition)
+    private static Expression<Action<RazorSlice, IServiceProvider?, HttpContext?>> GetExpressionInitAction(
+        Type sliceType, (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable) properties)
     {
-        if (!sliceDefinition.InjectableProperties.Any)
-        {
-            throw new InvalidOperationException("Shouldn't call GetExpressionInitAction if there's no injectable properties.");
-        }
-
         // Make a delegate like:
         //
         // (RazorSlice slice, IServiceProvider? sp, HttpContext? httpContext) =>
@@ -124,11 +189,11 @@ internal static (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable)
         //     s.NextProp = (SomeOtherService)services.GetRequiredService(typeof(SomeOtherService));
         // }
 
-        var sliceParam = Expression.Parameter(_razorSliceType, "slice");
+        var sliceParam = Expression.Parameter(typeof(RazorSlice), "slice");
         var spParam = Expression.Parameter(typeof(IServiceProvider), "sp");
         var httpContextParam = Expression.Parameter(typeof(HttpContext), "httpContext");
         var servicesVar = Expression.Variable(typeof(IServiceProvider), "services");
-        var castSliceVar = Expression.Variable(sliceDefinition.SliceType, "s");
+        var castSliceVar = Expression.Variable(sliceType, "s");
 
         var body = new List<Expression>
         {
@@ -149,10 +214,10 @@ internal static (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable)
                 // throw new InvalidOperationException
                 Expression.Throw(Expression.New(_ioeCtor, Expression.Constant("Cannot initialize @inject properties of slice because the ServiceProvider property is null.")))),
             // var s = (MySlice)slice;
-            Expression.Assign(castSliceVar, Expression.Convert(sliceParam, sliceDefinition.SliceType))
+            Expression.Assign(castSliceVar, Expression.Convert(sliceParam, sliceType))
         };
 
-        foreach (var ip in sliceDefinition.InjectableProperties.Nullable)
+        foreach (var ip in properties.Nullable)
         {
             // s.SomeProp = (SomeService)services.GetService(typeof(SomeService));
             var propertyAccess = Expression.MakeMemberAccess(castSliceVar, ip);
@@ -160,7 +225,7 @@ internal static (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable)
             body.Add(Expression.Assign(propertyAccess, Expression.Convert(getServiceCall, ip.PropertyType)));
         }
 
-        foreach (var ip in sliceDefinition.InjectableProperties.NonNullable)
+        foreach (var ip in properties.NonNullable)
         {
             // s.SomeProp = (SomeService)services.GetRequiredService(typeof(SomeService));
             var propertyAccess = Expression.MakeMemberAccess(castSliceVar, ip);
@@ -175,105 +240,6 @@ internal static (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable)
             parameters: [sliceParam, spParam, httpContextParam]);
     }
 
-    [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.",
-        Justification = "Guarded by check of RuntimeFeature.IsDynamicCodeCompiled")]
-    internal static Delegate GetSliceFactory(SliceDefinition sliceDefinition) => RuntimeFeature.IsDynamicCodeCompiled
-            ? GetExpressionsSliceFactory(sliceDefinition)
-            : GetReflectionSliceFactory(sliceDefinition);
-
-    private static Delegate GetReflectionSliceFactory(SliceDefinition sliceDefinition)
-    {
-        var init = GetReflectionInitAction(sliceDefinition);
-        return sliceDefinition.HasModel
-            ? (object model) =>
-            {
-                var slice = (RazorSlice)Activator.CreateInstance(sliceDefinition.SliceType)!;
-                sliceDefinition.ModelProperty!.SetValue(slice, model);
-                slice.Initialize = init;
-                return slice;
-            }
-        : () =>
-        {
-            var slice = (RazorSlice)Activator.CreateInstance(sliceDefinition.SliceType)!;
-            slice.Initialize = init;
-            return slice;
-        };
-    }
-
-    /// <summary>
-    /// Creates a <see cref="RazorSliceFactory"/> that can be used to create a <see cref="RazorSlice"/> of the specified <see cref="Type"/>.
-    /// </summary>
-    /// <param name="sliceDefinition"></param>
-    /// <returns>A <see cref="RazorSliceFactory"/> that can be used to create an instance of the slice.</returns>
-    [RequiresDynamicCode("Uses System.Linq.Expressions to dynamically generate delegates for creating slices")]
-    private static Delegate GetExpressionsSliceFactory(SliceDefinition sliceDefinition)
-    {
-        var sliceType = sliceDefinition.SliceType;
-
-        if (sliceType.GetConstructor(Type.EmptyTypes) is null)
-        {
-            throw new ArgumentException($"Slice type {sliceType.Name} must have a parameterless constructor.", nameof(sliceDefinition));
-        }
-
-        var body = new List<Expression>();
-
-        // Make a delegate like:
-        //
-        // MySlice CreateSlice()
-        // {
-        //     var slice = new SliceType();
-        //     slice.Init = ...;
-        //     return slice;
-        // }
-        //
-        // or
-        //
-        // MySlice CreateSlice(object model)
-        // {
-        //     var slice = new SliceType<MyModel>();
-        //     slice.Init = ...;
-        //     slice.Model = (MyModel)model
-        //     return slice;
-        // }
-
-        var sliceVariable = Expression.Variable(sliceType, "slice");
-        body.Add(Expression.Assign(sliceVariable, Expression.New(sliceType)));
-        ParameterExpression[]? parameters = null;
-        var factoryType = typeof(Func<RazorSlice>);
-
-        if (sliceDefinition.InjectableProperties.Any)
-        {
-            body.Add(Expression.Assign(
-                Expression.MakeMemberAccess(sliceVariable, _razorSliceInitializeProperty),
-                GetExpressionInitAction(sliceDefinition)!));
-        }
-
-        if (sliceDefinition.ModelType is not null)
-        {
-            // Func<object, RazorSlice<MyModel>>
-            var modelPropInfo = sliceType.GetProperty("Model")!;
-            factoryType = typeof(Func<,>).MakeGenericType(typeof(object), sliceType);
-            var modelParam = Expression.Parameter(typeof(object), "model");
-            parameters = [modelParam];
-            body.Add(Expression.Assign(
-                Expression.MakeMemberAccess(sliceVariable, modelPropInfo),
-                Expression.Convert(modelParam, sliceDefinition.ModelType)));
-        }
-
-        var returnTarget = Expression.Label(sliceType);
-        body.Add(Expression.Label(returnTarget, sliceVariable));
-
-        return Expression.Lambda(
-            delegateType: factoryType,
-            body: Expression.Block(
-                variables: [sliceVariable],
-                body
-            ),
-            name: "CreateSlice",
-            parameters: parameters)
-        .Compile();
-    }
-
     private static bool IsNullable(PropertyInfo info) =>
         Nullable.GetUnderlyingType(info.PropertyType) is not null
             || _nullabilityContext.Create(info).WriteState is not NullabilityState.NotNull;
diff --git a/razor-slices/src/RazorSlices/ReusableStringWriter.cs b/razor-slices/src/RazorSlices/ReusableStringWriter.cs
index 376568a2..d0e70cd7 100644
--- a/razor-slices/src/RazorSlices/ReusableStringWriter.cs
+++ b/razor-slices/src/RazorSlices/ReusableStringWriter.cs
@@ -1,6 +1,9 @@
 // Copyright (c) Duende Software. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
 
+// Adapted from System.IO.StringWriter
+// https://github.com/dotnet/runtime/blob/57ab984bd0dbbacd02315d41e09144d2823e9475/src/libraries/System.Private.CoreLib/src/System/IO/StringWriter.cs
+
 using System.Text;
 using Microsoft.Extensions.ObjectPool;
 
diff --git a/razor-slices/src/RazorSlices/SliceDefinition.cs b/razor-slices/src/RazorSlices/SliceDefinition.cs
deleted file mode 100644
index 7da5b279..00000000
--- a/razor-slices/src/RazorSlices/SliceDefinition.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright (c) Duende Software. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
-
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Reflection;
-
-namespace Duende.RazorSlices;
-
-/// <summary>
-/// Defines a Razor Slice that can be created via <see cref="RazorSliceFactory"/>.
-/// </summary>
-/// <remarks>
-/// This type is used by the types generated by the Razor Slices source generator. You should not need to interact with this type directly in your project.
-/// </remarks>
-public class SliceDefinition
-{
-    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
-    private readonly Type _originalSliceType;
-
-    /// <summary>
-    /// Creates a new instance of <see cref="SliceDefinition"/>.
-    /// </summary>
-    /// <param name="sliceType">The type of the slice.</param>
-    /// <exception cref="ArgumentException">Thrown if the specified slice type cannot be loaded.</exception>
-    public SliceDefinition(
-        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
-        Type sliceType)
-    {
-        ArgumentNullException.ThrowIfNull(sliceType);
-
-        if (HotReloadService.IsSupported)
-        {
-            HotReloadService.ClearCacheEvent += ReplaceSliceType;
-        }
-
-        _originalSliceType = sliceType;
-        Initialize(sliceType);
-        Factory = RazorSliceFactory.GetSliceFactory(this);
-    }
-
-    [MemberNotNull(nameof(SliceType))]
-    private void Initialize(
-        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
-        Type sliceType)
-    {
-        SliceType = sliceType;
-        HasModel = RazorSliceFactory.IsModelSlice(SliceType);
-        ModelProperty = SliceType.GetProperty("Model");
-        ModelType = ModelProperty?.PropertyType;
-        InjectableProperties = RazorSliceFactory.GetInjectableProperties(SliceType);
-        Factory = RazorSliceFactory.GetSliceFactory(this);
-    }
-
-    [UnconditionalSuppressMessage("AssemblyLoadTrimming", "IL2067",
-        Justification = "This method should only be called when a type is updated by the Hot Reload service and thus is fine for it to be" +
-                        "trimmed during publish as Hot Reload doesn't run after publish anyway.")]
-    private void ReplaceSliceType(Type[]? changedTypes)
-    {
-        var started = Stopwatch.GetTimestamp();
-
-        if (HotReloadService.TryGetUpdatedType(changedTypes, _originalSliceType, out var updatedSliceType))
-        {
-            Debug.Write($"Hot reloading slice of type '{_originalSliceType.Name}'... ");
-
-            Initialize(updatedSliceType);
-
-            Debug.WriteLine($"done! It took {Stopwatch.GetElapsedTime(started).TotalMilliseconds}ms");
-        }
-    }
-
-    /// <summary>
-    /// Gets the type of the slice.
-    /// </summary>
-    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
-    public Type SliceType { get; private set; }
-
-    /// <summary>
-    /// Gets whether this slice has a model.
-    /// </summary>
-    public bool HasModel { get; private set; }
-
-    /// <summary>
-    /// Gets the information about the model property for the slice if it has a model.
-    /// </summary>
-    public PropertyInfo? ModelProperty { get; private set; }
-
-    /// <summary>
-    /// Gets the model type for the slice if it has a model.
-    /// </summary>
-    public Type? ModelType { get; private set; }
-
-    /// <summary>
-    /// Gets details of the injectable properties for the slice.
-    /// </summary>
-    public (bool Any, PropertyInfo[] Nullable, PropertyInfo[] NonNullable) InjectableProperties { get; private set; }
-
-    /// <summary>
-    /// Gets the factory delegate for creating instances of the slice.
-    /// </summary>
-    public Delegate Factory { get; private set; }
-
-    /// <summary>
-    /// Creates a new instance of the slice this definition represents.
-    /// </summary>
-    /// <returns>The slice instance.</returns>
-    /// <exception cref="InvalidOperationException">Thrown if the slice requires a model.</exception>
-    public RazorSlice CreateSlice() => HasModel
-        ? throw new InvalidOperationException($"Slice {SliceType.Name} requires a model of type {ModelType?.Name}. Call Create<TModel>(TModel model) instead.")
-        : ((Func<RazorSlice>)Factory)();
-
-    /// <summary>
-    /// Creates a new instance of the slice this definition represents with the specified model.
-    /// </summary>
-    /// <typeparam name="TModel">The type of the slice model.</typeparam>
-    /// <param name="model">The model for the slice.</param>
-    /// <returns>The slice instance.</returns>
-    /// <exception cref="InvalidOperationException">Thrown if the slice does not require a model or the model instance passed is not assignable to the model type the slice requires.</exception>
-    public RazorSlice<TModel> CreateSlice<TModel>(TModel model) => !HasModel || !typeof(TModel).IsAssignableTo(ModelType)
-        ? throw new InvalidOperationException($"""
-            Cannot use model of type {typeof(TModel).Name} with slice {SliceType.Name}.
-            {(HasModel ? $"Ensure the model is assignable to {ModelType!.Name}" : "It is not a strongly-typed slice.")}
-            """)
-        : (RazorSlice<TModel>)((Func<object, RazorSlice>)Factory)(model!);
-}
diff --git a/razor-slices/src/RazorSlices/TaskExtensions.cs b/razor-slices/src/RazorSlices/TaskExtensions.cs
index 5f417ca7..ed657210 100644
--- a/razor-slices/src/RazorSlices/TaskExtensions.cs
+++ b/razor-slices/src/RazorSlices/TaskExtensions.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Duende Software. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
 
+// Parts taken from https://github.com/dotnet/aspnetcore/blob/4eae56d8f7315cbd49fcbd760341940e3d087aa5/src/Shared/ValueTaskExtensions/ValueTaskExtensions.cs
 using System.IO.Pipelines;
 using System.Runtime.CompilerServices;
 
diff --git a/razor-slices/src/RazorSlices/build/Duende.RazorSlices.props b/razor-slices/src/RazorSlices/build/Duende.RazorSlices.props
index 5d9f39a0..287a3090 100644
--- a/razor-slices/src/RazorSlices/build/Duende.RazorSlices.props
+++ b/razor-slices/src/RazorSlices/build/Duende.RazorSlices.props
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <EnableDefaultRazorSlices Condition=" '$(EnableDefaultRazorSlices)' == '' ">true</EnableDefaultRazorSlices>
-    <RazorSliceProxiesSealed Condition=" '$(RazorSliceProxiesSealed)' == '' ">true</RazorSliceProxiesSealed>
+    <RazorSliceProxiesAsRecords Condition=" '$(RazorSliceProxiesAsRecords)' == '' ">false</RazorSliceProxiesAsRecords>
   </PropertyGroup>
 
   <!-- Define a new item type for consumers to easily specify which files should generate slices -->
diff --git a/razor-slices/src/RazorSlices/build/Duende.RazorSlices.targets b/razor-slices/src/RazorSlices/build/Duende.RazorSlices.targets
index 473c1e97..a641cc53 100644
--- a/razor-slices/src/RazorSlices/build/Duende.RazorSlices.targets
+++ b/razor-slices/src/RazorSlices/build/Duende.RazorSlices.targets
@@ -31,6 +31,7 @@
 
       <!-- Make the RazorGenerate item type and GenerateRazorSlice item metadata visible to the source generator -->
       <CompilerVisibleItemMetadata Include="RazorGenerate" MetadataName="GenerateRazorSlice" />
+      <CompilerVisibleProperty Include="RazorSliceProxiesAsRecords" />
     </ItemGroup>
   </Target>
 
diff --git a/razor-slices/src/SourceGenerator/ModelTypeResolver.cs b/razor-slices/src/SourceGenerator/ModelTypeResolver.cs
index 26537042..2f5fcdad 100644
--- a/razor-slices/src/SourceGenerator/ModelTypeResolver.cs
+++ b/razor-slices/src/SourceGenerator/ModelTypeResolver.cs
@@ -52,6 +52,46 @@ internal static class ModelTypeResolver
     /// <returns>The fully qualified type name with global:: prefix, or null if resolution fails.</returns>
     internal static string? ResolveModelType(string modelTypeName, List<UsingDirective> usingDirectives, Compilation compilation, string? rootNamespace = null) => ResolveTypeExpression(modelTypeName.Trim(), usingDirectives, compilation, rootNamespace);
 
+    /// <summary>
+    /// Resolves the model type by resolving an inherited slice base type and walking its base type hierarchy
+    /// until a <c>Duende.RazorSlices.RazorSlice&lt;TModel&gt;</c> base type is found.
+    /// Returns null when the inherited type cannot be resolved or does not derive from a generic RazorSlice.
+    /// </summary>
+    internal static string? ResolveModelTypeFromSliceBaseType(string baseTypeName, List<UsingDirective> usingDirectives, Compilation compilation, string? rootNamespace = null)
+    {
+        var trimmedBaseTypeName = baseTypeName.Trim();
+        if (trimmedBaseTypeName.StartsWith("global::", StringComparison.Ordinal))
+        {
+            trimmedBaseTypeName = trimmedBaseTypeName.Substring("global::".Length);
+        }
+
+        var baseTypeSymbol = ResolveTypeSymbolExpression(trimmedBaseTypeName, usingDirectives, compilation, rootNamespace) as INamedTypeSymbol;
+        if (baseTypeSymbol is null)
+        {
+            return null;
+        }
+
+        for (var currentType = baseTypeSymbol; currentType is not null; currentType = currentType.BaseType)
+        {
+            if (!string.Equals(currentType.Name, "RazorSlice", StringComparison.Ordinal) ||
+                !string.Equals(currentType.ContainingNamespace.ToDisplayString(), "Duende.RazorSlices", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            if (currentType.IsGenericType && currentType.TypeArguments.Length == 1)
+            {
+                return "global::" + currentType.TypeArguments[0].ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat
+                    .WithGlobalNamespaceStyle(SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining));
+            }
+
+            // Reached non-generic RazorSlice, so there is no model.
+            return null;
+        }
+
+        return null;
+    }
+
     private static string? ResolveTypeExpression(string typeName, List<UsingDirective> usingDirectives, Compilation compilation, string? rootNamespace)
     {
         // Handle nullable value types: T?
@@ -86,6 +126,93 @@ internal static class ModelTypeResolver
         return ResolveSimpleType(typeName, usingDirectives, compilation, rootNamespace: rootNamespace);
     }
 
+    private static ITypeSymbol? ResolveTypeSymbolExpression(string typeName, List<UsingDirective> usingDirectives, Compilation compilation, string? rootNamespace)
+    {
+        // Handle nullable value/reference types by resolving the underlying type symbol.
+        if (typeName.EndsWith("?", StringComparison.Ordinal))
+        {
+            var innerType = typeName.Substring(0, typeName.Length - 1).Trim();
+            return ResolveTypeSymbolExpression(innerType, usingDirectives, compilation, rootNamespace);
+        }
+
+        // Handle array types: T[], T[,], etc.
+        if (typeName.EndsWith("]", StringComparison.Ordinal))
+        {
+            var bracketStart = FindArrayBracketStart(typeName);
+            if (bracketStart >= 0)
+            {
+                var elementType = typeName.Substring(0, bracketStart).Trim();
+                var elementSymbol = ResolveTypeSymbolExpression(elementType, usingDirectives, compilation, rootNamespace);
+                if (elementSymbol is null)
+                {
+                    return null;
+                }
+
+                var arraySuffix = typeName.Substring(bracketStart);
+                var rank = 1;
+                for (var i = 0; i < arraySuffix.Length; i++)
+                {
+                    if (arraySuffix[i] == ',')
+                    {
+                        rank++;
+                    }
+                }
+
+                return compilation.CreateArrayTypeSymbol(elementSymbol, rank);
+            }
+        }
+
+        // Handle generic types: Type<T1, T2>
+        var genericOpen = FindTopLevelGenericOpen(typeName);
+        if (genericOpen >= 0)
+        {
+            var outerType = typeName.Substring(0, genericOpen).Trim();
+            var genericClose = typeName.LastIndexOf('>');
+            if (genericClose <= genericOpen)
+            {
+                return null;
+            }
+
+            var argsString = typeName.Substring(genericOpen + 1, genericClose - genericOpen - 1);
+            var args = SplitGenericArguments(argsString);
+
+            var metadataName = outerType + "`" + args.Count;
+            var resolvedOuter = ResolveSimpleType(outerType, usingDirectives, compilation, metadataName, stripGenericParams: true, rootNamespace: rootNamespace);
+            if (resolvedOuter is null)
+            {
+                return null;
+            }
+
+            var outerSymbol = ResolveNamedTypeSymbol(resolvedOuter + "`" + args.Count, compilation);
+            if (outerSymbol is null)
+            {
+                return null;
+            }
+
+            var resolvedArgs = new ITypeSymbol[args.Count];
+            for (var i = 0; i < args.Count; i++)
+            {
+                var resolvedArg = ResolveTypeSymbolExpression(args[i].Trim(), usingDirectives, compilation, rootNamespace);
+                if (resolvedArg is null)
+                {
+                    return null;
+                }
+
+                resolvedArgs[i] = resolvedArg;
+            }
+
+            return outerSymbol.Construct(resolvedArgs);
+        }
+
+        var resolvedSimple = ResolveSimpleType(typeName, usingDirectives, compilation, rootNamespace: rootNamespace);
+        if (resolvedSimple is null)
+        {
+            return null;
+        }
+
+        return ResolveNamedTypeSymbol(resolvedSimple, compilation);
+    }
+
     private static string? ResolveGenericType(string typeName, int genericOpen, List<UsingDirective> usingDirectives, Compilation compilation, string? rootNamespace)
     {
         var outerType = typeName.Substring(0, genericOpen).Trim();
@@ -171,11 +298,94 @@ internal static class ModelTypeResolver
                     {
                         return resolved;
                     }
+
+                    // Try treating dots in the suffix as nested type separators
+                    resolved = TryResolveNestedType(expandedType, expandedLookup, compilation, stripGenericParams);
+                    if (resolved != null)
+                    {
+                        return resolved;
+                    }
+                }
+            }
+        }
+
+        // 3-6. Try as fully-qualified, with @using prefixes, implicit namespaces, and root namespace
+        var result = TryResolveWithNamespaces(typeName, metadataNameOverride, usingDirectives, compilation, stripGenericParams, rootNamespace);
+        if (result != null)
+        {
+            return result;
+        }
+
+        // 7. Try nested types: for types like "Outer.Inner", try treating dots as
+        //    nested type separators ('+' in metadata) with namespace resolution.
+        var parts = typeName.Split('.');
+        for (var j = parts.Length - 1; j > 0; j--)
+        {
+            var outerPart = string.Join(".", parts, 0, j);
+            var nestedPart = string.Join("+", parts, j, parts.Length - j);
+            var candidateName = outerPart + "+" + nestedPart;
+            string? candidateLookup = null;
+
+            if (metadataNameOverride != null)
+            {
+                var arityIndex = metadataNameOverride.IndexOf('`');
+                candidateLookup = arityIndex >= 0
+                    ? candidateName + metadataNameOverride.Substring(arityIndex)
+                    : candidateName;
+            }
+
+            result = TryResolveWithNamespaces(candidateName, candidateLookup, usingDirectives, compilation, stripGenericParams, rootNamespace);
+            if (result != null)
+            {
+                return result;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Tries to resolve a fully-qualified type name by treating dots as nested type separators.
+    /// For "Namespace.Outer.Inner", tries "Namespace.Outer+Inner", "Namespace+Outer+Inner", etc.
+    /// </summary>
+    private static string? TryResolveNestedType(string typeName, string? metadataNameOverride, Compilation compilation, bool stripGenericParams)
+    {
+        var parts = typeName.Split('.');
+        for (var j = parts.Length - 1; j > 0; j--)
+        {
+            var namespacePart = string.Join(".", parts, 0, j);
+            var nestedPart = string.Join("+", parts, j, parts.Length - j);
+            var candidateName = namespacePart + "+" + nestedPart;
+            string? candidateLookup = null;
+
+            if (metadataNameOverride != null)
+            {
+                var metaParts = metadataNameOverride.Split('.');
+                if (metaParts.Length == parts.Length)
+                {
+                    var metaNamespacePart = string.Join(".", metaParts, 0, j);
+                    var metaNestedPart = string.Join("+", metaParts, j, metaParts.Length - j);
+                    candidateLookup = metaNamespacePart + "+" + metaNestedPart;
                 }
             }
+
+            var resolved = TryResolveViaCompilation(candidateName, candidateLookup, compilation, stripGenericParams);
+            if (resolved != null)
+            {
+                return resolved;
+            }
         }
 
-        // 3. Try as fully-qualified name first
+        return null;
+    }
+
+    /// <summary>
+    /// Tries to resolve a type name by attempting it as fully-qualified, then with each @using namespace prefix,
+    /// implicit namespaces, and the project's root namespace.
+    /// </summary>
+    private static string? TryResolveWithNamespaces(string typeName, string? metadataNameOverride, List<UsingDirective> usingDirectives, Compilation compilation, bool stripGenericParams, string? rootNamespace)
+    {
+        // Try as fully-qualified name
         var lookupName = metadataNameOverride ?? typeName;
         var result = TryResolveViaCompilation(typeName, lookupName, compilation, stripGenericParams);
         if (result != null)
@@ -183,12 +393,12 @@ internal static class ModelTypeResolver
             return result;
         }
 
-        // 4. Try with each @using namespace prefix
+        // Try with each @using namespace prefix
         foreach (var ud in usingDirectives)
         {
             if (ud.Alias != null)
             {
-                continue; // Skip aliases, handled above
+                continue;
             }
 
             var candidateName = ud.NamespaceOrType + "." + typeName;
@@ -203,7 +413,7 @@ internal static class ModelTypeResolver
             }
         }
 
-        // 5. Try with implicit namespaces (System, System.Collections.Generic, etc.)
+        // Try with implicit namespaces (System, System.Collections.Generic, etc.)
         foreach (var implicitNs in ImplicitNamespaces)
         {
             var candidateName = implicitNs + "." + typeName;
@@ -218,7 +428,7 @@ internal static class ModelTypeResolver
             }
         }
 
-        // 6. Try with the project's root namespace
+        // Try with the project's root namespace
         if (!string.IsNullOrEmpty(rootNamespace))
         {
             var candidateName = rootNamespace + "." + typeName;
@@ -261,6 +471,36 @@ internal static class ModelTypeResolver
         return null;
     }
 
+    private static INamedTypeSymbol? ResolveNamedTypeSymbol(string fullyQualifiedTypeName, Compilation compilation)
+    {
+        const string GlobalPrefix = "global::";
+
+        var metadataName = fullyQualifiedTypeName.StartsWith(GlobalPrefix, StringComparison.Ordinal)
+            ? fullyQualifiedTypeName.Substring(GlobalPrefix.Length)
+            : fullyQualifiedTypeName;
+
+        var symbol = compilation.GetTypeByMetadataName(metadataName);
+        if (symbol is not null)
+        {
+            return symbol;
+        }
+
+        var parts = metadataName.Split('.');
+        for (var j = parts.Length - 1; j > 0; j--)
+        {
+            var namespacePart = string.Join(".", parts, 0, j);
+            var nestedPart = string.Join("+", parts, j, parts.Length - j);
+            var candidateName = namespacePart + "+" + nestedPart;
+            symbol = compilation.GetTypeByMetadataName(candidateName);
+            if (symbol is not null)
+            {
+                return symbol;
+            }
+        }
+
+        return null;
+    }
+
     /// <summary>
     /// Splits generic arguments at the top level, respecting nested angle brackets.
     /// "int, List&lt;string&gt;" → ["int", "List&lt;string&gt;"]
@@ -268,7 +508,9 @@ internal static class ModelTypeResolver
     private static List<string> SplitGenericArguments(string args)
     {
         var result = new List<string>();
-        var depth = 0;
+        var angleDepth = 0;
+        var squareDepth = 0;
+        var parenDepth = 0;
         var start = 0;
 
         for (var i = 0; i < args.Length; i++)
@@ -276,13 +518,29 @@ private static List<string> SplitGenericArguments(string args)
             var c = args[i];
             if (c == '<')
             {
-                depth++;
+                angleDepth++;
             }
             else if (c == '>')
             {
-                depth--;
+                angleDepth--;
+            }
+            else if (c == '[')
+            {
+                squareDepth++;
+            }
+            else if (c == ']')
+            {
+                squareDepth--;
+            }
+            else if (c == '(')
+            {
+                parenDepth++;
+            }
+            else if (c == ')')
+            {
+                parenDepth--;
             }
-            else if (c == ',' && depth == 0)
+            else if (c == ',' && angleDepth == 0 && squareDepth == 0 && parenDepth == 0)
             {
                 result.Add(args.Substring(start, i - start));
                 start = i + 1;
diff --git a/razor-slices/src/SourceGenerator/PathUtils.cs b/razor-slices/src/SourceGenerator/PathUtils.cs
index be67e6ae..9ff195d1 100644
--- a/razor-slices/src/SourceGenerator/PathUtils.cs
+++ b/razor-slices/src/SourceGenerator/PathUtils.cs
@@ -1,6 +1,10 @@
 // Copyright (c) Duende Software. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
 
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
 // Adapted from https://github.com/dotnet/corefx/blob/master/src/Common/src/CoreLib/System/IO/Path.cs#L697
 // by Anton Krouglov
 
diff --git a/razor-slices/src/SourceGenerator/RazorDirectiveParser.cs b/razor-slices/src/SourceGenerator/RazorDirectiveParser.cs
index 4ae389f9..440e5b22 100644
--- a/razor-slices/src/SourceGenerator/RazorDirectiveParser.cs
+++ b/razor-slices/src/SourceGenerator/RazorDirectiveParser.cs
@@ -74,6 +74,27 @@ internal static List<UsingDirective> ParseUsingDirectives(SourceText sourceText)
         return usings;
     }
 
+    /// <summary>
+    /// Parses the @namespace directive value from the given source text.
+    /// Returns null if no @namespace directive is found.
+    /// </summary>
+    internal static string? ParseNamespaceDirective(SourceText sourceText)
+    {
+        foreach (var line in sourceText.Lines)
+        {
+            var lineText = line.ToString().TrimStart();
+            if (lineText.StartsWith("@namespace ", StringComparison.Ordinal))
+            {
+                var value = lineText.Substring("@namespace ".Length).Trim();
+                if (value.Length > 0)
+                {
+                    return value;
+                }
+            }
+        }
+        return null;
+    }
+
     /// <summary>
     /// Extracts the model type from a base type string.
     /// For example, "RazorSlice&lt;Models.Todo&gt;" returns "Models.Todo".
diff --git a/razor-slices/src/SourceGenerator/RazorSliceProxyGenerator.cs b/razor-slices/src/SourceGenerator/RazorSliceProxyGenerator.cs
index a13acacd..19a7fe18 100644
--- a/razor-slices/src/SourceGenerator/RazorSliceProxyGenerator.cs
+++ b/razor-slices/src/SourceGenerator/RazorSliceProxyGenerator.cs
@@ -21,13 +21,14 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         var projectDirectory = context.AnalyzerConfigOptionsProvider.Select(static (options, _) =>
             options.GlobalOptions.TryGetValue("build_property.MSBuildProjectDirectory", out var projectDir) ? projectDir : null);
 
-        var sealSliceProxies = context.AnalyzerConfigOptionsProvider.Select(static (options, _) =>
-            options.GlobalOptions.TryGetValue("build_property.RazorSliceProxiesSealed", out var sealSliceProxiesValue)
-                && bool.TryParse(sealSliceProxiesValue, out var result) && result);
+        var useRecords = context.AnalyzerConfigOptionsProvider.Select(static (options, _) =>
+            options.GlobalOptions.TryGetValue("build_property.RazorSliceProxiesAsRecords",
+                out var recordSliceProxiesValue)
+            && bool.TryParse(recordSliceProxiesValue, out var result) && result);
 
-        // (Left.Left          , (Left.Right.Left.Left     , (Left.Right.Right.Left, Left.Right.Right.Right))
-        // (string assemblyName, (string rootNamespace     , (string projectDirectory, bool sealSliceProxies))
-        var projectInfo = assemblyName.Combine(rootNamespace.Combine(projectDirectory.Combine(sealSliceProxies)));
+        // (Left.Left          , (Left.Right.Left.Left     , (Left.Right.Right.Left, Left.Right.Right.Right)))
+        // (string assemblyName, (string rootNamespace     , (string projectDirectory, bool useRecords)))
+        var projectInfo = assemblyName.Combine(rootNamespace.Combine(projectDirectory.Combine(useRecords)));
 
         // Collect all .cshtml files (both slices and _ViewImports)
         var allCshtmlFiles = context.AdditionalTextsProvider
@@ -80,7 +81,7 @@ private static void Execute(
         string? assemblyName,
         string? rootNamespace,
         string? projectDirectory,
-        bool sealSliceProxies,
+        bool useRecords,
         ImmutableArray<AdditionalText> sliceTexts,
         ImmutableArray<AdditionalText> allCshtmlFiles,
         Compilation compilation)
@@ -108,7 +109,6 @@ private static void Execute(
 
         codeBuilder.AppendLine("// <auto-generated/>");
         codeBuilder.AppendLine();
-        codeBuilder.AppendLine("using global::System.Diagnostics.CodeAnalysis;");
         codeBuilder.AppendLine("using global::Duende.RazorSlices;");
         codeBuilder.AppendLine();
         codeBuilder.AppendLine("#nullable enable");
@@ -164,36 +164,57 @@ private static void Execute(
                 string? resolvedModelType = null;
                 var hasModel = false;
 
+                var templateNameSpace = "AspNetCoreGeneratedDocument";
+
                 if (sourceText is not null)
                 {
                     var directives = ViewImportsResolver.ResolveDirectives(file.Path, projectDirectory!, viewImportsMap, sourceText);
 
                     if (directives.InheritsDirective is not null)
                     {
-                        var modelTypeName = RazorDirectiveParser.ExtractModelType(directives.InheritsDirective);
-                        if (modelTypeName is not null)
+                        var inheritsBaseTypeName = RazorDirectiveParser.ExtractBaseTypeName(directives.InheritsDirective);
+                        if (IsDirectRazorSliceBaseType(inheritsBaseTypeName))
+                        {
+                            var modelTypeName = RazorDirectiveParser.ExtractModelType(directives.InheritsDirective);
+                            if (modelTypeName is not null)
+                            {
+                                resolvedModelType = ModelTypeResolver.ResolveModelType(
+                                    modelTypeName, directives.UsingDirectives, compilation, rootNamespace);
+
+                                if (resolvedModelType is not null)
+                                {
+                                    hasModel = true;
+                                }
+                                else
+                                {
+                                    // Report diagnostic for unresolvable model type
+                                    var descriptor = new DiagnosticDescriptor(
+                                        "RSG0002",
+                                        "Unresolvable Model Type",
+                                        $"Could not resolve model type '{modelTypeName}' for slice '{relativeFilePath}'. The generated proxy will not have a strongly-typed Create method.",
+                                        "TypeResolution",
+                                        DiagnosticSeverity.Warning,
+                                        true);
+                                    context.ReportDiagnostic(Diagnostic.Create(descriptor, Location.None));
+                                }
+                            }
+                        }
+                        else
                         {
-                            resolvedModelType = ModelTypeResolver.ResolveModelType(
-                                modelTypeName, directives.UsingDirectives, compilation, rootNamespace);
+                            resolvedModelType = ModelTypeResolver.ResolveModelTypeFromSliceBaseType(
+                                directives.InheritsDirective, directives.UsingDirectives, compilation, rootNamespace);
 
                             if (resolvedModelType is not null)
                             {
                                 hasModel = true;
                             }
-                            else
-                            {
-                                // Report diagnostic for unresolvable model type
-                                var descriptor = new DiagnosticDescriptor(
-                                    "RSG0002",
-                                    "Unresolvable Model Type",
-                                    $"Could not resolve model type '{modelTypeName}' for slice '{relativeFilePath}'. The generated proxy will not have a strongly-typed Create method.",
-                                    "TypeResolution",
-                                    DiagnosticSeverity.Warning,
-                                    true);
-                                context.ReportDiagnostic(Diagnostic.Create(descriptor, Location.None));
-                            }
                         }
                     }
+
+                    if (directives.NamespaceDirective is not null)
+                    {
+                        templateNameSpace = directives.NamespaceDirective;
+                    }
                 }
 
                 codeBuilder.AppendLine($$"""
@@ -205,21 +226,17 @@ namespace {{fullNamespace}}
                     ? className
                     : $"{subNamespaceAsClassName}_{className}";
 
-                var sealedValue = sealSliceProxies ? "sealed " : "partial ";
+                var sliceTypeDeclaration = useRecords ? "record " : "class ";
                 var genericParameter = hasModel && resolvedModelType is not null ? $"<{resolvedModelType}>" : "";
 
+                var fullyQualifiedGeneratedTypeName = $"global::{templateNameSpace}.{generatedTypeName}";
+
                 codeBuilder.AppendLine($$"""
                         /// <summary>
                         /// Static proxy for the Razor Slice defined in <c>{{relativeFilePath}}</c>.
                         /// </summary>
-                        public {{sealedValue}}class {{className}} : global::Duende.RazorSlices.IRazorSliceProxy{{genericParameter}}
+                        public sealed partial {{sliceTypeDeclaration}}{{className}} : global::Duende.RazorSlices.IRazorSliceProxy{{genericParameter}}
                         {
-                            [global::System.Diagnostics.CodeAnalysis.DynamicDependency(global::System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All, TypeName, "{{assemblyName}}")]
-                            private const string TypeName = "AspNetCoreGeneratedDocument.{{generatedTypeName}}, {{assemblyName}}";
-                            [global::System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(global::System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)]
-                            private static readonly global::System.Type _sliceType = global::System.Type.GetType(TypeName)
-                                ?? throw new global::System.InvalidOperationException($"Razor view type '{TypeName}' was not found. This is likely a bug in the RazorSlices source generator.");
-                            private static readonly global::Duende.RazorSlices.SliceDefinition _sliceDefinition = new(_sliceType);
                     """);
 
                 if (hasModel && resolvedModelType is not null)
@@ -228,7 +245,8 @@ namespace {{fullNamespace}}
                             /// <summary>
                             /// Creates a new instance of the Razor Slice defined in <c>{{relativeFilePath}}</c> with the given model.
                             /// </summary>
-                            public static global::Duende.RazorSlices.RazorSlice<{{resolvedModelType}}> Create({{resolvedModelType}} model) => _sliceDefinition.CreateSlice<{{resolvedModelType}}>(model);
+                            public static global::Duende.RazorSlices.RazorSlice<{{resolvedModelType}}> Create({{resolvedModelType}} model) =>
+                                global::Duende.RazorSlices.RazorSliceFactory.Create(model, static model => new {{fullyQualifiedGeneratedTypeName}} { Model = model });
 
                             // Explicit interface implementation, workaround for https://github.com/dotnet/runtime/issues/102796
                             static global::Duende.RazorSlices.RazorSlice<{{resolvedModelType}}> global::Duende.RazorSlices.IRazorSliceProxy<{{resolvedModelType}}>.CreateSlice({{resolvedModelType}} model) => Create(model);
@@ -240,7 +258,8 @@ namespace {{fullNamespace}}
                             /// <summary>
                             /// Creates a new instance of the Razor Slice defined in <c>{{relativeFilePath}}</c>.
                             /// </summary>
-                            public static global::Duende.RazorSlices.RazorSlice Create() => _sliceDefinition.CreateSlice();
+                            public static global::Duende.RazorSlices.RazorSlice Create() =>
+                                global::Duende.RazorSlices.RazorSliceFactory.Create(static () => new {{fullyQualifiedGeneratedTypeName}}());
 
                             // Explicit interface implementation, workaround for https://github.com/dotnet/runtime/issues/102796
                             static global::Duende.RazorSlices.RazorSlice global::Duende.RazorSlices.IRazorSliceProxy.CreateSlice() => Create();
@@ -259,4 +278,9 @@ namespace {{fullNamespace}}
 
         context.AddSource($"{rootNamespace}.RazorSliceProxies.g.cs", SourceText.From(codeBuilder.ToString(), Encoding.UTF8));
     }
+
+    private static bool IsDirectRazorSliceBaseType(string baseTypeName) =>
+        string.Equals(baseTypeName, "RazorSlice", StringComparison.Ordinal) ||
+        string.Equals(baseTypeName, "Duende.RazorSlices.RazorSlice", StringComparison.Ordinal) ||
+        string.Equals(baseTypeName, "global::Duende.RazorSlices.RazorSlice", StringComparison.Ordinal);
 }
diff --git a/razor-slices/src/SourceGenerator/ViewImportsResolver.cs b/razor-slices/src/SourceGenerator/ViewImportsResolver.cs
index 83c0f48f..c4d289ba 100644
--- a/razor-slices/src/SourceGenerator/ViewImportsResolver.cs
+++ b/razor-slices/src/SourceGenerator/ViewImportsResolver.cs
@@ -44,8 +44,9 @@ internal static Dictionary<string, ViewImportsDirectives> BuildViewImportsMap(Im
 
             var inheritsDirective = RazorDirectiveParser.ParseInheritsDirective(sourceText);
             var usingDirectives = RazorDirectiveParser.ParseUsingDirectives(sourceText);
+            var namespaceDirective = RazorDirectiveParser.ParseNamespaceDirective(sourceText);
 
-            map[directory] = new ViewImportsDirectives(inheritsDirective, usingDirectives);
+            map[directory] = new ViewImportsDirectives(inheritsDirective, usingDirectives, namespaceDirective);
         }
 
         return map;
@@ -69,12 +70,13 @@ internal static ResolvedDirectives ResolveDirectives(
         // Parse the slice file's own directives
         var sliceInherits = RazorDirectiveParser.ParseInheritsDirective(sliceSourceText);
         var sliceUsings = RazorDirectiveParser.ParseUsingDirectives(sliceSourceText);
+        var sliceNamespace = RazorDirectiveParser.ParseNamespaceDirective(sliceSourceText);
 
         // Build the directory chain from project root down to the slice's directory
         var sliceDirectory = Path.GetDirectoryName(sliceFilePath);
         if (sliceDirectory is null)
         {
-            return new ResolvedDirectives(sliceInherits, sliceUsings);
+            return new ResolvedDirectives(sliceInherits, sliceUsings, sliceNamespace);
         }
 
         // Collect all _ViewImports directories from project root down to slice directory
@@ -83,6 +85,7 @@ internal static ResolvedDirectives ResolveDirectives(
         // Accumulate usings from outermost to innermost (parent first, child last)
         var accumulatedUsings = new List<UsingDirective>();
         string? effectiveInherits = null;
+        string? effectiveNamespace = null;
 
         foreach (var dir in directoryChain)
         {
@@ -95,6 +98,11 @@ internal static ResolvedDirectives ResolveDirectives(
                 {
                     effectiveInherits = directives.InheritsDirective;
                 }
+
+                if (directives.NamespaceDirective is not null)
+                {
+                    effectiveNamespace = directives.NamespaceDirective;
+                }
             }
         }
 
@@ -107,7 +115,12 @@ internal static ResolvedDirectives ResolveDirectives(
             effectiveInherits = sliceInherits;
         }
 
-        return new ResolvedDirectives(effectiveInherits, accumulatedUsings);
+        if (sliceNamespace is not null)
+        {
+            effectiveNamespace = sliceNamespace;
+        }
+
+        return new ResolvedDirectives(effectiveInherits, accumulatedUsings, effectiveNamespace);
     }
 
     /// <summary>
@@ -146,13 +159,15 @@ private static List<string> GetDirectoryChain(string targetDirectory, string pro
     private static string NormalizePath(string path) => path.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
 }
 
-internal readonly struct ViewImportsDirectives(string? inheritsDirective, List<UsingDirective> usingDirectives)
+internal readonly struct ViewImportsDirectives(string? inheritsDirective, List<UsingDirective> usingDirectives, string? namespaceDirective)
 {
     public string? InheritsDirective { get; } = inheritsDirective;
     public List<UsingDirective> UsingDirectives { get; } = usingDirectives;
+
+    public string? NamespaceDirective { get; } = namespaceDirective;
 }
 
-internal readonly struct ResolvedDirectives(string? inheritsDirective, List<UsingDirective> usingDirectives)
+internal readonly struct ResolvedDirectives(string? inheritsDirective, List<UsingDirective> usingDirectives, string? namespaceDirective)
 {
 
     /// <summary>
@@ -164,4 +179,9 @@ internal readonly struct ResolvedDirectives(string? inheritsDirective, List<Usin
     /// All accumulated @using directives from the _ViewImports hierarchy and the slice itself.
     /// </summary>
     public List<UsingDirective> UsingDirectives { get; } = usingDirectives;
+
+    /// <summary>
+    /// The effective @namespace directive value (from the slice or nearest _ViewImports).
+    /// </summary>
+    public string? NamespaceDirective { get; } = namespaceDirective;
 }
diff --git a/razor-slices/test/RazorSlices.Tests/RazorSliceFactoryTests.cs b/razor-slices/test/RazorSlices.Tests/RazorSliceFactoryTests.cs
new file mode 100644
index 00000000..33cd8574
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/RazorSliceFactoryTests.cs
@@ -0,0 +1,254 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.Runtime.CompilerServices;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Razor.Internal;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Duende.RazorSlices.Tests;
+
+public class RazorSliceFactoryTests
+{
+    [Fact]
+    public void Create_UsesDirectConstructorAndReturnsFreshInstances()
+    {
+        using var first = RazorSliceFactory.Create(static () => new ConstructorSlice("first"));
+        using var second = RazorSliceFactory.Create(static () => new ConstructorSlice("second"));
+
+        Assert.Equal("first", Assert.IsType<ConstructorSlice>(first).Value);
+        Assert.Equal("second", Assert.IsType<ConstructorSlice>(second).Value);
+        Assert.NotSame(first, second);
+        Assert.Null(first.Initialize);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("model")]
+    public void Create_AssignsModelInConstructorCallback(string? model)
+    {
+        using var slice = RazorSliceFactory.Create(model, static value => new ModelSlice { Model = value });
+
+        Assert.IsType<ModelSlice>(slice);
+        Assert.Equal(model, slice.Model);
+        Assert.Null(slice.Initialize);
+    }
+
+    [Fact]
+    public void Create_PreservesConstructorExceptions()
+    {
+        var exception = new InvalidOperationException("Constructor failed.");
+        var actual = Assert.Throws<InvalidOperationException>(
+            () => RazorSliceFactory.Create<ConstructorSlice>(() => throw exception));
+
+        Assert.Same(exception, actual);
+    }
+
+    [Fact]
+    public void Create_RejectsNullCallbacks()
+    {
+        Assert.Throws<ArgumentNullException>(() => RazorSliceFactory.Create<ConstructorSlice>(null!));
+        Assert.Throws<ArgumentNullException>(() => RazorSliceFactory.Create<ModelSlice, string?>(null, null!));
+    }
+
+    [Theory]
+    [InlineData(false, false)]
+    [InlineData(false, true)]
+    [InlineData(true, false)]
+    [InlineData(true, true)]
+    public async Task Injection_IsDeferredAndUsesExplicitServicesBeforeHttpContext(bool reflection, bool explicitServices)
+    {
+        var requestService = new TestService();
+        var explicitService = new TestService();
+        using var requestServices = new ServiceCollection().AddSingleton(requestService).BuildServiceProvider();
+        using var services = new ServiceCollection().AddSingleton(explicitService).BuildServiceProvider();
+        using var slice = CreateInjectableSlice(reflection);
+        slice.HttpContext = new DefaultHttpContext { RequestServices = requestServices };
+        if (explicitServices)
+        {
+            slice.ServiceProvider = services;
+        }
+
+        Assert.Null(slice.Service);
+        await slice.ExecuteAsyncImpl();
+
+        Assert.Same(explicitServices ? explicitService : requestService, slice.Service);
+        Assert.Null(slice.Optional);
+        Assert.Null(slice.OptionalValue);
+        Assert.Null(slice.MvcService);
+
+        using var emptyServices = new ServiceCollection().BuildServiceProvider();
+        slice.ServiceProvider = emptyServices;
+        await slice.ExecuteAsyncImpl();
+        Assert.Same(explicitServices ? explicitService : requestService, slice.Service);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task Injection_ResolvesOptionalServices(bool reflection)
+    {
+        var optional = new OptionalService();
+        using var services = new ServiceCollection()
+            .AddSingleton(new TestService())
+            .AddSingleton(optional)
+            .BuildServiceProvider();
+        using var slice = CreateInjectableSlice(reflection);
+        slice.ServiceProvider = services;
+
+        await slice.ExecuteAsyncImpl();
+
+        Assert.Same(optional, slice.Optional);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task Injection_ThrowsWithoutServiceProvider(bool reflection)
+    {
+        using var slice = CreateInjectableSlice(reflection);
+
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => slice.ExecuteAsyncImpl());
+
+        Assert.Contains("ServiceProvider property is null", exception.Message);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task Injection_ThrowsForMissingRequiredService(bool reflection)
+    {
+        using var services = new ServiceCollection().BuildServiceProvider();
+        using var slice = CreateInjectableSlice(reflection);
+        slice.ServiceProvider = services;
+
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => slice.ExecuteAsyncImpl());
+
+        Assert.Contains(nameof(TestService), exception.Message);
+    }
+
+    [Fact]
+    public async Task HotReload_ReplacesConstructionAndInjectionTogether()
+    {
+        var original = RazorSliceFactory.SliceCache<OriginalSlice>.Current;
+        try
+        {
+            using var before = RazorSliceFactory.Create(static () => new OriginalSlice());
+            RazorSliceFactory.SliceCache<OriginalSlice>.ReplaceSliceType([typeof(ReplacementSlice)]);
+            using var after = RazorSliceFactory.Create<OriginalSlice>(static () => throw new InvalidOperationException("Old constructor called."));
+            using var services = new ServiceCollection().AddSingleton(new TestService()).BuildServiceProvider();
+            after.ServiceProvider = services;
+            await after.ExecuteAsyncImpl();
+
+            Assert.IsType<OriginalSlice>(before);
+            Assert.Null(before.Initialize);
+            Assert.NotNull(Assert.IsType<ReplacementSlice>(after).Service);
+
+            RazorSliceFactory.SliceCache<OriginalSlice>.ReplaceSliceType([typeof(SecondReplacementSlice)]);
+            using var next = RazorSliceFactory.Create(static () => new OriginalSlice());
+            Assert.IsType<SecondReplacementSlice>(next);
+            Assert.Null(next.Initialize);
+        }
+        finally
+        {
+            RazorSliceFactory.SliceCache<OriginalSlice>.Current = original;
+        }
+    }
+
+    [Fact]
+    public void HotReload_PreservesModelOnReplacement()
+    {
+        var original = RazorSliceFactory.SliceCache<ModelSlice>.Current;
+        try
+        {
+            RazorSliceFactory.SliceCache<ModelSlice>.ReplaceSliceType([typeof(ReplacementModelSlice)]);
+            using var slice = RazorSliceFactory.Create<ModelSlice, string?>("updated", static value => new ModelSlice { Model = value });
+
+            Assert.IsType<ReplacementModelSlice>(slice);
+            Assert.Equal("updated", slice.Model);
+        }
+        finally
+        {
+            RazorSliceFactory.SliceCache<ModelSlice>.Current = original;
+        }
+    }
+
+    [Fact]
+    public void HotReload_IgnoresUnrelatedUpdates()
+    {
+        var original = RazorSliceFactory.SliceCache<ConstructorSlice>.Current;
+
+        RazorSliceFactory.SliceCache<ConstructorSlice>.ReplaceSliceType(null);
+        RazorSliceFactory.SliceCache<ConstructorSlice>.ReplaceSliceType([typeof(ReplacementSlice)]);
+
+        Assert.Same(original, RazorSliceFactory.SliceCache<ConstructorSlice>.Current);
+    }
+
+    private static InjectableSlice CreateInjectableSlice(bool reflection)
+    {
+        var slice = (InjectableSlice)RazorSliceFactory.Create(static () => new InjectableSlice());
+        if (reflection)
+        {
+            slice.Initialize = RazorSliceFactory.GetReflectionInitAction(
+                typeof(InjectableSlice), RazorSliceFactory.GetInjectableProperties(typeof(InjectableSlice)));
+        }
+        return slice;
+    }
+
+    public sealed class ConstructorSlice(string value) : RazorSlice
+    {
+        public string Value { get; } = value;
+        public override Task ExecuteAsync() => Task.CompletedTask;
+    }
+
+    public sealed class ModelSlice : RazorSlice<string?>
+    {
+        public override Task ExecuteAsync() => Task.CompletedTask;
+    }
+
+    public abstract class InjectableBaseSlice : RazorSlice
+    {
+        [RazorInject]
+        public TestService Service { get; set; } = null!;
+    }
+
+    public sealed class InjectableSlice : InjectableBaseSlice
+    {
+        [RazorInject]
+        public OptionalService? Optional { get; set; }
+
+        [RazorInject]
+        public int? OptionalValue { get; set; }
+
+        [RazorInject]
+        public Microsoft.AspNetCore.Mvc.IUrlHelper MvcService { get; set; } = null!;
+
+        public override Task ExecuteAsync() => Task.CompletedTask;
+    }
+
+    public sealed class TestService;
+    public sealed class OptionalService;
+
+    public sealed class OriginalSlice : RazorSlice
+    {
+        public override Task ExecuteAsync() => Task.CompletedTask;
+    }
+
+    [MetadataUpdateOriginalType(typeof(OriginalSlice))]
+    public sealed class ReplacementSlice : InjectableBaseSlice
+    {
+        public override Task ExecuteAsync() => Task.CompletedTask;
+    }
+
+    [MetadataUpdateOriginalType(typeof(OriginalSlice))]
+    public sealed class SecondReplacementSlice : RazorSlice
+    {
+        public override Task ExecuteAsync() => Task.CompletedTask;
+    }
+
+    [MetadataUpdateOriginalType(typeof(ModelSlice))]
+    public sealed class ReplacementModelSlice : RazorSlice<string?>
+    {
+        public override Task ExecuteAsync() => Task.CompletedTask;
+    }
+}
diff --git a/razor-slices/test/RazorSlices.Tests/RazorSliceHtmlAttributesTests.cs b/razor-slices/test/RazorSlices.Tests/RazorSliceHtmlAttributesTests.cs
new file mode 100644
index 00000000..2365a8dd
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/RazorSliceHtmlAttributesTests.cs
@@ -0,0 +1,39 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace Duende.RazorSlices.Tests;
+
+public class RazorSliceHtmlAttributesTests
+{
+    [Theory]
+    [InlineData(true, " checked=\"checked\"")]
+    [InlineData(false, "")]
+    public async Task ObjectTypedBoolean_RendersConditionalAttribute(bool value, string expected)
+    {
+        var slice = new ObjectAttributeSlice("checked", value);
+
+        Assert.Equal(expected, await slice.RenderAsync());
+    }
+
+    [Theory]
+    [InlineData(null, "")]
+    [InlineData("", " class=\"\"")]
+    [InlineData("active", " class=\"active\"")]
+    public async Task ObjectTypedString_RendersConditionalAttribute(string? value, string expected)
+    {
+        var slice = new ObjectAttributeSlice("class", value);
+
+        Assert.Equal(expected, await slice.RenderAsync());
+    }
+
+    private sealed class ObjectAttributeSlice(string name, object? value) : RazorSlice
+    {
+        public override Task ExecuteAsync()
+        {
+            BeginWriteAttribute(name, $" {name}=\"", 0, "\"", 0, 1);
+            WriteAttributeValue("", 0, value, 0, 0, false);
+            EndWriteAttribute();
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/razor-slices/test/RazorSlices.Tests/RazorSliceIResultTests.cs b/razor-slices/test/RazorSlices.Tests/RazorSliceIResultTests.cs
new file mode 100644
index 00000000..d7f31824
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/RazorSliceIResultTests.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Http;
+
+namespace Duende.RazorSlices.Tests;
+
+public class RazorSliceIResultTests
+{
+    [Fact]
+    public async Task ExecuteAsync_UsesDefaultHtmlContentType()
+    {
+        var slice = new TestSlice
+        {
+            HtmlEncoder = HtmlEncoder.Default
+        };
+        var httpContext = CreateHttpContext();
+
+        await ((IResult)slice).ExecuteAsync(httpContext);
+
+        Assert.Equal("text/html; charset=utf-8", httpContext.Response.ContentType);
+    }
+
+    [Fact]
+    public async Task ExecuteAsync_UsesOverriddenContentType()
+    {
+        var slice = new TestSlice
+        {
+            ContentType = "application/xml; charset=utf-8",
+            HtmlEncoder = HtmlEncoder.Default
+        };
+        var httpContext = CreateHttpContext();
+
+        await ((IResult)slice).ExecuteAsync(httpContext);
+
+        Assert.Equal("application/xml; charset=utf-8", httpContext.Response.ContentType);
+    }
+
+    private static HttpContext CreateHttpContext()
+    {
+        var httpContext = new DefaultHttpContext();
+        httpContext.Response.Body = new MemoryStream();
+        return httpContext;
+    }
+
+    private sealed class TestSlice : RazorSlice
+    {
+        public override Task ExecuteAsync() => Task.CompletedTask;
+    }
+}
diff --git a/razor-slices/test/RazorSlices.Tests/RazorSliceUtf8LiteralTests.cs b/razor-slices/test/RazorSlices.Tests/RazorSliceUtf8LiteralTests.cs
new file mode 100644
index 00000000..2a3197fd
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/RazorSliceUtf8LiteralTests.cs
@@ -0,0 +1,48 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.IO.Pipelines;
+using System.Text;
+
+namespace Duende.RazorSlices.Tests;
+
+public class RazorSliceUtf8LiteralTests
+{
+    private const string ExpectedMarkup = "<p>hello</p><p>héllo wörld ✓</p>";
+
+    [Fact]
+    public async Task RenderAsync_TextWriter_WritesUtf8LiteralsAsText()
+    {
+        // The Razor compiler in .NET SDK 10.0.400+ emits WriteLiteral(ReadOnlySpan<byte>) with "..."u8 literals,
+        // so static markup takes this path regardless of which SDK compiled the template.
+        var slice = new Utf8LiteralSlice();
+        using var writer = new StringWriter();
+
+        await slice.RenderAsync(writer);
+
+        writer.ToString().ShouldBe(ExpectedMarkup);
+    }
+
+    [Fact]
+    public async Task RenderAsync_PipeWriter_WritesUtf8LiteralsAsText()
+    {
+        var slice = new Utf8LiteralSlice();
+        using var stream = new MemoryStream();
+        var pipeWriter = PipeWriter.Create(stream);
+
+        await slice.RenderAsync(pipeWriter);
+        await pipeWriter.FlushAsync();
+
+        Encoding.UTF8.GetString(stream.ToArray()).ShouldBe(ExpectedMarkup);
+    }
+
+    private sealed class Utf8LiteralSlice : RazorSlice
+    {
+        public override Task ExecuteAsync()
+        {
+            WriteLiteral("<p>hello</p>"u8);
+            WriteLiteral("<p>héllo wörld ✓</p>"u8);
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/razor-slices/test/RazorSlices.Tests/RazorSliceWriteHtmlTests.cs b/razor-slices/test/RazorSlices.Tests/RazorSliceWriteHtmlTests.cs
new file mode 100644
index 00000000..78777155
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/RazorSliceWriteHtmlTests.cs
@@ -0,0 +1,62 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.IO.Pipelines;
+using System.Text;
+using System.Text.Encodings.Web;
+
+namespace Duende.RazorSlices.Tests;
+
+public class RazorSliceWriteHtmlTests
+{
+    [Fact]
+    public async Task WriteHtmlString_WritesRawHtmlToTextWriter()
+    {
+        var writer = new StringWriter();
+        var slice = new WriteHtmlStringSlice("<span>&</span>");
+
+        await slice.RenderAsync(writer, HtmlEncoder.Default);
+
+        Assert.Equal("<span>&</span>", writer.ToString());
+    }
+
+    [Fact]
+    public async Task WriteHtmlString_WritesRawHtmlToPipeWriter()
+    {
+        using var stream = new MemoryStream();
+        var pipeWriter = PipeWriter.Create(stream);
+        var slice = new WriteHtmlStringSlice("<span>&</span>");
+
+        await slice.RenderAsync(pipeWriter, HtmlEncoder.Default);
+        await pipeWriter.FlushAsync();
+        await pipeWriter.CompleteAsync();
+
+        Assert.Equal("<span>&</span>", Encoding.UTF8.GetString(stream.ToArray()));
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    public async Task WriteHtmlString_DoesNotWriteNullOrEmptyString(string? html)
+    {
+        var writer = new StringWriter();
+        var slice = new WriteHtmlStringSlice(html);
+
+        await slice.RenderAsync(writer, HtmlEncoder.Default);
+
+        Assert.Equal("", writer.ToString());
+    }
+
+    private sealed class WriteHtmlStringSlice : RazorSlice
+    {
+        private readonly string? _html;
+
+        public WriteHtmlStringSlice(string? html) => _html = html;
+
+        public override Task ExecuteAsync()
+        {
+            WriteHtml(_html);
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/razor-slices/test/RazorSlices.Tests/RazorSliceWriteTests.cs b/razor-slices/test/RazorSlices.Tests/RazorSliceWriteTests.cs
new file mode 100644
index 00000000..385b2c45
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/RazorSliceWriteTests.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.Text;
+using System.Text.Encodings.Web;
+using System.Text.Unicode;
+
+namespace Duende.RazorSlices.Tests;
+
+public class RazorSliceWriteTests
+{
+    [Fact]
+    public async Task WriteReadOnlyMemoryByte_WritesHtmlEncodedUtf8Text()
+    {
+        var value = new ReadOnlyMemory<byte>(Encoding.UTF8.GetBytes("Héllo <Wörld> 日本語"));
+        var slice = new WriteReadOnlyMemoryByteSlice(value);
+
+        var result = await slice.RenderAsync(HtmlEncoder.Create(UnicodeRanges.All));
+
+        Assert.Equal("Héllo &lt;Wörld&gt; 日本語", result);
+    }
+
+    private sealed class WriteReadOnlyMemoryByteSlice(ReadOnlyMemory<byte> value) : RazorSlice
+    {
+        public override Task ExecuteAsync()
+        {
+            Write(value);
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsTests.cs b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsTests.cs
new file mode 100644
index 00000000..33f597fd
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsTests.cs
@@ -0,0 +1,213 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.Text;
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace Duende.RazorSlices.Tests;
+
+public class TextWriterHtmlExtensionsTests
+{
+    [Fact]
+    public void WriteUtf8_WritesAsciiTextCorrectly()
+    {
+        var writer = new StringWriter();
+        var utf8Bytes = Encoding.UTF8.GetBytes("Hello, World!");
+
+        writer.WriteUtf8(utf8Bytes);
+
+        Assert.Equal("Hello, World!", writer.ToString());
+    }
+
+    [Fact]
+    public void WriteUtf8_WritesMultiByteUtf8TextCorrectly()
+    {
+        var writer = new StringWriter();
+        var text = "Héllo, Wörld! 日本語 🎉";
+        var utf8Bytes = Encoding.UTF8.GetBytes(text);
+
+        writer.WriteUtf8(utf8Bytes);
+
+        Assert.Equal(text, writer.ToString());
+    }
+
+    [Fact]
+    public void WriteUtf8_WritesEmptySpanCorrectly()
+    {
+        var writer = new StringWriter();
+
+        writer.WriteUtf8(ReadOnlySpan<byte>.Empty);
+
+        Assert.Equal("", writer.ToString());
+    }
+
+    [Fact]
+    public void WriteUtf8_WritesHtmlCharsWithoutEncoding()
+    {
+        var writer = new StringWriter();
+        var text = "<div class=\"test\">&amp;</div>";
+        var utf8Bytes = Encoding.UTF8.GetBytes(text);
+
+        writer.WriteUtf8(utf8Bytes);
+
+        Assert.Equal(text, writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteUtf8_EncodesHtmlCharacters()
+    {
+        var writer = new StringWriter();
+        var utf8Bytes = Encoding.UTF8.GetBytes("<script>alert('xss')</script>");
+
+        writer.HtmlEncodeAndWriteUtf8(utf8Bytes, HtmlEncoder.Default);
+
+        Assert.Equal("&lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;", writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteUtf8_WritesTextThatRequiresNoEncoding()
+    {
+        var writer = new StringWriter();
+        var text = "Hello, World!";
+        var utf8Bytes = Encoding.UTF8.GetBytes(text);
+
+        writer.HtmlEncodeAndWriteUtf8(utf8Bytes, HtmlEncoder.Default);
+
+        Assert.Equal(text, writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteUtf8_DoesNotEncodeWithNullEncoder()
+    {
+        var writer = new StringWriter();
+        var text = "Hello, <World>!";
+        var utf8Bytes = Encoding.UTF8.GetBytes(text);
+
+        writer.HtmlEncodeAndWriteUtf8(utf8Bytes, NullHtmlEncoder.Default);
+
+        Assert.Equal(text, writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteUtf8_HandlesMultiByteUtf8Characters()
+    {
+        var writer = new StringWriter();
+        var text = "Héllo <Wörld> 日本語";
+        var utf8Bytes = Encoding.UTF8.GetBytes(text);
+
+        writer.HtmlEncodeAndWriteUtf8(utf8Bytes, HtmlEncoder.Default);
+
+        var result = writer.ToString();
+        Assert.Contains("&lt;", result);
+        Assert.Contains("&gt;", result);
+        Assert.Contains("H&#xE9;llo", result);
+    }
+
+    [Fact]
+    public void WriteUtf8_WritesLargeUtf8TextCorrectly()
+    {
+        var writer = new StringWriter();
+        var text = new string('a', 10_000) + "日本語" + new string('b', 10_000);
+        var utf8Bytes = Encoding.UTF8.GetBytes(text);
+
+        writer.WriteUtf8(utf8Bytes);
+
+        Assert.Equal(text, writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteUtf8_EncodesLargeUtf8Text()
+    {
+        var writer = new StringWriter();
+        var text = new string('<', 1_000);
+        var utf8Bytes = Encoding.UTF8.GetBytes(text);
+
+        writer.HtmlEncodeAndWriteUtf8(utf8Bytes, HtmlEncoder.Default);
+
+        var expected = string.Concat(Enumerable.Repeat("&lt;", 1_000));
+        Assert.Equal(expected, writer.ToString());
+    }
+
+    private enum SampleStatus
+    {
+        Open = 0,
+        Posted = 1
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_WritesOnlyTheFormattedChars_Enum()
+    {
+        var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteSpanFormattable(SampleStatus.Open, HtmlEncoder.Default);
+
+        Assert.Equal("Open", writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_WritesOnlyTheFormattedChars_Int()
+    {
+        var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteSpanFormattable(42, HtmlEncoder.Default);
+
+        Assert.Equal("42", writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_DoesNotWriteBufferPadding()
+    {
+        // The rented encode buffer comes from ArrayPool<char>.Shared, whose smallest bucket is 16.
+        // Writing the whole buffer instead of the encoded length appended 12 chars of whatever the
+        // previous renter left behind.
+        var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteSpanFormattable(SampleStatus.Open, HtmlEncoder.Default);
+
+        Assert.Equal(4, writer.ToString().Length);
+        Assert.DoesNotContain('\0', writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_DoesNotLeakPreviousRenterContent()
+    {
+        // Dirty the shared pool with a long value first, then write a short one. Without the fix
+        // the short write carried the tail of the long one into the output.
+        var warmup = new StringWriter();
+        warmup.HtmlEncodeAndWriteSpanFormattable(1234567890123456789L, HtmlEncoder.Default);
+
+        var writer = new StringWriter();
+        writer.HtmlEncodeAndWriteSpanFormattable(SampleStatus.Posted, HtmlEncoder.Default);
+
+        Assert.Equal("Posted", writer.ToString());
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_StillEncodesHtml()
+    {
+        var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteSpanFormattable(new HtmlishFormattable(), HtmlEncoder.Default);
+
+        Assert.Equal("a&lt;b&gt;c", writer.ToString());
+    }
+
+    private readonly struct HtmlishFormattable : ISpanFormattable
+    {
+        public string ToString(string? format, IFormatProvider? formatProvider) => "a<b>c";
+
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            const string value = "a<b>c";
+            if (destination.Length < value.Length)
+            {
+                charsWritten = 0;
+                return false;
+            }
+            value.AsSpan().CopyTo(destination);
+            charsWritten = value.Length;
+            return true;
+        }
+    }
+}
diff --git a/razor-slices/test/RazorSlices.Tests/TextWriterHtmlWritingTests.cs b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlWritingTests.cs
deleted file mode 100644
index 7c20fb95..00000000
--- a/razor-slices/test/RazorSlices.Tests/TextWriterHtmlWritingTests.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright (c) Duende Software. All rights reserved.
-// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
-
-using System.Text.Encodings.Web;
-
-namespace Duende.RazorSlices.Tests;
-
-public class TextWriterHtmlWritingTests
-{
-    [Fact]
-    public async Task RenderAsync_TextWriter_WritesUtf8LiteralsAsText()
-    {
-        // The Razor compiler in .NET SDK 10.0.400+ emits WriteLiteral(ReadOnlySpan<byte>) with "..."u8 literals,
-        // so static markup takes this path regardless of which SDK compiled the template.
-        var slice = new Utf8LiteralSlice();
-        using var writer = new StringWriter();
-
-        await slice.RenderAsync(writer);
-
-        writer.ToString().ShouldBe("<p>hello</p><p>héllo wörld ✓</p>");
-    }
-
-    [Fact]
-    public async Task RenderAsync_PipeWriter_WritesUtf8LiteralsAsText()
-    {
-        var slice = new Utf8LiteralSlice();
-        using var stream = new MemoryStream();
-        var pipeWriter = System.IO.Pipelines.PipeWriter.Create(stream);
-
-        await slice.RenderAsync(pipeWriter);
-        await pipeWriter.FlushAsync();
-
-        System.Text.Encoding.UTF8.GetString(stream.ToArray()).ShouldBe("<p>hello</p><p>héllo wörld ✓</p>");
-    }
-
-    [Fact]
-    public void WriteUtf8_DecodesAsUtf8()
-    {
-        using var writer = new StringWriter();
-
-        writer.WriteUtf8("<p>héllo wörld ✓</p>"u8);
-
-        writer.ToString().ShouldBe("<p>héllo wörld ✓</p>");
-    }
-
-    [Fact]
-    public void HtmlEncodeAndWriteUtf8_DecodesAsUtf8AndEncodesHtml()
-    {
-        using var writer = new StringWriter();
-
-        writer.HtmlEncodeAndWriteUtf8("<p>héllo</p>"u8, HtmlEncoder.Default);
-
-        writer.ToString().ShouldBe("&lt;p&gt;h&#xE9;llo&lt;/p&gt;");
-    }
-
-    [Fact]
-    public void HtmlEncodeAndWriteSpanFormattable_WritesOnlyTheFormattedChars()
-    {
-        using var writer = new StringWriter();
-
-        writer.HtmlEncodeAndWriteSpanFormattable(SampleStatus.Open, HtmlEncoder.Default);
-
-        writer.ToString().ShouldBe("Open");
-    }
-
-    [Fact]
-    public void HtmlEncodeAndWriteSpanFormattable_DoesNotLeakPreviousRenterContent()
-    {
-        // Dirty the shared pool with a long value first, then write a short one. Without slicing to the
-        // encoded length the short write carries the tail of the long one into the output.
-        using var warmup = new StringWriter();
-        warmup.HtmlEncodeAndWriteSpanFormattable(1234567890123456789L, HtmlEncoder.Default);
-
-        using var writer = new StringWriter();
-        writer.HtmlEncodeAndWriteSpanFormattable(SampleStatus.Posted, HtmlEncoder.Default);
-
-        writer.ToString().ShouldBe("Posted");
-    }
-
-    [Fact]
-    public void HtmlEncodeAndWriteSpanFormattable_EncodesHtmlOnSmallPath()
-    {
-        using var writer = new StringWriter();
-
-        writer.HtmlEncodeAndWriteSpanFormattable(new HtmlishFormattable(), HtmlEncoder.Default);
-
-        writer.ToString().ShouldBe("a&lt;b&gt;c");
-    }
-
-    private sealed class Utf8LiteralSlice : RazorSlice
-    {
-        public override Task ExecuteAsync()
-        {
-            WriteLiteral("<p>hello</p>"u8);
-            WriteLiteral("<p>héllo wörld ✓</p>"u8);
-            return Task.CompletedTask;
-        }
-    }
-
-    private enum SampleStatus
-    {
-        Open = 0,
-        Posted = 1
-    }
-
-    private readonly struct HtmlishFormattable : ISpanFormattable
-    {
-        private const string Value = "a<b>c";
-
-        public string ToString(string? format, IFormatProvider? formatProvider) => Value;
-
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            if (destination.Length < Value.Length)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            Value.AsSpan().CopyTo(destination);
-            charsWritten = Value.Length;
-            return true;
-        }
-    }
-}
diff --git a/razor-slices/test/SourceGenerator.Tests/ModelTypeResolverTests.cs b/razor-slices/test/SourceGenerator.Tests/ModelTypeResolverTests.cs
new file mode 100644
index 00000000..1ad2c972
--- /dev/null
+++ b/razor-slices/test/SourceGenerator.Tests/ModelTypeResolverTests.cs
@@ -0,0 +1,442 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Duende.RazorSlices.SourceGenerator.Tests;
+
+public class ModelTypeResolverTests
+{
+    private static readonly CSharpCompilation TestCompilation = CreateTestCompilation();
+
+    private static CSharpCompilation CreateTestCompilation()
+    {
+        var source = @"
+namespace TestNs
+{
+    public class TodoModel { }
+
+    public abstract class DirectTodoSliceBase : Duende.RazorSlices.RazorSlice<TodoModel> { }
+
+    public abstract class GenericTodoSliceBase<TModel> : Duende.RazorSlices.RazorSlice<TModel> { }
+
+    public abstract class DeepGenericTodoSliceBase<TModel> : GenericTodoSliceBase<TModel> { }
+
+    public abstract class DeepConcreteTodoSliceBase : DeepGenericTodoSliceBase<TodoModel[]> { }
+
+    public abstract class NoModelSliceBase : Duende.RazorSlices.RazorSlice { }
+
+    public abstract class MultiArgMappedSliceBase<TThing, TModel> : Duende.RazorSlices.RazorSlice<TModel> { }
+
+    public abstract class MultiArgMappedFirstSliceBase<TModel, TThing> : Duende.RazorSlices.RazorSlice<TModel> { }
+
+    public abstract class NonModelMappedSliceBase<TThing> : Duende.RazorSlices.RazorSlice<TodoModel> { }
+
+    public class Outer
+    {
+        public class Inner { }
+
+        public class Middle
+        {
+            public class Deep { }
+        }
+
+        public class GenericInner<T> { }
+
+        public class MultiGenericInner<T, U> { }
+    }
+
+    public struct ValueOuter
+    {
+        public struct ValueInner { }
+    }
+
+    public class _Odd_Name
+    {
+        public class _Inner_Type { }
+    }
+
+    public class Container123
+    {
+        public class Item456 { }
+    }
+}
+
+namespace AliasNs
+{
+    public class Host
+    {
+        public class Nested { }
+
+        public class Level2
+        {
+            public class Level3 { }
+        }
+
+        public class GenericNested<T> { }
+    }
+}
+
+namespace RootNs
+{
+    public class Parent
+    {
+        public class Child { }
+    }
+}
+
+namespace Duende.RazorSlices
+{
+    public abstract class RazorSlice { }
+
+    public abstract class RazorSlice<TModel> : RazorSlice { }
+}
+";
+        var syntaxTree = CSharpSyntaxTree.ParseText(source);
+        var runtimeDir = Path.GetDirectoryName(typeof(object).Assembly.Location)!;
+        var references = new MetadataReference[]
+        {
+            MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
+            MetadataReference.CreateFromFile(Path.Combine(runtimeDir, "System.Runtime.dll")),
+        };
+
+        var compilation = CSharpCompilation.Create(
+            "TestAssembly",
+            [syntaxTree],
+            references,
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+        // Verify compilation has no errors
+        var diagnostics = compilation.GetDiagnostics();
+        var errors = diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error).ToList();
+        if (errors.Count > 0)
+        {
+            throw new InvalidOperationException(
+                "Test compilation has errors: " + string.Join(", ", errors.Select(e => e.GetMessage())));
+        }
+
+        return compilation;
+    }
+
+    private static string? Resolve(
+        string modelTypeName,
+        List<UsingDirective>? usings = null,
+        string? rootNamespace = null) => ModelTypeResolver.ResolveModelType(
+            modelTypeName,
+            usings ?? [],
+            TestCompilation,
+            rootNamespace);
+
+    private static string? ResolveFromSliceBaseType(
+        string baseTypeName,
+        List<UsingDirective>? usings = null,
+        string? rootNamespace = null) => ModelTypeResolver.ResolveModelTypeFromSliceBaseType(
+            baseTypeName,
+            usings ?? [],
+            TestCompilation,
+            rootNamespace);
+
+    // ===== Basic nested type resolution via @using namespace =====
+
+    [Fact]
+    public void NestedType_ResolvedViaUsing()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer.Inner", usings);
+        Assert.Equal("global::TestNs.Outer.Inner", result);
+    }
+
+    [Fact]
+    public void NestedType_ThreeLevels_ResolvedViaUsing()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer.Middle.Deep", usings);
+        Assert.Equal("global::TestNs.Outer.Middle.Deep", result);
+    }
+
+    [Fact]
+    public void NestedValueType_ResolvedViaUsing()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("ValueOuter.ValueInner", usings);
+        Assert.Equal("global::TestNs.ValueOuter.ValueInner", result);
+    }
+
+    // ===== Nested type resolution via fully-qualified name =====
+
+    [Fact]
+    public void NestedType_FullyQualified()
+    {
+        var result = Resolve("TestNs.Outer.Inner");
+        Assert.Equal("global::TestNs.Outer.Inner", result);
+    }
+
+    [Fact]
+    public void NestedType_ThreeLevels_FullyQualified()
+    {
+        var result = Resolve("TestNs.Outer.Middle.Deep");
+        Assert.Equal("global::TestNs.Outer.Middle.Deep", result);
+    }
+
+    // ===== Nested type resolution via root namespace =====
+
+    [Fact]
+    public void NestedType_ResolvedViaRootNamespace()
+    {
+        var result = Resolve("Parent.Child", rootNamespace: "RootNs");
+        Assert.Equal("global::RootNs.Parent.Child", result);
+    }
+
+    // ===== Nested type resolution via using alias =====
+
+    [Fact]
+    public void NestedType_ResolvedViaAlias()
+    {
+        var usings = new List<UsingDirective> { new("AliasNs", "M") };
+        var result = Resolve("M.Host.Nested", usings);
+        Assert.Equal("global::AliasNs.Host.Nested", result);
+    }
+
+    [Fact]
+    public void NestedType_ThreeLevels_ResolvedViaAlias()
+    {
+        var usings = new List<UsingDirective> { new("AliasNs", "M") };
+        var result = Resolve("M.Host.Level2.Level3", usings);
+        Assert.Equal("global::AliasNs.Host.Level2.Level3", result);
+    }
+
+    [Fact]
+    public void NestedType_AliasOnly_NoMatchingNamespaceUsing()
+    {
+        // Only an alias, no non-alias @using that could find the type via namespace prefixing
+        var usings = new List<UsingDirective> { new("AliasNs", "Models") };
+        var result = Resolve("Models.Host.Nested", usings);
+        Assert.Equal("global::AliasNs.Host.Nested", result);
+    }
+
+    // ===== Nested types with generics =====
+
+    [Fact]
+    public void NestedGenericType_ResolvedViaUsing()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer.GenericInner<string>", usings);
+        Assert.Equal("global::TestNs.Outer.GenericInner<global::System.String>", result);
+    }
+
+    [Fact]
+    public void NestedGenericType_MultipleTypeArgs()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer.MultiGenericInner<string, int>", usings);
+        Assert.Equal("global::TestNs.Outer.MultiGenericInner<global::System.String, global::System.Int32>", result);
+    }
+
+    [Fact]
+    public void NestedType_AsGenericArgument()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("List<Outer.Inner>", usings);
+        Assert.Equal("global::System.Collections.Generic.List<global::TestNs.Outer.Inner>", result);
+    }
+
+    [Fact]
+    public void NestedType_AsMultipleGenericArguments()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Dictionary<string, Outer.Inner>", usings);
+        Assert.Equal("global::System.Collections.Generic.Dictionary<global::System.String, global::TestNs.Outer.Inner>", result);
+    }
+
+    [Fact]
+    public void NestedType_BothGenericArgsAreNested()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Dictionary<Outer.Inner, Outer.Middle.Deep>", usings);
+        Assert.Equal("global::System.Collections.Generic.Dictionary<global::TestNs.Outer.Inner, global::TestNs.Outer.Middle.Deep>", result);
+    }
+
+    [Fact]
+    public void NestedGenericType_ViaAlias()
+    {
+        var usings = new List<UsingDirective> { new("AliasNs", "M") };
+        var result = Resolve("M.Host.GenericNested<string>", usings);
+        Assert.Equal("global::AliasNs.Host.GenericNested<global::System.String>", result);
+    }
+
+    [Fact]
+    public void NestedType_AsGenericArgViaAlias()
+    {
+        var usings = new List<UsingDirective> { new("AliasNs", "M") };
+        var result = Resolve("List<M.Host.Nested>", usings);
+        Assert.Equal("global::System.Collections.Generic.List<global::AliasNs.Host.Nested>", result);
+    }
+
+    // ===== Nested types with arrays =====
+
+    [Fact]
+    public void NestedType_Array()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer.Inner[]", usings);
+        Assert.Equal("global::TestNs.Outer.Inner[]", result);
+    }
+
+    [Fact]
+    public void NestedType_MultiDimensionalArray()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer.Inner[,]", usings);
+        Assert.Equal("global::TestNs.Outer.Inner[,]", result);
+    }
+
+    [Fact]
+    public void NestedType_JaggedArray()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer.Inner[][]", usings);
+        Assert.Equal("global::TestNs.Outer.Inner[][]", result);
+    }
+
+    // ===== Nested types with nullable =====
+
+    [Fact]
+    public void NestedValueType_Nullable()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("ValueOuter.ValueInner?", usings);
+        Assert.Equal("global::TestNs.ValueOuter.ValueInner?", result);
+    }
+
+    // ===== Odd but valid identifiers =====
+
+    [Fact]
+    public void NestedType_UnderscoreIdentifiers()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("_Odd_Name._Inner_Type", usings);
+        Assert.Equal("global::TestNs._Odd_Name._Inner_Type", result);
+    }
+
+    [Fact]
+    public void NestedType_NumericSuffixIdentifiers()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Container123.Item456", usings);
+        Assert.Equal("global::TestNs.Container123.Item456", result);
+    }
+
+    // ===== Negative tests =====
+
+    [Fact]
+    public void NestedType_NonExistent_ReturnsNull()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer.DoesNotExist", usings);
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void NestedType_WrongNamespace_ReturnsNull()
+    {
+        var usings = new List<UsingDirective> { new("WrongNamespace", null) };
+        var result = Resolve("Outer.Inner", usings);
+        Assert.Null(result);
+    }
+
+    // ===== Regression tests: non-nested types still work =====
+
+    [Fact]
+    public void NonNestedType_ResolvedViaUsing()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = Resolve("Outer", usings);
+        Assert.Equal("global::TestNs.Outer", result);
+    }
+
+    [Fact]
+    public void NonNestedType_Primitive()
+    {
+        var result = Resolve("string");
+        Assert.Equal("global::System.String", result);
+    }
+
+    [Fact]
+    public void NonNestedType_FullyQualified()
+    {
+        var result = Resolve("TestNs.Outer");
+        Assert.Equal("global::TestNs.Outer", result);
+    }
+
+    [Fact]
+    public void NonNestedType_GenericWithPrimitive()
+    {
+        var result = Resolve("List<string>");
+        Assert.Equal("global::System.Collections.Generic.List<global::System.String>", result);
+    }
+
+    [Fact]
+    public void SliceBaseType_DirectlyInheritsGenericRazorSlice_ResolvesModelType()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = ResolveFromSliceBaseType("DirectTodoSliceBase", usings);
+        Assert.Equal("global::TestNs.TodoModel", result);
+    }
+
+    [Fact]
+    public void SliceBaseType_DeepGenericHierarchy_ResolvesModelType()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = ResolveFromSliceBaseType("DeepConcreteTodoSliceBase", usings);
+        Assert.Equal("global::TestNs.TodoModel[]", result);
+    }
+
+    [Fact]
+    public void SliceBaseType_GlobalQualified_ResolvesModelType()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = ResolveFromSliceBaseType("global::TestNs.DirectTodoSliceBase", usings);
+        Assert.Equal("global::TestNs.TodoModel", result);
+    }
+
+    [Fact]
+    public void SliceBaseType_DerivesFromNonGenericRazorSlice_ReturnsNull()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = ResolveFromSliceBaseType("NoModelSliceBase", usings);
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void SliceBaseType_MultipleGenericArgs_OneMappedToModel_ResolvesModelType()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = ResolveFromSliceBaseType("MultiArgMappedSliceBase<int, TodoModel>", usings);
+        Assert.Equal("global::TestNs.TodoModel", result);
+    }
+
+    [Fact]
+    public void SliceBaseType_GenericArgNotMappedToModel_ResolvesConcreteModelType()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = ResolveFromSliceBaseType("NonModelMappedSliceBase<int>", usings);
+        Assert.Equal("global::TestNs.TodoModel", result);
+    }
+
+    [Fact]
+    public void SliceBaseType_MappedGenericArg_WithMultiDimensionalArray_ResolvesModelType()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = ResolveFromSliceBaseType("MultiArgMappedFirstSliceBase<TodoModel[,], int>", usings);
+        Assert.Equal("global::TestNs.TodoModel[,]", result);
+    }
+
+    [Fact]
+    public void SliceBaseType_NonMappedGenericArg_WithMultiDimensionalArray_ResolvesConcreteModelType()
+    {
+        var usings = new List<UsingDirective> { new("TestNs", null) };
+        var result = ResolveFromSliceBaseType("NonModelMappedSliceBase<int[,]>", usings);
+        Assert.Equal("global::TestNs.TodoModel", result);
+    }
+}
diff --git a/razor-slices/test/SourceGenerator.Tests/RazorDirectiveParserTests.cs b/razor-slices/test/SourceGenerator.Tests/RazorDirectiveParserTests.cs
index 0253d9ce..016c4f3d 100644
--- a/razor-slices/test/SourceGenerator.Tests/RazorDirectiveParserTests.cs
+++ b/razor-slices/test/SourceGenerator.Tests/RazorDirectiveParserTests.cs
@@ -54,6 +54,28 @@ public void ExtractBaseTypeName_ReturnsCorrectName(string line, string expected)
     [InlineData("RazorLayoutSlice")]
     public void ExtractModelType_ReturnsNull_WhenNoGenericArg(string baseType) => Assert.Null(RazorDirectiveParser.ExtractModelType(baseType));
 
+    [Theory]
+    [InlineData("@namespace MyApp", "MyApp")]
+    [InlineData("@namespace MyApp.Slices", "MyApp.Slices")]
+    [InlineData("@namespace  MyApp ", "MyApp")]
+    [InlineData("  @namespace MyApp", "MyApp")]
+    public void ParseNamespaceDirective_ReturnsBaseType(string line, string expected)
+    {
+        var sourceText = SourceText.From(line);
+        var result = RazorDirectiveParser.ParseNamespaceDirective(sourceText);
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData("@* comment *@")]
+    [InlineData("<p>Hello</p>")]
+    [InlineData("@using System")]
+    public void ParseNamespaceDirective_ReturnsNull_WhenNoNamespace(string line)
+    {
+        var sourceText = SourceText.From(line);
+        Assert.Null(RazorDirectiveParser.ParseNamespaceDirective(sourceText));
+    }
+
     [Fact]
     public void ParseUsingDirectives_ReturnsSimpleUsings()
     {
diff --git a/razor-slices/test/SourceGenerator.Tests/RazorSliceProxyGeneratorTests.cs b/razor-slices/test/SourceGenerator.Tests/RazorSliceProxyGeneratorTests.cs
new file mode 100644
index 00000000..4cf8580d
--- /dev/null
+++ b/razor-slices/test/SourceGenerator.Tests/RazorSliceProxyGeneratorTests.cs
@@ -0,0 +1,144 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Duende.RazorSlices.SourceGenerator.Tests;
+
+public class RazorSliceProxyGeneratorTests
+{
+    [Theory]
+    [InlineData(false, false, false)]
+    [InlineData(false, true, false)]
+    [InlineData(true, false, false)]
+    [InlineData(true, true, false)]
+    [InlineData(true, false, true)]
+    public void Proxy_CompilesWithDirectConstructor(bool hasModel, bool useRecords, bool customBase)
+    {
+        var (source, compilation) = Generate(hasModel, useRecords, customBase);
+
+        Assert.Contains("new global::AspNetCoreGeneratedDocument.Slices_Hello", source);
+        Assert.DoesNotContain("SliceDefinition", source);
+        Assert.DoesNotContain("typeof(", source);
+        Assert.DoesNotContain("DynamicallyAccessedMembers", source);
+        Assert.Contains(useRecords ? "partial record Hello" : "partial class Hello", source);
+        if (hasModel)
+        {
+            Assert.Contains("static model => new global::AspNetCoreGeneratedDocument.Slices_Hello { Model = model }", source);
+            Assert.Contains(customBase ? "IRazorSliceProxy<global::TestApp.Model>.CreateSlice" : "IRazorSliceProxy<global::System.String>.CreateSlice", source);
+        }
+        else
+        {
+            Assert.Contains("static () => new global::AspNetCoreGeneratedDocument.Slices_Hello()", source);
+            Assert.Contains("IRazorSliceProxy.CreateSlice()", source);
+        }
+        Assert.Empty(compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error));
+    }
+
+    [Fact]
+    public void Proxy_ReportsInaccessibleConstructorAtCompileTime()
+    {
+        var (_, compilation) = Generate(false, false, false, privateConstructor: true);
+
+        Assert.Contains(compilation.GetDiagnostics(), d => d.Id == "CS0122");
+    }
+
+    private static (string Source, Compilation Compilation) Generate(
+        bool hasModel, bool useRecords, bool customBase, bool privateConstructor = false)
+    {
+        var projectDirectory = Path.GetFullPath("TestProject");
+        var baseType = customBase ? "TestApp.CustomSlice" : hasModel ? "Duende.RazorSlices.RazorSlice<string>" : "Duende.RazorSlices.RazorSlice";
+        var source = $$"""
+            #nullable enable
+            namespace Duende.RazorSlices
+            {
+                public abstract class RazorSlice { }
+                public abstract class RazorSlice<TModel> : RazorSlice
+                {
+                    public required TModel Model { get; set; }
+                }
+                public interface IRazorSliceProxy
+                {
+                    static abstract RazorSlice CreateSlice();
+                }
+                public interface IRazorSliceProxy<TModel>
+                {
+                    static abstract RazorSlice<TModel> CreateSlice(TModel model);
+                }
+                public static class RazorSliceFactory
+                {
+                    public static RazorSlice Create<TSlice>(System.Func<TSlice> create) where TSlice : RazorSlice => create();
+                    public static RazorSlice<TModel> Create<TSlice, TModel>(TModel model, System.Func<TModel, TSlice> create)
+                        where TSlice : RazorSlice<TModel> => create(model);
+                }
+            }
+            namespace TestApp
+            {
+                public class Model { }
+                public abstract class CustomSlice : Duende.RazorSlices.RazorSlice<Model> { }
+            }
+            namespace AspNetCoreGeneratedDocument
+            {
+                internal sealed class Slices_Hello : {{baseType}}
+                {
+                    {{(privateConstructor ? "private" : "public")}} Slices_Hello() { }
+                }
+            }
+            """;
+        var runtimeDirectory = Path.GetDirectoryName(typeof(object).Assembly.Location)!;
+        var compilation = CSharpCompilation.Create(
+            "TestApp",
+            [CSharpSyntaxTree.ParseText(source)],
+            [
+                MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
+                MetadataReference.CreateFromFile(Path.Combine(runtimeDirectory, "System.Runtime.dll"))
+            ],
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+        ImmutableArray<AdditionalText> texts =
+        [
+            new TestText(Path.Combine(projectDirectory, "Slices", "_ViewImports.cshtml"), $"@inherits {baseType}"),
+            new TestText(Path.Combine(projectDirectory, "Slices", "Hello.cshtml"), "<p>Hello</p>")
+        ];
+        var options = new TestOptionsProvider(projectDirectory, useRecords);
+        GeneratorDriver driver = CSharpGeneratorDriver.Create(
+            [new RazorSliceProxyGenerator().AsSourceGenerator()], texts, optionsProvider: options);
+
+        driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var output, out var diagnostics);
+
+        Assert.Empty(diagnostics);
+        return (Assert.Single(driver.GetRunResult().GeneratedTrees).ToString(), output);
+    }
+
+    private sealed class TestText(string path, string content) : AdditionalText
+    {
+        public override string Path => path;
+        public override SourceText GetText(CancellationToken cancellationToken = default) => SourceText.From(content);
+    }
+
+    private sealed class TestOptions(Dictionary<string, string> values) : AnalyzerConfigOptions
+    {
+        public override bool TryGetValue(string key, out string value) => values.TryGetValue(key, out value!);
+    }
+
+    private sealed class TestOptionsProvider(string projectDirectory, bool useRecords) : AnalyzerConfigOptionsProvider
+    {
+        public override AnalyzerConfigOptions GlobalOptions { get; } = new TestOptions(new()
+        {
+            ["build_property.RootNamespace"] = "TestApp",
+            ["build_property.MSBuildProjectDirectory"] = projectDirectory,
+            ["build_property.RazorSliceProxiesAsRecords"] = useRecords.ToString()
+        });
+
+        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree) => new TestOptions([]);
+
+        public override AnalyzerConfigOptions GetOptions(AdditionalText textFile) => new TestOptions(new()
+        {
+            ["build_metadata.RazorGenerate.GenerateRazorSlice"] =
+                (Path.GetFileName(textFile.Path) != "_ViewImports.cshtml").ToString()
+        });
+    }
+}

From 5399496f433e5232b306ef8a19136c26b602cba7 Mon Sep 17 00:00:00 2001
From: Joe DeCock <josephdecock@gmail.com>
Date: Wed, 23 Sep 2026 21:28:28 -0500
Subject: [PATCH 3/4] Add tests for HtmlEncodeAndWriteSpanFormattable
 pooled-buffer path

The upstream tests from DamianEdwards/RazorSlices#136 all use values shorter
than SmallFormattableWriteCharSize (32), so post-fix they take the stackalloc
fast path and never exercise the ArrayPool flush that #136 corrected.
Reintroducing the whole-buffer flush leaves them green.

These Duende-only tests use values above the threshold so the pooled path
and its final [..waitingToWrite] flush are covered. They live in a separate
file so upstream re-syncs do not overwrite them.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 ...TextWriterHtmlExtensionsPooledPathTests.cs | 73 +++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsPooledPathTests.cs

diff --git a/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsPooledPathTests.cs b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsPooledPathTests.cs
new file mode 100644
index 00000000..d809918c
--- /dev/null
+++ b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsPooledPathTests.cs
@@ -0,0 +1,73 @@
+// Copyright (c) Duende Software. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+using System.Text.Encodings.Web;
+
+namespace Duende.RazorSlices.Tests;
+
+// The upstream HtmlEncodeAndWriteSpanFormattable tests all use values shorter than
+// BufferSizes.SmallFormattableWriteCharSize, so they take the stackalloc fast path and never rent from
+// ArrayPool<char>. These tests use values longer than that threshold to exercise the pooled path and its
+// final flush, which must write only the encoded chars rather than the whole rented buffer.
+public class TextWriterHtmlExtensionsPooledPathTests
+{
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_PooledPath_WritesOnlyTheFormattedChars()
+    {
+        var value = new FixedStringFormattable(new string('a', BufferSizes.SmallFormattableWriteCharSize + 8));
+        using var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteSpanFormattable(value, HtmlEncoder.Default);
+
+        writer.ToString().ShouldBe(value.Value);
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_PooledPath_DoesNotLeakPreviousRenterContent()
+    {
+        // Dirty the shared pool with a long value whose tail is distinctive, then write a shorter value that
+        // still exceeds the small-path threshold so it rents (and likely receives) the same pooled array.
+        var longValue = new FixedStringFormattable(new string('X', 200));
+        var shortValue = new FixedStringFormattable(new string('y', BufferSizes.SmallFormattableWriteCharSize + 8));
+
+        using var warmup = new StringWriter();
+        warmup.HtmlEncodeAndWriteSpanFormattable(longValue, HtmlEncoder.Default);
+
+        using var writer = new StringWriter();
+        writer.HtmlEncodeAndWriteSpanFormattable(shortValue, HtmlEncoder.Default);
+
+        writer.ToString().ShouldBe(shortValue.Value);
+        writer.ToString().ShouldNotContain("X");
+    }
+
+    [Fact]
+    public void HtmlEncodeAndWriteSpanFormattable_PooledPath_EncodesHtml()
+    {
+        var value = new FixedStringFormattable("<" + new string('b', BufferSizes.SmallFormattableWriteCharSize + 8) + ">");
+        using var writer = new StringWriter();
+
+        writer.HtmlEncodeAndWriteSpanFormattable(value, HtmlEncoder.Default);
+
+        writer.ToString().ShouldBe("&lt;" + new string('b', BufferSizes.SmallFormattableWriteCharSize + 8) + "&gt;");
+    }
+
+    private readonly struct FixedStringFormattable(string value) : ISpanFormattable
+    {
+        public string Value { get; } = value;
+
+        public string ToString(string? format, IFormatProvider? formatProvider) => Value;
+
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            if (destination.Length < Value.Length)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            Value.AsSpan().CopyTo(destination);
+            charsWritten = Value.Length;
+            return true;
+        }
+    }
+}

From 85672bfdfb910bc02947ddf910875d7d6a441845 Mon Sep 17 00:00:00 2001
From: Stu Frankish <stuart.frankish@duendesoftware.com>
Date: Thu, 24 Sep 2026 09:56:58 +0100
Subject: [PATCH 4/4] Fix pooled TextWriter encoding stalls in RazorSlices

- Replace the manual encoding loop with HtmlEncoder's TextWriter overload
- Return the pooled formatting buffer when encoding or writing fails
- Add a non-ASCII regression test with process isolation and a 10-second timeout
---
 .../RazorSlices/TextWriterHtmlExtensions.cs   | 39 +--------
 ...TextWriterHtmlExtensionsPooledPathTests.cs | 84 ++++++++++++++++++-
 2 files changed, 86 insertions(+), 37 deletions(-)

diff --git a/razor-slices/src/RazorSlices/TextWriterHtmlExtensions.cs b/razor-slices/src/RazorSlices/TextWriterHtmlExtensions.cs
index cedefcb4..c023d141 100644
--- a/razor-slices/src/RazorSlices/TextWriterHtmlExtensions.cs
+++ b/razor-slices/src/RazorSlices/TextWriterHtmlExtensions.cs
@@ -35,45 +35,14 @@ public static void HtmlEncodeAndWriteSpanFormattable<T>(this TextWriter textWrit
             formatBuffer = ArrayPool<char>.Shared.Rent(bufferSize);
         }
 
-        var textToEncode = formatBuffer.AsSpan(..charsWritten);
-        var encodeBuffer = ArrayPool<char>.Shared.Rent(BufferSizes.GetHtmlEncodedSizeHint(textToEncode.Length));
-        var encodeBufferSpan = encodeBuffer.AsSpan();
-        var encodeStatus = OperationStatus.Done;
-        var waitingToWrite = 0;
-
-        while (textToEncode.Length > 0)
+        try
         {
-            if (encodeBufferSpan.Length == 0)
-            {
-                if (waitingToWrite > 0)
-                {
-                    textWriter.Write(encodeBuffer.AsSpan()[..waitingToWrite]);
-                    waitingToWrite = 0;
-                    encodeBufferSpan = encodeBuffer;
-                }
-            }
-
-            encodeStatus = htmlEncoder.Encode(textToEncode, encodeBufferSpan, out var charsConsumed, out var charsEncoded);
-            waitingToWrite += charsEncoded;
-
-            if (textToEncode.Length - charsConsumed == 0)
-            {
-                break;
-            }
-
-            textToEncode = textToEncode[charsConsumed..];
-            encodeBufferSpan = encodeBufferSpan[charsEncoded..];
+            htmlEncoder.Encode(textWriter, formatBuffer, 0, charsWritten);
         }
-
-        if (waitingToWrite > 0)
+        finally
         {
-            textWriter.Write(encodeBuffer.AsSpan()[..waitingToWrite]);
+            ArrayPool<char>.Shared.Return(formatBuffer);
         }
-
-        ArrayPool<char>.Shared.Return(encodeBuffer);
-        ArrayPool<char>.Shared.Return(formatBuffer);
-
-        Debug.Assert(encodeStatus == OperationStatus.Done, "Bad math in TextWriter HTML writing extensions");
     }
 
     private static bool TryHtmlEncodeAndWriteSpanFormattableSmall<T>(TextWriter textWriter, T formattable, HtmlEncoder htmlEncoder, ReadOnlySpan<char> format = default, IFormatProvider? formatProvider = null)
diff --git a/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsPooledPathTests.cs b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsPooledPathTests.cs
index d809918c..79892781 100644
--- a/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsPooledPathTests.cs
+++ b/razor-slices/test/RazorSlices.Tests/TextWriterHtmlExtensionsPooledPathTests.cs
@@ -1,14 +1,16 @@
 // Copyright (c) Duende Software. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
 
+using System.Diagnostics;
+using System.Globalization;
 using System.Text.Encodings.Web;
 
 namespace Duende.RazorSlices.Tests;
 
 // The upstream HtmlEncodeAndWriteSpanFormattable tests all use values shorter than
 // BufferSizes.SmallFormattableWriteCharSize, so they take the stackalloc fast path and never rent from
-// ArrayPool<char>. These tests use values longer than that threshold to exercise the pooled path and its
-// final flush, which must write only the encoded chars rather than the whole rented buffer.
+// ArrayPool<char>. These tests use values longer than that threshold to exercise the pooled path,
+// which must encode only the formatted chars rather than the whole rented buffer.
 public class TextWriterHtmlExtensionsPooledPathTests
 {
     [Fact]
@@ -51,6 +53,84 @@ public void HtmlEncodeAndWriteSpanFormattable_PooledPath_EncodesHtml()
         writer.ToString().ShouldBe("&lt;" + new string('b', BufferSizes.SmallFormattableWriteCharSize + 8) + "&gt;");
     }
 
+    [Fact]
+    public async Task HtmlEncodeAndWriteSpanFormattable_PooledPath_EncodesNonAscii()
+    {
+        const string childProcessVariable = "DUENDE_RAZOR_SLICES_NON_ASCII_ENCODING_CHILD";
+
+        if (Environment.GetEnvironmentVariable(childProcessVariable) == "1")
+        {
+            var value = new FixedStringFormattable(new string('\u00E9', 100));
+            using var writer = new StringWriter();
+
+            writer.HtmlEncodeAndWriteSpanFormattable(value, HtmlEncoder.Default);
+
+            writer.ToString().ShouldBe(string.Concat(Enumerable.Repeat("&#xE9;", 100)));
+            return;
+        }
+
+        // A task timeout cannot stop a synchronous encoding loop. Isolate it in a process we can terminate.
+        var resultsDirectory = Directory.CreateTempSubdirectory("RazorSlices-encoding-");
+        try
+        {
+            var startInfo = new ProcessStartInfo(Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") ?? "dotnet")
+            {
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true
+            };
+            startInfo.ArgumentList.Add(typeof(TextWriterHtmlExtensionsPooledPathTests).Assembly.Location);
+            startInfo.ArgumentList.Add("--filter-method");
+            startInfo.ArgumentList.Add($"{typeof(TextWriterHtmlExtensionsPooledPathTests).FullName}.{nameof(HtmlEncodeAndWriteSpanFormattable_PooledPath_EncodesNonAscii)}");
+            startInfo.ArgumentList.Add("--minimum-expected-tests");
+            startInfo.ArgumentList.Add("1");
+            startInfo.ArgumentList.Add("--exit-on-process-exit");
+            startInfo.ArgumentList.Add(Environment.ProcessId.ToString(CultureInfo.InvariantCulture));
+            startInfo.ArgumentList.Add("--results-directory");
+            startInfo.ArgumentList.Add(resultsDirectory.FullName);
+            startInfo.ArgumentList.Add("--no-progress");
+            startInfo.ArgumentList.Add("--no-ansi");
+            startInfo.Environment[childProcessVariable] = "1";
+
+            using var process = new Process { StartInfo = startInfo };
+            process.Start().ShouldBeTrue();
+            var outputTask = process.StandardOutput.ReadToEndAsync(CancellationToken.None);
+            var errorTask = process.StandardError.ReadToEndAsync(CancellationToken.None);
+            var timedOut = false;
+            string output;
+            string error;
+
+            try
+            {
+                await process.WaitForExitAsync(TestContext.Current.CancellationToken)
+                    .WaitAsync(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken);
+            }
+            catch (TimeoutException)
+            {
+                timedOut = true;
+            }
+            finally
+            {
+                if (!process.HasExited)
+                {
+                    process.Kill(entireProcessTree: true);
+                    await process.WaitForExitAsync(CancellationToken.None);
+                }
+
+                output = await outputTask;
+                error = await errorTask;
+            }
+
+            timedOut.ShouldBeFalse($"Non-ASCII encoding did not complete within 10 seconds. The child process was terminated.\n{output}\n{error}");
+            process.ExitCode.ShouldBe(0, $"The encoding regression test failed in the child process.\n{output}\n{error}");
+        }
+        finally
+        {
+            resultsDirectory.Delete(recursive: true);
+        }
+    }
+
     private readonly struct FixedStringFormattable(string value) : ISpanFormattable
     {
         public string Value { get; } = value;