Rename HostedSurface to ExternalSurface

JimBobSquarePants · JimBobSquarePants · commit 66b9e719ef7e · 2026-04-28T11:14:03.000+10:00
diff --git a/WinFormsSamples.sln b/WinFormsSamples.sln
@@ -15,7 +15,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ImageSharp.Drawing.WebGPU.S
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DrawingBackendBenchmark", "samples\DrawingBackendBenchmark\DrawingBackendBenchmark.csproj", "{0AF23A97-CD73-409A-AA29-D214AA400AB0}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebGPUHostedSurfaceDemo", "samples\WebGPUHostedSurfaceDemo\WebGPUHostedSurfaceDemo.csproj", "{478855A1-ECEA-4DF6-9D7B-0342EA26726E}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebGPUExternalSurfaceDemo", "samples\WebGPUExternalSurfaceDemo\WebGPUExternalSurfaceDemo.csproj", "{478855A1-ECEA-4DF6-9D7B-0342EA26726E}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/samples/WebGPUExternalSurfaceDemo/Controls/WebGPURenderControl.cs b/samples/WebGPUExternalSurfaceDemo/Controls/WebGPURenderControl.cs
@@ -8,10 +8,10 @@
 using SixLabors.ImageSharp.PixelFormats;
 using ImageSharpSize = SixLabors.ImageSharp.Size;
 
-namespace WebGPUHostedSurfaceDemo.Controls;
+namespace WebGPUExternalSurfaceDemo.Controls;
 
 /// <summary>
-/// A reusable WinForms control that embeds a <see cref="WebGPUHostedSurface{TPixel}"/> and drives a continuous
+/// A reusable WinForms control that embeds a <see cref="WebGPUExternalSurface{TPixel}"/> and drives a continuous
 /// render loop via <see cref="Application.Idle"/>. Callers hook <see cref="PaintFrame"/> with their scene logic;
 /// the control handles construction, resize, acquire/present, and teardown.
 /// </summary>
@@ -20,7 +20,7 @@ public sealed partial class WebGPURenderControl : Control
     private const int WM_MOVING = 0x0216;
     private const int WM_EXITSIZEMOVE = 0x0232;
 
-    private WebGPUHostedSurface<Bgra32>? surface;
+    private WebGPUExternalSurface<Bgra32>? surface;
     private Size framebufferSize;
     private bool idleHooked;
     private long lastTicks;
@@ -44,7 +44,7 @@ public WebGPURenderControl()
     }
 
     /// <summary>
-    /// Raised each frame once the hosted surface has acquired a drawable frame. The canvas dimensions match
+    /// Raised each frame once the external surface has acquired a drawable frame. The canvas dimensions match
     /// <see cref="FramebufferSize"/>.
     /// </summary>
     public event Action<DrawingCanvas<Bgra32>, TimeSpan>? PaintFrame;
@@ -59,7 +59,7 @@ protected override void OnHandleCreated(EventArgs e)
     {
         base.OnHandleCreated(e);
 
-        // A hosted surface can only be created once the native HWND exists. The surface borrows the HWND;
+        // An external surface can only be created once the native HWND exists. The surface borrows the HWND;
         // WinForms still owns the control, handle lifetime, and layout.
         // WinForms ClientSize is the HWND client rectangle size; pass it through as the drawable framebuffer size.
         this.framebufferSize = this.ClientSize;
@@ -69,7 +69,7 @@ protected override void OnHandleCreated(EventArgs e)
 
         // The module handle is required by the Win32 surface descriptor. It identifies the process module
         // that owns the window class backing this control.
-        this.surface = new WebGPUHostedSurface<Bgra32>(
+        this.surface = new WebGPUExternalSurface<Bgra32>(
             WebGPUSurfaceHost.Win32(
                 this.Handle,
                 Marshal.GetHINSTANCE(typeof(WebGPURenderControl).Module)),
diff --git a/samples/WebGPUExternalSurfaceDemo/MainForm.cs b/samples/WebGPUExternalSurfaceDemo/MainForm.cs
@@ -3,14 +3,14 @@
 
 using SixLabors.ImageSharp.Drawing.Processing;
 using SixLabors.ImageSharp.PixelFormats;
-using WebGPUHostedSurfaceDemo.Controls;
-using WebGPUHostedSurfaceDemo.Scenes;
+using WebGPUExternalSurfaceDemo.Controls;
+using WebGPUExternalSurfaceDemo.Scenes;
 
-namespace WebGPUHostedSurfaceDemo;
+namespace WebGPUExternalSurfaceDemo;
 
 /// <summary>
-/// Main window for the sample. A tab control switches between demo scenes, each hosted by its own
-/// <see cref="WebGPURenderControl"/> instance. This demonstrates that multiple independent hosted surfaces
+/// Main window for the sample. A tab control switches between demo scenes, each displayed in its own
+/// <see cref="WebGPURenderControl"/> instance. This demonstrates that multiple independent external surfaces
 /// can coexist in the same WinForms process without managing surfaces or swapchains in user code.
 /// </summary>
 internal sealed class MainForm : Form
@@ -25,7 +25,7 @@ internal sealed class MainForm : Form
 
     public MainForm()
     {
-        this.Text = "ImageSharp.Drawing WebGPU - Hosted Surface Demo";
+        this.Text = "ImageSharp.Drawing WebGPU - External Surface Demo";
         this.ClientSize = new Size(1280, 800);
         this.StartPosition = FormStartPosition.CenterScreen;
         this.BackColor = Color.FromArgb(11, 18, 32);
@@ -34,7 +34,7 @@ public MainForm()
         this.tigerScene = new TigerViewerScene();
         this.applyScene = new ApplyReadbackScene();
 
-        // Each tab gets its own render control and hosted surface. This mirrors real UI applications where
+        // Each tab gets its own render control and external surface. This mirrors real UI applications where
         // separate controls or panels own their own native drawable areas.
         this.clockControl = new WebGPURenderControl { Dock = DockStyle.Fill };
         this.clockControl.PaintFrame += this.OnPaintClock;
diff --git a/samples/WebGPUExternalSurfaceDemo/MainForm.resx b/samples/WebGPUExternalSurfaceDemo/MainForm.resx
diff --git a/samples/WebGPUExternalSurfaceDemo/Program.cs b/samples/WebGPUExternalSurfaceDemo/Program.cs
@@ -1,10 +1,10 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-namespace WebGPUHostedSurfaceDemo;
+namespace WebGPUExternalSurfaceDemo;
 
 /// <summary>
-/// Entry point for the hosted WebGPU surface sample.
+/// Entry point for the external WebGPU surface sample.
 /// </summary>
 internal static class Program
 {
diff --git a/samples/WebGPUExternalSurfaceDemo/Properties/AssemblyInfo.cs b/samples/WebGPUExternalSurfaceDemo/Properties/AssemblyInfo.cs
diff --git a/samples/WebGPUExternalSurfaceDemo/README.md b/samples/WebGPUExternalSurfaceDemo/README.md
@@ -1,19 +1,19 @@
-# WebGPU Hosted Surface Demo
+# WebGPU External Surface Demo
 
-`WebGPUHostedSurfaceDemo` shows how to render ImageSharp.Drawing content into a UI object owned by an application framework. The sample uses a WinForms `Control`, but the API shape is intended for any externally-owned native drawable host.
+`WebGPUExternalSurfaceDemo` shows how to render ImageSharp.Drawing content into a UI object owned by an application framework. The sample uses a WinForms `Control`, but the API shape is intended for any externally-owned native drawable host.
 
 It exists to demonstrate:
 
-- creating a `WebGPUHostedSurface<Bgra32>` from a `WebGPUSurfaceHost`
-- keeping the hosted surface synchronized with the host control's drawable framebuffer size
+- creating a `WebGPUExternalSurface<Bgra32>` from a `WebGPUSurfaceHost`
+- keeping the external surface synchronized with the host control's drawable framebuffer size
 - acquiring `WebGPUSurfaceFrame<TPixel>` instances manually
 - drawing with the normal `DrawingCanvas<TPixel>` API
 - presenting by disposing the acquired frame
 
 ## Running
 
 ```bash
-dotnet run --project samples/WebGPUHostedSurfaceDemo -c Debug
+dotnet run --project samples/WebGPUExternalSurfaceDemo -c Debug
 ```
 
 Requirements:
@@ -27,11 +27,11 @@ When the sample starts you should see a WinForms window with three tabs:
 
 - `Clock`: a continuously-rendered animated clock scene
 - `Tiger`: an interactive SVG tiger viewer with pan and zoom
-- `Apply`: a reactive hosted-surface readback scene using `DrawingCanvas.Apply(...)`; move the mouse to move the edge-detect and blur regions, and use the mouse wheel to resize them
+- `Apply`: a reactive external-surface readback scene using `DrawingCanvas.Apply(...)`; move the mouse to move the edge-detect and blur regions, and use the mouse wheel to resize them
 
 ## Why This Sample Matters
 
-`WebGPUWindow<TPixel>` owns a top-level native window. `WebGPUHostedSurface<TPixel>` is different: it attaches WebGPU rendering to something the application already owns, such as a control, view, widget, or native surface.
+`WebGPUWindow<TPixel>` owns a top-level native window. `WebGPUExternalSurface<TPixel>` is different: it attaches WebGPU rendering to something the application already owns, such as a control, view, widget, or native surface.
 
 That makes it the integration path for UI frameworks. The host owns:
 
@@ -40,7 +40,7 @@ That makes it the integration path for UI frameworks. The host owns:
 - layout and resize events
 - input events
 
-The hosted surface owns:
+The external surface owns:
 
 - the WebGPU surface created for that host
 - swapchain configuration
@@ -50,25 +50,25 @@ The hosted surface owns:
 
 ## Code Tour
 
-The reusable integration point is [WebGPURenderControl.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/Controls/WebGPURenderControl.cs).
+The reusable integration point is [WebGPURenderControl.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/Controls/WebGPURenderControl.cs).
 
 ### Surface Creation
 
-`WebGPURenderControl.OnHandleCreated(...)` creates the hosted surface from the WinForms control handle:
+`WebGPURenderControl.OnHandleCreated(...)` creates the external surface from the WinForms control handle:
 
 ```csharp
-this.surface = new WebGPUHostedSurface<Bgra32>(
+this.surface = new WebGPUExternalSurface<Bgra32>(
     WebGPUSurfaceHost.Win32(
         this.Handle,
         Marshal.GetHINSTANCE(typeof(WebGPURenderControl).Module)),
     initialFramebufferSize);
 ```
 
-`WebGPUSurfaceHost` is a small public descriptor for externally-owned native handles. The host keeps ownership of those handles; `WebGPUHostedSurface<TPixel>` only uses them to create and manage the WebGPU rendering surface.
+`WebGPUSurfaceHost` is a small public descriptor for externally-owned native handles. The host keeps ownership of those handles; `WebGPUExternalSurface<TPixel>` only uses them to create and manage the WebGPU rendering surface.
 
 ### Resize
 
-`WebGPUHostedSurface<TPixel>.Resize(...)` expects the drawable framebuffer size in pixels:
+`WebGPUExternalSurface<TPixel>.Resize(...)` expects the drawable framebuffer size in pixels:
 
 ```csharp
 this.framebufferSize = this.ClientSize;
@@ -103,13 +103,13 @@ Frame pacing is delegated to the present mode. With the default `WebGPUPresentMo
 
 ## Scene Code
 
-[MainForm.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/MainForm.cs) creates independent `WebGPURenderControl` instances, one per tab. Each control owns its own hosted surface.
+[MainForm.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/MainForm.cs) creates independent `WebGPURenderControl` instances, one per tab. Each control owns its own external surface.
 
 The scenes are deliberately ordinary canvas code:
 
-- [ClockScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/Scenes/ClockScene.cs): animated vector clock
-- [TigerViewerScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/Scenes/TigerViewerScene.cs): pan and zoom SVG tiger viewer
-- [ApplyReadbackScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/Scenes/ApplyReadbackScene.cs): `Apply(...)` scene that reads the hosted surface back into CPU processing
+- [ClockScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/Scenes/ClockScene.cs): animated vector clock
+- [TigerViewerScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/Scenes/TigerViewerScene.cs): pan and zoom SVG tiger viewer
+- [ApplyReadbackScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/Scenes/ApplyReadbackScene.cs): `Apply(...)` scene that reads the external surface back into CPU processing
 
 Each scene receives:
 
@@ -119,9 +119,9 @@ Each scene receives:
 
 ## Files
 
-- [WebGPURenderControl.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/Controls/WebGPURenderControl.cs): reusable WinForms hosted-surface control
-- [MainForm.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/MainForm.cs): tabs and scene wiring
-- [ClockScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/Scenes/ClockScene.cs): clock scene
-- [TigerViewerScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/Scenes/TigerViewerScene.cs): tiger viewer scene
-- [ApplyReadbackScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/Scenes/ApplyReadbackScene.cs): apply readback scene
-- [WebGPUHostedSurfaceDemo.csproj](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUHostedSurfaceDemo/WebGPUHostedSurfaceDemo.csproj): sample project file
+- [WebGPURenderControl.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/Controls/WebGPURenderControl.cs): reusable WinForms external-surface control
+- [MainForm.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/MainForm.cs): tabs and scene wiring
+- [ClockScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/Scenes/ClockScene.cs): clock scene
+- [TigerViewerScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/Scenes/TigerViewerScene.cs): tiger viewer scene
+- [ApplyReadbackScene.cs](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/Scenes/ApplyReadbackScene.cs): apply readback scene
+- [WebGPUExternalSurfaceDemo.csproj](d:/GitHub/SixLabors/ImageSharp.Drawing/samples/WebGPUExternalSurfaceDemo/WebGPUExternalSurfaceDemo.csproj): sample project file
diff --git a/samples/WebGPUExternalSurfaceDemo/Scenes/ApplyReadbackScene.cs b/samples/WebGPUExternalSurfaceDemo/Scenes/ApplyReadbackScene.cs
@@ -14,10 +14,10 @@
 using Size = SixLabors.ImageSharp.Size;
 using SizeF = SixLabors.ImageSharp.SizeF;
 
-namespace WebGPUHostedSurfaceDemo.Scenes;
+namespace WebGPUExternalSurfaceDemo.Scenes;
 
 /// <summary>
-/// Hosted-surface scene that exercises canvas readback by applying CPU image processors to regions of the current frame.
+/// External surface scene that exercises canvas readback by applying CPU image processors to regions of the current frame.
 /// Pointer movement changes the processed regions so readback cost can be assessed interactively.
 /// </summary>
 internal sealed class ApplyReadbackScene : RenderScene
diff --git a/samples/WebGPUExternalSurfaceDemo/Scenes/ClockScene.cs b/samples/WebGPUExternalSurfaceDemo/Scenes/ClockScene.cs
@@ -20,7 +20,7 @@
 using SystemFonts = SixLabors.Fonts.SystemFonts;
 using VerticalAlignment = SixLabors.Fonts.VerticalAlignment;
 
-namespace WebGPUHostedSurfaceDemo.Scenes;
+namespace WebGPUExternalSurfaceDemo.Scenes;
 
 /// <summary>
 /// Animated analog clock. Validates continuous render, curves, thin-stroke antialiasing, text rendering,
diff --git a/samples/WebGPUExternalSurfaceDemo/Scenes/RenderScene.cs b/samples/WebGPUExternalSurfaceDemo/Scenes/RenderScene.cs
@@ -5,7 +5,7 @@
 using SixLabors.ImageSharp.PixelFormats;
 using Size = SixLabors.ImageSharp.Size;
 
-namespace WebGPUHostedSurfaceDemo.Scenes;
+namespace WebGPUExternalSurfaceDemo.Scenes;
 
 /// <summary>
 /// Base class for a demo scene rendered into a <see cref="WebGPURenderControl"/>.
@@ -21,7 +21,7 @@ internal abstract class RenderScene
     /// <summary>
     /// Draws the scene into <paramref name="canvas"/> for the current frame.
     /// </summary>
-    /// <param name="canvas">The per-frame drawing canvas bound to the hosted surface's swap-chain texture.</param>
+    /// <param name="canvas">The per-frame drawing canvas bound to the external surface's swap-chain texture.</param>
     /// <param name="viewportSize">The framebuffer size in pixels.</param>
     /// <param name="deltaTime">Elapsed time since the previous frame. Scenes that render from absolute state can ignore it.</param>
     public abstract void Paint(DrawingCanvas<Bgra32> canvas, Size viewportSize, TimeSpan deltaTime);
diff --git a/samples/WebGPUExternalSurfaceDemo/Scenes/TigerViewerScene.cs b/samples/WebGPUExternalSurfaceDemo/Scenes/TigerViewerScene.cs
@@ -14,7 +14,7 @@
 using SizeF = SixLabors.ImageSharp.SizeF;
 using SolidBrush = SixLabors.ImageSharp.Drawing.Processing.SolidBrush;
 
-namespace WebGPUHostedSurfaceDemo.Scenes;
+namespace WebGPUExternalSurfaceDemo.Scenes;
 
 /// <summary>
 /// Loads the Ghostscript Tiger SVG via the shared <see cref="SvgBenchmarkHelper"/> and renders it with
diff --git a/samples/WebGPUExternalSurfaceDemo/WebGPUExternalSurfaceDemo.csproj b/samples/WebGPUExternalSurfaceDemo/WebGPUExternalSurfaceDemo.csproj
@@ -5,7 +5,7 @@
     <UseWindowsForms>true</UseWindowsForms>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Nullable>enable</Nullable>
-    <RootNamespace>WebGPUHostedSurfaceDemo</RootNamespace>
+    <RootNamespace>WebGPUExternalSurfaceDemo</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/ImageSharp.Drawing.WebGPU/WEBGPU_BACKEND.md b/src/ImageSharp.Drawing.WebGPU/WEBGPU_BACKEND.md
@@ -22,7 +22,7 @@ The public WebGPU surface area around this backend is small and target-first. Mo
 
 - `WebGPUEnvironment` exposes explicit support probes for the library-managed WebGPU environment
 - `WebGPUWindow<TPixel>` owns a native window and either runs a render loop or returns `WebGPUSurfaceFrame<TPixel>` instances through `TryAcquireFrame(...)`
-- `WebGPUHostedSurface<TPixel>` attaches to a caller-owned native host via `WebGPUSurfaceHost`; the host application owns the UI object and tells the hosted surface when the drawable framebuffer resizes
+- `WebGPUExternalSurface<TPixel>` attaches to a caller-owned native host via `WebGPUSurfaceHost`; the host application owns the UI object and tells the external surface when the drawable framebuffer resizes
 - `WebGPURenderTarget<TPixel>` owns an offscreen native target for GPU rendering, hybrid CPU plus GPU canvases, and readback
 
 **Advanced types** — interop escape hatches for applications that already own a WebGPU device, queue, or native surface:
@@ -156,7 +156,7 @@ The expensive staged work is delegated:
 The public object graph around those responsibilities is also separate:
 
 - `WebGPUEnvironment` handles explicit support probes
-- `WebGPUWindow<TPixel>`, `WebGPUHostedSurface<TPixel>`, and `WebGPURenderTarget<TPixel>` are the recommended target constructors; `WebGPUDeviceContext<TPixel>` and `WebGPUNativeSurfaceFactory` are advanced interop escape hatches for caller-owned devices or surfaces
+- `WebGPUWindow<TPixel>`, `WebGPUExternalSurface<TPixel>`, and `WebGPURenderTarget<TPixel>` are the recommended target constructors; `WebGPUDeviceContext<TPixel>` and `WebGPUNativeSurfaceFactory` are advanced interop escape hatches for caller-owned devices or surfaces
 - `DrawingCanvas<TPixel>` hands a prepared `CompositionScene` to the backend
 
 ## The Flush Boundary
@@ -267,7 +267,7 @@ The staged scene pipeline itself is described in [`WEBGPU_RASTERIZER.md`](d:/Git
 If you want to understand the backend first, read the code in this order:
 
 1. `WebGPUEnvironment.cs`
-2. `WebGPUWindow{TPixel}.cs`, `WebGPUSurfaceFrame{TPixel}.cs`, `WebGPUHostedSurface{TPixel}.cs`, `WebGPUSurfaceHost.cs`, `WebGPURenderTarget{TPixel}.cs`, and `WebGPUDeviceContext{TPixel}.cs`
+2. `WebGPUWindow{TPixel}.cs`, `WebGPUSurfaceFrame{TPixel}.cs`, `WebGPUExternalSurface{TPixel}.cs`, `WebGPUSurfaceHost.cs`, `WebGPURenderTarget{TPixel}.cs`, and `WebGPUDeviceContext{TPixel}.cs`
 3. `WebGPUDrawingBackend.cs`
 4. `WebGPUFlushContext.cs`
 5. `WebGPURuntime.cs`
@@ -285,7 +285,7 @@ The easiest way to keep this backend straight is to remember that it is not the
 If that model is clear, the major types fall into place:
 
 - `WebGPUEnvironment` exposes explicit support probes
-- `WebGPUWindow<TPixel>`, `WebGPUHostedSurface<TPixel>`, and `WebGPURenderTarget<TPixel>` are the recommended target types; `WebGPUDeviceContext<TPixel>` and `WebGPUNativeSurfaceFactory` are advanced interop escape hatches
+- `WebGPUWindow<TPixel>`, `WebGPUExternalSurface<TPixel>`, and `WebGPURenderTarget<TPixel>` are the recommended target types; `WebGPUDeviceContext<TPixel>` and `WebGPUNativeSurfaceFactory` are advanced interop escape hatches
 - `WebGPUDrawingBackend` orchestrates and decides policy
 - `WebGPUFlushContext` owns one flush's execution state
 - `WebGPURuntime` owns longer-lived device state
diff --git a/src/ImageSharp.Drawing.WebGPU/WebGPUExternalSurfaceOptions.cs b/src/ImageSharp.Drawing.WebGPU/WebGPUExternalSurfaceOptions.cs
@@ -4,13 +4,13 @@
 namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 
 /// <summary>
-/// Options for creating a <see cref="WebGPUHostedSurface{TPixel}"/>.
+/// Options for creating a <see cref="WebGPUExternalSurface{TPixel}"/>.
 /// </summary>
 /// <remarks>
 /// Only values that are meaningful for an externally-owned surface are exposed here.
 /// Lifecycle, title, position, border, and state belong to the host application and its UI framework.
 /// </remarks>
-public sealed class WebGPUHostedSurfaceOptions
+public sealed class WebGPUExternalSurfaceOptions
 {
     /// <summary>
     /// Gets or sets how completed frames are queued for presentation to the display.
diff --git a/src/ImageSharp.Drawing.WebGPU/WebGPUExternalSurface{TPixel}.cs b/src/ImageSharp.Drawing.WebGPU/WebGPUExternalSurface{TPixel}.cs
diff --git a/src/ImageSharp.Drawing.WebGPU/WebGPUSurfaceHost.cs b/src/ImageSharp.Drawing.WebGPU/WebGPUSurfaceHost.cs
diff --git a/src/ImageSharp.Drawing.WebGPU/WebGPUSurfaceResources{TPixel}.cs b/src/ImageSharp.Drawing.WebGPU/WebGPUSurfaceResources{TPixel}.cs
