diff --git a/README.md b/README.md
index 2ba4a37..ad0fcab 100644
--- a/README.md
+++ b/README.md
@@ -16,18 +16,21 @@ ReactiveUI.Primitives is designed to:
 ## Table of contents
 
 1. [Install](#install)
-2. [Target frameworks and dependencies](#target-frameworks-and-dependencies)
-3. [Core model](#core-model)
-4. [Creation factories](#creation-factories)
-5. [Operators](#operators)
-6. [Stateful signals and subject-like types](#stateful-signals-and-subject-like-types)
-7. [Sequencers](#sequencers)
-8. [Threading, disposal, and error semantics](#threading-disposal-and-error-semantics)
-9. [Source-generator bridge behavior](#source-generator-bridge-behavior)
-10. [Migration guides](#systemreactive-to-reactiveuiprimitives-migration-guide)
-11. [Benchmarks and performance posture](#benchmarks-and-performance-posture)
-12. [Repository layout](#repository-layout)
-13. [Validation commands](#validation-commands)
+2. [Agent Skills](#agent-skills)
+3. [Target frameworks and dependencies](#target-frameworks-and-dependencies)
+4. [Core model](#core-model)
+5. [Creation factories](#creation-factories)
+6. [Operators](#operators)
+7. [ReactiveUI.Primitives.Async](#reactiveuiprimitivesasync)
+8. [ReactiveUI.Primitives.Extensions](#reactiveuiprimitivesextensions)
+9. [Stateful signals and subject-like types](#stateful-signals-and-subject-like-types)
+10. [Sequencers](#sequencers)
+11. [Threading, disposal, and error semantics](#threading-disposal-and-error-semantics)
+12. [Source-generator bridge behavior](#source-generator-bridge-behavior)
+13. [Migration guides](#systemreactive-to-reactiveuiprimitives-migration-guide)
+14. [Benchmarks and performance posture](#benchmarks-and-performance-posture)
+15. [Repository layout](#repository-layout)
+16. [Validation commands](#validation-commands)
 
 ## Install
 
@@ -37,9 +40,11 @@ When the package is available on your configured NuGet feed:
 dotnet add package ReactiveUI.Primitives
 ```
 
-Optional UI/platform integration packages are split out so the base package stays free of UI framework references:
+Optional Async, Extensions, and UI/platform integration packages are split out so the base package stays free of async-helper and UI framework references:
 
 ```bash
+dotnet add package ReactiveUI.Primitives.Async
+dotnet add package ReactiveUI.Primitives.Extensions
 dotnet add package ReactiveUI.Primitives.Wpf
 dotnet add package ReactiveUI.Primitives.WinForms
 dotnet add package ReactiveUI.Primitives.WinUI
@@ -51,8 +56,11 @@ Then import the namespaces you need:
 
 ```csharp
 using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.Async;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions;
+using ReactiveUI.Primitives.Async.Signals;
 using ReactiveUI.Primitives.Signals;
 ```
 
@@ -63,6 +71,36 @@ The package metadata is configured to include this README in the NuGet package v
 
 Those generators are analyzers. They do not add runtime System.Reactive or R3 dependencies to ReactiveUI.Primitives. They emit bridge code only when the consuming compilation already references the relevant external library symbols.
 
+## Agent Skills
+
+The base `ReactiveUI.Primitives` NuGet package includes `Skills.md` at the package root. It is an agent-oriented guide for using ReactiveUI.Primitives, Async, Extensions, UI sequencers, bridge source generators, and migration from System.Reactive or R3 while assuming the libraries are consumed from NuGet packages.
+
+After package restore, locate the file in the local NuGet package cache:
+
+```powershell
+$version = "<version>"
+$skill = "$env:USERPROFILE\.nuget\packages\reactiveui.primitives\$version\Skills.md"
+```
+
+On macOS or Linux:
+
+```bash
+version="<version>"
+skill="$HOME/.nuget/packages/reactiveui.primitives/$version/Skills.md"
+```
+
+Install the skill by copying the contents of `Skills.md` into the instruction location supported by the agent. Agents that expect a `SKILL.md` file should use a `reactiveui-primitives` directory and rename the copied file to `SKILL.md`.
+
+| Agent | Recommended project-local install | Notes |
+|---|---|---|
+| [OpenAI Codex](https://developers.openai.com/codex/skills) | `.agents/skills/reactiveui-primitives/SKILL.md` | Codex also supports user-level skills under `$HOME/.agents/skills`. |
+| [Claude Code](https://code.claude.com/docs/en/skills) | `.claude/skills/reactiveui-primitives/SKILL.md` | Claude Code also supports personal skills under `~/.claude/skills`. |
+| [Cline](https://docs.cline.bot/customization/skills) | `.cline/skills/reactiveui-primitives/SKILL.md` | Cline skills must be enabled in Cline's feature settings. |
+| [GitHub Copilot](https://docs.github.com/en/copilot/concepts/prompting/response-customization) | `.github/instructions/reactiveui-primitives.instructions.md` | For repository-wide behavior, summarize or link the skill from `.github/copilot-instructions.md`. |
+| [Cursor](https://docs.cursor.com/en/context) | `.cursor/rules/reactiveui-primitives.mdc` | Cursor project rules are version-controlled under `.cursor/rules`; `AGENTS.md` is also supported. |
+| [Windsurf](https://docs.windsurf.com/windsurf/cascade/memories) | `.windsurf/rules/reactiveui-primitives.md` | Windsurf also reads `AGENTS.md` through the same rules engine. |
+| [Gemini CLI](https://google-gemini.github.io/gemini-cli/docs/cli/gemini-md.html) | `GEMINI.md` or an imported file referenced from `GEMINI.md` | Gemini CLI loads hierarchical context files and supports importing other markdown files with `@file.md`. |
+
 ## Target frameworks and dependencies
 
 The base production `ReactiveUI.Primitives` library uses `$(LibraryTargetFrameworks)` from `src/Directory.Build.props` and currently targets:
@@ -72,19 +110,22 @@ The base production `ReactiveUI.Primitives` library uses `$(LibraryTargetFramewo
 - `net10.0`
 - `net462`
 - `net472`
+- `net48`
 - `net481`
 
 Windows UI and platform-integration projects in this repository use their own TFM properties (for example `net8.0-windows`, `net9.0-windows`, `net10.0-windows`, or MAUI/platform-focused TFMs where applicable). Those platform TFMs are not target frameworks of the base `ReactiveUI.Primitives` package.
 
 The optional package TFMs are:
 
-- `ReactiveUI.Primitives.Wpf`: `net8.0-windows`, `net9.0-windows`, `net10.0-windows`, `net462`, `net472`, `net481`
-- `ReactiveUI.Primitives.WinForms`: `net8.0-windows`, `net9.0-windows`, `net10.0-windows`, `net462`, `net472`, `net481`
+- `ReactiveUI.Primitives.Wpf`: `net8.0-windows`, `net9.0-windows`, `net10.0-windows`, `net462`, `net472`, `net48`, `net481`
+- `ReactiveUI.Primitives.WinForms`: `net8.0-windows`, `net9.0-windows`, `net10.0-windows`, `net462`, `net472`, `net48`, `net481`
 - `ReactiveUI.Primitives.WinUI`: `net8.0-windows10.0.19041.0`, `net9.0-windows10.0.19041.0`, `net10.0-windows10.0.19041.0`
 - `ReactiveUI.Primitives.Blazor`: `net8.0`, `net9.0`, `net10.0`
 - `ReactiveUI.Primitives.Maui`: `net9.0`, `net10.0`
+- `ReactiveUI.Primitives.Async`: `net8.0`, `net9.0`, `net10.0`, `net462`, `net472`, `net48`, `net481`
+- `ReactiveUI.Primitives.Extensions`: `net8.0`, `net9.0`, `net10.0`, `net462`, `net472`, `net48`, `net481`
 
-Runtime package dependencies are intentionally small. The base production package does not depend on System.Reactive or R3. The only runtime package reference declared directly by `src/ReactiveUI.Primitives/ReactiveUI.Primitives.csproj` is `System.ValueTuple` for `net462`; the bridge source generators are packed as analyzers in the base package rather than shipped as separate NuGet packages. `ReactiveUI.Primitives.Blazor` references `Microsoft.AspNetCore.Components`, `ReactiveUI.Primitives.Maui` references `Microsoft.Maui.Core`, and `ReactiveUI.Primitives.WinUI` references `Microsoft.WindowsAppSDK`. The remaining shared package references are analyzer, SourceLink, versioning, ILLink, reference-assembly, or build-time support packages such as Blazor.Common.Analyzers, Microsoft.SourceLink.GitHub, MinVer, Roslynator.Analyzers, SonarAnalyzer.CSharp, stylecop.analyzers, Microsoft.NET.ILLink.Tasks, and Microsoft.NETFramework.ReferenceAssemblies. Benchmark projects may reference System.Reactive and R3 as comparison baselines, but those references are not production dependencies.
+Runtime package dependencies are intentionally small. The base production package does not depend on System.Reactive or R3. The only runtime package reference declared directly by `src/ReactiveUI.Primitives/ReactiveUI.Primitives.csproj` is `System.ValueTuple` for `net462`; the bridge source generators are packed as analyzers in the base package rather than shipped as separate NuGet packages. `ReactiveUI.Primitives.Async` and `ReactiveUI.Primitives.Extensions` reference `ReactiveUI.Primitives`; their additional package references are limited to .NET Framework compatibility/support packages such as `System.ValueTuple`, Polyfill, Microsoft.Bcl.TimeProvider, System.Threading.Channels, System.Runtime.CompilerServices.Unsafe, System.ComponentModel.Annotations, System.Buffers, System.Memory, and System.Collections.Immutable for `net4x` targets. `ReactiveUI.Primitives.Async` also packs the bridge source generators as analyzers so async bridge methods are generated for consumers that reference System.Reactive or R3. `ReactiveUI.Primitives.Extensions` has no production System.Reactive or R3 dependency. `ReactiveUI.Primitives.Blazor` references `Microsoft.AspNetCore.Components`, `ReactiveUI.Primitives.Maui` references `Microsoft.Maui.Core`, and `ReactiveUI.Primitives.WinUI` references `Microsoft.WindowsAppSDK`. The remaining shared package references are analyzer, SourceLink, versioning, ILLink, reference-assembly, or build-time support packages such as Blazor.Common.Analyzers, Microsoft.SourceLink.GitHub, MinVer, Roslynator.Analyzers, SonarAnalyzer.CSharp, stylecop.analyzers, Microsoft.NET.ILLink.Tasks, and Microsoft.NETFramework.ReferenceAssemblies. Benchmark projects may reference System.Reactive, R3, and ReactiveUI.Extensions as comparison baselines, but those references are not production dependencies.
 
 ## Core model
 
@@ -366,6 +407,163 @@ IObservable<Spark<int>> sparks = Signal.Sequence(1, 3).Spark();
 IObservable<int> values = sparks.Unspark();
 ```
 
+## ReactiveUI.Primitives.Async
+
+`ReactiveUI.Primitives.Async` is the async counterpart to the base `ReactiveUI.Primitives` surface. It keeps the Primitives vocabulary and adds `ValueTask`/`CancellationToken`-aware observer calls for producers and consumers that need asynchronous notification, asynchronous disposal, or async stream collection.
+
+Core async contracts and data types:
+
+| API | Purpose |
+|---|---|
+| `IObservableAsync<T>` | Async observable contract. `SubscribeAsync` receives an `IObserverAsync<T>` and returns an `IAsyncDisposable`. |
+| `IObserverAsync<T>` | Async observer contract with `OnNextAsync`, `OnErrorResumeAsync`, `OnCompletedAsync`, and `DisposeAsync`. |
+| `ObserverAsync<T>` | Base observer type for implementing async observers. |
+| `ISignalAsync<T>` | Pushable async signal that combines `IObserverAsync<T>`, `IObservableAsync<T>`, and a `Values` observable. |
+| `SignalAsync<T>` | Abstract base and static factory/operator host for async observables. |
+| `ConnectableSignalAsync<T>` | Async connectable sequence returned by multicast/publish operators. |
+| `Result` | Completion result that represents success or terminal failure. |
+| `Optional<T>` | Allocation-free optional value used by replay/latest async signals. |
+| `AsyncContext` | Dispatch abstraction over `SynchronizationContext`, `TaskScheduler`, or `ISequencer`. |
+| `ConcurrentObserverCallsException` | Raised when a serial signal detects concurrent observer calls. |
+| `UnhandledExceptionHandler` | Central handler for async fire-and-forget failures. |
+
+Async signal factories live in two places. Use `ReactiveUI.Primitives.Async.Signals.Signal` when you need a mutable signal, and use `SignalAsync` when you need a sequence factory or operator:
+
+| Factory group | APIs |
+|---|---|
+| Mutable signals | `Signal.Create<T>()`, `Signal.Create<T>(SignalCreationOptions)`, `Signal.CreateBehavior<T>(startValue)`, `Signal.CreateBehavior<T>(startValue, BehaviorSignalCreationOptions)`, `Signal.CreateReplayLatest<T>()`, `Signal.CreateReplayLatest<T>(ReplayLatestSignalCreationOptions)` |
+| Signal options | `SignalCreationOptions`, `BehaviorSignalCreationOptions`, `ReplayLatestSignalCreationOptions`, `PublishingOption` |
+| Stateless factories | `SignalAsync.Emit`, `EmitRxVoid`, `None`, `Fail`, `Return`, `Empty`, `Never`, `Throw` |
+| Sequence factories | `Sequence`, `Range`, `FromEnumerable`, `FromAsyncEnumerable`, `ToAsyncSignal`, `Create`, `CreateAsBackgroundJob`, `Defer`, `FromAsync`, `Use`, `Using` |
+| Time factories | `After`, `Every`, `Pulse`, `Timer`, `Interval` |
+| Async disposables | `DisposableAsync.Empty`, `DisposableAsync.Create`, `DisposableAsyncSlot`, `SingleAssignmentDisposableAsync`, `SingleReplaceableDisposableAsync`, `MultipleDisposableAsync` |
+
+Async operators follow the same naming style as the core package where that avoids collisions with System.Reactive/R3, while preserving familiar aliases for compatibility:
+
+| Category | APIs |
+|---|---|
+| Projection/filtering | `Map`, `MapWith`, `Keep`, `KeepWith`, `KeepNotNull`, `KeepType`, `CastTo`, `Select`, `Where`, `OfType`, `Cast`, `Tap`, `Do`, `Fold`, `Scan`, `ReduceAsync`, `AggregateAsync`, `Distinct`, `Unique`, `DistinctBy`, `UniqueBy`, `DistinctUntilChanged`, `DistinctUntilChangedBy`, `SkipWhileNull`, `WhereIsNotNull`, `WhereTrue`, `WhereFalse`, `Not`, `GetMin`, `GetMax`, `ForEach` |
+| Composition | `Bind`, `FlatMap`, `SelectMany`, `Chain`, `Concat`, `Blend`, `Merge`, `SwitchTo`, `Switch`, `Pair`, `Zip`, `SyncLatest`, `PairLatest`, `CombineLatest`, `CombineLatestValuesAreAllTrue`, `CombineLatestValuesAreAllFalse`, `GroupBy` |
+| Error/retry/recovery | `Reattempt`, `Retry`, `Recover`, `Rescue`, `Resume`, `Catch`, `OnErrorResumeAsFailure` |
+| Time/scheduling | `Shift`, `Delay`, `Expire`, `Timeout`, `Throttle`, `ObserveOn`, `Yield` |
+| Lifetime/multicast | `Multicast`, `Publish`, `StatelessPublish`, `ReplayLatestPublish`, `StatelessReplayLatestPublish`, `RefCount`, `OnDispose`, `TakeUntil`, `TakeUntilOptions`, `CompletionSignalDelegate`, `Wrap` |
+| Sequence boundaries | `Take`, `Skip`, `TakeWhile`, `SkipWhile`, `Lead`, `Prepend`, `StartWith` |
+| Terminal helpers | `FirstAsync`, `FirstOrDefaultAsync`, `LastAsync`, `LastOrDefaultAsync`, `SingleAsync`, `SingleOrDefaultAsync`, `AnyAsync`, `AllAsync`, `ContainsAsync`, `CountAsync`, `LongCountAsync`, `ToListAsync`, `CollectListAsync`, `CollectArrayAsync`, `ToDictionaryAsync`, `ToAsyncEnumerable`, `WaitCompletionAsync`, `ForEachAsync`, `SubscribeAsync` |
+
+Basic async sequence example:
+
+```csharp
+using ReactiveUI.Primitives.Async;
+
+List<string> labels = await SignalAsync.Sequence(1, 12)
+    .Keep(static value => value % 2 == 0)
+    .Map(static value => $"even:{value}")
+    .ToListAsync();
+```
+
+Mutable async signal example:
+
+```csharp
+using ReactiveUI.Primitives.Async;
+using ReactiveUI.Primitives.Async.Signals;
+
+ISignalAsync<int> requests = Signal.Create<int>();
+
+await using IAsyncDisposable subscription = await requests.Values
+    .Map(static value => value * 2)
+    .SubscribeAsync(value => Console.WriteLine(value));
+
+await requests.OnNextAsync(21, CancellationToken.None);
+await requests.OnCompletedAsync(Result.Success);
+```
+
+Async context example:
+
+```csharp
+using ReactiveUI.Primitives.Async;
+
+AsyncContext context = AsyncContext.From(TaskScheduler.Default);
+
+await using IAsyncDisposable subscription = await SignalAsync.Sequence(1, 3)
+    .ObserveOn(context)
+    .SubscribeAsync(static value => Console.WriteLine(value));
+```
+
+`ReactiveUI.Primitives.Async` also packs the bridge source generators as analyzers. A consumer that references System.Reactive can use generated `ToObservableAsync<T>(this System.IObservable<T>)` and `ToObservable<T>(this IObservableAsync<T>)` adapters. A consumer that references R3 can use generated `AsPrimitivesAsyncObservable<T>(this R3.Observable<T>)` and `AsR3Observable<T>(this IObservableAsync<T>)` adapters.
+
+## ReactiveUI.Primitives.Extensions
+
+`ReactiveUI.Primitives.Extensions` migrates the non-async helper surface from `ReactiveUI.Extensions` onto `ReactiveUI.Primitives`. It is still based on the BCL `IObservable<T>` contract, but it uses `ISequencer` for scheduling and production references only `ReactiveUI.Primitives` plus framework compatibility packages. It does not reference System.Reactive or R3.
+
+Core utility surface:
+
+| API | Purpose |
+|---|---|
+| `Heartbeat<T>` / `IHeartbeat<T>` | Value plus heartbeat metadata from heartbeat operators. |
+| `Stale<T>` / `IStale<T>` | Value plus stale/fresh state from stale-detection operators. |
+| `Continuation` | Disposable continuation helper for bridging synchronous waits. |
+| `Observables.Return<T>(value)` | Single-value observable factory. |
+| `ObserverExtensions.FastForEach` | Pushes enumerable values into an observer with array/list fast paths. |
+| `ObservableSubscriptionExtensions` | Synchronous test/utility helpers: `SubscribeGetValue`, `SubscribeAndComplete`, `SubscribeGetError`, `WaitForValue`, `WaitForCompletion`, `WaitForError`. |
+
+Extension operators are grouped below by feature area:
+
+| Category | APIs |
+|---|---|
+| Filtering/projection | `WhereIsNotNull`, `SkipWhileNull`, `Not`, `WhereTrue`, `WhereFalse`, `WhereSelect`, `SelectConstant`, `TrySelect`, `SelectManyThen`, `Pairwise`, `Partition`, `Filter`, `ForEach`, `Shuffle`, `LatestOrDefault`, `GetMin`, `GetMax`, `CombineLatestValuesAreAllTrue`, `CombineLatestValuesAreAllFalse` |
+| Error/retry | `CatchIgnore`, `CatchAndReturn`, `CatchReturn`, `CatchReturnUnit`, `LogErrors`, `OnErrorRetry`, `RetryWithBackoff`, `RetryWithDelay`, `RetryForeverWithDelay`, `RetryWithFixedDelay` |
+| Time/scheduling | `SyncTimer`, `ObserveOnIf`, `ScheduleSafe`, `Schedule`, `SampleLatest`, `DetectStale`, `Conflate`, `Heartbeat`, `ThrottleFirst`, `ThrottleUntilTrue`, `ThrottleOnScheduler`, `ThrottleDistinct`, `DebounceImmediate`, `DebounceUntil`, `WaitUntil` |
+| Buffer/collection | `BufferUntil`, `BufferUntilIdle`, `BufferUntilInactive`, `FromArray`, `RunAll`, `FirstMatchFromCandidates` |
+| Async/sync interaction | `SynchronizeSynchronous`, `SubscribeSynchronous`, `SynchronizeAsync`, `SubscribeAsync`, `SelectAsync`, `SelectAsyncSequential`, `SelectLatestAsync`, `SelectAsyncConcurrent`, `DropIfBusy`, `WithLimitedConcurrency` |
+| State/property/lifetime | `AsSignal`, `ToReadOnlyBehavior`, `ReplayLastOnSubscribe`, `SwitchIfEmpty`, `TakeUntil`, `Start`, `Using`, `While`, `ScanWithInitial`, `ToHotTask`, `ToHotValueTask`, `ToPropertyObservable`, `OnNext(params)`, `DoOnSubscribe`, `DoOnDispose` |
+
+Filtering and projection example:
+
+```csharp
+using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.Extensions;
+using ReactiveUI.Primitives.Signals;
+
+IObservable<string> labels = Signal.Sequence(1, 10)
+    .WhereSelect(
+        static value => value % 2 == 0,
+        static value => $"even:{value}");
+
+using IDisposable subscription = labels.Subscribe(Console.WriteLine);
+```
+
+Scheduling example:
+
+```csharp
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions;
+
+ISequencer sequencer = ThreadPoolSequencer.Instance;
+
+using IDisposable work = "ready"
+    .Schedule(TimeSpan.FromMilliseconds(50), sequencer)
+    .Subscribe(Console.WriteLine);
+```
+
+Async selector example over a BCL observable:
+
+```csharp
+using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.Extensions;
+using ReactiveUI.Primitives.Signals;
+
+IObservable<string> names = Signal.Sequence(1, 3)
+    .SelectAsyncSequential(static async value =>
+    {
+        await Task.Yield();
+        return $"item:{value}";
+    });
+
+using IDisposable subscription = names.Subscribe(Console.WriteLine);
+```
+
+The Extensions project is intended for applications that already use the helper operators from `ReactiveUI.Extensions` and want the same shapes without pulling System.Reactive or R3 into the production dependency graph.
+
 ## Stateful signals and subject-like types
 
 ReactiveUI.Primitives uses explicit names instead of cloning every System.Reactive subject type name.
@@ -498,16 +696,21 @@ Generated System.Reactive bridge methods:
 - `AsSystemObservable<T>(this System.IObservable<T> source)`
 - `AsSequencer(this System.Reactive.Concurrency.IScheduler scheduler)`
 - `AsSystemScheduler(this ReactiveUI.Primitives.Concurrency.ISequencer sequencer)`
+- `ToObservableAsync<T>(this System.IObservable<T> source)` when `ReactiveUI.Primitives.Async` is referenced
+- `ToObservable<T>(this ReactiveUI.Primitives.Async.IObservableAsync<T> source)` when `ReactiveUI.Primitives.Async` is referenced
 
 Generated R3 bridge methods:
 
 - `AsPrimitivesSignal<T>(this R3.Observable<T> source)`
 - `AsR3Observable<T>(this System.IObservable<T> source)`
+- `AsPrimitivesAsyncObservable<T>(this R3.Observable<T> source)` when `ReactiveUI.Primitives.Async` is referenced
+- `AsR3Observable<T>(this ReactiveUI.Primitives.Async.IObservableAsync<T> source)` when `ReactiveUI.Primitives.Async` is referenced
 
 System.Reactive bridge example, when the consuming project already references System.Reactive:
 
 ```csharp
 using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.Async;
 using ReactiveUI.Primitives.Signals;
 using ReactiveUI.Primitives.SystemReactiveBridge;
 using System.Reactive.Linq;
@@ -520,6 +723,9 @@ using var subscription = PrimitivesSource
     .Subscribe(Console.WriteLine);
 
 IObservable<int> systemObservable = Signal.Sequence(1, 3).AsSystemObservable();
+
+IObservableAsync<int> asyncSource = rxSource.ToObservableAsync();
+IObservable<int> rxAgain = asyncSource.ToObservable();
 ```
 
 The scheduler bridge is a compatibility boundary. Its generated adapters carry the recursive `IScheduler.Schedule` callback and `IDisposable` return shape so native `ISequencer`/`IWorkItem` paths stay on the lean core scheduler contract.
@@ -659,13 +865,28 @@ R3 uses its own `Observable<T>` type and observer model. ReactiveUI.Primitives s
 | R3 subject | `Signal<T>` / `StateSignal<T>` / `HistorySignal<T>` depending on state/replay needs. |
 | R3 `Select` / `Where` | `Map` / `Keep`. |
 | R3 time operators | `Signal.After`, `Signal.Pulse`, `Calm`, `Probe`, `Shift`, scheduler overloads. |
-| R3 bridge | Generated `AsPrimitivesSignal` / `AsR3Observable` when R3 is referenced by the consumer. |
+| R3 bridge | Generated `AsPrimitivesSignal` / `AsR3Observable`; async bridge methods add `AsPrimitivesAsyncObservable` / `AsR3Observable` when R3 and `ReactiveUI.Primitives.Async` are referenced by the consumer. |
 
 Use the generated bridge only at boundaries. Prefer native ReactiveUI.Primitives operators inside new code.
 
+## ReactiveUI.Extensions migration notes
+
+`ReactiveUI.Primitives.Extensions` is the migration target for the non-async helpers that previously lived in `ReactiveUI.Extensions`. The package intentionally keeps the helper names where those names already describe the behavior and do not collide with the core Primitives vocabulary. Scheduling overloads use `ISequencer` instead of System.Reactive schedulers.
+
+| ReactiveUI.Extensions usage | ReactiveUI.Primitives.Extensions usage |
+|---|---|
+| `WhereIsNotNull`, `SkipWhileNull`, `WhereTrue`, `WhereFalse`, `Not` | Same names over BCL `IObservable<T>`. |
+| `WhereSelect`, `SelectConstant`, `TrySelect`, `SelectManyThen`, `Pairwise`, `Partition` | Same helper names; implemented with direct observers and fused operator shapes where useful. |
+| `SyncTimer`, `ObserveOnIf`, `Schedule`, `ScheduleSafe`, throttle/debounce helpers | Same helper names; use `ISequencer` overloads for scheduling. |
+| `CatchIgnore`, `CatchAndReturn`, `CatchReturn`, retry helpers | Same helper names; no System.Reactive dependency. |
+| `SubscribeAsync`, `SelectAsync`, `SelectLatestAsync`, `DropIfBusy` | Same BCL observable helper names for Task/ValueTask interop. |
+| `RunAll`, `BufferUntil`, `FirstMatchFromCandidates`, `ToHotTask`, `ToHotValueTask` | Same helper names; backed by ReactiveUI.Primitives runtime utilities. |
+
+For async-native streams, prefer `ReactiveUI.Primitives.Async` and its `IObservableAsync<T>` operators. For existing BCL observable helpers, migrate to `ReactiveUI.Primitives.Extensions`.
+
 ## Benchmarks and performance posture
 
-Benchmarks live in `src/benchmarks/ReactiveUI.Primitives.Benchmarks`. The benchmark project may reference System.Reactive and R3 to compare throughput and allocation behavior; the production package must not.
+Benchmarks live in `src/benchmarks/ReactiveUI.Primitives.Benchmarks`. The benchmark project may reference System.Reactive, R3, and ReactiveUI.Extensions to compare throughput and allocation behavior; the production packages must not.
 
 The latest complete BenchmarkDotNet run finished on 2026-05-29 at 06:37:05 Europe/London with .NET SDK 10.0.300 and .NET runtime 10.0.8 on Windows 11. It executed 201 benchmarks with no skipped suites in 00:21:37:
 
@@ -686,7 +907,34 @@ Smoke validation for deterministic benchmark behavior passed for 67 benchmark gr
 dotnet run --project src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveUI.Primitives.Benchmarks.csproj --configuration Release --no-build -- --smoke
 ```
 
-The latest direct test/coverage validation passed 181/181 net10.0 tests and reports 91.74% line coverage and 86.01% branch coverage from `.tmp/test-results-20260529-net10-readme/coverage.cobertura.xml`. The full solution test pass also passed 558/558 tests across net8.0, net9.0, and net10.0.
+The latest direct test/coverage validation passed 2032/2032 net8.0 tests and reports 99.28% line coverage and 97.22% branch coverage for `ReactiveUI.Primitives.Extensions` from `src/tests/ReactiveUI.Primitives.Tests/TestResults/extensions-optimization/coverage.cobertura.xml`. Direct executable validation also passed 2032/2032 tests on net9.0 and 2032/2032 tests on net10.0.
+
+Focused Async and Extensions BenchmarkDotNet runs were added on 2026-05-30 on Windows 11 with .NET SDK 10.0.300 and .NET runtime 10.0.8. They used `LaunchCount=1`, `WarmupCount=1`, and `IterationCount=3`.
+
+```powershell
+dotnet run --project src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveUI.Primitives.Benchmarks.csproj --configuration Release --no-build -- --filter "*ReactiveExtensionsComparisonBenchmarks*" --launchCount 1 --warmupCount 1 --iterationCount 3
+dotnet run --project src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveUI.Primitives.Benchmarks.csproj --configuration Release --no-build -- --filter "*AsyncExtensionsComparisonBenchmarks*" --launchCount 1 --warmupCount 1 --iterationCount 3
+```
+
+Extensions comparison against `ReactiveUI.Extensions` 4.0.0:
+
+| Scenario | ReactiveUI.Primitives.Extensions | ReactiveUI.Extensions 4.0.0 |
+|---|---:|---:|
+| `WhereSelect` range | 75.87 ns / 136 B | 2,655.97 ns / 2512 B |
+| `FromArray` subscribe | 58.42 ns / 40 B | 59.15 ns / 40 B |
+| `Pairwise` range | 515.51 ns / 160 B | 3,016.54 ns / 2536 B |
+| `BufferUntil` chars | 52.81 ns / 264 B | 53.01 ns / 264 B |
+| `Not` + `WhereTrue` | 28.81 ns / 144 B | 30.42 ns / 144 B |
+
+Async comparison against `ReactiveUI.Extensions.Async` 4.0.0:
+
+| Scenario | ReactiveUI.Primitives.Async | ReactiveUI.Extensions.Async 4.0.0 |
+|---|---:|---:|
+| `Sequence` + `Map` + `Keep` + `ToListAsync` | 2,109.7 ns / 1600 B | 2,085.6 ns / 1600 B |
+| Async `CountAsync` | 817.2 ns / 704 B | 808.0 ns / 704 B |
+| Async signal/subject broadcast | 6,822.4 ns / 2320 B | 6,802.5 ns / 2320 B |
+
+The focused Extensions results show the fused and direct-observer operators winning the high-value migrated scenarios while preserving allocations where both implementations use equivalent buffering. The Async results are allocation-equivalent to the baseline and within measurement noise on the selected parity paths.
 
 The table below is generated from the joined BenchmarkDotNet CSV and uses `Mean / Allocated` for each cell.
 
@@ -806,6 +1054,8 @@ Performance constraints used by the project:
 | Path | Purpose |
 |---|---|
 | `src/ReactiveUI.Primitives` | Production runtime library. |
+| `src/ReactiveUI.Primitives.Async` | Async observable/signal library built on `IObservableAsync<T>` and `IObserverAsync<T>`. |
+| `src/ReactiveUI.Primitives.Extensions` | Migrated non-async ReactiveUI.Extensions helper operators backed by ReactiveUI.Primitives. |
 | `src/ReactiveUI.Primitives.Wpf` | Optional WPF dispatcher integration library. |
 | `src/ReactiveUI.Primitives.WinForms` | Optional Windows Forms control integration library. |
 | `src/ReactiveUI.Primitives.WinUI` | Optional WinUI dispatcher queue integration library. |
@@ -822,22 +1072,23 @@ Performance constraints used by the project:
 
 ```powershell
 # Build solution.
-dotnet build .\src\ReactiveUI.Primitives.slnx -c Release --no-restore -v:minimal -p:UseSharedCompilation=false -p:BuildInParallel=false -maxcpucount:1
+dotnet build .\src\ReactiveUI.Primitives.slnx -c Release -v minimal /nr:false -p:UseSharedCompilation=false -p:BuildInParallel=false -maxcpucount:1
 
-# Net10 coverage run through the Microsoft Testing Platform/TUnit executable.
-dotnet .\src\tests\ReactiveUI.Primitives.Tests\bin\Release\net10.0\ReactiveUI.Primitives.Tests.dll --results-directory .\.tmp\test-results-20260529-net10-readme --report-trx --report-trx-filename net10.trx --coverage --coverage-output coverage.cobertura.xml --coverage-output-format cobertura --no-progress --maximum-parallel-tests 1 --timeout 10m --output Normal --show-stdout Failed --show-stderr Failed --disable-logo
+# Net8 coverage run through the Microsoft Testing Platform/TUnit executable.
+dotnet .\src\tests\ReactiveUI.Primitives.Tests\bin\Release\net8.0\ReactiveUI.Primitives.Tests.dll --coverage --coverage-output coverage.cobertura.xml --coverage-output-format cobertura --results-directory .\src\tests\ReactiveUI.Primitives.Tests\TestResults\extensions-optimization --no-ansi --no-progress --output Normal --timeout 10m
 
-# All target-framework tests.
-Push-Location .\src
-dotnet test .\ReactiveUI.Primitives.slnx -c Release --no-build -v:minimal --results-directory ..\.tmp\test-results-20260529-solution-readme -- --report-trx --report-trx-filename solution.trx --no-progress --maximum-parallel-tests 1 --timeout 10m --disable-logo
-Pop-Location
+# Remaining test target frameworks through the generated TUnit executables.
+dotnet .\src\tests\ReactiveUI.Primitives.Tests\bin\Release\net9.0\ReactiveUI.Primitives.Tests.dll --results-directory .\src\tests\ReactiveUI.Primitives.Tests\TestResults\extensions-optimization-net9 --no-ansi --no-progress --output Normal --timeout 10m
+dotnet .\src\tests\ReactiveUI.Primitives.Tests\bin\Release\net10.0\ReactiveUI.Primitives.Tests.dll --results-directory .\src\tests\ReactiveUI.Primitives.Tests\TestResults\extensions-optimization-net10 --no-ansi --no-progress --output Normal --timeout 10m
 
-# Benchmark smoke and complete joined comparison run.
+# Benchmark smoke, focused Async/Extensions comparisons, and complete joined comparison run.
 dotnet run --project .\src\benchmarks\ReactiveUI.Primitives.Benchmarks\ReactiveUI.Primitives.Benchmarks.csproj --configuration Release --no-build -- --smoke
+dotnet run --project .\src\benchmarks\ReactiveUI.Primitives.Benchmarks\ReactiveUI.Primitives.Benchmarks.csproj --configuration Release --no-build -- --filter "*ReactiveExtensionsComparisonBenchmarks*" --launchCount 1 --warmupCount 1 --iterationCount 3
+dotnet run --project .\src\benchmarks\ReactiveUI.Primitives.Benchmarks\ReactiveUI.Primitives.Benchmarks.csproj --configuration Release --no-build -- --filter "*AsyncExtensionsComparisonBenchmarks*" --launchCount 1 --warmupCount 1 --iterationCount 3
 dotnet run --project .\src\benchmarks\ReactiveUI.Primitives.Benchmarks\ReactiveUI.Primitives.Benchmarks.csproj --configuration Release --no-build -- --filter "*" --join --launchCount 1 --warmupCount 1 --iterationCount 3
 ```
 
-Results: build passed with 0 warnings/0 errors; the net10.0 coverage run passed 181/181 tests; `dotnet test` passed 558/558 tests across net8.0, net9.0, and net10.0; benchmark smoke parity passed for 67 groups; the joined BenchmarkDotNet run executed 201 benchmarks. The latest coverage snapshot reported 91.74% line (10740/11707) and 86.01% branch (4280/4976) coverage.
+Results: build passed with 0 warnings/0 errors; the net8.0 coverage run passed 2032/2032 tests; direct TUnit executable validation passed 2032/2032 tests on net9.0 and 2032/2032 tests on net10.0. The latest `ReactiveUI.Primitives.Extensions` coverage snapshot reported 99.28% line (3171/3194) and 97.22% branch (875/900) coverage. Benchmark smoke parity passed for 67 groups; the joined BenchmarkDotNet run executed 201 benchmarks, and the focused Async/Extensions BenchmarkDotNet runs produced the comparison tables above.
 
 ### Package verification
 
diff --git a/Skills.md b/Skills.md
new file mode 100644
index 0000000..e11ee46
--- /dev/null
+++ b/Skills.md
@@ -0,0 +1,520 @@
+---
+name: reactiveui-primitives
+description: Use when working with ReactiveUI.Primitives NuGet packages, migrating from System.Reactive or R3, choosing Signal/Sequencer/Async/Extensions APIs, or using the generated bridge adapters without adding runtime Rx or R3 dependencies.
+---
+
+# ReactiveUI.Primitives
+
+Use this skill when a .NET project consumes ReactiveUI.Primitives from NuGet and needs reactive streams, state, scheduling, async observables, migrated ReactiveUI.Extensions helpers, UI sequencer adapters, or migration guidance from System.Reactive or R3.
+
+Assume package consumption from NuGet. Do not assume repository source paths, local project references, or repository-only workflows.
+
+## Package Setup
+
+Install the packages that match the target application surface:
+
+```bash
+dotnet add package ReactiveUI.Primitives
+dotnet add package ReactiveUI.Primitives.Async
+dotnet add package ReactiveUI.Primitives.Extensions
+```
+
+Add UI adapter packages only when the application needs that UI thread integration:
+
+```bash
+dotnet add package ReactiveUI.Primitives.Wpf
+dotnet add package ReactiveUI.Primitives.WinForms
+dotnet add package ReactiveUI.Primitives.WinUI
+dotnet add package ReactiveUI.Primitives.Blazor
+dotnet add package ReactiveUI.Primitives.Maui
+```
+
+Common imports:
+
+```csharp
+using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions;
+using ReactiveUI.Primitives.Signals;
+```
+
+For async APIs:
+
+```csharp
+using ReactiveUI.Primitives.Async;
+using ReactiveUI.Primitives.Async.Signals;
+```
+
+## Design Rules For Agents
+
+- Prefer ReactiveUI.Primitives names when writing new code: `Signal`, `Map`, `Keep`, `Spark`, `ISequencer`.
+- Do not introduce a System.Reactive or R3 runtime dependency unless the user's project already has that dependency or explicitly needs a bridge boundary.
+- Use bridge source-generator methods only at interop boundaries. Convert at the edge, then keep internal code in Primitives types and naming.
+- Use `ISequencer` for scheduling and UI marshalling. Do not design new code around `IScheduler`.
+- Use `IDisposable` and `IAsyncDisposable` lifetimes explicitly. Store subscriptions in `MultipleDisposable`, `Pocket`, `Slot`, or async disposable containers as appropriate.
+- Keep async pipelines in `IObservableAsync<T>` when the observer work is asynchronous or cancellation-aware.
+
+## Core Package
+
+`ReactiveUI.Primitives` is the base package. It uses BCL `IObservable<T>` and `IObserver<T>` contracts and has no runtime System.Reactive or R3 dependency.
+
+Important public types:
+
+- `Signal<T>`: hot subject-like source and sink. Use instead of `Subject<T>`.
+- `BehaviorSignal<T>`: signal with current value replayed to new subscribers.
+- `StateSignal<T>`: mutable current state signal with a `Value` setter and state projection helpers.
+- `ReadOnlyState<T>` and `ProjectedReadOnlyState<TSource,TResult>`: read-only state projections.
+- `ReplaySignal<T>` and `HistorySignal<T>`: replay buffered values by count and optional time window.
+- `ConnectableSignal<T>`: explicit connectable source for share, replay, auto-connect, and ref-count flows.
+- `TaskSignal` and `TaskSignal<T>`: task-backed signal sources with cancellation-aware execution.
+- `CommandSignal<TResult>` and `CommandExecution<TResult>`: command execution, `CanRun`, `IsRunning`, results, faults, and execution lifecycle.
+- `RxVoid`: no-value event marker, equivalent to Rx `Unit`.
+- `Spark<T>` and `SparkKind`: materialized next/error/completed notifications.
+- `EventPattern<TEventArgs>`, `Moment<T>`, and `TimeInterval<T>`: event and time wrappers.
+
+Signal factory entry point:
+
+```csharp
+using ReactiveUI.Primitives.Signals;
+
+IObservable<int> values = Signal.Sequence(1, 3);
+IObservable<string> one = Signal.Emit("ready");
+IObservable<string> none = Signal.None<string>();
+IObservable<string> failed = Signal.Fail<string>(new InvalidOperationException("boom"));
+IObservable<long> tick = Signal.Every(TimeSpan.FromSeconds(1));
+```
+
+Core factories:
+
+- `Signal.Create`, `CreateSafe`, `CreateWithState`, `Lazy`
+- `Emit`, `EmitRxVoid`, `None`, `Silent`, `Fail`
+- `Sequence`, `Loop`, `Unfold`, `Iterate`
+- `FromEnumerable`, `FromAsyncEnumerable`, `FromTask`, `FromAsync`, `FromEventPattern`
+- `Start`, `Use`, `After`, `Every`, `Pulse`
+- `Chain`, `Blend`, `Race`, `Pair`, `SyncLatest`, `PairLatest`, `ForkJoin`
+
+Example:
+
+```csharp
+using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.Signals;
+
+var input = new Signal<int>();
+
+using var subscription = input
+    .Keep(value => value > 0)
+    .Map(value => value * 2)
+    .Subscribe(value => Console.WriteLine(value));
+
+input.OnNext(21);
+input.OnCompleted();
+```
+
+## Operator Vocabulary
+
+ReactiveUI.Primitives keeps common LINQ-compatible names where useful and adds distinct names to avoid confusion with System.Reactive and R3.
+
+Prefer these Primitives names in new code:
+
+| System.Reactive or R3 concept | ReactiveUI.Primitives name |
+| --- | --- |
+| `Subject<T>` | `Signal<T>` |
+| `BehaviorSubject<T>` | `BehaviorSignal<T>` or `StateSignal<T>` |
+| `ReplaySubject<T>` | `ReplaySignal<T>` or `HistorySignal<T>` |
+| `Observable.Return` | `Signal.Emit` |
+| `Observable.Empty` | `Signal.None` |
+| `Observable.Never` | `Signal.Silent` |
+| `Observable.Throw` | `Signal.Fail` |
+| `Observable.Range` | `Signal.Sequence` |
+| `Observable.Timer` | `Signal.After` |
+| `Observable.Interval` | `Signal.Every` or `Signal.Pulse` |
+| `Select` | `Map` |
+| `Where` | `Keep` |
+| `OfType` | `KeepType` |
+| `Cast` | `CastTo` |
+| `Where(x is not null)` | `KeepNotNull` |
+| `Do` | `Tap` or `TapWith` |
+| `Scan` | `Fold` |
+| `Aggregate` | `Reduce` |
+| `SelectMany` | `FlatMap` or `Bind` |
+| `Concat` | `Chain` |
+| `Merge` | `Blend` |
+| `Amb` | `Race` |
+| `Zip` | `Pair` |
+| `CombineLatest` | `SyncLatest` or `PairLatest` |
+| `WithLatestFrom` | `Latch` |
+| `Switch` | `SwitchTo` |
+| `Retry` | `Reattempt` |
+| `Catch` | `Recover`, `Rescue`, or `Resume` |
+| `Delay` | `Shift` |
+| `Timeout` | `Expire` |
+| `StartWith` | `Lead` |
+| `Materialize` | `Spark` |
+| `Dematerialize` | `Unspark` |
+| `Unit` | `RxVoid` |
+| `Notification<T>` | `Spark<T>` |
+| `IScheduler` | `ISequencer` |
+| `CompositeDisposable` | `MultipleDisposable`, `Pocket`, or the `CompositeDisposable` alias |
+| `SerialDisposable` | `SingleReplaceableDisposable` or `Slot` |
+| `SingleAssignmentDisposable` | `SingleDisposable` or `AssignmentSlot` |
+
+Standard names such as `Take`, `Skip`, `Distinct`, `DistinctBy`, `DefaultIfEmpty`, `Buffer`, `Timestamp`, `TimeInterval`, `SubscribeOn`, `ObserveOn`, terminal collection methods, and async terminal methods may also be available. Prefer the Primitives name when both exist and the target code is intended to avoid Rx/R3 vocabulary.
+
+## Sequencers
+
+`ISequencer` is the scheduling abstraction. Use it instead of Rx `IScheduler`.
+
+Common sequencers:
+
+- `Sequencer.Immediate`
+- `Sequencer.CurrentThread`
+- `Sequencer.Default`
+- `ImmediateSequencer`
+- `CurrentThreadSequencer`
+- `TaskPoolSequencer`
+- `ThreadPoolSequencer`
+- `SynchronizationContextSequencer`
+- `VirtualClock`, `TestClock`, and `VirtualTimeSequencer<TAbsolute,TRelative>` for deterministic virtual time
+
+Example:
+
+```csharp
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Signals;
+
+ISequencer ui = SynchronizationContextSequencer.Current;
+
+using var subscription = Signal
+    .Every(TimeSpan.FromSeconds(1), Sequencer.Default)
+    .ObserveOn(ui)
+    .Subscribe(_ => RefreshView());
+```
+
+UI adapter packages provide UI-specific sequencers:
+
+- WPF: `DispatcherSequencer`
+- WinForms: `ControlSequencer`
+- WinUI: `DispatcherQueueSequencer` and `ToSequencer`
+- Blazor: `BlazorRendererSequencer` and `ReactiveComponentBase`
+- MAUI: `MauiDispatcherSequencer` and `ToSequencer`
+
+## Disposables
+
+Use `ReactiveUI.Primitives.Disposables` for subscription and resource lifetimes:
+
+- `Disposable.Empty` and `Disposable.Create(Action)`
+- `BooleanDisposable`
+- `CancellationDisposable`
+- `MultipleDisposable` and `CompositeDisposable`
+- `Pocket`
+- `SingleDisposable` and `AssignmentSlot`
+- `SingleReplaceableDisposable` and `Slot`
+- `MutableDisposable`, `SwapDisposable`, and `DisposableBag`
+- `Handle`, `Handle<T>`, `Handle<T1,T2>`, `Handle<T1,T2,T3>`
+
+Example:
+
+```csharp
+using ReactiveUI.Primitives.Disposables;
+
+var subscriptions = new MultipleDisposable();
+
+source.Subscribe(value => Console.WriteLine(value))
+    .DisposeWith(subscriptions);
+
+subscriptions.Dispose();
+```
+
+## Async Package
+
+`ReactiveUI.Primitives.Async` adds asynchronous observable contracts:
+
+- `IObservableAsync<T>`
+- `IObserverAsync<T>`
+- `ObserverAsync<T>`
+- `SignalAsync<T>`
+- `ISignalAsync<T>`
+- `ConnectableSignalAsync<T>`
+- `Result`
+- `Optional<T>`
+- `AsyncContext`
+
+Async observer methods return `ValueTask` and accept cancellation where relevant:
+
+- `OnNextAsync(T value, CancellationToken cancellationToken)`
+- `OnErrorResumeAsync(Exception error, CancellationToken cancellationToken)`
+- `OnCompletedAsync(Result result)`
+- `DisposeAsync()`
+
+Use `ReactiveUI.Primitives.Async.SignalAsync` for async observable factories and operators:
+
+```csharp
+using ReactiveUI.Primitives.Async;
+
+IObservableAsync<int> source = SignalAsync.Sequence(1, 3);
+
+List<int> values = await source
+    .Keep(value => value > 1)
+    .Map(value => value * 10)
+    .CollectListAsync();
+```
+
+Use `ReactiveUI.Primitives.Async.Signals.Signal` for mutable async signals:
+
+```csharp
+using AsyncSignal = ReactiveUI.Primitives.Async.Signals.Signal;
+
+await using var signal = AsyncSignal.Create<int>();
+
+await signal.SubscribeAsync(async (value, cancellationToken) =>
+{
+    await StoreAsync(value, cancellationToken);
+});
+
+await signal.OnNextAsync(42, CancellationToken.None);
+await signal.OnCompletedAsync(Result.Success);
+```
+
+Async creation options:
+
+- `SignalCreationOptions`
+- `BehaviorSignalCreationOptions`
+- `ReplayLatestSignalCreationOptions`
+- `PublishingOption.Serial`
+- `PublishingOption.Concurrent`
+
+Async mutable signal factories:
+
+- `Signal.Create<T>()`
+- `Signal.Create<T>(SignalCreationOptions?)`
+- `Signal.CreateBehavior<T>(T startValue)`
+- `Signal.CreateBehavior<T>(T startValue, BehaviorSignalCreationOptions?)`
+- `Signal.CreateReplayLatest<T>()`
+- `Signal.CreateReplayLatest<T>(ReplayLatestSignalCreationOptions?)`
+
+Async operator vocabulary follows the core Primitives names where possible:
+
+- `Emit`, `None`, `Fail`, `Sequence`, `FromEnumerable`, `FromAsyncEnumerable`, `After`, `Every`, `Pulse`, `Use`
+- `Map`, `MapWith`
+- `Keep`, `KeepWith`, `KeepNotNull`, `KeepType`
+- `CastTo`
+- `Tap`
+- `Fold`, `ReduceAsync`
+- `FlatMap`, `Bind`
+- `Unique`, `UniqueBy`
+- `Chain`, `Blend`, `SwitchTo`
+- `Pair`, `SyncLatest`, `PairLatest`
+- `Reattempt`, `Recover`, `Rescue`, `Resume`
+- `Shift`, `Expire`, `Lead`
+- `CollectListAsync`, `CollectArrayAsync`
+
+Async also exposes parity operators such as `AggregateAsync`, `AnyAsync`, `AllAsync`, `CountAsync`, `LongCountAsync`, `ContainsAsync`, `FirstAsync`, `FirstOrDefaultAsync`, `LastAsync`, `LastOrDefaultAsync`, `SingleAsync`, `SingleOrDefaultAsync`, `ForEachAsync`, `WaitCompletionAsync`, `ToAsyncEnumerable`, `ToDictionaryAsync`, `GroupBy`, `Merge`, `Concat`, `Zip`, `Switch`, `Retry`, `Throttle`, `Timeout`, `Delay`, `ObserveOn`, and `SubscribeAsync`.
+
+Async disposable helpers:
+
+- `DisposableAsync.Empty`
+- `DisposableAsync.Create(...)`
+- `MultipleDisposableAsync`
+- `SingleAssignmentDisposableAsync`
+- `SingleReplaceableDisposableAsync`
+- `DisposableAsyncSlot`
+
+## Extensions Package
+
+`ReactiveUI.Primitives.Extensions` contains migrated convenience operators that reference ReactiveUI.Primitives and avoid production System.Reactive/R3 dependencies.
+
+High-value extension areas:
+
+- Null and boolean helpers: `WhereIsNotNull`, `SkipWhileNull`, `WhereTrue`, `WhereFalse`, `Not`
+- Signal helpers: `AsSignal`, `ToReadOnlyBehavior`, `ReplayLastOnSubscribe`
+- Error helpers: `CatchIgnore`, `CatchAndReturn`, `CatchReturn`, `CatchReturnUnit`, `LogErrors`
+- Retry helpers: `OnErrorRetry`, `RetryWithBackoff`, `RetryWithDelay`, `RetryForeverWithDelay`, `RetryWithFixedDelay`
+- Timing helpers: `SyncTimer`, `Schedule`, `SampleLatest`, `ThrottleFirst`, `ThrottleUntilTrue`, `ThrottleOnScheduler`, `ThrottleDistinct`, `DebounceImmediate`, `DebounceUntil`
+- Buffering and state helpers: `BufferUntil`, `BufferUntilIdle`, `BufferUntilInactive`, `Conflate`, `Heartbeat`, `DetectStale`, `LatestOrDefault`
+- Async interop helpers: `SubscribeAsync`, `SelectAsync`, `SelectAsyncSequential`, `SelectLatestAsync`, `SelectAsyncConcurrent`, `ToHotTask`, `ToHotValueTask`, `WaitUntil`, `DropIfBusy`
+- Collection and projection helpers: `ForEach`, `FromArray`, `Using`, `While`, `ScanWithInitial`, `Filter`, `Shuffle`, `Pairwise`, `Partition`, `WhereSelect`, `SelectConstant`, `TrySelect`, `SelectManyThen`, `RunAll`, `FirstMatchFromCandidates`
+- Subscription helpers: `SubscribeGetValue`, `SubscribeGetError`, `WaitForValue`, `WaitForCompletion`, `WaitForError`
+
+Example:
+
+```csharp
+using ReactiveUI.Primitives.Extensions;
+
+IObservable<string> nonEmpty = names
+    .WhereIsNotNull()
+    .Keep(name => name.Length > 0)
+    .ReplayLastOnSubscribe();
+```
+
+## Source Generator Bridges
+
+The base package packs source generators as analyzers. The async package also packs them so async bridge methods can be generated.
+
+The generators do not add runtime System.Reactive or R3 dependencies to ReactiveUI.Primitives. They emit bridge code only when the consuming project already references the relevant external package.
+
+System.Reactive bridge:
+
+- Generated namespace: `ReactiveUI.Primitives.SystemReactiveBridge`
+- Available when `System.Reactive` symbols are present.
+- `AsPrimitivesSignal<T>(this System.IObservable<T>)`
+- `AsSystemObservable<T>(this System.IObservable<T>)`
+- `AsSequencer(this System.Reactive.Concurrency.IScheduler)`
+- `AsSystemScheduler(this ReactiveUI.Primitives.Concurrency.ISequencer)`
+- If `ReactiveUI.Primitives.Async` is referenced: `ToObservableAsync<T>(this IObservable<T>)`
+- If `ReactiveUI.Primitives.Async` is referenced: `ToObservable<T>(this IObservableAsync<T>)`
+
+R3 bridge:
+
+- Generated namespace: `ReactiveUI.Primitives.R3Bridge`
+- Available when `R3.Observable<T>` symbols are present.
+- `AsPrimitivesSignal<T>(this R3.Observable<T>)`
+- `AsR3Observable<T>(this System.IObservable<T>)`
+- If `ReactiveUI.Primitives.Async` is referenced: `AsPrimitivesAsyncObservable<T>(this R3.Observable<T>)`
+- If `ReactiveUI.Primitives.Async` is referenced: `AsR3Observable<T>(this IObservableAsync<T>)`
+
+Bridge example for System.Reactive:
+
+```csharp
+using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.SystemReactiveBridge;
+
+IObservable<int> primitives = rxObservable.AsPrimitivesSignal();
+
+using var subscription = primitives
+    .Map(value => value + 1)
+    .Subscribe(Console.WriteLine);
+```
+
+Bridge example for R3:
+
+```csharp
+using ReactiveUI.Primitives.R3Bridge;
+
+IObservable<int> primitives = r3Observable.AsPrimitivesSignal();
+R3.Observable<int> r3 = primitives.AsR3Observable();
+```
+
+Generated bridge classes are internal to the consuming assembly. The extension methods are still usable by code in that assembly after importing the generated namespace.
+
+## System.Reactive Migration
+
+Use this migration path:
+
+1. Add `ReactiveUI.Primitives`.
+2. Add `ReactiveUI.Primitives.Async`, `ReactiveUI.Primitives.Extensions`, or UI adapter packages only where needed.
+3. Keep System.Reactive package references temporarily only in assemblies that still consume Rx APIs or need bridge adapters.
+4. Convert hot sources first: `Subject<T>` to `Signal<T>`, `BehaviorSubject<T>` to `StateSignal<T>` or `BehaviorSignal<T>`, and `ReplaySubject<T>` to `ReplaySignal<T>` or `HistorySignal<T>`.
+5. Replace operators with Primitives vocabulary at the same time as touching code.
+6. Replace `IScheduler` dependencies with `ISequencer` dependencies. Use generated scheduler bridge adapters only at external Rx boundaries.
+7. Replace Rx disposables with Primitives disposables.
+8. Remove System.Reactive package references from assemblies once no Rx symbols remain.
+
+System.Reactive factory mapping:
+
+```csharp
+// Before
+var values = System.Reactive.Linq.Observable.Range(1, 3);
+
+// After
+var values = ReactiveUI.Primitives.Signals.Signal.Sequence(1, 3);
+```
+
+System.Reactive subject mapping:
+
+```csharp
+// Before
+var subject = new System.Reactive.Subjects.Subject<string>();
+
+// After
+var signal = new ReactiveUI.Primitives.Signals.Signal<string>();
+```
+
+State mapping:
+
+```csharp
+// Before
+var current = new System.Reactive.Subjects.BehaviorSubject<int>(0);
+
+// After
+var state = new ReactiveUI.Primitives.Signals.StateSignal<int>(0);
+state.Value = 1;
+```
+
+Command migration:
+
+```csharp
+using ReactiveUI.Primitives.Signals;
+
+var canRun = new StateSignal<bool>(true);
+var command = new CommandSignal<string>(
+    async cancellationToken =>
+    {
+        await SaveAsync(cancellationToken);
+        return "saved";
+    },
+    canRun);
+
+using var results = command.Results.Subscribe(Console.WriteLine);
+await command.ExecuteAsync(CancellationToken.None);
+```
+
+## R3 Migration
+
+Use this migration path:
+
+1. Add `ReactiveUI.Primitives`.
+2. Keep R3 references temporarily only in assemblies that still expose or consume R3 APIs.
+3. Convert R3 hot sources to `Signal<T>` or async signals depending on whether observer work is synchronous or asynchronous.
+4. Convert `R3.Observable<T>` to BCL `IObservable<T>` with `AsPrimitivesSignal()` at the boundary when the generated bridge is available.
+5. Convert Primitives streams back to R3 only at public boundaries that must still expose R3.
+6. Prefer `ISequencer` and Primitives time operators for new scheduling code.
+7. Remove R3 references from assemblies once no R3 symbols remain.
+
+R3 bridge example:
+
+```csharp
+using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.R3Bridge;
+
+IObservable<int> primitives = r3Source.AsPrimitivesSignal();
+
+using var subscription = primitives
+    .Keep(value => value > 0)
+    .Map(value => value * 2)
+    .Subscribe(Console.WriteLine);
+```
+
+Async R3 bridge example:
+
+```csharp
+using ReactiveUI.Primitives.Async;
+using ReactiveUI.Primitives.R3Bridge;
+
+IObservableAsync<int> asyncSource = r3Source.AsPrimitivesAsyncObservable();
+List<int> values = await asyncSource.CollectListAsync();
+```
+
+## Choosing Sync Or Async
+
+Use `IObservable<T>` and the base package when:
+
+- Values are pushed synchronously.
+- Observer work is fast and does not need `await`.
+- Existing consumers already use BCL `IObservable<T>`.
+
+Use `IObservableAsync<T>` and the async package when:
+
+- Observers perform asynchronous work.
+- Backpressure-like awaiting between observer calls matters.
+- Cancellation needs to flow through subscriptions and `OnNextAsync`.
+- Completion needs the async `Result` shape, especially when bridging from R3.
+
+## Common Mistakes To Avoid
+
+- Do not rename `Signal<T>` back to `Subject<T>` in Primitives code.
+- Do not introduce `System.Reactive.Linq.Observable` just for basic factories; use `ReactiveUI.Primitives.Signals.Signal`.
+- Do not expose `IScheduler` in new APIs; expose `ISequencer`.
+- Do not mix `SignalAsync<T>` and `Signal<T>` in the same pipeline without an explicit bridge or conversion reason.
+- Do not keep bridge conversions in the middle of a pipeline. Convert once at the boundary.
+- Do not use UI sequencers from the base package; install the matching UI adapter package.
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index e45d640..9d9e393 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -50,9 +50,9 @@
     <NetTargetFrameworks>net8.0;net9.0;net10.0</NetTargetFrameworks>
 
     <!-- .NET Framework TFMs - EnableWindowsTargeting allows cross-platform compilation -->
-    <NetFrameworkTargetFrameworks>net462;net472;net481</NetFrameworkTargetFrameworks>
+    <NetFrameworkTargetFrameworks>net462;net472;net48;net481</NetFrameworkTargetFrameworks>
 
-    <!-- Library projects: net8.0, net9.0, net10.0, net462, net472, net481 -->
+    <!-- Library projects: net8.0, net9.0, net10.0, net462, net472, net48, net481 -->
     <LibraryTargetFrameworks>$(NetTargetFrameworks);$(NetFrameworkTargetFrameworks)</LibraryTargetFrameworks>
 
     <!-- Windows UI integration projects: modern Windows TFMs plus supported .NET Framework TFMs -->
diff --git a/src/ReactiveUI.Primitives.Async/Disposables/MultipleDisposableAsync.cs b/src/ReactiveUI.Primitives.Async/Disposables/MultipleDisposableAsync.cs
index 5443074..198fd72 100644
--- a/src/ReactiveUI.Primitives.Async/Disposables/MultipleDisposableAsync.cs
+++ b/src/ReactiveUI.Primitives.Async/Disposables/MultipleDisposableAsync.cs
@@ -29,11 +29,7 @@ public sealed class MultipleDisposableAsync : IAsyncDisposable
     /// <summary>
     /// The synchronization gate protecting all mutable state in this collection.
     /// </summary>
-#if NET9_0_OR_GREATER
     private readonly Lock _gate = new();
-#else
-    private readonly object _gate = new();
-#endif
 
     /// <summary>
     /// Backing array of disposables. Slots may be <see langword="null"/> after removal to avoid shifting elements;
diff --git a/src/ReactiveUI.Primitives.Async/Operators/CombineLatestEnumerable.cs b/src/ReactiveUI.Primitives.Async/Operators/CombineLatestEnumerable.cs
index dc6bde6..a8251f7 100644
--- a/src/ReactiveUI.Primitives.Async/Operators/CombineLatestEnumerable.cs
+++ b/src/ReactiveUI.Primitives.Async/Operators/CombineLatestEnumerable.cs
@@ -138,13 +138,8 @@ internal sealed class Subscription(
             /// <summary>Cancellation source for disposal.</summary>
             private readonly CancellationTokenSource _disposeCts = new();
 
-#if NET9_0_OR_GREATER
             /// <summary>The completion lock.</summary>
             private readonly Lock _completionLock = new();
-#else
-            /// <summary>The completion lock.</summary>
-            private readonly object _completionLock = new();
-#endif
 
             /// <summary>Downstream observer.</summary>
             [SuppressMessage(
diff --git a/src/ReactiveUI.Primitives.Async/Operators/ParityHelpers.OperatorFusions.cs b/src/ReactiveUI.Primitives.Async/Operators/ParityHelpers.OperatorFusions.cs
index 9af0f29..1c7fd24 100644
--- a/src/ReactiveUI.Primitives.Async/Operators/ParityHelpers.OperatorFusions.cs
+++ b/src/ReactiveUI.Primitives.Async/Operators/ParityHelpers.OperatorFusions.cs
@@ -208,11 +208,7 @@ internal sealed class ThrottleDistinctObserver(
             private static readonly EqualityComparer<T> Comparer = EqualityComparer<T>.Default;
 
             /// <summary>Synchronization gate protecting throttle/distinct state.</summary>
-#if NET9_0_OR_GREATER
             private readonly Lock _gate = new();
-#else
-            private readonly object _gate = new();
-#endif
 
             /// <summary>Most-recent upstream value (for upstream DistinctUntilChanged).</summary>
             private T _lastUpstream = default!;
@@ -488,11 +484,7 @@ public PartitionCoordinator(IObservableAsync<T> source, Func<T, bool> predicate)
         }
 
         /// <summary>Synchronization gate protecting branch slots and the source-subscription lifecycle.</summary>
-#if NET9_0_OR_GREATER
         private readonly Lock _gate = new();
-#else
-        private readonly object _gate = new();
-#endif
 
         /// <summary>The active observer for the truthy branch, or <see langword="null"/> when nobody is subscribed.</summary>
         private IObserverAsync<T>? _trueObserver;
@@ -777,11 +769,7 @@ internal sealed class DebounceUntilObserver(
             CancellationToken subscribeToken) : ObserverAsync<T>(subscribeToken)
         {
             /// <summary>Synchronization gate protecting the id counter.</summary>
-#if NET9_0_OR_GREATER
             private readonly Lock _gate = new();
-#else
-            private readonly object _gate = new();
-#endif
 
             /// <summary>Monotonically increasing identifier used to detect supersession of pending delays.</summary>
             private long _id;
diff --git a/src/ReactiveUI.Primitives.Async/Operators/SwitchSignal.cs b/src/ReactiveUI.Primitives.Async/Operators/SwitchSignal.cs
index 7b13fcd..8cc0119 100644
--- a/src/ReactiveUI.Primitives.Async/Operators/SwitchSignal.cs
+++ b/src/ReactiveUI.Primitives.Async/Operators/SwitchSignal.cs
@@ -59,17 +59,10 @@ internal sealed class SwitchSubscription : IAsyncDisposable
         /// </summary>
         private readonly CancellationToken _disposeCancellationToken;
 
-#if NET9_0_OR_GREATER
         /// <summary>
         /// Lock that protects mutable state from concurrent access.
         /// </summary>
         private readonly Lock _gate = new();
-#else
-        /// <summary>
-        /// Lock that protects mutable state from concurrent access.
-        /// </summary>
-        private readonly object _gate = new();
-#endif
 
         /// <summary>
         /// Async gate that serializes observer callbacks to ensure thread-safe emission.
diff --git a/src/ReactiveUI.Primitives.Async/Operators/Throttle.cs b/src/ReactiveUI.Primitives.Async/Operators/Throttle.cs
index ba7a3cd..882c016 100644
--- a/src/ReactiveUI.Primitives.Async/Operators/Throttle.cs
+++ b/src/ReactiveUI.Primitives.Async/Operators/Throttle.cs
@@ -121,11 +121,7 @@ internal sealed class ThrottleObserver(IObserverAsync<T> observer, TimeSpan dueT
             /// <summary>
             /// The synchronization gate protecting shared throttle state.
             /// </summary>
-#if NET9_0_OR_GREATER
             private readonly Lock _gate = new();
-#else
-            private readonly object _gate = new();
-#endif
 
             /// <summary>
             /// A monotonically increasing identifier used to detect whether a newer element has superseded the current timer.
diff --git a/src/ReactiveUI.Primitives.Async/Operators/Timeout.cs b/src/ReactiveUI.Primitives.Async/Operators/Timeout.cs
index add065c..8ffbf84 100644
--- a/src/ReactiveUI.Primitives.Async/Operators/Timeout.cs
+++ b/src/ReactiveUI.Primitives.Async/Operators/Timeout.cs
@@ -141,11 +141,7 @@ internal sealed class TimeoutObserver(IObserverAsync<T> observer, TimeSpan dueTi
             /// <summary>
             /// Synchronization gate protecting timer state.
             /// </summary>
-#if NET9_0_OR_GREATER
             private readonly Lock _gate = new();
-#else
-            private readonly object _gate = new();
-#endif
 
             /// <summary>
             /// Single pre-allocated timer rearmed via <see cref="ITimer.Change(TimeSpan, TimeSpan)"/>
diff --git a/src/ReactiveUI.Primitives.Async/Operators/Zip.cs b/src/ReactiveUI.Primitives.Async/Operators/Zip.cs
index 68d09fa..f2068d6 100644
--- a/src/ReactiveUI.Primitives.Async/Operators/Zip.cs
+++ b/src/ReactiveUI.Primitives.Async/Operators/Zip.cs
@@ -111,11 +111,7 @@ internal sealed class ZipState(
             /// <summary>
             /// The synchronization gate protecting shared state access.
             /// </summary>
-#if NET9_0_OR_GREATER
             private readonly Lock _gate = new();
-#else
-            private readonly object _gate = new();
-#endif
 
             /// <summary>
             /// Queue of buffered elements from the first source awaiting a pair from the second source.
diff --git a/src/ReactiveUI.Primitives.Async/ReactiveUI.Primitives.Async.csproj b/src/ReactiveUI.Primitives.Async/ReactiveUI.Primitives.Async.csproj
index 2a395df..c6de0b0 100644
--- a/src/ReactiveUI.Primitives.Async/ReactiveUI.Primitives.Async.csproj
+++ b/src/ReactiveUI.Primitives.Async/ReactiveUI.Primitives.Async.csproj
@@ -22,34 +22,24 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.Bcl.TimeProvider"/>
-    <PackageReference Include="System.Threading.Channels"/>
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe"/>
-    <PackageReference Include="System.ComponentModel.Annotations"/>
-    <PackageReference Include="System.Buffers"/>
-    <PackageReference Include="System.Memory"/>
-    <PackageReference Include="System.Collections.Immutable"/>
+    <PackageReference Include="Microsoft.Bcl.TimeProvider" />
+    <PackageReference Include="System.Threading.Channels" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" />
+    <PackageReference Include="System.ComponentModel.Annotations" />
+    <PackageReference Include="System.Buffers" />
+    <PackageReference Include="System.Memory" />
+    <PackageReference Include="System.Collections.Immutable" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\ReactiveUI.Primitives\ReactiveUI.Primitives.csproj" />
-    <ProjectReference Include="..\ReactiveUI.Primitives.R3Bridge.Generator\ReactiveUI.Primitives.R3Bridge.Generator.csproj"
-                      ReferenceOutputAssembly="false"
-                      PrivateAssets="all" />
-    <ProjectReference Include="..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\ReactiveUI.Primitives.SystemReactiveBridge.Generator.csproj"
-                      ReferenceOutputAssembly="false"
-                      PrivateAssets="all" />
+    <ProjectReference Include="..\ReactiveUI.Primitives.R3Bridge.Generator\ReactiveUI.Primitives.R3Bridge.Generator.csproj" ReferenceOutputAssembly="false" PrivateAssets="all" />
+    <ProjectReference Include="..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\ReactiveUI.Primitives.SystemReactiveBridge.Generator.csproj" ReferenceOutputAssembly="false" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
-    <None Include="..\ReactiveUI.Primitives.R3Bridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.R3Bridge.Generator.dll"
-          Pack="true"
-          PackagePath="analyzers/dotnet/cs"
-          Visible="false" />
-    <None Include="..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.SystemReactiveBridge.Generator.dll"
-          Pack="true"
-          PackagePath="analyzers/dotnet/cs"
-          Visible="false" />
+    <None Include="..\ReactiveUI.Primitives.R3Bridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.R3Bridge.Generator.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.SystemReactiveBridge.Generator.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
   </ItemGroup>
 
 </Project>
diff --git a/src/ReactiveUI.Primitives.Async/Signals/Base/BaseSignalAsync.cs b/src/ReactiveUI.Primitives.Async/Signals/Base/BaseSignalAsync.cs
index 9ad1043..be0f1a5 100644
--- a/src/ReactiveUI.Primitives.Async/Signals/Base/BaseSignalAsync.cs
+++ b/src/ReactiveUI.Primitives.Async/Signals/Base/BaseSignalAsync.cs
@@ -23,11 +23,7 @@ public abstract class BaseSignalAsync<T> : SignalAsync<T>, ISignalAsync<T>
     /// <summary>
     /// The lock object used to synchronize access to the Signal's mutable state.
     /// </summary>
-#if NET9_0_OR_GREATER
     private readonly Lock _gate = new();
-#else
-    private readonly object _gate = new();
-#endif
 
     /// <summary>
     /// The immutable list of currently subscribed observers.
diff --git a/src/ReactiveUI.Primitives.Extensions/Continuation.cs b/src/ReactiveUI.Primitives.Extensions/Continuation.cs
new file mode 100644
index 0000000..d559e42
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Continuation.cs
@@ -0,0 +1,137 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Continuation.
+/// </summary>
+public class Continuation : IDisposable
+{
+    /// <summary>
+    /// The barrier used to synchronize phases between the lock holder and the continuation.
+    /// </summary>
+    private readonly Barrier _phaseSync = new(2);
+
+    /// <summary>
+    /// A value indicating whether this instance has been disposed.
+    /// </summary>
+    private bool _disposedValue;
+
+    /// <summary>
+    /// A value indicating whether the continuation is currently locked.
+    /// </summary>
+    private bool _locked;
+
+    /// <summary>
+    /// Gets the number of completed phases.
+    /// </summary>
+    /// <value>
+    /// The completed phases.
+    /// </value>
+    public long CompletedPhases => _phaseSync.CurrentPhaseNumber;
+
+    /// <summary>
+    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+    /// </summary>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Locks this instance.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="item">The item.</param>
+    /// <param name="observer">The observer.</param>
+    /// <returns>
+    /// A <see cref="Task" /> representing the asynchronous operation.
+    /// </returns>
+    public Task Lock<T>(T item, IObserver<(T value, IDisposable Sync)>? observer)
+    {
+        if (_locked)
+        {
+            return Task.CompletedTask;
+        }
+
+        _locked = true;
+        observer?.OnNext((item, this));
+        return ScheduleSignalPhase();
+    }
+
+    /// <summary>
+    /// <see cref="ValueTask"/>-returning counterpart to <see cref="Lock{T}"/>. Use this at per-emission
+    /// call sites where the returned task is awaited exactly once — saves the boxed <see cref="Task"/>
+    /// wrapper allocation in the already-locked fast path.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="item">The item.</param>
+    /// <param name="observer">The observer.</param>
+    /// <returns>A <see cref="ValueTask"/> representing the asynchronous operation.</returns>
+    public ValueTask LockValueTask<T>(T item, IObserver<(T value, IDisposable Sync)>? observer)
+    {
+        if (_locked)
+        {
+            return default;
+        }
+
+        _locked = true;
+        observer?.OnNext((item, this));
+        return new ValueTask(ScheduleSignalPhase());
+    }
+
+    /// <summary>
+    /// UnLocks this instance.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    internal Task UnLock()
+    {
+        if (!_locked)
+        {
+            return Task.CompletedTask;
+        }
+
+        _locked = false;
+        return ScheduleSignalPhase();
+    }
+
+    /// <summary>
+    /// Releases unmanaged and - optionally - managed resources.
+    /// </summary>
+    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+    protected virtual async void Dispose(bool disposing)
+    {
+        if (_disposedValue)
+        {
+            return;
+        }
+
+        if (disposing)
+        {
+            await UnLock().ConfigureAwait(false);
+            _phaseSync.Dispose();
+        }
+
+        _disposedValue = true;
+    }
+
+    /// <summary>Static state-carrying signal callback; avoids the per-call closure allocation a captured lambda would produce.</summary>
+    /// <param name="state">The owning <see cref="Continuation"/> instance.</param>
+    private static void SignalPhaseSync(object? state) => ((Continuation)state!)._phaseSync.SignalAndWait(CancellationToken.None);
+
+    /// <summary>Schedules <see cref="SignalPhaseSync"/> on the default task scheduler. Hoisted
+    /// out of the <see cref="Lock{T}"/> and <see cref="UnLock"/> call sites because cobertura
+    /// tags the multi-argument <c>Task.Factory.StartNew(...)</c> call as a branch line — the
+    /// per-call overload-resolution metadata is collapsed here so it counts once.</summary>
+    /// <returns>The task representing the scheduled signal work.</returns>
+    private Task ScheduleSignalPhase() =>
+        Task.Factory.StartNew(
+            SignalPhaseSync,
+            this,
+            CancellationToken.None,
+            TaskCreationOptions.DenyChildAttach,
+            TaskScheduler.Default);
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Heartbeat.cs b/src/ReactiveUI.Primitives.Extensions/Heartbeat.cs
new file mode 100644
index 0000000..27c7e5d
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Heartbeat.cs
@@ -0,0 +1,40 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Represents either a heartbeat signal or a value update from an observable stream. Value-type shape; the
+/// heartbeat operator emits these directly so per-emission allocations are zero. Note that
+/// <c>default(Heartbeat&lt;T&gt;)</c> represents a value update with the default <typeparamref name="T"/>; use
+/// <c>new Heartbeat&lt;T&gt;()</c> to construct a heartbeat tick.
+/// </summary>
+/// <typeparam name="T">The type of the update value.</typeparam>
+public readonly record struct Heartbeat<T> : IHeartbeat<T>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Heartbeat{T}"/> struct representing a heartbeat tick.
+    /// </summary>
+    public Heartbeat()
+    {
+        IsHeartbeat = true;
+        Update = default;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Heartbeat{T}"/> struct representing a value update.
+    /// </summary>
+    /// <param name="update">The update value.</param>
+    public Heartbeat(T? update)
+    {
+        IsHeartbeat = false;
+        Update = update;
+    }
+
+    /// <inheritdoc/>
+    public bool IsHeartbeat { get; }
+
+    /// <inheritdoc/>
+    public T? Update { get; }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/IHeartbeat.cs b/src/ReactiveUI.Primitives.Extensions/IHeartbeat.cs
new file mode 100644
index 0000000..a68db00
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/IHeartbeat.cs
@@ -0,0 +1,24 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Heart beat.
+/// </summary>
+/// <typeparam name="T">The type.</typeparam>
+public interface IHeartbeat<out T>
+{
+    /// <summary>
+    /// Gets a value indicating whether this instance is heartbeat.
+    /// </summary>
+    /// <value><c>true</c> if this instance is heartbeat; otherwise, <c>false</c>.</value>
+    bool IsHeartbeat { get; }
+
+    /// <summary>
+    /// Gets the update.
+    /// </summary>
+    /// <value>The update.</value>
+    T? Update { get; }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/IStale.cs b/src/ReactiveUI.Primitives.Extensions/IStale.cs
new file mode 100644
index 0000000..976fe27
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/IStale.cs
@@ -0,0 +1,24 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Indicator for connection that has become stale.
+/// </summary>
+/// <typeparam name="T">The type.</typeparam>
+public interface IStale<out T>
+{
+    /// <summary>
+    /// Gets a value indicating whether this instance is stale.
+    /// </summary>
+    /// <value><c>true</c> if this instance is stale; otherwise, <c>false</c>.</value>
+    bool IsStale { get; }
+
+    /// <summary>
+    /// Gets the update.
+    /// </summary>
+    /// <value>The update.</value>
+    T? Update { get; }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/ArgumentExceptionHelper.cs b/src/ReactiveUI.Primitives.Extensions/Internal/ArgumentExceptionHelper.cs
new file mode 100644
index 0000000..3fd0b91
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/ArgumentExceptionHelper.cs
@@ -0,0 +1,107 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Provides helper methods for argument validation.
+/// These methods serve as polyfills for ArgumentExceptionHelper.ThrowIfNull and related methods
+/// that are only available in newer .NET versions.
+/// </summary>
+[ExcludeFromCodeCoverage]
+internal static class ArgumentExceptionHelper
+{
+    /// <summary>
+    /// Throws an <see cref="ArgumentNullException"/> if <paramref name="argument"/> is null.
+    /// </summary>
+    /// <param name="argument">The reference type argument to validate as non-null.</param>
+    /// <param name="paramName">The name of the parameter with which <paramref name="argument"/> corresponds.</param>
+    public static void ThrowIfNull(
+        [NotNull] object? argument,
+        [CallerArgumentExpression(nameof(argument))]
+        string? paramName = null)
+    {
+        if (argument is not null)
+        {
+            return;
+        }
+
+        throw new ArgumentNullException(paramName);
+    }
+
+    /// <summary>
+    /// Validates an argument and returns it if it is not null, otherwise throws an <see cref="ArgumentNullException"/>.
+    /// Designed for use in constructor initializers.
+    /// </summary>
+    /// <typeparam name="T">The type of the argument.</typeparam>
+    /// <param name="argument">The argument to validate.</param>
+    /// <param name="paramName">Captured automatically via <see cref="CallerArgumentExpressionAttribute"/>.</param>
+    /// <returns>The non-null argument.</returns>
+    public static T Check<T>(
+        [NotNull] T? argument,
+        [CallerArgumentExpression(nameof(argument))]
+        string? paramName = null)
+        where T : class
+    {
+        if (argument is not null)
+        {
+            return argument;
+        }
+
+        throw new ArgumentNullException(paramName);
+    }
+
+    /// <summary>
+    /// Validates a string argument and returns it if it is not null or empty, otherwise throws an <see cref="ArgumentNullException"/> or <see cref="ArgumentException"/>.
+    /// Designed for use in constructor initializers.
+    /// </summary>
+    /// <param name="argument">The argument to validate.</param>
+    /// <param name="paramName">Captured automatically via <see cref="CallerArgumentExpressionAttribute"/>.</param>
+    /// <returns>The non-null, non-empty argument.</returns>
+    public static string Check(
+        [NotNull] string? argument,
+        [CallerArgumentExpression(nameof(argument))]
+        string? paramName = null)
+    {
+        if (argument is null)
+        {
+            throw new ArgumentNullException(paramName);
+        }
+
+        if (argument.Length == 0)
+        {
+            throw new ArgumentException("The value cannot be an empty string.", paramName);
+        }
+
+        return argument;
+    }
+
+    /// <summary>
+    /// Throws an exception if <paramref name="argument"/> is null or empty.
+    /// </summary>
+    /// <param name="argument">The string argument to validate as non-null and non-empty.</param>
+    /// <param name="paramName">The name of the parameter with which <paramref name="argument"/> corresponds.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="argument"/> is null.</exception>
+    /// <exception cref="ArgumentException"><paramref name="argument"/> is empty.</exception>
+    public static void ThrowIfNullOrEmpty(
+        [NotNull] string? argument,
+        [CallerArgumentExpression(nameof(argument))]
+        string? paramName = null)
+    {
+        if (argument is null)
+        {
+            throw new ArgumentNullException(paramName);
+        }
+
+        if (argument.Length != 0)
+        {
+            return;
+        }
+
+        throw new ArgumentException("The value cannot be an empty string.", paramName);
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/ConcurrencyLimiter.cs b/src/ReactiveUI.Primitives.Extensions/Internal/ConcurrencyLimiter.cs
new file mode 100644
index 0000000..7d9bb12
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/ConcurrencyLimiter.cs
@@ -0,0 +1,192 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Limits the concurrency of task execution and emits results through an observable sequence.
+/// Implements <see cref="IObservable{T}"/> directly so the surface needs no
+/// <c>ActionDisposable</c> closure wrappers; the per-task continuation state is the
+/// per-subscription <see cref="Subscription"/> instance, which is already a reference type
+/// and therefore needs no boxing through <see cref="object"/>.
+/// </summary>
+/// <typeparam name="T">The type of the task results.</typeparam>
+internal sealed class ConcurrencyLimiter<T> : IObservable<T>
+{
+    /// <summary>The synchronization gate protecting task scheduling and completion state.</summary>
+    private readonly Lock _gate = new();
+
+    /// <summary>Source enumerable; the enumerator is pulled lazily on first <see cref="Subscribe"/>.</summary>
+    private readonly IEnumerable<Task<T>> _taskFunctions;
+
+    /// <summary>Maximum concurrent task continuations.</summary>
+    private readonly int _maxConcurrency;
+
+    /// <summary>The number of tasks currently in flight that have not yet completed.</summary>
+    private int _outstanding;
+
+    /// <summary>Global disposal latch set by any <see cref="Subscription.Dispose"/>. Preserves the
+    /// existing single-subscription-at-a-time semantics: once any consumer disposes, the limiter
+    /// stops pulling further tasks.</summary>
+    private int _disposed;
+
+    /// <summary>Lazy enumerator over the source task sequence; <see langword="null"/> once exhausted.</summary>
+    private IEnumerator<Task<T>>? _rator;
+
+    /// <summary>Initializes a new instance of the <see cref="ConcurrencyLimiter{T}"/> class.</summary>
+    /// <param name="taskFunctions">The task functions to drain.</param>
+    /// <param name="maxConcurrency">The maximum concurrency.</param>
+    public ConcurrencyLimiter(IEnumerable<Task<T>> taskFunctions, int maxConcurrency)
+    {
+        _taskFunctions = taskFunctions;
+        _maxConcurrency = maxConcurrency;
+    }
+
+    /// <summary>Gets the observable sequence — the limiter is its own <see cref="IObservable{T}"/>.</summary>
+    public IObservable<T> Observable => this;
+
+    /// <summary>Gets or sets a value indicating whether the limiter has been disposed by any
+    /// consumer. Exposed to internal tests; production paths set it via
+    /// <see cref="Subscription.Dispose"/>.</summary>
+    internal bool Disposed
+    {
+        get => Volatile.Read(ref _disposed) != 0;
+        set => Interlocked.Exchange(ref _disposed, value ? 1 : 0);
+    }
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        var subscription = new Subscription(this, observer);
+        lock (_gate)
+        {
+            _rator ??= _taskFunctions.GetEnumerator();
+        }
+
+        for (var i = 0; i < _maxConcurrency; i++)
+        {
+            PullNextTask(subscription);
+        }
+
+        return subscription;
+    }
+
+    /// <summary>Clears the lazy enumerator. Caller must hold <see cref="_gate"/> on the production
+    /// paths; exposed to internal tests that exercise the idempotent-second-call branch.</summary>
+    internal void ClearRator()
+    {
+        _rator?.Dispose();
+        _rator = null;
+    }
+
+    /// <summary>Test entry point that adapts a raw <see cref="IObserver{T}"/> into a fresh
+    /// <see cref="Subscription"/> and pulls the next task. Production paths go through
+    /// <see cref="Subscribe"/> which creates the subscription once.</summary>
+    /// <param name="observer">The observer that will receive notifications.</param>
+    internal void PullNextTask(IObserver<T> observer) =>
+        PullNextTask(new Subscription(this, observer));
+
+    /// <summary>Processes the completion of a previously-scheduled task.</summary>
+    /// <param name="subscription">The owning subscription.</param>
+    /// <param name="completed">The completed task.</param>
+    [SuppressMessage(
+        "Major Bug",
+        "S4462:Calls to async methods should not be blocking",
+        Justification = "Task is guaranteed complete at this call site (IsFaulted/IsCanceled were both false above); reading .Result drives the synchronous IObserver<T> contract without blocking.")]
+    private void ProcessTaskCompletion(Subscription subscription, Task<T> completed)
+    {
+        lock (_gate)
+        {
+            if (subscription.Disposed || completed.IsFaulted || completed.IsCanceled)
+            {
+                ClearRator();
+                if (!subscription.Disposed)
+                {
+                    subscription.Observer.OnError((completed.Exception == null
+                        ? new OperationCanceledException()
+                        : completed.Exception.InnerException)!);
+                }
+
+                return;
+            }
+
+            subscription.Observer.OnNext(completed.Result);
+            if (--_outstanding == 0 && _rator == null)
+            {
+                subscription.Observer.OnCompleted();
+            }
+            else
+            {
+                PullNextTask(subscription);
+            }
+        }
+    }
+
+    /// <summary>Pulls the next task and schedules its continuation against this limiter.</summary>
+    /// <param name="subscription">The owning subscription.</param>
+    private void PullNextTask(Subscription subscription)
+    {
+        lock (_gate)
+        {
+            if (subscription.Disposed)
+            {
+                ClearRator();
+            }
+
+            if (_rator is null)
+            {
+                return;
+            }
+
+            if (!_rator.MoveNext())
+            {
+                ClearRator();
+                if (_outstanding == 0)
+                {
+                    subscription.Observer.OnCompleted();
+                }
+
+                return;
+            }
+
+            _outstanding++;
+
+            // The continuation passes the Subscription as state — already a reference type, so
+            // no per-task ValueTuple boxing is needed. The static lambda preserves zero closure
+            // capture.
+            _rator.Current?.ContinueWith(
+                static (ant, state) =>
+                {
+                    var sub = (Subscription)state!;
+                    sub.Limiter.ProcessTaskCompletion(sub, ant);
+                },
+                subscription,
+                CancellationToken.None,
+                TaskContinuationOptions.ExecuteSynchronously,
+                TaskScheduler.Default);
+        }
+    }
+
+    /// <summary>Per-subscription handle: holds the observer reference and a disposal latch.
+    /// Replaces the previous <c>ActionDisposable(() =&gt; Disposed = true)</c> pattern with a
+    /// dedicated class — no closure object per subscribe.</summary>
+    /// <param name="limiter">The owning limiter.</param>
+    /// <param name="observer">The downstream observer.</param>
+    internal sealed class Subscription(ConcurrencyLimiter<T> limiter, IObserver<T> observer) : IDisposable
+    {
+        /// <summary>Gets the owning limiter.</summary>
+        public ConcurrencyLimiter<T> Limiter { get; } = limiter;
+
+        /// <summary>Gets the downstream observer.</summary>
+        public IObserver<T> Observer { get; } = observer;
+
+        /// <summary>Gets a value indicating whether the subscription has been disposed.</summary>
+        public bool Disposed => Limiter.Disposed;
+
+        /// <inheritdoc/>
+        public void Dispose() => Limiter.Disposed = true;
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/ConcurrencyRaceHelpers.cs b/src/ReactiveUI.Primitives.Extensions/Internal/ConcurrencyRaceHelpers.cs
new file mode 100644
index 0000000..abe1f85
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/ConcurrencyRaceHelpers.cs
@@ -0,0 +1,56 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Pure helpers for the two recurring race-claim primitives in the async layer:
+/// the "first caller wins" <see cref="Interlocked.CompareExchange(ref int, int, int)"/>
+/// transition used by <c>PooledDelaySource</c>, and the "tolerate already-disposed CTS"
+/// <c>CancellationTokenSource.CancelAsync</c> wrapper used by <c>ObserverAsync</c>'s
+/// dispose path. Both are pure functions over their inputs and are directly RxVoid-tested
+/// against this class.
+/// </summary>
+internal static class ConcurrencyRaceHelpers
+{
+    /// <summary>
+    /// Atomically transitions <paramref name="state"/> from <paramref name="openSentinel"/>
+    /// to <paramref name="claimedSentinel"/>. Returns <see langword="true"/> if this caller
+    /// won the race; <see langword="false"/> if another caller had already claimed the state.
+    /// </summary>
+    /// <param name="state">The reference to the state field.</param>
+    /// <param name="openSentinel">The sentinel value the state must currently hold.</param>
+    /// <param name="claimedSentinel">The sentinel value the state transitions to on success.</param>
+    /// <returns>
+    /// <see langword="true"/> if the claim succeeded; <see langword="false"/> if another caller
+    /// already claimed the state.
+    /// </returns>
+    public static bool TryClaim(ref int state, int openSentinel, int claimedSentinel) =>
+        Interlocked.CompareExchange(ref state, claimedSentinel, openSentinel) == openSentinel;
+
+    /// <summary>
+    /// Calls <c>CancellationTokenSource.CancelAsync</c> on <paramref name="cts"/>,
+    /// tolerating the <see cref="ObjectDisposedException"/> that another concurrent dispose
+    /// may have already raced ahead with. Returns <see langword="true"/> if the cancellation
+    /// went through; <see langword="false"/> if another caller had already cancelled-and-
+    /// disposed the source.
+    /// </summary>
+    /// <param name="cts">The cancellation token source to cancel.</param>
+    /// <returns>
+    /// <see langword="true"/> if the cancellation completed; <see langword="false"/> if the
+    /// source was already disposed.
+    /// </returns>
+    public static async ValueTask<bool> TryCancelAsync(CancellationTokenSource cts)
+    {
+        try
+        {
+            await cts.CancelAsync().ConfigureAwait(false);
+            return true;
+        }
+        catch (ObjectDisposedException)
+        {
+            return false;
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/CurrentValueSubject.cs b/src/ReactiveUI.Primitives.Extensions/Internal/CurrentValueSubject.cs
new file mode 100644
index 0000000..2c52084
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/CurrentValueSubject.cs
@@ -0,0 +1,320 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Thread-safe subject that holds the most-recently-emitted value, replays it to new subscribers,
+/// and broadcasts subsequent emissions. Per-emission hot path:
+/// <list type="bullet">
+///   <item>Lock taken only to read the current observer state and update the cached value.</item>
+///   <item>Single-observer state lives in a dedicated field — no array allocated for the common case.</item>
+///   <item>Multi-observer state uses a copy-on-write <c>IObserver{T}[]</c> snapshot iterated outside the lock.</item>
+/// </list>
+/// </summary>
+/// <typeparam name="T">The element type.</typeparam>
+internal sealed class CurrentValueSubject<T> : IObservable<T>, IObserver<T>, IDisposable
+{
+    /// <summary>Lock guarding state mutations; held only across snapshot reads and field writes.</summary>
+    private readonly Lock _gate = new();
+
+    /// <summary>Single-observer fast path; non-null when exactly one observer is subscribed.</summary>
+    private IObserver<T>? _observer;
+
+    /// <summary>Multi-observer snapshot; non-null when two or more observers are subscribed. Copy-on-write.</summary>
+    private IObserver<T>[]? _observers;
+
+    /// <summary>Latest value, replayed to new subscribers.</summary>
+    private T _value;
+
+    /// <summary>Terminal error; non-null once <see cref="OnError"/> has fired.</summary>
+    private Exception? _error;
+
+    /// <summary>Latched when the source has completed.</summary>
+    private bool _completed;
+
+    /// <summary>Latched when <see cref="Dispose"/> has been called.</summary>
+    private bool _disposed;
+
+    /// <summary>Initializes a new instance of the <see cref="CurrentValueSubject{T}"/> class with the supplied current value.</summary>
+    /// <param name="initialValue">The value replayed to subscribers until <see cref="OnNext"/> overwrites it.</param>
+    public CurrentValueSubject(T initialValue)
+    {
+        _value = initialValue;
+    }
+
+    /// <summary>Gets the most recently emitted value.</summary>
+    public T Value
+    {
+        get
+        {
+            lock (_gate)
+            {
+                return _value;
+            }
+        }
+    }
+
+    /// <inheritdoc/>
+    public void OnNext(T value)
+    {
+        IObserver<T>? single;
+        IObserver<T>[]? multi;
+        lock (_gate)
+        {
+            if (_disposed || _completed || _error is not null)
+            {
+                return;
+            }
+
+            _value = value;
+            single = _observer;
+            multi = _observers;
+        }
+
+        if (single is not null)
+        {
+            single.OnNext(value);
+            return;
+        }
+
+        if (multi is null)
+        {
+            return;
+        }
+
+        for (var i = 0; i < multi.Length; i++)
+        {
+            multi[i].OnNext(value);
+        }
+    }
+
+    /// <inheritdoc/>
+    public void OnError(Exception error)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(error);
+
+        IObserver<T>? single;
+        IObserver<T>[]? multi;
+        lock (_gate)
+        {
+            if (_disposed || _completed || _error is not null)
+            {
+                return;
+            }
+
+            _error = error;
+            single = _observer;
+            multi = _observers;
+            _observer = null;
+            _observers = null;
+        }
+
+        if (single is not null)
+        {
+            single.OnError(error);
+            return;
+        }
+
+        if (multi is null)
+        {
+            return;
+        }
+
+        for (var i = 0; i < multi.Length; i++)
+        {
+            multi[i].OnError(error);
+        }
+    }
+
+    /// <inheritdoc/>
+    public void OnCompleted()
+    {
+        IObserver<T>? single;
+        IObserver<T>[]? multi;
+        lock (_gate)
+        {
+            if (_disposed || _completed || _error is not null)
+            {
+                return;
+            }
+
+            _completed = true;
+            single = _observer;
+            multi = _observers;
+            _observer = null;
+            _observers = null;
+        }
+
+        if (single is not null)
+        {
+            single.OnCompleted();
+            return;
+        }
+
+        if (multi is null)
+        {
+            return;
+        }
+
+        for (var i = 0; i < multi.Length; i++)
+        {
+            multi[i].OnCompleted();
+        }
+    }
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        lock (_gate)
+        {
+            if (_disposed)
+            {
+                observer.OnError(new ObjectDisposedException(nameof(CurrentValueSubject<T>)));
+                return EmptyDisposable.Instance;
+            }
+
+            if (_error is not null)
+            {
+                observer.OnError(_error);
+                return EmptyDisposable.Instance;
+            }
+
+            observer.OnNext(_value);
+
+            if (_completed)
+            {
+                observer.OnCompleted();
+                return EmptyDisposable.Instance;
+            }
+
+            AddObserverNoLock(observer);
+        }
+
+        return new Subscription(this, observer);
+    }
+
+    /// <summary>Returns an <see cref="IObservable{T}"/> view that hides the <see cref="IObserver{T}"/> side.</summary>
+    /// <returns>A read-only observable view.</returns>
+    public IObservable<T> AsObservable() => new ReadOnlyView(this);
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            _disposed = true;
+            _observer = null;
+            _observers = null;
+        }
+    }
+
+    /// <summary>Adds an observer to the subscriber state; assumes the caller holds <see cref="_gate"/>.</summary>
+    /// <param name="observer">The observer to attach.</param>
+    private void AddObserverNoLock(IObserver<T> observer)
+    {
+        if (_observer is null && _observers is null)
+        {
+            _observer = observer;
+            return;
+        }
+
+        if (_observer is not null)
+        {
+            _observers = [_observer, observer];
+            _observer = null;
+            return;
+        }
+
+        var existing = _observers!;
+        var grown = new IObserver<T>[existing.Length + 1];
+        Array.Copy(existing, grown, existing.Length);
+        grown[existing.Length] = observer;
+        _observers = grown;
+    }
+
+    /// <summary>Removes the supplied observer from the subscriber state.</summary>
+    /// <param name="observer">The observer to detach.</param>
+    private void Unsubscribe(IObserver<T> observer)
+    {
+        lock (_gate)
+        {
+            if (ReferenceEquals(_observer, observer))
+            {
+                _observer = null;
+                return;
+            }
+
+            var existing = _observers;
+            if (existing is null)
+            {
+                return;
+            }
+
+            // Subscription.Dispose's Interlocked guard means a given observer reaches Unsubscribe
+            // at most once, and Subscribe ensures that observer is present in _observers before
+            // returning. OnError / OnCompleted / Dispose nullify _observers atomically, which the
+            // is-null check above already short-circuits — so when we get here, IndexOf finds the
+            // observer by construction.
+            var index = Array.IndexOf(existing, observer);
+
+            if (existing.Length == 2)
+            {
+                // Collapse back to the single-observer fast path.
+                _observer = index == 0 ? existing[1] : existing[0];
+                _observers = null;
+                return;
+            }
+
+            var shrunk = new IObserver<T>[existing.Length - 1];
+            if (index > 0)
+            {
+                Array.Copy(existing, 0, shrunk, 0, index);
+            }
+
+            if (index < existing.Length - 1)
+            {
+                Array.Copy(existing, index + 1, shrunk, index, existing.Length - index - 1);
+            }
+
+            _observers = shrunk;
+        }
+    }
+
+    /// <summary>Per-subscription handle that detaches the observer on dispose. Idempotency is
+    /// enforced via <see cref="Interlocked.Exchange{T}(ref T, T)"/> on <see cref="_observer"/> —
+    /// the second dispose sees <see langword="null"/> and returns. Eliminates the previous
+    /// dedicated <c>_disposed</c> int and shaves a field off every subscription.</summary>
+    /// <param name="parent">The owning subject.</param>
+    /// <param name="observer">The observer to detach.</param>
+    private sealed class Subscription(CurrentValueSubject<T> parent, IObserver<T> observer) : IDisposable
+    {
+        /// <summary>Observer reference captured at attach time; nulled atomically on first dispose.</summary>
+        private IObserver<T>? _observer = observer;
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            var captured = Interlocked.Exchange(ref _observer, null);
+            if (captured is null)
+            {
+                return;
+            }
+
+            parent.Unsubscribe(captured);
+        }
+    }
+
+    /// <summary>Read-only observable view that forwards subscription to the owning subject.</summary>
+    /// <param name="parent">The owning subject.</param>
+    private sealed class ReadOnlyView(CurrentValueSubject<T> parent) : IObservable<T>
+    {
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer) => parent.Subscribe(observer);
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/DrainNotificationKind.cs b/src/ReactiveUI.Primitives.Extensions/Internal/DrainNotificationKind.cs
new file mode 100644
index 0000000..b8e1c7f
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/DrainNotificationKind.cs
@@ -0,0 +1,18 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>Kind of upstream notification enqueued for a <see cref="ScheduledDrainState{T}"/> drain pass.</summary>
+internal enum DrainNotificationKind
+{
+    /// <summary>OnNext with a value.</summary>
+    Next,
+
+    /// <summary>OnError with an exception.</summary>
+    Error,
+
+    /// <summary>OnCompleted (no value).</summary>
+    Completed,
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/FirstAsTaskHelper.cs b/src/ReactiveUI.Primitives.Extensions/Internal/FirstAsTaskHelper.cs
new file mode 100644
index 0000000..41aec66
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/FirstAsTaskHelper.cs
@@ -0,0 +1,70 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Subscribes once and completes the returned <see cref="Task{T}"/> with the first emitted value;
+/// faults the task on source error or on empty completion. Combines the <see cref="TaskCompletionSource{T}"/>
+/// and the IObserver into a single allocation per call.
+/// </summary>
+internal static class FirstAsTaskHelper
+{
+    /// <summary>Subscribes and resolves a task with the first value.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <returns>A task that completes with the first value, faults on error, or faults on empty completion.</returns>
+    public static Task<T> FirstAsTask<T>(IObservable<T> source)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+        var observer = new FirstObserver<T>();
+        observer.Subscription = source.Subscribe(observer);
+        return observer.Task;
+    }
+
+    /// <summary>Combined TaskCompletionSource + IObserver — one heap allocation per call instead of two.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class FirstObserver<T>() : TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously), IObserver<T>
+    {
+        /// <summary>Latches to <c>1</c> once the task has been settled so subsequent callbacks are no-ops.</summary>
+        private int _settled;
+
+        /// <summary>Gets or sets the source subscription so the first-value path can dispose it on completion.</summary>
+        public IDisposable? Subscription { get; set; }
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            if (Interlocked.Exchange(ref _settled, 1) != 0)
+            {
+                return;
+            }
+
+            TrySetResult(value);
+            Subscription?.Dispose();
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            if (Interlocked.Exchange(ref _settled, 1) != 0)
+            {
+                return;
+            }
+
+            TrySetException(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            if (Interlocked.Exchange(ref _settled, 1) != 0)
+            {
+                return;
+            }
+
+            TrySetException(new InvalidOperationException("Sequence contains no elements."));
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/FirstAsValueTaskHelper.cs b/src/ReactiveUI.Primitives.Extensions/Internal/FirstAsValueTaskHelper.cs
new file mode 100644
index 0000000..bd6f0e3
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/FirstAsValueTaskHelper.cs
@@ -0,0 +1,113 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Threading.Tasks.Sources;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// <see cref="ValueTask{T}"/>-returning counterpart to <see cref="FirstAsTaskHelper"/>. Backs the
+/// <c>ToHotValueTask</c> extension with a pooled <see cref="IValueTaskSource{T}"/> implementation
+/// so steady-state callers pay zero allocations after the pool warms up.
+/// </summary>
+/// <typeparam name="T">The element type.</typeparam>
+internal static class FirstAsValueTaskHelper<T>
+{
+    /// <summary>Single-slot pool. <c>null</c> when the previous instance is in flight.</summary>
+    private static PooledFirstObserver? _pooled;
+
+    /// <summary>Subscribes once and resolves a <see cref="ValueTask{T}"/> with the first value.</summary>
+    /// <param name="source">The source observable.</param>
+    /// <returns>A value task that completes with the first value, faults on error, or faults on empty completion.</returns>
+    public static ValueTask<T> FirstAsValueTask(IObservable<T> source)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        var inst = Interlocked.Exchange(ref _pooled, null) ?? new PooledFirstObserver();
+        return inst.Begin(source);
+    }
+
+    /// <summary>Pooled combined <see cref="IValueTaskSource{T}"/> + <see cref="IObserver{T}"/>.</summary>
+    private sealed class PooledFirstObserver : IValueTaskSource<T>, IObserver<T>
+    {
+        /// <summary>The reset-able backing store for the <see cref="ValueTask{T}"/> machinery.</summary>
+        private ManualResetValueTaskSourceCore<T> _core = new() { RunContinuationsAsynchronously = true };
+
+        /// <summary>Latches to <c>1</c> once the source has been settled so subsequent callbacks no-op.</summary>
+        private int _settled;
+
+        /// <summary>The upstream subscription, retained so <see cref="OnNext"/> can cancel it on first match.</summary>
+        private IDisposable? _subscription;
+
+        /// <summary>Begins a fresh capture cycle: resets the core, subscribes the source, returns the task.</summary>
+        /// <param name="source">The source observable to subscribe to.</param>
+        /// <returns>The value task observers consume to receive the first value.</returns>
+        public ValueTask<T> Begin(IObservable<T> source)
+        {
+            _core.Reset();
+            _settled = 0;
+            _subscription = source.Subscribe(this);
+            return new ValueTask<T>(this, _core.Version);
+        }
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            if (Interlocked.Exchange(ref _settled, 1) != 0)
+            {
+                return;
+            }
+
+            _subscription?.Dispose();
+            _core.SetResult(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            if (Interlocked.Exchange(ref _settled, 1) != 0)
+            {
+                return;
+            }
+
+            _core.SetException(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            if (Interlocked.Exchange(ref _settled, 1) != 0)
+            {
+                return;
+            }
+
+            _core.SetException(new InvalidOperationException("Sequence contains no elements."));
+        }
+
+        /// <inheritdoc/>
+        ValueTaskSourceStatus IValueTaskSource<T>.GetStatus(short token) => _core.GetStatus(token);
+
+        /// <inheritdoc/>
+        void IValueTaskSource<T>.OnCompleted(
+            Action<object?> continuation,
+            object? state,
+            short token,
+            ValueTaskSourceOnCompletedFlags flags) =>
+            _core.OnCompleted(continuation, state, token, flags);
+
+        /// <inheritdoc/>
+        T IValueTaskSource<T>.GetResult(short token)
+        {
+            try
+            {
+                return _core.GetResult(token);
+            }
+            finally
+            {
+                _subscription = null;
+                Interlocked.CompareExchange(ref _pooled, this, null);
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/IDrainTarget.cs b/src/ReactiveUI.Primitives.Extensions/Internal/IDrainTarget.cs
new file mode 100644
index 0000000..13cdb89
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/IDrainTarget.cs
@@ -0,0 +1,16 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Implemented by sinks that drive a <see cref="ScheduledDrainState{T}"/>. The state helper invokes
+/// <see cref="Drain"/> once per scheduled burst via a static scheduler callback, so passing the sink
+/// as an <see cref="IDrainTarget"/> keeps the scheduled action allocation-free (no captured closure).
+/// </summary>
+internal interface IDrainTarget
+{
+    /// <summary>Drains the queued notifications on the scheduler thread.</summary>
+    void Drain();
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/IndexedSubscribeHelper.cs b/src/ReactiveUI.Primitives.Extensions/Internal/IndexedSubscribeHelper.cs
new file mode 100644
index 0000000..fa8fe00
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/IndexedSubscribeHelper.cs
@@ -0,0 +1,73 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Shared subscription loop for sync operators that fan an indexed callback set across an N-source
+/// list (e.g. <c>BooleanReduceObservable</c>, <c>MinMaxObservable</c>). Each call site previously
+/// hand-rolled the same loop — index-capture, <see cref="ObservableSubscribeExtensions.SubscribeCallbacks{T}"/>
+/// triple, <see cref="DisposableBag"/> aggregate — so centralising it here keeps the per-emission
+/// closure shape consistent and the duplication off Sonar's CPD radar.
+/// </summary>
+internal static class IndexedSubscribeHelper
+{
+    /// <summary>
+    /// Subscribes the supplied callbacks to every source in <paramref name="sources"/>, threading
+    /// each source's positional index through to the <paramref name="onNext"/> and
+    /// <paramref name="onCompleted"/> hooks. The returned disposable disposes every per-source
+    /// subscription on dispose.
+    /// </summary>
+    /// <typeparam name="T">The element type of the source observables.</typeparam>
+    /// <param name="sources">The source observables, indexed 0..N-1.</param>
+    /// <param name="onNext">Per-source OnNext hook: <c>(index, value)</c>.</param>
+    /// <param name="onError">Shared OnError hook (errors from any source forward unchanged).</param>
+    /// <param name="onCompleted">Per-source OnCompleted hook: <c>(index)</c>.</param>
+    /// <returns>A composite disposable that releases every per-source subscription on dispose.</returns>
+    public static IDisposable SubscribeIndexed<T>(
+        IReadOnlyList<IObservable<T>> sources,
+        Action<int, T> onNext,
+        Action<Exception> onError,
+        Action<int> onCompleted)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(sources);
+        ArgumentExceptionHelper.ThrowIfNull(onNext);
+        ArgumentExceptionHelper.ThrowIfNull(onError);
+        ArgumentExceptionHelper.ThrowIfNull(onCompleted);
+
+        var composite = new DisposableBag();
+        for (var i = 0; i < sources.Count; i++)
+        {
+            composite.Add(sources[i].Subscribe(new IndexedObserver<T>(i, onNext, onError, onCompleted)));
+        }
+
+        return composite;
+    }
+
+    /// <summary>
+    /// Observer that carries a source index without allocating per-source callback closures.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="index">The source index.</param>
+    /// <param name="onNext">Per-source OnNext hook.</param>
+    /// <param name="onError">Shared OnError hook.</param>
+    /// <param name="onCompleted">Per-source OnCompleted hook.</param>
+    private sealed class IndexedObserver<T>(
+        int index,
+        Action<int, T> onNext,
+        Action<Exception> onError,
+        Action<int> onCompleted) : IObserver<T>
+    {
+        /// <inheritdoc/>
+        public void OnNext(T value) => onNext(index, value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => onError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => onCompleted(index);
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/InvalidOperationExceptionHelper.cs b/src/ReactiveUI.Primitives.Extensions/Internal/InvalidOperationExceptionHelper.cs
new file mode 100644
index 0000000..e975d7b
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/InvalidOperationExceptionHelper.cs
@@ -0,0 +1,90 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Provides helper methods for throwing <see cref="InvalidOperationException"/> when
+/// constructor-supplied state on an operator is missing at the time it is consumed.
+/// The thrown message is composed of the captured member name and the caller member
+/// (typically <c>Subscribe</c> or the enclosing type), so call sites just pass the
+/// field being validated.
+/// </summary>
+[ExcludeFromCodeCoverage]
+internal static class InvalidOperationExceptionHelper
+{
+    /// <summary>
+    /// Throws an <see cref="InvalidOperationException"/> if <paramref name="argument"/> is null.
+    /// The exception message is composed from the captured argument expression and the
+    /// caller member, e.g. <c>"'source' was not supplied to 'Subscribe'."</c>.
+    /// </summary>
+    /// <param name="argument">The reference type field to validate as non-null.</param>
+    /// <param name="memberName">Captured automatically via <see cref="CallerArgumentExpressionAttribute"/>.</param>
+    /// <param name="operation">Captured automatically via <see cref="CallerMemberNameAttribute"/>.</param>
+    public static void ThrowIfNull(
+        [NotNull] object? argument,
+        [CallerArgumentExpression(nameof(argument))]
+        string? memberName = null,
+        [CallerMemberName] string? operation = null)
+    {
+        if (argument is not null)
+        {
+            return;
+        }
+
+        throw new InvalidOperationException(
+            $"'{memberName}' was not supplied to '{operation}'.");
+    }
+
+    /// <summary>
+    /// Validates an argument and returns it if it is not null, otherwise throws an <see cref="InvalidOperationException"/>.
+    /// Designed for use in primary constructor initializers.
+    /// </summary>
+    /// <typeparam name="T">The type of the argument.</typeparam>
+    /// <param name="argument">The argument to validate.</param>
+    /// <param name="memberName">Captured automatically via <see cref="CallerArgumentExpressionAttribute"/>.</param>
+    /// <param name="operation">Captured automatically via <see cref="CallerMemberNameAttribute"/>.</param>
+    /// <returns>The non-null argument.</returns>
+    public static T Check<T>(
+        [NotNull] T? argument,
+        [CallerArgumentExpression(nameof(argument))]
+        string? memberName = null,
+        [CallerMemberName] string? operation = null)
+        where T : class
+    {
+        if (argument is not null)
+        {
+            return argument;
+        }
+
+        throw new InvalidOperationException(
+            $"'{memberName}' was not supplied to '{operation}'.");
+    }
+
+    /// <summary>
+    /// Validates a string argument and returns it if it is not null or empty, otherwise throws an <see cref="InvalidOperationException"/>.
+    /// Designed for use in primary constructor initializers.
+    /// </summary>
+    /// <param name="argument">The argument to validate.</param>
+    /// <param name="memberName">Captured automatically via <see cref="CallerArgumentExpressionAttribute"/>.</param>
+    /// <param name="operation">Captured automatically via <see cref="CallerMemberNameAttribute"/>.</param>
+    /// <returns>The non-null, non-empty argument.</returns>
+    public static string Check(
+        [NotNull] string? argument,
+        [CallerArgumentExpression(nameof(argument))]
+        string? memberName = null,
+        [CallerMemberName] string? operation = null)
+    {
+        if (argument is null || string.IsNullOrEmpty(argument))
+        {
+            throw new InvalidOperationException(
+                $"'{memberName}' was not supplied to '{operation}'.");
+        }
+
+        return argument;
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/ObservableSubscribeExtensions.cs b/src/ReactiveUI.Primitives.Extensions/Internal/ObservableSubscribeExtensions.cs
new file mode 100644
index 0000000..fb419b6
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/ObservableSubscribeExtensions.cs
@@ -0,0 +1,30 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Internal subscribe helpers that adapt delegate triples to a proper observer.
+/// </summary>
+internal static class ObservableSubscribeExtensions
+{
+    /// <summary>
+    /// Subscribes using delegate callbacks for OnNext / OnError / OnCompleted. Unique name to
+    /// avoid the System.Reactive <c>Subscribe(onNext, onError, onCompleted)</c> ambiguity; the
+    /// delegates are wrapped by the core <see cref="SubscribeMixins"/> sink rather than a
+    /// duplicated observer.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="onNext">Per-value callback.</param>
+    /// <param name="onError">Error callback.</param>
+    /// <param name="onCompleted">Completion callback.</param>
+    /// <returns>The subscription disposable.</returns>
+    public static IDisposable SubscribeCallbacks<T>(
+        this IObservable<T> source,
+        Action<T> onNext,
+        Action<Exception> onError,
+        Action onCompleted) =>
+        source.Subscribe(onNext, onError, onCompleted);
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/ObserverArrayHelpers.cs b/src/ReactiveUI.Primitives.Extensions/Internal/ObserverArrayHelpers.cs
new file mode 100644
index 0000000..d06c64e
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/ObserverArrayHelpers.cs
@@ -0,0 +1,78 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Pure-plumbing helpers for swap-on-write <see cref="IObserver{T}"/> arrays. Centralizes the
+/// empty-array short-circuit on broadcast and the not-present short-circuit on remove so the
+/// operator hot paths stay branchless on the steady state. Every branch is a pure function
+/// over its inputs and is directly RxVoid-testable through this class.
+/// </summary>
+internal static class ObserverArrayHelpers
+{
+    /// <summary>
+    /// Snapshots the supplied observer array and fans the value out to every observer in order.
+    /// Returns silently if the array is empty (which happens during the race between the last
+    /// unsubscribe and an already-scheduled broadcast).
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="observers">The observer array snapshot.</param>
+    /// <param name="value">The value to broadcast.</param>
+    public static void Broadcast<T>(IObserver<T>[] observers, T value)
+    {
+        if (observers.Length == 0)
+        {
+            return;
+        }
+
+        for (var i = 0; i < observers.Length; i++)
+        {
+            observers[i].OnNext(value);
+        }
+    }
+
+    /// <summary>
+    /// Returns a new observer array with <paramref name="observer"/> removed, or
+    /// <see langword="null"/> if the observer was not in the array (which happens during
+    /// the race between an idempotent subscription dispose and a previous successful remove).
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="current">The current observer array snapshot.</param>
+    /// <param name="observer">The observer to remove.</param>
+    /// <param name="empty">The sentinel empty array.</param>
+    /// <returns>
+    /// The new array (possibly the empty sentinel), or <see langword="null"/> if the observer
+    /// was not present.
+    /// </returns>
+    public static IObserver<T>[]? RemoveOrNull<T>(
+        IObserver<T>[] current,
+        IObserver<T> observer,
+        IObserver<T>[] empty)
+    {
+        var idx = Array.IndexOf(current, observer);
+        if (idx < 0)
+        {
+            return null;
+        }
+
+        if (current.Length == 1)
+        {
+            return empty;
+        }
+
+        var copy = new IObserver<T>[current.Length - 1];
+        for (var i = 0; i < idx; i++)
+        {
+            copy[i] = current[i];
+        }
+
+        for (var i = idx + 1; i < current.Length; i++)
+        {
+            copy[i - 1] = current[i];
+        }
+
+        return copy;
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/ReduceSinkState.cs b/src/ReactiveUI.Primitives.Extensions/Internal/ReduceSinkState.cs
new file mode 100644
index 0000000..a776a07
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/ReduceSinkState.cs
@@ -0,0 +1,95 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Shared synchronous reduce-sink state used by <c>BooleanReduceObservable</c> (AllTrue / AllFalse)
+/// and <c>MinMaxObservable</c> (Max / Min). Each per-operator sink composes one instance (has-a, not
+/// is-a) and adds only its operator-specific OnNext reduce step; the boilerplate gate, value cache,
+/// completion bookkeeping, OnError, and OnCompleted bodies all live here in one place.
+/// </summary>
+/// <typeparam name="TIn">The source element type (must be a struct so <c>TIn?</c> doubles as the
+/// "value seen yet?" Optional).</typeparam>
+/// <typeparam name="TOut">The downstream element type the operator emits after reducing.</typeparam>
+internal sealed class ReduceSinkState<TIn, TOut>
+    where TIn : struct
+{
+    /// <summary>Initializes a new instance of the <see cref="ReduceSinkState{TIn, TOut}"/> class.</summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="count">The number of sources.</param>
+    public ReduceSinkState(IObserver<TOut> downstream, int count)
+    {
+        Downstream = downstream;
+        Values = new TIn?[count];
+        Completed = new bool[count];
+    }
+
+    /// <summary>Gets the synchronization gate held across every state read/write and every downstream notification.</summary>
+    public Lock Gate { get; } = new();
+
+    /// <summary>Gets the downstream observer that receives reduced values, error, and completion.</summary>
+    public IObserver<TOut> Downstream { get; }
+
+    /// <summary>Gets the per-source latest values; index N is set on first OnNext from source N.</summary>
+    public TIn?[] Values { get; }
+
+    /// <summary>Gets the per-source completion bookkeeping.</summary>
+    public bool[] Completed { get; }
+
+    /// <summary>Gets or sets the number of sources that have produced at least one value.</summary>
+    public int HasValueCount { get; set; }
+
+    /// <summary>Gets or sets the number of sources that have completed.</summary>
+    public int CompletedCount { get; set; }
+
+    /// <summary>Gets or sets a value indicating whether the sink has reached its terminal state.</summary>
+    public bool IsDone { get; set; }
+
+    /// <summary>Gets a value indicating whether every source has produced at least one value.</summary>
+    public bool AllValuesPresent => HasValueCount >= Values.Length;
+
+    /// <summary>
+    /// Forwards a terminal error to the downstream observer and marks the sink terminal. Idempotent.
+    /// </summary>
+    /// <param name="error">The error to forward.</param>
+    public void HandleError(Exception error)
+    {
+        lock (Gate)
+        {
+            if (IsDone)
+            {
+                return;
+            }
+
+            IsDone = true;
+            Downstream.OnError(error);
+        }
+    }
+
+    /// <summary>
+    /// Records completion of the source at <paramref name="index"/>. The combined sequence terminates
+    /// once every source has completed OR a source completes without ever having emitted a value.
+    /// </summary>
+    /// <param name="index">The 0-based source index that just completed.</param>
+    public void HandleCompleted(int index)
+    {
+        lock (Gate)
+        {
+            if (IsDone || Completed[index])
+            {
+                return;
+            }
+
+            Completed[index] = true;
+            CompletedCount++;
+
+            if (CompletedCount == Values.Length || !Values[index].HasValue)
+            {
+                IsDone = true;
+                Downstream.OnCompleted();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/ScheduledDrainState.cs b/src/ReactiveUI.Primitives.Extensions/Internal/ScheduledDrainState.cs
new file mode 100644
index 0000000..120ab8a
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/ScheduledDrainState.cs
@@ -0,0 +1,164 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Shared queue-and-single-drain marshaller used by the synchronous scheduler-marshalling operator
+/// sinks (<c>ObserveOn</c>, <c>Conflate</c>). Each of those sinks previously hand-rolled the same gate,
+/// FIFO queue, drain-in-flight flag, terminal flag, enqueue-and-schedule logic, and dequeue loop on top
+/// of identical fields; this helper centralises that machinery so the per-sink class only carries the
+/// operator-specific notification handling. Notifications are enqueued and a single drain pass is
+/// scheduled per burst (rather than one scheduled action per item), and the drain callback carries no
+/// captures — the sink is passed through as an <see cref="IDrainTarget"/>. Sinks compose one instance
+/// and forward to it; there is no base class and no per-item virtual dispatch.
+/// </summary>
+/// <typeparam name="T">The element type carried by <see cref="DrainNotificationKind.Next"/> notifications.</typeparam>
+/// <param name="scheduler">The scheduler each drain pass runs on.</param>
+/// <param name="target">The sink whose <see cref="IDrainTarget.Drain"/> the scheduled pass invokes.</param>
+internal sealed class ScheduledDrainState<T>(ISequencer scheduler, IDrainTarget target)
+{
+    /// <summary>The FIFO queue of pending upstream notifications.</summary>
+    private readonly Queue<Notification> _queue = new();
+
+    /// <summary>Upstream subscription handle, recorded via <see cref="Attach"/> for teardown on dispose.</summary>
+    private IDisposable? _sourceSubscription;
+
+    /// <summary><see langword="true"/> while a drain pass is in flight on the scheduler.</summary>
+    private bool _draining;
+
+    /// <summary><see langword="true"/> once a terminal notification has been delivered or the sink disposed.</summary>
+    private bool _done;
+
+    /// <summary>Gets the gate protecting the queue, drain flag, done flag, and the composing sink's own
+    /// operator-specific state. Sinks lock this directly when guarding their extra fields.</summary>
+    public Lock Gate { get; } = new();
+
+    /// <summary>Gets a value indicating whether the sink has reached a terminal state. Read inside
+    /// <see cref="Gate"/> by callers that need to short-circuit once terminated.</summary>
+    public bool Done => _done;
+
+    /// <summary>Enqueues an OnNext notification and schedules a drain pass if one isn't already running.</summary>
+    /// <param name="value">The value to forward downstream.</param>
+    public void EnqueueNext(T value) => Enqueue(new Notification(DrainNotificationKind.Next, value, null));
+
+    /// <summary>Enqueues an OnError notification and schedules a drain pass if one isn't already running.</summary>
+    /// <param name="error">The error to forward downstream.</param>
+    public void EnqueueError(Exception error) => Enqueue(new Notification(DrainNotificationKind.Error, default!, error));
+
+    /// <summary>Enqueues an OnCompleted notification and schedules a drain pass if one isn't already running.</summary>
+    public void EnqueueCompleted() => Enqueue(new Notification(DrainNotificationKind.Completed, default!, null));
+
+    /// <summary>Records the upstream subscription, or disposes it immediately if the sink is already done.</summary>
+    /// <param name="subscription">The upstream subscription handle.</param>
+    public void Attach(IDisposable subscription)
+    {
+        lock (Gate)
+        {
+            if (!_done)
+            {
+                _sourceSubscription = subscription;
+                return;
+            }
+        }
+
+        subscription.Dispose();
+    }
+
+    /// <summary>Dequeues the next pending notification, clearing the drain flag when the queue empties or
+    /// the sink has terminated.</summary>
+    /// <param name="notification">The dequeued notification when this returns <see langword="true"/>.</param>
+    /// <returns><see langword="true"/> if a notification was dequeued; otherwise <see langword="false"/>.</returns>
+    public bool TryDequeue(out Notification notification)
+    {
+        lock (Gate)
+        {
+            if (_done || _queue.Count == 0)
+            {
+                _draining = false;
+                notification = default;
+                return false;
+            }
+
+            notification = _queue.Dequeue();
+            return true;
+        }
+    }
+
+    /// <summary>Marks the sink terminated and drops any still-queued notifications. Locks <see cref="Gate"/>.</summary>
+    public void Terminate()
+    {
+        lock (Gate)
+        {
+            _done = true;
+            _queue.Clear();
+        }
+    }
+
+    /// <summary>Marks the sink terminated without clearing the queue. Caller must hold <see cref="Gate"/>;
+    /// the still-queued notifications are abandoned because <see cref="TryDequeue"/> checks the done flag first.</summary>
+    public void MarkDoneLocked() => _done = true;
+
+    /// <summary>Begins disposal under <see cref="Gate"/>: marks the sink done, clears the queue, and detaches
+    /// the upstream subscription — returned to the caller so it is disposed outside the gate. Returns
+    /// <see langword="null"/> when already disposed.</summary>
+    /// <returns>The upstream subscription to dispose outside the gate, or <see langword="null"/>.</returns>
+    public IDisposable? BeginDispose()
+    {
+        lock (Gate)
+        {
+            return _done ? null : BeginDisposeLocked();
+        }
+    }
+
+    /// <summary>Marks the sink done, clears the queue, and detaches the upstream subscription, returning it for
+    /// disposal outside the gate. Caller must hold <see cref="Gate"/> and have confirmed <see cref="Done"/> is
+    /// <see langword="false"/>. Lets a composing sink dispose its own scheduled-work slot atomically with the
+    /// done transition under the same lock.</summary>
+    /// <returns>The upstream subscription to dispose outside the gate, or <see langword="null"/>.</returns>
+    public IDisposable? BeginDisposeLocked()
+    {
+        _done = true;
+        _queue.Clear();
+        var subscription = _sourceSubscription;
+        _sourceSubscription = null;
+        return subscription;
+    }
+
+    /// <summary>Enqueues a notification; claims and schedules a single drain pass if one isn't running.</summary>
+    /// <param name="notification">The notification to forward to the drain loop.</param>
+    private void Enqueue(in Notification notification)
+    {
+        lock (Gate)
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            _queue.Enqueue(notification);
+            if (_draining)
+            {
+                return;
+            }
+
+            _draining = true;
+        }
+
+        scheduler.Schedule(target, static (_, drainTarget) =>
+        {
+            drainTarget.Drain();
+            return EmptyDisposable.Instance;
+        });
+    }
+
+    /// <summary>Discriminated notification payload enqueued for the scheduled drain.</summary>
+    /// <param name="Kind">The notification kind.</param>
+    /// <param name="Value">The element carried by <see cref="DrainNotificationKind.Next"/>; default otherwise.</param>
+    /// <param name="Error">The error carried by <see cref="DrainNotificationKind.Error"/>; null otherwise.</param>
+    internal readonly record struct Notification(DrainNotificationKind Kind, T Value, Exception? Error);
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/SequencerPeriodicMixins.cs b/src/ReactiveUI.Primitives.Extensions/Internal/SequencerPeriodicMixins.cs
new file mode 100644
index 0000000..85f2f52
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/SequencerPeriodicMixins.cs
@@ -0,0 +1,154 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Periodic scheduling helpers used by migrated extension operators.
+/// </summary>
+internal static class SequencerPeriodicMixins
+{
+    /// <summary>
+    /// Schedules <paramref name="action"/> repeatedly, starting after <paramref name="period"/>.
+    /// </summary>
+    /// <typeparam name="TState">The state type.</typeparam>
+    /// <param name="scheduler">The scheduler used for each tick.</param>
+    /// <param name="state">The state passed to each tick.</param>
+    /// <param name="period">The period between ticks.</param>
+    /// <param name="action">The tick action.</param>
+    /// <returns>A disposable that cancels future ticks.</returns>
+    public static IDisposable SchedulePeriodic<TState>(
+        this ISequencer scheduler,
+        TState state,
+        TimeSpan period,
+        Action<TState> action) =>
+        SchedulePeriodic(scheduler, state, period, period, action);
+
+    /// <summary>
+    /// Schedules <paramref name="action"/> repeatedly with an explicit first due time.
+    /// </summary>
+    /// <param name="scheduler">The scheduler used for each tick.</param>
+    /// <param name="dueTime">The delay before the first tick.</param>
+    /// <param name="period">The period between ticks.</param>
+    /// <param name="action">The tick action.</param>
+    /// <returns>A disposable that cancels future ticks.</returns>
+    public static IDisposable SchedulePeriodic(
+        this ISequencer scheduler,
+        TimeSpan dueTime,
+        TimeSpan period,
+        Action action) =>
+        SchedulePeriodic(scheduler, action, dueTime, period, static tick => tick());
+
+    /// <summary>
+    /// Schedules a stateful periodic action.
+    /// </summary>
+    /// <typeparam name="TState">The state type.</typeparam>
+    /// <param name="scheduler">The scheduler used for each tick.</param>
+    /// <param name="state">The state passed to each tick.</param>
+    /// <param name="dueTime">The delay before the first tick.</param>
+    /// <param name="period">The period between ticks.</param>
+    /// <param name="action">The tick action.</param>
+    /// <returns>A disposable that cancels future ticks.</returns>
+    private static PeriodicSubscription<TState> SchedulePeriodic<TState>(
+        ISequencer scheduler,
+        TState state,
+        TimeSpan dueTime,
+        TimeSpan period,
+        Action<TState> action)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(action);
+
+        var subscription = new PeriodicSubscription<TState>(scheduler, state, Sequencer.Normalize(period), action);
+        subscription.ScheduleNext(Sequencer.Normalize(dueTime));
+        return subscription;
+    }
+
+    /// <summary>
+    /// Disposable state for one periodic schedule. Internal (rather than private) so coverage tests can
+    /// drive <see cref="Tick"/> directly instead of via reflection.
+    /// </summary>
+    /// <typeparam name="TState">The state type.</typeparam>
+    internal sealed class PeriodicSubscription<TState> : IDisposable
+    {
+        /// <summary>The scheduler used for each tick.</summary>
+        private readonly ISequencer _scheduler;
+
+        /// <summary>The state passed to each tick.</summary>
+        private readonly TState _state;
+
+        /// <summary>The period between ticks.</summary>
+        private readonly TimeSpan _period;
+
+        /// <summary>The tick action.</summary>
+        private readonly Action<TState> _action;
+
+        /// <summary>The current scheduled work.</summary>
+        private readonly SwapDisposable _scheduled = new();
+
+        /// <summary>0 = active, 1 = disposed.</summary>
+        private int _disposed;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PeriodicSubscription{TState}"/> class.
+        /// </summary>
+        /// <param name="scheduler">The scheduler used for each tick.</param>
+        /// <param name="state">The state passed to each tick.</param>
+        /// <param name="period">The period between ticks.</param>
+        /// <param name="action">The tick action.</param>
+        public PeriodicSubscription(ISequencer scheduler, TState state, TimeSpan period, Action<TState> action)
+        {
+            _scheduler = scheduler;
+            _state = state;
+            _period = period;
+            _action = action;
+        }
+
+        /// <summary>
+        /// Schedules the next tick.
+        /// </summary>
+        /// <param name="dueTime">The delay before the tick.</param>
+        public void ScheduleNext(TimeSpan dueTime)
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return;
+            }
+
+            _scheduled.Disposable = _scheduler.Schedule(this, dueTime, static (_, subscription) =>
+            {
+                subscription.Tick();
+                return EmptyDisposable.Instance;
+            });
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            _scheduled.Dispose();
+        }
+
+        /// <summary>
+        /// Runs a tick and schedules the next one when still active.
+        /// </summary>
+        internal void Tick()
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return;
+            }
+
+            _action(_state);
+            ScheduleNext(_period);
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/SingleValueObservable.cs b/src/ReactiveUI.Primitives.Extensions/Internal/SingleValueObservable.cs
new file mode 100644
index 0000000..1805c07
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/SingleValueObservable.cs
@@ -0,0 +1,25 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Synchronously emits a single cached value to each subscriber and completes. Drop-in for
+/// the Rx <c>Observable.Return</c> pattern when sharing the observable instance across calls.
+/// </summary>
+/// <typeparam name="T">The element type.</typeparam>
+/// <param name="value">The value emitted to every subscriber.</param>
+internal sealed class SingleValueObservable<T>(T value) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        observer.OnNext(value);
+        observer.OnCompleted();
+        return EmptyDisposable.Instance;
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Internal/TimerSinkState.cs b/src/ReactiveUI.Primitives.Extensions/Internal/TimerSinkState.cs
new file mode 100644
index 0000000..d90ae87
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Internal/TimerSinkState.cs
@@ -0,0 +1,74 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Internal;
+
+/// <summary>
+/// Shared lock + timer + done-flag triple used by the synchronous timer-driven operator sinks
+/// (Debounce-Until, Detect-Stale, Throttle-Distinct, Buffer-Until-Idle, etc.). Each of those sinks
+/// previously hand-rolled three identical OnError / OnCompleted / Dispose method bodies on top of
+/// the same fields; this helper centralises the bodies so the per-sink class only carries the
+/// operator-specific OnNext logic. Sinks compose one instance and forward to it — no base class.
+/// </summary>
+/// <typeparam name="T">The element type the downstream observer receives.</typeparam>
+/// <param name="downstream">The downstream observer terminal callbacks fan out to.</param>
+internal sealed class TimerSinkState<T>(IObserver<T> downstream)
+{
+    /// <summary>Gets the gate protecting state transitions and downstream notification.</summary>
+    public Lock Gate { get; } = new();
+
+    /// <summary>Gets the timer slot used by the operator's OnNext logic to schedule deferred emissions.</summary>
+    public SwapDisposable Timer { get; } = new();
+
+    /// <summary>
+    /// Gets a value indicating whether the sink has reached a terminal state (OnError, OnCompleted,
+    /// or Dispose). Read inside the gate by callers that need to short-circuit a deferred operation.
+    /// </summary>
+    public bool Done { get; private set; }
+
+    /// <summary>Forwards a terminal error to the downstream observer and tears the sink down.</summary>
+    /// <param name="error">The error to forward.</param>
+    public void HandleError(Exception error)
+    {
+        lock (Gate)
+        {
+            if (Done)
+            {
+                return;
+            }
+
+            Done = true;
+            Timer.Dispose();
+            downstream.OnError(error);
+        }
+    }
+
+    /// <summary>Forwards completion to the downstream observer and tears the sink down.</summary>
+    public void HandleCompleted()
+    {
+        lock (Gate)
+        {
+            if (Done)
+            {
+                return;
+            }
+
+            Done = true;
+            Timer.Dispose();
+            downstream.OnCompleted();
+        }
+    }
+
+    /// <summary>Marks the sink terminal and disposes the timer without forwarding a notification.</summary>
+    public void HandleDispose()
+    {
+        lock (Gate)
+        {
+            Done = true;
+            Timer.Dispose();
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/ObservableSubscriptionExtensions.cs b/src/ReactiveUI.Primitives.Extensions/ObservableSubscriptionExtensions.cs
new file mode 100644
index 0000000..dcb1b47
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/ObservableSubscriptionExtensions.cs
@@ -0,0 +1,425 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Provides extension methods for subscribing to and handling reactive sequences
+/// in a synchronous or blocking manner. These methods offer utility functions
+/// to retrieve emitted values, handle completion, and capture errors from observables.
+/// </summary>
+public static class ObservableSubscriptionExtensions
+{
+    /// <summary>The default timeout used by the <c>WaitFor*</c> helpers when no override is supplied.</summary>
+    private static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(30);
+
+    /// <summary>
+    /// Subscribes to <paramref name="source"/> and returns the last value emitted during
+    /// the synchronous <see cref="IObservable{T}.Subscribe(IObserver{T})"/> call.
+    /// </summary>
+    /// <typeparam name="T">The element type of <paramref name="source"/>.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <returns>The last emitted value, or <see langword="default"/> if no value was emitted.</returns>
+    public static T? SubscribeGetValue<T>(this IObservable<T> source)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        var sink = new ValueCaptureObserver<T>();
+        using var subscription = source.Subscribe(sink);
+        return sink.Value;
+    }
+
+    /// <summary>
+    /// Subscribes to a <see cref="RxVoid"/>-producing observable, discarding the value.
+    /// Safe only when the sequence terminates synchronously.
+    /// </summary>
+    /// <param name="source">The observable to subscribe to.</param>
+    public static void SubscribeAndComplete(this IObservable<RxVoid> source)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        using var subscription = source.Subscribe(NoopObserver<RxVoid>.Instance);
+    }
+
+    /// <summary>
+    /// Subscribes to <paramref name="source"/> and returns any error emitted during the
+    /// synchronous <see cref="IObservable{T}.Subscribe(IObserver{T})"/> call.
+    /// </summary>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <returns>The captured error, or <see langword="null"/> if none.</returns>
+    public static Exception? SubscribeGetError(this IObservable<RxVoid> source) =>
+        SubscribeGetError<RxVoid>(source);
+
+    /// <summary>
+    /// Subscribes to <paramref name="source"/> and returns any error emitted during the
+    /// synchronous <see cref="IObservable{T}.Subscribe(IObserver{T})"/> call.
+    /// </summary>
+    /// <typeparam name="T">The element type of <paramref name="source"/>.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <returns>The captured error, or <see langword="null"/> if none.</returns>
+    public static Exception? SubscribeGetError<T>(this IObservable<T> source)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        var sink = new ErrorCaptureObserver<T>();
+        using var subscription = source.Subscribe(sink);
+        return sink.Error;
+    }
+
+    /// <summary>
+    /// Blocks until <paramref name="source"/> emits a value, errors, or completes
+    /// (default 30s timeout).
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <returns>The last value emitted before terminal, or <see langword="default"/> if the sequence completed empty.</returns>
+    /// <exception cref="TimeoutException">The sequence did not terminate in time.</exception>
+    public static T? WaitForValue<T>(this IObservable<T> source) =>
+        WaitForValueCore(source, null, DefaultTimeout);
+
+    /// <summary>
+    /// Blocks until <paramref name="source"/> emits a value, errors, or completes,
+    /// honoring an explicit <paramref name="timeout"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    /// <returns>The last value emitted before terminal, or <see langword="default"/> if the sequence completed empty.</returns>
+    /// <exception cref="TimeoutException">The sequence did not terminate within <paramref name="timeout"/>.</exception>
+    public static T? WaitForValue<T>(this IObservable<T> source, TimeSpan timeout) =>
+        WaitForValueCore(source, null, timeout);
+
+    /// <summary>
+    /// Blocks until <paramref name="source"/> emits a value, errors, or completes,
+    /// routing the subscribe call through <paramref name="scheduler"/> (default 30s timeout).
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="scheduler">Scheduler used to dispatch the subscribe call.</param>
+    /// <returns>The last value emitted before terminal, or <see langword="default"/> if the sequence completed empty.</returns>
+    /// <exception cref="TimeoutException">The sequence did not terminate in time.</exception>
+    public static T? WaitForValue<T>(this IObservable<T> source, ISequencer scheduler) =>
+        WaitForValueCore(source, scheduler, DefaultTimeout);
+
+    /// <summary>
+    /// Blocks until <paramref name="source"/> emits a value, errors, or completes,
+    /// routing the subscribe call through <paramref name="scheduler"/> with an explicit
+    /// <paramref name="timeout"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="scheduler">Scheduler used to dispatch the subscribe call.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    /// <returns>The last value emitted before terminal, or <see langword="default"/> if the sequence completed empty.</returns>
+    /// <exception cref="TimeoutException">The sequence did not terminate within <paramref name="timeout"/>.</exception>
+    public static T? WaitForValue<T>(this IObservable<T> source, ISequencer scheduler, TimeSpan timeout) =>
+        WaitForValueCore(source, scheduler, timeout);
+
+    /// <summary>
+    /// Blocks until a <see cref="RxVoid"/>-producing <paramref name="source"/> completes
+    /// (default 30s timeout); rethrows any captured error.
+    /// </summary>
+    /// <param name="source">The observable to subscribe to.</param>
+    public static void WaitForCompletion(this IObservable<RxVoid> source) =>
+        WaitForCompletionCore(source, null, DefaultTimeout);
+
+    /// <summary>
+    /// Blocks until a <see cref="RxVoid"/>-producing <paramref name="source"/> completes,
+    /// honoring an explicit <paramref name="timeout"/>; rethrows any captured error.
+    /// </summary>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    public static void WaitForCompletion(this IObservable<RxVoid> source, TimeSpan timeout) =>
+        WaitForCompletionCore(source, null, timeout);
+
+    /// <summary>
+    /// Blocks until a <see cref="RxVoid"/>-producing <paramref name="source"/> completes,
+    /// routing the subscribe call through <paramref name="scheduler"/>; rethrows any captured error.
+    /// </summary>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="scheduler">Scheduler used to dispatch the subscribe call.</param>
+    public static void WaitForCompletion(this IObservable<RxVoid> source, ISequencer scheduler) =>
+        WaitForCompletionCore(source, scheduler, DefaultTimeout);
+
+    /// <summary>
+    /// Blocks until a <see cref="RxVoid"/>-producing <paramref name="source"/> completes,
+    /// routing the subscribe call through <paramref name="scheduler"/> with an explicit
+    /// <paramref name="timeout"/>; rethrows any captured error.
+    /// </summary>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="scheduler">Scheduler used to dispatch the subscribe call.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    public static void WaitForCompletion(this IObservable<RxVoid> source, ISequencer scheduler, TimeSpan timeout) =>
+        WaitForCompletionCore(source, scheduler, timeout);
+
+    /// <summary>
+    /// Blocks until <paramref name="source"/> terminates; returns any captured error
+    /// (does NOT rethrow). Default 30s timeout.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <returns>The captured error, or <see langword="null"/> if completion was normal.</returns>
+    public static Exception? WaitForError<T>(this IObservable<T> source) =>
+        WaitForErrorCore(source, null, DefaultTimeout);
+
+    /// <summary>
+    /// Blocks until <paramref name="source"/> terminates with an explicit <paramref name="timeout"/>;
+    /// returns any captured error (does NOT rethrow).
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    /// <returns>The captured error, or <see langword="null"/> if completion was normal.</returns>
+    public static Exception? WaitForError<T>(this IObservable<T> source, TimeSpan timeout) =>
+        WaitForErrorCore(source, null, timeout);
+
+    /// <summary>
+    /// Blocks until <paramref name="source"/> terminates, routing the subscribe call
+    /// through <paramref name="scheduler"/>; returns any captured error (does NOT rethrow).
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="scheduler">Scheduler used to dispatch the subscribe call.</param>
+    /// <returns>The captured error, or <see langword="null"/> if completion was normal.</returns>
+    public static Exception? WaitForError<T>(this IObservable<T> source, ISequencer scheduler) =>
+        WaitForErrorCore(source, scheduler, DefaultTimeout);
+
+    /// <summary>
+    /// Blocks until <paramref name="source"/> terminates, routing the subscribe call
+    /// through <paramref name="scheduler"/> with an explicit <paramref name="timeout"/>;
+    /// returns any captured error (does NOT rethrow).
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="scheduler">Scheduler used to dispatch the subscribe call.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    /// <returns>The captured error, or <see langword="null"/> if completion was normal.</returns>
+    public static Exception? WaitForError<T>(this IObservable<T> source, ISequencer scheduler, TimeSpan timeout) =>
+        WaitForErrorCore(source, scheduler, timeout);
+
+    /// <summary>Shared implementation of <see cref="WaitForValue{T}(IObservable{T})"/> and its overloads.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="scheduler">Optional scheduler for the subscribe call.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    /// <returns>The last value emitted before terminal, or <see langword="default"/>.</returns>
+    private static T? WaitForValueCore<T>(IObservable<T> source, ISequencer? scheduler, TimeSpan timeout)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        using ManualResetEventSlim done = new();
+        var sink = new BlockingValueObserver<T>(done);
+        using var subscription = ScheduledSubscribe(source, sink, scheduler);
+
+        if (!done.Wait(timeout))
+        {
+            throw new TimeoutException(
+                $"WaitForValue timed out after {timeout.TotalSeconds}s.");
+        }
+
+        return sink.Result;
+    }
+
+    /// <summary>Shared implementation of <see cref="WaitForCompletion(IObservable{RxVoid})"/> and its overloads.</summary>
+    /// <param name="source">The source observable.</param>
+    /// <param name="scheduler">Optional scheduler for the subscribe call.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    private static void WaitForCompletionCore(IObservable<RxVoid> source, ISequencer? scheduler, TimeSpan timeout)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        using ManualResetEventSlim done = new();
+        var sink = new BlockingTerminalObserver<RxVoid>(done);
+        using var subscription = ScheduledSubscribe(source, sink, scheduler);
+
+        if (!done.Wait(timeout))
+        {
+            throw new TimeoutException(
+                $"WaitForCompletion timed out after {timeout.TotalSeconds}s.");
+        }
+
+        if (sink.Error is null)
+        {
+            return;
+        }
+
+        throw sink.Error;
+    }
+
+    /// <summary>Shared implementation of <see cref="WaitForError{T}(IObservable{T})"/> and its overloads.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="scheduler">Optional scheduler for the subscribe call.</param>
+    /// <param name="timeout">The wait timeout.</param>
+    /// <returns>The captured error, or <see langword="null"/>.</returns>
+    private static Exception? WaitForErrorCore<T>(IObservable<T> source, ISequencer? scheduler, TimeSpan timeout)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        using ManualResetEventSlim done = new();
+        var sink = new BlockingTerminalObserver<T>(done);
+        using var subscription = ScheduledSubscribe(source, sink, scheduler);
+
+        if (!done.Wait(timeout))
+        {
+            throw new TimeoutException(
+                $"WaitForError timed out after {timeout.TotalSeconds}s.");
+        }
+
+        return sink.Error;
+    }
+
+    /// <summary>
+    /// Subscribes to the specified <paramref name="source"/> observable using the provided <paramref name="scheduler"/>.
+    /// If a scheduler is specified, the subscription is scheduled; otherwise, the subscription occurs immediately.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in <paramref name="source"/>.</typeparam>
+    /// <param name="source">The observable to subscribe to.</param>
+    /// <param name="observer">The observer to receive notifications from the observable.</param>
+    /// <param name="scheduler">
+    /// The scheduler on which to execute the subscription logic. If <see langword="null"/>, the subscription occurs directly without scheduling.
+    /// </param>
+    /// <returns>A disposable representing the subscription.</returns>
+    private static IDisposable ScheduledSubscribe<T>(
+        IObservable<T> source,
+        IObserver<T> observer,
+        ISequencer? scheduler)
+    {
+        if (scheduler is null)
+        {
+            return source.Subscribe(observer);
+        }
+
+        var swap = new SwapDisposable();
+        var scheduled = scheduler.Schedule(() => swap.Disposable = source.Subscribe(observer));
+        return new DisposableBag(scheduled, swap);
+    }
+
+    /// <summary>
+    /// No-op observer used by <see cref="SubscribeAndComplete"/> to absorb signals
+    /// without allocating a delegate trio.
+    /// </summary>
+    /// <typeparam name="T">The element type of the source.</typeparam>
+    private sealed class NoopObserver<T> : IObserver<T>
+    {
+        /// <summary>Singleton instance to avoid per-call allocation.</summary>
+        public static readonly NoopObserver<T> Instance = new();
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+        }
+    }
+
+    /// <summary>Observer that captures the last value seen during synchronous subscribe.</summary>
+    /// <typeparam name="T">The element type of the source.</typeparam>
+    private sealed class ValueCaptureObserver<T> : IObserver<T>
+    {
+        /// <summary>Gets the captured value, or <see langword="default"/> if none.</summary>
+        public T? Value { get; private set; }
+
+        /// <summary>Gets a value indicating whether at least one value was observed.</summary>
+        public bool HasValue { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            Value = value;
+            HasValue = true;
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+        }
+    }
+
+    /// <summary>Observer that captures the first error seen during synchronous subscribe.</summary>
+    /// <typeparam name="T">The element type of the source.</typeparam>
+    private sealed class ErrorCaptureObserver<T> : IObserver<T>
+    {
+        /// <summary>Gets the captured error, or <see langword="null"/> if none.</summary>
+        public Exception? Error { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => Error ??= error;
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+        }
+    }
+
+    /// <summary>
+    /// Observer used by the value-returning <c>WaitFor</c> path: captures the last value,
+    /// signals the gate on terminal, swallows errors (caller's timeout / default reflects outcome).
+    /// </summary>
+    /// <typeparam name="T">The element type of the source.</typeparam>
+    /// <param name="done">The gate signalled on terminal.</param>
+    private sealed class BlockingValueObserver<T>(ManualResetEventSlim done) : IObserver<T>
+    {
+        /// <summary>Gets the most recent value seen.</summary>
+        public T? Result { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => Result = value;
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => done.Set();
+
+        /// <inheritdoc/>
+        public void OnCompleted() => done.Set();
+    }
+
+    /// <summary>
+    /// Observer used by the completion / error <c>WaitFor</c> paths: captures any
+    /// terminal error and signals the gate on terminal.
+    /// </summary>
+    /// <typeparam name="T">The element type of the source.</typeparam>
+    /// <param name="done">The gate signalled on terminal.</param>
+    private sealed class BlockingTerminalObserver<T>(ManualResetEventSlim done) : IObserver<T>
+    {
+        /// <summary>Gets the captured terminal error, or <see langword="null"/> if completion was normal.</summary>
+        public Exception? Error { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            Error = error;
+            done.Set();
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => done.Set();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Observables.cs b/src/ReactiveUI.Primitives.Extensions/Observables.cs
new file mode 100644
index 0000000..77664c3
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Observables.cs
@@ -0,0 +1,24 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Factory methods that build <see cref="IObservable{T}"/> instances. The plural name avoids
+/// resolution collisions with other observable factory types at call sites that import multiple
+/// reactive namespaces.
+/// </summary>
+public static class Observables
+{
+    /// <summary>
+    /// Returns an observable sequence that emits a single value and completes synchronously inside
+    /// <see cref="IObservable{T}.Subscribe"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="value">The value emitted to every subscriber.</param>
+    /// <returns>An observable that emits <paramref name="value"/> and completes on subscribe.</returns>
+    public static IObservable<T> Return<T>(T value) => new SingleValueObservable<T>(value);
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/ObserverExtensions.cs b/src/ReactiveUI.Primitives.Extensions/ObserverExtensions.cs
new file mode 100644
index 0000000..550bbd2
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/ObserverExtensions.cs
@@ -0,0 +1,74 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Extension methods for <see cref="IObserver{T}"/>.
+/// </summary>
+public static class ObserverExtensions
+{
+    /// <summary>
+    /// Emits each element from <paramref name="source"/> to <paramref name="observer"/>
+    /// via <see cref="IObserver{T}.OnNext(T)"/> using a fast-path iteration for known
+    /// concrete collection types (<see cref="List{T}"/>, arrays, <see cref="IList{T}"/>).
+    /// Avoids the per-iteration enumerator allocation that <c>foreach</c> over a bare
+    /// <see cref="IEnumerable{T}"/> would incur on these common shapes.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the source collection.</typeparam>
+    /// <param name="observer">The observer to emit elements to.</param>
+    /// <param name="source">The source collection to iterate.</param>
+    public static void FastForEach<T>(this IObserver<T> observer, IEnumerable<T> source)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        if (source is T[] array)
+        {
+            for (var i = 0; i < array.Length; i++)
+            {
+                observer.OnNext(array[i]);
+            }
+
+            return;
+        }
+
+        if (source is List<T> fullList)
+        {
+            for (var i = 0; i < fullList.Count; i++)
+            {
+                observer.OnNext(fullList[i]);
+            }
+
+            return;
+        }
+
+        if (source is IList<T> list)
+        {
+            for (var i = 0; i < list.Count; i++)
+            {
+                observer.OnNext(list[i]);
+            }
+
+            return;
+        }
+
+        if (source is IReadOnlyList<T> readOnlyList)
+        {
+            for (var i = 0; i < readOnlyList.Count; i++)
+            {
+                observer.OnNext(readOnlyList[i]);
+            }
+
+            return;
+        }
+
+        foreach (var item in source)
+        {
+            observer.OnNext(item);
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/AsSignalObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/AsSignalObservable.cs
new file mode 100644
index 0000000..c5e705a
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/AsSignalObservable.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Projection operator that emits <see cref="RxVoid.Default"/> for every source
+/// element. Replaces the <c>source.Select(_ =&gt; RxVoid.Default)</c> pattern,
+/// avoiding the per-subscription closure allocation that the projection lambda
+/// would otherwise capture.
+/// </summary>
+/// <typeparam name="T">The element type of the source observable (ignored).</typeparam>
+/// <param name="source">The source observable whose values are ignored.</param>
+internal sealed class AsSignalObservable<T>(IObservable<T> source) : IObservable<RxVoid>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<RxVoid> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new AsSignalObserver(observer));
+    }
+
+    /// <summary>
+    /// Forwarding observer that replaces every <see cref="OnNext"/> value with
+    /// <see cref="RxVoid.Default"/>. Error and completion signals pass through unchanged.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class AsSignalObserver(IObserver<RxVoid> downstream) : IObserver<T>
+    {
+        /// <inheritdoc/>
+        public void OnNext(T value) => downstream.OnNext(RxVoid.Default);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/BooleanReduceObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/BooleanReduceObservable.cs
new file mode 100644
index 0000000..c2f716f
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/BooleanReduceObservable.cs
@@ -0,0 +1,141 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Combines the latest boolean values from multiple sources and emits <c>true</c> iff every latest
+/// value equals <paramref name="target"/>. Backs both <c>AllTrue</c> (target=true) and <c>AllFalse</c>
+/// (target=false) without the array allocations a generic <c>CombineLatest(...).Select(xs =&gt; xs.All(...))</c>
+/// pipeline would incur.
+/// </summary>
+/// <param name="sources">The source observables.</param>
+/// <param name="target">The value every source must hold for the operator to emit <c>true</c>.</param>
+internal sealed class BooleanReduceObservable(IEnumerable<IObservable<bool>> sources, bool target) : IObservable<bool>
+{
+    /// <summary>The source list.</summary>
+    private readonly IReadOnlyList<IObservable<bool>> _sourceList = MaterializeSources(sources);
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<bool> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        if (_sourceList.Count == 0)
+        {
+            observer.OnNext(true);
+            observer.OnCompleted();
+            return EmptyDisposable.Instance;
+        }
+
+        var sink = new Sink(observer, _sourceList.Count, target);
+        return IndexedSubscribeHelper.SubscribeIndexed(_sourceList, sink.OnNext, sink.OnError, sink.OnCompleted);
+    }
+
+    /// <summary>Materializes source enumeration once without using LINQ in shipping code.</summary>
+    /// <param name="sources">The sources to materialize.</param>
+    /// <returns>The source list.</returns>
+    private static IReadOnlyList<IObservable<bool>> MaterializeSources(IEnumerable<IObservable<bool>> sources)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(sources);
+
+        if (sources is IReadOnlyList<IObservable<bool>> readOnlyList)
+        {
+            return readOnlyList;
+        }
+
+        if (sources is ICollection<IObservable<bool>> collection)
+        {
+            var materialized = new IObservable<bool>[collection.Count];
+            collection.CopyTo(materialized, 0);
+            return materialized;
+        }
+
+        var buffer = Array.Empty<IObservable<bool>>();
+        var count = 0;
+        foreach (var source in sources)
+        {
+            if (count == buffer.Length)
+            {
+                var grown = new IObservable<bool>[buffer.Length == 0 ? 4 : buffer.Length * 2];
+                Array.Copy(buffer, grown, count);
+                buffer = grown;
+            }
+
+            buffer[count++] = source;
+        }
+
+        if (count == buffer.Length)
+        {
+            return buffer;
+        }
+
+        var trimmed = new IObservable<bool>[count];
+        Array.Copy(buffer, trimmed, count);
+        return trimmed;
+    }
+
+    /// <summary>
+    /// Sink that holds the latest value per source and reduces them against <paramref name="target"/>.
+    /// Composes <see cref="ReduceSinkState{TIn, TOut}"/> for the shared gate / value cache / OnError /
+    /// OnCompleted plumbing so this class carries only the per-operator reduce step.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="count">The number of sources.</param>
+    /// <param name="target">The value every source must hold for emit to be <c>true</c>.</param>
+    private sealed class Sink(IObserver<bool> downstream, int count, bool target)
+    {
+        /// <summary>Shared gate / value cache / terminal-state plumbing.</summary>
+        private readonly ReduceSinkState<bool, bool> _state = new(downstream, count);
+
+        /// <summary>Handles OnNext from a source.</summary>
+        /// <param name="index">Source index.</param>
+        /// <param name="value">Emitted value.</param>
+        public void OnNext(int index, bool value)
+        {
+            lock (_state.Gate)
+            {
+                if (_state.IsDone)
+                {
+                    return;
+                }
+
+                if (!_state.Values[index].HasValue)
+                {
+                    _state.HasValueCount++;
+                }
+
+                _state.Values[index] = value;
+
+                if (!_state.AllValuesPresent)
+                {
+                    return;
+                }
+
+                var matches = true;
+                for (var i = 0; i < _state.Values.Length; i++)
+                {
+                    if (_state.Values[i] != target)
+                    {
+                        matches = false;
+                        break;
+                    }
+                }
+
+                _state.Downstream.OnNext(matches);
+            }
+        }
+
+        /// <summary>Handles OnError from any source.</summary>
+        /// <param name="error">The error.</param>
+        public void OnError(Exception error) => _state.HandleError(error);
+
+        /// <summary>Handles OnCompleted from a source.</summary>
+        /// <param name="index">Source index.</param>
+        public void OnCompleted(int index) => _state.HandleCompleted(index);
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/BufferUntilIdleObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/BufferUntilIdleObservable.cs
new file mode 100644
index 0000000..7924520
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/BufferUntilIdleObservable.cs
@@ -0,0 +1,110 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Buffers elements and emits them when the stream has been idle for a specified duration. Backs both
+/// the <c>BufferUntilIdle</c> and <c>BufferUntilInactive</c> public operators.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="idleTime">The duration of inactivity required to flush the buffer.</param>
+/// <param name="scheduler">The scheduler to run the idle timer on.</param>
+internal sealed class BufferUntilIdleObservable<T>(
+    IObservable<T> source,
+    TimeSpan idleTime,
+    ISequencer scheduler) : IObservable<IList<T>>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<IList<T>> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new BufferUntilIdleSink(observer, idleTime, scheduler);
+        var subscription = source.Subscribe(sink);
+        return new DisposableBag(subscription, sink);
+    }
+
+    /// <summary>
+    /// Sink that manages the buffer and idle timer. Composes <see cref="TimerSinkState{T}"/> for
+    /// the shared gate / timer / done-flag plumbing so this class only carries the buffer logic.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="idleTime">The idle time period.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    private sealed class BufferUntilIdleSink(
+        IObserver<IList<T>> downstream,
+        TimeSpan idleTime,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>Shared gate / timer / done-flag plumbing.</summary>
+        private readonly TimerSinkState<IList<T>> _state = new(downstream);
+
+        /// <summary>The current buffer of elements.</summary>
+        private List<T> _buffer = [];
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    return;
+                }
+
+                _buffer.Add(value);
+                ScheduleFlush();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            Flush();
+            _state.HandleError(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            Flush();
+            _state.HandleCompleted();
+        }
+
+        /// <inheritdoc/>
+        public void Dispose() => _state.HandleDispose();
+
+        /// <summary>Schedules a flush after the idle period.</summary>
+        private void ScheduleFlush() => _state.Timer.Disposable = scheduler.Schedule(idleTime, Flush);
+
+        /// <summary>Flushes the current buffer to the downstream observer.</summary>
+        private void Flush()
+        {
+            List<T>? toEmit = null;
+            lock (_state.Gate)
+            {
+                if (_buffer.Count > 0)
+                {
+                    toEmit = _buffer;
+                    _buffer = [];
+                }
+            }
+
+            if (toEmit is null)
+            {
+                return;
+            }
+
+            downstream.OnNext(toEmit);
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/BufferUntilObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/BufferUntilObservable.cs
new file mode 100644
index 0000000..35ce50b
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/BufferUntilObservable.cs
@@ -0,0 +1,85 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Text;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Operator that buffers characters until a start and end delimiter are found.
+/// </summary>
+/// <param name="source">The source observable of characters.</param>
+/// <param name="startsWith">The starting delimiter.</param>
+/// <param name="endsWith">The ending delimiter.</param>
+internal sealed class BufferUntilObservable(
+    IObservable<char> source,
+    char startsWith,
+    char endsWith) : IObservable<string>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<string> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new BufferUntilObserver(observer, startsWith, endsWith));
+    }
+
+    /// <summary>
+    /// Observer that buffers characters until delimiters are matched.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="startsWith">Start char.</param>
+    /// <param name="endsWith">End char.</param>
+    private sealed class BufferUntilObserver(
+        IObserver<string> downstream,
+        char startsWith,
+        char endsWith) : IObserver<char>
+    {
+        /// <summary>
+        /// The string builder.
+        /// </summary>
+        private readonly StringBuilder _sb = new();
+
+        /// <summary>
+        /// Whether the start delimiter has been found.
+        /// </summary>
+        private bool _startFound;
+
+        /// <inheritdoc/>
+        public void OnNext(char value)
+        {
+            if (!_startFound && value != startsWith)
+            {
+                return;
+            }
+
+            _startFound = true;
+            _sb.Append(value);
+
+            if (value != endsWith)
+            {
+                return;
+            }
+
+            downstream.OnNext(_sb.ToString());
+            _startFound = false;
+            _sb.Clear();
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            if (_startFound && _sb.Length > 0)
+            {
+                downstream.OnNext(_sb.ToString());
+            }
+
+            downstream.OnCompleted();
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/CachedObservables.cs b/src/ReactiveUI.Primitives.Extensions/Operators/CachedObservables.cs
new file mode 100644
index 0000000..495fc1f
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/CachedObservables.cs
@@ -0,0 +1,18 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Shared, cached observable singletons for frequently emitted trivial values.
+/// </summary>
+public static class CachedObservables
+{
+    /// <summary>
+    /// Gets a cached observable that synchronously emits a single <see cref="RxVoid.Default"/> and completes.
+    /// </summary>
+    public static IObservable<RxVoid> UnitDefault { get; } = new SingleValueObservable<RxVoid>(RxVoid.Default);
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/CatchAndReturnWithFactoryObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/CatchAndReturnWithFactoryObservable.cs
new file mode 100644
index 0000000..8428037
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/CatchAndReturnWithFactoryObservable.cs
@@ -0,0 +1,72 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Catches the configured exception type, emits a fallback built from the exception, and completes.
+/// Other exception types propagate downstream.
+/// </summary>
+/// <typeparam name="T">Element type.</typeparam>
+/// <typeparam name="TException">Exception type to catch.</typeparam>
+/// <param name="source">Upstream source.</param>
+/// <param name="fallbackFactory">Builds the fallback from the caught exception.</param>
+internal sealed class CatchAndReturnWithFactoryObservable<T, TException>(
+    IObservable<T> source,
+    Func<TException, T> fallbackFactory) : IObservable<T>
+    where TException : Exception
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(fallbackFactory);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new CatchAndReturnWithFactoryObserver(observer, fallbackFactory));
+    }
+
+    /// <summary>
+    /// Forwarding observer that passes <see cref="OnNext"/> / <see cref="OnCompleted"/>
+    /// through and converts a matching <see cref="OnError"/> into an inline emit of the
+    /// factory-produced fallback followed by terminal <see cref="IObserver{T}.OnCompleted"/>.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="fallbackFactory">The fallback factory.</param>
+    private sealed class CatchAndReturnWithFactoryObserver(
+        IObserver<T> downstream,
+        Func<TException, T> fallbackFactory) : IObserver<T>
+    {
+        /// <inheritdoc/>
+        public void OnNext(T value) => downstream.OnNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            if (error is not TException typed)
+            {
+                downstream.OnError(error);
+                return;
+            }
+
+            T fallback;
+            try
+            {
+                fallback = fallbackFactory(typed);
+            }
+            catch (Exception factoryError)
+            {
+                downstream.OnError(factoryError);
+                return;
+            }
+
+            downstream.OnNext(fallback);
+            downstream.OnCompleted();
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/CatchIgnoreEmptyObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/CatchIgnoreEmptyObservable.cs
new file mode 100644
index 0000000..e3a5a64
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/CatchIgnoreEmptyObservable.cs
@@ -0,0 +1,41 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Forwards source values; on any source error, swallows it and completes silently.
+/// </summary>
+/// <typeparam name="T">Element type.</typeparam>
+/// <param name="source">Upstream source.</param>
+internal sealed class CatchIgnoreEmptyObservable<T>(IObservable<T> source) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new CatchIgnoreEmptyObserver(observer));
+    }
+
+    /// <summary>
+    /// Forwarding observer that passes <see cref="OnNext"/> / <see cref="OnCompleted"/>
+    /// through and replaces <see cref="OnError"/> with terminal
+    /// <see cref="IObserver{T}.OnCompleted"/>.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class CatchIgnoreEmptyObserver(IObserver<T> downstream) : IObserver<T>
+    {
+        /// <inheritdoc/>
+        public void OnNext(T value) => downstream.OnNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnCompleted();
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/CatchIgnoreObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/CatchIgnoreObservable.cs
new file mode 100644
index 0000000..84960ef
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/CatchIgnoreObservable.cs
@@ -0,0 +1,76 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Operator that catches exceptions of a specific type and completes.
+/// </summary>
+/// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+/// <typeparam name="TException">The type of the exception to catch.</typeparam>
+/// <param name="source">The source observable sequence.</param>
+/// <param name="errorAction">Action to invoke when an exception of type <typeparamref name="TException"/> occurs.</param>
+internal sealed class CatchIgnoreObservable<TSource, TException>(
+    IObservable<TSource> source,
+    Action<TException> errorAction) : IObservable<TSource>
+    where TException : Exception
+{
+    /// <summary>
+    /// The source observable.
+    /// </summary>
+    private readonly IObservable<TSource> _source = InvalidOperationExceptionHelper.Check(source);
+
+    /// <summary>
+    /// The action to invoke when an exception occurs.
+    /// </summary>
+    private readonly Action<TException> _errorAction = InvalidOperationExceptionHelper.Check(errorAction);
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TSource> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return _source.Subscribe(new CatchIgnoreObserver(observer, _errorAction));
+    }
+
+    /// <summary>
+    /// Observer that catches specific exceptions.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="errorAction">The error action.</param>
+    private sealed class CatchIgnoreObserver(
+        IObserver<TSource> downstream,
+        Action<TException> errorAction) : IObserver<TSource>
+    {
+        /// <inheritdoc/>
+        public void OnNext(TSource value) => downstream.OnNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            if (error is TException ex)
+            {
+                try
+                {
+                    errorAction(ex);
+                }
+                catch (Exception actionEx)
+                {
+                    downstream.OnError(actionEx);
+                    return;
+                }
+
+                downstream.OnCompleted();
+            }
+            else
+            {
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/CatchReturnObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/CatchReturnObservable.cs
new file mode 100644
index 0000000..4ac24ad
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/CatchReturnObservable.cs
@@ -0,0 +1,47 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Forwards source values; on any source error, emits the stored fallback then completes.
+/// </summary>
+/// <typeparam name="T">Element type.</typeparam>
+/// <param name="source">Upstream source.</param>
+/// <param name="fallback">Value emitted on the error path.</param>
+internal sealed class CatchReturnObservable<T>(IObservable<T> source, T fallback) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new CatchReturnObserver(observer, fallback));
+    }
+
+    /// <summary>
+    /// Forwarding observer that passes <see cref="OnNext"/>/<see cref="OnCompleted"/>
+    /// through and replaces <see cref="OnError"/> with an inline emit of the stored
+    /// fallback followed by terminal <see cref="IObserver{T}.OnCompleted"/>.
+    /// </summary>
+    /// <param name="downstream">The downstream observer receiving the forwarded signals.</param>
+    /// <param name="fallback">The fallback value to emit when the source errors.</param>
+    private sealed class CatchReturnObserver(IObserver<T> downstream, T fallback) : IObserver<T>
+    {
+        /// <inheritdoc/>
+        public void OnNext(T value) => downstream.OnNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            downstream.OnNext(fallback);
+            downstream.OnCompleted();
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ConflateObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ConflateObservable.cs
new file mode 100644
index 0000000..43d22ab
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ConflateObservable.cs
@@ -0,0 +1,263 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Conflates an observable stream by delaying updates that occur within a minimum period.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="minimumUpdatePeriod">The minimum period between emissions.</param>
+/// <param name="scheduler">The scheduler to run the conflation on.</param>
+internal sealed class ConflateObservable<T>(
+    IObservable<T> source,
+    TimeSpan minimumUpdatePeriod,
+    ISequencer scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new ConflateSink(observer, minimumUpdatePeriod, scheduler);
+        sink.AttachSourceSubscription(source.Subscribe(sink));
+        return sink;
+    }
+
+    /// <summary>
+    /// Single observer that combines two previously-distinct concerns into one allocation:
+    /// (1) marshals upstream notifications onto the scheduler thread — delegated to the shared
+    /// <see cref="ScheduledDrainState{T}"/> FIFO queue and scheduled drain — and (2) applies the conflate
+    /// time-window throttle to each <see cref="DrainNotificationKind.Next"/> notification. End-user-observable
+    /// semantics are unchanged from the prior two-observer implementation.
+    /// </summary>
+    internal sealed class ConflateSink : IObserver<T>, IDisposable, IDrainTarget
+    {
+        /// <summary>The downstream observer.</summary>
+        private readonly IObserver<T> _downstream;
+
+        /// <summary>The minimum period between emissions.</summary>
+        private readonly TimeSpan _minimumUpdatePeriod;
+
+        /// <summary>The scheduler to run the conflation on.</summary>
+        private readonly ISequencer _scheduler;
+
+        /// <summary>Shared queue / gate / scheduled-drain machinery.</summary>
+        private readonly ScheduledDrainState<T> _state;
+
+        /// <summary>The disposable tracking a scheduled deferred emission.</summary>
+        private readonly MutableDisposable _updateScheduled = new();
+
+        /// <summary>Wall-clock timestamp of the last emission forwarded downstream.</summary>
+        private DateTimeOffset _lastUpdateTime = DateTimeOffset.MinValue;
+
+        /// <summary><see langword="true"/> when an upstream OnCompleted is queued but a deferred
+        /// emission is still pending; the completion fires after that emission lands.</summary>
+        private bool _completionRequested;
+
+        /// <summary>Initializes a new instance of the <see cref="ConflateSink"/> class.</summary>
+        /// <param name="downstream">The downstream observer.</param>
+        /// <param name="minimumUpdatePeriod">The minimum period between emissions.</param>
+        /// <param name="scheduler">The scheduler to run the conflation on.</param>
+        public ConflateSink(IObserver<T> downstream, TimeSpan minimumUpdatePeriod, ISequencer scheduler)
+        {
+            _downstream = downstream;
+            _minimumUpdatePeriod = minimumUpdatePeriod;
+            _scheduler = scheduler;
+            _state = new ScheduledDrainState<T>(scheduler, this);
+        }
+
+        /// <summary>Records the upstream subscription so <see cref="Dispose"/> can tear it down.</summary>
+        /// <param name="subscription">The upstream subscription handle.</param>
+        public void AttachSourceSubscription(IDisposable subscription) => _state.Attach(subscription);
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => _state.EnqueueNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => _state.EnqueueError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => _state.EnqueueCompleted();
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            IDisposable? subscription;
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    return;
+                }
+
+                subscription = _state.BeginDisposeLocked();
+                _updateScheduled.Dispose();
+            }
+
+            subscription?.Dispose();
+        }
+
+        /// <inheritdoc/>
+        void IDrainTarget.Drain()
+        {
+            while (_state.TryDequeue(out var notification))
+            {
+                switch (notification.Kind)
+                {
+                    case DrainNotificationKind.Next:
+                    {
+                        ProcessNext(notification.Value);
+                        break;
+                    }
+
+                    case DrainNotificationKind.Error:
+                    {
+                        ForwardError(notification.Error!);
+                        return;
+                    }
+
+                    default:
+                    {
+                        // DrainNotificationKind has only three values; the discard arm absorbs
+                        // Completed so the compiler sees an exhaustive switch.
+                        ForwardCompleted();
+                        return;
+                    }
+                }
+            }
+        }
+
+        /// <summary>Applies the throttle-window decision to a dequeued value and either emits inline or
+        /// schedules a deferred emission. The emission bodies live in covered helpers; only this
+        /// race-guarded shell (whose already-done early-out is reachable only when a concurrent dispose
+        /// flips the flag between the drain dequeue and this gate acquisition) is excluded.</summary>
+        /// <param name="value">The value to forward.</param>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        private void ProcessNext(T value)
+        {
+            var currentUpdateTime = _scheduler.Now;
+            bool scheduleRequired;
+
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    return;
+                }
+
+                scheduleRequired = currentUpdateTime - _lastUpdateTime < _minimumUpdatePeriod;
+                if (scheduleRequired && _updateScheduled.Disposable != null)
+                {
+                    _updateScheduled.Disposable.Dispose();
+                    _updateScheduled.Disposable = null;
+                }
+            }
+
+            if (scheduleRequired)
+            {
+                ScheduleDeferredEmission(value);
+            }
+            else
+            {
+                EmitInline(value);
+            }
+        }
+
+        /// <summary>Schedules a deferred emission of <paramref name="value"/> at the end of the throttle window,
+        /// forwarding a pending completion once it lands.</summary>
+        /// <param name="value">The value to emit when the window elapses.</param>
+        private void ScheduleDeferredEmission(T value) =>
+            _updateScheduled.Disposable = _scheduler.Schedule(
+                (Sink: this, Value: value),
+                _lastUpdateTime + _minimumUpdatePeriod,
+                static (_, state) =>
+                {
+                    state.Sink.EmitDeferred(state.Value);
+                    return EmptyDisposable.Instance;
+                });
+
+        /// <summary>Emits a deferred value and forwards a pending completion once the value lands.</summary>
+        /// <param name="value">The deferred value.</param>
+        private void EmitDeferred(T value)
+        {
+            _downstream.OnNext(value);
+
+            lock (_state.Gate)
+            {
+                _lastUpdateTime = _scheduler.Now;
+                _updateScheduled.Disposable = null;
+                if (_completionRequested)
+                {
+                    _state.MarkDoneLocked();
+                    _downstream.OnCompleted();
+                }
+            }
+        }
+
+        /// <summary>Emits <paramref name="value"/> immediately and records the emission time.</summary>
+        /// <param name="value">The value to emit.</param>
+        private void EmitInline(T value)
+        {
+            _downstream.OnNext(value);
+            lock (_state.Gate)
+            {
+                _lastUpdateTime = _scheduler.Now;
+            }
+        }
+
+        /// <summary>Forwards an error to downstream and terminates the sink.</summary>
+        /// <param name="error">The error to forward.</param>
+        /// <remarks>The already-terminated early-out is reachable only when a concurrent dispose flips the
+        /// flag between the drain dequeue and this gate acquisition; excluded as race-only.</remarks>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        private void ForwardError(Exception error)
+        {
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    return;
+                }
+
+                _state.MarkDoneLocked();
+                _updateScheduled.Dispose();
+            }
+
+            _downstream.OnError(error);
+        }
+
+        /// <summary>Forwards completion, deferring if a throttled emission is still scheduled.</summary>
+        /// <remarks>The already-terminated early-out is reachable only when a concurrent dispose flips the
+        /// flag between the drain dequeue and this gate acquisition; excluded as race-only.</remarks>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        private void ForwardCompleted()
+        {
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    return;
+                }
+
+                if (_updateScheduled.Disposable != null)
+                {
+                    _completionRequested = true;
+                    return;
+                }
+
+                _state.MarkDoneLocked();
+            }
+
+            _downstream.OnCompleted();
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/DebounceImmediateObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/DebounceImmediateObservable.cs
new file mode 100644
index 0000000..7b2d95a
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/DebounceImmediateObservable.cs
@@ -0,0 +1,166 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Debounces a sequence but emits the first value immediately.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="dueTime">The debounce duration.</param>
+/// <param name="scheduler">The scheduler to use for timing.</param>
+internal sealed class DebounceImmediateObservable<T>(
+    IObservable<T> source,
+    TimeSpan dueTime,
+    ISequencer scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new DebounceImmediateSink(observer, dueTime, scheduler);
+        var subscription = source.Subscribe(sink);
+        return new DisposableBag(subscription, sink);
+    }
+
+    /// <summary>
+    /// Sink for the debounce immediate observable.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="dueTime">The debounce duration.</param>
+    /// <param name="scheduler">The scheduler to use for timing.</param>
+    private sealed class DebounceImmediateSink(
+        IObserver<T> downstream,
+        TimeSpan dueTime,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>
+        /// The gate for thread safety.
+        /// </summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// The timer for debouncing.
+        /// </summary>
+        private readonly SwapDisposable _timer = new();
+
+        /// <summary>
+        /// Whether the first value has been emitted.
+        /// </summary>
+        private bool _isFirst = true;
+
+        /// <summary>
+        /// The last value received.
+        /// </summary>
+        private T? _lastValue;
+
+        /// <summary>
+        /// Whether a value is pending.
+        /// </summary>
+        private bool _hasValue;
+
+        /// <summary>
+        /// Whether the sequence is done.
+        /// </summary>
+        private bool _done;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                if (_isFirst)
+                {
+                    _isFirst = false;
+                    downstream.OnNext(value);
+                    return;
+                }
+
+                _lastValue = value;
+                _hasValue = true;
+                _timer.Disposable = scheduler.Schedule(dueTime, Emit);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                Emit();
+                _timer.Dispose();
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                Emit();
+                _timer.Dispose();
+                downstream.OnCompleted();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _done = true;
+                _timer.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Emits the last value if any.
+        /// </summary>
+        private void Emit()
+        {
+            T? toEmit;
+            bool shouldEmit;
+
+            lock (_gate)
+            {
+                shouldEmit = _hasValue;
+                toEmit = _lastValue;
+                _hasValue = false;
+            }
+
+            if (!shouldEmit)
+            {
+                return;
+            }
+
+            downstream.OnNext(toEmit!);
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/DebounceUntilObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/DebounceUntilObservable.cs
new file mode 100644
index 0000000..ebace51
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/DebounceUntilObservable.cs
@@ -0,0 +1,102 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Debounces a sequence until a condition becomes true for an element.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="debounce">The debounce duration.</param>
+/// <param name="condition">The condition to determine if an element should be emitted immediately or debounced.</param>
+/// <param name="scheduler">The scheduler to use for timing.</param>
+internal sealed class DebounceUntilObservable<T>(
+    IObservable<T> source,
+    TimeSpan debounce,
+    Func<T, bool> condition,
+    ISequencer scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(condition);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new DebounceUntilSink(observer, debounce, condition, scheduler);
+        var subscription = source.Subscribe(sink);
+        return new DisposableBag(subscription, sink);
+    }
+
+    /// <summary>
+    /// Sink for the debounce-until observable. Composes <see cref="TimerSinkState{T}"/> for the
+    /// shared gate / timer / done-flag plumbing so this class only carries the OnNext logic.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="debounce">The debounce duration.</param>
+    /// <param name="condition">The condition.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    private sealed class DebounceUntilSink(
+        IObserver<T> downstream,
+        TimeSpan debounce,
+        Func<T, bool> condition,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>Shared gate / timer / done-flag plumbing.</summary>
+        private readonly TimerSinkState<T> _state = new(downstream);
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    return;
+                }
+
+                if (condition(value))
+                {
+                    _state.Timer.Disposable = null;
+                    downstream.OnNext(value);
+                }
+                else
+                {
+                    _state.Timer.Disposable = scheduler.Schedule(
+                        (Sink: this, Value: value),
+                        debounce,
+                        static state => state.Sink.EmitDebounced(state.Value));
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => _state.HandleError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => _state.HandleCompleted();
+
+        /// <inheritdoc/>
+        public void Dispose() => _state.HandleDispose();
+
+        /// <summary>Emits a debounced value when the sink is still active.</summary>
+        /// <param name="value">The debounced value.</param>
+        private void EmitDebounced(T value)
+        {
+            lock (_state.Gate)
+            {
+                if (!_state.Done)
+                {
+                    downstream.OnNext(value);
+                }
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/DetectStaleObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/DetectStaleObservable.cs
new file mode 100644
index 0000000..eb0c6bf
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/DetectStaleObservable.cs
@@ -0,0 +1,123 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Detects when a sequence becomes stale (no emissions for a specified period).
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="stalenessPeriod">The period after which the sequence is considered stale.</param>
+/// <param name="scheduler">The scheduler to run the staleness timer on.</param>
+internal sealed class DetectStaleObservable<T>(
+    IObservable<T> source,
+    TimeSpan stalenessPeriod,
+    ISequencer scheduler) : IObservable<Stale<T>>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<Stale<T>> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new DetectStaleSink(observer, stalenessPeriod, scheduler);
+        sink.AttachSourceSubscription(source.Subscribe(sink));
+        sink.Initialize();
+        return sink;
+    }
+
+    /// <summary>
+    /// Sink that manages staleness detection. Composes <see cref="TimerSinkState{T}"/> for the
+    /// shared gate / timer / done-flag plumbing so this class only carries the OnNext / schedule logic.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="stalenessPeriod">The staleness period.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    private sealed class DetectStaleSink(
+        IObserver<Stale<T>> downstream,
+        TimeSpan stalenessPeriod,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>Shared gate / timer / done-flag plumbing.</summary>
+        private readonly TimerSinkState<Stale<T>> _state = new(downstream);
+
+        /// <summary>Upstream subscription handle, set once via <see cref="AttachSourceSubscription"/>
+        /// so the sink can tear it down on dispose without a wrapper bag.</summary>
+        private IDisposable? _sourceSubscription;
+
+        /// <summary>Records the upstream subscription for disposal.</summary>
+        /// <param name="subscription">The upstream subscription handle.</param>
+        public void AttachSourceSubscription(IDisposable subscription)
+        {
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    subscription.Dispose();
+                    return;
+                }
+
+                _sourceSubscription = subscription;
+            }
+        }
+
+        /// <summary>Initializes the staleness timer.</summary>
+        public void Initialize() => ScheduleStale();
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    return;
+                }
+
+                downstream.OnNext(new Stale<T>(value));
+                ScheduleStale();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => _state.HandleError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => _state.HandleCompleted();
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            _state.HandleDispose();
+            Interlocked.Exchange(ref _sourceSubscription, null)?.Dispose();
+        }
+
+        /// <summary>Schedules the staleness notification. Uses the state-carrying scheduler
+        /// overload with a static lambda so no per-reschedule closure capturing <c>this</c> is
+        /// allocated (the timer re-arms on every upstream emission).</summary>
+        private void ScheduleStale() =>
+            _state.Timer.Disposable = scheduler.Schedule(this, stalenessPeriod, static (_, self) => self.OnStaleTimer());
+
+        /// <summary>Fires the stale marker downstream when the staleness window elapses.</summary>
+        /// <returns>The singleton empty disposable for the scheduler contract.</returns>
+        private EmptyDisposable OnStaleTimer()
+        {
+            lock (_state.Gate)
+            {
+                if (!_state.Done)
+                {
+                    downstream.OnNext(new Stale<T>());
+                }
+            }
+
+            return EmptyDisposable.Instance;
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/DoOnDisposeObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/DoOnDisposeObservable.cs
new file mode 100644
index 0000000..c64593f
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/DoOnDisposeObservable.cs
@@ -0,0 +1,59 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Executes an action when the subscription is disposed.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="disposeAction">The action to execute when the subscription is disposed.</param>
+internal sealed class DoOnDisposeObservable<T>(
+    IObservable<T> source,
+    Action disposeAction) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(disposeAction);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        return new DoOnDisposeSubscription(source.Subscribe(observer), disposeAction);
+    }
+
+    /// <summary>
+    /// Per-subscribe disposal handle that forwards <see cref="IDisposable.Dispose"/> to the source
+    /// subscription and then to the caller-supplied action. Dedicated class instead of the
+    /// previous <c>ActionDisposable(() =&gt; …)</c> form so no closure is allocated per subscribe.
+    /// </summary>
+    /// <param name="subscription">The upstream subscription disposed before the action fires.</param>
+    /// <param name="disposeAction">The action executed once after the upstream is disposed.</param>
+    private sealed class DoOnDisposeSubscription(IDisposable subscription, Action disposeAction) : IDisposable
+    {
+        /// <summary>Latches to <c>1</c> on the first dispose so the action fires exactly once.</summary>
+        private int _disposed;
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            try
+            {
+                subscription.Dispose();
+            }
+            finally
+            {
+                disposeAction();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/DoOnSubscribeObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/DoOnSubscribeObservable.cs
new file mode 100644
index 0000000..6d1ad98
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/DoOnSubscribeObservable.cs
@@ -0,0 +1,29 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Executes an action at subscription time.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="action">The action to execute when subscribed.</param>
+internal sealed class DoOnSubscribeObservable<T>(
+    IObservable<T> source,
+    Action action) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(action);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        action();
+        return source.Subscribe(observer);
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/DropIfBusyObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/DropIfBusyObservable.cs
new file mode 100644
index 0000000..23b6176
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/DropIfBusyObservable.cs
@@ -0,0 +1,118 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Operator that drops source elements while an asynchronous action is in progress.
+/// Replaces the closure-based implementation in ReactiveExtensions.DropIfBusy.
+/// </summary>
+/// <typeparam name="T">The element type.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="asyncAction">The asynchronous action to execute for each forwarded element.</param>
+internal sealed class DropIfBusyObservable<T>(
+    IObservable<T> source,
+    Func<T, ValueTask> asyncAction) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(asyncAction);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        var sink = new DropIfBusySink(observer, asyncAction);
+        var sub = source.Subscribe(sink);
+        return new DisposableBag(sub, sink);
+    }
+
+    /// <summary>
+    /// Sink that manages the busy state and executes the async action.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="asyncAction">The async action to run.</param>
+    private sealed class DropIfBusySink(
+        IObserver<T> downstream,
+        Func<T, ValueTask> asyncAction) : IObserver<T>, IDisposable
+    {
+        /// <summary>0 = idle, 1 = busy.</summary>
+        private int _isBusy;
+
+        /// <summary>Whether the sink is terminal.</summary>
+        private bool _done;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            // If we can transition from 0 to 1, we handle this value.
+            if (Interlocked.CompareExchange(ref _isBusy, 1, 0) != 0)
+            {
+                return;
+            }
+
+            _ = ProcessAsync(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            _done = true;
+            downstream.OnError(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            _done = true;
+            downstream.OnCompleted();
+        }
+
+        /// <inheritdoc/>
+        public void Dispose() => _done = true;
+
+        /// <summary>
+        /// Executes the async action and manages the busy state transition.
+        /// </summary>
+        /// <param name="value">The value to process.</param>
+        /// <returns>A task representing the async operation.</returns>
+        private async Task ProcessAsync(T value)
+        {
+            try
+            {
+                await asyncAction(value).ConfigureAwait(false);
+                if (_done)
+                {
+                    return;
+                }
+
+                downstream.OnNext(value);
+            }
+            catch (Exception ex)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                downstream.OnError(ex);
+            }
+            finally
+            {
+                Volatile.Write(ref _isBusy, 0);
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/FilterRegexObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/FilterRegexObservable.cs
new file mode 100644
index 0000000..ac18c77
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/FilterRegexObservable.cs
@@ -0,0 +1,60 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Text.RegularExpressions;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Operator that filters string elements using a <see cref="Regex"/>.
+/// Replaces the closure-based implementation in ReactiveExtensions.Filter.
+/// </summary>
+/// <param name="source">The source observable emitting strings.</param>
+/// <param name="regex">The regex to use for filtering.</param>
+internal sealed class FilterRegexObservable(
+    IObservable<string> source,
+    Regex regex) : IObservable<string>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<string> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(regex);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new FilterRegexObserver(observer, regex));
+    }
+
+    /// <summary>
+    /// Observer that filters strings using regex.
+    /// </summary>
+    /// <param name="downstream">The downstream observer receiving strings that match the regex.</param>
+    /// <param name="regex">The regex used for filtering.</param>
+    private sealed class FilterRegexObserver(
+        IObserver<string> downstream,
+        Regex regex) : IObserver<string>
+    {
+        /// <inheritdoc/>
+        public void OnNext(string value)
+        {
+            try
+            {
+                if (value is not null && regex.IsMatch(value))
+                {
+                    downstream.OnNext(value);
+                }
+            }
+            catch (Exception ex)
+            {
+                downstream.OnError(ex);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/FirstMatchFromCandidatesObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/FirstMatchFromCandidatesObservable.cs
new file mode 100644
index 0000000..970ff90
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/FirstMatchFromCandidatesObservable.cs
@@ -0,0 +1,369 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Walks a list of candidate keys sequentially, projects each into a one-shot
+/// <see cref="IObservable{TRaw}"/>, transforms the raw value into
+/// <typeparamref name="TResult"/>, and emits the first transformed value that
+/// satisfies a predicate. Errors from individual projections are swallowed (the
+/// candidate is skipped and the next one is tried). If no candidate matches,
+/// completes with a single emission of <paramref name="fallback"/>.
+/// </summary>
+/// <remarks>
+/// <c>Subscribe</c> attempts a synchronous fast-path first: each candidate's
+/// projection is subscribed and, if it completes inline, the transform + predicate
+/// run on the calling thread with zero additional allocations. Only when a
+/// projection completes asynchronously does the method allocate an
+/// <see cref="AsyncSink"/> to track state across callbacks.
+/// </remarks>
+/// <typeparam name="TKey">The type of candidate keys.</typeparam>
+/// <typeparam name="TRaw">The element type emitted by the projected observable.</typeparam>
+/// <typeparam name="TResult">The final result type emitted to downstream after transformation.</typeparam>
+/// <param name="candidates">The ordered list of candidate keys to walk.</param>
+/// <param name="project">Projects a candidate key into a one-shot observable of raw values.</param>
+/// <param name="transform">Synchronous transform applied to each raw value to produce the result.</param>
+/// <param name="predicate">Returns <see langword="true"/> when a transformed value is a match.</param>
+/// <param name="fallback">Value emitted when no candidate matches.</param>
+internal sealed class FirstMatchFromCandidatesObservable<TKey, TRaw, TResult>(
+    IReadOnlyList<TKey> candidates,
+    Func<TKey, IObservable<TRaw>> project,
+    Func<TRaw, TResult> transform,
+    Func<TResult, bool> predicate,
+    TResult fallback) : IObservable<TResult>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TResult> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(candidates);
+        InvalidOperationExceptionHelper.ThrowIfNull(project);
+        InvalidOperationExceptionHelper.ThrowIfNull(transform);
+        InvalidOperationExceptionHelper.ThrowIfNull(predicate);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        if (candidates.Count == 0)
+        {
+            observer.OnNext(fallback);
+            observer.OnCompleted();
+            return EmptyDisposable.Instance;
+        }
+
+        return TrySyncLoop(observer);
+    }
+
+    /// <summary>
+    /// Tries a synchronous fast-path: each candidate's projected observable is.
+    /// </summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The subscription disposable.</returns>
+    internal IDisposable TrySyncLoop(IObserver<TResult> observer)
+    {
+        // Reuse the SyncProbe across subscribes on the current thread — it carries no
+        // per-call state once Reset, so per-cycle allocation drops to zero on the fast path.
+        // Race-free because the field is [ThreadStatic]; only one TrySyncLoop call can be
+        // active per thread.
+        var probe = SyncProbe.RentForCurrentThread();
+
+        for (var i = 0; i < candidates.Count; i++)
+        {
+            TResult transformed;
+            try
+            {
+                var projected = project(candidates[i]);
+
+                probe.Reset();
+                var sub = projected.Subscribe(probe);
+
+                if (!probe.Completed)
+                {
+                    sub.Dispose();
+                    var sink = new AsyncSink(observer, candidates, project, transform, predicate, fallback, i);
+                    sink.TryNext();
+                    SyncProbe.ReturnToCurrentThread(probe);
+                    return sink;
+                }
+
+                sub.Dispose();
+
+                if (probe.Errored || !probe.HasValue)
+                {
+                    continue;
+                }
+
+                transformed = transform(probe.Value!);
+            }
+            catch
+            {
+                continue;
+            }
+
+            if (predicate(transformed))
+            {
+                observer.OnNext(transformed);
+                observer.OnCompleted();
+                SyncProbe.ReturnToCurrentThread(probe);
+                return EmptyDisposable.Instance;
+            }
+        }
+
+        observer.OnNext(fallback);
+        observer.OnCompleted();
+        SyncProbe.ReturnToCurrentThread(probe);
+        return EmptyDisposable.Instance;
+    }
+
+    /// <summary>
+    /// Lightweight observer used by the synchronous fast-path to capture the result
+    /// of a one-shot projection. Cheaper than <see cref="AsyncSink"/> because it
+    /// carries no downstream observer, candidate list, or delegate references.
+    /// </summary>
+    internal sealed class SyncProbe : IObserver<TRaw>
+    {
+        /// <summary>Per-thread cached instance; rented on entry to <c>TrySyncLoop</c> and returned
+        /// on exit. Eliminates the per-subscribe allocation on the fast path.</summary>
+        [ThreadStatic]
+        private static SyncProbe? _cached;
+
+        /// <summary>Gets a value indicating whether <c>OnNext</c> was called.</summary>
+        internal bool HasValue { get; private set; }
+
+        /// <summary>Gets a value indicating whether <c>OnError</c> was called.</summary>
+        internal bool Errored { get; private set; }
+
+        /// <summary>Gets a value indicating whether <c>OnCompleted</c> or <c>OnError</c> was called.</summary>
+        internal bool Completed { get; private set; }
+
+        /// <summary>Gets the value received via <c>OnNext</c>.</summary>
+        internal TRaw? Value { get; private set; }
+
+        /// <summary>Rents a probe from the current-thread cache, allocating only if the slot is empty.</summary>
+        /// <returns>A fresh-reset probe ready for use.</returns>
+        public static SyncProbe RentForCurrentThread()
+        {
+            var rented = _cached;
+            if (rented is null)
+            {
+                return new SyncProbe();
+            }
+
+            _cached = null;
+            rented.Reset();
+            return rented;
+        }
+
+        /// <summary>Returns a probe to the current-thread cache for reuse on the next call.</summary>
+        /// <param name="probe">The probe instance to cache.</param>
+        public static void ReturnToCurrentThread(SyncProbe probe) => _cached = probe;
+
+        /// <inheritdoc/>
+        public void OnNext(TRaw value)
+        {
+            Value = value;
+            HasValue = true;
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            Errored = true;
+            Completed = true;
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => Completed = true;
+
+        /// <summary>Resets state for reuse across candidates.</summary>
+        internal void Reset()
+        {
+            HasValue = false;
+            Errored = false;
+            Completed = false;
+            Value = default;
+        }
+    }
+
+    /// <summary>
+    /// Heap-allocated observer used when a projection does not complete synchronously.
+    /// Walks the remaining candidates via async callbacks.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="candidates">The candidate list.</param>
+    /// <param name="project">The projection delegate.</param>
+    /// <param name="transform">The transform delegate.</param>
+    /// <param name="predicate">The match predicate.</param>
+    /// <param name="fallback">The fallback value.</param>
+    /// <param name="startIndex">Index of the first candidate to try.</param>
+    private sealed class AsyncSink(
+        IObserver<TResult> downstream,
+        IReadOnlyList<TKey> candidates,
+        Func<TKey, IObservable<TRaw>> project,
+        Func<TRaw, TResult> transform,
+        Func<TResult, bool> predicate,
+        TResult fallback,
+        int startIndex) : IObserver<TRaw>, IDisposable
+    {
+        /// <summary>The current candidate index.</summary>
+        private int _index = startIndex;
+
+        /// <summary>The subscription to the current candidate's projected observable.</summary>
+        private IDisposable? _currentSubscription;
+
+        /// <summary>Whether the sink has reached a terminal state.</summary>
+        private bool _done;
+
+        /// <summary>Whether the sink is currently looping through candidates.</summary>
+        private bool _looping;
+
+        /// <inheritdoc/>
+        public void OnNext(TRaw value)
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            TResult transformed;
+            try
+            {
+                transformed = transform(value);
+            }
+            catch
+            {
+                return;
+            }
+
+            if (!predicate(transformed))
+            {
+                return;
+            }
+
+            _done = true;
+            downstream.OnNext(transformed);
+            downstream.OnCompleted();
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            if (_looping)
+            {
+                // Sync-completion is captured by the probe in TryNext; nothing more to do here.
+                return;
+            }
+
+            TryNext();
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            if (_looping)
+            {
+                // Sync-completion is captured by the probe in TryNext; nothing more to do here.
+                return;
+            }
+
+            TryNext();
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            _done = true;
+            Interlocked.Exchange(ref _currentSubscription, null)?.Dispose();
+        }
+
+        /// <summary>
+        /// Subscribes to the next candidate's projected observable, or emits the
+        /// fallback if no candidates remain.
+        /// </summary>
+        internal void TryNext()
+        {
+            _looping = true;
+            try
+            {
+                while (!_done && _index < candidates.Count)
+                {
+                    var key = candidates[_index++];
+
+                    IObservable<TRaw> projected;
+                    try
+                    {
+                        projected = project(key);
+                    }
+                    catch
+                    {
+                        continue;
+                    }
+
+                    var probe = new CompletionFlagObserver(this);
+                    var sub = projected.Subscribe(probe);
+                    Interlocked.Exchange(ref _currentSubscription, sub);
+
+                    if (!probe.Completed)
+                    {
+                        return;
+                    }
+                }
+            }
+            finally
+            {
+                _looping = false;
+            }
+
+            if (_done)
+            {
+                return;
+            }
+
+            _done = true;
+            downstream.OnNext(fallback);
+            downstream.OnCompleted();
+        }
+
+        /// <summary>
+        /// Forwarding <see cref="IObserver{TRaw}"/> that records whether a terminal notification
+        /// (<c>OnError</c> / <c>OnCompleted</c>) arrived synchronously during the <c>Subscribe</c>
+        /// call. Replaces the prior <c>_syncCompleted</c> field on <see cref="AsyncSink"/> so the
+        /// flag is per-iteration state rather than instance state.
+        /// </summary>
+        /// <param name="inner">The wrapped sink that receives forwarded notifications.</param>
+        private sealed class CompletionFlagObserver(IObserver<TRaw> inner) : IObserver<TRaw>
+        {
+            /// <summary>Gets a value indicating whether a terminal notification was observed.</summary>
+            public bool Completed { get; private set; }
+
+            /// <inheritdoc/>
+            public void OnNext(TRaw value) => inner.OnNext(value);
+
+            /// <inheritdoc/>
+            public void OnError(Exception error)
+            {
+                Completed = true;
+                inner.OnError(error);
+            }
+
+            /// <inheritdoc/>
+            public void OnCompleted()
+            {
+                Completed = true;
+                inner.OnCompleted();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ForEachObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ForEachObservable.cs
new file mode 100644
index 0000000..717e282
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ForEachObservable.cs
@@ -0,0 +1,59 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Flattening operator that subscribes to an upstream sequence of
+/// <see cref="IEnumerable{T}"/> batches and emits each contained element
+/// individually. Replaces the
+/// <c>Observable.Create&lt;T&gt;(o =&gt; source.ObserveOnSafe(s).Subscribe(v =&gt; o.FastForEach(v)))</c>
+/// pattern with a single operator + observer pair.
+/// </summary>
+/// <typeparam name="T">The element type emitted to the downstream observer.</typeparam>
+/// <param name="source">The source observable of enumerables.</param>
+/// <param name="scheduler">An optional scheduler used to marshal source notifications onto.</param>
+internal sealed class ForEachObservable<T>(
+    IObservable<IEnumerable<T>> source,
+    ISequencer? scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var observed = scheduler is null ? source : new ObserveOnObservable<IEnumerable<T>>(source, scheduler);
+        return observed.Subscribe(new ForEachObserver(observer));
+    }
+
+    /// <summary>
+    /// Forwarding observer that fans each batch element out to the downstream
+    /// via <see cref="ObserverExtensions.FastForEach{T}(IObserver{T}, IEnumerable{T})"/>
+    /// and passes terminal signals through.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class ForEachObserver(IObserver<T> downstream) : IObserver<IEnumerable<T>>
+    {
+        /// <inheritdoc/>
+        public void OnNext(IEnumerable<T> value)
+        {
+            if (value is null)
+            {
+                return;
+            }
+
+            downstream.FastForEach(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/FromArrayObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/FromArrayObservable.cs
new file mode 100644
index 0000000..1888ee4
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/FromArrayObservable.cs
@@ -0,0 +1,69 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Factory operator that emits each element of an <see cref="IEnumerable{T}"/>
+/// to a single subscriber, then completes. The emission can optionally be
+/// marshalled through a scheduler. Replaces the
+/// <c>Observable.Create&lt;T&gt;(o =&gt; scheduler.ScheduleSafe(() =&gt; o.FastForEach(source)))</c>
+/// pattern with a dedicated <see cref="IObservable{T}"/> implementation.
+/// </summary>
+/// <typeparam name="T">The element type emitted to the downstream observer.</typeparam>
+/// <param name="source">The source enumerable whose elements are pumped on subscription.</param>
+/// <param name="scheduler">An optional scheduler used to dispatch the pump.</param>
+internal sealed class FromArrayObservable<T>(
+    IEnumerable<T> source,
+    ISequencer? scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        if (scheduler is null)
+        {
+            Pump(observer, source);
+            return EmptyDisposable.Instance;
+        }
+
+        var capturedObserver = observer;
+        var capturedSource = source;
+        return scheduler.Schedule(
+            (capturedObserver, capturedSource),
+            static (_, state) =>
+            {
+                Pump(state.capturedObserver, state.capturedSource);
+                return EmptyDisposable.Instance;
+            });
+    }
+
+    /// <summary>
+    /// Pumps each element of <paramref name="elements"/> into <paramref name="observer"/>
+    /// and signals completion. Errors thrown during enumeration are forwarded
+    /// to <see cref="IObserver{T}.OnError"/>.
+    /// </summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="elements">The elements to pump.</param>
+    private static void Pump(IObserver<T> observer, IEnumerable<T> elements)
+    {
+        try
+        {
+            observer.FastForEach(elements);
+        }
+        catch (Exception error)
+        {
+            observer.OnError(error);
+            return;
+        }
+
+        observer.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/HeartbeatObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/HeartbeatObservable.cs
new file mode 100644
index 0000000..46dd6a4
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/HeartbeatObservable.cs
@@ -0,0 +1,168 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Injects heartbeat values into the sequence when the source remains quiet for a specified period.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="heartbeatPeriod">The period between heartbeats.</param>
+/// <param name="scheduler">The scheduler to run the heartbeat timer on.</param>
+internal sealed class HeartbeatObservable<T>(
+    IObservable<T> source,
+    TimeSpan heartbeatPeriod,
+    ISequencer scheduler) : IObservable<Heartbeat<T>>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<Heartbeat<T>> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new HeartbeatSink(observer, heartbeatPeriod, scheduler);
+        sink.AttachSourceSubscription(source.Subscribe(sink));
+        sink.Initialize();
+        return sink;
+    }
+
+    /// <summary>
+    /// The sink for the heartbeat operator.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="heartbeatPeriod">The period between heartbeats.</param>
+    /// <param name="scheduler">The scheduler to run the heartbeat timer on.</param>
+    private sealed class HeartbeatSink(
+        IObserver<Heartbeat<T>> downstream,
+        TimeSpan heartbeatPeriod,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>
+        /// The gate to synchronize access to the sink's state.
+        /// </summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// The subscription to the periodic heartbeat timer.
+        /// </summary>
+        private readonly MutableDisposable _timerSubscription = new();
+
+        /// <summary>Upstream subscription handle; set once via <see cref="AttachSourceSubscription"/>
+        /// so the sink can tear it down in <see cref="Dispose"/> without needing a wrapper bag.</summary>
+        private IDisposable? _sourceSubscription;
+
+        /// <summary>
+        /// Whether the sink has completed or been disposed.
+        /// </summary>
+        private bool _done;
+
+        /// <summary>Records the upstream subscription so <see cref="Dispose"/> can tear it down.</summary>
+        /// <param name="subscription">The upstream subscription handle.</param>
+        public void AttachSourceSubscription(IDisposable subscription)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    subscription.Dispose();
+                    return;
+                }
+
+                _sourceSubscription = subscription;
+            }
+        }
+
+        /// <summary>
+        /// Initializes the heartbeat timer.
+        /// </summary>
+        public void Initialize() => ScheduleHeartbeats();
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                downstream.OnNext(new Heartbeat<T>(value));
+                ScheduleHeartbeats();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                _timerSubscription.Dispose();
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                _timerSubscription.Dispose();
+                downstream.OnCompleted();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            IDisposable? subscription;
+            lock (_gate)
+            {
+                _done = true;
+                _timerSubscription.Dispose();
+                subscription = _sourceSubscription;
+                _sourceSubscription = null;
+            }
+
+            subscription?.Dispose();
+        }
+
+        /// <summary>
+        /// Schedules the next heartbeat.
+        /// </summary>
+        private void ScheduleHeartbeats()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _timerSubscription.Disposable = scheduler.SchedulePeriodic(
+                    downstream,
+                    heartbeatPeriod,
+                    static d => d.OnNext(new Heartbeat<T>()));
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/LatestOrDefaultObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/LatestOrDefaultObservable.cs
new file mode 100644
index 0000000..4b95a30
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/LatestOrDefaultObservable.cs
@@ -0,0 +1,75 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Emits the latest value from the source sequence or a default value if no value has been emitted.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="defaultValue">The value to emit initially.</param>
+internal sealed class LatestOrDefaultObservable<T>(
+    IObservable<T> source,
+    T defaultValue) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new LatestOrDefaultSink(observer, defaultValue);
+        sink.Initialize();
+        return source.Subscribe(sink);
+    }
+
+    /// <summary>
+    /// Sink that implements the latest or default logic.
+    /// </summary>
+    /// <param name="downstream">The observer to forward elements to.</param>
+    /// <param name="defaultValue">The value to emit initially.</param>
+    private sealed class LatestOrDefaultSink(IObserver<T> downstream, T defaultValue) : IObserver<T>
+    {
+        /// <summary>
+        /// The last value emitted.
+        /// </summary>
+        private T? _last = defaultValue;
+
+        /// <summary>
+        /// Whether any value has been emitted yet.
+        /// </summary>
+        private bool _hasEmitted;
+
+        /// <summary>
+        /// Initializes the sink by emitting the default value.
+        /// </summary>
+        public void Initialize()
+        {
+            downstream.OnNext(_last!);
+            _hasEmitted = true;
+        }
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            if (_hasEmitted && EqualityComparer<T>.Default.Equals(value, _last!))
+            {
+                return;
+            }
+
+            _last = value;
+            _hasEmitted = true;
+            downstream.OnNext(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/LogErrorsObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/LogErrorsObservable.cs
new file mode 100644
index 0000000..e64103e
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/LogErrorsObservable.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Forwards source values verbatim, invokes the logger on error, then propagates the error downstream.
+/// </summary>
+/// <typeparam name="T">Element type.</typeparam>
+/// <param name="source">Upstream source.</param>
+/// <param name="logger">Invoked once with the source error before downstream sees it.</param>
+internal sealed class LogErrorsObservable<T>(IObservable<T> source, Action<Exception> logger) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new LogErrorsObserver(observer, logger));
+    }
+
+    /// <summary>Per-subscription observer that taps errors through the logger.</summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="logger">Logger invoked on the error path.</param>
+    private sealed class LogErrorsObserver(IObserver<T> downstream, Action<Exception> logger) : IObserver<T>
+    {
+        /// <inheritdoc/>
+        public void OnNext(T value) => downstream.OnNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            logger(error);
+            downstream.OnError(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/MinMaxObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/MinMaxObservable.cs
new file mode 100644
index 0000000..2f017c6
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/MinMaxObservable.cs
@@ -0,0 +1,99 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Combines the latest values from multiple sources and emits either the maximum or minimum on each
+/// tick. Backs both the <c>Max</c> (<paramref name="emitMaximum"/>=true) and <c>Min</c>
+/// (<paramref name="emitMaximum"/>=false) operators without the array allocations a generic
+/// <c>CombineLatest(...).Select(xs =&gt; xs.Max())</c> pipeline would incur.
+/// </summary>
+/// <typeparam name="T">The value type.</typeparam>
+/// <param name="sources">The source observables.</param>
+/// <param name="emitMaximum"><c>true</c> to emit the maximum; <c>false</c> to emit the minimum.</param>
+internal sealed class MinMaxObservable<T>(IReadOnlyList<IObservable<T>> sources, bool emitMaximum) : IObservable<T>
+    where T : struct, IComparable<T>
+{
+    /// <summary>The source list.</summary>
+    private readonly IReadOnlyList<IObservable<T>> _sourceList = InvalidOperationExceptionHelper.Check(sources);
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        if (_sourceList.Count == 0)
+        {
+            observer.OnCompleted();
+            return EmptyDisposable.Instance;
+        }
+
+        var sink = new Sink(observer, _sourceList.Count, emitMaximum);
+        return IndexedSubscribeHelper.SubscribeIndexed(_sourceList, sink.OnNext, sink.OnError, sink.OnCompleted);
+    }
+
+    /// <summary>
+    /// Sink that holds the latest value per source and emits either the max or the min. Composes
+    /// <see cref="ReduceSinkState{TIn, TOut}"/> for the shared plumbing.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="count">The number of sources.</param>
+    /// <param name="emitMaximum"><c>true</c> for max; <c>false</c> for min.</param>
+    private sealed class Sink(IObserver<T> downstream, int count, bool emitMaximum)
+    {
+        /// <summary>Shared gate / value cache / terminal-state plumbing.</summary>
+        private readonly ReduceSinkState<T, T> _state = new(downstream, count);
+
+        /// <summary>Handles OnNext from a source.</summary>
+        /// <param name="index">Source index.</param>
+        /// <param name="value">Emitted value.</param>
+        public void OnNext(int index, T value)
+        {
+            lock (_state.Gate)
+            {
+                if (_state.IsDone)
+                {
+                    return;
+                }
+
+                if (!_state.Values[index].HasValue)
+                {
+                    _state.HasValueCount++;
+                }
+
+                _state.Values[index] = value;
+
+                if (!_state.AllValuesPresent)
+                {
+                    return;
+                }
+
+                var result = _state.Values[0]!.Value;
+                for (var i = 1; i < _state.Values.Length; i++)
+                {
+                    var current = _state.Values[i]!.Value;
+                    var cmp = current.CompareTo(result);
+                    if (emitMaximum ? cmp > 0 : cmp < 0)
+                    {
+                        result = current;
+                    }
+                }
+
+                _state.Downstream.OnNext(result);
+            }
+        }
+
+        /// <summary>Handles OnError from any source.</summary>
+        /// <param name="error">The error.</param>
+        public void OnError(Exception error) => _state.HandleError(error);
+
+        /// <summary>Handles OnCompleted from a source.</summary>
+        /// <param name="index">Source index.</param>
+        public void OnCompleted(int index) => _state.HandleCompleted(index);
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/NotObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/NotObservable.cs
new file mode 100644
index 0000000..fd1e530
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/NotObservable.cs
@@ -0,0 +1,40 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Boolean negation operator. Replaces the <c>source.Select(b =&gt; !b)</c>
+/// pattern with a dedicated forwarding observer, avoiding the per-subscription
+/// closure allocation that the projection lambda would otherwise capture.
+/// </summary>
+/// <param name="source">The boolean source observable.</param>
+internal sealed class NotObservable(IObservable<bool> source) : IObservable<bool>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<bool> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new NotObserver(observer));
+    }
+
+    /// <summary>
+    /// Forwarding observer that negates every boolean <see cref="OnNext"/>.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class NotObserver(IObserver<bool> downstream) : IObserver<bool>
+    {
+        /// <inheritdoc/>
+        public void OnNext(bool value) => downstream.OnNext(!value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ObserveOnIfObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ObserveOnIfObservable.cs
new file mode 100644
index 0000000..d90bd6a
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ObserveOnIfObservable.cs
@@ -0,0 +1,222 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Conditionally switches between two schedulers based on a reactive condition.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="condition">The reactive condition observable.</param>
+/// <param name="trueScheduler">The scheduler to use when condition is true.</param>
+/// <param name="falseScheduler">The scheduler to use when condition is false.</param>
+internal sealed class ObserveOnIfObservable<T>(
+    IObservable<T> source,
+    IObservable<bool> condition,
+    ISequencer trueScheduler,
+    ISequencer falseScheduler) : IObservable<T>
+{
+    /// <summary>
+    /// The source observable.
+    /// </summary>
+    private readonly IObservable<T> _source = InvalidOperationExceptionHelper.Check(source);
+
+    /// <summary>
+    /// The reactive condition observable.
+    /// </summary>
+    private readonly IObservable<bool> _condition = InvalidOperationExceptionHelper.Check(condition);
+
+    /// <summary>
+    /// The scheduler to use when condition is true.
+    /// </summary>
+    private readonly ISequencer _trueScheduler = InvalidOperationExceptionHelper.Check(trueScheduler);
+
+    /// <summary>
+    /// The scheduler to use when condition is false.
+    /// </summary>
+    private readonly ISequencer _falseScheduler = InvalidOperationExceptionHelper.Check(falseScheduler);
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new ObserveOnIfSink(observer, _trueScheduler, _falseScheduler);
+        var conditionSub = _condition.Subscribe(sink.ConditionObserver);
+        var sourceSub = _source.Subscribe(sink);
+        return new DisposableBag(sourceSub, conditionSub, sink);
+    }
+
+    /// <summary>
+    /// Sinks the source observable and conditionally observes on different schedulers.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="trueScheduler">The scheduler to use when condition is true.</param>
+    /// <param name="falseScheduler">The scheduler to use when condition is false.</param>
+    private sealed class ObserveOnIfSink(
+        IObserver<T> downstream,
+        ISequencer trueScheduler,
+        ISequencer falseScheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>
+        /// The gate for synchronization.
+        /// </summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// The downstream observer.
+        /// </summary>
+        private readonly IObserver<T> _downstream = InvalidOperationExceptionHelper.Check(downstream);
+
+        /// <summary>
+        /// The scheduler to use when condition is true.
+        /// </summary>
+        private readonly ISequencer _trueScheduler = InvalidOperationExceptionHelper.Check(trueScheduler);
+
+        /// <summary>
+        /// The scheduler to use when condition is false.
+        /// </summary>
+        private readonly ISequencer _falseScheduler = InvalidOperationExceptionHelper.Check(falseScheduler);
+
+        /// <summary>
+        /// The current scheduler.
+        /// </summary>
+        private ISequencer _currentScheduler = falseScheduler;
+
+        /// <summary>
+        /// The last condition value.
+        /// </summary>
+        private bool _lastCondition;
+
+        /// <summary>
+        /// Whether the condition has been received.
+        /// </summary>
+        private bool _hasCondition;
+
+        /// <summary>
+        /// Whether the sequence is done.
+        /// </summary>
+        private bool _done;
+
+        /// <summary>
+        /// Gets the condition observer.
+        /// </summary>
+        public IObserver<bool> ConditionObserver => new ConditionObserverImpl(this);
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            ISequencer scheduler;
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                scheduler = _currentScheduler;
+            }
+
+            scheduler.Schedule((Sink: this, Value: value), static state => state.Sink.ForwardNext(state.Value));
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+            }
+
+            _downstream.OnError(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+            }
+
+            _downstream.OnCompleted();
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _done = true;
+            }
+        }
+
+        /// <summary>Updates the scheduler selected by the condition stream.</summary>
+        /// <param name="conditionValue">The latest condition value.</param>
+        private void UpdateCondition(bool conditionValue)
+        {
+            lock (_gate)
+            {
+                if (_hasCondition && _lastCondition == conditionValue)
+                {
+                    return;
+                }
+
+                _currentScheduler = conditionValue ? _trueScheduler : _falseScheduler;
+                _lastCondition = conditionValue;
+                _hasCondition = true;
+            }
+        }
+
+        /// <summary>Forwards a scheduled value to the downstream observer if the sink is still active.</summary>
+        /// <param name="value">The value to forward.</param>
+        private void ForwardNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+            }
+
+            _downstream.OnNext(value);
+        }
+
+        /// <summary>
+        /// Observer for condition updates.
+        /// </summary>
+        /// <param name="sink">The owning sink.</param>
+        private sealed class ConditionObserverImpl(ObserveOnIfSink sink) : IObserver<bool>
+        {
+            /// <inheritdoc/>
+            public void OnNext(bool value) => sink.UpdateCondition(value);
+
+            /// <inheritdoc/>
+            public void OnError(Exception error)
+            {
+            }
+
+            /// <inheritdoc/>
+            public void OnCompleted()
+            {
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ObserveOnObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ObserveOnObservable.cs
new file mode 100644
index 0000000..509d5cd
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ObserveOnObservable.cs
@@ -0,0 +1,111 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Marshals every source notification onto the supplied <see cref="ISequencer"/>, preserving order.
+/// Replaces the <c>System.Reactive.Linq.Observable.ObserveOn</c> delegation behind the sync
+/// <c>ObserveOnSafe</c> / <c>ObserveOnIf</c> helpers with our own queue-and-single-drain marshaller:
+/// notifications are enqueued and a single drain pass is scheduled per burst (rather than one
+/// scheduled action per item). The shared queue / gate / drain machinery lives in
+/// <see cref="ScheduledDrainState{T}"/>; this sink only carries the forward-everything drain handling.
+/// </summary>
+/// <typeparam name="T">The element type of the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="scheduler">The scheduler every notification is delivered on.</param>
+internal sealed class ObserveOnObservable<T>(IObservable<T> source, ISequencer scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        // The immediate scheduler runs scheduled work inline on the calling thread, so the
+        // queue-and-drain machinery would be pure overhead: forward straight through.
+        if (ReferenceEquals(scheduler, Sequencer.Immediate))
+        {
+            return source.Subscribe(observer);
+        }
+
+        var sink = new ObserveOnSink(observer, scheduler);
+        sink.AttachSourceSubscription(source.Subscribe(sink));
+        return sink;
+    }
+
+    /// <summary>
+    /// Single observer that queues upstream notifications and drains them on the scheduler thread in
+    /// FIFO order. Terminal notifications travel through the same queue so they never overtake
+    /// still-queued values.
+    /// </summary>
+    private sealed class ObserveOnSink : IObserver<T>, IDisposable, IDrainTarget
+    {
+        /// <summary>The downstream observer.</summary>
+        private readonly IObserver<T> _downstream;
+
+        /// <summary>Shared queue / gate / scheduled-drain machinery.</summary>
+        private readonly ScheduledDrainState<T> _state;
+
+        /// <summary>Initializes a new instance of the <see cref="ObserveOnSink"/> class.</summary>
+        /// <param name="downstream">The downstream observer.</param>
+        /// <param name="scheduler">The scheduler notifications are delivered on.</param>
+        public ObserveOnSink(IObserver<T> downstream, ISequencer scheduler)
+        {
+            _downstream = downstream;
+            _state = new ScheduledDrainState<T>(scheduler, this);
+        }
+
+        /// <summary>Records the upstream subscription so <see cref="Dispose"/> can tear it down.</summary>
+        /// <param name="subscription">The upstream subscription handle.</param>
+        public void AttachSourceSubscription(IDisposable subscription) => _state.Attach(subscription);
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => _state.EnqueueNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => _state.EnqueueError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => _state.EnqueueCompleted();
+
+        /// <inheritdoc/>
+        public void Dispose() => _state.BeginDispose()?.Dispose();
+
+        /// <inheritdoc/>
+        void IDrainTarget.Drain()
+        {
+            while (_state.TryDequeue(out var notification))
+            {
+                switch (notification.Kind)
+                {
+                    case DrainNotificationKind.Next:
+                    {
+                        _downstream.OnNext(notification.Value);
+                        break;
+                    }
+
+                    case DrainNotificationKind.Error:
+                    {
+                        _state.Terminate();
+                        _downstream.OnError(notification.Error!);
+                        return;
+                    }
+
+                    default:
+                    {
+                        // DrainNotificationKind has only three values; the discard arm absorbs Completed.
+                        _state.Terminate();
+                        _downstream.OnCompleted();
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/PairwiseObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/PairwiseObservable.cs
new file mode 100644
index 0000000..4c2a73a
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/PairwiseObservable.cs
@@ -0,0 +1,67 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Emits (previous, current) pairs from a sequence.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+internal sealed class PairwiseObservable<T>(IObservable<T> source) : IObservable<(T Previous, T Current)>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<(T Previous, T Current)> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        return source.Subscribe(new PairwiseObserver(observer));
+    }
+
+    /// <summary>
+    /// The observer for the pairwise operator.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class PairwiseObserver(IObserver<(T Previous, T Current)> downstream) : IObserver<T>
+    {
+        /// <summary>
+        /// The gate for state access.
+        /// </summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// The previous value.
+        /// </summary>
+        private T? _previous;
+
+        /// <summary>
+        /// A value indicating whether there is a previous value.
+        /// </summary>
+        private bool _hasPrevious;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_hasPrevious)
+                {
+                    downstream.OnNext((_previous!, value));
+                }
+
+                _previous = value;
+                _hasPrevious = true;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/PartitionObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/PartitionObservable.cs
new file mode 100644
index 0000000..9bdcfa3
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/PartitionObservable.cs
@@ -0,0 +1,314 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+using System;
+using System.Threading;
+
+/// <summary>
+/// Partitions a sequence into two observables based on a predicate.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+internal sealed class PartitionObservable<T>
+{
+    /// <summary>
+    /// The source observable.
+    /// </summary>
+    private readonly IObservable<T> _source;
+
+    /// <summary>
+    /// The predicate to partition elements.
+    /// </summary>
+    private readonly Func<T, bool> _predicate;
+
+    /// <summary>
+    /// The gate for synchronization.
+    /// </summary>
+    private readonly Lock _gate = new();
+
+    /// <summary>
+    /// The source subscription.
+    /// </summary>
+    private IDisposable? _sourceSubscription;
+
+    /// <summary>
+    /// The observer for the source.
+    /// </summary>
+    private PartitionSink? _sink;
+
+    /// <summary>
+    /// The number of subscriptions.
+    /// </summary>
+    private int _subscriptionCount;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PartitionObservable{T}"/> class.
+    /// </summary>
+    /// <param name="source">The source observable.</param>
+    /// <param name="predicate">The predicate to partition elements.</param>
+    public PartitionObservable(IObservable<T> source, Func<T, bool> predicate)
+    {
+        _source = source;
+        _predicate = predicate;
+        True = new PartitionSide(this, true);
+        False = new PartitionSide(this, false);
+    }
+
+    /// <summary>Gets the observable emitting elements that satisfy the predicate.</summary>
+    public IObservable<T> True { get; }
+
+    /// <summary>Gets the observable emitting elements that do not satisfy the predicate.</summary>
+    public IObservable<T> False { get; }
+
+    /// <summary>
+    /// Subscribes an observer to the specified side of the partition.
+    /// </summary>
+    /// <param name="observer">The observer.</param>
+    /// <param name="side">The side (true or false).</param>
+    /// <returns>A disposable to unsubscribe.</returns>
+    private Subscription Subscribe(IObserver<T> observer, bool side)
+    {
+        lock (_gate)
+        {
+            if (_subscriptionCount == 0)
+            {
+                _sink = new(this);
+                _sourceSubscription = _source.Subscribe(_sink);
+            }
+
+            _subscriptionCount++;
+            _sink!.Add(observer, side);
+        }
+
+        return new(this, observer, side);
+    }
+
+    /// <summary>
+    /// Represents a subscription to the partition.
+    /// </summary>
+    /// <param name="parent">The parent observable.</param>
+    /// <param name="observer">The observer.</param>
+    /// <param name="side">The side.</param>
+    private sealed class Subscription(PartitionObservable<T> parent, IObserver<T> observer, bool side) : IDisposable
+    {
+        /// <summary>
+        /// The parent observable.
+        /// </summary>
+        private readonly PartitionObservable<T> _parent = parent;
+
+        /// <summary>
+        /// The observer.
+        /// </summary>
+        private readonly IObserver<T> _observer = observer;
+
+        /// <summary>
+        /// The side.
+        /// </summary>
+        private readonly bool _side = side;
+
+        /// <summary>
+        /// Whether the subscription is disposed.
+        /// </summary>
+        private int _disposed;
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            lock (_parent._gate)
+            {
+                // Invariant: a Subscription whose Interlocked.Exchange just transitioned _disposed
+                // from 0 to 1 was created by Subscribe under the same lock, which sets _sink
+                // before returning — so _sink is non-null here by construction.
+                _parent._sink!.Remove(_observer, _side);
+                _parent._subscriptionCount--;
+                if (_parent._subscriptionCount == 0)
+                {
+                    // Subscribe set _sourceSubscription alongside _sink under the same lock,
+                    // so when the last branch disposes here it is non-null by construction.
+                    _parent._sourceSubscription!.Dispose();
+                    _parent._sourceSubscription = null;
+                    _parent._sink = null;
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Represents a side of the partition.
+    /// </summary>
+    private sealed class PartitionSide : IObservable<T>
+    {
+        /// <summary>
+        /// The parent observable.
+        /// </summary>
+        private readonly PartitionObservable<T> _parent;
+
+        /// <summary>
+        /// The side.
+        /// </summary>
+        private readonly bool _side;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PartitionSide"/> class.
+        /// </summary>
+        /// <param name="parent">The parent observable.</param>
+        /// <param name="side">The side (true or false).</param>
+        public PartitionSide(PartitionObservable<T> parent, bool side)
+        {
+            _parent = parent;
+            _side = side;
+        }
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer) => _parent.Subscribe(observer, _side);
+    }
+
+    /// <summary>
+    /// Sink that partitions elements.
+    /// </summary>
+    /// <param name="parent">The parent observable.</param>
+    private sealed class PartitionSink(PartitionObservable<T> parent) : IObserver<T>
+    {
+        /// <summary>
+        /// The observers for the true side.
+        /// </summary>
+        private IObserver<T>[] _trueObservers = [];
+
+        /// <summary>
+        /// The observers for the false side.
+        /// </summary>
+        private IObserver<T>[] _falseObservers = [];
+
+        /// <summary>
+        /// Adds an observer to the specified side.
+        /// </summary>
+        /// <param name="observer">The observer to add.</param>
+        /// <param name="side">The side.</param>
+        public void Add(IObserver<T> observer, bool side)
+        {
+            if (side)
+            {
+                _trueObservers = [.. _trueObservers, observer];
+            }
+            else
+            {
+                _falseObservers = [.. _falseObservers, observer];
+            }
+        }
+
+        /// <summary>
+        /// Removes an observer from the specified side.
+        /// </summary>
+        /// <param name="observer">The observer to remove.</param>
+        /// <param name="side">The side.</param>
+        public void Remove(IObserver<T> observer, bool side)
+        {
+            if (side)
+            {
+                var index = Array.IndexOf(_trueObservers, observer);
+                if (index >= 0)
+                {
+                    if (_trueObservers.Length == 1)
+                    {
+                        _trueObservers = [];
+                    }
+                    else
+                    {
+                        var newObservers = new IObserver<T>[_trueObservers.Length - 1];
+                        Array.Copy(_trueObservers, 0, newObservers, 0, index);
+                        Array.Copy(_trueObservers, index + 1, newObservers, index, _trueObservers.Length - index - 1);
+                        _trueObservers = newObservers;
+                    }
+                }
+            }
+            else
+            {
+                var index = Array.IndexOf(_falseObservers, observer);
+                if (index >= 0)
+                {
+                    if (_falseObservers.Length == 1)
+                    {
+                        _falseObservers = [];
+                    }
+                    else
+                    {
+                        var newObservers = new IObserver<T>[_falseObservers.Length - 1];
+                        Array.Copy(_falseObservers, 0, newObservers, 0, index);
+                        Array.Copy(_falseObservers, index + 1, newObservers, index, _falseObservers.Length - index - 1);
+                        _falseObservers = newObservers;
+                    }
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            IObserver<T>[] trueObservers;
+            IObserver<T>[] falseObservers;
+
+            lock (parent._gate)
+            {
+                trueObservers = _trueObservers;
+                falseObservers = _falseObservers;
+            }
+
+            for (var i = 0; i < trueObservers.Length; i++)
+            {
+                trueObservers[i].OnCompleted();
+            }
+
+            for (var i = 0; i < falseObservers.Length; i++)
+            {
+                falseObservers[i].OnCompleted();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            IObserver<T>[] trueObservers;
+            IObserver<T>[] falseObservers;
+
+            lock (parent._gate)
+            {
+                trueObservers = _trueObservers;
+                falseObservers = _falseObservers;
+            }
+
+            for (var i = 0; i < trueObservers.Length; i++)
+            {
+                trueObservers[i].OnError(error);
+            }
+
+            for (var i = 0; i < falseObservers.Length; i++)
+            {
+                falseObservers[i].OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            var result = parent._predicate(value);
+
+            IObserver<T>[] observers;
+            lock (parent._gate)
+            {
+                observers = result ? _trueObservers : _falseObservers;
+            }
+
+            for (var i = 0; i < observers.Length; i++)
+            {
+                observers[i].OnNext(value);
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/PropertyChangedObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/PropertyChangedObservable.cs
new file mode 100644
index 0000000..aafb1e5
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/PropertyChangedObservable.cs
@@ -0,0 +1,136 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.ComponentModel;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Fused replacement for
+/// <c>Observable.FromEventPattern(...).Where(name match).Select(getter).StartWith(getter)</c>.
+/// Subscribes directly to <see cref="INotifyPropertyChanged.PropertyChanged"/>, holds the
+/// compiled getter once at construction (the original chain compiled it twice per
+/// subscription), and emits the current value on subscribe followed by the getter
+/// result for each matching property change — all through a single sink.
+/// </summary>
+/// <typeparam name="T">The owning type that raises <see cref="INotifyPropertyChanged.PropertyChanged"/>.</typeparam>
+/// <typeparam name="TProperty">The property element type.</typeparam>
+/// <param name="source">The owning instance.</param>
+/// <param name="propertyName">The property name to filter by.</param>
+/// <param name="getter">The compiled property getter (compiled once at construction).</param>
+internal sealed class PropertyChangedObservable<T, TProperty>(
+    T source,
+    string propertyName,
+    Func<T, TProperty> getter) : IObservable<TProperty>
+    where T : INotifyPropertyChanged
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TProperty> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(propertyName);
+        InvalidOperationExceptionHelper.ThrowIfNull(getter);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        observer.OnNext(getter(source));
+
+        var sink = new PropertyChangedSink(observer, source, propertyName, getter);
+        source.PropertyChanged += sink.Handler;
+        return sink;
+    }
+
+    /// <summary>
+    /// Sink that holds the bound <see cref="PropertyChangedEventHandler"/> and detaches
+    /// it on dispose. Filters by property name inline and pulls the value through the
+    /// pre-compiled getter.
+    /// </summary>
+    private sealed class PropertyChangedSink : IDisposable
+    {
+        /// <summary>The downstream observer receiving filtered property values.</summary>
+        private readonly IObserver<TProperty> _downstream;
+
+        /// <summary>The owning instance whose event is being observed.</summary>
+        private readonly T _source;
+
+        /// <summary>The property name to filter on.</summary>
+        private readonly string _propertyName;
+
+        /// <summary>The pre-compiled property getter.</summary>
+        private readonly Func<T, TProperty> _getter;
+
+        /// <summary>Disposed flag (0 = active, 1 = disposed). Updated lock-free.</summary>
+        private int _disposed;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PropertyChangedSink"/> class.
+        /// </summary>
+        /// <param name="downstream">The downstream observer.</param>
+        /// <param name="source">The owning instance.</param>
+        /// <param name="propertyName">The property name to filter on.</param>
+        /// <param name="getter">The pre-compiled property getter.</param>
+        public PropertyChangedSink(
+            IObserver<TProperty> downstream,
+            T source,
+            string propertyName,
+            Func<T, TProperty> getter)
+        {
+            _downstream = downstream;
+            _source = source;
+            _propertyName = propertyName;
+            _getter = getter;
+            Handler = OnPropertyChanged;
+        }
+
+        /// <summary>
+        /// Gets the bound event handler attached to the source's
+        /// <see cref="INotifyPropertyChanged.PropertyChanged"/> event.
+        /// </summary>
+        public PropertyChangedEventHandler Handler { get; }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            _source.PropertyChanged -= Handler;
+        }
+
+        /// <summary>
+        /// Bound <see cref="INotifyPropertyChanged.PropertyChanged"/> handler — filters
+        /// by property name then forwards the pre-compiled getter result downstream.
+        /// </summary>
+        /// <param name="sender">Event sender (unused).</param>
+        /// <param name="e">Event payload carrying the changed property name.</param>
+        private void OnPropertyChanged(object? sender, PropertyChangedEventArgs e)
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return;
+            }
+
+            if (e.PropertyName != _propertyName)
+            {
+                return;
+            }
+
+            TProperty value;
+            try
+            {
+                value = _getter(_source);
+            }
+            catch (Exception ex)
+            {
+                _downstream.OnError(ex);
+                Dispose();
+                return;
+            }
+
+            _downstream.OnNext(value);
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ReplayLastOnSubscribeObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ReplayLastOnSubscribeObservable.cs
new file mode 100644
index 0000000..7260b9f
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ReplayLastOnSubscribeObservable.cs
@@ -0,0 +1,29 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Emits a stored initial value to every new subscriber, then forwards subsequent emissions from the
+/// shared source. Each subscriber gets its own independent subscription to the source; the per-subscriber
+/// replay is the fixed <c>initialValue</c> supplied at construction (matching the legacy BehaviorSubject
+/// semantics — late subscribers do NOT see the latest value emitted to earlier subscribers).
+/// </summary>
+/// <typeparam name="T">The element type of the source observable.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="initialValue">The initial value emitted to every new subscriber.</param>
+internal sealed class ReplayLastOnSubscribeObservable<T>(IObservable<T> source, T initialValue) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        observer.OnNext(initialValue);
+        return source.Subscribe(observer);
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/RetryBackoffPolicy.cs b/src/ReactiveUI.Primitives.Extensions/Operators/RetryBackoffPolicy.cs
new file mode 100644
index 0000000..938ed58
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/RetryBackoffPolicy.cs
@@ -0,0 +1,26 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Bundled retry configuration for <see cref="RetryWithBackoffObservable{T}"/>: retry count,
+/// delay schedule, scheduler, and an optional error sink. A <see langword="readonly record struct"/>
+/// so it stays allocation-free and keeps consuming constructors below Sonar's S107 parameter limit.
+/// </summary>
+/// <param name="MaxRetries">Maximum number of retries.</param>
+/// <param name="InitialDelay">Delay before the first retry.</param>
+/// <param name="BackoffFactor">Multiplier applied to the delay per retry attempt.</param>
+/// <param name="MaxDelay">Cap on the computed delay, or <see langword="null"/> for no cap.</param>
+/// <param name="Scheduler">Scheduler used to schedule each delay.</param>
+/// <param name="OnError">Optional callback invoked on every upstream error.</param>
+internal readonly record struct RetryBackoffPolicy(
+    int MaxRetries,
+    TimeSpan InitialDelay,
+    double BackoffFactor,
+    TimeSpan? MaxDelay,
+    ISequencer Scheduler,
+    Action<Exception>? OnError);
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/RetryForeverObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/RetryForeverObservable.cs
new file mode 100644
index 0000000..d980bf1
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/RetryForeverObservable.cs
@@ -0,0 +1,86 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Re-subscribes to the source indefinitely on error. Forwards values verbatim and completes when
+/// the source completes. Per-subscription state is held in a single sink; resubscription swaps the
+/// inner disposable rather than allocating a new wrapper chain.
+/// </summary>
+/// <typeparam name="T">Element type.</typeparam>
+/// <param name="source">Upstream source.</param>
+internal sealed class RetryForeverObservable<T>(IObservable<T> source) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        var sink = new RetrySink(source, observer);
+        sink.Start();
+        return sink;
+    }
+
+    /// <summary>Sink that re-subscribes the source on every error.</summary>
+    private sealed class RetrySink(IObservable<T> source, IObserver<T> downstream) : IObserver<T>, IDisposable
+    {
+        /// <summary>Holds the current inner subscription; swapped on each resubscribe.</summary>
+        private readonly MutableDisposable _inner = new();
+
+        /// <summary>Latches to <c>1</c> on the first dispose so teardown is idempotent.</summary>
+        private int _disposed;
+
+        /// <summary>Begins the first subscription.</summary>
+        public void Start() => _inner.Disposable = source.Subscribe(this);
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return;
+            }
+
+            downstream.OnNext(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return;
+            }
+
+            _ = error;
+            _inner.Disposable = source.Subscribe(this);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return;
+            }
+
+            downstream.OnCompleted();
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            _inner.Dispose();
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/RetryWithBackoffObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/RetryWithBackoffObservable.cs
new file mode 100644
index 0000000..bd1d279
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/RetryWithBackoffObservable.cs
@@ -0,0 +1,127 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Retries the source observable sequence upon error, with optional delay, retry count, and backoff.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="policy">The retry / backoff configuration.</param>
+internal sealed class RetryWithBackoffObservable<T>(
+    IObservable<T> source,
+    RetryBackoffPolicy policy) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(policy.Scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new RetryWithBackoffSink(observer, source, policy);
+        sink.Run();
+        return sink;
+    }
+
+    /// <summary>
+    /// Sink that manages retries with exponential backoff.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="source">The source observable.</param>
+    /// <param name="policy">The retry / backoff configuration.</param>
+    private sealed class RetryWithBackoffSink(
+        IObserver<T> downstream,
+        IObservable<T> source,
+        RetryBackoffPolicy policy) : IObserver<T>, IDisposable
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>The subscription to the source sequence.</summary>
+        private readonly MutableDisposable _subscription = new();
+
+        /// <summary>The number of retries already attempted.</summary>
+        private int _retries;
+
+        /// <summary>Whether the sink has been disposed.</summary>
+        private bool _disposed;
+
+        /// <summary>Starts the retry process.</summary>
+        public void Run() => SubscribeToSource();
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => downstream.OnNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            policy.OnError?.Invoke(error);
+
+            lock (_gate)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                if (_retries < policy.MaxRetries)
+                {
+                    var delay = TimeSpan.FromTicks((long)(policy.InitialDelay.Ticks * Math.Pow(policy.BackoffFactor, _retries)));
+                    if (policy.MaxDelay.HasValue && delay > policy.MaxDelay.Value)
+                    {
+                        delay = policy.MaxDelay.Value;
+                    }
+
+                    _retries++;
+
+                    if (delay == TimeSpan.Zero)
+                    {
+                        SubscribeToSource();
+                    }
+                    else
+                    {
+                        _subscription.Disposable = policy.Scheduler.Schedule(delay, SubscribeToSource);
+                    }
+                }
+                else
+                {
+                    downstream.OnError(error);
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _disposed = true;
+                _subscription.Dispose();
+            }
+        }
+
+        /// <summary>Subscribes to the source sequence.</summary>
+        private void SubscribeToSource()
+        {
+            lock (_gate)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                _subscription.Disposable = source.Subscribe(this);
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/RetryWithDelayObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/RetryWithDelayObservable.cs
new file mode 100644
index 0000000..3c428d0
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/RetryWithDelayObservable.cs
@@ -0,0 +1,130 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Retries the source observable sequence upon error, with a delay selected by a function.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="retryCount">The maximum number of retries.</param>
+/// <param name="delaySelector">A function to select the delay for each retry attempt.</param>
+internal sealed class RetryWithDelayObservable<T>(
+    IObservable<T> source,
+    int retryCount,
+    Func<int, TimeSpan> delaySelector) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(delaySelector);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new RetryWithDelaySink(observer, source, retryCount, delaySelector, Sequencer.Default);
+        sink.Run();
+        return sink;
+    }
+
+    /// <summary>
+    /// Sink that manages retries with a custom delay selector.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="source">The source observable.</param>
+    /// <param name="maxRetries">The maximum number of retries.</param>
+    /// <param name="delaySelector">The delay selector.</param>
+    /// <param name="scheduler">The scheduler used to time retry delays.</param>
+    private sealed class RetryWithDelaySink(
+        IObserver<T> downstream,
+        IObservable<T> source,
+        int maxRetries,
+        Func<int, TimeSpan> delaySelector,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>The subscription to the source sequence.</summary>
+        private readonly MutableDisposable _subscription = new();
+
+        /// <summary>The number of retries already attempted.</summary>
+        private int _retries;
+
+        /// <summary>Whether the sink has been disposed.</summary>
+        private bool _disposed;
+
+        /// <summary>Starts the retry process.</summary>
+        public void Run() => SubscribeToSource();
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => downstream.OnNext(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                if (_retries < maxRetries)
+                {
+                    var delay = delaySelector(_retries);
+                    _retries++;
+
+                    if (delay == TimeSpan.Zero)
+                    {
+                        SubscribeToSource();
+                    }
+                    else
+                    {
+                        _subscription.Disposable = scheduler.Schedule(this, delay, static (_, self) =>
+                        {
+                            self.SubscribeToSource();
+                            return EmptyDisposable.Instance;
+                        });
+                    }
+                }
+                else
+                {
+                    downstream.OnError(error);
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _disposed = true;
+                _subscription.Dispose();
+            }
+        }
+
+        /// <summary>Subscribes to the source sequence.</summary>
+        private void SubscribeToSource()
+        {
+            lock (_gate)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                _subscription.Disposable = source.Subscribe(this);
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/RunAllObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/RunAllObservable.cs
new file mode 100644
index 0000000..951399a
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/RunAllObservable.cs
@@ -0,0 +1,162 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Runs a list of one-shot <see cref="IObservable{RxVoid}"/> observables sequentially,
+/// ignoring emitted values, and emits a single <see cref="RxVoid.Default"/> when all
+/// have completed. If the list is empty, emits <see cref="RxVoid.Default"/> immediately.
+/// Errors from any observable propagate to the downstream observer.
+/// </summary>
+/// <remarks>
+/// Replaces patterns like <c>sources.Concat().LastOrDefaultAsync()</c> with a single
+/// operator that subscribes sequentially. Uses an iterative loop with a sync-completion
+/// flag to avoid stack overflow when sources complete synchronously during
+/// <c>Subscribe</c>.
+/// </remarks>
+/// <param name="sources">The list of one-shot observables to run in order.</param>
+internal sealed class RunAllObservable(IReadOnlyList<IObservable<RxVoid>> sources) : IObservable<RxVoid>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<RxVoid> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(sources);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        if (sources.Count == 0)
+        {
+            observer.OnNext(RxVoid.Default);
+            observer.OnCompleted();
+            return EmptyDisposable.Instance;
+        }
+
+        var sink = new Sink(observer, sources);
+        sink.RunNext();
+        return sink;
+    }
+
+    /// <summary>
+    /// Stateful observer that walks the source list sequentially. The sink subscribes itself
+    /// directly to each source — its own <see cref="IObserver{RxVoid}.OnCompleted"/> sets a
+    /// per-iteration flag the surrounding loop reads to decide whether to advance. This
+    /// replaces the previous probe-observer-per-iteration allocation pattern.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="sources">The source list to walk.</param>
+    private sealed class Sink(
+        IObserver<RxVoid> downstream,
+        IReadOnlyList<IObservable<RxVoid>> sources) : IObserver<RxVoid>, IDisposable
+    {
+        /// <summary>Index of the current source being observed.</summary>
+        private int _index;
+
+        /// <summary>Subscription to the current source.</summary>
+        private IDisposable? _currentSubscription;
+
+        /// <summary>Set once all sources have completed or we've been disposed.</summary>
+        private bool _done;
+
+        /// <summary>Guards against re-entrant <see cref="RunNext"/> calls.</summary>
+        private bool _looping;
+
+        /// <summary>Per-iteration latch (0 = pending, 1 = terminated). Set by <see cref="OnCompleted"/>
+        /// when a source terminates synchronously during <c>Subscribe</c>; read by the surrounding
+        /// loop in <see cref="RunNext"/>. Accessed via <see cref="Volatile"/> so it crosses the
+        /// method boundary safely without needing a separate probe-observer allocation per iteration.</summary>
+        private int _iterationTerminated;
+
+        /// <inheritdoc/>
+        public void OnNext(RxVoid value)
+        {
+            // Ignore — we only care about completion.
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            _done = true;
+            downstream.OnError(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            if (_looping)
+            {
+                // Inside the loop the surrounding RunNext reads _iterationTerminated; no recursion.
+                Volatile.Write(ref _iterationTerminated, 1);
+                return;
+            }
+
+            RunNext();
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            _done = true;
+            Interlocked.Exchange(ref _currentSubscription, null)?.Dispose();
+        }
+
+        /// <summary>
+        /// Subscribes to the next source, or emits RxVoid and completes if all are done.
+        /// Iteratively loops on synchronous completion to avoid recursive stack growth.
+        /// </summary>
+        internal void RunNext()
+        {
+            _looping = true;
+            try
+            {
+                while (!_done && _index < sources.Count)
+                {
+                    var source = sources[_index++];
+                    Volatile.Write(ref _iterationTerminated, 0);
+                    var sub = source.Subscribe(this);
+                    Interlocked.Exchange(ref _currentSubscription, sub);
+
+                    if (Volatile.Read(ref _iterationTerminated) == 0)
+                    {
+                        return;
+                    }
+                }
+            }
+            finally
+            {
+                _looping = false;
+            }
+
+            CompleteRun();
+        }
+
+        /// <summary>Emits the terminal <see cref="RxVoid"/> and completes once all sources have run.</summary>
+        /// <remarks>The already-done early-out is only reachable when a concurrent dispose latches between the
+        /// loop exit and this call; this small completion shell is excluded from coverage as race-only while the
+        /// trampoline loop in <see cref="RunNext"/> stays covered.</remarks>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        private void CompleteRun()
+        {
+            if (_done)
+            {
+                return;
+            }
+
+            _done = true;
+            downstream.OnNext(RxVoid.Default);
+            downstream.OnCompleted();
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SampleLatestObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SampleLatestObservable.cs
new file mode 100644
index 0000000..a419928
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SampleLatestObservable.cs
@@ -0,0 +1,174 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Samples the latest value from the source observable whenever a trigger observable emits.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="trigger">The trigger observable.</param>
+internal sealed class SampleLatestObservable<T>(
+    IObservable<T> source,
+    IObservable<object> trigger) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(trigger);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new SampleLatestSink(observer);
+        var sourceSub = source.Subscribe(sink.SourceObserver);
+        var triggerSub = trigger.Subscribe(sink.TriggerObserver);
+        return new DisposableBag(sourceSub, triggerSub, sink);
+    }
+
+    /// <summary>
+    /// Sinks the source observable and samples it based on the trigger.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class SampleLatestSink(IObserver<T> downstream) : IDisposable
+    {
+        /// <summary>
+        /// The gate for synchronization.
+        /// </summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// The latest value from the source.
+        /// </summary>
+        private T? _latest;
+
+        /// <summary>
+        /// Whether the source has produced a value.
+        /// </summary>
+        private bool _hasValue;
+
+        /// <summary>
+        /// Whether the sequence is done.
+        /// </summary>
+        private bool _done;
+
+        /// <summary>
+        /// Gets the source observer.
+        /// </summary>
+        public IObserver<T> SourceObserver => new SourceSampleObserver(this);
+
+        /// <summary>
+        /// Gets the trigger observer.
+        /// </summary>
+        public IObserver<object> TriggerObserver => new TriggerSampleObserver(this);
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _done = true;
+            }
+        }
+
+        /// <summary>Records the latest source value.</summary>
+        /// <param name="value">The source value.</param>
+        private void OnSourceNext(T value)
+        {
+            lock (_gate)
+            {
+                _latest = value;
+                _hasValue = true;
+            }
+        }
+
+        /// <summary>Forwards a terminal error from either source.</summary>
+        /// <param name="error">The terminal error.</param>
+        private void OnAnyError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <summary>Forwards source completion.</summary>
+        private void OnSourceCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnCompleted();
+            }
+        }
+
+        /// <summary>Samples and forwards the latest source value if one is available.</summary>
+        private void OnTriggerNext()
+        {
+            T? value;
+            bool shouldEmit;
+            lock (_gate)
+            {
+                shouldEmit = _hasValue;
+                value = _latest;
+            }
+
+            if (!shouldEmit)
+            {
+                return;
+            }
+
+            downstream.OnNext(value!);
+        }
+
+        /// <summary>
+        /// Observer for source values.
+        /// </summary>
+        /// <param name="sink">The owning sink.</param>
+        private sealed class SourceSampleObserver(SampleLatestSink sink) : IObserver<T>
+        {
+            /// <inheritdoc/>
+            public void OnNext(T value) => sink.OnSourceNext(value);
+
+            /// <inheritdoc/>
+            public void OnError(Exception error) => sink.OnAnyError(error);
+
+            /// <inheritdoc/>
+            public void OnCompleted() => sink.OnSourceCompleted();
+        }
+
+        /// <summary>
+        /// Observer for trigger values.
+        /// </summary>
+        /// <param name="sink">The owning sink.</param>
+        private sealed class TriggerSampleObserver(SampleLatestSink sink) : IObserver<object>
+        {
+            /// <inheritdoc/>
+            public void OnNext(object value) => sink.OnTriggerNext();
+
+            /// <inheritdoc/>
+            public void OnError(Exception error) => sink.OnAnyError(error);
+
+            /// <inheritdoc/>
+            public void OnCompleted()
+            {
+                /* Trigger completion does not affect sample */
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ScanWithInitialObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ScanWithInitialObservable.cs
new file mode 100644
index 0000000..b60f0cd
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ScanWithInitialObservable.cs
@@ -0,0 +1,124 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Scans the source sequence and emits the initial value immediately upon subscription.
+/// </summary>
+/// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+/// <typeparam name="TAccumulate">The type of the accumulated value.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="initial">The initial accumulated value.</param>
+/// <param name="accumulator">The accumulator function.</param>
+internal sealed class ScanWithInitialObservable<TSource, TAccumulate>(
+    IObservable<TSource> source,
+    TAccumulate initial,
+    Func<TAccumulate, TSource, TAccumulate> accumulator) : IObservable<TAccumulate>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TAccumulate> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(accumulator);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new ScanWithInitialSink(observer, initial, accumulator);
+        sink.Initialize();
+        return source.Subscribe(sink);
+    }
+
+    /// <summary>
+    /// Sink that implements the scan with initial logic.
+    /// </summary>
+    /// <param name="downstream">The observer to forward elements to.</param>
+    /// <param name="initial">The initial accumulated value.</param>
+    /// <param name="accumulator">The accumulator function.</param>
+    private sealed class ScanWithInitialSink(
+        IObserver<TAccumulate> downstream,
+        TAccumulate initial,
+        Func<TAccumulate, TSource, TAccumulate> accumulator) : IObserver<TSource>
+    {
+        /// <summary>
+        /// The gate to synchronize access to the sink state.
+        /// </summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// The current accumulated value.
+        /// </summary>
+        private TAccumulate _current = initial;
+
+        /// <summary>
+        /// Whether the sink has finished.
+        /// </summary>
+        private bool _done;
+
+        /// <summary>
+        /// Initializes the sink by emitting the initial value.
+        /// </summary>
+        public void Initialize() => downstream.OnNext(_current);
+
+        /// <inheritdoc/>
+        public void OnNext(TSource value)
+        {
+            TAccumulate current;
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                try
+                {
+                    _current = accumulator(_current, value);
+                    current = _current;
+                }
+                catch (Exception ex)
+                {
+                    _done = true;
+                    downstream.OnError(ex);
+                    return;
+                }
+            }
+
+            downstream.OnNext(current);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+            }
+
+            downstream.OnError(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+            }
+
+            downstream.OnCompleted();
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ScheduleConfig.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ScheduleConfig.cs
new file mode 100644
index 0000000..8384355
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ScheduleConfig.cs
@@ -0,0 +1,61 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Bundled scheduling configuration shared by <see cref="ScheduledValueObservable{T}"/> and
+/// <see cref="ScheduledSourceObservable{T}"/>. Carrying these parameters as a single readonly record
+/// struct keeps observable/observer constructor parameter counts low, avoids SA1117-style parameter
+/// soup, and lets the compiler copy the configuration into capture-free scheduler lambdas.
+/// </summary>
+/// <typeparam name="T">The element type emitted by the configured observable.</typeparam>
+/// <param name="Scheduler">The scheduler on which each emission is dispatched.</param>
+/// <param name="HasDelay"><c>true</c> when a delay (relative or absolute) is configured.</param>
+/// <param name="UseAbsolute"><c>true</c> when <paramref name="AbsoluteDueTime"/> is used; <c>false</c> when <paramref name="DueTime"/> applies.</param>
+/// <param name="DueTime">The relative delay before each emission.</param>
+/// <param name="AbsoluteDueTime">The absolute time at which each emission fires.</param>
+/// <param name="Transform">Optional transform applied to the value before emission.</param>
+/// <param name="Action">Optional side-effect invoked with the value before emission.</param>
+internal readonly record struct ScheduleConfig<T>(
+    ISequencer Scheduler,
+    bool HasDelay,
+    bool UseAbsolute,
+    TimeSpan DueTime,
+    DateTimeOffset AbsoluteDueTime,
+    Func<T, T>? Transform,
+    Action<T>? Action)
+{
+    /// <summary>Creates a config with no delay, no transform, no action.</summary>
+    /// <param name="scheduler">The scheduler used to dispatch emissions.</param>
+    /// <returns>A new configuration.</returns>
+    public static ScheduleConfig<T> Immediate(ISequencer scheduler) =>
+        new(scheduler, false, false, TimeSpan.Zero, default, null, null);
+
+    /// <summary>Creates a config with a relative delay.</summary>
+    /// <param name="scheduler">The scheduler used to dispatch emissions.</param>
+    /// <param name="dueTime">The relative delay before each emission.</param>
+    /// <returns>A new configuration.</returns>
+    public static ScheduleConfig<T> Delayed(ISequencer scheduler, TimeSpan dueTime) =>
+        new(scheduler, true, false, dueTime, default, null, null);
+
+    /// <summary>Creates a config with an absolute due time.</summary>
+    /// <param name="scheduler">The scheduler used to dispatch emissions.</param>
+    /// <param name="absoluteDueTime">The absolute time at which each emission fires.</param>
+    /// <returns>A new configuration.</returns>
+    public static ScheduleConfig<T> Absolute(ISequencer scheduler, DateTimeOffset absoluteDueTime) =>
+        new(scheduler, true, true, TimeSpan.Zero, absoluteDueTime, null, null);
+
+    /// <summary>Returns a new config with the supplied transform applied to each value before emission.</summary>
+    /// <param name="transform">The transform.</param>
+    /// <returns>A new configuration.</returns>
+    public ScheduleConfig<T> WithTransform(Func<T, T> transform) => this with { Transform = transform };
+
+    /// <summary>Returns a new config with the supplied side-effect invoked with each value before emission.</summary>
+    /// <param name="action">The action.</param>
+    /// <returns>A new configuration.</returns>
+    public ScheduleConfig<T> WithAction(Action<T> action) => this with { Action = action };
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ScheduledSourceObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ScheduledSourceObservable.cs
new file mode 100644
index 0000000..23657f3
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ScheduledSourceObservable.cs
@@ -0,0 +1,148 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Source-driven scheduled observable. Subscribes to an upstream
+/// <see cref="IObservable{T}"/> and, for every emitted value, schedules a
+/// callback on the supplied <see cref="ISequencer"/> that applies an optional
+/// <see cref="Action{T}"/> side-effect and/or <see cref="Func{T,T}"/> transform
+/// before forwarding the value to the downstream observer. Replaces the
+/// <c>Observable.Create&lt;T&gt;(o =&gt; source.Subscribe(v =&gt; scheduler.Schedule(...)))</c>
+/// family of source-driven <c>Schedule</c> overloads.
+/// </summary>
+/// <typeparam name="T">The element type of the source observable.</typeparam>
+/// <remarks>
+/// To match the original <c>source.Subscribe(Action&lt;T&gt;)</c> semantics, this
+/// operator only forwards <see cref="IObserver{T}.OnNext"/>. Source errors and
+/// completion are intentionally not propagated to the downstream observer; that
+/// preserves the historical behaviour of <c>Observable.Create</c> + a
+/// next-only subscription.
+/// </remarks>
+internal sealed class ScheduledSourceObservable<T> : IObservable<T>
+{
+    /// <summary>The upstream observable.</summary>
+    private readonly IObservable<T> _source;
+
+    /// <summary>The bundled scheduling configuration shared across every subscription.</summary>
+    private readonly ScheduleConfig<T> _config;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ScheduledSourceObservable{T}"/> class.
+    /// </summary>
+    /// <param name="source">The upstream observable.</param>
+    /// <param name="config">Bundled scheduling configuration (scheduler, optional delay, optional transform/action).</param>
+    public ScheduledSourceObservable(IObservable<T> source, ScheduleConfig<T> config)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(config.Scheduler);
+        _source = source;
+        _config = config;
+    }
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new ScheduledSourceObserver(observer, _config);
+        return _source.Subscribe(sink);
+    }
+
+    /// <summary>
+    /// Carries the per-emission state into the scheduled callback so the
+    /// scheduler lambda does not capture any fields. A <see langword="readonly"/>
+    /// <see langword="record"/> <see langword="struct"/> so it rides inside the
+    /// scheduler's work item by value rather than as a separate per-emission heap
+    /// allocation.
+    /// </summary>
+    /// <param name="Observer">The downstream observer.</param>
+    /// <param name="Value">The value to emit.</param>
+    /// <param name="Transform">The optional transform.</param>
+    /// <param name="Action">The optional side-effect.</param>
+    private readonly record struct EmitState(
+        IObserver<T> Observer,
+        T Value,
+        Func<T, T>? Transform,
+        Action<T>? Action)
+    {
+        /// <summary>
+        /// Applies the optional side-effect and transform, then emits the value
+        /// to the captured observer.
+        /// </summary>
+        public void Emit()
+        {
+            try
+            {
+                Action?.Invoke(Value);
+                var emitted = Transform is null ? Value : Transform(Value);
+                Observer.OnNext(emitted);
+            }
+            catch (Exception error)
+            {
+                Observer.OnError(error);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Per-value sink that captures the configured scheduling parameters once
+    /// and schedules each <see cref="OnNext"/> through the configured
+    /// <see cref="ISequencer"/>.
+    /// </summary>
+    private sealed class ScheduledSourceObserver(IObserver<T> downstream, ScheduleConfig<T> config) : IObserver<T>
+    {
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            var state = new EmitState(downstream, value, config.Transform, config.Action);
+            var scheduler = config.Scheduler;
+
+            if (!config.HasDelay)
+            {
+                scheduler.Schedule(state, static (_, s) =>
+                {
+                    s.Emit();
+                    return EmptyDisposable.Instance;
+                });
+                return;
+            }
+
+            if (config.UseAbsolute)
+            {
+                scheduler.Schedule(state, config.AbsoluteDueTime, static (_, s) =>
+                {
+                    s.Emit();
+                    return EmptyDisposable.Instance;
+                });
+                return;
+            }
+
+            scheduler.Schedule(state, config.DueTime, static (_, s) =>
+            {
+                s.Emit();
+                return EmptyDisposable.Instance;
+            });
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            // Intentionally not forwarded: original Observable.Create + Subscribe(Action<T>)
+            // pattern silently dropped source errors. Preserving that behaviour.
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            // Intentionally not forwarded: original Observable.Create + Subscribe(Action<T>)
+            // pattern silently dropped completion. Preserving that behaviour.
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ScheduledValueObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ScheduledValueObservable.cs
new file mode 100644
index 0000000..da5448d
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ScheduledValueObservable.cs
@@ -0,0 +1,152 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Single-value scheduled observable. On subscription, schedules a callback on
+/// the supplied <see cref="ISequencer"/> that applies an optional
+/// <see cref="Action{T}"/> side-effect and/or an optional <see cref="Func{T,T}"/>
+/// transform to the captured value, calls <see cref="IObserver{T}.OnNext"/>
+/// once, then <see cref="IObserver{T}.OnCompleted"/>. Replaces the
+/// <c>Observable.Create&lt;T&gt;(o =&gt; scheduler.Schedule[Safe](due, () =&gt; o.OnNext(...)))</c>
+/// family of single-value <c>Schedule</c> overloads with one dedicated type
+/// that captures only the fields each overload actually uses.
+/// </summary>
+/// <typeparam name="T">The value type emitted to the downstream observer.</typeparam>
+internal sealed class ScheduledValueObservable<T> : IObservable<T>
+{
+    /// <summary>The value to emit.</summary>
+    private readonly T _value;
+
+    /// <summary>The scheduler used to dispatch the emission.</summary>
+    private readonly ISequencer _scheduler;
+
+    /// <summary>The relative delay if <see cref="_useAbsolute"/> is <c>false</c>.</summary>
+    private readonly TimeSpan _dueTime;
+
+    /// <summary>The absolute due time if <see cref="_useAbsolute"/> is <c>true</c>.</summary>
+    private readonly DateTimeOffset _absoluteDueTime;
+
+    /// <summary>Optional transform applied to the value before emission.</summary>
+    private readonly Func<T, T>? _transform;
+
+    /// <summary>Optional side-effect invoked with the value before emission.</summary>
+    private readonly Action<T>? _action;
+
+    /// <summary><c>true</c> when <see cref="_absoluteDueTime"/> is used; otherwise <see cref="_dueTime"/> is used.</summary>
+    private readonly bool _useAbsolute;
+
+    /// <summary><c>true</c> when a delay is configured (relative or absolute).</summary>
+    private readonly bool _hasDelay;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ScheduledValueObservable{T}"/> class.
+    /// </summary>
+    /// <param name="value">The value to emit.</param>
+    /// <param name="scheduler">The scheduler used to dispatch the emission.</param>
+    /// <param name="dueTime">Optional relative delay before emission.</param>
+    /// <param name="absoluteDueTime">Optional absolute time at which to emit.</param>
+    /// <param name="transform">Optional transform applied to the value before emission.</param>
+    /// <param name="action">Optional side-effect invoked with the value before emission.</param>
+    public ScheduledValueObservable(
+        T value,
+        ISequencer scheduler,
+        TimeSpan? dueTime,
+        DateTimeOffset? absoluteDueTime,
+        Func<T, T>? transform,
+        Action<T>? action)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(scheduler);
+        _value = value;
+        _scheduler = scheduler;
+        _transform = transform;
+        _action = action;
+
+        if (absoluteDueTime.HasValue)
+        {
+            _absoluteDueTime = absoluteDueTime.Value;
+            _useAbsolute = true;
+            _hasDelay = true;
+        }
+        else if (dueTime.HasValue)
+        {
+            _dueTime = dueTime.Value;
+            _hasDelay = true;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var state = new EmitState(observer, _value, _transform, _action);
+
+        if (!_hasDelay)
+        {
+            return _scheduler.Schedule(state, static (_, s) =>
+            {
+                s.Emit();
+                return EmptyDisposable.Instance;
+            });
+        }
+
+        if (_useAbsolute)
+        {
+            return _scheduler.Schedule(state, _absoluteDueTime, static (_, s) =>
+            {
+                s.Emit();
+                return EmptyDisposable.Instance;
+            });
+        }
+
+        return _scheduler.Schedule(state, _dueTime, static (_, s) =>
+        {
+            s.Emit();
+            return EmptyDisposable.Instance;
+        });
+    }
+
+    /// <summary>
+    /// Carries the per-subscription state into the scheduled callback so the
+    /// scheduler lambda does not capture any fields.
+    /// </summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="value">The value to emit.</param>
+    /// <param name="transform">The optional transform.</param>
+    /// <param name="action">The optional side-effect.</param>
+    private sealed class EmitState(
+        IObserver<T> observer,
+        T value,
+        Func<T, T>? transform,
+        Action<T>? action)
+    {
+        /// <summary>
+        /// Applies the optional side-effect and transform, then emits the value
+        /// followed by completion to the captured observer.
+        /// </summary>
+        public void Emit()
+        {
+            // Preserves the original Observable.Create-based semantics: the
+            // scheduled callback only emits OnNext. The sequence completes
+            // when downstream subscribers dispose; we do not auto-call
+            // OnCompleted here.
+            try
+            {
+                action?.Invoke(value);
+                var emitted = transform is null ? value : transform(value);
+                observer.OnNext(emitted);
+            }
+            catch (Exception error)
+            {
+                observer.OnError(error);
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SelectAsyncConcurrentObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SelectAsyncConcurrentObservable.cs
new file mode 100644
index 0000000..e589709
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SelectAsyncConcurrentObservable.cs
@@ -0,0 +1,176 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Projects each element to an asynchronous operation with limited concurrency.
+/// </summary>
+/// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+/// <typeparam name="TResult">The type of the result of the asynchronous operation.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="selector">The asynchronous projection function.</param>
+/// <param name="maxConcurrency">The maximum number of concurrent operations.</param>
+internal sealed class SelectAsyncConcurrentObservable<TSource, TResult>(
+    IObservable<TSource> source,
+    Func<TSource, Task<TResult>> selector,
+    int maxConcurrency) : IObservable<TResult>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TResult> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(selector);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new SelectAsyncConcurrentSink(observer, selector, maxConcurrency);
+        var sub = source.Subscribe(sink);
+        return new DisposableBag(sub, sink);
+    }
+
+    /// <summary>
+    /// Sink that manages concurrent async projection.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="selector">The async selector.</param>
+    /// <param name="maxConcurrency">The maximum concurrency.</param>
+    private sealed class SelectAsyncConcurrentSink(
+        IObserver<TResult> downstream,
+        Func<TSource, Task<TResult>> selector,
+        int maxConcurrency) : IObserver<TSource>, IDisposable
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>Queue of values to process.</summary>
+        private readonly Queue<TSource> _queue = new();
+
+        /// <summary>The number of currently running async operations.</summary>
+        private int _running;
+
+        /// <summary>Whether the source has completed.</summary>
+        private bool _done;
+
+        /// <summary>Whether the sink has been disposed.</summary>
+        private bool _disposed;
+
+        /// <inheritdoc/>
+        public void OnNext(TSource value)
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+
+                _queue.Enqueue(value);
+                TryProcessNext();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+
+                _done = true;
+                if (_running == 0 && _queue.Count == 0)
+                {
+                    downstream.OnCompleted();
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _disposed = true;
+            }
+        }
+
+        /// <summary>Attempts to process the next value in the queue.</summary>
+        private void TryProcessNext()
+        {
+            while (_running < maxConcurrency && _queue.Count > 0)
+            {
+                var value = _queue.Dequeue();
+                _running++;
+                _ = ProcessAsync(value);
+            }
+        }
+
+        /// <summary>Processes the async operation.</summary>
+        /// <param name="value">The value to project.</param>
+        /// <returns>A task representing the operation.</returns>
+        private async Task ProcessAsync(TSource value)
+        {
+            try
+            {
+                var result = await selector(value).ConfigureAwait(false);
+                lock (_gate)
+                {
+                    if (!_disposed)
+                    {
+                        downstream.OnNext(result);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                lock (_gate)
+                {
+                    if (!_disposed)
+                    {
+                        _done = true;
+                        downstream.OnError(ex);
+                    }
+                }
+            }
+            finally
+            {
+                lock (_gate)
+                {
+                    _running--;
+                    if (!_disposed)
+                    {
+                        if (_done && _running == 0 && _queue.Count == 0)
+                        {
+                            downstream.OnCompleted();
+                        }
+                        else
+                        {
+                            TryProcessNext();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SelectAsyncSequentialObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SelectAsyncSequentialObservable.cs
new file mode 100644
index 0000000..921cda2
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SelectAsyncSequentialObservable.cs
@@ -0,0 +1,169 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Projects each element to an asynchronous operation, preserving order and handling sequential execution.
+/// </summary>
+/// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+/// <typeparam name="TResult">The type of the result of the asynchronous operation.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="selector">The asynchronous projection function.</param>
+internal sealed class SelectAsyncSequentialObservable<TSource, TResult>(
+    IObservable<TSource> source,
+    Func<TSource, Task<TResult>> selector) : IObservable<TResult>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TResult> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(selector);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new SelectAsyncSequentialSink(observer, selector);
+        var sub = source.Subscribe(sink);
+        return new DisposableBag(sub, sink);
+    }
+
+    /// <summary>
+    /// Sink that manages sequential async projection.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="selector">The async selector.</param>
+    private sealed class SelectAsyncSequentialSink(
+        IObserver<TResult> downstream,
+        Func<TSource, Task<TResult>> selector) : IObserver<TSource>, IDisposable
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>Queue of values to process.</summary>
+        private readonly Queue<TSource> _queue = new();
+
+        /// <summary>Whether an async operation is currently in progress.</summary>
+        private bool _isProcessing;
+
+        /// <summary>Whether the source has completed.</summary>
+        private bool _done;
+
+        /// <summary>Whether the sink has been disposed.</summary>
+        private bool _disposed;
+
+        /// <inheritdoc/>
+        public void OnNext(TSource value)
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+
+                _queue.Enqueue(value);
+                if (!_isProcessing)
+                {
+                    _isProcessing = true;
+                    _ = ProcessNextAsync();
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+
+                _done = true;
+                if (!_isProcessing)
+                {
+                    downstream.OnCompleted();
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _disposed = true;
+            }
+        }
+
+        /// <summary>Processes the next value in the queue.</summary>
+        /// <returns>A task representing the operation.</returns>
+        private async Task ProcessNextAsync()
+        {
+            while (true)
+            {
+                TSource value;
+                lock (_gate)
+                {
+                    if (_disposed || _queue.Count == 0)
+                    {
+                        _isProcessing = false;
+                        if (_done && !_disposed)
+                        {
+                            downstream.OnCompleted();
+                        }
+
+                        return;
+                    }
+
+                    value = _queue.Dequeue();
+                }
+
+                try
+                {
+                    var result = await selector(value).ConfigureAwait(false);
+                    lock (_gate)
+                    {
+                        if (!_disposed)
+                        {
+                            downstream.OnNext(result);
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    lock (_gate)
+                    {
+                        if (!_disposed)
+                        {
+                            _done = true;
+                            downstream.OnError(ex);
+                        }
+
+                        _isProcessing = false;
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SelectConstantObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SelectConstantObservable.cs
new file mode 100644
index 0000000..48f55fc
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SelectConstantObservable.cs
@@ -0,0 +1,48 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Projection operator that ignores every source element and emits a stored constant
+/// instead. Replaces the common <c>.Select(_ =&gt; value)</c> pattern, avoiding the
+/// per-subscription closure allocation that the lambda <c>_ =&gt; value</c> would
+/// capture.
+/// </summary>
+/// <typeparam name="TSource">The source element type (ignored).</typeparam>
+/// <typeparam name="TResult">The result element type emitted to the downstream observer.</typeparam>
+/// <param name="source">The source observable whose values are ignored.</param>
+/// <param name="constant">The constant value emitted for each source element.</param>
+internal sealed class SelectConstantObservable<TSource, TResult>(
+    IObservable<TSource> source,
+    TResult constant) : IObservable<TResult>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TResult> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new SelectConstantObserver(observer, constant));
+    }
+
+    /// <summary>
+    /// Forwarding observer that replaces every <see cref="OnNext"/> value with
+    /// the stored constant. Error and completion signals pass through unchanged.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="constant">The constant value to emit.</param>
+    private sealed class SelectConstantObserver(IObserver<TResult> downstream, TResult constant) : IObserver<TSource>
+    {
+        /// <inheritdoc/>
+        public void OnNext(TSource value) => downstream.OnNext(constant);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SelectLatestAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SelectLatestAsyncObservable.cs
new file mode 100644
index 0000000..c0c0f2b
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SelectLatestAsyncObservable.cs
@@ -0,0 +1,185 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Projects each element to an asynchronous operation, but only the result of the latest operation is emitted.
+/// </summary>
+/// <typeparam name="TSource">The type of elements in the source sequence.</typeparam>
+/// <typeparam name="TResult">The type of the result of the asynchronous operation.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="selector">The asynchronous projection function.</param>
+internal sealed class SelectLatestAsyncObservable<TSource, TResult>(
+    IObservable<TSource> source,
+    Func<TSource, Task<TResult>> selector) : IObservable<TResult>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TResult> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(selector);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new SelectLatestAsyncSink(observer, selector);
+        var sub = source.Subscribe(sink);
+        return new DisposableBag(sub, sink);
+    }
+
+    /// <summary>
+    /// Sink that manages the latest async projection.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="selector">The async selector.</param>
+    private sealed class SelectLatestAsyncSink(
+        IObserver<TResult> downstream,
+        Func<TSource, Task<TResult>> selector) : IObserver<TSource>, IDisposable
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>The current operation ID to track latest.</summary>
+        private long _currentId;
+
+        /// <summary>Whether the source has completed (no more values will arrive).</summary>
+        private bool _sourceCompleted;
+
+        /// <summary>Whether downstream completion has been signalled.</summary>
+        private bool _completionSignalled;
+
+        /// <summary>The latest in-flight projection task, used to delay completion until it finishes.</summary>
+        private Task? _latestTask;
+
+        /// <summary>Whether the sink has been disposed.</summary>
+        private bool _disposed;
+
+        /// <inheritdoc/>
+        public void OnNext(TSource value)
+        {
+            long id;
+            lock (_gate)
+            {
+                if (_sourceCompleted || _disposed)
+                {
+                    return;
+                }
+
+                id = ++_currentId;
+            }
+
+            var task = ProcessAsync(value, id);
+            lock (_gate)
+            {
+                _latestTask = task;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_sourceCompleted || _disposed)
+                {
+                    return;
+                }
+
+                _sourceCompleted = true;
+                _completionSignalled = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            Task? toAwait;
+            lock (_gate)
+            {
+                if (_sourceCompleted || _disposed)
+                {
+                    return;
+                }
+
+                _sourceCompleted = true;
+                toAwait = _latestTask;
+            }
+
+            if (toAwait?.IsCompleted != false)
+            {
+                SignalCompleted();
+                return;
+            }
+
+            _ = toAwait.ContinueWith(static (_, s) => ((SelectLatestAsyncSink)s!).SignalCompleted(), this, TaskScheduler.Default);
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _disposed = true;
+            }
+        }
+
+        /// <summary>Signals downstream completion exactly once after the latest projection has finished.</summary>
+        private void SignalCompleted()
+        {
+            lock (_gate)
+            {
+                if (_disposed || _completionSignalled)
+                {
+                    return;
+                }
+
+                _completionSignalled = true;
+                downstream.OnCompleted();
+            }
+        }
+
+        /// <summary>Processes the async operation and checks for latest ID.</summary>
+        /// <param name="value">The value to project.</param>
+        /// <param name="id">The ID of this operation.</param>
+        /// <returns>A task representing the operation.</returns>
+        private async Task ProcessAsync(TSource value, long id)
+        {
+            try
+            {
+                var result = await selector(value).ConfigureAwait(false);
+                bool sourceDone;
+                lock (_gate)
+                {
+                    if (_disposed || id != _currentId)
+                    {
+                        return;
+                    }
+
+                    downstream.OnNext(result);
+                    sourceDone = _sourceCompleted;
+                }
+
+                if (sourceDone)
+                {
+                    SignalCompleted();
+                }
+            }
+            catch (Exception ex)
+            {
+                lock (_gate)
+                {
+                    if (!_disposed && id == _currentId && !_completionSignalled)
+                    {
+                        _sourceCompleted = true;
+                        _completionSignalled = true;
+                        downstream.OnError(ex);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SelectManyThenObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SelectManyThenObservable.cs
new file mode 100644
index 0000000..2f161ed
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SelectManyThenObservable.cs
@@ -0,0 +1,112 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Fused <c>.SelectMany(first).SelectMany(second)</c> operator that chains two one-shot
+/// async projections in a single operator allocation. The source emits a value, it's
+/// projected through <paramref name="first"/> producing an intermediate observable, whose
+/// single emission is then projected through <paramref name="second"/> producing the
+/// final result. Errors at any stage propagate to the downstream observer.
+/// </summary>
+/// <typeparam name="TSource">The source element type.</typeparam>
+/// <typeparam name="TMid">The intermediate element type produced by the first projection.</typeparam>
+/// <typeparam name="TResult">The final element type produced by the second projection.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="first">First projection: source element → intermediate observable.</param>
+/// <param name="second">Second projection: intermediate element → result observable.</param>
+internal sealed class SelectManyThenObservable<TSource, TMid, TResult>(
+    IObservable<TSource> source,
+    Func<TSource, IObservable<TMid>> first,
+    Func<TMid, IObservable<TResult>> second) : IObservable<TResult>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TResult> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(first);
+        InvalidOperationExceptionHelper.ThrowIfNull(second);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new SourceObserver(observer, first, second));
+    }
+
+    /// <summary>Receives the source value and subscribes to the first projection. Holds a single
+    /// reusable <see cref="MidObserver"/> created at subscribe time — the mid observer captures
+    /// only <c>downstream</c> and <c>second</c>, so the same instance handles every source emission.</summary>
+    private sealed class SourceObserver : IObserver<TSource>
+    {
+        /// <summary>The downstream observer that ultimately receives <typeparamref name="TResult"/> values.</summary>
+        private readonly IObserver<TResult> _downstream;
+
+        /// <summary>First projection delegate.</summary>
+        private readonly Func<TSource, IObservable<TMid>> _first;
+
+        /// <summary>Pre-allocated intermediate observer shared across every source emission.</summary>
+        private readonly MidObserver _midObserver;
+
+        /// <summary>Initializes a new instance of the <see cref="SourceObserver"/> class and primes the reusable mid observer.</summary>
+        /// <param name="downstream">The downstream observer.</param>
+        /// <param name="first">First projection delegate.</param>
+        /// <param name="second">Second projection delegate.</param>
+        public SourceObserver(
+            IObserver<TResult> downstream,
+            Func<TSource, IObservable<TMid>> first,
+            Func<TMid, IObservable<TResult>> second)
+        {
+            _downstream = downstream;
+            _first = first;
+            _midObserver = new MidObserver(downstream, second);
+        }
+
+        /// <inheritdoc/>
+        public void OnNext(TSource value)
+        {
+            try
+            {
+                _first(value).Subscribe(_midObserver);
+            }
+            catch (Exception ex)
+            {
+                _downstream.OnError(ex);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => _downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => _downstream.OnCompleted();
+    }
+
+    /// <summary>Receives the intermediate value, applies <c>second</c>, and subscribes the resulting
+    /// observable directly to <c>downstream</c> — no separate final-stage observer needed.</summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="second">Second projection delegate.</param>
+    private sealed class MidObserver(
+        IObserver<TResult> downstream,
+        Func<TMid, IObservable<TResult>> second) : IObserver<TMid>
+    {
+        /// <inheritdoc/>
+        public void OnNext(TMid value)
+        {
+            try
+            {
+                second(value).Subscribe(downstream);
+            }
+            catch (Exception ex)
+            {
+                downstream.OnError(ex);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ShuffleObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ShuffleObservable.cs
new file mode 100644
index 0000000..2d30153
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ShuffleObservable.cs
@@ -0,0 +1,82 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Operator that randomly shuffles arrays emitted by the source. The shuffle is not
+/// cryptographically secure — callers needing crypto-grade randomness should compose
+/// <see cref="System.Security.Cryptography.RandomNumberGenerator"/> themselves.
+/// </summary>
+/// <typeparam name="T">The array element type.</typeparam>
+/// <param name="source">The source observable emitting arrays.</param>
+internal sealed class ShuffleObservable<T>(IObservable<T[]> source) : IObservable<T[]>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T[]> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new ShuffleObserver(observer));
+    }
+
+    /// <summary>Observer that shuffles arrays in place.</summary>
+    /// <param name="downstream">The downstream observer receiving shuffled arrays.</param>
+    [SuppressMessage("Security", "CA5394:Do not use insecure randomness", Justification = "Shuffle is non-cryptographic; Random is faster.")]
+    private sealed class ShuffleObserver(IObserver<T[]> downstream) : IObserver<T[]>
+    {
+#if !NET8_0_OR_GREATER
+        /// <summary>Per-thread <see cref="Random"/> used by the netfx fallback path.</summary>
+        [ThreadStatic]
+        private static Random? _threadRandom;
+#endif
+
+        /// <inheritdoc/>
+        public void OnNext(T[] value)
+        {
+            if (value is null)
+            {
+                downstream.OnNext(value!);
+                return;
+            }
+
+#if NET8_0_OR_GREATER
+            Random.Shared.Shuffle(value);
+#else
+            ShuffleInPlace(value);
+#endif
+
+            downstream.OnNext(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+
+#if !NET8_0_OR_GREATER
+        /// <summary>Fisher-Yates over a per-thread <see cref="Random"/> for targets without <c>Random.Shuffle</c>.</summary>
+        /// <param name="array">The array to shuffle in place.</param>
+        private static void ShuffleInPlace(T[] array)
+        {
+            var random = _threadRandom;
+            if (random is null)
+            {
+                random = new Random();
+                _threadRandom = random;
+            }
+
+            for (var n = array.Length - 1; n > 0; n--)
+            {
+                var k = random.Next(n + 1);
+                (array[n], array[k]) = (array[k], array[n]);
+            }
+        }
+#endif
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SkipWhileNullObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SkipWhileNullObservable.cs
new file mode 100644
index 0000000..3955558
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SkipWhileNullObservable.cs
@@ -0,0 +1,62 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Filtering operator that drops leading <see langword="null"/> values, then forwards every value
+/// (including subsequent <see langword="null"/>s) once the latch has opened. Replaces the previous
+/// <c>source.SkipWhile(x =&gt; x == null)</c> composition that delegated to System.Reactive's
+/// <c>SkipWhile</c>, eliminating the per-subscription closure allocation and the extra observer
+/// layer the chain introduced.
+/// </summary>
+/// <typeparam name="T">The element type of the source observable; must be a reference type so the
+/// null check is meaningful.</typeparam>
+/// <param name="source">The source observable.</param>
+internal sealed class SkipWhileNullObservable<T>(IObservable<T> source) : IObservable<T>
+    where T : class
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new SkipWhileNullObserver(observer));
+    }
+
+    /// <summary>
+    /// Forwarding observer that swallows leading <see langword="null"/> values until the first
+    /// non-null value, then becomes a transparent forwarder for the remainder of the sequence.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class SkipWhileNullObserver(IObserver<T> downstream) : IObserver<T>
+    {
+        /// <summary>Latches to <see langword="true"/> after the first non-null value has been forwarded.</summary>
+        private bool _gateOpen;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            if (!_gateOpen)
+            {
+                if (value is null)
+                {
+                    return;
+                }
+
+                _gateOpen = true;
+            }
+
+            downstream.OnNext(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/StartActionObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/StartActionObservable.cs
new file mode 100644
index 0000000..94571e1
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/StartActionObservable.cs
@@ -0,0 +1,61 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Operator that runs an action and completes immediately.
+/// </summary>
+/// <param name="action">The action to run.</param>
+/// <param name="scheduler">An optional scheduler; <c>null</c> runs the action synchronously inline.</param>
+internal sealed class StartActionObservable(Action action, ISequencer? scheduler) : IObservable<RxVoid>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<RxVoid> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(action);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        if (scheduler is null)
+        {
+            Run(observer, action);
+            return EmptyDisposable.Instance;
+        }
+
+        var capturedObserver = observer;
+        var capturedAction = action;
+        return scheduler.Schedule((capturedObserver, capturedAction), static (_, state) =>
+        {
+            Run(state.capturedObserver, state.capturedAction);
+            return EmptyDisposable.Instance;
+        });
+    }
+
+    /// <summary>
+    /// Runs <paramref name="action"/> and signals <paramref name="observer"/>
+    /// with <see cref="RxVoid.Default"/> followed by completion. Exceptions
+    /// thrown by the action are forwarded to <see cref="IObserver{T}.OnError"/>.
+    /// </summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="action">The action to invoke.</param>
+    private static void Run(IObserver<RxVoid> observer, Action action)
+    {
+        try
+        {
+            action();
+        }
+        catch (Exception error)
+        {
+            observer.OnError(error);
+            return;
+        }
+
+        observer.OnNext(RxVoid.Default);
+        observer.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/StartFuncObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/StartFuncObservable.cs
new file mode 100644
index 0000000..a2a1262
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/StartFuncObservable.cs
@@ -0,0 +1,66 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Runs the function once — inline when no scheduler is supplied, otherwise on the scheduler —
+/// emits the result, then completes.
+/// </summary>
+/// <typeparam name="TResult">Result type.</typeparam>
+/// <param name="function">Function to run.</param>
+/// <param name="scheduler">Optional scheduler; null runs inline.</param>
+internal sealed class StartFuncObservable<TResult>(
+    Func<TResult> function,
+    ISequencer? scheduler) : IObservable<TResult>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TResult> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(function);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        if (scheduler is null)
+        {
+            Run(observer, function);
+            return EmptyDisposable.Instance;
+        }
+
+        var capturedObserver = observer;
+        var capturedFunction = function;
+        return scheduler.Schedule((capturedObserver, capturedFunction), static (_, state) =>
+        {
+            Run(state.capturedObserver, state.capturedFunction);
+            return EmptyDisposable.Instance;
+        });
+    }
+
+    /// <summary>
+    /// Runs <paramref name="function"/> and signals <paramref name="observer"/>
+    /// with the result followed by completion. Exceptions thrown by the function
+    /// are forwarded to <see cref="IObserver{T}.OnError"/>.
+    /// </summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="function">The function to invoke.</param>
+    private static void Run(IObserver<TResult> observer, Func<TResult> function)
+    {
+        TResult result;
+        try
+        {
+            result = function();
+        }
+        catch (Exception error)
+        {
+            observer.OnError(error);
+            return;
+        }
+
+        observer.OnNext(result);
+        observer.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SubscribeAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SubscribeAsyncObservable.cs
new file mode 100644
index 0000000..cc87504
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SubscribeAsyncObservable.cs
@@ -0,0 +1,168 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Subscribes to an observable sequence and executes an asynchronous handler for each element.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+internal sealed class SubscribeAsyncObservable<T> : IDisposable
+{
+    /// <summary>The gate for state access.</summary>
+    private readonly Lock _gate = new();
+
+    /// <summary>Queue of values to process.</summary>
+    private readonly Queue<T> _queue = new();
+
+    /// <summary>The subscription to the source sequence.</summary>
+    private readonly IDisposable _subscription;
+
+    /// <summary>The asynchronous element handler.</summary>
+    private readonly Func<T, ValueTask> _onNext;
+
+    /// <summary>The error handler.</summary>
+    private readonly Action<Exception>? _onError;
+
+    /// <summary>The completion handler.</summary>
+    private readonly Action? _onCompleted;
+
+    /// <summary>Whether an async operation is currently in progress.</summary>
+    private bool _isProcessing;
+
+    /// <summary>Whether the source has completed.</summary>
+    private bool _done;
+
+    /// <summary>Whether the sink has been disposed.</summary>
+    private bool _disposed;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SubscribeAsyncObservable{T}"/> class.
+    /// </summary>
+    /// <param name="source">The source observable.</param>
+    /// <param name="onNext">The asynchronous element handler.</param>
+    /// <param name="onError">The error handler.</param>
+    /// <param name="onCompleted">The completion handler.</param>
+    public SubscribeAsyncObservable(
+        IObservable<T> source,
+        Func<T, ValueTask> onNext,
+        Action<Exception>? onError = null,
+        Action? onCompleted = null)
+    {
+        _onNext = onNext;
+        _onError = onError;
+        _onCompleted = onCompleted;
+        _subscription = source.SubscribeCallbacks(OnNext, OnError, OnCompleted);
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            _disposed = true;
+            _subscription.Dispose();
+        }
+    }
+
+    /// <summary>Called when a new value is emitted by the source.</summary>
+    /// <param name="value">The value emitted by the source.</param>
+    private void OnNext(T value)
+    {
+        lock (_gate)
+        {
+            if (_done || _disposed)
+            {
+                return;
+            }
+
+            _queue.Enqueue(value);
+            if (!_isProcessing)
+            {
+                _isProcessing = true;
+                _ = ProcessNextAsync();
+            }
+        }
+    }
+
+    /// <summary>Called when an error occurs in the source.</summary>
+    /// <param name="error">The error that occurred.</param>
+    private void OnError(Exception error)
+    {
+        lock (_gate)
+        {
+            if (_done || _disposed)
+            {
+                return;
+            }
+
+            _done = true;
+            _onError?.Invoke(error);
+        }
+    }
+
+    /// <summary>Called when the source completes.</summary>
+    private void OnCompleted()
+    {
+        lock (_gate)
+        {
+            if (_done || _disposed)
+            {
+                return;
+            }
+
+            _done = true;
+            if (!_isProcessing)
+            {
+                _onCompleted?.Invoke();
+            }
+        }
+    }
+
+    /// <summary>Processes the next value in the queue.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    private async Task ProcessNextAsync()
+    {
+        while (true)
+        {
+            T value;
+            lock (_gate)
+            {
+                if (_disposed || _queue.Count == 0)
+                {
+                    _isProcessing = false;
+                    if (_done && !_disposed)
+                    {
+                        _onCompleted?.Invoke();
+                    }
+
+                    return;
+                }
+
+                value = _queue.Dequeue();
+            }
+
+            try
+            {
+                await _onNext(value).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                lock (_gate)
+                {
+                    if (!_disposed)
+                    {
+                        _done = true;
+                        _onError?.Invoke(ex);
+                    }
+
+                    _isProcessing = false;
+                    return;
+                }
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SwitchIfEmptyObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SwitchIfEmptyObservable.cs
new file mode 100644
index 0000000..662cba4
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SwitchIfEmptyObservable.cs
@@ -0,0 +1,124 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Provides a fallback observable if the source sequence completes without emitting any elements.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="fallback">The fallback observable.</param>
+internal sealed class SwitchIfEmptyObservable<T>(
+    IObservable<T> source,
+    IObservable<T> fallback) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(fallback);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new SwitchIfEmptySink(observer, fallback);
+        var sub = source.Subscribe(sink);
+        sink.SetSubscription(sub);
+        return sink;
+    }
+
+    /// <summary>
+    /// The sink for the <see cref="SwitchIfEmptyObservable{T}"/>.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="fallback">The fallback observable.</param>
+    private sealed class SwitchIfEmptySink(
+        IObserver<T> downstream,
+        IObservable<T> fallback) : IObserver<T>, IDisposable
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>The current subscription.</summary>
+        private readonly MutableDisposable _subscription = new();
+
+        /// <summary>Whether the source has emitted a value.</summary>
+        private bool _hasValue;
+
+        /// <summary>Whether the sink has completed or been disposed.</summary>
+        private bool _done;
+
+        /// <summary>
+        /// Sets the subscription to the source observable.
+        /// </summary>
+        /// <param name="sub">The subscription.</param>
+        public void SetSubscription(IDisposable sub) => _subscription.Disposable = sub;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _hasValue = true;
+            }
+
+            downstream.OnNext(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                if (_hasValue)
+                {
+                    _done = true;
+                    downstream.OnCompleted();
+                }
+                else
+                {
+                    // Source was empty, switch to fallback
+                    _subscription.Disposable = fallback.Subscribe(downstream);
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _done = true;
+                _subscription.Dispose();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SyncTimerObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SyncTimerObservable.cs
new file mode 100644
index 0000000..9f2f0bd
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SyncTimerObservable.cs
@@ -0,0 +1,145 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.Concurrent;
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Optimized operator that shares a single timer per <c>(TimeSpan, ISequencer)</c> key.
+/// Replaces the manual <c>ConcurrentDictionary&lt;..., Lazy&lt;SharedTimer&gt;&gt;</c> shape with a stateful
+/// <c>ConcurrentDictionary.GetOrAdd</c> overload that doesn't allocate a
+/// <see cref="Lazy{T}"/> or its factory delegate on the hot path.
+/// </summary>
+internal static class SyncTimerObservable
+{
+    /// <summary>The timer cache, keyed by <c>(TimeSpan, ISequencer)</c>.</summary>
+    private static readonly ConcurrentDictionary<(TimeSpan TimeSpan, ISequencer Scheduler), SharedTimer>
+        _timerList = [];
+
+    /// <summary>Static factory passed to <c>ConcurrentDictionary.GetOrAdd</c>;
+    /// avoids a per-call delegate allocation.</summary>
+    private static readonly Func<(TimeSpan TimeSpan, ISequencer Scheduler), SharedTimer> _create =
+        static key => new SharedTimer(key.TimeSpan, key.Scheduler);
+
+    /// <summary>
+    /// Gets a shared timer for the specified period and scheduler.
+    /// </summary>
+    /// <param name="timeSpan">The period.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <returns>A shared observable sequence of timer ticks.</returns>
+    public static IObservable<DateTime> Get(TimeSpan timeSpan, ISequencer scheduler)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(scheduler);
+
+        return _timerList.GetOrAdd((timeSpan, scheduler), _create);
+    }
+
+    /// <summary>
+    /// A manual implementation of a connectable timer that minimizes allocations and unrolls Rx chains.
+    /// Tick uses a swap-on-write <see cref="IObserver{DateTime}"/> array so the read path is allocation-free
+    /// and lock-free; subscribe / unsubscribe takes the gate and publishes a fresh array.
+    /// </summary>
+    /// <param name="timeSpan">The period.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    private sealed class SharedTimer(TimeSpan timeSpan, ISequencer scheduler) : IObservable<DateTime>
+    {
+        /// <summary>Sentinel empty observer array, shared so unsubscribing the last observer doesn't allocate.</summary>
+        private static readonly IObserver<DateTime>[] _emptyObservers = [];
+
+        /// <summary>The gate for subscribe/unsubscribe writes.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// Snapshot of currently active observers. Replaced (not mutated) on subscribe / unsubscribe under
+        /// <see cref="_gate"/>. The tick path reads this via <c>Volatile.Read</c> with no lock and no
+        /// allocation.
+        /// </summary>
+        private IObserver<DateTime>[] _observers = _emptyObservers;
+
+        /// <summary>The active timer subscription, or <see langword="null"/> when no observers are attached.</summary>
+        private IDisposable? _timerSubscription;
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<DateTime> observer)
+        {
+            ArgumentExceptionHelper.ThrowIfNull(observer);
+
+            lock (_gate)
+            {
+                var current = _observers;
+                var copy = new IObserver<DateTime>[current.Length + 1];
+                for (var i = 0; i < current.Length; i++)
+                {
+                    copy[i] = current[i];
+                }
+
+                copy[current.Length] = observer;
+                Volatile.Write(ref _observers, copy);
+
+                _timerSubscription ??= scheduler.SchedulePeriodic(TimeSpan.Zero, timeSpan, Tick);
+            }
+
+            return new TimerSubscription(this, observer);
+        }
+
+        /// <summary>Ticks every currently-subscribed observer with the scheduler's current time.
+        /// The empty-array short-circuit lives in <see cref="ObserverArrayHelpers.Broadcast{T}"/>
+        /// (excluded from coverage) so this hot path stays branchless on the steady state.</summary>
+        private void Tick() =>
+            ObserverArrayHelpers.Broadcast(Volatile.Read(ref _observers), scheduler.Now.DateTime);
+
+        /// <summary>Removes <paramref name="observer"/> from the observer set, stopping the timer when the set becomes empty.</summary>
+        /// <param name="observer">The observer to remove.</param>
+        private void Remove(IObserver<DateTime> observer)
+        {
+            lock (_gate)
+            {
+                // TimerSubscription.Dispose's Interlocked guard ensures Remove is called at most
+                // once per subscription, and each subscription's observer was placed in _observers
+                // under this same lock before the disposable was returned — so RemoveOrNull always
+                // locates the observer by construction.
+                var updated = ObserverArrayHelpers.RemoveOrNull(_observers, observer, _emptyObservers)!;
+
+                Volatile.Write(ref _observers, updated);
+                if (ReferenceEquals(updated, _emptyObservers))
+                {
+                    // Subscribe sets _timerSubscription on first add, before the disposable is
+                    // returned; if we reach the "all observers gone" branch, at least one Subscribe
+                    // ran, so _timerSubscription is non-null by construction.
+                    _timerSubscription!.Dispose();
+                    _timerSubscription = null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Per-subscribe disposable. Holding <c>(parent, observer)</c> as fields instead of capturing them in
+        /// a lambda removes the per-subscribe closure allocation that <see cref="ActionDisposable"/> would
+        /// have required.
+        /// </summary>
+        /// <param name="parent">The owning timer.</param>
+        /// <param name="observer">The observer to remove on dispose.</param>
+        private sealed class TimerSubscription(SharedTimer parent, IObserver<DateTime> observer) : IDisposable
+        {
+            /// <summary>0 = active, 1 = disposed.</summary>
+            private int _disposed;
+
+            /// <inheritdoc/>
+            public void Dispose()
+            {
+                if (Interlocked.Exchange(ref _disposed, 1) == 1)
+                {
+                    return;
+                }
+
+                parent.Remove(observer);
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/SynchronizeAsyncObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/SynchronizeAsyncObservable.cs
new file mode 100644
index 0000000..e54222b
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/SynchronizeAsyncObservable.cs
@@ -0,0 +1,174 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Wraps elements in a synchronization context that waits for a disposal signal before proceeding to the next element.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+internal sealed class SynchronizeAsyncObservable<T>(IObservable<T> source) : IObservable<(T Value, IDisposable Sync)>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<(T Value, IDisposable Sync)> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new SynchronizeAsyncSink(observer);
+        var sub = source.Subscribe(sink);
+        return new DisposableBag(sub, sink);
+    }
+
+    /// <summary>
+    /// The sink for the <see cref="SynchronizeAsyncObservable{T}"/>.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class SynchronizeAsyncSink(IObserver<(T Value, IDisposable Sync)> downstream)
+        : IObserver<T>, IDisposable
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>Whether the sink has completed.</summary>
+        private bool _done;
+
+        /// <summary>Whether the sink has been disposed.</summary>
+        private bool _disposed;
+
+        /// <inheritdoc/>
+        /// <param name="value">The value.</param>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+            }
+
+            // Implementation note: The original used 'new Continuation().Lock(item, observer)'.
+            // This is complex and stateful, so we maintain that logic in a way that respects sequentiality.
+            _ = ProcessAsync(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done || _disposed)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnCompleted();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Processes the value. Pushes <c>(value, signal)</c> downstream and waits for the consumer
+        /// to dispose the signal. The fast path (consumer disposes synchronously inside <c>OnNext</c>)
+        /// returns a completed task without allocating a state machine or <see cref="TaskCompletionSource"/>;
+        /// the slow path (consumer defers disposal) lazily promotes the signal to a TCS-backed gate.
+        /// </summary>
+        /// <param name="value">The value to process.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        private Task ProcessAsync(T value)
+        {
+            var signal = new SyncSignal();
+            downstream.OnNext((value, signal));
+            return signal.WaitForDisposeAsync();
+        }
+
+        /// <summary>
+        /// Per-emission gate: the downstream receives this handle as <c>Sync</c>. The producer
+        /// calls <see cref="WaitForDisposeAsync"/> after pushing the value; synchronous disposal
+        /// short-circuits to <see cref="Task.CompletedTask"/> with no TCS allocation. Late
+        /// (asynchronous) disposal lazily allocates a single <see cref="TaskCompletionSource"/>.
+        /// </summary>
+        private sealed class SyncSignal : IDisposable
+        {
+            /// <summary>The lazily-created completion source; only allocated on the slow path.</summary>
+            private TaskCompletionSource? _tcs;
+
+            /// <summary>Latches to <c>1</c> on the first dispose so signalling is idempotent.</summary>
+            private int _disposed;
+
+            /// <summary>Returns the task the producer should await before completing the emission.
+            /// The producer calls this exactly once per signal, so the TCS is published with a plain
+            /// volatile write rather than a compare-exchange.</summary>
+            /// <returns>A completed task if the consumer already disposed; otherwise the lazily-allocated TCS task.</returns>
+            public Task WaitForDisposeAsync()
+            {
+                if (Volatile.Read(ref _disposed) == 1)
+                {
+                    return Task.CompletedTask;
+                }
+
+                var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                Volatile.Write(ref _tcs, tcs);
+                CompleteIfDisposedRaced(tcs);
+                return tcs.Task;
+            }
+
+            /// <inheritdoc/>
+            public void Dispose()
+            {
+                if (Interlocked.Exchange(ref _disposed, 1) != 0)
+                {
+                    return;
+                }
+
+                Volatile.Read(ref _tcs)?.TrySetResult();
+            }
+
+            /// <summary>Self-completes the just-published TCS if a dispose raced ahead of the publish and could
+            /// not see it, so the producer's await never hangs.</summary>
+            /// <param name="tcs">The completion source published for this signal.</param>
+            /// <remarks>The set-result is only taken when a concurrent dispose latches between the publish and
+            /// this re-check; isolated here and excluded from coverage as race-only.</remarks>
+            [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+            private void CompleteIfDisposedRaced(TaskCompletionSource tcs)
+            {
+                if (Volatile.Read(ref _disposed) != 1)
+                {
+                    return;
+                }
+
+                tcs.TrySetResult();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/TakeUntilInclusiveObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/TakeUntilInclusiveObservable.cs
new file mode 100644
index 0000000..6e88e3f
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/TakeUntilInclusiveObservable.cs
@@ -0,0 +1,111 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Takes elements from the source sequence until a predicate returns true for an element.
+/// The element that satisfies the predicate is included in the sequence.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="predicate">The predicate to determine when to stop taking elements.</param>
+internal sealed class TakeUntilInclusiveObservable<T>(
+    IObservable<T> source,
+    Func<T, bool> predicate) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(predicate);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        return source.Subscribe(new TakeUntilInclusiveObserver(observer, predicate));
+    }
+
+    /// <summary>
+    /// The observer for the <see cref="TakeUntilInclusiveObservable{T}"/>.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="predicate">The predicate to determine when to stop taking elements.</param>
+    private sealed class TakeUntilInclusiveObserver(
+        IObserver<T> downstream,
+        Func<T, bool> predicate) : IObserver<T>
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>Whether the observer is done.</summary>
+        private bool _done;
+
+        /// <inheritdoc/>
+        /// <param name="value">The value.</param>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                bool isMatch;
+                try
+                {
+                    isMatch = predicate(value);
+                }
+                catch (Exception ex)
+                {
+                    _done = true;
+                    downstream.OnError(ex);
+                    return;
+                }
+
+                downstream.OnNext(value);
+
+                if (!isMatch)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnCompleted();
+            }
+        }
+
+        /// <inheritdoc/>
+        /// <param name="error">The error.</param>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnCompleted();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleDistinctObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleDistinctObservable.cs
new file mode 100644
index 0000000..bb7da82
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleDistinctObservable.cs
@@ -0,0 +1,122 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Throttles a sequence and ensures only distinct values are emitted.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="throttle">The throttle duration.</param>
+/// <param name="scheduler">The scheduler to use for timing.</param>
+internal sealed class ThrottleDistinctObservable<T>(
+    IObservable<T> source,
+    TimeSpan throttle,
+    ISequencer scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        // Implementation of .DistinctUntilChanged().Throttle(throttle, scheduler).DistinctUntilChanged()
+        // But fused into a single sink to avoid multiple operator allocations and observer chains.
+        var sink = new ThrottleDistinctSink(observer, throttle, scheduler);
+        var subscription = source.Subscribe(sink);
+        return new DisposableBag(subscription, sink);
+    }
+
+    /// <summary>
+    /// Sink that implements the throttle distinct logic. Composes <see cref="TimerSinkState{T}"/>
+    /// for the shared gate / timer / done-flag plumbing so this class only carries the throttle
+    /// and distinct-value tracking.
+    /// </summary>
+    /// <param name="downstream">The observer to forward elements to.</param>
+    /// <param name="throttle">The throttle duration.</param>
+    /// <param name="scheduler">The scheduler to use for timing.</param>
+    private sealed class ThrottleDistinctSink(
+        IObserver<T> downstream,
+        TimeSpan throttle,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>Shared gate / timer / done-flag plumbing.</summary>
+        private readonly TimerSinkState<T> _state = new(downstream);
+
+        /// <summary>The last emitted value.</summary>
+        private T? _lastEmitted;
+
+        /// <summary>The last received value.</summary>
+        private T? _lastReceived;
+
+        /// <summary>Whether a value has been received but not yet emitted.</summary>
+        private bool _hasLastReceived;
+
+        /// <summary>Whether any value has been emitted yet.</summary>
+        private bool _hasLastEmitted;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_state.Gate)
+            {
+                if (_state.Done)
+                {
+                    return;
+                }
+
+                if (_hasLastEmitted && EqualityComparer<T>.Default.Equals(value, _lastEmitted!))
+                {
+                    _hasLastReceived = false;
+                    _state.Timer.Disposable = null;
+                    return;
+                }
+
+                _lastReceived = value;
+                _hasLastReceived = true;
+                _state.Timer.Disposable = scheduler.Schedule(throttle, Emit);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => _state.HandleError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => _state.HandleCompleted();
+
+        /// <inheritdoc/>
+        public void Dispose() => _state.HandleDispose();
+
+        /// <summary>Emits the last received value if it differs from the last emitted value.
+        /// Marked <c>[ExcludeFromCodeCoverage]</c> because the in-lock
+        /// race-loser branch (sink done or no buffered value) is only reachable when the
+        /// scheduled callback fires concurrently with Dispose / OnCompleted, which the
+        /// single-threaded test harness cannot trigger.</summary>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        private void Emit()
+        {
+            T? toEmit;
+            lock (_state.Gate)
+            {
+                if (_state.Done || !_hasLastReceived)
+                {
+                    return;
+                }
+
+                toEmit = _lastReceived;
+                _lastEmitted = toEmit;
+                _hasLastEmitted = true;
+                _hasLastReceived = false;
+            }
+
+            downstream.OnNext(toEmit!);
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleFirstObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleFirstObservable.cs
new file mode 100644
index 0000000..ac39353
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleFirstObservable.cs
@@ -0,0 +1,122 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Throttles a sequence by only emitting the first element in each window.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="window">The window duration.</param>
+/// <param name="scheduler">The scheduler to use for timing.</param>
+internal sealed class ThrottleFirstObservable<T>(
+    IObservable<T> source,
+    TimeSpan window,
+    ISequencer scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        return source.Subscribe(new ThrottleFirstObserver(observer, window, scheduler));
+    }
+
+    /// <summary>
+    /// Observer that implements the throttle first logic.
+    /// </summary>
+    /// <param name="downstream">The observer to forward elements to.</param>
+    /// <param name="window">The window duration.</param>
+    /// <param name="scheduler">The scheduler to use for timing.</param>
+    private sealed class ThrottleFirstObserver(
+        IObserver<T> downstream,
+        TimeSpan window,
+        ISequencer scheduler) : IObserver<T>
+    {
+        /// <summary>
+        /// The gate to synchronize access to the observer state.
+        /// </summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// The last time an element was emitted.
+        /// </summary>
+        private DateTimeOffset _last;
+
+        /// <summary>
+        /// Whether at least one element has been emitted.
+        /// </summary>
+        private bool _hasLast;
+
+        /// <summary>
+        /// Whether the observer has finished.
+        /// </summary>
+        private bool _done;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            var now = scheduler.Now;
+            bool emit;
+
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                emit = !_hasLast || now - _last >= window;
+                if (emit)
+                {
+                    _last = now;
+                    _hasLast = true;
+                }
+            }
+
+            if (!emit)
+            {
+                return;
+            }
+
+            downstream.OnNext(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnCompleted();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleObservable.cs
new file mode 100644
index 0000000..b396856
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleObservable.cs
@@ -0,0 +1,175 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Classic throttle (debounce) operator. Emits a value only after
+/// <paramref name="dueTime"/> has elapsed without any new emission from the
+/// source. Each new upstream <c>OnNext</c> cancels the pending emission and
+/// schedules a new one. Provides the equivalent of Rx's
+/// <c>Observable.Throttle</c> without depending on System.Reactive.Linq.
+/// </summary>
+/// <typeparam name="T">The element type of the source observable.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="dueTime">The quiescence duration required before emission.</param>
+/// <param name="scheduler">The scheduler used to time emissions.</param>
+internal sealed class ThrottleObservable<T>(
+    IObservable<T> source,
+    TimeSpan dueTime,
+    ISequencer scheduler) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new ThrottleSink(observer, dueTime, scheduler);
+        var subscription = source.Subscribe(sink);
+        return new DisposableBag(subscription, sink);
+    }
+
+    /// <summary>
+    /// Sink that holds the most-recent value and a scheduled emission that
+    /// fires after the configured quiescence interval.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="dueTime">The quiescence duration.</param>
+    /// <param name="scheduler">The scheduler used to time emissions.</param>
+    private sealed class ThrottleSink(
+        IObserver<T> downstream,
+        TimeSpan dueTime,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>The synchronization gate.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>The pending scheduled emission.</summary>
+        private readonly SwapDisposable _pending = new();
+
+        /// <summary>The most-recent value waiting to be emitted.</summary>
+        private T _latest = default!;
+
+        /// <summary>Whether a value is currently pending emission.</summary>
+        private bool _hasValue;
+
+        /// <summary>Monotonic id of the latest scheduled emission.</summary>
+        private long _emissionId;
+
+        /// <summary>Whether the sequence is terminally done.</summary>
+        private bool _done;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            long id;
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _latest = value;
+                _hasValue = true;
+                id = ++_emissionId;
+            }
+
+            _pending.Disposable = scheduler.Schedule((this, id), dueTime, static (_, state) =>
+            {
+                state.Item1.Emit(state.id);
+                return EmptyDisposable.Instance;
+            });
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+            }
+
+            _pending.Dispose();
+            downstream.OnError(error);
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            T pending;
+            bool flush;
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                flush = _hasValue;
+                pending = _latest;
+                _hasValue = false;
+            }
+
+            _pending.Dispose();
+
+            if (flush)
+            {
+                downstream.OnNext(pending);
+            }
+
+            downstream.OnCompleted();
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _done = true;
+            }
+
+            _pending.Dispose();
+        }
+
+        /// <summary>
+        /// Emits the buffered value if it is still current (i.e. no newer
+        /// <see cref="OnNext"/> arrived after this emission was scheduled).
+        /// Marked <c>[ExcludeFromCodeCoverage]</c> because the in-lock
+        /// race-loser branch (sink done, emission superseded, value already drained) is only
+        /// reachable when the scheduled callback fires concurrently with Dispose / OnCompleted,
+        /// which the single-threaded test harness cannot trigger.
+        /// </summary>
+        /// <param name="id">The emission id this callback was scheduled for.</param>
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        private void Emit(long id)
+        {
+            T value;
+            lock (_gate)
+            {
+                if (_done || id != _emissionId || !_hasValue)
+                {
+                    return;
+                }
+
+                value = _latest;
+                _hasValue = false;
+            }
+
+            downstream.OnNext(value);
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleUntilTrueObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleUntilTrueObservable.cs
new file mode 100644
index 0000000..8908ae5
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/ThrottleUntilTrueObservable.cs
@@ -0,0 +1,169 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Throttles a sequence until a predicate becomes true for an element.
+/// </summary>
+/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="throttle">The throttle duration.</param>
+/// <param name="predicate">The predicate to determine if an element should be emitted immediately or throttled.</param>
+internal sealed class ThrottleUntilTrueObservable<T>(
+    IObservable<T> source,
+    TimeSpan throttle,
+    Func<T, bool> predicate) : IObservable<T>
+{
+    /// <summary>
+    /// The source observable.
+    /// </summary>
+    private readonly IObservable<T> _source = InvalidOperationExceptionHelper.Check(source);
+
+    /// <summary>
+    /// The throttle duration.
+    /// </summary>
+    private readonly TimeSpan _throttle = throttle;
+
+    /// <summary>
+    /// The predicate to determine if an element should be emitted immediately or throttled.
+    /// </summary>
+    private readonly Func<T, bool> _predicate = InvalidOperationExceptionHelper.Check(predicate);
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new ThrottleUntilTrueSink(observer, _throttle, _predicate, Sequencer.Default);
+        var subscription = _source.Subscribe(sink);
+        return new DisposableBag(subscription, sink);
+    }
+
+    /// <summary>
+    /// Sinks the source observable and throttles elements until a predicate is true.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="throttle">The throttle duration.</param>
+    /// <param name="predicate">The predicate.</param>
+    /// <param name="scheduler">The scheduler used to time throttled emissions.</param>
+    private sealed class ThrottleUntilTrueSink(
+        IObserver<T> downstream,
+        TimeSpan throttle,
+        Func<T, bool> predicate,
+        ISequencer scheduler) : IObserver<T>, IDisposable
+    {
+        /// <summary>
+        /// The gate for synchronization.
+        /// </summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>
+        /// The downstream observer.
+        /// </summary>
+        private readonly IObserver<T> _downstream = downstream;
+
+        /// <summary>
+        /// The throttle duration.
+        /// </summary>
+        private readonly TimeSpan _throttle = throttle;
+
+        /// <summary>
+        /// The predicate.
+        /// </summary>
+        private readonly Func<T, bool> _predicate = predicate;
+
+        /// <summary>
+        /// The timer for throttling.
+        /// </summary>
+        private readonly SwapDisposable _timer = new();
+
+        /// <summary>
+        /// Whether the sequence is done.
+        /// </summary>
+        private bool _done;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                if (_predicate(value))
+                {
+                    _timer.Disposable = null;
+                    _downstream.OnNext(value);
+                }
+                else
+                {
+                    _timer.Disposable = scheduler.Schedule(
+                        (sink: this, value),
+                        _throttle,
+                        static (_, state) =>
+                        {
+                            lock (state.sink._gate)
+                            {
+                                if (!state.sink._done)
+                                {
+                                    state.sink._downstream.OnNext(state.value);
+                                }
+                            }
+
+                            return EmptyDisposable.Instance;
+                        });
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                _timer.Dispose();
+                _downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                _timer.Dispose();
+                _downstream.OnCompleted();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                _done = true;
+                _timer.Dispose();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/TrySelectObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/TrySelectObservable.cs
new file mode 100644
index 0000000..3e6e2c5
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/TrySelectObservable.cs
@@ -0,0 +1,69 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Fused <c>.Select(selector).Where(x =&gt; x is not null).Select(x =&gt; x!)</c> operator
+/// that applies a transform and emits only non-null results. Replaces the 3-operator
+/// null-filtering chain with a single operator + observer allocation.
+/// </summary>
+/// <typeparam name="TIn">The source element type.</typeparam>
+/// <typeparam name="TOut">The projected element type.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="selector">Projection that may return <see langword="null"/> for elements that should be skipped.</param>
+internal sealed class TrySelectObservable<TIn, TOut>(
+    IObservable<TIn> source,
+    Func<TIn, TOut?> selector) : IObservable<TOut>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TOut> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(selector);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new TrySelectObserver(observer, selector));
+    }
+
+    /// <summary>
+    /// Observer that applies the selector and only forwards non-null results.
+    /// Exceptions from the selector are routed to <see cref="IObserver{T}.OnError"/>.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="selector">The projection delegate.</param>
+    private sealed class TrySelectObserver(
+        IObserver<TOut> downstream,
+        Func<TIn, TOut?> selector) : IObserver<TIn>
+    {
+        /// <inheritdoc/>
+        public void OnNext(TIn value)
+        {
+            TOut? projected;
+            try
+            {
+                projected = selector(value);
+            }
+            catch (Exception ex)
+            {
+                downstream.OnError(ex);
+                return;
+            }
+
+            if (projected is null)
+            {
+                return;
+            }
+
+            downstream.OnNext(projected);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/UsingActionObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/UsingActionObservable.cs
new file mode 100644
index 0000000..c49bced
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/UsingActionObservable.cs
@@ -0,0 +1,83 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Resource-bound factory observable that runs an optional
+/// <see cref="Action{T}"/> against a captured <see cref="IDisposable"/>
+/// resource, emits <see cref="RxVoid.Default"/>, completes, and finally disposes
+/// the resource. Replaces the legacy
+/// <c>Observable.Using(() =&gt; obj, id =&gt; Observable.Start(...))</c> pattern.
+/// </summary>
+/// <typeparam name="T">The disposable resource type.</typeparam>
+/// <param name="resource">The resource to use during the operation and dispose at the end.</param>
+/// <param name="action">An optional action invoked against the resource.</param>
+/// <param name="scheduler">An optional scheduler; <c>null</c> runs the action synchronously inline.</param>
+internal sealed class UsingActionObservable<T>(
+    T resource,
+    Action<T>? action,
+    ISequencer? scheduler) : IObservable<RxVoid>
+    where T : IDisposable
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<RxVoid> observer)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        if (scheduler is null)
+        {
+            Run(observer, resource, action);
+            return EmptyDisposable.Instance;
+        }
+
+        var capturedObserver = observer;
+        var capturedResource = resource;
+        var capturedAction = action;
+        return scheduler.Schedule(
+            (capturedObserver, capturedResource, capturedAction),
+            static (_, state) =>
+            {
+                Run(state.capturedObserver, state.capturedResource, state.capturedAction);
+                return EmptyDisposable.Instance;
+            });
+    }
+
+    /// <summary>
+    /// Invokes the optional action against the resource, signals
+    /// <see cref="RxVoid.Default"/> and completion, then disposes the resource.
+    /// </summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="resource">The resource to use and dispose.</param>
+    /// <param name="action">The optional action.</param>
+    private static void Run(IObserver<RxVoid> observer, T resource, Action<T>? action)
+    {
+        try
+        {
+            action?.Invoke(resource);
+        }
+        catch (Exception error)
+        {
+            try
+            {
+                resource?.Dispose();
+            }
+            catch
+            {
+                // Swallow secondary dispose failure; the primary exception is what callers care about.
+            }
+
+            observer.OnError(error);
+            return;
+        }
+
+        observer.OnNext(RxVoid.Default);
+        observer.OnCompleted();
+        resource?.Dispose();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/UsingFuncObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/UsingFuncObservable.cs
new file mode 100644
index 0000000..39008a7
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/UsingFuncObservable.cs
@@ -0,0 +1,85 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Resource-bound factory observable that runs a <see cref="Func{T, TResult}"/>
+/// against a captured <see cref="IDisposable"/> resource, emits the result,
+/// completes, and finally disposes the resource. Replaces the legacy
+/// <c>Observable.Using(() =&gt; obj, id =&gt; Observable.Start(() =&gt; func(id)))</c> pattern.
+/// </summary>
+/// <typeparam name="T">The disposable resource type.</typeparam>
+/// <typeparam name="TResult">The result type emitted to the downstream observer.</typeparam>
+/// <param name="resource">The resource to use during the operation and dispose at the end.</param>
+/// <param name="function">The function invoked against the resource to produce the emitted value.</param>
+/// <param name="scheduler">An optional scheduler; <c>null</c> runs the function synchronously inline.</param>
+internal sealed class UsingFuncObservable<T, TResult>(
+    T resource,
+    Func<T, TResult> function,
+    ISequencer? scheduler) : IObservable<TResult>
+    where T : IDisposable
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TResult> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(function);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        if (scheduler is null)
+        {
+            Run(observer, resource, function);
+            return EmptyDisposable.Instance;
+        }
+
+        var capturedObserver = observer;
+        var capturedResource = resource;
+        var capturedFunction = function;
+        return scheduler.Schedule(
+            (capturedObserver, capturedResource, capturedFunction),
+            static (_, state) =>
+            {
+                Run(state.capturedObserver, state.capturedResource, state.capturedFunction);
+                return EmptyDisposable.Instance;
+            });
+    }
+
+    /// <summary>
+    /// Invokes the function against the resource, signals the produced value
+    /// followed by completion, then disposes the resource.
+    /// </summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="resource">The resource to use and dispose.</param>
+    /// <param name="function">The function invoked against the resource.</param>
+    private static void Run(IObserver<TResult> observer, T resource, Func<T, TResult> function)
+    {
+        TResult result;
+        try
+        {
+            result = function(resource);
+        }
+        catch (Exception error)
+        {
+            try
+            {
+                resource?.Dispose();
+            }
+            catch
+            {
+                // Swallow secondary dispose failure; the primary exception is what callers care about.
+            }
+
+            observer.OnError(error);
+            return;
+        }
+
+        observer.OnNext(result);
+        observer.OnCompleted();
+        resource?.Dispose();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/WaitUntilObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/WaitUntilObservable.cs
new file mode 100644
index 0000000..7e26f0b
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/WaitUntilObservable.cs
@@ -0,0 +1,121 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Fused <c>Where(predicate).Take(1)</c>. Subscribes a single observer to the source,
+/// emits the first value satisfying <paramref name="predicate"/> followed by
+/// <see cref="IObserver{T}.OnCompleted"/>, then disposes the source subscription —
+/// avoiding the two intermediate observer wrappers that the equivalent Rx chain would
+/// allocate per subscription.
+/// </summary>
+/// <typeparam name="T">The element type of the source observable.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="predicate">The match predicate; the first value returning <see langword="true"/> is emitted.</param>
+internal sealed class WaitUntilObservable<T>(
+    IObservable<T> source,
+    Func<T, bool> predicate) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(predicate);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var subscription = new OnceDisposable();
+        var sink = new WaitUntilObserver(observer, predicate, subscription);
+        subscription.Disposable = source.Subscribe(sink);
+        return subscription;
+    }
+
+    /// <summary>
+    /// Forwarding observer that filters by <paramref name="predicate"/> and completes
+    /// after the first match, disposing the upstream subscription handle.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    /// <param name="predicate">The match predicate.</param>
+    /// <param name="subscription">The handle controlling the upstream subscription.</param>
+    private sealed class WaitUntilObserver(
+        IObserver<T> downstream,
+        Func<T, bool> predicate,
+        IDisposable subscription) : IObserver<T>
+    {
+        /// <summary>The gate for state access.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>Whether the observer is done.</summary>
+        private bool _done;
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                bool isMatch;
+                try
+                {
+                    isMatch = predicate(value);
+                }
+                catch (Exception ex)
+                {
+                    _done = true;
+                    downstream.OnError(ex);
+                    subscription.Dispose();
+                    return;
+                }
+
+                if (!isMatch)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnNext(value);
+                downstream.OnCompleted();
+            }
+
+            subscription.Dispose();
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnError(error);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_done)
+                {
+                    return;
+                }
+
+                _done = true;
+                downstream.OnCompleted();
+            }
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/WhereFalseObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/WhereFalseObservable.cs
new file mode 100644
index 0000000..548b113
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/WhereFalseObservable.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Filtering operator that forwards only <c>false</c> values from a boolean source.
+/// Replaces the <c>source.Where(b =&gt; !b)</c> pattern with a dedicated forwarding
+/// observer, avoiding the per-subscription closure allocation that the predicate
+/// lambda would otherwise capture.
+/// </summary>
+/// <param name="source">The boolean source observable.</param>
+internal sealed class WhereFalseObservable(IObservable<bool> source) : IObservable<bool>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<bool> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new WhereFalseObserver(observer));
+    }
+
+    /// <summary>
+    /// Forwarding observer that drops <c>true</c> values and passes <c>false</c>
+    /// values, terminal error and completion through unchanged.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class WhereFalseObserver(IObserver<bool> downstream) : IObserver<bool>
+    {
+        /// <inheritdoc/>
+        public void OnNext(bool value)
+        {
+            if (value)
+            {
+                return;
+            }
+
+            downstream.OnNext(false);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/WhereIsNotNullObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/WhereIsNotNullObservable.cs
new file mode 100644
index 0000000..797929b
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/WhereIsNotNullObservable.cs
@@ -0,0 +1,51 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Filtering operator that forwards only the non-null values of the source
+/// sequence. Replaces the <c>source.Where(x =&gt; x is not null)</c> pattern,
+/// avoiding the per-subscription closure allocation that the predicate lambda
+/// would otherwise capture.
+/// </summary>
+/// <typeparam name="T">The element type of the source observable.</typeparam>
+/// <param name="source">The source observable whose null values are filtered out.</param>
+internal sealed class WhereIsNotNullObservable<T>(IObservable<T> source) : IObservable<T>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new WhereIsNotNullObserver(observer));
+    }
+
+    /// <summary>
+    /// Forwarding observer that suppresses null <see cref="OnNext"/> values and
+    /// passes <see cref="OnError"/> and <see cref="OnCompleted"/> through unchanged.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class WhereIsNotNullObserver(IObserver<T> downstream) : IObserver<T>
+    {
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+            if (value is null)
+            {
+                return;
+            }
+
+            downstream.OnNext(value);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/WhereSelectObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/WhereSelectObservable.cs
new file mode 100644
index 0000000..8423e7d
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/WhereSelectObservable.cs
@@ -0,0 +1,76 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Fused <c>Where(predicate).Select(selector)</c> operator. Replaces the two-operator
+/// Rx chain with a single observable + observer pair, saving the intermediate
+/// <c>Select</c> operator allocation (and its <see cref="IObserver{T}"/>) per
+/// subscription on hot paths.
+/// </summary>
+/// <typeparam name="TIn">The source element type.</typeparam>
+/// <typeparam name="TOut">The projected element type after applying the selector.</typeparam>
+/// <param name="source">The source observable to filter and project.</param>
+/// <param name="predicate">Predicate applied to each source element; only elements returning <see langword="true"/> are forwarded through <paramref name="selector"/>.</param>
+/// <param name="selector">Projection applied to elements that pass <paramref name="predicate"/>.</param>
+internal sealed class WhereSelectObservable<TIn, TOut>(
+    IObservable<TIn> source,
+    Func<TIn, bool> predicate,
+    Func<TIn, TOut> selector) : IObservable<TOut>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<TOut> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        InvalidOperationExceptionHelper.ThrowIfNull(predicate);
+        InvalidOperationExceptionHelper.ThrowIfNull(selector);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new WhereSelectObserver(observer, predicate, selector));
+    }
+
+    /// <summary>
+    /// Forwarding observer that applies the predicate and selector inline on each
+    /// <see cref="OnNext"/>. Any exception thrown by either delegate is routed to
+    /// <see cref="IObserver{T}.OnError"/> on the downstream observer.
+    /// </summary>
+    /// <param name="downstream">The downstream observer receiving projected values.</param>
+    /// <param name="predicate">Filter delegate.</param>
+    /// <param name="selector">Projection delegate.</param>
+    private sealed class WhereSelectObserver(
+        IObserver<TOut> downstream,
+        Func<TIn, bool> predicate,
+        Func<TIn, TOut> selector) : IObserver<TIn>
+    {
+        /// <inheritdoc/>
+        public void OnNext(TIn value)
+        {
+            TOut projected;
+            try
+            {
+                if (!predicate(value))
+                {
+                    return;
+                }
+
+                projected = selector(value);
+            }
+            catch (Exception ex)
+            {
+                downstream.OnError(ex);
+                return;
+            }
+
+            downstream.OnNext(projected);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/WhereTrueObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/WhereTrueObservable.cs
new file mode 100644
index 0000000..c6c19f5
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/WhereTrueObservable.cs
@@ -0,0 +1,50 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Filtering operator that forwards only <c>true</c> values from a boolean source.
+/// Replaces the <c>source.Where(b =&gt; b)</c> pattern with a dedicated forwarding
+/// observer, avoiding the per-subscription closure allocation that the predicate
+/// lambda would otherwise capture.
+/// </summary>
+/// <param name="source">The boolean source observable.</param>
+internal sealed class WhereTrueObservable(IObservable<bool> source) : IObservable<bool>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<bool> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        return source.Subscribe(new WhereTrueObserver(observer));
+    }
+
+    /// <summary>
+    /// Forwarding observer that drops <c>false</c> values and passes <c>true</c>
+    /// values, terminal error and completion through unchanged.
+    /// </summary>
+    /// <param name="downstream">The downstream observer.</param>
+    private sealed class WhereTrueObserver(IObserver<bool> downstream) : IObserver<bool>
+    {
+        /// <inheritdoc/>
+        public void OnNext(bool value)
+        {
+            if (!value)
+            {
+                return;
+            }
+
+            downstream.OnNext(true);
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => downstream.OnError(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => downstream.OnCompleted();
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/Operators/WhileObservable.cs b/src/ReactiveUI.Primitives.Extensions/Operators/WhileObservable.cs
new file mode 100644
index 0000000..4f218fe
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Operators/WhileObservable.cs
@@ -0,0 +1,155 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Operators;
+
+/// <summary>
+/// Loops the supplied <see cref="Action"/> on the supplied
+/// <see cref="ISequencer"/> (or inline when no scheduler is provided), emitting
+/// <see cref="RxVoid.Default"/> after each iteration, for as long as
+/// <paramref name="condition"/> returns <c>true</c>. Replaces the legacy
+/// <c>Observable.While(condition, Observable.Start(action, scheduler))</c>
+/// pattern.
+/// </summary>
+/// <param name="condition">The loop predicate. Evaluated before each iteration.</param>
+/// <param name="action">The action to invoke per iteration.</param>
+/// <param name="scheduler">An optional scheduler; <c>null</c> runs every iteration inline.</param>
+internal sealed class WhileObservable(
+    Func<bool> condition,
+    Action action,
+    ISequencer? scheduler) : IObservable<RxVoid>
+{
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<RxVoid> observer)
+    {
+        InvalidOperationExceptionHelper.ThrowIfNull(condition);
+        InvalidOperationExceptionHelper.ThrowIfNull(action);
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+
+        var sink = new WhileSink(observer, condition, action, scheduler);
+        sink.Run();
+        return sink;
+    }
+
+    /// <summary>
+    /// Sink that orchestrates the iteration loop, scheduling the next iteration
+    /// after each emission and terminating when the predicate becomes false.
+    /// </summary>
+    private sealed class WhileSink : IDisposable
+    {
+        /// <summary>The downstream observer.</summary>
+        private readonly IObserver<RxVoid> _downstream;
+
+        /// <summary>The loop predicate.</summary>
+        private readonly Func<bool> _condition;
+
+        /// <summary>The action invoked per iteration.</summary>
+        private readonly Action _action;
+
+        /// <summary>An optional scheduler used per iteration.</summary>
+        private readonly ISequencer? _scheduler;
+
+        /// <summary>The disposable tracking the currently-scheduled iteration.</summary>
+        private readonly MutableDisposable _current = new();
+
+        /// <summary>Whether the sink has been disposed.</summary>
+        private int _disposed;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WhileSink"/> class.
+        /// </summary>
+        /// <param name="downstream">The downstream observer.</param>
+        /// <param name="condition">The loop predicate.</param>
+        /// <param name="action">The action invoked per iteration.</param>
+        /// <param name="scheduler">An optional scheduler used per iteration.</param>
+        public WhileSink(IObserver<RxVoid> downstream, Func<bool> condition, Action action, ISequencer? scheduler)
+        {
+            _downstream = downstream;
+            _condition = condition;
+            _action = action;
+            _scheduler = scheduler;
+        }
+
+        /// <summary>Starts the loop.</summary>
+        public void Run() => Iterate();
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) == 1)
+            {
+                return;
+            }
+
+            _current.Dispose();
+        }
+
+        /// <summary>
+        /// Performs a single iteration: checks the predicate, runs the action,
+        /// emits <see cref="RxVoid.Default"/>, and schedules the next iteration.
+        /// </summary>
+        private void Iterate()
+        {
+            if (Volatile.Read(ref _disposed) == 1)
+            {
+                return;
+            }
+
+            try
+            {
+                if (!_condition())
+                {
+                    _downstream.OnCompleted();
+                    return;
+                }
+            }
+            catch (Exception error)
+            {
+                _downstream.OnError(error);
+                return;
+            }
+
+            if (_scheduler is null)
+            {
+                RunActionAndContinue();
+                return;
+            }
+
+            _current.Disposable = _scheduler.Schedule(this, static (_, self) =>
+            {
+                self.RunActionAndContinue();
+                return EmptyDisposable.Instance;
+            });
+        }
+
+        /// <summary>
+        /// Runs the per-iteration action, emits <see cref="RxVoid.Default"/>, and re-enters
+        /// <see cref="Iterate"/> to evaluate the predicate for the next iteration.
+        /// </summary>
+        private void RunActionAndContinue()
+        {
+            if (Volatile.Read(ref _disposed) == 1)
+            {
+                return;
+            }
+
+            try
+            {
+                _action();
+            }
+            catch (Exception error)
+            {
+                _downstream.OnError(error);
+                return;
+            }
+
+            _downstream.OnNext(RxVoid.Default);
+            Iterate();
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/ReactiveExtensions.cs b/src/ReactiveUI.Primitives.Extensions/ReactiveExtensions.cs
new file mode 100644
index 0000000..a0fb8ec
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/ReactiveExtensions.cs
@@ -0,0 +1,1649 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Text.RegularExpressions;
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Extensions.Internal;
+using ReactiveUI.Primitives.Extensions.Operators;
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Extension methods for Reactive objects.
+/// </summary>
+[SuppressMessage("Roslynator", "RCS1047:Non-asynchronous method name should not end with \'Async\'", Justification = "Existing API")]
+public static class ReactiveExtensions
+{
+    /// <summary>Default backoff factor for <see cref="RetryWithBackoff{T}(IObservable{T}, int, TimeSpan)"/>: each retry doubles the previous delay.</summary>
+    private const double DefaultBackoffFactor = 2.0;
+
+    /// <summary>
+    /// Returns only values that are not null.
+    /// Converts the nullability.
+    /// </summary>
+    /// <typeparam name="T">The type of value emitted by the observable.</typeparam>
+    /// <param name="observable">The observable that can contain nulls.</param>
+    /// <returns>A non nullable version of the observable that only emits valid values.</returns>
+    public static IObservable<T> WhereIsNotNull<T>(this IObservable<T> observable) =>
+        new WhereIsNotNullObservable<T>(observable);
+
+    /// <summary>
+    /// Change the source observable type to <see cref="RxVoid"/>.
+    /// This allows us to be notified when the observable emits a value.
+    /// </summary>
+    /// <typeparam name="T">The current type of the observable.</typeparam>
+    /// <param name="observable">The observable to convert.</param>
+    /// <returns>The signal.</returns>
+    public static IObservable<RxVoid> AsSignal<T>(this IObservable<T> observable) =>
+        new AsSignalObservable<T>(observable);
+
+    /// <summary>
+    /// Synchronized timer all instances of this with the same TimeSpan use the same timer.
+    /// </summary>
+    /// <param name="timeSpan">The time span.</param>
+    /// <returns>An observable sequence producing the shared DateTime ticks.</returns>
+    public static IObservable<DateTime> SyncTimer(TimeSpan timeSpan) =>
+        SyncTimerObservable.Get(timeSpan, Sequencer.Default);
+
+    /// <summary>
+    /// Synchronized timer all instances of this with the same TimeSpan and scheduler use the same timer.
+    /// </summary>
+    /// <param name="timeSpan">The time span.</param>
+    /// <param name="scheduler">Scheduler used to emit ticks.</param>
+    /// <returns>An observable sequence producing the shared DateTime ticks.</returns>
+    public static IObservable<DateTime> SyncTimer(TimeSpan timeSpan, ISequencer scheduler) =>
+        SyncTimerObservable.Get(timeSpan, scheduler);
+
+    /// <summary>
+    /// Buffers until Start char and End char are found.
+    /// </summary>
+    /// <param name="this">The source observable of characters.</param>
+    /// <param name="startsWith">The starting delimiter.</param>
+    /// <param name="endsWith">The ending delimiter.</param>
+    /// <returns>A sequence of buffered strings including the start and end delimiters.</returns>
+    public static IObservable<string> BufferUntil(this IObservable<char> @this, char startsWith, char endsWith) =>
+        new BufferUntilObservable(@this, startsWith, endsWith);
+
+    /// <summary>
+    /// Emit a batch when the stream goes quiet.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="idleTime">The idle time.</param>
+    /// <returns>A sequence of buffered lists.</returns>
+    public static IObservable<IList<T>> BufferUntilIdle<T>(
+        this IObservable<T> source,
+        TimeSpan idleTime) =>
+        source.BufferUntilIdle(idleTime, null);
+
+    /// <summary>
+    /// Emit a batch when the stream goes quiet.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="idleTime">The idle time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <returns>A sequence of buffered lists.</returns>
+    public static IObservable<IList<T>> BufferUntilIdle<T>(
+        this IObservable<T> source,
+        TimeSpan idleTime,
+        ISequencer? scheduler) =>
+        new BufferUntilIdleObservable<T>(source, idleTime, scheduler ?? Sequencer.Default);
+
+    /// <summary>
+    /// Catch exception and return Observable.Empty.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <returns>A sequence that ignores errors and completes.</returns>
+    public static IObservable<TSource?> CatchIgnore<TSource>(this IObservable<TSource?> source) =>
+        new CatchIgnoreEmptyObservable<TSource?>(source);
+
+    /// <summary>
+    /// Catch exception and return Observable.Empty.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TException">The type of the exception.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="errorAction">The error action.</param>
+    /// <returns>A sequence that invokes <paramref name="errorAction"/> on error and completes.</returns>
+    public static IObservable<TSource> CatchIgnore<TSource, TException>(
+        this IObservable<TSource> source,
+        Action<TException> errorAction)
+        where TException : Exception =>
+        new CatchIgnoreObservable<TSource, TException>(source, errorAction);
+
+    /// <summary>
+    /// Latest values of each sequence are all false.
+    /// </summary>
+    /// <param name="sources">The sources.</param>
+    /// <returns>A sequence that emits true when all latest booleans are false.</returns>
+    public static IObservable<bool> CombineLatestValuesAreAllFalse(this IEnumerable<IObservable<bool>> sources) =>
+        new BooleanReduceObservable(sources, target: false);
+
+    /// <summary>
+    /// Latest values of each sequence are all true.
+    /// </summary>
+    /// <param name="sources">The sources.</param>
+    /// <returns>A sequence that emits true when all latest booleans are true.</returns>
+    public static IObservable<bool> CombineLatestValuesAreAllTrue(this IEnumerable<IObservable<bool>> sources) =>
+        new BooleanReduceObservable(sources, target: true);
+
+    /// <summary>
+    /// Gets the maximum from all sources.
+    /// </summary>
+    /// <typeparam name="T">The Value Type.</typeparam>
+    /// <param name="this">The first observable.</param>
+    /// <param name="sources">Other sources.</param>
+    /// <returns>A sequence emitting the maximum of the latest values.</returns>
+    public static IObservable<T> GetMax<T>(this IObservable<T> @this, params IObservable<T>[] sources)
+        where T : struct, IComparable<T>
+    {
+        var allSources = new IObservable<T>[sources.Length + 1];
+        allSources[0] = @this;
+        Array.Copy(sources, 0, allSources, 1, sources.Length);
+        return new MinMaxObservable<T>(allSources, emitMaximum: true);
+    }
+
+    /// <summary>
+    /// Gets the minimum from all sources.
+    /// </summary>
+    /// <typeparam name="T">The Value Type.</typeparam>
+    /// <param name="this">The first observable.</param>
+    /// <param name="sources">Other sources.</param>
+    /// <returns>A sequence emitting the minimum of the latest values.</returns>
+    public static IObservable<T> GetMin<T>(this IObservable<T> @this, params IObservable<T>[] sources)
+        where T : struct, IComparable<T>
+    {
+        var allSources = new IObservable<T>[sources.Length + 1];
+        allSources[0] = @this;
+        Array.Copy(sources, 0, allSources, 1, sources.Length);
+        return new MinMaxObservable<T>(allSources, emitMaximum: false);
+    }
+
+    /// <summary>
+    /// Detects when a stream becomes inactive for some period of time.
+    /// </summary>
+    /// <typeparam name="T">update type.</typeparam>
+    /// <param name="source">source stream.</param>
+    /// <param name="stalenessPeriod">If source stream does not OnNext any update during this period, it is declared stale.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <returns>Observable stale markers or updates.</returns>
+    public static IObservable<Stale<T>> DetectStale<T>(
+        this IObservable<T> source,
+        TimeSpan stalenessPeriod,
+        ISequencer scheduler) =>
+        new DetectStaleObservable<T>(source, stalenessPeriod, scheduler);
+
+    /// <summary>
+    /// Applies a conflation algorithm to an observable stream. Anytime the stream OnNext twice
+    /// below minimumUpdatePeriod, the second update gets delayed to respect the
+    /// minimumUpdatePeriod. If more than 2 updates happen, only the last update is pushed.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The stream.</param>
+    /// <param name="minimumUpdatePeriod">Minimum delay between two updates.</param>
+    /// <param name="scheduler">Scheduler to publish updates.</param>
+    /// <returns>The conflated stream.</returns>
+    public static IObservable<T> Conflate<T>(
+        this IObservable<T> source,
+        TimeSpan minimumUpdatePeriod,
+        ISequencer scheduler) =>
+        new ConflateObservable<T>(source, minimumUpdatePeriod, scheduler);
+
+    /// <summary>
+    /// Injects heartbeats in a stream when the source stream becomes quiet.
+    /// </summary>
+    /// <typeparam name="T">Update type.</typeparam>
+    /// <param name="source">Source stream.</param>
+    /// <param name="heartbeatPeriod">Period between heartbeats.</param>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <returns>Observable heartbeat values.</returns>
+    public static IObservable<Heartbeat<T>> Heartbeat<T>(
+        this IObservable<T> source,
+        TimeSpan heartbeatPeriod,
+        ISequencer scheduler) =>
+        new HeartbeatObservable<T>(source, heartbeatPeriod, scheduler);
+
+    /// <summary>
+    /// Emit the latest value or a default if none exists.
+    /// </summary>
+    /// <typeparam name="T">The type of the source.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="defaultValue">The default value.</param>
+    /// <returns>A sequence that emits the latest value or the default.</returns>
+    public static IObservable<T> LatestOrDefault<T>(
+        this IObservable<T> source,
+        T defaultValue) => new LatestOrDefaultObservable<T>(source, defaultValue);
+
+    /// <summary>
+    /// Logs the errors. Inline error logging without terminating the stream.
+    /// </summary>
+    /// <typeparam name="T">The type of the source.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="logger">The logger.</param>
+    /// <returns>A sequence that logs errors.</returns>
+    public static IObservable<T> LogErrors<T>(
+        this IObservable<T> source,
+        Action<Exception> logger)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+        ArgumentExceptionHelper.ThrowIfNull(logger);
+        return new LogErrorsObservable<T>(source, logger);
+    }
+
+    /// <summary>
+    /// Executes with limited concurrency.
+    /// </summary>
+    /// <typeparam name="T">The result type.</typeparam>
+    /// <param name="taskFunctions">Tasks to execute.</param>
+    /// <param name="maxConcurrency">Maximum concurrency.</param>
+    /// <returns>A sequence of task results.</returns>
+    public static IObservable<T> WithLimitedConcurrency<T>(this IEnumerable<Task<T>> taskFunctions, int maxConcurrency)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(taskFunctions);
+
+        return new ConcurrencyLimiter<T>(taskFunctions, maxConcurrency).Observable;
+    }
+
+    /// <summary>
+    /// Pushes multiple values to an observer.
+    /// </summary>
+    /// <typeparam name="T">Type of value.</typeparam>
+    /// <param name="observer">Observer to push to.</param>
+    /// <param name="events">Values to push.</param>
+    public static void OnNext<T>(this IObserver<T> observer, params T[] events)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(observer);
+        ArgumentExceptionHelper.ThrowIfNull(events);
+
+        observer.FastForEach(events);
+    }
+
+    /// <summary>
+    /// If the scheduler is not null observes on that scheduler.
+    /// </summary>
+    /// <typeparam name="TSource">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="scheduler">Scheduler to notify observers on (optional).</param>
+    /// <returns>The source sequence whose callbacks happen on the specified scheduler.</returns>
+    public static IObservable<TSource>
+        ObserveOnSafe<TSource>(this IObservable<TSource> source, ISequencer? scheduler) =>
+        scheduler == null ? source : new ObserveOnObservable<TSource>(source, scheduler);
+
+    /// <summary>
+    /// Conditionally switch schedulers.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="condition">if set to <c>true</c> [condition].</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> ObserveOnIf<T>(
+        this IObservable<T> source,
+        bool condition,
+        ISequencer scheduler) => condition ? new ObserveOnObservable<T>(source, scheduler) : source;
+
+    /// <summary>
+    /// Conditionally switch schedulers.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="condition">if set to <c>true</c> [condition].</param>
+    /// <param name="trueScheduler">The true scheduler.</param>
+    /// <param name="falseScheduler">The false scheduler.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> ObserveOnIf<T>(
+        this IObservable<T> source,
+        bool condition,
+        ISequencer trueScheduler,
+        ISequencer falseScheduler) => condition
+        ? new ObserveOnObservable<T>(source, trueScheduler)
+        : new ObserveOnObservable<T>(source, falseScheduler);
+
+    /// <summary>
+    /// Conditionally switch schedulers based on a reactive condition.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="condition">The reactive condition.</param>
+    /// <param name="trueScheduler">The scheduler to use when condition is true.</param>
+    /// <param name="falseScheduler">The scheduler to use when condition is false.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> ObserveOnIf<T>(
+        this IObservable<T> source,
+        IObservable<bool> condition,
+        ISequencer trueScheduler,
+        ISequencer falseScheduler) =>
+        new ObserveOnIfObservable<T>(source, condition, trueScheduler, falseScheduler);
+
+    /// <summary>
+    /// Conditionally switch schedulers based on a reactive condition.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="condition">The reactive condition.</param>
+    /// <param name="scheduler">The scheduler to use when condition is true.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> ObserveOnIf<T>(
+        this IObservable<T> source,
+        IObservable<bool> condition,
+        ISequencer scheduler) =>
+        new ObserveOnIfObservable<T>(source, condition, scheduler, Sequencer.Immediate);
+
+    /// <summary>
+    /// Skip null values until the first non-null appears.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> SkipWhileNull<T>(this IObservable<T> source)
+        where T : class
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+        return new SkipWhileNullObservable<T>(source);
+    }
+
+    /// <summary>
+    /// Invokes the action asynchronously surfacing the result through a RxVoid observable.
+    /// </summary>
+    /// <param name="action">Action to run.</param>
+    /// <param name="scheduler">Scheduler (optional).</param>
+    /// <returns>A sequence producing RxVoid upon completion.</returns>
+    public static IObservable<RxVoid> Start(Action action, ISequencer? scheduler) =>
+        new StartActionObservable(action, scheduler);
+
+    /// <summary>
+    /// Invokes the specified function asynchronously surfacing the result.
+    /// </summary>
+    /// <typeparam name="TResult">Result type.</typeparam>
+    /// <param name="function">Function to run.</param>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <returns>A sequence producing the function result.</returns>
+    public static IObservable<TResult> Start<TResult>(Func<TResult> function, ISequencer? scheduler) =>
+        new StartFuncObservable<TResult>(function, scheduler);
+
+    /// <summary>
+    /// Flattens a sequence of enumerables into individual values.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source of enumerables.</param>
+    /// <returns>A flattened observable.</returns>
+    public static IObservable<T> ForEach<T>(this IObservable<IEnumerable<T>> source) =>
+        source.ForEach(null);
+
+    /// <summary>
+    /// Flattens a sequence of enumerables into individual values.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source of enumerables.</param>
+    /// <param name="scheduler">Scheduler (optional).</param>
+    /// <returns>A flattened observable.</returns>
+    public static IObservable<T> ForEach<T>(this IObservable<IEnumerable<T>> source, ISequencer? scheduler) =>
+        new ForEachObservable<T>(source, scheduler);
+
+    /// <summary>
+    /// Schedules an action immediately if scheduler null, else on scheduler.
+    /// </summary>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <param name="action">Action.</param>
+    /// <returns>Disposable for the scheduled action.</returns>
+    public static IDisposable ScheduleSafe(this ISequencer? scheduler, Action action)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(action);
+
+        if (scheduler != null)
+        {
+            return scheduler.Schedule(action);
+        }
+
+        action();
+        return EmptyDisposable.Instance;
+    }
+
+    /// <summary>
+    /// Schedules an action after a due time.
+    /// </summary>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <param name="dueTime">Delay.</param>
+    /// <param name="action">Action.</param>
+    /// <returns>Disposable for the scheduled action.</returns>
+    public static IDisposable ScheduleSafe(this ISequencer? scheduler, TimeSpan dueTime, Action action)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(action);
+
+        if (scheduler == null)
+        {
+            Thread.Sleep(dueTime);
+            action();
+            return EmptyDisposable.Instance;
+        }
+
+        return scheduler.Schedule(dueTime, action);
+    }
+
+    /// <summary>
+    /// Emits each element of an IEnumerable.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source enumerable.</param>
+    /// <returns>Observable of elements.</returns>
+    public static IObservable<T> FromArray<T>(this IEnumerable<T> source) =>
+        source.FromArray(null);
+
+    /// <summary>
+    /// Emits each element of an IEnumerable.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source enumerable.</param>
+    /// <param name="scheduler">Scheduler (optional).</param>
+    /// <returns>Observable of elements.</returns>
+    public static IObservable<T> FromArray<T>(this IEnumerable<T> source, ISequencer? scheduler) =>
+        new FromArrayObservable<T>(source, scheduler);
+
+    /// <summary>
+    /// Using helper with Action.
+    /// </summary>
+    /// <typeparam name="T">Disposable type.</typeparam>
+    /// <param name="obj">Object to use.</param>
+    /// <param name="action">Action to run.</param>
+    /// <returns>Completion signal.</returns>
+    public static IObservable<RxVoid> Using<T>(this T obj, Action<T>? action)
+        where T : IDisposable =>
+        obj.Using(action, null);
+
+    /// <summary>
+    /// Using helper with Action.
+    /// </summary>
+    /// <typeparam name="T">Disposable type.</typeparam>
+    /// <param name="obj">Object to use.</param>
+    /// <param name="action">Action to run.</param>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <returns>Completion signal.</returns>
+    public static IObservable<RxVoid> Using<T>(this T obj, Action<T>? action, ISequencer? scheduler)
+        where T : IDisposable =>
+        new UsingActionObservable<T>(obj, action, scheduler);
+
+    /// <summary>
+    /// Using helper with Func.
+    /// </summary>
+    /// <typeparam name="T">Disposable type.</typeparam>
+    /// <typeparam name="TResult">Result type.</typeparam>
+    /// <param name="obj">Object to use.</param>
+    /// <param name="function">Function to invoke.</param>
+    /// <returns>Observable of result.</returns>
+    public static IObservable<TResult> Using<T, TResult>(
+        this T obj,
+        Func<T, TResult> function)
+        where T : IDisposable => obj.Using(function, null);
+
+    /// <summary>
+    /// Using helper with Func.
+    /// </summary>
+    /// <typeparam name="T">Disposable type.</typeparam>
+    /// <typeparam name="TResult">Result type.</typeparam>
+    /// <param name="obj">Object to use.</param>
+    /// <param name="function">Function to invoke.</param>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <returns>Observable of result.</returns>
+    public static IObservable<TResult> Using<T, TResult>(
+        this T obj,
+        Func<T, TResult> function,
+        ISequencer? scheduler)
+        where T : IDisposable => new UsingFuncObservable<T, TResult>(obj, function, scheduler);
+
+    /// <summary>
+    /// While construct.
+    /// </summary>
+    /// <param name="condition">Condition to evaluate.</param>
+    /// <param name="action">Action to execute.</param>
+    /// <returns>Observable representing the loop.</returns>
+    public static IObservable<RxVoid> While(Func<bool> condition, Action action) =>
+        While(condition, action, null);
+
+    /// <summary>
+    /// While construct.
+    /// </summary>
+    /// <param name="condition">Condition to evaluate.</param>
+    /// <param name="action">Action to execute.</param>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <returns>Observable representing the loop.</returns>
+    public static IObservable<RxVoid> While(Func<bool> condition, Action action, ISequencer? scheduler) =>
+        new WhileObservable(condition, action, scheduler);
+
+    /// <summary>
+    /// Sample the latest value whenever a trigger fires.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="trigger">The trigger.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> SampleLatest<T>(
+        this IObservable<T> source,
+        IObservable<object> trigger) => new SampleLatestObservable<T>(source, trigger);
+
+    /// <summary>
+    /// Scan that always emits the initial value first.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TAccumulate">The type of the accumulate.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="initial">The initial.</param>
+    /// <param name="accumulator">The accumulator.</param>
+    /// <returns>An IObservable of TAccumulate.</returns>
+    public static IObservable<TAccumulate> ScanWithInitial<TSource, TAccumulate>(
+        this IObservable<TSource> source,
+        TAccumulate initial,
+        Func<TAccumulate, TSource, TAccumulate> accumulator) =>
+        new ScanWithInitialObservable<TSource, TAccumulate>(source, initial, accumulator);
+
+    /// <summary>
+    /// Schedules a single value after a delay.
+    /// </summary>
+    /// <typeparam name="T">Value type.</typeparam>
+    /// <param name="value">Value.</param>
+    /// <param name="dueTime">Delay.</param>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <returns>Observable that emits the value.</returns>
+    public static IObservable<T> Schedule<T>(this T value, TimeSpan dueTime, ISequencer scheduler) =>
+        new ScheduledValueObservable<T>(value, scheduler, dueTime, null, null, null);
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer scheduler) =>
+        new ScheduledSourceObservable<T>(source, ScheduleConfig<T>.Delayed(scheduler, dueTime));
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="value">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(this T value, DateTimeOffset dueTime, ISequencer scheduler) =>
+        new ScheduledValueObservable<T>(value, scheduler, null, dueTime, null, null);
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T>
+        Schedule<T>(this IObservable<T> source, DateTimeOffset dueTime, ISequencer scheduler) =>
+        new ScheduledSourceObservable<T>(source, ScheduleConfig<T>.Absolute(scheduler, dueTime));
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="value">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="action">The action.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(this T value, TimeSpan dueTime, ISequencer scheduler, Action<T> action) =>
+        new ScheduledValueObservable<T>(value, scheduler, dueTime, null, null, action);
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="action">The action.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(
+        this IObservable<T> source,
+        TimeSpan dueTime,
+        ISequencer scheduler,
+        Action<T> action) =>
+        new ScheduledSourceObservable<T>(source, ScheduleConfig<T>.Delayed(scheduler, dueTime).WithAction(action));
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="value">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="action">The action.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(
+        this T value,
+        DateTimeOffset dueTime,
+        ISequencer scheduler,
+        Action<T> action) =>
+        new ScheduledValueObservable<T>(value, scheduler, null, dueTime, null, action);
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="action">The action.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(
+        this IObservable<T> source,
+        DateTimeOffset dueTime,
+        ISequencer scheduler,
+        Action<T> action) =>
+        new ScheduledSourceObservable<T>(source, ScheduleConfig<T>.Absolute(scheduler, dueTime).WithAction(action));
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="value">The value.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="function">The function.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(this T value, ISequencer scheduler, Func<T, T> function) =>
+        new ScheduledValueObservable<T>(value, scheduler, null, null, function, null);
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The value.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="function">The function.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(this IObservable<T> source, ISequencer scheduler, Func<T, T> function) =>
+        new ScheduledSourceObservable<T>(source, ScheduleConfig<T>.Immediate(scheduler).WithTransform(function));
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="value">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="function">The function.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T>
+        Schedule<T>(this T value, TimeSpan dueTime, ISequencer scheduler, Func<T, T> function) =>
+        new ScheduledValueObservable<T>(value, scheduler, dueTime, null, function, null);
+
+    /// <summary>
+    /// Schedules the specified due time.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The value.</param>
+    /// <param name="dueTime">The due time.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <param name="function">The function.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> Schedule<T>(
+        this IObservable<T> source,
+        TimeSpan dueTime,
+        ISequencer scheduler,
+        Func<T, T> function) =>
+        new ScheduledSourceObservable<T>(source, ScheduleConfig<T>.Delayed(scheduler, dueTime).WithTransform(function));
+
+    /// <summary>
+    /// Filters strings by regex.
+    /// </summary>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="regexPattern">Regex pattern.</param>
+    /// <returns>Filtered sequence.</returns>
+    public static IObservable<string> Filter(this IObservable<string> source, string regexPattern) =>
+        source.Filter(new Regex(regexPattern, RegexOptions.None, TimeSpan.FromSeconds(1)));
+
+    /// <summary>
+    /// Filters strings by regex.
+    /// </summary>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="regex">Regex.</param>
+    /// <returns>Filtered sequence.</returns>
+    public static IObservable<string> Filter(this IObservable<string> source, Regex regex) =>
+        new FilterRegexObservable(source, regex);
+
+    /// <summary>
+    /// Randomly shuffles arrays emitted by the source.
+    /// </summary>
+    /// <typeparam name="T">Array element type.</typeparam>
+    /// <param name="source">Source array sequence.</param>
+    /// <returns>Sequence of shuffled arrays (in-place).</returns>
+    public static IObservable<T[]> Shuffle<T>(this IObservable<T[]> source) => new ShuffleObservable<T>(source);
+
+    /// <summary>
+    /// Repeats the source until it terminates successfully (alias of Retry).
+    /// </summary>
+    /// <typeparam name="TSource">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <returns>Retried sequence.</returns>
+    public static IObservable<TSource> OnErrorRetry<TSource>(this IObservable<TSource> source)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+        return new RetryForeverObservable<TSource>(source);
+    }
+
+    /// <summary>
+    /// When caught exception, do onError action and repeat observable sequence.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TException">The type of the exception.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="onError">The on error.</param>
+    /// <returns>A sequence that retries on error with optional delay.</returns>
+    public static IObservable<TSource> OnErrorRetry<TSource, TException>(
+        this IObservable<TSource> source,
+        Action<TException> onError)
+        where TException : Exception => source.OnErrorRetry(onError, TimeSpan.Zero);
+
+    /// <summary>
+    /// When caught exception, do onError action and repeat observable sequence after delay time.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TException">The type of the exception.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="onError">The on error.</param>
+    /// <param name="delay">The delay.</param>
+    /// <returns>A sequence that retries on error with optional delay.</returns>
+    public static IObservable<TSource> OnErrorRetry<TSource, TException>(
+        this IObservable<TSource> source,
+        Action<TException> onError,
+        TimeSpan delay)
+        where TException : Exception => source.OnErrorRetry(onError, int.MaxValue, delay);
+
+    /// <summary>
+    /// When caught exception, do onError action and repeat observable sequence during within retryCount.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TException">The type of the exception.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="onError">The on error.</param>
+    /// <param name="retryCount">The retry count.</param>
+    /// <returns>A sequence that retries on error with optional delay.</returns>
+    public static IObservable<TSource> OnErrorRetry<TSource, TException>(
+        this IObservable<TSource> source,
+        Action<TException> onError,
+        int retryCount)
+        where TException : Exception => source.OnErrorRetry(onError, retryCount, TimeSpan.Zero);
+
+    /// <summary>
+    /// When caught exception, do onError action and repeat observable sequence after delay time
+    /// during within retryCount.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TException">The type of the exception.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="onError">The on error.</param>
+    /// <param name="retryCount">The retry count.</param>
+    /// <param name="delay">The delay.</param>
+    /// <returns>A sequence that retries on error with optional delay.</returns>
+    public static IObservable<TSource> OnErrorRetry<TSource, TException>(
+        this IObservable<TSource> source,
+        Action<TException> onError,
+        int retryCount,
+        TimeSpan delay)
+        where TException : Exception => source.OnErrorRetry(onError, retryCount, delay, Sequencer.Default);
+
+    /// <summary>
+    /// When caught exception, do onError action and repeat observable sequence after delay
+    /// time(work on delayScheduler) during within retryCount.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TException">The type of the exception.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="onError">The on error.</param>
+    /// <param name="retryCount">The retry count.</param>
+    /// <param name="delay">The delay.</param>
+    /// <param name="delayScheduler">The delay scheduler.</param>
+    /// <returns>A sequence that retries on error with optional delay.</returns>
+    public static IObservable<TSource> OnErrorRetry<TSource, TException>(
+        this IObservable<TSource> source,
+        Action<TException> onError,
+        int retryCount,
+        TimeSpan delay,
+        ISequencer delayScheduler)
+        where TException : Exception
+    {
+        ArgumentExceptionHelper.ThrowIfNull(source);
+
+        return new RetryWithBackoffObservable<TSource>(
+            source,
+            new RetryBackoffPolicy(
+                MaxRetries: retryCount,
+                InitialDelay: delay,
+                BackoffFactor: 1.0,
+                MaxDelay: null,
+                Scheduler: delayScheduler,
+                OnError: ex =>
+                {
+                    if (ex is not TException tex)
+                    {
+                        return;
+                    }
+
+                    onError(tex);
+                }));
+    }
+
+    /// <summary>
+    /// Takes elements until predicate returns true for an element (inclusive) then completes.
+    /// </summary>
+    /// <typeparam name="TSource">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="predicate">Predicate for completion.</param>
+    /// <returns>Sequence that completes when predicate satisfied.</returns>
+    public static IObservable<TSource> TakeUntil<TSource>(
+        this IObservable<TSource> source,
+        Func<TSource, bool> predicate)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(predicate);
+        return new TakeUntilInclusiveObservable<TSource>(source, predicate);
+    }
+
+    /// <summary>
+    /// Wraps values with a synchronization disposable that completes when disposed.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <returns>Sequence of (value, sync handle).</returns>
+    public static IObservable<(T Value, IDisposable Sync)> SynchronizeSynchronous<T>(this IObservable<T> source) =>
+        new SynchronizeAsyncObservable<T>(source);
+
+    /// <summary>
+    /// Subscribes to the specified source synchronously.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="onNext">The on next.</param>
+    /// <param name="onError">The on error.</param>
+    /// <param name="onCompleted">The on completed.</param>
+    /// <returns><see cref="IDisposable"/> object used to unsubscribe from the observable sequence.</returns>
+    public static IDisposable SubscribeSynchronous<T>(
+        this IObservable<T> source,
+        Func<T, ValueTask> onNext,
+        Action<Exception> onError,
+        Action onCompleted) =>
+        new SubscribeAsyncObservable<T>(source, onNext, onError, onCompleted);
+
+    /// <summary>
+    /// Subscribes an element handler and an exception handler to an observable sequence synchronously.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">Observable sequence to subscribe to.</param>
+    /// <param name="onNext">Action to invoke for each element in the observable sequence.</param>
+    /// <param name="onError">Action to invoke upon exceptional termination of the observable sequence.</param>
+    /// <returns><see cref="IDisposable"/> object used to unsubscribe from the observable sequence.</returns>
+    public static IDisposable SubscribeSynchronous<T>(
+        this IObservable<T> source,
+        Func<T, ValueTask> onNext,
+        Action<Exception> onError) =>
+        new SubscribeAsyncObservable<T>(source, onNext, onError);
+
+    /// <summary>
+    /// Subscribes an element handler and a completion handler to an observable sequence synchronously.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">Observable sequence to subscribe to.</param>
+    /// <param name="onNext">Action to invoke for each element in the observable sequence.</param>
+    /// <param name="onCompleted">Action to invoke upon graceful termination of the observable sequence.</param>
+    /// <returns><see cref="IDisposable"/> object used to unsubscribe from the observable sequence.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="onNext"/> or <paramref name="onCompleted"/> is <c>null</c>.</exception>
+    public static IDisposable SubscribeSynchronous<T>(
+        this IObservable<T> source,
+        Func<T, ValueTask> onNext,
+        Action onCompleted) =>
+        new SubscribeAsyncObservable<T>(source, onNext, onCompleted: onCompleted);
+
+    /// <summary>
+    /// Subscribes an element handler to an observable sequence synchronously.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">Observable sequence to subscribe to.</param>
+    /// <param name="onNext">Action to invoke for each element in the observable sequence.</param>
+    /// <returns><see cref="IDisposable"/> object used to unsubscribe from the observable sequence.</returns>
+    public static IDisposable SubscribeSynchronous<T>(this IObservable<T> source, Func<T, ValueTask> onNext) =>
+        new SubscribeAsyncObservable<T>(source, onNext);
+
+    /// <summary>
+    /// Provide a fallback observable if the source completes without emitting.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="fallback">The fallback.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> SwitchIfEmpty<T>(
+        this IObservable<T> source,
+        IObservable<T> fallback) => new SwitchIfEmptyObservable<T>(source, fallback);
+
+    /// <summary>
+    /// Synchronizes the asynchronous operations in downstream operations.
+    /// Use SubscribeSynchronus instead for a simpler version.
+    /// Call Sync.Dispose() to release the lock in the downstream methods.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <returns>An Observable of T and a release mechanism.</returns>
+    public static IObservable<(T Value, IDisposable Sync)> SynchronizeAsync<T>(this IObservable<T> source) =>
+        new SynchronizeAsyncObservable<T>(source);
+
+    /// <summary>
+    /// Subscribes allowing asynchronous operations to be executed without blocking the source.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">Observable sequence to subscribe to.</param>
+    /// <param name="onNext">Action to invoke for each element in the observable sequence.</param>
+    /// <returns><see cref="IDisposable"/> object used to unsubscribe from the observable sequence.</returns>
+    [SuppressMessage(
+        "Roslynator",
+        "RCS1047:Non-asynchronous method name should not end with \'Async\'",
+        Justification = "This is an existing method")]
+    public static IDisposable SubscribeAsync<T>(this IObservable<T> source, Func<T, ValueTask> onNext) =>
+        new SubscribeAsyncObservable<T>(source, onNext);
+
+    /// <summary>
+    /// Subscribes allowing asynchronous operations to be executed without blocking the source.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">Observable sequence to subscribe to.</param>
+    /// <param name="onNext">Action to invoke for each element in the observable sequence.</param>
+    /// <param name="onCompleted">The on completed.</param>
+    /// <returns>
+    ///   <see cref="IDisposable" /> object used to unsubscribe from the observable sequence.
+    /// </returns>
+    [SuppressMessage(
+        "Roslynator",
+        "RCS1047:Non-asynchronous method name should not end with \'Async\'",
+        Justification = "This is an existing method")]
+    public static IDisposable SubscribeAsync<T>(this IObservable<T> source, Func<T, ValueTask> onNext, Action onCompleted) =>
+        new SubscribeAsyncObservable<T>(source, onNext, onCompleted: onCompleted);
+
+    /// <summary>
+    /// Subscribes allowing asynchronous operations to be executed without blocking the source.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">Observable sequence to subscribe to.</param>
+    /// <param name="onNext">Action to invoke for each element in the observable sequence.</param>
+    /// <param name="onError">The on error.</param>
+    /// <returns>
+    ///   <see cref="IDisposable" /> object used to unsubscribe from the observable sequence.
+    /// </returns>
+    [SuppressMessage(
+        "Roslynator",
+        "RCS1047:Non-asynchronous method name should not end with \'Async\'",
+        Justification = "This is an existing method")]
+    public static IDisposable SubscribeAsync<T>(
+        this IObservable<T> source,
+        Func<T, ValueTask> onNext,
+        Action<Exception> onError) =>
+        new SubscribeAsyncObservable<T>(source, onNext, onError);
+
+    /// <summary>
+    /// Subscribes allowing asynchronous operations to be executed without blocking the source.
+    /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">Observable sequence to subscribe to.</param>
+    /// <param name="onNext">Action to invoke for each element in the observable sequence.</param>
+    /// <param name="onError">The on error.</param>
+    /// <param name="onCompleted">The on completed.</param>
+    /// <returns>
+    ///   <see cref="IDisposable" /> object used to unsubscribe from the observable sequence.
+    /// </returns>
+    [SuppressMessage(
+        "Roslynator",
+        "RCS1047:Non-asynchronous method name should not end with \'Async\'",
+        Justification = "This is an existing method")]
+    public static IDisposable SubscribeAsync<T>(
+        this IObservable<T> source,
+        Func<T, ValueTask> onNext,
+        Action<Exception> onError,
+        Action onCompleted) =>
+        new SubscribeAsyncObservable<T>(source, onNext, onError, onCompleted);
+
+    /// <summary>
+    /// Emits the boolean negation of the source sequence.
+    /// </summary>
+    /// <param name="source">Boolean source.</param>
+    /// <returns>Negated boolean sequence.</returns>
+    public static IObservable<bool> Not(this IObservable<bool> source) => new NotObservable(source);
+
+    /// <summary>
+    /// Filters to true values only.
+    /// </summary>
+    /// <param name="source">Boolean source.</param>
+    /// <returns>Sequence of true values.</returns>
+    public static IObservable<bool> WhereTrue(this IObservable<bool> source) => new WhereTrueObservable(source);
+
+    /// <summary>
+    /// Filters to false values only.
+    /// </summary>
+    /// <param name="source">Boolean source.</param>
+    /// <returns>Sequence of false values.</returns>
+    public static IObservable<bool> WhereFalse(this IObservable<bool> source) => new WhereFalseObservable(source);
+
+    /// <summary>
+    /// Catches any error and returns a fallback value then completes.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="fallback">Fallback value.</param>
+    /// <returns>Sequence producing either original values or fallback on error then completing.</returns>
+    public static IObservable<T> CatchAndReturn<T>(this IObservable<T> source, T fallback) =>
+        new CatchReturnObservable<T>(source, fallback);
+
+    /// <summary>
+    /// Catches a specific exception type mapping it to a fallback value.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <typeparam name="TException">Exception type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="fallbackFactory">Factory producing fallback from the exception.</param>
+    /// <returns>Recovered sequence.</returns>
+    public static IObservable<T> CatchAndReturn<T, TException>(
+        this IObservable<T> source,
+        Func<TException, T> fallbackFactory)
+        where TException : Exception
+    {
+        ArgumentExceptionHelper.ThrowIfNull(fallbackFactory);
+        return new CatchAndReturnWithFactoryObservable<T, TException>(source, fallbackFactory);
+    }
+
+    /// <summary>
+    /// Retries with exponential backoff.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="maxRetries">Maximum number of retries.</param>
+    /// <param name="initialDelay">Initial backoff delay.</param>
+    /// <returns>Retried sequence with backoff.</returns>
+    public static IObservable<T> RetryWithBackoff<T>(
+        this IObservable<T> source,
+        int maxRetries,
+        TimeSpan initialDelay) =>
+        source.RetryWithBackoff(maxRetries, initialDelay, DefaultBackoffFactor, null, null);
+
+    /// <summary>
+    /// Retries with exponential backoff.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="maxRetries">Maximum number of retries.</param>
+    /// <param name="initialDelay">Initial backoff delay.</param>
+    /// <param name="backoffFactor">Multiplier for each retry (default 2).</param>
+    /// <param name="maxDelay">Optional maximum delay.</param>
+    /// <param name="scheduler">Scheduler (optional).</param>
+    /// <returns>Retried sequence with backoff.</returns>
+    public static IObservable<T> RetryWithBackoff<T>(
+        this IObservable<T> source,
+        int maxRetries,
+        TimeSpan initialDelay,
+        double backoffFactor,
+        TimeSpan? maxDelay,
+        ISequencer? scheduler) =>
+        new RetryWithBackoffObservable<T>(
+            source,
+            new RetryBackoffPolicy(
+                MaxRetries: maxRetries,
+                InitialDelay: initialDelay,
+                BackoffFactor: backoffFactor,
+                MaxDelay: maxDelay,
+                Scheduler: scheduler ?? Sequencer.Default,
+                OnError: null));
+
+    /// <summary>
+    /// Retry with exponential.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="retryCount">The retry count.</param>
+    /// <param name="delaySelector">The delay selector.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> RetryWithDelay<T>(
+        this IObservable<T> source,
+        int retryCount,
+        Func<int, TimeSpan> delaySelector) =>
+        new RetryWithDelayObservable<T>(source, retryCount, delaySelector);
+
+    /// <summary>
+    /// Retries the forever with delay.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="delay">The delay.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> RetryForeverWithDelay<T>(this IObservable<T> source, TimeSpan delay) =>
+        new RetryWithDelayObservable<T>(source, int.MaxValue, _ => delay);
+
+    /// <summary>
+    /// Retry with fixed backoff.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="retryCount">The retry count.</param>
+    /// <param name="delay">The delay.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> RetryWithFixedDelay<T>(
+        this IObservable<T> source,
+        int retryCount,
+        TimeSpan delay)
+        => new RetryWithBackoffObservable<T>(
+            source,
+            new RetryBackoffPolicy(
+                MaxRetries: retryCount,
+                InitialDelay: delay,
+                BackoffFactor: 1.0,
+                MaxDelay: null,
+                Scheduler: Sequencer.Default,
+                OnError: null));
+
+    /// <summary>
+    /// Always replay the last value, even if the source hasn’t produced one yet.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="initialValue">The initial value.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> ReplayLastOnSubscribe<T>(
+        this IObservable<T> source,
+        T initialValue)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        return new ReplayLastOnSubscribeObservable<T>(source, initialValue);
+    }
+
+    /// <summary>
+    /// Emits only the first value in each time window.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="window">Time window.</param>
+    /// <returns>Throttle-first sequence.</returns>
+    public static IObservable<T> ThrottleFirst<T>(
+        this IObservable<T> source,
+        TimeSpan window) =>
+        source.ThrottleFirst(window, null);
+
+    /// <summary>
+    /// Emits only the first value in each time window.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="window">Time window.</param>
+    /// <param name="scheduler">Scheduler (optional).</param>
+    /// <returns>Throttle-first sequence.</returns>
+    public static IObservable<T> ThrottleFirst<T>(
+        this IObservable<T> source,
+        TimeSpan window,
+        ISequencer? scheduler) =>
+        new ThrottleFirstObservable<T>(source, window, scheduler ?? Sequencer.Default);
+
+    /// <summary>
+    /// Throttle until a predicate becomes true.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="throttle">The throttle.</param>
+    /// <param name="predicate">The predicate.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> ThrottleUntilTrue<T>(
+        this IObservable<T> source,
+        TimeSpan throttle,
+        Func<T, bool> predicate) =>
+        new ThrottleUntilTrueObservable<T>(source, throttle, predicate);
+
+    /// <summary>
+    /// Throttles the on scheduler.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="timeSpan">The time span.</param>
+    /// <param name="scheduler">A scheduler for the operation.</param>
+    /// <returns>A observable for the throttle operation.</returns>
+    public static IObservable<T> ThrottleOnScheduler<T>(
+        this IObservable<T> source,
+        TimeSpan timeSpan,
+        ISequencer scheduler)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(scheduler);
+        return new ThrottleObservable<T>(source, timeSpan, scheduler);
+    }
+
+    /// <summary>
+    /// Builds a current-value subject pair: a read-only observable and the push-side observer.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="initialValue">The initial value.</param>
+    /// <returns>A tuple of IObservable and IObserver.</returns>
+    public static (IObservable<T> Observable, IObserver<T> Observer) ToReadOnlyBehavior<T>(T initialValue)
+    {
+        var subject = new CurrentValueSubject<T>(initialValue);
+        return (subject.AsObservable(), subject);
+    }
+
+    /// <summary>
+    /// Convert an observable to a Task that starts immediately.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <returns>A Task of T.</returns>
+    public static Task<T> ToHotTask<T>(this IObservable<T> source) => FirstAsTaskHelper.FirstAsTask(source);
+
+    /// <summary>
+    /// Convert an observable to a <see cref="ValueTask{T}"/> that starts immediately. Backed by a
+    /// pooled <see cref="System.Threading.Tasks.Sources.IValueTaskSource{T}"/> implementation, so
+    /// steady-state callers pay no allocations after the per-type pool warms up. Prefer this over
+    /// <see cref="ToHotTask{T}"/> when the call site can consume a <see cref="ValueTask{T}"/>
+    /// (single await, no caching, no <c>WhenAll</c>).
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <returns>A <see cref="ValueTask{T}"/> that completes with the first value, faults on source error, or faults on empty completion.</returns>
+    public static ValueTask<T> ToHotValueTask<T>(this IObservable<T> source) =>
+        FirstAsValueTaskHelper<T>.FirstAsValueTask(source);
+
+    /// <summary>
+    /// Convert a property getter into an observable that emits on change.
+    /// </summary>
+    /// <typeparam name="T">The type of the source.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="propertyExpression">The property expression.</param>
+    /// <returns>An IObservable of TProperty.</returns>
+    /// <exception cref="ArgumentException">Expression must be a property.</exception>
+    public static IObservable<TProperty> ToPropertyObservable<T, TProperty>(
+        this T source,
+        Expression<Func<T, TProperty>> propertyExpression)
+        where T : INotifyPropertyChanged
+    {
+        ArgumentExceptionHelper.ThrowIfNull(propertyExpression);
+
+        var member = propertyExpression.Body as MemberExpression
+                     ?? throw new ArgumentException("Expression must be a property");
+
+        return new PropertyChangedObservable<T, TProperty>(
+            source,
+            member.Member.Name,
+            propertyExpression.Compile());
+    }
+
+    /// <summary>
+    /// Throttle but only emit when the value actually changes.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="throttle">The throttle.</param>
+    /// <returns>A throttled distinct sequence.</returns>
+    public static IObservable<T> ThrottleDistinct<T>(
+        this IObservable<T> source,
+        TimeSpan throttle) =>
+        new ThrottleDistinctObservable<T>(source, throttle, Sequencer.Default);
+
+    /// <summary>
+    /// Throttle but only emit when the value actually changes.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="throttle">The throttle.</param>
+    /// <param name="scheduler">The scheduler.</param>
+    /// <returns>A throttled distinct sequence.</returns>
+    public static IObservable<T> ThrottleDistinct<T>(
+        this IObservable<T> source,
+        TimeSpan throttle,
+        ISequencer scheduler) =>
+        new ThrottleDistinctObservable<T>(source, throttle, scheduler);
+
+    /// <summary>
+    /// Debounces with an immediate first emission then standard debounce behavior.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="dueTime">Debounce time.</param>
+    /// <returns>Debounced sequence.</returns>
+    public static IObservable<T> DebounceImmediate<T>(
+        this IObservable<T> source,
+        TimeSpan dueTime) =>
+        source.DebounceImmediate(dueTime, null);
+
+    /// <summary>
+    /// Debounces with an immediate first emission then standard debounce behavior.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="dueTime">Debounce time.</param>
+    /// <param name="scheduler">Scheduler (optional).</param>
+    /// <returns>Debounced sequence.</returns>
+    public static IObservable<T> DebounceImmediate<T>(
+        this IObservable<T> source,
+        TimeSpan dueTime,
+        ISequencer? scheduler) =>
+        new DebounceImmediateObservable<T>(source, dueTime, scheduler ?? Sequencer.Default);
+
+    /// <summary>
+    /// Debounce until a condition becomes true.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="debounce">The debounce.</param>
+    /// <param name="condition">The condition.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> DebounceUntil<T>(
+        this IObservable<T> source,
+        TimeSpan debounce,
+        Func<T, bool> condition) =>
+        source.DebounceUntil(debounce, condition, null);
+
+    /// <summary>
+    /// Debounce until a condition becomes true.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="debounce">The debounce.</param>
+    /// <param name="condition">The condition.</param>
+    /// <param name="scheduler">A scheduler for the operation.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> DebounceUntil<T>(
+        this IObservable<T> source,
+        TimeSpan debounce,
+        Func<T, bool> condition,
+        ISequencer? scheduler) =>
+        new DebounceUntilObservable<T>(source, debounce, condition, scheduler ?? Sequencer.Default);
+
+    /// <summary>
+    /// Maps values to async operations without losing ordering or cancellation semantics.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="asyncSelector">The asynchronous selector.</param>
+    /// <returns>An IObservable of TResult.</returns>
+    public static IObservable<TResult> SelectAsync<TSource, TResult>(
+        this IObservable<TSource> source,
+        Func<TSource, CancellationToken, Task<TResult>> asyncSelector) =>
+        new SelectAsyncSequentialObservable<TSource, TResult>(source, x => asyncSelector(x, CancellationToken.None));
+
+    /// <summary>
+    /// Maps values to async operations without losing ordering or cancellation semantics.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the source.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="asyncSelector">The asynchronous selector.</param>
+    /// <returns>An IObservable of TResult.</returns>
+    public static IObservable<TResult> SelectAsync<TSource, TResult>(
+        this IObservable<TSource> source,
+        Func<TSource, Task<TResult>> asyncSelector) =>
+        new SelectAsyncSequentialObservable<TSource, TResult>(source, asyncSelector);
+
+    /// <summary>
+    /// Projects each element to a task executed sequentially.
+    /// </summary>
+    /// <typeparam name="TSource">Source element type.</typeparam>
+    /// <typeparam name="TResult">Result type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="selector">Task selector.</param>
+    /// <returns>Sequence of results preserving order.</returns>
+    public static IObservable<TResult> SelectAsyncSequential<TSource, TResult>(
+        this IObservable<TSource> source,
+        Func<TSource, Task<TResult>> selector) =>
+        new SelectAsyncSequentialObservable<TSource, TResult>(source, selector);
+
+    /// <summary>
+    /// Projects each element to a task but only latest result is emitted.
+    /// </summary>
+    /// <typeparam name="TSource">Source type.</typeparam>
+    /// <typeparam name="TResult">Result type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="selector">Task selector.</param>
+    /// <returns>Sequence of latest task results.</returns>
+    public static IObservable<TResult> SelectLatestAsync<TSource, TResult>(
+        this IObservable<TSource> source,
+        Func<TSource, Task<TResult>> selector) =>
+        new SelectLatestAsyncObservable<TSource, TResult>(source, selector);
+
+    /// <summary>
+    /// Projects each element to a task with limited concurrency.
+    /// </summary>
+    /// <typeparam name="TSource">Source type.</typeparam>
+    /// <typeparam name="TResult">Result type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="selector">Task selector.</param>
+    /// <param name="maxConcurrency">Max concurrency.</param>
+    /// <returns>Merged sequence of task results.</returns>
+    public static IObservable<TResult> SelectAsyncConcurrent<TSource, TResult>(
+        this IObservable<TSource> source,
+        Func<TSource, Task<TResult>> selector,
+        int maxConcurrency) =>
+        new SelectAsyncConcurrentObservable<TSource, TResult>(source, selector, maxConcurrency);
+
+    /// <summary>
+    /// Emit (previous, current) pairs.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <returns>An IObservable of (T Previous, T Current).</returns>
+    public static IObservable<(T Previous, T Current)> Pairwise<T>(
+        this IObservable<T> source) => new PairwiseObservable<T>(source);
+
+    /// <summary>
+    /// Partitions a sequence into two based on predicate.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="predicate">Predicate.</param>
+    /// <returns>Tuple of (trueSequence, falseSequence).</returns>
+    public static (IObservable<T> True, IObservable<T> False) Partition<T>(
+        this IObservable<T> source,
+        Func<T, bool> predicate)
+    {
+        var partition = new PartitionObservable<T>(source, predicate);
+        return (partition.True, partition.False);
+    }
+
+    /// <summary>
+    /// Buffers items until inactivity period elapses then emits and resets buffer.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="inactivityPeriod">Inactivity period.</param>
+    /// <returns>Sequence of buffered lists.</returns>
+    public static IObservable<IList<T>> BufferUntilInactive<T>(
+        this IObservable<T> source,
+        TimeSpan inactivityPeriod) =>
+        source.BufferUntilInactive(inactivityPeriod, null);
+
+    /// <summary>
+    /// Buffers items until inactivity period elapses then emits and resets buffer.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="inactivityPeriod">Inactivity period.</param>
+    /// <param name="scheduler">Scheduler.</param>
+    /// <returns>Sequence of buffered lists.</returns>
+    public static IObservable<IList<T>> BufferUntilInactive<T>(
+        this IObservable<T> source,
+        TimeSpan inactivityPeriod,
+        ISequencer? scheduler) =>
+        new BufferUntilIdleObservable<T>(source, inactivityPeriod, scheduler ?? Sequencer.Default);
+
+    /// <summary>
+    /// Emits the first element matching predicate then completes.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="predicate">Predicate.</param>
+    /// <returns>Sequence with first matching element.</returns>
+    public static IObservable<T> WaitUntil<T>(this IObservable<T> source, Func<T, bool> predicate) =>
+        new WaitUntilObservable<T>(source, predicate);
+
+    /// <summary>
+    /// Drop values when the previous async operation is still running.
+    /// </summary>
+    /// <typeparam name="T">The type.</typeparam>
+    /// <param name="source">The source.</param>
+    /// <param name="asyncAction">The asynchronous action.</param>
+    /// <returns>An IObservable of T.</returns>
+    public static IObservable<T> DropIfBusy<T>(
+        this IObservable<T> source,
+        Func<T, ValueTask> asyncAction) =>
+        new DropIfBusyObservable<T>(source, asyncAction);
+
+    /// <summary>
+    /// Executes an action at subscription time.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="action">Action to run on subscribe.</param>
+    /// <returns>Original sequence with subscribe side-effect.</returns>
+    public static IObservable<T> DoOnSubscribe<T>(this IObservable<T> source, Action action) =>
+        new DoOnSubscribeObservable<T>(source, action);
+
+    /// <summary>
+    /// Executes an action when subscription is disposed.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequence.</param>
+    /// <param name="disposeAction">Action to run on dispose.</param>
+    /// <returns>Original sequence with dispose side-effect.</returns>
+    public static IObservable<T> DoOnDispose<T>(this IObservable<T> source, Action disposeAction) =>
+        new DoOnDisposeObservable<T>(source, disposeAction);
+
+    /// <summary>
+    /// Fused <c>Where(predicate).Select(selector)</c>. Allocates a single observer
+    /// per subscription instead of two, eliminating the intermediate operator that
+    /// the equivalent Rx chain would build.
+    /// </summary>
+    /// <typeparam name="TIn">The source element type.</typeparam>
+    /// <typeparam name="TOut">The projected element type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="predicate">Filter applied to each source element.</param>
+    /// <param name="selector">Projection applied to elements that pass <paramref name="predicate"/>.</param>
+    /// <returns>A fused filter-and-project observable.</returns>
+    public static IObservable<TOut> WhereSelect<TIn, TOut>(
+        this IObservable<TIn> source,
+        Func<TIn, bool> predicate,
+        Func<TIn, TOut> selector) =>
+        new WhereSelectObservable<TIn, TOut>(source, predicate, selector);
+
+    /// <summary>
+    /// Swallows any source error by emitting the fallback value followed by completion.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The source observable whose values are forwarded verbatim.</param>
+    /// <param name="fallback">The value emitted if the source errors.</param>
+    /// <returns>An observable that never produces an error terminal.</returns>
+    public static IObservable<T> CatchReturn<T>(this IObservable<T> source, T fallback) =>
+        new CatchReturnObservable<T>(source, fallback);
+
+    /// <summary>
+    /// Convenience overload: <c>source.CatchReturnUnit()</c> is shorthand for
+    /// <c>source.CatchReturn(RxVoid.Default)</c>.
+    /// </summary>
+    /// <param name="source">The source observable.</param>
+    /// <returns>An observable that never produces an error terminal — errors are replaced with a single <see cref="RxVoid.Default"/>.</returns>
+    public static IObservable<RxVoid> CatchReturnUnit(this IObservable<RxVoid> source) =>
+        new CatchReturnObservable<RxVoid>(source, RxVoid.Default);
+
+    /// <summary>
+    /// Projects every source element to a stored constant, avoiding the closure
+    /// allocation of <c>.Select(_ =&gt; value)</c>. Common in fire-then-return-value
+    /// chains.
+    /// </summary>
+    /// <typeparam name="TSource">The source element type (ignored).</typeparam>
+    /// <typeparam name="TResult">The result element type.</typeparam>
+    /// <param name="source">The source observable whose values are ignored.</param>
+    /// <param name="constant">The constant value emitted for each source element.</param>
+    /// <returns>An observable that emits <paramref name="constant"/> for each source element.</returns>
+    public static IObservable<TResult> SelectConstant<TSource, TResult>(
+        this IObservable<TSource> source,
+        TResult constant) =>
+        new SelectConstantObservable<TSource, TResult>(source, constant);
+
+    /// <summary>
+    /// Applies <paramref name="selector"/> and emits only non-null results.
+    /// Replaces <c>.Select(f).Where(x =&gt; x is not null).Select(x =&gt; x!)</c>
+    /// with a single operator allocation.
+    /// </summary>
+    /// <typeparam name="TIn">The source element type.</typeparam>
+    /// <typeparam name="TOut">The projected element type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="selector">Projection that may return <see langword="null"/>.</param>
+    /// <returns>An observable that emits only non-null projected values.</returns>
+    public static IObservable<TOut> TrySelect<TIn, TOut>(
+        this IObservable<TIn> source,
+        Func<TIn, TOut?> selector) =>
+        new TrySelectObservable<TIn, TOut>(source, selector);
+
+    /// <summary>
+    /// Chains two one-shot <c>SelectMany</c> projections into a single operator.
+    /// Replaces <c>.SelectMany(a).SelectMany(b)</c> (2 operator allocations) with 1.
+    /// </summary>
+    /// <typeparam name="TSource">The source element type.</typeparam>
+    /// <typeparam name="TMid">The intermediate element type.</typeparam>
+    /// <typeparam name="TResult">The final result type.</typeparam>
+    /// <param name="source">The source observable.</param>
+    /// <param name="first">First projection: source → intermediate observable.</param>
+    /// <param name="second">Second projection: intermediate → result observable.</param>
+    /// <returns>A fused two-stage SelectMany observable.</returns>
+    public static IObservable<TResult> SelectManyThen<TSource, TMid, TResult>(
+        this IObservable<TSource> source,
+        Func<TSource, IObservable<TMid>> first,
+        Func<TMid, IObservable<TResult>> second) =>
+        new SelectManyThenObservable<TSource, TMid, TResult>(source, first, second);
+
+    /// <summary>
+    /// Runs a list of one-shot <see cref="IObservable{RxVoid}"/> sequentially and emits
+    /// a single <see cref="RxVoid.Default"/> when all have completed. Replaces
+    /// <c>.Concat().LastOrDefaultAsync()</c> with a single operator that avoids stack
+    /// overflow on inline-completing sources.
+    /// </summary>
+    /// <param name="sources">The observables to run in order.</param>
+    /// <returns>A one-shot observable that completes after all sources.</returns>
+    public static IObservable<RxVoid> RunAll(this IReadOnlyList<IObservable<RxVoid>> sources) =>
+        new RunAllObservable(sources);
+
+    /// <summary>
+    /// Walks a list of candidate keys sequentially, projects each into a one-shot
+    /// observable, transforms the raw value, and emits the first transformed value
+    /// that satisfies <paramref name="predicate"/>. Errors from individual projections
+    /// are swallowed (the candidate is skipped). If no candidate matches, emits
+    /// <paramref name="fallback"/>.
+    /// </summary>
+    /// <typeparam name="TKey">The candidate key type.</typeparam>
+    /// <typeparam name="TRaw">The raw element type emitted by the projection.</typeparam>
+    /// <typeparam name="TResult">The transformed result type.</typeparam>
+    /// <param name="candidates">The ordered list of candidate keys to walk.</param>
+    /// <param name="project">Projects a key into a one-shot observable of raw values.</param>
+    /// <param name="transform">Transform applied to each raw value to produce the result.</param>
+    /// <param name="predicate">Returns <see langword="true"/> for a matching transformed value.</param>
+    /// <param name="fallback">Value emitted when no candidate matches.</param>
+    /// <returns>An observable emitting the first matching transformed value, or <paramref name="fallback"/>.</returns>
+    public static IObservable<TResult> FirstMatchFromCandidates<TKey, TRaw, TResult>(
+        this IReadOnlyList<TKey> candidates,
+        Func<TKey, IObservable<TRaw>> project,
+        Func<TRaw, TResult> transform,
+        Func<TResult, bool> predicate,
+        TResult fallback) =>
+        new FirstMatchFromCandidatesObservable<TKey, TRaw, TResult>(
+            candidates,
+            project,
+            transform,
+            predicate,
+            fallback);
+}
diff --git a/src/ReactiveUI.Primitives.Extensions/ReactiveUI.Primitives.Extensions.csproj b/src/ReactiveUI.Primitives.Extensions/ReactiveUI.Primitives.Extensions.csproj
new file mode 100644
index 0000000..9d748b9
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/ReactiveUI.Primitives.Extensions.csproj
@@ -0,0 +1,45 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(LibraryTargetFrameworks)</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>preview</LangVersion>
+  </PropertyGroup>
+
+  <!-- Alias Lock to the dedicated System.Threading.Lock on .NET 9+ (faster EnterScope fast path),
+       and to a plain object elsewhere (the lock statement falls back to Monitor). -->
+  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))">
+    <Using Include="System.Threading.Lock" Alias="Lock" />
+  </ItemGroup>
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))">
+    <Using Include="System.Object" Alias="Lock" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
+    <PackageReference Include="System.ValueTuple" />
+  </ItemGroup>
+
+  <ItemGroup Condition="$(TargetFramework.StartsWith('net4'))">
+    <PackageReference Include="Polyfill">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.Bcl.TimeProvider" />
+    <PackageReference Include="System.Threading.Channels" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" />
+    <PackageReference Include="System.ComponentModel.Annotations" />
+    <PackageReference Include="System.Buffers" />
+    <PackageReference Include="System.Memory" />
+    <PackageReference Include="System.Collections.Immutable" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="$(AssemblyName).Tests" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ReactiveUI.Primitives\ReactiveUI.Primitives.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/ReactiveUI.Primitives.Extensions/Stale.cs b/src/ReactiveUI.Primitives.Extensions/Stale.cs
new file mode 100644
index 0000000..69c73b8
--- /dev/null
+++ b/src/ReactiveUI.Primitives.Extensions/Stale.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions;
+
+/// <summary>
+/// Represents either a staleness indicator or a value update from an observable stream. Value-type shape;
+/// the stale-detection operator emits these directly so per-emission allocations are zero. Note that
+/// <c>default(Stale&lt;T&gt;)</c> represents a value update with the default <typeparamref name="T"/>; use
+/// <c>new Stale&lt;T&gt;()</c> to construct a staleness signal.
+/// </summary>
+/// <typeparam name="T">The type of the update value.</typeparam>
+public readonly record struct Stale<T> : IStale<T>
+{
+    /// <summary>The update value, or <see langword="default"/> when the instance is a stale signal.</summary>
+    private readonly T? _update;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Stale{T}"/> struct representing a stale signal.
+    /// </summary>
+    public Stale()
+    {
+        IsStale = true;
+        _update = default;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Stale{T}"/> struct representing a value update.
+    /// </summary>
+    /// <param name="update">The update value.</param>
+    public Stale(T? update)
+    {
+        IsStale = false;
+        _update = update;
+    }
+
+    /// <inheritdoc/>
+    public bool IsStale { get; }
+
+    /// <inheritdoc/>
+    public T? Update => IsStale ? throw new InvalidOperationException("Stale instance has no update.") : _update;
+}
diff --git a/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs b/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
index d1a8b6d..a72c967 100644
--- a/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives.Wpf/Concurrency/DispatcherSequencer.cs
@@ -9,7 +9,7 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// <summary>
 /// WPF dispatcher sequencer that coalesces scheduled work onto a dispatcher drain.
 /// </summary>
-/// <seealso cref="ReactiveUI.Primitives.Concurrency.DispatchSequencerBase" />
+/// <seealso cref="DispatchSequencerBase" />
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public class DispatcherSequencer : DispatchSequencerBase
 {
diff --git a/src/ReactiveUI.Primitives.slnx b/src/ReactiveUI.Primitives.slnx
index cdd9bb3..c95f245 100644
--- a/src/ReactiveUI.Primitives.slnx
+++ b/src/ReactiveUI.Primitives.slnx
@@ -19,6 +19,7 @@
     </Folder>
     <Folder Name="/tests/">
         <Project Path="tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj" />
+        <Project Path="tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveUI.Primitives.Extensions.Tests.csproj" />
         <Project Path="tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj" />
         <Project Path="tests/ReactiveUI.Primitives.Blazor.Tests/ReactiveUI.Primitives.Blazor.Tests.csproj" />
         <Project Path="tests/ReactiveUI.Primitives.Maui.Tests/ReactiveUI.Primitives.Maui.Tests.csproj" />
@@ -30,6 +31,7 @@
     <Project Path="ReactiveUI.Primitives.SystemReactiveBridge.Generator/ReactiveUI.Primitives.SystemReactiveBridge.Generator.csproj" />
     <Project Path="ReactiveUI.Primitives/ReactiveUI.Primitives.csproj" />
     <Project Path="ReactiveUI.Primitives.Async/ReactiveUI.Primitives.Async.csproj" />
+    <Project Path="ReactiveUI.Primitives.Extensions/ReactiveUI.Primitives.Extensions.csproj" />
     <Project Path="ReactiveUI.Primitives.Blazor/ReactiveUI.Primitives.Blazor.csproj" />
     <Project Path="ReactiveUI.Primitives.Maui/ReactiveUI.Primitives.Maui.csproj" />
     <Project Path="ReactiveUI.Primitives.WinUI/ReactiveUI.Primitives.WinUI.csproj" />
diff --git a/src/ReactiveUI.Primitives/Disposables/ActionDisposable.cs b/src/ReactiveUI.Primitives/Disposables/ActionDisposable.cs
new file mode 100644
index 0000000..a47f3df
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Disposables/ActionDisposable.cs
@@ -0,0 +1,39 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Disposables;
+
+/// <summary>
+/// An <see cref="IDisposable"/> that runs the supplied <see cref="Action"/> exactly once on
+/// <see cref="Dispose"/>. Replaces <c>Disposable.Create(Action)</c>.
+/// </summary>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed class ActionDisposable : IsDisposed
+{
+    /// <summary>
+    /// The action to invoke once on dispose.
+    /// </summary>
+    private Action? _action;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ActionDisposable"/> class.
+    /// </summary>
+    /// <param name="action">The action to invoke once on dispose.</param>
+    public ActionDisposable(Action action) => _action = action;
+
+    /// <summary>
+    /// Gets a value indicating whether this instance has been disposed.
+    /// </summary>
+    public bool IsDisposed => Volatile.Read(ref _action) is null;
+
+    /// <summary>
+    /// Gets the debugger display text.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+    private string DebuggerDisplay => ToString() ?? string.Empty;
+
+    /// <inheritdoc/>
+    public void Dispose() => Interlocked.Exchange(ref _action, null)?.Invoke();
+}
diff --git a/src/ReactiveUI.Primitives/Disposables/AnonymousDisposable.cs b/src/ReactiveUI.Primitives/Disposables/AnonymousDisposable.cs
deleted file mode 100644
index 2d9480e..0000000
--- a/src/ReactiveUI.Primitives/Disposables/AnonymousDisposable.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
-// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for full license information.
-
-namespace ReactiveUI.Primitives.Disposables;
-
-/// <summary>
-/// Represents an Action-based disposable.
-/// </summary>
-public sealed class AnonymousDisposable : IDisposable
-{
-    /// <summary>
-    /// Disposal action, cleared after the first dispose call.
-    /// </summary>
-    private volatile Action? _dispose;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="AnonymousDisposable"/> class.
-    /// </summary>
-    /// <param name="dispose">The dispose.</param>
-    public AnonymousDisposable(Action dispose) =>
-        _dispose = dispose;
-
-    /// <summary>
-    /// Calls the disposal action if and only if the current instance hasn't been disposed yet.
-    /// </summary>
-    public void Dispose() =>
-        Interlocked.Exchange(ref _dispose, null)?.Invoke();
-}
\ No newline at end of file
diff --git a/src/ReactiveUI.Primitives/Disposables/Disposable.cs b/src/ReactiveUI.Primitives/Disposables/Disposable.cs
index 66a6538..8264706 100644
--- a/src/ReactiveUI.Primitives/Disposables/Disposable.cs
+++ b/src/ReactiveUI.Primitives/Disposables/Disposable.cs
@@ -12,7 +12,7 @@ public static class Disposable
     /// <summary>
     /// Gets the disposable that does nothing when disposed.
     /// </summary>
-    public static IDisposable Empty { get; } = new EmptyDisposable();
+    public static IDisposable Empty { get; } = EmptyDisposable.Instance;
 
     /// <summary>
     /// Creates a disposable object that invokes the specified action when disposed.
@@ -21,5 +21,5 @@ public static class Disposable
     /// <returns>The disposable object that runs the given action upon disposal.</returns>
     /// <remarks>A <see langword="null"/> action returns <see cref="Empty"/> for backward compatibility with existing ReactiveUI.Primitives create pipelines.</remarks>
     public static IDisposable Create(Action dispose) =>
-        dispose == null ? Empty : new AnonymousDisposable(dispose);
+        dispose == null ? Empty : new ActionDisposable(dispose);
 }
diff --git a/src/ReactiveUI.Primitives/Disposables/DisposableBag.cs b/src/ReactiveUI.Primitives/Disposables/DisposableBag.cs
new file mode 100644
index 0000000..ca051c0
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Disposables/DisposableBag.cs
@@ -0,0 +1,192 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Disposables;
+
+/// <summary>
+/// A small composite-disposable replacement specialised for the common 2-slot
+/// "subscription + sink" pair found throughout this codebase. Avoids the
+/// <see cref="List{T}"/> backing field of
+/// <c>System.Reactive.Disposables.CompositeDisposable</c>.
+/// </summary>
+/// <remarks>
+/// The first two added entries are stored inline. A third or later entry causes a fall-back
+/// to a heap-allocated array. Disposal is idempotent and disposes every contained entry,
+/// in registration order, exactly once.
+/// </remarks>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed class DisposableBag : IsDisposed
+{
+    /// <summary>Starting capacity of the overflow array once the two inline slots are taken.</summary>
+    private const int OverflowInitialCapacity = 2;
+
+    /// <summary>Growth factor for the overflow array.</summary>
+    private const int OverflowGrowthFactor = 2;
+
+    /// <summary>
+    /// The synchronization object.
+    /// </summary>
+    private readonly Lock _gate = new();
+
+    /// <summary>
+    /// The first disposable slot.
+    /// </summary>
+    private IDisposable? _slot0;
+
+    /// <summary>
+    /// The second disposable slot.
+    /// </summary>
+    private IDisposable? _slot1;
+
+    /// <summary>
+    /// The overflow array for additional disposables.
+    /// </summary>
+    private IDisposable[]? _overflow;
+
+    /// <summary>
+    /// The number of disposables in the overflow array.
+    /// </summary>
+    private int _overflowCount;
+
+    /// <summary>
+    /// Indicates whether the bag has been disposed.
+    /// </summary>
+    private bool _disposed;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DisposableBag"/> class.
+    /// </summary>
+    public DisposableBag()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DisposableBag"/> class with two pre-populated slots.
+    /// </summary>
+    /// <param name="first">The first disposable.</param>
+    /// <param name="second">The second disposable.</param>
+    public DisposableBag(IDisposable first, IDisposable second)
+    {
+        _slot0 = first;
+        _slot1 = second;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DisposableBag"/> class with three pre-populated slots.
+    /// </summary>
+    /// <param name="first">The first disposable.</param>
+    /// <param name="second">The second disposable.</param>
+    /// <param name="third">The third disposable.</param>
+    public DisposableBag(IDisposable first, IDisposable second, IDisposable third)
+    {
+        _slot0 = first;
+        _slot1 = second;
+        _overflow = new IDisposable[OverflowInitialCapacity];
+        _overflow[0] = third;
+        _overflowCount = 1;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether this instance has been disposed.
+    /// </summary>
+    public bool IsDisposed => Volatile.Read(ref _disposed);
+
+    /// <summary>
+    /// Gets the debugger display text.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+    private string DebuggerDisplay => ToString() ?? string.Empty;
+
+    /// <summary>
+    /// Adds a disposable to the bag. If the bag is already disposed, the supplied
+    /// disposable is disposed immediately.
+    /// </summary>
+    /// <param name="disposable">The disposable to add.</param>
+    public void Add(IDisposable disposable)
+    {
+        if (disposable is null)
+        {
+            return;
+        }
+
+        var disposeNow = false;
+        lock (_gate)
+        {
+            if (_disposed)
+            {
+                disposeNow = true;
+            }
+            else if (_slot0 is null)
+            {
+                _slot0 = disposable;
+            }
+            else if (_slot1 is null)
+            {
+                _slot1 = disposable;
+            }
+            else
+            {
+                if (_overflow is null)
+                {
+                    _overflow = new IDisposable[OverflowInitialCapacity];
+                }
+                else if (_overflowCount == _overflow.Length)
+                {
+                    var grown = new IDisposable[_overflow.Length * OverflowGrowthFactor];
+                    Array.Copy(_overflow, grown, _overflowCount);
+                    _overflow = grown;
+                }
+
+                _overflow[_overflowCount++] = disposable;
+            }
+        }
+
+        if (!disposeNow)
+        {
+            return;
+        }
+
+        disposable.Dispose();
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        IDisposable? s0;
+        IDisposable? s1;
+        IDisposable[]? overflow;
+        int overflowCount;
+
+        lock (_gate)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+            s0 = _slot0;
+            s1 = _slot1;
+            overflow = _overflow;
+            overflowCount = _overflowCount;
+            _slot0 = null;
+            _slot1 = null;
+            _overflow = null;
+            _overflowCount = 0;
+        }
+
+        s0?.Dispose();
+        s1?.Dispose();
+        if (overflow is null)
+        {
+            return;
+        }
+
+        for (var i = 0; i < overflowCount; i++)
+        {
+            overflow[i].Dispose();
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives/Disposables/DisposableSlotHelper.cs b/src/ReactiveUI.Primitives/Disposables/DisposableSlotHelper.cs
new file mode 100644
index 0000000..5ce5288
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Disposables/DisposableSlotHelper.cs
@@ -0,0 +1,116 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace ReactiveUI.Primitives.Disposables;
+
+/// <summary>
+/// Pure-plumbing helpers for the swap-disposable-slot pattern shared by
+/// <see cref="MutableDisposable"/> and <see cref="SwapDisposable"/>. Centralizes the
+/// pre-check / store / race-recheck flow so the call-site setters stay one-line delegations.
+/// All testable branches (already-disposed pre-check, steady-state assign, idempotent dispose)
+/// have direct RxVoid tests against this class. The single race-recheck step that fires only
+/// when <c>Dispose()</c> runs concurrently between the helper's <c>Volatile.Read</c> pre-check
+/// and the store is isolated in <see cref="DisposeIfRaced"/>, which is marked
+/// <see cref="ExcludeFromCodeCoverageAttribute"/>. That step is unreachable without a real
+/// concurrent thread, in the same spirit as the library's throw-helper methods.
+/// </summary>
+internal static class DisposableSlotHelper
+{
+    /// <summary>Sentinel value indicating the holder has been disposed.</summary>
+    public const int DisposedSentinel = 1;
+
+    /// <summary>
+    /// Reassigns an inner disposable slot WITHOUT disposing the previous value (mutable-assign
+    /// semantics, matching the <see cref="MutableDisposable"/> contract). If the holder is
+    /// already disposed, the incoming value is disposed immediately; if Dispose races between
+    /// the pre-check and the store, the just-stored value is disposed via
+    /// <see cref="DisposeIfRaced"/>.
+    /// </summary>
+    /// <param name="slot">The reference to the current-inner field.</param>
+    /// <param name="disposed">The reference to the disposed-flag field.</param>
+    /// <param name="value">The incoming value (or <see langword="null"/>).</param>
+    public static void AssignWithoutDisposingPrevious(
+        ref IDisposable? slot,
+        ref int disposed,
+        IDisposable? value)
+    {
+        if (Volatile.Read(ref disposed) == DisposedSentinel)
+        {
+            value?.Dispose();
+            return;
+        }
+
+        Interlocked.Exchange(ref slot, value);
+        DisposeIfRaced(ref slot, ref disposed);
+    }
+
+    /// <summary>
+    /// Reassigns an inner disposable slot and disposes the previous value (swap semantics,
+    /// matching the <see cref="SwapDisposable"/> contract). If the holder is already disposed,
+    /// the incoming value is disposed immediately; if Dispose races between the swap and the
+    /// recheck, the just-stored value is disposed via <see cref="DisposeIfRaced"/>.
+    /// </summary>
+    /// <param name="slot">The reference to the current-inner field.</param>
+    /// <param name="disposed">The reference to the disposed-flag field.</param>
+    /// <param name="value">The incoming value (or <see langword="null"/>).</param>
+    public static void SwapAndDisposePrevious(
+        ref IDisposable? slot,
+        ref int disposed,
+        IDisposable? value)
+    {
+        if (Volatile.Read(ref disposed) == DisposedSentinel)
+        {
+            value?.Dispose();
+            return;
+        }
+
+        var previous = Interlocked.Exchange(ref slot, value);
+        previous?.Dispose();
+        DisposeIfRaced(ref slot, ref disposed);
+    }
+
+    /// <summary>
+    /// Performs the standard idempotent dispose step: latches the disposed flag and disposes
+    /// the current inner (if any). Returns <see langword="true"/> if this was the first call
+    /// and the caller should clean up; <see langword="false"/> if a prior dispose has already
+    /// done the work.
+    /// </summary>
+    /// <param name="slot">The reference to the current-inner field.</param>
+    /// <param name="disposed">The reference to the disposed-flag field.</param>
+    /// <returns>
+    /// <see langword="true"/> if the current invocation latched the flag; otherwise
+    /// <see langword="false"/>.
+    /// </returns>
+    public static bool TryDispose(ref IDisposable? slot, ref int disposed)
+    {
+        if (Interlocked.Exchange(ref disposed, DisposedSentinel) == DisposedSentinel)
+        {
+            return false;
+        }
+
+        Interlocked.Exchange(ref slot, null)?.Dispose();
+        return true;
+    }
+
+    /// <summary>
+    /// Race-only cleanup: if <c>Dispose()</c> ran concurrently between the setter's pre-check
+    /// and the slot store, swap the value out and dispose it to avoid leaking. The branch
+    /// only fires when a real concurrent thread cancels in the TOCTOU window, which cannot
+    /// be deterministically simulated in single-threaded RxVoid tests, hence the exclusion.
+    /// </summary>
+    /// <param name="slot">The reference to the current-inner field.</param>
+    /// <param name="disposed">The reference to the disposed-flag field.</param>
+    [ExcludeFromCodeCoverage]
+    private static void DisposeIfRaced(ref IDisposable? slot, ref int disposed)
+    {
+        if (Volatile.Read(ref disposed) != DisposedSentinel)
+        {
+            return;
+        }
+
+        Interlocked.Exchange(ref slot, null)?.Dispose();
+    }
+}
diff --git a/src/ReactiveUI.Primitives/Disposables/EmptyDisposable.cs b/src/ReactiveUI.Primitives/Disposables/EmptyDisposable.cs
index d853530..7ab5677 100644
--- a/src/ReactiveUI.Primitives/Disposables/EmptyDisposable.cs
+++ b/src/ReactiveUI.Primitives/Disposables/EmptyDisposable.cs
@@ -5,10 +5,30 @@
 namespace ReactiveUI.Primitives.Disposables;
 
 /// <summary>
-/// Disposable that performs no action.
+/// A no-op <see cref="IDisposable"/> singleton used in place of <c>Disposable.Empty</c>.
 /// </summary>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class EmptyDisposable : IDisposable
 {
+    /// <summary>
+    /// Prevents a default instance of the <see cref="EmptyDisposable"/> class from being created.
+    /// </summary>
+    private EmptyDisposable()
+    {
+    }
+
+    /// <summary>
+    /// Gets the shared singleton instance.
+    /// </summary>
+    public static EmptyDisposable Instance { get; } = new();
+
+    /// <summary>
+    /// Gets the debugger display text.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+    private string DebuggerDisplay => ToString() ?? string.Empty;
+
     /// <inheritdoc/>
     public void Dispose()
     {
diff --git a/src/ReactiveUI.Primitives/Disposables/MutableDisposable.cs b/src/ReactiveUI.Primitives/Disposables/MutableDisposable.cs
new file mode 100644
index 0000000..29713e0
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Disposables/MutableDisposable.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Disposables;
+
+/// <summary>
+/// A disposable holder whose inner disposable can be re-assigned. The previous inner
+/// disposable is NOT disposed when replaced (in contrast to <see cref="SwapDisposable"/>).
+/// Once this object is disposed, any subsequently assigned inner disposable is disposed
+/// immediately. Replaces <c>MultipleAssignmentDisposable</c>.
+/// </summary>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed class MutableDisposable : IsDisposed
+{
+    /// <summary>The current inner disposable.</summary>
+    private IDisposable? _current;
+
+    /// <summary>Indicates whether the object has been disposed (0 = open, 1 = disposed).</summary>
+    private int _disposed;
+
+    /// <summary>
+    /// Gets a value indicating whether this instance has been disposed.
+    /// </summary>
+    public bool IsDisposed => Volatile.Read(ref _disposed) == DisposableSlotHelper.DisposedSentinel;
+
+    /// <summary>Gets or sets the current inner disposable.</summary>
+    public IDisposable? Disposable
+    {
+        get => Volatile.Read(ref _current);
+        set => DisposableSlotHelper.AssignWithoutDisposingPrevious(ref _current, ref _disposed, value);
+    }
+
+    /// <summary>
+    /// Gets the debugger display text.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+    private string DebuggerDisplay => ToString() ?? string.Empty;
+
+    /// <inheritdoc/>
+    public void Dispose() => DisposableSlotHelper.TryDispose(ref _current, ref _disposed);
+}
diff --git a/src/ReactiveUI.Primitives/Disposables/OnceDisposable.cs b/src/ReactiveUI.Primitives/Disposables/OnceDisposable.cs
new file mode 100644
index 0000000..504d181
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Disposables/OnceDisposable.cs
@@ -0,0 +1,83 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Disposables;
+
+/// <summary>
+/// A disposable holder whose inner disposable can be set exactly once.
+/// Replaces <c>SingleAssignmentDisposable</c>. Subsequent assignments throw
+/// <see cref="InvalidOperationException"/>; if the holder has been disposed before
+/// assignment, the supplied disposable is disposed immediately and no exception is thrown.
+/// </summary>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed class OnceDisposable : IsDisposed
+{
+    /// <summary>
+    /// Sentinel value indicating the object has been disposed.
+    /// </summary>
+    private static readonly IDisposable DisposedSentinel = EmptyDisposable.Instance;
+
+    /// <summary>
+    /// The current inner disposable.
+    /// </summary>
+    private IDisposable? _current;
+
+    /// <summary>
+    /// Gets a value indicating whether a disposable has been assigned.
+    /// </summary>
+    public bool IsAssigned => Volatile.Read(ref _current) is not null;
+
+    /// <summary>
+    /// Gets a value indicating whether this instance has been disposed.
+    /// </summary>
+    public bool IsDisposed => ReferenceEquals(Volatile.Read(ref _current), DisposedSentinel);
+
+    /// <summary>
+    /// Gets or sets the inner disposable. Setting more than once throws.
+    /// </summary>
+    public IDisposable? Disposable
+    {
+        get
+        {
+            var current = Volatile.Read(ref _current);
+            return ReferenceEquals(current, DisposedSentinel) ? null : current;
+        }
+
+        set
+        {
+            var previous = Interlocked.CompareExchange(ref _current, value, null);
+            if (previous is null)
+            {
+                return;
+            }
+
+            if (ReferenceEquals(previous, DisposedSentinel))
+            {
+                value?.Dispose();
+                return;
+            }
+
+            throw new InvalidOperationException("Disposable already assigned.");
+        }
+    }
+
+    /// <summary>
+    /// Gets the debugger display text.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+    private string DebuggerDisplay => ToString() ?? string.Empty;
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        var previous = Interlocked.Exchange(ref _current, DisposedSentinel);
+        if (previous is null || ReferenceEquals(previous, DisposedSentinel))
+        {
+            return;
+        }
+
+        previous.Dispose();
+    }
+}
diff --git a/src/ReactiveUI.Primitives/Disposables/SwapDisposable.cs b/src/ReactiveUI.Primitives/Disposables/SwapDisposable.cs
new file mode 100644
index 0000000..67229ae
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Disposables/SwapDisposable.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Disposables;
+
+/// <summary>
+/// A disposable holder whose inner disposable can be re-assigned. The previous inner
+/// disposable is disposed when replaced (in contrast to <see cref="MutableDisposable"/>).
+/// Once this object is disposed, any subsequently assigned inner disposable is disposed
+/// immediately. Replaces <c>SerialDisposable</c>.
+/// </summary>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed class SwapDisposable : IsDisposed
+{
+    /// <summary>The current inner disposable.</summary>
+    private IDisposable? _current;
+
+    /// <summary>Indicates whether the object has been disposed (0 = open, 1 = disposed).</summary>
+    private int _disposed;
+
+    /// <summary>
+    /// Gets a value indicating whether this instance has been disposed.
+    /// </summary>
+    public bool IsDisposed => Volatile.Read(ref _disposed) == DisposableSlotHelper.DisposedSentinel;
+
+    /// <summary>Gets or sets the current inner disposable. Setting disposes the previous value.</summary>
+    public IDisposable? Disposable
+    {
+        get => Volatile.Read(ref _current);
+        set => DisposableSlotHelper.SwapAndDisposePrevious(ref _current, ref _disposed, value);
+    }
+
+    /// <summary>
+    /// Gets the debugger display text.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+    private string DebuggerDisplay => ToString() ?? string.Empty;
+
+    /// <inheritdoc/>
+    public void Dispose() => DisposableSlotHelper.TryDispose(ref _current, ref _disposed);
+}
diff --git a/src/ReactiveUI.Primitives/ReactiveUI.Primitives.csproj b/src/ReactiveUI.Primitives/ReactiveUI.Primitives.csproj
index 8c50554..bb75464 100644
--- a/src/ReactiveUI.Primitives/ReactiveUI.Primitives.csproj
+++ b/src/ReactiveUI.Primitives/ReactiveUI.Primitives.csproj
@@ -4,26 +4,6 @@
     <TargetFrameworks>$(LibraryTargetFrameworks)</TargetFrameworks>
   </PropertyGroup>
 
-  <PropertyGroup Condition="$(TargetFramework.Contains('-ios'))">
-    <SupportedOSPlatformVersion>15.0</SupportedOSPlatformVersion>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="$(TargetFramework.Contains('-tvos'))">
-    <SupportedOSPlatformVersion>15.0</SupportedOSPlatformVersion>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="$(TargetFramework.Contains('-macos'))">
-    <SupportedOSPlatformVersion>12.0</SupportedOSPlatformVersion>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="$(TargetFramework.Contains('-maccatalyst'))">
-    <SupportedOSPlatformVersion>15.0</SupportedOSPlatformVersion>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="$(TargetFramework.Contains('-android'))">
-    <SupportedOSPlatformVersion>23.0</SupportedOSPlatformVersion>
-  </PropertyGroup>
-
   <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
     <PackageReference Include="System.ValueTuple" />
   </ItemGroup>
@@ -39,33 +19,20 @@
 
   <ItemGroup>
     <InternalsVisibleTo Include="ReactiveUI.Primitives.Tests" />
+    <InternalsVisibleTo Include="ReactiveUI.Primitives.Extensions.Tests" />
     <InternalsVisibleTo Include="ReactiveUI.Primitives.Async.Tests" />
     <InternalsVisibleTo Include="ReactiveUI.Primitives.Blazor.Tests" />
-    <InternalsVisibleTo Include="ReactiveUI.Primitives.Blazor" />
-    <InternalsVisibleTo Include="ReactiveUI.Primitives.Maui" />
-    <InternalsVisibleTo Include="ReactiveUI.Primitives.WinUI" />
-    <InternalsVisibleTo Include="ReactiveUI.Primitives.WinForms" />
-    <InternalsVisibleTo Include="ReactiveUI.Primitives.Wpf" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\ReactiveUI.Primitives.R3Bridge.Generator\ReactiveUI.Primitives.R3Bridge.Generator.csproj"
-                      ReferenceOutputAssembly="false"
-                      PrivateAssets="all" />
-    <ProjectReference Include="..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\ReactiveUI.Primitives.SystemReactiveBridge.Generator.csproj"
-                      ReferenceOutputAssembly="false"
-                      PrivateAssets="all" />
+    <ProjectReference Include="..\ReactiveUI.Primitives.R3Bridge.Generator\ReactiveUI.Primitives.R3Bridge.Generator.csproj" ReferenceOutputAssembly="false" PrivateAssets="all" />
+    <ProjectReference Include="..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\ReactiveUI.Primitives.SystemReactiveBridge.Generator.csproj" ReferenceOutputAssembly="false" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
-    <None Include="..\ReactiveUI.Primitives.R3Bridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.R3Bridge.Generator.dll"
-          Pack="true"
-          PackagePath="analyzers/dotnet/cs"
-          Visible="false" />
-    <None Include="..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.SystemReactiveBridge.Generator.dll"
-          Pack="true"
-          PackagePath="analyzers/dotnet/cs"
-          Visible="false" />
+    <None Include="..\..\Skills.md" Pack="true" PackagePath="Skills.md" Visible="false" />
+    <None Include="..\ReactiveUI.Primitives.R3Bridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.R3Bridge.Generator.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.SystemReactiveBridge.Generator.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
   </ItemGroup>
 
 </Project>
diff --git a/src/ReactiveUI.Primitives/SignalOperatorParityMixins.Helpers.cs b/src/ReactiveUI.Primitives/SignalOperatorParityMixins.Helpers.cs
index 41abf54..d6f7a1a 100644
--- a/src/ReactiveUI.Primitives/SignalOperatorParityMixins.Helpers.cs
+++ b/src/ReactiveUI.Primitives/SignalOperatorParityMixins.Helpers.cs
@@ -522,7 +522,7 @@ public IDisposable Subscribe(IObserver<T> observer)
             return _sequencer.Schedule(
                 (Observer: observer, Range: _range),
                 _dueTime,
-                static (_, state) => EmitShiftedRange<T>(state.Observer, state.Range));
+                static (_, state) => EmitShiftedRange(state.Observer, state.Range));
         }
 
         /// <inheritdoc/>
@@ -541,7 +541,7 @@ public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action
             return _sequencer.Schedule(
                 (OnNext: onNext, OnCompleted: onCompleted, Range: _range),
                 _dueTime,
-                static (_, state) => EmitShiftedRange<T>(state.OnNext, state.OnCompleted, state.Range));
+                static (_, state) => EmitShiftedRange(state.OnNext, state.OnCompleted, state.Range));
         }
     }
 
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.cs
new file mode 100644
index 0000000..e99ea5c
--- /dev/null
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveExtensionsComparisonBenchmarks.cs
@@ -0,0 +1,243 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using BenchmarkDotNet.Attributes;
+using ReactiveUI.Primitives.Signals;
+using PackageExtensions = ReactiveUI.Extensions.ReactiveExtensions;
+using PrimitivesExtensions = ReactiveUI.Primitives.Extensions.ReactiveExtensions;
+using RxObservable = System.Reactive.Linq.Observable;
+
+namespace ReactiveUI.Primitives.Benchmarks;
+
+/// <summary>
+/// Benchmarks the synchronous extension-operator package against ReactiveUI.Extensions 4.0.0.
+/// </summary>
+[MemoryDiagnoser]
+public class ReactiveExtensionsComparisonBenchmarks
+{
+    /// <summary>
+    /// The number of values produced by range-based benchmarks.
+    /// </summary>
+    private const int Count = 32;
+
+    /// <summary>
+    /// Source array used by FromArray/FastForEach style benchmarks.
+    /// </summary>
+    private static readonly int[] Values = CreateValues();
+
+    /// <summary>
+    /// Source characters used by delimiter-buffer benchmarks.
+    /// </summary>
+    private static readonly char[] BufferCharacters = "xx[abc]yy[de]".ToCharArray();
+
+    /// <summary>
+    /// Source booleans used by boolean extension benchmarks.
+    /// </summary>
+    private static readonly bool[] BooleanValues = [true, false, false, true, false, true, false, false];
+
+    /// <summary>
+    /// Compares the fused filter/projection operator over a finite range.
+    /// </summary>
+    /// <returns>The observed value total.</returns>
+    [Benchmark(Baseline = true)]
+    public int PrimitivesWhereSelectRange()
+    {
+        var observer = new IntSignalObserver();
+        using var subscription = PrimitivesExtensions.WhereSelect(
+                Signal.Sequence(0, Count),
+                static value => (value & 1) == 0,
+                static value => value * 3)
+            .Subscribe(observer);
+        return observer.Total;
+    }
+
+    /// <summary>
+    /// Compares the ReactiveUI.Extensions 4.0.0 fused filter/projection operator over a finite range.
+    /// </summary>
+    /// <returns>The observed value total.</returns>
+    [Benchmark]
+    public int PackageWhereSelectRange()
+    {
+        var observer = new IntSignalObserver();
+        using var subscription = PackageExtensions.WhereSelect(
+                RxObservable.Range(0, Count),
+                static value => (value & 1) == 0,
+                static value => value * 3)
+            .Subscribe(observer);
+        return observer.Total;
+    }
+
+    /// <summary>
+    /// Compares the array-to-observable helper over an integer array.
+    /// </summary>
+    /// <returns>The observed value total.</returns>
+    [Benchmark]
+    public int PrimitivesFromArraySubscribe()
+    {
+        var observer = new IntSignalObserver();
+        using var subscription = PrimitivesExtensions.FromArray(Values).Subscribe(observer);
+        return observer.Total;
+    }
+
+    /// <summary>
+    /// Compares the ReactiveUI.Extensions 4.0.0 array-to-observable helper.
+    /// </summary>
+    /// <returns>The observed value total.</returns>
+    [Benchmark]
+    public int PackageFromArraySubscribe()
+    {
+        var observer = new IntSignalObserver();
+        using var subscription = PackageExtensions.FromArray(Values).Subscribe(observer);
+        return observer.Total;
+    }
+
+    /// <summary>
+    /// Compares the pairwise operator over a finite range.
+    /// </summary>
+    /// <returns>The aggregate of observed pair values.</returns>
+    [Benchmark]
+    public int PrimitivesPairwiseRange()
+    {
+        var observer = new PairObserver();
+        using var subscription = PrimitivesExtensions.Pairwise(Signal.Sequence(0, Count)).Subscribe(observer);
+        return observer.Total;
+    }
+
+    /// <summary>
+    /// Compares the ReactiveUI.Extensions 4.0.0 pairwise operator over a finite range.
+    /// </summary>
+    /// <returns>The aggregate of observed pair values.</returns>
+    [Benchmark]
+    public int PackagePairwiseRange()
+    {
+        var observer = new PairObserver();
+        using var subscription = PackageExtensions.Pairwise(RxObservable.Range(0, Count)).Subscribe(observer);
+        return observer.Total;
+    }
+
+    /// <summary>
+    /// Compares the delimiter-buffer operator over a finite character stream.
+    /// </summary>
+    /// <returns>The total length of emitted buffers.</returns>
+    [Benchmark]
+    public int PrimitivesBufferUntil()
+    {
+        var observer = new StringLengthObserver();
+        using var subscription = PrimitivesExtensions.BufferUntil(
+                PrimitivesExtensions.FromArray(BufferCharacters),
+                '[',
+                ']')
+            .Subscribe(observer);
+        return observer.TotalLength;
+    }
+
+    /// <summary>
+    /// Compares the ReactiveUI.Extensions 4.0.0 delimiter-buffer operator.
+    /// </summary>
+    /// <returns>The total length of emitted buffers.</returns>
+    [Benchmark]
+    public int PackageBufferUntil()
+    {
+        var observer = new StringLengthObserver();
+        using var subscription = PackageExtensions.BufferUntil(
+                PackageExtensions.FromArray(BufferCharacters),
+                '[',
+                ']')
+            .Subscribe(observer);
+        return observer.TotalLength;
+    }
+
+    /// <summary>
+    /// Compares the boolean negation operator over a finite stream.
+    /// </summary>
+    /// <returns>The number of true values emitted after negation.</returns>
+    [Benchmark]
+    public int PrimitivesNotWhereTrue()
+    {
+        var observer = new BoolSignalObserver();
+        using var subscription = PrimitivesExtensions.WhereTrue(
+                PrimitivesExtensions.Not(
+                    PrimitivesExtensions.FromArray(BooleanValues)))
+            .Subscribe(observer);
+        return observer.Total;
+    }
+
+    /// <summary>
+    /// Compares the ReactiveUI.Extensions 4.0.0 boolean negation and true-filter operators.
+    /// </summary>
+    /// <returns>The number of true values emitted after negation.</returns>
+    [Benchmark]
+    public int PackageNotWhereTrue()
+    {
+        var observer = new BoolSignalObserver();
+        using var subscription = PackageExtensions.WhereTrue(
+                PackageExtensions.Not(
+                    PackageExtensions.FromArray(BooleanValues)))
+            .Subscribe(observer);
+        return observer.Total;
+    }
+
+    /// <summary>
+    /// Creates the shared source array.
+    /// </summary>
+    /// <returns>An array containing values 0..31.</returns>
+    private static int[] CreateValues()
+    {
+        var values = new int[Count];
+        for (var i = 0; i < values.Length; i++)
+        {
+            values[i] = i;
+        }
+
+        return values;
+    }
+
+    /// <summary>
+    /// Observer that aggregates pairwise tuple values.
+    /// </summary>
+    private sealed class PairObserver : IObserver<(int Previous, int Current)>
+    {
+        /// <summary>
+        /// Gets the aggregate total.
+        /// </summary>
+        public int Total { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext((int Previous, int Current) value) => Total += value.Previous + value.Current;
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+        }
+    }
+
+    /// <summary>
+    /// Observer that aggregates emitted string lengths.
+    /// </summary>
+    private sealed class StringLengthObserver : IObserver<string>
+    {
+        /// <summary>
+        /// Gets the combined string length.
+        /// </summary>
+        public int TotalLength { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(string value) => TotalLength += value.Length;
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+        }
+    }
+}
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveUI.Primitives.Benchmarks.csproj b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveUI.Primitives.Benchmarks.csproj
index 3c6ac81..863a884 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveUI.Primitives.Benchmarks.csproj
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/ReactiveUI.Primitives.Benchmarks.csproj
@@ -20,6 +20,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\ReactiveUI.Primitives\ReactiveUI.Primitives.csproj" />
     <ProjectReference Include="..\..\ReactiveUI.Primitives.Async\ReactiveUI.Primitives.Async.csproj" />
+    <ProjectReference Include="..\..\ReactiveUI.Primitives.Extensions\ReactiveUI.Primitives.Extensions.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
index 1ea3742..5f787c9 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombineLatestOperatorTests.EnumerableRest.cs
@@ -323,7 +323,7 @@ public async Task WhenCombineLatestEnumerableDisposedDuringSubscribeLoop_ThenRet
         // First source triggers disposal when subscribed
         var disposeTrigger =
             new TaskCompletionSource<IAsyncDisposable>(TaskCreationOptions.RunContinuationsAsynchronously);
-        var slowSource = SignalAsync.Create<int>(async (_, ct) =>
+        var slowSource = AsyncObs.Create<int>(async (_, ct) =>
         {
             var disp = await disposeTrigger.Task.WaitAsync(ct);
             await disp.DisposeAsync();
@@ -365,7 +365,7 @@ public async Task WhenCombineLatestEnumerableFirstSourceCompletesImmediately_The
         var secondSourceSubscribed = false;
 
         // Second source records whether it was ever subscribed.
-        var trackingSource = SignalAsync.Create<int>((_, _) =>
+        var trackingSource = AsyncObs.Create<int>((_, _) =>
         {
             secondSourceSubscribed = true;
             return new(DisposableAsync.Empty);
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Concat.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Concat.cs
index cf9d774..7ed779c 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Concat.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Concat.cs
@@ -789,7 +789,7 @@ public async Task WhenConcatObservablesHandleAlreadyDisposedWithoutFailure_ThenN
     public async Task WhenConcatObservablesInnerFails_ThenErrorPropagated()
     {
         var error = new InvalidOperationException("obs-concat-fail");
-        var outer = SignalAsync.Return<IObservableAsync<int>>(SignalAsync.Throw<int>(error));
+        var outer = SignalAsync.Return(SignalAsync.Throw<int>(error));
 
         await Assert.ThrowsAsync<InvalidOperationException>(async () =>
             await outer.Concat().FirstAsync());
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Switch.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Switch.cs
index 853b793..d797aaa 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Switch.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/CombiningOperatorTests.Switch.cs
@@ -496,7 +496,7 @@ public async Task WhenSwitchInnerSubscriptionThrows_ThenCompletesWithFailure()
     [Test]
     public async Task WhenSwitchNewInnerArrives_ThenEmitsFromLatest()
     {
-        var result = await SignalAsync.Return<IObservableAsync<int>>(SignalAsync.Return(42))
+        var result = await SignalAsync.Return(SignalAsync.Return(42))
             .Switch()
             .FirstAsync();
 
@@ -525,7 +525,7 @@ public async Task WhenSwitchSubscribedWithAlreadyCancelledToken_ThenSubscription
         using var cts = new CancellationTokenSource();
         await cts.CancelAsync();
 
-        await using var sub = await SignalAsync.Return<IObservableAsync<int>>(SignalAsync.Return(1))
+        await using var sub = await SignalAsync.Return(SignalAsync.Return(1))
             .Switch()
             .SubscribeAsync(static (_, _) => default, cts.Token);
 
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
index a7157fa..7b69a90 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ErrorHandlingOperatorTests.cs
@@ -342,7 +342,7 @@ public async Task WhenCatchHandlerThrows_ThenCompletesWithHandlerException()
         var source = SignalAsync.Throw<int>(new InvalidOperationException("source error"));
 
         await using var sub = await source
-            .Catch<int>(_ => throw new ArithmeticException("handler error"))
+            .Catch(_ => throw new ArithmeticException("handler error"))
             .SubscribeAsync(
                 (_, _) => default,
                 null,
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj b/src/tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj
index a642e8b..3898734 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/ReactiveUI.Primitives.Async.Tests.csproj
@@ -15,6 +15,7 @@
 
   <ItemGroup>
     <Compile Include="..\Shared\ApiApprovalExtensions.cs" Link="ApiApprovalExtensions.cs" />
+    <Compile Include="..\Shared\AsyncTestHelpers.cs" Link="AsyncTestHelpers.cs" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.MappedAndConcurrent.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.MappedAndConcurrent.cs
index 02c762c..f4f38ef 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.MappedAndConcurrent.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/SignalTests.MappedAndConcurrent.cs
@@ -557,7 +557,7 @@ public async Task WhenForwardOnCompletedConcurrentlyWithEmptyObservers_ThenCompl
     {
         var emptyObservers = ImmutableArray<IObserverAsync<int>>.Empty;
 
-        var task = Concurrent.ForwardOnCompletedConcurrently<int>(emptyObservers, Result.Success);
+        var task = Concurrent.ForwardOnCompletedConcurrently(emptyObservers, Result.Success);
 
         await Assert.That(task.IsCompletedSuccessfully).IsTrue();
     }
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
index 29aa1f3..eda3dbd 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs
@@ -977,7 +977,7 @@ public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSp
 
         /// <summary>
         /// A timer that performs no operations. Used as the return value from
-        /// <see cref="ImmediateFireTimeProvider.CreateTimer"/>.
+        /// <see cref="CreateTimer"/>.
         /// </summary>
         private sealed class NoOpTimer : ITimer
         {
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionTestExecutor.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionTestExecutor.cs
index d270d8a..024a48b 100644
--- a/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionTestExecutor.cs
+++ b/src/tests/ReactiveUI.Primitives.Async.Tests/UnhandledExceptionTestExecutor.cs
@@ -2,8 +2,8 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-[assembly: TestExecutorAttribute<ReactiveUI.Primitives.Async.Tests.UnhandledExceptionTestExecutor>]
-[assembly: NotInParallelAttribute]
+[assembly: TestExecutor<ReactiveUI.Primitives.Async.Tests.UnhandledExceptionTestExecutor>]
+[assembly: NotInParallel]
 
 namespace ReactiveUI.Primitives.Async.Tests;
 
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/AotSafeAssertionExtensions.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/AotSafeAssertionExtensions.cs
new file mode 100644
index 0000000..d86da73
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/AotSafeAssertionExtensions.cs
@@ -0,0 +1,32 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using TUnit.Assertions.Conditions;
+using TUnit.Assertions.Core;
+using TUnit.Assertions.Enums;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>
+/// AOT-safe collection-equality helpers.
+/// </summary>
+internal static class AotSafeAssertionExtensions
+{
+    /// <summary>
+    /// Asserts the collection is equivalent to <paramref name="expected"/>
+    /// using the element type's default <see cref="EqualityComparer{T}"/>
+    /// (order-insensitive, mirroring <c>IsEquivalentTo</c>'s default
+    /// <see cref="CollectionOrdering.Any"/>).
+    /// </summary>
+    /// <typeparam name="TCollection">The collection type being asserted.</typeparam>
+    /// <typeparam name="TItem">The element type.</typeparam>
+    /// <param name="source">The assertion source.</param>
+    /// <param name="expected">The expected element sequence.</param>
+    /// <returns>The chained collection-equivalency assertion.</returns>
+    public static IsEquivalentToAssertion<TCollection, TItem> IsCollectionEqualTo<TCollection, TItem>(
+        this IAssertionSource<TCollection> source,
+        IEnumerable<TItem> expected)
+        where TCollection : IEnumerable<TItem>
+        => source.IsEquivalentTo(expected, EqualityComparer<TItem>.Default);
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet10_0.verified.txt b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet10_0.verified.txt
new file mode 100644
index 0000000..73d4ad7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet10_0.verified.txt
@@ -0,0 +1,229 @@
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Extensions.Tests")]
+namespace ReactiveUI.Primitives.Extensions
+{
+    public class Continuation : System.IDisposable
+    {
+        public Continuation() { }
+        public long CompletedPhases { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool disposing) { }
+        public System.Threading.Tasks.Task Lock<T>(T item, [System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "value",
+                "Sync"})] System.IObserver<System.ValueTuple<T, System.IDisposable>>? observer) { }
+        public System.Threading.Tasks.ValueTask LockValueTask<T>(T item, [System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "value",
+                "Sync"})] System.IObserver<System.ValueTuple<T, System.IDisposable>>? observer) { }
+    }
+    public readonly struct Heartbeat<T> : ReactiveUI.Primitives.Extensions.IHeartbeat<T>, System.IEquatable<ReactiveUI.Primitives.Extensions.Heartbeat<T>>
+    {
+        public Heartbeat() { }
+        public Heartbeat(T? update) { }
+        public bool IsHeartbeat { get; }
+        public T Update { get; }
+    }
+    public interface IHeartbeat<out T>
+    {
+        bool IsHeartbeat { get; }
+        T Update { get; }
+    }
+    public interface IStale<out T>
+    {
+        bool IsStale { get; }
+        T Update { get; }
+    }
+    public static class ObservableSubscriptionExtensions
+    {
+        public static void SubscribeAndComplete(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.Exception? SubscribeGetError(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.Exception? SubscribeGetError<T>(this System.IObservable<T> source) { }
+        public static T? SubscribeGetValue<T>(this System.IObservable<T> source) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, System.TimeSpan timeout) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, System.TimeSpan timeout) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, System.TimeSpan timeout) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+    }
+    public static class Observables
+    {
+        public static System.IObservable<T> Return<T>(T value) { }
+    }
+    public static class ObserverExtensions
+    {
+        public static void FastForEach<T>(this System.IObserver<T> observer, System.Collections.Generic.IEnumerable<T> source) { }
+    }
+    public static class ReactiveExtensions
+    {
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> AsSignal<T>(this System.IObservable<T> observable) { }
+        public static System.IObservable<string> BufferUntil(this System.IObservable<char> @this, char startsWith, char endsWith) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilIdle<T>(this System.IObservable<T> source, System.TimeSpan idleTime) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilIdle<T>(this System.IObservable<T> source, System.TimeSpan idleTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilInactive<T>(this System.IObservable<T> source, System.TimeSpan inactivityPeriod) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilInactive<T>(this System.IObservable<T> source, System.TimeSpan inactivityPeriod, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> CatchAndReturn<T>(this System.IObservable<T> source, T fallback) { }
+        public static System.IObservable<T> CatchAndReturn<T, TException>(this System.IObservable<T> source, System.Func<TException, T> fallbackFactory)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource?> CatchIgnore<TSource>(this System.IObservable<TSource?> source) { }
+        public static System.IObservable<TSource> CatchIgnore<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> errorAction)
+            where TException : System.Exception { }
+        public static System.IObservable<T> CatchReturn<T>(this System.IObservable<T> source, T fallback) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> CatchReturnUnit(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.IObservable<bool> CombineLatestValuesAreAllFalse(this System.Collections.Generic.IEnumerable<System.IObservable<bool>> sources) { }
+        public static System.IObservable<bool> CombineLatestValuesAreAllTrue(this System.Collections.Generic.IEnumerable<System.IObservable<bool>> sources) { }
+        public static System.IObservable<T> Conflate<T>(this System.IObservable<T> source, System.TimeSpan minimumUpdatePeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> DebounceImmediate<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
+        public static System.IObservable<T> DebounceImmediate<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> DebounceUntil<T>(this System.IObservable<T> source, System.TimeSpan debounce, System.Func<T, bool> condition) { }
+        public static System.IObservable<T> DebounceUntil<T>(this System.IObservable<T> source, System.TimeSpan debounce, System.Func<T, bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<ReactiveUI.Primitives.Extensions.Stale<T>> DetectStale<T>(this System.IObservable<T> source, System.TimeSpan stalenessPeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> DoOnDispose<T>(this System.IObservable<T> source, System.Action disposeAction) { }
+        public static System.IObservable<T> DoOnSubscribe<T>(this System.IObservable<T> source, System.Action action) { }
+        public static System.IObservable<T> DropIfBusy<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> asyncAction) { }
+        public static System.IObservable<string> Filter(this System.IObservable<string> source, System.Text.RegularExpressions.Regex regex) { }
+        public static System.IObservable<string> Filter(this System.IObservable<string> source, string regexPattern) { }
+        public static System.IObservable<TResult> FirstMatchFromCandidates<TKey, TRaw, TResult>(this System.Collections.Generic.IReadOnlyList<TKey> candidates, System.Func<TKey, System.IObservable<TRaw>> project, System.Func<TRaw, TResult> transform, System.Func<TResult, bool> predicate, TResult fallback) { }
+        public static System.IObservable<T> ForEach<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source) { }
+        public static System.IObservable<T> ForEach<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> FromArray<T>(this System.Collections.Generic.IEnumerable<T> source) { }
+        public static System.IObservable<T> FromArray<T>(this System.Collections.Generic.IEnumerable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> GetMax<T>(this System.IObservable<T> @this, params System.IObservable<T>[] sources)
+            where T :  struct, System.IComparable<T> { }
+        public static System.IObservable<T> GetMin<T>(this System.IObservable<T> @this, params System.IObservable<T>[] sources)
+            where T :  struct, System.IComparable<T> { }
+        public static System.IObservable<ReactiveUI.Primitives.Extensions.Heartbeat<T>> Heartbeat<T>(this System.IObservable<T> source, System.TimeSpan heartbeatPeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> LatestOrDefault<T>(this System.IObservable<T> source, T defaultValue) { }
+        public static System.IObservable<T> LogErrors<T>(this System.IObservable<T> source, System.Action<System.Exception> logger) { }
+        public static System.IObservable<bool> Not(this System.IObservable<bool> source) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, System.IObservable<bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, bool condition, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, System.IObservable<bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer trueScheduler, ReactiveUI.Primitives.Concurrency.ISequencer falseScheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, bool condition, ReactiveUI.Primitives.Concurrency.ISequencer trueScheduler, ReactiveUI.Primitives.Concurrency.ISequencer falseScheduler) { }
+        public static System.IObservable<TSource> ObserveOnSafe<TSource>(this System.IObservable<TSource> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource>(this System.IObservable<TSource> source) { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, System.TimeSpan delay)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount, System.TimeSpan delay)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount, System.TimeSpan delay, ReactiveUI.Primitives.Concurrency.ISequencer delayScheduler)
+            where TException : System.Exception { }
+        public static void OnNext<T>(this System.IObserver<T> observer, params T[] events) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Previous",
+                "Current"})]
+        public static System.IObservable<System.ValueTuple<T, T>> Pairwise<T>(this System.IObservable<T> source) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "True",
+                "False"})]
+        public static System.ValueTuple<System.IObservable<T>, System.IObservable<T>> Partition<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
+        public static System.IObservable<T> ReplayLastOnSubscribe<T>(this System.IObservable<T> source, T initialValue) { }
+        public static System.IObservable<T> RetryForeverWithDelay<T>(this System.IObservable<T> source, System.TimeSpan delay) { }
+        public static System.IObservable<T> RetryWithBackoff<T>(this System.IObservable<T> source, int maxRetries, System.TimeSpan initialDelay) { }
+        public static System.IObservable<T> RetryWithBackoff<T>(this System.IObservable<T> source, int maxRetries, System.TimeSpan initialDelay, double backoffFactor, System.TimeSpan? maxDelay, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> RetryWithDelay<T>(this System.IObservable<T> source, int retryCount, System.Func<int, System.TimeSpan> delaySelector) { }
+        public static System.IObservable<T> RetryWithFixedDelay<T>(this System.IObservable<T> source, int retryCount, System.TimeSpan delay) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> RunAll(this System.Collections.Generic.IReadOnlyList<System.IObservable<ReactiveUI.Primitives.RxVoid>> sources) { }
+        public static System.IObservable<T> SampleLatest<T>(this System.IObservable<T> source, System.IObservable<object> trigger) { }
+        public static System.IObservable<TAccumulate> ScanWithInitial<TSource, TAccumulate>(this System.IObservable<TSource> source, TAccumulate initial, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this T value, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IDisposable ScheduleSafe(this ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Action action) { }
+        public static System.IDisposable ScheduleSafe(this ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.TimeSpan dueTime, System.Action action) { }
+        public static System.IObservable<TResult> SelectAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> asyncSelector) { }
+        public static System.IObservable<TResult> SelectAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> asyncSelector) { }
+        public static System.IObservable<TResult> SelectAsyncConcurrent<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector, int maxConcurrency) { }
+        public static System.IObservable<TResult> SelectAsyncSequential<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector) { }
+        public static System.IObservable<TResult> SelectConstant<TSource, TResult>(this System.IObservable<TSource> source, TResult constant) { }
+        public static System.IObservable<TResult> SelectLatestAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector) { }
+        public static System.IObservable<TResult> SelectManyThen<TSource, TMid, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.IObservable<TMid>> first, System.Func<TMid, System.IObservable<TResult>> second) { }
+        public static System.IObservable<T[]> Shuffle<T>(this System.IObservable<T[]> source) { }
+        public static System.IObservable<T> SkipWhileNull<T>(this System.IObservable<T> source)
+            where T :  class { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Start(System.Action action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<TResult> Start<TResult>(System.Func<TResult> function, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
+        public static System.IObservable<T> SwitchIfEmpty<T>(this System.IObservable<T> source, System.IObservable<T> fallback) { }
+        public static System.IObservable<System.DateTime> SyncTimer(System.TimeSpan timeSpan) { }
+        public static System.IObservable<System.DateTime> SyncTimer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Value",
+                "Sync"})]
+        public static System.IObservable<System.ValueTuple<T, System.IDisposable>> SynchronizeAsync<T>(this System.IObservable<T> source) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Value",
+                "Sync"})]
+        public static System.IObservable<System.ValueTuple<T, System.IDisposable>> SynchronizeSynchronous<T>(this System.IObservable<T> source) { }
+        public static System.IObservable<TSource> TakeUntil<TSource>(this System.IObservable<TSource> source, System.Func<TSource, bool> predicate) { }
+        public static System.IObservable<T> ThrottleDistinct<T>(this System.IObservable<T> source, System.TimeSpan throttle) { }
+        public static System.IObservable<T> ThrottleDistinct<T>(this System.IObservable<T> source, System.TimeSpan throttle, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ThrottleFirst<T>(this System.IObservable<T> source, System.TimeSpan window) { }
+        public static System.IObservable<T> ThrottleFirst<T>(this System.IObservable<T> source, System.TimeSpan window, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> ThrottleOnScheduler<T>(this System.IObservable<T> source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ThrottleUntilTrue<T>(this System.IObservable<T> source, System.TimeSpan throttle, System.Func<T, bool> predicate) { }
+        public static System.Threading.Tasks.Task<T> ToHotTask<T>(this System.IObservable<T> source) { }
+        public static System.Threading.Tasks.ValueTask<T> ToHotValueTask<T>(this System.IObservable<T> source) { }
+        public static System.IObservable<TProperty> ToPropertyObservable<T, TProperty>(this T source, System.Linq.Expressions.Expression<System.Func<T, TProperty>> propertyExpression)
+            where T : System.ComponentModel.INotifyPropertyChanged { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Observable",
+                "Observer"})]
+        public static System.ValueTuple<System.IObservable<T>, System.IObserver<T>> ToReadOnlyBehavior<T>(T initialValue) { }
+        public static System.IObservable<TOut> TrySelect<TIn, TOut>(this System.IObservable<TIn> source, System.Func<TIn, TOut?> selector) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Using<T>(this T obj, System.Action<T>? action)
+            where T : System.IDisposable { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Using<T>(this T obj, System.Action<T>? action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler)
+            where T : System.IDisposable { }
+        public static System.IObservable<TResult> Using<T, TResult>(this T obj, System.Func<T, TResult> function)
+            where T : System.IDisposable { }
+        public static System.IObservable<TResult> Using<T, TResult>(this T obj, System.Func<T, TResult> function, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler)
+            where T : System.IDisposable { }
+        public static System.IObservable<T> WaitUntil<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
+        public static System.IObservable<bool> WhereFalse(this System.IObservable<bool> source) { }
+        public static System.IObservable<T> WhereIsNotNull<T>(this System.IObservable<T> observable) { }
+        public static System.IObservable<TOut> WhereSelect<TIn, TOut>(this System.IObservable<TIn> source, System.Func<TIn, bool> predicate, System.Func<TIn, TOut> selector) { }
+        public static System.IObservable<bool> WhereTrue(this System.IObservable<bool> source) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> While(System.Func<bool> condition, System.Action action) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> While(System.Func<bool> condition, System.Action action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> WithLimitedConcurrency<T>(this System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task<T>> taskFunctions, int maxConcurrency) { }
+    }
+    public readonly struct Stale<T> : ReactiveUI.Primitives.Extensions.IStale<T>, System.IEquatable<ReactiveUI.Primitives.Extensions.Stale<T>>
+    {
+        public Stale() { }
+        public Stale(T? update) { }
+        public bool IsStale { get; }
+        public T Update { get; }
+    }
+}
+namespace ReactiveUI.Primitives.Extensions.Operators
+{
+    public static class CachedObservables
+    {
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> UnitDefault { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet8_0.verified.txt b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet8_0.verified.txt
new file mode 100644
index 0000000..73d4ad7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet8_0.verified.txt
@@ -0,0 +1,229 @@
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Extensions.Tests")]
+namespace ReactiveUI.Primitives.Extensions
+{
+    public class Continuation : System.IDisposable
+    {
+        public Continuation() { }
+        public long CompletedPhases { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool disposing) { }
+        public System.Threading.Tasks.Task Lock<T>(T item, [System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "value",
+                "Sync"})] System.IObserver<System.ValueTuple<T, System.IDisposable>>? observer) { }
+        public System.Threading.Tasks.ValueTask LockValueTask<T>(T item, [System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "value",
+                "Sync"})] System.IObserver<System.ValueTuple<T, System.IDisposable>>? observer) { }
+    }
+    public readonly struct Heartbeat<T> : ReactiveUI.Primitives.Extensions.IHeartbeat<T>, System.IEquatable<ReactiveUI.Primitives.Extensions.Heartbeat<T>>
+    {
+        public Heartbeat() { }
+        public Heartbeat(T? update) { }
+        public bool IsHeartbeat { get; }
+        public T Update { get; }
+    }
+    public interface IHeartbeat<out T>
+    {
+        bool IsHeartbeat { get; }
+        T Update { get; }
+    }
+    public interface IStale<out T>
+    {
+        bool IsStale { get; }
+        T Update { get; }
+    }
+    public static class ObservableSubscriptionExtensions
+    {
+        public static void SubscribeAndComplete(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.Exception? SubscribeGetError(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.Exception? SubscribeGetError<T>(this System.IObservable<T> source) { }
+        public static T? SubscribeGetValue<T>(this System.IObservable<T> source) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, System.TimeSpan timeout) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, System.TimeSpan timeout) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, System.TimeSpan timeout) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+    }
+    public static class Observables
+    {
+        public static System.IObservable<T> Return<T>(T value) { }
+    }
+    public static class ObserverExtensions
+    {
+        public static void FastForEach<T>(this System.IObserver<T> observer, System.Collections.Generic.IEnumerable<T> source) { }
+    }
+    public static class ReactiveExtensions
+    {
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> AsSignal<T>(this System.IObservable<T> observable) { }
+        public static System.IObservable<string> BufferUntil(this System.IObservable<char> @this, char startsWith, char endsWith) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilIdle<T>(this System.IObservable<T> source, System.TimeSpan idleTime) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilIdle<T>(this System.IObservable<T> source, System.TimeSpan idleTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilInactive<T>(this System.IObservable<T> source, System.TimeSpan inactivityPeriod) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilInactive<T>(this System.IObservable<T> source, System.TimeSpan inactivityPeriod, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> CatchAndReturn<T>(this System.IObservable<T> source, T fallback) { }
+        public static System.IObservable<T> CatchAndReturn<T, TException>(this System.IObservable<T> source, System.Func<TException, T> fallbackFactory)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource?> CatchIgnore<TSource>(this System.IObservable<TSource?> source) { }
+        public static System.IObservable<TSource> CatchIgnore<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> errorAction)
+            where TException : System.Exception { }
+        public static System.IObservable<T> CatchReturn<T>(this System.IObservable<T> source, T fallback) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> CatchReturnUnit(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.IObservable<bool> CombineLatestValuesAreAllFalse(this System.Collections.Generic.IEnumerable<System.IObservable<bool>> sources) { }
+        public static System.IObservable<bool> CombineLatestValuesAreAllTrue(this System.Collections.Generic.IEnumerable<System.IObservable<bool>> sources) { }
+        public static System.IObservable<T> Conflate<T>(this System.IObservable<T> source, System.TimeSpan minimumUpdatePeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> DebounceImmediate<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
+        public static System.IObservable<T> DebounceImmediate<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> DebounceUntil<T>(this System.IObservable<T> source, System.TimeSpan debounce, System.Func<T, bool> condition) { }
+        public static System.IObservable<T> DebounceUntil<T>(this System.IObservable<T> source, System.TimeSpan debounce, System.Func<T, bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<ReactiveUI.Primitives.Extensions.Stale<T>> DetectStale<T>(this System.IObservable<T> source, System.TimeSpan stalenessPeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> DoOnDispose<T>(this System.IObservable<T> source, System.Action disposeAction) { }
+        public static System.IObservable<T> DoOnSubscribe<T>(this System.IObservable<T> source, System.Action action) { }
+        public static System.IObservable<T> DropIfBusy<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> asyncAction) { }
+        public static System.IObservable<string> Filter(this System.IObservable<string> source, System.Text.RegularExpressions.Regex regex) { }
+        public static System.IObservable<string> Filter(this System.IObservable<string> source, string regexPattern) { }
+        public static System.IObservable<TResult> FirstMatchFromCandidates<TKey, TRaw, TResult>(this System.Collections.Generic.IReadOnlyList<TKey> candidates, System.Func<TKey, System.IObservable<TRaw>> project, System.Func<TRaw, TResult> transform, System.Func<TResult, bool> predicate, TResult fallback) { }
+        public static System.IObservable<T> ForEach<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source) { }
+        public static System.IObservable<T> ForEach<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> FromArray<T>(this System.Collections.Generic.IEnumerable<T> source) { }
+        public static System.IObservable<T> FromArray<T>(this System.Collections.Generic.IEnumerable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> GetMax<T>(this System.IObservable<T> @this, params System.IObservable<T>[] sources)
+            where T :  struct, System.IComparable<T> { }
+        public static System.IObservable<T> GetMin<T>(this System.IObservable<T> @this, params System.IObservable<T>[] sources)
+            where T :  struct, System.IComparable<T> { }
+        public static System.IObservable<ReactiveUI.Primitives.Extensions.Heartbeat<T>> Heartbeat<T>(this System.IObservable<T> source, System.TimeSpan heartbeatPeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> LatestOrDefault<T>(this System.IObservable<T> source, T defaultValue) { }
+        public static System.IObservable<T> LogErrors<T>(this System.IObservable<T> source, System.Action<System.Exception> logger) { }
+        public static System.IObservable<bool> Not(this System.IObservable<bool> source) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, System.IObservable<bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, bool condition, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, System.IObservable<bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer trueScheduler, ReactiveUI.Primitives.Concurrency.ISequencer falseScheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, bool condition, ReactiveUI.Primitives.Concurrency.ISequencer trueScheduler, ReactiveUI.Primitives.Concurrency.ISequencer falseScheduler) { }
+        public static System.IObservable<TSource> ObserveOnSafe<TSource>(this System.IObservable<TSource> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource>(this System.IObservable<TSource> source) { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, System.TimeSpan delay)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount, System.TimeSpan delay)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount, System.TimeSpan delay, ReactiveUI.Primitives.Concurrency.ISequencer delayScheduler)
+            where TException : System.Exception { }
+        public static void OnNext<T>(this System.IObserver<T> observer, params T[] events) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Previous",
+                "Current"})]
+        public static System.IObservable<System.ValueTuple<T, T>> Pairwise<T>(this System.IObservable<T> source) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "True",
+                "False"})]
+        public static System.ValueTuple<System.IObservable<T>, System.IObservable<T>> Partition<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
+        public static System.IObservable<T> ReplayLastOnSubscribe<T>(this System.IObservable<T> source, T initialValue) { }
+        public static System.IObservable<T> RetryForeverWithDelay<T>(this System.IObservable<T> source, System.TimeSpan delay) { }
+        public static System.IObservable<T> RetryWithBackoff<T>(this System.IObservable<T> source, int maxRetries, System.TimeSpan initialDelay) { }
+        public static System.IObservable<T> RetryWithBackoff<T>(this System.IObservable<T> source, int maxRetries, System.TimeSpan initialDelay, double backoffFactor, System.TimeSpan? maxDelay, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> RetryWithDelay<T>(this System.IObservable<T> source, int retryCount, System.Func<int, System.TimeSpan> delaySelector) { }
+        public static System.IObservable<T> RetryWithFixedDelay<T>(this System.IObservable<T> source, int retryCount, System.TimeSpan delay) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> RunAll(this System.Collections.Generic.IReadOnlyList<System.IObservable<ReactiveUI.Primitives.RxVoid>> sources) { }
+        public static System.IObservable<T> SampleLatest<T>(this System.IObservable<T> source, System.IObservable<object> trigger) { }
+        public static System.IObservable<TAccumulate> ScanWithInitial<TSource, TAccumulate>(this System.IObservable<TSource> source, TAccumulate initial, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this T value, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IDisposable ScheduleSafe(this ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Action action) { }
+        public static System.IDisposable ScheduleSafe(this ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.TimeSpan dueTime, System.Action action) { }
+        public static System.IObservable<TResult> SelectAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> asyncSelector) { }
+        public static System.IObservable<TResult> SelectAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> asyncSelector) { }
+        public static System.IObservable<TResult> SelectAsyncConcurrent<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector, int maxConcurrency) { }
+        public static System.IObservable<TResult> SelectAsyncSequential<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector) { }
+        public static System.IObservable<TResult> SelectConstant<TSource, TResult>(this System.IObservable<TSource> source, TResult constant) { }
+        public static System.IObservable<TResult> SelectLatestAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector) { }
+        public static System.IObservable<TResult> SelectManyThen<TSource, TMid, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.IObservable<TMid>> first, System.Func<TMid, System.IObservable<TResult>> second) { }
+        public static System.IObservable<T[]> Shuffle<T>(this System.IObservable<T[]> source) { }
+        public static System.IObservable<T> SkipWhileNull<T>(this System.IObservable<T> source)
+            where T :  class { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Start(System.Action action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<TResult> Start<TResult>(System.Func<TResult> function, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
+        public static System.IObservable<T> SwitchIfEmpty<T>(this System.IObservable<T> source, System.IObservable<T> fallback) { }
+        public static System.IObservable<System.DateTime> SyncTimer(System.TimeSpan timeSpan) { }
+        public static System.IObservable<System.DateTime> SyncTimer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Value",
+                "Sync"})]
+        public static System.IObservable<System.ValueTuple<T, System.IDisposable>> SynchronizeAsync<T>(this System.IObservable<T> source) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Value",
+                "Sync"})]
+        public static System.IObservable<System.ValueTuple<T, System.IDisposable>> SynchronizeSynchronous<T>(this System.IObservable<T> source) { }
+        public static System.IObservable<TSource> TakeUntil<TSource>(this System.IObservable<TSource> source, System.Func<TSource, bool> predicate) { }
+        public static System.IObservable<T> ThrottleDistinct<T>(this System.IObservable<T> source, System.TimeSpan throttle) { }
+        public static System.IObservable<T> ThrottleDistinct<T>(this System.IObservable<T> source, System.TimeSpan throttle, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ThrottleFirst<T>(this System.IObservable<T> source, System.TimeSpan window) { }
+        public static System.IObservable<T> ThrottleFirst<T>(this System.IObservable<T> source, System.TimeSpan window, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> ThrottleOnScheduler<T>(this System.IObservable<T> source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ThrottleUntilTrue<T>(this System.IObservable<T> source, System.TimeSpan throttle, System.Func<T, bool> predicate) { }
+        public static System.Threading.Tasks.Task<T> ToHotTask<T>(this System.IObservable<T> source) { }
+        public static System.Threading.Tasks.ValueTask<T> ToHotValueTask<T>(this System.IObservable<T> source) { }
+        public static System.IObservable<TProperty> ToPropertyObservable<T, TProperty>(this T source, System.Linq.Expressions.Expression<System.Func<T, TProperty>> propertyExpression)
+            where T : System.ComponentModel.INotifyPropertyChanged { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Observable",
+                "Observer"})]
+        public static System.ValueTuple<System.IObservable<T>, System.IObserver<T>> ToReadOnlyBehavior<T>(T initialValue) { }
+        public static System.IObservable<TOut> TrySelect<TIn, TOut>(this System.IObservable<TIn> source, System.Func<TIn, TOut?> selector) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Using<T>(this T obj, System.Action<T>? action)
+            where T : System.IDisposable { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Using<T>(this T obj, System.Action<T>? action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler)
+            where T : System.IDisposable { }
+        public static System.IObservable<TResult> Using<T, TResult>(this T obj, System.Func<T, TResult> function)
+            where T : System.IDisposable { }
+        public static System.IObservable<TResult> Using<T, TResult>(this T obj, System.Func<T, TResult> function, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler)
+            where T : System.IDisposable { }
+        public static System.IObservable<T> WaitUntil<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
+        public static System.IObservable<bool> WhereFalse(this System.IObservable<bool> source) { }
+        public static System.IObservable<T> WhereIsNotNull<T>(this System.IObservable<T> observable) { }
+        public static System.IObservable<TOut> WhereSelect<TIn, TOut>(this System.IObservable<TIn> source, System.Func<TIn, bool> predicate, System.Func<TIn, TOut> selector) { }
+        public static System.IObservable<bool> WhereTrue(this System.IObservable<bool> source) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> While(System.Func<bool> condition, System.Action action) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> While(System.Func<bool> condition, System.Action action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> WithLimitedConcurrency<T>(this System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task<T>> taskFunctions, int maxConcurrency) { }
+    }
+    public readonly struct Stale<T> : ReactiveUI.Primitives.Extensions.IStale<T>, System.IEquatable<ReactiveUI.Primitives.Extensions.Stale<T>>
+    {
+        public Stale() { }
+        public Stale(T? update) { }
+        public bool IsStale { get; }
+        public T Update { get; }
+    }
+}
+namespace ReactiveUI.Primitives.Extensions.Operators
+{
+    public static class CachedObservables
+    {
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> UnitDefault { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet9_0.verified.txt b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet9_0.verified.txt
new file mode 100644
index 0000000..73d4ad7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.Extensions.DotNet9_0.verified.txt
@@ -0,0 +1,229 @@
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Extensions.Tests")]
+namespace ReactiveUI.Primitives.Extensions
+{
+    public class Continuation : System.IDisposable
+    {
+        public Continuation() { }
+        public long CompletedPhases { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool disposing) { }
+        public System.Threading.Tasks.Task Lock<T>(T item, [System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "value",
+                "Sync"})] System.IObserver<System.ValueTuple<T, System.IDisposable>>? observer) { }
+        public System.Threading.Tasks.ValueTask LockValueTask<T>(T item, [System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "value",
+                "Sync"})] System.IObserver<System.ValueTuple<T, System.IDisposable>>? observer) { }
+    }
+    public readonly struct Heartbeat<T> : ReactiveUI.Primitives.Extensions.IHeartbeat<T>, System.IEquatable<ReactiveUI.Primitives.Extensions.Heartbeat<T>>
+    {
+        public Heartbeat() { }
+        public Heartbeat(T? update) { }
+        public bool IsHeartbeat { get; }
+        public T Update { get; }
+    }
+    public interface IHeartbeat<out T>
+    {
+        bool IsHeartbeat { get; }
+        T Update { get; }
+    }
+    public interface IStale<out T>
+    {
+        bool IsStale { get; }
+        T Update { get; }
+    }
+    public static class ObservableSubscriptionExtensions
+    {
+        public static void SubscribeAndComplete(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.Exception? SubscribeGetError(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.Exception? SubscribeGetError<T>(this System.IObservable<T> source) { }
+        public static T? SubscribeGetValue<T>(this System.IObservable<T> source) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, System.TimeSpan timeout) { }
+        public static void WaitForCompletion(this System.IObservable<ReactiveUI.Primitives.RxVoid> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, System.TimeSpan timeout) { }
+        public static System.Exception? WaitForError<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, System.TimeSpan timeout) { }
+        public static T? WaitForValue<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.TimeSpan timeout) { }
+    }
+    public static class Observables
+    {
+        public static System.IObservable<T> Return<T>(T value) { }
+    }
+    public static class ObserverExtensions
+    {
+        public static void FastForEach<T>(this System.IObserver<T> observer, System.Collections.Generic.IEnumerable<T> source) { }
+    }
+    public static class ReactiveExtensions
+    {
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> AsSignal<T>(this System.IObservable<T> observable) { }
+        public static System.IObservable<string> BufferUntil(this System.IObservable<char> @this, char startsWith, char endsWith) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilIdle<T>(this System.IObservable<T> source, System.TimeSpan idleTime) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilIdle<T>(this System.IObservable<T> source, System.TimeSpan idleTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilInactive<T>(this System.IObservable<T> source, System.TimeSpan inactivityPeriod) { }
+        public static System.IObservable<System.Collections.Generic.IList<T>> BufferUntilInactive<T>(this System.IObservable<T> source, System.TimeSpan inactivityPeriod, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> CatchAndReturn<T>(this System.IObservable<T> source, T fallback) { }
+        public static System.IObservable<T> CatchAndReturn<T, TException>(this System.IObservable<T> source, System.Func<TException, T> fallbackFactory)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource?> CatchIgnore<TSource>(this System.IObservable<TSource?> source) { }
+        public static System.IObservable<TSource> CatchIgnore<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> errorAction)
+            where TException : System.Exception { }
+        public static System.IObservable<T> CatchReturn<T>(this System.IObservable<T> source, T fallback) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> CatchReturnUnit(this System.IObservable<ReactiveUI.Primitives.RxVoid> source) { }
+        public static System.IObservable<bool> CombineLatestValuesAreAllFalse(this System.Collections.Generic.IEnumerable<System.IObservable<bool>> sources) { }
+        public static System.IObservable<bool> CombineLatestValuesAreAllTrue(this System.Collections.Generic.IEnumerable<System.IObservable<bool>> sources) { }
+        public static System.IObservable<T> Conflate<T>(this System.IObservable<T> source, System.TimeSpan minimumUpdatePeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> DebounceImmediate<T>(this System.IObservable<T> source, System.TimeSpan dueTime) { }
+        public static System.IObservable<T> DebounceImmediate<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> DebounceUntil<T>(this System.IObservable<T> source, System.TimeSpan debounce, System.Func<T, bool> condition) { }
+        public static System.IObservable<T> DebounceUntil<T>(this System.IObservable<T> source, System.TimeSpan debounce, System.Func<T, bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<ReactiveUI.Primitives.Extensions.Stale<T>> DetectStale<T>(this System.IObservable<T> source, System.TimeSpan stalenessPeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> DoOnDispose<T>(this System.IObservable<T> source, System.Action disposeAction) { }
+        public static System.IObservable<T> DoOnSubscribe<T>(this System.IObservable<T> source, System.Action action) { }
+        public static System.IObservable<T> DropIfBusy<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> asyncAction) { }
+        public static System.IObservable<string> Filter(this System.IObservable<string> source, System.Text.RegularExpressions.Regex regex) { }
+        public static System.IObservable<string> Filter(this System.IObservable<string> source, string regexPattern) { }
+        public static System.IObservable<TResult> FirstMatchFromCandidates<TKey, TRaw, TResult>(this System.Collections.Generic.IReadOnlyList<TKey> candidates, System.Func<TKey, System.IObservable<TRaw>> project, System.Func<TRaw, TResult> transform, System.Func<TResult, bool> predicate, TResult fallback) { }
+        public static System.IObservable<T> ForEach<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source) { }
+        public static System.IObservable<T> ForEach<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> FromArray<T>(this System.Collections.Generic.IEnumerable<T> source) { }
+        public static System.IObservable<T> FromArray<T>(this System.Collections.Generic.IEnumerable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> GetMax<T>(this System.IObservable<T> @this, params System.IObservable<T>[] sources)
+            where T :  struct, System.IComparable<T> { }
+        public static System.IObservable<T> GetMin<T>(this System.IObservable<T> @this, params System.IObservable<T>[] sources)
+            where T :  struct, System.IComparable<T> { }
+        public static System.IObservable<ReactiveUI.Primitives.Extensions.Heartbeat<T>> Heartbeat<T>(this System.IObservable<T> source, System.TimeSpan heartbeatPeriod, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> LatestOrDefault<T>(this System.IObservable<T> source, T defaultValue) { }
+        public static System.IObservable<T> LogErrors<T>(this System.IObservable<T> source, System.Action<System.Exception> logger) { }
+        public static System.IObservable<bool> Not(this System.IObservable<bool> source) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, System.IObservable<bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, bool condition, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, System.IObservable<bool> condition, ReactiveUI.Primitives.Concurrency.ISequencer trueScheduler, ReactiveUI.Primitives.Concurrency.ISequencer falseScheduler) { }
+        public static System.IObservable<T> ObserveOnIf<T>(this System.IObservable<T> source, bool condition, ReactiveUI.Primitives.Concurrency.ISequencer trueScheduler, ReactiveUI.Primitives.Concurrency.ISequencer falseScheduler) { }
+        public static System.IObservable<TSource> ObserveOnSafe<TSource>(this System.IObservable<TSource> source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource>(this System.IObservable<TSource> source) { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, System.TimeSpan delay)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount, System.TimeSpan delay)
+            where TException : System.Exception { }
+        public static System.IObservable<TSource> OnErrorRetry<TSource, TException>(this System.IObservable<TSource> source, System.Action<TException> onError, int retryCount, System.TimeSpan delay, ReactiveUI.Primitives.Concurrency.ISequencer delayScheduler)
+            where TException : System.Exception { }
+        public static void OnNext<T>(this System.IObserver<T> observer, params T[] events) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Previous",
+                "Current"})]
+        public static System.IObservable<System.ValueTuple<T, T>> Pairwise<T>(this System.IObservable<T> source) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "True",
+                "False"})]
+        public static System.ValueTuple<System.IObservable<T>, System.IObservable<T>> Partition<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
+        public static System.IObservable<T> ReplayLastOnSubscribe<T>(this System.IObservable<T> source, T initialValue) { }
+        public static System.IObservable<T> RetryForeverWithDelay<T>(this System.IObservable<T> source, System.TimeSpan delay) { }
+        public static System.IObservable<T> RetryWithBackoff<T>(this System.IObservable<T> source, int maxRetries, System.TimeSpan initialDelay) { }
+        public static System.IObservable<T> RetryWithBackoff<T>(this System.IObservable<T> source, int maxRetries, System.TimeSpan initialDelay, double backoffFactor, System.TimeSpan? maxDelay, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> RetryWithDelay<T>(this System.IObservable<T> source, int retryCount, System.Func<int, System.TimeSpan> delaySelector) { }
+        public static System.IObservable<T> RetryWithFixedDelay<T>(this System.IObservable<T> source, int retryCount, System.TimeSpan delay) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> RunAll(this System.Collections.Generic.IReadOnlyList<System.IObservable<ReactiveUI.Primitives.RxVoid>> sources) { }
+        public static System.IObservable<T> SampleLatest<T>(this System.IObservable<T> source, System.IObservable<object> trigger) { }
+        public static System.IObservable<TAccumulate> ScanWithInitial<TSource, TAccumulate>(this System.IObservable<TSource> source, TAccumulate initial, System.Func<TAccumulate, TSource, TAccumulate> accumulator) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this T value, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this System.IObservable<T> source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Action<T> action) { }
+        public static System.IObservable<T> Schedule<T>(this T value, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer scheduler, System.Func<T, T> function) { }
+        public static System.IDisposable ScheduleSafe(this ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Action action) { }
+        public static System.IDisposable ScheduleSafe(this ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.TimeSpan dueTime, System.Action action) { }
+        public static System.IObservable<TResult> SelectAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> asyncSelector) { }
+        public static System.IObservable<TResult> SelectAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> asyncSelector) { }
+        public static System.IObservable<TResult> SelectAsyncConcurrent<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector, int maxConcurrency) { }
+        public static System.IObservable<TResult> SelectAsyncSequential<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector) { }
+        public static System.IObservable<TResult> SelectConstant<TSource, TResult>(this System.IObservable<TSource> source, TResult constant) { }
+        public static System.IObservable<TResult> SelectLatestAsync<TSource, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.Threading.Tasks.Task<TResult>> selector) { }
+        public static System.IObservable<TResult> SelectManyThen<TSource, TMid, TResult>(this System.IObservable<TSource> source, System.Func<TSource, System.IObservable<TMid>> first, System.Func<TMid, System.IObservable<TResult>> second) { }
+        public static System.IObservable<T[]> Shuffle<T>(this System.IObservable<T[]> source) { }
+        public static System.IObservable<T> SkipWhileNull<T>(this System.IObservable<T> source)
+            where T :  class { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Start(System.Action action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<TResult> Start<TResult>(System.Func<TResult> function, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError) { }
+        public static System.IDisposable SubscribeAsync<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action onCompleted) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError) { }
+        public static System.IDisposable SubscribeSynchronous<T>(this System.IObservable<T> source, System.Func<T, System.Threading.Tasks.ValueTask> onNext, System.Action<System.Exception> onError, System.Action onCompleted) { }
+        public static System.IObservable<T> SwitchIfEmpty<T>(this System.IObservable<T> source, System.IObservable<T> fallback) { }
+        public static System.IObservable<System.DateTime> SyncTimer(System.TimeSpan timeSpan) { }
+        public static System.IObservable<System.DateTime> SyncTimer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Value",
+                "Sync"})]
+        public static System.IObservable<System.ValueTuple<T, System.IDisposable>> SynchronizeAsync<T>(this System.IObservable<T> source) { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Value",
+                "Sync"})]
+        public static System.IObservable<System.ValueTuple<T, System.IDisposable>> SynchronizeSynchronous<T>(this System.IObservable<T> source) { }
+        public static System.IObservable<TSource> TakeUntil<TSource>(this System.IObservable<TSource> source, System.Func<TSource, bool> predicate) { }
+        public static System.IObservable<T> ThrottleDistinct<T>(this System.IObservable<T> source, System.TimeSpan throttle) { }
+        public static System.IObservable<T> ThrottleDistinct<T>(this System.IObservable<T> source, System.TimeSpan throttle, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ThrottleFirst<T>(this System.IObservable<T> source, System.TimeSpan window) { }
+        public static System.IObservable<T> ThrottleFirst<T>(this System.IObservable<T> source, System.TimeSpan window, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> ThrottleOnScheduler<T>(this System.IObservable<T> source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        public static System.IObservable<T> ThrottleUntilTrue<T>(this System.IObservable<T> source, System.TimeSpan throttle, System.Func<T, bool> predicate) { }
+        public static System.Threading.Tasks.Task<T> ToHotTask<T>(this System.IObservable<T> source) { }
+        public static System.Threading.Tasks.ValueTask<T> ToHotValueTask<T>(this System.IObservable<T> source) { }
+        public static System.IObservable<TProperty> ToPropertyObservable<T, TProperty>(this T source, System.Linq.Expressions.Expression<System.Func<T, TProperty>> propertyExpression)
+            where T : System.ComponentModel.INotifyPropertyChanged { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "Observable",
+                "Observer"})]
+        public static System.ValueTuple<System.IObservable<T>, System.IObserver<T>> ToReadOnlyBehavior<T>(T initialValue) { }
+        public static System.IObservable<TOut> TrySelect<TIn, TOut>(this System.IObservable<TIn> source, System.Func<TIn, TOut?> selector) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Using<T>(this T obj, System.Action<T>? action)
+            where T : System.IDisposable { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> Using<T>(this T obj, System.Action<T>? action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler)
+            where T : System.IDisposable { }
+        public static System.IObservable<TResult> Using<T, TResult>(this T obj, System.Func<T, TResult> function)
+            where T : System.IDisposable { }
+        public static System.IObservable<TResult> Using<T, TResult>(this T obj, System.Func<T, TResult> function, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler)
+            where T : System.IDisposable { }
+        public static System.IObservable<T> WaitUntil<T>(this System.IObservable<T> source, System.Func<T, bool> predicate) { }
+        public static System.IObservable<bool> WhereFalse(this System.IObservable<bool> source) { }
+        public static System.IObservable<T> WhereIsNotNull<T>(this System.IObservable<T> observable) { }
+        public static System.IObservable<TOut> WhereSelect<TIn, TOut>(this System.IObservable<TIn> source, System.Func<TIn, bool> predicate, System.Func<TIn, TOut> selector) { }
+        public static System.IObservable<bool> WhereTrue(this System.IObservable<bool> source) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> While(System.Func<bool> condition, System.Action action) { }
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> While(System.Func<bool> condition, System.Action action, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) { }
+        public static System.IObservable<T> WithLimitedConcurrency<T>(this System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task<T>> taskFunctions, int maxConcurrency) { }
+    }
+    public readonly struct Stale<T> : ReactiveUI.Primitives.Extensions.IStale<T>, System.IEquatable<ReactiveUI.Primitives.Extensions.Stale<T>>
+    {
+        public Stale() { }
+        public Stale(T? update) { }
+        public bool IsStale { get; }
+        public T Update { get; }
+    }
+}
+namespace ReactiveUI.Primitives.Extensions.Operators
+{
+    public static class CachedObservables
+    {
+        public static System.IObservable<ReactiveUI.Primitives.RxVoid> UnitDefault { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.cs
new file mode 100644
index 0000000..ea89a56
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ApiApprovalTests.cs
@@ -0,0 +1,23 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.ApiApproval;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>
+/// Checks that the public API of ReactiveUI.Primitives.Extensions is consistent with previous releases,
+/// highlighting any new or changed API.
+/// </summary>
+[ExcludeFromCodeCoverage]
+public class ApiApprovalTests
+{
+    /// <summary>
+    /// Generates the public API for the ReactiveUI.Primitives.Extensions assembly.
+    /// </summary>
+    /// <returns>A task to monitor the process.</returns>
+    [Test]
+    public Task Extensions() =>
+        typeof(ReactiveExtensions).Assembly.CheckApproval();
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
new file mode 100644
index 0000000..0aaeddb
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ContinuationTests.cs
@@ -0,0 +1,134 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for <see cref="Continuation"/> — the phase-barrier lock used to serialise emissions,
+/// covering both the <see cref="Continuation.Lock{T}"/> (Task) and <see cref="Continuation.LockValueTask{T}"/>
+/// (ValueTask) entry points plus the already-locked short-circuit.</summary>
+public class ContinuationTests
+{
+    /// <summary>Guard timeout to keep barrier rendezvous from hanging the test run.</summary>
+    private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(5);
+
+    /// <summary>Verifies <see cref="Continuation.LockValueTask{T}"/> pushes the item downstream, locks,
+    /// and completes once the phase is signalled by an unlock.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLockValueTaskNotLocked_ThenEmitsAndCompletesOnUnlock()
+    {
+        using var continuation = new Continuation();
+        var values = new List<int>();
+        var observer = Observer.Create<(int Value, IDisposable Sync)>(v => values.Add(v.Value));
+
+        var lockTask = continuation.LockValueTask(1, observer);
+        var unlockTask = continuation.UnLock();
+
+        await lockTask.AsTask().WaitAsync(Timeout);
+        await unlockTask.WaitAsync(Timeout);
+
+        await Assert.That(values.Count).IsEqualTo(1);
+        await Assert.That(values[0]).IsEqualTo(1);
+        await Assert.That(continuation.CompletedPhases).IsGreaterThanOrEqualTo(1);
+    }
+
+    /// <summary>Verifies a second <see cref="Continuation.LockValueTask{T}"/> while already locked returns a
+    /// completed default value task and does not push the item downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLockValueTaskAlreadyLocked_ThenReturnsDefaultAndDropsItem()
+    {
+        using var continuation = new Continuation();
+        var values = new List<int>();
+        var observer = Observer.Create<(int Value, IDisposable Sync)>(v => values.Add(v.Value));
+
+        var first = continuation.LockValueTask(1, observer);
+        var second = continuation.LockValueTask(2, observer);
+
+        await Assert.That(second.IsCompleted).IsTrue();
+        await second;
+
+        var unlockTask = continuation.UnLock();
+        await first.AsTask().WaitAsync(Timeout);
+        await unlockTask.WaitAsync(Timeout);
+
+        await Assert.That(values.Count).IsEqualTo(1);
+        await Assert.That(values[0]).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <see cref="Continuation.Lock{T}"/> (the Task overload) emits and completes on unlock.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLockNotLocked_ThenEmitsAndCompletesOnUnlock()
+    {
+        using var continuation = new Continuation();
+        var values = new List<int>();
+        var observer = Observer.Create<(int Value, IDisposable Sync)>(v => values.Add(v.Value));
+
+        var lockTask = continuation.Lock(1, observer);
+        var unlockTask = continuation.UnLock();
+
+        await lockTask.WaitAsync(Timeout);
+        await unlockTask.WaitAsync(Timeout);
+
+        await Assert.That(values.Count).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies a second <see cref="Continuation.Lock{T}"/> while already locked returns a completed
+    /// task and drops the item.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLockAlreadyLocked_ThenReturnsCompletedAndDropsItem()
+    {
+        using var continuation = new Continuation();
+        var values = new List<int>();
+        var observer = Observer.Create<(int Value, IDisposable Sync)>(v => values.Add(v.Value));
+
+        var first = continuation.Lock(1, observer);
+        var second = continuation.Lock(2, observer);
+
+        await Assert.That(second.IsCompleted).IsTrue();
+
+        var unlockTask = continuation.UnLock();
+        await first.WaitAsync(Timeout);
+        await unlockTask.WaitAsync(Timeout);
+
+        await Assert.That(values.Count).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that unlocking a continuation that was never locked completes immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUnlockNotLocked_ThenCompletesImmediately()
+    {
+        using var continuation = new Continuation();
+
+        await continuation.UnLock().WaitAsync(Timeout);
+
+        await Assert.That(continuation.CompletedPhases).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies disposing twice is an idempotent no-op on the second call.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposeTwice_ThenSecondDisposeIsNoOp()
+    {
+        var continuation = new Continuation();
+        Exception? caught = null;
+
+        try
+        {
+            continuation.Dispose();
+            continuation.Dispose();
+        }
+        catch (Exception ex)
+        {
+            caught = ex;
+        }
+
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs
new file mode 100644
index 0000000..2b2f935
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.MultiObserver.cs
@@ -0,0 +1,285 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Multi-observer and post-terminal coverage for <see cref="CurrentValueSubject{T}"/>
+/// — copy-on-write growth, mid-array unsubscribe, collapse back to single-observer, late
+/// subscribers after error or completion, and dispose with active observers.</summary>
+public partial class CurrentValueSubjectTests
+{
+    /// <summary>Initial value for multi-observer tests.</summary>
+    private const int MultiInitialValue = 1;
+
+    /// <summary>Verifies that three concurrent observers all receive the latest value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThreeObserversAndOnNext_ThenAllReceiveValue()
+    {
+        const int Update = 2;
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var a = new List<int>();
+        var b = new List<int>();
+        var c = new List<int>();
+
+        using var subA = subject.Subscribe(a.Add);
+        using var subB = subject.Subscribe(b.Add);
+        using var subC = subject.Subscribe(c.Add);
+
+        subject.OnNext(Update);
+
+        await Assert.That(a).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(b).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(c).IsCollectionEqualTo([MultiInitialValue, Update]);
+    }
+
+    /// <summary>Verifies that disposing the middle observer of a 3-observer subject does not
+    /// affect the other observers' delivery.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMiddleObserverDisposed_ThenOthersStillReceive()
+    {
+        const int Update = 2;
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var a = new List<int>();
+        var b = new List<int>();
+        var c = new List<int>();
+
+        using var subA = subject.Subscribe(a.Add);
+        var subB = subject.Subscribe(b.Add);
+        using var subC = subject.Subscribe(c.Add);
+
+        subB.Dispose();
+        subject.OnNext(Update);
+
+        await Assert.That(a).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(b).IsCollectionEqualTo([MultiInitialValue]);
+        await Assert.That(c).IsCollectionEqualTo([MultiInitialValue, Update]);
+    }
+
+    /// <summary>Verifies that going from two observers back to one collapses to the
+    /// single-observer fast path while still broadcasting correctly.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSecondObserverDisposedFromPair_ThenSingleObserverStillReceives()
+    {
+        const int Update = 2;
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var a = new List<int>();
+        var b = new List<int>();
+
+        using var subA = subject.Subscribe(a.Add);
+        var subB = subject.Subscribe(b.Add);
+        subB.Dispose();
+
+        subject.OnNext(Update);
+
+        await Assert.That(a).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(b).IsCollectionEqualTo([MultiInitialValue]);
+    }
+
+    /// <summary>Disposing the first observer of a 2-observer subject exercises Unsubscribe's
+    /// <c>index == 0 ? existing[1] : existing[0]</c> ternary on the true branch — the surviving
+    /// observer collapses back to the single-observer fast path.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstObserverOfPairDisposed_ThenSingleSurvivorReceives()
+    {
+        const int Update = 2;
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var a = new List<int>();
+        var b = new List<int>();
+
+        var subA = subject.Subscribe(a.Add);
+        using var subB = subject.Subscribe(b.Add);
+
+        // Dispose subA from the two-observer array; Unsubscribe's `index == 0 ? existing[1] : existing[0]`
+        // ternary picks the true branch, collapsing _observer to subB.
+        subA.Dispose();
+        subject.OnNext(Update);
+
+        await Assert.That(a).IsCollectionEqualTo([MultiInitialValue]);
+        await Assert.That(b).IsCollectionEqualTo([MultiInitialValue, Update]);
+    }
+
+    /// <summary>Verifies that disposing the first observer of a 3-observer subject works
+    /// (collapse exercises the index==0 branch of the shrink path).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstObserverDisposed_ThenOthersStillReceive()
+    {
+        const int Update = 2;
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var a = new List<int>();
+        var b = new List<int>();
+        var c = new List<int>();
+
+        var subA = subject.Subscribe(a.Add);
+        using var subB = subject.Subscribe(b.Add);
+        using var subC = subject.Subscribe(c.Add);
+
+        subA.Dispose();
+        subject.OnNext(Update);
+
+        await Assert.That(a).IsCollectionEqualTo([MultiInitialValue]);
+        await Assert.That(b).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(c).IsCollectionEqualTo([MultiInitialValue, Update]);
+    }
+
+    /// <summary>Verifies that disposing the last observer of a 3-observer subject works
+    /// (collapse exercises the tail-only branch of the shrink path).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLastObserverDisposed_ThenOthersStillReceive()
+    {
+        const int Update = 2;
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var a = new List<int>();
+        var b = new List<int>();
+        var c = new List<int>();
+
+        using var subA = subject.Subscribe(a.Add);
+        using var subB = subject.Subscribe(b.Add);
+        var subC = subject.Subscribe(c.Add);
+
+        subC.Dispose();
+        subject.OnNext(Update);
+
+        await Assert.That(a).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(b).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(c).IsCollectionEqualTo([MultiInitialValue]);
+    }
+
+    /// <summary>Verifies that subscribing after the subject has errored immediately delivers the error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAfterError_ThenErrorDeliveredImmediately()
+    {
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var expected = new InvalidOperationException("late-error");
+        subject.OnError(expected);
+
+        Exception? caught = null;
+        using var sub = subject.Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that subscribing after the subject has completed delivers the cached
+    /// value and an immediate completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAfterCompleted_ThenReplayThenCompletes()
+    {
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        subject.OnCompleted();
+
+        var values = new List<int>();
+        var completed = false;
+        using var sub = subject.Subscribe(values.Add, () => completed = true);
+
+        await Assert.That(values).IsCollectionEqualTo([MultiInitialValue]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>OnError</c> broadcasts to multiple observers and is idempotent.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMultipleObserversAndOnError_ThenAllReceiveError()
+    {
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        Exception? errA = null;
+        Exception? errB = null;
+        Exception? errC = null;
+        var expected = new InvalidOperationException("multi-error");
+
+        using var subA = subject.Subscribe(static _ => { }, ex => errA = ex);
+        using var subB = subject.Subscribe(static _ => { }, ex => errB = ex);
+        using var subC = subject.Subscribe(static _ => { }, ex => errC = ex);
+
+        subject.OnError(expected);
+
+        // Second OnError is a no-op.
+        subject.OnError(new InvalidOperationException("ignored"));
+
+        await Assert.That(errA).IsSameReferenceAs(expected);
+        await Assert.That(errB).IsSameReferenceAs(expected);
+        await Assert.That(errC).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>OnCompleted</c> broadcasts to multiple observers and a
+    /// subsequent <c>OnCompleted</c> is a no-op.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMultipleObserversAndOnCompleted_ThenAllReceiveCompletionAndSecondIsNoOp()
+    {
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var completedA = 0;
+        var completedB = 0;
+        var completedC = 0;
+
+        using var subA = subject.Subscribe(static _ => { }, () => completedA++);
+        using var subB = subject.Subscribe(static _ => { }, () => completedB++);
+        using var subC = subject.Subscribe(static _ => { }, () => completedC++);
+
+        subject.OnCompleted();
+        subject.OnCompleted();
+
+        await Assert.That(completedA).IsEqualTo(1);
+        await Assert.That(completedB).IsEqualTo(1);
+        await Assert.That(completedC).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that disposing the same subscription twice is idempotent.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscriptionDisposedTwice_ThenIdempotent()
+    {
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var values = new List<int>();
+
+        var sub = subject.Subscribe(values.Add);
+        sub.Dispose();
+        sub.Dispose();
+
+        subject.OnNext(MultiInitialValue + 1);
+
+        await Assert.That(values).IsCollectionEqualTo([MultiInitialValue]);
+    }
+
+    /// <summary>Verifies the multi-observer Unsubscribe path tolerates a stale dispose —
+    /// after a middle observer is detached from a 4-observer array, disposing its returned
+    /// subscription a second time hits the <c>Array.IndexOf</c> not-found early-return.
+    /// The 4-observer setup keeps <c>_observers</c> non-null after the first dispose (the
+    /// 2-observer setup collapses back to the single-observer fast path, which hits a
+    /// different short-circuit instead of the IndexOf path).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMultiObserverDisposedTwice_ThenSecondDisposeIsNoOp()
+    {
+        const int Update = 2;
+        using var subject = new CurrentValueSubject<int>(MultiInitialValue);
+        var a = new List<int>();
+        var b = new List<int>();
+        var c = new List<int>();
+        var d = new List<int>();
+
+        using var subA = subject.Subscribe(a.Add);
+        var subB = subject.Subscribe(b.Add);
+        using var subC = subject.Subscribe(c.Add);
+        using var subD = subject.Subscribe(d.Add);
+
+        subB.Dispose();
+        subB.Dispose();
+
+        subject.OnNext(Update);
+
+        await Assert.That(a).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(b).IsCollectionEqualTo([MultiInitialValue]);
+        await Assert.That(c).IsCollectionEqualTo([MultiInitialValue, Update]);
+        await Assert.That(d).IsCollectionEqualTo([MultiInitialValue, Update]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.cs
new file mode 100644
index 0000000..6b043c0
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/CurrentValueSubjectTests.cs
@@ -0,0 +1,220 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+using ReactiveUI.Primitives.Extensions.Operators;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for <see cref="CurrentValueSubject{T}"/>, <see cref="SingleValueObservable{T}"/>,
+/// and the <see cref="CachedObservables"/> singletons.</summary>
+public partial class CurrentValueSubjectTests
+{
+    /// <summary>Initial value used by subject tests so the replay value is unambiguous.</summary>
+    private const int InitialValue = 42;
+
+    /// <summary>Second value that overwrites the initial value via <c>OnNext</c>.</summary>
+    private const int SecondValue = 7;
+
+    /// <summary>Third value used to assert later observers see only the most recent emission.</summary>
+    private const int ThirdValue = 99;
+
+    /// <summary>Verifies the subject replays its initial value to a new subscriber.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenNewSubscriber_ThenReceivesInitialValueImmediately()
+    {
+        using var subject = new CurrentValueSubject<int>(InitialValue);
+        var results = new List<int>();
+
+        using var sub = subject.Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue]);
+        await Assert.That(subject.Value).IsEqualTo(InitialValue);
+    }
+
+    /// <summary>Verifies that OnNext updates the cached value and broadcasts to a single observer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextSingleObserver_ThenValueAndBroadcastUpdate()
+    {
+        using var subject = new CurrentValueSubject<int>(InitialValue);
+        var results = new List<int>();
+
+        using var sub = subject.Subscribe(results.Add);
+        subject.OnNext(SecondValue);
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue, SecondValue]);
+        await Assert.That(subject.Value).IsEqualTo(SecondValue);
+    }
+
+    /// <summary>Verifies that two observers both receive the initial value and subsequent emissions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTwoObservers_ThenBothReceiveReplayAndOnNext()
+    {
+        using var subject = new CurrentValueSubject<int>(InitialValue);
+        var first = new List<int>();
+        var second = new List<int>();
+
+        using var sub1 = subject.Subscribe(first.Add);
+        using var sub2 = subject.Subscribe(second.Add);
+        subject.OnNext(SecondValue);
+
+        await Assert.That(first).IsCollectionEqualTo([InitialValue, SecondValue]);
+        await Assert.That(second).IsCollectionEqualTo([InitialValue, SecondValue]);
+    }
+
+    /// <summary>Verifies that a late subscriber after multiple OnNext receives only the most recent value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLateSubscriber_ThenReceivesOnlyLatest()
+    {
+        using var subject = new CurrentValueSubject<int>(InitialValue);
+        subject.OnNext(SecondValue);
+        subject.OnNext(ThirdValue);
+
+        var results = new List<int>();
+        using var sub = subject.Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([ThirdValue]);
+    }
+
+    /// <summary>Verifies that disposing the subscription stops future deliveries to the disposed observer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscriptionDisposed_ThenNoFurtherDeliveries()
+    {
+        using var subject = new CurrentValueSubject<int>(InitialValue);
+        var results = new List<int>();
+        var sub = subject.Subscribe(results.Add);
+
+        sub.Dispose();
+        subject.OnNext(SecondValue);
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue]);
+    }
+
+    /// <summary>Verifies that OnCompleted terminates active subscribers and that late subscribers also see completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnCompleted_ThenObserversReceiveCompletion()
+    {
+        using var subject = new CurrentValueSubject<int>(InitialValue);
+        var completedFirst = false;
+        var completedLate = false;
+        var lateValues = new List<int>();
+
+        using var subFirst = subject.Subscribe(static _ => { }, () => completedFirst = true);
+        subject.OnCompleted();
+
+        using var subLate = subject.Subscribe(lateValues.Add, () => completedLate = true);
+
+        await Assert.That(completedFirst).IsTrue();
+        await Assert.That(completedLate).IsTrue();
+
+        // Late subscriber still sees the replayed value before completion.
+        await Assert.That(lateValues).IsCollectionEqualTo([InitialValue]);
+    }
+
+    /// <summary>Verifies that OnError terminates active subscribers and that late subscribers replay the error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnError_ThenObserversReceiveError()
+    {
+        var expected = new InvalidOperationException("boom");
+        using var subject = new CurrentValueSubject<int>(InitialValue);
+        Exception? firstError = null;
+        Exception? lateError = null;
+
+        using var subFirst = subject.Subscribe(static _ => { }, ex => firstError = ex);
+        subject.OnError(expected);
+
+        using var subLate = subject.Subscribe(static _ => { }, ex => lateError = ex);
+
+        await Assert.That(firstError).IsEqualTo(expected);
+        await Assert.That(lateError).IsEqualTo(expected);
+    }
+
+    /// <summary>Verifies that OnNext after disposal is silently ignored.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposedThenOnNext_ThenIgnored()
+    {
+        var subject = new CurrentValueSubject<int>(InitialValue);
+        var results = new List<int>();
+        using var sub = subject.Subscribe(results.Add);
+
+        subject.Dispose();
+        subject.OnNext(SecondValue);
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue]);
+    }
+
+    /// <summary>Verifies that subscribing after disposal immediately errors with <see cref="ObjectDisposedException"/>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAfterDispose_ThenObjectDisposedExceptionDelivered()
+    {
+        var subject = new CurrentValueSubject<int>(InitialValue);
+        subject.Dispose();
+
+        Exception? error = null;
+        using var sub = subject.Subscribe(static _ => { }, ex => error = ex);
+
+        await Assert.That(error).IsTypeOf<ObjectDisposedException>();
+    }
+
+    /// <summary>Verifies that AsObservable returns a hide-the-observer view that still delivers values.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsObservable_ThenDeliversValuesButHidesObserverApi()
+    {
+        using var subject = new CurrentValueSubject<int>(InitialValue);
+        var view = subject.AsObservable();
+        var results = new List<int>();
+
+        using var sub = view.Subscribe(results.Add);
+        subject.OnNext(SecondValue);
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue, SecondValue]);
+        await Assert.That(view).IsNotTypeOf<CurrentValueSubject<int>>();
+    }
+
+    /// <summary>Verifies that <see cref="SingleValueObservable{T}"/> emits exactly one value and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSingleValueObservableSubscribed_ThenEmitsOnceAndCompletes()
+    {
+        var observable = new SingleValueObservable<int>(SecondValue);
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = observable.Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([SecondValue]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <see cref="CachedObservables.UnitDefault"/> emits a single <see cref="RxVoid"/> and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCachedUnitDefaultSubscribed_ThenEmitsUnitAndCompletes()
+    {
+        var count = 0;
+        var completed = false;
+
+        var localCount = 0;
+        using var sub = CachedObservables.UnitDefault.Subscribe(
+            _ => localCount++,
+            () => completed = true);
+        count = localCount;
+
+        await Assert.That(Volatile.Read(ref count)).IsEqualTo(1);
+        await Assert.That(completed).IsTrue();
+
+        // The same singleton instance should service repeated calls without re-allocating.
+        await Assert.That(CachedObservables.UnitDefault).IsSameReferenceAs(CachedObservables.UnitDefault);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/DisposableExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/DisposableExtensionsTests.cs
new file mode 100644
index 0000000..a1a3262
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/DisposableExtensionsTests.cs
@@ -0,0 +1,66 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Disposables;
+using System.Reactive.Disposables.Fluent;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>
+/// Tests disposable extensions.
+/// </summary>
+public class DisposableExtensionsTests
+{
+    /// <summary>
+    /// Tests DisposeWith returns a disposable.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GivenNull_WhenDisposeWith_ThenExceptionThrown()
+    {
+        // Given
+        var sut = Disposable.Create(() => { });
+
+        // When
+        var result = Assert.Throws<ArgumentNullException>(() => sut.DisposeWith((CompositeDisposable)null!));
+
+        // Then
+        await Assert.That(result).IsTypeOf<ArgumentNullException>();
+    }
+
+    /// <summary>
+    /// Tests DisposeWith disposes the underlying disposable.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GivenDisposable_WhenDisposeWith_ThenDisposed()
+    {
+        // Given
+        var sut = new CompositeDisposable();
+        var compositeDisposable = new CompositeDisposable();
+        sut.DisposeWith(compositeDisposable);
+
+        // When
+        compositeDisposable.Dispose();
+
+        // Then
+        await Assert.That(sut.IsDisposed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests DisposeWith returns the original disposable.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GivenDisposable_WhenDisposeWith_ThenReturnsDisposable()
+    {
+        // Given, When
+        var sut = new CompositeDisposable();
+        var compositeDisposable = new CompositeDisposable();
+        var result = sut.DisposeWith(compositeDisposable);
+
+        // Then
+        await Assert.That(result).IsCollectionEqualTo(sut);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/GlobalTestSetup.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/GlobalTestSetup.cs
new file mode 100644
index 0000000..239e7c7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/GlobalTestSetup.cs
@@ -0,0 +1,25 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>
+/// Configures assembly-wide TUnit defaults via a <see cref="TestDiscovery"/> hook so they
+/// are in place before any test executes.
+/// </summary>
+internal static class GlobalTestSetup
+{
+    /// <summary>
+    /// Caps every test at 60 seconds. Without a default cap, a single flaky test that hangs
+    /// stalls the entire assembly (the whole suite is serialised via
+    /// <c>[assembly: NotInParallel(nameof(UnhandledExceptionHandler))]</c>) and we lose the
+    /// per-test failure signal — the CI just reports the workflow-level timeout. 60s is far
+    /// above every legitimate test (slowest non-cancellation test is ~5s) so any future hang
+    /// fails its own test with a clear message instead of killing the whole run.
+    /// </summary>
+    /// <param name="context">The TUnit test-discovery context exposing programmatic settings.</param>
+    [Before(HookType.TestDiscovery)]
+    public static void ConfigureDefaults(BeforeTestDiscoveryContext context) =>
+        context.Settings.Timeouts.DefaultTestTimeout = TimeSpan.FromSeconds(60);
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ActionDisposableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ActionDisposableTests.cs
new file mode 100644
index 0000000..b2e8503
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ActionDisposableTests.cs
@@ -0,0 +1,30 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for <see cref="ActionDisposable"/> — verifies the dispose action runs exactly
+/// once regardless of how many times <c>Dispose</c> is called.</summary>
+public class ActionDisposableTests
+{
+    /// <summary>Verifies the action is invoked exactly once across repeated <c>Dispose</c> calls.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenActionDisposableDisposedTwice_ThenActionInvokedExactlyOnce()
+    {
+        var invocations = 0;
+        var disposable = new ActionDisposable(() => invocations++);
+
+        await Assert.That(disposable.IsDisposed).IsFalse();
+
+        disposable.Dispose();
+        disposable.Dispose();
+        disposable.Dispose();
+
+        await Assert.That(disposable.IsDisposed).IsTrue();
+        await Assert.That(invocations).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ConcurrencyRaceHelpersTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ConcurrencyRaceHelpersTests.cs
new file mode 100644
index 0000000..2fa9cde
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ConcurrencyRaceHelpersTests.cs
@@ -0,0 +1,75 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Direct RxVoid tests for <see cref="ConcurrencyRaceHelpers"/> — both race-claim
+/// primitives are pure functions over their inputs and every branch is exercised here.</summary>
+public class ConcurrencyRaceHelpersTests
+{
+    /// <summary>Sentinel for the "not yet claimed" state in the tests.</summary>
+    private const int Open = 0;
+
+    /// <summary>Sentinel for the "claimed" state in the tests.</summary>
+    private const int Claimed = 1;
+
+    /// <summary>Verifies <see cref="ConcurrencyRaceHelpers.TryClaim"/> succeeds when the state
+    /// is open and transitions it to the claimed sentinel.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTryClaimOpen_ThenReturnsTrueAndTransitions()
+    {
+        var state = Open;
+
+        var claimed = ConcurrencyRaceHelpers.TryClaim(ref state, Open, Claimed);
+
+        await Assert.That(claimed).IsTrue();
+        await Assert.That(state).IsEqualTo(Claimed);
+    }
+
+    /// <summary>Verifies <see cref="ConcurrencyRaceHelpers.TryClaim"/> returns false when the
+    /// state is already claimed and does not mutate it further.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTryClaimAlreadyClaimed_ThenReturnsFalse()
+    {
+        var state = Claimed;
+
+        var claimed = ConcurrencyRaceHelpers.TryClaim(ref state, Open, Claimed);
+
+        await Assert.That(claimed).IsFalse();
+        await Assert.That(state).IsEqualTo(Claimed);
+    }
+
+    /// <summary>Verifies <see cref="ConcurrencyRaceHelpers.TryCancelAsync"/> returns
+    /// <see langword="true"/> when called on an open CTS and the cancellation goes through.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTryCancelOpenCts_ThenReturnsTrueAndTokenCancels()
+    {
+        var cts = new CancellationTokenSource();
+
+        var succeeded = await ConcurrencyRaceHelpers.TryCancelAsync(cts);
+
+        await Assert.That(succeeded).IsTrue();
+        await Assert.That(cts.IsCancellationRequested).IsTrue();
+    }
+
+    /// <summary>Verifies <see cref="ConcurrencyRaceHelpers.TryCancelAsync"/> returns
+    /// <see langword="false"/> when called on a disposed CTS and silently swallows the
+    /// <see cref="ObjectDisposedException"/>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTryCancelDisposedCts_ThenReturnsFalseAndSwallowsObjectDisposed()
+    {
+        var cts = new CancellationTokenSource();
+        cts.Dispose();
+
+        var succeeded = await ConcurrencyRaceHelpers.TryCancelAsync(cts);
+
+        await Assert.That(succeeded).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/DisposableBagTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/DisposableBagTests.cs
new file mode 100644
index 0000000..1a90eb4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/DisposableBagTests.cs
@@ -0,0 +1,121 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Coverage for <see cref="DisposableBag"/> — inline-slot fill, overflow growth,
+/// add-after-dispose immediate disposal, three-arg constructor, and dispose-order guarantees.</summary>
+public class DisposableBagTests
+{
+    /// <summary>Verifies that the parameterless constructor accepts inline slot fills and disposes both.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDefaultBagFilledViaAdd_ThenDisposesBoth()
+    {
+        var bag = new DisposableBag();
+        var d1 = new CountedDisposable();
+        var d2 = new CountedDisposable();
+
+        bag.Add(d1);
+        bag.Add(d2);
+        await Assert.That(bag.IsDisposed).IsFalse();
+
+        bag.Dispose();
+
+        await Assert.That(bag.IsDisposed).IsTrue();
+        await Assert.That(d1.DisposeCount).IsEqualTo(1);
+        await Assert.That(d2.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that adding a null disposable is a no-op.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAddNull_ThenIgnored()
+    {
+        var bag = new DisposableBag();
+        bag.Add(null!);
+        bag.Dispose();
+
+        await Assert.That(bag).IsNotNull();
+    }
+
+    /// <summary>Verifies that overflow growth and disposal works for more than three entries.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOverflowGrowthRequired_ThenAllEntriesDisposed()
+    {
+        const int Count = 8;
+        var bag = new DisposableBag();
+        var entries = new CountedDisposable[Count];
+        for (var i = 0; i < Count; i++)
+        {
+            entries[i] = new CountedDisposable();
+            bag.Add(entries[i]);
+        }
+
+        bag.Dispose();
+
+        for (var i = 0; i < Count; i++)
+        {
+            await Assert.That(entries[i].DisposeCount).IsEqualTo(1);
+        }
+    }
+
+    /// <summary>Verifies that the three-arg constructor populates inline slots plus overflow and disposes all.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThreeArgConstructor_ThenAllThreeDisposed()
+    {
+        var d1 = new CountedDisposable();
+        var d2 = new CountedDisposable();
+        var d3 = new CountedDisposable();
+        var bag = new DisposableBag(d1, d2, d3);
+
+        bag.Dispose();
+
+        await Assert.That(d1.DisposeCount).IsEqualTo(1);
+        await Assert.That(d2.DisposeCount).IsEqualTo(1);
+        await Assert.That(d3.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that double-dispose is idempotent.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposeCalledTwice_ThenIdempotent()
+    {
+        var d1 = new CountedDisposable();
+        var bag = new DisposableBag(d1, new CountedDisposable());
+
+        bag.Dispose();
+        bag.Dispose();
+
+        await Assert.That(d1.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that adding after disposal disposes the supplied entry immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAddAfterDispose_ThenSuppliedDisposableDisposedImmediately()
+    {
+        var bag = new DisposableBag();
+        bag.Dispose();
+
+        var late = new CountedDisposable();
+        bag.Add(late);
+
+        await Assert.That(late.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Tracking disposable used to count dispose invocations.</summary>
+    private sealed class CountedDisposable : IDisposable
+    {
+        /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/DisposableSlotHelperTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/DisposableSlotHelperTests.cs
new file mode 100644
index 0000000..e1e9044
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/DisposableSlotHelperTests.cs
@@ -0,0 +1,119 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Direct RxVoid tests for <see cref="DisposableSlotHelper"/>. Covers every reachable
+/// branch — the already-disposed pre-check, the steady-state assign, the swap-disposes-previous
+/// path, and the idempotent <c>TryDispose</c> latch. The single race-recheck step that fires
+/// only under a real concurrent dispose is isolated in <c>DisposeIfRaced</c> and excluded from
+/// coverage there.</summary>
+public class DisposableSlotHelperTests
+{
+    /// <summary>Verifies that an incoming value is disposed immediately if the slot is already disposed.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAssignWithoutDisposingPreviousIntoDisposedSlot_ThenIncomingDisposed()
+    {
+        IDisposable? slot = null;
+        var disposed = DisposableSlotHelper.DisposedSentinel;
+        var late = new CountingDisposable();
+
+        DisposableSlotHelper.AssignWithoutDisposingPrevious(ref slot, ref disposed, late);
+
+        await Assert.That(late.DisposeCount).IsEqualTo(1);
+        await Assert.That(slot).IsNull();
+    }
+
+    /// <summary>Verifies the steady-state assign — slot transitions to the new value without disposing the previous.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAssignWithoutDisposingPreviousOpen_ThenStoresAndLeavesPreviousAlone()
+    {
+        var first = new CountingDisposable();
+        IDisposable? slot = first;
+        var disposed = 0;
+        var second = new CountingDisposable();
+
+        DisposableSlotHelper.AssignWithoutDisposingPrevious(ref slot, ref disposed, second);
+
+        await Assert.That(slot).IsSameReferenceAs(second);
+        await Assert.That(first.DisposeCount).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that assigning a null value into an open slot stores null without throwing.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAssignWithoutDisposingPreviousNullValueOpen_ThenStoresNull()
+    {
+        var first = new CountingDisposable();
+        IDisposable? slot = first;
+        var disposed = 0;
+
+        DisposableSlotHelper.AssignWithoutDisposingPrevious(ref slot, ref disposed, null);
+
+        await Assert.That(slot).IsNull();
+        await Assert.That(first.DisposeCount).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies the swap path disposes the previous value on each assignment.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwapAndDisposePreviousOpen_ThenPreviousDisposed()
+    {
+        var first = new CountingDisposable();
+        IDisposable? slot = first;
+        var disposed = 0;
+        var second = new CountingDisposable();
+
+        DisposableSlotHelper.SwapAndDisposePrevious(ref slot, ref disposed, second);
+
+        await Assert.That(slot).IsSameReferenceAs(second);
+        await Assert.That(first.DisposeCount).IsEqualTo(1);
+        await Assert.That(second.DisposeCount).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies the swap path disposes the incoming value if the slot is already disposed.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwapAndDisposePreviousIntoDisposedSlot_ThenIncomingDisposed()
+    {
+        IDisposable? slot = null;
+        var disposed = DisposableSlotHelper.DisposedSentinel;
+        var late = new CountingDisposable();
+
+        DisposableSlotHelper.SwapAndDisposePrevious(ref slot, ref disposed, late);
+
+        await Assert.That(late.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>TryDispose</c> latches and disposes the inner on the first call.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTryDisposeOpen_ThenLatchesAndDisposesInner()
+    {
+        var inner = new CountingDisposable();
+        IDisposable? slot = inner;
+        var disposed = 0;
+
+        var first = DisposableSlotHelper.TryDispose(ref slot, ref disposed);
+        var second = DisposableSlotHelper.TryDispose(ref slot, ref disposed);
+
+        await Assert.That(first).IsTrue();
+        await Assert.That(second).IsFalse();
+        await Assert.That(inner.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Disposable used to verify dispose counts.</summary>
+    private sealed class CountingDisposable : IDisposable
+    {
+        /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsTaskHelperTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsTaskHelperTests.cs
new file mode 100644
index 0000000..318dbda
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsTaskHelperTests.cs
@@ -0,0 +1,165 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for <see cref="FirstAsTaskHelper"/> covering the error and empty-completion
+/// paths that <c>ToHotTask</c> does not otherwise exercise.</summary>
+public class FirstAsTaskHelperTests
+{
+    /// <summary>Value used by the latch-on-first-emission test.</summary>
+    private const int FirstValue = 7;
+
+    /// <summary>Value used by the latch-on-first-emission test to verify subsequent values are ignored.</summary>
+    private const int SecondValue = 11;
+
+    /// <summary>Verifies the helper faults the task when the source emits an error before any value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceErrors_ThenTaskFaults()
+    {
+        var expected = new InvalidOperationException("boom");
+        var task = FirstAsTaskHelper.FirstAsTask(Observable.Throw<int>(expected));
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+        await Assert.That(ex).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies the helper faults the task when the source completes empty.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceCompletesEmpty_ThenTaskFaultsWithInvalidOperation()
+    {
+        var task = FirstAsTaskHelper.FirstAsTask(Observable.Empty<int>());
+
+        await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+    }
+
+    /// <summary>Verifies the task latches on the first emission and ignores subsequent values.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceEmitsMultiple_ThenTaskCompletesWithFirst()
+    {
+        var subject = new Subject<int>();
+        var task = FirstAsTaskHelper.FirstAsTask(subject);
+
+        subject.OnNext(FirstValue);
+        subject.OnNext(SecondValue);
+        subject.OnCompleted();
+
+        await Assert.That(await task).IsEqualTo(FirstValue);
+    }
+
+    /// <summary>Verifies the helper throws when the source argument is null.</summary>
+    [Test]
+    public void WhenSourceNull_ThenThrowsArgumentNullException() =>
+        Assert.Throws<ArgumentNullException>(static () => FirstAsTaskHelper.FirstAsTask<int>(null!));
+
+    /// <summary>Exercises the <c>Subscription?.Dispose()</c> null-conditional branch on
+    /// <c>FirstObserver.OnNext</c> — a source that synchronously emits during <c>Subscribe</c>
+    /// (such as <see cref="Observable.Return{T}(T)"/>) fires <c>OnNext</c> before
+    /// <c>FirstAsTask</c> can assign the <c>Subscription</c> property, so the latch-and-cleanup
+    /// path sees <c>Subscription == null</c> and the conditional dispose becomes a no-op.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSyncSourceEmits_ThenSubscriptionNullBranchSkipsDispose()
+    {
+        const int Sentinel = 17;
+
+        var task = FirstAsTaskHelper.FirstAsTask(Observable.Return(Sentinel));
+
+        await Assert.That(await task).IsEqualTo(Sentinel);
+    }
+
+    /// <summary>Verifies emissions arriving after the task has already settled are silently ignored.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubjectErrorsThenLaterEvents_ThenLaterEventsIgnored()
+    {
+        var subject = new Subject<int>();
+        var task = FirstAsTaskHelper.FirstAsTask(subject);
+        var expected = new InvalidOperationException("first");
+
+        subject.OnError(expected);
+        subject.OnCompleted();
+        subject.OnNext(FirstValue);
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+        await Assert.That(ex).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that a second <c>OnNext</c> arriving via a non-cooperative source
+    /// (one that does not stop emitting after the first value) is dropped by the latch.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSecondOnNextAfterFirstSettled_ThenIgnored()
+    {
+        var source = new InvasiveObservable<int>();
+        var task = FirstAsTaskHelper.FirstAsTask(source);
+
+        source.Observer.OnNext(FirstValue);
+        source.Observer.OnNext(SecondValue);
+        source.Observer.OnError(new InvalidOperationException("ignored"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(await task).IsEqualTo(FirstValue);
+    }
+
+    /// <summary>Verifies that a second <c>OnError</c> arriving after the first is dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSecondOnErrorAfterFirstSettled_ThenIgnored()
+    {
+        var source = new InvasiveObservable<int>();
+        var task = FirstAsTaskHelper.FirstAsTask(source);
+        var expected = new InvalidOperationException("first");
+
+        source.Observer.OnError(expected);
+        source.Observer.OnError(new InvalidOperationException("ignored"));
+        source.Observer.OnCompleted();
+
+        var caught = await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that a second <c>OnCompleted</c> arriving after the first is dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSecondOnCompletedAfterFirstSettled_ThenIgnored()
+    {
+        var source = new InvasiveObservable<int>();
+        var task = FirstAsTaskHelper.FirstAsTask(source);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnCompleted();
+        source.Observer.OnError(new InvalidOperationException("ignored"));
+
+        await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+    }
+
+    /// <summary>Test observable that captures its subscriber so tests can directly invoke
+    /// non-cooperative double-terminal sequences against <c>FirstAsTaskHelper</c>'s observer.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class InvasiveObservable<T> : IObservable<T>
+    {
+        /// <summary>The captured observer from the most recent subscription.</summary>
+        private IObserver<T>? _observer;
+
+        /// <summary>Gets the captured observer.</summary>
+        public IObserver<T> Observer => _observer
+            ?? throw new InvalidOperationException("No subscriber yet.");
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            _observer = observer;
+            return System.Reactive.Disposables.Disposable.Empty;
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs
new file mode 100644
index 0000000..e8cc0b4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/FirstAsValueTaskHelperTests.cs
@@ -0,0 +1,175 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for <see cref="FirstAsValueTaskHelper{T}"/> covering the value, error, and
+/// empty-completion paths the pooled <c>ToHotValueTask</c> source exposes, plus the pool reuse and
+/// post-settle drop branches.</summary>
+public class FirstAsValueTaskHelperTests
+{
+    /// <summary>Value used by the latch-on-first-emission tests.</summary>
+    private const int FirstValue = 7;
+
+    /// <summary>Value used to verify subsequent values are ignored.</summary>
+    private const int SecondValue = 11;
+
+    /// <summary>Verifies the helper completes with the first value the source emits.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceEmits_ThenValueTaskCompletesWithFirst()
+    {
+        var subject = new Subject<int>();
+        var task = FirstAsValueTaskHelper<int>.FirstAsValueTask(subject);
+
+        subject.OnNext(FirstValue);
+        subject.OnNext(SecondValue);
+        subject.OnCompleted();
+
+        await Assert.That(await task).IsEqualTo(FirstValue);
+    }
+
+    /// <summary>Verifies the helper faults the value task when the source errors before any value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceErrors_ThenValueTaskFaults()
+    {
+        var expected = new InvalidOperationException("boom");
+        var task = FirstAsValueTaskHelper<int>.FirstAsValueTask(Observable.Throw<int>(expected));
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+        await Assert.That(ex).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies the helper faults the value task when the source completes empty.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceCompletesEmpty_ThenValueTaskFaultsWithInvalidOperation()
+    {
+        var task = FirstAsValueTaskHelper<int>.FirstAsValueTask(Observable.Empty<int>());
+
+        await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+    }
+
+    /// <summary>Verifies the helper throws when the source argument is null.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceNull_ThenThrowsArgumentNullException() =>
+        await Assert.ThrowsAsync<ArgumentNullException>(
+            static async () => await FirstAsValueTaskHelper<int>.FirstAsValueTask(null!));
+
+    /// <summary>Exercises the <c>Subscription?.Dispose()</c> null-conditional branch when a source
+    /// synchronously emits during <c>Subscribe</c> before the subscription field is assigned.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSyncSourceEmits_ThenSubscriptionNullBranchSkipsDispose()
+    {
+        const int Sentinel = 17;
+
+        var value = await FirstAsValueTaskHelper<int>.FirstAsValueTask(Observable.Return(Sentinel));
+
+        await Assert.That(value).IsEqualTo(Sentinel);
+    }
+
+    /// <summary>Verifies the pooled source is reused across sequential calls — a second call after the
+    /// first has settled returns to the pool and resolves correctly.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCalledSequentially_ThenPooledSourceReused()
+    {
+        var first = await FirstAsValueTaskHelper<int>.FirstAsValueTask(Observable.Return(FirstValue));
+        var second = await FirstAsValueTaskHelper<int>.FirstAsValueTask(Observable.Return(SecondValue));
+
+        await Assert.That(first).IsEqualTo(FirstValue);
+        await Assert.That(second).IsEqualTo(SecondValue);
+    }
+
+    /// <summary>Verifies awaiting the value task before the source emits registers a continuation on the
+    /// pooled source (the incomplete-await path) and resolves once the value later arrives.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAwaitedBeforeEmission_ThenCompletesOnLaterValue()
+    {
+        var subject = new Subject<int>();
+        var pending = FirstAsValueTaskHelper<int>.FirstAsValueTask(subject).AsTask();
+
+        subject.OnNext(FirstValue);
+
+        var result = await pending.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(result).IsEqualTo(FirstValue);
+    }
+
+    /// <summary>Verifies emissions arriving after the value task has already settled are silently ignored.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSecondTerminalAfterSettled_ThenIgnored()
+    {
+        var source = new InvasiveObservable<int>();
+        var task = FirstAsValueTaskHelper<int>.FirstAsValueTask(source);
+
+        source.Observer.OnNext(FirstValue);
+        source.Observer.OnNext(SecondValue);
+        source.Observer.OnError(new InvalidOperationException("ignored"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(await task).IsEqualTo(FirstValue);
+    }
+
+    /// <summary>Verifies a second <c>OnError</c> arriving after the first is dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSecondOnErrorAfterSettled_ThenIgnored()
+    {
+        var source = new InvasiveObservable<int>();
+        var task = FirstAsValueTaskHelper<int>.FirstAsValueTask(source);
+        var expected = new InvalidOperationException("first");
+
+        source.Observer.OnError(expected);
+        source.Observer.OnError(new InvalidOperationException("ignored"));
+        source.Observer.OnCompleted();
+
+        var caught = await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies a second <c>OnCompleted</c> arriving after the first is dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSecondOnCompletedAfterSettled_ThenIgnored()
+    {
+        var source = new InvasiveObservable<int>();
+        var task = FirstAsValueTaskHelper<int>.FirstAsValueTask(source);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnCompleted();
+        source.Observer.OnError(new InvalidOperationException("ignored"));
+
+        await Assert.ThrowsAsync<InvalidOperationException>(async () => await task);
+    }
+
+    /// <summary>Test observable that captures its subscriber so tests can directly invoke
+    /// non-cooperative double-terminal sequences against the pooled first-value observer.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class InvasiveObservable<T> : IObservable<T>
+    {
+        /// <summary>The captured observer from the most recent subscription.</summary>
+        private IObserver<T>? _observer;
+
+        /// <summary>Gets the captured observer.</summary>
+        public IObserver<T> Observer => _observer
+            ?? throw new InvalidOperationException("No subscriber yet.");
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            _observer = observer;
+            return System.Reactive.Disposables.Disposable.Empty;
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/IndexedSubscribeHelperTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/IndexedSubscribeHelperTests.cs
new file mode 100644
index 0000000..d3904b5
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/IndexedSubscribeHelperTests.cs
@@ -0,0 +1,138 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for <see cref="IndexedSubscribeHelper"/>, the shared indexed-subscribe loop used
+/// by the synchronous combine-then-reduce operator family.</summary>
+public class IndexedSubscribeHelperTests
+{
+    /// <summary>Value emitted by source 0 in the index-threading test.</summary>
+    private const int Source0Value = 20;
+
+    /// <summary>Value emitted by source 1 in the index-threading test.</summary>
+    private const int Source1Value = 10;
+
+    /// <summary>Value emitted by source 2 in the index-threading test.</summary>
+    private const int Source2Value = 30;
+
+    /// <summary>First post-subscribe value used by the dispose-guard test.</summary>
+    private const int DisposeValue1 = 1;
+
+    /// <summary>Post-dispose value used by the dispose-guard test.</summary>
+    private const int DisposeValue2 = 2;
+
+    /// <summary>Post-dispose value emitted by the second source in the dispose-guard test.</summary>
+    private const int DisposeValue3 = 3;
+
+    /// <summary>Verifies that the helper threads each source's positional index through to the OnNext hook.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourcesEmit_ThenOnNextReceivesPerSourceIndex()
+    {
+        using var s0 = new Subject<int>();
+        using var s1 = new Subject<int>();
+        using var s2 = new Subject<int>();
+        var captured = new List<(int Index, int Value)>();
+
+        using var sub = IndexedSubscribeHelper.SubscribeIndexed(
+            [s0, s1, s2],
+            (i, v) => captured.Add((i, v)),
+            static _ => { },
+            static _ => { });
+
+        s1.OnNext(Source1Value);
+        s0.OnNext(Source0Value);
+        s2.OnNext(Source2Value);
+
+        const int FirstIndex = 0;
+        const int SecondIndex = 1;
+        const int ThirdIndex = 2;
+        await Assert.That(captured).IsCollectionEqualTo(
+            [(SecondIndex, Source1Value), (FirstIndex, Source0Value), (ThirdIndex, Source2Value)]);
+    }
+
+    /// <summary>Verifies that the helper forwards any source's error through the shared OnError hook.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAnySourceErrors_ThenOnErrorForwarded()
+    {
+        using var s0 = new Subject<int>();
+        using var s1 = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("source error");
+
+        using var sub = IndexedSubscribeHelper.SubscribeIndexed(
+            [s0, s1],
+            static (_, _) => { },
+            ex => caught = ex,
+            static _ => { });
+
+        s1.OnError(expected);
+
+        await Assert.That(caught).IsEqualTo(expected);
+    }
+
+    /// <summary>Verifies that the helper threads each source's positional index through to the OnCompleted hook.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourcesComplete_ThenOnCompletedReceivesPerSourceIndex()
+    {
+        using var s0 = new Subject<int>();
+        using var s1 = new Subject<int>();
+        var completed = new List<int>();
+
+        using var sub = IndexedSubscribeHelper.SubscribeIndexed(
+            [s0, s1],
+            static (_, _) => { },
+            static _ => { },
+            completed.Add);
+
+        const int FirstIndex = 0;
+        const int SecondIndex = 1;
+        s1.OnCompleted();
+        s0.OnCompleted();
+
+        await Assert.That(completed).IsCollectionEqualTo([SecondIndex, FirstIndex]);
+    }
+
+    /// <summary>Verifies that disposing the returned aggregate stops further deliveries from every source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposed_ThenNoFurtherDeliveries()
+    {
+        using var s0 = new Subject<int>();
+        using var s1 = new Subject<int>();
+        var captured = new List<(int Index, int Value)>();
+
+        var sub = IndexedSubscribeHelper.SubscribeIndexed(
+            [s0, s1],
+            (i, v) => captured.Add((i, v)),
+            static _ => { },
+            static _ => { });
+
+        s0.OnNext(DisposeValue1);
+        sub.Dispose();
+        s0.OnNext(DisposeValue2);
+        s1.OnNext(DisposeValue3);
+
+        await Assert.That(captured).IsCollectionEqualTo([(0, DisposeValue1)]);
+    }
+
+    /// <summary>Verifies that the helper validates its null arguments and surfaces a meaningful exception.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenNullArgs_ThenArgumentNullException()
+    {
+        const IReadOnlyList<IObservable<int>> NullSources = null!;
+        var ex = Assert.Throws<ArgumentNullException>(() =>
+            IndexedSubscribeHelper.SubscribeIndexed(NullSources, static (_, _) => { }, static _ => { }, static _ => { }));
+
+        await Assert.That(ex).IsNotNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/InternalDisposablesTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/InternalDisposablesTests.cs
new file mode 100644
index 0000000..5f5b90a
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/InternalDisposablesTests.cs
@@ -0,0 +1,173 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for the internal disposable holders
+/// (<see cref="SwapDisposable"/>, <see cref="MutableDisposable"/>, <see cref="OnceDisposable"/>)
+/// that back the sync-side sinks.</summary>
+public class InternalDisposablesTests
+{
+    /// <summary>Verifies that assigning a new inner disposes the previous one.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwapDisposableReplaced_ThenPreviousDisposed()
+    {
+        var holder = new SwapDisposable();
+        var first = new CountingDisposable();
+        var second = new CountingDisposable();
+
+        holder.Disposable = first;
+        await Assert.That(holder.Disposable).IsSameReferenceAs(first);
+
+        holder.Disposable = second;
+        await Assert.That(first.DisposeCount).IsEqualTo(1);
+        await Assert.That(holder.Disposable).IsSameReferenceAs(second);
+
+        holder.Dispose();
+        await Assert.That(second.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that once disposed, subsequent assignments dispose the supplied value immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwapDisposableAfterDispose_ThenAssignmentDisposesValue()
+    {
+        var holder = new SwapDisposable();
+        holder.Dispose();
+
+        var late = new CountingDisposable();
+        holder.Disposable = late;
+
+        await Assert.That(late.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that double-dispose is a no-op on <see cref="SwapDisposable"/>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwapDisposableDisposedTwice_ThenNoOp()
+    {
+        var inner = new CountingDisposable();
+        var holder = new SwapDisposable { Disposable = inner };
+
+        holder.Dispose();
+        holder.Dispose();
+
+        await Assert.That(inner.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that <see cref="MutableDisposable"/> replacement does NOT dispose the previous inner.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMutableDisposableReplaced_ThenPreviousNotDisposed()
+    {
+        var holder = new MutableDisposable();
+        var first = new CountingDisposable();
+        var second = new CountingDisposable();
+
+        holder.Disposable = first;
+        holder.Disposable = second;
+
+        await Assert.That(first.DisposeCount).IsEqualTo(0);
+
+        holder.Dispose();
+        await Assert.That(second.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that assigning after dispose immediately disposes the value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMutableDisposableAfterDispose_ThenAssignmentDisposesValue()
+    {
+        var holder = new MutableDisposable();
+        holder.Dispose();
+
+        var late = new CountingDisposable();
+        holder.Disposable = late;
+
+        await Assert.That(late.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that <see cref="MutableDisposable"/> double-dispose is a no-op.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMutableDisposableDisposedTwice_ThenNoOp()
+    {
+        var inner = new CountingDisposable();
+        var holder = new MutableDisposable { Disposable = inner };
+
+        holder.Dispose();
+        holder.Dispose();
+
+        await Assert.That(inner.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies single-assignment succeeds and <see cref="OnceDisposable.IsAssigned"/> reflects state.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnceDisposableAssignedOnce_ThenIsAssignedTrueAndDisposed()
+    {
+        var holder = new OnceDisposable();
+        var inner = new CountingDisposable();
+
+        await Assert.That(holder.IsAssigned).IsFalse();
+        await Assert.That(holder.IsDisposed).IsFalse();
+        holder.Disposable = inner;
+        await Assert.That(holder.IsAssigned).IsTrue();
+        await Assert.That(holder.Disposable).IsSameReferenceAs(inner);
+
+        holder.Dispose();
+        await Assert.That(holder.IsDisposed).IsTrue();
+        await Assert.That(inner.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that a second non-null assignment throws.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnceDisposableAssignedTwice_ThenThrows()
+    {
+        var holder = new OnceDisposable { Disposable = new CountingDisposable() };
+
+        var ex = Assert.Throws<InvalidOperationException>(() => holder.Disposable = new CountingDisposable());
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>Verifies that assigning after dispose disposes the supplied value and reports null via the getter.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnceDisposableAfterDispose_ThenAssignmentDisposesValueAndGetterReportsNull()
+    {
+        var holder = new OnceDisposable();
+        holder.Dispose();
+
+        var late = new CountingDisposable();
+        holder.Disposable = late;
+
+        await Assert.That(late.DisposeCount).IsEqualTo(1);
+        await Assert.That(holder.Disposable).IsNull();
+    }
+
+    /// <summary>Verifies that disposing without ever assigning is a no-op.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnceDisposableDisposedUnassigned_ThenNoOp()
+    {
+        var holder = new OnceDisposable();
+        holder.Dispose();
+
+        await Assert.That(holder.Disposable).IsNull();
+    }
+
+    /// <summary>Counts how many times <see cref="IDisposable.Dispose"/> is invoked.</summary>
+    private sealed class CountingDisposable : IDisposable
+    {
+        /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/MutableDisposableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/MutableDisposableTests.cs
new file mode 100644
index 0000000..ecaa042
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/MutableDisposableTests.cs
@@ -0,0 +1,77 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for <see cref="MutableDisposable"/> — verifies that reassigning the inner does
+/// NOT dispose the previous, that assigning after disposal immediately disposes the incoming
+/// value, and that <c>Dispose</c> is idempotent.</summary>
+public class MutableDisposableTests
+{
+    /// <summary>Verifies replacement leaves the previous inner alone.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenInnerReplaced_ThenPreviousIsNotDisposed()
+    {
+        using var holder = new MutableDisposable();
+        var firstDisposed = 0;
+        var secondDisposed = 0;
+        var first = new ActionDisposable(() => firstDisposed++);
+        var second = new ActionDisposable(() => secondDisposed++);
+
+        holder.Disposable = first;
+        holder.Disposable = second;
+
+        await Assert.That(firstDisposed).IsEqualTo(0);
+        await Assert.That(holder.Disposable).IsSameReferenceAs(second);
+        await Assert.That(secondDisposed).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that assigning after disposal immediately disposes the incoming value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSetAfterDispose_ThenIncomingIsDisposedImmediately()
+    {
+        var holder = new MutableDisposable();
+        holder.Dispose();
+        var late = 0;
+
+        holder.Disposable = new ActionDisposable(() => late++);
+
+        await Assert.That(late).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that assigning <see langword="null"/> after disposal is a no-op.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSetNullAfterDispose_ThenNoThrow()
+    {
+        var holder = new MutableDisposable();
+        holder.Dispose();
+
+        holder.Disposable = null;
+
+        await Assert.That(holder.Disposable).IsNull();
+    }
+
+    /// <summary>Verifies <c>Dispose</c> disposes the inner and is idempotent across repeated calls.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposedTwice_ThenInnerDisposedOnce()
+    {
+        var holder = new MutableDisposable();
+        var disposed = 0;
+        holder.Disposable = new ActionDisposable(() => disposed++);
+
+        await Assert.That(holder.IsDisposed).IsFalse();
+
+        holder.Dispose();
+        holder.Dispose();
+
+        await Assert.That(holder.IsDisposed).IsTrue();
+        await Assert.That(disposed).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ObserverArrayHelpersTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ObserverArrayHelpersTests.cs
new file mode 100644
index 0000000..6582b39
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ObserverArrayHelpersTests.cs
@@ -0,0 +1,163 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Direct RxVoid tests for <see cref="ObserverArrayHelpers"/> — both the broadcast
+/// loop and the remove-or-null short-circuit paths. The helpers are pure functions over
+/// their inputs, so each branch is exercised by passing synthesized arrays rather than
+/// relying on operator-level scheduler races.</summary>
+public class ObserverArrayHelpersTests
+{
+    /// <summary>Sentinel value broadcast through the helper.</summary>
+    private const int Sentinel = 7;
+
+    /// <summary>Expected length of the array after removing one observer from three.</summary>
+    private const int RemainingLengthAfterRemoveFromThree = 2;
+
+    /// <summary>Verifies <see cref="ObserverArrayHelpers.Broadcast{T}"/> short-circuits when
+    /// the observer array is empty.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBroadcastEmpty_ThenNoOp()
+    {
+        var observers = Array.Empty<IObserver<int>>();
+
+        ObserverArrayHelpers.Broadcast(observers, Sentinel);
+
+        await Assert.That(observers).IsEmpty();
+    }
+
+    /// <summary>Verifies <see cref="ObserverArrayHelpers.Broadcast{T}"/> fans the value out to
+    /// every observer in order.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBroadcastMultiple_ThenEveryObserverReceivesValue()
+    {
+        var first = new RecordingObserver<int>();
+        var second = new RecordingObserver<int>();
+        var third = new RecordingObserver<int>();
+        IObserver<int>[] observers = [first, second, third];
+
+        ObserverArrayHelpers.Broadcast(observers, Sentinel);
+
+        await Assert.That(first.Values).IsCollectionEqualTo([Sentinel]);
+        await Assert.That(second.Values).IsCollectionEqualTo([Sentinel]);
+        await Assert.That(third.Values).IsCollectionEqualTo([Sentinel]);
+    }
+
+    /// <summary>Verifies <see cref="ObserverArrayHelpers.RemoveOrNull{T}"/> returns <see langword="null"/>
+    /// when the observer is not present in the array.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRemoveNotPresent_ThenReturnsNull()
+    {
+        var empty = Array.Empty<IObserver<int>>();
+        var resident = new RecordingObserver<int>();
+        var stranger = new RecordingObserver<int>();
+        IObserver<int>[] current = [resident];
+
+        var result = ObserverArrayHelpers.RemoveOrNull(current, stranger, empty);
+
+        await Assert.That(result).IsNull();
+    }
+
+    /// <summary>Verifies <see cref="ObserverArrayHelpers.RemoveOrNull{T}"/> returns the empty
+    /// sentinel when the array contains exactly one observer (the one being removed).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRemoveSingleton_ThenReturnsEmptySentinel()
+    {
+        var empty = Array.Empty<IObserver<int>>();
+        var only = new RecordingObserver<int>();
+        IObserver<int>[] current = [only];
+
+        var result = ObserverArrayHelpers.RemoveOrNull(current, only, empty);
+
+        await Assert.That(result).IsSameReferenceAs(empty);
+    }
+
+    /// <summary>Verifies <see cref="ObserverArrayHelpers.RemoveOrNull{T}"/> removes the first
+    /// observer from a multi-element array (no left copy, full right copy).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRemoveFirstFromThree_ThenLeavesTrailingPair()
+    {
+        var empty = Array.Empty<IObserver<int>>();
+        var a = new RecordingObserver<int>();
+        var b = new RecordingObserver<int>();
+        var c = new RecordingObserver<int>();
+        IObserver<int>[] current = [a, b, c];
+
+        var result = ObserverArrayHelpers.RemoveOrNull(current, a, empty);
+
+        await Assert.That(result).IsNotNull();
+        await Assert.That(result!.Length).IsEqualTo(RemainingLengthAfterRemoveFromThree);
+        await Assert.That(ReferenceEquals(result[0], b)).IsTrue();
+        await Assert.That(ReferenceEquals(result[1], c)).IsTrue();
+    }
+
+    /// <summary>Verifies <see cref="ObserverArrayHelpers.RemoveOrNull{T}"/> removes the middle
+    /// observer (both left and right copies non-empty).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRemoveMiddleFromThree_ThenLeavesFirstAndLast()
+    {
+        var empty = Array.Empty<IObserver<int>>();
+        var a = new RecordingObserver<int>();
+        var b = new RecordingObserver<int>();
+        var c = new RecordingObserver<int>();
+        IObserver<int>[] current = [a, b, c];
+
+        var result = ObserverArrayHelpers.RemoveOrNull(current, b, empty);
+
+        await Assert.That(result).IsNotNull();
+        await Assert.That(result!.Length).IsEqualTo(RemainingLengthAfterRemoveFromThree);
+        await Assert.That(ReferenceEquals(result[0], a)).IsTrue();
+        await Assert.That(ReferenceEquals(result[1], c)).IsTrue();
+    }
+
+    /// <summary>Verifies <see cref="ObserverArrayHelpers.RemoveOrNull{T}"/> removes the last
+    /// observer (full left copy, no right copy).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRemoveLastFromThree_ThenLeavesLeadingPair()
+    {
+        var empty = Array.Empty<IObserver<int>>();
+        var a = new RecordingObserver<int>();
+        var b = new RecordingObserver<int>();
+        var c = new RecordingObserver<int>();
+        IObserver<int>[] current = [a, b, c];
+
+        var result = ObserverArrayHelpers.RemoveOrNull(current, c, empty);
+
+        await Assert.That(result).IsNotNull();
+        await Assert.That(result!.Length).IsEqualTo(RemainingLengthAfterRemoveFromThree);
+        await Assert.That(ReferenceEquals(result[0], a)).IsTrue();
+        await Assert.That(ReferenceEquals(result[1], b)).IsTrue();
+    }
+
+    /// <summary>Recording observer used to verify <c>Broadcast</c> reaches each slot.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class RecordingObserver<T> : IObserver<T>
+    {
+        /// <summary>Gets the captured <c>OnNext</c> values in order.</summary>
+        public List<T> Values { get; } = [];
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => Values.Add(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnCompleted()
+        {
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ReduceSinkStateTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ReduceSinkStateTests.cs
new file mode 100644
index 0000000..f29e7a8
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/ReduceSinkStateTests.cs
@@ -0,0 +1,146 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for <see cref="ReduceSinkState{TIn, TOut}"/>, the shared state object used by
+/// the synchronous combine-then-reduce operator family.</summary>
+public class ReduceSinkStateTests
+{
+    /// <summary>Verifies that a freshly-constructed state reports zero values seen and is not terminal.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFreshState_ThenZeroValuesAndNotTerminal()
+    {
+        const int SourceCount = 3;
+        var observer = new CaptureObserver<int>();
+        var state = new ReduceSinkState<int, int>(observer, SourceCount);
+
+        await Assert.That(state.HasValueCount).IsEqualTo(0);
+        await Assert.That(state.CompletedCount).IsEqualTo(0);
+        await Assert.That(state.IsDone).IsFalse();
+        await Assert.That(state.AllValuesPresent).IsFalse();
+        await Assert.That(state.Values).Count().IsEqualTo(SourceCount);
+        await Assert.That(state.Completed).Count().IsEqualTo(SourceCount);
+    }
+
+    /// <summary>Verifies that <c>AllValuesPresent</c> flips once every slot has a value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEverySlotPopulated_ThenAllValuesPresent()
+    {
+        const int FirstSeed = 1;
+        const int SecondSeed = 2;
+        var observer = new CaptureObserver<int>();
+        var state = new ReduceSinkState<int, int>(observer, count: 2);
+
+        state.Values[0] = FirstSeed;
+        state.HasValueCount++;
+        await Assert.That(state.AllValuesPresent).IsFalse();
+
+        state.Values[1] = SecondSeed;
+        state.HasValueCount++;
+        await Assert.That(state.AllValuesPresent).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>HandleError</c> forwards once, marks terminal, and is idempotent.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandleError_ThenForwardsAndIsTerminal()
+    {
+        var observer = new CaptureObserver<int>();
+        var state = new ReduceSinkState<int, int>(observer, count: 2);
+        var error = new InvalidOperationException("boom");
+
+        state.HandleError(error);
+        state.HandleError(new InvalidOperationException("second")); // should be no-op
+
+        await Assert.That(state.IsDone).IsTrue();
+        await Assert.That(observer.Errors).Count().IsEqualTo(1);
+        await Assert.That(observer.Errors[0]).IsEqualTo(error);
+    }
+
+    /// <summary>Verifies that <c>HandleCompleted</c> completes once every source has completed.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAllSourcesComplete_ThenDownstreamCompletes()
+    {
+        const int SeedValue1 = 1;
+        const int SeedValue2 = 2;
+        const int SeededValueCount = 2;
+        var observer = new CaptureObserver<int>();
+        var state = new ReduceSinkState<int, int>(observer, count: 2);
+
+        // Seed both values so completion-without-value path isn't triggered.
+        state.Values[0] = SeedValue1;
+        state.Values[1] = SeedValue2;
+        state.HasValueCount = SeededValueCount;
+
+        state.HandleCompleted(0);
+        await Assert.That(state.IsDone).IsFalse();
+        await Assert.That(observer.Completed).IsFalse();
+
+        state.HandleCompleted(1);
+        await Assert.That(state.IsDone).IsTrue();
+        await Assert.That(observer.Completed).IsTrue();
+    }
+
+    /// <summary>Verifies that a source completing without ever emitting closes the combined sequence.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceCompletesWithoutValue_ThenDownstreamCompletesEarly()
+    {
+        const int FirstSeed = 1;
+        var observer = new CaptureObserver<int>();
+        var state = new ReduceSinkState<int, int>(observer, count: 2);
+
+        // Source 0 emitted; source 1 completes without a value.
+        state.Values[0] = FirstSeed;
+        state.HasValueCount = 1;
+
+        state.HandleCompleted(1);
+
+        await Assert.That(state.IsDone).IsTrue();
+        await Assert.That(observer.Completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>HandleCompleted</c> is idempotent per-source-index.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSameSourceCompletesTwice_ThenSecondCallIgnored()
+    {
+        var observer = new CaptureObserver<int>();
+        var state = new ReduceSinkState<int, int>(observer, count: 2);
+
+        state.HandleCompleted(0);
+        state.HandleCompleted(0); // same index — should be no-op
+
+        await Assert.That(state.CompletedCount).IsEqualTo(1);
+    }
+
+    /// <summary>Tiny capture observer used by the helper tests.</summary>
+    /// <typeparam name="T">Captured element type.</typeparam>
+    private sealed class CaptureObserver<T> : IObserver<T>
+    {
+        /// <summary>Gets the captured OnNext values in order.</summary>
+        public List<T> Values { get; } = [];
+
+        /// <summary>Gets the captured OnError exceptions in order.</summary>
+        public List<Exception> Errors { get; } = [];
+
+        /// <summary>Gets a value indicating whether OnCompleted was observed.</summary>
+        public bool Completed { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => Values.Add(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => Errors.Add(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => Completed = true;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/SequencerPeriodicMixinsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/SequencerPeriodicMixinsTests.cs
new file mode 100644
index 0000000..5d68953
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/SequencerPeriodicMixinsTests.cs
@@ -0,0 +1,38 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for periodic sequencer scheduling helpers.</summary>
+public class SequencerPeriodicMixinsTests
+{
+    /// <summary>Period used by virtual-clock tests.</summary>
+    private static readonly TimeSpan Period = TimeSpan.FromTicks(10);
+
+    /// <summary>Verifies repeated disposal and a tick observed after disposal are both no-ops.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPeriodicSubscriptionDisposedTwiceAndTickRuns_ThenNoOp()
+    {
+        var scheduler = new VirtualClock();
+        var ticks = 0;
+        var subscription = scheduler.SchedulePeriodic(Period, Period, () => ticks++);
+
+        const int PeriodsToAdvance = 3;
+        subscription.Dispose();
+        subscription.Dispose();
+        InvokeTick(subscription);
+        scheduler.AdvanceBy(TimeSpan.FromTicks(Period.Ticks * PeriodsToAdvance));
+
+        await Assert.That(ticks).IsEqualTo(0);
+    }
+
+    /// <summary>Invokes the tick method to exercise the disposed tick guard.</summary>
+    /// <param name="subscription">The subscription under test.</param>
+    private static void InvokeTick(IDisposable subscription) =>
+        ((SequencerPeriodicMixins.PeriodicSubscription<Action>)subscription).Tick();
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/SwapDisposableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/SwapDisposableTests.cs
new file mode 100644
index 0000000..091f7cc
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/SwapDisposableTests.cs
@@ -0,0 +1,73 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Tests for <see cref="SwapDisposable"/> — verifies replacement disposes the previous
+/// inner, assigning after disposal immediately disposes the incoming value, and <c>Dispose</c>
+/// is idempotent.</summary>
+public class SwapDisposableTests
+{
+    /// <summary>Verifies that replacement disposes the previous inner.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenInnerReplaced_ThenPreviousIsDisposed()
+    {
+        using var holder = new SwapDisposable();
+        var firstDisposed = 0;
+        var secondDisposed = 0;
+        holder.Disposable = new ActionDisposable(() => firstDisposed++);
+        holder.Disposable = new ActionDisposable(() => secondDisposed++);
+
+        await Assert.That(firstDisposed).IsEqualTo(1);
+        await Assert.That(secondDisposed).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that the getter returns the currently-assigned inner.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenGetCurrent_ThenReturnsCurrent()
+    {
+        using var holder = new SwapDisposable();
+        var current = new ActionDisposable(static () => { });
+
+        holder.Disposable = current;
+
+        await Assert.That(holder.Disposable).IsSameReferenceAs(current);
+    }
+
+    /// <summary>Verifies that assigning after disposal immediately disposes the incoming value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSetAfterDispose_ThenIncomingIsDisposedImmediately()
+    {
+        var holder = new SwapDisposable();
+        holder.Dispose();
+        var late = 0;
+
+        holder.Disposable = new ActionDisposable(() => late++);
+
+        await Assert.That(late).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>Dispose</c> is idempotent across repeated calls.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposedTwice_ThenInnerDisposedOnce()
+    {
+        var holder = new SwapDisposable();
+        var disposed = 0;
+        holder.Disposable = new ActionDisposable(() => disposed++);
+
+        await Assert.That(holder.IsDisposed).IsFalse();
+
+        holder.Dispose();
+        holder.Dispose();
+
+        await Assert.That(holder.IsDisposed).IsTrue();
+        await Assert.That(disposed).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/TimerSinkStateTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/TimerSinkStateTests.cs
new file mode 100644
index 0000000..f991e18
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Internal/TimerSinkStateTests.cs
@@ -0,0 +1,112 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Internal;
+
+/// <summary>Direct RxVoid tests for <see cref="TimerSinkState{T}"/> — covers the terminal
+/// idempotency guards across <c>HandleError</c>, <c>HandleCompleted</c>, and <c>HandleDispose</c>.</summary>
+public class TimerSinkStateTests
+{
+    /// <summary>Verifies <c>HandleError</c> forwards the error then marks the state done.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandleError_ThenForwardsAndMarksDone()
+    {
+        var observer = new RecordingObserver<int>();
+        var state = new TimerSinkState<int>(observer);
+        var expected = new InvalidOperationException("timer-error");
+
+        state.HandleError(expected);
+
+        await Assert.That(state.Done).IsTrue();
+        await Assert.That(observer.Errors).Count().IsEqualTo(1);
+        await Assert.That(observer.Errors[0]).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>HandleCompleted</c> forwards completion then marks the state done.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandleCompleted_ThenForwardsAndMarksDone()
+    {
+        var observer = new RecordingObserver<int>();
+        var state = new TimerSinkState<int>(observer);
+
+        state.HandleCompleted();
+
+        await Assert.That(state.Done).IsTrue();
+        await Assert.That(observer.Completions).IsEqualTo(1);
+    }
+
+    /// <summary>Exercises the <c>HandleCompleted</c> idempotency guard — once the state is
+    /// already terminal, a second call returns without re-forwarding to the downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandleCompletedAfterError_ThenNoOp()
+    {
+        var observer = new RecordingObserver<int>();
+        var state = new TimerSinkState<int>(observer);
+
+        state.HandleError(new InvalidOperationException("first"));
+        state.HandleCompleted();
+
+        await Assert.That(observer.Completions).IsEqualTo(0);
+        await Assert.That(observer.Errors).Count().IsEqualTo(1);
+    }
+
+    /// <summary>Exercises the <c>HandleError</c> idempotency guard — once the state is
+    /// already terminal, a second call returns without re-forwarding.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandleErrorAfterCompleted_ThenNoOp()
+    {
+        var observer = new RecordingObserver<int>();
+        var state = new TimerSinkState<int>(observer);
+
+        state.HandleCompleted();
+        state.HandleError(new InvalidOperationException("second"));
+
+        await Assert.That(observer.Errors).IsEmpty();
+        await Assert.That(observer.Completions).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>HandleDispose</c> marks the state done without forwarding any
+    /// notification to the downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandleDispose_ThenMarksDoneWithoutForwarding()
+    {
+        var observer = new RecordingObserver<int>();
+        var state = new TimerSinkState<int>(observer);
+
+        state.HandleDispose();
+
+        await Assert.That(state.Done).IsTrue();
+        await Assert.That(observer.Errors).IsEmpty();
+        await Assert.That(observer.Completions).IsEqualTo(0);
+    }
+
+    /// <summary>Recording observer used by the direct <c>TimerSinkState</c> tests.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class RecordingObserver<T> : IObserver<T>
+    {
+        /// <summary>Gets the captured errors.</summary>
+        public List<Exception> Errors { get; } = [];
+
+        /// <summary>Gets the number of <c>OnCompleted</c> calls observed.</summary>
+        public int Completions { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(T value)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => Errors.Add(error);
+
+        /// <inheritdoc/>
+        public void OnCompleted() => Completions++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs
new file mode 100644
index 0000000..8a3cc57
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.SchedulerOverloads.cs
@@ -0,0 +1,102 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Coverage for the scheduler-routed overloads of the WaitFor* helpers on
+/// <see cref="ObservableSubscriptionExtensions"/>. The non-scheduler overloads are
+/// already covered in the companion file; these dispatch the subscribe call via a
+/// scheduler before blocking.</summary>
+public partial class ObservableSubscriptionExtensionsTests
+{
+    /// <summary>Sentinel value emitted by single-value scheduler tests.</summary>
+    private const int SchedulerSentinelValue = 13;
+
+    /// <summary>Default test timeout for the scheduler-routed overloads.</summary>
+    private static readonly TimeSpan SchedulerWaitTimeout = TimeSpan.FromSeconds(5);
+
+    /// <summary>Verifies that <c>WaitForValue</c> with a scheduler returns the emitted value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForValueWithSchedulerOnly_ThenReturnsEmittedValue()
+    {
+        var result = Observable.Return(SchedulerSentinelValue)
+            .WaitForValue(TaskPoolSequencer.Default);
+
+        await Assert.That(result).IsEqualTo(SchedulerSentinelValue);
+    }
+
+    /// <summary>Verifies that <c>WaitForValue</c> with a scheduler and explicit timeout returns the emitted value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForValueWithSchedulerAndTimeout_ThenReturnsEmittedValue()
+    {
+        var result = Observable.Return(SchedulerSentinelValue)
+            .WaitForValue(TaskPoolSequencer.Default, SchedulerWaitTimeout);
+
+        await Assert.That(result).IsEqualTo(SchedulerSentinelValue);
+    }
+
+    /// <summary>Verifies that the scheduler+timeout form of <c>WaitForValue</c> times out for a never-terminating source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForValueWithSchedulerTimesOut_ThenTimeoutException()
+    {
+        Action call = () => Observable.Never<int>()
+            .WaitForValue(TaskPoolSequencer.Default, TimeSpan.FromMilliseconds(50));
+        var ex = Assert.Throws<TimeoutException>(call);
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>Verifies that <c>WaitForCompletion</c> with a scheduler returns after terminal.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForCompletionWithSchedulerOnly_ThenReturnsAfterTerminal()
+    {
+        Observable.Return(RxVoid.Default)
+            .WaitForCompletion(TaskPoolSequencer.Default);
+
+        // Sentinel follow-up to give TUnit a real assertion.
+        var sentinel = Observable.Return(SchedulerSentinelValue).SubscribeGetValue();
+        await Assert.That(sentinel).IsEqualTo(SchedulerSentinelValue);
+    }
+
+    /// <summary>Verifies that <c>WaitForCompletion</c> with a scheduler and explicit timeout returns after terminal.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForCompletionWithSchedulerAndTimeout_ThenReturnsAfterTerminal()
+    {
+        Observable.Return(RxVoid.Default)
+            .WaitForCompletion(TaskPoolSequencer.Default, SchedulerWaitTimeout);
+
+        var sentinel = Observable.Return(SchedulerSentinelValue).SubscribeGetValue();
+        await Assert.That(sentinel).IsEqualTo(SchedulerSentinelValue);
+    }
+
+    /// <summary>Verifies that <c>WaitForError</c> with a scheduler returns null for a normal completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForErrorWithSchedulerOnly_ThenReturnsNullOnNormalCompletion()
+    {
+        var error = Observable.Return(SchedulerSentinelValue)
+            .WaitForError(TaskPoolSequencer.Default);
+
+        await Assert.That(error).IsNull();
+    }
+
+    /// <summary>Verifies that <c>WaitForError</c> with a scheduler and timeout captures the error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForErrorWithSchedulerAndTimeout_ThenCapturesError()
+    {
+        var expected = new InvalidOperationException("scheduler-captured");
+        var error = Observable.Throw<int>(expected)
+            .WaitForError(TaskPoolSequencer.Default, SchedulerWaitTimeout);
+
+        await Assert.That(error).IsEqualTo(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs
new file mode 100644
index 0000000..0e2d393
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservableSubscriptionExtensionsTests.cs
@@ -0,0 +1,247 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for the blocking subscribe helpers on <see cref="ObservableSubscriptionExtensions"/>.</summary>
+public partial class ObservableSubscriptionExtensionsTests
+{
+    /// <summary>Sentinel value emitted by single-value tests.</summary>
+    private const int SentinelValue = 7;
+
+    /// <summary>Verifies that <c>SubscribeGetValue</c> returns the last synchronously-emitted value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeGetValue_ThenReturnsLastSyncValue()
+    {
+        var result = Observable.Return(SentinelValue).SubscribeGetValue();
+
+        await Assert.That(result).IsEqualTo(SentinelValue);
+    }
+
+    /// <summary>Verifies that <c>SubscribeGetValue</c> returns the default when the sequence is empty.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeGetValueEmpty_ThenReturnsDefault()
+    {
+        var result = Observable.Empty<int>().SubscribeGetValue();
+
+        await Assert.That(result).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that <c>SubscribeAndComplete</c> consumes a RxVoid-producing observable without error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAndComplete_ThenSwallowsUnitAndReturns()
+    {
+        // Helper is fire-and-forget; verify a follow-up call on a different sequence still
+        // returns the expected value, proving SubscribeAndComplete didn't leave state behind.
+        Observable.Return(RxVoid.Default).SubscribeAndComplete();
+        var followUp = Observable.Return(RxVoid.Default).SubscribeGetValue();
+        await Assert.That(followUp).IsEqualTo(RxVoid.Default);
+    }
+
+    /// <summary>Verifies that <c>SubscribeGetError</c> captures a synchronous error and returns it.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeGetError_ThenCapturesSyncError()
+    {
+        var expected = new InvalidOperationException("sync");
+        var error = Observable.Throw<int>(expected).SubscribeGetError();
+
+        await Assert.That(error).IsEqualTo(expected);
+    }
+
+    /// <summary>Verifies that the RxVoid-overload of <c>SubscribeGetError</c> captures the error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeGetErrorUnit_ThenCapturesSyncError()
+    {
+        var expected = new InvalidOperationException("RxVoid-sync");
+        var error = Observable.Throw<RxVoid>(expected).SubscribeGetError();
+
+        await Assert.That(error).IsEqualTo(expected);
+    }
+
+    /// <summary>Verifies that <c>WaitForValue</c> blocks until the synchronously-completing source emits.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForValue_ThenReturnsEmittedValue()
+    {
+        var result = Observable.Return(SentinelValue).WaitForValue();
+
+        await Assert.That(result).IsEqualTo(SentinelValue);
+    }
+
+    /// <summary>Verifies that the timeout overload of <c>WaitForValue</c> honours an explicit deadline.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForValueWithTimeout_ThenReturnsEmittedValue()
+    {
+        var result = Observable.Return(SentinelValue).WaitForValue(TimeSpan.FromSeconds(5));
+
+        await Assert.That(result).IsEqualTo(SentinelValue);
+    }
+
+    /// <summary>Verifies that <c>WaitForValue</c> throws <see cref="TimeoutException"/> on a non-terminating source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForValueTimesOut_ThenTimeoutException()
+    {
+        Action call = () => Observable.Never<int>().WaitForValue(TimeSpan.FromMilliseconds(50));
+        var ex = Assert.Throws<TimeoutException>(call);
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>Verifies that <c>WaitForCompletion</c> returns once the RxVoid-producing source completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForCompletion_ThenReturnsAfterTerminal()
+    {
+        // Helper returns void on success; the absence of TimeoutException after a synchronous
+        // completion is the contract under test. Use the value-returning sibling for the actual
+        // assertion so TUnit has a real check.
+        Observable.Return(RxVoid.Default).WaitForCompletion(TimeSpan.FromSeconds(5));
+        var subsequent = Observable.Return(RxVoid.Default).SubscribeGetValue();
+        await Assert.That(subsequent).IsEqualTo(RxVoid.Default);
+    }
+
+    /// <summary>Verifies that <c>WaitForCompletion</c> rethrows the source's error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForCompletionWithError_ThenRethrows()
+    {
+        var expected = new InvalidOperationException("wait");
+        Action call = () => Observable.Throw<RxVoid>(expected).WaitForCompletion(TimeSpan.FromSeconds(5));
+        var ex = Assert.Throws<InvalidOperationException>(call);
+        await Assert.That(ex).IsEqualTo(expected);
+    }
+
+    /// <summary>Verifies that <c>WaitForCompletion</c> throws <see cref="TimeoutException"/> for a non-terminating source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForCompletionTimesOut_ThenTimeoutException()
+    {
+        Action call = () => Observable.Never<RxVoid>().WaitForCompletion(TimeSpan.FromMilliseconds(50));
+        var ex = Assert.Throws<TimeoutException>(call);
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>Verifies that <c>WaitForError</c> returns null when the source completes normally.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForErrorNormalCompletion_ThenReturnsNull()
+    {
+        var error = Observable.Return(SentinelValue).WaitForError(TimeSpan.FromSeconds(5));
+
+        await Assert.That(error).IsNull();
+    }
+
+    /// <summary>Verifies the default <c>WaitForError</c> overload returns null on normal completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForErrorDefaultNormalCompletion_ThenReturnsNull()
+    {
+        var error = Observable.Return(SentinelValue).WaitForError();
+
+        await Assert.That(error).IsNull();
+    }
+
+    /// <summary>Verifies that <c>WaitForError</c> returns the captured error rather than rethrowing.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForErrorSourceErrors_ThenReturnsCapturedError()
+    {
+        var expected = new InvalidOperationException("captured");
+        var error = Observable.Throw<int>(expected).WaitForError(TimeSpan.FromSeconds(5));
+
+        await Assert.That(error).IsEqualTo(expected);
+    }
+
+    /// <summary>Verifies the default <c>WaitForError</c> overload returns the captured source error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForErrorDefaultSourceErrors_ThenReturnsCapturedError()
+    {
+        var expected = new InvalidOperationException("captured-default");
+        var error = Observable.Throw<int>(expected).WaitForError();
+
+        await Assert.That(error).IsEqualTo(expected);
+    }
+
+    /// <summary>Verifies that <c>WaitForError</c> throws <see cref="TimeoutException"/> for a non-terminating source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForErrorTimesOut_ThenTimeoutException()
+    {
+        Action call = () => Observable.Never<int>().WaitForError(TimeSpan.FromMilliseconds(50));
+        var ex = Assert.Throws<TimeoutException>(call);
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>Verifies the single-arg <c>WaitForCompletion(IObservable&lt;RxVoid&gt;)</c> overload —
+    /// pass-through to the scheduler-aware core with default timeout.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForCompletionUnitDefault_ThenReturnsOnCompletion()
+    {
+        var subject = new Subject<RxVoid>();
+        var pump = Task.Run(() =>
+        {
+            subject.OnNext(RxVoid.Default);
+            subject.OnCompleted();
+        });
+
+        subject.WaitForCompletion();
+        await pump;
+    }
+
+    /// <summary>Exercises the no-op <c>OnError</c> body of <c>ValueCaptureObserver</c> —
+    /// <c>SubscribeGetValue</c> on an erroring source still returns the last captured value
+    /// (default) and the error is silently swallowed by the observer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeGetValueSourceErrors_ThenErrorSwallowed()
+    {
+        var error = new InvalidOperationException("source-error");
+        var source = Observable.Throw<int>(error);
+
+        var value = source.SubscribeGetValue();
+
+        await Assert.That(value).IsEqualTo(0);
+    }
+
+    /// <summary>Exercises the no-op <c>OnNext</c> and <c>OnCompleted</c> bodies of
+    /// <c>ErrorCaptureObserver</c> — <c>SubscribeGetError</c> on a completing source ignores
+    /// the value and the completion, returning a null error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeGetErrorSourceCompletesWithValue_ThenReturnsNull()
+    {
+        IObservable<int> source = Observable.Return(SentinelValue);
+
+        var error = source.SubscribeGetError();
+
+        await Assert.That(error).IsNull();
+    }
+
+    /// <summary>Exercises the <c>OnError</c> path of <c>BlockingValueObserver</c> —
+    /// <c>WaitForValue</c> on an erroring source returns the default value once the gate
+    /// is signalled by the error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitForValueSourceErrors_ThenGateSignalledAndDefaultReturned()
+    {
+        var subject = new Subject<int>();
+        var pump = Task.Run(() => subject.OnError(new InvalidOperationException("source-error")));
+
+        var value = subject.WaitForValue();
+        await pump;
+
+        await Assert.That(value).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservablesTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservablesTests.cs
new file mode 100644
index 0000000..5e0b760
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ObservablesTests.cs
@@ -0,0 +1,24 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for the <see cref="Observables"/> factory methods.</summary>
+public class ObservablesTests
+{
+    /// <summary>Verifies <see cref="Observables.Return{T}"/> emits the single value and completes on subscribe.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenReturn_ThenEmitsValueAndCompletes()
+    {
+        const int Value = 42;
+        var values = new List<int>();
+        var completed = false;
+
+        using var sub = Observables.Return(Value).Subscribe(values.Add, () => completed = true);
+
+        await Assert.That(values).IsCollectionEqualTo([Value]);
+        await Assert.That(completed).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/BooleanReduceObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/BooleanReduceObservableTests.cs
new file mode 100644
index 0000000..c07d315
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/BooleanReduceObservableTests.cs
@@ -0,0 +1,254 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the boolean-reduce operators backed by
+/// <c>BooleanReduceObservable</c> — empty-source short-circuit, partial-value
+/// suppression, target match/mismatch, error broadcast.</summary>
+public class BooleanReduceObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Verifies that an empty input emits a single <c>true</c> and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCombineLatestValuesAreAllTrueWithEmptySources_ThenEmitsTrueAndCompletes()
+    {
+        var results = new List<bool>();
+        var completed = false;
+
+        using var sub = Array.Empty<IObservable<bool>>()
+            .CombineLatestValuesAreAllTrue()
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([true]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that partial sources do not emit until every source has a value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAllTruePartialSources_ThenSuppressesEmission()
+    {
+        var a = new Subject<bool>();
+        var b = new Subject<bool>();
+        var results = new List<bool>();
+
+        using var sub = new IObservable<bool>[] { a, b }
+            .CombineLatestValuesAreAllTrue()
+            .Subscribe(results.Add);
+
+        a.OnNext(true);
+
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that the operator emits <c>true</c> only when every latest value is <c>true</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAllTrueTransitions_ThenEmitsExpectedSequence()
+    {
+        var a = new Subject<bool>();
+        var b = new Subject<bool>();
+        var results = new List<bool>();
+
+        using var sub = new IObservable<bool>[] { a, b }
+            .CombineLatestValuesAreAllTrue()
+            .Subscribe(results.Add);
+
+        a.OnNext(true);
+        b.OnNext(false);
+        b.OnNext(true);
+        a.OnNext(false);
+
+        await Assert.That(results).IsCollectionEqualTo([false, true, false]);
+    }
+
+    /// <summary>Verifies that <c>AllFalse</c> emits <c>true</c> only when every latest value is <c>false</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAllFalseTransitions_ThenEmitsExpectedSequence()
+    {
+        var a = new Subject<bool>();
+        var b = new Subject<bool>();
+        var results = new List<bool>();
+
+        using var sub = new IObservable<bool>[] { a, b }
+            .CombineLatestValuesAreAllFalse()
+            .Subscribe(results.Add);
+
+        a.OnNext(false);
+        b.OnNext(false);
+        b.OnNext(true);
+
+        await Assert.That(results).IsCollectionEqualTo([true, false]);
+    }
+
+    /// <summary>Verifies that a source error propagates downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAllTrueSourceErrors_ThenForwardsError()
+    {
+        var a = new Subject<bool>();
+        var b = new Subject<bool>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = new IObservable<bool>[] { a, b }
+            .CombineLatestValuesAreAllTrue()
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        a.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies collection-only source materialization uses <see cref="ICollection{T}.CopyTo"/>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourcesAreCollectionOnly_ThenMaterializedByCopyTo()
+    {
+        using var a = new BehaviorSubject<bool>(true);
+        using var b = new BehaviorSubject<bool>(true);
+        var sources = new CollectionOnlySources([a.AsObservable(), b.AsObservable()]);
+        var results = new List<bool>();
+
+        using var sub = sources.CombineLatestValuesAreAllTrue().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([true]);
+    }
+
+    /// <summary>Verifies the non-collection materialization path returns the exact-size buffer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenNonCollectionSourcesExactlyFillBuffer_ThenUsesBufferDirectly()
+    {
+        using var a = new BehaviorSubject<bool>(true);
+        using var b = new BehaviorSubject<bool>(true);
+        using var c = new BehaviorSubject<bool>(true);
+        using var d = new BehaviorSubject<bool>(true);
+        var results = new List<bool>();
+
+        using var sub = Enumerate(a, b, c, d)
+            .CombineLatestValuesAreAllTrue()
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([true]);
+
+        static IEnumerable<IObservable<bool>> Enumerate(params BehaviorSubject<bool>[] subjects)
+        {
+            for (var i = 0; i < subjects.Length; i++)
+            {
+                yield return subjects[i].AsObservable();
+            }
+        }
+    }
+
+    /// <summary>Verifies non-collection materialization grows beyond the initial buffer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenNonCollectionSourcesExceedInitialBuffer_ThenGrowsBuffer()
+    {
+        using var a = new BehaviorSubject<bool>(true);
+        using var b = new BehaviorSubject<bool>(true);
+        using var c = new BehaviorSubject<bool>(true);
+        using var d = new BehaviorSubject<bool>(true);
+        using var e = new BehaviorSubject<bool>(true);
+        var results = new List<bool>();
+
+        using var sub = Enumerate(a, b, c, d, e)
+            .CombineLatestValuesAreAllTrue()
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([true]);
+
+        static IEnumerable<IObservable<bool>> Enumerate(params BehaviorSubject<bool>[] subjects)
+        {
+            for (var i = 0; i < subjects.Length; i++)
+            {
+                yield return subjects[i].AsObservable();
+            }
+        }
+    }
+
+    /// <summary>Verifies that when every source completes, the combined sequence completes via
+    /// the per-source <c>OnCompleted</c> path.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAllSourcesComplete_ThenForwardsCompletion()
+    {
+        var a = new Subject<bool>();
+        var b = new Subject<bool>();
+        var completed = false;
+        IObservable<bool>[] sources = [a, b];
+
+        using var sub = sources.CombineLatestValuesAreAllTrue().Subscribe(static _ => { }, () => completed = true);
+
+        a.OnNext(true);
+        b.OnNext(true);
+        a.OnCompleted();
+        b.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that an <c>OnNext</c> arriving after the combined sequence has terminated
+    /// is silently dropped via the <c>_state.IsDone</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextAfterTerminated_ThenDropped()
+    {
+        var a = new SyncDirectSource<bool>();
+        var b = new SyncDirectSource<bool>();
+        var results = new List<bool>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+        IObservable<bool>[] sources = [a, b];
+
+        using var sub = sources.CombineLatestValuesAreAllTrue()
+            .Subscribe(results.Add, ex => caught = ex);
+
+        a.Observer.OnError(expected);
+        b.Observer.OnNext(true);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Collection implementation that deliberately avoids <see cref="IReadOnlyList{T}"/>.</summary>
+    /// <param name="items">The source items.</param>
+    private sealed class CollectionOnlySources(IObservable<bool>[] items) : ICollection<IObservable<bool>>
+    {
+        /// <inheritdoc/>
+        public int Count => items.Length;
+
+        /// <inheritdoc/>
+        public bool IsReadOnly => true;
+
+        /// <inheritdoc/>
+        public void Add(IObservable<bool> item) => throw new NotSupportedException();
+
+        /// <inheritdoc/>
+        public void Clear() => throw new NotSupportedException();
+
+        /// <inheritdoc/>
+        public bool Contains(IObservable<bool> item) => Array.IndexOf(items, item) >= 0;
+
+        /// <inheritdoc/>
+        public void CopyTo(IObservable<bool>[] array, int arrayIndex) => Array.Copy(items, 0, array, arrayIndex, items.Length);
+
+        /// <inheritdoc/>
+        public bool Remove(IObservable<bool> item) => throw new NotSupportedException();
+
+        /// <inheritdoc/>
+        public IEnumerator<IObservable<bool>> GetEnumerator() => ((IEnumerable<IObservable<bool>>)items).GetEnumerator();
+
+        /// <inheritdoc/>
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchAndReturnWithFactoryObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchAndReturnWithFactoryObservableTests.cs
new file mode 100644
index 0000000..c3ee11e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchAndReturnWithFactoryObservableTests.cs
@@ -0,0 +1,106 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the factory overload of <c>CatchAndReturn</c>
+/// backed by <c>CatchAndReturnWithFactoryObservable&lt;T, TException&gt;</c> —
+/// matching exception path, non-matching exception passthrough, and
+/// factory-error propagation.</summary>
+public class CatchAndReturnWithFactoryObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "matching";
+
+    /// <summary>Synthetic error message attached to mismatched source errors.</summary>
+    private const string MismatchedErrorMessage = "different type";
+
+    /// <summary>Synthetic error message attached to factory failures.</summary>
+    private const string FactoryFailedMessage = "factory failed";
+
+    /// <summary>Length used to build a fallback from the captured exception message.</summary>
+    private const int FallbackBaseValue = 100;
+
+    /// <summary>Verifies that a matching exception emits a fallback from the factory and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchAndReturnMatchingException_ThenEmitsFactoryFallbackAndCompletes()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.CatchAndReturn<int, InvalidOperationException>(
+                ex => FallbackBaseValue + ex.Message.Length)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnError(expected);
+
+        await Assert.That(results).IsCollectionEqualTo([FallbackBaseValue + SourceErrorMessage.Length]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that a non-matching exception passes through to <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchAndReturnNonMatchingException_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new ArgumentException(MismatchedErrorMessage);
+
+        using var sub = subject.CatchAndReturn<int, InvalidOperationException>(
+                static _ => FallbackBaseValue)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that an exception thrown by the fallback factory replaces the original error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchAndReturnFactoryThrows_ThenForwardsFactoryError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var sourceError = new InvalidOperationException(SourceErrorMessage);
+        var factoryError = new InvalidOperationException(FactoryFailedMessage);
+
+        using var sub = subject.CatchAndReturn<int, InvalidOperationException>(
+                _ => throw factoryError)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(sourceError);
+
+        await Assert.That(caught).IsSameReferenceAs(factoryError);
+    }
+
+    /// <summary>Verifies that <c>OnNext</c> values pass through unchanged when no error occurs.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchAndReturnNoError_ThenPassesValuesThrough()
+    {
+        const int First = 1;
+        const int Second = 2;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.CatchAndReturn<int, InvalidOperationException>(
+                static _ => FallbackBaseValue)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(First);
+        subject.OnNext(Second);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([First, Second]);
+        await Assert.That(completed).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchIgnoreObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchIgnoreObservableTests.cs
new file mode 100644
index 0000000..bc4eb7e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/CatchIgnoreObservableTests.cs
@@ -0,0 +1,93 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>CatchIgnore&lt;TSource, TException&gt;</c> backed by
+/// <c>CatchIgnoreObservable&lt;TSource, TException&gt;</c> — exception filtering and the
+/// action-throws branch.</summary>
+public class CatchIgnoreObservableTests
+{
+    /// <summary>Verifies that <c>CatchIgnore</c> invokes the action and completes on a matching exception.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchIgnoreMatchesException_ThenInvokesActionAndCompletes()
+    {
+        var subject = new Subject<int>();
+        Exception? observed = null;
+        var completed = false;
+        var expected = new InvalidOperationException("caught");
+
+        using var sub = subject.CatchIgnore<int, InvalidOperationException>(ex => observed = ex)
+            .Subscribe(
+                static _ => { },
+                static _ => Assert.Fail("OnError should not run when ignored."),
+                () => completed = true);
+
+        subject.OnError(expected);
+
+        await Assert.That(observed).IsSameReferenceAs(expected);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>CatchIgnore</c> forwards non-matching exceptions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchIgnoreDoesNotMatchException_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var actionInvocations = 0;
+        var expected = new ArgumentException("not matching");
+
+        using var sub = subject.CatchIgnore<int, InvalidOperationException>(_ => actionInvocations++)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(actionInvocations).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that when the catch action itself throws, the new exception is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchIgnoreActionThrows_ThenForwardsActionException()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var fromAction = new InvalidOperationException("action failed");
+
+        using var sub = subject.CatchIgnore<int, InvalidOperationException>(_ => throw fromAction)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(new InvalidOperationException("original"));
+
+        await Assert.That(caught).IsSameReferenceAs(fromAction);
+    }
+
+    /// <summary>Verifies that values arriving before the error are forwarded unchanged.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchIgnoreSourceEmitsValues_ThenForwardedThenCompletedOnIgnoredError()
+    {
+        const int FirstValue = 1;
+        const int SecondValue = 2;
+        var subject = new Subject<int>();
+        var values = new List<int>();
+        var completed = false;
+
+        using var sub = subject.CatchIgnore<int, InvalidOperationException>(static _ => { })
+            .Subscribe(values.Add, () => completed = true);
+
+        subject.OnNext(FirstValue);
+        subject.OnNext(SecondValue);
+        subject.OnError(new InvalidOperationException("swallowed"));
+
+        await Assert.That(values).IsCollectionEqualTo([FirstValue, SecondValue]);
+        await Assert.That(completed).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs
new file mode 100644
index 0000000..460c059
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ConflateObservableTests.cs
@@ -0,0 +1,270 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Operators;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the <c>Conflate</c> operator backed by
+/// <c>ConflateObservable&lt;T&gt;</c> — source-error path through the scheduler
+/// marshaller, completion-while-throttled, fast-path interruption by a newer value,
+/// and dispose mid-drain.</summary>
+public class ConflateObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Minimum-update-period tick window for the conflate operator.</summary>
+    private const int UpdatePeriodTicks = 100;
+
+    /// <summary>Multiplier used to advance past the update period in settle assertions.</summary>
+    private const int SettleMultiplier = 2;
+
+    /// <summary>Half of the update-period window.</summary>
+    private const int HalfWindowTicks = 50;
+
+    /// <summary>Sentinel values.</summary>
+    private const int First = 1;
+
+    /// <summary>Second sentinel value.</summary>
+    private const int Second = 2;
+
+    /// <summary>Third sentinel value.</summary>
+    private const int Third = 3;
+
+    /// <summary>Verifies that a source error is forwarded through the scheduler marshaller.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenConflateSourceErrors_ThenForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.Conflate(TimeSpan.FromTicks(UpdatePeriodTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+        scheduler.AdvanceBy(UpdatePeriodTicks * SettleMultiplier);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that a newer value arriving inside the throttle window replaces the
+    /// pending scheduled emission rather than emitting both.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenConflateNewerValueDuringThrottle_ThenReplacesPending()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject.Conflate(TimeSpan.FromTicks(UpdatePeriodTicks), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(First);
+        scheduler.AdvanceBy(HalfWindowTicks);
+        subject.OnNext(Second);
+        scheduler.AdvanceBy(HalfWindowTicks);
+        subject.OnNext(Third);
+        scheduler.AdvanceBy(UpdatePeriodTicks * SettleMultiplier);
+
+        // Inside the throttle window: the first pending value is replaced by the newer one.
+        await Assert.That(results.Count).IsGreaterThanOrEqualTo(1);
+        await Assert.That(results).DoesNotContain(First);
+        await Assert.That(results).Contains(Second);
+    }
+
+    /// <summary>Verifies that completion before any throttled emission flushes through.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenConflateCompletesBeforeFirstEmission_ThenCompletes()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.Conflate(TimeSpan.FromTicks(UpdatePeriodTicks), scheduler)
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that disposing before the scheduled emission fires suppresses the value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenConflateDisposedBeforeScheduledEmission_ThenSuppressed()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        var sub = subject.Conflate(TimeSpan.FromTicks(UpdatePeriodTicks), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(First);
+        scheduler.AdvanceBy(HalfWindowTicks);
+        subject.OnNext(Second);
+        sub.Dispose();
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+
+        // Initial value may or may not have fired before disposal but no late emission must arrive.
+        var snapshot = results.Count;
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+        await Assert.That(results.Count).IsEqualTo(snapshot);
+    }
+
+    /// <summary>Verifies that an <c>OnNext</c> arriving after the source has completed is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = source.Conflate(TimeSpan.FromTicks(UpdatePeriodTicks), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        source.Observer.OnCompleted();
+        scheduler.AdvanceBy(SettleMultiplier * UpdatePeriodTicks);
+        source.Observer.OnNext(1);
+        scheduler.AdvanceBy(SettleMultiplier * UpdatePeriodTicks);
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that an <c>OnError</c> arriving after completion is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completed = false;
+
+        using var sub = source.Conflate(TimeSpan.FromTicks(UpdatePeriodTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completed = true);
+
+        source.Observer.OnCompleted();
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Verifies that a duplicate <c>OnCompleted</c> after an error is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnCompletedAfterError_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completed = false;
+        var expected = new InvalidOperationException("first");
+
+        using var sub = source.Conflate(TimeSpan.FromTicks(UpdatePeriodTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completed = true);
+
+        source.Observer.OnError(expected);
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+        source.Observer.OnCompleted();
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Verifies <see cref="ConflateObservable{T}.ConflateSink"/>'s
+    /// post-dispose <c>Enqueue</c> guard by constructing the sink directly, disposing it, and then
+    /// pushing notifications — exercising the defensive branch that is otherwise unreachable
+    /// through the front-door <c>Conflate</c> pipeline.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSinkEnqueuedAfterDispose_ThenSilentlyDropped()
+    {
+        var downstream = new RecordingObserver<int>();
+        var scheduler = new VirtualClock();
+        var sink = new ConflateObservable<int>.ConflateSink(
+            downstream,
+            TimeSpan.FromTicks(UpdatePeriodTicks),
+            scheduler);
+
+        sink.Dispose();
+        sink.OnNext(1);
+        sink.OnError(new InvalidOperationException("late"));
+        sink.OnCompleted();
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+
+        await Assert.That(downstream.Values).IsEmpty();
+        await Assert.That(downstream.Error).IsNull();
+        await Assert.That(downstream.Completed).IsFalse();
+    }
+
+    /// <summary>Verifies <see cref="ConflateObservable{T}.ConflateSink"/>'s
+    /// after-terminal guards on <c>OnNext</c>, <c>OnError</c>, and <c>OnCompleted</c> by constructing
+    /// the sink directly, terminating via <c>OnError</c>, and then pushing follow-up notifications.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSinkEventsAfterTerminated_ThenDropped()
+    {
+        var downstream = new RecordingObserver<int>();
+        var scheduler = new VirtualClock();
+        var sink = new ConflateObservable<int>.ConflateSink(
+            downstream,
+            TimeSpan.FromTicks(UpdatePeriodTicks),
+            scheduler);
+
+        var expected = new InvalidOperationException("first");
+        sink.OnError(expected);
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+
+        sink.OnNext(1);
+        sink.OnError(new InvalidOperationException("ignored"));
+        sink.OnCompleted();
+        scheduler.AdvanceBy(UpdatePeriodTicks);
+
+        await Assert.That(downstream.Error).IsSameReferenceAs(expected);
+        await Assert.That(downstream.Values).IsEmpty();
+        await Assert.That(downstream.Completed).IsFalse();
+    }
+
+    /// <summary>Recording observer used to verify direct-invocation tests of the conflate sink
+    /// and marshaller — does not race with a scheduler, so the assertion sees exactly the
+    /// notifications that were forwarded.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class RecordingObserver<T> : IObserver<T>
+    {
+        /// <summary>Gets the captured <c>OnNext</c> values in order.</summary>
+        public List<T> Values { get; } = [];
+
+        /// <summary>Gets the first captured <c>OnError</c> exception, if any.</summary>
+        public Exception? Error { get; private set; }
+
+        /// <summary>Gets a value indicating whether <c>OnCompleted</c> has been called.</summary>
+        public bool Completed { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => Values.Add(value);
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => Error ??= error;
+
+        /// <inheritdoc/>
+        public void OnCompleted() => Completed = true;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DebounceImmediateObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DebounceImmediateObservableTests.cs
new file mode 100644
index 0000000..0edc5ec
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DebounceImmediateObservableTests.cs
@@ -0,0 +1,81 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <c>DebounceImmediateObservable</c> covering the after-terminal guards
+/// on the sink that fire only when an upstream pushes events past its own completion.</summary>
+public class DebounceImmediateObservableTests
+{
+    /// <summary>Tick window for the debounce.</summary>
+    private const int DebounceTicks = 10;
+
+    /// <summary>Ticks to advance past the debounce window in settle assertions.</summary>
+    private const int SettleTicks = 100;
+
+    /// <summary>Verifies that <c>OnNext</c> after the source has completed is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completed = false;
+
+        using var sub = source.DebounceImmediate(TimeSpan.FromTicks(DebounceTicks), scheduler)
+            .Subscribe(values.Add, () => completed = true);
+
+        source.Observer.OnCompleted();
+        scheduler.AdvanceBy(SettleTicks);
+        source.Observer.OnNext(1);
+        scheduler.AdvanceBy(SettleTicks);
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>OnError</c> after the source has completed is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completed = false;
+
+        using var sub = source.DebounceImmediate(TimeSpan.FromTicks(DebounceTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completed = true);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnError(new InvalidOperationException("late"));
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Verifies that a duplicate <c>OnCompleted</c> after an error is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnCompletedAfterError_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completed = false;
+        var expected = new InvalidOperationException("first");
+
+        using var sub = source.DebounceImmediate(TimeSpan.FromTicks(DebounceTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completed = true);
+
+        source.Observer.OnError(expected);
+        source.Observer.OnCompleted();
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(completed).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs
new file mode 100644
index 0000000..22e7518
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DetectStaleObservableTests.cs
@@ -0,0 +1,54 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Disposables;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Coverage for <c>DetectStaleObservable</c>'s subscription-teardown branch — when the source
+/// terminates synchronously during subscribe, the sink is already done by the time the upstream handle
+/// is attached, so the attach disposes it instead of recording it.</summary>
+public class DetectStaleObservableTests
+{
+    /// <summary>Staleness window used by the tests.</summary>
+    private const int WindowTicks = 100;
+
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Verifies that a source erroring synchronously during subscribe forwards the error and
+    /// disposes the upstream handle through the attach-after-terminated branch.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceTerminatesDuringSubscribe_ThenLateAttachDisposesSubscription()
+    {
+        var scheduler = new VirtualClock();
+        var expected = new InvalidOperationException(SourceErrorMessage);
+        var source = new SyncErroringObservable<int>(expected);
+        Exception? caught = null;
+
+        using var sub = source.DetectStale(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(source.Subscription.IsDisposed).IsTrue();
+    }
+
+    /// <summary>Observable that synchronously errors during <c>Subscribe</c> and exposes the subscription
+    /// handle it returned so tests can assert it was disposed.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class SyncErroringObservable<T>(Exception error) : IObservable<T>
+    {
+        /// <summary>Gets the subscription handle returned from the most recent subscribe.</summary>
+        public BooleanDisposable Subscription { get; } = new();
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            observer.OnError(error);
+            return Subscription;
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DoOnDisposeObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DoOnDisposeObservableTests.cs
new file mode 100644
index 0000000..a721056
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DoOnDisposeObservableTests.cs
@@ -0,0 +1,31 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Coverage for <c>DoOnDisposeObservable</c> — the dispose action fires exactly once even when
+/// the subscription is disposed multiple times, and the upstream is torn down before the action runs.</summary>
+public class DoOnDisposeObservableTests
+{
+    /// <summary>Verifies the dispose action fires once and the upstream is detached on first dispose, and a
+    /// second dispose is a no-op via the latch.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposedTwice_ThenActionFiresOnce()
+    {
+        var executed = 0;
+        var source = new Subject<int>();
+
+        var sub = source.DoOnDispose(() => executed++).Subscribe();
+        await Assert.That(source.HasObservers).IsTrue();
+
+        sub.Dispose();
+        sub.Dispose();
+
+        await Assert.That(executed).IsEqualTo(1);
+        await Assert.That(source.HasObservers).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs
new file mode 100644
index 0000000..8b130d0
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/DropIfBusyObservableTests.cs
@@ -0,0 +1,102 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>DropIfBusyObservable&lt;T&gt;</c>.</summary>
+public class DropIfBusyObservableTests
+{
+    /// <summary>Delay used to let fire-and-forget async continuations settle.</summary>
+    private const int SettleDelayMilliseconds = 50;
+
+    /// <summary>Verifies a handler completion after source completion does not emit the value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandlerCompletesAfterSourceDone_ThenValueDropped()
+    {
+        var subject = new Subject<int>();
+        var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var values = new List<int>();
+        var completed = false;
+
+        using var sub = subject.DropIfBusy(async _ => await release.Task.ConfigureAwait(false))
+            .Subscribe(values.Add, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnCompleted();
+        release.SetResult();
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(values).IsEmpty();
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies a handler fault after source completion does not report an error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandlerThrowsAfterSourceDone_ThenErrorDropped()
+    {
+        var subject = new Subject<int>();
+        var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException("late-handler");
+        Exception? caught = null;
+        var completed = false;
+
+        using var sub = subject.DropIfBusy(async _ =>
+        {
+            await release.Task.ConfigureAwait(false);
+            throw expected;
+        }).Subscribe(static _ => { }, ex => caught = ex, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnCompleted();
+        release.SetResult();
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(caught).IsNull();
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies a source error before termination is forwarded downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceErrorsBeforeDone_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        var expected = new InvalidOperationException("source-error");
+        Exception? caught = null;
+
+        using var sub = subject.DropIfBusy(static _ => default)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies a handler fault before termination is forwarded downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHandlerThrowsBeforeDone_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException("handler");
+        Exception? caught = null;
+
+        using var sub = subject.DropIfBusy(async _ =>
+        {
+            await release.Task.ConfigureAwait(false);
+            throw expected;
+        }).Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(1);
+        release.SetResult();
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs
new file mode 100644
index 0000000..a3bf546
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncPathTests.cs
@@ -0,0 +1,366 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Coverage for the asynchronous-projection path of
+/// <c>FirstMatchFromCandidates</c> backed by <c>FirstMatchFromCandidatesObservable</c>
+/// — empty candidate list, async-projection match, async-projection no-match falls back,
+/// async-projection error skips, and dispose during the async walk.</summary>
+public class FirstMatchFromCandidatesAsyncPathTests
+{
+    /// <summary>Fallback value emitted when no candidate matches.</summary>
+    private const string Fallback = "fallback";
+
+    /// <summary>Candidate key whose projection is an async (never-sync-completing) subject.</summary>
+    private const string AsyncKey = "async";
+
+    /// <summary>Candidate key whose projection is a synchronously-erroring observable.</summary>
+    private const string SyncErrorKey = "sync-error";
+
+    /// <summary>Candidate key whose projection is a synchronously-completing empty observable.</summary>
+    private const string SyncCompleteKey = "sync-complete";
+
+    /// <summary>Candidate key whose projection emits the match value.</summary>
+    private const string HitKey = "hit";
+
+    /// <summary>Verifies that an empty candidate list emits the fallback and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCandidatesEmpty_ThenEmitsFallbackAndCompletes()
+    {
+        var results = new List<string>();
+        var completed = false;
+
+        using var sub = Array.Empty<string>()
+            .FirstMatchFromCandidates(
+                static _ => Observable.Empty<string>(),
+                static raw => raw,
+                static value => value.Length > 0,
+                Fallback)
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([Fallback]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that an async projection whose value matches the predicate emits the
+    /// matching value and completes — exercises the <c>AsyncSink.OnNext</c> match path.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncProjectionMatches_ThenEmitsMatch()
+    {
+        string[] keys = ["miss", HitKey];
+        var emissionGate = new Subject<string>();
+        var results = new List<string>();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                key => key == HitKey ? emissionGate : Observable.Empty<string>(),
+                static raw => raw,
+                static value => value == HitKey,
+                Fallback)
+            .Subscribe(results.Add, () => completed.TrySetResult(true));
+
+        emissionGate.OnNext(HitKey);
+        emissionGate.OnCompleted();
+
+        var done = await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(done).IsTrue();
+        await Assert.That(results).IsCollectionEqualTo([HitKey]);
+    }
+
+    /// <summary>Verifies that an async projection that never matches falls through to the
+    /// fallback when its source completes — exercises the async <c>OnCompleted</c> path.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncProjectionNeverMatches_ThenFallback()
+    {
+        string[] keys = ["only"];
+        var subject = new Subject<string>();
+        var results = new List<string>();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                _ => subject,
+                static raw => raw,
+                static value => value == "match-impossible",
+                Fallback)
+            .Subscribe(results.Add, () => completed.TrySetResult(true));
+
+        subject.OnNext("nope");
+        subject.OnCompleted();
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(results).IsCollectionEqualTo([Fallback]);
+    }
+
+    /// <summary>Verifies that an async projection error is swallowed and the walk continues
+    /// to the next candidate — exercises the async <c>OnError</c> path.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncProjectionErrors_ThenSkipsToNextCandidate()
+    {
+        string[] keys = ["bad", "good"];
+        var badSubject = new Subject<string>();
+        var goodSubject = new Subject<string>();
+        var results = new List<string>();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                key => key == "bad" ? badSubject : goodSubject,
+                static raw => raw,
+                static value => value == "good",
+                Fallback)
+            .Subscribe(results.Add, () => completed.TrySetResult(true));
+
+        badSubject.OnError(new InvalidOperationException("bad failed"));
+        goodSubject.OnNext("good");
+        goodSubject.OnCompleted();
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(results).IsCollectionEqualTo(["good"]);
+    }
+
+    /// <summary>Verifies that disposing during the async walk stops further candidate processing.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposedDuringAsyncWalk_ThenStops()
+    {
+        string[] keys = ["k1", "k2"];
+        var firstSubject = new Subject<string>();
+        var results = new List<string>();
+        var completed = false;
+
+        var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                _ => firstSubject,
+                static raw => raw,
+                static _ => true,
+                Fallback)
+            .Subscribe(results.Add, () => completed = true);
+
+        sub.Dispose();
+
+        // Second dispose hits the Interlocked.Exchange null-loser branch in AsyncSink.Dispose
+        // — the first call swapped in null and disposed the previous subscription, so the
+        // second call sees null and the `?.Dispose()` no-op fires.
+        sub.Dispose();
+
+        firstSubject.OnNext("late");
+        firstSubject.OnCompleted();
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Verifies that when the synchronous transform throws for one candidate the next
+    /// candidate is tried — exercises the <c>catch { continue; }</c> path in the sync fast path.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSyncTransformThrows_ThenContinuesToNextCandidate()
+    {
+        string[] keys = ["throw", HitKey];
+        var results = new List<string>();
+        var completed = false;
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                static key => Observable.Return(key),
+                static raw => raw == "throw"
+                    ? throw new InvalidOperationException("transform-throws")
+                    : raw,
+                static value => value == HitKey,
+                Fallback)
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([HitKey]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that a candidate whose projected observable synchronously calls
+    /// <c>OnError</c> on the sink during its <c>Subscribe</c> call hits the
+    /// <c>if (_looping) return;</c> re-entrancy guard in <c>AsyncSink.OnError</c> and
+    /// proceeds to the next candidate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncCandidateProjectionSyncErrors_ThenLoopingGuardSkipsToNextCandidate()
+    {
+        string[] keys = [SyncErrorKey, HitKey];
+        var results = new List<string>();
+        var completed = false;
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                key => key == SyncErrorKey
+                    ? new SyncErroringObservable<string>(new InvalidOperationException(SyncErrorKey))
+                    : Observable.Return(key),
+                static raw => raw,
+                static value => value == HitKey,
+                Fallback)
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([HitKey]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that a candidate whose projected observable synchronously calls
+    /// <c>OnCompleted</c> on the sink during its <c>Subscribe</c> call hits the
+    /// <c>if (_looping) return;</c> re-entrancy guard in <c>AsyncSink.OnCompleted</c> and
+    /// proceeds to the next candidate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncCandidateProjectionSyncCompletes_ThenLoopingGuardSkipsToNextCandidate()
+    {
+        string[] keys = [SyncCompleteKey, HitKey];
+        var results = new List<string>();
+        var completed = false;
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                key => key == SyncCompleteKey
+                    ? new SyncCompletingObservable<string>()
+                    : Observable.Return(key),
+                static raw => raw,
+                static value => value == HitKey,
+                Fallback)
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([HitKey]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that a second async candidate emission arriving after a match has already
+    /// fired is silently dropped via the <c>_done</c> guard in <c>AsyncSink.OnNext</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncCandidateEmitsAfterMatch_ThenDroppedByDoneGuard()
+    {
+        string[] keys = [HitKey];
+        var subject = new Subject<string>();
+        var results = new List<string>();
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                _ => subject,
+                static raw => raw,
+                static value => value == HitKey,
+                Fallback)
+            .Subscribe(results.Add, () => completed.TrySetResult());
+
+        subject.OnNext(HitKey);
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        subject.OnNext("ignored-late");
+        subject.OnError(new InvalidOperationException("ignored-late"));
+        subject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([HitKey]);
+    }
+
+    /// <summary>Drives <c>AsyncSink.TryNext</c> through a candidate whose projection
+    /// synchronously errors — that path enters <c>AsyncSink.OnError</c> while <c>_looping == true</c>
+    /// (inside <c>TryNext</c>), exercising the <c>if (_looping) return;</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncSinkWalkHitsSyncErroringCandidate_ThenLoopingGuardSkipsAhead()
+    {
+        // First candidate's projection is async (never completes during Subscribe), forcing
+        // TrySyncLoop to hand off to AsyncSink. Second candidate's projection synchronously
+        // errors during AsyncSink.TryNext's loop iteration, hitting AsyncSink.OnError with
+        // _looping == true.
+        string[] keys = [AsyncKey, SyncErrorKey, HitKey];
+        var asyncSubject = new Subject<string>();
+        var results = new List<string>();
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                key => key switch
+                {
+                    AsyncKey => asyncSubject,
+                    SyncErrorKey => new SyncErroringObservable<string>(new InvalidOperationException("sync")),
+                    _ => Observable.Return(key),
+                },
+                static raw => raw,
+                static value => value == HitKey,
+                Fallback)
+            .Subscribe(results.Add, () => completed.TrySetResult());
+
+        // Complete the async subject — AsyncSink.OnCompleted runs (outside TryNext, so _looping
+        // is false), which invokes TryNext. The next iteration projects SyncErrorKey whose
+        // SyncErroringObservable.Subscribe calls observer.OnError synchronously, re-entering
+        // AsyncSink.OnError while _looping is still true — hitting the looping-guard return.
+        asyncSubject.OnCompleted();
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(results).IsCollectionEqualTo([HitKey]);
+    }
+
+    /// <summary>Same shape as the looping-error case but the intermediate candidate
+    /// synchronously completes instead of erroring, exercising
+    /// <c>AsyncSink.OnCompleted</c>'s <c>_looping</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncSinkWalkHitsSyncCompletingCandidate_ThenLoopingGuardSkipsAhead()
+    {
+        string[] keys = [AsyncKey, SyncCompleteKey, HitKey];
+        var asyncSubject = new Subject<string>();
+        var results = new List<string>();
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ((IReadOnlyList<string>)keys)
+            .FirstMatchFromCandidates(
+                key => key switch
+                {
+                    AsyncKey => asyncSubject,
+                    SyncCompleteKey => new SyncCompletingObservable<string>(),
+                    _ => Observable.Return(key),
+                },
+                static raw => raw,
+                static value => value == HitKey,
+                Fallback)
+            .Subscribe(results.Add, () => completed.TrySetResult());
+
+        asyncSubject.OnCompleted();
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(results).IsCollectionEqualTo([HitKey]);
+    }
+
+    /// <summary>Observable that synchronously calls <c>OnError</c> on the subscriber from inside
+    /// its <c>Subscribe</c> method — used to exercise the re-entrancy <c>_looping</c> guard.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="error">The exception to deliver to the subscriber.</param>
+    private sealed class SyncErroringObservable<T>(Exception error) : IObservable<T>
+    {
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            observer.OnError(error);
+            return System.Reactive.Disposables.Disposable.Empty;
+        }
+    }
+
+    /// <summary>Observable that synchronously calls <c>OnCompleted</c> on the subscriber from
+    /// inside its <c>Subscribe</c> method — used to exercise the re-entrancy <c>_looping</c>
+    /// guard.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class SyncCompletingObservable<T> : IObservable<T>
+    {
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            observer.OnCompleted();
+            return System.Reactive.Disposables.Disposable.Empty;
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncTests.cs
new file mode 100644
index 0000000..68cac2a
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/FirstMatchFromCandidatesAsyncTests.cs
@@ -0,0 +1,188 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests covering the async-sink path of
+/// <c>FirstMatchFromCandidates</c> (when projections do not complete synchronously)
+/// and edge cases not exercised by the sync fast-path tests.</summary>
+public class FirstMatchFromCandidatesAsyncTests
+{
+    /// <summary>Fallback value emitted when no candidate satisfies the predicate.</summary>
+    private const string Fallback = "fallback";
+
+    /// <summary>Sentinel raw value used by tests that drive an async projection to a matching emission.</summary>
+    private const string MatchRaw = "match";
+
+    /// <summary>Verifies that the empty-candidate fast path emits the fallback and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCandidatesEmpty_ThenEmitsFallback()
+    {
+        var results = new List<string>();
+        var completed = false;
+
+        using var sub = Array.Empty<string>().FirstMatchFromCandidates(
+            static _ => Observable.Empty<string>(),
+            static raw => raw,
+            static _ => true,
+            Fallback).Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([Fallback]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that when the projection is asynchronous and emits a matching value,
+    /// the downstream receives that transformed value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncProjectionEmitsMatch_ThenEmitsTransformedValue()
+    {
+        using var s = new Subject<string>();
+        var results = new List<string>();
+        var keys = new[] { "k" };
+
+        using var sub = keys.FirstMatchFromCandidates(
+            _ => s,
+            static raw => raw.ToUpperInvariant(),
+            static transformed => transformed.StartsWith('M'),
+            Fallback).Subscribe(results.Add);
+
+        s.OnNext("match");
+
+        await Assert.That(results).IsCollectionEqualTo(["MATCH"]);
+    }
+
+    /// <summary>Verifies that when every async projection completes without a match the fallback is emitted.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncProjectionsCompleteWithoutMatch_ThenEmitsFallback()
+    {
+        var s1 = new Subject<string>();
+        var s2 = new Subject<string>();
+        var subjects = new[] { s1, s2 };
+        var results = new List<string>();
+        var completed = false;
+        var keys = new[] { 0, 1 };
+
+        using var sub = keys.FirstMatchFromCandidates(
+            i => subjects[i],
+            static raw => raw,
+            static _ => false,
+            Fallback).Subscribe(results.Add, () => completed = true);
+
+        s1.OnCompleted();
+        s2.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([Fallback]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that an async projection's error skips the candidate and the next is tried.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncProjectionErrors_ThenSkipsAndContinues()
+    {
+        var s1 = new Subject<string>();
+        var s2 = new Subject<string>();
+        var subjects = new[] { s1, s2 };
+        var results = new List<string>();
+        var keys = new[] { 0, 1 };
+
+        using var sub = keys.FirstMatchFromCandidates(
+            i => subjects[i],
+            static raw => raw,
+            static raw => raw == MatchRaw,
+            Fallback).Subscribe(results.Add);
+
+        s1.OnError(new InvalidOperationException("ignored"));
+        s2.OnNext(MatchRaw);
+
+        await Assert.That(results).IsCollectionEqualTo([MatchRaw]);
+    }
+
+    /// <summary>Verifies that when the transform throws on the async path the candidate is skipped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncTransformThrows_ThenValueIsIgnoredAndPipelineContinues()
+    {
+        using var s = new Subject<string>();
+        var results = new List<string>();
+        var keys = new[] { "k" };
+
+        using var sub = keys.FirstMatchFromCandidates(
+            _ => s,
+            static raw =>
+            {
+                if (raw == "bad")
+                {
+                    throw new InvalidOperationException("transform failed");
+                }
+
+                return raw.ToUpperInvariant();
+            },
+            static t => t.StartsWith('G'),
+            Fallback).Subscribe(results.Add);
+
+        s.OnNext("bad");
+        s.OnNext("good");
+
+        await Assert.That(results).IsCollectionEqualTo(["GOOD"]);
+    }
+
+    /// <summary>Verifies that disposing the async sink before the projection emits prevents any
+    /// downstream notifications.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncSinkDisposedBeforeEmission_ThenNoDownstreamNotifications()
+    {
+        using var s = new Subject<string>();
+        var results = new List<string>();
+        var completed = false;
+        var keys = new[] { "k" };
+
+        var sub = keys.FirstMatchFromCandidates(
+            _ => s,
+            static raw => raw,
+            static _ => true,
+            Fallback).Subscribe(results.Add, () => completed = true);
+
+        sub.Dispose();
+        s.OnNext("ignored");
+        s.OnCompleted();
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Verifies that a thrown projection on the async path is skipped and the loop continues
+    /// to the next candidate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsyncProjectionFactoryThrows_ThenSkipsAndContinues()
+    {
+        using var asyncFirst = new Subject<string>();
+        var results = new List<string>();
+        var keys = new[] { "async-open", "throw-key", "match" };
+
+        using var sub = keys.FirstMatchFromCandidates(
+            key => key switch
+            {
+                "async-open" => asyncFirst,
+                "throw-key" => throw new InvalidOperationException("project failed"),
+                _ => Observable.Return(key),
+            },
+            static raw => raw.ToUpperInvariant(),
+            static t => t == "MATCH",
+            Fallback).Subscribe(results.Add);
+
+        // Trigger async sink: complete the first projection so AsyncSink.TryNext walks the rest.
+        asyncFirst.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo(["MATCH"]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs
new file mode 100644
index 0000000..cbb5037
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ForEachObservableTests.cs
@@ -0,0 +1,90 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Extensions.Operators;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <see cref="ForEachObservable{T}"/> — null-batch ignore semantics, the
+/// scheduler-marshalled delivery path, error forwarding, and the null-observer subscribe guard.</summary>
+public class ForEachObservableTests
+{
+    /// <summary>Sentinel batch element.</summary>
+    private const int ValueOne = 1;
+
+    /// <summary>Sentinel batch element.</summary>
+    private const int ValueTwo = 2;
+
+    /// <summary>Sentinel batch element.</summary>
+    private const int ValueThree = 3;
+
+    /// <summary>Scheduler-delivered sentinel.</summary>
+    private const int ScheduledTen = 10;
+
+    /// <summary>Scheduler-delivered sentinel.</summary>
+    private const int ScheduledTwenty = 20;
+
+    /// <summary>Scheduler-delivered sentinel.</summary>
+    private const int ScheduledThirty = 30;
+
+    /// <summary>Verifies that a null inner enumerable is ignored and subsequent batches continue flowing.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenForEachReceivesNullBatch_ThenIgnoresNullAndProcessesNext()
+    {
+        var subject = new Subject<IEnumerable<int>>();
+        var results = new List<int>();
+        using var sub = subject.ForEach().Subscribe(results.Add);
+
+        subject.OnNext(null!);
+        subject.OnNext([ValueOne, ValueTwo]);
+        subject.OnNext([ValueThree]);
+
+        await Assert.That(results).IsCollectionEqualTo([ValueOne, ValueTwo, ValueThree]);
+    }
+
+    /// <summary>Verifies the scheduler overload delivers every value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenForEachWithScheduler_ThenDeliversAllValues()
+    {
+        IEnumerable<int>[] batches = [[ScheduledTen, ScheduledTwenty], [ScheduledThirty]];
+        var source = batches.ToObservable();
+        var done = new TaskCompletionSource<List<int>>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var results = new List<int>();
+
+        using var sub = source.ForEach(Sequencer.Default).Subscribe(
+            results.Add,
+            () => done.TrySetResult(results));
+
+        var output = await done.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(output).IsCollectionEqualTo([ScheduledTen, ScheduledTwenty, ScheduledThirty]);
+    }
+
+    /// <summary>Verifies source errors are forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenForEachSourceErrors_ThenErrorForwarded()
+    {
+        var subject = new Subject<IEnumerable<int>>();
+        Exception? caught = null;
+        using var sub = subject.ForEach().Subscribe(static _ => { }, ex => caught = ex);
+        var expected = new InvalidOperationException("boom");
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies subscribing with a null observer throws.</summary>
+    [Test]
+    public void WhenForEachObserverNull_ThenSubscribeThrows()
+    {
+        var observable = new ForEachObservable<int>(new Subject<IEnumerable<int>>(), null);
+
+        Assert.Throws<ArgumentNullException>(() => observable.Subscribe(null!));
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs
new file mode 100644
index 0000000..4b31cd1
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/HeartbeatObservableTests.cs
@@ -0,0 +1,148 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>Heartbeat</c> backed by
+/// <c>HeartbeatObservable&lt;T&gt;</c> — heartbeat-on-quiet, error/completion
+/// forwarding, and post-terminal timer suppression.</summary>
+public class HeartbeatObservableTests
+{
+    /// <summary>Heartbeat period for the scheduler-driven tests.</summary>
+    private const int HeartbeatTicks = 100;
+
+    /// <summary>Tick advance large enough to fire several heartbeats.</summary>
+    private const int LargeAdvanceTicks = 500;
+
+    /// <summary>Message attached to synthetic source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Verifies that the heartbeat scheduler injects heartbeats when the source is quiet.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHeartbeatSourceQuiet_ThenEmitsHeartbeats()
+    {
+        const int ModestAdvanceTicks = 350;
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var heartbeats = 0;
+
+        using var sub = subject.Heartbeat(TimeSpan.FromTicks(HeartbeatTicks), scheduler)
+            .Subscribe(hb => heartbeats += hb.IsHeartbeat ? 1 : 0);
+
+        scheduler.AdvanceBy(ModestAdvanceTicks);
+
+        await Assert.That(heartbeats).IsGreaterThanOrEqualTo(1);
+    }
+
+    /// <summary>Verifies that <c>Heartbeat</c> forwards source errors and stops the timer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHeartbeatSourceErrors_ThenForwardsErrorAndStopsTimer()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var postErrorHeartbeats = 0;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.Heartbeat(TimeSpan.FromTicks(HeartbeatTicks), scheduler)
+            .Subscribe(
+                hb => postErrorHeartbeats += hb.IsHeartbeat && caught is not null ? 1 : 0,
+                ex => caught = ex);
+
+        subject.OnError(expected);
+        scheduler.AdvanceBy(LargeAdvanceTicks);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(postErrorHeartbeats).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that <c>Heartbeat</c> forwards completion and stops the timer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHeartbeatSourceCompletes_ThenForwardsCompletionAndStopsTimer()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var completed = false;
+        var postCompletionHeartbeats = 0;
+
+        using var sub = subject.Heartbeat(TimeSpan.FromTicks(HeartbeatTicks), scheduler)
+            .Subscribe(
+                hb => postCompletionHeartbeats += hb.IsHeartbeat && completed ? 1 : 0,
+                () => completed = true);
+
+        subject.OnCompleted();
+        scheduler.AdvanceBy(LargeAdvanceTicks);
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(postCompletionHeartbeats).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that a source emission wraps the value as a non-heartbeat update.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHeartbeatSourceEmits_ThenForwardsValueUpdate()
+    {
+        const int Value = 42;
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var updates = new List<int>();
+
+        using var sub = subject.Heartbeat(TimeSpan.FromTicks(HeartbeatTicks), scheduler)
+            .Subscribe(hb =>
+            {
+                if (hb.IsHeartbeat)
+                {
+                    return;
+                }
+
+                updates.Add(hb.Update);
+            });
+
+        subject.OnNext(Value);
+
+        await Assert.That(updates).IsCollectionEqualTo([Value]);
+    }
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving after the source has already completed are silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.Heartbeat(TimeSpan.FromTicks(HeartbeatTicks), scheduler)
+            .Subscribe(
+                hb =>
+                {
+                    if (hb.IsHeartbeat)
+                    {
+                        return;
+                    }
+
+                    values.Add(hb.Update);
+                },
+                ex => caught = ex,
+                () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/LogErrorsObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/LogErrorsObservableTests.cs
new file mode 100644
index 0000000..94d8cf3
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/LogErrorsObservableTests.cs
@@ -0,0 +1,63 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <see cref="LogErrorsObservable{T}"/> — verifies the logger is tapped on
+/// the error path, never on the success path, and that the null-observer subscribe guard fires.</summary>
+public class LogErrorsObservableTests
+{
+    /// <summary>Sentinel value flowing through the success path.</summary>
+    private const int Sentinel = 1;
+
+    /// <summary>Verifies the logger is invoked with the source error and the error is forwarded downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLogErrorsSourceErrors_ThenLoggerInvokedAndErrorForwarded()
+    {
+        var subject = new Subject<int>();
+        Exception? logged = null;
+        Exception? caught = null;
+        var values = new List<int>();
+        var expected = new InvalidOperationException("logged");
+
+        using var sub = subject.LogErrors(ex => logged = ex).Subscribe(values.Add, ex => caught = ex);
+
+        subject.OnNext(Sentinel);
+        subject.OnError(expected);
+
+        await Assert.That(values).IsCollectionEqualTo([Sentinel]);
+        await Assert.That(logged).IsSameReferenceAs(expected);
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies completion is forwarded without invoking the logger.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLogErrorsSourceCompletes_ThenLoggerNotInvoked()
+    {
+        var subject = new Subject<int>();
+        var logged = 0;
+        var completed = false;
+
+        using var sub = subject.LogErrors(_ => logged++).Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(logged).IsEqualTo(0);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies subscribing with a null observer throws.</summary>
+    [Test]
+    public void WhenLogErrorsObserverNull_ThenSubscribeThrows()
+    {
+        var observable = new LogErrorsObservable<int>(new Subject<int>(), static _ => { });
+
+        Assert.Throws<ArgumentNullException>(() => observable.Subscribe(null!));
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs
new file mode 100644
index 0000000..86665f1
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/MinMaxObservableTests.cs
@@ -0,0 +1,179 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the <c>GetMin</c> / <c>GetMax</c> operators
+/// backed by <c>MinMaxObservable&lt;T&gt;</c> — partial-source suppression,
+/// max/min selection over multiple updates, and source-error propagation.</summary>
+public class MinMaxObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Sentinel value for the first source.</summary>
+    private const int LowValue = 1;
+
+    /// <summary>Sentinel value for the second source (initial).</summary>
+    private const int MidValue = 5;
+
+    /// <summary>Sentinel value used as an update to the second source.</summary>
+    private const int HighValue = 10;
+
+    /// <summary>Verifies that <c>GetMax</c> emits the largest of the latest values from every source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenGetMaxTwoSources_ThenEmitsMaxAcrossUpdates()
+    {
+        var a = new Subject<int>();
+        var b = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = a.GetMax(b).Subscribe(results.Add);
+
+        a.OnNext(LowValue);
+        b.OnNext(MidValue);
+        b.OnNext(HighValue);
+        a.OnNext(MidValue);
+
+        await Assert.That(results).IsCollectionEqualTo([MidValue, HighValue, HighValue]);
+    }
+
+    /// <summary>Verifies that <c>GetMin</c> emits the smallest of the latest values from every source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenGetMinTwoSources_ThenEmitsMinAcrossUpdates()
+    {
+        var a = new Subject<int>();
+        var b = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = a.GetMin(b).Subscribe(results.Add);
+
+        a.OnNext(HighValue);
+        b.OnNext(MidValue);
+        a.OnNext(LowValue);
+
+        await Assert.That(results).IsCollectionEqualTo([MidValue, LowValue]);
+    }
+
+    /// <summary>Verifies that partial sources do not emit until every source has a value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenGetMaxPartialSources_ThenSuppressesEmission()
+    {
+        var a = new Subject<int>();
+        var b = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = a.GetMax(b).Subscribe(results.Add);
+
+        a.OnNext(LowValue);
+
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that a source error propagates downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenGetMaxSourceErrors_ThenForwardsError()
+    {
+        var a = new Subject<int>();
+        var b = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = a.GetMax(b).Subscribe(static _ => { }, ex => caught = ex);
+
+        a.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>GetMax</c> with no additional sources still emits the source's own values verbatim.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenGetMaxSingleSource_ThenEmitsSourceValues()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        using var sub = subject.GetMax().Subscribe(results.Add);
+
+        subject.OnNext(LowValue);
+        subject.OnNext(MidValue);
+        subject.OnNext(HighValue);
+
+        await Assert.That(results).IsCollectionEqualTo([LowValue, MidValue, HighValue]);
+    }
+
+    /// <summary>Verifies that <see cref="MinMaxObservable{T}"/>
+    /// with an empty source list completes immediately without emitting.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMinMaxObservableNoSources_ThenCompletesImmediately()
+    {
+        var observable = new MinMaxObservable<int>([], emitMaximum: true);
+        var completed = false;
+        var emitted = 0;
+
+        using var sub = observable.Subscribe(_ => emitted++, () => completed = true);
+
+        await Assert.That(emitted).IsEqualTo(0);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <see cref="MinMaxObservable{T}"/>
+    /// throws when subscribed with a null observer.</summary>
+    [Test]
+    public void WhenMinMaxObservableNullObserver_ThenSubscribeThrows()
+    {
+        var observable = new MinMaxObservable<int>([new Subject<int>()], emitMaximum: false);
+
+        Assert.Throws<ArgumentNullException>(() => observable.Subscribe(null!));
+    }
+
+    /// <summary>Verifies that when every source completes, the combined sequence completes via
+    /// the per-source <c>OnCompleted</c> path.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAllSourcesComplete_ThenForwardsCompletion()
+    {
+        var a = new Subject<int>();
+        var b = new Subject<int>();
+        var completed = false;
+
+        using var sub = a.GetMax(b).Subscribe(static _ => { }, () => completed = true);
+
+        a.OnNext(LowValue);
+        b.OnNext(MidValue);
+        a.OnCompleted();
+        b.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that an <c>OnNext</c> arriving after the combined sequence has terminated
+    /// is silently dropped via the <c>_state.IsDone</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextAfterTerminated_ThenDropped()
+    {
+        var a = new SyncDirectSource<int>();
+        var b = new SyncDirectSource<int>();
+        var results = new List<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = a.GetMax(b).Subscribe(results.Add, ex => caught = ex);
+
+        a.Observer.OnError(expected);
+        b.Observer.OnNext(HighValue);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(results).IsEmpty();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/NotObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/NotObservableTests.cs
new file mode 100644
index 0000000..fde8686
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/NotObservableTests.cs
@@ -0,0 +1,55 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <see cref="NotObservable"/> — boolean negation, terminal forwarding,
+/// and the null-observer subscribe guard.</summary>
+public class NotObservableTests
+{
+    /// <summary>Verifies values are negated and completion is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenNotSourceEmitsAndCompletes_ThenValuesNegatedAndCompletes()
+    {
+        var subject = new Subject<bool>();
+        var values = new List<bool>();
+        var completed = false;
+        using var sub = subject.Not().Subscribe(values.Add, () => completed = true);
+
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnCompleted();
+
+        await Assert.That(values).IsCollectionEqualTo([false, true]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies source errors are forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenNotSourceErrors_ThenErrorForwarded()
+    {
+        var subject = new Subject<bool>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("boom");
+        using var sub = subject.Not().Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies subscribing with a null observer throws.</summary>
+    [Test]
+    public void WhenNotObserverNull_ThenSubscribeThrows()
+    {
+        var observable = new NotObservable(new Subject<bool>());
+
+        Assert.Throws<ArgumentNullException>(() => observable.Subscribe(null!));
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs
new file mode 100644
index 0000000..e17ae9b
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnIfObservableTests.cs
@@ -0,0 +1,234 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the reactive-condition <c>ObserveOnIf</c> overload
+/// backed by <c>ObserveOnIfObservable&lt;T&gt;</c> — condition switching, error forwarding,
+/// and completion forwarding.</summary>
+public class ObserveOnIfObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Verifies that values dispatch on the false-scheduler before any condition arrives.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfNoCondition_ThenUsesFalseScheduler()
+    {
+        const int Value = 11;
+        var source = new Subject<int>();
+        var condition = new Subject<bool>();
+        var trueScheduler = new RecordingScheduler();
+        var falseScheduler = new RecordingScheduler();
+        var emitted = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = source.ObserveOnIf(condition, trueScheduler, falseScheduler)
+            .Subscribe(v => emitted.TrySetResult(v));
+
+        source.OnNext(Value);
+
+        var v2 = await emitted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(v2).IsEqualTo(Value);
+        await Assert.That(falseScheduler.ScheduleCount).IsGreaterThanOrEqualTo(1);
+        await Assert.That(trueScheduler.ScheduleCount).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that emitting after the condition becomes true dispatches on the true-scheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfConditionTrue_ThenUsesTrueScheduler()
+    {
+        const int Value = 22;
+        var source = new Subject<int>();
+        var condition = new Subject<bool>();
+        var trueScheduler = new RecordingScheduler();
+        var falseScheduler = new RecordingScheduler();
+        var emitted = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = source.ObserveOnIf(condition, trueScheduler, falseScheduler)
+            .Subscribe(v => emitted.TrySetResult(v));
+
+        condition.OnNext(true);
+        source.OnNext(Value);
+
+        var v2 = await emitted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(v2).IsEqualTo(Value);
+        await Assert.That(trueScheduler.ScheduleCount).IsGreaterThanOrEqualTo(1);
+    }
+
+    /// <summary>Verifies that <c>ObserveOnIf</c> forwards source errors without scheduler dispatch.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfSourceErrors_ThenForwardsError()
+    {
+        var source = new Subject<int>();
+        var condition = new Subject<bool>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = source.ObserveOnIf(condition, TaskPoolSequencer.Default, Sequencer.Immediate)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        source.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>ObserveOnIf</c> forwards source completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfSourceCompletes_ThenForwardsCompletion()
+    {
+        var source = new Subject<int>();
+        var condition = new Subject<bool>();
+        var completed = false;
+
+        using var sub = source.ObserveOnIf(condition, TaskPoolSequencer.Default, Sequencer.Immediate)
+            .Subscribe(static _ => { }, () => completed = true);
+
+        source.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that the single-scheduler overload defaults the false branch to
+    /// <see cref="Sequencer.Immediate"/> by emitting synchronously when the condition is false.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfSingleSchedulerConditionFalse_ThenImmediate()
+    {
+        const int Value = 33;
+        var source = new Subject<int>();
+        var condition = new Subject<bool>();
+        var trueScheduler = new RecordingScheduler();
+        var results = new List<int>();
+
+        using var sub = source.ObserveOnIf(condition, trueScheduler)
+            .Subscribe(results.Add);
+
+        condition.OnNext(false);
+        source.OnNext(Value);
+
+        await Assert.That(results).IsCollectionEqualTo([Value]);
+        await Assert.That(trueScheduler.ScheduleCount).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that an <c>OnNext</c> arriving after the source has completed is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextAfterCompleted_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var condition = new Subject<bool>();
+        var trueScheduler = Sequencer.Immediate;
+        var falseScheduler = Sequencer.Immediate;
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.ObserveOnIf(condition, trueScheduler, falseScheduler)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Exercises the <c>_done</c> guard inside the scheduled callback —
+    /// when the source completes between <c>OnNext</c>'s schedule call and the scheduler firing
+    /// the queued callback, the callback observes <c>_done == true</c> and returns without
+    /// forwarding to downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduledCallbackFiresAfterSourceCompleted_ThenDroppedByDoneGuard()
+    {
+        var source = new SyncDirectSource<int>();
+        var condition = new Subject<bool>();
+        var scheduler = new VirtualClock();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.ObserveOnIf(condition, scheduler, scheduler)
+            .Subscribe(values.Add, () => completedCount++);
+
+        // First emission queues the forward-to-downstream callback on the VirtualClock.
+        source.Observer.OnNext(1);
+
+        // Source completes synchronously, flipping _done = true before the queued callback runs.
+        source.Observer.OnCompleted();
+
+        // Advance the scheduler so the queued callback fires; it observes _done == true and
+        // returns at the in-callback guard rather than calling downstream.OnNext.
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies the condition observer's duplicate-value short-circuit — emitting the
+    /// same condition value twice in a row hits the <c>_hasCondition &amp;&amp; _lastCondition == c</c>
+    /// guard and returns silently without re-assigning the current scheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfConditionDuplicate_ThenSilentlyShortCircuits()
+    {
+        var source = new Subject<int>();
+        var condition = new Subject<bool>();
+        var trueScheduler = new RecordingScheduler();
+        var falseScheduler = new RecordingScheduler();
+        var values = new List<int>();
+
+        using var sub = source.ObserveOnIf(condition, trueScheduler, falseScheduler)
+            .Subscribe(values.Add);
+
+        // First emission seeds the gate (_hasCondition transitions from false to true).
+        condition.OnNext(true);
+
+        // Second identical emission hits the duplicate-value guard and returns early.
+        condition.OnNext(true);
+
+        source.OnNext(1);
+
+        // Sanity: subsequent value still routes through the true-scheduler (the duplicate did
+        // not corrupt the captured state).
+        await Assert.That(values.Count).IsLessThanOrEqualTo(1);
+    }
+
+    /// <summary>Sequencer that delegates to the default thread-pool sequencer but records each scheduled work item.</summary>
+    private sealed class RecordingScheduler : ISequencer
+    {
+        /// <summary>Backing scheduler used to actually dispatch work.</summary>
+        private readonly TaskPoolSequencer _inner = TaskPoolSequencer.Default;
+
+        /// <summary>Gets the number of recorded schedule calls.</summary>
+        public int ScheduleCount { get; private set; }
+
+        /// <inheritdoc/>
+        public DateTimeOffset Now => _inner.Now;
+
+        /// <inheritdoc/>
+        public long Timestamp => _inner.Timestamp;
+
+        /// <inheritdoc/>
+        public void Schedule(IWorkItem item)
+        {
+            ScheduleCount++;
+            _inner.Schedule(item);
+        }
+
+        /// <inheritdoc/>
+        public void Schedule(IWorkItem item, long dueTimestamp)
+        {
+            ScheduleCount++;
+            _inner.Schedule(item, dueTimestamp);
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs
new file mode 100644
index 0000000..1bc0b53
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ObserveOnObservableTests.cs
@@ -0,0 +1,172 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Disposables;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Coverage for <c>ObserveOnObservable</c> (reached via <c>ObserveOnSafe</c>) — the
+/// immediate-scheduler passthrough, the queue-and-drain marshaller's value / error / completion
+/// forwarding, dispose teardown, and the attach-after-terminated branch of the shared drain state.</summary>
+public class ObserveOnObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Second sentinel value (kept as a constant to satisfy the no-magic-number rule).</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Verifies the immediate scheduler is special-cased to forward straight through the source
+    /// subscription without the queue-and-drain machinery.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenImmediateScheduler_ThenForwardsDirectly()
+    {
+        var source = new Subject<int>();
+        var values = new List<int>();
+        var completed = false;
+
+        using var sub = source.ObserveOnSafe(Sequencer.Immediate)
+            .Subscribe(values.Add, () => completed = true);
+
+        source.OnNext(1);
+        source.OnNext(SecondValue);
+        source.OnCompleted();
+
+        await Assert.That(values).IsCollectionEqualTo([1, SecondValue]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies queued values are drained downstream in FIFO order on the scheduler thread.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenValuesMarshalled_ThenForwardedInOrderOnDrain()
+    {
+        var scheduler = new VirtualClock();
+        var source = new Subject<int>();
+        var values = new List<int>();
+
+        using var sub = source.ObserveOnSafe(scheduler).Subscribe(values.Add);
+
+        source.OnNext(1);
+        source.OnNext(SecondValue);
+
+        // Nothing forwarded until the scheduled drain pass runs.
+        await Assert.That(values).IsEmpty();
+
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(values).IsCollectionEqualTo([1, SecondValue]);
+    }
+
+    /// <summary>Verifies a source error is forwarded through the scheduler marshaller.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceErrors_ThenForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var source = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = source.ObserveOnSafe(scheduler).Subscribe(static _ => { }, ex => caught = ex);
+
+        source.OnError(expected);
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies source completion is forwarded through the scheduler marshaller.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceCompletes_ThenForwardsCompletion()
+    {
+        var scheduler = new VirtualClock();
+        var source = new Subject<int>();
+        var completed = false;
+
+        using var sub = source.ObserveOnSafe(scheduler).Subscribe(static _ => { }, () => completed = true);
+
+        source.OnCompleted();
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies disposing tears down the upstream subscription and stops forwarding queued values.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDisposedBeforeDrain_ThenTearsDownAndDropsQueued()
+    {
+        var scheduler = new VirtualClock();
+        var source = new Subject<int>();
+        var values = new List<int>();
+
+        var sub = source.ObserveOnSafe(scheduler).Subscribe(values.Add);
+
+        source.OnNext(1);
+        await Assert.That(source.HasObservers).IsTrue();
+
+        sub.Dispose();
+        await Assert.That(source.HasObservers).IsFalse();
+
+        scheduler.AdvanceBy(1);
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies the upstream subscription is disposed when the source terminates synchronously during
+    /// subscribe — the drain runs inline (terminating the sink) before <c>AttachSourceSubscription</c> records
+    /// the handle, so the late attach disposes it instead.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceTerminatesDuringSubscribe_ThenLateAttachDisposesSubscription()
+    {
+        var expected = new InvalidOperationException(SourceErrorMessage);
+        var source = new SyncErroringObservable<int>(expected);
+        Exception? caught = null;
+
+        using var sub = source.ObserveOnSafe(new InlineScheduler())
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(source.Subscription.IsDisposed).IsTrue();
+    }
+
+    /// <summary>Observable that synchronously errors during <c>Subscribe</c> and exposes the subscription
+    /// handle it returned so tests can assert it was disposed.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class SyncErroringObservable<T>(Exception error) : IObservable<T>
+    {
+        /// <summary>Gets the subscription handle returned from the most recent subscribe.</summary>
+        public BooleanDisposable Subscription { get; } = new();
+
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            observer.OnError(error);
+            return Subscription;
+        }
+    }
+
+    /// <summary>Scheduler that runs scheduled work synchronously on the calling thread, so a drain pass
+    /// executes inline during the schedule call. Distinct instance from <see cref="Sequencer.Immediate"/>
+    /// so the operator's immediate-scheduler passthrough does not apply.</summary>
+    private sealed class InlineScheduler : ISequencer
+    {
+        /// <inheritdoc/>
+        public DateTimeOffset Now => DateTimeOffset.MinValue;
+
+        /// <inheritdoc/>
+        public long Timestamp => Now.UtcTicks;
+
+        /// <inheritdoc/>
+        public void Schedule(IWorkItem item) => item.Execute();
+
+        /// <inheritdoc/>
+        public void Schedule(IWorkItem item, long dueTimestamp) => item.Execute();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs
new file mode 100644
index 0000000..5a5b8da
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/OperatorAfterTerminalGuardTests.cs
@@ -0,0 +1,541 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Covers the consistent <c>if (_done) return;</c> after-terminal guards on the
+/// remaining sync operators that share the pattern but lacked dedicated coverage —
+/// <c>RetryWithDelay</c>, <c>OnErrorRetry</c>, <c>TakeUntilInclusive</c>, <c>SwitchIfEmpty</c>,
+/// <c>ThrottleOnScheduler</c>, <c>BufferUntilIdle</c>, <c>ObserveOnIf</c>. Each test drives a
+/// <see cref="SyncDirectSource{T}"/> through one terminal event, then pushes additional
+/// notifications past the terminal to verify the guard silently drops them.</summary>
+public class OperatorAfterTerminalGuardTests
+{
+    /// <summary>Settle window used to let scheduler-marshalled tests fire any racing emission.</summary>
+    private const int SettleDelayMilliseconds = 50;
+
+    /// <summary>Tick window for fast-scheduler tests.</summary>
+    private const int TickWindow = 100;
+
+    /// <summary>Multiplier used to advance past the tick window in settle assertions.</summary>
+    private const int SettleMultiplier = 2;
+
+    /// <summary>Second sentinel value used in after-terminal pushes.</summary>
+    private const int SecondValue = 2;
+
+    /// <summary>Verifies <c>OnErrorRetry</c>'s sink silently drops events after a downstream
+    /// completion has set the <c>_disposed</c> latch — and that a second dispose hits the
+    /// <c>Interlocked.Exchange != 0</c> idempotency guard in <see cref="IDisposable.Dispose"/>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryForeverEventsAfterDispose_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completed = false;
+
+        var sub = source.OnErrorRetry().Subscribe(values.Add, () => completed = true);
+        source.Observer.OnCompleted();
+
+        // First dispose latches _disposed in the retry sink.
+        sub.Dispose();
+
+        // Second dispose exercises the Interlocked.Exchange idempotency guard.
+        sub.Dispose();
+
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>RetryWithDelay</c>'s sink silently drops a source error
+    /// arriving after dispose — exercises the <c>if (_disposed) return;</c> guard in OnError.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithDelaySourceErrorAfterDispose_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+
+        var sub = source.RetryForeverWithDelay(TimeSpan.FromMilliseconds(SettleDelayMilliseconds))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        sub.Dispose();
+        source.Observer.OnError(new InvalidOperationException("after-dispose"));
+
+        // The sink's _disposed guard short-circuits, so the downstream onError handler is not invoked
+        // (no retry, no terminal forwarded).
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Exercises <c>RetryWithDelay.SubscribeToSource</c>'s <c>_disposed</c> guard —
+    /// when the source errors and schedules a delayed re-subscribe, then the subscription is
+    /// disposed before the delay elapses, the scheduled callback invokes <c>SubscribeToSource</c>
+    /// which sees <c>_disposed == true</c> and returns at the guard rather than re-subscribing.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithDelayDisposedDuringDelay_ThenSubscribeToSourceGuardSkipsRetry()
+    {
+        const int LongDelayMs = 250;
+        var subscribeCount = 0;
+        IObservable<int> source = Observable.Create<int>(o =>
+        {
+            subscribeCount++;
+            o.OnError(new InvalidOperationException("retry-after-dispose"));
+            return System.Reactive.Disposables.Disposable.Empty;
+        });
+
+        var sub = source.RetryForeverWithDelay(TimeSpan.FromMilliseconds(LongDelayMs))
+            .Subscribe(static _ => { });
+
+        // First subscribe ran; source errored synchronously and a retry has been scheduled.
+        sub.Dispose();
+
+        // Wait past the delay window so the scheduled callback fires while _disposed = true,
+        // hitting the SubscribeToSource _disposed guard rather than re-subscribing.
+        await Task.Delay(LongDelayMs + LongDelayMs);
+
+        await Assert.That(subscribeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Exercises <c>RetryWithBackoff.SubscribeToSource</c>'s <c>_disposed</c> guard —
+    /// same shape as the RetryWithDelay variant.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffDisposedDuringDelay_ThenSubscribeToSourceGuardSkipsRetry()
+    {
+        const int LongDelayMs = 250;
+        var subscribeCount = 0;
+        IObservable<int> source = Observable.Create<int>(o =>
+        {
+            subscribeCount++;
+            o.OnError(new InvalidOperationException("retry-after-dispose"));
+            return System.Reactive.Disposables.Disposable.Empty;
+        });
+
+        var sub = source.OnErrorRetry(
+                (Exception _) => { },
+                10,
+                TimeSpan.FromMilliseconds(LongDelayMs),
+                TaskPoolSequencer.Default)
+            .Subscribe(static _ => { });
+
+        sub.Dispose();
+
+        await Task.Delay(LongDelayMs + LongDelayMs);
+
+        await Assert.That(subscribeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>TakeUntilInclusive</c>'s after-terminal sink guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTakeUntilInclusiveEventsAfterTerminated_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.TakeUntil(static x => x > 0)
+            .Subscribe(values.Add, () => completedCount++);
+
+        // Predicate triggers on the first positive value, sets _done.
+        source.Observer.OnNext(1);
+        source.Observer.OnNext(SecondValue);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsCollectionEqualTo([1]);
+    }
+
+    /// <summary>Verifies <c>SwitchIfEmpty</c>'s after-terminal sink guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwitchIfEmptyEventsAfterTerminated_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var fallback = new Subject<int>();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.SwitchIfEmpty(fallback)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnNext(1);
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(SecondValue);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsCollectionEqualTo([1]);
+    }
+
+    /// <summary>Verifies <c>ThrottleOnScheduler</c>'s post-completion sink guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleOnSchedulerEventsAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.ThrottleOnScheduler(TimeSpan.FromTicks(TickWindow), scheduler)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies <c>DetectStale</c>'s post-completion <c>OnNext</c> guard — values
+    /// arriving after the upstream completed are dropped at the <c>_state.Done</c> check.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDetectStaleEventsAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var values = new List<Stale<int>>();
+        var completedCount = 0;
+
+        using var sub = source.DetectStale(TimeSpan.FromTicks(TickWindow), scheduler)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies <c>DropIfBusy</c>'s post-completion <c>OnNext</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDropIfBusyEventsAfterCompleted_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.DropIfBusy(static _ => default)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Exercises <c>WhileObservable.Iterate</c>'s <c>_disposed</c> guard — when the
+    /// downstream consumer's <c>OnNext</c> callback disposes the subscription captured via
+    /// a single-assignment slot, the post-action call back to <c>Iterate</c> sees
+    /// <c>_disposed == 1</c> and returns at the guard rather than re-entering RunActionAndContinue.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhileDownstreamDisposesInsideOnNext_ThenIterateGuardSkipsNextPredicate()
+    {
+        // The scheduler indirection lets us defer the first iteration to after Subscribe has
+        // returned (so the SingleAssignmentDisposable can capture the subscription), then run
+        // the inner iterations synchronously enough that the OnNext-side dispose hits before
+        // the second Iterate evaluates the predicate.
+        var scheduler = new VirtualClock();
+        var actionCalls = 0;
+        var sub = new SingleAssignmentDisposable();
+
+        sub.Disposable = ReactiveExtensions.While(
+                () => true,
+                () => actionCalls++,
+                scheduler)
+            .Subscribe(_ => sub.Dispose());
+
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(actionCalls).IsEqualTo(1);
+    }
+
+    /// <summary>Exercises <c>ThrottleDistinct</c>'s scheduled-emit done guard — when the source
+    /// completes between a value being received and the throttle window elapsing, the
+    /// scheduled <c>Emit</c> callback sees <c>_state.Done == true</c> and returns without
+    /// forwarding the buffered value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleDistinctSourceCompletesBeforeEmitWindow_ThenScheduledEmitDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.ThrottleDistinct(TimeSpan.FromTicks(TickWindow), scheduler)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnNext(1);
+        source.Observer.OnCompleted();
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Exercises the <c>SampleLatest</c> trigger-error post-terminal guard — when the
+    /// source has already errored (setting <c>_done = true</c>), a subsequent error on the
+    /// trigger observer hits the <c>if (_done) return;</c> guard inside the trigger's
+    /// OnError delegate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSampleLatestTriggerErrorsAfterSourceErrored_ThenDroppedByDoneGuard()
+    {
+        var source = new Subject<int>();
+        var trigger = new Subject<object>();
+        Exception? caught = null;
+        var sourceError = new InvalidOperationException("source");
+
+        using var sub = source.SampleLatest(trigger)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        source.OnError(sourceError);
+        trigger.OnError(new InvalidOperationException("trigger"));
+
+        await Assert.That(caught).IsSameReferenceAs(sourceError);
+    }
+
+    /// <summary>Verifies <c>SampleLatest</c>'s post-completion <c>Sample</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSampleLatestSampledAfterCompleted_ThenNoOp()
+    {
+        var source = new SyncDirectSource<int>();
+        var sampler = new Subject<object>();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.SampleLatest(sampler)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnNext(1);
+        source.Observer.OnCompleted();
+        sampler.OnNext(new object());
+
+        await Assert.That(completedCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>Heartbeat</c>'s post-completion <c>OnNext</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHeartbeatEventsAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var completedCount = 0;
+
+        using var sub = source.Heartbeat(TimeSpan.FromTicks(TickWindow), scheduler)
+            .Subscribe(static _ => { }, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
+
+        await Assert.That(completedCount).IsEqualTo(1);
+    }
+
+    /// <summary>Exercises <c>Heartbeat</c>'s <c>ScheduleHeartbeats</c> <c>_done</c> guard —
+    /// when the source completes synchronously during <c>source.Subscribe(sink)</c>, the sink
+    /// is marked done before <c>sink.Initialize()</c> runs, so the post-Initialize call to
+    /// <c>ScheduleHeartbeats</c> returns at the <c>_done</c> check without arming the timer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHeartbeatSourceCompletesDuringSubscribe_ThenInitializeShortCircuits()
+    {
+        var scheduler = new VirtualClock();
+        var completedCount = 0;
+
+        using var sub = Observable.Empty<int>().Heartbeat(TimeSpan.FromTicks(TickWindow), scheduler)
+            .Subscribe(static _ => { }, () => completedCount++);
+
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
+
+        await Assert.That(completedCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>DebounceUntil</c>'s post-completion sink guard — values arriving
+    /// after the upstream has already completed are dropped at the <c>_state.Done</c> check
+    /// inside <c>OnNext</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceUntilEventsAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.DebounceUntil(TimeSpan.FromTicks(TickWindow), static _ => true, scheduler)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies <c>BufferUntilIdle</c>'s post-completion sink guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilIdleEventsAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var batches = new List<IList<int>>();
+        var completedCount = 0;
+
+        using var sub = source.BufferUntilIdle(TimeSpan.FromTicks(TickWindow), scheduler)
+            .Subscribe(batches.Add, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
+
+        await Assert.That(completedCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>ObserveOnIf</c>'s post-completion sink guard on the condition observer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenObserveOnIfConditionEventsAfterCompleted_ThenDropped()
+    {
+        var source = new Subject<int>();
+        var condition = new SyncDirectSource<bool>();
+        var trueScheduler = Sequencer.Immediate;
+        var falseScheduler = Sequencer.Immediate;
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.ObserveOnIf(condition, trueScheduler, falseScheduler)
+            .Subscribe(values.Add, () => completedCount++);
+
+        // Drive the condition observer terminal, then push more events to hit the after-terminal guard.
+        condition.Observer.OnCompleted();
+        condition.Observer.OnNext(true);
+        condition.Observer.OnError(new InvalidOperationException("late"));
+        condition.Observer.OnCompleted();
+
+        // Source still works because the operator multicasts via condition.
+        source.OnNext(1);
+        source.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>RetryWithBackoff</c>'s sink silently drops a source error after dispose.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffSourceErrorAfterDispose_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+
+        var sub = source.RetryWithBackoff(maxRetries: 1, TimeSpan.FromMilliseconds(SettleDelayMilliseconds))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        sub.Dispose();
+        source.Observer.OnError(new InvalidOperationException("after-dispose"));
+
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Verifies <c>WhileObservable</c>'s after-dispose guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhileDisposedTwice_ThenSecondIsNoOp()
+    {
+        var ran = 0;
+        var condition = true;
+        var sub = ReactiveExtensions.While(
+                () =>
+                {
+                    if (!condition)
+                    {
+                        return false;
+                    }
+
+                    condition = false;
+                    return true;
+                },
+                () => Interlocked.Increment(ref ran))
+            .Subscribe(static _ => { });
+
+        sub.Dispose();
+        sub.Dispose();
+
+        await Assert.That(ran).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies <c>ScheduledSource</c>'s emit catch — when the side-effect action throws,
+    /// the exception is forwarded as <c>OnError</c> on the downstream observer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduledSourceActionThrows_ThenForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var source = new Subject<int>();
+        var expected = new InvalidOperationException("action-failed");
+        Exception? caught = null;
+
+        using var sub = source.Schedule(TimeSpan.FromTicks(TickWindow), scheduler, _ => throw expected)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        source.OnNext(1);
+        scheduler.AdvanceBy(TickWindow * SettleMultiplier);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies the <c>SubscribeSynchronous</c> sink's null-callback branches —
+    /// omitting <c>onError</c> and <c>onCompleted</c> covers the null-coalescing fast paths.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeSynchronousOmitsErrorAndCompletedCallbacks_ThenNullPathsTaken()
+    {
+        var subject = new Subject<int>();
+        var processed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SubscribeSynchronous(_ =>
+        {
+            processed.TrySetResult();
+            return default;
+        });
+
+        subject.OnNext(1);
+        await processed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        // Subject silently terminates without invoking the optional callbacks.
+        subject.OnError(new InvalidOperationException("ignored"));
+
+        var second = new Subject<int>();
+        using var sub2 = second.SubscribeSynchronous(static _ => default);
+        second.OnCompleted();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.MultiSubscriber.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.MultiSubscriber.cs
new file mode 100644
index 0000000..27c3d1d
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.MultiSubscriber.cs
@@ -0,0 +1,97 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Coverage for the multi-subscriber and idempotent-dispose paths of
+/// <c>Partition</c> backed by <c>PartitionObservable&lt;T&gt;</c> — three observers on
+/// one side, mid-array removal, and double-dispose of a side subscription.</summary>
+public partial class PartitionObservableTests
+{
+    /// <summary>Verifies that three observers on the same side each receive every matching value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThreeObserversSameSide_ThenAllReceive()
+    {
+        var subject = new Subject<int>();
+        var (evens, _) = subject.Partition(static x => x % Two == 0);
+        var a = new List<int>();
+        var b = new List<int>();
+        var c = new List<int>();
+
+        using var subA = evens.Subscribe(a.Add);
+        using var subB = evens.Subscribe(b.Add);
+        using var subC = evens.Subscribe(c.Add);
+
+        subject.OnNext(Two);
+        subject.OnNext(Four);
+
+        await Assert.That(a).IsCollectionEqualTo([Two, Four]);
+        await Assert.That(b).IsCollectionEqualTo([Two, Four]);
+        await Assert.That(c).IsCollectionEqualTo([Two, Four]);
+    }
+
+    /// <summary>Verifies that disposing the middle of three same-side observers
+    /// exercises the <c>existing.Length &gt; 2</c> shrink branch.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMiddleOfThreeDisposed_ThenOthersStillReceive()
+    {
+        var subject = new Subject<int>();
+        var (evens, _) = subject.Partition(static x => x % Two == 0);
+        var a = new List<int>();
+        var b = new List<int>();
+        var c = new List<int>();
+
+        using var subA = evens.Subscribe(a.Add);
+        var subB = evens.Subscribe(b.Add);
+        using var subC = evens.Subscribe(c.Add);
+
+        subject.OnNext(Two);
+        subB.Dispose();
+        subject.OnNext(Four);
+
+        await Assert.That(a).IsCollectionEqualTo([Two, Four]);
+        await Assert.That(b).IsCollectionEqualTo([Two]);
+        await Assert.That(c).IsCollectionEqualTo([Two, Four]);
+    }
+
+    /// <summary>Verifies that double-dispose of a partition subscription is a no-op
+    /// (idempotent Subscription.Dispose).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscriptionDisposedTwice_ThenIdempotent()
+    {
+        var subject = new Subject<int>();
+        var (evens, _) = subject.Partition(static x => x % Two == 0);
+        var values = new List<int>();
+
+        var sub = evens.Subscribe(values.Add);
+        sub.Dispose();
+        sub.Dispose();
+
+        subject.OnNext(Two);
+
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>Remove</c> ignores observers that were never added.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceCompletesAfterAllDropped_ThenSafe()
+    {
+        var subject = new Subject<int>();
+        var (evens, _) = subject.Partition(static x => x % Two == 0);
+
+        var sub = evens.Subscribe(static _ => { });
+        sub.Dispose();
+
+        // Source completion arriving after every observer has dropped must not throw.
+        subject.OnCompleted();
+
+        await Assert.That(subject.HasObservers).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.cs
new file mode 100644
index 0000000..7ca8019
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PartitionObservableTests.cs
@@ -0,0 +1,201 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>Partition</c> backed by
+/// <c>PartitionObservable&lt;T&gt;</c> — both-sides routing, single-side disposal,
+/// error broadcast, completion broadcast, and re-subscription after both sides drop.</summary>
+public partial class PartitionObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Even-modulus divisor.</summary>
+    private const int Two = 2;
+
+    /// <summary>First odd value.</summary>
+    private const int One = 1;
+
+    /// <summary>Second odd value.</summary>
+    private const int Three = 3;
+
+    /// <summary>Second even value.</summary>
+    private const int Four = 4;
+
+    /// <summary>Verifies that elements route to the correct side based on the predicate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPartitionWithBothSidesSubscribed_ThenRoutesByPredicate()
+    {
+        var subject = new Subject<int>();
+        var (evens, odds) = subject.Partition(static x => x % Two == 0);
+        var evenResults = new List<int>();
+        var oddResults = new List<int>();
+
+        using var evenSub = evens.Subscribe(evenResults.Add);
+        using var oddSub = odds.Subscribe(oddResults.Add);
+
+        subject.OnNext(One);
+        subject.OnNext(Two);
+        subject.OnNext(Three);
+        subject.OnNext(Four);
+
+        await Assert.That(evenResults).IsCollectionEqualTo([Two, Four]);
+        await Assert.That(oddResults).IsCollectionEqualTo([One, Three]);
+    }
+
+    /// <summary>Verifies that a value with no observer on its side is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPartitionOnlyOneSideSubscribed_ThenOtherSideValuesDropped()
+    {
+        var subject = new Subject<int>();
+        var (evens, _) = subject.Partition(static x => x % Two == 0);
+        var evenResults = new List<int>();
+
+        using var evenSub = evens.Subscribe(evenResults.Add);
+
+        subject.OnNext(One);
+        subject.OnNext(Two);
+
+        await Assert.That(evenResults).IsCollectionEqualTo([Two]);
+    }
+
+    /// <summary>Verifies that errors are broadcast to both sides.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPartitionSourceErrors_ThenBroadcastsToBothSides()
+    {
+        var subject = new Subject<int>();
+        var (evens, odds) = subject.Partition(static x => x % Two == 0);
+        Exception? evenError = null;
+        Exception? oddError = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var evenSub = evens.Subscribe(static _ => { }, ex => evenError = ex);
+        using var oddSub = odds.Subscribe(static _ => { }, ex => oddError = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(evenError).IsSameReferenceAs(expected);
+        await Assert.That(oddError).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that completion is broadcast to both sides.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPartitionSourceCompletes_ThenBroadcastsToBothSides()
+    {
+        var subject = new Subject<int>();
+        var (evens, odds) = subject.Partition(static x => x % Two == 0);
+        var evenCompleted = false;
+        var oddCompleted = false;
+
+        using var evenSub = evens.Subscribe(static _ => { }, () => evenCompleted = true);
+        using var oddSub = odds.Subscribe(static _ => { }, () => oddCompleted = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(evenCompleted).IsTrue();
+        await Assert.That(oddCompleted).IsTrue();
+    }
+
+    /// <summary>Verifies that disposing one side stops it from receiving further emissions
+    /// while the other side keeps receiving.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPartitionOneSideDisposed_ThenOnlyOtherSideReceives()
+    {
+        var subject = new Subject<int>();
+        var (evens, odds) = subject.Partition(static x => x % Two == 0);
+        var evenResults = new List<int>();
+        var oddResults = new List<int>();
+
+        var evenSub = evens.Subscribe(evenResults.Add);
+        using var oddSub = odds.Subscribe(oddResults.Add);
+
+        subject.OnNext(Two);
+        evenSub.Dispose();
+        subject.OnNext(Four);
+        subject.OnNext(Three);
+
+        await Assert.That(evenResults).IsCollectionEqualTo([Two]);
+        await Assert.That(oddResults).IsCollectionEqualTo([Three]);
+    }
+
+    /// <summary>Verifies that the partition can be resubscribed after all sides drop —
+    /// the source subscription is re-established.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPartitionResubscribedAfterAllSidesDropped_ThenSourceRebound()
+    {
+        var subject = new Subject<int>();
+        var (evens, _) = subject.Partition(static x => x % Two == 0);
+
+        var firstSub = evens.Subscribe(static _ => { });
+        firstSub.Dispose();
+
+        var secondResults = new List<int>();
+        using var secondSub = evens.Subscribe(secondResults.Add);
+
+        subject.OnNext(Two);
+
+        await Assert.That(secondResults).IsCollectionEqualTo([Two]);
+    }
+
+    /// <summary>Verifies the mid-array remove path on the false-side observer set — subscribes
+    /// three odd-side observers, disposes the middle one, and confirms the remaining two still
+    /// see odd values.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMiddleFalseSideObserverDisposed_ThenOthersStillReceiveValues()
+    {
+        var subject = new Subject<int>();
+        var (_, odds) = subject.Partition(static x => x % Two == 0);
+        var firstResults = new List<int>();
+        var middleResults = new List<int>();
+        var lastResults = new List<int>();
+
+        using var first = odds.Subscribe(firstResults.Add);
+        var middle = odds.Subscribe(middleResults.Add);
+        using var last = odds.Subscribe(lastResults.Add);
+
+        subject.OnNext(One);
+        middle.Dispose();
+        subject.OnNext(Three);
+
+        await Assert.That(firstResults).IsCollectionEqualTo([One, Three]);
+        await Assert.That(middleResults).IsCollectionEqualTo([One]);
+        await Assert.That(lastResults).IsCollectionEqualTo([One, Three]);
+    }
+
+    /// <summary>Verifies that disposing a subscription whose parent sink has already been torn
+    /// down (last subscriber path) is a no-op.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscriptionDisposedAfterParentSinkTornDown_ThenNoOp()
+    {
+        var subject = new Subject<int>();
+        var (evens, _) = subject.Partition(static x => x % Two == 0);
+
+        var first = evens.Subscribe(static _ => { });
+        first.Dispose();
+
+        // Subscribe again to create a fresh sink, then dispose the OLD disposable a second time
+        // (which now finds _sink == null because the prior tear-down already nulled it).
+        using var second = evens.Subscribe(static _ => { });
+        first.Dispose();
+
+        var results = new List<int>();
+        using var third = evens.Subscribe(results.Add);
+        subject.OnNext(Two);
+
+        // Third subscriber must receive the value emitted after the stale-subscription
+        // dispose, confirming the dispose was a safe no-op.
+        await Assert.That(results).IsCollectionEqualTo([Two]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PropertyChangedObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PropertyChangedObservableTests.cs
new file mode 100644
index 0000000..79fbd21
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/PropertyChangedObservableTests.cs
@@ -0,0 +1,209 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>ToPropertyObservable</c> backed by
+/// <c>PropertyChangedObservable&lt;T, TProperty&gt;</c> — initial-value emission,
+/// matching-name forwarding, unmatched-name filtering, getter-throws forwarding,
+/// and dispose detaches the handler.</summary>
+public class PropertyChangedObservableTests
+{
+    /// <summary>Initial property value.</summary>
+    private const int InitialValue = 1;
+
+    /// <summary>Updated property value.</summary>
+    private const int UpdatedValue = 42;
+
+    /// <summary>Synthetic error message attached to getter failures.</summary>
+    private const string GetterFailedMessage = "getter failed";
+
+    /// <summary>Verifies that subscribing emits the current property value immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribePropertyObservable_ThenEmitsCurrentValue()
+    {
+        var owner = new ObservableOwner { Value = InitialValue };
+        var results = new List<int>();
+
+        using var sub = owner.ToPropertyObservable(x => x.Value)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue]);
+    }
+
+    /// <summary>Verifies that matching-name property changes are forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMatchingPropertyChanges_ThenForwardsValue()
+    {
+        var owner = new ObservableOwner { Value = InitialValue };
+        var results = new List<int>();
+
+        using var sub = owner.ToPropertyObservable(x => x.Value)
+            .Subscribe(results.Add);
+
+        owner.Value = UpdatedValue;
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue, UpdatedValue]);
+    }
+
+    /// <summary>Verifies that non-matching property changes are ignored.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUnrelatedPropertyChanges_ThenIgnored()
+    {
+        var owner = new ObservableOwner { Value = InitialValue };
+        var results = new List<int>();
+
+        using var sub = owner.ToPropertyObservable(x => x.Value)
+            .Subscribe(results.Add);
+
+        owner.Other = "anything";
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue]);
+    }
+
+    /// <summary>Verifies that disposing detaches the handler and stops forwarding.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscriptionDisposed_ThenNoFurtherEmissions()
+    {
+        var owner = new ObservableOwner { Value = InitialValue };
+        var results = new List<int>();
+
+        var sub = owner.ToPropertyObservable(x => x.Value)
+            .Subscribe(results.Add);
+        sub.Dispose();
+
+        owner.Value = UpdatedValue;
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValue]);
+    }
+
+    /// <summary>Verifies that an exception thrown by the getter on a property-changed callback
+    /// is forwarded to <c>OnError</c>. The initial subscribe read succeeds; the second read (triggered
+    /// by <c>Raise</c>) throws.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenGetterThrowsOnChange_ThenForwardsError()
+    {
+        var owner = new LatchingThrowingOwner();
+        Exception? caught = null;
+
+        using var sub = owner.ToPropertyObservable(x => x.Latched)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        owner.ArmAndRaise();
+
+        await Assert.That(caught).IsTypeOf<InvalidOperationException>();
+    }
+
+    /// <summary>Exercises the <c>OnPropertyChanged</c> <c>_disposed</c> guard — fires a
+    /// PropertyChanged event for the subscribed property after the subscription has been
+    /// disposed but using an owner whose remove-handler is a no-op so the event delivery
+    /// reaches the still-bound handler, which then sees <c>_disposed != 0</c> and returns.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPropertyEventFiresAfterDispose_ThenHandlerGuardSkipsForward()
+    {
+        var owner = new RetainingObservableOwner();
+        var results = new List<int>();
+
+        var sub = owner.ToPropertyObservable(x => x.Value).Subscribe(results.Add);
+
+        sub.Dispose();
+
+        // Even after Dispose, the retaining owner still references the handler — invoking the
+        // event delivers to it, but the handler observes _disposed != 0 and returns early.
+        owner.Raise();
+
+        await Assert.That(results).IsCollectionEqualTo([0]);
+    }
+
+    /// <summary>INPC owner that retains every handler ever attached and exposes a manual
+    /// <c>Raise</c> so a test can fire the PropertyChanged event after the subscription that
+    /// added the handler has already been disposed.</summary>
+    private sealed class RetainingObservableOwner : INotifyPropertyChanged
+    {
+        /// <summary>The retained handler list.</summary>
+        private PropertyChangedEventHandler? _retained;
+
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler? PropertyChanged
+        {
+            add => _retained += value;
+            remove
+            {
+                // Intentionally a no-op so disposed subscriptions stay reachable for Raise().
+            }
+        }
+
+        /// <summary>Gets the observed property — never mutated. The body reads <c>this.GetHashCode</c>
+        /// to keep the getter instance-bound so the <c>ToPropertyObservable</c> expression tree compiler
+        /// resolves it against this instance.</summary>
+        public int Value => GetHashCode() & 0;
+
+        /// <summary>Invokes the retained handler with a <c>PropertyChanged</c> event for <see cref="Value"/>.</summary>
+        public void Raise() => _retained?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+    }
+
+    /// <summary>Test owner that fires <see cref="INotifyPropertyChanged"/> on property writes.</summary>
+    private sealed class ObservableOwner : INotifyPropertyChanged
+    {
+        /// <summary>Backing field for <see cref="Value"/>.</summary>
+        private int _value;
+
+        /// <summary>Backing field for <see cref="Other"/>.</summary>
+        private string _other = string.Empty;
+
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        /// <summary>Gets or sets the value being observed by the test.</summary>
+        public int Value
+        {
+            get => _value;
+            set
+            {
+                _value = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+            }
+        }
+
+        /// <summary>Gets or sets the unrelated property used to validate name-filtering.</summary>
+        public string Other
+        {
+            get => _other;
+            set
+            {
+                _other = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Other)));
+            }
+        }
+    }
+
+    /// <summary>Test owner whose getter succeeds on the first read but throws on subsequent reads.</summary>
+    private sealed class LatchingThrowingOwner : INotifyPropertyChanged
+    {
+        /// <summary>Failure message used by the latched getter.</summary>
+        private readonly string _message = GetterFailedMessage;
+
+        /// <summary>Set after <see cref="ArmAndRaise"/> latches the getter into throwing mode.</summary>
+        private bool _armed;
+
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        /// <summary>Gets a property that succeeds while disarmed and throws once armed.</summary>
+        public int Latched => _armed ? throw new InvalidOperationException(_message) : 0;
+
+        /// <summary>Arms the throwing behaviour and raises a change notification.</summary>
+        public void ArmAndRaise()
+        {
+            _armed = true;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Latched)));
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryAndThrottleAndFactoryOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryAndThrottleAndFactoryOperatorTests.cs
new file mode 100644
index 0000000..6178734
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryAndThrottleAndFactoryOperatorTests.cs
@@ -0,0 +1,325 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for several small synchronous operators:
+/// <c>WhereSelect</c>, <c>FromArray</c>, <c>RetryWithDelay</c>,
+/// <c>RetryForeverWithDelay</c>, <c>ThrottleOnScheduler</c>,
+/// <c>ThrottleDistinct</c> (sync), <c>SubscribeAndComplete</c> error path,
+/// <c>Schedule</c> with side-effect and transform overloads,
+/// <c>ToReadOnlyBehavior</c>, and <c>Pairwise</c> after-error path.</summary>
+public class RetryAndThrottleAndFactoryOperatorTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Window in scheduler ticks for the throttle tests.</summary>
+    private const int ThrottleWindowTicks = 100;
+
+    /// <summary>Advance past the throttle window.</summary>
+    private const int AdvancePastWindowTicks = 101;
+
+    /// <summary>First sentinel.</summary>
+    private const int Value1 = 1;
+
+    /// <summary>Second sentinel.</summary>
+    private const int Value2 = 2;
+
+    /// <summary>Third sentinel.</summary>
+    private const int Value3 = 3;
+
+    /// <summary>Multiplier used by <c>WhereSelect</c>.</summary>
+    private const int Multiplier = 10;
+
+    /// <summary>Verifies that <c>WhereSelect</c> filters by predicate and projects matching values.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereSelect_ThenFiltersThenProjects()
+    {
+        int[] inputs = [Value1, Value2, Value3];
+        var results = new List<int>();
+
+        using var sub = inputs.ToObservable()
+            .WhereSelect(static x => x % Value2 == 0, static x => x * Multiplier)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([Value2 * Multiplier]);
+    }
+
+    /// <summary>Verifies that a <c>WhereSelect</c> predicate exception forwards to <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereSelectPredicateThrows_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("predicate failed");
+
+        using var sub = subject.WhereSelect(_ => throw expected, static x => x)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(Value1);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that a <c>WhereSelect</c> selector exception forwards to <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereSelectSelectorThrows_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("selector failed");
+
+        using var sub = subject.WhereSelect<int, int>(static _ => true, _ => throw expected)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(Value1);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>WhereSelect</c> forwards source errors and completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereSelectSourceCompletes_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.WhereSelect(static _ => true, static x => x)
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>FromArray</c> with no scheduler pumps inline and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFromArrayInline_ThenPumpsAndCompletes()
+    {
+        int[] inputs = [Value1, Value2, Value3];
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = inputs.FromArray()
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo(inputs);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>FromArray</c> with a scheduler dispatches the pump via the scheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFromArrayWithScheduler_ThenPumpsViaScheduler()
+    {
+        int[] inputs = [Value1, Value2, Value3];
+        var scheduler = new VirtualClock();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = inputs.FromArray(scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsEmpty();
+
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(results).IsCollectionEqualTo(inputs);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>FromArray</c> forwards enumeration errors to <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFromArrayEnumerationThrows_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException("enumeration failed");
+
+        using var sub = BadEnumerable(expected).FromArray()
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>RetryWithDelay</c> retries the configured number of times with
+    /// a zero delay (so retries happen synchronously on the default scheduler).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithDelayAlwaysFails_ThenRetriesThenErrors()
+    {
+        const int RetryCount = 3;
+        var attempts = 0;
+        var expected = new InvalidOperationException("attempt failed");
+
+        var source = Observable.Create<int>(o =>
+        {
+            attempts++;
+            o.OnError(expected);
+            return () => { };
+        });
+
+        using var sub = source
+            .RetryWithDelay(RetryCount, _ => TimeSpan.Zero)
+            .Subscribe(static _ => { }, static _ => { });
+
+        // Initial attempt + RetryCount retries = RetryCount+1 total invocations.
+        await Assert.That(attempts).IsGreaterThan(1);
+    }
+
+    /// <summary>Verifies that <c>RetryForeverWithDelay</c> keeps retrying after failures.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryForeverWithDelay_ThenKeepsRetrying()
+    {
+        var attempts = 0;
+
+        var source = Observable.Create<int>(o =>
+        {
+            attempts++;
+            if (attempts < Value3)
+            {
+                o.OnError(new InvalidOperationException("retry"));
+            }
+            else
+            {
+                o.OnNext(Value1);
+                o.OnCompleted();
+            }
+
+            return () => { };
+        });
+
+        var results = new List<int>();
+        using var sub = source.RetryForeverWithDelay(TimeSpan.Zero).Subscribe(results.Add);
+
+        await Assert.That(attempts).IsGreaterThanOrEqualTo(Value3);
+        await Assert.That(results).IsCollectionEqualTo([Value1]);
+    }
+
+    /// <summary>Verifies that <c>ThrottleOnScheduler</c> emits the latest value after the window.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleOnScheduler_ThenEmitsLatestAfterWindow()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleWindowTicks), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(Value1);
+        subject.OnNext(Value2);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([Value2]);
+    }
+
+    /// <summary>Verifies that <c>ThrottleOnScheduler</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleOnSchedulerSourceErrors_ThenForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleWindowTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>ThrottleDistinct</c> (sync overload, no scheduler) emits distinct
+    /// values respecting the throttle window.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleDistinctSyncDefaultScheduler_ThenForwardsSourceError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.ThrottleDistinct(TimeSpan.FromTicks(ThrottleWindowTicks))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>ThrottleDistinct</c> (sync overload with scheduler) suppresses duplicates
+    /// and emits the latest after the throttle window.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleDistinctSyncWithScheduler_ThenSuppressesUpstreamDuplicates()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject.ThrottleDistinct(TimeSpan.FromTicks(ThrottleWindowTicks), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(Value1);
+        subject.OnNext(Value1);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results.Count).IsLessThanOrEqualTo(1);
+    }
+
+    /// <summary>Verifies that <c>ToReadOnlyBehavior</c> returns a paired observable / observer that
+    /// replays the initial value to new subscribers.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenToReadOnlyBehavior_ThenReplayInitial()
+    {
+        var (observable, observer) = ReactiveExtensions.ToReadOnlyBehavior(Value1);
+        var results = new List<int>();
+
+        using var sub = observable.Subscribe(results.Add);
+
+        observer.OnNext(Value2);
+
+        await Assert.That(results).IsCollectionEqualTo([Value1, Value2]);
+    }
+
+    /// <summary>Verifies that <c>SubscribeAndComplete</c> handles a RxVoid-producing source that errors,
+    /// swallowing the error silently as the contract requires.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAndCompleteSourceErrors_ThenSwallows()
+    {
+        // The NoopObserver inside SubscribeAndComplete must absorb the error without throwing.
+        var captured = new InvalidOperationException("ignored");
+        Observable.Throw<RxVoid>(captured).SubscribeAndComplete();
+
+        var followUp = Observable.Return(RxVoid.Default).SubscribeGetValue();
+        await Assert.That(followUp).IsEqualTo(RxVoid.Default);
+    }
+
+    /// <summary>An <see cref="IEnumerable{T}"/> whose <c>MoveNext</c> throws when enumerated,
+    /// used to drive the error path of <c>FromArray</c>.</summary>
+    /// <param name="error">The exception thrown when enumeration begins.</param>
+    /// <returns>An enumerable that throws.</returns>
+    private static IEnumerable<int> BadEnumerable(Exception error)
+    {
+        yield return Value1;
+        throw error;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryForeverObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryForeverObservableTests.cs
new file mode 100644
index 0000000..2f5cf4a
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RetryForeverObservableTests.cs
@@ -0,0 +1,103 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Extensions.Operators;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <see cref="RetryForeverObservable{T}"/> — exercises the resubscribe-on-error
+/// loop, the dispose-after-error short-circuit that prevents a runaway resubscribe, and the
+/// null-observer subscribe guard.</summary>
+public class RetryForeverObservableTests
+{
+    /// <summary>Sentinel for the first source emission.</summary>
+    private const int FirstAttempt = 1;
+
+    /// <summary>Sentinel for the second source emission.</summary>
+    private const int SecondAttempt = 2;
+
+    /// <summary>Number of attempts the resubscribe loop is configured to make.</summary>
+    private const int FinalAttempt = 3;
+
+    /// <summary>Verifies the resubscribe loop replays values from a fresh subscription on every error and finally forwards completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryForeverSourceErrorsThenCompletes_ThenResubscribesAndForwards()
+    {
+        var attempts = 0;
+        var values = new List<int>();
+        var completed = false;
+        var source = Observable.Create<int>(observer =>
+        {
+            var attempt = Interlocked.Increment(ref attempts);
+            observer.OnNext(attempt);
+            if (attempt < FinalAttempt)
+            {
+                observer.OnError(new InvalidOperationException("retry"));
+            }
+            else
+            {
+                observer.OnCompleted();
+            }
+
+            return System.Reactive.Disposables.Disposable.Empty;
+        });
+
+        using var sub = source.OnErrorRetry().Subscribe(values.Add, () => completed = true);
+
+        await Assert.That(values).IsCollectionEqualTo([FirstAttempt, SecondAttempt, FinalAttempt]);
+        await Assert.That(completed).IsTrue();
+        await Assert.That(attempts).IsEqualTo(FinalAttempt);
+    }
+
+    /// <summary>Verifies that disposing the subscription suppresses resubscription on a subsequent error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryForeverDisposedAfterError_ThenDoesNotResubscribe()
+    {
+        var subscribeCount = 0;
+        IObserver<int>? captured = null;
+        var source = Observable.Create<int>(observer =>
+        {
+            Interlocked.Increment(ref subscribeCount);
+            captured = observer;
+            return System.Reactive.Disposables.Disposable.Empty;
+        });
+
+        var sub = source.OnErrorRetry().Subscribe(static _ => { });
+        await Assert.That(subscribeCount).IsEqualTo(1);
+
+        sub.Dispose();
+        captured!.OnError(new InvalidOperationException("after-dispose"));
+
+        await Assert.That(subscribeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies completion after disposal is ignored.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryForeverDisposedBeforeCompletion_ThenCompletionDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var completedCount = 0;
+
+        var sub = source.OnErrorRetry().Subscribe(static _ => { }, () => completedCount++);
+
+        sub.Dispose();
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies subscribing with a null observer throws.</summary>
+    [Test]
+    public void WhenRetryForeverObserverNull_ThenSubscribeThrows()
+    {
+        var observable = new RetryForeverObservable<int>(new Subject<int>());
+
+        Assert.Throws<ArgumentNullException>(() => observable.Subscribe(null!));
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RunAllObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RunAllObservableTests.cs
new file mode 100644
index 0000000..3f5c125
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/RunAllObservableTests.cs
@@ -0,0 +1,211 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>RunAll</c> backed by <c>RunAllObservable</c> —
+/// empty-list short-circuit, sequential walk through synchronous and asynchronous
+/// sources, error propagation, and disposal mid-walk.</summary>
+public class RunAllObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Verifies that an empty list emits <see cref="RxVoid"/> and completes immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRunAllEmptyList_ThenEmitsAndCompletes()
+    {
+        var emitted = 0;
+        var completed = false;
+
+        using var sub = Array.Empty<IObservable<RxVoid>>().RunAll()
+            .Subscribe(_ => emitted++, () => completed = true);
+
+        await Assert.That(emitted).IsEqualTo(1);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that synchronous sources iterate without stack growth and complete.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRunAllSyncSources_ThenWalksAllAndCompletes()
+    {
+        const int SourceCount = 5;
+        var runOrder = new List<int>();
+        var sources = new IObservable<RxVoid>[SourceCount];
+        for (var i = 0; i < SourceCount; i++)
+        {
+            var index = i;
+            sources[i] = Observable.Defer(() =>
+            {
+                runOrder.Add(index);
+                return Observable.Return(RxVoid.Default);
+            });
+        }
+
+        var emitted = 0;
+        var completed = false;
+
+        using var sub = ((IReadOnlyList<IObservable<RxVoid>>)sources).RunAll()
+            .Subscribe(_ => emitted++, () => completed = true);
+
+        await Assert.That(runOrder).IsCollectionEqualTo(BuildIndexSequence(SourceCount));
+        await Assert.That(emitted).IsEqualTo(1);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that asynchronous sources complete in order before emitting.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRunAllAsyncSources_ThenWalksSequentially()
+    {
+        var subjectA = new Subject<RxVoid>();
+        var subjectB = new Subject<RxVoid>();
+        IObservable<RxVoid>[] sources = [subjectA, subjectB];
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ((IReadOnlyList<IObservable<RxVoid>>)sources).RunAll()
+            .Subscribe(static _ => { }, () => completed.TrySetResult(true));
+
+        await Assert.That(subjectA.HasObservers).IsTrue();
+        await Assert.That(subjectB.HasObservers).IsFalse();
+
+        subjectA.OnCompleted();
+
+        await Assert.That(subjectB.HasObservers).IsTrue();
+        subjectB.OnCompleted();
+
+        var done = await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(done).IsTrue();
+    }
+
+    /// <summary>Verifies that an error in any source propagates and aborts the walk.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRunAllSourceErrors_ThenForwardsAndStops()
+    {
+        var subjectA = new Subject<RxVoid>();
+        var subjectB = new Subject<RxVoid>();
+        IObservable<RxVoid>[] sources = [subjectA, subjectB];
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = ((IReadOnlyList<IObservable<RxVoid>>)sources).RunAll()
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subjectA.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(subjectB.HasObservers).IsFalse();
+    }
+
+    /// <summary>Verifies that disposing mid-walk releases the active subscription.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRunAllDisposedMidWalk_ThenStops()
+    {
+        var subjectA = new Subject<RxVoid>();
+        var subjectB = new Subject<RxVoid>();
+        IObservable<RxVoid>[] sources = [subjectA, subjectB];
+        var completed = false;
+
+        var sub = ((IReadOnlyList<IObservable<RxVoid>>)sources).RunAll()
+            .Subscribe(static _ => { }, () => completed = true);
+
+        sub.Dispose();
+
+        // Second dispose hits the Interlocked.Exchange null-loser branch in Sink.Dispose —
+        // the first call swapped in null and disposed the previous subscription, so the
+        // second call sees null and the `?.Dispose()` no-op fires.
+        sub.Dispose();
+
+        subjectA.OnCompleted();
+
+        await Assert.That(completed).IsFalse();
+        await Assert.That(subjectB.HasObservers).IsFalse();
+    }
+
+    /// <summary>Returns <c>[0, 1, …, count-1]</c> for collection-equality assertions.</summary>
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving from a candidate after <c>RunAll</c> has already completed are silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterCompleted_ThenDropped()
+    {
+        var first = new SyncDirectSource<RxVoid>();
+        IObservable<RxVoid>[] sources = [first];
+        var values = new List<RxVoid>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = ((IReadOnlyList<IObservable<RxVoid>>)sources).RunAll()
+            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+
+        first.Observer.OnNext(RxVoid.Default);
+        first.Observer.OnCompleted();
+        first.Observer.OnNext(RxVoid.Default);
+        first.Observer.OnError(new InvalidOperationException("late"));
+        first.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsCollectionEqualTo([RxVoid.Default]);
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Exercises <c>RunAll.RunNext</c>'s post-loop <c>_done</c> guard — a source
+    /// that synchronously errors during <c>Subscribe</c> sets <c>_done = true</c> inline,
+    /// the <c>while (!_done ...)</c> loop bails, and the post-loop check returns without
+    /// emitting <c>RxVoid.Default</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRunAllSourceSyncErrors_ThenPostLoopDoneGuardSuppressesFinalEmit()
+    {
+        IObservable<RxVoid>[] sources =
+        [
+            new SyncErroringObservable<RxVoid>(new InvalidOperationException(SourceErrorMessage)),
+        ];
+        Exception? caught = null;
+        var emitted = 0;
+        var completed = false;
+
+        using var sub = ((IReadOnlyList<IObservable<RxVoid>>)sources).RunAll()
+            .Subscribe(_ => emitted++, ex => caught = ex, () => completed = true);
+
+        await Assert.That(caught).IsNotNull();
+        await Assert.That(caught!.Message).IsEqualTo(SourceErrorMessage);
+        await Assert.That(emitted).IsEqualTo(0);
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Builds a zero-based index sequence of the given length.</summary>
+    /// <param name="count">The exclusive upper bound.</param>
+    /// <returns>A new array of zero-based indices.</returns>
+    private static int[] BuildIndexSequence(int count)
+    {
+        var output = new int[count];
+        for (var i = 0; i < count; i++)
+        {
+            output[i] = i;
+        }
+
+        return output;
+    }
+
+    /// <summary>Synchronously-erroring observable used to drive the sync-error path of
+    /// <c>RunAll.RunNext</c>.</summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    private sealed class SyncErroringObservable<T>(Exception error) : IObservable<T>
+    {
+        /// <inheritdoc/>
+        public IDisposable Subscribe(IObserver<T> observer)
+        {
+            observer.OnError(error);
+            return System.Reactive.Disposables.Disposable.Empty;
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SampleLatestObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SampleLatestObservableTests.cs
new file mode 100644
index 0000000..70d88e8
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SampleLatestObservableTests.cs
@@ -0,0 +1,165 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>SampleLatest</c> backed by
+/// <c>SampleLatestObservable&lt;T&gt;</c> — trigger before any source value,
+/// source completion, source error, trigger error, and trigger completion not
+/// terminating downstream.</summary>
+public class SampleLatestObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Synthetic error message attached to trigger errors.</summary>
+    private const string TriggerErrorMessage = "trigger error";
+
+    /// <summary>Trigger token reused across tests.</summary>
+    private static readonly object TriggerToken = new();
+
+    /// <summary>Verifies that a trigger arriving before any source value does not emit.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSampleLatestTriggerBeforeAnyValue_ThenNoEmission()
+    {
+        var source = new Subject<int>();
+        var trigger = new Subject<object>();
+        var results = new List<int>();
+
+        using var sub = source.SampleLatest(trigger)
+            .Subscribe(results.Add);
+
+        trigger.OnNext(TriggerToken);
+
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>SampleLatest</c> emits the latest source value on each trigger.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSampleLatestTriggerAfterValues_ThenEmitsLatest()
+    {
+        const int First = 1;
+        const int Second = 2;
+        var source = new Subject<int>();
+        var trigger = new Subject<object>();
+        var results = new List<int>();
+
+        using var sub = source.SampleLatest(trigger)
+            .Subscribe(results.Add);
+
+        source.OnNext(First);
+        source.OnNext(Second);
+        trigger.OnNext(TriggerToken);
+        trigger.OnNext(TriggerToken);
+
+        await Assert.That(results).IsCollectionEqualTo([Second, Second]);
+    }
+
+    /// <summary>Verifies that <c>SampleLatest</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSampleLatestSourceErrors_ThenForwardsError()
+    {
+        var source = new Subject<int>();
+        var trigger = new Subject<object>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = source.SampleLatest(trigger)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        source.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>SampleLatest</c> forwards trigger errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSampleLatestTriggerErrors_ThenForwardsError()
+    {
+        var source = new Subject<int>();
+        var trigger = new Subject<object>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(TriggerErrorMessage);
+
+        using var sub = source.SampleLatest(trigger)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        trigger.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that source completion is forwarded downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSampleLatestSourceCompletes_ThenForwardsCompletion()
+    {
+        var source = new Subject<int>();
+        var trigger = new Subject<object>();
+        var completed = false;
+
+        using var sub = source.SampleLatest(trigger)
+            .Subscribe(static _ => { }, () => completed = true);
+
+        source.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that trigger completion alone does NOT complete the downstream sequence.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSampleLatestTriggerCompletes_ThenDownstreamRemainsOpen()
+    {
+        const int Value = 7;
+        var source = new Subject<int>();
+        var trigger = new Subject<object>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = source.SampleLatest(trigger)
+            .Subscribe(results.Add, () => completed = true);
+
+        source.OnNext(Value);
+        trigger.OnCompleted();
+
+        // After trigger completion, source values are still tracked. No emission, no termination.
+        await Assert.That(completed).IsFalse();
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving from the source after the combined sequence has already terminated are silently
+    /// dropped via the <c>_done</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceEventsAfterTerminated_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var trigger = new SyncDirectSource<object>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.SampleLatest(trigger)
+            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+
+        // Terminate via trigger error first.
+        var expected = new InvalidOperationException("trigger");
+        trigger.Observer.OnError(expected);
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(completedCount).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.Terminal.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.Terminal.cs
new file mode 100644
index 0000000..c5f85f7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.Terminal.cs
@@ -0,0 +1,113 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Terminal-notification coverage for <c>ScanWithInitial</c> — source error,
+/// source completion, and post-terminal value ignore.</summary>
+public partial class ScanWithInitialTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Initial accumulator value.</summary>
+    private const int TerminalInitial = 0;
+
+    /// <summary>Verifies that <c>OnError</c> is forwarded after the initial value has been emitted.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScanSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.ScanWithInitial(TerminalInitial, static (acc, x) => acc + x)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>OnCompleted</c> is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScanSourceCompletes_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.ScanWithInitial(TerminalInitial, static (acc, x) => acc + x)
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that values arriving after <c>OnError</c> are ignored.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScanValueAfterError_ThenIgnored()
+    {
+        const int IgnoredValue = 5;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.ScanWithInitial(TerminalInitial, static (acc, x) => acc + x)
+            .Subscribe(results.Add, static _ => { });
+
+        subject.OnError(expected);
+        subject.OnNext(IgnoredValue);
+
+        await Assert.That(results).IsCollectionEqualTo([TerminalInitial]);
+    }
+
+    /// <summary>Verifies that values arriving after <c>OnCompleted</c> are ignored.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScanValueAfterCompleted_ThenIgnored()
+    {
+        const int IgnoredValue = 5;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject.ScanWithInitial(TerminalInitial, static (acc, x) => acc + x)
+            .Subscribe(results.Add);
+
+        subject.OnCompleted();
+        subject.OnNext(IgnoredValue);
+
+        await Assert.That(results).IsCollectionEqualTo([TerminalInitial]);
+    }
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving after the sink has marked itself terminated are silently dropped via the
+    /// <c>_done</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterTerminated_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.ScanWithInitial(TerminalInitial, static (acc, x) => acc + x)
+            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsCollectionEqualTo([TerminalInitial]);
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs
new file mode 100644
index 0000000..a458b43
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScanWithInitialTests.cs
@@ -0,0 +1,162 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>
+/// Tests for the <see cref="ScanWithInitialObservable{TSource, TAccumulate}"/> class.
+/// </summary>
+public partial class ScanWithInitialTests
+{
+#if NET9_0_OR_GREATER
+    /// <summary>Synchronization gate used by tests.</summary>
+    private readonly Lock _gate = new();
+#else
+    /// <summary>Synchronization gate used by tests.</summary>
+    private readonly object _gate = new();
+#endif
+
+    /// <summary>
+    /// Tests that <see cref="ScanWithInitialObservable{TSource, TAccumulate}"/> emits the initial value immediately upon subscription.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Subscribe_EmitsInitialValueImmediately()
+    {
+        // Arrange
+        var source = new Subject<int>();
+        const int Initial = 10;
+        var accumulator = (int acc, int x) =>
+            acc + x;
+        var observable = new ScanWithInitialObservable<int, int>(source, Initial, accumulator);
+        var results = new List<int>();
+
+        // Act
+        using (observable.Subscribe(
+                   results.Add))
+        {
+            // Assert
+            const int ExpectedInitial = 10;
+            await Assert.That(results).IsCollectionEqualTo([ExpectedInitial]);
+        }
+    }
+
+    /// <summary>
+    /// Tests that <see cref="ScanWithInitialObservable{TSource, TAccumulate}"/> accumulates values correctly.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnNext_AccumulatesValues()
+    {
+        // Arrange
+        var source = new Subject<int>();
+        const int Initial = 0;
+        var accumulator = (int acc, int x) =>
+            acc + x;
+        var observable = new ScanWithInitialObservable<int, int>(source, Initial, accumulator);
+        var results = new List<int>();
+
+        // Act
+        using (observable.Subscribe(
+                   results.Add))
+        {
+            const int Second = 2;
+            const int Third = 3;
+            source.OnNext(1);
+            source.OnNext(Second);
+            source.OnNext(Third);
+        }
+
+        // Assert
+        const int RunningSumAfterSecond = 3;
+        const int RunningSumAfterThird = 6;
+        await Assert.That(results).IsCollectionEqualTo([0, 1, RunningSumAfterSecond, RunningSumAfterThird]);
+    }
+
+    /// <summary>
+    /// Tests that <see cref="ScanWithInitialObservable{TSource, TAccumulate}"/> handles errors in the accumulator.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task AccumulatorError_PropagatesError()
+    {
+        // Arrange
+        var source = new Subject<int>();
+        const int Initial = 0;
+        Exception exception = new InvalidOperationException("Accumulator failed");
+        Func<int, int, int> accumulator = (_, _) =>
+            throw exception;
+        var observable = new ScanWithInitialObservable<int, int>(source, Initial, accumulator);
+        var errors = new List<Exception>();
+
+        // Act
+        using (observable.Subscribe(
+                   _ => { },
+                   errors.Add))
+        {
+            source.OnNext(1);
+        }
+
+        // Assert
+        await Assert.That(errors).IsCollectionEqualTo([exception]);
+    }
+
+    /// <summary>
+    /// Tests that <see cref="ScanWithInitialObservable{TSource, TAccumulate}"/> is thread-safe.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    [SuppressMessage("Blocker Code Smell", "S4462:Calls to \"async\" methods should not be blocking", Justification = "Test is synchronous.")]
+    public async Task Observable_IsThreadSafe()
+    {
+        // Arrange
+        var source = new Subject<int>();
+        const int Initial = 0;
+        var accumulator = (int acc, int x) =>
+        {
+            Thread.Sleep(1); // Force potential race condition
+            return acc + x;
+        };
+        var observable = new ScanWithInitialObservable<int, int>(source, Initial, accumulator);
+        var results = new List<int>();
+        var completedCount = 0;
+
+        // Act
+        using (observable.Subscribe(
+                   x =>
+                   {
+                       lock (_gate)
+                       {
+                           results.Add(x);
+                       }
+                   },
+                   _ => { },
+                   () => Interlocked.Increment(ref completedCount)))
+        {
+            var t1 = Task.Run(() =>
+            {
+                for (var i = 0; i < 100; i++)
+                {
+                    source.OnNext(i);
+                }
+            });
+
+            var t2 = Task.Run(async () =>
+            {
+                await Task.Delay(50);
+                source.OnCompleted();
+            });
+
+            await Task.WhenAll(t1, t2);
+        }
+
+        // Assert
+        // We can't easily assert the exact sequence due to the non-thread-safe Subject,
+        // but we can assert that it didn't crash and the state remains consistent.
+        // The lock in ScanWithInitialSink ensures that OnNext doesn't race with OnCompleted internally.
+        await Assert.That(completedCount).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledAndDebounceSyncOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledAndDebounceSyncOperatorTests.cs
new file mode 100644
index 0000000..90f0565
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledAndDebounceSyncOperatorTests.cs
@@ -0,0 +1,450 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage batch for several small synchronous operators:
+/// <c>DetectStale</c>, <c>BufferUntilIdle</c>, <c>DebounceImmediate</c>,
+/// <c>DebounceUntil</c>, <c>Schedule</c> (value and source overloads),
+/// <c>LatestOrDefault</c>, <c>Pairwise</c>, <c>WaitUntil</c>,
+/// <c>SwitchIfEmpty</c>. Tests focus on the terminal/error/disposal branches
+/// that the existing happy-path tests don't already cover.</summary>
+public class ScheduledAndDebounceSyncOperatorTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Standard scheduler tick window used by the timed operators.</summary>
+    private const int WindowTicks = 100;
+
+    /// <summary>Advance amount that exceeds the window once.</summary>
+    private const int AdvancePastWindowTicks = 101;
+
+    /// <summary>Sentinel value 1.</summary>
+    private const int Value1 = 1;
+
+    /// <summary>Sentinel value 2.</summary>
+    private const int Value2 = 2;
+
+    /// <summary>Sentinel value 3.</summary>
+    private const int Value3 = 3;
+
+    /// <summary>Fallback sentinel.</summary>
+    private const int Fallback = 99;
+
+    /// <summary>Verifies that <c>DetectStale</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDetectStaleSourceErrors_ThenForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.DetectStale(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>DetectStale</c> forwards source completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDetectStaleSourceCompletes_ThenForwardsCompletion()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.DetectStale(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>BufferUntilIdle</c> flushes pending values then forwards errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilIdleSourceErrors_ThenFlushesThenForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.BufferUntilIdle(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(results.Add, ex => caught = ex);
+
+        subject.OnNext(Value1);
+        subject.OnNext(Value2);
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(results.Count).IsEqualTo(1);
+        await Assert.That(results[0]).IsCollectionEqualTo([Value1, Value2]);
+    }
+
+    /// <summary>Verifies that <c>DebounceImmediate</c> emits the first value inline and debounces the rest.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceImmediate_ThenFirstInlineThenDebouncedTail()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject.DebounceImmediate(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(Value1);
+        subject.OnNext(Value2);
+        subject.OnNext(Value3);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([Value1, Value3]);
+    }
+
+    /// <summary>Verifies that <c>DebounceImmediate</c> flushes pending values then completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceImmediateCompletesWithPending_ThenFlushesThenCompletes()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.DebounceImmediate(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(Value1);
+        subject.OnNext(Value2);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([Value1, Value2]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>DebounceImmediate</c> flushes pending values then forwards errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceImmediateSourceErrors_ThenFlushesThenForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.DebounceImmediate(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(results.Add, ex => caught = ex);
+
+        subject.OnNext(Value1);
+        subject.OnNext(Value2);
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(results).IsCollectionEqualTo([Value1, Value2]);
+    }
+
+    /// <summary>Verifies that <c>DebounceUntil</c> emits values that satisfy the condition immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceUntilConditionTrue_ThenImmediate()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject.DebounceUntil(
+                TimeSpan.FromTicks(WindowTicks),
+                static x => x >= Value3,
+                scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(Value3);
+
+        await Assert.That(results).IsCollectionEqualTo([Value3]);
+    }
+
+    /// <summary>Verifies that <c>DebounceUntil</c> debounces values that don't satisfy the condition.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceUntilConditionFalse_ThenDebounced()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject.DebounceUntil(
+                TimeSpan.FromTicks(WindowTicks),
+                static _ => false,
+                scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(Value1);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([Value1]);
+    }
+
+    /// <summary>Verifies that <c>Schedule(this T value, TimeSpan, ISequencer)</c> emits the value after the delay.</summary>
+    /// <remarks>The operator preserves the original <c>Observable.Create</c>-based semantics —
+    /// the scheduled callback emits <c>OnNext</c> only; <c>OnCompleted</c> is not signalled.</remarks>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleValueWithDelay_ThenEmitsAfterDelay()
+    {
+        var scheduler = new VirtualClock();
+        var results = new List<int>();
+
+        using var sub = Value1.Schedule(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsEmpty();
+
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([Value1]);
+    }
+
+    /// <summary>Verifies that <c>Schedule(this T value, DateTimeOffset, ISequencer)</c> emits at the absolute time.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleValueAbsolute_ThenEmitsAtTime()
+    {
+        var scheduler = new VirtualClock();
+        var results = new List<int>();
+        var due = scheduler.Now.AddTicks(WindowTicks);
+
+        using var sub = Value1.Schedule(due, scheduler).Subscribe(results.Add);
+
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([Value1]);
+    }
+
+    /// <summary>Verifies that <c>Schedule(this IObservable&lt;T&gt;, TimeSpan, ISequencer)</c>
+    /// dispatches each <c>OnNext</c> via the scheduler after the configured delay.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleSourceWithDelay_ThenEmitsAfterDelay()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = ((IObservable<int>)subject).Schedule(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(Value1);
+
+        await Assert.That(results).IsEmpty();
+
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([Value1]);
+    }
+
+    /// <summary>Verifies that <c>Schedule(this IObservable&lt;T&gt;, DateTimeOffset, ISequencer)</c>
+    /// dispatches each <c>OnNext</c> at the absolute time.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleSourceAbsolute_ThenEmitsAtTime()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var due = scheduler.Now.AddTicks(WindowTicks);
+
+        using var sub = ((IObservable<int>)subject).Schedule(due, scheduler).Subscribe(results.Add);
+
+        subject.OnNext(Value2);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([Value2]);
+    }
+
+    /// <summary>Verifies that <c>LatestOrDefault</c> emits the default seed first, then distinct values.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLatestOrDefault_ThenSeedThenDistinctValues()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject.LatestOrDefault(Fallback).Subscribe(results.Add);
+
+        subject.OnNext(Fallback);
+        subject.OnNext(Value1);
+        subject.OnNext(Value1);
+        subject.OnNext(Value2);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([Fallback, Value1, Value2]);
+    }
+
+    /// <summary>Verifies that <c>LatestOrDefault</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLatestOrDefaultSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.LatestOrDefault(Fallback)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>Pairwise</c> produces adjacent pairs from the source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPairwise_ThenAdjacentPairs()
+    {
+        var subject = new Subject<int>();
+        var results = new List<(int Previous, int Current)>();
+
+        using var sub = subject.Pairwise().Subscribe(results.Add);
+
+        subject.OnNext(Value1);
+        subject.OnNext(Value2);
+        subject.OnNext(Value3);
+
+        await Assert.That(results).IsCollectionEqualTo([(Value1, Value2), (Value2, Value3)]);
+    }
+
+    /// <summary>Verifies that <c>Pairwise</c> emits nothing for a single-element source.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPairwiseSingleElement_ThenEmpty()
+    {
+        var subject = new Subject<int>();
+        var results = new List<(int Previous, int Current)>();
+        var completed = false;
+
+        using var sub = subject.Pairwise().Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(Value1);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>Pairwise</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenPairwiseSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.Pairwise().Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>WaitUntil</c> emits the first matching value and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitUntilMatches_ThenEmitsAndCompletes()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.WaitUntil(static x => x >= Value3)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(Value1);
+        subject.OnNext(Value2);
+        subject.OnNext(Value3);
+        subject.OnNext(Fallback);
+
+        await Assert.That(results).IsCollectionEqualTo([Value3]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>WaitUntil</c> forwards source errors before a match.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitUntilSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.WaitUntil(static _ => false)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>SwitchIfEmpty</c> emits the fallback when the source completes empty.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwitchIfEmptySourceEmpty_ThenEmitsFallback()
+    {
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = Observable.Empty<int>()
+            .SwitchIfEmpty(Observable.Return(Fallback))
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([Fallback]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>SwitchIfEmpty</c> passes the source through when it emits.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwitchIfEmptySourceNonEmpty_ThenPassthrough()
+    {
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = Observable.Return(Value1)
+            .SwitchIfEmpty(Observable.Return(Fallback))
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([Value1]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>SwitchIfEmpty</c> forwards source errors without switching.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwitchIfEmptySourceErrors_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = Observable.Throw<int>(expected)
+            .SwitchIfEmpty(Observable.Return(Fallback))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledSourceObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledSourceObservableTests.cs
new file mode 100644
index 0000000..dda747e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ScheduledSourceObservableTests.cs
@@ -0,0 +1,112 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Direct coverage for <c>ScheduledSourceObservable&lt;T&gt;</c>'s
+/// no-op terminal handlers and the <c>EmitState</c> action/transform catch block —
+/// branches the happy-path scheduler tests don't reach.</summary>
+public class ScheduledSourceObservableTests
+{
+    /// <summary>Sentinel value used by the emission tests.</summary>
+    private const int Sentinel = 5;
+
+    /// <summary>Standard scheduler tick window.</summary>
+    private const int WindowTicks = 50;
+
+    /// <summary>Advance amount that exceeds the window once.</summary>
+    private const int AdvancePastWindowTicks = 60;
+
+    /// <summary>Exercises the intentionally-empty <c>OnError</c> body — source errors
+    /// after a delayed-schedule subscribe are silently dropped, matching the original
+    /// <c>Observable.Create</c> + <c>Subscribe(Action&lt;T&gt;)</c> semantics.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceErrors_ThenSilentlySwallowed()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var results = new List<int>();
+
+        using var sub = ((IObservable<int>)subject)
+            .Schedule(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(results.Add, ex => caught = ex, () => { });
+
+        subject.OnError(new InvalidOperationException("dropped"));
+
+        await Assert.That(caught).IsNull();
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Exercises the intentionally-empty <c>OnCompleted</c> body — source
+    /// completion after a delayed-schedule subscribe is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSourceCompletes_ThenSilentlySwallowed()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var completed = false;
+        var results = new List<int>();
+
+        using var sub = ((IObservable<int>)subject)
+            .Schedule(TimeSpan.FromTicks(WindowTicks), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsFalse();
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Exercises the <c>EmitState.Emit</c> catch block — when the configured
+    /// side-effect throws inside the scheduled callback, the exception is forwarded to
+    /// the downstream <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduledActionThrows_ThenForwardsErrorToDownstream()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("action-threw");
+        Action<int> throwing = _ => throw expected;
+
+        using var sub = ((IObservable<int>)subject)
+            .Schedule(TimeSpan.FromTicks(WindowTicks), scheduler, throwing)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(Sentinel);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Exercises the same catch block via the transform overload — when the
+    /// transform throws inside the scheduled callback, the exception flows to
+    /// downstream <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduledTransformThrows_ThenForwardsErrorToDownstream()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("transform-threw");
+        Func<int, int> throwing = _ => throw expected;
+
+        using var sub = ((IObservable<int>)subject)
+            .Schedule(TimeSpan.FromTicks(WindowTicks), scheduler, throwing)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(Sentinel);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs
new file mode 100644
index 0000000..607e95a
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncConcurrentObservableTests.cs
@@ -0,0 +1,167 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>SelectAsyncConcurrent</c> backed by
+/// <c>SelectAsyncConcurrentObservable&lt;TSource, TResult&gt;</c> — error forwarding,
+/// disposal mid-flight, and deferred completion while in-flight selectors finish.</summary>
+public class SelectAsyncConcurrentObservableTests
+{
+    /// <summary>Synthetic error message attached to a failing selector.</summary>
+    private const string SelectorErrorMessage = "selector failed";
+
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Settle delay in milliseconds used to let an awaited continuation attempt delivery.</summary>
+    private const int SettleDelayMilliseconds = 50;
+
+    /// <summary>Max concurrency used for two-in-flight tests.</summary>
+    private const int MaxConcurrencyTwo = 2;
+
+    /// <summary>Max concurrency used for four-in-flight tests.</summary>
+    private const int MaxConcurrencyFour = 4;
+
+    /// <summary>Verifies that <c>SelectAsyncConcurrent</c> forwards selector exceptions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncConcurrentSelectorThrows_ThenForwardsError()
+    {
+        const int TriggerValue = 1;
+        var subject = new Subject<int>();
+        var faulted = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException(SelectorErrorMessage);
+
+        using var sub = subject.SelectAsyncConcurrent(
+            _ => Task.FromException<int>(expected),
+            maxConcurrency: MaxConcurrencyTwo)
+            .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+
+        subject.OnNext(TriggerValue);
+
+        var caught = await faulted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>SelectAsyncConcurrent</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncConcurrentSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.SelectAsyncConcurrent(static x => Task.FromResult(x), maxConcurrency: MaxConcurrencyTwo)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that disposing the subscription mid-flight suppresses
+    /// further emissions and completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncConcurrentDisposedMidFlight_ThenSuppressesEmissionAndCompletion()
+    {
+        const int TriggerValue = 1;
+        var subject = new Subject<int>();
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var results = new List<int>();
+        var completed = false;
+
+        var sub = subject.SelectAsyncConcurrent(
+            async x =>
+            {
+                await gate.Task.ConfigureAwait(false);
+                return x;
+            },
+            maxConcurrency: MaxConcurrencyTwo)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(TriggerValue);
+        subject.OnCompleted();
+        sub.Dispose();
+        gate.TrySetResult(true);
+
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Verifies that completion arriving while selectors are still in flight
+    /// is forwarded after all selectors finish.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncConcurrentCompletesWithInFlight_ThenDeferredCompletion()
+    {
+        const int First = 1;
+        const int Second = 2;
+        var subject = new Subject<int>();
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var results = new List<int>();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SelectAsyncConcurrent(
+            async x =>
+            {
+                await gate.Task.ConfigureAwait(false);
+                return x;
+            },
+            maxConcurrency: MaxConcurrencyFour)
+            .Subscribe(
+                results.Add,
+                () => completed.TrySetResult(true));
+
+        subject.OnNext(First);
+        subject.OnNext(Second);
+        subject.OnCompleted();
+
+        // The selector is gated; nothing should have emitted yet.
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        await Assert.That(completed.Task.IsCompleted).IsFalse();
+
+        gate.TrySetResult(true);
+
+        var done = await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(done).IsTrue();
+
+        // Downstream OnNext from this operator is serialized inside the sink's lock, so the
+        // list is safely populated by the time completion fires. Order is concurrent so sort.
+        int[] sorted = [.. results];
+        Array.Sort(sorted);
+        await Assert.That(sorted).IsCollectionEqualTo([First, Second]);
+    }
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving after the source has already completed are silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterCompleted_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.SelectAsyncConcurrent(static x => Task.FromResult(x), maxConcurrency: 1)
+            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Task.Delay(SettleDelayMilliseconds);
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs
new file mode 100644
index 0000000..ad92e89
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectAsyncSequentialObservableTests.cs
@@ -0,0 +1,149 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>SelectAsyncSequential</c> backed by
+/// <c>SelectAsyncSequentialObservable&lt;TSource, TResult&gt;</c> — error forwarding,
+/// disposal mid-flight, and completion while an in-flight selector is running.</summary>
+public class SelectAsyncSequentialObservableTests
+{
+    /// <summary>Synthetic error message attached to a failing selector.</summary>
+    private const string SelectorErrorMessage = "selector failed";
+
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Settle delay in milliseconds used to let an awaited continuation attempt delivery.</summary>
+    private const int SettleDelayMilliseconds = 50;
+
+    /// <summary>Verifies that <c>SelectAsyncSequential</c> forwards selector exceptions
+    /// and stops draining the queue afterwards.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncSequentialSelectorThrows_ThenForwardsErrorAndStops()
+    {
+        const int First = 1;
+        const int Second = 2;
+        var subject = new Subject<int>();
+        var faulted = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var results = new List<int>();
+        var expected = new InvalidOperationException(SelectorErrorMessage);
+
+        using var sub = subject.SelectAsyncSequential(x =>
+            x == First ? Task.FromException<int>(expected) : Task.FromResult(x))
+            .Subscribe(results.Add, ex => faulted.TrySetResult(ex));
+
+        subject.OnNext(First);
+        subject.OnNext(Second);
+
+        var caught = await faulted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>SelectAsyncSequential</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncSequentialSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.SelectAsyncSequential(static x => Task.FromResult(x))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that disposing the subscription mid-flight suppresses
+    /// further emissions and completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncSequentialDisposedMidFlight_ThenSuppressesEmissionAndCompletion()
+    {
+        const int TriggerValue = 1;
+        var subject = new Subject<int>();
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var results = new List<int>();
+        var completed = false;
+
+        var sub = subject.SelectAsyncSequential(async x =>
+        {
+            await gate.Task.ConfigureAwait(false);
+            return x;
+        }).Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(TriggerValue);
+        subject.OnCompleted();
+        sub.Dispose();
+        gate.TrySetResult(true);
+
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Verifies that completion arriving while a selector is in flight
+    /// is forwarded after the in-flight selector finishes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncSequentialCompletesWhileProcessing_ThenDeferredCompletion()
+    {
+        const int Value = 42;
+        var subject = new Subject<int>();
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var results = new List<int>();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SelectAsyncSequential(async x =>
+        {
+            await gate.Task.ConfigureAwait(false);
+            return x;
+        }).Subscribe(results.Add, () => completed.TrySetResult(true));
+
+        subject.OnNext(Value);
+        subject.OnCompleted();
+
+        // Completion must not fire while selector is gated.
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        await Assert.That(completed.Task.IsCompleted).IsFalse();
+
+        gate.TrySetResult(true);
+
+        var done = await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(done).IsTrue();
+        await Assert.That(results).IsCollectionEqualTo([Value]);
+    }
+
+    /// <summary>Verifies that <c>OnError</c> and a duplicate <c>OnCompleted</c> arriving from
+    /// the source after the sink has marked itself terminated are silently dropped via the
+    /// <c>_done || _disposed</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterTerminated_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.SelectAsyncSequential(static x => Task.FromResult(x))
+            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Task.Delay(SettleDelayMilliseconds);
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs
new file mode 100644
index 0000000..e6237fd
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectLatestAsyncObservableTests.cs
@@ -0,0 +1,177 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>SelectLatestAsync</c> backed by
+/// <c>SelectLatestAsyncObservable&lt;TSource, TResult&gt;</c> — error forwarding,
+/// disposal mid-flight, stale-id drop path and completion-after-in-flight.</summary>
+public class SelectLatestAsyncObservableTests
+{
+    /// <summary>Synthetic error message attached to a failing selector.</summary>
+    private const string SelectorErrorMessage = "selector failed";
+
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Settle delay in milliseconds used to let an awaited continuation attempt delivery.</summary>
+    private const int SettleDelayMilliseconds = 50;
+
+    /// <summary>Poll interval in milliseconds used while waiting for an emission.</summary>
+    private const int PollIntervalMilliseconds = 10;
+
+    /// <summary>Multiplier applied inside the projection selector.</summary>
+    private const int ProjectionMultiplier = 10;
+
+    /// <summary>Verifies that <c>SelectLatestAsync</c> forwards selector exceptions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectLatestAsyncSelectorThrows_ThenForwardsError()
+    {
+        const int TriggerValue = 1;
+        var subject = new Subject<int>();
+        var faulted = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException(SelectorErrorMessage);
+
+        using var sub = subject.SelectLatestAsync(_ => Task.FromException<int>(expected))
+            .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+
+        subject.OnNext(TriggerValue);
+
+        var caught = await faulted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>SelectLatestAsync</c> forwards source errors immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectLatestAsyncSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.SelectLatestAsync(static x => Task.FromResult(x))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that disposing the subscription before the selector completes
+    /// suppresses any later <c>OnNext</c> / <c>OnCompleted</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectLatestAsyncDisposedMidFlight_ThenSuppressesEmissionAndCompletion()
+    {
+        const int TriggerValue = 1;
+        var subject = new Subject<int>();
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var results = new List<int>();
+        var completed = false;
+
+        var sub = subject.SelectLatestAsync(async x =>
+        {
+            await gate.Task.ConfigureAwait(false);
+            return x * 2;
+        }).Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(TriggerValue);
+        subject.OnCompleted();
+        sub.Dispose();
+        gate.TrySetResult(true);
+
+        // Give the awaited continuation a chance to attempt delivery.
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Verifies that a newer value supersedes a slower in-flight projection,
+    /// so only the latest result is emitted.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectLatestAsyncNewerArrives_ThenOlderResultDropped()
+    {
+        const int Slow = 1;
+        const int Fast = 2;
+        var subject = new Subject<int>();
+        var slowGate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var results = new List<int>();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SelectLatestAsync(async x =>
+        {
+            if (x == Slow)
+            {
+                await slowGate.Task.ConfigureAwait(false);
+            }
+
+            return x * ProjectionMultiplier;
+        }).Subscribe(results.Add, () => completed.TrySetResult(true));
+
+        subject.OnNext(Slow);
+        subject.OnNext(Fast);
+
+        // Wait for the fast projection to complete and emit.
+        while (results.Count == 0)
+        {
+            await Task.Delay(PollIntervalMilliseconds).ConfigureAwait(false);
+        }
+
+        slowGate.TrySetResult(true);
+        subject.OnCompleted();
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        // Only the latest (Fast) projection's result should appear.
+        await Assert.That(results).IsCollectionEqualTo([Fast * ProjectionMultiplier]);
+    }
+
+    /// <summary>Verifies that source completion before any value still completes downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectLatestAsyncSourceCompletesWithNoValues_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int>();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SelectLatestAsync(static x => Task.FromResult(x))
+            .Subscribe(static _ => { }, () => completed.TrySetResult(true));
+
+        subject.OnCompleted();
+
+        var done = await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(done).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving after the source has already completed are silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterCompleted_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.SelectLatestAsync(static x => Task.FromResult(x))
+            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Task.Delay(SettleDelayMilliseconds);
+        await Assert.That(completedCount).IsLessThanOrEqualTo(1);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectManyThenObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectManyThenObservableTests.cs
new file mode 100644
index 0000000..272d9e1
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SelectManyThenObservableTests.cs
@@ -0,0 +1,148 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>SelectManyThen</c> backed by
+/// <c>SelectManyThenObservable&lt;TSource, TMid, TResult&gt;</c> — two-stage projection,
+/// first/second projection throws, source error/completion, and inner-observable errors.</summary>
+public class SelectManyThenObservableTests
+{
+    /// <summary>Synthetic error messages.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Synthetic error for the first projection.</summary>
+    private const string FirstProjectionFailedMessage = "first failed";
+
+    /// <summary>Synthetic error for the second projection.</summary>
+    private const string SecondProjectionFailedMessage = "second failed";
+
+    /// <summary>Synthetic error for the inner observable.</summary>
+    private const string InnerErrorMessage = "inner error";
+
+    /// <summary>Multiplier used to derive intermediate values from the source.</summary>
+    private const int IntermediateMultiplier = 10;
+
+    /// <summary>Multiplier used to derive final values from the intermediate.</summary>
+    private const int FinalMultiplier = 7;
+
+    /// <summary>Source sentinel value.</summary>
+    private const int SourceValue = 3;
+
+    /// <summary>Verifies that values flow through both projections to downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectManyThenTwoStages_ThenComposesProjections()
+    {
+        var results = new List<int>();
+
+        using var sub = Observable.Return(SourceValue)
+            .SelectManyThen(
+                static x => Observable.Return(x * IntermediateMultiplier),
+                static mid => Observable.Return(mid * FinalMultiplier))
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([SourceValue * IntermediateMultiplier * FinalMultiplier]);
+    }
+
+    /// <summary>Verifies that a throwing first projection forwards the error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectManyThenFirstThrows_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException(FirstProjectionFailedMessage);
+
+        using var sub = Observable.Return(SourceValue)
+            .SelectManyThen<int, int, int>(
+                _ => throw expected,
+                static _ => Observable.Return(0))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that a throwing second projection forwards the error.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectManyThenSecondThrows_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SecondProjectionFailedMessage);
+
+        using var sub = Observable.Return(SourceValue)
+            .SelectManyThen<int, int, int>(
+                static x => Observable.Return(x),
+                _ => throw expected)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that a source error is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectManyThenSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.SelectManyThen(
+                static x => Observable.Return(x),
+                static x => Observable.Return(x))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that a source completion is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectManyThenSourceCompletes_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.SelectManyThen(
+                static x => Observable.Return(x),
+                static x => Observable.Return(x))
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that an inner-observable error is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectManyThenInnerErrors_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException(InnerErrorMessage);
+
+        using var sub = Observable.Return(SourceValue)
+            .SelectManyThen(
+                static _ => Observable.Throw<int>(new InvalidOperationException("first-inner")),
+                static x => Observable.Return(x))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsNotNull();
+
+        Exception? caughtSecond = null;
+        using var sub2 = Observable.Return(SourceValue)
+            .SelectManyThen(
+                static x => Observable.Return(x),
+                _ => Observable.Throw<int>(expected))
+            .Subscribe(static _ => { }, ex => caughtSecond = ex);
+
+        await Assert.That(caughtSecond).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SimpleSyncOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SimpleSyncOperatorTests.cs
new file mode 100644
index 0000000..4cf80aa
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SimpleSyncOperatorTests.cs
@@ -0,0 +1,231 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using System.Text.RegularExpressions;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for several small synchronous operators
+/// — <c>Shuffle</c>, <c>Filter</c> (regex), <c>TrySelect</c>.</summary>
+public partial class SimpleSyncOperatorTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Apple sentinel used by regex-filter tests.</summary>
+    private const string Apple = "apple";
+
+    /// <summary>Shuffle test sentinels.</summary>
+    private const int Shuffle1 = 1;
+
+    /// <summary>Shuffle test sentinel.</summary>
+    private const int Shuffle2 = 2;
+
+    /// <summary>Shuffle test sentinel.</summary>
+    private const int Shuffle3 = 3;
+
+    /// <summary>Shuffle test sentinel.</summary>
+    private const int Shuffle4 = 4;
+
+    /// <summary>Shuffle test sentinel.</summary>
+    private const int Shuffle5 = 5;
+
+    /// <summary>Inputs used by the <c>Shuffle</c> multiset test.</summary>
+    private static readonly int[] ShuffleInput = [Shuffle1, Shuffle2, Shuffle3, Shuffle4, Shuffle5];
+
+    /// <summary>Verifies that <c>Shuffle</c> preserves the multiset of input values.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenShuffle_ThenPreservesMultiset()
+    {
+        var subject = new Subject<int[]>();
+        int[]? shuffled = null;
+
+        using var sub = subject.Shuffle().Subscribe(value => shuffled = value);
+
+        subject.OnNext((int[])ShuffleInput.Clone());
+
+        await Assert.That(shuffled).IsNotNull();
+        var sorted = (int[])shuffled!.Clone();
+        Array.Sort(sorted);
+        await Assert.That(sorted).IsCollectionEqualTo(ShuffleInput);
+    }
+
+    /// <summary>Verifies that <c>Shuffle</c> forwards <c>null</c> arrays unchanged.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenShuffleNullArray_ThenForwardsAsIs()
+    {
+        var subject = new Subject<int[]>();
+        var received = 0;
+        int[]? value = null;
+
+        using var sub = subject.Shuffle().Subscribe(v =>
+        {
+            received++;
+            value = v;
+        });
+
+        subject.OnNext(null!);
+
+        await Assert.That(received).IsEqualTo(1);
+        await Assert.That(value).IsNull();
+    }
+
+    /// <summary>Verifies that <c>Shuffle</c> forwards source errors and disposes the RNG.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenShuffleSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int[]>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.Shuffle().Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>Shuffle</c> forwards source completion and disposes the RNG.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenShuffleSourceCompletes_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int[]>();
+        var completed = false;
+
+        using var sub = subject.Shuffle().Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>Filter</c> with a regex pattern forwards only matching strings.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFilterRegexMatches_ThenForwardsMatching()
+    {
+        string[] input = [Apple, "banana", "avocado"];
+        var results = new List<string>();
+
+        using var sub = input.ToObservable()
+            .Filter("^a")
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([Apple, "avocado"]);
+    }
+
+    /// <summary>Verifies that <c>Filter</c> with a precompiled regex behaves identically.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFilterRegexCompiled_ThenForwardsMatching()
+    {
+        string[] input = ["aa", "bb", "ac"];
+        var results = new List<string>();
+        var regex = StartsWithA();
+
+        using var sub = input.ToObservable()
+            .Filter(regex)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["aa", "ac"]);
+    }
+
+    /// <summary>Verifies that <c>Filter</c> ignores null inputs without throwing.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFilterNullInput_ThenIgnored()
+    {
+        var subject = new Subject<string>();
+        var results = new List<string>();
+
+        using var sub = subject.Filter("^a").Subscribe(results.Add);
+
+        subject.OnNext(null!);
+        subject.OnNext(Apple);
+
+        await Assert.That(results).IsCollectionEqualTo([Apple]);
+    }
+
+    /// <summary>Verifies that <c>Filter</c> forwards regex exceptions to <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFilterRegexThrows_ThenForwardsError()
+    {
+        // A regex with a 1-microsecond timeout against pathological input should throw.
+        var regex = PathologicalCatastrophicBacktrack();
+        var subject = new Subject<string>();
+        Exception? caught = null;
+
+        using var sub = subject.Filter(regex).Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(new string('a', 100) + "!");
+
+        await Assert.That(caught).IsNotNull();
+    }
+
+    /// <summary>Verifies that <c>TrySelect</c> drops null projections and forwards non-nulls.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTrySelectNullProjection_ThenDropped()
+    {
+        int[] input = [1, 2, 3, 4];
+        var results = new List<string>();
+
+        using var sub = input.ToObservable()
+            .TrySelect(static x => x % 2 == 0 ? x.ToString() : null)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["2", "4"]);
+    }
+
+    /// <summary>Verifies that an exception thrown by the <c>TrySelect</c> selector is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTrySelectThrows_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("selector failed");
+
+        using var sub = subject.TrySelect<int, string>(_ => throw expected)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(1);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>TrySelect</c> forwards source completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTrySelectSourceCompletes_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.TrySelect(static x => x.ToString())
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Compiled regex matching strings that begin with the letter 'a'.</summary>
+    /// <returns>A compile-time generated <see cref="Regex"/> instance.</returns>
+    [GeneratedRegex("^a")]
+    private static partial Regex StartsWithA();
+
+    /// <summary>Compiled regex with catastrophic backtracking and a 1-tick timeout —
+    /// guaranteed to throw <see cref="RegexMatchTimeoutException"/> on pathological input.
+    /// Used to exercise the error-forwarding branch of <c>Filter</c>.</summary>
+    /// <returns>A compile-time generated <see cref="Regex"/> instance with a 1-tick match timeout.</returns>
+    [GeneratedRegex("(a+)+$", RegexOptions.None, matchTimeoutMilliseconds: 1)]
+    private static partial Regex PathologicalCatastrophicBacktrack();
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartActionObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartActionObservableTests.cs
new file mode 100644
index 0000000..6f3f350
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartActionObservableTests.cs
@@ -0,0 +1,77 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the action-form <c>Start</c> operator backed by
+/// <c>StartActionObservable</c> — synchronous inline path, scheduler dispatch,
+/// and action-throws forwarding.</summary>
+public class StartActionObservableTests
+{
+    /// <summary>Synthetic error message attached to action failures.</summary>
+    private const string ActionFailedMessage = "action failed";
+
+    /// <summary>Verifies that <c>Start</c> with a null scheduler runs synchronously and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartActionInline_ThenRunsAndCompletes()
+    {
+        var ran = false;
+        var completed = false;
+        var emitted = 0;
+
+        using var sub = ReactiveExtensions.Start(() => ran = true, scheduler: null)
+            .Subscribe(_ => emitted++, () => completed = true);
+
+        await Assert.That(ran).IsTrue();
+        await Assert.That(emitted).IsEqualTo(1);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>Start</c> with a scheduler dispatches the action via that scheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartActionWithScheduler_ThenRunsViaScheduler()
+    {
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var ran = false;
+
+        using var sub = ReactiveExtensions.Start(() => ran = true, TaskPoolSequencer.Default)
+            .Subscribe(static _ => { }, () => completed.TrySetResult(true));
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(ran).IsTrue();
+    }
+
+    /// <summary>Verifies that an exception thrown by the inline action is forwarded to <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartActionThrowsInline_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ActionFailedMessage);
+
+        using var sub = ReactiveExtensions.Start(() => throw expected, scheduler: null)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that an exception thrown by the scheduled action is forwarded to <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartActionThrowsScheduled_ThenForwardsError()
+    {
+        var faulted = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException(ActionFailedMessage);
+
+        using var sub = ReactiveExtensions.Start(() => throw expected, TaskPoolSequencer.Default)
+            .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+
+        var caught = await faulted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartFuncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartFuncObservableTests.cs
new file mode 100644
index 0000000..e03ea7c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/StartFuncObservableTests.cs
@@ -0,0 +1,78 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the <c>Start(Func{TResult}, ISequencer?)</c> overload
+/// backed by <c>StartFuncObservable&lt;TResult&gt;</c> — paths missed by the happy-path tests
+/// (inline vs scheduler dispatch and function-throws on both paths).</summary>
+public class StartFuncObservableTests
+{
+    /// <summary>Result returned by the Start tests.</summary>
+    private const int StartResult = 17;
+
+    /// <summary>Message attached to a thrown <c>Start</c> function.</summary>
+    private const string FunctionFailedMessage = "function failed";
+
+    /// <summary>Verifies that the inline (null-scheduler) overload runs the function, emits the result and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartFuncInline_ThenEmitsResultAndCompletes()
+    {
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = ReactiveExtensions.Start(static () => StartResult, null)
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([StartResult]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that the scheduler overload defers execution but still emits and completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartFuncOnScheduler_ThenRunsOnSchedulerAndCompletes()
+    {
+        var results = new List<int>();
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ReactiveExtensions.Start(static () => StartResult, Sequencer.Default)
+            .Subscribe(results.Add, () => completed.TrySetResult());
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(results).IsCollectionEqualTo([StartResult]);
+    }
+
+    /// <summary>Verifies that an exception thrown by the function is surfaced as <c>OnError</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartFuncThrows_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException(FunctionFailedMessage);
+
+        using var sub = ReactiveExtensions.Start((Func<int>)(() => throw expected), null)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that the scheduler path also forwards function errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartFuncOnSchedulerThrows_ThenForwardsError()
+    {
+        var faulted = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException(FunctionFailedMessage);
+
+        using var sub = ReactiveExtensions.Start((Func<int>)(() => throw expected), Sequencer.Default)
+            .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+
+        var caught = await faulted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs
new file mode 100644
index 0000000..1e17f2e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SubscribeAsyncObservableTests.cs
@@ -0,0 +1,269 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the <c>SubscribeSynchronous</c> / <c>SubscribeAsync</c>
+/// overloads backed by <c>SubscribeAsyncObservable&lt;T&gt;</c> — sequential handler invocation,
+/// handler-throws forwards via onError, completion-while-processing defers, disposal stops queue.</summary>
+public class SubscribeAsyncObservableTests
+{
+    /// <summary>Synthetic error message attached to handler failures.</summary>
+    private const string HandlerFailedMessage = "handler failed";
+
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Settle delay in milliseconds used to confirm completion is deferred.</summary>
+    private const int SettleDelayMilliseconds = 50;
+
+    /// <summary>Verifies that values are handled in order and completion fires.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncProcessesValues_ThenInOrder()
+    {
+        const int First = 1;
+        const int Second = 2;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SubscribeSynchronous(
+            x =>
+            {
+                results.Add(x);
+                return default;
+            },
+            static _ => { },
+            () => completed.TrySetResult(true));
+
+        subject.OnNext(First);
+        subject.OnNext(Second);
+        subject.OnCompleted();
+
+        var done = await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(done).IsTrue();
+        await Assert.That(results).IsCollectionEqualTo([First, Second]);
+    }
+
+    /// <summary>Verifies that a handler exception is forwarded to the error callback.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncHandlerThrows_ThenForwardsToOnError()
+    {
+        const int TriggerValue = 1;
+        var subject = new Subject<int>();
+        var faulted = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException(HandlerFailedMessage);
+
+        using var sub = subject.SubscribeSynchronous(
+            _ => ValueTask.FromException(expected),
+            ex => faulted.TrySetResult(ex));
+
+        subject.OnNext(TriggerValue);
+
+        var caught = await faulted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies a handler exception is swallowed when no error callback is supplied.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncHandlerThrowsWithoutOnError_ThenNoExceptionEscapes()
+    {
+        const int TriggerValue = 1;
+        var subject = new Subject<int>();
+        var handlerRan = 0;
+
+        using var sub = subject.SubscribeSynchronous(_ =>
+        {
+            handlerRan++;
+            return ValueTask.FromException(new InvalidOperationException(HandlerFailedMessage));
+        });
+
+        subject.OnNext(TriggerValue);
+
+        await Assert.That(handlerRan).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that source errors are forwarded to the error callback.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncSourceErrors_ThenForwardsToOnError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.SubscribeSynchronous(
+            static _ => default,
+            ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that completion arriving while a handler is in flight defers
+    /// completion until the handler finishes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncCompletesWhileProcessing_ThenDeferredCompletion()
+    {
+        const int Value = 7;
+        var subject = new Subject<int>();
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SubscribeSynchronous(
+            async _ => await gate.Task.ConfigureAwait(false),
+            () => completed.TrySetResult(true));
+
+        subject.OnNext(Value);
+        subject.OnCompleted();
+
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        await Assert.That(completed.Task.IsCompleted).IsFalse();
+
+        gate.TrySetResult(true);
+
+        var done = await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(done).IsTrue();
+    }
+
+    /// <summary>Verifies deferred completion with no completion callback takes the null-callback path.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncCompletesWhileProcessingWithoutCallback_ThenNoExceptionEscapes()
+    {
+        const int Value = 7;
+        var subject = new Subject<int>();
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var handled = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SubscribeSynchronous(async _ =>
+        {
+            await gate.Task.ConfigureAwait(false);
+            handled.TrySetResult(true);
+        });
+
+        subject.OnNext(Value);
+        subject.OnCompleted();
+        gate.TrySetResult(true);
+
+        var done = await handled.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        await Assert.That(done).IsTrue();
+    }
+
+    /// <summary>Verifies disposal during an in-flight handler suppresses deferred terminal callbacks.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncDisposedDuringInFlight_ThenSuppressesCompletionAndError()
+    {
+        const int Value = 7;
+        var subject = new Subject<int>();
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var handlerStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        Exception? caught = null;
+        var completedCount = 0;
+
+        var sub = subject.SubscribeSynchronous(
+            async _ =>
+            {
+                handlerStarted.TrySetResult(true);
+                await gate.Task.ConfigureAwait(false);
+                throw new InvalidOperationException(HandlerFailedMessage);
+            },
+            ex => caught = ex,
+            () => completedCount++);
+
+        subject.OnNext(Value);
+        await handlerStarted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        subject.OnCompleted();
+        sub.Dispose();
+        gate.TrySetResult(true);
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(caught).IsNull();
+        await Assert.That(completedCount).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that disposing the subscription stops further handler invocations.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncDisposed_ThenStopsProcessing()
+    {
+        const int IgnoredValue = 1;
+        var subject = new Subject<int>();
+        var handlerRan = 0;
+
+        var sub = subject.SubscribeSynchronous(_ =>
+        {
+            Interlocked.Increment(ref handlerRan);
+            return default;
+        });
+
+        sub.Dispose();
+        subject.OnNext(IgnoredValue);
+
+        await Assert.That(Volatile.Read(ref handlerRan)).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving after the source has already completed are silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterCompleted_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.SubscribeSynchronous(
+            x =>
+            {
+                values.Add(x);
+                return default;
+            },
+            ex => caught = ex,
+            () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Task.Delay(SettleDelayMilliseconds);
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Verifies that an <c>OnCompleted</c> arriving after a prior <c>OnError</c> is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnCompletedAfterError_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+        var expected = new InvalidOperationException("first");
+
+        using var sub = source.SubscribeSynchronous(
+            static _ => default,
+            ex => caught = ex,
+            () => completedCount++);
+
+        source.Observer.OnError(expected);
+        source.Observer.OnCompleted();
+
+        await Task.Delay(SettleDelayMilliseconds);
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(completedCount).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncDirectSource.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncDirectSource.cs
new file mode 100644
index 0000000..15989d4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncDirectSource.cs
@@ -0,0 +1,32 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>
+/// Synchronous test source that hands its observer back to the test so the test can
+/// invoke <c>OnNext</c> / <c>OnError</c> / <c>OnCompleted</c> directly — including
+/// sequences that <see cref="Subject{T}"/> would otherwise block (emit-after-complete,
+/// double-terminal). Subscriptions return a no-op disposable so external dispose does
+/// not detach the observer.
+/// </summary>
+/// <typeparam name="T">The element type.</typeparam>
+internal sealed class SyncDirectSource<T> : IObservable<T>
+{
+    /// <summary>The captured observer from the most recent subscription.</summary>
+    private IObserver<T>? _observer;
+
+    /// <summary>Gets the captured observer; throws if no one has subscribed yet.</summary>
+    public IObserver<T> Observer => _observer
+        ?? throw new InvalidOperationException("No observer is currently subscribed.");
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<T> observer)
+    {
+        _observer = observer;
+        return System.Reactive.Disposables.Disposable.Empty;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncOperatorErrorForwardingTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncOperatorErrorForwardingTests.cs
new file mode 100644
index 0000000..cf25fe5
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncOperatorErrorForwardingTests.cs
@@ -0,0 +1,132 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using System.Text.RegularExpressions;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Direct coverage for the trivial <c>OnError</c> forwarders on a cluster of small
+/// synchronous operators. Each method is a one-liner that hands a source error straight to
+/// the downstream observer; the existing happy-path tests never exercised the error branch.</summary>
+public class SyncOperatorErrorForwardingTests
+{
+    /// <summary>Synthetic error message used by every forwarder test.</summary>
+    private const string ForwardedMessage = "forwarded";
+
+    /// <summary>Verifies <c>TrySelectObservable</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTrySelectSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ForwardedMessage);
+
+        using var sub = subject.TrySelect(static x => (int?)x)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>WhereTrueObservable</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereTrueSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<bool>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ForwardedMessage);
+
+        using var sub = subject.WhereTrue().Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>WhereFalseObservable</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereFalseSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<bool>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ForwardedMessage);
+
+        using var sub = subject.WhereFalse().Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>WhereIsNotNullObservable</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereIsNotNullSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<string?>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ForwardedMessage);
+
+        using var sub = subject.WhereIsNotNull().Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>SkipWhileNullObservable</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSkipWhileNullSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<string>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ForwardedMessage);
+
+        using var sub = subject.SkipWhileNull().Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>FilterRegexObservable</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFilterRegexSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<string>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ForwardedMessage);
+
+        using var sub = subject.Filter(new Regex("x", RegexOptions.None, TimeSpan.FromSeconds(1)))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>SelectConstantObservable</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectConstantSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ForwardedMessage);
+
+        using var sub = subject.SelectConstant("constant")
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncTimerObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncTimerObservableTests.cs
new file mode 100644
index 0000000..0b66ec7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SyncTimerObservableTests.cs
@@ -0,0 +1,63 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <c>SyncTimerObservable</c> — covers the mid-array remove path of the
+/// shared timer's observer set, the idempotent subscription dispose, and the empty-targets
+/// fast-path inside the tick callback.</summary>
+public class SyncTimerObservableTests
+{
+    /// <summary>Number of periods to advance for the idempotent-dispose assertion.</summary>
+    private const int IdempotentAdvancePeriods = 3;
+
+    /// <summary>Verifies that disposing the middle subscription of three keeps the other two ticking.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenMiddleObserverDisposed_ThenOthersStillReceiveTicks()
+    {
+        var scheduler = new VirtualClock();
+        var firstTicks = 0;
+        var secondTicks = 0;
+        var thirdTicks = 0;
+        var period = TimeSpan.FromTicks(100);
+
+        var timer = ReactiveExtensions.SyncTimer(period, scheduler);
+
+        using var subFirst = timer.Subscribe(_ => firstTicks++);
+        var subSecond = timer.Subscribe(_ => secondTicks++);
+        using var subThird = timer.Subscribe(_ => thirdTicks++);
+
+        scheduler.AdvanceBy(period.Ticks);
+        var secondTicksBeforeDispose = secondTicks;
+        subSecond.Dispose();
+        scheduler.AdvanceBy(period.Ticks);
+
+        await Assert.That(firstTicks).IsGreaterThanOrEqualTo(1);
+        await Assert.That(thirdTicks).IsGreaterThanOrEqualTo(1);
+        await Assert.That(secondTicks).IsEqualTo(secondTicksBeforeDispose);
+    }
+
+    /// <summary>Verifies that disposing a subscription twice is idempotent.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscriptionDisposedTwice_ThenIdempotent()
+    {
+        var scheduler = new VirtualClock();
+        var ticks = 0;
+        var period = TimeSpan.FromTicks(100);
+
+        var timer = ReactiveExtensions.SyncTimer(period, scheduler);
+        var sub = timer.Subscribe(_ => ticks++);
+
+        sub.Dispose();
+        sub.Dispose();
+
+        scheduler.AdvanceBy(period.Ticks * IdempotentAdvancePeriods);
+
+        await Assert.That(ticks).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs
new file mode 100644
index 0000000..4cf43a2
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/SynchronizeAsyncObservableTests.cs
@@ -0,0 +1,81 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <c>SynchronizeAsyncObservable</c> — covers the after-terminal guards
+/// on the sink that only fire when the upstream pushes events past its own completion.</summary>
+public class SynchronizeAsyncObservableTests
+{
+    /// <summary>Settle delay to confirm nothing fires.</summary>
+    private const int SettleDelayMilliseconds = 50;
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving after the source has already completed are silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterCompleted_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.SynchronizeAsync()
+            .Subscribe(t => values.Add(t.Value), ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Task.Delay(SettleDelayMilliseconds);
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Verifies that an <c>OnCompleted</c> arriving after a prior <c>OnError</c> is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnCompletedAfterError_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+        var expected = new InvalidOperationException("first");
+
+        using var sub = source.SynchronizeAsync()
+            .Subscribe(static _ => { }, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnError(expected);
+        source.Observer.OnCompleted();
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(completedCount).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies the per-emission <c>Sync</c> signal latches on first dispose so a second
+    /// dispose by the consumer is a silent no-op.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSyncSignalDisposedTwice_ThenSecondDisposeIsNoOp()
+    {
+        var source = new SyncDirectSource<int>();
+        var processed = 0;
+
+        using var sub = source.SynchronizeAsync()
+            .Subscribe(t =>
+            {
+                t.Sync.Dispose();
+                t.Sync.Dispose();
+                processed++;
+            });
+
+        source.Observer.OnNext(1);
+
+        await Task.Delay(SettleDelayMilliseconds);
+        await Assert.That(processed).IsEqualTo(1);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleAndWaitOperatorCoverageTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleAndWaitOperatorCoverageTests.cs
new file mode 100644
index 0000000..d9d1b74
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleAndWaitOperatorCoverageTests.cs
@@ -0,0 +1,336 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>ThrottleOnScheduler</c>, <c>WaitUntil</c>,
+/// <c>TakeUntilInclusive</c>, and <c>SynchronizeAsync</c> — paths the happy-path
+/// tests do not reach (error propagation, predicate throws, dispose, completion-flush).</summary>
+public class ThrottleAndWaitOperatorCoverageTests
+{
+    /// <summary>Throttle interval used across the scheduler-driven tests.</summary>
+    private const int ThrottleTicks = 100;
+
+    /// <summary>Tick advance guaranteed to fire any pending throttle scheduling.</summary>
+    private const int AdvancePastWindowTicks = 200;
+
+    /// <summary>Message used for synthesised source exceptions across the error-propagation tests.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Message used for synthesised predicate-throws exceptions.</summary>
+    private const string PredicateFailedMessage = "predicate failed";
+
+    /// <summary>Sample value 1 used by the predicate-walk tests.</summary>
+    private const int Sample1 = 1;
+
+    /// <summary>Sample value 2 used by the predicate-walk tests.</summary>
+    private const int Sample2 = 2;
+
+    /// <summary>Sample value 3 used by the predicate-walk tests (also the inclusive match boundary).</summary>
+    private const int Sample3 = 3;
+
+    /// <summary>Sample value 4 used by the predicate-walk tests (ignored once the match completes).</summary>
+    private const int Sample4 = 4;
+
+    /// <summary>Match threshold large enough that no Sample value satisfies the predicate.</summary>
+    private const int NoMatchThreshold = 100;
+
+    /// <summary>Value that does satisfy <see cref="NoMatchThreshold"/> so the dispose test can confirm
+    /// nothing is delivered after disposal.</summary>
+    private const int MatchValue = 500;
+
+    /// <summary>Verifies that <c>ThrottleOnScheduler</c> forwards source errors and cancels the pending emission.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleOnSchedulerSourceErrors_ThenForwardsErrorAndDropsPending()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(results.Add, ex => caught = ex);
+
+        subject.OnNext(Sample1);
+        subject.OnError(expected);
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that completion with a pending value flushes the latest value before completing.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleOnSchedulerCompletesWithPending_ThenFlushesLatestThenCompletes()
+    {
+        const int Pending = 7;
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(Pending);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([Pending]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that completion with no pending value just completes (no flushed value).</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleOnSchedulerCompletesEmpty_ThenCompletesWithoutValue()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that disposing a throttle subscription stops further deliveries even when a scheduled
+    /// emission was already enqueued.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleOnSchedulerDisposed_ThenScheduledEmissionDropped()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        var sub = subject.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(Sample1);
+        sub.Dispose();
+        scheduler.AdvanceBy(AdvancePastWindowTicks);
+
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies <c>WaitUntil</c> forwards source errors when no match has occurred yet.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitUntilSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.WaitUntil(static x => x > NoMatchThreshold)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(Sample1);
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>WaitUntil</c> completes if the source completes before any element matches.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitUntilSourceCompletesWithoutMatch_ThenCompletesWithoutValue()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.WaitUntil(static x => x > NoMatchThreshold)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(Sample1);
+        subject.OnNext(Sample2);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that a throwing predicate is surfaced as an OnError and stops further deliveries.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitUntilPredicateThrows_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var results = new List<int>();
+        var expected = new InvalidOperationException(PredicateFailedMessage);
+
+        using var sub = subject.WaitUntil((Func<int, bool>)(_ => throw expected))
+            .Subscribe(results.Add, ex => caught = ex);
+
+        subject.OnNext(Sample1);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that disposing a WaitUntil subscription before a match stops downstream emissions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWaitUntilDisposedBeforeMatch_ThenNoDownstreamEmission()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        var sub = subject.WaitUntil(static x => x > NoMatchThreshold)
+            .Subscribe(results.Add, () => completed = true);
+
+        sub.Dispose();
+        subject.OnNext(MatchValue);
+
+        await Assert.That(results).IsEmpty();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Verifies that <c>TakeUntilInclusive</c> emits the matching element then completes.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTakeUntilInclusivePredicateMatches_ThenEmitsThroughMatchAndCompletes()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.TakeUntil(static x => x >= Sample3)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(Sample1);
+        subject.OnNext(Sample2);
+        subject.OnNext(Sample3);
+        subject.OnNext(Sample4);
+
+        await Assert.That(results).IsCollectionEqualTo([Sample1, Sample2, Sample3]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>TakeUntilInclusive</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTakeUntilInclusiveSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.TakeUntil(static x => x >= NoMatchThreshold)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext(Sample1);
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that a throwing predicate on <c>TakeUntilInclusive</c> surfaces as OnError.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTakeUntilInclusivePredicateThrows_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var results = new List<int>();
+        var expected = new InvalidOperationException(PredicateFailedMessage);
+
+        using var sub = subject.TakeUntil((Func<int, bool>)(_ => throw expected))
+            .Subscribe(results.Add, ex => caught = ex);
+
+        subject.OnNext(Sample1);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>TakeUntilInclusive</c> completes when the source completes before any match.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTakeUntilInclusiveSourceCompletesBeforeMatch_ThenCompletes()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.TakeUntil(static x => x >= NoMatchThreshold)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(Sample1);
+        subject.OnNext(Sample2);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([Sample1, Sample2]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies <c>SynchronizeAsync</c> forwards source errors to the downstream observer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSynchronizeAsyncSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.SynchronizeAsync()
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies <c>SynchronizeAsync</c> forwards completion to the downstream observer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSynchronizeAsyncSourceCompletes_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.SynchronizeAsync()
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that disposing a <c>SynchronizeAsync</c> subscription suppresses subsequent emissions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSynchronizeAsyncDisposed_ThenSuppressesSubsequentEmissions()
+    {
+        var subject = new Subject<int>();
+        var emissions = 0;
+
+        var sub = subject.SynchronizeAsync()
+            .Subscribe(tuple =>
+            {
+                Interlocked.Increment(ref emissions);
+                tuple.Sync.Dispose();
+            });
+
+        sub.Dispose();
+        subject.OnNext(Sample1);
+        subject.OnNext(Sample2);
+
+        await Assert.That(emissions).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleDistinctObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleDistinctObservableTests.cs
new file mode 100644
index 0000000..c191a84
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleDistinctObservableTests.cs
@@ -0,0 +1,61 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <c>ThrottleDistinctObservable</c> — the after-terminal guards on the
+/// distinct-throttle sink, exercised via a source that pushes events past its own completion.</summary>
+public class ThrottleDistinctObservableTests
+{
+    /// <summary>Tick window for advancing past the throttle in settle assertions.</summary>
+    private const int SettleTicks = 100;
+
+    /// <summary>Tick window for the throttle itself.</summary>
+    private const int ThrottleTicks = 10;
+
+    /// <summary>Verifies that an <c>OnNext</c> arriving after completion is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completed = false;
+
+        using var sub = source.ThrottleDistinct(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(values.Add, () => completed = true);
+
+        source.Observer.OnCompleted();
+        scheduler.AdvanceBy(SettleTicks);
+        source.Observer.OnNext(1);
+        scheduler.AdvanceBy(SettleTicks);
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies that an <c>OnError</c> arriving after a prior <c>OnCompleted</c> is
+    /// silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completed = false;
+
+        using var sub = source.ThrottleDistinct(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completed = true);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnError(new InvalidOperationException("late"));
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleFirstObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleFirstObservableTests.cs
new file mode 100644
index 0000000..2ad4269
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleFirstObservableTests.cs
@@ -0,0 +1,101 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>ThrottleFirst</c> backed by
+/// <c>ThrottleFirstObservable&lt;T&gt;</c> — error/completion forwarding and
+/// post-terminal behaviour not exercised by the happy-path window test.</summary>
+public class ThrottleFirstObservableTests
+{
+    /// <summary>Message attached to synthetic source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Throttle window for the tests.</summary>
+    private static readonly TimeSpan ThrottleFirstWindow = TimeSpan.FromMilliseconds(50);
+
+    /// <summary>Verifies that <c>ThrottleFirst</c> forwards source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleFirstSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.ThrottleFirst(ThrottleFirstWindow)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that <c>ThrottleFirst</c> forwards completion and ignores post-completion emissions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleFirstSourceCompletes_ThenForwardsCompletionAndIgnoresLater()
+    {
+        const int Initial = 1;
+        const int IgnoredAfterCompletion = 2;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.ThrottleFirst(ThrottleFirstWindow)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(Initial);
+        subject.OnCompleted();
+        subject.OnNext(IgnoredAfterCompletion);
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(results).IsCollectionEqualTo([Initial]);
+    }
+
+    /// <summary>Verifies that values arriving after an error are not delivered downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleFirstValueAfterError_ThenIgnored()
+    {
+        const int IgnoredAfterError = 5;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.ThrottleFirst(ThrottleFirstWindow)
+            .Subscribe(results.Add, static _ => { });
+
+        subject.OnError(expected);
+        subject.OnNext(IgnoredAfterError);
+
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving after the source has already completed are silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterCompleted_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.ThrottleFirst(ThrottleFirstWindow)
+            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs
new file mode 100644
index 0000000..92d0d1b
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs
@@ -0,0 +1,85 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <c>ThrottleObservable</c> — the after-terminal guards on
+/// <c>OnNext</c> / <c>OnError</c> / <c>OnCompleted</c> that are only reachable when
+/// an upstream pushes events past its own completion.</summary>
+public class ThrottleObservableTests
+{
+    /// <summary>Tick window for advancing past the throttle in settle assertions.</summary>
+    private const int SettleTicks = 100;
+
+    /// <summary>Tick window for the throttle itself.</summary>
+    private const int ThrottleTicks = 10;
+
+    /// <summary>Verifies that an <c>OnNext</c> arriving after the source has already
+    /// completed is silently dropped by the throttle sink.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completed = false;
+
+        using var sub = source.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(values.Add, () => completed = true);
+
+        source.Observer.OnCompleted();
+        scheduler.AdvanceBy(SettleTicks);
+        source.Observer.OnNext(1);
+        scheduler.AdvanceBy(SettleTicks);
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(values).IsEmpty();
+    }
+
+    /// <summary>Verifies that an <c>OnError</c> arriving after the source has already
+    /// completed is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorAfterCompleted_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completed = false;
+
+        using var sub = source.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completed = true);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnError(new InvalidOperationException("late"));
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Verifies that an <c>OnCompleted</c> arriving after a prior <c>OnError</c>
+    /// is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnCompletedAfterError_ThenDropped()
+    {
+        var scheduler = new VirtualClock();
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completed = false;
+        var expected = new InvalidOperationException("first");
+
+        using var sub = source.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleTicks), scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completed = true);
+
+        source.Observer.OnError(expected);
+        source.Observer.OnCompleted();
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(completed).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs
new file mode 100644
index 0000000..ef1044b
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleUntilTrueObservableTests.cs
@@ -0,0 +1,164 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for <c>ThrottleUntilTrue</c> backed by
+/// <c>ThrottleUntilTrueObservable&lt;T&gt;</c> — predicate-true bypass, predicate-false
+/// throttling, error forwarding, completion forwarding, and dispose-before-fire.</summary>
+public class ThrottleUntilTrueObservableTests
+{
+    /// <summary>Synthetic error message attached to source errors.</summary>
+    private const string SourceErrorMessage = "source error";
+
+    /// <summary>Throttle window in milliseconds for tests.</summary>
+    private const int ThrottleWindowMilliseconds = 50;
+
+    /// <summary>Long throttle window in milliseconds used by the dispose-before-fire test.</summary>
+    private const int LongThrottleWindowMilliseconds = 500;
+
+    /// <summary>Settle delay in milliseconds used to confirm a throttled emission never fires.</summary>
+    private const int SettleDelayMilliseconds = 150;
+
+    /// <summary>Throttle window for tests.</summary>
+    private static readonly TimeSpan ThrottleWindow = TimeSpan.FromMilliseconds(ThrottleWindowMilliseconds);
+
+    /// <summary>Verifies that elements matching the predicate emit immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleUntilTruePredicateTrue_ThenEmitsImmediately()
+    {
+        const int MatchingValue = 1;
+        var subject = new Subject<int>();
+        var emitted = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static x => x == MatchingValue)
+            .Subscribe(v => emitted.TrySetResult(v));
+
+        subject.OnNext(MatchingValue);
+
+        var got = await emitted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(got).IsEqualTo(MatchingValue);
+    }
+
+    /// <summary>Verifies that non-matching elements are throttled but eventually emit.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleUntilTruePredicateFalse_ThenEmitsAfterDelay()
+    {
+        const int NonMatchingValue = 99;
+        var subject = new Subject<int>();
+        var emitted = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static _ => false)
+            .Subscribe(v => emitted.TrySetResult(v));
+
+        subject.OnNext(NonMatchingValue);
+
+        var got = await emitted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(got).IsEqualTo(NonMatchingValue);
+    }
+
+    /// <summary>Verifies that a later throttled value replaces an earlier still-pending one.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleUntilTrueFastReplacements_ThenLatestWins()
+    {
+        const int Earlier = 1;
+        const int Later = 2;
+        var subject = new Subject<int>();
+        var emitted = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static _ => false)
+            .Subscribe(v => emitted.TrySetResult(v));
+
+        subject.OnNext(Earlier);
+        subject.OnNext(Later);
+
+        var got = await emitted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(got).IsEqualTo(Later);
+    }
+
+    /// <summary>Verifies that source errors are forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleUntilTrueSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(SourceErrorMessage);
+
+        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static _ => true)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that source completion is forwarded and post-completion values ignored.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleUntilTrueSourceCompletes_ThenForwardsCompletion()
+    {
+        const int IgnoredAfterCompletion = 9;
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.ThrottleUntilTrue(ThrottleWindow, static _ => true)
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+        subject.OnNext(IgnoredAfterCompletion);
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that disposing before a throttled emission fires suppresses it.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleUntilTrueDisposedBeforeFire_ThenNoEmission()
+    {
+        const int NonMatchingValue = 1;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        var sub = subject.ThrottleUntilTrue(TimeSpan.FromMilliseconds(LongThrottleWindowMilliseconds), static _ => false)
+            .Subscribe(results.Add);
+
+        subject.OnNext(NonMatchingValue);
+        sub.Dispose();
+
+        // Wait past the throttle window to confirm nothing fires.
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Verifies that <c>OnNext</c>, <c>OnError</c> and a duplicate <c>OnCompleted</c>
+    /// arriving after the source has already completed are silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenEventsAfterCompleted_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.ThrottleUntilTrue(ThrottleWindow, static _ => true)
+            .Subscribe(values.Add, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnCompleted();
+        source.Observer.OnNext(1);
+        source.Observer.OnError(new InvalidOperationException("late"));
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.SecondaryDispose.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.SecondaryDispose.cs
new file mode 100644
index 0000000..7f9ef3b
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.SecondaryDispose.cs
@@ -0,0 +1,79 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Covers the secondary-dispose-failure swallow branch and the
+/// scheduler-error-forwarding path of <c>UsingActionObservable&lt;T&gt;</c>.</summary>
+public partial class UsingActionObservableTests
+{
+    /// <summary>Verifies that when the action throws AND the resource also throws on dispose,
+    /// the primary action exception is forwarded and the dispose failure is swallowed.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenActionAndDisposeBothThrow_ThenPrimaryActionErrorForwardedAndDisposeSwallowed()
+    {
+        var resource = new HookDisposable(static () => throw new InvalidOperationException("dispose failed"));
+        Exception? caught = null;
+        var actionFailure = new InvalidOperationException("action failed");
+
+        using var sub = resource.Using(_ => throw actionFailure)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(actionFailure);
+        await Assert.That(resource.DisposeAttempts).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that an action exception forwarded via the scheduler path also disposes the resource.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerPathActionThrows_ThenForwardsErrorAndDisposes()
+    {
+        var resource = new CountingDisposable();
+        var faulted = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException("scheduler action failed");
+
+        using var sub = resource.Using(_ => throw expected, TaskPoolSequencer.Default)
+            .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+
+        var caught = await faulted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Disposable that delegates the side-effect of <c>Dispose</c> to a caller-supplied
+    /// <see cref="Action"/>. Used by tests that intentionally exercise the secondary-failure
+    /// swallow branch of <c>UsingActionObservable</c> by passing a throwing hook.</summary>
+    private sealed class HookDisposable : IDisposable
+    {
+        /// <summary>Per-dispose hook invoked from <see cref="Dispose"/>.</summary>
+        private readonly Action _onDispose;
+
+        /// <summary>Initializes a new instance of the <see cref="HookDisposable"/> class.</summary>
+        /// <param name="onDispose">The hook invoked from <see cref="Dispose"/>.</param>
+        public HookDisposable(Action onDispose) => _onDispose = onDispose;
+
+        /// <summary>Gets the number of times <see cref="Dispose"/> was attempted.</summary>
+        public int DisposeAttempts { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            DisposeAttempts++;
+            _onDispose();
+        }
+    }
+
+    /// <summary>Disposable that simply counts dispose invocations without throwing.</summary>
+    private sealed class CountingDisposable : IDisposable
+    {
+        /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.cs
new file mode 100644
index 0000000..392a835
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingActionObservableTests.cs
@@ -0,0 +1,111 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the action-form <c>Using</c> operator backed by
+/// <c>UsingActionObservable&lt;T&gt;</c> — happy path, null action, scheduler dispatch,
+/// and action-throws-then-disposes paths.</summary>
+public partial class UsingActionObservableTests
+{
+    /// <summary>Synthetic error message attached to action failures.</summary>
+    private const string ActionFailedMessage = "action failed";
+
+    /// <summary>Verifies that <c>Using</c> with a null action still emits, completes,
+    /// and disposes the resource.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingNullAction_ThenEmitsUnitCompletesAndDisposes()
+    {
+        var resource = new TrackedDisposable();
+        var completed = false;
+        var emitted = 0;
+
+        using var sub = resource.Using(action: null)
+            .Subscribe(_ => emitted++, () => completed = true);
+
+        await Assert.That(emitted).IsEqualTo(1);
+        await Assert.That(completed).IsTrue();
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that <c>Using</c> invokes the action against the resource
+    /// and disposes after completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingActionInvoked_ThenActionRunsThenResourceDisposed()
+    {
+        var resource = new TrackedDisposable();
+        var actionRan = false;
+        var completed = false;
+
+        using var sub = resource.Using(r =>
+        {
+            actionRan = true;
+            ThrowIfDisposed(r);
+        }).Subscribe(static _ => { }, () => completed = true);
+
+        await Assert.That(actionRan).IsTrue();
+        await Assert.That(completed).IsTrue();
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that an action exception forwards the error and still disposes the resource.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingActionThrows_ThenForwardsErrorAndDisposes()
+    {
+        var resource = new TrackedDisposable();
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ActionFailedMessage);
+
+        using var sub = resource.Using(_ => throw expected)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that the scheduler overload dispatches via the scheduler and still
+    /// invokes the action then disposes the resource.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingWithScheduler_ThenRunsViaScheduler()
+    {
+        var resource = new TrackedDisposable();
+        var completed = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var actionRan = false;
+
+        using var sub = resource.Using(_ => actionRan = true, scheduler: TaskPoolSequencer.Default)
+            .Subscribe(static _ => { }, () => completed.TrySetResult(true));
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(actionRan).IsTrue();
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Throws when the resource was disposed before the action ran.</summary>
+    /// <param name="resource">The resource to check.</param>
+    private static void ThrowIfDisposed(TrackedDisposable resource)
+    {
+        if (resource.DisposeCount == 0)
+        {
+            return;
+        }
+
+        throw new InvalidOperationException("disposed before action ran");
+    }
+
+    /// <summary>Disposable that counts how many times it has been disposed.</summary>
+    private sealed class TrackedDisposable : IDisposable
+    {
+        /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingAndSwitchIfEmptyEdgeTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingAndSwitchIfEmptyEdgeTests.cs
new file mode 100644
index 0000000..e0884c2
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingAndSwitchIfEmptyEdgeTests.cs
@@ -0,0 +1,187 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case tests for <c>Using</c> (action / func overloads) and
+/// <c>SwitchIfEmpty</c> that target paths not exercised by the existing happy-path tests.</summary>
+public class UsingAndSwitchIfEmptyEdgeTests
+{
+    /// <summary>Sentinel value the fallback observable would emit if it were subscribed.</summary>
+    private const int FallbackSentinel = 99;
+
+    /// <summary>Verifies that <c>Using</c> with a null action still emits RxVoid, completes, and disposes the resource.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingActionNull_ThenEmitsUnitAndDisposesResource()
+    {
+        var resource = new TrackedDisposable();
+        var results = new List<RxVoid>();
+        var completed = false;
+
+        using var sub = resource.Using(null).Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).Count().IsEqualTo(1);
+        await Assert.That(completed).IsTrue();
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that when the action throws the error is forwarded and the resource is still disposed exactly once.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingActionThrows_ThenForwardsErrorAndDisposes()
+    {
+        var resource = new TrackedDisposable();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("action failed");
+
+        using var sub = resource.Using(_ => throw expected).Subscribe(
+            static _ => { },
+            ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that the scheduler overload defers execution to the scheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingActionWithScheduler_ThenRunsOnScheduler()
+    {
+        var resource = new TrackedDisposable();
+        var ran = false;
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = resource.Using(_ => ran = true, Sequencer.Default)
+            .Subscribe(
+                static _ => { },
+                () => completed.TrySetResult());
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(ran).IsTrue();
+
+        // OnCompleted is signalled before the resource is disposed on the scheduler
+        // thread, so spin briefly for the dispose to land.
+        var deadline = Environment.TickCount64 + 5000;
+        while (resource.DisposeCount == 0 && Environment.TickCount64 < deadline)
+        {
+            await Task.Yield();
+        }
+
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that the Func overload returns the function's result and disposes the resource.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingFunc_ThenEmitsFunctionResultAndDisposes()
+    {
+        const int Expected = 42;
+        var resource = new TrackedDisposable();
+        var results = new List<int>();
+
+        using var sub = resource.Using(_ => Expected).Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([Expected]);
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that when the func throws the error is forwarded and the resource is still disposed.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingFuncThrows_ThenForwardsErrorAndDisposes()
+    {
+        var resource = new TrackedDisposable();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("func failed");
+
+        using var sub = resource.Using<TrackedDisposable, int>(_ => throw expected)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that SwitchIfEmpty forwards source errors without subscribing to the fallback.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwitchIfEmptySourceErrors_ThenForwardsErrorAndIgnoresFallback()
+    {
+        var source = new Subject<int>();
+        var fallbackSubscribed = false;
+        var fallback = Observable.Defer(() =>
+        {
+            fallbackSubscribed = true;
+            return Observable.Return(FallbackSentinel);
+        });
+        Exception? caught = null;
+        var expected = new InvalidOperationException("source error");
+
+        using var sub = source.SwitchIfEmpty(fallback).Subscribe(static _ => { }, ex => caught = ex);
+
+        source.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(fallbackSubscribed).IsFalse();
+    }
+
+    /// <summary>Verifies that SwitchIfEmpty completes immediately when the source emits at least one value
+    /// without subscribing to the fallback.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwitchIfEmptySourceEmits_ThenCompletesWithoutFallback()
+    {
+        const int Value = 5;
+        var source = new Subject<int>();
+        var fallbackSubscribed = false;
+        var fallback = Observable.Defer(() =>
+        {
+            fallbackSubscribed = true;
+            return Observable.Return(FallbackSentinel);
+        });
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = source.SwitchIfEmpty(fallback).Subscribe(results.Add, () => completed = true);
+
+        source.OnNext(Value);
+        source.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([Value]);
+        await Assert.That(completed).IsTrue();
+        await Assert.That(fallbackSubscribed).IsFalse();
+    }
+
+    /// <summary>Verifies that disposing a SwitchIfEmpty subscription before the source completes stops further emissions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSwitchIfEmptyDisposed_ThenNoFurtherEmissions()
+    {
+        var source = new Subject<int>();
+        var fallback = new Subject<int>();
+        var results = new List<int>();
+
+        var sub = source.SwitchIfEmpty(fallback).Subscribe(results.Add);
+
+        sub.Dispose();
+        source.OnCompleted();
+        fallback.OnNext(FallbackSentinel);
+
+        await Assert.That(results).IsEmpty();
+    }
+
+    /// <summary>Tracks dispose invocations to verify resource lifecycle.</summary>
+    private sealed class TrackedDisposable : IDisposable
+    {
+        /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingFuncObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingFuncObservableTests.cs
new file mode 100644
index 0000000..02f980b
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/UsingFuncObservableTests.cs
@@ -0,0 +1,100 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Covers the function-overload Using factory (<c>UsingFuncObservable&lt;T,TResult&gt;</c>).
+/// Targets the secondary-dispose-failure swallow branch and the happy-path resource-disposal,
+/// matching the methodology used for <c>UsingActionObservable</c>.</summary>
+public class UsingFuncObservableTests
+{
+    /// <summary>Sentinel result emitted by the happy-path test.</summary>
+    private const int Sentinel = 42;
+
+    /// <summary>Verifies the happy path — the function's result is emitted, completion fires,
+    /// and the resource is disposed exactly once.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFunctionSucceeds_ThenEmitsResultAndDisposesResource()
+    {
+        var resource = new CountingDisposable();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = resource.Using(static _ => Sentinel)
+            .Subscribe(results.Add, () => completed = true);
+
+        await Assert.That(results).IsCollectionEqualTo([Sentinel]);
+        await Assert.That(completed).IsTrue();
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies the secondary-dispose-failure swallow branch — when the function
+    /// throws AND the resource also throws on Dispose, the primary function exception is
+    /// forwarded and the dispose failure is silently swallowed.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFunctionAndDisposeBothThrow_ThenPrimaryErrorForwardedAndDisposeSwallowed()
+    {
+        var resource = new HookDisposable(static () => throw new InvalidOperationException("dispose failed"));
+        Exception? caught = null;
+        var functionFailure = new InvalidOperationException("function failed");
+
+        using var sub = resource.Using(new Func<HookDisposable, int>(_ => throw functionFailure))
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(functionFailure);
+        await Assert.That(resource.DisposeAttempts).IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that a function exception forwarded via the scheduler path also disposes the resource.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerPathFunctionThrows_ThenForwardsErrorAndDisposes()
+    {
+        var resource = new CountingDisposable();
+        var faulted = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var expected = new InvalidOperationException("scheduler function failed");
+
+        using var sub = resource.Using(new Func<CountingDisposable, int>(_ => throw expected), TaskPoolSequencer.Default)
+            .Subscribe(static _ => { }, ex => faulted.TrySetResult(ex));
+
+        var caught = await faulted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(resource.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Disposable that delegates Dispose to a caller-supplied <see cref="Action"/>.</summary>
+    private sealed class HookDisposable : IDisposable
+    {
+        /// <summary>Per-dispose hook invoked from <see cref="Dispose"/>.</summary>
+        private readonly Action _onDispose;
+
+        /// <summary>Initializes a new instance of the <see cref="HookDisposable"/> class.</summary>
+        /// <param name="onDispose">The hook invoked from <see cref="Dispose"/>.</param>
+        public HookDisposable(Action onDispose) => _onDispose = onDispose;
+
+        /// <summary>Gets the number of times <see cref="Dispose"/> was attempted.</summary>
+        public int DisposeAttempts { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            DisposeAttempts++;
+            _onDispose();
+        }
+    }
+
+    /// <summary>Disposable that counts dispose invocations without throwing.</summary>
+    private sealed class CountingDisposable : IDisposable
+    {
+        /// <summary>Gets the number of times <see cref="Dispose"/> has been invoked.</summary>
+        public int DisposeCount { get; private set; }
+
+        /// <inheritdoc/>
+        public void Dispose() => DisposeCount++;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WaitUntilObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WaitUntilObservableTests.cs
new file mode 100644
index 0000000..34f0c5f
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WaitUntilObservableTests.cs
@@ -0,0 +1,74 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Tests for <c>WaitUntilObservable</c> — covers the after-terminal guards
+/// on <c>OnNext</c>, <c>OnError</c>, and <c>OnCompleted</c> that fire only when an
+/// upstream pushes events past its own completion.</summary>
+public class WaitUntilObservableTests
+{
+    /// <summary>Verifies that an <c>OnNext</c> arriving after the predicate has already
+    /// fired and completed the sequence is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextAfterCompleted_ThenDropped()
+    {
+        const int Match = 1;
+        var source = new SyncDirectSource<int>();
+        var values = new List<int>();
+        var completedCount = 0;
+
+        using var sub = source.WaitUntil(static x => x == Match)
+            .Subscribe(values.Add, () => completedCount++);
+
+        source.Observer.OnNext(Match);
+        source.Observer.OnNext(Match);
+        source.Observer.OnCompleted();
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(values).IsCollectionEqualTo([Match]);
+    }
+
+    /// <summary>Verifies that an <c>OnError</c> arriving after the predicate has fired is
+    /// silently dropped via the <c>_done</c> guard.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorAfterCompleted_ThenDropped()
+    {
+        const int Match = 1;
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+
+        using var sub = source.WaitUntil(static x => x == Match)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnNext(Match);
+        source.Observer.OnError(new InvalidOperationException("late"));
+
+        await Assert.That(completedCount).IsEqualTo(1);
+        await Assert.That(caught).IsNull();
+    }
+
+    /// <summary>Verifies that a duplicate <c>OnCompleted</c> after an error is silently dropped.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnCompletedAfterError_ThenDropped()
+    {
+        var source = new SyncDirectSource<int>();
+        Exception? caught = null;
+        var completedCount = 0;
+        var expected = new InvalidOperationException("first");
+
+        using var sub = source.WaitUntil(static _ => false)
+            .Subscribe(static _ => { }, ex => caught = ex, () => completedCount++);
+
+        source.Observer.OnError(expected);
+        source.Observer.OnCompleted();
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+        await Assert.That(completedCount).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs
new file mode 100644
index 0000000..ff09ce9
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/WhileObservableTests.cs
@@ -0,0 +1,128 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests.Operators;
+
+/// <summary>Edge-case coverage for the <c>While</c> operator backed by
+/// <c>WhileObservable</c> — inline iteration, scheduler dispatch, predicate-throws,
+/// action-throws, and dispose-during-iteration paths.</summary>
+public class WhileObservableTests
+{
+    /// <summary>Synthetic error message attached to predicate failures.</summary>
+    private const string PredicateFailedMessage = "predicate failed";
+
+    /// <summary>Synthetic error message attached to action failures.</summary>
+    private const string ActionFailedMessage = "action failed";
+
+    /// <summary>Number of inline iterations to run.</summary>
+    private const int IterationCount = 3;
+
+    /// <summary>Settle delay in milliseconds used to confirm a disposed loop stops ticking.</summary>
+    private const int SettleDelayMilliseconds = 50;
+
+    /// <summary>Maximum tolerated extra iterations after Dispose() returns.</summary>
+    private const int MaxStragglerIterations = 10;
+
+    /// <summary>Verifies that the inline form runs until the predicate returns <c>false</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhileInline_ThenRunsUntilPredicateFalseAndCompletes()
+    {
+        var remaining = IterationCount;
+        var emitted = 0;
+        var completed = false;
+
+        using var sub = ReactiveExtensions.While(() => remaining > 0, () => remaining--)
+            .Subscribe(_ => emitted++, () => completed = true);
+
+        await Assert.That(emitted).IsEqualTo(IterationCount);
+        await Assert.That(completed).IsTrue();
+        await Assert.That(remaining).IsEqualTo(0);
+    }
+
+    /// <summary>Verifies that the scheduler form dispatches every iteration via the scheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhileWithScheduler_ThenRunsUntilPredicateFalse()
+    {
+        var remaining = IterationCount;
+        var completed = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var emitted = 0;
+
+        using var sub = ReactiveExtensions.While(() => remaining > 0, () => remaining--, TaskPoolSequencer.Default)
+            .Subscribe(_ => emitted++, () => completed.TrySetResult(emitted));
+
+        var final = await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(final).IsEqualTo(IterationCount);
+    }
+
+    /// <summary>Verifies that an exception thrown by the predicate is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhilePredicateThrows_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException(PredicateFailedMessage);
+
+        using var sub = ReactiveExtensions.While(() => throw expected, static () => { })
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that an exception thrown by the action is forwarded.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhileActionThrows_ThenForwardsError()
+    {
+        Exception? caught = null;
+        var expected = new InvalidOperationException(ActionFailedMessage);
+
+        using var sub = ReactiveExtensions.While(static () => true, () => throw expected)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>Verifies that disposing the scheduled loop stops further iterations.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhileScheduledThenDisposed_ThenIterationStops()
+    {
+        var ran = 0;
+        var gate = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        var sub = ReactiveExtensions.While(
+                static () => true,
+                () => SignalFirstIteration(ref ran, gate),
+                TaskPoolSequencer.Default)
+            .Subscribe(static _ => { });
+
+        await gate.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        sub.Dispose();
+
+        var snapshot = Volatile.Read(ref ran);
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+        var later = Volatile.Read(ref ran);
+
+        // The loop may execute a few more iterations between Dispose() being called
+        // and the next disposal-check, but it must not keep ticking forever.
+        await Assert.That(later - snapshot).IsLessThanOrEqualTo(MaxStragglerIterations);
+    }
+
+    /// <summary>Increments <paramref name="counter"/> and signals <paramref name="gate"/> on the first iteration.</summary>
+    /// <param name="counter">Shared iteration counter.</param>
+    /// <param name="gate">Completion source signalled after the first iteration.</param>
+    private static void SignalFirstIteration(ref int counter, TaskCompletionSource<bool> gate)
+    {
+        if (Interlocked.Increment(ref counter) != 1)
+        {
+            return;
+        }
+
+        gate.TrySetResult(true);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs
new file mode 100644
index 0000000..ad70f3e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsPortedTests.cs
@@ -0,0 +1,304 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>
+/// Ported coverage for the migrated synchronous extension operators using primitives runtime types.
+/// </summary>
+public sealed class ReactiveExtensionsPortedTests
+{
+    /// <summary>Candidate keys probed by the first-match test.</summary>
+    private static readonly int[] MatchCandidates = [1, 2, 3];
+
+    /// <summary>Verifies signal data wrappers keep their update/signal semantics.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task DataWrappersExposeUpdateAndSignalState()
+    {
+        const int HeartbeatUpdate = 42;
+        const int StaleUpdate = 7;
+
+        var heartbeat = new Heartbeat<int>();
+        var heartbeatUpdate = new Heartbeat<int>(HeartbeatUpdate);
+        var stale = new Stale<int>();
+        var staleUpdate = new Stale<int>(StaleUpdate);
+
+        await Assert.That(heartbeat.IsHeartbeat).IsTrue();
+        await Assert.That(heartbeatUpdate.Update).IsEqualTo(HeartbeatUpdate);
+        await Assert.That(stale.IsStale).IsTrue();
+        await Assert.That(staleUpdate.Update).IsEqualTo(StaleUpdate);
+        Assert.Throws<InvalidOperationException>(() => _ = stale.Update);
+    }
+
+    /// <summary>Verifies null filtering, signal projection, and boolean helpers.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task BasicProjectionAndBooleanOperatorsEmitExpectedValues()
+    {
+        var nullable = new Subject<string?>();
+        var notNull = new List<string>();
+        using var nonNullSub = nullable.WhereIsNotNull().Subscribe(value => notNull.Add(value!));
+        nullable.OnNext(null);
+        nullable.OnNext("value");
+
+        var signalValues = new List<RxVoid>();
+        using var signalSub = Observable.Return(1).AsSignal().Subscribe(signalValues.Add);
+
+        var bools = new Subject<bool>();
+        var notValues = new List<bool>();
+        var trueValues = new List<bool>();
+        var falseValues = new List<bool>();
+        using var notSub = bools.Not().Subscribe(notValues.Add);
+        using var trueSub = bools.WhereTrue().Subscribe(trueValues.Add);
+        using var falseSub = bools.WhereFalse().Subscribe(falseValues.Add);
+        bools.OnNext(true);
+        bools.OnNext(false);
+
+        await Assert.That(notNull).IsCollectionEqualTo(["value"]);
+        await Assert.That(signalValues.Count).IsEqualTo(1);
+        await Assert.That(signalValues[0]).IsEqualTo(RxVoid.Default);
+        await Assert.That(notValues).IsCollectionEqualTo([false, true]);
+        await Assert.That(trueValues).IsCollectionEqualTo([true]);
+        await Assert.That(falseValues).IsCollectionEqualTo([false]);
+    }
+
+    /// <summary>Verifies buffering and combining helpers copied from ReactiveUI.Extensions.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task BufferAndCombineHelpersPreserveLegacyBehavior()
+    {
+        const int MaxAInitial = 1;
+        const int MaxBInitial = 5;
+        const int MaxAUpdate = 9;
+
+        var chars = new Subject<char>();
+        var frames = new List<string>();
+        using var frameSub = chars.BufferUntil('[', ']').Subscribe(frames.Add);
+        foreach (var value in "x[abc]y")
+        {
+            chars.OnNext(value);
+        }
+
+        var first = new BehaviorSubject<bool>(false);
+        var second = new BehaviorSubject<bool>(false);
+        var allFalse = new List<bool>();
+        using var allFalseSub = new[] { first, second }.CombineLatestValuesAreAllFalse().Subscribe(allFalse.Add);
+        first.OnNext(true);
+
+        var maxA = new BehaviorSubject<int>(MaxAInitial);
+        var maxB = new BehaviorSubject<int>(MaxBInitial);
+        var maxValues = new List<int>();
+        using var maxSub = maxA.GetMax(maxB).Subscribe(maxValues.Add);
+        maxA.OnNext(MaxAUpdate);
+
+        await Assert.That(frames).IsCollectionEqualTo(["[abc]"]);
+        await Assert.That(allFalse).IsCollectionEqualTo([true, false]);
+        await Assert.That(maxValues).IsCollectionEqualTo([MaxBInitial, MaxAUpdate]);
+    }
+
+    /// <summary>Verifies virtual-time operators use <see cref="ISequencer"/> instead of Rx schedulers.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task TimeBasedOperatorsUsePrimitiveSequencer()
+    {
+        const int FirstValue = 1;
+        const int SecondValue = 2;
+        const int StaleWindowSeconds = 2;
+        const int ExpectedStaleCount = 3;
+        const int ThirdEmissionIndex = 2;
+
+        var clock = new VirtualClock();
+        var source = new Subject<int>();
+        var batches = new List<IList<int>>();
+        var stale = new List<Stale<int>>();
+        using var bufferSub = source.BufferUntilInactive(TimeSpan.FromSeconds(1), clock).Subscribe(batches.Add);
+        using var staleSub = source.DetectStale(TimeSpan.FromSeconds(StaleWindowSeconds), clock).Subscribe(stale.Add);
+
+        source.OnNext(FirstValue);
+        source.OnNext(SecondValue);
+        clock.AdvanceBy(TimeSpan.FromSeconds(1));
+        clock.AdvanceBy(TimeSpan.FromSeconds(1));
+
+        await Assert.That(batches.Count).IsEqualTo(1);
+        await Assert.That(batches[0]).IsCollectionEqualTo([FirstValue, SecondValue]);
+        await Assert.That(stale.Count).IsEqualTo(ExpectedStaleCount);
+        await Assert.That(stale[0].Update).IsEqualTo(FirstValue);
+        await Assert.That(stale[1].Update).IsEqualTo(SecondValue);
+        await Assert.That(stale[ThirdEmissionIndex].IsStale).IsTrue();
+    }
+
+    /// <summary>Verifies scheduling and throttling helpers use primitive clocks.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SchedulingOperatorsUsePrimitiveSequencer()
+    {
+        const int ScheduledValue = 5;
+        const int FirstThrottled = 1;
+        const int SuppressedThrottled = 2;
+        const int EmittedThrottled = 3;
+
+        var clock = new VirtualClock();
+        var scheduled = new List<int>();
+        using var scheduledSub = ScheduledValue.Schedule(TimeSpan.FromSeconds(1), clock).Subscribe(scheduled.Add);
+
+        var throttledSource = new Subject<int>();
+        var throttled = new List<int>();
+        using var throttleSub = throttledSource.ThrottleFirst(TimeSpan.FromSeconds(1), clock).Subscribe(throttled.Add);
+        throttledSource.OnNext(FirstThrottled);
+        throttledSource.OnNext(SuppressedThrottled);
+        clock.AdvanceBy(TimeSpan.FromSeconds(1));
+        throttledSource.OnNext(EmittedThrottled);
+        clock.AdvanceBy(TimeSpan.FromSeconds(1));
+
+        await Assert.That(scheduled).IsCollectionEqualTo([ScheduledValue]);
+        await Assert.That(throttled).IsCollectionEqualTo([FirstThrottled, EmittedThrottled]);
+    }
+
+    /// <summary>Verifies fused projection/filter helpers.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task FusedProjectionOperatorsEmitExpectedValues()
+    {
+        const int EvenDivisor = 2;
+        const int OddInput = 1;
+        const int EvenInput = 2;
+
+        var values = new Subject<int>();
+        var whereSelect = new List<string>();
+        var trySelect = new List<string>();
+        var constants = new List<string>();
+
+        using var whereSelectSub = values.WhereSelect(x => x % EvenDivisor == 0, x => $"even-{x}").Subscribe(whereSelect.Add);
+        using var trySelectSub = values.TrySelect(x => x > OddInput ? $"value-{x}" : null).Subscribe(trySelect.Add);
+        using var constantsSub = values.SelectConstant("tick").Subscribe(constants.Add);
+        values.OnNext(OddInput);
+        values.OnNext(EvenInput);
+
+        await Assert.That(whereSelect).IsCollectionEqualTo(["even-2"]);
+        await Assert.That(trySelect).IsCollectionEqualTo(["value-2"]);
+        await Assert.That(constants).IsCollectionEqualTo(["tick", "tick"]);
+    }
+
+    /// <summary>Verifies catch/fallback operators preserve their terminal behavior.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ErrorFallbackOperatorsHandleFailures()
+    {
+        const int CatchReturnValue = 7;
+
+        var catchReturn = new List<int>();
+        var catchIgnoreCompleted = false;
+        Exception? caught = null;
+
+        using var returnSub = Observable.Throw<int>(new InvalidOperationException())
+            .CatchReturn(CatchReturnValue)
+            .Subscribe(catchReturn.Add);
+
+        using var ignoreSub = Observable.Throw<int>(new InvalidOperationException("handled"))
+            .CatchIgnore<int, InvalidOperationException>(ex => caught = ex)
+            .Subscribe(static _ => { }, () => catchIgnoreCompleted = true);
+
+        await Assert.That(catchReturn).IsCollectionEqualTo([CatchReturnValue]);
+        await Assert.That(caught).IsNotNull();
+        await Assert.That(catchIgnoreCompleted).IsTrue();
+    }
+
+    /// <summary>Verifies latest, replay, pairwise, partition, sample, and switch helpers.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task StateAndRoutingOperatorsEmitExpectedValues()
+    {
+        const int DefaultValue = -1;
+        const int PartitionDivisor = 2;
+        const int FirstValue = 1;
+        const int SecondValue = 2;
+        const int FallbackValue = 99;
+
+        var source = new Subject<int>();
+        var latest = new List<int>();
+        var pairwise = new List<(int Previous, int Current)>();
+        var even = new List<int>();
+        var odd = new List<int>();
+        var sampled = new List<int>();
+        var trigger = new Subject<object>();
+
+        using var latestSub = source.LatestOrDefault(DefaultValue).Subscribe(latest.Add);
+        using var pairwiseSub = source.Pairwise().Subscribe(pairwise.Add);
+        var (truePartition, falsePartition) = source.Partition(x => x % PartitionDivisor == 0);
+        using var evenSub = truePartition.Subscribe(even.Add);
+        using var oddSub = falsePartition.Subscribe(odd.Add);
+        using var sampledSub = source.SampleLatest(trigger).Subscribe(sampled.Add);
+
+        source.OnNext(FirstValue);
+        trigger.OnNext(new object());
+        source.OnNext(SecondValue);
+        trigger.OnNext(new object());
+
+        var switched = new List<int>();
+        using var switchSub = Observable.Empty<int>().SwitchIfEmpty(Observable.Return(FallbackValue)).Subscribe(switched.Add);
+
+        await Assert.That(latest).IsCollectionEqualTo([DefaultValue, FirstValue, SecondValue]);
+        await Assert.That(pairwise).IsCollectionEqualTo([(FirstValue, SecondValue)]);
+        await Assert.That(even).IsCollectionEqualTo([SecondValue]);
+        await Assert.That(odd).IsCollectionEqualTo([FirstValue]);
+        await Assert.That(sampled).IsCollectionEqualTo([FirstValue, SecondValue]);
+        await Assert.That(switched).IsCollectionEqualTo([FallbackValue]);
+    }
+
+    /// <summary>Verifies async projection and sequential run helpers.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task AsyncAndSequentialHelpersEmitExpectedValues()
+    {
+        const int InputValue = 2;
+        const int SequentialMultiplier = 2;
+        const int ConcurrentMultiplier = 3;
+        const int MaxConcurrency = 2;
+        const int DelayMilliseconds = 50;
+        const int SequentialResult = 4;
+        const int ConcurrentResult = 6;
+
+        var source = new Subject<int>();
+        var sequential = new List<int>();
+        var concurrent = new List<int>();
+        using var seqSub = source.SelectAsyncSequential(x => Task.FromResult(x * SequentialMultiplier)).Subscribe(sequential.Add);
+        using var conSub = source.SelectAsyncConcurrent(x => Task.FromResult(x * ConcurrentMultiplier), maxConcurrency: MaxConcurrency).Subscribe(concurrent.Add);
+
+        source.OnNext(InputValue);
+        await Task.Delay(DelayMilliseconds);
+
+        var runAll = new List<RxVoid>();
+        using var runAllSub = new[]
+        {
+            Observable.Return(RxVoid.Default),
+            Observable.Return(RxVoid.Default)
+        }.RunAll().Subscribe(runAll.Add);
+
+        await Assert.That(sequential).IsCollectionEqualTo([SequentialResult]);
+        await Assert.That(concurrent).IsCollectionEqualTo([ConcurrentResult]);
+        await Assert.That(runAll).IsCollectionEqualTo([RxVoid.Default]);
+    }
+
+    /// <summary>Verifies candidate probing emits the first transformed match.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task FirstMatchFromCandidatesEmitsFirstMatch()
+    {
+        var results = new List<string>();
+        using var sub = MatchCandidates
+            .FirstMatchFromCandidates(
+                key => Observable.Return(key),
+                value => $"value-{value}",
+                value => value.EndsWith("2", StringComparison.Ordinal),
+                "fallback")
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["value-2"]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Buffer.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Buffer.cs
new file mode 100644
index 0000000..ebfdedf
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Buffer.cs
@@ -0,0 +1,355 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>
+    /// Tests BufferUntil with character delimiters.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task BufferUntil_WithStartAndEndChars_BuffersCorrectly()
+    {
+        using var subject = new Subject<char>();
+        var results = new List<string>();
+        using var sub = subject.BufferUntil('<', '>').Subscribe(results.Add);
+
+        subject.OnNext('a');
+        subject.OnNext('<');
+        subject.OnNext('t');
+        subject.OnNext('e');
+        subject.OnNext('s');
+        subject.OnNext('t');
+        subject.OnNext('>');
+        subject.OnNext('b');
+        subject.OnNext('<');
+        subject.OnNext('d');
+        subject.OnNext('a');
+        subject.OnNext('t');
+        subject.OnNext('a');
+        subject.OnNext('>');
+        subject.OnCompleted();
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(SampleValue2);
+            await Assert.That(results[0]).IsEqualTo("<test>");
+            await Assert.That(results[1]).IsEqualTo("<data>");
+        }
+    }
+
+    /// <summary>Exercises <c>BufferUntilObservable</c>'s <c>OnError</c> forwarding —
+    /// the observer hands the source's error straight to the downstream subscriber.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilSourceErrors_ThenForwardsError()
+    {
+        using var subject = new Subject<char>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("buffer-until-error");
+
+        using var sub = subject.BufferUntil('<', '>').Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnNext('a');
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>
+    /// Tests BufferUntil emits remaining buffered content when the source completes before the end delimiter.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task BufferUntil_WhenSourceCompletesWithPartialBuffer_EmitsRemainingContent()
+    {
+        using var subject = new Subject<char>();
+        var results = new List<string>();
+        var completed = false;
+        using var sub = subject.BufferUntil('<', '>').Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext('x');
+        subject.OnNext('<');
+        subject.OnNext('a');
+        subject.OnNext('b');
+        subject.OnCompleted();
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(results[0]).IsEqualTo("<ab");
+            await Assert.That(completed).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests Conflate with minimum update period.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Conflate_WithMinimumPeriod_DelaysUpdates()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        using var sub = subject.Conflate(TimeSpan.FromTicks(100), scheduler).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnNext(SampleValue3);
+        scheduler.AdvanceBy(SchedulerWindowTicks + 1);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(results[0]).IsEqualTo(SampleValue3);
+        }
+    }
+
+    /// <summary>
+    /// Tests Conflate completes after a pending delayed update has been emitted.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Conflate_WithPendingDelayedUpdate_CompletesAfterFlush()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+        using var sub = subject.Conflate(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsFalse();
+
+        scheduler.AdvanceBy(SchedulerWindowTicks + 1);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([SampleValue2]);
+            await Assert.That(completed).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests BufferUntilIdle buffers values until idle period.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task BufferUntilIdle_BuffersUntilIdle()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+
+        subject.BufferUntilIdle(TimeSpan.FromMilliseconds(100), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(TimeSpan.FromMilliseconds(50).Ticks);
+        subject.OnNext(SampleValue3);
+        scheduler.AdvanceBy(TimeSpan.FromMilliseconds(150).Ticks); // Wait for idle period
+
+        await Assert.That(results).Count().IsEqualTo(1);
+        await Assert.That(results[0]).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
+    }
+
+    /// <summary>
+    /// Tests BufferUntilIdle with scheduler forwards source error after flushing buffered items.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilIdleWithSchedulerSourceErrors_ThenFlushesAndForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+        Exception? observedError = null;
+
+        subject.BufferUntilIdle(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add, ex => observedError = ex);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnError(new InvalidOperationException("test error"));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(results[0]).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(observedError).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests BufferUntilIdle with scheduler flushes buffered items on source completion.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilIdleWithSchedulerSourceCompletes_ThenFlushesAndCompletes()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+        var completed = false;
+
+        subject.BufferUntilIdle(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnCompleted();
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(results[0]).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(completed).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests BufferUntilIdle without scheduler uses the Publish+Buffer+Throttle path.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilIdleCalledWithoutScheduler_ThenBuffersUntilIdle()
+    {
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+
+        subject.BufferUntilIdle(TimeSpan.FromMilliseconds(100))
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnNext(SampleValue3);
+        subject.OnCompleted();
+
+        await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
+    }
+
+    /// <summary>
+    /// Tests BufferUntilInactive buffers items and flushes after inactivity period.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilInactive_ThenBuffersAndFlushesOnInactivity()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+
+        subject.BufferUntilInactive(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(SchedulerHalfWindowTicks);
+        subject.OnNext(SampleValue3);
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(results).Count().IsEqualTo(1);
+        await Assert.That(results[0]).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
+    }
+
+    /// <summary>
+    /// Tests BufferUntilInactive flushes remaining items on error.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilInactiveSourceErrors_ThenFlushesAndForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+        Exception? observedError = null;
+
+        subject.BufferUntilInactive(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add, ex => observedError = ex);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnError(new InvalidOperationException("test"));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(results[0]).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(observedError).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests BufferUntilInactive flushes remaining items on completion.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilInactiveSourceCompletes_ThenFlushesAndCompletes()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+        var completed = false;
+
+        subject.BufferUntilInactive(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnCompleted();
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(results[0]).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(completed).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests Conflate non-throttled path emits immediately when update period has passed.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenConflateNonThrottledPath_ThenEmitsImmediately()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        subject.Conflate(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add, _ => { }, () => completed = true);
+
+        // Emit first value - goes through non-throttled path (line 353)
+        subject.OnNext(1);
+        scheduler.AdvanceBy(1);
+
+        // Advance past the minimum update period
+        scheduler.AdvanceBy(SettleDelayMilliseconds);
+
+        // Emit second value - also non-throttled since enough time passed
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(1);
+
+        // Complete with no scheduled update pending (line 372)
+        subject.OnCompleted();
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+        await Assert.That(completed).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Catch.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Catch.cs
new file mode 100644
index 0000000..d93cef7
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Catch.cs
@@ -0,0 +1,119 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>
+    /// Tests CatchIgnore without error action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task CatchIgnore_OnError_ReturnsEmpty()
+    {
+        using var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+        using var sub = subject.CatchIgnore().Subscribe(results.Add, _ => { }, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnError(new InvalidOperationException());
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(completed).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests CatchIgnore with error action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task CatchIgnore_WithErrorAction_CallsActionAndReturnsEmpty()
+    {
+        using var subject = new Subject<int>();
+        var results = new List<int>();
+        var errorCaught = false;
+        var completed = false;
+        using var sub = subject.CatchIgnore<int, InvalidOperationException>(ex => errorCaught = true)
+            .Subscribe(results.Add, _ => { }, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnError(new InvalidOperationException());
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1]);
+            await Assert.That(errorCaught).IsTrue();
+            await Assert.That(completed).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests CatchAndReturn with fallback value.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task CatchAndReturn_OnError_ReturnsFallback()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        using var sub = subject.CatchAndReturn(99).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnError(new InvalidOperationException());
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue99]);
+    }
+
+    /// <summary>
+    /// Tests LogErrors invokes the logger when the source faults.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task LogErrors_WhenSourceErrors_InvokesLogger()
+    {
+        Exception? logged = null;
+        Exception? observed = null;
+        using var subject = new Subject<int>();
+        using var sub = subject.LogErrors(ex => logged = ex)
+            .Subscribe(_ => { }, ex => observed = ex);
+
+        var exception = new InvalidOperationException("boom");
+        subject.OnError(exception);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(logged).IsSameReferenceAs(exception);
+            await Assert.That(observed).IsSameReferenceAs(exception);
+        }
+    }
+
+    /// <summary>
+    /// Tests CatchAndReturn with factory recovers from a specific exception type.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchAndReturnWithFactory_ThenRecoverFromException()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.CatchAndReturn<int, InvalidOperationException>(ex => -1)
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnError(new InvalidOperationException("boom"));
+
+        await Assert.That(results).IsCollectionEqualTo([1, -1]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.CombineLatest.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.CombineLatest.cs
new file mode 100644
index 0000000..c37e2b6
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.CombineLatest.cs
@@ -0,0 +1,229 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>Exercises the <c>BooleanReduceObservable</c> ctor's <c>sources is null</c>
+    /// branch — both the cast-to-IReadOnlyList and the <c>sources?.ToList()</c> shortcut produce
+    /// null, so <c>InvalidOperationExceptionHelper.Check</c> throws.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCombineLatestValuesAreAllFalseNullSources_ThenThrowsInvalidOperation()
+    {
+        Action call = () => _ = ((IEnumerable<IObservable<bool>>)null!).CombineLatestValuesAreAllFalse();
+        var ex = Assert.Throws<InvalidOperationException>(call);
+
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>Exercises the <c>BooleanReduceObservable</c> ctor's fallback when the supplied
+    /// <see cref="IEnumerable{T}"/> is not also an <see cref="IReadOnlyList{T}"/> — the cast
+    /// fails, the null-coalescing operator falls through to <c>sources.ToList()</c>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCombineLatestValuesAreAllFalseNonListEnumerable_ThenMaterializedToList()
+    {
+        var subject1 = new BehaviorSubject<bool>(false);
+        var subject2 = new BehaviorSubject<bool>(false);
+        IEnumerable<IObservable<bool>> sources = new[] { subject1.AsObservable(), subject2.AsObservable() }.Where(static _ => true);
+        bool? result = null;
+
+        using var sub = sources.CombineLatestValuesAreAllFalse().Subscribe(x => result = x);
+
+        await Assert.That(result).IsTrue();
+    }
+
+/// <summary>
+    /// Tests CombineLatestValuesAreAllFalse.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task CombineLatestValuesAreAllFalse_WhenAllFalse_ReturnsTrue()
+    {
+        var subject1 = new BehaviorSubject<bool>(false);
+        var subject2 = new BehaviorSubject<bool>(false);
+        var sources = new[] { subject1.AsObservable(), subject2.AsObservable() };
+        bool? result = null;
+        using var sub = sources.CombineLatestValuesAreAllFalse().Subscribe(x => result = x);
+
+        await Assert.That(result).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests CombineLatestValuesAreAllTrue.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task CombineLatestValuesAreAllTrue_WhenAllTrue_ReturnsTrue()
+    {
+        var subject1 = new BehaviorSubject<bool>(true);
+        var subject2 = new BehaviorSubject<bool>(true);
+        var sources = new[] { subject1.AsObservable(), subject2.AsObservable() };
+        bool? result = null;
+        using var sub = sources.CombineLatestValuesAreAllTrue().Subscribe(x => result = x);
+
+        await Assert.That(result).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests GetMax returns maximum value.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GetMax_WithMultipleSources_ReturnsMaximum()
+    {
+        var subject1 = new BehaviorSubject<int>(5);
+        var subject2 = new BehaviorSubject<int>(10);
+        var subject3 = new BehaviorSubject<int>(3);
+        int? result = null;
+        using var sub = subject1.GetMax(subject2, subject3).Subscribe(x => result = x);
+
+        await Assert.That(result).IsEqualTo(SampleValue10);
+    }
+
+    /// <summary>
+    /// Tests GetMin returns minimum value.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GetMin_WithMultipleSources_ReturnsMinimum()
+    {
+        var subject1 = new BehaviorSubject<int>(5);
+        var subject2 = new BehaviorSubject<int>(10);
+        var subject3 = new BehaviorSubject<int>(3);
+        int? result = null;
+        using var sub = subject1.GetMin(subject2, subject3).Subscribe(x => result = x);
+
+        await Assert.That(result).IsEqualTo(SampleValue3);
+    }
+
+    /// <summary>
+    /// Tests GetMin tracking minimum values as sources change over time.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GetMin_TracksMinimumOverTime()
+    {
+        var subject1 = new BehaviorSubject<int>(5);
+        var subject2 = new BehaviorSubject<int>(10);
+        var subject3 = new BehaviorSubject<int>(3);
+
+        var results = new List<int>();
+        using var sub = subject1
+            .GetMin(subject2, subject3)
+            .Subscribe(results.Add);
+
+        // Initial minimum is 3
+        await Assert.That(results).IsCollectionEqualTo([SampleValue3]);
+
+        // Change minimum to 1
+        subject3.OnNext(1);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue3, 1]);
+
+        // Change minimum to 0
+        subject1.OnNext(0);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue3, 1, 0]);
+    }
+
+    /// <summary>
+    /// Tests GetMax tracking maximum values as sources change over time.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GetMax_TracksMaximumOverTime()
+    {
+        var subject1 = new BehaviorSubject<int>(5);
+        var subject2 = new BehaviorSubject<int>(10);
+        var subject3 = new BehaviorSubject<int>(3);
+
+        var results = new List<int>();
+        using var sub = subject1
+            .GetMax(subject2, subject3)
+            .Subscribe(results.Add);
+
+        // Initial maximum is 10
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10]);
+
+        // Change maximum to 15
+        subject2.OnNext(SampleValue15);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10, SampleValue15]);
+
+        // Change maximum to 20
+        subject1.OnNext(SampleValue20);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10, SampleValue15, SampleValue20]);
+    }
+
+    /// <summary>
+    /// Tests CombineLatestValuesAreAllTrue tracking state changes.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task CombineLatestValuesAreAllTrue_TracksStateChanges()
+    {
+        var subject1 = new BehaviorSubject<bool>(false);
+        var subject2 = new BehaviorSubject<bool>(false);
+        var subject3 = new BehaviorSubject<bool>(false);
+
+        var results = new List<bool>();
+        using var sub = new[] { subject1, subject2, subject3 }
+            .CombineLatestValuesAreAllTrue()
+            .Subscribe(results.Add);
+
+        // Initially all false
+        await Assert.That(results).IsCollectionEqualTo([false]);
+
+        // One true, still false
+        subject1.OnNext(true);
+        await Assert.That(results).IsCollectionEqualTo([false, false]);
+
+        // Two true, still false
+        subject2.OnNext(true);
+        await Assert.That(results).IsCollectionEqualTo([false, false, false]);
+
+        // All true
+        subject3.OnNext(true);
+        await Assert.That(results).IsCollectionEqualTo([false, false, false, true]);
+
+        // Back to false
+        subject1.OnNext(false);
+        await Assert.That(results).IsCollectionEqualTo([false, false, false, true, false]);
+    }
+
+    /// <summary>
+    /// Tests CombineLatestValuesAreAllFalse tracking state changes.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task CombineLatestValuesAreAllFalse_TracksStateChanges()
+    {
+        var subject1 = new BehaviorSubject<bool>(false);
+        var subject2 = new BehaviorSubject<bool>(false);
+        var subject3 = new BehaviorSubject<bool>(false);
+
+        var results = new List<bool>();
+        using var sub = new[] { subject1, subject2, subject3 }
+            .CombineLatestValuesAreAllFalse()
+            .Subscribe(results.Add);
+
+        // Initially all false - result is true
+        await Assert.That(results).IsCollectionEqualTo([true]);
+
+        // One becomes true - result becomes false
+        subject1.OnNext(true);
+        await Assert.That(results).IsCollectionEqualTo([true, false]);
+
+        // Back to false - result becomes true
+        subject1.OnNext(false);
+        await Assert.That(results).IsCollectionEqualTo([true, false, true]);
+
+        // Another becomes true - result becomes false
+        subject2.OnNext(true);
+        await Assert.That(results).IsCollectionEqualTo([true, false, true, false]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FastForEachAndForEach.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FastForEachAndForEach.cs
new file mode 100644
index 0000000..2a66371
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FastForEachAndForEach.cs
@@ -0,0 +1,236 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive;
+using System.Reactive.Linq;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>
+    /// Tests ForEach flattens enumerables.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ForEach_FlattensEnumerables()
+    {
+        var source = Observable.Return(ExpectedSequence123);
+        var results = new List<int>();
+        using var sub = source.ForEach().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
+    }
+
+    /// <summary>
+    /// Tests FastForEach with List source emits all items via OnNext.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEachWithList_ThenEmitsAllItems()
+    {
+        var source = Observable.Return(new List<int> { 1, 2, 3 } as IEnumerable<int>);
+        var results = new List<int>();
+        using var sub = source.ForEach().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
+    }
+
+    /// <summary>
+    /// Tests FastForEach with array source emits all items via OnNext.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEachWithArray_ThenEmitsAllItems()
+    {
+        var arr = new[] { 1, 2, 3 };
+        var results = new List<int>();
+        using var sub = arr.FromArray().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
+    }
+
+    /// <summary>
+    /// Tests FastForEach with generic IEnumerable source emits all items.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEachWithEnumerable_ThenEmitsAllItems()
+    {
+        var source = Observable.Return(Enumerate());
+        var results = new List<int>();
+        using var sub = source.ForEach().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
+
+        static IEnumerable<int> Enumerate()
+        {
+            yield return 1;
+            yield return SampleValue2;
+            yield return SampleValue3;
+        }
+    }
+
+    /// <summary>
+    /// Tests FastForEach with IList branch using ArraySegment which implements IList but not List or T[].
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEachWithIList_ThenEmitsAllItems()
+    {
+        IList<int> ilist = new ArraySegment<int>([10, 20, 30]);
+        var source = Observable.Return((IEnumerable<int>)ilist);
+        var results = new List<int>();
+        using var sub = source.ForEach().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10, SampleValue20, SampleValue30]);
+    }
+
+    /// <summary>
+    /// Tests FastForEach with an array passed through ForEach (Observable of IEnumerable).
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEachWithArrayViaForEach_ThenEmitsAllItems()
+    {
+        var arr = new[] { 10, 20, 30 };
+        var source = Observable.Return(arr as IEnumerable<int>);
+        var results = new List<int>();
+        using var sub = source.ForEach().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10, SampleValue20, SampleValue30]);
+    }
+
+    /// <summary>
+    /// Tests FastForEach with an IList source.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEach_GivenIList_ThenAllItemsEmitted()
+    {
+        // Given
+        List<int> source = [1, 2, 3];
+        var received = new List<int>();
+        var observer = Observer.Create<int>(received.Add);
+
+        // When
+        observer.FastForEach(source);
+
+        // Then
+        await Assert.That(received).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
+    }
+
+    /// <summary>
+    /// Tests FastForEach with an array source.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEach_GivenArray_ThenAllItemsEmitted()
+    {
+        // Given
+        var source = new[] { 10, 20, 30 };
+        var received = new List<int>();
+        var observer = Observer.Create<int>(received.Add);
+
+        // When
+        observer.FastForEach(source);
+
+        // Then
+        await Assert.That(received).IsCollectionEqualTo([SampleValue10, SampleValue20, SampleValue30]);
+    }
+
+    /// <summary>
+    /// Tests FastForEach with a plain IEnumerable source.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEach_GivenIEnumerable_ThenAllItemsEmitted()
+    {
+        // Given
+        static IEnumerable<int> Generate()
+        {
+            yield return SchedulerWindowTicks;
+            yield return SettleDelayMilliseconds;
+        }
+
+        var received = new List<int>();
+        var observer = Observer.Create<int>(received.Add);
+
+        // When
+        observer.FastForEach(Generate());
+
+        // Then
+        await Assert.That(received).IsCollectionEqualTo([SchedulerWindowTicks, SettleDelayMilliseconds]);
+    }
+
+    /// <summary>
+    /// Verifies that FastForEach dispatches a T[] array through the dedicated array branch,
+    /// which is checked before the IList{T} branch.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEachWithArrayAsIEnumerable_ThenHandledByArrayBranch()
+    {
+        var arr = new[] { 5, 10, 15 };
+        var received = new List<int>();
+        var observer = Observer.Create<int>(received.Add);
+
+        observer.FastForEach(arr);
+
+        await Assert.That(received).IsCollectionEqualTo([SampleValue5, SampleValue10, SampleValue15]);
+    }
+
+    /// <summary>
+    /// Verifies that FastForEach iterates a T[] array correctly when the array contains a
+    /// single element, exercising the array branch with a minimal collection.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEach_GivenSingleElementArray_ThenEmitsSingleItem()
+    {
+        // Given
+        var source = new[] { 99 };
+        var received = new List<int>();
+        var observer = Observer.Create<int>(received.Add);
+
+        // When
+        observer.FastForEach(source);
+
+        // Then
+        await Assert.That(received).IsCollectionEqualTo([SampleValue99]);
+    }
+
+    /// <summary>Verifies FastForEach handles an <see cref="IReadOnlyList{T}"/> that is not an <see cref="IList{T}"/>.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFastForEach_GivenReadOnlyListOnly_ThenAllItemsEmitted()
+    {
+        var source = new ReadOnlyListOnly<int>([SampleValue5, SampleValue10, SampleValue15]);
+        var received = new List<int>();
+        var observer = Observer.Create<int>(received.Add);
+
+        observer.FastForEach(source);
+
+        await Assert.That(received).IsCollectionEqualTo([SampleValue5, SampleValue10, SampleValue15]);
+    }
+
+    /// <summary>Read-only list implementation that deliberately does not implement <see cref="IList{T}"/>.</summary>
+    /// <typeparam name="T">The item type.</typeparam>
+    /// <param name="items">The backing items.</param>
+    private sealed class ReadOnlyListOnly<T>(T[] items) : IReadOnlyList<T>
+    {
+        /// <inheritdoc/>
+        public int Count => items.Length;
+
+        /// <inheritdoc/>
+        public T this[int index] => items[index];
+
+        /// <inheritdoc/>
+        public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>)items).GetEnumerator();
+
+        /// <inheritdoc/>
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FusedSelect.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FusedSelect.cs
new file mode 100644
index 0000000..d436b0e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.FusedSelect.cs
@@ -0,0 +1,201 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for the fused Select/Where operators and the candidate-walking helpers
+/// (<c>WhereSelect</c>, <c>SelectConstant</c>, <c>TrySelect</c>, <c>SelectManyThen</c>,
+/// <c>RunAll</c>, <c>FirstMatchFromCandidates</c>).</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>Constant emitted by SelectConstant tests so the chosen value is unambiguous.</summary>
+    private const string SelectConstantSentinel = "constant";
+
+    /// <summary>Fallback value used by FirstMatchFromCandidates when no candidate matches.</summary>
+    private const string CandidateFallback = "fallback";
+
+    /// <summary>
+    /// Verifies that WhereSelect forwards only values that satisfy the predicate, projected through the selector.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereSelect_ThenEmitsOnlyMatchingProjectedValues()
+    {
+        var results = new List<string>();
+
+        using var subscription = new[] { 1, SampleValue2, SampleValue3, SampleValue4 }
+            .ToObservable()
+            .WhereSelect(static x => x % 2 == 0, static x => $"e{x}")
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["e2", "e4"]);
+    }
+
+    /// <summary>Verifies that WhereSelect forwards source errors to the downstream observer.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhereSelectSourceErrors_ThenErrorForwarded()
+    {
+        var expected = new InvalidOperationException("boom");
+        Exception? caught = null;
+
+        using var subscription = Observable.Throw<int>(expected)
+            .WhereSelect(static x => true, static x => x.ToString())
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        await Assert.That(caught).IsEqualTo(expected);
+    }
+
+    /// <summary>Verifies that SelectConstant emits the constant for every source element regardless of value.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectConstant_ThenEmitsConstantForEachElement()
+    {
+        var results = new List<string>();
+
+        using var subscription = new[] { 1, SampleValue2, SampleValue3 }
+            .ToObservable()
+            .SelectConstant(SelectConstantSentinel)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([SelectConstantSentinel, SelectConstantSentinel, SelectConstantSentinel]);
+    }
+
+    /// <summary>Verifies that TrySelect drops null projected values and emits only the non-null results.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenTrySelect_ThenDropsNullProjections()
+    {
+        var results = new List<string>();
+
+        using var subscription = new[] { 1, SampleValue2, SampleValue3, SampleValue4 }
+            .ToObservable()
+            .TrySelect(static x => x % 2 == 0 ? $"e{x}" : null)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["e2", "e4"]);
+    }
+
+    /// <summary>Verifies that SelectManyThen runs both projections in sequence and forwards the final inner result.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectManyThen_ThenChainsTwoProjections()
+    {
+        const int ExpectedChained = 11;
+        var results = new List<int>();
+
+        // Single source emission keeps the test deterministic — the operator's downstream
+        // completes once the inner-inner observable completes, so a multi-emission source
+        // would race against the early-completion semantic.
+        using var subscription = Observable.Return(1)
+            .SelectManyThen(
+                static x => Observable.Return(x * SampleValue10),
+                static mid => Observable.Return(mid + 1))
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([ExpectedChained]);
+    }
+
+    /// <summary>Verifies that RunAll completes after every source has completed and emits a single RxVoid.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRunAll_ThenEmitsSingleUnitAfterAllComplete()
+    {
+        var results = new List<RxVoid>();
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        IReadOnlyList<IObservable<RxVoid>> sources =
+        [
+            Observable.Return(RxVoid.Default),
+            Observable.Return(RxVoid.Default),
+            Observable.Return(RxVoid.Default),
+        ];
+
+        using var subscription = sources.RunAll().Subscribe(
+            results.Add,
+            () => completed.TrySetResult());
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(results).Count().IsEqualTo(1);
+    }
+
+    /// <summary>
+    /// Verifies that RunAll on an empty list still emits the terminal <see cref="RxVoid.Default"/> and
+    /// completes — the empty case is vacuously "all sources completed".
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRunAllEmpty_ThenEmitsUnitAndCompletes()
+    {
+        var results = new List<RxVoid>();
+        var completed = false;
+
+        using var subscription = Array.Empty<IObservable<RxVoid>>().RunAll().Subscribe(
+            results.Add,
+            () => completed = true);
+
+        await Assert.That(completed).IsTrue();
+        await Assert.That(results).Count().IsEqualTo(1);
+    }
+
+    /// <summary>Verifies that FirstMatchFromCandidates emits the first transformed value that satisfies the predicate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstMatchFromCandidates_ThenEmitsFirstSatisfyingValue()
+    {
+        var keys = new[] { "a", "b", "c" };
+        var results = new List<string>();
+
+        using var subscription = keys.FirstMatchFromCandidates(
+            static key => Observable.Return(key + "-raw"),
+            static raw => raw.ToUpperInvariant(),
+            static transformed => transformed.StartsWith('B'),
+            CandidateFallback)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["B-RAW"]);
+    }
+
+    /// <summary>Verifies that FirstMatchFromCandidates emits the fallback when no candidate satisfies the predicate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstMatchFromCandidatesNoMatch_ThenEmitsFallback()
+    {
+        var keys = new[] { "a", "b", "c" };
+        var results = new List<string>();
+
+        using var subscription = keys.FirstMatchFromCandidates(
+            static key => Observable.Return(key + "-raw"),
+            static raw => raw.ToUpperInvariant(),
+            static _ => false,
+            CandidateFallback)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([CandidateFallback]);
+    }
+
+    /// <summary>
+    /// Verifies that FirstMatchFromCandidates skips candidates whose projection errors and continues walking the list.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenFirstMatchFromCandidatesProjectionErrors_ThenSkipsAndContinues()
+    {
+        var keys = new[] { "fail", "match" };
+        var results = new List<string>();
+
+        using var subscription = keys.FirstMatchFromCandidates(
+            static key => key == "fail"
+                ? Observable.Throw<string>(new InvalidOperationException("ignored"))
+                : Observable.Return(key + "-raw"),
+            static raw => raw.ToUpperInvariant(),
+            static transformed => transformed.StartsWith('M'),
+            CandidateFallback)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["MATCH-RAW"]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs
new file mode 100644
index 0000000..f809ac9
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Misc.cs
@@ -0,0 +1,953 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>String literal "changed" used by multiple tests.</summary>
+    private const string ChangedValueLiteral = "changed";
+
+    /// <summary>String literal "initial" used by multiple tests.</summary>
+    private const string InitialValueLiteral = "initial";
+
+    /// <summary>Stabilization window for scheduler-driven assertions.</summary>
+    private const int SchedulerStabilizeMilliseconds = 100;
+
+    /// <summary>Hoisted source array used by tests (was inline literal).</summary>
+    private static readonly string[] SequenceTest123HelloTest456World = ["test123", "hello", "test456", "world"];
+
+    /// <summary>
+    /// Syncronizes the asynchronous runs with asynchronous tasks in subscriptions.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SyncronizeAsync_RunsWithAsyncTasksInSubscriptions()
+    {
+        // Given, When
+        var result = 0;
+        var itterations = 0;
+        var subject = new Subject<bool>();
+        var tasks = new List<Task>();
+        using var disposable = subject
+            .SynchronizeAsync()
+            .Subscribe(x => tasks.Add(HandleAsync(x)));
+
+        async Task HandleAsync((bool Value, IDisposable Sync) x)
+        {
+            try
+            {
+                if (x.Value)
+                {
+                    await Task.Delay(LongDelayMilliseconds);
+                    Interlocked.Increment(ref result);
+                }
+                else
+                {
+                    await Task.Delay(ShortDelayMilliseconds);
+                    Interlocked.Decrement(ref result);
+                }
+            }
+            finally
+            {
+                x.Sync.Dispose();
+                Interlocked.Increment(ref itterations);
+            }
+        }
+
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+
+        await Task.WhenAll(tasks);
+
+        while (itterations < SampleValue6)
+        {
+            Thread.Yield();
+        }
+
+        // Then
+        await Assert.That(result).IsZero();
+    }
+
+    /// <summary>
+    /// Tests OnNext with params.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnNext_WithMultipleValues_PushesAll()
+    {
+        var results = new List<int>();
+        var subject = new Subject<int>();
+        using var sub = subject.Subscribe(results.Add);
+
+        subject.OnNext(1, SampleValue2, SampleValue3, SampleValue4, SampleValue5);
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue3, SampleValue4, SampleValue5]);
+    }
+
+    /// <summary>
+    /// Tests FromArray with scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task FromArray_WithScheduler_EmitsElements()
+    {
+        var source = new[] { 1, 2, 3, 4, 5 };
+        var results = new List<int>();
+        using var sub = source.FromArray(Sequencer.Immediate).Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(source);
+    }
+
+    /// <summary>
+    /// Tests Filter with regex.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Filter_WithRegex_FiltersStrings()
+    {
+        var source = SequenceTest123HelloTest456World.ToObservable();
+        var results = new List<string>();
+        using var sub = source.Filter(@"^test\d+$").Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["test123", "test456"]);
+    }
+
+    /// <summary>
+    /// Tests Shuffle randomizes array.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Shuffle_RandomizesArray()
+    {
+        var original = Enumerable.Range(1, 100).ToArray();
+        var source = Observable.Return(original.ToArray());
+        int[]? result = null;
+        using var sub = source.Shuffle().Subscribe(x => result = x);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(result).IsNotNull();
+            await Assert.That(result).Count().IsEqualTo(SchedulerWindowTicks);
+            var sorted = result!.ToArray();
+            Array.Sort(sorted);
+            await Assert.That(sorted).IsCollectionEqualTo(original);
+        }
+    }
+
+    /// <summary>
+    /// Tests TakeUntil with predicate.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task TakeUntil_WithPredicate_CompletesWhenPredicateTrue()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        using var sub = subject.TakeUntil(x => x >= 5).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnNext(SampleValue5);
+        subject.OnNext(SampleValue6);
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue5]);
+    }
+
+    /// <summary>
+    /// Tests Partition splits sequence.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Partition_SplitsSequence()
+    {
+        var subject = new Subject<int>();
+        var trueResults = new List<int>();
+        var falseResults = new List<int>();
+
+        var (trueObs, falseObs) = subject.Partition(x => x % SampleValue2 == 0);
+
+        using var trueSub = trueObs.Subscribe(trueResults.Add);
+        using var falseSub = falseObs.Subscribe(falseResults.Add);
+
+        for (int i = 1; i <= SampleValue10; i++)
+        {
+            subject.OnNext(i);
+        }
+
+        subject.OnCompleted();
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(trueResults).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6, SampleValue8, SampleValue10]);
+            await Assert.That(falseResults).IsCollectionEqualTo([1, SampleValue3, SampleValue5, SampleValue7, SampleValue9]);
+        }
+    }
+
+    /// <summary>
+    /// Tests WaitUntil takes first matching.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WaitUntil_TakesFirstMatching()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        using var sub = subject.WaitUntil(x => x > 5).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue3);
+        subject.OnNext(SampleValue7);
+        subject.OnNext(SampleValue9);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue7]);
+    }
+
+    /// <summary>
+    /// Tests DoOnSubscribe executes on subscribe.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task DoOnSubscribe_ExecutesOnSubscribe()
+    {
+        var executed = false;
+        var source = Observable.Return(1);
+        using var sub = source.DoOnSubscribe(() => executed = true).Subscribe();
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests DoOnDispose executes on dispose.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task DoOnDispose_ExecutesOnDispose()
+    {
+        var executed = false;
+        var source = Observable.Never<int>();
+        var sub = source.DoOnDispose(() => executed = true).Subscribe();
+
+        sub.Dispose();
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Stale class with update.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Stale_WithUpdate_IsNotStale()
+    {
+        var stale = new Stale<int>(42);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(stale.IsStale).IsFalse();
+            await Assert.That(stale.Update).IsEqualTo(SampleValue42);
+        }
+    }
+
+    /// <summary>
+    /// Tests Stale class without update.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Stale_WithoutUpdate_IsStale()
+    {
+        var stale = new Stale<int>();
+
+        await Assert.That(stale.IsStale).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Stale throws on Update access when stale.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Stale_WithoutUpdate_ThrowsOnUpdateAccess()
+    {
+        var stale = new Stale<int>();
+
+        var ex = Assert.Throws<InvalidOperationException>(() => _ = stale.Update);
+
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>
+    /// Tests Continuation can be disposed.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Continuation_CanBeDisposed()
+    {
+        var continuation = new Continuation();
+
+        continuation.Dispose();
+    }
+
+    /// <summary>
+    /// Tests Continuation tracks completed phases.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Continuation_TracksCompletedPhases()
+    {
+        using var continuation = new Continuation();
+
+        var phases = continuation.CompletedPhases;
+
+        await Assert.That(phases).IsGreaterThanOrEqualTo(0);
+    }
+
+    /// <summary>
+    /// Tests Pairwise emits previous and current pairs.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Pairwise_EmitsPairs()
+    {
+        var subject = new Subject<int>();
+        var results = new List<(int Previous, int Current)>();
+
+        subject.Pairwise().Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnNext(SampleValue3);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(SampleValue2);
+            await Assert.That(results[0]).IsEqualTo((1, SampleValue2));
+            await Assert.That(results[1]).IsEqualTo((SampleValue2, SampleValue3));
+        }
+    }
+
+    /// <summary>
+    /// Tests ScanWithInitial starts with initial value.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ScanWithInitial_StartsWithInitial()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.ScanWithInitial(SampleValue10, (acc, x) => acc + x).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10, SampleValue11, SampleValue13]);
+    }
+
+    /// <summary>
+    /// Tests SampleLatest samples latest on trigger.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SampleLatest_SamplesLatestOnTrigger()
+    {
+        var subject = new Subject<int>();
+        var trigger = new Subject<object>();
+        var results = new List<int>();
+
+        subject.SampleLatest(trigger).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        trigger.OnNext(new object()); // Should emit 2
+        subject.OnNext(SampleValue3);
+        trigger.OnNext(new object()); // Should emit 3
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue3]);
+    }
+
+    /// <summary>
+    /// Tests SwitchIfEmpty switches to fallback when empty.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SwitchIfEmpty_SwitchesWhenEmpty()
+    {
+        var emptySubject = new Subject<int>();
+        var fallbackSubject = new Subject<int>();
+        var results = new List<int>();
+
+        emptySubject.SwitchIfEmpty(fallbackSubject).Subscribe(results.Add);
+
+        emptySubject.OnCompleted(); // Empty completes
+        fallbackSubject.OnNext(SampleValue42);
+        fallbackSubject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue42]);
+    }
+
+    /// <summary>
+    /// Tests ToReadOnlyBehavior creates read-only behavior.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ToReadOnlyBehavior_CreatesReadOnly()
+    {
+        var (observable, observer) = ReactiveExtensions.ToReadOnlyBehavior(SampleValue10);
+        var results = new List<int>();
+
+        observable.Subscribe(results.Add);
+
+        observer.OnNext(SampleValue20);
+        observer.OnNext(SampleValue30);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10, SampleValue20, SampleValue30]);
+    }
+
+    /// <summary>
+    /// Tests ToHotTask converts to hot task.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ToHotTask_ConvertsToTask()
+    {
+        var subject = new Subject<int>();
+        var task = subject.ToHotTask();
+
+        subject.OnNext(SampleValue42);
+
+        await Assert.That(await task).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests ToHotValueTask converts to a hot value task that completes with the first value.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ToHotValueTask_ConvertsToValueTask()
+    {
+        var subject = new Subject<int>();
+        var task = subject.ToHotValueTask();
+
+        subject.OnNext(SampleValue42);
+
+        await Assert.That(await task).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests ToPropertyObservable observes property changes.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ToPropertyObservable_ObservesProperty()
+    {
+        var obj = new TestNotifyPropertyChanged { TestProperty = InitialValueLiteral };
+        var results = new List<string>();
+
+        obj.ToPropertyObservable(x => x.TestProperty).Subscribe(results.Add);
+
+        obj.TestProperty = ChangedValueLiteral;
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValueLiteral, ChangedValueLiteral]);
+    }
+
+    /// <summary>
+    /// Tests SkipWhileNull emits values after the first non-null value, including later nulls.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SkipWhileNull_WhenFirstValueArrives_EmitsRemainingValues()
+    {
+        IObservable<string> source = Observable.Create<string>(observer =>
+        {
+            observer.OnNext(null!);
+            observer.OnNext(null!);
+            observer.OnNext("first");
+            observer.OnNext(null!);
+            observer.OnNext("second");
+            observer.OnCompleted();
+            return Disposable.Empty;
+        });
+        var results = new List<string>();
+
+        using var sub = source.SkipWhileNull().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo(["first", null, "second"]);
+    }
+
+    /// <summary>
+    /// Tests ReplayLastOnSubscribe replays last value to new subscribers.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ReplayLastOnSubscribe_ReplaysLastValueToNewSubscribers()
+    {
+        var subject = new Subject<int>();
+        var replayed = subject.ReplayLastOnSubscribe(SampleValue99);
+
+        var results1 = new List<int>();
+        using var sub1 = replayed.Subscribe(results1.Add);
+
+        // First subscriber gets the per-subscription initial value.
+        await Assert.That(results1).IsCollectionEqualTo([SampleValue99]);
+
+        subject.OnNext(1);
+        await Assert.That(results1).IsCollectionEqualTo([SampleValue99, 1]);
+
+        var results2 = new List<int>();
+        using var sub2 = replayed.Subscribe(results2.Add);
+
+        // ReplayLastOnSubscribe creates a fresh BehaviorSubject per subscriber seeded with the initial value;
+        // late subscribers therefore receive the initial value, not values emitted to earlier subscribers.
+        await Assert.That(results2).IsCollectionEqualTo([SampleValue99]);
+
+        subject.OnNext(SampleValue2);
+        using (Assert.Multiple())
+        {
+            await Assert.That(results1).IsCollectionEqualTo([SampleValue99, 1, SampleValue2]);
+            await Assert.That(results2).IsCollectionEqualTo([SampleValue99, SampleValue2]);
+        }
+    }
+
+    /// <summary>
+    /// Tests LatestOrDefault emits default first then distinct values.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenLatestOrDefault_ThenEmitsDefaultThenDistinctValues()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.LatestOrDefault(SampleValue42).Subscribe(results.Add);
+
+        subject.OnNext(SampleValue42); // Same as default, should be suppressed by DistinctUntilChanged
+        subject.OnNext(1);
+        subject.OnNext(1); // Duplicate, suppressed
+        subject.OnNext(SampleValue2);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue42, 1, SampleValue2]);
+    }
+
+    /// <summary>
+    /// Tests OnNext with null observer throws ArgumentNullException.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextWithNullObserver_ThenThrowsArgumentNullException()
+    {
+        IObserver<int>? observer = null;
+
+        var ex = Assert.Throws<ArgumentNullException>(() => observer!.OnNext(1, 2, 3));
+
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>
+    /// Tests OnNext with null events array throws ArgumentNullException.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnNextWithNullEvents_ThenThrowsArgumentNullException()
+    {
+        var subject = new Subject<int>();
+
+        var ex = Assert.Throws<ArgumentNullException>(() => subject.OnNext(null!));
+
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>
+    /// Tests SubscribeAsync with all three handlers (onNext, onError, onCompleted).
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSubscribeAsyncWithAllHandlers_ThenInvokesAll()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+        Exception? caughtError = null;
+        var completionSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        const int ExpectedCount = 2;
+        var allReceived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.SubscribeAsync(
+            async x =>
+            {
+                await Task.Yield();
+                results.Add(x);
+                _ = results.Count == ExpectedCount && allReceived.TrySetResult();
+            },
+            ex => caughtError = ex,
+            () =>
+            {
+                completed = true;
+                completionSource.TrySetResult(true);
+            });
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        await allReceived.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        subject.OnCompleted();
+
+        await completionSource.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(completed).IsTrue();
+            await Assert.That(caughtError).IsNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests ToPropertyObservable unsubscribes from PropertyChanged when disposed,
+    /// exercising line 1428 of ReactiveExtensions.cs (the -= handler).
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenToPropertyObservableDisposed_ThenUnsubscribesFromPropertyChanged()
+    {
+        var obj = new TestNotifyPropertyChanged { TestProperty = InitialValueLiteral };
+        var results = new List<string>();
+
+        var sub = obj.ToPropertyObservable(x => x.TestProperty).Subscribe(results.Add);
+
+        obj.TestProperty = ChangedValueLiteral;
+
+        // Dispose the subscription, triggering the -= handler
+        sub.Dispose();
+
+        // Changes after dispose should not be observed
+        obj.TestProperty = "afterDispose";
+
+        await Assert.That(results).IsCollectionEqualTo([InitialValueLiteral, ChangedValueLiteral]);
+    }
+
+    /// <summary>Verifies <c>ScheduleSafe(action)</c> uses the scheduler when one is supplied.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleSafeImmediateWithScheduler_ThenSchedulerIsUsed()
+    {
+        var scheduler = new VirtualClock();
+        var ran = false;
+
+        scheduler.ScheduleSafe(() => ran = true);
+
+        await Assert.That(ran).IsFalse();
+        scheduler.AdvanceBy(1);
+        await Assert.That(ran).IsTrue();
+    }
+
+    /// <summary>Verifies <c>ScheduleSafe(dueTime, action)</c> uses the scheduler when one is supplied.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleSafeDelayedWithScheduler_ThenSchedulerIsUsed()
+    {
+        const int DelayTicks = 50;
+        var scheduler = new VirtualClock();
+        var ran = false;
+
+        scheduler.ScheduleSafe(TimeSpan.FromTicks(DelayTicks), () => ran = true);
+
+        await Assert.That(ran).IsFalse();
+        scheduler.AdvanceBy(DelayTicks + 1);
+        await Assert.That(ran).IsTrue();
+    }
+
+    /// <summary>Verifies the two-argument <c>OnErrorRetry&lt;TSource,TException&gt;</c> overload retries indefinitely.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorRetryTypedTwoArgOverload_ThenRetriesAndCallsErrorHandler()
+    {
+        const int SuccessAttempt = 2;
+        var attempts = 0;
+        var values = new List<int>();
+        var caught = new List<InvalidOperationException>();
+        var source = Observable.Create<int>(observer =>
+        {
+            var attempt = Interlocked.Increment(ref attempts);
+            observer.OnNext(attempt);
+            if (attempt < SuccessAttempt)
+            {
+                observer.OnError(new InvalidOperationException("retry"));
+            }
+            else
+            {
+                observer.OnCompleted();
+            }
+
+            return System.Reactive.Disposables.Disposable.Empty;
+        });
+
+        using var sub = source.OnErrorRetry<int, InvalidOperationException>(caught.Add).Subscribe(values.Add);
+
+        await Assert.That(values).IsCollectionEqualTo([1, SuccessAttempt]);
+        await Assert.That(caught).Count().IsEqualTo(1);
+    }
+
+    /// <summary>Verifies the typed <c>OnErrorRetry&lt;TSource,TException&gt;</c> skips the error callback when the exception type does not match.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorRetryNonMatchingExceptionType_ThenOnErrorCallbackSkipped()
+    {
+        var caught = new List<NotSupportedException>();
+        var values = new List<int>();
+        var failure = new InvalidOperationException("wrong type");
+
+        var source = Observable.Create<int>(observer =>
+        {
+            observer.OnNext(1);
+            observer.OnError(failure);
+            return System.Reactive.Disposables.Disposable.Empty;
+        });
+
+        using var sub = source.OnErrorRetry<int, NotSupportedException>(caught.Add, retryCount: 1, TimeSpan.Zero, Sequencer.Default)
+            .Subscribe(values.Add, static _ => { });
+
+        await Task.Delay(TimeSpan.FromMilliseconds(SchedulerStabilizeMilliseconds));
+
+        await Assert.That(caught).IsEmpty();
+        await Assert.That(values.Count).IsGreaterThanOrEqualTo(1);
+    }
+
+    /// <summary>Verifies the two-argument <c>RetryWithBackoff</c> overload retries until success.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffTwoArgOverload_ThenRetriesUntilSuccess()
+    {
+        const int SuccessAttempt = 2;
+        var attempts = 0;
+        var done = new TaskCompletionSource<List<int>>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var values = new List<int>();
+        var source = Observable.Create<int>(observer =>
+        {
+            var attempt = Interlocked.Increment(ref attempts);
+            if (attempt < SuccessAttempt)
+            {
+                observer.OnError(new InvalidOperationException("retry"));
+            }
+            else
+            {
+                observer.OnNext(attempt);
+                observer.OnCompleted();
+            }
+
+            return System.Reactive.Disposables.Disposable.Empty;
+        });
+
+        using var sub = source.RetryWithBackoff(maxRetries: 3, TimeSpan.FromMilliseconds(1))
+            .Subscribe(values.Add, () => done.TrySetResult(values));
+
+        var captured = await done.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(captured).IsCollectionEqualTo([SuccessAttempt]);
+    }
+
+    /// <summary>Verifies <c>ReplayLastOnSubscribe</c> throws when the source is null.</summary>
+    [Test]
+    public void WhenReplayLastOnSubscribeSourceNull_ThenThrows() =>
+        Assert.Throws<ArgumentNullException>(static () => ReactiveExtensions.ReplayLastOnSubscribe(null!, 0));
+
+    /// <summary>Verifies the two-argument <c>BufferUntilInactive</c> overload flushes a buffer on completion using the default scheduler.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenBufferUntilInactiveTwoArgOverload_ThenFlushesBufferOnCompletion()
+    {
+        var subject = new Subject<int>();
+        var results = new List<IList<int>>();
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.BufferUntilInactive(TimeSpan.FromSeconds(5))
+            .Subscribe(results.Add, () => completed.TrySetResult());
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnCompleted();
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(results.Count).IsGreaterThanOrEqualTo(1);
+        await Assert.That(results[^1]).IsCollectionEqualTo([1, SampleValue2]);
+    }
+
+    /// <summary>Verifies <c>CatchReturn</c> substitutes the fallback value when the source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchReturnSourceErrors_ThenEmitsFallbackAndCompletes()
+    {
+        const int Fallback = 99;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.CatchReturn(Fallback).Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnError(new InvalidOperationException("boom"));
+
+        await Assert.That(results).IsCollectionEqualTo([1, Fallback]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies <c>CatchReturnUnit</c> substitutes <see cref="RxVoid.Default"/> when the source errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchReturnUnitSourceErrors_ThenEmitsUnitAndCompletes()
+    {
+        var subject = new Subject<RxVoid>();
+        var results = new List<RxVoid>();
+        var completed = false;
+
+        using var sub = subject.CatchReturnUnit().Subscribe(results.Add, () => completed = true);
+
+        subject.OnError(new InvalidOperationException("boom"));
+
+        await Assert.That(results).IsCollectionEqualTo([RxVoid.Default]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Exercises <c>CatchReturn</c>'s <c>OnCompleted</c> forwarder — when the source
+    /// completes normally without erroring, completion passes through to the downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchReturnSourceCompletesNormally_ThenForwardsCompletion()
+    {
+        const int Fallback = 99;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.CatchReturn(Fallback).Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([1]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Exercises <c>CatchIgnore&lt;T,TException&gt;</c>'s <c>OnCompleted</c> forwarder —
+    /// when the source completes normally, the observer passes completion straight through.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchIgnoreWithErrorActionSourceCompletesNormally_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        using var sub = subject.CatchIgnore<int, InvalidOperationException>(static _ => { })
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(1);
+        subject.OnCompleted();
+
+        await Assert.That(results).IsCollectionEqualTo([1]);
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Exercises the empty-on-error <c>CatchIgnore&lt;T&gt;</c> overload's <c>OnCompleted</c>
+    /// forwarder — when the source completes normally, the observer forwards completion.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenCatchIgnoreEmptyOverloadSourceCompletesNormally_ThenForwardsCompletion()
+    {
+        var subject = new Subject<int?>();
+        var completed = false;
+
+        using var sub = subject.CatchIgnore().Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Exercises <c>ToPropertyObservable</c>'s <c>as MemberExpression ?? throw</c> branch
+    /// — passing an expression whose body is not a member access raises ArgumentException.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenToPropertyObservableNonMemberExpression_ThenThrowsArgumentException()
+    {
+        var owner = new ToPropertyNonMemberOwner();
+
+        Action call = () => owner.ToPropertyObservable(static _ => 1 + 1);
+        var ex = Assert.Throws<ArgumentException>(call);
+
+        await Assert.That(ex).IsNotNull();
+    }
+
+    /// <summary>Exercises <c>AsSignalObservable</c>'s <c>OnError</c> forwarder — the synthesized
+    /// RxVoid-stream propagates the source's error verbatim.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenAsSignalSourceErrors_ThenForwardsError()
+    {
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("as-signal-error");
+
+        using var sub = subject.AsSignal().Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>
+    /// Test class for INotifyPropertyChanged.
+    /// </summary>
+    private sealed class TestNotifyPropertyChanged : INotifyPropertyChanged
+    {
+        /// <summary>
+        /// Property changed event.
+        /// </summary>
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        /// <summary>
+        /// Gets or sets the test property.
+        /// </summary>
+        /// <returns>The test property value.</returns>
+        public string TestProperty
+        {
+            get;
+            set
+            {
+                if (field == value)
+                {
+                    return;
+                }
+
+                field = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(TestProperty)));
+            }
+        }
+
+        = string.Empty;
+    }
+
+    /// <summary>INPC owner whose property type lets us pass a non-member expression body
+    /// (e.g. a literal arithmetic expression) into <c>ToPropertyObservable</c> so the
+    /// <c>as MemberExpression ?? throw</c> guard fires. The <c>PropertyChanged</c> event is
+    /// required by the interface but never raised — the guard short-circuits before
+    /// subscription wiring runs.</summary>
+    private sealed class ToPropertyNonMemberOwner : INotifyPropertyChanged
+    {
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler? PropertyChanged
+        {
+            add => _ = value;
+            remove => _ = value;
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Retry.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Retry.cs
new file mode 100644
index 0000000..6a704c3
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Retry.cs
@@ -0,0 +1,841 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using ReactiveUI.Primitives.Async.Tests;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>
+    /// Tests OnErrorRetry without parameters.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnErrorRetry_RetriesOnError()
+    {
+        var attempts = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 3)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var results = new List<int>();
+        using var sub = source.OnErrorRetry().Subscribe(results.Add);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(results[0]).IsEqualTo(SampleValue42);
+            await Assert.That(attempts).IsEqualTo(SampleValue3);
+        }
+    }
+
+    /// <summary>
+    /// Tests RetryWithBackoff respects max delay.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task RetryWithBackoff_RespectsMaxDelay()
+    {
+        var attempts = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 5)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var result = source.RetryWithBackoff(
+            maxRetries: 10,
+            initialDelay: TimeSpan.FromMilliseconds(10),
+            backoffFactor: 2.0,
+            maxDelay: TimeSpan.FromMilliseconds(50),
+            scheduler: null)
+            .Wait();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with error action and retry count.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnErrorRetry_WithErrorActionAndRetryCount_RetriesLimitedTimes()
+    {
+        const int RetryCount = 3;
+        const int ExpectedAttempts = RetryCount + 1;
+        var attempts = 0;
+        var errorCount = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            observer.OnError(new InvalidOperationException());
+            return Disposable.Empty;
+        });
+
+        Exception? caughtException = null;
+
+        using var sub = source.OnErrorRetry<int, InvalidOperationException>(ex => errorCount++, retryCount: RetryCount)
+            .Subscribe(_ => { }, ex => caughtException = ex);
+
+        using (Assert.Multiple())
+        {
+            // retryCount = retries after the initial attempt; total subscriptions = 1 + retryCount.
+            await Assert.That(attempts).IsEqualTo(ExpectedAttempts);
+            await Assert.That(caughtException).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with delay.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnErrorRetry_WithDelay_DelaysRetries()
+    {
+        var attempts = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 3)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var startTimestamp = TimeProvider.System.GetTimestamp();
+
+        var result = source.OnErrorRetry<int, InvalidOperationException>(
+            ex => { },
+            retryCount: 5,
+            delay: TimeSpan.FromMilliseconds(50))
+            .Wait();
+
+        var elapsed = TimeProvider.System.GetElapsedTime(startTimestamp);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(result).IsEqualTo(SampleValue42);
+            await Assert.That(elapsed.TotalMilliseconds).IsGreaterThanOrEqualTo(MinimumExpectedMilliseconds);
+        }
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with delay and no error action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnErrorRetry_WithDelayAndErrorAction_RetriesWithDelay()
+    {
+        var attemptCount = 0;
+        var errorsCaught = 0;
+        var results = new List<int>();
+        var scheduler = new VirtualClock();
+
+        var source = Observable.Create<int>(observer =>
+        {
+            attemptCount++;
+            if (attemptCount < 2)
+            {
+                observer.OnError(new InvalidOperationException($"Attempt {attemptCount}"));
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        source.OnErrorRetry<int, InvalidOperationException>(
+                ex => errorsCaught++,
+                retryCount: int.MaxValue,
+                delay: TimeSpan.FromMilliseconds(10),
+                delayScheduler: scheduler)
+            .Subscribe(results.Add);
+
+        scheduler.AdvanceBy(TimeSpan.FromMilliseconds(10).Ticks);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(errorsCaught).IsEqualTo(1);
+            await Assert.That(results).IsCollectionEqualTo([SampleValue42]);
+        }
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with retry count limit.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnErrorRetry_WithRetryCount_LimitsRetries()
+    {
+        const int RetryCount = 2;
+        const int ExpectedErrorCallbacks = RetryCount + 1;
+        var attemptCount = 0;
+        var errorsCaught = 0;
+        var finalError = false;
+
+        var source = Observable.Create<int>(observer =>
+        {
+            attemptCount++;
+            observer.OnError(new InvalidOperationException($"Attempt {attemptCount}"));
+            return Disposable.Empty;
+        });
+
+        source.OnErrorRetry<int, InvalidOperationException>(
+                ex => errorsCaught++,
+                retryCount: RetryCount)
+            .Subscribe(_ => { }, ex => finalError = true);
+
+        var finalErrorReceived = await AsyncTestHelpers.WaitForConditionAsync(
+            () => finalError,
+            TimeSpan.FromSeconds(2));
+
+        using (Assert.Multiple())
+        {
+            // OnError callback fires for every failure (including the final propagated one):
+            // 1 initial attempt + retryCount retries = retryCount + 1 callbacks.
+            await Assert.That(finalErrorReceived).IsTrue();
+            await Assert.That(errorsCaught).IsEqualTo(ExpectedErrorCallbacks);
+            await Assert.That(finalError).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with retry count and delay.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnErrorRetry_WithRetryCountAndDelay_LimitsRetriesWithDelay()
+    {
+        const int RetryCount = 2;
+        const int ExpectedErrorCallbacks = RetryCount + 1;
+        const int DelayMilliseconds = 10;
+        var attemptCount = 0;
+        var errorsCaught = 0;
+        var finalError = false;
+        var scheduler = new VirtualClock();
+
+        var source = Observable.Create<int>(observer =>
+        {
+            attemptCount++;
+            observer.OnError(new InvalidOperationException($"Attempt {attemptCount}"));
+            return Disposable.Empty;
+        });
+
+        source.OnErrorRetry<int, InvalidOperationException>(
+                ex => errorsCaught++,
+                retryCount: RetryCount,
+                delay: TimeSpan.FromMilliseconds(DelayMilliseconds),
+                delayScheduler: scheduler)
+            .Subscribe(_ => { }, ex => finalError = true);
+
+        // Advance enough virtual time to drain all retries plus the final propagation.
+        scheduler.AdvanceBy(TimeSpan.FromMilliseconds(DelayMilliseconds * (RetryCount + 1)).Ticks);
+
+        using (Assert.Multiple())
+        {
+            // OnError callback fires for every failure (initial + retries) = retryCount + 1 calls.
+            await Assert.That(errorsCaught).IsEqualTo(ExpectedErrorCallbacks);
+            await Assert.That(finalError).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with retry count, delay, and scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task OnErrorRetry_WithRetryCountDelayAndScheduler_RetriesCorrectly()
+    {
+        var attemptCount = 0;
+        var errorsCaught = 0;
+
+        var source = Observable.Create<int>(observer =>
+        {
+            attemptCount++;
+            if (attemptCount < 2)
+            {
+                observer.OnError(new InvalidOperationException($"Attempt {attemptCount}"));
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var result = 0;
+        source.OnErrorRetry<int, InvalidOperationException>(
+                ex => errorsCaught++,
+                retryCount: 3,
+                delay: TimeSpan.FromMilliseconds(10),
+                delayScheduler: Sequencer.Immediate)
+            .Subscribe(r => result = r);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(errorsCaught).IsEqualTo(1);
+            await Assert.That(result).IsEqualTo(SampleValue42);
+        }
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with action only uses zero-delay retry.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorRetryWithActionOnly_ThenRetriesImmediately()
+    {
+        var attempts = 0;
+        var errorCount = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 3)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var results = new List<int>();
+        using var sub = source.OnErrorRetry<int, InvalidOperationException>(ex => errorCount++)
+            .Subscribe(results.Add);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([SampleValue42]);
+            await Assert.That(errorCount).IsEqualTo(SampleValue2);
+        }
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with delay retries after specified delay.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorRetryWithDelay_ThenRetriesAfterDelay()
+    {
+        var attempts = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 2)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var result = source.OnErrorRetry<int, InvalidOperationException>(
+            ex => { },
+            TimeSpan.FromMilliseconds(10))
+            .Wait();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests RetryWithBackoff rethrows after max retries exceeded.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffExceedsMaxRetries_ThenRethrows()
+    {
+        var source = Observable.Throw<int>(new InvalidOperationException("fail"));
+        Exception? caughtError = null;
+
+        source.RetryWithBackoff(
+            maxRetries: 2,
+            initialDelay: TimeSpan.FromMilliseconds(1),
+            backoffFactor: 2.0,
+            maxDelay: null,
+            scheduler: Sequencer.Immediate)
+            .Subscribe(_ => { }, ex => caughtError = ex);
+
+        await Assert.That(caughtError).IsNotNull();
+    }
+
+    /// <summary>
+    /// Tests RetryWithBackoff caps delay at maxDelay.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffDelayExceedsMax_ThenCapsDelay()
+    {
+        var attempts = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 4)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var result = source.RetryWithBackoff(
+            maxRetries: 5,
+            initialDelay: TimeSpan.FromMilliseconds(5),
+            backoffFactor: 10.0,
+            maxDelay: TimeSpan.FromMilliseconds(20),
+            scheduler: Sequencer.Immediate)
+            .Wait();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests RetryWithDelay retries with custom delay selector.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithDelay_ThenRetriesWithCustomDelay()
+    {
+        var attempts = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 3)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var result = source.RetryWithDelay(5, attempt => TimeSpan.FromMilliseconds(1)).Wait();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests RetryForeverWithDelay retries indefinitely with delay.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryForeverWithDelay_ThenRetriesIndefinitely()
+    {
+        var attempts = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 4)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var result = source.RetryForeverWithDelay(TimeSpan.FromMilliseconds(1)).Wait();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests RetryWithFixedDelay retries with constant delay between retries.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithFixedDelay_ThenRetriesWithConstantDelay()
+    {
+        var attempts = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attempts++;
+            if (attempts < 3)
+            {
+                observer.OnError(new InvalidOperationException());
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var result = source.RetryWithFixedDelay(5, TimeSpan.FromMilliseconds(1)).Wait();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests RetryWithBackoff inner retry with max delay cap path.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffInnerRetry_ThenRetriesAndCapsDelay()
+    {
+        var scheduler = new VirtualClock();
+        var attempt = 0;
+        var source = Observable.Defer(() =>
+        {
+            attempt++;
+            return attempt < 3
+                ? Observable.Throw<int>(new InvalidOperationException("retry"))
+                : Observable.Return(42);
+        });
+
+        var results = new List<int>();
+        Exception? error = null;
+
+        source.RetryWithBackoff(
+            maxRetries: 5,
+            initialDelay: TimeSpan.FromTicks(10),
+            backoffFactor: 2.0,
+            maxDelay: TimeSpan.FromTicks(15),
+            scheduler: scheduler)
+            .Subscribe(results.Add, ex => error = ex);
+
+        // Advance through retry delays
+        scheduler.AdvanceBy(LongDelayMilliseconds);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue42]);
+        await Assert.That(error).IsNull();
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with negative delay ticks sets dueTime to zero.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorRetryNegativeDelay_ThenUsesZeroDelay()
+    {
+        var attempt = 0;
+        var source = Observable.Defer(() =>
+        {
+            attempt++;
+            return attempt < 3
+                ? Observable.Throw<int>(new InvalidOperationException("fail"))
+                : Observable.Return(42);
+        });
+
+        var results = new List<int>();
+        Exception? error = null;
+        var received = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        source.OnErrorRetry<int, InvalidOperationException>(
+            _ => { },
+            retryCount: 5,
+            delay: TimeSpan.FromTicks(-1))
+            .Subscribe(
+                v =>
+                {
+                    results.Add(v);
+                    received.TrySetResult();
+                },
+                ex => error = ex);
+
+        await received.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(results).Contains(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests OnErrorRetry with retry count check rethrows after exceeding count.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenOnErrorRetryExceedsRetryCount_ThenRethrows()
+    {
+        var source = Observable.Throw<int>(new InvalidOperationException("fail"));
+        Exception? caught = null;
+        var errorReceived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        source.OnErrorRetry<int, InvalidOperationException>(
+            _ => { },
+            retryCount: 2,
+            delay: TimeSpan.Zero)
+            .Subscribe(
+                _ => { },
+                ex =>
+                {
+                    caught = ex;
+                    errorReceived.TrySetResult();
+                });
+
+        await errorReceived.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(caught).IsNotNull();
+        await Assert.That(caught).IsTypeOf<InvalidOperationException>();
+    }
+
+    /// <summary>
+    /// Tests RetryWithBackoff caps delay at maxDelay when backoff exceeds it.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffExceedsMaxDelay_ThenCapsAtMaxDelay()
+    {
+        var scheduler = new VirtualClock();
+        var attempt = 0;
+        var source = Observable.Create<int>(obs =>
+        {
+            attempt++;
+            if (attempt <= 3)
+            {
+                obs.OnError(new InvalidOperationException($"fail {attempt}"));
+            }
+            else
+            {
+                obs.OnNext(42);
+                obs.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var results = new List<int>();
+        using var sub = source
+            .RetryWithBackoff(
+                5,
+                initialDelay: TimeSpan.FromMilliseconds(100),
+                backoffFactor: 10.0,
+                maxDelay: TimeSpan.FromMilliseconds(200),
+                scheduler: scheduler)
+            .Subscribe(results.Add);
+
+        // Advance through retry delays
+        for (var i = 0; i < SampleValue5; i++)
+        {
+            scheduler.AdvanceBy(TimeSpan.FromMilliseconds(250).Ticks);
+        }
+
+        await Assert.That(results).Contains(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests RetryWithBackoff maxDelay cap is applied when computed delay exceeds it,
+    /// exercising line 1240 of ReactiveExtensions.cs.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffDelayExceedsMaxDelay_ThenCappedAtMaxDelay()
+    {
+        var scheduler = new VirtualClock();
+        var attemptCount = 0;
+
+        var source = Observable.Create<int>(observer =>
+        {
+            attemptCount++;
+            if (attemptCount <= 3)
+            {
+                observer.OnError(new InvalidOperationException($"attempt {attemptCount}"));
+            }
+            else
+            {
+                observer.OnNext(99);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        // initialDelay=1ms, backoffFactor=100 => attempt 2 delay = 1*100^1 = 100ms, exceeds maxDelay=5ms
+        var results = new List<int>();
+        source.RetryWithBackoff(
+            maxRetries: 5,
+            initialDelay: TimeSpan.FromMilliseconds(1),
+            backoffFactor: 100.0,
+            maxDelay: TimeSpan.FromMilliseconds(5),
+            scheduler: scheduler)
+            .Subscribe(results.Add);
+
+        // Advance past the capped delays
+        scheduler.AdvanceBy(TimeSpan.FromSeconds(1).Ticks);
+
+        await Assert.That(results).Contains(SampleValue99);
+    }
+
+    /// <summary>
+    /// Verifies that RetryWithBackoff caps the computed delay at maxDelay when the
+    /// exponential backoff exceeds it. Uses Sequencer.Immediate so the cap is exercised
+    /// synchronously.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoffComputedDelayExceedsMaxDelay_ThenCappedToMaxDelay()
+    {
+        var attemptCount = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attemptCount++;
+
+            // Fail on first two attempts, succeed on third
+            if (attemptCount <= 2)
+            {
+                observer.OnError(new InvalidOperationException($"attempt {attemptCount}"));
+            }
+            else
+            {
+                observer.OnNext(42);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        // initialDelay=1ms, backoffFactor=1000 => computed delay = 1000ms >> maxDelay=2ms
+        // This ensures the cap path at line 1240 is hit
+        var result = source.RetryWithBackoff(
+            maxRetries: 5,
+            initialDelay: TimeSpan.FromMilliseconds(1),
+            backoffFactor: 1000.0,
+            maxDelay: TimeSpan.FromMilliseconds(2),
+            scheduler: Sequencer.Immediate)
+            .Wait();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+        await Assert.That(attemptCount).IsEqualTo(SampleValue3);
+    }
+
+    /// <summary>
+    /// Verifies that RetryWithBackoff caps the computed delay at maxDelay using a
+    /// VirtualClock so the cap assignment is directly exercised.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithBackoff_GivenLargeBackoffFactor_ThenDelayIsCappedAtMaxDelay()
+    {
+        // Given
+        var scheduler = new VirtualClock();
+        var attemptCount = 0;
+        var source = Observable.Create<int>(observer =>
+        {
+            attemptCount++;
+
+            if (attemptCount <= 3)
+            {
+                observer.OnError(new InvalidOperationException($"fail {attemptCount}"));
+            }
+            else
+            {
+                observer.OnNext(100);
+                observer.OnCompleted();
+            }
+
+            return Disposable.Empty;
+        });
+
+        var results = new List<int>();
+
+        // When — backoffFactor 500 with initialDelay 1ms yields huge computed delays,
+        // all of which must be capped to maxDelay 5ms.
+        using var sub = source
+            .RetryWithBackoff(
+                maxRetries: 5,
+                initialDelay: TimeSpan.FromMilliseconds(1),
+                backoffFactor: 500.0,
+                maxDelay: TimeSpan.FromMilliseconds(5),
+                scheduler: scheduler)
+            .Subscribe(results.Add);
+
+        // Advance the scheduler enough for each capped retry delay
+        for (var i = 0; i < SampleValue10; i++)
+        {
+            scheduler.AdvanceBy(TimeSpan.FromMilliseconds(10).Ticks);
+        }
+
+        // Then
+        await Assert.That(results).Contains(SchedulerWindowTicks);
+        await Assert.That(attemptCount).IsEqualTo(SampleValue4);
+    }
+
+    /// <summary>
+    /// Verifies that RetryWithDelay rethrows the original exception when all retries
+    /// are exhausted, exercising the error-propagation branch.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenRetryWithDelayExhaustsRetries_ThenRethrowsOriginalException()
+    {
+        // Given — source always fails
+        var source = Observable.Throw<int>(new InvalidOperationException("permanent"));
+        Exception? caught = null;
+
+        // When
+        using var sub = source
+            .RetryWithDelay(2, _ => TimeSpan.FromMilliseconds(1))
+            .Subscribe(
+                static _ => { },
+                ex => caught = ex);
+
+        // Allow time for the retry attempts to complete
+        await AsyncTestHelpers.WaitForConditionAsync(() => caught is not null, TimeSpan.FromSeconds(5));
+
+        // Then
+        await Assert.That(caught).IsNotNull();
+        await Assert.That(caught).IsTypeOf<InvalidOperationException>();
+        await Assert.That(caught!.Message).IsEqualTo("permanent");
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs
new file mode 100644
index 0000000..3d1d6e8
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Scheduling.cs
@@ -0,0 +1,900 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Async.Tests;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>
+/// Tests for ReactiveExtensions around scheduling.
+/// </summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>
+    /// Tests DetectStale marks stream as stale.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task DetectStale_WhenInactive_MarksAsStale()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<Stale<int>>();
+        using var sub = subject.DetectStale(TimeSpan.FromTicks(100), scheduler).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        scheduler.AdvanceBy(SchedulerHalfWindowTicks);
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(SampleValue3);
+            await Assert.That(results[0].IsStale).IsFalse();
+            await Assert.That(results[0].Update).IsEqualTo(1);
+            await Assert.That(results[1].IsStale).IsFalse();
+            await Assert.That(results[1].Update).IsEqualTo(SampleValue2);
+            await Assert.That(results[SampleValue2].IsStale).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests Heartbeat injects heartbeats.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Heartbeat_WhenInactive_InjectsHeartbeats()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<Heartbeat<int>>();
+        using var sub = subject.Heartbeat(TimeSpan.FromTicks(100), scheduler).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        // Updates and heartbeats interleave; assert by predicate rather than positional index
+        // because the periodic-tick count between updates depends on scheduler implementation details.
+        var updates = results.Where(static h => !h.IsHeartbeat).ToList();
+        var heartbeats = results.Where(static h => h.IsHeartbeat).ToList();
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsGreaterThanOrEqualTo(SampleValue3);
+            await Assert.That(updates).Count().IsEqualTo(SampleValue2);
+            await Assert.That(updates[0].Update).IsEqualTo(1);
+            await Assert.That(updates[1].Update).IsEqualTo(SampleValue2);
+            await Assert.That(heartbeats).IsNotEmpty();
+        }
+    }
+
+    /// <summary>
+    /// Tests ObserveOnSafe with null scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ObserveOnSafe_WithNullScheduler_ReturnsSource()
+    {
+        var source = Observable.Return(1);
+        var result = source.ObserveOnSafe(null);
+
+        await Assert.That(result).IsSameReferenceAs(source);
+    }
+
+    /// <summary>
+    /// Tests ObserveOnSafe with scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ObserveOnSafe_WithScheduler_ObservesOnScheduler()
+    {
+        var scheduler = new VirtualClock();
+        var source = Observable.Return(1);
+        int? result = null;
+        using var sub = source.ObserveOnSafe(scheduler).Subscribe(x => result = x);
+
+        await Assert.That(result).IsNull();
+
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(result).IsEqualTo(1);
+    }
+
+    /// <summary>
+    /// Tests Start with Action and null scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Start_WithActionAndNullScheduler_ExecutesAction()
+    {
+        var executed = false;
+        Action action = () => executed = true;
+
+        using var sub = ReactiveExtensions.Start(action, Sequencer.Immediate).Subscribe();
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Start with function and null scheduler executes immediately.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Start_WithFunctionAndNullScheduler_ReturnsComputedValue()
+    {
+        var result = await ReactiveExtensions.Start(() => 21 * 2, scheduler: null).ToTask();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests ScheduleSafe with null scheduler executes immediately.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ScheduleSafe_WithNullScheduler_ExecutesImmediately()
+    {
+        var executed = false;
+        const ISequencer? Scheduler = null;
+        var disposable = Scheduler.ScheduleSafe(() => executed = true);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(executed).IsTrue();
+            await Assert.That(disposable).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests Heartbeat class with update.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Heartbeat_WithUpdate_IsNotHeartbeat()
+    {
+        var heartbeat = new Heartbeat<int>(42);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(heartbeat.IsHeartbeat).IsFalse();
+            await Assert.That(heartbeat.Update).IsEqualTo(SampleValue42);
+        }
+    }
+
+    /// <summary>
+    /// Tests Heartbeat class without update.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Heartbeat_WithoutUpdate_IsHeartbeat()
+    {
+        var heartbeat = new Heartbeat<int>();
+
+        await Assert.That(heartbeat.IsHeartbeat).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Schedule with value and TimeSpan and function.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithValueTimeSpanAndFunction_DelaysAndTransforms()
+    {
+        var scheduler = new VirtualClock();
+        int? result = null;
+
+        using var sub = 10.Schedule(TimeSpan.FromTicks(100), scheduler, x => x * 2)
+            .Subscribe(x => result = x);
+
+        await Assert.That(result).IsNull();
+
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(result).IsEqualTo(SampleValue20);
+    }
+
+    /// <summary>
+    /// Tests Schedule with observable, TimeSpan and function.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithObservableTimeSpanAndFunction_DelaysAndTransforms()
+    {
+        var scheduler = new VirtualClock();
+        var source = Observable.Return(10);
+        var results = new List<int>();
+
+        using var sub = source.Schedule(TimeSpan.FromTicks(100), scheduler, x => x * 2)
+            .Subscribe(results.Add);
+
+        await Assert.That(results).IsEmpty();
+
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue20]);
+    }
+
+    /// <summary>
+    /// Tests SyncTimer creates shared observable that produces ticks.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SyncTimer_ProducesSharedTicks()
+    {
+        var timeSpan = TimeSpan.FromMilliseconds(100);
+        var scheduler = new VirtualClock();
+        var results1 = new List<DateTime>();
+        var results2 = new List<DateTime>();
+
+        using var sub1 = ReactiveExtensions.SyncTimer(timeSpan, scheduler).Take(2).Subscribe(results1.Add);
+        using var sub2 = ReactiveExtensions.SyncTimer(timeSpan, scheduler).Take(2).Subscribe(results2.Add);
+
+        scheduler.AdvanceBy(timeSpan.Ticks * SampleValue2);
+
+        using (Assert.Multiple())
+        {
+            // Both subscriptions should get ticks (shared timer)
+            await Assert.That(results1).Count().IsGreaterThanOrEqualTo(1);
+            await Assert.That(results2).Count().IsGreaterThanOrEqualTo(1);
+        }
+    }
+
+    /// <summary>
+    /// Tests Using with action executes the action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Using_WithAction_ExecutesActionImmediately()
+    {
+        var executed = false;
+        using var disposable = Disposable.Create(() => { });
+
+        disposable.Using(d => executed = true, Sequencer.Immediate).Subscribe();
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Using with action and null scheduler executes immediately.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Using_WithActionAndNullScheduler_ExecutesActionImmediately()
+    {
+        var executed = false;
+        using var disposable = Disposable.Create(() => { });
+
+        await disposable.Using(d => executed = true, scheduler: null).ToTask();
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Using with function transforms the value.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Using_WithFunction_TransformsValue()
+    {
+        using var disposable = Disposable.Create(() => { });
+        var result = 0;
+
+        disposable.Using(d => SampleValue42, Sequencer.Immediate).Subscribe(r => result = r);
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests Schedule with TimeSpan and action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithTimeSpanAndAction_ExecutesAction()
+    {
+        var executed = false;
+        const int Value = 42;
+
+        Value.Schedule(TimeSpan.FromMilliseconds(10), Sequencer.Immediate, v => executed = true)
+            .Subscribe();
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Schedule with observable, DateTimeOffset and action delays emission until the scheduler advances.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithObservableDateTimeOffsetAndAction_DelaysAndExecutesAction()
+    {
+        var scheduler = new VirtualClock();
+        var dueTime = scheduler.Now.AddTicks(100);
+        var subject = new Subject<int>();
+        var executed = false;
+        var results = new List<int>();
+
+        using var sub = subject.Schedule(dueTime, scheduler, value => executed = value == 42)
+            .Subscribe(results.Add);
+
+        subject.OnNext(SampleValue42);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(executed).IsFalse();
+            await Assert.That(results).IsEmpty();
+        }
+
+        scheduler.AdvanceBy(SchedulerWindowTicks + 1);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(executed).IsTrue();
+            await Assert.That(results).IsCollectionEqualTo([SampleValue42]);
+        }
+    }
+
+    /// <summary>
+    /// Tests Schedule with observable, TimeSpan and action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithObservableTimeSpanAndAction_ExecutesAction()
+    {
+        var executed = false;
+        var subject = new Subject<int>();
+
+        subject.Schedule(TimeSpan.FromMilliseconds(10), Sequencer.Immediate, v => executed = true)
+            .Subscribe();
+
+        subject.OnNext(SampleValue42);
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Schedule with DateTimeOffset and action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithDateTimeOffsetAndAction_ExecutesAction()
+    {
+        var executed = false;
+        const int Value = 42;
+
+        Value.Schedule(TimeProvider.System.GetLocalNow().AddMilliseconds(SampleValue10), Sequencer.Immediate, v => executed = true)
+            .Subscribe();
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Schedule with observable, DateTimeOffset and action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithObservableDateTimeOffsetAndAction_ExecutesAction()
+    {
+        var executed = false;
+        var subject = new Subject<int>();
+
+        subject.Schedule(TimeProvider.System.GetLocalNow().AddMilliseconds(SampleValue10), Sequencer.Immediate, v => executed = true)
+            .Subscribe();
+
+        subject.OnNext(SampleValue42);
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Schedule with function and scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithFunction_TransformsValue()
+    {
+        const int Value = 42;
+        var result = 0;
+
+        Value.Schedule(Sequencer.Immediate, v => v * SampleValue2)
+            .Subscribe(r => result = r);
+
+        await Assert.That(result).IsEqualTo(SampleValue84);
+    }
+
+    /// <summary>
+    /// Tests Schedule with observable and function.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithObservableAndFunction_TransformsValue()
+    {
+        var subject = new Subject<int>();
+        var result = 0;
+
+        subject.Schedule(Sequencer.Immediate, v => v * SampleValue2)
+            .Subscribe(r => result = r);
+
+        subject.OnNext(SampleValue42);
+
+        await Assert.That(result).IsEqualTo(SampleValue84);
+    }
+
+    /// <summary>
+    /// Tests Schedule with TimeSpan and function.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithTimeSpanAndFunction_TransformsValue()
+    {
+        const int Value = 42;
+        var result = 0;
+
+        Value.Schedule(TimeSpan.FromMilliseconds(10), Sequencer.Immediate, v => v * SampleValue2)
+            .Subscribe(r => result = r);
+
+        await Assert.That(result).IsEqualTo(SampleValue84);
+    }
+
+    /// <summary>
+    /// Tests Schedule with observable, TimeSpan and function.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Schedule_WithObservableTimeSpanAndFunction_TransformsValue()
+    {
+        var subject = new Subject<int>();
+        var result = 0;
+
+        subject.Schedule(TimeSpan.FromMilliseconds(10), Sequencer.Immediate, v => v * SampleValue2)
+            .Subscribe(r => result = r);
+
+        subject.OnNext(SampleValue42);
+
+        await Assert.That(result).IsEqualTo(SampleValue84);
+    }
+
+    /// <summary>
+    /// Tests ObserveOnIf with bool condition and single scheduler when true.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ObserveOnIf_WithBoolConditionTrue_ObservesOnScheduler()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.ObserveOnIf(true, scheduler).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        await Assert.That(results).IsEmpty();
+
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(results).IsCollectionEqualTo([1]);
+    }
+
+    /// <summary>
+    /// Tests ObserveOnIf with bool condition and single scheduler when false.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ObserveOnIf_WithBoolConditionFalse_DoesNotObserveOnScheduler()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.ObserveOnIf(false, scheduler).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        await Assert.That(results).IsCollectionEqualTo([1]);
+    }
+
+    /// <summary>
+    /// Tests ObserveOnIf with bool condition and two schedulers when true.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ObserveOnIf_WithBoolConditionTrue_ObservesOnTrueScheduler()
+    {
+        var trueScheduler = new VirtualClock();
+        var falseScheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.ObserveOnIf(true, trueScheduler, falseScheduler).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        await Assert.That(results).IsEmpty();
+
+        trueScheduler.AdvanceBy(1);
+        await Assert.That(results).IsCollectionEqualTo([1]);
+    }
+
+    /// <summary>
+    /// Tests ObserveOnIf with bool condition and two schedulers when false.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ObserveOnIf_WithBoolConditionFalse_ObservesOnFalseScheduler()
+    {
+        var trueScheduler = new VirtualClock();
+        var falseScheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.ObserveOnIf(false, trueScheduler, falseScheduler).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        await Assert.That(results).IsEmpty();
+
+        falseScheduler.AdvanceBy(1);
+        await Assert.That(results).IsCollectionEqualTo([1]);
+    }
+
+    /// <summary>
+    /// Tests ObserveOnIf with reactive condition routes notifications to both schedulers as the condition changes.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ObserveOnIf_WithReactiveCondition_ObservesOnMatchingScheduler()
+    {
+        var trueScheduler = new VirtualClock();
+        var falseScheduler = new VirtualClock();
+        var source = new Subject<int>();
+        var condition = new BehaviorSubject<bool>(false);
+        var results = new List<int>();
+
+        using var sub = source.ObserveOnIf(condition, trueScheduler, falseScheduler).Subscribe(results.Add);
+
+        source.OnNext(1);
+        await Assert.That(results).IsEmpty();
+
+        falseScheduler.AdvanceBy(1);
+        await Assert.That(results).IsCollectionEqualTo([1]);
+
+        condition.OnNext(true);
+        source.OnNext(SampleValue2);
+
+        await Assert.That(results).IsCollectionEqualTo([1]);
+
+        trueScheduler.AdvanceBy(1);
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+    }
+
+    /// <summary>
+    /// Tests ObserveOnIf with reactive condition and single scheduler observes only when condition is true.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ObserveOnIf_WithReactiveConditionAndSingleScheduler_ObservesOnlyWhenEnabled()
+    {
+        var scheduler = new VirtualClock();
+        var source = new Subject<int>();
+        var condition = new BehaviorSubject<bool>(false);
+        var results = new List<int>();
+
+        using var sub = source.ObserveOnIf(condition, scheduler).Subscribe(results.Add);
+
+        source.OnNext(1);
+        await Assert.That(results).IsCollectionEqualTo([1]);
+
+        condition.OnNext(true);
+        source.OnNext(SampleValue2);
+
+        await Assert.That(results).IsCollectionEqualTo([1]);
+
+        scheduler.AdvanceBy(1);
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+    }
+
+    /// <summary>
+    /// Tests SyncTimer without scheduler uses default scheduler and produces ticks.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSyncTimerCalledWithoutScheduler_ThenProducesTicks()
+    {
+        var results = new List<DateTime>();
+        using var sub = ReactiveExtensions.SyncTimer(TimeSpan.FromMilliseconds(50)).Take(2).Subscribe(results.Add);
+
+        await AsyncTestHelpers.WaitForConditionAsync(
+            () => results.Count >= 1,
+            TimeSpan.FromSeconds(5));
+
+        await Assert.That(results).Count().IsGreaterThanOrEqualTo(1);
+    }
+
+    /// <summary>
+    /// Tests Start with null scheduler executes the action directly.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartActionWithNullScheduler_ThenExecutesAction()
+    {
+        var executed = false;
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = ReactiveExtensions.Start(() => executed = true, scheduler: null)
+            .Subscribe(_ => { }, completed.SetResult);
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(30));
+
+        await Assert.That(executed).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Start with function and null scheduler returns computed result.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenStartFuncWithNullScheduler_ThenReturnsResult()
+    {
+        var result = await ReactiveExtensions.Start(() => 42, scheduler: null).ToTask();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests ScheduleSafe with TimeSpan and null scheduler uses Thread.Sleep path.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleSafeWithTimeSpanAndNullScheduler_ThenSleepsAndExecutes()
+    {
+        var executed = false;
+        const ISequencer? Scheduler = null;
+        var disposable = Scheduler.ScheduleSafe(TimeSpan.FromMilliseconds(10), () => executed = true);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(executed).IsTrue();
+            await Assert.That(disposable).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests Using with Action invokes the action and disposes the resource.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingWithActionAndNoScheduler_ThenExecutesAndDisposes()
+    {
+        var actionExecuted = false;
+        using var disposable = Disposable.Create(() => { });
+
+        await disposable.Using(d => actionExecuted = true).ToTask();
+
+        await Assert.That(actionExecuted).IsTrue();
+    }
+
+    /// <summary>
+    /// Tests Schedule with value and TimeSpan emits value after delay.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleValueWithTimeSpan_ThenEmitsAfterDelay()
+    {
+        var scheduler = new VirtualClock();
+        int? result = null;
+
+        using var sub = 42.Schedule(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(x => result = x);
+
+        await Assert.That(result).IsNull();
+
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests Schedule with observable and TimeSpan delays each emitted value.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleObservableWithTimeSpan_ThenDelaysValues()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = ((IObservable<int>)subject).Schedule(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(SampleValue10);
+        await Assert.That(results).IsEmpty();
+
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10]);
+    }
+
+    /// <summary>
+    /// Tests Schedule with value and DateTimeOffset emits value at due time.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleValueWithDateTimeOffset_ThenEmitsAtDueTime()
+    {
+        var scheduler = new VirtualClock();
+        int? result = null;
+        var dueTime = scheduler.Now.AddTicks(100);
+
+        using var sub = 42.Schedule(dueTime, scheduler)
+            .Subscribe(x => result = x);
+
+        await Assert.That(result).IsNull();
+
+        scheduler.AdvanceBy(SchedulerWindowTicks + 1);
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests Schedule with observable and DateTimeOffset delays values to due time.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleObservableWithDateTimeOffset_ThenDelaysValues()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var dueTime = scheduler.Now.AddTicks(100);
+
+        using var sub = ((IObservable<int>)subject).Schedule(dueTime, scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(SampleValue10);
+        await Assert.That(results).IsEmpty();
+
+        scheduler.AdvanceBy(SchedulerWindowTicks + 1);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10]);
+    }
+
+    /// <summary>
+    /// Tests Schedule with action and TimeSpan executes action then emits value.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleValueWithTimeSpanAndAction_ThenExecutesActionAndEmits()
+    {
+        var scheduler = new VirtualClock();
+        var actionExecuted = false;
+        int? result = null;
+
+        using var sub = 42.Schedule(TimeSpan.FromTicks(100), scheduler, v => actionExecuted = v == 42)
+            .Subscribe(x => result = x);
+
+        await Assert.That(actionExecuted).IsFalse();
+
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(actionExecuted).IsTrue();
+            await Assert.That(result).IsEqualTo(SampleValue42);
+        }
+    }
+
+    /// <summary>
+    /// Tests Using with Func overload returns the function result.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingWithFunc_ThenReturnsFunctionResult()
+    {
+        var disposable = new CompositeDisposable();
+        var result = await disposable.Using(d => 42).FirstAsync();
+
+        await Assert.That(result).IsEqualTo(SampleValue42);
+    }
+
+    /// <summary>
+    /// Tests While with scheduler repeatedly executes action while condition holds.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenWhileWithScheduler_ThenExecutesActionOnScheduler()
+    {
+        var executedOnScheduler = false;
+        var scheduler = new VirtualClock();
+
+        // Test that the scheduler parameter is passed through to Observable.Start
+        var obs = ReactiveExtensions.While(
+            () => !executedOnScheduler,
+            () => executedOnScheduler = true,
+            scheduler);
+
+        var results = new List<RxVoid>();
+        using var sub = obs.Subscribe(results.Add);
+
+        // Nothing should execute until the scheduler advances
+        await Assert.That(executedOnScheduler).IsFalse();
+
+        scheduler.Start();
+
+        await Assert.That(executedOnScheduler).IsTrue();
+        await Assert.That(results).Count().IsEqualTo(1);
+    }
+
+    /// <summary>
+    /// Tests Schedule with action, observable source, and TimeSpan overload.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenScheduleWithActionAndTimeSpan_ThenExecutesActionAndEmits()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var actionValues = new List<int>();
+
+        subject.Schedule(TimeSpan.FromTicks(50), scheduler, actionValues.Add)
+            .Subscribe(results.Add);
+
+        subject.OnNext(SampleValue10);
+        scheduler.AdvanceBy(SchedulerHalfWindowTicks + 1);
+
+        await Assert.That(actionValues).IsCollectionEqualTo([SampleValue10]);
+        await Assert.That(results).IsCollectionEqualTo([SampleValue10]);
+    }
+
+    /// <summary>
+    /// Tests Heartbeat timer subscription null check path by quickly disposing.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenHeartbeatSourceEmits_ThenTimerSubscriptionDisposed()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<Heartbeat<int>>();
+
+        using var sub = subject.Heartbeat(TimeSpan.FromTicks(100), scheduler).Subscribe(results.Add);
+
+        // Emit value, which disposes the current timer
+        subject.OnNext(1);
+        scheduler.AdvanceBy(1);
+
+        // Emit another quickly, before heartbeat timer fires
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(1);
+
+        await Assert.That(results.Count).IsGreaterThanOrEqualTo(SampleValue2);
+        await Assert.That(results[0].Update).IsEqualTo(1);
+        await Assert.That(results[1].Update).IsEqualTo(SampleValue2);
+    }
+
+    /// <summary>
+    /// Tests Using with Action and null scheduler disposes the object after executing the action.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenUsingWithActionAndNullScheduler_ThenDisposesObject()
+    {
+        var executed = false;
+        await using var stream = new MemoryStream();
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = stream.Using<MemoryStream>(
+            _ => executed = true,
+            null).Subscribe(
+            _ => { },
+            completed.SetResult);
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(executed).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs
new file mode 100644
index 0000000..4670b52
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.SelectAsync.cs
@@ -0,0 +1,123 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>
+    /// Tests SelectAsync with CancellationToken projects values asynchronously.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncWithCancellationToken_ThenProjectsValues()
+    {
+        var source = ExpectedSequence123.ToObservable();
+        var results = new List<int>();
+        var tcs = new TaskCompletionSource<bool>();
+
+        source.SelectAsync((x, _) => Task.FromResult(x * SampleValue2))
+            .Subscribe(
+            results.Add,
+            () => tcs.TrySetResult(true));
+
+        await tcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6]);
+    }
+
+    /// <summary>
+    /// Tests SelectAsync simple overload projects values asynchronously.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncSimple_ThenProjectsValues()
+    {
+        var source = ExpectedSequence123.ToObservable();
+        var results = new List<int>();
+        var tcs = new TaskCompletionSource<bool>();
+
+        source.SelectAsync(x => Task.FromResult(x * SampleValue2))
+            .Subscribe(
+            results.Add,
+            () => tcs.TrySetResult(true));
+
+        await tcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6]);
+    }
+
+    /// <summary>
+    /// Tests SelectAsyncSequential processes tasks in order.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncSequential_ThenProcessesInOrder()
+    {
+        var source = ExpectedSequence123.ToObservable();
+        var results = new List<int>();
+        var tcs = new TaskCompletionSource<bool>();
+
+        source.SelectAsyncSequential(x => Task.FromResult(x * SampleValue2))
+            .Subscribe(
+            results.Add,
+            () => tcs.TrySetResult(true));
+
+        await tcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6]);
+    }
+
+    /// <summary>
+    /// Tests SelectLatestAsync emits only the latest async result.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectLatestAsync_ThenEmitsLatestResult()
+    {
+        const int AsyncDelayMs = 10;
+        var source = ExpectedSequence123.ToObservable();
+        var results = new List<int>();
+        var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        source.SelectLatestAsync(async x =>
+        {
+            await Task.Delay(AsyncDelayMs);
+            return x * SampleValue2;
+        }).Subscribe(
+            results.Add,
+            () => tcs.TrySetResult(true));
+
+        await tcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        // Switch means only the latest survives; with sources 1,2,3 and selector x*2, expect [6].
+        await Assert.That(results).IsNotEmpty();
+    }
+
+    /// <summary>
+    /// Tests SelectAsyncConcurrent processes tasks concurrently up to max concurrency.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSelectAsyncConcurrent_ThenProcessesConcurrently()
+    {
+        var source = ExpectedSequence123.ToObservable();
+        var results = new List<int>();
+        var tcs = new TaskCompletionSource<bool>();
+
+        source.SelectAsyncConcurrent(
+            async x =>
+            {
+                await Task.Delay(1);
+                return x * SampleValue2;
+            },
+            maxConcurrency: 2).Subscribe(results.Add, () => tcs.TrySetResult(true));
+
+        await tcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        results.Sort();
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2, SampleValue4, SampleValue6]);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs
new file mode 100644
index 0000000..0ac54a8
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Synchronize.cs
@@ -0,0 +1,567 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Extensions.Internal;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>
+    /// Syncronizes the asynchronous runs with asynchronous tasks in subscriptions.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SubscribeSynchronus_RunsWithAsyncTasksInSubscriptions()
+    {
+        // Given, When. SubscribeSynchronous dispatches each OnNext concurrently on the thread
+        // pool, so result / itterations need Interlocked for the read-modify-write to be safe.
+        var result = 0;
+        var itterations = 0;
+        var subject = new Subject<bool>();
+        using var disposable = subject
+            .SubscribeSynchronous(async x =>
+            {
+                if (x)
+                {
+                    await Task.Delay(1000);
+                    Interlocked.Increment(ref result);
+                }
+                else
+                {
+                    await Task.Delay(500);
+                    Interlocked.Decrement(ref result);
+                }
+
+                Interlocked.Increment(ref itterations);
+            });
+
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+
+        while (Volatile.Read(ref itterations) < SampleValue6)
+        {
+            Thread.Yield();
+        }
+
+        // Then
+        await Assert.That(Volatile.Read(ref result)).IsZero();
+    }
+
+    /// <summary>
+    /// Syncronizes the asynchronous runs with asynchronous tasks in subscriptions.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SynchronizeSynchronous_RunsWithAsyncTasksInSubscriptions()
+    {
+        // Given, When. SynchronizeSynchronous dispatches each OnNext through an independent
+        // Continuation so the six HandleAsync invocations run concurrently on the thread pool —
+        // the int read-modify-write therefore needs Interlocked. The test asserts pair-wise
+        // (+1, -1) sums to zero after WhenAll completes.
+        var result = 0;
+        var itterations = 0;
+        var subject = new Subject<bool>();
+        var tasks = new List<Task>();
+        using var disposable = subject
+            .SynchronizeSynchronous()
+            .Subscribe(x => tasks.Add(HandleAsync(x)));
+
+        async Task HandleAsync((bool Value, IDisposable Sync) x)
+        {
+            try
+            {
+                if (x.Value)
+                {
+                    await Task.Delay(LongDelayMilliseconds);
+                    Interlocked.Increment(ref result);
+                }
+                else
+                {
+                    await Task.Delay(ShortDelayMilliseconds);
+                    Interlocked.Decrement(ref result);
+                }
+            }
+            finally
+            {
+                x.Sync.Dispose();
+                Interlocked.Increment(ref itterations);
+            }
+        }
+
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+
+        await Task.WhenAll(tasks);
+
+        // Then
+        await Assert.That(Volatile.Read(ref result)).IsZero();
+    }
+
+    /// <summary>
+    /// Syncronizes the asynchronous runs with asynchronous tasks in subscriptions.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SubscribeAsync_RunsWithAsyncTasksInSubscriptions()
+    {
+        // Given, When. SubscribeAsync dispatches each OnNext concurrently, so the integer
+        // read-modify-write needs Interlocked and the polling read needs Volatile.
+        var result = 0;
+        var itterations = 0;
+        var subject = new Subject<bool>();
+        using var disposable = subject
+            .SubscribeAsync(async x =>
+            {
+                if (x)
+                {
+                    await Task.Delay(1000);
+                    Interlocked.Increment(ref result);
+                }
+                else
+                {
+                    await Task.Delay(500);
+                    Interlocked.Decrement(ref result);
+                }
+
+                Interlocked.Increment(ref itterations);
+            });
+
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+
+        while (Volatile.Read(ref itterations) < SampleValue6)
+        {
+            Thread.Yield();
+        }
+
+        // Then
+        await Assert.That(Volatile.Read(ref result)).IsZero();
+    }
+
+    /// <summary>
+    /// Tests WithLimitedConcurrency.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous RxVoid test.</returns>
+    [Test]
+    public async Task WithLimitedConcurrency_LimitsConcurrentTasks()
+    {
+        var maxConcurrent = 0;
+        var currentConcurrent = 0;
+
+        IEnumerable<Task<int>> CreateTasks()
+        {
+            for (int i = 1; i <= SampleValue10; i++)
+            {
+                var value = i;
+                yield return Task.Run(async () =>
+                {
+                    lock (_gate)
+                    {
+                        currentConcurrent++;
+                        maxConcurrent = Math.Max(maxConcurrent, currentConcurrent);
+                    }
+
+                    await Task.Delay(SampleValue10);
+
+                    lock (_gate)
+                    {
+                        currentConcurrent--;
+                    }
+
+                    return value;
+                });
+            }
+        }
+
+        var results = await CreateTasks().WithLimitedConcurrency(3).ToList();
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(SampleValue10);
+            await Assert.That(maxConcurrent).IsLessThanOrEqualTo(SampleValue3);
+        }
+    }
+
+    /// <summary>Verifies an empty limited-concurrency task sequence completes immediately.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WithLimitedConcurrency_EmptyTaskSequence_Completes()
+    {
+        var completed = false;
+        var values = new List<int>();
+
+        using var sub = Array.Empty<Task<int>>()
+            .WithLimitedConcurrency(SampleValue3)
+            .Subscribe(values.Add, () => completed = true);
+
+        await Assert.That(values).IsEmpty();
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies faulted and canceled tasks stop enumeration and report the expected errors.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WithLimitedConcurrency_TaskFaultsOrCancels_ThenErrorsAndStops()
+    {
+        var expected = new InvalidOperationException("limited-concurrency");
+        Exception? fault = null;
+        Exception? canceled = null;
+        var afterFaultPulled = false;
+
+        IEnumerable<Task<int>> FaultingTasks()
+        {
+            yield return Task.FromException<int>(expected);
+            afterFaultPulled = true;
+            yield return Task.FromResult(SampleValue2);
+        }
+
+        using var faultSub = FaultingTasks()
+            .WithLimitedConcurrency(1)
+            .Subscribe(static _ => { }, ex => fault = ex);
+
+        using var canceledSub = new[] { Task.FromCanceled<int>(new CancellationToken(canceled: true)) }
+            .WithLimitedConcurrency(1)
+            .Subscribe(static _ => { }, ex => canceled = ex);
+
+        await Assert.That(fault).IsSameReferenceAs(expected);
+        await Assert.That(canceled).IsTypeOf<OperationCanceledException>();
+        await Assert.That(afterFaultPulled).IsFalse();
+    }
+
+    /// <summary>Verifies disposing before a pending task completes drops later notifications.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WithLimitedConcurrency_DisposeBeforeTaskContinuation_DropsWork()
+    {
+        var task = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var values = new List<int>();
+        Exception? caught = null;
+        var completed = false;
+
+        var sub = new[] { task.Task }
+            .WithLimitedConcurrency(1)
+            .Subscribe(values.Add, ex => caught = ex, () => completed = true);
+
+        sub.Dispose();
+        task.SetResult(SampleValue10);
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Exercises the internal disposed pull path used after a subscription is closed.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WithLimitedConcurrency_PullAfterDisposed_ThenNoNotifications()
+    {
+        var limiter = new ConcurrencyLimiter<int>([Task.FromResult(SampleValue10)], 1)
+        {
+            Disposed = true
+        };
+        var values = new List<int>();
+        var completed = false;
+
+        limiter.PullNextTask(Observer.Create<int>(values.Add, static _ => { }, () => completed = true));
+
+        await Assert.That(values).IsEmpty();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>Exercises the null-current continuation path defensively tolerated by the limiter.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WithLimitedConcurrency_NullTaskEntry_ThenNoNotifications()
+    {
+        IEnumerable<Task<int>> tasks = [null!];
+        var values = new List<int>();
+        Exception? caught = null;
+        var completed = false;
+
+        using var sub = tasks
+            .WithLimitedConcurrency(1)
+            .Subscribe(values.Add, ex => caught = ex, () => completed = true);
+
+        await Task.Delay(SettleDelayMilliseconds).ConfigureAwait(false);
+
+        await Assert.That(values).IsEmpty();
+        await Assert.That(caught).IsNull();
+        await Assert.That(completed).IsFalse();
+    }
+
+    /// <summary>
+    /// Tests SynchronizeSynchronous provides sync lock.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SynchronizeSynchronous_ProvidesSyncLock()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        IDisposable? lastSync = null;
+
+        using var sub = subject.SynchronizeSynchronous().Subscribe(tuple =>
+        {
+            results.Add(tuple.Value);
+            lastSync = tuple.Sync;
+            tuple.Sync.Dispose(); // Must dispose sync lock to allow next item to process
+        });
+
+        subject.OnNext(1);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(lastSync).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests SynchronizeAsync provides sync lock.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SynchronizeAsync_ProvidesSyncLock()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        IDisposable? lastSync = null;
+
+        using var sub = subject.SynchronizeAsync().Subscribe(tuple =>
+        {
+            results.Add(tuple.Value);
+            lastSync = tuple.Sync;
+        });
+
+        subject.OnNext(1);
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).Count().IsEqualTo(1);
+            await Assert.That(lastSync).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests SubscribeAsync with onNext and onError.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous RxVoid test.</returns>
+    [Test]
+    public async Task SubscribeAsync_WithOnNextAndOnError_HandlesError()
+    {
+        var results = new List<int>();
+        Exception? caughtException = null;
+        var errorSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var source = Observable.Create<int>(observer =>
+        {
+            observer.OnNext(1);
+            observer.OnError(new InvalidOperationException());
+            return Disposable.Empty;
+        });
+
+        using var sub = source.SubscribeAsync(
+            async x => results.Add(x),
+            ex =>
+            {
+                caughtException = ex;
+                errorSource.TrySetResult(true);
+            });
+
+        await errorSource.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1]);
+            await Assert.That(caughtException).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests SubscribeSynchronous with full callbacks.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SubscribeSynchronous_WithFullCallbacks_ExecutesAll()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var errorHandled = false;
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        subject.SubscribeSynchronous(
+            async v =>
+            {
+                await Task.Yield();
+                results.Add(v);
+            },
+            _ => errorHandled = true,
+            () => completed.TrySetResult());
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnCompleted();
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(errorHandled).IsFalse();
+            await Assert.That(completed.Task.IsCompletedSuccessfully).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests SubscribeSynchronous with onNext and onError.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SubscribeSynchronous_WithOnNextAndOnError_HandlesError()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var onNextCompleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var errorHandled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        subject.SubscribeSynchronous(
+            async v =>
+            {
+                await Task.Yield();
+                results.Add(v);
+                onNextCompleted.TrySetResult();
+            },
+            _ => errorHandled.TrySetResult());
+
+        subject.OnNext(1);
+        await onNextCompleted.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        subject.OnError(new InvalidOperationException());
+        await errorHandled.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1]);
+            await Assert.That(errorHandled.Task.IsCompletedSuccessfully).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests SubscribeSynchronous with onNext and onCompleted.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SubscribeSynchronous_WithOnNextAndOnCompleted_CompletesCorrectly()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        subject.SubscribeSynchronous(
+            async v =>
+            {
+                await Task.Yield();
+                results.Add(v);
+            },
+            () => completed.TrySetResult());
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnCompleted();
+
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(completed.Task.IsCompletedSuccessfully).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests SubscribeSynchronous with only onNext.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SubscribeSynchronous_WithOnlyOnNext_ProcessesValues()
+    {
+        const int ExpectedCount = 3;
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var allReceived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        subject.SubscribeSynchronous(
+            async v =>
+            {
+                await Task.Yield();
+                results.Add(v);
+                _ = results.Count == ExpectedCount && allReceived.TrySetResult();
+            });
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnNext(SampleValue3);
+
+        await allReceived.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue2, SampleValue3]);
+    }
+
+    /// <summary>
+    /// Tests SubscribeAsync with onNext and onCompleted.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task SubscribeAsync_WithOnNextAndOnCompleted_CompletesCorrectly()
+    {
+        var results = new List<int>();
+        var completed = false;
+        var completionSource = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var source = Observable.Create<int>(observer =>
+        {
+            observer.OnNext(1);
+            observer.OnNext(2);
+            observer.OnCompleted();
+            return Disposable.Empty;
+        });
+
+        using var subscription = source.SubscribeAsync(
+            async v =>
+            {
+                await Task.Delay(1);
+                results.Add(v);
+            },
+            () =>
+            {
+                completed = true;
+                completionSource.TrySetResult(true);
+            });
+
+        await completionSource.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(completed).IsTrue();
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs
new file mode 100644
index 0000000..2031a65
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.Throttle.cs
@@ -0,0 +1,409 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Subjects;
+using ReactiveUI.Primitives.Async.Tests;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>
+    /// Tests DebounceImmediate emits first immediately.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task DebounceImmediate_EmitsFirstImmediately()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        using var sub = subject.DebounceImmediate(TimeSpan.FromTicks(100), scheduler).Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(results).IsNotEmpty();
+        await Assert.That(results[0]).IsEqualTo(1);
+    }
+
+    /// <summary>
+    /// Tests ThrottleFirst emits first immediately, then ignores subsequent values within the throttle window.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ThrottleFirst_EmitsFirstImmediately_IgnoresSubsequentWithinWindow()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        // Throttle window of 100 ms
+        subject.ThrottleFirst(TimeSpan.FromMilliseconds(100))
+            .Subscribe(results.Add);
+
+        subject.OnNext(1); // Should be emitted immediately
+        subject.OnNext(SampleValue2); // Should be ignored (within throttle window)
+        subject.OnNext(SampleValue3); // Should be ignored (within throttle window)
+        await Task.Delay(ThrottleWaitMilliseconds); // Wait for throttle window to pass
+        subject.OnNext(SampleValue4); // Should be emitted
+
+        // Verify results
+        await Assert.That(results).IsCollectionEqualTo([1, SampleValue4]);
+    }
+
+    /// <summary>
+    /// Tests DropIfBusy drops values when busy.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous RxVoid test.</returns>
+    [Test]
+    public async Task DropIfBusy_DropsWhenBusy()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var release = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var processed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        subject.DropIfBusy(async x =>
+        {
+            await release.Task;
+            results.Add(x);
+            processed.TrySetResult();
+        }).Subscribe();
+
+        subject.OnNext(1); // Should process
+        subject.OnNext(SampleValue2); // Should drop
+        subject.OnNext(SampleValue3); // Should drop
+
+        release.SetResult(new object()); // Complete the async action
+        await processed.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(results).IsCollectionEqualTo([1]);
+    }
+
+    /// <summary>
+    /// Tests ThrottleDistinct throttles distinct values.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task ThrottleDistinct_ThrottlesDistinct()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.ThrottleDistinct(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(1); // Duplicate, ignored
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+        subject.OnNext(SampleValue2); // Duplicate after throttle
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2]);
+    }
+
+    /// <summary>
+    /// Tests DebounceUntil emits immediately when condition true, delays when false.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task DebounceUntil_EmitsImmediatelyWhenConditionTrue_DelaysWhenFalse()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.DebounceUntil(TimeSpan.FromTicks(100), x => x % SampleValue2 == 0, scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(1); // Odd, should be delayed
+        scheduler.AdvanceBy(SchedulerHalfWindowTicks); // Advance less than debounce period
+        subject.OnNext(SampleValue2); // Even, should emit immediately, cancelling delayed 1
+        scheduler.AdvanceBy(SchedulerWindowTicks); // Advance past debounce period
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2]);
+    }
+
+    /// <summary>
+    /// Tests ThrottleOnScheduler throttles on the specified scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleOnScheduler_ThenThrottlesOnScheduler()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.ThrottleOnScheduler(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2]);
+    }
+
+    /// <summary>
+    /// Tests ThrottleDistinct with scheduler throttles and deduplicates.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleDistinctWithScheduler_ThenThrottlesAndDeduplicates()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.ThrottleDistinct(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(1); // Duplicate, suppressed by DistinctUntilChanged
+        subject.OnNext(SampleValue2);
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2]);
+    }
+
+    /// <summary>
+    /// Tests DebounceImmediate flushes pending value when source errors.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceImmediateSourceErrors_ThenFlushesAndForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        Exception? observedError = null;
+
+        subject.DebounceImmediate(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add, ex => observedError = ex);
+
+        subject.OnNext(1); // Emitted immediately (first)
+        subject.OnNext(SampleValue2); // Buffered as pending
+        subject.OnError(new InvalidOperationException("test"));
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(observedError).IsNotNull();
+        }
+    }
+
+    /// <summary>
+    /// Tests DebounceImmediate flushes pending value when source completes.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceImmediateSourceCompletes_ThenFlushesAndCompletes()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var completed = false;
+
+        subject.DebounceImmediate(TimeSpan.FromTicks(100), scheduler)
+            .Subscribe(results.Add, () => completed = true);
+
+        subject.OnNext(1); // Emitted immediately (first)
+        subject.OnNext(SampleValue2); // Buffered as pending
+        subject.OnCompleted();
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(results).IsCollectionEqualTo([1, SampleValue2]);
+            await Assert.That(completed).IsTrue();
+        }
+    }
+
+    /// <summary>
+    /// Tests DebounceUntil with scheduler delays non-matching values using the scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceUntilWithScheduler_ThenUsesSchedulerForDelay()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.DebounceUntil(TimeSpan.FromTicks(100), x => x % SampleValue2 == 0, scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(SampleValue2); // Even, emits immediately
+        subject.OnNext(1); // Odd, delayed
+        scheduler.AdvanceBy(SchedulerAdvancePastWindowTicks);
+
+        await Assert.That(results).IsCollectionEqualTo([SampleValue2, 1]);
+    }
+
+    /// <summary>
+    /// Tests ThrottleUntilTrue with predicate false path applies throttle.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleUntilTruePredicateFalse_ThenAppliesThrottle()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var throttledArrived = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject
+            .ThrottleUntilTrue(TimeSpan.FromMilliseconds(100), x => x > 5)
+            .Subscribe(value =>
+            {
+                results.Add(value);
+                _ = value == 1 && throttledArrived.TrySetResult(value);
+            });
+
+        // Predicate true: immediate.
+        subject.OnNext(SampleValue10);
+
+        // Predicate false: throttled — wait on the event instead of racing a fixed delay.
+        subject.OnNext(1);
+        await throttledArrived.Task.WaitAsync(TimeSpan.FromSeconds(5));
+
+        await Assert.That(results).Contains(SampleValue10);
+        await Assert.That(results).Contains(1);
+    }
+
+    /// <summary>
+    /// Tests ThrottleDistinct without scheduler parameter.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenThrottleDistinctWithoutScheduler_ThenThrottlesAndDeduplicates()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject
+            .ThrottleDistinct(TimeSpan.FromMilliseconds(200))
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+
+        await AsyncTestHelpers.WaitForConditionAsync(
+            () => results.Contains(SampleValue2),
+            TimeSpan.FromSeconds(30));
+
+        await Assert.That(results).Contains(SampleValue2);
+    }
+
+    /// <summary>
+    /// Tests DebounceUntil with scheduler delays non-matching values and passes matching immediately.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceUntilWithScheduler_ThenUsesScheduler()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        subject.DebounceUntil(TimeSpan.FromTicks(100), x => x % SampleValue2 == 0, scheduler)
+            .Subscribe(results.Add);
+
+        subject.OnNext(SampleValue2); // condition true -> immediate
+        subject.OnNext(SampleValue3); // condition false -> delayed
+        scheduler.AdvanceBy(SchedulerWindowTicks + 1);
+
+        await Assert.That(results).Contains(SampleValue2);
+        await Assert.That(results).Contains(SampleValue3);
+    }
+
+    /// <summary>
+    /// Tests DebounceImmediate with null scheduler uses Default scheduler.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceImmediateNullScheduler_ThenUsesDefault()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+
+        using var sub = subject
+            .DebounceImmediate(TimeSpan.FromMilliseconds(200))
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+
+        await AsyncTestHelpers.WaitForConditionAsync(
+            () => results.Count >= 2,
+            TimeSpan.FromSeconds(30));
+
+        await Assert.That(results).Contains(1);
+        await Assert.That(results).Contains(SampleValue2);
+    }
+
+    /// <summary>
+    /// Tests DebounceUntil without scheduler emits immediately when condition true.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceUntilWithoutScheduler_ThenEmitsImmediatelyWhenConditionTrue()
+    {
+        var subject = new Subject<int>();
+        var results = new List<int>();
+        var received = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using var sub = subject.DebounceUntil(TimeSpan.FromMilliseconds(500), x => x % 2 == 0)
+            .Subscribe(v =>
+            {
+                results.Add(v);
+                received.TrySetResult();
+            });
+
+        // Even values should emit immediately (condition true)
+        subject.OnNext(SampleValue2);
+
+        await received.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Assert.That(results).Contains(SampleValue2);
+    }
+
+    /// <summary>Verifies that <c>DebounceUntil</c> forwards source completion downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceUntilSourceCompletes_ThenForwardsCompletion()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        var completed = false;
+
+        using var sub = subject.DebounceUntil(TimeSpan.FromTicks(SchedulerWindowTicks), static _ => true, scheduler)
+            .Subscribe(static _ => { }, () => completed = true);
+
+        subject.OnCompleted();
+
+        await Assert.That(completed).IsTrue();
+    }
+
+    /// <summary>Verifies that <c>DebounceUntil</c> forwards source errors downstream.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenDebounceUntilSourceErrors_ThenForwardsError()
+    {
+        var scheduler = new VirtualClock();
+        var subject = new Subject<int>();
+        Exception? caught = null;
+        var expected = new InvalidOperationException("source-failed");
+
+        using var sub = subject.DebounceUntil(TimeSpan.FromTicks(SchedulerWindowTicks), static _ => true, scheduler)
+            .Subscribe(static _ => { }, ex => caught = ex);
+
+        subject.OnError(expected);
+
+        await Assert.That(caught).IsSameReferenceAs(expected);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.WhereIsNotNullAndSignal.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.WhereIsNotNullAndSignal.cs
new file mode 100644
index 0000000..8c7770c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.WhereIsNotNullAndSignal.cs
@@ -0,0 +1,199 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>Tests for ReactiveExtensionsTests.</summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>Alternating true/false source pattern (T,F,T,F,T) used by predicate tests.</summary>
+    private static readonly bool[] WhereIsNotNullSignalAlternatingTrueFalse = [true, false, true, false, true];
+
+    /// <summary>Expected sequence of first/second/third strings (nullable element type to match WhereIsNotNull source signature).</summary>
+    private static readonly string?[] ExpectedFirstSecondThirdNullable = ["first", "second", "third"];
+
+    /// <summary>
+    /// Tests the WhereIsNotNull extension.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GivenNull_WhenWhereIsNotNull_ThenNoNotification()
+    {
+        // Given, When
+        bool? result = null;
+        using var disposable = Observable.Return<bool?>(null).WhereIsNotNull().Subscribe(x => result = x);
+
+        // Then
+        await Assert.That(result).IsNull();
+    }
+
+    /// <summary>
+    /// Tests the WhereIsNotNull extension.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GivenValue_WhenWhereIsNotNull_ThenNotification()
+    {
+        // Given, When
+        bool? result = null;
+        using var disposable = Observable.Return<bool?>(false).WhereIsNotNull().Subscribe(x => result = x);
+
+        // Then
+        await Assert.That(result).IsFalse();
+    }
+
+    /// <summary>
+    /// Tests the AsSignal extension.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task GivenObservable_WhenAsSignal_ThenNotifiesUnit()
+    {
+        // Given, When
+        RxVoid? result = null;
+        using var disposable = Observable.Return<bool?>(false).AsSignal().Subscribe(x => result = x);
+
+        // Then
+        await Assert.That(result).IsEqualTo(RxVoid.Default);
+    }
+
+    /// <summary>
+    /// Tests Not inverts boolean.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Not_InvertsBoolean()
+    {
+        var subject = new BehaviorSubject<bool>(true);
+        bool? result = null;
+        using var sub = subject.Not().Subscribe(x => result = x);
+
+        await Assert.That(result).IsFalse();
+    }
+
+    /// <summary>
+    /// Tests WhereTrue filters to true values.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhereTrue_FiltersTrueValues()
+    {
+        var source = WhereIsNotNullSignalAlternatingTrueFalse.ToObservable();
+        var results = new List<bool>();
+        using var sub = source.WhereTrue().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([true, true, true]);
+    }
+
+    /// <summary>
+    /// Tests WhereFalse filters to false values.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhereFalse_FiltersFalseValues()
+    {
+        var source = WhereIsNotNullSignalAlternatingTrueFalse.ToObservable();
+        var results = new List<bool>();
+        using var sub = source.WhereFalse().Subscribe(results.Add);
+
+        await Assert.That(results).IsCollectionEqualTo([false, false]);
+    }
+
+    /// <summary>
+    /// Tests WhereIsNotNull filters null values.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhereIsNotNull_FiltersNullValues()
+    {
+        var source = new[] { "a", null, "b", null, "c" }.ToObservable();
+        var results = new List<string>();
+        using var sub = source.WhereIsNotNull().Subscribe(x => results.Add(x!));
+
+        await Assert.That(results).IsCollectionEqualTo(["a", "b", "c"]);
+    }
+
+    /// <summary>
+    /// Tests AsSignal converts to RxVoid.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task AsSignal_ConvertsToUnit()
+    {
+        var source = Observable.Range(1, 3);
+        var results = new List<RxVoid>();
+        using var sub = source.AsSignal().Subscribe(results.Add);
+
+        await Assert.That(results).Count().IsEqualTo(SampleValue3);
+    }
+
+    /// <summary>
+    /// Tests WhereIsNotNull filtering nulls over time.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhereIsNotNull_FiltersNullsOverTime()
+    {
+        var subject = new Subject<string?>();
+        var results = new List<string?>();
+
+        subject.WhereIsNotNull()
+            .Subscribe(results.Add);
+
+        subject.OnNext("first");
+        subject.OnNext(null);
+        subject.OnNext("second");
+        subject.OnNext(null);
+        subject.OnNext("third");
+
+        // Only non-null values collected
+        await Assert.That(results).IsCollectionEqualTo(ExpectedFirstSecondThirdNullable);
+    }
+
+    /// <summary>
+    /// Tests Not operator inverting boolean values over time.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task Not_InvertsBooleanValuesOverTime()
+    {
+        var subject = new Subject<bool>();
+        var results = new List<bool>();
+
+        subject.Not()
+            .Subscribe(results.Add);
+
+        subject.OnNext(true);
+        subject.OnNext(false);
+        subject.OnNext(true);
+        subject.OnNext(false);
+
+        await Assert.That(results).IsCollectionEqualTo([false, true, false, true]);
+    }
+
+    /// <summary>
+    /// Tests AsSignal converting values to RxVoid over time.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task AsSignal_ConvertsToUnitOverTime()
+    {
+        var subject = new Subject<int>();
+        var results = new List<RxVoid>();
+
+        subject.AsSignal()
+            .Subscribe(results.Add);
+
+        subject.OnNext(1);
+        subject.OnNext(SampleValue2);
+        subject.OnNext(SampleValue3);
+
+        // All values converted to RxVoid.Default
+        await Assert.That(results).Count().IsEqualTo(SampleValue3);
+        await Assert.That(results).All(x => x == RxVoid.Default);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.cs
new file mode 100644
index 0000000..265745c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveExtensionsTests.cs
@@ -0,0 +1,97 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>
+/// Tests Reactive Extensions.
+/// </summary>
+public partial class ReactiveExtensionsTests
+{
+    /// <summary>Sample integer value (2) used by multiple tests.</summary>
+    private const int SampleValue2 = 2;
+
+    /// <summary>Sample integer value (3) used by multiple tests.</summary>
+    private const int SampleValue3 = 3;
+
+    /// <summary>Sample integer value (4) used by multiple tests.</summary>
+    private const int SampleValue4 = 4;
+
+    /// <summary>Sample integer value (5) used by multiple tests.</summary>
+    private const int SampleValue5 = 5;
+
+    /// <summary>Sample integer value (6) used by multiple tests.</summary>
+    private const int SampleValue6 = 6;
+
+    /// <summary>Sample integer value (10) used by multiple tests.</summary>
+    private const int SampleValue10 = 10;
+
+    /// <summary>Sample integer value (20) used by multiple tests.</summary>
+    private const int SampleValue20 = 20;
+
+    /// <summary>Sample integer value (30) used by multiple tests.</summary>
+    private const int SampleValue30 = 30;
+
+    /// <summary>Sample integer value (42) used by multiple tests.</summary>
+    private const int SampleValue42 = 42;
+
+    /// <summary>Sample integer value (84) used by multiple tests.</summary>
+    private const int SampleValue84 = 84;
+
+    /// <summary>Sample integer value (7) used by multiple tests.</summary>
+    private const int SampleValue7 = 7;
+
+    /// <summary>Sample integer value (8) used by multiple tests.</summary>
+    private const int SampleValue8 = 8;
+
+    /// <summary>Sample integer value (9) used by multiple tests.</summary>
+    private const int SampleValue9 = 9;
+
+    /// <summary>Sample integer value (11) used by multiple tests.</summary>
+    private const int SampleValue11 = 11;
+
+    /// <summary>Sample integer value (13) used by multiple tests.</summary>
+    private const int SampleValue13 = 13;
+
+    /// <summary>Sample integer value (15) used by multiple tests.</summary>
+    private const int SampleValue15 = 15;
+
+    /// <summary>Sample integer value (99) used by multiple tests.</summary>
+    private const int SampleValue99 = 99;
+
+    /// <summary>Minimum-elapsed-time guard in milliseconds for timing assertions.</summary>
+    private const int MinimumExpectedMilliseconds = 90;
+
+    /// <summary>Throttle/debounce wait window in milliseconds.</summary>
+    private const int ThrottleWaitMilliseconds = 150;
+
+    /// <summary>Settle delay in milliseconds used by buffer/foreach tests.</summary>
+    private const int SettleDelayMilliseconds = 200;
+
+    /// <summary>Half of the scheduler window in virtual ticks.</summary>
+    private const int SchedulerHalfWindowTicks = 50;
+
+    /// <summary>Scheduler window length in virtual ticks.</summary>
+    private const int SchedulerWindowTicks = 100;
+
+    /// <summary>One tick past the scheduler window, used to advance virtual time.</summary>
+    private const int SchedulerAdvancePastWindowTicks = 101;
+
+    /// <summary>Short real-time delay in milliseconds.</summary>
+    private const int ShortDelayMilliseconds = 500;
+
+    /// <summary>Long real-time delay in milliseconds.</summary>
+    private const int LongDelayMilliseconds = 1_000;
+
+    /// <summary>Expected sequence [1, 2, 3] for collection equality assertions.</summary>
+    private static readonly int[] ExpectedSequence123 = [1, 2, 3];
+
+#if NET9_0_OR_GREATER
+    /// <summary>Lock used to synchronize observer callbacks during concurrency tests.</summary>
+    private readonly Lock _gate = new();
+#else
+    /// <summary>Lock used to synchronize observer callbacks during concurrency tests.</summary>
+    private readonly object _gate = new();
+#endif
+}
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveUI.Primitives.Extensions.Tests.csproj b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveUI.Primitives.Extensions.Tests.csproj
new file mode 100644
index 0000000..40854a2
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/ReactiveUI.Primitives.Extensions.Tests.csproj
@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(TestTargetFrameworks)</TargetFrameworks>
+    <IsPackable>false</IsPackable>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" />
+    <PackageReference Include="System.Reactive" />
+    <PackageReference Include="Microsoft.Reactive.Testing" />
+    <PackageReference Include="PublicApiGenerator" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\Shared\ApiApprovalExtensions.cs" Link="ApiApprovalExtensions.cs" />
+    <Compile Include="..\Shared\AsyncTestHelpers.cs" Link="AsyncTestHelpers.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="System" />
+    <Using Include="System.Collections.Generic" />
+    <Using Include="System.ComponentModel" />
+    <Using Include="System.Diagnostics.CodeAnalysis" />
+    <Using Include="System.Linq" />
+    <Using Include="System.Linq.Expressions" />
+    <Using Include="System.Threading" />
+    <Using Include="System.Threading.Tasks" />
+    <Using Include="TUnit.Core.Executors" />
+    <Using Include="TUnit.Core.Interfaces" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\ReactiveUI.Primitives\ReactiveUI.Primitives.csproj" />
+    <ProjectReference Include="..\..\ReactiveUI.Primitives.Async\ReactiveUI.Primitives.Async.csproj" />
+    <ProjectReference Include="..\..\ReactiveUI.Primitives.Extensions\ReactiveUI.Primitives.Extensions.csproj" />
+    <ProjectReference Include="..\..\ReactiveUI.Primitives.R3Bridge.Generator\ReactiveUI.Primitives.R3Bridge.Generator.csproj" />
+    <ProjectReference Include="..\..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\ReactiveUI.Primitives.SystemReactiveBridge.Generator.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Analyzer Include="..\..\ReactiveUI.Primitives.R3Bridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.R3Bridge.Generator.dll" />
+    <Analyzer Include="..\..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\bin\$(Configuration)\netstandard2.0\ReactiveUI.Primitives.SystemReactiveBridge.Generator.dll" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/VirtualClockTestExtensions.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/VirtualClockTestExtensions.cs
new file mode 100644
index 0000000..4dbc28b
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/VirtualClockTestExtensions.cs
@@ -0,0 +1,29 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Extensions.Tests;
+
+/// <summary>
+/// Compatibility helpers for tests migrated from Microsoft.Reactive.Testing.
+/// </summary>
+internal static class VirtualClockTestExtensions
+{
+    /// <summary>
+    /// Advances a virtual clock by ticks.
+    /// </summary>
+    /// <param name="clock">The virtual clock.</param>
+    /// <param name="ticks">The number of ticks to advance.</param>
+    public static void AdvanceBy(this VirtualClock clock, long ticks) =>
+        clock.AdvanceBy(TimeSpan.FromTicks(ticks));
+
+    /// <summary>
+    /// Advances a virtual clock to an absolute tick value.
+    /// </summary>
+    /// <param name="clock">The virtual clock.</param>
+    /// <param name="ticks">The absolute tick value.</param>
+    public static void AdvanceTo(this VirtualClock clock, long ticks) =>
+        clock.AdvanceTo(new DateTimeOffset(ticks, TimeSpan.Zero));
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet10_0.verified.txt b/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet10_0.verified.txt
index 58e9b65..bed1b27 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet10_0.verified.txt
+++ b/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet10_0.verified.txt
@@ -1,11 +1,7 @@
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Async.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Blazor")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Blazor.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Maui")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Extensions.Tests")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.WinForms")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.WinUI")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Wpf")]
 namespace ReactiveUI.Primitives
 {
     public sealed class AllPredicateObserver<T> : ReactiveUI.Primitives.BooleanTerminalObserver<T>
@@ -742,9 +738,11 @@ namespace ReactiveUI.Primitives.Core
 }
 namespace ReactiveUI.Primitives.Disposables
 {
-    public sealed class AnonymousDisposable : System.IDisposable
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class ActionDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
     {
-        public AnonymousDisposable(System.Action dispose) { }
+        public ActionDisposable(System.Action action) { }
+        public bool IsDisposed { get; }
         public void Dispose() { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
@@ -776,9 +774,20 @@ namespace ReactiveUI.Primitives.Disposables
         public static System.IDisposable Empty { get; }
         public static System.IDisposable Create(System.Action dispose) { }
     }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class DisposableBag : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public DisposableBag() { }
+        public DisposableBag(System.IDisposable first, System.IDisposable second) { }
+        public DisposableBag(System.IDisposable first, System.IDisposable second, System.IDisposable third) { }
+        public bool IsDisposed { get; }
+        public void Add(System.IDisposable disposable) { }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class EmptyDisposable : System.IDisposable
     {
-        public EmptyDisposable() { }
+        public static ReactiveUI.Primitives.Disposables.EmptyDisposable Instance { get; }
         public void Dispose() { }
     }
     public interface IsDisposed : System.IDisposable
@@ -800,6 +809,23 @@ namespace ReactiveUI.Primitives.Disposables
         public static System.IDisposable Create(params System.IDisposable[] disposables) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class MutableDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public MutableDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public OnceDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsAssigned { get; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class Pocket : ReactiveUI.Primitives.Disposables.MultipleDisposable
     {
         public Pocket() { }
@@ -839,6 +865,14 @@ namespace ReactiveUI.Primitives.Disposables
         public Slot(System.IDisposable disposable) { }
         public Slot(System.IDisposable disposable, System.Action? action) { }
     }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class SwapDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public SwapDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
 }
 namespace ReactiveUI.Primitives.Signals
 {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet8_0.verified.txt b/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet8_0.verified.txt
index 58e9b65..bed1b27 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet8_0.verified.txt
+++ b/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet8_0.verified.txt
@@ -1,11 +1,7 @@
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Async.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Blazor")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Blazor.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Maui")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Extensions.Tests")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.WinForms")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.WinUI")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Wpf")]
 namespace ReactiveUI.Primitives
 {
     public sealed class AllPredicateObserver<T> : ReactiveUI.Primitives.BooleanTerminalObserver<T>
@@ -742,9 +738,11 @@ namespace ReactiveUI.Primitives.Core
 }
 namespace ReactiveUI.Primitives.Disposables
 {
-    public sealed class AnonymousDisposable : System.IDisposable
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class ActionDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
     {
-        public AnonymousDisposable(System.Action dispose) { }
+        public ActionDisposable(System.Action action) { }
+        public bool IsDisposed { get; }
         public void Dispose() { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
@@ -776,9 +774,20 @@ namespace ReactiveUI.Primitives.Disposables
         public static System.IDisposable Empty { get; }
         public static System.IDisposable Create(System.Action dispose) { }
     }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class DisposableBag : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public DisposableBag() { }
+        public DisposableBag(System.IDisposable first, System.IDisposable second) { }
+        public DisposableBag(System.IDisposable first, System.IDisposable second, System.IDisposable third) { }
+        public bool IsDisposed { get; }
+        public void Add(System.IDisposable disposable) { }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class EmptyDisposable : System.IDisposable
     {
-        public EmptyDisposable() { }
+        public static ReactiveUI.Primitives.Disposables.EmptyDisposable Instance { get; }
         public void Dispose() { }
     }
     public interface IsDisposed : System.IDisposable
@@ -800,6 +809,23 @@ namespace ReactiveUI.Primitives.Disposables
         public static System.IDisposable Create(params System.IDisposable[] disposables) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class MutableDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public MutableDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public OnceDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsAssigned { get; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class Pocket : ReactiveUI.Primitives.Disposables.MultipleDisposable
     {
         public Pocket() { }
@@ -839,6 +865,14 @@ namespace ReactiveUI.Primitives.Disposables
         public Slot(System.IDisposable disposable) { }
         public Slot(System.IDisposable disposable, System.Action? action) { }
     }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class SwapDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public SwapDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
 }
 namespace ReactiveUI.Primitives.Signals
 {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet9_0.verified.txt b/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet9_0.verified.txt
index 58e9b65..bed1b27 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet9_0.verified.txt
+++ b/src/tests/ReactiveUI.Primitives.Tests/ApiApprovalTests.Primitives.DotNet9_0.verified.txt
@@ -1,11 +1,7 @@
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Async.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Blazor")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Blazor.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Maui")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Extensions.Tests")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Tests")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.WinForms")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.WinUI")]
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("ReactiveUI.Primitives.Wpf")]
 namespace ReactiveUI.Primitives
 {
     public sealed class AllPredicateObserver<T> : ReactiveUI.Primitives.BooleanTerminalObserver<T>
@@ -742,9 +738,11 @@ namespace ReactiveUI.Primitives.Core
 }
 namespace ReactiveUI.Primitives.Disposables
 {
-    public sealed class AnonymousDisposable : System.IDisposable
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class ActionDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
     {
-        public AnonymousDisposable(System.Action dispose) { }
+        public ActionDisposable(System.Action action) { }
+        public bool IsDisposed { get; }
         public void Dispose() { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
@@ -776,9 +774,20 @@ namespace ReactiveUI.Primitives.Disposables
         public static System.IDisposable Empty { get; }
         public static System.IDisposable Create(System.Action dispose) { }
     }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class DisposableBag : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public DisposableBag() { }
+        public DisposableBag(System.IDisposable first, System.IDisposable second) { }
+        public DisposableBag(System.IDisposable first, System.IDisposable second, System.IDisposable third) { }
+        public bool IsDisposed { get; }
+        public void Add(System.IDisposable disposable) { }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class EmptyDisposable : System.IDisposable
     {
-        public EmptyDisposable() { }
+        public static ReactiveUI.Primitives.Disposables.EmptyDisposable Instance { get; }
         public void Dispose() { }
     }
     public interface IsDisposed : System.IDisposable
@@ -800,6 +809,23 @@ namespace ReactiveUI.Primitives.Disposables
         public static System.IDisposable Create(params System.IDisposable[] disposables) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class MutableDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public MutableDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class OnceDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public OnceDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsAssigned { get; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class Pocket : ReactiveUI.Primitives.Disposables.MultipleDisposable
     {
         public Pocket() { }
@@ -839,6 +865,14 @@ namespace ReactiveUI.Primitives.Disposables
         public Slot(System.IDisposable disposable) { }
         public Slot(System.IDisposable disposable, System.Action? action) { }
     }
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed class SwapDisposable : ReactiveUI.Primitives.Disposables.IsDisposed, System.IDisposable
+    {
+        public SwapDisposable() { }
+        public System.IDisposable? Disposable { get; set; }
+        public bool IsDisposed { get; }
+        public void Dispose() { }
+    }
 }
 namespace ReactiveUI.Primitives.Signals
 {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/PublicApiBehaviorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/PublicApiBehaviorTests.cs
index 8643b0b..c3ba79a 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/PublicApiBehaviorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/PublicApiBehaviorTests.cs
@@ -670,7 +670,7 @@ public void SparksCoverValueErrorCompletionEqualityAndAcceptOverloads()
         Assert.True(next.ToString().Contains(FortyTwo.ToString(), StringComparison.Ordinal));
         Assert.Equal(next.GetHashCode(), sameNext.GetHashCode());
         next.Accept((IObserver<int>)observer);
-        Assert.Equal("next:42", next.Accept<string>((IObserver<int, string>)observer));
+        Assert.Equal("next:42", next.Accept((IObserver<int, string>)observer));
         next.Accept(value => observer.Events.Add("delegate-next:" + value), ex => observer.Events.Add(ex.Message), () => observer.Events.Add("delegate-completed"));
         Assert.Equal("fn-next:42", next.Accept(value => "fn-next:" + value, ex => ex.Message, () => FunctionCompletedText));
         Assert.Throws<ArgumentNullException>(() => next.Accept((IObserver<int>)null!));
@@ -678,7 +678,7 @@ public void SparksCoverValueErrorCompletionEqualityAndAcceptOverloads()
         Assert.Throws<ArgumentNullException>(() => next.Accept(null!, ex => { }, () => { }));
         Assert.Throws<ArgumentNullException>(() => next.Accept(value => { }, null!, () => { }));
         Assert.Throws<ArgumentNullException>(() => next.Accept(value => { }, ex => { }, null!));
-        Assert.Throws<ArgumentNullException>(() => next.Accept<string>(null!, ex => ex.Message, () => "done"));
+        Assert.Throws<ArgumentNullException>(() => next.Accept(null!, ex => ex.Message, () => "done"));
         Assert.Throws<ArgumentNullException>(() => next.Accept(value => value.ToString(), null!, () => "done"));
         Assert.Throws<ArgumentNullException>(() => next.Accept(value => value.ToString(), ex => ex.Message, null!));
 
@@ -700,7 +700,7 @@ public void SparksCoverValueErrorCompletionEqualityAndAcceptOverloads()
         Assert.Throws<ArgumentNullException>(() => errorSpark.Accept(null!, ex => { }, () => { }));
         Assert.Throws<ArgumentNullException>(() => errorSpark.Accept(value => { }, null!, () => { }));
         Assert.Throws<ArgumentNullException>(() => errorSpark.Accept(value => { }, ex => { }, null!));
-        Assert.Throws<ArgumentNullException>(() => errorSpark.Accept<string>(null!, ex => ex.Message, () => "done"));
+        Assert.Throws<ArgumentNullException>(() => errorSpark.Accept(null!, ex => ex.Message, () => "done"));
         Assert.Throws<ArgumentNullException>(() => errorSpark.Accept(value => value.ToString(), null!, () => "done"));
         Assert.Throws<ArgumentNullException>(() => errorSpark.Accept(value => value.ToString(), ex => ex.Message, null!));
 
@@ -719,7 +719,7 @@ public void SparksCoverValueErrorCompletionEqualityAndAcceptOverloads()
         Assert.Throws<ArgumentNullException>(() => completed.Accept(null!, ex => { }, () => { }));
         Assert.Throws<ArgumentNullException>(() => completed.Accept(value => { }, null!, () => { }));
         Assert.Throws<ArgumentNullException>(() => completed.Accept(value => { }, ex => { }, null!));
-        Assert.Throws<ArgumentNullException>(() => completed.Accept<string>(null!, ex => ex.Message, () => "done"));
+        Assert.Throws<ArgumentNullException>(() => completed.Accept(null!, ex => ex.Message, () => "done"));
         Assert.Throws<ArgumentNullException>(() => completed.Accept(value => value.ToString(), null!, () => "done"));
         Assert.Throws<ArgumentNullException>(() => completed.Accept(value => value.ToString(), ex => ex.Message, null!));
         Assert.Throws<ArgumentNullException>(() => completed.ToObservable(null!));
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj b/src/tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj
index c4e5dd8..f5db6d2 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj
+++ b/src/tests/ReactiveUI.Primitives.Tests/ReactiveUI.Primitives.Tests.csproj
@@ -21,6 +21,7 @@
 
   <ItemGroup>
     <Compile Include="..\Shared\ApiApprovalExtensions.cs" Link="ApiApprovalExtensions.cs" />
+    <Compile Include="..\Shared\AsyncTestHelpers.cs" Link="AsyncTestHelpers.cs" />
   </ItemGroup>
 
   <ItemGroup>
@@ -38,6 +39,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\ReactiveUI.Primitives\ReactiveUI.Primitives.csproj" />
+    <ProjectReference Include="..\..\ReactiveUI.Primitives.Async\ReactiveUI.Primitives.Async.csproj" />
     <ProjectReference Include="..\..\ReactiveUI.Primitives.R3Bridge.Generator\ReactiveUI.Primitives.R3Bridge.Generator.csproj" />
     <ProjectReference Include="..\..\ReactiveUI.Primitives.SystemReactiveBridge.Generator\ReactiveUI.Primitives.SystemReactiveBridge.Generator.csproj" />
   </ItemGroup>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalFromTaskTest.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalFromTaskTest.cs
index e38f3e6..98c67e3 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalFromTaskTest.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalFromTaskTest.cs
@@ -31,6 +31,14 @@ public class SignalFromTaskTest
     /// </summary>
     private const int CleanupDelayMilliseconds = 5000;
 
+    /// <summary>
+    /// Time spent performing synchronous cancellation cleanup work. Kept short so the
+    /// blocking <see cref="Thread.Sleep(int)"/> does not occupy a thread-pool thread long
+    /// enough to delay the timer-driven cancellation callbacks the tests wait on (which
+    /// previously tipped the loaded CI runners over <see cref="CancellationCallbackTimeoutMilliseconds"/>).
+    /// </summary>
+    private const int CleanupWorkMilliseconds = 250;
+
     /// <summary>
     /// Delay used to wait for cancellation cleanup to finish.
     /// </summary>
@@ -601,7 +609,7 @@ private static void RecordStatus(StatusTrail statusTrail, ref int position, stri
     private static void RecordCancellationCleanup(StatusTrail statusTrail, ref int position)
     {
         RecordStatus(statusTrail, ref position, StartingCancellingCommand);
-        Thread.Sleep(CleanupDelayMilliseconds);
+        Thread.Sleep(CleanupWorkMilliseconds);
         RecordStatus(statusTrail, ref position, FinishedCancellingCommand);
     }
 
diff --git a/src/tests/Shared/ApiApprovalExtensions.cs b/src/tests/Shared/ApiApprovalExtensions.cs
index c704c98..f040cba 100644
--- a/src/tests/Shared/ApiApprovalExtensions.cs
+++ b/src/tests/Shared/ApiApprovalExtensions.cs
@@ -27,7 +27,13 @@ public static async Task CheckApproval(
         [CallerFilePath] string filePath = "")
     {
         var generatorOptions = new ApiGeneratorOptions();
-        var apiText = assembly.GeneratePublicApi(generatorOptions);
+
+        // Normalise line endings so the approval is resilient to CRLF/LF differences between
+        // the checked-in baseline (committed via .gitattributes as CRLF) and the value produced
+        // on whichever platform the tests run (LF on Linux/macOS, CRLF on Windows).
+        var apiText = assembly.GeneratePublicApi(generatorOptions)
+            .Replace("\r\n", "\n", StringComparison.Ordinal)
+            .Replace('\r', '\n');
         _ = await Verifier.Verify(apiText, null, filePath)
             .UniqueForRuntimeAndVersion()
             .ScrubEmptyLines()
diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/AsyncTestHelpers.cs b/src/tests/Shared/AsyncTestHelpers.cs
similarity index 100%
rename from src/tests/ReactiveUI.Primitives.Async.Tests/AsyncTestHelpers.cs
rename to src/tests/Shared/AsyncTestHelpers.cs