From 277749de1a87d0d8f6d91bae7c8fddd4cce9be3d Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 15:54:26 +1000
Subject: [PATCH 1/9] docs(claude): add the soft-tone Material 3 diagram style

---
 CLAUDE.md | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/CLAUDE.md b/CLAUDE.md
index 02d63da6..95895096 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -114,6 +114,41 @@ The model is [`ReactiveUI.Binding.SourceGenerators/README.md`](https://github.co
 the problem first, then a numbered walkthrough of the first use, then reference sections. A reader who stops
 after the walkthrough can already do the thing.
 
+### Diagrams: soft-tone Material 3
+
+The site renders ```` ```mermaid ```` fences (NuStreamDocs.Mermaid, Mermaid 10). Every diagram uses the same palette,
+taken from Material 3 container roles and seeded from the site's ReactiveUI blue (`#319af3`). Fills are light tones with
+dark text, so a diagram reads in both the light and dark site themes. Copy the `init` line and the `classDef` lines
+exactly. Do not invent colours.
+
+```mermaid
+%%{init: {"theme": "base", "themeVariables": {"fontFamily": "Roboto, Helvetica, Arial, sans-serif", "fontSize": "15px", "primaryColor": "#DCE9FF", "primaryBorderColor": "#6C8EC4", "primaryTextColor": "#0B2447", "secondaryColor": "#E3F2E8", "secondaryBorderColor": "#7FA88C", "secondaryTextColor": "#12301C", "tertiaryColor": "#F3E5F5", "tertiaryBorderColor": "#A98BB0", "tertiaryTextColor": "#2E1437", "lineColor": "#7B8699", "textColor": "#1B1F27", "noteBkgColor": "#FFF4D6", "noteBorderColor": "#C9A94F", "noteTextColor": "#3A2A00", "actorBkg": "#DCE9FF", "actorBorder": "#6C8EC4", "actorTextColor": "#0B2447", "signalColor": "#7B8699", "signalTextColor": "#1B1F27", "labelBoxBkgColor": "#F1F3F8", "labelBoxBorderColor": "#A7AEBB", "edgeLabelBackground": "#F7F9FC", "clusterBkg": "#F7F9FC", "clusterBorder": "#C9D1DE"}}}%%
+flowchart LR
+    classDef view fill:#DCE9FF,stroke:#6C8EC4,color:#0B2447
+    classDef vm fill:#E3F2E8,stroke:#7FA88C,color:#12301C
+    classDef model fill:#F3E5F5,stroke:#A98BB0,color:#2E1437
+    classDef warn fill:#FDE7E4,stroke:#C98A82,color:#410E0B
+    classDef neutral fill:#F1F3F8,stroke:#A7AEBB,color:#1B1F27
+    View(["View"]):::view -- "binds to" --> VM(["View model"]):::vm
+    VM -- "reads and writes" --> Model(["Model"]):::model
+```
+
+| Class | Tone | Use for |
+| --- | --- | --- |
+| `view` | soft blue (primary container) | views, controls, anything the user sees |
+| `vm` | soft green (secondary container) | view models, commands, reactive objects |
+| `model` | soft lavender (tertiary container) | models, stores, services, data |
+| `warn` | soft rose (error container) | errors, exceptions, failure paths |
+| `neutral` | soft grey (surface variant) | infrastructure: sequencers, the builder, the resolver |
+
+- Use a diagram only where it shows something faster than words: data flowing between view, view model and model; a
+  command's life cycle; a navigation stack; activation and deactivation; where work runs; suspension states. Most
+  pages need at most two.
+- Use rounded shapes (`(["text"])` or `("text")`) and `flowchart LR` unless the flow is a stack or a timeline. Use
+  `sequenceDiagram` for "who calls whom, in what order" and `stateDiagram-v2` for life cycles.
+- Keep to about eight nodes. Labels are plain words a grade 8 reader follows, in the page's own terms.
+- Put each diagram after the paragraph that introduces it, and follow it with one sentence saying what to notice.
+
 ## In Flight: Per-Operator Pages For ReactiveUI.Primitives
 
 The site is to carry one page per operator family for `ReactiveUI.Primitives`, with an example for every

From d7e8a1389dfbb751b09beefb9f2c30067f95aa40 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 16:08:17 +1000
Subject: [PATCH 2/9] docs(reactiveui): rewrite the Avalonia binding page for
 ReactiveUI.Avalonia

---
 .../handbook/data-binding/avalonia.md         | 115 +++++++++---------
 1 file changed, 57 insertions(+), 58 deletions(-)

diff --git a/docs/documentation/reactiveui/handbook/data-binding/avalonia.md b/docs/documentation/reactiveui/handbook/data-binding/avalonia.md
index d5fc98f8..b556263d 100644
--- a/docs/documentation/reactiveui/handbook/data-binding/avalonia.md
+++ b/docs/documentation/reactiveui/handbook/data-binding/avalonia.md
@@ -1,72 +1,71 @@
 ---
 Order: 3
 ---
-# Data Binding in AvaloniaUI with ReactiveUI
+# Data Binding in Avalonia
 
-> **Note** First of all, ensure you install the `Avalonia.ReactiveUI` package and *add a call* to `UseReactiveUI()` to your `AppBuilder` — that's super important. Note, that `Avalonia.ReactiveUI` package is supported by AvaloniaUI team, so if anything goes wrong, head over to [AvaloniaUI Gitter](https://gitter.im/AvaloniaUI/Avalonia). Also see [Avalonia.ReactiveUI Docs](https://docs.avaloniaui.net/guides/deep-dives/reactiveui).
+An Avalonia view binds to its view model with the same `Bind`, `OneWayBind` and `BindCommand` calls as any other
+platform. The Avalonia pieces, such as the view base classes and the start-up call, ship in the `ReactiveUI.Avalonia`
+package. That package lives in its own repository, [reactiveui/ReactiveUI.Avalonia](https://github.com/reactiveui/ReactiveUI.Avalonia),
+so the code on this page is quoted from its
+[example app](https://github.com/reactiveui/ReactiveUI.Avalonia/tree/main/src/examples/ReactiveUI.Avalonia.Example).
+[Installing for Avalonia](../../getting-started/installation/avalonia.md) lists the packages.
 
-For [WhenActivated](../when-activated.md) to work, you need to use custom base classes from `Avalonia.ReactiveUI` package, such as `ReactiveWindow<TViewModel>` or `ReactiveUserControl<TViewModel>`. Of course, you can also implement the `IViewFor<TViewModel>` interface by hand in your class, but ensure to store the `ViewModel` inside an `AvaloniaProperty`. If you wish to add activation support to your view models, then implement the `IActivatableViewModel` interface. A view model implementing `IActivatableViewModel` might look like the one below:
+## Bind a view in three steps
 
-```cs
-public class ViewModel : ReactiveObject, IActivatableViewModel
-{
-    public ViewModelActivator Activator { get; } = new ViewModelActivator();
+1. **Start ReactiveUI with the app.** Call `UseReactiveUI` on Avalonia's `AppBuilder`. It registers the main-thread
+   sequencer, activation and binding support. `RegisterReactiveUIViewsFromEntryAssembly` registers each view in your
+   app, so view location can find it.
 
-    public ViewModel()
-    {
-        this.WhenActivated(disposables =>
-        {
-            /* Handle activation */
-            Disposable
-                .Create(() => { /* Handle deactivation */ })
-                .DisposeWith(disposables);
-        });
-    }
-}
-```
+   ```cs
+   public static AppBuilder BuildAvaloniaApp() => AppBuilder
+       .Configure<App>()
+       .UsePlatformDetect()
+       .UseReactiveUI(rxui =>
+       {
+           // Optional: add custom registration here via rxui.WithRegistration(...)
+       })
+       .RegisterReactiveUIViewsFromEntryAssembly();
+   ```
 
-Remember to place a call to `WhenActivated` to the code-behind of your view, otherwise your view model's `WhenActivated` block won't get called.
+2. **Derive the view from a ReactiveUI base class.** `ReactiveWindow<TViewModel>` and `ReactiveUserControl<TViewModel>`
+   implement `IViewFor<TViewModel>`. They store the view model in an Avalonia property, so XAML bindings see it too.
+   Avalonia generates a field for each control that has an `x:Name` in the markup, so the view can name its controls
+   directly.
 
-```cs
-// This represents the View.xaml.cs code-behind file.
-public partial class View : ReactiveWindow<ViewModel>
-{
-    public View()
-    {
-        // If you put a WhenActivated block here, your activatable view model 
-        // will also support activation, otherwise it won't.
-        this.WhenActivated(disposables => { /* Handle interactions etc. */ });
-        AvaloniaXamlLoader.Load(this);
-    }
-}
-```
+3. **Bind inside `WhenActivated`.** [WhenActivated](../when-activated.md) runs its block when the view joins the
+   visual tree and disposes everything the block added when the view leaves it. Add each binding to the block's
+   `MultipleDisposable`, so no binding outlives the view.
 
-```xml
-<!-- This represents the View.xaml markup file. -->
-<Window xmlns="https://github.com/avaloniaui">
-  <TextBlock Text="Hello, world!" />
-</Window>
-```
+   ```cs
+   public sealed partial class CommandLabView : ReactiveUserControl<CommandLabViewModel>
+   {
+       public CommandLabView()
+       {
+           InitializeComponent();
+           _ = this.WhenActivated(BindView);
+       }
 
-The `WhenActivated` block is called when the `AttachedToVisualTree` event is published, and the disposable is disposed of when the `DetachedFromVisualTree` event is published. The behavior is the same for both the views and the view models. Unfortunately, Avalonia won't generate strongly typed `x:Name` references to controls, so the only way for now is to use the `FindControl` method that will find a control by the name specified in XAML, or to use `{Binding Path}` syntax. 
+       private void BindView(ReactiveUI.Primitives.Disposables.MultipleDisposable disposables)
+       {
+           disposables.Add(this.Bind(ViewModel, static viewModel => viewModel.WorkItemText, static view => view.WorkItemTextBox.Text));
+           disposables.Add(this.OneWayBind(ViewModel, static viewModel => viewModel.LastResult, static view => view.LastResultText.Text));
+           disposables.Add(this.BindCommand(ViewModel, static viewModel => viewModel.RunWork, static view => view.RunWorkButton));
+       }
+   }
+   ```
 
-> **Note** The `FindControl` method shouldn't be used inside an expression. Instead, create a custom property which calls the `FindControl` method, or store the control in a variable. See an example of how to use ReactiveUI type-safe bindings with AvaloniaUI.
+`WorkItemTextBox`, `LastResultText` and `RunWorkButton` are the `x:Name` values in the view's `.axaml` file. The
+lambdas are `static` because they capture nothing. See
+[Dispose your subscriptions](../../guidelines/framework/dispose-your-subscriptions.md) for why every binding goes
+into the activation block.
 
-```cs
-public partial class View : ReactiveWindow<ViewModel>
-{
-    // Assume the Button control has the Name="ExampleButton" attribute defined in XAML.
-    public Button ExampleButton => this.FindControl<Button>("ExampleButton");
+## Activate the view model too
 
-    public View()
-    {
-        this.WhenActivated(disposables => 
-        {
-            // Bind the 'ExampleCommand' to 'ExampleButton' defined above.
-            this.BindCommand(ViewModel, x => x.ExampleCommand, x => x.ExampleButton)
-                .DisposeWith(disposables);
-        });
-        AvaloniaXamlLoader.Load(this);
-    }
-}
-```
+A view model that implements `IActivatableViewModel` gets its own `WhenActivated` block. That block runs only while
+a view that calls `WhenActivated` shows the view model. [WhenActivated](../when-activated.md) covers both halves.
+
+## Where to go next
+
+- [Data Binding](index.md) explains `Bind`, `OneWayBind` and `BindCommand` and their converters.
+- The [ReactiveUI.Avalonia README](https://github.com/reactiveui/ReactiveUI.Avalonia#readme) covers start-up with a
+  dependency-injection container: Autofac, DryIoc, Microsoft.Extensions.DependencyInjection or Ninject.

From 7456e409d98805e3e7e172a1ac337c4fd2371215 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 16:12:10 +1000
Subject: [PATCH 3/9] docs(reactiveui): activation through
 IActivatableViewModel and command witnesses

---
 .../reactiveui/handbook/commands/advanced.md  | 43 +++++++++++++++++++
 .../reactiveui/handbook/when-activated.md     | 13 ++++++
 2 files changed, 56 insertions(+)

diff --git a/docs/documentation/reactiveui/handbook/commands/advanced.md b/docs/documentation/reactiveui/handbook/commands/advanced.md
index 5db76bbc..df061fe0 100644
--- a/docs/documentation/reactiveui/handbook/commands/advanced.md
+++ b/docs/documentation/reactiveui/handbook/commands/advanced.md
@@ -261,6 +261,45 @@ Closing the desk raises `CanExecuteChanged`, which the sample's handler turns in
 `CanExecute(null)` again. `DeskAnnouncementCommand` raises that event itself, by calling the protected
 `OnCanExecuteChanged` method `ReactiveCommandBase` defines for exactly this purpose.
 
+## Subscribe a witness directly
+
+A command is an `IObservable<TResult>`, so a witness — a class that implements `IObserver<T>` itself instead of
+using an operator such as `Subscribe(Action<T>)` — can subscribe to it the normal way, whether the command is a
+`ReactiveCommand<TParam, TResult>` or a hand-written subclass of `ReactiveCommandBase<TParam, TResult>`.
+`BookReceiptPrinter` prints a receipt for every book a command produces:
+
+```csharp
+LibraryDesk desk = new();
+BookReceiptPrinter witness = new();
+
+using ReactiveCommand<int, Book> borrow = ReactiveCommand.Create<int, Book>(desk.Borrow);
+using IDisposable subscription = borrow.Subscribe(witness);
+
+_ = await borrow.Execute(1);
+_ = await borrow.Execute(4);
+
+// Output:
+// Printed a receipt for Clean Code
+// Printed a receipt for Refactoring
+```
+
+Code that only knows a command through the abstract `ReactiveCommandBase<TParam, TResult>` subscribes a witness the
+same way, whether the command underneath was built by a factory or, like `DeskAnnouncementCommand`, by hand:
+
+```csharp
+LibraryDesk desk = new();
+DeskAnnouncementBoard board = new();
+using DeskAnnouncementCommand closingSoon = new(desk, static () => "The desk closes in ten minutes.");
+
+ReactiveCommandBase<RxVoid, string> command = closingSoon;
+using IDisposable subscription = command.Subscribe(board);
+
+_ = await command.Execute();
+
+// Output:
+// Board: The desk closes in ten minutes.
+```
+
 ## Exposing a command from a view model
 
 A view model property typed as a concrete `ReactiveCommand<TParam, TResult>` or `CombinedReactiveCommand<TParam,
@@ -513,6 +552,10 @@ source, for apps that use System.Reactive instead.
 | `ReactiveCommand<TParam, TResult>` constructor (cancel callback) | Base constructor for execution logic that cancels through a callback rather than by unsubscribing. |
 | `CombinedReactiveCommand<TParam, TResult>` constructors | Three base constructors a subclass uses, with `canExecute`, an `ISequencer`, or both. |
 | `ReactiveCommandBase<TParam, TResult>` | Abstract base every command type shares: `CanExecute`, `IsExecuting`, `ThrownExceptions`, `Execute`, `Subscribe`, plus the `ICommand` hooks a subclass overrides. |
+| `ReactiveCommandBase<TParam, TResult>.ICommandCanExecute(object?)` | Protected hook a subclass overrides; an `ICommand` caller's `CanExecute` routes here. |
+| `ReactiveCommandBase<TParam, TResult>.ICommandExecute(object?)` | Protected hook a subclass overrides; an `ICommand` caller's `Execute` routes here. |
+| `ReactiveCommandBase<TParam, TResult>.Subscribe(IObserver<TResult>)` | Subscribes a witness directly to a command's results. |
+| `ReactiveCommand<TParam, TResult>.Subscribe(IObserver<TResult>)` | The same subscription on a plain `ReactiveCommand<TParam, TResult>`. |
 | `IReactiveCommand<TParam, TResult>` | The interface to expose a command through when a view model should not commit to a concrete command type. |
 | `IReactiveCommand` | The non-generic interface for code that only needs `CanExecute` and `IsExecuting`. |
 | `SwitchSubscribe` | Subscribes to the inner observable a property currently holds, following each replacement. |
diff --git a/docs/documentation/reactiveui/handbook/when-activated.md b/docs/documentation/reactiveui/handbook/when-activated.md
index 0f5f665a..618769ee 100644
--- a/docs/documentation/reactiveui/handbook/when-activated.md
+++ b/docs/documentation/reactiveui/handbook/when-activated.md
@@ -55,6 +55,19 @@ using (viewModel.Activator.Activate())
 
 The list is empty before activation and loaded once `Activate` runs the constructor's `WhenActivated` block. Leaving the `using` block disposes the `IDisposable` that `Activate` returned, which deactivates the view model and disposes everything the block created.
 
+Code that only knows a screen through `IActivatableViewModel` can activate it the same way, without knowing its concrete view model type. A navigation host that keeps a stack of screens works this way: it reads `Activator` through the interface.
+
+```csharp
+using TodoListViewModel viewModel = new(InMemoryTodoStore.CreateSeeded());
+List<IActivatableViewModel> screenStack = [viewModel];
+
+using IDisposable activation = screenStack[0].Activator.Activate();
+Console.WriteLine(viewModel.Items.Count);
+
+// Output:
+// 4
+```
+
 ## Give a view an activation block
 
 A view calls the same method, `WhenActivated`, but passes it a stream of its own view model instead of relying on reflection to find one. `TodoListView` implements `IViewFor<TodoListViewModel>` and passes `this.WhenAnyValue(x => x.ViewModel)` as that stream. Each disposable the block creates goes through the `disposables` callback.

From bc2ce27a4a84513511e677c79fb6989b261ff1d5 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 16:27:27 +1000
Subject: [PATCH 4/9] docs(reactiveui): document the remaining Android, MAUI,
 WinForms and WinUI members; rewrite extending IViewFor

---
 .../data-binding/android/wire-up-controls.md  |  41 ++-
 .../reactiveui/handbook/platforms/android.md  | 169 ++++++++++-
 .../reactiveui/handbook/platforms/maui.md     |  56 +++-
 .../reactiveui/handbook/platforms/winforms.md |  38 ++-
 .../reactiveui/handbook/platforms/winui.md    | 121 +++++++-
 .../view-location/extending-iviewfor.md       | 287 ++++++++++++++----
 .../handbook/view-location/index.md           |   8 +-
 7 files changed, 639 insertions(+), 81 deletions(-)

diff --git a/docs/documentation/reactiveui/handbook/data-binding/android/wire-up-controls.md b/docs/documentation/reactiveui/handbook/data-binding/android/wire-up-controls.md
index b2f3be10..97bb78ee 100644
--- a/docs/documentation/reactiveui/handbook/data-binding/android/wire-up-controls.md
+++ b/docs/documentation/reactiveui/handbook/data-binding/android/wire-up-controls.md
@@ -127,6 +127,23 @@ against the inflated row view, from its constructor body:
     this.WireUpControls();
 ```
 
+A fragment calls a two-argument overload instead, since it wires against its inflated view rather than itself.
+`LessonNotesFragment` uses the convenience form of that overload, which takes only the view and applies
+`Implicit` without naming it:
+
+```csharp
+View view = inflater!.Inflate(Resource.Layout.fragment_lesson_notes, container, false)
+    ?? throw new InvalidOperationException("Inflating fragment_lesson_notes produced no view.");
+
+// The convenience overload: no resolve strategy to state, since Implicit is what most fragments want.
+AndroidX.ControlFetcherMixins.WireUpControls(this, view);
+```
+
+The core, non-AndroidX `ReactiveUI.ControlFetcherMixins` declares the same two overloads for the platform's own
+`Android.App.Fragment`. This page does not show them: attaching a classic `Fragment` to an activity needs the
+classic `Activity.FragmentManager`, which the Android platform itself deprecated at API level 28, and the
+timetable app targets a newer API than that.
+
 ### Explicit opt-in
 
 Under `ExplicitOptIn`, only a property that carries `[WireUpResource]` is wired; every other property is
@@ -166,6 +183,23 @@ instead of as an extension method:
 AndroidX.ControlFetcherMixins.WireUpControls(this, view, ControlFetcherMixins.ResolveStrategy.ExplicitOptIn);
 ```
 
+`[WireUpResource]`'s constructor argument is stored on `ResourceNameOverride`; `GetResourceName()` reads it as a
+fallback when a property carries no override. `LessonDetailFragment` also reads it directly, off the attribute
+itself:
+
+```csharp
+// The name SubjectLabel was wired under: WireUpResourceAttribute.ResourceNameOverride, read directly
+// rather than through GetResourceName().
+WireUpResourceAttribute? subjectAttribute = typeof(LessonDetailFragment)
+    .GetProperty(nameof(SubjectLabel))!
+    .GetCustomAttribute<WireUpResourceAttribute>();
+TimetableLog.Info($"SubjectLabel's resource name override: {subjectAttribute?.ResourceNameOverride}.");
+```
+
+```text
+SubjectLabel's resource name override: detailSubject.
+```
+
 The fragment's layout carries a third control, `detailIcon`, that no property wires. `GetControl` fetches it
 directly instead, resolving it against a `View` and the fragment's assembly:
 
@@ -249,9 +283,10 @@ fetches `extraLabel` directly on the activity, the same way `LessonDetailFragmen
 `LessonCountBadgeHost`, a host with no view model, wires its one label through the auto-wireup constructor of
 `LayoutViewHostUnsafe` instead of a call to `WireUpControls` in its own body. Its constructor passes
 `attachToRoot: false`, `performAutoWireup: true` and `resolveStrategy: ControlFetcherMixins.ResolveStrategy.Implicit`
-to the base constructor, which performs the same `Implicit` wire-up once inflation finishes; the constructor's
-own body adds nothing further. `ReactiveViewHostUnsafe<TViewModel>` offers the same constructor for a host with a view
-model. The reflection-free `LayoutViewHost` and `ReactiveViewHost<TViewModel>` have no such constructor.
+to the base constructor, which calls the `ILayoutViewHost` overload of `WireUpControls` itself once inflation
+finishes; the constructor's own body adds nothing further. `ReactiveViewHostUnsafe<TViewModel>` offers the same
+constructor for a host with a view model, and `FirstLessonPeekHost` passes the same two flags to it. The
+reflection-free `LayoutViewHost` and `ReactiveViewHost<TViewModel>` have no such constructor.
 
 A host that wires its child without reflection, and stays trim- and AOT-safe, uses the `bind`-callback
 constructor instead and calls `FindViewById` itself. `WeekdayViewHost`, one page of the weekday pager, passes
diff --git a/docs/documentation/reactiveui/handbook/platforms/android.md b/docs/documentation/reactiveui/handbook/platforms/android.md
index 5a4b3b57..1cbba3eb 100644
--- a/docs/documentation/reactiveui/handbook/platforms/android.md
+++ b/docs/documentation/reactiveui/handbook/platforms/android.md
@@ -161,8 +161,9 @@ AbsenceConfirmationDialogFragment activated.
 Every one of these types also carries the classic reactive object surface. `Changed` and `Changing` observe
 property changes, and `PropertyChanged` and `PropertyChanging` are the .NET events behind them.
 `ThrownExceptions` reports errors raised inside reactive operators. `SuppressChangeNotifications()` pauses
-change notifications until its result is disposed. `AbsenceActivity` subscribes to `ThrownExceptions` and
-suppresses notifications while it fills in a freshly-created view model from an intent extra:
+change notifications until its result is disposed, and `AreChangeNotificationsEnabled()` reports whether a
+suppression is active. `AbsenceActivity` subscribes to `ThrownExceptions` and suppresses notifications while it
+fills in a freshly-created view model from an intent extra:
 
 ```csharp
 _ = ThrownExceptions.Subscribe(static error => TimetableLog.Info($"AbsenceActivity reported an exception: {error.Message}"));
@@ -176,6 +177,42 @@ using (SuppressChangeNotifications())
 }
 ```
 
+`MainActivity` subscribes to `Changed` and `Changing` too, alongside the same `ThrownExceptions` and
+`SuppressChangeNotifications` pattern around its own `ViewModel` assignment:
+
+```csharp
+_subscriptions.Add(Changed.Subscribe(static change => TimetableLog.Info($"MainActivity property changed: {change.PropertyName}.")));
+_subscriptions.Add(Changing.Subscribe(static change => TimetableLog.Info($"MainActivity property changing: {change.PropertyName}.")));
+_subscriptions.Add(ThrownExceptions.Subscribe(static error => TimetableLog.Info($"MainActivity reported an exception: {error.Message}.")));
+
+using (SuppressChangeNotifications())
+{
+    ViewModel = new TimetableViewModel();
+}
+```
+
+`LessonViewHolder` shows `AreChangeNotificationsEnabled()` alongside the rest of the surface, reading it both
+while a suppression is active and after it ends:
+
+```csharp
+using (SuppressChangeNotifications())
+{
+    TimetableLog.Info($"Change notifications enabled while suppressed: {AreChangeNotificationsEnabled()}.");
+}
+
+TimetableLog.Info($"Change notifications enabled once the suppression ends: {AreChangeNotificationsEnabled()}.");
+```
+
+```text
+Change notifications enabled while suppressed: False.
+Change notifications enabled once the suppression ends: True.
+```
+
+Every other reactive Android base class on this page (`ReactiveDialogFragment`, `ReactiveFragment`,
+`ReactiveFragmentActivity` and `ReactivePreferenceFragment`) carries the identical surface, inherited from the
+same `IReactiveObject` and `IHandleObservableErrors` interfaces; the app does not repeat the same four
+subscriptions on every one of them.
+
 ## Move between activities and read the result
 
 `StartActivityForResultAsync` replaces the classic `StartActivityForResult` plus an `OnActivityResult` override
@@ -209,6 +246,31 @@ _subscriptions.Add(ActivityResult.Subscribe(static result =>
 MainActivity received an activity result: Ok.
 ```
 
+`ReactiveUI.ReactiveActivity<TViewModel>` carries its own `ActivityResult` and `StartActivityForResultAsync`,
+separate from the AndroidX base class's members above. `AbsenceActivity` uses both overloads to start
+`AbsenceNotePromptActivity`, a small screen offering to add a note to the report, and subscribes to its own
+`ActivityResult`:
+
+```csharp
+_ = ActivityResult.Subscribe(static result =>
+    TimetableLog.Info($"AbsenceActivity's own ActivityResult observed request {result.RequestCode}: {result.ResultCode}."));
+
+Intent notePromptIntent = new(this, typeof(AbsenceNotePromptActivity));
+notePromptIntent.PutExtra(SubjectExtra, ViewModel!.Subject);
+(Android.App.Result ResultCode, Intent? Intent) notePromptByIntent = await StartActivityForResultAsync(notePromptIntent, 400);
+TimetableLog.Info($"Note prompt (by intent) finished with {notePromptByIntent.ResultCode}.");
+
+(Android.App.Result ResultCode, Intent? Intent) notePromptByType = await StartActivityForResultAsync(typeof(AbsenceNotePromptActivity), 401);
+TimetableLog.Info($"Note prompt (by type) finished with {notePromptByType.ResultCode}.");
+```
+
+```text
+AbsenceActivity's own ActivityResult observed request 400: Ok.
+Note prompt (by intent) finished with Ok.
+AbsenceActivity's own ActivityResult observed request 401: Ok.
+Note prompt (by type) finished with Ok.
+```
+
 Only the activity base classes carry `ActivityResult` and `StartActivityForResultAsync`; the fragment and
 dialog base classes do not navigate between activities.
 
@@ -315,13 +377,19 @@ tags each page this way as it creates it, then reads the tag straight back to sh
 
 ```csharp
 WeekdayViewHost host = new(this, parent);
-View view = host.ToView()!;
+
+// LayoutViewHost's implicit operator to View, used here instead of the ToView() alternate.
+View? convertedView = host;
+View view = convertedView ?? throw new InvalidOperationException("WeekdayViewHost converted to a null View.");
 
 WeekdayViewHost? typedHost = view.GetViewHost<WeekdayViewHost>();
 ILayoutViewHost? untypedHost = view.GetViewHost();
 TimetableLog.Info($"Weekday page tagged: typed={typedHost is not null}, untyped={untypedHost is not null}.");
 ```
 
+`LayoutViewHost` also converts to `View?` implicitly, the way this excerpt does instead of calling `ToView()`;
+both read the same backing field.
+
 ## Show a list with RecyclerView
 
 `ReactiveRecyclerViewAdapter<TViewModel, TCollection>` adapts a collection of view models to a `RecyclerView`.
@@ -331,6 +399,15 @@ TimetableLog.Info($"Weekday page tagged: typed={typedHost is not null}, untyped=
 ```csharp
 public sealed class LessonsRecyclerAdapter(ObservableCollection<LessonViewModel> lessons) : ReactiveRecyclerViewAdapter<LessonViewModel, ObservableCollection<LessonViewModel>>(lessons)
 {
+    /// <summary>The view type for a lesson held in the science lab, room 7.</summary>
+    private const int LabViewType = 1;
+
+    /// <summary>The view type for every other lesson.</summary>
+    private const int StandardViewType = 0;
+
+    public override int GetItemViewType(int position, LessonViewModel? viewModel) =>
+        viewModel?.Room == "7" ? LabViewType : StandardViewType;
+
     /// <inheritdoc/>
     public override RecyclerView.ViewHolder OnCreateViewHolder(ViewGroup parent, int viewType)
     {
@@ -341,11 +418,37 @@ public sealed class LessonsRecyclerAdapter(ObservableCollection<LessonViewModel>
         View itemView = inflater.Inflate(Resource.Layout.lesson_item, parent, false)
             ?? throw new InvalidOperationException("Inflating lesson_item produced no view.");
 
+        if (viewType == LabViewType)
+        {
+            TimetableLog.Info("Lesson row created for the science lab (room 7).");
+        }
+
         return new LessonViewHolder(itemView);
     }
 }
 ```
 
+```text
+Lesson row created for the science lab (room 7).
+```
+
+`GetItemViewType(int, TViewModel?)` is the overload to override: it gets the position and the view model
+already resolved, so a view type can depend on the view model's own data. `RecyclerView` itself calls the
+non-generic `GetItemViewType(int)` while it lays out and recycles rows; the base class implements that overload
+once, to resolve the view model at the given position and forward to the one above, so app code never overrides
+it directly. `ItemCount`, inherited from `RecyclerView.Adapter`, reports how many rows the adapter currently
+holds:
+
+```csharp
+LessonsRecyclerAdapter lessonsAdapter = new(ViewModel.Lessons);
+LessonsRecyclerView!.SetAdapter(lessonsAdapter);
+TimetableLog.Info($"Lessons adapter reports {lessonsAdapter.ItemCount} items.");
+```
+
+```text
+Lessons adapter reports 6 items.
+```
+
 `ReactiveRecyclerViewAdapter<TViewModel>` is the lower-level, single-generic form: it takes an
 `IObservable<IReactiveChangeSet<TViewModel>>` directly instead of a collection, for pages built from a query or
 a filter rather than a plain list. `LessonViewHolder`, the row this adapter creates, derives from
@@ -375,10 +478,19 @@ constructor passes `itemView` straight to the base constructor, then does the re
 
 `Selected` reports the row's adapter position when it is tapped; `SelectedWithViewModel` reports the view model
 it holds at that moment instead. `LongClicked` and `LongClickedWithViewModel` report the same two shapes for a
-long press. `AreChangeNotificationsEnabled()`, `View` and `AllPublicProperties` round out the holder's surface:
-the first mirrors `SuppressChangeNotifications`, `View` is the inherited `LayoutViewHost.View`, and
-`AllPublicProperties` lists the holder's public properties for reflection-based wiring. The holder's
-`[DynamicallyAccessedMembers]` annotation tells the trimmer to keep those properties, so it stays safe to trim.
+long press. The constructor also reads the holder's own `View`, the inherited `LayoutViewHost.View`. It shows
+the rest of the reactive object surface too, the same surface covered under
+[Detect activation](#detect-activation) above: `Changed`, `Changing`, `ThrownExceptions`,
+`SuppressChangeNotifications()` and `AreChangeNotificationsEnabled()`.
+
+```csharp
+TimetableLog.Info($"Lesson row view: {View.GetType().Name}.");
+```
+
+`AllPublicProperties`, a `protected` property the reflection-based `*Unsafe` hosts fill for older code that
+reads it, stays unused here: `LessonViewHolder` wires its controls through the ordinary `WireUpControls()` call
+above, which needs no such cache. The holder's `[DynamicallyAccessedMembers]` annotation tells the trimmer to
+keep its public properties regardless, so it stays safe to trim.
 
 ## Page through view models
 
@@ -416,6 +528,10 @@ Weekday pager adapter reports 5 pages.
 Weekday pager moved to Tuesday.
 ```
 
+`InstantiateItem`, `DestroyItem` and `IsViewFromObject` are the `PagerAdapter` overrides that do this work.
+AndroidX's `ViewPager` calls them internally as pages scroll into and out of range. `WeekdayPagerActivity` never
+calls them directly; it only builds the adapter and hands it to `pager.Adapter`.
+
 `ReactivePagerAdapter<TViewModel>` is the single-generic form: it pages any
 `IObservable<IReactiveChangeSet<TViewModel>>`, the same change-set stream `ToReactiveChangeSet()` produces from
 a collection, rather than requiring the collection itself.
@@ -626,7 +742,33 @@ Device orientation: Rotation0.
 
 `UsbManagerExtensions.PermissionRequested` turns a USB permission dialog into a stream of the granted result,
 for either a `UsbDevice` or a `UsbAccessory`, instead of a `BroadcastReceiver` your code registers and
-unregisters. It needs a physical or emulated USB device attached, so this example does not exercise it.
+unregisters. Some timetable devices use a USB barcode scanner to check students in, so `MainActivity` asks for
+permission to talk to any USB device or accessory already plugged in when it starts:
+
+```csharp
+private void RequestAttendanceScannerPermission()
+{
+    if (GetSystemService(UsbService) is not UsbManager usbManager)
+    {
+        return;
+    }
+
+    foreach (UsbDevice device in usbManager.DeviceList?.Values ?? [])
+    {
+        _subscriptions.Add(usbManager.PermissionRequested(this, device)
+            .Subscribe(granted => TimetableLog.Info($"USB device {device.DeviceName} permission granted: {granted}.")));
+    }
+
+    foreach (UsbAccessory accessory in usbManager.GetAccessoryList() ?? [])
+    {
+        _subscriptions.Add(usbManager.PermissionRequested(this, accessory)
+            .Subscribe(granted => TimetableLog.Info($"USB accessory {accessory.Model} permission granted: {granted}.")));
+    }
+}
+```
+
+Neither loop finds a device on a plain emulator, so this method logs nothing unless a scanner is attached. A
+physical or emulated USB device is still needed to see the granted result itself.
 
 ## At a glance
 
@@ -646,7 +788,8 @@ unregisters. It needs a physical or emulated USB device attached, so this exampl
 | `Changed` / `Changing` / `PropertyChanged` / `PropertyChanging` | Observe and raise property changes, as on any `ReactiveObject` |
 | `ThrownExceptions` | Reports errors raised inside reactive operators |
 | `SuppressChangeNotifications()` | Pauses change notifications until the result is disposed |
-| `ActivityResult` | An observable of every activity result received |
+| `AreChangeNotificationsEnabled()` | Reports whether a `SuppressChangeNotifications()` suppression is currently active |
+| `ActivityResult` | An observable of every activity result received; both `ReactiveActivity<TViewModel>` and the AndroidX activity base classes carry their own |
 | `StartActivityForResultAsync(Intent, int)` / `StartActivityForResultAsync(Type, int)` | Starts an activity and awaits its result as a `Task` |
 | `ControlFetcherMixins.WireUpControls(...)` (both namespaces) | Finds controls in a layout by naming convention; see [Wire up controls](../data-binding/android/wire-up-controls.md) |
 | `ControlFetcherMixins.GetControl(...)` | Fetches one control by resource name without a property |
@@ -654,8 +797,10 @@ unregisters. It needs a physical or emulated USB device attached, so this exampl
 | `ControlFetcherMixins.GetResourceName(PropertyInfo)` | Reads the resource name a property wires to |
 | `ControlFetcherMixins.ResolveStrategy` | `Implicit`, `ExplicitOptIn` and `ExplicitOptOut`: which properties `WireUpControls` wires |
 | `WireUpResourceAttribute` | Opts a property in under `ExplicitOptIn`, with an optional resource name override |
+| `WireUpResourceAttribute.ResourceNameOverride` | The resource name the constructor argument set, or `null` |
 | `IgnoreResourceAttribute` | Opts a property out under `ExplicitOptOut` |
 | `LayoutViewHost` | Inflates a layout into a `View` your code owns, wiring its children by hand with no reflection |
+| `LayoutViewHost.implicit operator View?(LayoutViewHost)` | Converts a host to its backing `View`, the same value `ToView()` returns |
 | `LayoutViewHostUnsafe` | A `LayoutViewHost` whose constructor can wire its children by reflection (auto-wireup) |
 | `ReactiveViewHost<TViewModel>` | A `LayoutViewHost` that is also an `IViewFor<TViewModel>` |
 | `ReactiveViewHostUnsafe<TViewModel>` | A `ReactiveViewHost<TViewModel>` whose constructor can wire its children by reflection (auto-wireup) |
@@ -663,9 +808,13 @@ unregisters. It needs a physical or emulated USB device attached, so this exampl
 | `ViewMixins.GetViewHost()` / `GetViewHost<T>()` | Reads the host a `View` was tagged with when it was hosted |
 | `AndroidX.ReactiveRecyclerViewAdapter<TViewModel, TCollection>` | Adapts a collection of view models to a `RecyclerView` |
 | `AndroidX.ReactiveRecyclerViewAdapter<TViewModel>` | Adapts a change-set stream of view models to a `RecyclerView` |
+| `GetItemViewType(int, TViewModel?)` | Override to pick a view type from the position and its view model |
+| `GetItemViewType(int)` | The non-generic override `RecyclerView` calls; resolves the view model and forwards to the overload above |
+| `ItemCount` | The number of rows the adapter currently holds |
 | `AndroidX.ReactiveRecyclerViewViewHolder<TViewModel>` | A `RecyclerView.ViewHolder` that is an `IViewFor<TViewModel>`, with `Selected`, `SelectedWithViewModel`, `LongClicked` and `LongClickedWithViewModel` |
 | `AndroidX.ReactivePagerAdapter<TViewModel, TCollection>` | Pages a collection of view models through a `ViewPager` |
 | `AndroidX.ReactivePagerAdapter<TViewModel>` | Pages a change-set stream of view models through a `ViewPager` |
+| `InstantiateItem(ViewGroup, int)` / `DestroyItem(ViewGroup, int, Object)` / `IsViewFromObject(View, Object)` | `PagerAdapter` overrides `ViewPager` calls internally as pages scroll into and out of range |
 | `ContextExtensions.ServiceBound(...)` / `ServiceBound<TBinder>(...)` | Binds a service and exposes its binder as a stream |
 | `AutoSuspendHelper` | Turns activity lifecycle callbacks into suspend/resume signals |
 | `AutoSuspendHelper.LatestBundle` | The bundle from the most recent `OnSaveInstanceState`, or `null` on a cold launch |
@@ -675,4 +824,4 @@ unregisters. It needs a physical or emulated USB device attached, so this exampl
 | `BundleSuspensionDriver.SaveState<T>(T)` / `LoadState()` | The untyped, reflection-based overloads; not callable from a trimmed or AOT page project |
 | `PlatformOperations.GetOrientation()` | Returns the display's current rotation, such as `"Rotation0"` |
 | `SharedPreferencesExtensions.PreferenceChanged()` | A stream of the key each changed shared preference used |
-| `UsbManagerExtensions.PermissionRequested(...)` | A stream of the granted result for a USB device or accessory permission request; needs real or emulated hardware |
+| `UsbManagerExtensions.PermissionRequested(...)` | A stream of the granted result for a USB device or accessory permission request |
diff --git a/docs/documentation/reactiveui/handbook/platforms/maui.md b/docs/documentation/reactiveui/handbook/platforms/maui.md
index 18f39e33..37dd23c7 100644
--- a/docs/documentation/reactiveui/handbook/platforms/maui.md
+++ b/docs/documentation/reactiveui/handbook/platforms/maui.md
@@ -692,6 +692,38 @@ Console.WriteLine(host.ViewModel.Recipes.Count);
 // 3
 ```
 
+### Observe or customize each resolution
+
+Both hosts call a protected `ResolveViewForViewModel(object? viewModel, string? contract)` method internally whenever `ViewModel` or the view contract changes. Override it in a subclass to run code around the base resolution, for example to log which view model resolved.
+
+```csharp
+AppLocator.CurrentMutable.Register<IViewFor<RecipeListViewModel>>(static () => new RecipeListContentView());
+
+LoggingViewModelViewHost host = new();
+host.ViewModel = new RecipeListViewModel(new RecipeBookScreen());
+host.ViewModel = null;
+
+Console.WriteLine(string.Join(", ", host.ResolvedViewModelTypes));
+
+// Output:
+// RecipeListViewModel
+```
+
+`ViewModelViewHost<TViewModel>` overrides the same method, so a generic host can add behavior too:
+
+```csharp
+AppLocator.CurrentMutable.Register<IViewFor<RecipeListViewModel>>(static () => new RecipeListContentView());
+
+LoggingRecipeViewHost host = new();
+host.ViewModel = new RecipeListViewModel(new RecipeBookScreen());
+host.ViewModel = new RecipeListViewModel(new RecipeBookScreen());
+
+Console.WriteLine(host.ResolutionCount);
+
+// Output:
+// 2
+```
+
 ## Show a view only the service locator knows
 
 `ViewModelViewHost` and `RoutedViewHost` ask the [view locator](../view-location/index.md) for a view in two steps, and neither step uses reflection. The first step is the view lookup the source generator writes for every view class in your project that implements `IViewFor<T>`. That lookup asks Splat's service locator for the view first, which is why the examples above can register `RecipeListContentView` there. The second step is the views you add to the view locator with `Map`. So the hosts are safe to trim and to publish with Native AOT.
@@ -805,6 +837,22 @@ Console.WriteLine(invertedVisibleIsFalse);
 // False
 ```
 
+`GetAffinityForObjects` reports how well each converter matches a binding; the [converter service](../../../binding/converters.md) calls it when it picks a converter. Both converters return the same built-in score.
+
+On the Windows build, both converters' `TryConvert` overloads convert to and from `Microsoft.UI.Xaml.Visibility` instead of the MAUI `Visibility` type shown above. This page's plain `net10.0` target does not compile against WinUI, so the example project does not exercise those overloads.
+
+```csharp
+BooleanToVisibilityTypeConverter toVisibility = new();
+VisibilityToBooleanTypeConverter toBoolean = new();
+
+Console.WriteLine(toVisibility.GetAffinityForObjects());
+Console.WriteLine(toBoolean.GetAffinityForObjects());
+
+// Output:
+// 2
+// 2
+```
+
 ## Register MAUI's own services
 
 `WithMaui` and `UseReactiveUI` load `ReactiveUI.Maui.Registrations`, the module that fills a [dependency resolver](../registration.md) with the two services MAUI binding needs: the activation fetcher and the two visibility converters above. `ReactiveUI.Maui` and plain `ReactiveUI` each have a type named `Registrations`, so an app that needs both keeps the platform one's full name, as the example below does.
@@ -823,7 +871,7 @@ Console.WriteLine(resolver.GetServices<IBindingTypeConverter>().Count());
 // 2
 ```
 
-Two further members appear only in the Windows build of `ReactiveUI.Maui`, alongside its WinUI-based sequencer. `AutoDataTemplateBindingHook` supplies a default `DataTemplate` for an `ItemsControl` that has none of its own, so an unbound item still shows through `ViewModelViewHost`. `ReactiveUserControl<TViewModel>` is a WinUI `UserControl` base with the same `ViewModel`/`BindingContext` pattern as the page bases above. Neither needs WinUI to compile against on this page's plain `net10.0` target, so the example project does not exercise them.
+Two further members appear only in the Windows build of `ReactiveUI.Maui`, alongside its WinUI-based sequencer. `AutoDataTemplateBindingHook` supplies a default `DataTemplate` for an `ItemsControl` that has none of its own, so an unbound item still shows through `ViewModelViewHost`. Its `DefaultItemTemplate` property builds that template. Its `ExecuteHook` method is the binding hook that a `Bind`/`OneWayBind` call runs before setting the target, the same way `ContentControlBindingHook` does on WinForms. `ReactiveUserControl<TViewModel>` is a WinUI `UserControl` base with the same `ViewModel`/`BindingContext` pattern as the page bases above. None of the three needs WinUI to compile against on this page's plain `net10.0` target, so the example project does not exercise them.
 
 ## Check device orientation
 
@@ -880,12 +928,16 @@ Console.WriteLine(operations.GetOrientation() ?? "(null)");
 | `ViewModelViewHost.ViewContract` / `ViewContractObservable` | The contract used to resolve the view, fixed or as a stream; each new contract resolves the view again. |
 | `ViewModelViewHost.ContractFallbackByPass` | Stops falling back to the default view for an unregistered contract. |
 | `ViewModelViewHost.ViewLocator` | Overrides the service-located locator for this host alone. |
-| `ViewModelViewHost.ResolveViewForViewModel(object, string?)` | Protected resolution member `ViewModel` and contract changes call. |
+| `ViewModelViewHost.ResolveViewForViewModel(object?, string?)` | Protected resolution method `ViewModel` and contract changes call; override to observe or customize a resolution. |
 | `ViewModelViewHost<TViewModel>` | Types `ViewModel` to the view model's own type. |
+| `ViewModelViewHost<TViewModel>.ResolveViewForViewModel(object?, string?)` | The generic host's own override of the resolution method above. |
 | `BooleanToVisibilityTypeConverter` | Converts `bool` to `Visibility`. |
+| `BooleanToVisibilityTypeConverter.GetAffinityForObjects()` / `VisibilityToBooleanTypeConverter.GetAffinityForObjects()` | Report the built-in affinity score the [converter service](../../../binding/converters.md) uses to pick a converter. |
 | `VisibilityToBooleanTypeConverter` | Converts `Visibility` back to `bool`. |
 | `BooleanToVisibilityHint` | `None`, `Inverse` and `UseHidden`, the hints both converters read. |
 | `ReactiveUI.Maui.Registrations` | Registers the activation fetcher and the two converters. |
 | `AutoDataTemplateBindingHook` | Windows-only default item template for an unbound `ItemsControl`. |
+| `AutoDataTemplateBindingHook.DefaultItemTemplate` | The `DataTemplate` the hook assigns; Windows-only. |
+| `AutoDataTemplateBindingHook.ExecuteHook(...)` | The binding hook `Bind`/`OneWayBind` runs; Windows-only. |
 | `ReactiveUserControl<TViewModel>` | Windows-only WinUI `UserControl` base with the same sync. |
 | `PlatformOperations` | Reports device orientation; always `null` on MAUI. |
diff --git a/docs/documentation/reactiveui/handbook/platforms/winforms.md b/docs/documentation/reactiveui/handbook/platforms/winforms.md
index fc4020d5..92b91ce0 100644
--- a/docs/documentation/reactiveui/handbook/platforms/winforms.md
+++ b/docs/documentation/reactiveui/handbook/platforms/winforms.md
@@ -215,7 +215,39 @@ directly.
 `TableContentSetMethodBindingConverter`. Each gives an affinity of 10 to a source that implements
 `IEnumerable<Control>` against its own collection type, and 0 to anything else. The generated binding fills
 both collection types itself, so these converters matter only for code that asks the converter registry
-directly.
+directly, the way the calls below do.
+
+```csharp
+PanelSetMethodBindingConverter converter = new();
+
+Console.WriteLine(converter.GetAffinityForObjects(typeof(List<Label>), typeof(Control.ControlCollection)));
+Console.WriteLine(converter.GetAffinityForObjects(typeof(string), typeof(Control.ControlCollection)));
+
+// Output:
+// 10
+// 0
+```
+
+`PerformSet` is the other half: it is what the generated binding calls to clear the target collection and add
+every control from the new value.
+
+```csharp
+using Panel panel = new();
+using Label first = new() { Text = "Chicken soup" };
+using Label second = new() { Text = "Bread rolls" };
+
+PanelSetMethodBindingConverter converter = new();
+converter.PerformSet(panel.Controls, new List<Label> { first, second }, arguments: null);
+
+Console.WriteLine(panel.Controls.Count);
+Console.WriteLine(((Label)panel.Controls[0]).Text);
+
+// Output:
+// 2
+// Chicken soup
+```
+
+`TableContentSetMethodBindingConverter` works the same way, against a `TableLayoutControlCollection` instead.
 
 ## Detect activation
 
@@ -561,6 +593,10 @@ last changed `ViewModel` when the router subscription assigned the member's card
 | `ActivationForViewFetcher` | Turns a control's handle and visibility events into the activation signal |
 | `PlatformOperations` | Answers `GetOrientation()`; always `null` on the desktop |
 | `PanelSetMethodBindingConverter` | Binds a collection of controls into a `Panel` |
+| `PanelSetMethodBindingConverter.GetAffinityForObjects(Type?, Type?)` | Scores 10 for a source of `Control`s against `Control.ControlCollection`, else 0 |
+| `PanelSetMethodBindingConverter.PerformSet(object?, object?, object?[]?)` | Clears the panel's `Controls` and adds every control from the new value |
 | `TableContentSetMethodBindingConverter` | Binds a collection of controls into a `TableLayoutPanel` |
+| `TableContentSetMethodBindingConverter.GetAffinityForObjects(Type?, Type?)` | Scores 10 for a source of `Control`s against `TableLayoutControlCollection`, else 0 |
+| `TableContentSetMethodBindingConverter.PerformSet(object?, object?, object?[]?)` | Clears the table's `Controls` and adds every control from the new value |
 | `ContentControlBindingHook` | A binding hook that always lets the binding proceed |
 | `Registrations` | The module `WithWinForms` loads: platform operations, activation fetcher, both converters, four type converters |
diff --git a/docs/documentation/reactiveui/handbook/platforms/winui.md b/docs/documentation/reactiveui/handbook/platforms/winui.md
index 0e42e93e..bcb147e6 100644
--- a/docs/documentation/reactiveui/handbook/platforms/winui.md
+++ b/docs/documentation/reactiveui/handbook/platforms/winui.md
@@ -161,12 +161,92 @@ also pushes the new value onto `ViewContractObservable`, so a binding that watch
 no view is registered for the routed view model, `ResolveViewForViewModel` throws an `InvalidOperationException`
 rather than showing nothing.
 
+Set `ViewContract` before the router navigates, and the host asks the view locator for the view registered under
+that contract, falling back to the contract-free view when none matches. A `ViewLocator` set on the host, rather
+than on the builder, keeps a set of mappings private to that host, the way each example below does.
+
+```csharp
+DefaultViewLocator locator = new();
+locator.Map<SensorMaintenanceViewModel, SensorMaintenanceView>();
+locator.Map<SensorMaintenanceViewModel, SensorMaintenanceCompactView>("Compact");
+
+WeatherShell defaultShell = new();
+RoutedViewHost defaultHost = new() { ViewLocator = locator, Router = defaultShell.Router };
+_ = defaultShell.Router.Navigate.Execute(new SensorMaintenanceViewModel(defaultShell, "Harbor", "Replace the wind vane")).Subscribe();
+Console.WriteLine(((SensorMaintenanceView)defaultHost.Content).Summary);
+
+WeatherShell compactShell = new();
+RoutedViewHost compactHost = new() { ViewLocator = locator, Router = compactShell.Router, ViewContract = "Compact" };
+_ = compactShell.Router.Navigate.Execute(new SensorMaintenanceViewModel(compactShell, "Riverside", "Clean the rain gauge")).Subscribe();
+Console.WriteLine(((SensorMaintenanceCompactView)compactHost.Content).Summary);
+Console.WriteLine(compactHost.ViewContract);
+
+string? published = null;
+using IDisposable subscription = ((IObservable<string?>)compactHost.GetValue(RoutedViewHost.ViewContractObservableProperty))
+    .Subscribe(contract => published = contract);
+Console.WriteLine(published);
+```
+
+```text
+Harbor: Replace the wind vane
+Riverside
+Compact
+Compact
+```
+
+`RoutedViewHost<TViewModel>` reads `ViewContractObservableProperty` the same way, through its own generic
+`ViewContractObservableProperty` field.
+
 `ViewModelViewHost` and its generic form add `ViewModel` and `ContractFallbackByPass` to the same set of properties
 (`ViewModelProperty` and `ContractFallbackByPassProperty`). Assign `null` and the host shows `DefaultContent`. When
 `ContractFallbackByPass` is `false` and no view matches the contract, the host falls back to a view without one;
 when it is `true`, that fallback is skipped. If no view is found at all, the host logs a warning and shows
 `DefaultContent` instead of throwing.
 
+`ViewModelViewHost` resolves through the protected `ResolveViewForViewModel(object?, string?)`, called once for the
+freshly constructed host and again for every later `ViewModel` change. Override it, calling the base implementation
+first, to add behavior of your own, such as recording which view it chose. `ViewContract` still republishes onto
+`ViewContractObservable`, the same stream the `ViewContractObservableProperty` dependency property holds. On
+`ViewModelViewHost`, though, that stream drives the platform-orientation contract the host starts with, not a later
+`ViewContract` assignment. Change the view by assigning a new `ViewModel` instead of by reassigning the contract
+after construction.
+
+```csharp
+DefaultViewLocator locator = new();
+locator.Map<WeatherReading, WeatherReadingRowView>();
+
+AnalyticsViewModelViewHost host = new() { ViewLocator = locator };
+WeatherReading riverside = new("Riverside", 18.5, isStormy: false);
+WeatherReading highlands = new("Highlands", 9.0, isStormy: true);
+
+host.ViewModel = riverside;
+host.ViewModel = highlands;
+
+Console.WriteLine(string.Join(", ", host.ResolvedViews));
+
+host.ViewContract = "Wide";
+Console.WriteLine(host.ViewContract);
+
+string? published = null;
+using IDisposable subscription = host.ViewContractObservable.Subscribe(contract => published = contract);
+Console.WriteLine(published);
+
+bool sameObservable = ReferenceEquals(host.ViewContractObservable, host.GetValue(ViewModelViewHost.ViewContractObservableProperty));
+Console.WriteLine(sameObservable);
+```
+
+```text
+(nothing), WeatherReadingRowView, WeatherReadingRowView
+Wide
+Wide
+True
+```
+
+`AnalyticsViewModelViewHost` is a `ViewModelViewHost` subclass that overrides `ResolveViewForViewModel` to append
+the resolved view's type name to a list. The first entry, `(nothing)`, is the empty host's own construction-time
+resolution, before any `ViewModel` is assigned. `ViewModelViewHost<TViewModel>` overrides the generic
+`ResolveViewForViewModel(TViewModel?, string?)` the same way.
+
 Both hosts derive from `TransitioningContentControl`, a plain `ContentControl` with a single transition. It carries
 no members of its own beyond what `ContentControl` gives it, and the example also uses it directly, further down,
 to wrap a panel that appears and disappears.
@@ -248,6 +328,41 @@ their conversion hint is a `BooleanToVisibilityHint`, with members `None`, `Inve
 `Visibility.Collapsed`; with `Inverse`, the mapping flips. `ToBoolean.TryConvert` does the opposite conversion, so
 the assertion above proves that converting a `Visibility` back with the same hint reproduces the original flag.
 
+`GetAffinityForObjects()` is how ReactiveUI's binding resolution picks a converter: it asks every registered
+`IBindingTypeConverter` for its affinity and uses the one with the highest score. Both converters return the same
+built-in score. `BooleanToVisibilityHint.UseHidden` asks for `Visibility.Hidden` instead of `Visibility.Collapsed`
+for the non-visible value; WinUI's `Visibility` enum has no `Hidden` member, so the converter ignores the hint there.
+
+```csharp
+BooleanToVisibilityTypeConverter converter = new();
+
+_ = converter.TryConvert(false, BooleanToVisibilityHint.None, out Visibility none);
+_ = converter.TryConvert(false, BooleanToVisibilityHint.UseHidden, out Visibility useHidden);
+
+Console.WriteLine(none);
+Console.WriteLine(useHidden);
+Console.WriteLine(none == useHidden);
+```
+
+```text
+Collapsed
+Collapsed
+True
+```
+
+```csharp
+BooleanToVisibilityTypeConverter toVisibility = new();
+VisibilityToBooleanTypeConverter toBoolean = new();
+
+Console.WriteLine(toVisibility.GetAffinityForObjects());
+Console.WriteLine(toBoolean.GetAffinityForObjects());
+```
+
+```text
+2
+2
+```
+
 ## Fill a list without an `ItemTemplate`
 
 `AutoDataTemplateBindingHook` watches every binding that sets an `ItemsControl`'s `ItemsSource`. When the control
@@ -505,14 +620,14 @@ fired, so this fresh subscription has nothing to deliver yet, and only the affin
 | `WinUIMainThreadScheduler` | The shared `DispatcherQueueSequencer.Main` sequencer for the WinUI UI thread. |
 | `WinUI.Registrations` | The `IWantsToRegisterStuff` `WithWinUI` installs; registers the fetcher, both converters, `PlatformOperations` and `AutoDataTemplateBindingHook`. |
 | `WinUI.ActivationForViewFetcher` | Reports affinity `10` for any `FrameworkElement`; its activation stream follows `Loading`/`Unloaded`, gated on `IsHitTestVisible`. |
-| `RoutedViewHost` / `RoutedViewHost<TViewModel>` | Shows the view for whichever page is on top of a `Router`'s stack. Finds generated and `Map` views without reflection. Properties: `Router`, `DefaultContent`, `ViewContract`, `ViewContractObservable`, `ViewLocator`. |
-| `ViewModelViewHost` / `ViewModelViewHost<TViewModel>` | Shows the view for a view model you assign directly. Adds `ViewModel` and `ContractFallbackByPass` to the routed host's properties. |
+| `RoutedViewHost` / `RoutedViewHost<TViewModel>` | Shows the view for whichever page is on top of a `Router`'s stack. Finds generated and `Map` views without reflection. Properties: `Router`, `DefaultContent`, `ViewContract`, `ViewContractObservable` (backed by `ViewContractObservableProperty`), `ViewLocator`. |
+| `ViewModelViewHost` / `ViewModelViewHost<TViewModel>` | Shows the view for a view model you assign directly. Adds `ViewModel` and `ContractFallbackByPass` to the routed host's properties. `ResolveViewForViewModel` is the protected method both override to resolve and show a view. |
 | `ReactivePage<TViewModel>` | A `Page` that implements `IViewFor<TViewModel>` through a `ViewModel` dependency property. |
 | `ReactiveUserControl<TViewModel>` | A `UserControl` that implements `IViewFor<TViewModel>` the same way. |
 | `TransitioningContentControl` | A `ContentControl` with a single transition; the base class both view hosts build on. |
 | `AutoDataTemplateBindingHook` | Assigns `DefaultItemTemplate` to an `ItemsControl` bound with no `ItemTemplate` of its own. The template names only WinUI types, so it works in a code-only app. |
 | `RoutedViewHostUnsafe` / `ViewModelViewHostUnsafe` | The hosts with one more lookup step: the service locator, for `IViewFor<T>` of the view model's run-time type. Marked `[RequiresDynamicCode]`. |
 | `AutoDataTemplateBindingHookUnsafe` | Replaces the safe hook's default template with its own `DefaultItemTemplate`, which hosts each item in a `ViewModelViewHostUnsafe`. Marked `[RequiresDynamicCode]`. |
-| `BooleanToVisibilityTypeConverter` / `VisibilityToBooleanTypeConverter` | Convert between `bool` and `Visibility`, honoring a `BooleanToVisibilityHint`. |
+| `BooleanToVisibilityTypeConverter` / `VisibilityToBooleanTypeConverter` | Convert between `bool` and `Visibility`, honoring a `BooleanToVisibilityHint`. `GetAffinityForObjects()` returns the same built-in score, `2`, for both. |
 | `BooleanToVisibilityHint` | `None`, `Inverse` and `UseHidden`; WinUI ignores `UseHidden`. |
 | `PlatformOperations` | `GetOrientation()` always returns `null` on WinUI. |
diff --git a/docs/documentation/reactiveui/handbook/view-location/extending-iviewfor.md b/docs/documentation/reactiveui/handbook/view-location/extending-iviewfor.md
index ff7233cd..e352c0c4 100644
--- a/docs/documentation/reactiveui/handbook/view-location/extending-iviewfor.md
+++ b/docs/documentation/reactiveui/handbook/view-location/extending-iviewfor.md
@@ -3,95 +3,260 @@ Order: 2
 ---
 # Extending IViewFor
 
-There will be times where you need to extend the power of ReactiveUI view types to concrete implementations you don't control. The answer then is in extending the `IViewFor` interface so that ReactiveUI will pick up and register it against the `ViewLocator` instance.  Once you implement `IViewFor<T>`, binding methods are now available as extension methods on your class.
+[Run the complete page example](https://github.com/reactiveui/ReactiveUI/blob/main/src/examples/Documentation/Pages/view-location/view-location.csproj).
 
-Below are a few ReactiveUI base implementations that are provided for various platforms, this is not an extensive list.
+`ReactiveContentPage<TViewModel>`, `ReactiveUserControl<TViewModel>` and ReactiveUI's other platform bases give
+a view its `ViewModel` property and its bindings for free. Sometimes you cannot use one, because a control
+library already gives you the base class you must derive from: a popup, a dialog box, or a third-party window.
+C# does not let a class derive from two classes, so a view built on that base cannot also derive from a
+ReactiveUI base.
 
-- [ReactiveUserControl](https://github.com/reactiveui/ReactiveUI/blob/main/src/ReactiveUI/Platforms/windows-common/ReactiveUserControl.cs) (Windows Platform)
-- [ReactiveContentPage](https://github.com/reactiveui/ReactiveUI/blob/main/src/ReactiveUI.Maui/ReactiveContentPage.cs) (MAUI)
+The fix is the same one ReactiveUI's own bases use: implement `IViewFor<TViewModel>` yourself, on top of the
+base class you were given. `IViewFor<T>` is an interface, not a base class, so any class can implement it.
+Once a class implements `IViewFor<T>`, the view locator finds it like any other view. The binding methods
+(`Bind`, `OneWayBind`, `BindCommand`) become available on it too, the same as on a view built on a ReactiveUI base.
 
-#### **Note: As of writting this C# does not support inheritance from multiple classes.**
+```mermaid
+%%{init: {"theme": "base", "themeVariables": {"fontFamily": "Roboto, Helvetica, Arial, sans-serif", "fontSize": "15px", "primaryColor": "#DCE9FF", "primaryBorderColor": "#6C8EC4", "primaryTextColor": "#0B2447", "secondaryColor": "#E3F2E8", "secondaryBorderColor": "#7FA88C", "secondaryTextColor": "#12301C", "tertiaryColor": "#F3E5F5", "tertiaryBorderColor": "#A98BB0", "tertiaryTextColor": "#2E1437", "lineColor": "#7B8699", "textColor": "#1B1F27", "noteBkgColor": "#FFF4D6", "noteBorderColor": "#C9A94F", "noteTextColor": "#3A2A00", "actorBkg": "#DCE9FF", "actorBorder": "#6C8EC4", "actorTextColor": "#0B2447", "signalColor": "#7B8699", "signalTextColor": "#1B1F27", "labelBoxBkgColor": "#F1F3F8", "labelBoxBorderColor": "#A7AEBB", "edgeLabelBackground": "#F7F9FC", "clusterBkg": "#F7F9FC", "clusterBorder": "#C9D1DE"}}}%%
+flowchart LR
+    classDef view fill:#DCE9FF,stroke:#6C8EC4,color:#0B2447
+    classDef vm fill:#E3F2E8,stroke:#7FA88C,color:#12301C
+    classDef neutral fill:#F1F3F8,stroke:#A7AEBB,color:#1B1F27
+    Vendor(["VendorDialog\n(third-party base)"]):::neutral --> Base(["ReactiveVendorDialog&lt;TViewModel&gt;\nimplements IViewFor&lt;TViewModel&gt;"]):::view
+    Base --> Dialog(["BookReturnDialog"]):::view
+    Dialog -- "binds to" --> VM(["BookReturnViewModel"]):::vm
+```
+
+`VendorDialog` stands in for the base a real dialog library would ship. `ReactiveVendorDialog<TViewModel>`
+is the bridge you write once; every concrete dialog then derives from it the way `BookReturnDialog` does.
+
+## Bridge a third-party base
 
-## MAUI Example
+**1. Give the vendor base its own context object.** `VendorDialog` is the stand-in third-party base: an app
+must derive from it to show a dialog, and it exposes a loosely typed context, the way a host framework's
+`DataContext` or `BindingContext` works.
 
-For this example we will use [Maui.Plugins.Popup](https://github.com/reactiveui/Maui.Plugins.Popup), a library that displays popup-style modal pages for .NET MAUI.  This scenario expects that you are extending for a base implementation.  Another option is to explicitly extend each page from `IViewFor<T>`.  Choose the path that is right for you.
+```csharp
+[System.Diagnostics.DebuggerDisplay("VendorDialog DialogContext = {DialogContext}")]
+public class VendorDialog
+{
+    /// <summary>Raised when <see cref="DialogContext"/> changes.</summary>
+    public event EventHandler? DialogContextChanged;
 
-### The implementation
+    /// <summary>Raised when the dialog is shown.</summary>
+    public event EventHandler? Opened;
 
-The first thing we need to do is bridge the `PopupPage`, which is a concrete implementation, by extending from `IViewFor`.
+    /// <summary>Raised when the dialog is closed.</summary>
+    public event EventHandler? Closed;
 
-``` cs
- public abstract class BasePopupPage<TViewModel> : PopupPage, IViewFor<TViewModel>
-        where TViewModel : class
+    /// <summary>Gets or sets the context object the dialog's controls bind against.</summary>
+    public object? DialogContext
     {
-        protected readonly MultipleDisposable SubscriptionDisposables = new MultipleDisposable();
-
-        public static readonly BindableProperty ViewModelProperty =
-            BindableProperty.Create(nameof(ViewModel),
-                typeof(TViewModel),
-                typeof(IViewFor<TViewModel>),
-                (object) null,
-                BindingMode.OneWay,
-                (BindableProperty.ValidateValueDelegate) null,
-                new BindableProperty.BindingPropertyChangedDelegate(OnViewModelChanged),
-                (BindableProperty.BindingPropertyChangingDelegate) null,
-                (BindableProperty.CoerceValueDelegate) null,
-                (BindableProperty.CreateDefaultValueDelegate) null);
-
-        /// <summary>The ViewModel to display</summary>
-        public TViewModel ViewModel
+        get;
+        set
         {
-            get => (TViewModel) GetValue(ViewModelProperty);
-            set => SetValue(ViewModelProperty, (object) value);
-        }
+            if (ReferenceEquals(field, value))
+            {
+                return;
+            }
 
-        protected override void OnBindingContextChanged()
-        {
-            base.OnBindingContextChanged();
-            ViewModel = BindingContext as TViewModel;
+            field = value;
+            DialogContextChanged?.Invoke(this, EventArgs.Empty);
         }
+    }
 
-        private static void OnViewModelChanged(BindableObject bindableObject, object oldValue, object newValue)
-        {
-            bindableObject.BindingContext = newValue;
-        }
+    /// <summary>Shows the dialog, raising <see cref="Opened"/>.</summary>
+    public void Show() => Opened?.Invoke(this, EventArgs.Empty);
+
+    /// <summary>Closes the dialog, raising <see cref="Closed"/>.</summary>
+    public void Close() => Closed?.Invoke(this, EventArgs.Empty);
+}
+```
+
+**2. Write the bridge once, as a generic base.** `ReactiveVendorDialog<TViewModel>` derives from `VendorDialog`
+and implements `IViewFor<TViewModel>`. It keeps `ViewModel` and `DialogContext` in step in both directions.
+`ReactiveContentPage<TViewModel>` does the same for `ViewModel` and `BindingContext`.
+`ReactiveUserControl<TViewModel>` skips that step and exposes `ViewModel` directly, because WinForms has no
+separate context object to sync with. Setting `ViewModel` also raises `PropertyChanged`. `WhenAnyValue` and the
+binding methods read a property's changes through `INotifyPropertyChanged`. `VendorDialog` is a plain class
+with no change notification of its own, so the bridge has to raise it.
+
+```csharp
+[System.Diagnostics.DebuggerDisplay("ReactiveVendorDialog ViewModel = {ViewModel}")]
+public class ReactiveVendorDialog<TViewModel> : VendorDialog, IViewFor<TViewModel>, INotifyPropertyChanged
+    where TViewModel : class
+{
+    /// <summary>Initializes a new instance of the <see cref="ReactiveVendorDialog{TViewModel}"/> class.</summary>
+    protected ReactiveVendorDialog() => DialogContextChanged += (_, _) => ViewModel = DialogContext as TViewModel;
 
-        object IViewFor.ViewModel
+    /// <inheritdoc/>
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    /// <summary>Gets or sets the view model the dialog displays.</summary>
+    public TViewModel? ViewModel
+    {
+        get;
+        set
         {
-            get => ViewModel;
-            set => ViewModel = (TViewModel)value;
+            if (ReferenceEquals(field, value))
+            {
+                return;
+            }
+
+            field = value;
+            DialogContext = value;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ViewModel)));
         }
     }
+
+    /// <inheritdoc/>
+    object? IViewFor.ViewModel
+    {
+        get => ViewModel;
+        set => ViewModel = (TViewModel?)value;
+    }
+}
+```
+
+`IViewFor<T>` requires the explicit `object? IViewFor.ViewModel` property alongside the typed one: code that
+only knows it has an `IViewFor`, such as the view locator, reads and sets the view model through that member.
+`IViewFor<T>` extends `IViewFor`, which extends `IActivatableView`, a marker interface with no members of its
+own. Implementing `IViewFor<T>` is what makes `ReactiveVendorDialog<TViewModel>` an `IActivatableView` too, so
+`WhenActivated` accepts it without any extra work.
+
+**3. Derive a concrete dialog.** `BookReturnDialog`, a library app's book-return confirmation dialog, derives
+from `ReactiveVendorDialog<BookReturnViewModel>` and binds the way any ReactiveUI view does.
+
+```csharp
+[System.Diagnostics.DebuggerDisplay("BookReturnDialog ViewModel = {ViewModel}")]
+public sealed class BookReturnDialog : ReactiveVendorDialog<BookReturnViewModel>
+{
+    /// <summary>Initializes a new instance of the <see cref="BookReturnDialog"/> class.</summary>
+    public BookReturnDialog() =>
+        this.WhenActivated(
+            disposables =>
+            {
+                disposables(this.OneWayBind(ViewModel, x => x.BookTitle, v => v.TitleLabel.Text));
+                disposables(this.Bind(ViewModel, x => x.IsDamaged, v => v.DamagedCheckBox.IsChecked));
+            },
+            this.WhenAnyValue(x => x.ViewModel));
+
+    /// <summary>Gets the label that shows the title of the book being returned.</summary>
+    public Label TitleLabel { get; } = new();
+
+    /// <summary>Gets the check box the librarian ticks when the book comes back damaged.</summary>
+    public CheckBox DamagedCheckBox { get; } = new();
+}
 ```
 
-### The usage
+**4. Tell ReactiveUI how the dialog activates.** `WhenActivated` needs to know when a view turns on and off.
+ReactiveUI's MAUI package ships an `IActivationForViewFetcher` that watches a page's `Appearing` and
+`Disappearing` events, which is what makes `WhenActivated` work on `ReactiveContentPage<TViewModel>`.
+`VendorDialog` is not a platform type ReactiveUI already knows. Nothing recognizes it until you write the same
+kind of fetcher, translating `Opened` and `Closed` into the stream `WhenActivated` reads.
 
-From here all we need to inherit from `BasePopupPage`.
+```csharp
+public sealed class VendorDialogActivationFetcher : IActivationForViewFetcher
+{
+    /// <inheritdoc/>
+    public int GetAffinityForView(Type view) => typeof(VendorDialog).IsAssignableFrom(view) ? BindingAffinity.ExactType : 0;
 
-``` cs
-    public partial class ExtendingPopupPage : BasePopupPage<ExtendingPopupViewModel>
+    /// <inheritdoc/>
+    public IObservable<bool> GetActivationForView(IActivatableView view)
     {
-        public ExtendingPopupPage()
+        VendorDialog dialog = (VendorDialog)view;
+        return Signal.Create<bool>(witness =>
         {
-            InitializeComponent();
-        }
+            EventHandler onOpened = (_, _) => witness.OnNext(true);
+            EventHandler onClosed = (_, _) => witness.OnNext(false);
+
+            dialog.Opened += onOpened;
+            dialog.Closed += onClosed;
+
+            return new ActionDisposable(() =>
+            {
+                dialog.Opened -= onOpened;
+                dialog.Closed -= onClosed;
+            });
+        });
     }
+}
+```
+
+Register it once, when the app starts, the way a platform package registers its own fetcher:
+
+```csharp
+ExampleApp.Start(static builder => builder
+    .WithViewModule<GitHubViewModule>()
+    .WithRegistration(static resolver => resolver.RegisterConstant<IActivationForViewFetcher>(new VendorDialogActivationFetcher())));
 ```
 
-### The XAML
+**5. Show the dialog.** Setting `ViewModel` binds the controls straight away; `Show` and `Close` drive
+activation through the fetcher.
+
+```csharp
+BookReturnViewModel viewModel = new("Clean Code");
+BookReturnDialog dialog = new() { ViewModel = viewModel };
+
+dialog.Show();
+Console.WriteLine(dialog.TitleLabel.Text);
 
-In our XAML we need to make sure that we inherit from the same page so that the partial class will resolve correctly.  That should look similar to below.
+dialog.DamagedCheckBox.IsChecked = true;
+Console.WriteLine(viewModel.IsDamaged);
 
-``` xml
-<ui:BasePopupPage
-    x:TypeArguments="ui:ExtendingPopupViewModel"
-    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
-    xmlns:x="https://schemas.microsoft.com/winfx/2009/xaml"
-    xmlns:pages="clr-namespace:Mopups.Pages;assembly=Mopups"
-    xmlns:ui="clr-namespace:MyApplication;assembly=MyApplication"
-    x:Class="MyApplication.ExtendingPopupPage">
+dialog.Close();
+dialog.DamagedCheckBox.IsChecked = false;
+Console.WriteLine(viewModel.IsDamaged);
+```
 
-</ui:BasePopupPage>
+```text
+Clean Code
+True
+True
 ```
 
-Now you should have full access to the `ViewModel` property on the `PopupPage` and be able to use Reactive Bindings and View Activation.
+`viewModel.IsDamaged` stays `True` after `Close`. `Close` raises `false` through `VendorDialogActivationFetcher`,
+which deactivates `WhenActivated`'s block and disposes the `Bind` subscription set up inside it. The check box
+itself still accepts the new value; it is the two-way flow back to `ViewModel` that stops.
+
+## The locator finds it like any other view
+
+`BookReturnDialog` needs no attribute or registration to be found: implementing `IViewFor<T>` is all a view
+needs, whatever base class it derives from. The source generator that scans the project for `IViewFor<T>`
+implementations at compile time finds `BookReturnDialog` the same way it finds a view built on a ReactiveUI
+base.
+
+```csharp
+BookReturnViewModel viewModel = new("Refactoring");
+
+IViewFor? view = ViewLocator.GetCurrent().ResolveView(viewModel);
+
+Console.WriteLine(view?.GetType().Name);
+Console.WriteLine(ReferenceEquals(view?.ViewModel, viewModel));
+```
+
+```text
+BookReturnDialog
+True
+```
+
+## Mopups already has one
+
+[ReactiveUI.Maui.Plugins.Popup](../../../maui-plugins-popup.md) ships `ReactivePopupPage<TViewModel>`, the
+same bridge shown above already written for [Mopups](https://github.com/LuckyDucko/Mopups)' `PopupPage`. Take a
+dependency on that package for a Mopups popup, rather than writing your own bridge. Write your own bridge only
+when your base class has no ReactiveUI package for it yet.
+
+`ReactiveUI` also ships as `ReactiveUI.Reactive`, built from the same source for apps that use System.Reactive
+instead of the streams in [ReactiveUI.Primitives](../../../primitives/index.md).
+
+## At a glance
+
+| Member | What it does |
+| --- | --- |
+| `IViewFor<T>` | The interface a view implements to be found by the view locator and bound with `Bind`, `OneWayBind` and `BindCommand`. Requires an explicit `object? IViewFor.ViewModel` alongside the typed `ViewModel`. |
+| `IActivatableView` | The marker interface every `IViewFor` implements; `WhenActivated` and `IActivationForViewFetcher` work against it. |
+| `IActivationForViewFetcher` | The interface a base class that is not already wired up implements, to turn its own show/hide signal into the `bool` stream `WhenActivated` reads. |
+| `BindingAffinity.ExactType` | The affinity value an `IActivationForViewFetcher` returns for a view type it recognizes exactly. |
+| `WithRegistration` | Registers a custom `IActivationForViewFetcher` (or any other service) with the app's dependency resolver at start-up. |
+| `ReactivePopupPage<TViewModel>` | The bridge ReactiveUI.Maui.Plugins.Popup already ships for Mopups' `PopupPage`, so most Mopups apps need none of the above. |
diff --git a/docs/documentation/reactiveui/handbook/view-location/index.md b/docs/documentation/reactiveui/handbook/view-location/index.md
index 835167b9..ffaec06f 100644
--- a/docs/documentation/reactiveui/handbook/view-location/index.md
+++ b/docs/documentation/reactiveui/handbook/view-location/index.md
@@ -145,9 +145,15 @@ registers a `DefaultViewLocator`, such as `WithCoreServices` or a platform modul
 `InvalidOperationException`, because it has no locator to add the module's views to.
 
 ```csharp
-ExampleApp.Start(static builder => _ = builder.WithViewModule<GitHubViewModule>());
+ExampleApp.Start(static builder => builder
+    .WithViewModule<GitHubViewModule>()
+    .WithRegistration(static resolver => resolver.RegisterConstant<IActivationForViewFetcher>(new VendorDialogActivationFetcher())));
 ```
 
+The `WithRegistration` call also on that builder registers an activation fetcher a later page needs; it plays
+no part in view modules. [Extending IViewFor](extending-iviewfor.md#bridge-a-third-party-base) covers what it
+does.
+
 Resolving a view model from that feature works the same as any other.
 
 ```csharp

From 09aa5094c4cc79efc4e74f234ec87faeabf8fd9a Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 16:35:27 +1000
Subject: [PATCH 5/9] docs(reactiveui): document the remaining WPF and Blend
 members with output from a real Windows run

---
 .../reactiveui/handbook/platforms/wpf.md      | 197 ++++++++++++++++--
 1 file changed, 180 insertions(+), 17 deletions(-)

diff --git a/docs/documentation/reactiveui/handbook/platforms/wpf.md b/docs/documentation/reactiveui/handbook/platforms/wpf.md
index 432bcb7d..7056a90d 100644
--- a/docs/documentation/reactiveui/handbook/platforms/wpf.md
+++ b/docs/documentation/reactiveui/handbook/platforms/wpf.md
@@ -91,6 +91,15 @@ view uses. The window's XAML names the generic argument with `x:TypeArguments`.
 </reactiveui:ReactiveWindow>
 ```
 
+`ViewContractObservable` is the stream a host reads its `ViewContract` from; setting `ViewContract` itself is really
+setting this to a stream of one value. An app whose layout never changes with device orientation can replace the
+default, orientation-built stream with a fixed one:
+
+```csharp
+Host.ViewContractObservable = Signal.Emit<string?>("desktop");
+Console.WriteLine($"Host view contract observable set: {Host.GetValue(RoutedViewHost.ViewContractObservableProperty) is not null}");
+```
+
 The two Unsafe hosts in the bottom panel show the school office's notices. The
 [service locator section](#show-a-view-only-the-service-locator-knows) covers them.
 
@@ -106,6 +115,10 @@ Host.Duration = TimeSpan.FromMilliseconds(250);
 Host.DefaultContent = "Pick a student to begin.";
 Host.TransitionStarted += static (_, _) => Console.WriteLine("Transition started.");
 Host.TransitionCompleted += static (_, _) => Console.WriteLine("Transition completed.");
+```
+
+```csharp
+CourseListViewModel courseList = new(ViewModel, courses);
 
 // The "d(...)" style registers one disposable at a time, rather than collecting them into a
 // MultipleDisposable first; RoutedViewHost's own constructor uses the same style internally.
@@ -113,8 +126,7 @@ _ = this.WhenActivated(d =>
 {
     Host.Router = ViewModel!.Router;
     Host.ViewLocator = ViewLocator.GetCurrent();
-    d(ViewModel.Router.Navigate.Execute(new CourseListViewModel(ViewModel, courses))
-        .Subscribe());
+    d(ViewModel.Router.Navigate.Execute(courseList).Subscribe());
     Console.WriteLine($"View contract: {Host.ViewContract ?? "(none)"}");
 
     // BindingRoot is the same view model as ViewModel, exposed under the name every ReactiveUI view uses.
@@ -180,7 +192,7 @@ A page like `CourseListView` is a `ReactiveUserControl<TViewModel>`: a `UserCont
 
         <StackPanel DockPanel.Dock="Right" Width="180" Margin="16,0,0,0">
             <TextBlock Text="Selected student" FontWeight="Bold" Margin="0,0,0,8" />
-            <reactiveui:ViewModelViewHost x:Name="SummaryHost" />
+            <local:LoggingViewModelViewHost x:Name="SummaryHost" />
             <Button x:Name="OpenButton" Content="Open grade" Margin="0,16,0,0" />
         </StackPanel>
 
@@ -225,6 +237,35 @@ SummaryHost.Transition = TransitioningContentControl.TransitionType.Move;
 SummaryHost.Direction = TransitioningContentControl.TransitionDirection.Up;
 ```
 
+`ContractFallbackByPass` stops the host from falling back to an uncontracted view when a view under the current
+contract is missing. `ViewContractObservable` is the stream `ViewContract` itself is built from. `Host` uses the
+same pair above, on `RoutedViewHost` instead of `ViewModelViewHost`. Reading each one back through its dependency
+property field, rather than the wrapper property, confirms both are backed by the same storage:
+
+```csharp
+SummaryHost.ContractFallbackByPass = true;
+Console.WriteLine($"Contract fallback bypass (via field): {(bool)SummaryHost.GetValue(ViewModelViewHost.ContractFallbackByPassProperty)}");
+
+SummaryHost.ViewContractObservable = Signal.Emit<string?>(null);
+Console.WriteLine($"Summary host contract observable set: {SummaryHost.GetValue(ViewModelViewHost.ViewContractObservableProperty) is not null}");
+```
+
+`SummaryHost` is a `LoggingViewModelViewHost`, not a plain `ViewModelViewHost`: it overrides the protected
+`ResolveViewForViewModel(object?, string?)`, the method a host calls every time its `ViewModel` or view contract
+changes, to log the view it resolved after calling the base implementation.
+
+```csharp
+public sealed class LoggingViewModelViewHost : ViewModelViewHost
+{
+    /// <inheritdoc/>
+    protected override void ResolveViewForViewModel(object? viewModel, string? contract)
+    {
+        base.ResolveViewForViewModel(viewModel, contract);
+        Console.WriteLine($"Summary panel resolved: {(viewModel is null ? "(none)" : Content?.GetType().Name)}");
+    }
+}
+```
+
 A view can build its bindings and return them instead of registering each one through `d`. `StudentSummaryView`
 uses the `Func<IEnumerable<IDisposable>>` overload: `WhenActivated` disposes every item in the list when the view
 deactivates.
@@ -335,6 +376,93 @@ Binding hook: AutoDataTemplateBindingHookUnsafe
 In your own app, add the same `WithRegistration` call to the `RxAppBuilder.CreateReactiveUIBuilder()` chain, before
 `BuildApp()`.
 
+Each hook's `DefaultItemTemplate` is the `DataTemplate` it assigns; an app can inspect or reuse it directly instead
+of registering the hook.
+
+```csharp
+DataTemplate template = AutoDataTemplateBindingHook.DefaultItemTemplate.Value;
+DependencyObject root = template.LoadContent();
+Console.WriteLine($"Default item template hosts each item in a: {root.GetType().Name}");
+
+DataTemplate unsafeTemplate = AutoDataTemplateBindingHookUnsafe.DefaultItemTemplate.Value;
+DependencyObject unsafeRoot = unsafeTemplate.LoadContent();
+Console.WriteLine($"Unsafe default item template hosts each item in a: {unsafeRoot.GetType().Name}");
+```
+
+```text
+Default item template hosts each item in a: ViewModelViewHost
+Unsafe default item template hosts each item in a: ViewModelViewHostUnsafe
+```
+
+## Every transition, and a view that isn't an `IViewFor`
+
+`TransitioningContentControl` supports five transitions (`Fade`, `Move`, `Slide`, `Drop`, `Bounce`) and four
+directions (`Up`, `Down`, `Left`, `Right`). `Host` and `SummaryHost` above use `Slide`/`Left` and `Move`/`Up`.
+`NoticeBoardHost` and `LatestNoticeHost` pick two more. A page-name banner built entirely in code picks the last
+one. It sets its direction and duration through the raw dependency properties, instead of the `Direction` and
+`Duration` wrapper properties the other hosts use:
+
+```csharp
+NoticeBoardHost.Transition = TransitioningContentControl.TransitionType.Drop;
+NoticeBoardHost.Direction = TransitioningContentControl.TransitionDirection.Right;
+LatestNoticeHost.Transition = TransitioningContentControl.TransitionType.Fade;
+```
+
+```csharp
+PageNameBanner.Transition = TransitioningContentControl.TransitionType.Bounce;
+PageNameBanner.SetValue(TransitioningContentControl.TransitionDirectionProperty, TransitioningContentControl.TransitionDirection.Down);
+_ = PageNameBanner.SetBinding(
+    TransitioningContentControl.TransitionDurationProperty,
+    new System.Windows.Data.Binding(nameof(AppShell.PageBannerDuration)) { Source = ViewModel });
+```
+
+`NoticeStatusText`, `CommandStatusText` and `PageSummaryText` are plain `TextBlock` labels, not `IViewFor` instances
+of their own. `WpfViewForMixins.WhenActivated` has a twin for each block style — `Action<Action<IDisposable>>`,
+`Action<MultipleDisposable>` and `Func<IEnumerable<IDisposable>>` — that also takes an explicit `IViewFor`. A plain
+element like these three labels uses it to tie its activation to a window or view that is one:
+
+```csharp
+_ = NoticeStatusText.WhenActivated(
+    d => d(noticeBoard.Router.CurrentViewModel.Subscribe(page =>
+        NoticeStatusText.Text = $"Notice board page: {page?.UrlPathSegment ?? "(none)"}")),
+    this);
+
+_ = CommandStatusText.WhenActivated(
+    d => d.Add(courseList.OpenStudent.IsExecuting.Subscribe(executing =>
+        CommandStatusText.Text = executing ? "Opening student..." : "Idle")),
+    this);
+
+_ = PageSummaryText.WhenActivated(
+    () =>
+    [
+        ViewModel!.Router.CurrentViewModel.CombineLatest(
+            noticeBoard.Router.CurrentViewModel,
+            static (course, notice) => $"{course?.UrlPathSegment ?? "start"} / {notice?.UrlPathSegment ?? "none"}")
+            .Subscribe(text => PageSummaryText.Text = text)
+    ],
+    this);
+```
+
+The parameterless `WhenActivated()` overload activates a view with no disposables of its own, purely to trigger an
+`IActivatableViewModel`'s activation. `OfficeHoursBannerView` has nothing to bind — its text is fixed — so it uses
+this overload just to log when its view model activates:
+
+```csharp
+public sealed class OfficeHoursBannerView : ReactiveUserControl<OfficeHoursBannerViewModel>
+{
+    private readonly TextBlock _text = new() { Text = "Office hours: 9am-4pm, Monday to Friday." };
+
+    public OfficeHoursBannerView()
+    {
+        Content = _text;
+        ViewModel = new OfficeHoursBannerViewModel();
+        ViewModel.Activator.Activated.Subscribe(static _ => Console.WriteLine("Office hours banner activated."));
+
+        _ = this.WhenActivated();
+    }
+}
+```
+
 ## Bind with validation
 
 `BindWithValidation` binds a control two-way to a view model property without a generated field for the control.
@@ -439,27 +567,47 @@ WithWpfConverters/WithWpfScheduler configured: True
 WPF main-thread scheduler: DispatcherSequencer
 Binding hook: AutoDataTemplateBindingHook
 Binding hook: AutoDataTemplateBindingHookUnsafe
+Default item template hosts each item in a: ViewModelViewHost
+Unsafe default item template hosts each item in a: ViewModelViewHostUnsafe
 Auto-suspend idle timeout: 00:00:20
+Host view contract observable set: True
 View contract: (none)
 BindingRoot's router has 1 page(s) on screen.
+Office hours banner activated.
+Contract fallback bypass (via field): True
+Summary host contract observable set: True
 Transition started.
+Contract fallback bypass (via field): True
+Summary host contract observable set: True
+Summary panel resolved: (none)
 Transition completed.
 Courses loaded: 2
 Students listed: 4
 RoutedViewHostUnsafe shows: OfficeNoticeView (Parent evening is on Tuesday.)
 ViewModelViewHostUnsafe shows: OfficeNoticeView (Reports are due on Friday.)
+Page name banner: courses
+Notice status: Notice board page: notice
+Command status: Idle
+Page summary: courses / notice
+Summary panel resolved: StudentSummaryView
 Selected in the summary panel: Ada Lovelace
 Transition started.
 Editing Ada Lovelace's grade.
 Navigated to: students/Ada Lovelace
 Typed grade: 97
+Contract fallback bypass (via field): True
+Summary host contract observable set: True
+Summary panel resolved: (none)
+Summary panel resolved: StudentSummaryView
 Saved grade for Ada Lovelace: 97
 Back on: courses
 Closing window.
 ```
 
-The `Transition started.` and `Transition completed.` lines come from the WPF dispatcher, so where they fall between
-the other lines can differ from run to run.
+The smoke run waits for the first page to finish sliding in, so the first `Transition started.` has its
+`Transition completed.`. It closes the window before the second animation ends, so that transition has no completed
+line. Where `Summary panel resolved:`, `Office hours banner activated.` and the status labels' first values land
+relative to each other depends on when each element loads into the visual tree, so it can differ from run to run.
 
 Selecting a student updates the `ViewModelViewHost` preview immediately, without navigating. Opening a student
 navigates the router, plays a transition, and shows `students/Ada Lovelace` as the current page's
@@ -558,13 +706,28 @@ Alert label: Storm warning issued
 ```
 
 Both `AutoResubscribeOnError="True"` above tell the behavior and the trigger to re-subscribe to `StateObservable`
-and `Observable` if either ever fails, instead of leaving the panel or the alert label stuck. Both types also have a
-`SchedulerOverride`, for a test that wants to assert their effect right after raising it instead of pumping a
-dispatcher: setting it to `Sequencer.Immediate` before assigning `StateObservable`/`Observable` delivers on the
-calling thread, with no dispatcher involved.
+and `Observable` if either ever fails, instead of leaving the panel or the alert label stuck. `TargetObject` is the
+element the behavior calls `VisualStateManager.GoToState` on. The XAML above binds it to `StatusPanel` itself; code
+that builds the behavior without XAML sets the same dependency property with `SetValue`:
 
 ```csharp
 FollowObservableStateBehavior stateBehavior = new() { SchedulerOverride = Sequencer.Immediate };
+
+// A test that builds the behavior in code, rather than XAML, sets TargetObject through its dependency
+// property field with SetValue; the window's XAML sets the same property with a binding instead.
+stateBehavior.SetValue(FollowObservableStateBehavior.TargetObjectProperty, targetElement);
+Console.WriteLine($"TargetObject via SetValue: {stateBehavior.GetValue(FollowObservableStateBehavior.TargetObjectProperty) == targetElement}");
+```
+
+```text
+TargetObject via SetValue: True
+```
+
+Both types also have a `SchedulerOverride`, for a test that wants to assert their effect right after raising it
+instead of pumping a dispatcher: setting it to `Sequencer.Immediate` before assigning `StateObservable`/`Observable`
+delivers on the calling thread, with no dispatcher involved.
+
+```csharp
 stateBehavior.Attach(probeElement);
 stateBehavior.StateObservable = Signal.Emit("Stormy");
 ```
@@ -613,8 +776,8 @@ contract that changes with orientation.
 | Member | What it does |
 | --- | --- |
 | `ActivationForViewFetcher` | Tells `WhenActivated` when a WPF `FrameworkElement` (or its containing `Window`) is on screen. Installed by `Wpf.Registrations`. |
-| `AutoDataTemplateBindingHook` | Supplies a default `DataTemplate` for an `ItemsControl` bound to view models, showing each one through a `ViewModelViewHost`. |
-| `AutoDataTemplateBindingHookUnsafe` | The same default template, with each item shown through a `ViewModelViewHostUnsafe`. Marked `[RequiresDynamicCode]`. |
+| `AutoDataTemplateBindingHook` | Supplies a default `DataTemplate` for an `ItemsControl` bound to view models, showing each one through a `ViewModelViewHost`. `DefaultItemTemplate` is the template itself. |
+| `AutoDataTemplateBindingHookUnsafe` | The same default template, with each item shown through a `ViewModelViewHostUnsafe`. Marked `[RequiresDynamicCode]`. `DefaultItemTemplate` is the template itself. |
 | `AutoSuspendHelper` | Forwards a WPF `Application`'s `Startup`, `Activated`, `Deactivated` and `Exit` events into the suspension host, with `IdleTimeout` controlling how long it waits before asking you to save. |
 | `WpfReactiveUIBuilderExtensions.WithWpf(IReactiveUIBuilder)` / `WithWpf(IAppBuilder)` | Registers the WPF view hosts, activation fetcher, converters and main-thread sequencer. |
 | `WpfReactiveUIBuilderExtensions.WithWpfConverters` | Registers the WPF-specific value converters on their own. |
@@ -624,16 +787,16 @@ contract that changes with orientation.
 | `ReactivePage<TViewModel>` | A WPF `Page` that implements `IViewFor<TViewModel>`, for apps that navigate with `Frame`/`NavigationWindow` instead of, or alongside, a router. |
 | `ReactiveUserControl<TViewModel>` | A `UserControl` that implements `IViewFor<TViewModel>`. |
 | `ReactiveWindow<TViewModel>` | A `Window` that implements `IViewFor<TViewModel>`. |
-| `RoutedViewHost` | Shows the view for the router's current page, resolved through `ViewLocator` from generated and `Map` views without reflection; shows `DefaultContent` when the stack is empty. |
+| `RoutedViewHost` | Shows the view for the router's current page, resolved through `ViewLocator` from generated and `Map` views without reflection; shows `DefaultContent` when the stack is empty. `ViewContractObservable` is the stream `ViewContract` is built from. |
 | `RoutedViewHostUnsafe` | A `RoutedViewHost` that also asks the service locator, for a view registered only there. Marked `[RequiresDynamicCode]`. |
-| `TransitioningContentControl` | The `ContentControl` `RoutedViewHost` and `ViewModelViewHost` build on; animates between old and new content with `Transition`, `Direction` and `Duration`, and raises `TransitionStarted`/`TransitionCompleted`. |
+| `TransitioningContentControl` | The `ContentControl` `RoutedViewHost` and `ViewModelViewHost` build on; animates between old and new content with `Transition` (`Fade`, `Move`, `Slide`, `Drop`, `Bounce`), `Direction` (`Up`, `Down`, `Left`, `Right`) and `Duration`, and raises `TransitionStarted`/`TransitionCompleted`. |
 | `ValidationBindingMixins.BindWithValidation` | Binds a control two-way to a view model property, finding the control by name in the view's visual tree instead of through a generated field. |
-| `ViewModelViewHost` | Shows the view for whatever view model its own `ViewModel` property holds, with no router involved. Finds generated and `Map` views without reflection. |
+| `ViewModelViewHost` | Shows the view for whatever view model its own `ViewModel` property holds, with no router involved. Finds generated and `Map` views without reflection. `ViewContractObservable` is the stream `ViewContract` is built from; `ContractFallbackByPass` stops it falling back to an uncontracted view; `ResolveViewForViewModel` is the protected method it calls to resolve and show the view, and a subclass can override it. |
 | `ViewModelViewHostUnsafe` | A `ViewModelViewHost` that also asks the service locator, for a view registered only there. Marked `[RequiresDynamicCode]`. |
 | `Wpf.Registrations` | The `IWantsToRegisterStuff` that `WithWpf` runs to register the platform services above; not the Unsafe twins. |
 | `WpfViewForMixins.GetIsDesignMode` | Reports whether the WPF designer is loading the view, so a constructor can skip work the designer cannot run. |
-| `WpfViewForMixins.WhenActivated` | The `Action<Action<IDisposable>>`, `Func<IEnumerable<IDisposable>>`, `Action<MultipleDisposable>` and no-argument overloads that run a block while a WPF view is active. |
-| `ReactiveUI.Blend.FollowObservableStateBehavior` | A Blend behavior that drives a `VisualStateManager` state from a stream of state names. |
-| `ReactiveUI.Blend.ObservableTrigger` | A Blend trigger that runs its actions each time an observable delivers a value. |
+| `WpfViewForMixins.WhenActivated` | The `Action<Action<IDisposable>>`, `Func<IEnumerable<IDisposable>>`, `Action<MultipleDisposable>` and no-argument overloads that run a block while a WPF view is active, each with a twin that also takes an explicit `IViewFor` for a plain element that isn't one itself. |
+| `ReactiveUI.Blend.FollowObservableStateBehavior` | A Blend behavior that drives a `VisualStateManager` state from a stream of state names. `TargetObject` is the element it calls `GoToState` on; `AutoResubscribeOnError` re-subscribes `StateObservable` after a failure. |
+| `ReactiveUI.Blend.ObservableTrigger` | A Blend trigger that runs its actions each time an observable delivers a value. `AutoResubscribeOnError` re-subscribes `Observable` after a failure. |
 | `ReactiveUIBuilderDrawingExtensions.WithDrawing` | Registers an `IBitmapLoader` for platforms, including WPF, that need one. |
 | `ReactiveUI.Drawing.Registrations` | The `IWantsToRegisterStuff` that `WithDrawing` runs. |

From a8cbec653639ec44762ae43da0d0e5c0b03d897e Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 16:35:50 +1000
Subject: [PATCH 6/9] docs(reactiveui): WinUI ViewModelViewHost does not choose
 views by a contract set later

---
 docs/documentation/reactiveui/handbook/platforms/winui.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/docs/documentation/reactiveui/handbook/platforms/winui.md b/docs/documentation/reactiveui/handbook/platforms/winui.md
index bcb147e6..c924406f 100644
--- a/docs/documentation/reactiveui/handbook/platforms/winui.md
+++ b/docs/documentation/reactiveui/handbook/platforms/winui.md
@@ -207,9 +207,10 @@ when it is `true`, that fallback is skipped. If no view is found at all, the hos
 freshly constructed host and again for every later `ViewModel` change. Override it, calling the base implementation
 first, to add behavior of your own, such as recording which view it chose. `ViewContract` still republishes onto
 `ViewContractObservable`, the same stream the `ViewContractObservableProperty` dependency property holds. On
-`ViewModelViewHost`, though, that stream drives the platform-orientation contract the host starts with, not a later
-`ViewContract` assignment. Change the view by assigning a new `ViewModel` instead of by reassigning the contract
-after construction.
+`ViewModelViewHost`, though, the host looks views up with the contract stream it builds from the window's size when
+it is constructed. A `ViewContract` or `ViewContractObservable` you set later is stored and published, but the host
+does not use it to choose a view, not even on the next `ViewModel` change. When the contract must choose the view,
+host the page in a `RoutedViewHost`, which watches its `ViewContract`.
 
 ```csharp
 DefaultViewLocator locator = new();

From 3142b5cbd9730ae1915024d0f7e6945f0cbef2c4 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 16:48:17 +1000
Subject: [PATCH 7/9] docs(reactiveui): plain Markdown landing page with an
 MVVM diagram; readability pass on guideline and install pages

---
 .../getting-started/installation/avalonia.md  | 13 ++--
 .../getting-started/installation/maui.md      | 18 +++---
 .../guidelines/debugging/debug-symbols.md     | 51 ++++++++--------
 .../debugging/disable-just-my-code.md         | 12 ++--
 .../reactiveui/guidelines/platform/android.md | 20 +++---
 .../windows-presentation-framework.md         | 20 +++---
 .../reactiveui/handbook/commands/advanced.md  | 60 +++++++++---------
 .../data-binding/android/wire-up-controls.md  | 34 +++++------
 .../obsolete/collections/derived-lists.md     | 10 +--
 .../reactive-composite-collections.md         | 10 +--
 .../reactiveui/handbook/platforms/index.md    | 12 ++--
 .../handbook/view-models/reactive-object.md   |  4 +-
 docs/documentation/reactiveui/index.md        | 61 +++++++++++--------
 13 files changed, 169 insertions(+), 156 deletions(-)

diff --git a/docs/documentation/reactiveui/getting-started/installation/avalonia.md b/docs/documentation/reactiveui/getting-started/installation/avalonia.md
index c09a6de0..e1220b43 100644
--- a/docs/documentation/reactiveui/getting-started/installation/avalonia.md
+++ b/docs/documentation/reactiveui/getting-started/installation/avalonia.md
@@ -3,8 +3,9 @@ Order: 2
 ---
 # Avalonia
 
-`ReactiveUI.Avalonia` lives in its own repository, [reactiveui/ReactiveUI.Avalonia](https://github.com/reactiveui/ReactiveUI.Avalonia),
-not in `reactiveui/ReactiveUI`. It has its own target frameworks, release schedule and documentation.
+`ReactiveUI.Avalonia` lives in its own repository, not in `reactiveui/ReactiveUI`. That repository is
+[reactiveui/ReactiveUI.Avalonia](https://github.com/reactiveui/ReactiveUI.Avalonia). It has its own supported
+.NET versions. It has its own release schedule and its own docs too.
 
 Add `ReactiveUI.Avalonia` to your Avalonia application project.
 
@@ -12,11 +13,11 @@ Add `ReactiveUI.Avalonia` to your Avalonia application project.
 dotnet add package ReactiveUI.Avalonia
 ```
 
-A dependency-injection container of your choice adds one more package: `ReactiveUI.Avalonia.Autofac`,
+Pick a dependency-injection container, and add one more package for it: `ReactiveUI.Avalonia.Autofac`,
 `ReactiveUI.Avalonia.DryIoc`, `ReactiveUI.Avalonia.Microsoft.Extensions.DependencyInjection` or
-`ReactiveUI.Avalonia.Ninject`. Each also ships as a `.Reactive` package, built from the same source, for an app
-that uses System.Reactive.
+`ReactiveUI.Avalonia.Ninject`. Each of these also ships as a `.Reactive` package, built from the same source,
+for an app that uses System.Reactive.
 
 See the [ReactiveUI.Avalonia repository](https://github.com/reactiveui/ReactiveUI.Avalonia) for setup and its
-own examples, and [Data Binding in AvaloniaUI with ReactiveUI](../../handbook/data-binding/avalonia.md) for
+own examples. See [Data Binding in AvaloniaUI with ReactiveUI](../../handbook/data-binding/avalonia.md) for
 binding a view to its view model with `WhenActivated`.
diff --git a/docs/documentation/reactiveui/getting-started/installation/maui.md b/docs/documentation/reactiveui/getting-started/installation/maui.md
index e72f4e4f..ecdc15e7 100644
--- a/docs/documentation/reactiveui/getting-started/installation/maui.md
+++ b/docs/documentation/reactiveui/getting-started/installation/maui.md
@@ -17,9 +17,9 @@ System.Reactive.
 
 ## Configure ReactiveUI at startup
 
-Call `UseReactiveUI` on the `MauiAppBuilder` in `MauiProgram.CreateMauiApp`, with a delegate that configures the
-`IReactiveUIBuilder` the way `RxAppBuilder` would elsewhere. `WithMauiConverters` here registers MAUI's
-boolean-to-visibility converters; a real app's delegate also registers its views and services.
+Call `UseReactiveUI` on the `MauiAppBuilder` in `MauiProgram.CreateMauiApp`. Pass it a delegate that configures
+the `IReactiveUIBuilder`, the same way `RxAppBuilder` would elsewhere. `WithMauiConverters` here registers
+MAUI's boolean-to-visibility converters. A real app's delegate also registers its views and services.
 
 ```csharp
 _ = mauiBuilder.UseReactiveUI(builder =>
@@ -30,11 +30,11 @@ _ = mauiBuilder.UseReactiveUI(builder =>
 ```
 
 `UseReactiveUI` registers MAUI's platform module, converters and dispatcher-backed main-thread sequencer.
-[RxAppBuilder](../../handbook/rxappbuilder.md) covers the builder itself, and [.NET MAUI](../../handbook/platforms/maui.md)
-covers everything you build with the package: `ReactiveContentPage<T>` and the other reactive page bases, binding
-a page to its view model, showing a router's current page, and navigating between pages.
+[RxAppBuilder](../../handbook/rxappbuilder.md) covers the builder itself. [.NET MAUI](../../handbook/platforms/maui.md)
+covers everything you build with the package. That includes `ReactiveContentPage<T>` and the other reactive page
+bases, binding a page to its view model, showing a router's current page, and navigating between pages.
 
-A view model implementing `IScreen` gives it a router to navigate; see [Routing](../../handbook/routing.md).
-The [compelling example](../compelling-example.md) walks through a first view model and view. There is no
-`ReactiveUI.Validation` code in this installation's example project; see [Validation](../../../validation.md)
+A view model that implements `IScreen` gets a router to navigate with. See [Routing](../../handbook/routing.md).
+The [compelling example](../compelling-example.md) walks through a first view model and view. This
+installation's example project has no `ReactiveUI.Validation` code. See [Validation](../../../validation.md)
 for validation rules on a view model.
diff --git a/docs/documentation/reactiveui/guidelines/debugging/debug-symbols.md b/docs/documentation/reactiveui/guidelines/debugging/debug-symbols.md
index 9d961167..d494639e 100644
--- a/docs/documentation/reactiveui/guidelines/debugging/debug-symbols.md
+++ b/docs/documentation/reactiveui/guidelines/debugging/debug-symbols.md
@@ -1,12 +1,12 @@
 # Debugging ReactiveUI
 
 Every ReactiveUI package on NuGet ships with [SourceLink](https://docs.microsoft.com/en-us/dotnet/standard/library-guidance/sourcelink)
-metadata embedded in the assembly's PDB (`<DebugType>embedded</DebugType>` +
-`Microsoft.SourceLink.GitHub`, configured once in
-[`src/Directory.Build.props`](https://github.com/reactiveui/reactiveui/blob/main/src/Directory.Build.props)).
-That means you can step from your own code straight into the framework source
-on GitHub, at the exact commit your installed version was built from. You need
-no matching local clone and no symbol-server hunting.
+metadata. The metadata is embedded in the assembly's PDB, a file that holds debug information. This comes from
+`<DebugType>embedded</DebugType>` and `Microsoft.SourceLink.GitHub`, configured once in
+[`src/Directory.Build.props`](https://github.com/reactiveui/reactiveui/blob/main/src/Directory.Build.props).
+That means you can step from your own code straight into the framework source on GitHub. You land at the exact
+commit your installed version was built from. You need no matching local clone. You need no symbol-server
+hunting either.
 
 ## Visual Studio (2022 and newer)
 
@@ -14,32 +14,31 @@ Two debugger settings unlock SourceLink stepping. Both live under
 **Tools → Options → Debugging**:
 
 1. **General** page
-   - **Enable Just My Code** — *uncheck*. With Just My Code on, the debugger
-     never asks the SourceLink resolver for framework frames; turning it off
+   - **Enable Just My Code** — *uncheck*. When Just My Code is on, the debugger
+     never asks the SourceLink resolver for framework frames. Turning it off
      lets the resolver fetch the matching ReactiveUI source on demand.
    - **Enable Source Link support** — *check*. This is the master switch
      that wires `Microsoft.VisualStudio.Debugger.SourceLink` into the
      symbol load path.
-   - *(Recommended)* **Enable source server support** + **Suppress JIT
-     optimization on module load (Managed only)** — gives you readable
+   - *(Recommended)* **Enable source server support** and **Suppress JIT
+     optimization on module load (Managed only)**. These give you readable
      locals when stepping into release-built framework code.
 2. **Symbols** page
-   - Make sure **Microsoft Symbol Servers** (or another server hosting the
-     ReactiveUI PDBs — typically not needed since `embedded` ships the PDB
-     inside the .dll itself) is enabled. With embedded PDBs, no extra
-     server entry is required.
+   - Make sure **Microsoft Symbol Servers** is enabled, or another server
+     that hosts the ReactiveUI PDBs. You usually don't need this step,
+     because the embedded PDB already ships inside the .dll.
 
 Set a breakpoint, hit it, then *Step Into* (`F11`) any ReactiveUI call
 (e.g. `this.WhenAnyValue(...)`). Visual Studio prompts once with
 *"Source Link will download <https://raw.githubusercontent.com/reactiveui/...>
-— OK?"*; accept and you land in the framework's source file at the exact
+— OK?"* Accept it, and you land in the framework's source file at the exact
 commit your NuGet package was published from.
 
 ## Rider / VS Code (C# Dev Kit)
 
-Rider honors SourceLink out of the box — make sure
+Rider honors SourceLink out of the box. Make sure
 **Settings → Build, Execution, Deployment → Debugger → Enable external source
-debug** is on, and disable Just My Code under the same screen.
+debug** is on. Disable Just My Code under the same screen.
 
 In VS Code with the C# Dev Kit, set in `launch.json`:
 
@@ -55,19 +54,19 @@ In VS Code with the C# Dev Kit, set in `launch.json`:
 
 ## Quick demo
 
-<div class="youtube-video-container"><iframe src="https://www.youtube.com/embed/gyRGhCQPkB4" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe></div>
+[Watch the SourceLink debugging demo on YouTube](https://www.youtube.com/watch?v=gyRGhCQPkB4)
 
 ## Troubleshooting
 
-- **Step Into still skips framework frames.** Confirm Just My Code is off
-  and that the package version on disk matches a published release tag (the
-  SourceLink URL embeds the commit SHA — local builds without a release
-  commit can't be resolved).
+- **Step Into still skips framework frames.** Confirm Just My Code is off.
+  Also confirm the package version on disk matches a published release tag.
+  The SourceLink URL embeds the commit SHA, so a local build without a
+  release commit can't be resolved.
 - **`The remote endpoint could not be reached`.** Your network blocks
-  `raw.githubusercontent.com`. Either whitelist that host or run with the
+  `raw.githubusercontent.com`. Either allow that host, or run with the
   source already on disk and point Visual Studio at it via
   **Debug → Options → Symbols → Specify excluded modules**.
 - **Mobile heads (iOS / Android via .NET MAUI).** The platform debuggers
-  honor SourceLink for managed code today, but native interop frames stay
-  opaque. For pure-managed ReactiveUI calls the experience matches WPF /
-  WinForms.
+  honor SourceLink for managed code today. Native interop frames stay
+  opaque, though. For pure-managed ReactiveUI calls, the experience matches
+  WPF and WinForms.
diff --git a/docs/documentation/reactiveui/guidelines/debugging/disable-just-my-code.md b/docs/documentation/reactiveui/guidelines/debugging/disable-just-my-code.md
index 91aa511d..57812371 100644
--- a/docs/documentation/reactiveui/guidelines/debugging/disable-just-my-code.md
+++ b/docs/documentation/reactiveui/guidelines/debugging/disable-just-my-code.md
@@ -1,9 +1,9 @@
 # Disable Just My Code
 
 Turn off Visual Studio's [Just My Code](https://learn.microsoft.com/visualstudio/debugger/just-my-code) feature.
-With it on, the debugger steps over framework code, including `IObservable<T>` pipelines and `async`/`await`
-state machines, so **Step Into** on a `WhenAnyValue` or `Subscribe` call skips straight past it. Turning it off
-lets you step through the framework's own code, which is where most reactive bugs actually show up.
+With it on, the debugger steps over framework code. This includes `IObservable<T>` pipelines and `async`/`await`
+state machines. So **Step Into** on a `WhenAnyValue` or `Subscribe` call skips straight past it. Turning it off
+lets you step through the framework's own code. That is where most reactive bugs actually show up.
 
 See [debugging ReactiveUI](debug-symbols.md) for the full set of debugger settings SourceLink needs, including
 this one.
@@ -19,6 +19,6 @@ Reactive debugging tip: turn on breaking on thrown exceptions before they are ha
 [Understanding exceptions while debugging with Visual
 Studio](https://devblogs.microsoft.com/devops/understanding-exceptions-while-debugging-with-visual-studio)
 
-An exception inside a stream's callback ends that subscription: the stream calls `OnError` instead of `OnNext`
-or `OnCompleted`, and stops. Breaking on the exception itself, rather than after it becomes an unhandled error,
-puts you at the exact line that failed.
+An exception inside a stream's callback ends that subscription. The stream calls `OnError` instead of `OnNext`
+or `OnCompleted`, and it stops. Break on the exception itself, rather than after it becomes an unhandled error.
+That puts you at the exact line that failed.
diff --git a/docs/documentation/reactiveui/guidelines/platform/android.md b/docs/documentation/reactiveui/guidelines/platform/android.md
index eeba77bc..79370aa6 100644
--- a/docs/documentation/reactiveui/guidelines/platform/android.md
+++ b/docs/documentation/reactiveui/guidelines/platform/android.md
@@ -3,22 +3,22 @@
 `ReactiveUI.AndroidX` connects ReactiveUI to Android through the AndroidX support libraries. Add it by following
 [Installation](../../getting-started/installation/androidx.md). `ReactiveUI.AndroidX` also ships as
 `ReactiveUI.AndroidX.Reactive`, built from the same source, for an app that uses System.Reactive.
-[Android](../../handbook/platforms/android.md) walks through every pattern below with a school timetable app. The core
-`ReactiveUI` package's Android build adds `ReactiveActivity`, `SharedPreferencesExtensions` and
-`UsbManagerExtensions` for apps that do not use AndroidX.
+[Android](../../handbook/platforms/android.md) walks through every pattern below with a school timetable app. For
+an app that does not use AndroidX, the core `ReactiveUI` package's Android build adds `ReactiveActivity`,
+`SharedPreferencesExtensions` and `UsbManagerExtensions`.
 
 ## Guidelines
 
-- **View models inherit from `ReactiveObject`.** They stay free of any Android type, so you can unit test them
+- **View models inherit from `ReactiveObject`.** They stay free of any Android type. So you can unit test them
   without a device or an emulator.
 - **Activities, fragments and dialogs inherit from the reactive base classes.** `ReactiveAppCompatActivity<TViewModel>`,
   `ReactiveFragmentActivity<TViewModel>`, `ReactiveFragment<TViewModel>`, `ReactiveDialogFragment<TViewModel>` and
   `ReactivePreferenceFragment<TViewModel>` each implement `IViewFor<TViewModel>`. Each one exposes a `ViewModel`
-  property, so you never wire one up by hand.
+  property. You never wire one up by hand.
 - **Wire up controls with `WireUpControls()`, not `FindViewById`.** `ControlFetcherMixins.WireUpControls` reads a
-  view's properties by reflection and finds each one's matching resource by name, once, instead of a
-  `FindViewById` call per control. Its `ResolveStrategy` decides which properties it wires: `Implicit` wires every
-  writable `View`-typed property, `ExplicitOptIn` wires only properties marked to opt in, and `ExplicitOptOut`
+  view's properties by reflection. It finds each one's matching resource by name, once, instead of a
+  `FindViewById` call per control. Its `ResolveStrategy` decides which properties it wires. `Implicit` wires every
+  writable `View`-typed property. `ExplicitOptIn` wires only properties marked to opt in. `ExplicitOptOut`
   wires every property except those marked to opt out.
 - **Use `IActivatableViewModel` and `WhenActivated` for lifecycle.** See [When Activated](../../handbook/when-activated.md)
   for how a subscription's lifetime follows the view's.
@@ -26,11 +26,11 @@
   and [Disposables](../../../primitives/disposables.md).
 - **Convert Android events to streams instead of attaching event handlers.** The extension methods in
   `ReactiveUI.Primitives.ObservableEvents` turn an event into an `IObservable<T>`. Compose it with the rest of a
-  view model's streams; see [Events](../../handbook/events.md) and
+  view model's streams. See [Events](../../handbook/events.md) and
   [ObservableEvents](../../../primitives/observable-events/index.md).
 - **Bind a list without a hand-written adapter.** `ReactiveRecyclerViewAdapter<TViewModel, TCollection>` and
   `ReactiveRecyclerViewViewHolder` bind a `RecyclerView` to a collection of view models. `ReactivePagerAdapter<TViewModel, TCollection>`
   does the same for a `ViewPager`.
 - **Await an activity result instead of overriding `OnActivityResult`.** `StartActivityForResultAsync` on the reactive
-  activity base classes turns a launched activity's result into a `Task`, so the calling code reads like ordinary
+  activity base classes turns a launched activity's result into a `Task`. The calling code then reads like ordinary
   asynchronous code.
diff --git a/docs/documentation/reactiveui/guidelines/platform/windows-presentation-framework.md b/docs/documentation/reactiveui/guidelines/platform/windows-presentation-framework.md
index 451e4b82..fa813b83 100644
--- a/docs/documentation/reactiveui/guidelines/platform/windows-presentation-framework.md
+++ b/docs/documentation/reactiveui/guidelines/platform/windows-presentation-framework.md
@@ -1,6 +1,6 @@
 # Windows Presentation Framework guidelines
 
-See [WPF](wpf-overview.md) for an introduction to the package, and
+See [WPF](wpf-overview.md) for an introduction to the package. See
 [WPF](../../handbook/platforms/wpf.md) for a full walkthrough, built around a university grade book. This page
 lists the WPF-specific practices worth calling out on their own.
 
@@ -9,16 +9,16 @@ lists the WPF-specific practices worth calling out on their own.
 - **Keep every subscription disposed.** See [Cleaning up subscriptions](../../../reactive-programming/observables.md#cleaning-up)
   and [Disposables](../../../primitives/disposables.md).
 - **Convert WPF events to streams instead of attaching event handlers.** The extension methods in
-  `ReactiveUI.Primitives.ObservableEvents` turn an event into an `IObservable<T>`; see
+  `ReactiveUI.Primitives.ObservableEvents` turn an event into an `IObservable<T>`. See
   [Events](../../handbook/events.md) and [ObservableEvents](../../../primitives/observable-events/index.md).
 - **A window, page or control that needs a view model derives from `ReactiveWindow<TViewModel>`,
-  `ReactivePage<TViewModel>` or `ReactiveUserControl<TViewModel>`.** Each implements `IViewFor<TViewModel>` with a
-  `ViewModel` dependency property.
-- **Host a routed page stack with `RoutedViewHost`, and a single view model with `ViewModelViewHost`.**
+  `ReactivePage<TViewModel>` or `ReactiveUserControl<TViewModel>`.** Each of these implements
+  `IViewFor<TViewModel>` with a `ViewModel` dependency property.
+- **Host a routed page stack with `RoutedViewHost`.** Host a single view model with `ViewModelViewHost`.
 - **Starting WPF from something other than its own `Application` entry point needs a scheduler set by hand.** A
   console host that creates the WPF application on its own thread has no dispatcher yet when the process starts.
-  Once that thread's dispatcher exists, set `RxSchedulers.MainThreadScheduler` to a dispatcher-backed sequencer
-  before anything schedules work onto it. `WithWpfScheduler` (part of `WithWpf`) needs the same dispatcher to
-  already exist.
-- **A control bound without a source-generated `Bind`** — one whose target control is resolved by name at run
-  time — uses `BindWithValidation` instead of `Bind`.
+  Once that thread's dispatcher exists, set `RxSchedulers.MainThreadScheduler` to a dispatcher-backed sequencer.
+  Do this before anything schedules work onto it. `WithWpfScheduler` (part of `WithWpf`) needs that same
+  dispatcher to already exist.
+- **A control bound without a source-generated `Bind` uses `BindWithValidation` instead.** This applies to a
+  control whose target is resolved by name at run time.
diff --git a/docs/documentation/reactiveui/handbook/commands/advanced.md b/docs/documentation/reactiveui/handbook/commands/advanced.md
index df061fe0..ec6054bd 100644
--- a/docs/documentation/reactiveui/handbook/commands/advanced.md
+++ b/docs/documentation/reactiveui/handbook/commands/advanced.md
@@ -7,10 +7,10 @@ Order: 3
 
 The [basics page](index.md) creates commands with the static factory methods on `ReactiveCommand`. Those factories
 cover almost every case, because they call the same constructors this page covers directly. Write your own command
-type when every command of a kind needs behavior the factories cannot give you: recording every parameter a
-command has run with, logging every run of a combined command, or wrapping a non-reactive command source. This
-page also covers the interfaces a view model exposes a command through, and `SwitchSubscribe`, for following a
-command property that gets replaced.
+type when every command of a kind needs behavior the factories cannot give you. Examples are recording every
+parameter a command has run with, logging every run of a combined command, or wrapping a non-reactive command
+source. This page also covers the interfaces a view model exposes a command through, and `SwitchSubscribe`, for
+following a command property that gets replaced.
 
 ## Derive from `ReactiveCommand<TParam, TResult>`
 
@@ -77,8 +77,8 @@ Console.WriteLine(string.Join(", ", borrow.History));
 ```
 
 The second constructor is for execution logic that cancels through a callback instead of by unsubscribing. It
-takes a `Func<TParam, IObservable<(IObservable<TResult> Result, Action Cancel)>>`: an observable of a tuple
-holding the result observable and a `Cancel` action. `ReactiveCommand` calls `Cancel` when the execution is
+takes a `Func<TParam, IObservable<(IObservable<TResult> Result, Action Cancel)>>`. That is an observable of a
+tuple holding the result observable and a `Cancel` action. `ReactiveCommand` calls `Cancel` when the execution is
 disposed, instead of unsubscribing from `Result` directly. Use this when the work you are wrapping only knows how
 to stop through a callback of its own, such as a printer driver.
 
@@ -105,7 +105,7 @@ Console.WriteLine(string.Join(", ", printReceipt.History));
 Disposing `execution` calls `printerToldToStop`'s setter rather than unsubscribing from `printerOutput`, because
 this constructor cancels through the `Cancel` callback the execute function supplied.
 
-A failed execution's exception reaches `ThrownExceptions` even when nothing awaits `Execute` — a plain
+A failed execution's exception reaches `ThrownExceptions` even when nothing awaits `Execute`. A plain
 subscription sees it too, because `ThrownExceptions` is a separate stream from the command's result.
 
 ```csharp
@@ -208,7 +208,7 @@ Console.WriteLine(thirdRun[0]);
 // 4
 ```
 
-`withCanExecuteAndScheduler` combines `takeBackLoans` and `countShelf`, so its list has both results; the other
+`withCanExecuteAndScheduler` combines `takeBackLoans` and `countShelf`, so its list has both results. The other
 two combine a single child, so their list holds one.
 
 ## Derive from `ReactiveCommandBase<TParam, TResult>`
@@ -217,7 +217,7 @@ two combine a single child, so their list holds one.
 `CombinedReactiveCommand<TParam, TResult>` both build on. Deriving from it directly means implementing
 `CanExecute`, `IsExecuting`, `ThrownExceptions`, `Execute()`, `Execute(TParam)` and `Subscribe` yourself. It also
 means implementing two protected hooks, `ICommandCanExecute` and `ICommandExecute`. A `System.Windows.Input.ICommand`
-caller — such as XAML binding infrastructure — routes through these hooks instead of calling `CanExecute` and
+caller, such as XAML binding infrastructure, routes through these hooks instead of calling `CanExecute` and
 `Execute` directly. A realistic reason to derive this way is adapting an existing, non-reactive command source
 into ReactiveUI's contract, rather than writing execution logic that itself produces an `IObservable`.
 
@@ -263,10 +263,10 @@ Closing the desk raises `CanExecuteChanged`, which the sample's handler turns in
 
 ## Subscribe a witness directly
 
-A command is an `IObservable<TResult>`, so a witness — a class that implements `IObserver<T>` itself instead of
-using an operator such as `Subscribe(Action<T>)` — can subscribe to it the normal way, whether the command is a
-`ReactiveCommand<TParam, TResult>` or a hand-written subclass of `ReactiveCommandBase<TParam, TResult>`.
-`BookReceiptPrinter` prints a receipt for every book a command produces:
+A command is an `IObservable<TResult>`. A witness is a class that implements `IObserver<T>` itself, instead of
+using an operator such as `Subscribe(Action<T>)`. A witness can subscribe to a command the normal way, whether
+the command is a `ReactiveCommand<TParam, TResult>` or a hand-written subclass of
+`ReactiveCommandBase<TParam, TResult>`. `BookReceiptPrinter` prints a receipt for every book a command produces:
 
 ```csharp
 LibraryDesk desk = new();
@@ -324,8 +324,8 @@ Console.WriteLine(matches[0].Title);
 ```
 
 `IReactiveCommand`, without the type parameters, drops `Execute` and the result type entirely. Use it for a method
-that only needs to know whether a command is busy or ready to run — a status bar, say. Neither the command's
-parameter type nor its result type matters there.
+that only needs to know whether a command is busy or ready to run. A status bar is one example. Neither the
+command's parameter type nor its result type matters there.
 
 ```csharp
 LibraryDesk desk = new();
@@ -357,13 +357,13 @@ private static async Task<string> DescribeAsync(IReactiveCommand command)
 
 ## Following a command property that gets replaced
 
-A clerk's console screen might swap in a new search command each time the clerk switches catalogue: `SearchCommand`
-on `DeskConsoleViewModel` is an `IReactiveCommand<TParam, TResult>?` property that gets reassigned, not a fixed
-field. Subscribing to `this.WhenAnyValue(x => x.SearchCommand)` gives you the command instances themselves, one
+A clerk's console screen might swap in a new search command each time the clerk switches catalogue.
+`SearchCommand` on `DeskConsoleViewModel` is an `IReactiveCommand<TParam, TResult>?` property that gets
+reassigned, not a fixed field. Subscribing to `this.WhenAnyValue(x => x.SearchCommand)` gives you the command instances themselves, one
 per assignment. You would still have to subscribe to whichever one is current by hand, and re-subscribe every
-time it changes. `SwitchSubscribe` does that for you. Given an observable of commands, or of any inner
-observable, it follows whichever one the property currently holds, dropping the old one and subscribing to the
-new one the moment the property changes.
+time it changes. `SwitchSubscribe` does that for you. Give it an observable of commands, or of any inner
+observable. It follows whichever one the property currently holds. It drops the old one, and it subscribes to
+the new one the moment the property changes.
 
 ```mermaid
 %%{init: {"theme": "base", "themeVariables": {"fontFamily": "Roboto, Helvetica, Arial, sans-serif", "fontSize": "15px", "primaryColor": "#DCE9FF", "primaryBorderColor": "#6C8EC4", "primaryTextColor": "#0B2447", "secondaryColor": "#E3F2E8", "secondaryBorderColor": "#7FA88C", "secondaryTextColor": "#12301C", "tertiaryColor": "#F3E5F5", "tertiaryBorderColor": "#A98BB0", "tertiaryTextColor": "#2E1437", "lineColor": "#7B8699", "textColor": "#1B1F27", "noteBkgColor": "#FFF4D6", "noteBorderColor": "#C9A94F", "noteTextColor": "#3A2A00", "actorBkg": "#DCE9FF", "actorBorder": "#6C8EC4", "actorTextColor": "#0B2447", "signalColor": "#7B8699", "signalTextColor": "#1B1F27", "labelBoxBkgColor": "#F1F3F8", "labelBoxBorderColor": "#A7AEBB", "edgeLabelBackground": "#F7F9FC", "clusterBkg": "#F7F9FC", "clusterBorder": "#C9D1DE"}}}%%
@@ -435,7 +435,7 @@ result stream completes. Swapping in a new command does not call it. A `Reactive
 fact, never completes on its own. So `onCompleted` is reachable only if the outer `WhenAnyValue` observable ends.
 
 **3. Pick one of the command's own observables with a selector.** `SwitchSubscribe(selector, onNext)` projects
-each command to one of its own observables — `IsExecuting`, here — before switching and subscribing. That lets you
+each command to one of its own observables, `IsExecuting` here, before switching and subscribing. That lets you
 drive a busy indicator from whichever command is current.
 
 ```csharp
@@ -460,8 +460,8 @@ The selector overload also takes error and completion handlers, for a command ty
 same three-callback shape as step 2.
 
 `SwitchSubscribe` is not limited to command properties. Any property typed as an `IObservable<T>` can be
-swapped and followed the same way: `DeskConsoleViewModel.Progress` is a running match count that gets replaced
-each time a new search starts.
+swapped and followed the same way. `DeskConsoleViewModel.Progress` is one example: a running match count that
+gets replaced each time a new search starts.
 
 ```csharp
 DeskConsoleViewModel console = new();
@@ -485,8 +485,8 @@ Console.WriteLine(string.Join(", ", matchCounts));
 // 1, 2, 5
 ```
 
-Once `console.Progress` is reassigned to `secondSearch`, further values from `firstSearch` (`3`) are dropped; only
-`secondSearch`'s values (`5`) reach `matchCounts`.
+Once `console.Progress` is reassigned to `secondSearch`, further values from `firstSearch` (`3`) are dropped.
+Only `secondSearch`'s values (`5`) reach `matchCounts`.
 
 A selector overload also works on a plain `IObservable<T>` property, when the value you want is not the property
 itself but something it exposes. `ActiveSession` holds a `SearchSession` record whose `MatchCount` is the stream
@@ -548,12 +548,12 @@ source, for apps that use System.Reactive instead.
 
 | Member | What it does |
 | --- | --- |
-| `ReactiveCommand<TParam, TResult>` constructor (result observable) | Base constructor a subclass uses to intercept every run; `ReactiveCommand.Create*` calls the same one. |
+| `ReactiveCommand<TParam, TResult>` constructor (result observable) | Base constructor a subclass uses to intercept every run. `ReactiveCommand.Create*` calls the same one. |
 | `ReactiveCommand<TParam, TResult>` constructor (cancel callback) | Base constructor for execution logic that cancels through a callback rather than by unsubscribing. |
 | `CombinedReactiveCommand<TParam, TResult>` constructors | Three base constructors a subclass uses, with `canExecute`, an `ISequencer`, or both. |
-| `ReactiveCommandBase<TParam, TResult>` | Abstract base every command type shares: `CanExecute`, `IsExecuting`, `ThrownExceptions`, `Execute`, `Subscribe`, plus the `ICommand` hooks a subclass overrides. |
-| `ReactiveCommandBase<TParam, TResult>.ICommandCanExecute(object?)` | Protected hook a subclass overrides; an `ICommand` caller's `CanExecute` routes here. |
-| `ReactiveCommandBase<TParam, TResult>.ICommandExecute(object?)` | Protected hook a subclass overrides; an `ICommand` caller's `Execute` routes here. |
+| `ReactiveCommandBase<TParam, TResult>` | Abstract base every command type shares. That includes `CanExecute`, `IsExecuting`, `ThrownExceptions`, `Execute`, `Subscribe`, plus the `ICommand` hooks a subclass overrides. |
+| `ReactiveCommandBase<TParam, TResult>.ICommandCanExecute(object?)` | Protected hook a subclass overrides. An `ICommand` caller's `CanExecute` routes here. |
+| `ReactiveCommandBase<TParam, TResult>.ICommandExecute(object?)` | Protected hook a subclass overrides. An `ICommand` caller's `Execute` routes here. |
 | `ReactiveCommandBase<TParam, TResult>.Subscribe(IObserver<TResult>)` | Subscribes a witness directly to a command's results. |
 | `ReactiveCommand<TParam, TResult>.Subscribe(IObserver<TResult>)` | The same subscription on a plain `ReactiveCommand<TParam, TResult>`. |
 | `IReactiveCommand<TParam, TResult>` | The interface to expose a command through when a view model should not commit to a concrete command type. |
diff --git a/docs/documentation/reactiveui/handbook/data-binding/android/wire-up-controls.md b/docs/documentation/reactiveui/handbook/data-binding/android/wire-up-controls.md
index 97bb78ee..36516482 100644
--- a/docs/documentation/reactiveui/handbook/data-binding/android/wire-up-controls.md
+++ b/docs/documentation/reactiveui/handbook/data-binding/android/wire-up-controls.md
@@ -6,17 +6,17 @@ that gap. Call it once, and it finds every eligible property on your `Activity`,
 `ILayoutViewHost`. It assigns each one the control with the matching resource ID, instead of a `FindViewById`
 call per field. It works the way [Butterknife](https://jakewharton.github.io/butterknife/) does for Java Android
 code.
-The [school timetable app](../../platforms/android.md) uses it throughout; the examples below are all from that
+The [school timetable app](../../platforms/android.md) uses it throughout. The examples below are all from that
 app.
 
 ## Naming policy
 
 `WireUpControls` builds a dictionary of every resource ID name in your layouts, lowercased, mapped to the actual
-resource ID; the mapping mirrors the generated `Resource.designer.cs` file. Because the lookup is
+resource ID. The mapping mirrors the generated `Resource.designer.cs` file. Because the lookup is
 case-insensitive, you cannot reuse the same resource name with two different casings across your layouts.
 Android generates a distinct ID for each casing, so there is no single ID `WireUpControls` could map both to.
 Layout files commonly use a lower-case-first name such as `subjectLabel`, while a C# property uses an
-upper-case-first name such as `SubjectLabel`; the lowercased lookup is why that difference does not need a
+upper-case-first name such as `SubjectLabel`. The lowercased lookup is why that difference does not need a
 `[WireUpResource]` override.
 
 ## Resolve strategies
@@ -50,8 +50,8 @@ foreach (PropertyInfo member in wiredMembers)
 WireUpControls found 3 members to wire.
 ```
 
-`GetWireUpMembers` returns the properties a strategy would wire without wiring them, and `GetResourceName`
-reads the resource name one property resolves to; both are useful for a diagnostic like the one above. The
+`GetWireUpMembers` returns the properties a strategy would wire without wiring them. `GetResourceName`
+reads the resource name one property resolves to. Both are useful for a diagnostic like the one above. The
 activity's layout, `activity_main.xml`, declares the three resources those properties resolve to:
 
 ```xml
@@ -88,7 +88,7 @@ activity's layout, `activity_main.xml`, declares the three resources those prope
 ```
 
 `LessonsRecyclerView`, `BadgeContainer` and `DetailContainer` are the three writable `View`-typed properties
-`MainActivity` declares; `FeaturedLessonCard` and `PeeksRow` are assigned separately in code, so `Implicit`
+`MainActivity` declares. `FeaturedLessonCard` and `PeeksRow` are assigned separately in code. So `Implicit`
 wires only the properties the activity actually declares as `View` subtypes. `LessonCardView`, a compound view
 inflated into the top of that layout, wires its own two labels the same way, from inside its own constructor:
 
@@ -140,13 +140,13 @@ AndroidX.ControlFetcherMixins.WireUpControls(this, view);
 ```
 
 The core, non-AndroidX `ReactiveUI.ControlFetcherMixins` declares the same two overloads for the platform's own
-`Android.App.Fragment`. This page does not show them: attaching a classic `Fragment` to an activity needs the
-classic `Activity.FragmentManager`, which the Android platform itself deprecated at API level 28, and the
+`Android.App.Fragment`. This page does not show them. Attaching a classic `Fragment` to an activity needs the
+classic `Activity.FragmentManager`. The Android platform itself deprecated that at API level 28, and the
 timetable app targets a newer API than that.
 
 ### Explicit opt-in
 
-Under `ExplicitOptIn`, only a property that carries `[WireUpResource]` is wired; every other property is
+Under `ExplicitOptIn`, only a property that carries `[WireUpResource]` is wired. Every other property is
 ignored, with no type check. `[WireUpResource]` takes an optional resource name, for a property whose name does
 not match its resource. `AbsenceStatusView`, a compound view, opts in its one label from its constructor body:
 
@@ -183,7 +183,7 @@ instead of as an extension method:
 AndroidX.ControlFetcherMixins.WireUpControls(this, view, ControlFetcherMixins.ResolveStrategy.ExplicitOptIn);
 ```
 
-`[WireUpResource]`'s constructor argument is stored on `ResourceNameOverride`; `GetResourceName()` reads it as a
+`[WireUpResource]`'s constructor argument is stored on `ResourceNameOverride`. `GetResourceName()` reads it as a
 fallback when a property carries no override. `LessonDetailFragment` also reads it directly, off the attribute
 itself:
 
@@ -254,7 +254,7 @@ public TextView? UnusedLabel { get; set; }
 Without `[IgnoreResource]`, `ExplicitOptOut` would try to wire `UnusedLabel` to a resource named `unusedlabel`
 and throw a `MissingFieldException`, since `activity_absence.xml` declares no such resource. `GetControl` above
 fetches `extraLabel` directly on the activity, the same way `LessonDetailFragment` fetched `detailIcon` on a
-`View`; called with no argument, it resolves the resource named after the calling member instead.
+`View`. Called with no argument, it resolves the resource named after the calling member instead.
 
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
@@ -283,18 +283,18 @@ fetches `extraLabel` directly on the activity, the same way `LessonDetailFragmen
 `LessonCountBadgeHost`, a host with no view model, wires its one label through the auto-wireup constructor of
 `LayoutViewHostUnsafe` instead of a call to `WireUpControls` in its own body. Its constructor passes
 `attachToRoot: false`, `performAutoWireup: true` and `resolveStrategy: ControlFetcherMixins.ResolveStrategy.Implicit`
-to the base constructor, which calls the `ILayoutViewHost` overload of `WireUpControls` itself once inflation
-finishes; the constructor's own body adds nothing further. `ReactiveViewHostUnsafe<TViewModel>` offers the same
-constructor for a host with a view model, and `FirstLessonPeekHost` passes the same two flags to it. The
-reflection-free `LayoutViewHost` and `ReactiveViewHost<TViewModel>` have no such constructor.
+to the base constructor. That base constructor calls the `ILayoutViewHost` overload of `WireUpControls` itself
+once inflation finishes. The constructor's own body adds nothing further. `ReactiveViewHostUnsafe<TViewModel>`
+offers the same constructor for a host with a view model. `FirstLessonPeekHost` passes the same two flags to
+it. The reflection-free `LayoutViewHost` and `ReactiveViewHost<TViewModel>` have no such constructor.
 
 A host that wires its child without reflection, and stays trim- and AOT-safe, uses the `bind`-callback
 constructor instead and calls `FindViewById` itself. `WeekdayViewHost`, one page of the weekday pager, passes
 `bind: static (host, view) => ((WeekdayViewHost)host)._weekdayLabel = view.FindViewById<TextView>(Resource.Id.weekdayLabel)`
 to the base constructor this way.
 
-Every `WireUpControls` overload, and `GetControl`, carries `RequiresUnreferencedCode` and `RequiresDynamicCode`:
-both reflect over your assembly's generated resource type to resolve a name to an integer ID. The `bind`-callback
+Every `WireUpControls` overload, and `GetControl`, carries `RequiresUnreferencedCode` and `RequiresDynamicCode`.
+Both reflect over your assembly's generated resource type to resolve a name to an integer ID. The `bind`-callback
 constructor above needs neither. `MissingFieldException` is what any `WireUpControls` overload throws when a
 property cannot be resolved to a matching resource, whichever strategy is in effect.
 
diff --git a/docs/documentation/reactiveui/handbook/obsolete/collections/derived-lists.md b/docs/documentation/reactiveui/handbook/obsolete/collections/derived-lists.md
index f62222de..5e23b037 100644
--- a/docs/documentation/reactiveui/handbook/obsolete/collections/derived-lists.md
+++ b/docs/documentation/reactiveui/handbook/obsolete/collections/derived-lists.md
@@ -7,9 +7,9 @@ Order: 2
 
 ## CreateDerivedCollection
 
-`CreateDerivedCollection` projected a `ReactiveList` into another list that stayed in step with the source: adding,
-removing or filtering an item in the source updated the derived list automatically, and the derived list could also
-sort and filter on its own terms.
+`CreateDerivedCollection` projected a `ReactiveList` into another list that stayed in step with the source.
+Adding, removing or filtering an item in the source updated the derived list automatically. The derived list
+could also sort and filter on its own terms.
 
-The same projections — mapping, filtering and ordering a collection that updates as its source changes — are
-available today through DynamicData's source lists and caches. See [DynamicData operators](../../collections.md).
+DynamicData's source lists and caches offer the same projections today. That means mapping, filtering and
+ordering a collection so it updates as its source changes. See [DynamicData operators](../../collections.md).
diff --git a/docs/documentation/reactiveui/handbook/obsolete/collections/reactive-composite-collections.md b/docs/documentation/reactiveui/handbook/obsolete/collections/reactive-composite-collections.md
index c3670c79..4bd1731e 100644
--- a/docs/documentation/reactiveui/handbook/obsolete/collections/reactive-composite-collections.md
+++ b/docs/documentation/reactiveui/handbook/obsolete/collections/reactive-composite-collections.md
@@ -9,10 +9,10 @@ Order: 4
 > observable collections.
 
 `ReactiveCompositeCollections`, by Brad Phelan, added an `ICompositeCollection<T>`. It supported `Select`,
-`SelectMany` and `Where` the way `IEnumerable<T>` and `IObservable<T>` do, so a screen could compose and filter
+`SelectMany` and `Where`, the way `IEnumerable<T>` and `IObservable<T>` do. That let a screen compose and filter
 several source lists into one collection declaratively. The library lives at
-[Reactive Composite Collections (GitHub)](https://github.com/Weingartner/ReactiveCompositeCollections) and was
-published on [NuGet](https://www.nuget.org/packages/ReactiveCompositeCollections/).
+[Reactive Composite Collections (GitHub)](https://github.com/Weingartner/ReactiveCompositeCollections). It was
+published on [NuGet](https://www.nuget.org/packages/ReactiveCompositeCollections/) too.
 
-DynamicData covers the same ground today, with its own source lists, caches and operators, and is what
-[Collections](../../collections.md) documents.
+DynamicData covers the same ground today. It has its own source lists, caches and operators.
+[Collections](../../collections.md) documents DynamicData.
diff --git a/docs/documentation/reactiveui/handbook/platforms/index.md b/docs/documentation/reactiveui/handbook/platforms/index.md
index d39acb10..78c64f0c 100644
--- a/docs/documentation/reactiveui/handbook/platforms/index.md
+++ b/docs/documentation/reactiveui/handbook/platforms/index.md
@@ -3,16 +3,16 @@ Order: 16
 ---
 # Platforms
 
-ReactiveUI's core package holds view models, commands, routing and activation, and none of it depends on a UI
+ReactiveUI's core package holds view models, commands, routing and activation. None of it depends on a UI
 framework. A platform package connects that core to one UI framework. It adds:
 
 - base classes for your windows, pages and controls, so each one is an `IViewFor<TViewModel>` with a `ViewModel`
   property the framework can bind to;
-- hosts that show a view for a view model: a routed host that follows a router's navigation stack, and a view model host
-  that shows whatever view model you give it;
-- an activation fetcher, which tells [`WhenActivated`](../when-activated.md) when a view appears on screen and when it
-  leaves;
-- a main-thread sequencer for the framework's UI thread, so results reach the UI on the right thread
+- hosts that show a view for a view model: a routed host that follows a router's navigation stack, and a view
+  model host that shows whatever view model you give it;
+- an activation fetcher, which tells [`WhenActivated`](../when-activated.md) when a view appears on screen and
+  when it leaves;
+- a main-thread sequencer for the framework's UI thread. This gets results to the UI on the right thread
   (see [Scheduling](../scheduling.md));
 - a `With<Platform>()` call for the [app builder](../rxappbuilder.md) that registers all of the above.
 
diff --git a/docs/documentation/reactiveui/handbook/view-models/reactive-object.md b/docs/documentation/reactiveui/handbook/view-models/reactive-object.md
index 6ccc48a9..171941a2 100644
--- a/docs/documentation/reactiveui/handbook/view-models/reactive-object.md
+++ b/docs/documentation/reactiveui/handbook/view-models/reactive-object.md
@@ -358,7 +358,7 @@ To skip writing these members by hand, mark a `partial` class with `[IReactiveOb
 
 ## ReactiveRecord for mostly-immutable data
 
-`ReactiveRecord` is the record equivalent of `ReactiveObject`. A record's properties are normally set once at construction with `init`, so most of a `ReactiveRecord`'s surface never raises a notification. Use it for a value that is mostly fixed but has one or two fields a later step can still edit, such as a moderator's note added after a grade is finalized. `CourseResult` in the example is a finalized grade: `StudentName`, `Course` and `Grade` are `init`-only. Only `ModeratorNotes` can change after construction, through `AddModeratorNote`, the same pattern as `Student.AddGrade` above.
+`ReactiveRecord` is the record equivalent of `ReactiveObject`. A record's properties are normally set once at construction with `init`, so most of a `ReactiveRecord`'s surface never raises a notification. Use it for a value that is mostly fixed but has one or two fields a later step can still edit. A moderator's note added after a grade is finalized is one example. `CourseResult` in the example is a finalized grade: `StudentName`, `Course` and `Grade` are `init`-only. Only `ModeratorNotes` can change after construction, through `AddModeratorNote`, the same pattern as `Student.AddGrade` above.
 
 ```csharp
 public sealed record CourseResult : ReactiveRecord
@@ -444,7 +444,7 @@ Console.WriteLine(original.StudentName == corrected.StudentName);
 // True
 ```
 
-`ReactiveRecord.Equals(ReactiveRecord)` compares two records by value, using the derived record's own properties. The notification state `ReactiveRecord` holds for each instance takes no part. So two results created separately with the same values are equal, and `==` agrees. `Equals` works this way even when both records are known only through the `ReactiveRecord` base type, such as inside a routine that audits every record type in a data layer without knowing their concrete types.
+`ReactiveRecord.Equals(ReactiveRecord)` compares two records by value, using the derived record's own properties. The notification state `ReactiveRecord` holds for each instance takes no part. So two results created separately with the same values are equal, and `==` agrees. `Equals` works this way even when both records are known only through the `ReactiveRecord` base type. That covers a routine that audits every record type in a data layer without knowing their concrete types.
 
 ```csharp
 CourseResult original = new() { StudentName = "Katherine Johnson", Course = "Orbital Mechanics", Grade = 99 };
diff --git a/docs/documentation/reactiveui/index.md b/docs/documentation/reactiveui/index.md
index d855bd63..74f51884 100644
--- a/docs/documentation/reactiveui/index.md
+++ b/docs/documentation/reactiveui/index.md
@@ -7,44 +7,57 @@ Source and issues: [reactiveui/ReactiveUI](https://github.com/reactiveui/Reactiv
 [getting started](getting-started/index.md), the [handbook](handbook/index.md), [guidelines](guidelines/index.md) and
 [upgrading](upgrading/index.md). ReactiveUI runs its bindings on [ReactiveUI.Binding](../binding/index.md).
 
-<p>ReactiveUI is a composable, cross-platform model-view-viewmodel framework for all .NET platforms, that is inspired by functional reactive programming. Reactive programming is a paradigm that allows you to express the idea around a feature in one readable place, abstract mutable state away from your user interfaces and improve the testability of your application.</p>
+ReactiveUI is a composable, cross-platform model-view-viewmodel (MVVM) framework. It works on every .NET platform. Functional reactive programming inspired it. That style of programming models values as streams that change over time. A stream fires an event each time its value changes. You subscribe to a stream to react to those changes.
 
-<p>It is the father of the extremely popular <a href="https://github.com/ReactiveCocoa/">ReactiveCocoa</a> framework. Internally the maintainers debate whether ReactiveUI is or is not a framework, as at its core the project is essentially a bunch of extension methods for reactive streams, built on <a href="../primitives/why-primitives.md">ReactiveUI.Primitives</a>. The project was started in 2009 by Anaïs Betts and is now old enough to attend grade school but unlike a teenager it is extremely stable and has matured over the years into a solid and fine choice for building your next application. <a href="https://github.com/reactiveui/ReactiveUI/issues/979#issuecomment-196735701" target="_blank">The framework is used by Slack, GitHub, Amazon, Elastic and Microsoft</a>.</p>
+Reactive programming lets you keep the logic for one feature in one place. It keeps mutable state out of your views. It makes your application easier to test. At its core, the project is a set of extension methods for reactive streams. Those extension methods are built on [ReactiveUI.Primitives](../primitives/why-primitives.md). [Slack, GitHub, Amazon, Elastic and Microsoft all use it](https://github.com/reactiveui/ReactiveUI/issues/979#issuecomment-196735701).
 
-<p>We believe that code is communication between people, that also happens to run on a computer. If you optimise for humans, then over a long time your project will end up better. Software should be understandable by other people; that is super important. We believe that only <a href="https://www.youtube.com/watch?v=5DZ8nC0ENdg" target="_blank">the power of reactive streams allows you to express the idea around a feature in one readable place</a>.</p>
+ReactiveUI connects three layers of your application. Those layers are the view, the view model and the model. A binding keeps a view control and a view model property in sync. A command runs a view model method when the user acts on the view. A change notification tells subscribers when a property's value changes. The diagram below shows how these pieces fit together.
 
-<p>Let’s say you have a text field, and whenever the user types something into it, you want to make a network request which searches for that query. Your designer has requested that this search query automatically execute as the user is typing but your operation team wants guarantees that only one network request is ever in transit and no more frequently than roughly once per second whilst the user is typing.</p>
+```mermaid
+%%{init: {"theme": "base", "themeVariables": {"fontFamily": "Roboto, Helvetica, Arial, sans-serif", "fontSize": "15px", "primaryColor": "#DCE9FF", "primaryBorderColor": "#6C8EC4", "primaryTextColor": "#0B2447", "secondaryColor": "#E3F2E8", "secondaryBorderColor": "#7FA88C", "secondaryTextColor": "#12301C", "tertiaryColor": "#F3E5F5", "tertiaryBorderColor": "#A98BB0", "tertiaryTextColor": "#2E1437", "lineColor": "#7B8699", "textColor": "#1B1F27", "noteBkgColor": "#FFF4D6", "noteBorderColor": "#C9A94F", "noteTextColor": "#3A2A00", "actorBkg": "#DCE9FF", "actorBorder": "#6C8EC4", "actorTextColor": "#0B2447", "signalColor": "#7B8699", "signalTextColor": "#1B1F27", "labelBoxBkgColor": "#F1F3F8", "labelBoxBorderColor": "#A7AEBB", "edgeLabelBackground": "#F7F9FC", "clusterBkg": "#F7F9FC", "clusterBorder": "#C9D1DE"}}}%%
+flowchart LR
+    classDef view fill:#DCE9FF,stroke:#6C8EC4,color:#0B2447
+    classDef vm fill:#E3F2E8,stroke:#7FA88C,color:#12301C
+    classDef model fill:#F3E5F5,stroke:#A98BB0,color:#2E1437
+    View(["View"]):::view -- "binding and commands" --> VM(["View model"]):::vm
+    VM -- "change notifications" --> View
+    VM -- "reads and writes" --> Model(["Model"]):::model
+```
 
-<img src="../../images/search-autocomplete.gif" alt="search autocomplete" />
+Notice that the view model never touches the view directly. It only exposes properties and commands, and ReactiveUI wires them up for you.
 
-<h3>How would you usually implement this?</h3>
+### An example: search as you type
 
-<p>Most modern programming today is basically imperative, meaning it models the traditional fetch-execute cycle of a CPU. Perform an instruction, fetch the next one. Perform that one, and so on. For decades, programmers have had to mould their brains to fit the paradigm of the CPU. It's been like this since the early 1980s.</p>
+Say you have a text field. You want to search a service each time the user types. Your designer wants the search to fire automatically as the user types. Your operations team wants only one search request in flight at a time. They also want no more than one request roughly every second.
 
-<p>When we rely on hoping that the behavior that emerges from a program is correct, and that reliance is based on nothing more than a programmer's correctness, then we can easily find ourselves in a sticky situation. We can try and mitigate the costs of imperative programming with things like unit tests or integration tests, but why mitigate the costs when there's a better way?</p>
+![Search results updating live as the user types in a search box](../../images/search-autocomplete.gif)
 
-<h3>There is a better way</h3>
+Most code today is imperative. An imperative program runs one instruction, then the next, then the next. This is much like how a CPU works through its fetch-execute cycle. This style has shaped how programmers write code since the early 1980s.
 
-<p>Long ago, when computer programming first came to be, machines had to be programmed quite manually. If the technician entered the correct sequence of machine codes in the correct order, then the resulting program behavior would satisfy the business requirements.  Instead of telling a computer how to do its job, which is error-prone and relies too heavily on the infallibility of the programmer, why don't we just tell it what its job is and let it figure the rest out?</p>
+An imperative solution to the search box above needs a timer. It also needs a flag for whether a request is in flight. It needs code to cancel a stale request too. You can test that code. The tests only catch the bugs you thought to write tests for.
 
-<p>ReactiveUI is inspired by the paradigm of Functional Reactive Programming, which allows you to model user input as a function that changes over time. This is super cool because it allows you to abstract mutable state away from your user interfaces and express the idea around a feature in one readable place whilst improving application testability. Reactive programming can look scary and complex at first glance, but the best way to describe reactive programming is to think of a spreadsheet:</p>
+Code is communication between people. It also happens to run on a computer. When you write code for the next person to read, your project stays healthier over time. [Reactive streams let you express a feature's idea in one readable place](https://www.youtube.com/watch?v=5DZ8nC0ENdg). That is what makes them worth learning.
 
-<br />
-<img src="../../images/frp-excel.gif" alt="frp excel" />
-<br />
+### A better way: reactive streams
 
-<br />
+ReactiveUI models the text field's input as a stream. A stream is a sequence of values that arrive over time. You can filter, delay and combine a stream with operators. This works the same way you filter and combine a collection with LINQ. It keeps the feature's logic in one readable place, including the delay and the one-request-at-a-time rule.
 
-<ul>
-    <li>Three cells, A, B, and C.</li>
-    <li>C is defined as the sum of A and B.</li>
-    <li>Whenever A or B changes, C reacts to update itself.</li>
-</ul>
+Reactive programming can look strange at first. The easiest way to picture it is a spreadsheet:
 
-<p>That's reactive programming: changes propagate throughout a system automatically. Welcome to the peanut butter and jelly of programming paradigms.</p>
+![A spreadsheet where cell C recalculates automatically when cell A or cell B changes](../../images/frp-excel.gif)
 
-<div class="youtube-video-container"><iframe src="https://www.youtube.com/embed/DYEbUF4xs1Q" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe></div>
+- Three cells, A, B, and C.
+- C is defined as the sum of A and B.
+- Whenever A or B changes, C reacts to update itself.
 
-<h3>Get started</h3>
+That is reactive programming. A change in one place propagates automatically to everywhere that depends on it.
 
-<p>Sounds interesting? <a href="getting-started/index.md">Get started!</a></p>
+[Watch "Functional Reactive Programming" on YouTube](https://www.youtube.com/watch?v=DYEbUF4xs1Q)
+
+### History
+
+Anaïs Betts started ReactiveUI in 2009. The project is the father of the popular [ReactiveCocoa](https://github.com/ReactiveCocoa/) framework. It has matured over the years. Today it is a stable, solid choice for your next application.
+
+### Get started
+
+Sounds interesting? [Get started!](getting-started/index.md)

From d66e6b8751581185e50affdd25af01b4e1bb6a35 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 17:14:15 +1000
Subject: [PATCH 8/9] docs(reactiveui): add the Apple platform page

---
 .../reactiveui/handbook/platforms/apple.md    | 582 ++++++++++++++++++
 .../reactiveui/handbook/platforms/index.md    |   6 +-
 2 files changed, 586 insertions(+), 2 deletions(-)
 create mode 100644 docs/documentation/reactiveui/handbook/platforms/apple.md

diff --git a/docs/documentation/reactiveui/handbook/platforms/apple.md b/docs/documentation/reactiveui/handbook/platforms/apple.md
new file mode 100644
index 00000000..009d66db
--- /dev/null
+++ b/docs/documentation/reactiveui/handbook/platforms/apple.md
@@ -0,0 +1,582 @@
+---
+Order: 8
+---
+# Apple platforms
+
+[Run the complete page example](https://github.com/reactiveui/ReactiveUI/blob/main/src/examples/Documentation/Pages/platform-apple/platform-apple.csproj).
+
+iOS, Mac Catalyst, tvOS and macOS views come from UIKit or AppKit. Neither toolkit gives a view a built-in way to
+raise a change notification, and neither has anything like a router or an activation lifecycle. The core
+`ReactiveUI` package supplies all three. It builds for the `ios`, `maccatalyst`, `macos` and `tvos` target
+frameworks, so there is no separate Apple package to install beyond `ReactiveUI` itself. It adds:
+
+- base classes for view controllers, views, controls, image views and (on UIKit) navigation, tab bar and page
+  containers, so each one is an `IViewFor<TViewModel>` with a `ViewModel` property and change notifications;
+- `RoutedViewHost`, which follows a router's navigation stack on iOS, Mac Catalyst and tvOS, and
+  `ViewModelViewHost`, which shows whatever view model you assign it, on every Apple platform including macOS;
+- `AutoSuspendHelper<T>`, which turns app life-cycle callbacks into the [suspension](../data-persistence.md)
+  signals a suspension driver needs, and `AppSupportJsonSuspensionDriver`, which saves and loads state under the
+  platform's Application Support directory;
+- `PlatformOperations`, which answers `IPlatformOperations.GetOrientation()` the way every platform does.
+
+This page's example is a library app: a catalog of books, a loan flow that picks a member, and a members tab.
+iOS and macOS share the same view models and the same `Book`, `Member`, `LoanViewModel` and `BookCatalogViewModel`
+types; only the views differ, because UIKit and AppKit are different toolkits. On iPhone the root is a tab bar
+with the catalog, members and a cover-paging tab. On iPad and on macOS the root is a split view: a catalog master
+column and a `ViewModelViewHost` detail column that shows whichever book is selected.
+
+## Start ReactiveUI
+
+**1. Register the platform module.** `WithPlatformModule<PlatformRegistrations>()` on the
+[app builder](../rxappbuilder.md) registers `IPlatformOperations`, `ISuspensionDriver` and the platform's
+main-thread sequencer. Call it once, before any view appears: in `FinishedLaunching` on iOS, in
+`DidFinishLaunching` on macOS.
+
+```csharp
+ReactiveUIBuilder builder = RxAppBuilder.CreateReactiveUIBuilder();
+_ = builder.WithPlatformModule<PlatformRegistrations>().BuildApp();
+```
+
+Apple ships no `With<Platform>()` convenience method of its own; `PlatformRegistrations` is the same
+`IWantsToRegisterStuff` module every platform package supplies, and `WithPlatformModule<T>()` is the general way
+to load one.
+
+**2. Wire up automatic state suspension.** `AutoSuspendHelper<T>` needs the app delegate as its type parameter,
+so it can verify the delegate overrides every life-cycle method it depends on. Forward each override to the
+matching helper method.
+
+```csharp
+_autoSuspendHelper = new AutoSuspendHelper<AppDelegate>(this);
+_autoSuspendHelper.FinishedLaunching(application, launchOptions!);
+Console.WriteLine($"FinishedLaunching captured {_autoSuspendHelper.LaunchOptions?.Count ?? 0} launch option(s).");
+```
+
+```text
+FinishedLaunching captured 0 launch option(s).
+```
+
+```csharp
+public override void OnActivated(UIApplication application) =>
+    _autoSuspendHelper?.OnActivated(application);
+
+public override void DidEnterBackground(UIApplication application) =>
+    _autoSuspendHelper?.DidEnterBackground(application);
+```
+
+On macOS the helper watches a different set of notifications, because `NSApplicationDelegate` has no
+`FinishedLaunching`/`OnActivated`/`DidEnterBackground` trio. It forwards `DidFinishLaunching`, `DidBecomeActive`,
+`DidResignActive`, `DidHide` and `ApplicationShouldTerminate` instead:
+
+```csharp
+_autoSuspendHelper = new AutoSuspendHelper<AppDelegate>(this);
+_autoSuspendHelper.DidFinishLaunching(notification);
+```
+
+```csharp
+public override void DidBecomeActive(NSNotification notification) =>
+    _autoSuspendHelper?.DidBecomeActive(notification);
+
+public override void DidResignActive(NSNotification notification) =>
+    _autoSuspendHelper?.DidResignActive(notification);
+
+public override void DidHide(NSNotification notification) =>
+    _autoSuspendHelper?.DidHide(notification);
+
+public override NSApplicationTerminateReply ApplicationShouldTerminate(NSApplication sender) =>
+    _autoSuspendHelper?.ApplicationShouldTerminate(sender) ?? NSApplicationTerminateReply.Now;
+```
+
+`ApplicationShouldTerminate` returns `NSApplicationTerminateReply.Later` and only lets AppKit quit once
+`ShouldPersistState` subscribers finish, so a quit never races a save.
+
+The helper itself is `IDisposable`. Dispose it from the app delegate's own `Dispose(bool)` override, the same
+override `NSObject`/`UIApplicationDelegate` subclasses already carry:
+
+```csharp
+protected override void Dispose(bool disposing)
+{
+    if (disposing)
+    {
+        _autoSuspendHelper?.Dispose();
+    }
+
+    base.Dispose(disposing);
+}
+```
+
+**3. Point the suspension host at a driver.** `AppSupportJsonSuspensionDriver` saves and loads state under
+`~/Library/Application Support/<bundle id>/<subdirectory>/state.dat`. Its parameterless constructor uses a
+`Data` subdirectory; the one-argument constructor names your own.
+
+```csharp
+RxSuspension.SuspensionHost.CreateNewAppState = static () => new LibraryAppState();
+
+AppSupportJsonSuspensionDriver driver = new("Library");
+RxSuspension.SuspensionHost.SetupDefaultSuspendResume(driver);
+
+_ = driver.SaveState(new LibraryAppState { LastViewedBook = "Pride and Prejudice" }, LibraryAppStateJsonContext.Default.LibraryAppState)
+    .Subscribe(static _ => Console.WriteLine("AppSupportJsonSuspensionDriver saved the app state."));
+_ = driver.LoadState(LibraryAppStateJsonContext.Default.LibraryAppState)
+    .Subscribe(
+        static state => Console.WriteLine($"AppSupportJsonSuspensionDriver loaded state for {state?.LastViewedBook}."),
+        static error => Console.WriteLine($"AppSupportJsonSuspensionDriver had nothing to load yet: {error.Message}."));
+_ = driver.InvalidateState().Subscribe(static _ => Console.WriteLine("AppSupportJsonSuspensionDriver invalidated the saved state."));
+```
+
+`SaveState<T>(T, JsonTypeInfo<T>)` and `LoadState<T>(JsonTypeInfo<T>)` take a source-generated
+`JsonTypeInfo<T>`, so serializing never needs reflection. `LibraryAppStateJsonContext` is a one-line
+`JsonSerializerContext` for `LibraryAppState`:
+
+```csharp
+[JsonSerializable(typeof(LibraryAppState))]
+public sealed partial class LibraryAppStateJsonContext : JsonSerializerContext;
+```
+
+`LoadState()` and `SaveState<T>(T)` are the same two operations without the type info, serializing through
+reflection instead. They carry `[RequiresUnreferencedCode]` and `[RequiresDynamicCode]`, so a page built for
+trimming and AOT calls only the typed overloads above.
+
+A reader who stops here can already start ReactiveUI and persist state on both platforms. The rest of this page
+gives a view controller a view model, wires up navigation, and covers the platform's other pieces.
+
+## Give a view controller a view model
+
+`ReactiveViewController<TViewModel>` wraps `UIViewController` on UIKit and `NSViewController` on AppKit with a
+`ViewModel` property and its change notifications. Build the view in code inside `ViewDidLoad` (`LoadView` on
+macOS, where `View` has no default), then bind inside `WhenActivated` so every binding tears down when the page
+leaves and starts again if it returns.
+
+```csharp
+public sealed class BookListViewController : ReactiveViewController<BookCatalogViewModel>
+{
+    internal UIButton LoanButton { get; } = UIButton.FromType(UIButtonType.System);
+
+    public override void ViewDidLoad()
+    {
+        base.ViewDidLoad();
+
+        Title = "Catalog";
+```
+
+```csharp
+        _ = this.WhenActivated(d =>
+        {
+            foreach (Book book in ViewModel!.Books)
+            {
+                // The frame constructor pre-sizes the row; Auto Layout resizes it once ViewModel bindings run.
+                BookRowView row = new(CGRect.Empty) { ViewModel = book };
+                UITapGestureRecognizer tap = new(() => ViewModel!.SelectedBook = book);
+                row.AddGestureRecognizer(tap);
+                _rows.AddArrangedSubview(row);
+            }
+
+            d(this.BindCommand(ViewModel, static vm => vm.OpenLoan, static v => v.LoanButton));
+        });
+    }
+```
+
+`LoanButton` is `internal`, not `private`: the `this.BindCommand(...)` call above compiles to a generated,
+reflection-free dispatch, and the generator can only observe a `public` or `internal` member. A `private` target
+fails the build with `RXUIBIND003`. `LoanViewController`, the page `RoutedViewHost` pushes next, follows the same
+shape and adds a one-way bind with a converter:
+
+```csharp
+d(this.OneWayBind(
+        ViewModel,
+        static vm => vm.SelectedMember,
+        static v => v.SelectedMemberLabel.Text,
+        static member => member is null ? "(no member selected)" : $"To: {member.Name}"));
+d(this.BindCommand(ViewModel, static vm => vm.ConfirmLoan, static v => v.ConfirmButton));
+d(this.BindCommand(ViewModel, static vm => vm.Cancel, static v => v.CancelButton));
+```
+
+Every `ReactiveViewController<TViewModel>` also frees its own controls. Override `Dispose(bool)`, the same
+`NSObject` override the base class itself overrides, and dispose what you built:
+
+```csharp
+protected override void Dispose(bool disposing)
+{
+    if (disposing)
+    {
+        _rows.Dispose();
+        LoanButton.Dispose();
+    }
+
+    base.Dispose(disposing);
+}
+```
+
+`ViewDidLoad`/`LoadView` run once, before the page ever appears; UIKit and AppKit call `ViewWillAppear` and
+`ViewDidDisappear` (`ViewWillAppear()`/`ViewDidDisappear()`, no argument, on macOS) every time the page appears
+and leaves. `ReactiveViewController<TViewModel>` overrides both to raise `Activated` and `Deactivated`, which
+`WhenActivated` needs internally; application code never calls either override directly.
+
+## Views, controls and image views
+
+`ReactiveView<TViewModel>`, `ReactiveControl<TViewModel>` and `ReactiveImageView<TViewModel>` give the same
+`ViewModel` property to a plain `UIView`/`NSView`, a `UIControl`/`NSControl`, and a `UIImageView`/`NSImageView`.
+`BookRowView` is a `ReactiveView<Book>` that shows one catalog row; a real catalog would use a reactive table
+source instead of a stack of rows, which is a different chunk of this API covered under
+[Tables and collections](#tables-and-collections) below.
+
+```csharp
+public sealed class BookRowView : ReactiveView<Book>
+{
+    internal UILabel TitleLabel { get; } = new() { Font = UIFont.PreferredHeadline! };
+
+    internal UILabel StatusLabel { get; } = new() { Font = UIFont.PreferredSubheadline!, TextColor = UIColor.SecondaryLabel };
+```
+
+```csharp
+        _ = this.WhenActivated(d =>
+        {
+            d(this.OneWayBind(ViewModel, static vm => vm.Title, static v => v.TitleLabel.Text));
+            d(this.OneWayBind(
+                ViewModel,
+                static vm => vm.IsOnLoan,
+                static v => v.StatusLabel.Text,
+                static onLoan => onLoan ? "On loan" : "Available"));
+            d(Activated.Subscribe(static _ => Console.WriteLine("BookRowView activated.")));
+            d(Deactivated.Subscribe(static _ => Console.WriteLine("BookRowView deactivated.")));
+        });
+```
+
+Setting `ViewModel` happens before a view or control ever gains a superview, never after. `Activated` fires from
+`WillMoveToSuperview`/`ViewWillMoveToSuperview` the moment a view or control gains one, so a `BookDetailViewController`
+that hosts a cover and a rating control builds each one fully, `ViewModel` included, before adding it to its
+stack:
+
+```csharp
+BookCoverImageView cover = new() { ViewModel = ViewModel, TranslatesAutoresizingMaskIntoConstraints = false };
+```
+
+```csharp
+StarRatingControl rating = new() { ViewModel = ViewModel };
+_layout.AddArrangedSubview(rating);
+```
+
+`StarRatingControl` is a `ReactiveControl<Book>` wrapping a `UIStepper`/`NSStepper`, since neither toolkit has a
+built-in star control. It shows the full `ReactiveControl<TViewModel>` surface in one place: the classic
+`PropertyChanged`/`PropertyChanging` events, the `Changed`/`Changing` observables, `ThrownExceptions`,
+`SuppressChangeNotifications()`, and a two-way `Bind`:
+
+```csharp
+public event EventHandler? StarsChanged;
+
+public int Stars
+{
+    get => (int)_stepper.Value;
+    set => _stepper.Value = value;
+}
+```
+
+```csharp
+_stepper.ValueChanged += (_, _) => StarsChanged?.Invoke(this, EventArgs.Empty);
+
+// A rating of 0 never fires a change notification on its own, so start silent rather than log a phantom change.
+using (SuppressChangeNotifications())
+{
+    Stars = 0;
+}
+
+PropertyChanging += static (_, e) => Console.WriteLine($"StarRatingControl.{e.PropertyName} is changing.");
+PropertyChanged += (_, e) => Console.WriteLine($"StarRatingControl.{e.PropertyName} changed to {Stars}.");
+
+_ = this.WhenActivated(d =>
+{
+    d(this.Bind(ViewModel, static vm => vm.Rating, static v => v.Stars));
+    d(Changed.Subscribe(static change => Console.WriteLine($"StarRatingControl.{change.PropertyName} changed (Changed stream).")));
+    d(Changing.Subscribe(static change => Console.WriteLine($"StarRatingControl.{change.PropertyName} is changing (Changing stream).")));
+    d(ThrownExceptions.Subscribe(static error => Console.WriteLine($"StarRatingControl threw: {error.Message}")));
+    d(Activated.Subscribe(static _ => Console.WriteLine("StarRatingControl activated.")));
+    d(Deactivated.Subscribe(static _ => Console.WriteLine("StarRatingControl deactivated.")));
+});
+```
+
+`this.Bind(ViewModel, vm => vm.Rating, v => v.Stars)` works two-way because the binding layer finds a
+`StarsChanged` event for the `Stars` property by name. Name a control's own change event `<Property>Changed` to
+opt into the same convention.
+
+`BookCoverImageView` is a `ReactiveImageView<Book>`. This page has no bundled cover art, so it sets a blank
+placeholder image once and binds the accessibility label to the book's title instead of the image itself:
+
+```csharp
+public sealed class BookCoverImageView : ReactiveImageView<Book>
+{
+    public BookCoverImageView()
+    {
+        Image ??= new UIImage();
+
+        _ = this.WhenActivated(d =>
+        {
+            d(this.OneWayBind(ViewModel, static vm => vm.Title, static v => v.AccessibilityLabel));
+            d(ThrownExceptions.Subscribe(static error => Console.WriteLine($"BookCoverImageView threw: {error.Message}")));
+        });
+    }
+}
+```
+
+## Navigate with RoutedViewHost
+
+`RoutedViewHost` is a `ReactiveNavigationController` that pushes a view for whichever view model a
+`RoutingState` router navigates to, and pops when the router navigates back. It exists on iOS, Mac Catalyst and
+tvOS, because it wraps `UINavigationController`, which AppKit has no equivalent of. Give it the router and a
+view locator, then navigate:
+
+```csharp
+RoutedViewHost catalogHost = new()
+{
+    Router = shell.Router,
+    ViewLocator = catalogViewLocator,
+};
+catalogHost.TabBarItem = new UITabBarItem("Catalog", null, 0);
+_ = shell.Router.Navigate.Execute(catalog).Subscribe();
+```
+
+`catalogViewLocator` is a `DefaultViewLocator` with a `Map` entry per view model, resolved without reflection:
+
+```csharp
+DefaultViewLocator catalogViewLocator = new();
+catalogViewLocator.Map<BookCatalogViewModel, BookListViewController>();
+catalogViewLocator.Map<LoanViewModel, LoanViewController>();
+```
+
+`RoutedViewHost`'s own constructor calls `WhenActivated` internally to track the router; its `PushViewController`
+and `PopViewController` overrides run when the router's stack grows or shrinks, never when application code
+calls them directly. `RoutedViewHostUnsafe`, the twin that also resolves a view registered only with the service
+locator, carries `[RequiresDynamicCode]`; this page is built for trimming and AOT, so it never calls that twin,
+the same way [data binding on Apple platforms](../data-binding/ios.md#which-views-the-hosts-find) recommends.
+
+For a screen that is not driven by a router at all, `ReactiveNavigationController<TViewModel>` wraps a root view
+controller directly. `MembersNavigationController` sets its own `ViewModel` once, for the tab bar to read:
+
+```csharp
+public sealed class MembersNavigationController : ReactiveNavigationController<MembersViewModel>
+{
+    public MembersNavigationController(MembersViewModel viewModel)
+        : base(new MembersPlaceholderViewController { ViewModel = viewModel }) =>
+        ViewModel = viewModel;
+}
+```
+
+## Show any view model with ViewModelViewHost
+
+`ViewModelViewHost` shows whatever view model you assign it, resolving a view through its own `ViewLocator`.
+Unlike `RoutedViewHost`, it exists on macOS too, since it only needs `NSViewController`, not a navigation
+controller. The library's iPad and macOS root is a split view whose detail column is a `ViewModelViewHost` that
+tracks the catalog's selection:
+
+```csharp
+DefaultViewLocator detailLocator = new();
+detailLocator.Map<Book, BookDetailViewController>();
+_detailHost = new ViewModelViewHost
+{
+    DefaultContent = new UIViewController(),
+    ViewLocator = detailLocator,
+};
+```
+
+```csharp
+_ = this.WhenActivated(d =>
+    d(catalog.WhenAnyValue(static vm => vm.SelectedBook)
+        .WhereNotNull()
+        .Subscribe(book => _detailHost.ViewModel = book)));
+```
+
+`DefaultContent` shows while `ViewModel` is `null`, before anything is selected. `ViewModelViewHostUnsafe`
+carries the same `[RequiresDynamicCode]` restriction as `RoutedViewHostUnsafe`, for the same reason.
+
+## Page and split across screens
+
+`ReactiveTabBarController<TViewModel>` and `ReactivePageViewController<TViewModel>` wrap
+`UITabBarController` and `UIPageViewController`; both exist only on iOS, Mac Catalyst and tvOS.
+`ReactiveSplitViewController<TViewModel>` wraps `UISplitViewController` on those three and `NSSplitViewController`
+on macOS, so the library's split-view root is the one container this page shares across every Apple platform.
+
+`LibraryTabBarController` is the iPhone root: a `RoutedViewHost` catalog tab, a `MembersNavigationController`
+tab, and a `BookCoverPagerViewController` tab.
+
+```csharp
+public sealed class LibraryTabBarController : ReactiveTabBarController<LibraryShellViewModel>
+{
+    public LibraryTabBarController(LibraryShellViewModel shell, IViewLocator catalogViewLocator, BookCatalogViewModel catalog, MembersViewModel members)
+    {
+        ViewModel = shell;
+```
+
+```csharp
+        ViewControllers = [catalogHost, membersNav, coverPager];
+
+        _ = this.WhenActivated(d =>
+        {
+            d(Activated.Subscribe(static _ => Console.WriteLine("LibraryTabBarController activated.")));
+            d(Deactivated.Subscribe(static _ => Console.WriteLine("LibraryTabBarController deactivated.")));
+        });
+    }
+}
+```
+
+`BookCoverPagerViewController` pages through a `BookDetailViewController` per book. Give the base constructor a
+transition style and orientation, implement `IUIPageViewControllerDataSource`, and set the first page once
+`ViewModel` is known:
+
+```csharp
+public sealed class BookCoverPagerViewController : ReactivePageViewController<BookCatalogViewModel>, IUIPageViewControllerDataSource
+{
+    public BookCoverPagerViewController()
+        : base(UIPageViewControllerTransitionStyle.Scroll, UIPageViewControllerNavigationOrientation.Horizontal)
+    {
+    }
+
+    public override void ViewDidLoad()
+    {
+        base.ViewDidLoad();
+
+        DataSource = this;
+
+        _ = this.WhenActivated((Action<IDisposable> onDispose) =>
+        {
+            _ = onDispose;
+            if (ViewModel!.Books.Count == 0)
+            {
+                return;
+            }
+
+            SetViewControllers([CreatePage(ViewModel.Books[0])], UIPageViewControllerNavigationDirection.Forward, false, null);
+        });
+    }
+```
+
+`GetPreviousViewController` and `GetNextViewController` are the data source methods `UIPageViewController` calls
+as the reader swipes; the app never calls either directly. Both create a fresh `BookDetailViewController` with
+its `ViewModel` already set, the same rule every view and control on this page follows.
+
+`LibrarySplitViewController` shares its shape across iOS and macOS: a master column, a `ViewModelViewHost`
+detail column, and a subscription that feeds the detail host from the master's selection. Only the master's
+own type (`ReactiveViewController<BookCatalogViewModel>`) and how a split item is added
+(`ViewControllers = [master, _detailHost]` on iOS, `AddSplitViewItem(NSSplitViewItem.FromViewController(...))`
+on macOS) differ between the two.
+
+```csharp
+public sealed class LibrarySplitViewController : ReactiveSplitViewController<LibraryShellViewModel>
+{
+    public LibrarySplitViewController(LibraryShellViewModel shell, BookCatalogViewModel catalog)
+    {
+        ViewModel = shell;
+        PreferredDisplayMode = UISplitViewControllerDisplayMode.OneBesideSecondary;
+```
+
+## The macOS window
+
+`ReactiveWindowController` wraps `NSWindowController` with a `ViewModel` property, since AppKit has nothing like
+a `UITableViewController` in this surface and needs its own window-level base class. `MainWindowController`
+builds the window in `CreateWindow`, which its constructor passes straight to the base constructor, then builds
+the split view once `WindowDidLoad` runs:
+
+```csharp
+public sealed class MainWindowController : ReactiveWindowController
+{
+    public MainWindowController()
+        : base(CreateWindow())
+    {
+    }
+
+    public override void WindowDidLoad()
+    {
+        base.WindowDidLoad();
+```
+
+```csharp
+        Window!.ContentViewController = new LibrarySplitViewController(shell, catalog);
+
+        // ReactiveWindowController does not implement IActivatableView, unlike the view and controller types, so
+        // it subscribes to Activated/Deactivated directly rather than through WhenActivated.
+        _ = Activated.Subscribe(static _ => Console.WriteLine("MainWindowController activated."));
+        _ = Deactivated.Subscribe(static _ => Console.WriteLine("MainWindowController deactivated."));
+    }
+```
+
+Every other Reactive base class on this page implements the interface `WhenActivated` needs and can use it
+directly. `ReactiveWindowController` does not, so it subscribes to `Activated`/`Deactivated` itself instead of
+wrapping the subscriptions in `WhenActivated`. Both still fire the same way, from `WindowDidLoad` and from
+AppKit's `NSWindow.WillCloseNotification`.
+
+## Read the device orientation
+
+`PlatformOperations.GetOrientation()` answers the same question every platform's `IPlatformOperations` answers.
+On UIKit it reads `UIDevice.CurrentDevice.Orientation`; AppKit has no concept of device orientation, so it always
+returns `null` there.
+
+```csharp
+PlatformOperations platformOperations = new();
+string? orientation = platformOperations.GetOrientation();
+Console.WriteLine($"Device orientation: {orientation}.");
+```
+
+```text
+Device orientation: Portrait.
+```
+
+## Suspension and life cycle, side by side
+
+```mermaid
+%%{init: {"theme": "base", "themeVariables": {"fontFamily": "Roboto, Helvetica, Arial, sans-serif", "fontSize": "15px", "primaryColor": "#DCE9FF", "primaryBorderColor": "#6C8EC4", "primaryTextColor": "#0B2447", "secondaryColor": "#E3F2E8", "secondaryBorderColor": "#7FA88C", "secondaryTextColor": "#12301C", "tertiaryColor": "#F3E5F5", "tertiaryBorderColor": "#A98BB0", "tertiaryTextColor": "#2E1437", "lineColor": "#7B8699", "textColor": "#1B1F27", "noteBkgColor": "#FFF4D6", "noteBorderColor": "#C9A94F", "noteTextColor": "#3A2A00", "actorBkg": "#DCE9FF", "actorBorder": "#6C8EC4", "actorTextColor": "#0B2447", "signalColor": "#7B8699", "signalTextColor": "#1B1F27", "labelBoxBkgColor": "#F1F3F8", "labelBoxBorderColor": "#A7AEBB", "edgeLabelBackground": "#F7F9FC", "clusterBkg": "#F7F9FC", "clusterBorder": "#C9D1DE"}}}%%
+flowchart LR
+    classDef view fill:#DCE9FF,stroke:#6C8EC4,color:#0B2447
+    classDef vm fill:#E3F2E8,stroke:#7FA88C,color:#12301C
+    classDef model fill:#F3E5F5,stroke:#A98BB0,color:#2E1437
+    classDef neutral fill:#F1F3F8,stroke:#A7AEBB,color:#1B1F27
+    Launch(["FinishedLaunching /\nDidFinishLaunching"]):::view -- "IsResuming" --> Host(["SuspensionHost"]):::vm
+    Background(["DidEnterBackground /\nDidResignActive"]):::view -- "ShouldPersistState" --> Host
+    Foreground(["OnActivated /\nDidBecomeActive"]):::view -- "IsUnpausing" --> Host
+    Crash(["Unhandled exception"]):::neutral -- "ShouldInvalidateState" --> Host
+    Host -- "SaveState / LoadState" --> Driver(["AppSupportJsonSuspensionDriver"]):::model
+```
+
+`AutoSuspendHelper<T>` turns four kinds of app life-cycle callback into the four signals `SuspensionHost`
+exposes; `SetupDefaultSuspendResume` connects `ShouldPersistState` and `ShouldInvalidateState` to the driver's
+`SaveState` and `InvalidateState`, and a resume connects `IsResuming` to `LoadState`.
+
+Each `ReactiveUI.*` package also ships as `ReactiveUI.*.Reactive`, built from the same source for apps that use
+System.Reactive instead of the primitives this page's samples use.
+
+## Tables and collections
+
+`ReactiveTableViewController<TViewModel>`, `ReactiveCollectionViewController<TViewModel>` and the sources and
+cells that feed them are a different chunk of this API surface, covered separately.
+
+## At a glance
+
+| Member | What it does |
+| --- | --- |
+| `RxAppBuilder.CreateReactiveUIBuilder()` / `WithPlatformModule<PlatformRegistrations>()` | Builds and registers ReactiveUI's Apple platform module |
+| `PlatformRegistrations` | The module `WithPlatformModule` loads: `IPlatformOperations`, `ISuspensionDriver` and the main-thread sequencer |
+| `AutoSuspendHelper<T>` | Turns app life-cycle callbacks into suspend/resume signals; `T` is the app delegate type |
+| `AutoSuspendHelper<T>.FinishedLaunching` / `OnActivated` / `DidEnterBackground` [ios] | The three UIKit callbacks to forward |
+| `AutoSuspendHelper<T>.DidFinishLaunching` / `DidBecomeActive` / `DidResignActive` / `DidHide` / `ApplicationShouldTerminate` [macos] | The five AppKit callbacks to forward |
+| `AutoSuspendHelper<T>.LaunchOptions` [ios] | The most recent launch options, as a string dictionary |
+| `AutoSuspendHelper<T>.Dispose()` | Unsubscribes from `AppDomain.UnhandledException` and disposes the helper's signals |
+| `AppSupportJsonSuspensionDriver` | Saves and loads state under Application Support |
+| `AppSupportJsonSuspensionDriver.SaveState<T>(T, JsonTypeInfo<T>)` / `LoadState<T>(JsonTypeInfo<T>)` | Trim- and AOT-safe save and load through a source-generated `JsonTypeInfo<T>` |
+| `AppSupportJsonSuspensionDriver.InvalidateState()` | Deletes the saved state file |
+| `AppSupportJsonSuspensionDriver.SaveState<T>(T)` / `LoadState()` | The untyped, reflection-based overloads; not callable from a trimmed or AOT page |
+| `PlatformOperations.GetOrientation()` | The device's current rotation on UIKit, or `null` on AppKit |
+| `ReactiveViewController<TViewModel>` | A `UIViewController`/`NSViewController` that is an `IViewFor<TViewModel>` |
+| `ReactiveView<TViewModel>` | A `UIView`/`NSView` that is an `IViewFor<TViewModel>` |
+| `ReactiveControl<TViewModel>` | A `UIControl`/`NSControl` that is an `IViewFor<TViewModel>` |
+| `ReactiveImageView<TViewModel>` | A `UIImageView`/`NSImageView` that is an `IViewFor<TViewModel>` |
+| `ReactiveNavigationController<TViewModel>` [ios] | A `UINavigationController` that is an `IViewFor<TViewModel>` |
+| `ReactiveTabBarController<TViewModel>` [ios] | A `UITabBarController` that is an `IViewFor<TViewModel>` |
+| `ReactivePageViewController<TViewModel>` [ios] | A `UIPageViewController` that is an `IViewFor<TViewModel>` |
+| `ReactiveSplitViewController<TViewModel>` | A `UISplitViewController`/`NSSplitViewController` that is an `IViewFor<TViewModel>` |
+| `ReactiveWindowController` [macos] | An `NSWindowController` that is an `IViewFor<TViewModel>`-less `ReactiveObject`, with `WindowDidLoad` |
+| `Activated` / `Deactivated` | Fire when a view, control or controller appears and leaves; feed [`WhenActivated`](../when-activated.md) |
+| `Changed` / `Changing` / `PropertyChanged` / `PropertyChanging` | Observe and raise property changes, as on any `ReactiveObject` |
+| `ThrownExceptions` | Reports errors raised inside reactive operators |
+| `SuppressChangeNotifications()` | Pauses change notifications until the result is disposed |
+| `RoutedViewHost` [ios] | Follows a `RoutingState`'s navigation stack, pushing and popping as it changes |
+| `RoutedViewHost.Router` / `ViewLocator` / `ViewContractObservable` | The router to follow, the locator to resolve views with, and an optional contract stream |
+| `RoutedViewHostUnsafe` [ios] | The `RoutedViewHost` twin that also resolves a service-locator-only view; carries `[RequiresDynamicCode]` |
+| `ViewModelViewHost` | Shows whichever view model is assigned to it, resolved through its own `ViewLocator` |
+| `ViewModelViewHost.ViewModel` / `ViewLocator` / `DefaultContent` / `ViewContract` / `ViewContractObservable` | The view model to show, the locator, the placeholder shown when `ViewModel` is `null`, and an optional contract |
+| `ViewModelViewHostUnsafe` | The `ViewModelViewHost` twin that also resolves a service-locator-only view; carries `[RequiresDynamicCode]` |
diff --git a/docs/documentation/reactiveui/handbook/platforms/index.md b/docs/documentation/reactiveui/handbook/platforms/index.md
index 78c64f0c..a4cae8a8 100644
--- a/docs/documentation/reactiveui/handbook/platforms/index.md
+++ b/docs/documentation/reactiveui/handbook/platforms/index.md
@@ -16,8 +16,9 @@ framework. A platform package connects that core to one UI framework. It adds:
   (see [Scheduling](../scheduling.md));
 - a `With<Platform>()` call for the [app builder](../rxappbuilder.md) that registers all of the above.
 
-Each page below starts from a runnable example app. The examples build on any operating system. The Windows ones run on
-Windows, and the Android one runs on a device or an emulator.
+Each page below starts from a runnable example app. Most examples build on any operating system. The Windows ones
+build only on Windows, the Apple ones build only on Windows or macOS, and the Android one runs on a device or an
+emulator.
 
 | Platform | Package | Example app |
 | --- | --- | --- |
@@ -27,6 +28,7 @@ Windows, and the Android one runs on a device or an emulator.
 | [.NET MAUI](maui.md) | `ReactiveUI.Maui` | A recipe book |
 | [Blazor](blazor.md) | `ReactiveUI.Blazor` | A to-do list |
 | [Android](android.md) | `ReactiveUI.AndroidX` | A school timetable |
+| [Apple platforms](apple.md) | `ReactiveUI` (`ios`, `maccatalyst`, `macos`, `tvos`) | A library catalog |
 
 Each package also ships as `ReactiveUI.<Platform>.Reactive`, built from the same source for apps that use
 System.Reactive.

From 4102e1a872078840cf01e8f4710a51f05b406386 Mon Sep 17 00:00:00 2001
From: Glenn Watson <5834289+glennawatson@users.noreply.github.com>
Date: Sun, 27 Sep 2026 17:53:23 +1000
Subject: [PATCH 9/9] docs(reactiveui): Apple tables and collections

---
 .../reactiveui/handbook/platforms/apple.md    | 193 +++++++++++++++++-
 1 file changed, 183 insertions(+), 10 deletions(-)

diff --git a/docs/documentation/reactiveui/handbook/platforms/apple.md b/docs/documentation/reactiveui/handbook/platforms/apple.md
index 009d66db..7697a071 100644
--- a/docs/documentation/reactiveui/handbook/platforms/apple.md
+++ b/docs/documentation/reactiveui/handbook/platforms/apple.md
@@ -147,10 +147,10 @@ macOS, where `View` has no default), then bind inside `WhenActivated` so every b
 leaves and starts again if it returns.
 
 ```csharp
-public sealed class BookListViewController : ReactiveViewController<BookCatalogViewModel>
-{
     internal UIButton LoanButton { get; } = UIButton.FromType(UIButtonType.System);
 
+    internal LoanBoardView LoanBoard { get; } = new(CGRect.Empty);
+
     public override void ViewDidLoad()
     {
         base.ViewDidLoad();
@@ -175,6 +175,9 @@ public sealed class BookListViewController : ReactiveViewController<BookCatalogV
     }
 ```
 
+`LoanBoard` is a compact "on loan now" list docked below the button; [Tables and collections](#tables-and-collections)
+covers what it is and how it gets its rows.
+
 `LoanButton` is `internal`, not `private`: the `this.BindCommand(...)` call above compiles to a generated,
 reflection-free dispatch, and the generator can only observe a `public` or `internal` member. A `private` target
 fails the build with `RXUIBIND003`. `LoanViewController`, the page `RoutedViewHost` pushes next, follows the same
@@ -200,6 +203,7 @@ protected override void Dispose(bool disposing)
     {
         _rows.Dispose();
         LoanButton.Dispose();
+        LoanBoard.Dispose();
     }
 
     base.Dispose(disposing);
@@ -220,8 +224,6 @@ source instead of a stack of rows, which is a different chunk of this API covere
 [Tables and collections](#tables-and-collections) below.
 
 ```csharp
-public sealed class BookRowView : ReactiveView<Book>
-{
     internal UILabel TitleLabel { get; } = new() { Font = UIFont.PreferredHeadline! };
 
     internal UILabel StatusLabel { get; } = new() { Font = UIFont.PreferredSubheadline!, TextColor = UIColor.SecondaryLabel };
@@ -394,7 +396,7 @@ carries the same `[RequiresDynamicCode]` restriction as `RoutedViewHostUnsafe`,
 on macOS, so the library's split-view root is the one container this page shares across every Apple platform.
 
 `LibraryTabBarController` is the iPhone root: a `RoutedViewHost` catalog tab, a `MembersNavigationController`
-tab, and a `BookCoverPagerViewController` tab.
+tab, a `BookCoverPagerViewController` tab, and a `BookShelfViewController` tab.
 
 ```csharp
 public sealed class LibraryTabBarController : ReactiveTabBarController<LibraryShellViewModel>
@@ -405,7 +407,13 @@ public sealed class LibraryTabBarController : ReactiveTabBarController<LibrarySh
 ```
 
 ```csharp
-        ViewControllers = [catalogHost, membersNav, coverPager];
+        BookShelfViewController shelf = new()
+        {
+            ViewModel = catalog,
+            TabBarItem = new UITabBarItem("Shelf", null, 3),
+        };
+
+        ViewControllers = [catalogHost, membersNav, coverPager, shelf];
 
         _ = this.WhenActivated(d =>
         {
@@ -458,8 +466,6 @@ own type (`ReactiveViewController<BookCatalogViewModel>`) and how a split item i
 on macOS) differ between the two.
 
 ```csharp
-public sealed class LibrarySplitViewController : ReactiveSplitViewController<LibraryShellViewModel>
-{
     public LibrarySplitViewController(LibraryShellViewModel shell, BookCatalogViewModel catalog)
     {
         ViewModel = shell;
@@ -542,8 +548,163 @@ System.Reactive instead of the primitives this page's samples use.
 
 ## Tables and collections
 
-`ReactiveTableViewController<TViewModel>`, `ReactiveCollectionViewController<TViewModel>` and the sources and
-cells that feed them are a different chunk of this API surface, covered separately.
+`ReactiveTableViewController<TViewModel>`, `ReactiveCollectionViewController<TViewModel>` and the plain
+`ReactiveTableView<TViewModel>`/`ReactiveCollectionView<TViewModel>` views wrap `UITableView` and `UICollectionView`
+with a reactive source that keeps rows in sync with a collection. `Members` and `Books` are both
+`ObservableCollection<T>`, ReactiveUI's collection change-set support: because each implements
+`INotifyCollectionChanged`, a bound source adds and removes rows as the collection changes, with no extra code.
+These types exist only on UIKit (iOS, Mac Catalyst, tvOS); AppKit has no table or collection source.
+
+**1. Pair the collection with a cell and a header.** `TableSectionInformation<TSource, TCell>` names the collection,
+the cell type's reuse key, a row height, and an optional `Action<TCell>` that runs once a cell is dequeued.
+`TableSectionInformation<TSource>` is the base type its `Header`, `Footer`, `Collection`, `CellKeySelector`,
+`InitializeCellAction` and `SizeHint` live on, and the type `ReactiveTableViewSource<TSource>.Data` returns. A
+`TableSectionHeader` names a section from a `string`, or builds its own view from a `Func<UIView>` and a height:
+
+```csharp
+TableSectionInformation<Member, MemberCell> section = new(
+    ViewModel!.Members,
+    MemberCell.Key,
+    sizeHint: 56F,
+    static cell => Console.WriteLine($"Initializing a {cell.GetType().Name}."))
+{
+    Header = new TableSectionHeader("Members"),
+    Footer = new TableSectionHeader(
+        static () => new UILabel
+        {
+            Text = "Tap a member to see their card.",
+            TextAlignment = UITextAlignment.Center,
+            Font = UIFont.PreferredFootnote!,
+            TextColor = UIColor.SecondaryLabel,
+        },
+        24F),
+};
+IReadOnlyList<TableSectionInformation<Member, MemberCell>> sections = [section];
+```
+
+The family's constructors differ only in a fixed `NSString` reuse key versus a `Func<object?, NSString>` chosen per
+item, and whether the `Action<TCell>` is supplied; this table always shows one cell, so it never needs the per-item
+selector. `CollectionViewSectionInformation<TSource>` and `CollectionViewSectionInformation<TSource, TCell>` are the
+same two types for a `UICollectionView`.
+
+**2. Bind the sections to the table view.** `ReactiveTableViewSourceExtensions.BindTo` builds a
+`ReactiveTableViewSource<TSource>`, sets it as the table view's `Source`, and keeps `Data` current whenever the
+sections observable emits again. The overload that takes a list of sections does not register the cell class, so
+`ViewDidLoad` calls `TableView.RegisterClassForCellReuse(typeof(MemberCell), MemberCell.Key)` once itself, before the
+table ever asks for a cell:
+
+```csharp
+d(Signal.Emit(sections).BindTo(TableView, source =>
+{
+    Source = source;
+    return source.ElementSelected.Subscribe(static item => Console.WriteLine($"Selected member {((Member)item!).Name}."));
+}));
+```
+
+`initSource` runs once, right after the source is built and before `Data` is set; it is the place to keep a reference
+to the source and subscribe to `ElementSelected`, the stream of tapped rows. `InsertRowsAnimation`, `DeleteRowsAnimation`,
+`ReloadRowsAnimation`, `InsertSectionsAnimation`, `DeleteSectionsAnimation` and `ReloadSectionsAnimation` keep their
+default `UITableViewRowAnimation.Automatic` here, since this table's `Data` is set once and never changes again.
+`Source.Data[0]` then reads back the same
+`Header`, `SizeHint`, `Collection` and `InitializeCellAction` the constructor above set, this time through the
+one-argument `TableSectionInformation<TSource>` the `Data` list holds.
+
+**3. Write the cell.** `ReactiveTableViewCell<TViewModel>` is an `IViewFor<TViewModel>` `UITableViewCell`. UIKit
+dequeues one through the `(IntPtr)` constructor a class registration needs, never any other. `MemberCell` also shows
+the six classic `IReactiveObject` members every reactive Apple type carries: since `Member` is an immutable record
+rather than a `ReactiveObject`, the label follows `ViewModel` itself changing instead of a `OneWayBind` on one of its
+properties:
+
+```csharp
+        // The classic events fire for any property change; a cell can use them without going through Changed/Changing.
+        PropertyChanged += static (_, e) => Console.WriteLine($"MemberCell.{e.PropertyName} changed (classic event).");
+        PropertyChanging += static (_, e) => Console.WriteLine($"MemberCell.{e.PropertyName} changing (classic event).");
+
+        _ = this.WhenActivated(d =>
+        {
+            // Member is an immutable record, not a ReactiveObject, so the label follows ViewModel itself changing
+            // (which the cell base class does raise) rather than a OneWayBind on one of its properties.
+            d(this.WhenAnyValue(static v => v.ViewModel).Subscribe(member => NameLabel.Text = member?.Name));
+            d(Changing.Subscribe(static _ => Console.WriteLine("MemberCell changing.")));
+            d(Changed.Subscribe(static _ => Console.WriteLine("MemberCell changed.")));
+            d(ThrownExceptions.Subscribe(static error => Console.WriteLine($"MemberCell binding failed: {error.Message}")));
+            d(Activated.Subscribe(static _ => Console.WriteLine("MemberCell activated.")));
+            d(Deactivated.Subscribe(static _ => Console.WriteLine("MemberCell deactivated.")));
+        });
+```
+
+`PrepareForReuse` clears that binding target inside a `SuppressChangeNotifications()` scope, so the reset itself never
+looks like a change to anything observing the cell.
+
+**4. Host the same collection in a plain view.** `ReactiveTableView<TViewModel>` and `ReactiveCollectionView<TViewModel>`
+give a `UITableView`/`UICollectionView` an `IViewFor<TViewModel>` `ViewModel` property with no controller of its own.
+The members page uses one as a header above its table: a horizontal strip of chips, bound with the simpler overload
+that takes a collection directly and registers its own cell:
+
+```csharp
+public sealed class MemberChipStripView : ReactiveCollectionView<MembersViewModel>
+{
+    public MemberChipStripView(CGRect frame, UICollectionViewLayout layout)
+        : base(frame, layout)
+    {
+        BackgroundColor = UIColor.SystemBackground;
+
+        _ = this.WhenActivated(d =>
+            d(Signal.Emit<INotifyCollectionChanged>(ViewModel!.Members).BindTo<Member, MemberChipCell>(this)));
+    }
+}
+```
+
+`BookListViewController` does the same with a `ReactiveTableView<BookCatalogViewModel>` further down its stack,
+listing the books currently on loan.
+
+**5. Give a grid a section header.** `ReactiveCollectionViewController<TViewModel>` wraps `UICollectionView` the way
+`ReactiveTableViewController<TViewModel>` wraps `UITableView`, but its source, `ReactiveCollectionViewSource<TSource>`,
+has no header hook of its own, unlike the table source's `Header`/`Footer`. A grid that needs a header subclasses the
+source and overrides `GetViewForSupplementaryElement`, the UIKit method that returns a header or footer view, which
+`BindTo` would otherwise leave unimplemented. It returns a `ReactiveCollectionReusableView<TViewModel>`, which
+`BookShelfViewController` dequeues by class the same way it dequeues a cell. `ViewDidLoad` registers both the cell
+and the header, since the sections overload of `BindTo` registers neither, then builds the section and constructs the
+source directly instead of calling `BindTo`, since the header needs the subclass above:
+
+```csharp
+public override UICollectionReusableView GetViewForSupplementaryElement(UICollectionView collectionView, NSString elementKind, NSIndexPath indexPath)
+{
+    ShelfHeaderView header = (ShelfHeaderView)collectionView.DequeueReusableSupplementaryView(UICollectionElementKindSection.Header, HeaderKey, indexPath);
+    header.ViewModel = _catalog;
+    return header;
+}
+```
+
+```csharp
+            CollectionViewSectionInformation<Book, BookCoverCell> section = new(
+                ViewModel!.Books,
+                static _ => CoverCellKey,
+                static cell => Console.WriteLine($"Initializing a {cell.GetType().Name}."));
+            IReadOnlyList<CollectionViewSectionInformation<Book, BookCoverCell>> sections = [section];
+
+            BookShelfCollectionViewSource source = new(CollectionView!, ViewModel);
+            source.Data = sections;
+            CollectionView!.Source = source;
+```
+
+`source.Data[0]` reads back through the one-argument `CollectionViewSectionInformation<TSource>`, the same way the
+table section does. A `ReactiveCollectionReusableView<TViewModel>` reacts to `ViewModel` directly rather than through
+`WhenActivated`, because UIKit sets it right after dequeuing the view and before adding it to the hierarchy:
+
+```csharp
+        _ = this.WhenAnyValue(static v => v.ViewModel)
+            .WhereNotNull()
+            .Subscribe(vm => CountLabel.Text = $"{vm.Books.Count} book(s)");
+```
+
+**6. Normalize a batch of index changes.** `Update`, `UpdateType` and `IndexNormalizer` are the infrastructure
+`ReactiveTableViewSource<TSource>` and `ReactiveCollectionViewSource<TSource>` use internally to turn a burst of adds
+and deletes on a collection into the ordered, de-duplicated batch UIKit's own batch-update APIs require. `Update` has
+no public constructor; only `Update.CreateAdd(int)`, `Update.CreateDelete(int)` and `Update.Create(UpdateType, int)`
+build one, and `IndexNormalizer.Normalize(IEnumerable<Update>)` is the one method that consumes them. Application code
+never calls it: a source's own `Data` setter and `INotifyCollectionChanged` handler already normalize every batch
+before applying it to the table or collection view.
 
 ## At a glance
 
@@ -580,3 +741,15 @@ cells that feed them are a different chunk of this API surface, covered separate
 | `ViewModelViewHost` | Shows whichever view model is assigned to it, resolved through its own `ViewLocator` |
 | `ViewModelViewHost.ViewModel` / `ViewLocator` / `DefaultContent` / `ViewContract` / `ViewContractObservable` | The view model to show, the locator, the placeholder shown when `ViewModel` is `null`, and an optional contract |
 | `ViewModelViewHostUnsafe` | The `ViewModelViewHost` twin that also resolves a service-locator-only view; carries `[RequiresDynamicCode]` |
+| `ReactiveTableViewController<TViewModel>` / `ReactiveCollectionViewController<TViewModel>` [ios] | A `UITableViewController`/`UICollectionViewController` that is an `IViewFor<TViewModel>` |
+| `ReactiveTableView<TViewModel>` / `ReactiveCollectionView<TViewModel>` [ios] | A `UITableView`/`UICollectionView` that is an `IViewFor<TViewModel>`, usable with no controller of its own |
+| `ReactiveTableViewCell<TViewModel>` / `ReactiveCollectionViewCell<TViewModel>` [ios] | A `UITableViewCell`/`UICollectionViewCell` that is an `IViewFor<TViewModel>` |
+| `ReactiveCollectionReusableView<TViewModel>` [ios] | A `UICollectionReusableView` that is an `IViewFor<TViewModel>`; used for a grid's section header or footer |
+| `ReactiveTableViewSource<TSource>` / `ReactiveCollectionViewSource<TSource>` [ios] | Drives a table or collection view from a `Data` list of sections; the collection source has no header hook, so subclass it to add one |
+| `ReactiveTableViewSource<TSource>.Data` / `ElementSelected` / `*RowsAnimation` / `*SectionsAnimation` | The bound sections, the stream of tapped rows, and the `UITableViewRowAnimation` each kind of update uses |
+| `ReactiveCollectionViewSource<TSource>.Data` / `ElementSelected` | The bound sections, and the stream of tapped cells |
+| `ReactiveTableViewSourceExtensions.BindTo` / `ReactiveCollectionViewSourceExtensions.BindTo` [ios] | Builds a source from a collection or a list of sections, and sets it on the table or collection view |
+| `TableSectionInformation<TSource>` / `TableSectionInformation<TSource, TCell>` [ios] | A table section: its collection, cell reuse key, size hint, header and footer |
+| `CollectionViewSectionInformation<TSource>` / `CollectionViewSectionInformation<TSource, TCell>` [ios] | The same section shape for a `UICollectionView`, with no header of its own |
+| `TableSectionHeader` [ios] | A section header or footer: a `string` title, or a `Func<UIView>` and a height |
+| `Update` / `UpdateType` / `IndexNormalizer` | The batching infrastructure the sources use internally to normalize adds and deletes for UIKit |