diff --git a/README.md b/README.md
index 9940f5f..5d29be0 100644
--- a/README.md
+++ b/README.md
@@ -124,6 +124,7 @@ Subscriptions and scheduled work return `IDisposable`. ReactiveUI.Primitives inc
 | `BooleanDisposable` | Track simple disposed state. |
 | `CancellationDisposable` | Tie disposal to a `CancellationTokenSource`. |
 | `MultipleDisposable` | Composite-disposable equivalent; add/remove multiple disposables. |
+| `CompositeDisposable` | System.Reactive-compatible alias over `MultipleDisposable`. |
 | `Pocket` | Named `MultipleDisposable` specialization. |
 | `SingleDisposable` / `AssignmentSlot` | Single-assignment disposable container. |
 | `SingleReplaceableDisposable` / `Slot` | Replaceable disposable container. |
@@ -165,8 +166,10 @@ Creation APIs live on `ReactiveUI.Primitives.Signals.Signal`.
 | `Signal.Unfold<TState,TResult>(...)` | Generate a finite sequence from state. |
 | `Signal.Use<TResource,T>(...)` | Tie a resource lifetime to a subscription. |
 | `Signal.FromEnumerable<T>(IEnumerable<T>)` | Convert an enumerable. |
+| `Signal.FromEnumerable<T>(IEnumerable<T>, CancellationToken)` | Convert an enumerable and stop synchronous enumeration when cancelled. |
 | `Signal.FromAsyncEnumerable<T>(IAsyncEnumerable<T>, CancellationToken)` | Convert an async enumerable on modern TFMs. |
 | `Signal.FromTask<T>(Task<T>)` | Convert a task to a signal. |
+| `Signal.FromAsync<T>(...)` | Invoke a task factory per subscription. |
 | `Signal.After(TimeSpan, ISequencer?)` | Emit one `long` tick after a delay. |
 | `Signal.Every(TimeSpan, ISequencer?)` | Emit increasing `long` ticks repeatedly. |
 | `Signal.Pulse(...)` | Alias of `Every`. |
@@ -342,7 +345,7 @@ ReactiveUI.Primitives uses explicit names instead of cloning every System.Reacti
 | System.Reactive type | ReactiveUI.Primitives equivalent | Notes |
 |---|---|---|
 | `Subject<T>` | `Signal<T>` | Push values, errors, and completion to subscribers. |
-| `BehaviorSubject<T>` | `BehaviourSignal<T>` or `StateSignal<T>` | Stores the latest value and emits it to new subscribers. `StateSignal<T>` adds a mutable `Value` setter and `Changed`. |
+| `BehaviorSubject<T>` | `BehaviorSignal<T>`, or `StateSignal<T>` | Stores the latest value and emits it to new subscribers. `StateSignal<T>` adds a mutable `Value` setter and `Changed`. |
 | `ReplaySubject<T>` | `ReplaySignal<T>` | Replays buffered values by size and/or time window. |
 | `AsyncSubject<T>` | `AsyncSignal<T>` | Awaitable subject-like signal; also implements `IAwaitSignal<T>`. |
 | `ReactiveProperty<T>` / state holder | `StateSignal<T>` plus `ReadOnlyState<T>` | Mutable state and read-only projected state. |
@@ -493,12 +496,13 @@ ReactiveUI.Primitives is not a byte-for-byte clone of System.Reactive. It keeps
 | `Observable.Repeat(value)` | `Signal.Repeat(value)` | Indefinite repeat. |
 | `Observable.Repeat(value, count)` | `Signal.Repeat(value, count)` | Fixed repeat. |
 | `Observable.Defer(factory)` | `Signal.Defer(factory)` | Create source per subscription. |
+| `Observable.FromAsync(...)` | `Signal.FromAsync(...)` | Invoke a task factory per subscription. |
 | `Observable.Create<T>(...)` | `Signal.Create<T>(...)` or `Signal.CreateSafe<T>(...)` | Prefer `CreateSafe` for general custom sources. |
 | `Observable.Using(...)` | `Signal.Use(...)` | Resource scoped to subscription. |
 | `Observable.Timer(dueTime)` | `Signal.Timer(dueTime)` or `Signal.After(dueTime)` | Emits `long` tick `0`. |
 | `Observable.Timer(dueTime, period)` | `Signal.Timer(dueTime, period)` | Periodic `long` ticks. |
 | `Observable.Interval(period)` | `Signal.Interval(period)` or `Signal.Every(period)` | Repeating ticks. |
-| `ToObservable()` from enumerable | `Signal.FromEnumerable(values)` or `values.ToSignal()` | `ToSignal` extension is available. |
+| `ToObservable()` from enumerable | `Signal.FromEnumerable(values)`, `values.ToSignal()`, or `values.ToObservable()` | Cancellation-token overloads are available. |
 | task conversion | `Signal.FromTask(task)` | Function-based task signals also exist. |
 
 ### Subject/state mapping
@@ -506,7 +510,7 @@ ReactiveUI.Primitives is not a byte-for-byte clone of System.Reactive. It keeps
 | System.Reactive | ReactiveUI.Primitives | Migration detail |
 |---|---|---|
 | `new Subject<T>()` | `new Signal<T>()` | Use `OnNext`, `OnError`, `OnCompleted`, and `Subscribe`. |
-| `new BehaviorSubject<T>(initial)` | `new BehaviourSignal<T>(initial)` | Keeps `Value` getter and emits latest value to subscribers. |
+| `new BehaviorSubject<T>(initial)` | `new BehaviorSignal<T>(initial)` | Keeps `Value` getter and emits latest value to subscribers. |
 | mutable reactive property | `new StateSignal<T>(initial)` | Set `Value` to emit. Use `Changed` for observable state stream. |
 | `new ReplaySubject<T>()` | `new ReplaySignal<T>()` | Unbounded replay. |
 | `new ReplaySubject<T>(bufferSize)` | `new ReplaySignal<T>(bufferSize)` | Size-limited replay. |
@@ -546,6 +550,7 @@ ReactiveUI.Primitives is not a byte-for-byte clone of System.Reactive. It keeps
 | `Buffer(count)` | `Buffer(count)` | Fixed-size buffers. |
 | `ToList` / `ToArray` | `CollectList` / `CollectArray` | Signal results. |
 | `FirstAsync` | `FirstAsync` | Task result. |
+| `CountAsync` / `AnyAsync` | `CountAsync` / `AnyAsync` | Task-shaped terminal helpers, including cancellation overloads. |
 
 ### Disposable mapping
 
diff --git a/src/ReactiveUI.Primitives.R3Bridge.Generator/R3BridgeGenerator.cs b/src/ReactiveUI.Primitives.R3Bridge.Generator/R3BridgeGenerator.cs
index 9a09610..768a365 100644
--- a/src/ReactiveUI.Primitives.R3Bridge.Generator/R3BridgeGenerator.cs
+++ b/src/ReactiveUI.Primitives.R3Bridge.Generator/R3BridgeGenerator.cs
@@ -53,7 +53,7 @@ internal static class R3SignalBridge
             throw new global::System.ArgumentNullException(nameof(source));
         }
 
-        return global::ReactiveUI.Primitives.Signals.Signal.Create<T>(observer => source.Subscribe(observer));
+        return global::ReactiveUI.Primitives.Signals.Signal.Create<T>(observer => source.Subscribe(new R3ToPrimitivesObserver<T>(observer)));
     }
 
     /// <summary>
@@ -66,7 +66,42 @@ internal static class R3SignalBridge
             throw new global::System.ArgumentNullException(nameof(source));
         }
 
-        return global::R3.Observable<T>.Create(observer => source.Subscribe(observer));
+        return global::R3.Observable.Create<T>(observer => source.Subscribe(new PrimitivesToR3Observer<T>(observer)));
+    }
+
+    private sealed class R3ToPrimitivesObserver<T> : global::R3.Observer<T>
+    {
+        private readonly global::System.IObserver<T> _observer;
+
+        public R3ToPrimitivesObserver(global::System.IObserver<T> observer) => _observer = observer;
+
+        protected override void OnNextCore(T value) => _observer.OnNext(value);
+
+        protected override void OnErrorResumeCore(global::System.Exception error) => _observer.OnError(error);
+
+        protected override void OnCompletedCore(global::R3.Result result)
+        {
+            if (result.IsFailure)
+            {
+                _observer.OnError(result.Exception);
+                return;
+            }
+
+            _observer.OnCompleted();
+        }
+    }
+
+    private sealed class PrimitivesToR3Observer<T> : global::System.IObserver<T>
+    {
+        private readonly global::R3.Observer<T> _observer;
+
+        public PrimitivesToR3Observer(global::R3.Observer<T> observer) => _observer = observer;
+
+        public void OnNext(T value) => _observer.OnNext(value);
+
+        public void OnError(global::System.Exception error) => _observer.OnCompleted(global::R3.Result.Failure(error));
+
+        public void OnCompleted() => _observer.OnCompleted(global::R3.Result.Success);
     }
 }
 """;
diff --git a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
index 751a6fa..f829b4c 100644
--- a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
@@ -10,8 +10,9 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// <summary>
 /// CurrentThreadSequencer.
 /// </summary>
-/// <seealso cref="ReactiveUI.Primitives.Concurrency.ISequencer" />
-public sealed class CurrentThreadSequencer : ISequencer
+/// <seealso cref="ISequencer" />
+[DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class CurrentThreadSequencer : ISequencer
 {
     /// <summary>
     /// Singleton holder for the current-thread sequencer.
@@ -103,7 +104,7 @@ public IDisposable Schedule<TState>(TState state, Func<ISequencer, TState, IDisp
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">action.</exception>
+    /// <exception cref="ArgumentNullException">action.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="action" /> is <c>null</c>.</exception>
     public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<ISequencer, TState, IDisposable> action)
     {
diff --git a/src/ReactiveUI.Primitives/Concurrency/DispatcherSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/DispatcherSequencer.cs
index a64c117..523cca6 100644
--- a/src/ReactiveUI.Primitives/Concurrency/DispatcherSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/DispatcherSequencer.cs
@@ -15,7 +15,8 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// DispatcherSequencer.
 /// </summary>
 /// <seealso cref="ReactiveUI.Primitives.Concurrency.ISequencer" />
-public class DispatcherSequencer : ISequencer
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class DispatcherSequencer : ISequencer
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="DispatcherSequencer"/> class.
diff --git a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
index e8cdf0e..7728800 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
@@ -7,8 +7,9 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// <summary>
 /// ImmediateSequencer.
 /// </summary>
-/// <seealso cref="ReactiveUI.Primitives.Concurrency.ISequencer" />
-public sealed class ImmediateSequencer : ISequencer
+/// <seealso cref="ISequencer" />
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class ImmediateSequencer : ISequencer
 {
     /// <summary>
     /// Singleton holder for the immediate sequencer.
diff --git a/src/ReactiveUI.Primitives/Concurrency/ScheduledItem.cs b/src/ReactiveUI.Primitives/Concurrency/ScheduledItem.cs
index 081c3f3..08f6cae 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ScheduledItem.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ScheduledItem.cs
@@ -11,7 +11,8 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// Abstract base class for scheduled work items.
 /// </summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
-public abstract class ScheduledItem<TAbsolute> : IScheduledItem<TAbsolute>, IComparable<ScheduledItem<TAbsolute>>, IsDisposed, IComparable
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public abstract partial class ScheduledItem<TAbsolute> : IScheduledItem<TAbsolute>, IComparable<ScheduledItem<TAbsolute>>, IsDisposed, IComparable
     where TAbsolute : IComparable<TAbsolute>
 {
     /// <summary>
@@ -35,7 +36,7 @@ public abstract class ScheduledItem<TAbsolute> : IScheduledItem<TAbsolute>, ICom
     /// </summary>
     /// <param name="dueTime">Absolute time at which the work item has to be executed.</param>
     /// <param name="comparer">Comparer used to compare work items based on their scheduled time.</param>
-    /// <exception cref="System.ArgumentNullException">comparer.</exception>
+    /// <exception cref="ArgumentNullException">comparer.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="comparer" /> is <c>null</c>.</exception>
     protected ScheduledItem(TAbsolute dueTime, IComparer<TAbsolute> comparer)
     {
diff --git a/src/ReactiveUI.Primitives/Concurrency/ScheduledItem{TAbsolute,TValue}.cs b/src/ReactiveUI.Primitives/Concurrency/ScheduledItem{TAbsolute,TValue}.cs
index f8c1633..6c1d445 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ScheduledItem{TAbsolute,TValue}.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ScheduledItem{TAbsolute,TValue}.cs
@@ -9,7 +9,8 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// </summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 /// <typeparam name="TValue">Type of the state passed to the scheduled action.</typeparam>
-public sealed class ScheduledItem<TAbsolute, TValue> : ScheduledItem<TAbsolute>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class ScheduledItem<TAbsolute, TValue> : ScheduledItem<TAbsolute>
     where TAbsolute : IComparable<TAbsolute>
 {
     /// <summary>
diff --git a/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs b/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
index 17d3df4..d303b57 100644
--- a/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/Sequencer.Simple.cs
@@ -42,7 +42,7 @@ public static IDisposable Schedule(this ISequencer scheduler, Action action)
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// scheduler
     /// or
     /// action.
@@ -72,7 +72,7 @@ public static IDisposable Schedule(this ISequencer scheduler, TimeSpan dueTime,
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// scheduler
     /// or
     /// action.
@@ -124,7 +124,7 @@ public static IDisposable Schedule(this ISequencer scheduler, Action<Action> act
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// scheduler
     /// or
     /// action.
@@ -190,7 +190,7 @@ internal static IDisposable ScheduleAction<TState>(this ISequencer scheduler, TS
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// scheduler
     /// or
     /// action.
@@ -222,7 +222,7 @@ internal static IDisposable ScheduleAction<TState>(this ISequencer scheduler, TS
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// scheduler
     /// or
     /// action.
@@ -254,7 +254,7 @@ internal static IDisposable ScheduleAction<TState>(this ISequencer scheduler, TS
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// scheduler
     /// or
     /// action.
@@ -286,7 +286,7 @@ internal static IDisposable ScheduleAction<TState>(this ISequencer scheduler, TS
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// scheduler
     /// or
     /// action.
diff --git a/src/ReactiveUI.Primitives/Concurrency/SequencerQueue.cs b/src/ReactiveUI.Primitives/Concurrency/SequencerQueue.cs
index dbb2655..44c0fca 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SequencerQueue.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SequencerQueue.cs
@@ -11,7 +11,8 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// </summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 /// <remarks>This type is not thread safe; users should ensure proper synchronization.</remarks>
-public class SequencerQueue<TAbsolute>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class SequencerQueue<TAbsolute>
     where TAbsolute : IComparable<TAbsolute>
 {
     /// <summary>
diff --git a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
index e811ede..8c5273c 100644
--- a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
@@ -9,8 +9,9 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// <summary>
 /// TaskPoolSequencer.
 /// </summary>
-/// <seealso cref="ReactiveUI.Primitives.Concurrency.ISequencer" />
-public sealed class TaskPoolSequencer : ISequencer
+/// <seealso cref="ISequencer" />
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class TaskPoolSequencer : ISequencer
 {
     /// <summary>
     /// Task factory used to schedule asynchronous work.
diff --git a/src/ReactiveUI.Primitives/Concurrency/TestClock.cs b/src/ReactiveUI.Primitives/Concurrency/TestClock.cs
index 499069a..a49ab01 100644
--- a/src/ReactiveUI.Primitives/Concurrency/TestClock.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/TestClock.cs
@@ -7,7 +7,8 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// <summary>
 /// Test-facing alias for <see cref="VirtualClock"/>.
 /// </summary>
-public sealed class TestClock : VirtualClock
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class TestClock : VirtualClock
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="TestClock"/> class at the default clock value.
diff --git a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
index 2b5d9e3..ecc78f7 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
@@ -4,14 +4,16 @@
 
 using ReactiveUI.Primitives.Disposables;
 using static ReactiveUI.Primitives.Disposables.Disposable;
+using Timer = System.Threading.Timer;
 
 namespace ReactiveUI.Primitives.Concurrency
 {
     /// <summary>
     /// ThreadPoolSequencer.
     /// </summary>
-    /// <seealso cref="ReactiveUI.Primitives.Concurrency.ISequencer" />
-    public sealed class ThreadPoolSequencer : ISequencer
+    /// <seealso cref="ISequencer" />
+    [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public sealed partial class ThreadPoolSequencer : ISequencer
     {
         /// <summary>
         /// Gets the shared thread-pool scheduler instance.
@@ -26,7 +28,7 @@ public sealed class ThreadPoolSequencer : ISequencer
         /// <summary>
         /// Keeps timers rooted until they fire or are cancelled.
         /// </summary>
-        internal static readonly Dictionary<System.Threading.Timer, object> Timers = [];
+        internal static readonly Dictionary<Timer, object> Timers = [];
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class.
@@ -49,7 +51,7 @@ private ThreadPoolSequencer()
         /// <returns>
         /// The disposable object used to cancel the scheduled action (best effort).
         /// </returns>
-        /// <exception cref="System.ArgumentNullException">action.</exception>
+        /// <exception cref="ArgumentNullException">action.</exception>
         public IDisposable Schedule<TState>(TState state, Func<ISequencer, TState, IDisposable> action)
         {
             if (action == null)
@@ -83,7 +85,7 @@ public IDisposable Schedule<TState>(TState state, Func<ISequencer, TState, IDisp
         /// <returns>
         /// The disposable object used to cancel the scheduled action (best effort).
         /// </returns>
-        /// <exception cref="System.ArgumentNullException">action.</exception>
+        /// <exception cref="ArgumentNullException">action.</exception>
         public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<ISequencer, TState, IDisposable> action)
         {
             if (action == null)
@@ -94,7 +96,7 @@ public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<ISequen
             var dueTime1 = Sequencer.Normalize(dueTime);
             var hasAdded = false;
             var hasRemoved = false;
-            System.Threading.Timer timer = null!;
+            Timer timer = null!;
             timer = new(
                 _ =>
             {
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
index 2227b84..139aae6 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
@@ -7,7 +7,8 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// <summary>
 /// Deterministic virtual scheduler backed by <see cref="DateTimeOffset"/> and <see cref="TimeSpan"/>.
 /// </summary>
-public class VirtualClock : VirtualTimeSequencer<DateTimeOffset, TimeSpan>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class VirtualClock : VirtualTimeSequencer<DateTimeOffset, TimeSpan>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="VirtualClock"/> class at the default clock value.
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerBase{TAbsolute,TRelative}.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerBase{TAbsolute,TRelative}.cs
index 739fc2c..2fbe289 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerBase{TAbsolute,TRelative}.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencerBase{TAbsolute,TRelative}.cs
@@ -11,7 +11,8 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// </summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 /// <typeparam name="TRelative">Relative time representation type.</typeparam>
-public abstract class VirtualTimeSequencerBase<TAbsolute, TRelative> : ISequencer, IServiceProvider, IStopwatchProvider
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public abstract partial class VirtualTimeSequencerBase<TAbsolute, TRelative> : ISequencer, IServiceProvider, IStopwatchProvider
     where TAbsolute : IComparable<TAbsolute>
 {
     /// <summary>
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
index 8c4feaa..a35f898 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualTimeSequencer{TAbsolute,TRelative}.cs
@@ -9,7 +9,8 @@ namespace ReactiveUI.Primitives.Concurrency;
 /// </summary>
 /// <typeparam name="TAbsolute">Absolute time representation type.</typeparam>
 /// <typeparam name="TRelative">Relative time representation type.</typeparam>
-public abstract class VirtualTimeSequencer<TAbsolute, TRelative> : VirtualTimeSequencerBase<TAbsolute, TRelative>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public abstract partial class VirtualTimeSequencer<TAbsolute, TRelative> : VirtualTimeSequencerBase<TAbsolute, TRelative>
     where TAbsolute : IComparable<TAbsolute>
 {
     /// <summary>
@@ -47,7 +48,7 @@ protected VirtualTimeSequencer(TAbsolute initialClock, IComparer<TAbsolute> comp
     /// <returns>
     /// The disposable object used to cancel the scheduled action (best effort).
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">action.</exception>
+    /// <exception cref="ArgumentNullException">action.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="action" /> is <c>null</c>.</exception>
     public override IDisposable ScheduleAbsolute<TState>(TState state, TAbsolute dueTime, Func<ISequencer, TState, IDisposable> action)
     {
diff --git a/src/ReactiveUI.Primitives/ConnectableSignalMixins.cs b/src/ReactiveUI.Primitives/ConnectableSignalMixins.cs
new file mode 100644
index 0000000..84c160a
--- /dev/null
+++ b/src/ReactiveUI.Primitives/ConnectableSignalMixins.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 ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives;
+
+/// <summary>
+/// Hot-sharing operators for Primitives connectable signals.
+/// </summary>
+public static class ConnectableSignalMixins
+{
+    /// <summary>
+    /// Multicasts source values through the supplied hub.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to multicast.</param>
+    /// <param name="hub">Hub that receives source values.</param>
+    /// <returns>A connectable signal.</returns>
+    public static ConnectableSignal<T> Multicast<T>(this IObservable<T> source, ISignal<T> hub)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (hub == null)
+        {
+            throw new ArgumentNullException(nameof(hub));
+        }
+
+        return new ConnectableSignal<T>(source, hub);
+    }
+
+    /// <summary>
+    /// Publishes source values through a live signal hub.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to publish.</param>
+    /// <returns>A connectable live signal.</returns>
+    public static ConnectableSignal<T> PublishLive<T>(this IObservable<T> source) =>
+        source.Multicast(new Signal<T>());
+
+    /// <summary>
+    /// Publishes source values through a live signal hub.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to publish.</param>
+    /// <returns>A connectable live signal.</returns>
+    public static ConnectableSignal<T> Publish<T>(this IObservable<T> source) =>
+        source.PublishLive();
+
+    /// <summary>
+    /// Replays source values through a bounded replay hub.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to replay.</param>
+    /// <param name="bufferSize">Maximum number of values to replay.</param>
+    /// <returns>A connectable replay signal.</returns>
+    public static ConnectableSignal<T> ReplayLive<T>(this IObservable<T> source, int bufferSize) =>
+        source.Multicast(new ReplaySignal<T>(bufferSize));
+
+    /// <summary>
+    /// Replays source values through a replay hub constrained by count and time.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to replay.</param>
+    /// <param name="bufferSize">Maximum number of values to replay.</param>
+    /// <param name="window">Maximum replay window.</param>
+    /// <returns>A connectable replay signal.</returns>
+    public static ConnectableSignal<T> ReplayLive<T>(this IObservable<T> source, int bufferSize, TimeSpan window) =>
+        source.Multicast(new ReplaySignal<T>(bufferSize, window));
+
+    /// <summary>
+    /// Replays source values through a bounded replay hub.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to replay.</param>
+    /// <param name="bufferSize">Maximum number of values to replay.</param>
+    /// <returns>A connectable replay signal.</returns>
+    public static ConnectableSignal<T> Replay<T>(this IObservable<T> source, int bufferSize) =>
+        source.ReplayLive(bufferSize);
+
+    /// <summary>
+    /// Replays source values through a replay hub constrained by count and time.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to replay.</param>
+    /// <param name="bufferSize">Maximum number of values to replay.</param>
+    /// <param name="window">Maximum replay window.</param>
+    /// <returns>A connectable replay signal.</returns>
+    public static ConnectableSignal<T> Replay<T>(this IObservable<T> source, int bufferSize, TimeSpan window) =>
+        source.ReplayLive(bufferSize, window);
+
+    /// <summary>
+    /// Shares one live source subscription while at least one observer is subscribed.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to share.</param>
+    /// <returns>A reference-counted live sequence.</returns>
+    public static IObservable<T> ShareLive<T>(this IObservable<T> source) => source.PublishLive().RefCount();
+
+    /// <summary>
+    /// Shares one live source subscription while at least one observer is subscribed.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Source sequence to share.</param>
+    /// <returns>A reference-counted live sequence.</returns>
+    public static IObservable<T> Share<T>(this IObservable<T> source) => source.ShareLive();
+
+    /// <summary>
+    /// Connects on first subscriber and disconnects when the last subscriber disposes.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Connectable signal to reference count.</param>
+    /// <returns>A reference-counted sequence.</returns>
+    public static IObservable<T> RefCount<T>(this ConnectableSignal<T> source)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        var gate = RefCountGate<T>.For(source);
+        return Signal.Create<T>(gate.Subscribe);
+    }
+
+    /// <summary>
+    /// Connects on the first observer subscription.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Connectable signal to connect.</param>
+    /// <returns>A sequence that connects after the first subscription.</returns>
+    public static IObservable<T> AutoConnect<T>(this ConnectableSignal<T> source) =>
+        AutoConnect(source, 1);
+
+    /// <summary>
+    /// Connects after <paramref name="subscriberCount"/> observers have subscribed.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">Connectable signal to connect.</param>
+    /// <param name="subscriberCount">Number of observers required before connecting.</param>
+    /// <returns>A sequence that connects after the requested number of subscriptions.</returns>
+    public static IObservable<T> AutoConnect<T>(this ConnectableSignal<T> source, int subscriberCount)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (subscriberCount < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(subscriberCount));
+        }
+
+        var gate = AutoConnectGate<T>.For(source, subscriberCount);
+        return Signal.Create<T>(gate.Subscribe);
+    }
+
+    /// <summary>
+    /// Tracks reference-counted connection state.
+    /// </summary>
+    /// <typeparam name="TValue">The value type.</typeparam>
+    private sealed class RefCountGate<TValue>
+    {
+        /// <summary>
+        /// Synchronizes reference-count state.
+        /// </summary>
+        private readonly object _gate = new();
+
+        /// <summary>
+        /// Connectable signal being reference-counted.
+        /// </summary>
+        private readonly ConnectableSignal<TValue> _source;
+
+        /// <summary>
+        /// Active subscriber count.
+        /// </summary>
+        private int _count;
+
+        /// <summary>
+        /// Active source connection.
+        /// </summary>
+        private IDisposable? _connection;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RefCountGate{TValue}"/> class.
+        /// </summary>
+        /// <param name="source">Connectable signal being reference-counted.</param>
+        private RefCountGate(ConnectableSignal<TValue> source) => _source = source;
+
+        /// <summary>
+        /// Creates a reference-count gate for a connectable signal.
+        /// </summary>
+        /// <param name="source">Connectable signal being reference-counted.</param>
+        /// <returns>A reference-count gate.</returns>
+        public static RefCountGate<TValue> For(ConnectableSignal<TValue> source) => new(source);
+
+        /// <summary>
+        /// Subscribes an observer and manages the shared connection lifetime.
+        /// </summary>
+        /// <param name="observer">Observer to subscribe.</param>
+        /// <returns>A disposable that removes the observer and may disconnect the source.</returns>
+        public IDisposable Subscribe(IObserver<TValue> observer)
+        {
+            IDisposable subscription;
+            lock (_gate)
+            {
+                subscription = _source.Subscribe(observer);
+                _count++;
+                _connection ??= _source.Connect();
+            }
+
+            return Disposable.Create(() =>
+            {
+                subscription.Dispose();
+                lock (_gate)
+                {
+                    _count--;
+                    if (_count == 0)
+                    {
+                        _connection?.Dispose();
+                        _connection = null;
+                    }
+                }
+            });
+        }
+    }
+
+    /// <summary>
+    /// Tracks auto-connect subscription state.
+    /// </summary>
+    /// <typeparam name="TValue">The value type.</typeparam>
+    private sealed class AutoConnectGate<TValue>
+    {
+        /// <summary>
+        /// Synchronizes auto-connect state.
+        /// </summary>
+        private readonly object _gate = new();
+
+        /// <summary>
+        /// Connectable signal being auto-connected.
+        /// </summary>
+        private readonly ConnectableSignal<TValue> _source;
+
+        /// <summary>
+        /// Number of observers required before connecting.
+        /// </summary>
+        private readonly int _subscriberCount;
+
+        /// <summary>
+        /// Current subscriber count.
+        /// </summary>
+        private int _count;
+
+        /// <summary>
+        /// Value indicating whether the source has connected.
+        /// </summary>
+        private bool _connected;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AutoConnectGate{TValue}"/> class.
+        /// </summary>
+        /// <param name="source">Connectable signal being auto-connected.</param>
+        /// <param name="subscriberCount">Number of observers required before connecting.</param>
+        private AutoConnectGate(ConnectableSignal<TValue> source, int subscriberCount)
+        {
+            _source = source;
+            _subscriberCount = subscriberCount;
+        }
+
+        /// <summary>
+        /// Creates an auto-connect gate for a connectable signal.
+        /// </summary>
+        /// <param name="source">Connectable signal being auto-connected.</param>
+        /// <param name="subscriberCount">Number of observers required before connecting.</param>
+        /// <returns>An auto-connect gate.</returns>
+        public static AutoConnectGate<TValue> For(ConnectableSignal<TValue> source, int subscriberCount) =>
+            new(source, subscriberCount);
+
+        /// <summary>
+        /// Subscribes an observer and connects when the threshold is reached.
+        /// </summary>
+        /// <param name="observer">Observer to subscribe.</param>
+        /// <returns>A disposable that removes the observer subscription.</returns>
+        public IDisposable Subscribe(IObserver<TValue> observer)
+        {
+            var subscription = _source.Subscribe(observer);
+            lock (_gate)
+            {
+                _count++;
+                if (!_connected && _count >= _subscriberCount)
+                {
+                    _connected = true;
+                    _source.Connect();
+                }
+            }
+
+            return subscription;
+        }
+    }
+}
diff --git a/src/ReactiveUI.Primitives/ConnectableSignal{T}.cs b/src/ReactiveUI.Primitives/ConnectableSignal{T}.cs
index b358610..452ea94 100644
--- a/src/ReactiveUI.Primitives/ConnectableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives/ConnectableSignal{T}.cs
@@ -5,15 +5,14 @@
 using ReactiveUI.Primitives.Disposables;
 using ReactiveUI.Primitives.Signals;
 
-#pragma warning disable SA1107, SA1116, SA1117, SA1204, SA1402, SA1501, SA1611, SA1615, SA1618
-
 namespace ReactiveUI.Primitives;
 
 /// <summary>
 /// Connectable hot signal that subscribes to its source only when connected.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
-public sealed class ConnectableSignal<T> : IObservable<T>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class ConnectableSignal<T> : IObservable<T>
 {
     /// <summary>
     /// Synchronizes connection state.
@@ -74,261 +73,3 @@ public IDisposable Connect()
     /// <inheritdoc />
     public IDisposable Subscribe(IObserver<T> observer) => _hub.Subscribe(observer);
 }
-
-/// <summary>
-/// Hot-sharing operators for Primitives connectable signals.
-/// </summary>
-public static class ConnectableSignalMixins
-{
-    /// <summary>
-    /// Multicasts source values through the supplied hub.
-    /// </summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">Source sequence to multicast.</param>
-    /// <param name="hub">Hub that receives source values.</param>
-    /// <returns>A connectable signal.</returns>
-    public static ConnectableSignal<T> Multicast<T>(this IObservable<T> source, ISignal<T> hub)
-    {
-        if (source == null)
-        {
-            throw new ArgumentNullException(nameof(source));
-        }
-
-        if (hub == null)
-        {
-            throw new ArgumentNullException(nameof(hub));
-        }
-
-        return new ConnectableSignal<T>(source, hub);
-    }
-
-    /// <summary>
-    /// Publishes source values through a live signal hub.
-    /// </summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">Source sequence to publish.</param>
-    /// <returns>A connectable live signal.</returns>
-    public static ConnectableSignal<T> PublishLive<T>(this IObservable<T> source) =>
-        source.Multicast(new Signal<T>());
-
-    /// <summary>
-    /// Replays source values through a bounded replay hub.
-    /// </summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">Source sequence to replay.</param>
-    /// <param name="bufferSize">Maximum number of values to replay.</param>
-    /// <returns>A connectable replay signal.</returns>
-    public static ConnectableSignal<T> ReplayLive<T>(this IObservable<T> source, int bufferSize) =>
-        source.Multicast(new ReplaySignal<T>(bufferSize));
-
-    /// <summary>
-    /// Replays source values through a replay hub constrained by count and time.
-    /// </summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">Source sequence to replay.</param>
-    /// <param name="bufferSize">Maximum number of values to replay.</param>
-    /// <param name="window">Maximum replay window.</param>
-    /// <returns>A connectable replay signal.</returns>
-    public static ConnectableSignal<T> ReplayLive<T>(this IObservable<T> source, int bufferSize, TimeSpan window) =>
-        source.Multicast(new ReplaySignal<T>(bufferSize, window));
-
-    /// <summary>
-    /// Shares one live source subscription while at least one observer is subscribed.
-    /// </summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">Source sequence to share.</param>
-    /// <returns>A reference-counted live sequence.</returns>
-    public static IObservable<T> ShareLive<T>(this IObservable<T> source) => source.PublishLive().RefCount();
-
-    /// <summary>
-    /// Connects on first subscriber and disconnects when the last subscriber disposes.
-    /// </summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">Connectable signal to reference count.</param>
-    /// <returns>A reference-counted sequence.</returns>
-    public static IObservable<T> RefCount<T>(this ConnectableSignal<T> source)
-    {
-        if (source == null)
-        {
-            throw new ArgumentNullException(nameof(source));
-        }
-
-        var gate = RefCountGate<T>.For(source);
-        return ReactiveUI.Primitives.Signals.Signal.Create<T>(gate.Subscribe);
-    }
-
-    /// <summary>
-    /// Connects on the first observer subscription.
-    /// </summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">Connectable signal to connect.</param>
-    /// <returns>A sequence that connects after the first subscription.</returns>
-    public static IObservable<T> AutoConnect<T>(this ConnectableSignal<T> source) =>
-        AutoConnect(source, 1);
-
-    /// <summary>
-    /// Connects after <paramref name="subscriberCount"/> observers have subscribed.
-    /// </summary>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <param name="source">Connectable signal to connect.</param>
-    /// <param name="subscriberCount">Number of observers required before connecting.</param>
-    /// <returns>A sequence that connects after the requested number of subscriptions.</returns>
-    public static IObservable<T> AutoConnect<T>(this ConnectableSignal<T> source, int subscriberCount)
-    {
-        if (source == null)
-        {
-            throw new ArgumentNullException(nameof(source));
-        }
-
-        if (subscriberCount < 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(subscriberCount));
-        }
-
-        var gate = AutoConnectGate<T>.For(source, subscriberCount);
-        return ReactiveUI.Primitives.Signals.Signal.Create<T>(gate.Subscribe);
-    }
-
-    /// <summary>
-    /// Tracks reference-counted connection state.
-    /// </summary>
-    /// <typeparam name="TValue">The value type.</typeparam>
-    private sealed class RefCountGate<TValue>
-    {
-        /// <summary>
-        /// Synchronizes reference-count state.
-        /// </summary>
-        private readonly object _gate = new();
-
-        /// <summary>
-        /// Connectable signal being reference-counted.
-        /// </summary>
-        private readonly ConnectableSignal<TValue> _source;
-
-        /// <summary>
-        /// Active subscriber count.
-        /// </summary>
-        private int _count;
-
-        /// <summary>
-        /// Active source connection.
-        /// </summary>
-        private IDisposable? _connection;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RefCountGate{TValue}"/> class.
-        /// </summary>
-        /// <param name="source">Connectable signal being reference-counted.</param>
-        private RefCountGate(ConnectableSignal<TValue> source) => _source = source;
-
-        /// <summary>
-        /// Creates a reference-count gate for a connectable signal.
-        /// </summary>
-        /// <param name="source">Connectable signal being reference-counted.</param>
-        /// <returns>A reference-count gate.</returns>
-        public static RefCountGate<TValue> For(ConnectableSignal<TValue> source) => new(source);
-
-        /// <summary>
-        /// Subscribes an observer and manages the shared connection lifetime.
-        /// </summary>
-        /// <param name="observer">Observer to subscribe.</param>
-        /// <returns>A disposable that removes the observer and may disconnect the source.</returns>
-        public IDisposable Subscribe(IObserver<TValue> observer)
-        {
-            IDisposable subscription;
-            lock (_gate)
-            {
-                subscription = _source.Subscribe(observer);
-                _count++;
-                _connection ??= _source.Connect();
-            }
-
-            return Disposable.Create(() =>
-            {
-                subscription.Dispose();
-                lock (_gate)
-                {
-                    _count--;
-                    if (_count == 0)
-                    {
-                        _connection?.Dispose();
-                        _connection = null;
-                    }
-                }
-            });
-        }
-    }
-
-    /// <summary>
-    /// Tracks auto-connect subscription state.
-    /// </summary>
-    /// <typeparam name="TValue">The value type.</typeparam>
-    private sealed class AutoConnectGate<TValue>
-    {
-        /// <summary>
-        /// Synchronizes auto-connect state.
-        /// </summary>
-        private readonly object _gate = new();
-
-        /// <summary>
-        /// Connectable signal being auto-connected.
-        /// </summary>
-        private readonly ConnectableSignal<TValue> _source;
-
-        /// <summary>
-        /// Number of observers required before connecting.
-        /// </summary>
-        private readonly int _subscriberCount;
-
-        /// <summary>
-        /// Current subscriber count.
-        /// </summary>
-        private int _count;
-
-        /// <summary>
-        /// Value indicating whether the source has connected.
-        /// </summary>
-        private bool _connected;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="AutoConnectGate{TValue}"/> class.
-        /// </summary>
-        /// <param name="source">Connectable signal being auto-connected.</param>
-        /// <param name="subscriberCount">Number of observers required before connecting.</param>
-        private AutoConnectGate(ConnectableSignal<TValue> source, int subscriberCount)
-        {
-            _source = source;
-            _subscriberCount = subscriberCount;
-        }
-
-        /// <summary>
-        /// Creates an auto-connect gate for a connectable signal.
-        /// </summary>
-        /// <param name="source">Connectable signal being auto-connected.</param>
-        /// <param name="subscriberCount">Number of observers required before connecting.</param>
-        /// <returns>An auto-connect gate.</returns>
-        public static AutoConnectGate<TValue> For(ConnectableSignal<TValue> source, int subscriberCount) =>
-            new(source, subscriberCount);
-
-        /// <summary>
-        /// Subscribes an observer and connects when the threshold is reached.
-        /// </summary>
-        /// <param name="observer">Observer to subscribe.</param>
-        /// <returns>A disposable that removes the observer subscription.</returns>
-        public IDisposable Subscribe(IObserver<TValue> observer)
-        {
-            var subscription = _source.Subscribe(observer);
-            lock (_gate)
-            {
-                _count++;
-                if (!_connected && _count >= _subscriberCount)
-                {
-                    _connected = true;
-                    _source.Connect();
-                }
-            }
-
-            return subscription;
-        }
-    }
-}
diff --git a/src/ReactiveUI.Primitives/Core/Moment{T}.cs b/src/ReactiveUI.Primitives/Core/Moment{T}.cs
index cb0224d..29b596e 100644
--- a/src/ReactiveUI.Primitives/Core/Moment{T}.cs
+++ b/src/ReactiveUI.Primitives/Core/Moment{T}.cs
@@ -11,7 +11,8 @@ namespace ReactiveUI.Primitives.Core;
 /// </summary>
 /// <typeparam name="T">The captured value type.</typeparam>
 [Serializable]
-public readonly struct Moment<T> : IEquatable<Moment<T>>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public readonly partial struct Moment<T> : IEquatable<Moment<T>>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="Moment{T}"/> struct.
diff --git a/src/ReactiveUI.Primitives/Core/Spark{T}.cs b/src/ReactiveUI.Primitives/Core/Spark{T}.cs
index 7f26636..ae0ff65 100644
--- a/src/ReactiveUI.Primitives/Core/Spark{T}.cs
+++ b/src/ReactiveUI.Primitives/Core/Spark{T}.cs
@@ -14,7 +14,8 @@ namespace ReactiveUI.Primitives.Core
     /// </summary>
     /// <typeparam name="T">The type of the elements received by the observer.</typeparam>
     [Serializable]
-    public abstract class Spark<T> : IEquatable<Spark<T>>
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    public abstract partial class Spark<T> : IEquatable<Spark<T>>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="Spark{T}"/> class.
diff --git a/src/ReactiveUI.Primitives/Core/TimeInterval{T}.cs b/src/ReactiveUI.Primitives/Core/TimeInterval{T}.cs
index d5bdb0f..f25a735 100644
--- a/src/ReactiveUI.Primitives/Core/TimeInterval{T}.cs
+++ b/src/ReactiveUI.Primitives/Core/TimeInterval{T}.cs
@@ -12,7 +12,8 @@ namespace ReactiveUI.Primitives.Core;
 /// </summary>
 /// <typeparam name="T">The type of the value being annotated with time interval information.</typeparam>
 [Serializable]
-public readonly struct TimeInterval<T> : IEquatable<TimeInterval<T>>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public readonly partial struct TimeInterval<T> : IEquatable<TimeInterval<T>>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="TimeInterval{T}"/> struct.
diff --git a/src/ReactiveUI.Primitives/DebuggerDisplay.Partials.cs b/src/ReactiveUI.Primitives/DebuggerDisplay.Partials.cs
new file mode 100644
index 0000000..90ec635
--- /dev/null
+++ b/src/ReactiveUI.Primitives/DebuggerDisplay.Partials.cs
@@ -0,0 +1,309 @@
+// 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.
+
+#pragma warning disable SA1201 // Debugger display partial members are grouped by namespace.
+#pragma warning disable SA1402 // Debugger display partial members are intentionally grouped in one support file.
+#pragma warning disable SA1403 // Debugger display partial members span the public namespaces that need the shared pattern.
+#pragma warning disable SA1601 // Primary type declarations carry the public documentation.
+
+namespace ReactiveUI.Primitives
+{
+    public sealed partial class ConnectableSignal<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public readonly partial struct RxVoid
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+}
+
+namespace ReactiveUI.Primitives.Concurrency
+{
+    public sealed partial class CurrentThreadSequencer
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+#if WINDOWS
+    public partial class DispatcherSequencer
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+#endif
+
+    public sealed partial class ImmediateSequencer
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public abstract partial class ScheduledItem<TAbsolute>
+        where TAbsolute : IComparable<TAbsolute>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class ScheduledItem<TAbsolute, TValue>
+        where TAbsolute : IComparable<TAbsolute>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public partial class SequencerQueue<TAbsolute>
+        where TAbsolute : IComparable<TAbsolute>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class TaskPoolSequencer
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class TestClock
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class ThreadPoolSequencer
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public partial class VirtualClock
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public abstract partial class VirtualTimeSequencer<TAbsolute, TRelative>
+        where TAbsolute : IComparable<TAbsolute>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public abstract partial class VirtualTimeSequencerBase<TAbsolute, TRelative>
+        where TAbsolute : IComparable<TAbsolute>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+}
+
+namespace ReactiveUI.Primitives.Core
+{
+    public readonly partial struct Moment<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public abstract partial class Spark<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public readonly partial struct TimeInterval<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+}
+
+namespace ReactiveUI.Primitives.Disposables
+{
+    public sealed partial class AssignmentSlot
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class BooleanDisposable
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class CancellationDisposable
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public partial class MultipleDisposable
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class Pocket
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public partial class SingleDisposable
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public partial class SingleReplaceableDisposable
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class Slot
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+}
+
+namespace ReactiveUI.Primitives.Signals
+{
+    public partial class AsyncSignal<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class CommandSignal<TResult>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public sealed partial class ReadOnlyState<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public partial class ReplaySignal<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public partial class Signal<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+
+    public partial class StateSignal<T>
+    {
+        /// <summary>
+        /// Gets the debugger display text.
+        /// </summary>
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private string DebuggerDisplay => ToString() ?? string.Empty;
+    }
+}
diff --git a/src/ReactiveUI.Primitives/Disposables/AssignmentSlot.cs b/src/ReactiveUI.Primitives/Disposables/AssignmentSlot.cs
index 84b2ba0..bce827d 100644
--- a/src/ReactiveUI.Primitives/Disposables/AssignmentSlot.cs
+++ b/src/ReactiveUI.Primitives/Disposables/AssignmentSlot.cs
@@ -7,7 +7,8 @@ namespace ReactiveUI.Primitives.Disposables;
 /// <summary>
 /// Primitives alias for a single-assignment disposable slot.
 /// </summary>
-public sealed class AssignmentSlot : SingleDisposable
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class AssignmentSlot : SingleDisposable
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="AssignmentSlot"/> class.
diff --git a/src/ReactiveUI.Primitives/Disposables/BooleanDisposable.cs b/src/ReactiveUI.Primitives/Disposables/BooleanDisposable.cs
index 5723f38..a7256fc 100644
--- a/src/ReactiveUI.Primitives/Disposables/BooleanDisposable.cs
+++ b/src/ReactiveUI.Primitives/Disposables/BooleanDisposable.cs
@@ -7,8 +7,9 @@ namespace ReactiveUI.Primitives.Disposables;
 /// <summary>
 /// BooleanDisposable.
 /// </summary>
-/// <seealso cref="ReactiveUI.Primitives.Disposables.IsDisposed" />
-public sealed class BooleanDisposable : IsDisposed
+/// <seealso cref="Disposables.IsDisposed" />
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class BooleanDisposable : IsDisposed
 {
     /// <summary>
     /// Gets a value indicating whether this instance is disposed.
diff --git a/src/ReactiveUI.Primitives/Disposables/CancellationDisposable.cs b/src/ReactiveUI.Primitives/Disposables/CancellationDisposable.cs
index 81e1968..805635e 100644
--- a/src/ReactiveUI.Primitives/Disposables/CancellationDisposable.cs
+++ b/src/ReactiveUI.Primitives/Disposables/CancellationDisposable.cs
@@ -7,8 +7,9 @@ namespace ReactiveUI.Primitives.Disposables;
 /// <summary>
 /// CancellationDisposable.
 /// </summary>
-/// <seealso cref="System.IDisposable" />
-public sealed class CancellationDisposable : IsDisposed
+/// <seealso cref="IDisposable" />
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class CancellationDisposable : IsDisposed
 {
     /// <summary>
     /// Cancellation source owned by this disposable.
@@ -19,7 +20,7 @@ public sealed class CancellationDisposable : IsDisposed
     /// Initializes a new instance of the <see cref="CancellationDisposable"/> class.
     /// </summary>
     /// <param name="cts">The CTS.</param>
-    /// <exception cref="System.ArgumentNullException">cts.</exception>
+    /// <exception cref="ArgumentNullException">cts.</exception>
     public CancellationDisposable(CancellationTokenSource cts) => _cts = cts ?? throw new ArgumentNullException(nameof(cts));
 
     /// <summary>
diff --git a/src/ReactiveUI.Primitives/Disposables/MultipleDisposable.cs b/src/ReactiveUI.Primitives/Disposables/MultipleDisposable.cs
index 03e9e7e..36d10a3 100644
--- a/src/ReactiveUI.Primitives/Disposables/MultipleDisposable.cs
+++ b/src/ReactiveUI.Primitives/Disposables/MultipleDisposable.cs
@@ -7,7 +7,8 @@ namespace ReactiveUI.Primitives.Disposables;
 /// <summary>
 /// A disposable pocket that contains a set of disposables and disposes them together.
 /// </summary>
-public class MultipleDisposable : IsDisposed
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class MultipleDisposable : IsDisposed
 {
     /// <summary>
     /// Initial capacity for overflow disposable storage.
diff --git a/src/ReactiveUI.Primitives/Disposables/Pocket.cs b/src/ReactiveUI.Primitives/Disposables/Pocket.cs
index aff6be0..4b987d1 100644
--- a/src/ReactiveUI.Primitives/Disposables/Pocket.cs
+++ b/src/ReactiveUI.Primitives/Disposables/Pocket.cs
@@ -7,7 +7,8 @@ namespace ReactiveUI.Primitives.Disposables;
 /// <summary>
 /// Primitives alias for a group of disposables that are disposed together.
 /// </summary>
-public sealed class Pocket : MultipleDisposable
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class Pocket : MultipleDisposable
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="Pocket"/> class.
diff --git a/src/ReactiveUI.Primitives/Disposables/SingleDisposable.cs b/src/ReactiveUI.Primitives/Disposables/SingleDisposable.cs
index 55143f8..db0c0fb 100644
--- a/src/ReactiveUI.Primitives/Disposables/SingleDisposable.cs
+++ b/src/ReactiveUI.Primitives/Disposables/SingleDisposable.cs
@@ -7,7 +7,8 @@ namespace ReactiveUI.Primitives.Disposables;
 /// <summary>
 /// Single-assignment disposable slot.
 /// </summary>
-public class SingleDisposable : IsDisposed
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class SingleDisposable : IsDisposed
 {
     /// <summary>
     /// Marker used once the slot has been disposed.
diff --git a/src/ReactiveUI.Primitives/Disposables/SingleReplaceableDisposable.cs b/src/ReactiveUI.Primitives/Disposables/SingleReplaceableDisposable.cs
index 73518db..92e7538 100644
--- a/src/ReactiveUI.Primitives/Disposables/SingleReplaceableDisposable.cs
+++ b/src/ReactiveUI.Primitives/Disposables/SingleReplaceableDisposable.cs
@@ -7,7 +7,8 @@ namespace ReactiveUI.Primitives.Disposables;
 /// <summary>
 /// SingleReplaceableDisposable.
 /// </summary>
-public class SingleReplaceableDisposable : IsDisposed
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class SingleReplaceableDisposable : IsDisposed
 {
     /// <summary>
     /// Marker used once the slot has been disposed.
diff --git a/src/ReactiveUI.Primitives/Disposables/Slot.cs b/src/ReactiveUI.Primitives/Disposables/Slot.cs
index 4c2ccab..ed54b55 100644
--- a/src/ReactiveUI.Primitives/Disposables/Slot.cs
+++ b/src/ReactiveUI.Primitives/Disposables/Slot.cs
@@ -7,7 +7,8 @@ namespace ReactiveUI.Primitives.Disposables;
 /// <summary>
 /// Primitives alias for a replaceable disposable slot.
 /// </summary>
-public sealed class Slot : SingleReplaceableDisposable
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class Slot : SingleReplaceableDisposable
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="Slot"/> class.
diff --git a/src/ReactiveUI.Primitives/LinqMixins.cs b/src/ReactiveUI.Primitives/LinqMixins.cs
index c76a886..f615299 100644
--- a/src/ReactiveUI.Primitives/LinqMixins.cs
+++ b/src/ReactiveUI.Primitives/LinqMixins.cs
@@ -20,7 +20,7 @@ public static partial class LinqMixins
     /// <param name="source">The source.</param>
     /// <param name="selector">The selector.</param>
     /// <returns>A ISignals.</returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// source
     /// or
     /// selector.
@@ -35,8 +35,8 @@ public static IObservable<TResult> Select<TSource, TResult>(this IObservable<TSo
     /// <param name="source">The source.</param>
     /// <param name="count">The count of each buffer.</param>
     /// <returns>An Signals sequence of buffers.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    /// <exception cref="System.ArgumentOutOfRangeException">count.</exception>
+    /// <exception cref="ArgumentNullException">source.</exception>
+    /// <exception cref="ArgumentOutOfRangeException">count.</exception>
     public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSource> source, int count)
     {
         if (source == null)
@@ -60,8 +60,8 @@ public static IObservable<IList<TSource>> Buffer<TSource>(this IObservable<TSour
     /// <param name="count">Length of each buffer before being skipped.</param>
     /// <param name="skip">Number of elements to skip between creation of consecutive buffers.</param>
     /// <returns>An Signals sequence of buffers taking the count then skipping the skipped value, the sequecnce is then repeated.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
-    /// <exception cref="System.ArgumentOutOfRangeException">
+    /// <exception cref="ArgumentNullException">source.</exception>
+    /// <exception cref="ArgumentOutOfRangeException">
     /// count
     /// or
     /// skip.
@@ -122,7 +122,7 @@ public static SingleDisposable DisposeWith(this IDisposable disposable, Action?
     /// <param name="source">The source.</param>
     /// <param name="predicate">The predicate.</param>
     /// <returns>An ISignals.</returns>
-    /// <exception cref="System.ArgumentNullException">
+    /// <exception cref="ArgumentNullException">
     /// source
     /// or
     /// predicate.
diff --git a/src/ReactiveUI.Primitives/RxVoid.cs b/src/ReactiveUI.Primitives/RxVoid.cs
index 5cd8e95..99654dd 100644
--- a/src/ReactiveUI.Primitives/RxVoid.cs
+++ b/src/ReactiveUI.Primitives/RxVoid.cs
@@ -8,7 +8,8 @@ namespace ReactiveUI.Primitives;
 /// A Reactive Void.
 /// </summary>
 [Serializable]
-public readonly struct RxVoid : IEquatable<RxVoid>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public readonly partial struct RxVoid : IEquatable<RxVoid>
 {
     /// <summary>
     /// Gets the single <see cref="RxVoid"/> value.
diff --git a/src/ReactiveUI.Primitives/Signal/AsyncSignal{T}.cs b/src/ReactiveUI.Primitives/Signal/AsyncSignal{T}.cs
index e824256..35c8650 100644
--- a/src/ReactiveUI.Primitives/Signal/AsyncSignal{T}.cs
+++ b/src/ReactiveUI.Primitives/Signal/AsyncSignal{T}.cs
@@ -11,8 +11,9 @@ namespace ReactiveUI.Primitives.Signals;
 /// AsyncSignal.
 /// </summary>
 /// <typeparam name="T">The Type.</typeparam>
-/// <seealso cref="ReactiveUI.Primitives.Signals.ISignal&lt;T&gt;" />
-public class AsyncSignal<T> : IAwaitSignal<T>
+/// <seealso cref="ISignal&lt;T&gt;" />
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class AsyncSignal<T> : IAwaitSignal<T>
 {
     /// <summary>
     /// Executes the new operation.
@@ -54,7 +55,7 @@ public class AsyncSignal<T> : IAwaitSignal<T>
     /// <value>
     /// The value.
     /// </value>
-    /// <exception cref="System.InvalidOperationException">AsyncSubject is not completed yet.</exception>
+    /// <exception cref="InvalidOperationException">AsyncSubject is not completed yet.</exception>
     public T Value
     {
         get
@@ -140,7 +141,7 @@ public void OnCompleted(Action continuation)
     /// Called when [error].
     /// </summary>
     /// <param name="error">The error.</param>
-    /// <exception cref="System.ArgumentNullException">error.</exception>
+    /// <exception cref="ArgumentNullException">error.</exception>
     public void OnError(Exception error)
     {
         if (error == null)
@@ -190,7 +191,7 @@ public void OnNext(T value)
     /// </summary>
     /// <param name="observer">The observer.</param>
     /// <returns>A Disposable.</returns>
-    /// <exception cref="System.ArgumentNullException">observer.</exception>
+    /// <exception cref="ArgumentNullException">observer.</exception>
     public IDisposable Subscribe(IObserver<T> observer)
     {
         if (observer == null)
diff --git a/src/ReactiveUI.Primitives/Signal/BehaviourSignal{T}.cs b/src/ReactiveUI.Primitives/Signal/BehaviorSignal{T}.cs
similarity index 93%
rename from src/ReactiveUI.Primitives/Signal/BehaviourSignal{T}.cs
rename to src/ReactiveUI.Primitives/Signal/BehaviorSignal{T}.cs
index b836024..e41ab61 100644
--- a/src/ReactiveUI.Primitives/Signal/BehaviourSignal{T}.cs
+++ b/src/ReactiveUI.Primitives/Signal/BehaviorSignal{T}.cs
@@ -11,7 +11,8 @@ namespace ReactiveUI.Primitives.Signals;
 /// BehaviourSignal.
 /// </summary>
 /// <typeparam name="T">The Type.</typeparam>
-public class BehaviourSignal<T> : ISignal<T>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public class BehaviorSignal<T> : ISignal<T>
 {
     /// <summary>
     /// Executes the new operation.
@@ -42,10 +43,10 @@ public class BehaviourSignal<T> : ISignal<T>
     private Exception? _lastError;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="BehaviourSignal{T}"/> class.
+    /// Initializes a new instance of the <see cref="BehaviorSignal{T}"/> class.
     /// </summary>
     /// <param name="defaultValue">The default value.</param>
-    public BehaviourSignal(T defaultValue)
+    public BehaviorSignal(T defaultValue)
     {
         _lastValue = defaultValue;
     }
@@ -90,6 +91,18 @@ public T Value
     /// </value>
     public bool IsDisposed { get; private set; }
 
+    /// <summary>
+    /// Gets the string representation of this object for debugger display purposes.
+    /// </summary>
+    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+    private string? DebuggerDisplay
+    {
+        get
+        {
+            return ToString();
+        }
+    }
+
     /// <summary>
     /// Tries to get the current value or throws an exception.
     /// </summary>
@@ -297,7 +310,7 @@ private sealed class ObserverHandler : IDisposable
         /// <summary>
         /// Stores state for the signal implementation.
         /// </summary>
-        private BehaviourSignal<T>? _subject;
+        private BehaviorSignal<T>? _subject;
 
         /// <summary>
         /// Stores state for the signal implementation.
@@ -309,7 +322,7 @@ private sealed class ObserverHandler : IDisposable
         /// </summary>
         /// <param name="subject">The subject value.</param>
         /// <param name="observer">The observer value.</param>
-        public ObserverHandler(BehaviourSignal<T> subject, IObserver<T> observer)
+        public ObserverHandler(BehaviorSignal<T> subject, IObserver<T> observer)
         {
             _subject = subject;
             _observer = observer;
diff --git a/src/ReactiveUI.Primitives/Signal/CommandSignal{TResult}.cs b/src/ReactiveUI.Primitives/Signal/CommandSignal{TResult}.cs
index 46f9991..36dd6b8 100644
--- a/src/ReactiveUI.Primitives/Signal/CommandSignal{TResult}.cs
+++ b/src/ReactiveUI.Primitives/Signal/CommandSignal{TResult}.cs
@@ -2,15 +2,14 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-#pragma warning disable SA1501
-
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>
 /// Minimal reactive command that gates execution and publishes result, fault, and running state streams.
 /// </summary>
 /// <typeparam name="TResult">The command result type.</typeparam>
-public sealed class CommandSignal<TResult> : IDisposable
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class CommandSignal<TResult> : IDisposable
 {
     /// <summary>
     /// Stores state for the signal implementation.
diff --git a/src/ReactiveUI.Primitives/Signal/IAwaitSignal{T}.cs b/src/ReactiveUI.Primitives/Signal/IAwaitSignal{T}.cs
index 61f13b7..71a3b97 100644
--- a/src/ReactiveUI.Primitives/Signal/IAwaitSignal{T}.cs
+++ b/src/ReactiveUI.Primitives/Signal/IAwaitSignal{T}.cs
@@ -8,7 +8,7 @@ namespace ReactiveUI.Primitives.Signals;
 /// IAwaitSignal.
 /// </summary>
 /// <typeparam name="T">The Type of Signal.</typeparam>
-/// <seealso cref="ReactiveUI.Primitives.Signals.ISignal&lt;T&gt;" />
+/// <seealso cref="ISignal&lt;T&gt;" />
 /// <seealso cref="System.Runtime.CompilerServices.INotifyCompletion" />
 public interface IAwaitSignal<T> : ISignal<T>, System.Runtime.CompilerServices.INotifyCompletion
 {
diff --git a/src/ReactiveUI.Primitives/Signal/ReadOnlyState{T}.cs b/src/ReactiveUI.Primitives/Signal/ReadOnlyState{T}.cs
index 65c6008..d585db3 100644
--- a/src/ReactiveUI.Primitives/Signal/ReadOnlyState{T}.cs
+++ b/src/ReactiveUI.Primitives/Signal/ReadOnlyState{T}.cs
@@ -2,15 +2,14 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-#pragma warning disable SA1116, SA1117, SA1204, SA1402, SA1501, SA1611, SA1615, SA1618
-
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>
 /// Read-only latest-value signal for projected or externally owned state.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
-public sealed class ReadOnlyState<T> : IObservable<T>, IDisposable
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public sealed partial class ReadOnlyState<T> : IObservable<T>, IDisposable
 {
     /// <summary>
     /// Stores state for the signal implementation.
@@ -49,9 +48,11 @@ public ReadOnlyState(IObservable<T> source, T initialValue)
     public IObservable<T> Changed => _inner;
 
     /// <summary>
-    /// Executes the Subscribe operation.
+    /// Notifies the provider that an observer is to receive notifications.
     /// </summary>
-    /// <returns>The result.</returns>
+    /// <param name="observer">The object that is to receive notifications.</param>
+    /// <returns>A reference to an interface that allows observers to stop receiving notifications before the provider has
+    /// finished sending them.</returns>
     public IDisposable Subscribe(IObserver<T> observer) => _inner.Subscribe(observer);
 
     /// <summary>
@@ -63,42 +64,3 @@ public void Dispose()
         _inner.Dispose();
     }
 }
-
-/// <summary>
-/// State projection helpers.
-/// </summary>
-public static class StateSignalMixins
-{
-    /// <summary>
-    /// Projects an observable sequence into a read-only state signal.
-    /// </summary>
-    /// <typeparam name="TSource">The source value type.</typeparam>
-    /// <typeparam name="TResult">The projected value type.</typeparam>
-    /// <param name="source">The source sequence.</param>
-    /// <param name="initialValue">The initial projected value.</param>
-    /// <param name="selector">The projection function.</param>
-    /// <returns>A read-only projected state.</returns>
-    public static ReadOnlyState<TResult> ToReadOnlyState<TSource, TResult>(
-        this IObservable<TSource> source,
-        TResult initialValue,
-        Func<TSource, TResult> selector)
-    {
-        if (source == null)
-        {
-            throw new ArgumentNullException(nameof(source));
-        }
-
-        if (selector == null)
-        {
-            throw new ArgumentNullException(nameof(selector));
-        }
-
-        return new ReadOnlyState<TResult>(
-            ReactiveUI.Primitives.Signals.Signal.CreateSafe<TResult>(
-                observer => source.Subscribe(
-                    value => observer.OnNext(selector(value)),
-                    observer.OnError,
-                    observer.OnCompleted)),
-            initialValue);
-    }
-}
diff --git a/src/ReactiveUI.Primitives/Signal/ReplaySignal{T}.cs b/src/ReactiveUI.Primitives/Signal/ReplaySignal{T}.cs
index 5bd9c14..49fec04 100644
--- a/src/ReactiveUI.Primitives/Signal/ReplaySignal{T}.cs
+++ b/src/ReactiveUI.Primitives/Signal/ReplaySignal{T}.cs
@@ -12,7 +12,8 @@ namespace ReactiveUI.Primitives.Signals;
 /// ReplaySignal.
 /// </summary>
 /// <typeparam name="T">The Type.</typeparam>
-public class ReplaySignal<T> : ISignal<T>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class ReplaySignal<T> : ISignal<T>
 {
     /// <summary>
     /// Stores state for the signal implementation.
diff --git a/src/ReactiveUI.Primitives/Signal/Signal{T}.cs b/src/ReactiveUI.Primitives/Signal/Signal{T}.cs
index 90fadc0..323c24f 100644
--- a/src/ReactiveUI.Primitives/Signal/Signal{T}.cs
+++ b/src/ReactiveUI.Primitives/Signal/Signal{T}.cs
@@ -12,7 +12,8 @@ namespace ReactiveUI.Primitives.Signals;
 /// Subject.
 /// </summary>
 /// <typeparam name="T">The Type.</typeparam>
-public class Signal<T> : ISignal<T>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class Signal<T> : ISignal<T>
 {
     /// <summary>
     /// Stores state for the signal implementation.
diff --git a/src/ReactiveUI.Primitives/Signal/StateSignalMixins.cs b/src/ReactiveUI.Primitives/Signal/StateSignalMixins.cs
new file mode 100644
index 0000000..b69313d
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Signal/StateSignalMixins.cs
@@ -0,0 +1,44 @@
+// 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.Signals;
+
+/// <summary>
+/// State projection helpers.
+/// </summary>
+public static class StateSignalMixins
+{
+    /// <summary>
+    /// Projects an observable sequence into a read-only state signal.
+    /// </summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <typeparam name="TResult">The projected value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="initialValue">The initial projected value.</param>
+    /// <param name="selector">The projection function.</param>
+    /// <returns>A read-only projected state.</returns>
+    public static ReadOnlyState<TResult> ToReadOnlyState<TSource, TResult>(
+        this IObservable<TSource> source,
+        TResult initialValue,
+        Func<TSource, TResult> selector)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (selector == null)
+        {
+            throw new ArgumentNullException(nameof(selector));
+        }
+
+        return new ReadOnlyState<TResult>(
+            Signal.CreateSafe<TResult>(
+                observer => source.Subscribe(
+                    value => observer.OnNext(selector(value)),
+                    observer.OnError,
+                    observer.OnCompleted)),
+            initialValue);
+    }
+}
diff --git a/src/ReactiveUI.Primitives/Signal/StateSignal{T}.cs b/src/ReactiveUI.Primitives/Signal/StateSignal{T}.cs
index 970b515..7dfb0cb 100644
--- a/src/ReactiveUI.Primitives/Signal/StateSignal{T}.cs
+++ b/src/ReactiveUI.Primitives/Signal/StateSignal{T}.cs
@@ -4,15 +4,14 @@
 
 using ReactiveUI.Primitives;
 
-#pragma warning disable SA1501
-
 namespace ReactiveUI.Primitives.Signals;
 
 /// <summary>
 /// Mutable latest-value signal with a ReactiveUI.Primitives name for reactive-property parity.
 /// </summary>
 /// <typeparam name="T">The value type.</typeparam>
-public class StateSignal<T> : BehaviourSignal<T>
+[System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
+public partial class StateSignal<T> : BehaviorSignal<T>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="StateSignal{T}"/> class.
diff --git a/src/ReactiveUI.Primitives/SignalOperatorMixins.cs b/src/ReactiveUI.Primitives/SignalOperatorMixins.cs
index ddd469d..3e5fbbf 100644
--- a/src/ReactiveUI.Primitives/SignalOperatorMixins.cs
+++ b/src/ReactiveUI.Primitives/SignalOperatorMixins.cs
@@ -8,8 +8,6 @@
 using ReactiveUI.Primitives.Signals;
 using ReactiveUI.Primitives.Signals.Core;
 
-#pragma warning disable SA1107, SA1116, SA1117, SA1501, SA1611, SA1615, SA1618
-
 namespace ReactiveUI.Primitives;
 
 /// <summary>
@@ -19,8 +17,15 @@ namespace ReactiveUI.Primitives;
 public static partial class LinqMixins
 {
     /// <summary>
-    /// Maps every value with <paramref name="selector"/>.
+    /// Projects each element of an observable sequence into a new form.
     /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+    /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
+    /// <param name="source">An observable sequence of elements to project.</param>
+    /// <param name="selector">A transform function to apply to each element.</param>
+    /// <returns>An observable sequence whose elements are the result of invoking the transform function on each element of the
+    /// source sequence.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> Map<TSource, TResult>(this IObservable<TSource> source, Func<TSource, TResult> selector)
     {
         if (source == null)
@@ -37,8 +42,18 @@ public static IObservable<TResult> Map<TSource, TResult>(this IObservable<TSourc
     }
 
     /// <summary>
-    /// Maps every value with explicit state to avoid closure allocations in hot paths.
+    /// Projects each element of an observable sequence into a new form by incorporating state that is passed to the
+    /// selector function.
     /// </summary>
+    /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
+    /// <typeparam name="TState">The type of the state used in the selector function.</typeparam>
+    /// <typeparam name="TResult">The type of the elements in the result sequence.</typeparam>
+    /// <param name="source">An observable sequence of elements to project.</param>
+    /// <param name="state">The state to pass to the selector function.</param>
+    /// <param name="selector">A transform function to apply to each source element along with the state.</param>
+    /// <returns>An observable sequence whose elements are the result of invoking the transform function on each element of the
+    /// source along with the state.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> MapWith<TSource, TState, TResult>(this IObservable<TSource> source, TState state, Func<TState, TSource, TResult> selector)
     {
         if (selector == null)
@@ -50,8 +65,14 @@ public static IObservable<TResult> MapWith<TSource, TState, TResult>(this IObser
     }
 
     /// <summary>
-    /// Keeps values that satisfy <paramref name="predicate"/>.
+    /// Filters an observable sequence to include only elements that satisfy a specified condition.
     /// </summary>
+    /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
+    /// <param name="source">The source observable sequence to filter.</param>
+    /// <param name="predicate">A function to test each element for a condition.</param>
+    /// <returns>An observable sequence that contains elements from the input sequence that satisfy the condition specified by
+    /// <paramref name="predicate"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Keep<T>(this IObservable<T> source, Func<T, bool> predicate)
     {
         if (source == null)
@@ -68,8 +89,16 @@ public static IObservable<T> Keep<T>(this IObservable<T> source, Func<T, bool> p
     }
 
     /// <summary>
-    /// Keeps values that satisfy a stateful predicate.
+    /// Filters elements from an observable sequence based on a predicate that uses external state.
     /// </summary>
+    /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+    /// <typeparam name="TState">The type of the state parameter passed to the predicate.</typeparam>
+    /// <param name="source">The source observable sequence to filter.</param>
+    /// <param name="state">The state value to pass to the predicate for each element.</param>
+    /// <param name="predicate">A function to test each element along with the state; returns <see langword="true"/> to keep the element, <see
+    /// langword="false"/> to filter it out.</param>
+    /// <returns>An observable sequence containing only the elements from the source sequence that satisfy the predicate.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="predicate"/> is <see langword="null"/>.</exception>
     public static IObservable<T> KeepWith<T, TState>(this IObservable<T> source, TState state, Func<TState, T, bool> predicate)
     {
         if (predicate == null)
@@ -81,8 +110,12 @@ public static IObservable<T> KeepWith<T, TState>(this IObservable<T> source, TSt
     }
 
     /// <summary>
-    /// Keeps non-null values and narrows nullable references.
+    /// Filters out null values from the source observable sequence, emitting only non-null values.
     /// </summary>
+    /// <typeparam name="T">The type of elements in the observable sequence.</typeparam>
+    /// <param name="source">The source observable sequence to filter.</param>
+    /// <returns>An observable sequence that emits only non-null values from the source sequence.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
     public static IObservable<T> KeepNotNull<T>(this IObservable<T?> source)
         where T : class
     {
@@ -106,8 +139,12 @@ public static IObservable<T> KeepNotNull<T>(this IObservable<T?> source)
     }
 
     /// <summary>
-    /// Projects only values assignable to <typeparamref name="TResult"/>.
+    /// Filters values to those assignable to <typeparamref name="TResult"/>.
     /// </summary>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence containing only values assignable to <typeparamref name="TResult"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Major Code Smell",
         "S4018:Generic methods should provide type parameters",
@@ -134,8 +171,12 @@ public static IObservable<TResult> OfType<TResult>(this IObservable<object?> sou
     }
 
     /// <summary>
-    /// Casts every value to <typeparamref name="TResult"/>.
+    /// Casts each source value to <typeparamref name="TResult"/>.
     /// </summary>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence containing each value cast to <typeparamref name="TResult"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Major Code Smell",
         "S4018:Generic methods should provide type parameters",
@@ -151,8 +192,13 @@ public static IObservable<TResult> Cast<TResult>(this IObservable<object?> sourc
     }
 
     /// <summary>
-    /// Runs a side effect for every value while preserving the source values.
+    /// Invokes an action for each value while preserving the original sequence.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="onNext">The action to invoke for each value.</param>
+    /// <returns>The source values after the action has run.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Tap<T>(this IObservable<T> source, Action<T> onNext)
     {
         if (onNext == null)
@@ -168,8 +214,15 @@ public static IObservable<T> Tap<T>(this IObservable<T> source, Action<T> onNext
     }
 
     /// <summary>
-    /// Runs a stateful side effect for every value while preserving the source values.
+    /// Invokes a stateful action for each value while preserving the original sequence.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <typeparam name="TState">The state type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="state">The state passed to <paramref name="onNext"/>.</param>
+    /// <param name="onNext">The action to invoke for each value.</param>
+    /// <returns>The source values after the action has run.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
     public static IObservable<T> TapWith<T, TState>(this IObservable<T> source, TState state, Action<TState, T> onNext)
     {
         if (onNext == null)
@@ -181,8 +234,15 @@ public static IObservable<T> TapWith<T, TState>(this IObservable<T> source, TSta
     }
 
     /// <summary>
-    /// Emits accumulated state for every source value.
+    /// Emits the accumulated state after each source value.
     /// </summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <typeparam name="TAccumulate">The accumulated value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="seed">The initial accumulated value.</param>
+    /// <param name="accumulator">The function that combines the current state with the next source value.</param>
+    /// <returns>A sequence of intermediate accumulated values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="accumulator"/> is <see langword="null"/>.</exception>
     public static IObservable<TAccumulate> Scan<TSource, TAccumulate>(this IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)
     {
         if (source == null)
@@ -210,8 +270,15 @@ public static IObservable<TAccumulate> Scan<TSource, TAccumulate>(this IObservab
     }
 
     /// <summary>
-    /// Emits one final accumulated value when the source completes.
+    /// Emits the final accumulated state when the source completes.
     /// </summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <typeparam name="TAccumulate">The accumulated value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="seed">The initial accumulated value.</param>
+    /// <param name="accumulator">The function that combines the current state with the next source value.</param>
+    /// <returns>A sequence that emits one accumulated value on completion.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="accumulator"/> is <see langword="null"/>.</exception>
     public static IObservable<TAccumulate> Fold<TSource, TAccumulate>(this IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)
     {
         if (source == null)
@@ -241,6 +308,12 @@ public static IObservable<TAccumulate> Fold<TSource, TAccumulate>(this IObservab
     /// <summary>
     /// Emits at most <paramref name="count"/> values before completing.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="count">The maximum number of values to emit.</param>
+    /// <returns>A sequence containing at most <paramref name="count"/> source values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero.</exception>
     public static IObservable<T> Take<T>(this IObservable<T> source, int count)
     {
         if (source == null)
@@ -285,8 +358,14 @@ public static IObservable<T> Take<T>(this IObservable<T> source, int count)
     }
 
     /// <summary>
-    /// Skips <paramref name="count"/> values.
+    /// Skips the first <paramref name="count"/> source values.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="count">The number of values to skip.</param>
+    /// <returns>A sequence containing source values after the skipped prefix.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero.</exception>
     public static IObservable<T> Skip<T>(this IObservable<T> source, int count)
     {
         if (source == null)
@@ -319,14 +398,23 @@ public static IObservable<T> Skip<T>(this IObservable<T> source, int count)
     }
 
     /// <summary>
-    /// Suppresses duplicate values according to the comparer.
+    /// Suppresses values that have already been observed.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence containing the first occurrence of each source value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Distinct<T>(this IObservable<T> source) =>
         source.Distinct(null);
 
     /// <summary>
-    /// Suppresses duplicate values according to the comparer.
+    /// Suppresses values that have already been observed using the supplied comparer.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="comparer">The comparer used to identify duplicate values.</param>
+    /// <returns>A sequence containing the first occurrence of each source value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Distinct<T>(this IObservable<T> source, IEqualityComparer<T>? comparer)
     {
         if (source == null)
@@ -353,14 +441,23 @@ public static IObservable<T> Distinct<T>(this IObservable<T> source, IEqualityCo
     }
 
     /// <summary>
-    /// Suppresses adjacent duplicate values according to the comparer.
+    /// Suppresses adjacent duplicate values.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence with adjacent duplicates removed.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DistinctUntilChanged<T>(this IObservable<T> source) =>
         source.DistinctUntilChanged(null);
 
     /// <summary>
-    /// Suppresses adjacent duplicate values according to the comparer.
+    /// Suppresses adjacent duplicate values using the supplied comparer.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="comparer">The comparer used to compare adjacent values.</param>
+    /// <returns>A sequence with adjacent duplicates removed.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DistinctUntilChanged<T>(this IObservable<T> source, IEqualityComparer<T>? comparer)
     {
         if (source == null)
@@ -391,8 +488,12 @@ public static IObservable<T> DistinctUntilChanged<T>(this IObservable<T> source,
     }
 
     /// <summary>
-    /// Converts values and terminal messages into sparks.
+    /// Converts source values and terminal notifications into <see cref="Spark{T}"/> values.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence of spark values representing source notifications; terminal sparks are followed by completion.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<Spark<T>> Sparkify<T>(this IObservable<T> source)
     {
         if (source == null)
@@ -415,8 +516,12 @@ public static IObservable<Spark<T>> Sparkify<T>(this IObservable<T> source)
     }
 
     /// <summary>
-    /// Converts spark values back into source notifications.
+    /// Converts <see cref="Spark{T}"/> values back into observer notifications.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The spark sequence.</param>
+    /// <returns>A sequence represented by the supplied spark values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Unspark<T>(this IObservable<Spark<T>> source)
     {
         if (source == null)
@@ -431,8 +536,12 @@ public static IObservable<T> Unspark<T>(this IObservable<Spark<T>> source)
     }
 
     /// <summary>
-    /// Concatenates a signal of signals.
+    /// Subscribes to inner sequences one at a time in source order.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="sources">The outer sequence of inner sequences.</param>
+    /// <returns>A sequence that emits each inner sequence after the previous one completes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Concat<T>(this IObservable<IObservable<T>> sources)
     {
         if (sources == null)
@@ -521,14 +630,22 @@ void Drain()
     }
 
     /// <summary>
-    /// Concatenates this signal followed by <paramref name="second"/>.
+    /// Concatenates two sequences.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="first">The first sequence.</param>
+    /// <param name="second">The second sequence.</param>
+    /// <returns>A sequence that emits <paramref name="second"/> after <paramref name="first"/> completes.</returns>
     public static IObservable<T> Concat<T>(this IObservable<T> first, IObservable<T> second) =>
         Signal.Concat(first, second);
 
     /// <summary>
-    /// Merges a signal of signals.
+    /// Subscribes to all inner sequences and forwards their values as they arrive.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="sources">The outer sequence of inner sequences.</param>
+    /// <returns>A sequence containing values from all inner sequences.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Merge<T>(this IObservable<IObservable<T>> sources)
     {
         if (sources == null)
@@ -597,8 +714,12 @@ void TryComplete()
     }
 
     /// <summary>
-    /// Races the supplied source signals and mirrors the first source to emit any notification.
+    /// Mirrors the first inner sequence to produce any notification.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="sources">The competing inner sequences.</param>
+    /// <returns>A sequence that mirrors the winning inner sequence.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Race<T>(this IObservable<IObservable<T>> sources)
     {
         if (sources == null)
@@ -610,8 +731,16 @@ public static IObservable<T> Race<T>(this IObservable<IObservable<T>> sources)
     }
 
     /// <summary>
-    /// Zips two signals by waiting for one value from both sides.
+    /// Combines paired values from two sequences, completing when no more pairs can be formed.
     /// </summary>
+    /// <typeparam name="TLeft">The left value type.</typeparam>
+    /// <typeparam name="TRight">The right value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="left">The left sequence.</param>
+    /// <param name="right">The right sequence.</param>
+    /// <param name="selector">The function that combines paired values.</param>
+    /// <returns>A sequence containing one result for each available value pair.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="left"/>, <paramref name="right"/>, or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> Zip<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
     {
         if (left == null)
@@ -629,7 +758,7 @@ public static IObservable<TResult> Zip<TLeft, TRight, TResult>(this IObservable<
             throw new ArgumentNullException(nameof(selector));
         }
 
-        if (left is RangeSignal leftRange && right is RangeSignal rightRange)
+        if (typeof(TLeft) == typeof(int) && typeof(TRight) == typeof(int) && left is RangeSignal leftRange && right is RangeSignal rightRange)
         {
             return new RangeZipSignal<TResult>(leftRange, rightRange, (Func<int, int, TResult>)(object)selector);
         }
@@ -638,8 +767,16 @@ public static IObservable<TResult> Zip<TLeft, TRight, TResult>(this IObservable<
     }
 
     /// <summary>
-    /// Combines the latest values after both sides have produced at least one value.
+    /// Combines the latest values after both sequences have produced at least one value.
     /// </summary>
+    /// <typeparam name="TLeft">The left value type.</typeparam>
+    /// <typeparam name="TRight">The right value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="left">The left sequence.</param>
+    /// <param name="right">The right sequence.</param>
+    /// <param name="selector">The function that combines the latest values.</param>
+    /// <returns>A sequence containing selected latest-value combinations.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="left"/>, <paramref name="right"/>, or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> CombineLatest<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
     {
         if (left == null)
@@ -657,12 +794,26 @@ public static IObservable<TResult> CombineLatest<TLeft, TRight, TResult>(this IO
             throw new ArgumentNullException(nameof(selector));
         }
 
+        if (typeof(TLeft) == typeof(int) && typeof(TRight) == typeof(int) && left is RangeSignal leftRange && right is RangeSignal rightRange)
+        {
+            return CreateRangeCombineLatestSignal(leftRange, rightRange, (Func<int, int, TResult>)(object)selector);
+        }
+
         return Signal.CreateSafe<TResult>(observer => new CombineLatestCoordinator<TLeft, TRight, TResult>(observer, selector).Run(left, right));
     }
 
     /// <summary>
-    /// Combines each left value with the latest right value after the right side has produced one value.
+    /// Combines each left value with the latest right value after the right sequence has produced a value.
     /// </summary>
+    /// <typeparam name="TLeft">The left value type.</typeparam>
+    /// <typeparam name="TRight">The right value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="left">The triggering sequence.</param>
+    /// <param name="right">The sequence that supplies the latest value.</param>
+    /// <param name="selector">The function that combines the left value with the latest right value.</param>
+    /// <returns>A sequence containing selected left/latest-right combinations.</returns>
+    /// <remarks>Left values produced before the first right value are ignored.</remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="left"/>, <paramref name="right"/>, or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> WithLatest<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
     {
         if (left == null)
@@ -680,6 +831,11 @@ public static IObservable<TResult> WithLatest<TLeft, TRight, TResult>(this IObse
             throw new ArgumentNullException(nameof(selector));
         }
 
+        if (typeof(TLeft) == typeof(int) && typeof(TRight) == typeof(int) && left is RangeSignal leftRange && right is RangeSignal rightRange)
+        {
+            return CreateRangeWithLatestSignal(leftRange, rightRange, (Func<int, int, TResult>)(object)selector);
+        }
+
         return Signal.CreateSafe<TResult>(observer =>
         {
             var gate = new OperatorGate();
@@ -719,8 +875,12 @@ public static IObservable<TResult> WithLatest<TLeft, TRight, TResult>(this IObse
     }
 
     /// <summary>
-    /// Switches to the most recent inner signal.
+    /// Switches to the most recent inner sequence.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="sources">The outer sequence of inner sequences.</param>
+    /// <returns>A sequence that mirrors only the latest inner sequence.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="sources"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Switch<T>(this IObservable<IObservable<T>> sources)
     {
         if (sources == null)
@@ -732,8 +892,14 @@ public static IObservable<T> Switch<T>(this IObservable<IObservable<T>> sources)
     }
 
     /// <summary>
-    /// Retries the source up to <paramref name="retryCount"/> times after failures.
+    /// Resubscribes to the source after an error up to <paramref name="retryCount"/> times.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="retryCount">The maximum number of retry attempts after the initial subscription.</param>
+    /// <returns>A sequence that retries the source before forwarding the final error.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="retryCount"/> is less than zero.</exception>
     public static IObservable<T> Retry<T>(this IObservable<T> source, int retryCount)
     {
         if (source == null)
@@ -776,14 +942,24 @@ void SubscribeNext()
     }
 
     /// <summary>
-    /// Recovers from errors by switching to a handler-provided signal.
+    /// Recovers from errors by switching to a handler-provided sequence.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="handler">The function that creates the recovery sequence for an error.</param>
+    /// <returns>A sequence that continues with the handler result after an error.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="handler"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Rescue<T>(this IObservable<T> source, Func<Exception, IObservable<T>> handler) =>
         source.Catch<T, Exception>(handler);
 
     /// <summary>
-    /// Continues with a fallback signal after an error.
+    /// Continues with a fallback sequence after an error.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="fallback">The sequence to subscribe to after an error.</param>
+    /// <returns>A sequence that resumes with <paramref name="fallback"/> after an error.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="fallback"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Resume<T>(this IObservable<T> source, IObservable<T> fallback)
     {
         if (fallback == null)
@@ -795,14 +971,23 @@ public static IObservable<T> Resume<T>(this IObservable<T> source, IObservable<T
     }
 
     /// <summary>
-    /// Delays notifications by <paramref name="dueTime"/>.
+    /// Delays source notifications by the specified duration.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The delay applied to each notification.</param>
+    /// <returns>A sequence that forwards source notifications after the delay.</returns>
     public static IObservable<T> Delay<T>(this IObservable<T> source, TimeSpan dueTime) =>
         source.Delay(dueTime, null);
 
     /// <summary>
-    /// Delays notifications by <paramref name="dueTime"/>.
+    /// Delays source notifications by the specified duration on a sequencer.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The delay applied to each notification.</param>
+    /// <param name="scheduler">The sequencer used to schedule delayed notifications.</param>
+    /// <returns>A sequence that forwards source notifications after the delay.</returns>
     public static IObservable<T> Delay<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer? scheduler)
     {
         if (source == null)
@@ -825,14 +1010,23 @@ public static IObservable<T> Delay<T>(this IObservable<T> source, TimeSpan dueTi
     }
 
     /// <summary>
-    /// Fails the signal if no terminal signal arrives before the timeout.
+    /// Fails the sequence if it does not terminate before the timeout.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The timeout duration.</param>
+    /// <returns>A sequence that errors with <see cref="TimeoutException"/> when the timeout elapses first.</returns>
     public static IObservable<T> Timeout<T>(this IObservable<T> source, TimeSpan dueTime) =>
         source.Timeout(dueTime, null);
 
     /// <summary>
-    /// Fails the signal if no terminal signal arrives before the timeout.
+    /// Fails the sequence if it does not terminate before the sequencer timeout.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The timeout duration.</param>
+    /// <param name="scheduler">The sequencer used to schedule the timeout.</param>
+    /// <returns>A sequence that errors with <see cref="TimeoutException"/> when the timeout elapses first.</returns>
     public static IObservable<T> Timeout<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer? scheduler)
     {
         if (source == null)
@@ -890,6 +1084,9 @@ public static IObservable<T> Timeout<T>(this IObservable<T> source, TimeSpan due
     /// <summary>
     /// Collects all values into a list when the source completes.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence that emits one list containing all source values.</returns>
     public static IObservable<IList<T>> CollectList<T>(this IObservable<T> source)
     {
         if (source == null)
@@ -897,6 +1094,11 @@ public static IObservable<IList<T>> CollectList<T>(this IObservable<T> source)
             throw new ArgumentNullException(nameof(source));
         }
 
+        if (source is RangeSignal range && CanReadRangeAs<T>())
+        {
+            return CreateRangeListSignal<T>(range);
+        }
+
         return Signal.CreateSafe<IList<T>>(observer =>
         {
             var values = new List<T>();
@@ -914,16 +1116,201 @@ public static IObservable<IList<T>> CollectList<T>(this IObservable<T> source)
     /// <summary>
     /// Collects all values into an array when the source completes.
     /// </summary>
-    public static IObservable<T[]> CollectArray<T>(this IObservable<T> source) =>
-        source.CollectList().Map(values => values.ToArray());
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence that emits one array containing all source values.</returns>
+    public static IObservable<T[]> CollectArray<T>(this IObservable<T> source)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (source is RangeSignal range && CanReadRangeAs<T>())
+        {
+            return CreateRangeArraySignal<T>(range);
+        }
+
+        return Signal.CreateSafe<T[]>(observer =>
+        {
+            var values = new List<T>();
+            return source.Subscribe(
+                values.Add,
+                observer.OnError,
+                () =>
+                {
+                    observer.OnNext([.. values]);
+                    observer.OnCompleted();
+                });
+        });
+    }
 
     /// <summary>
-    /// Converts an enumerable to a signal.
+    /// Converts an enumerable sequence to a signal.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="values">The values to enumerate.</param>
+    /// <returns>A signal that emits the enumerable values.</returns>
     public static IObservable<T> ToSignal<T>(this IEnumerable<T> values) => Signal.FromEnumerable(values);
 
     /// <summary>
-    /// Converts an observable to a signal-compatible observable.
+    /// Converts an enumerable sequence to a signal that observes cancellation.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="values">The values to enumerate.</param>
+    /// <param name="cancellationToken">The token used to stop enumeration.</param>
+    /// <returns>A signal that emits the enumerable values until enumeration completes or cancellation is requested.</returns>
+    public static IObservable<T> ToSignal<T>(this IEnumerable<T> values, CancellationToken cancellationToken) =>
+        Signal.FromEnumerable(values, cancellationToken);
+
+    /// <summary>
+    /// Returns an observable sequence as a signal-compatible observable.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>The supplied source sequence.</returns>
     public static IObservable<T> ToSignal<T>(this IObservable<T> source) => source ?? throw new ArgumentNullException(nameof(source));
+
+    /// <summary>
+    /// Creates the optimized range-backed combine-latest sequence.
+    /// </summary>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="left">The left range source.</param>
+    /// <param name="right">The right range source.</param>
+    /// <param name="selector">The function that combines range values.</param>
+    /// <returns>The optimized combine-latest sequence.</returns>
+    private static IObservable<TResult> CreateRangeCombineLatestSignal<TResult>(
+        RangeSignal left,
+        RangeSignal right,
+        Func<int, int, TResult> selector) =>
+        Signal.CreateSafe<TResult>(observer =>
+        {
+            var leftValue = left.Start + left.Count - 1;
+            for (var i = 0; i < right.Count; i++)
+            {
+                observer.OnNext(selector(leftValue, right.Start + i));
+            }
+
+            observer.OnCompleted();
+            return Disposable.Empty;
+        });
+
+    /// <summary>
+    /// Creates the optimized range-backed with-latest sequence.
+    /// </summary>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="left">The left range source.</param>
+    /// <param name="right">The right range source.</param>
+    /// <param name="selector">The function that combines range values.</param>
+    /// <returns>The optimized with-latest sequence.</returns>
+    private static IObservable<TResult> CreateRangeWithLatestSignal<TResult>(
+        RangeSignal left,
+        RangeSignal right,
+        Func<int, int, TResult> selector) =>
+        Signal.CreateSafe<TResult>(observer =>
+        {
+            var rightValue = right.Start + right.Count - 1;
+            for (var i = 0; i < left.Count; i++)
+            {
+                observer.OnNext(selector(left.Start + i, rightValue));
+            }
+
+            observer.OnCompleted();
+            return Disposable.Empty;
+        });
+
+    /// <summary>
+    /// Creates a range-backed list signal without per-value subscriptions.
+    /// </summary>
+    /// <typeparam name="T">The result element type.</typeparam>
+    /// <param name="range">The source range.</param>
+    /// <returns>The list signal.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Major Code Smell",
+        "S4018:Generic methods should provide type parameters",
+        Justification = "The generic type is validated by the caller before creating a range-backed signal.")]
+    private static IObservable<IList<T>> CreateRangeListSignal<T>(RangeSignal range)
+    {
+        if (typeof(T) == typeof(int))
+        {
+            return (IObservable<IList<T>>)(object)Signal.CreateSafe<IList<int>>(observer =>
+            {
+                var values = new List<int>(range.Count);
+                for (var i = 0; i < range.Count; i++)
+                {
+                    values.Add(range.Start + i);
+                }
+
+                observer.OnNext(values);
+                observer.OnCompleted();
+                return Disposable.Empty;
+            });
+        }
+
+        return Signal.CreateSafe<IList<T>>(observer =>
+        {
+            var values = new List<T>(range.Count);
+            for (var i = 0; i < range.Count; i++)
+            {
+                values.Add((T)(object)(range.Start + i));
+            }
+
+            observer.OnNext(values);
+            observer.OnCompleted();
+            return Disposable.Empty;
+        });
+    }
+
+    /// <summary>
+    /// Creates a range-backed array signal without per-value subscriptions.
+    /// </summary>
+    /// <typeparam name="T">The result element type.</typeparam>
+    /// <param name="range">The source range.</param>
+    /// <returns>The array signal.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Major Code Smell",
+        "S4018:Generic methods should provide type parameters",
+        Justification = "The generic type is validated by the caller before creating a range-backed signal.")]
+    private static IObservable<T[]> CreateRangeArraySignal<T>(RangeSignal range)
+    {
+        if (typeof(T) == typeof(int))
+        {
+            return (IObservable<T[]>)(object)Signal.CreateSafe<int[]>(observer =>
+            {
+                var values = new int[range.Count];
+                for (var i = 0; i < values.Length; i++)
+                {
+                    values[i] = range.Start + i;
+                }
+
+                observer.OnNext(values);
+                observer.OnCompleted();
+                return Disposable.Empty;
+            });
+        }
+
+        return Signal.CreateSafe<T[]>(observer =>
+        {
+            var values = new T[range.Count];
+            for (var i = 0; i < values.Length; i++)
+            {
+                values[i] = (T)(object)(range.Start + i);
+            }
+
+            observer.OnNext(values);
+            observer.OnCompleted();
+            return Disposable.Empty;
+        });
+    }
+
+    /// <summary>
+    /// Determines whether a generic observer type can receive boxed range integers.
+    /// </summary>
+    /// <typeparam name="T">The observer value type.</typeparam>
+    /// <returns><see langword="true"/> when the cast is valid.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Major Code Smell",
+        "S4018:Generic methods should provide type parameters",
+        Justification = "The method is a generic type test used by range fast paths.")]
+    private static bool CanReadRangeAs<T>() => typeof(T).IsAssignableFrom(typeof(int));
 }
diff --git a/src/ReactiveUI.Primitives/SignalOperatorParityMixins.AggregateHelpers.cs b/src/ReactiveUI.Primitives/SignalOperatorParityMixins.AggregateHelpers.cs
index 44cba1f..3dd02d7 100644
--- a/src/ReactiveUI.Primitives/SignalOperatorParityMixins.AggregateHelpers.cs
+++ b/src/ReactiveUI.Primitives/SignalOperatorParityMixins.AggregateHelpers.cs
@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for full license information.
 
 using ReactiveUI.Primitives.Core;
+using ReactiveUI.Primitives.Disposables;
+using ReactiveUI.Primitives.Signals.Core;
 
 namespace ReactiveUI.Primitives;
 
@@ -139,6 +141,13 @@ public IDisposable Subscribe(IObserver<int> observer)
                 throw new ArgumentNullException(nameof(observer));
             }
 
+            if (_source is RangeSignal range)
+            {
+                observer.OnNext(range.Count);
+                observer.OnCompleted();
+                return Disposable.Empty;
+            }
+
             if (_source is ICountSource countSource)
             {
                 return countSource.SubscribeCount(observer);
@@ -224,6 +233,13 @@ public IDisposable Subscribe(IObserver<long> observer)
                 throw new ArgumentNullException(nameof(observer));
             }
 
+            if (_source is RangeSignal range)
+            {
+                observer.OnNext(range.Count);
+                observer.OnCompleted();
+                return Disposable.Empty;
+            }
+
             if (_source is ICountSource countSource)
             {
                 return countSource.SubscribeLongCount(observer);
@@ -309,6 +325,13 @@ public IDisposable Subscribe(IObserver<bool> observer)
                 throw new ArgumentNullException(nameof(observer));
             }
 
+            if (_source is RangeSignal)
+            {
+                observer.OnNext(true);
+                observer.OnCompleted();
+                return Disposable.Empty;
+            }
+
             var sink = new AnyObserver<T>(observer);
             sink.SetSubscription(_source.Subscribe(sink));
             return sink;
diff --git a/src/ReactiveUI.Primitives/SignalOperatorParityMixins.Helpers.cs b/src/ReactiveUI.Primitives/SignalOperatorParityMixins.Helpers.cs
index 1cce3bc..e0f98cf 100644
--- a/src/ReactiveUI.Primitives/SignalOperatorParityMixins.Helpers.cs
+++ b/src/ReactiveUI.Primitives/SignalOperatorParityMixins.Helpers.cs
@@ -5,8 +5,6 @@
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Disposables;
 
-#pragma warning disable SA1107, SA1116, SA1117, SA1501, SA1611, SA1615, SA1618
-
 namespace ReactiveUI.Primitives;
 
 /// <summary>
@@ -199,8 +197,9 @@ public IDisposable Subscribe(IObserver<T> observer)
     }
 
     /// <summary>
-    /// Shared disposable sink for single-source terminal operators.
+    /// Abstract base class for observers that manage a single upstream subscription.
     /// </summary>
+    /// <typeparam name="T">The type of elements observed.</typeparam>
     private abstract class SingleSourceObserver<T> : IObserver<T>, IDisposable
     {
         /// <summary>
diff --git a/src/ReactiveUI.Primitives/SignalOperatorParityMixins.cs b/src/ReactiveUI.Primitives/SignalOperatorParityMixins.cs
index 931924e..2416280 100644
--- a/src/ReactiveUI.Primitives/SignalOperatorParityMixins.cs
+++ b/src/ReactiveUI.Primitives/SignalOperatorParityMixins.cs
@@ -6,8 +6,7 @@
 using ReactiveUI.Primitives.Core;
 using ReactiveUI.Primitives.Disposables;
 using ReactiveUI.Primitives.Signals;
-
-#pragma warning disable SA1107, SA1116, SA1117, SA1501, SA1611, SA1615, SA1618
+using ReactiveUI.Primitives.Signals.Core;
 
 namespace ReactiveUI.Primitives;
 
@@ -19,11 +18,21 @@ public static partial class LinqMixins
     /// <summary>
     /// Prepends a value before the source sequence. Alias of <see cref="Prepend{T}(IObservable{T}, T)"/> using Primitives vocabulary.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="value">The value to emit before the source.</param>
+    /// <returns>A sequence that emits <paramref name="value"/> before the source values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Lead<T>(this IObservable<T> source, T value) => source.Prepend(value);
 
     /// <summary>
     /// Prepends a value before the source sequence.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="value">The value to emit before the source.</param>
+    /// <returns>A sequence that emits <paramref name="value"/> before the source values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Prepend<T>(this IObservable<T> source, T value)
     {
         if (source == null)
@@ -37,6 +46,11 @@ public static IObservable<T> Prepend<T>(this IObservable<T> source, T value)
     /// <summary>
     /// Appends a value after the source sequence completes.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="value">The value to emit after the source completes.</param>
+    /// <returns>A sequence that emits the source values followed by <paramref name="value"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Append<T>(this IObservable<T> source, T value)
     {
         if (source == null)
@@ -50,11 +64,21 @@ public static IObservable<T> Append<T>(this IObservable<T> source, T value)
     /// <summary>
     /// Prepends a value before the source sequence using the System.Reactive operator name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="value">The value to emit before the source.</param>
+    /// <returns>A sequence that emits <paramref name="value"/> before the source values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> StartWith<T>(this IObservable<T> source, T value) => source.Prepend(value);
 
     /// <summary>
     /// Prepends values before the source sequence using the System.Reactive operator name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="values">The values to emit before the source.</param>
+    /// <returns>A sequence that emits <paramref name="values"/> before the source values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="values"/> is <see langword="null"/>.</exception>
     public static IObservable<T> StartWith<T>(this IObservable<T> source, params T[] values)
     {
         if (source == null)
@@ -73,6 +97,11 @@ public static IObservable<T> StartWith<T>(this IObservable<T> source, params T[]
     /// <summary>
     /// Prepends values before the source sequence using the System.Reactive operator name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="values">The values to emit before the source.</param>
+    /// <returns>A sequence that emits <paramref name="values"/> before the source values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="values"/> is <see langword="null"/>.</exception>
     public static IObservable<T> StartWith<T>(this IObservable<T> source, IEnumerable<T> values)
     {
         if (source == null)
@@ -91,16 +120,40 @@ public static IObservable<T> StartWith<T>(this IObservable<T> source, IEnumerabl
     /// <summary>
     /// Returns the source as an observable. This is an identity adapter for BCL observable sources.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>The supplied source sequence.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> AsObservable<T>(this IObservable<T> source) => source ?? throw new ArgumentNullException(nameof(source));
 
     /// <summary>
     /// Converts an enumerable sequence to a Primitives signal using the System.Reactive conversion name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="values">The values to enumerate.</param>
+    /// <returns>A signal that emits the enumerable values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="values"/> is <see langword="null"/>.</exception>
     public static IObservable<T> ToObservable<T>(this IEnumerable<T> values) => Signal.FromEnumerable(values);
 
+    /// <summary>
+    /// Converts an enumerable sequence to a Primitives signal using the System.Reactive conversion name.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="values">The values to enumerate.</param>
+    /// <param name="cancellationToken">The token used to stop enumeration.</param>
+    /// <returns>A signal that emits the enumerable values until enumeration completes or cancellation is requested.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="values"/> is <see langword="null"/>.</exception>
+    public static IObservable<T> ToObservable<T>(this IEnumerable<T> values, CancellationToken cancellationToken) =>
+        Signal.FromEnumerable(values, cancellationToken);
+
     /// <summary>
     /// Schedules observer notifications on the supplied scheduler using the System.Reactive operator name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="scheduler">The sequencer used to deliver observer notifications.</param>
+    /// <returns>The source sequence when <paramref name="scheduler"/> is immediate; otherwise a sequence observed on the sequencer.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="scheduler"/> is <see langword="null"/>.</exception>
     public static IObservable<T> ObserveOn<T>(this IObservable<T> source, ISequencer scheduler)
     {
         if (source == null)
@@ -113,29 +166,59 @@ public static IObservable<T> ObserveOn<T>(this IObservable<T> source, ISequencer
             throw new ArgumentNullException(nameof(scheduler));
         }
 
+        if (scheduler == Sequencer.Immediate)
+        {
+            return source;
+        }
+
         return source.WitnessOn(scheduler);
     }
 
     /// <summary>
     /// Alias for <see cref="DelayStart{T}(IObservable{T}, TimeSpan, ISequencer?)"/> using the System.Reactive operator name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The delay before subscribing to the source.</param>
+    /// <returns>A sequence that subscribes to the source after <paramref name="dueTime"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, TimeSpan dueTime) =>
         source.DelayStart(dueTime, null);
 
     /// <summary>
     /// Alias for <see cref="DelayStart{T}(IObservable{T}, TimeSpan, ISequencer?)"/> using the System.Reactive operator name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The delay before subscribing to the source.</param>
+    /// <param name="scheduler">The sequencer used to schedule the delayed subscription.</param>
+    /// <returns>A sequence that subscribes to the source after <paramref name="dueTime"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer? scheduler) =>
         source.DelayStart(dueTime, scheduler);
 
     /// <summary>
     /// Runs a side effect for each source value using the System.Reactive operator name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="onNext">The action to invoke for each value.</param>
+    /// <returns>The source values after <paramref name="onNext"/> runs.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="onNext"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Do<T>(this IObservable<T> source, Action<T> onNext) => source.Tap(onNext);
 
     /// <summary>
-    /// Runs side effects for source notifications using the System.Reactive operator name.
+    /// Invokes actions for each element in the observable sequence, for error notifications, and for successful
+    /// completion.
     /// </summary>
+    /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+    /// <param name="source">The source sequence.</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>
+    /// <param name="onCompleted">Action to invoke upon graceful termination of the observable sequence.</param>
+    /// <returns>The source sequence with the side-effecting behavior applied.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/>, <paramref name="onNext"/>, <paramref name="onError"/>, or <paramref
+    /// name="onCompleted"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Do<T>(this IObservable<T> source, Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
         if (source == null)
@@ -179,12 +262,21 @@ public static IObservable<T> Do<T>(this IObservable<T> source, Action<T> onNext,
     /// <summary>
     /// Alias for <see cref="Rescue{T}(IObservable{T}, Func{Exception, IObservable{T}})"/> using the System.Reactive operator name.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="handler">The function that creates the recovery sequence for an error.</param>
+    /// <returns>A sequence that continues with the handler result after an error.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="handler"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Catch<T>(this IObservable<T> source, Func<Exception, IObservable<T>> handler) =>
         source.Rescue(handler);
 
     /// <summary>
     /// Ignores all source values and only forwards terminal messages.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence that forwards only error and completion notifications.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> IgnoreValues<T>(this IObservable<T> source)
     {
         if (source == null)
@@ -198,12 +290,21 @@ public static IObservable<T> IgnoreValues<T>(this IObservable<T> source)
     /// <summary>
     /// Emits the supplied value if the source completes without values.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence that emits <see langword="default"/> when the source is empty.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DefaultIfEmpty<T>(this IObservable<T> source) =>
         source.DefaultIfEmpty(default!);
 
     /// <summary>
     /// Emits the supplied value if the source completes without values.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="defaultValue">The value to emit when the source is empty.</param>
+    /// <returns>A sequence that emits <paramref name="defaultValue"/> when the source is empty.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DefaultIfEmpty<T>(this IObservable<T> source, T defaultValue)
     {
         if (source == null)
@@ -217,12 +318,25 @@ public static IObservable<T> DefaultIfEmpty<T>(this IObservable<T> source, T def
     /// <summary>
     /// Suppresses duplicate keys according to the comparer.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <typeparam name="TKey">The key type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="keySelector">The function that selects the comparison key.</param>
+    /// <returns>A sequence containing the first value for each observed key.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DistinctBy<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector) =>
         source.DistinctBy(keySelector, null);
 
     /// <summary>
     /// Suppresses duplicate keys according to the comparer.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <typeparam name="TKey">The key type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="keySelector">The function that selects the comparison key.</param>
+    /// <param name="comparer">The comparer used to identify duplicate keys.</param>
+    /// <returns>A sequence containing the first value for each observed key.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DistinctBy<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector, IEqualityComparer<TKey>? comparer)
     {
         if (source == null)
@@ -241,12 +355,25 @@ public static IObservable<T> DistinctBy<T, TKey>(this IObservable<T> source, Fun
     /// <summary>
     /// Suppresses adjacent duplicate keys according to the comparer.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <typeparam name="TKey">The key type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="keySelector">The function that selects the comparison key.</param>
+    /// <returns>A sequence with adjacent duplicate keys removed.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DistinctUntilChangedBy<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector) =>
         source.DistinctUntilChangedBy(keySelector, null);
 
     /// <summary>
     /// Suppresses adjacent duplicate keys according to the comparer.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <typeparam name="TKey">The key type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="keySelector">The function that selects the comparison key.</param>
+    /// <param name="comparer">The comparer used to compare adjacent keys.</param>
+    /// <returns>A sequence with adjacent duplicate keys removed.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DistinctUntilChangedBy<T, TKey>(this IObservable<T> source, Func<T, TKey> keySelector, IEqualityComparer<TKey>? comparer)
     {
         if (source == null)
@@ -285,6 +412,11 @@ public static IObservable<T> DistinctUntilChangedBy<T, TKey>(this IObservable<T>
     /// <summary>
     /// Emits values while the predicate remains true, then completes.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that determines whether to keep taking values.</param>
+    /// <returns>A sequence that emits the leading values that satisfy <paramref name="predicate"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
     public static IObservable<T> TakeWhile<T>(this IObservable<T> source, Func<T, bool> predicate)
     {
         if (source == null)
@@ -326,6 +458,11 @@ public static IObservable<T> TakeWhile<T>(this IObservable<T> source, Func<T, bo
     /// <summary>
     /// Skips values while the predicate remains true, then mirrors the remaining source.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that determines whether to keep skipping values.</param>
+    /// <returns>A sequence that emits values after the leading values that satisfy <paramref name="predicate"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
     public static IObservable<T> SkipWhile<T>(this IObservable<T> source, Func<T, bool> predicate)
     {
         if (source == null)
@@ -360,11 +497,23 @@ public static IObservable<T> SkipWhile<T>(this IObservable<T> source, Func<T, bo
     /// <summary>
     /// Projects each source value to an inner signal and concatenates all inner values.
     /// </summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="selector">The function that projects each source value to an inner sequence.</param>
+    /// <returns>A sequence containing the concatenated inner values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> Bind<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IObservable<TResult>> selector) => source.SelectMany(selector);
 
     /// <summary>
     /// Projects each source value to an inner signal and concatenates all inner values.
     /// </summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="selector">The function that projects each source value to an inner sequence.</param>
+    /// <returns>A sequence containing the concatenated inner values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IObservable<TResult>> selector)
     {
         if (source == null)
@@ -383,6 +532,14 @@ public static IObservable<TResult> SelectMany<TSource, TResult>(this IObservable
     /// <summary>
     /// Projects each source value to an inner signal and maps outer/inner values with a result selector.
     /// </summary>
+    /// <typeparam name="TSource">The source value type.</typeparam>
+    /// <typeparam name="TCollection">The inner value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="collectionSelector">The function that projects each source value to an inner sequence.</param>
+    /// <param name="resultSelector">The function that combines source and inner values.</param>
+    /// <returns>A sequence containing selected outer/inner combinations.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="collectionSelector"/> or <paramref name="resultSelector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(
         this IObservable<TSource> source,
         Func<TSource, IObservable<TCollection>> collectionSelector,
@@ -404,6 +561,10 @@ public static IObservable<TResult> SelectMany<TSource, TCollection, TResult>(
     /// <summary>
     /// Counts the source values as an <see cref="int"/>.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence that emits the number of source values when the source completes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<int> Count<T>(this IObservable<T> source)
     {
         if (source == null)
@@ -417,6 +578,11 @@ public static IObservable<int> Count<T>(this IObservable<T> source)
     /// <summary>
     /// Counts source values that satisfy the predicate as an <see cref="int"/>.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that identifies values to count.</param>
+    /// <returns>A sequence that emits the matching value count when the source completes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
     public static IObservable<int> Count<T>(this IObservable<T> source, Func<T, bool> predicate)
     {
         if (predicate == null)
@@ -435,6 +601,10 @@ public static IObservable<int> Count<T>(this IObservable<T> source, Func<T, bool
     /// <summary>
     /// Counts the source values as an <see cref="long"/>.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence that emits the number of source values when the source completes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<long> LongCount<T>(this IObservable<T> source)
     {
         if (source == null)
@@ -448,6 +618,11 @@ public static IObservable<long> LongCount<T>(this IObservable<T> source)
     /// <summary>
     /// Counts source values that satisfy the predicate as an <see cref="long"/>.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that identifies values to count.</param>
+    /// <returns>A sequence that emits the matching value count when the source completes.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
     public static IObservable<long> LongCount<T>(this IObservable<T> source, Func<T, bool> predicate)
     {
         if (predicate == null)
@@ -466,6 +641,10 @@ public static IObservable<long> LongCount<T>(this IObservable<T> source, Func<T,
     /// <summary>
     /// Emits true when any value is present.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence that emits whether the source produced any values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<bool> Any<T>(this IObservable<T> source)
     {
         if (source == null)
@@ -479,6 +658,11 @@ public static IObservable<bool> Any<T>(this IObservable<T> source)
     /// <summary>
     /// Emits true when any value satisfies the predicate.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that tests each value.</param>
+    /// <returns>A sequence that emits whether any source value satisfies <paramref name="predicate"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
     public static IObservable<bool> Any<T>(this IObservable<T> source, Func<T, bool> predicate)
     {
         if (source == null)
@@ -497,6 +681,11 @@ public static IObservable<bool> Any<T>(this IObservable<T> source, Func<T, bool>
     /// <summary>
     /// Emits true when every value satisfies the predicate.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that tests each value.</param>
+    /// <returns>A sequence that emits whether every source value satisfies <paramref name="predicate"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
     public static IObservable<bool> All<T>(this IObservable<T> source, Func<T, bool> predicate)
     {
         if (source == null)
@@ -541,12 +730,23 @@ public static IObservable<bool> All<T>(this IObservable<T> source, Func<T, bool>
     /// <summary>
     /// Emits true when the source contains the requested value.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="value">The value to locate.</param>
+    /// <returns>A sequence that emits whether the source contains <paramref name="value"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<bool> Contains<T>(this IObservable<T> source, T value) =>
         source.Contains(value, null);
 
     /// <summary>
     /// Emits true when the source contains the requested value.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="value">The value to locate.</param>
+    /// <param name="comparer">The comparer used to compare source values.</param>
+    /// <returns>A sequence that emits whether the source contains <paramref name="value"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<bool> Contains<T>(this IObservable<T> source, T value, IEqualityComparer<T>? comparer)
     {
         comparer ??= EqualityComparer<T>.Default;
@@ -556,17 +756,32 @@ public static IObservable<bool> Contains<T>(this IObservable<T> source, T value,
     /// <summary>
     /// Emits true when the source completes without values.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence that emits whether the source completed without values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<bool> IsEmpty<T>(this IObservable<T> source) => source.Any().Map(hasValue => !hasValue);
 
     /// <summary>
     /// Emits values from source after delaying subscription by the due time.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The delay before subscribing to the source.</param>
+    /// <returns>A sequence that subscribes to the source after <paramref name="dueTime"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DelayStart<T>(this IObservable<T> source, TimeSpan dueTime) =>
         source.DelayStart(dueTime, null);
 
     /// <summary>
     /// Emits values from source after delaying subscription by the due time.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The delay before subscribing to the source.</param>
+    /// <param name="scheduler">The sequencer used to schedule the delayed subscription.</param>
+    /// <returns>A sequence that subscribes to the source after <paramref name="dueTime"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> DelayStart<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer? scheduler)
     {
         if (source == null)
@@ -586,12 +801,23 @@ public static IObservable<T> DelayStart<T>(this IObservable<T> source, TimeSpan
     /// <summary>
     /// Emits only the most recent value after the quiet period elapses.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The quiet period before emitting the latest value.</param>
+    /// <returns>A sequence that emits the latest value after each quiet period.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Throttle<T>(this IObservable<T> source, TimeSpan dueTime) =>
         source.Throttle(dueTime, null);
 
     /// <summary>
     /// Emits only the most recent value after the quiet period elapses.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="dueTime">The quiet period before emitting the latest value.</param>
+    /// <param name="scheduler">The sequencer used to schedule quiet-period timers.</param>
+    /// <returns>A sequence that emits the latest value after each quiet period.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<T> Throttle<T>(this IObservable<T> source, TimeSpan dueTime, ISequencer? scheduler)
     {
         if (source == null)
@@ -638,12 +864,25 @@ public static IObservable<T> Throttle<T>(this IObservable<T> source, TimeSpan du
     /// <summary>
     /// Emits the latest source value whenever the sampling period ticks.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="period">The interval between sampling ticks.</param>
+    /// <returns>A sequence that emits the latest source value on each sampling tick.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="period"/> is less than <see cref="TimeSpan.Zero"/>.</exception>
     public static IObservable<T> Sample<T>(this IObservable<T> source, TimeSpan period) =>
         source.Sample(period, null);
 
     /// <summary>
     /// Emits the latest source value whenever the sampling period ticks.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="period">The interval between sampling ticks.</param>
+    /// <param name="scheduler">The sequencer used to schedule sampling ticks.</param>
+    /// <returns>A sequence that emits the latest source value on each sampling tick.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="period"/> is less than <see cref="TimeSpan.Zero"/>.</exception>
     public static IObservable<T> Sample<T>(this IObservable<T> source, TimeSpan period, ISequencer? scheduler)
     {
         if (source == null)
@@ -665,12 +904,21 @@ public static IObservable<T> Sample<T>(this IObservable<T> source, TimeSpan peri
     /// <summary>
     /// Annotates values with their scheduler timestamp.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence containing each value with its timestamp.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<Moment<T>> Timestamp<T>(this IObservable<T> source) =>
         source.Timestamp(null);
 
     /// <summary>
     /// Annotates values with their scheduler timestamp.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="scheduler">The sequencer that supplies timestamps.</param>
+    /// <returns>A sequence containing each value with its timestamp.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<Moment<T>> Timestamp<T>(this IObservable<T> source, ISequencer? scheduler)
     {
         if (source == null)
@@ -685,12 +933,21 @@ public static IObservable<Moment<T>> Timestamp<T>(this IObservable<T> source, IS
     /// <summary>
     /// Annotates each value with the elapsed scheduler time since the previous value.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A sequence containing each value with its elapsed interval since the previous value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<TimeInterval<T>> TimeInterval<T>(this IObservable<T> source) =>
         source.TimeInterval(null);
 
     /// <summary>
     /// Annotates each value with the elapsed scheduler time since the previous value.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="scheduler">The sequencer that supplies timestamps.</param>
+    /// <returns>A sequence containing each value with its elapsed interval since the previous value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static IObservable<TimeInterval<T>> TimeInterval<T>(this IObservable<T> source, ISequencer? scheduler)
     {
         if (source == null)
@@ -720,18 +977,42 @@ public static IObservable<TimeInterval<T>> TimeInterval<T>(this IObservable<T> s
     /// <summary>
     /// Combines latest values from both sources. Alias for latest-fusion vocabulary.
     /// </summary>
+    /// <typeparam name="TLeft">The left value type.</typeparam>
+    /// <typeparam name="TRight">The right value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="left">The left sequence.</param>
+    /// <param name="right">The right sequence.</param>
+    /// <param name="selector">The function that combines the latest values.</param>
+    /// <returns>A sequence containing selected latest-value combinations.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="left"/>, <paramref name="right"/>, or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> ZipLatest<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector) =>
         left.CombineLatest(right, selector);
 
     /// <summary>
     /// Alias for <see cref="ZipLatest{TLeft, TRight, TResult}(IObservable{TLeft}, IObservable{TRight}, Func{TLeft, TRight, TResult})"/>.
     /// </summary>
+    /// <typeparam name="TLeft">The left value type.</typeparam>
+    /// <typeparam name="TRight">The right value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="left">The left sequence.</param>
+    /// <param name="right">The right sequence.</param>
+    /// <param name="selector">The function that combines the latest values.</param>
+    /// <returns>A sequence containing selected latest-value combinations.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="left"/>, <paramref name="right"/>, or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> FuseLatest<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector) =>
         left.ZipLatest(right, selector);
 
     /// <summary>
     /// Waits for both sources to complete and emits one value from their last elements when both produced at least one value.
     /// </summary>
+    /// <typeparam name="TLeft">The left value type.</typeparam>
+    /// <typeparam name="TRight">The right value type.</typeparam>
+    /// <typeparam name="TResult">The result value type.</typeparam>
+    /// <param name="left">The left sequence.</param>
+    /// <param name="right">The right sequence.</param>
+    /// <param name="selector">The function that combines the final values.</param>
+    /// <returns>A sequence that emits one selected value after both sources complete.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="left"/>, <paramref name="right"/>, or <paramref name="selector"/> is <see langword="null"/>.</exception>
     public static IObservable<TResult> ForkJoin<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
     {
         if (left == null)
@@ -749,33 +1030,112 @@ public static IObservable<TResult> ForkJoin<TLeft, TRight, TResult>(this IObserv
             throw new ArgumentNullException(nameof(selector));
         }
 
+        if (typeof(TLeft) == typeof(int) && typeof(TRight) == typeof(int) && left is RangeSignal leftRange && right is RangeSignal rightRange)
+        {
+            return Signal.CreateSafe<TResult>(observer =>
+            {
+                observer.OnNext(((Func<int, int, TResult>)(object)selector)(
+                    leftRange.Start + leftRange.Count - 1,
+                    rightRange.Start + rightRange.Count - 1));
+                observer.OnCompleted();
+                return Disposable.Empty;
+            });
+        }
+
         return Signal.CreateSafe<TResult>(observer => new ForkJoinCoordinator<TLeft, TRight, TResult>(observer, selector).Run(left, right));
     }
 
     /// <summary>
     /// Awaits the first source value.
     /// </summary>
-    public static Task<T> FirstAsync<T>(this IObservable<T> source) => source.FirstOrDefaultCoreAsync(false, default!);
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A task that completes with the first source value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The source completes without producing a value.</exception>
+    public static Task<T> FirstAsync<T>(this IObservable<T> source)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (source is RangeSignal range && CanReadRangeAs<T>())
+        {
+            return Task.FromResult(CreateRangeValue<T>(range.Start));
+        }
+
+        return source.FirstOrDefaultCoreAsync(false, default!);
+    }
 
     /// <summary>
     /// Awaits the first source value, returning a default value when the source is empty.
     /// </summary>
-    public static Task<T> FirstOrDefaultAsync<T>(this IObservable<T> source) =>
-        source.FirstOrDefaultCoreAsync(true, default!);
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A task that completes with the first source value, or <see langword="default"/> when the source is empty.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static Task<T> FirstOrDefaultAsync<T>(this IObservable<T> source)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (source is RangeSignal range && CanReadRangeAs<T>())
+        {
+            return Task.FromResult(CreateRangeValue<T>(range.Start));
+        }
+
+        return source.FirstOrDefaultCoreAsync(true, default!);
+    }
 
     /// <summary>
     /// Awaits the first source value, returning a default value when the source is empty.
     /// </summary>
-    public static Task<T> FirstOrDefaultAsync<T>(this IObservable<T> source, T defaultValue) => source.FirstOrDefaultCoreAsync(true, defaultValue);
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="defaultValue">The value to return when the source is empty.</param>
+    /// <returns>A task that completes with the first source value, or <paramref name="defaultValue"/> when the source is empty.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static Task<T> FirstOrDefaultAsync<T>(this IObservable<T> source, T defaultValue)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (source is RangeSignal range && CanReadRangeAs<T>())
+        {
+            return Task.FromResult(CreateRangeValue<T>(range.Start));
+        }
+
+        return source.FirstOrDefaultCoreAsync(true, defaultValue);
+    }
 
     /// <summary>
     /// Awaits source completion and returns the last value produced by the source.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A task that completes with the final source value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The source completes without producing a value.</exception>
     public static Task<T> ToTask<T>(this IObservable<T> source) => source.ToTask(CancellationToken.None);
 
     /// <summary>
     /// Awaits source completion and returns the last value produced by the source.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="cancellationToken">The token used to cancel the task and dispose the subscription.</param>
+    /// <returns>A task that completes with the final source value.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">The source completes without producing a value.</exception>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Major Code Smell",
+        "S1541:Methods and properties should not be too complex",
+        Justification = "ToTask keeps cancellation, terminal, and synchronous fast paths together to avoid extra allocations.")]
     public static Task<T> ToTask<T>(this IObservable<T> source, CancellationToken cancellationToken)
     {
         if (source == null)
@@ -783,6 +1143,16 @@ public static Task<T> ToTask<T>(this IObservable<T> source, CancellationToken ca
             throw new ArgumentNullException(nameof(source));
         }
 
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return Task.FromCanceled<T>(cancellationToken);
+        }
+
+        if (source is RangeSignal range && CanReadRangeAs<T>())
+        {
+            return Task.FromResult(CreateRangeValue<T>(range.Start + range.Count - 1));
+        }
+
         var completion = new TaskCompletionSource<T>();
         var seen = false;
         var last = default(T);
@@ -834,11 +1204,107 @@ public static Task<T> ToTask<T>(this IObservable<T> source, CancellationToken ca
     /// <summary>
     /// Identity helper that keeps source-compatible <c>FirstAsync().ToTask()</c> migrations compiling.
     /// </summary>
+    /// <typeparam name="T">The task result type.</typeparam>
+    /// <param name="task">The task to return.</param>
+    /// <returns>The supplied task.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="task"/> is <see langword="null"/>.</exception>
     public static Task<T> ToTask<T>(this Task<T> task) => task ?? throw new ArgumentNullException(nameof(task));
 
+    /// <summary>
+    /// Awaits the source count as a task.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A task that completes with the number of source values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static Task<int> CountAsync<T>(this IObservable<T> source) =>
+        source.Count().ToTask();
+
+    /// <summary>
+    /// Awaits the source count as a task.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="cancellationToken">The token used to cancel the task.</param>
+    /// <returns>A task that completes with the number of source values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static Task<int> CountAsync<T>(this IObservable<T> source, CancellationToken cancellationToken) =>
+        source.Count().ToTask(cancellationToken);
+
+    /// <summary>
+    /// Awaits the source predicate count as a task.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that identifies values to count.</param>
+    /// <returns>A task that completes with the matching value count.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
+    public static Task<int> CountAsync<T>(this IObservable<T> source, Func<T, bool> predicate) =>
+        source.Count(predicate).ToTask();
+
+    /// <summary>
+    /// Awaits the source predicate count as a task.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that identifies values to count.</param>
+    /// <param name="cancellationToken">The token used to cancel the task.</param>
+    /// <returns>A task that completes with the matching value count.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
+    public static Task<int> CountAsync<T>(this IObservable<T> source, Func<T, bool> predicate, CancellationToken cancellationToken) =>
+        source.Count(predicate).ToTask(cancellationToken);
+
+    /// <summary>
+    /// Awaits whether any value is present.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A task that completes with whether the source produced any values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static Task<bool> AnyAsync<T>(this IObservable<T> source) =>
+        source.Any().ToTask();
+
+    /// <summary>
+    /// Awaits whether any value is present.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="cancellationToken">The token used to cancel the task.</param>
+    /// <returns>A task that completes with whether the source produced any values.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
+    public static Task<bool> AnyAsync<T>(this IObservable<T> source, CancellationToken cancellationToken) =>
+        source.Any().ToTask(cancellationToken);
+
+    /// <summary>
+    /// Awaits whether any value matches a predicate.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that tests each value.</param>
+    /// <returns>A task that completes with whether any source value satisfies <paramref name="predicate"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
+    public static Task<bool> AnyAsync<T>(this IObservable<T> source, Func<T, bool> predicate) =>
+        source.Any(predicate).ToTask();
+
+    /// <summary>
+    /// Awaits whether any value matches a predicate.
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="predicate">The function that tests each value.</param>
+    /// <param name="cancellationToken">The token used to cancel the task.</param>
+    /// <returns>A task that completes with whether any source value satisfies <paramref name="predicate"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is <see langword="null"/>.</exception>
+    public static Task<bool> AnyAsync<T>(this IObservable<T> source, Func<T, bool> predicate, CancellationToken cancellationToken) =>
+        source.Any(predicate).ToTask(cancellationToken);
+
     /// <summary>
     /// Collects all values into an array task.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A task that completes with all source values in an array.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static Task<T[]> CollectArrayAsync<T>(this IObservable<T> source)
     {
         if (source == null)
@@ -846,6 +1312,11 @@ public static Task<T[]> CollectArrayAsync<T>(this IObservable<T> source)
             throw new ArgumentNullException(nameof(source));
         }
 
+        if (source is RangeSignal range && CanReadRangeAs<T>())
+        {
+            return Task.FromResult(CreateRangeArray<T>(range));
+        }
+
         var completion = new TaskCompletionSource<T[]>();
         var values = new List<T>();
         source.Subscribe(values.Add, error => completion.TrySetException(error), () => completion.TrySetResult([.. values]));
@@ -855,6 +1326,10 @@ public static Task<T[]> CollectArrayAsync<T>(this IObservable<T> source)
     /// <summary>
     /// Collects all values into a list task.
     /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <returns>A task that completes with all source values in a list.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="source"/> is <see langword="null"/>.</exception>
     public static Task<IList<T>> CollectListAsync<T>(this IObservable<T> source)
     {
         if (source == null)
@@ -862,6 +1337,11 @@ public static Task<IList<T>> CollectListAsync<T>(this IObservable<T> source)
             throw new ArgumentNullException(nameof(source));
         }
 
+        if (source is RangeSignal range && CanReadRangeAs<T>())
+        {
+            return Task.FromResult((IList<T>)CreateRangeList<T>(range));
+        }
+
         var completion = new TaskCompletionSource<IList<T>>();
         var values = new List<T>();
         source.Subscribe(values.Add, error => completion.TrySetException(error), () => completion.TrySetResult(values));
@@ -915,4 +1395,84 @@ private static Task<T> FirstOrDefaultCoreAsync<T>(this IObservable<T> source, bo
         });
         return completion.Task;
     }
+
+    /// <summary>
+    /// Converts an integer value to the specified numeric type.
+    /// </summary>
+    /// <remarks>Uses boxing and unboxing to perform the conversion. The generic type parameter is expected to
+    /// be validated by the caller.</remarks>
+    /// <typeparam name="T">The target numeric type.</typeparam>
+    /// <param name="value">The integer value to convert.</param>
+    /// <returns>The value converted to type <typeparamref name="T"/>.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Major Code Smell",
+        "S4018:Generic methods should provide type parameters",
+        Justification = "The generic type is validated by the caller before reading range values.")]
+    private static T CreateRangeValue<T>(int value) => (T)(object)value;
+
+    /// <summary>
+    /// Creates an array of sequential values from the specified range signal.
+    /// </summary>
+    /// <typeparam name="T">The element type of the array.</typeparam>
+    /// <param name="range">The range signal specifying the start value and count.</param>
+    /// <returns>An array containing sequential values from the range start to start + count - 1.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Major Code Smell",
+        "S4018:Generic methods should provide type parameters",
+        Justification = "The generic type is validated by the caller before reading range values.")]
+    private static T[] CreateRangeArray<T>(RangeSignal range)
+    {
+        if (typeof(T) == typeof(int))
+        {
+            var values = new int[range.Count];
+            for (var i = 0; i < values.Length; i++)
+            {
+                values[i] = range.Start + i;
+            }
+
+            return (T[])(object)values;
+        }
+
+        var boxed = new T[range.Count];
+        for (var i = 0; i < boxed.Length; i++)
+        {
+            boxed[i] = CreateRangeValue<T>(range.Start + i);
+        }
+
+        return boxed;
+    }
+
+    /// <summary>
+    /// Creates a list of values from the specified range signal.
+    /// </summary>
+    /// <remarks>Optimized for integer types by directly incrementing values. For other types, uses
+    /// <c>CreateRangeValue</c> to generate each element.</remarks>
+    /// <typeparam name="T">The type of elements to create in the list.</typeparam>
+    /// <param name="range">The range signal containing the start value and count.</param>
+    /// <returns>A list containing the generated range values.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Major Code Smell",
+        "S4018:Generic methods should provide type parameters",
+        Justification = "The generic type is validated by the caller before reading range values.")]
+    private static List<T> CreateRangeList<T>(RangeSignal range)
+    {
+        if (typeof(T) == typeof(int))
+        {
+            var integers = new List<int>(range.Count);
+            for (var i = 0; i < range.Count; i++)
+            {
+                integers.Add(range.Start + i);
+            }
+
+            return (List<T>)(object)integers;
+        }
+
+        var values = new List<T>(range.Count);
+        for (var i = 0; i < range.Count; i++)
+        {
+            values.Add(CreateRangeValue<T>(range.Start + i));
+        }
+
+        return values;
+    }
 }
diff --git a/src/ReactiveUI.Primitives/Signals/Core/FromEnumerableSignal{T}.cs b/src/ReactiveUI.Primitives/Signals/Core/FromEnumerableSignal{T}.cs
index 6643184..50a53e3 100644
--- a/src/ReactiveUI.Primitives/Signals/Core/FromEnumerableSignal{T}.cs
+++ b/src/ReactiveUI.Primitives/Signals/Core/FromEnumerableSignal{T}.cs
@@ -18,6 +18,11 @@ internal sealed class FromEnumerableSignal<T> : IRequireCurrentThread<T>, IInlin
     /// </summary>
     private readonly IEnumerable<T> _values;
 
+    /// <summary>
+    /// Cancels synchronous enumeration when requested.
+    /// </summary>
+    private readonly CancellationToken _cancellationToken;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="FromEnumerableSignal{T}"/> class.
     /// </summary>
@@ -25,6 +30,17 @@ internal sealed class FromEnumerableSignal<T> : IRequireCurrentThread<T>, IInlin
     public FromEnumerableSignal(IEnumerable<T> values) =>
         _values = values;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FromEnumerableSignal{T}"/> class.
+    /// </summary>
+    /// <param name="values">The source values.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    public FromEnumerableSignal(IEnumerable<T> values, CancellationToken cancellationToken)
+    {
+        _values = values;
+        _cancellationToken = cancellationToken;
+    }
+
     /// <summary>
     /// Executes the IsRequiredSubscribeOnCurrentThread operation.
     /// </summary>
@@ -43,7 +59,7 @@ public IDisposable Subscribe(IObserver<T> observer)
             throw new ArgumentNullException(nameof(observer));
         }
 
-        if (_values is T[] array)
+        if (!_cancellationToken.CanBeCanceled && _values is T[] array)
         {
             for (var i = 0; i < array.Length; i++)
             {
@@ -54,7 +70,7 @@ public IDisposable Subscribe(IObserver<T> observer)
             return Disposable.Empty;
         }
 
-        if (_values is IReadOnlyList<T> readOnlyList)
+        if (!_cancellationToken.CanBeCanceled && _values is IReadOnlyList<T> readOnlyList)
         {
             for (var i = 0; i < readOnlyList.Count; i++)
             {
@@ -67,6 +83,11 @@ public IDisposable Subscribe(IObserver<T> observer)
 
         foreach (var value in _values)
         {
+            if (_cancellationToken.IsCancellationRequested)
+            {
+                return Disposable.Empty;
+            }
+
             observer.OnNext(value);
         }
 
@@ -81,6 +102,10 @@ public IDisposable Subscribe(IObserver<T> observer)
     /// <param name="onError">The onError value.</param>
     /// <param name="onCompleted">The onCompleted value.</param>
     /// <returns>The subscription.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Major Code Smell",
+        "S1541:Methods and properties should not be too complex",
+        Justification = "The method keeps array, read-only-list, iterator, and cancellation fast paths allocation-free.")]
     public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action onCompleted)
     {
         if (onNext == null)
@@ -93,7 +118,7 @@ public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action
             throw new ArgumentNullException(nameof(onCompleted));
         }
 
-        if (_values is T[] array)
+        if (!_cancellationToken.CanBeCanceled && _values is T[] array)
         {
             for (var i = 0; i < array.Length; i++)
             {
@@ -104,7 +129,7 @@ public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action
             return Disposable.Empty;
         }
 
-        if (_values is IReadOnlyList<T> readOnlyList)
+        if (!_cancellationToken.CanBeCanceled && _values is IReadOnlyList<T> readOnlyList)
         {
             for (var i = 0; i < readOnlyList.Count; i++)
             {
@@ -117,6 +142,11 @@ public IDisposable Subscribe(Action<T> onNext, Action<Exception> onError, Action
 
         foreach (var value in _values)
         {
+            if (_cancellationToken.IsCancellationRequested)
+            {
+                return Disposable.Empty;
+            }
+
             onNext(value);
         }
 
diff --git a/src/ReactiveUI.Primitives/Signals/Core/RangeConcatSignal.cs b/src/ReactiveUI.Primitives/Signals/Core/RangeConcatSignal.cs
new file mode 100644
index 0000000..e555964
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Signals/Core/RangeConcatSignal.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.Core;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Signals.Core;
+
+/// <summary>
+/// Concatenates synchronous integer ranges without outer observable/coordinator overhead.
+/// </summary>
+internal sealed class RangeConcatSignal : IRequireCurrentThread<int>, IInlineSignal<int>
+{
+    /// <summary>
+    /// Source ranges to emit in order.
+    /// </summary>
+    private readonly RangeSignal[] _ranges;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RangeConcatSignal"/> class.
+    /// </summary>
+    /// <param name="ranges">The source ranges.</param>
+    public RangeConcatSignal(RangeSignal[] ranges) => _ranges = ranges;
+
+    /// <inheritdoc/>
+    public bool IsRequiredSubscribeOnCurrentThread() => false;
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(IObserver<int> observer)
+    {
+        if (observer == null)
+        {
+            throw new ArgumentNullException(nameof(observer));
+        }
+
+        for (var rangeIndex = 0; rangeIndex < _ranges.Length; rangeIndex++)
+        {
+            var range = _ranges[rangeIndex];
+            for (var i = 0; i < range.Count; i++)
+            {
+                observer.OnNext(range.Start + i);
+            }
+        }
+
+        observer.OnCompleted();
+        return Disposable.Empty;
+    }
+
+    /// <inheritdoc/>
+    public IDisposable Subscribe(Action<int> onNext, Action<Exception> onError, Action onCompleted)
+    {
+        if (onNext == null)
+        {
+            throw new ArgumentNullException(nameof(onNext));
+        }
+
+        if (onCompleted == null)
+        {
+            throw new ArgumentNullException(nameof(onCompleted));
+        }
+
+        for (var rangeIndex = 0; rangeIndex < _ranges.Length; rangeIndex++)
+        {
+            var range = _ranges[rangeIndex];
+            for (var i = 0; i < range.Count; i++)
+            {
+                onNext(range.Start + i);
+            }
+        }
+
+        onCompleted();
+        return Disposable.Empty;
+    }
+}
diff --git a/src/ReactiveUI.Primitives/Signals/Signal{Catch}.cs b/src/ReactiveUI.Primitives/Signals/Signal{Catch}.cs
index b9d14ab..7402ecd 100644
--- a/src/ReactiveUI.Primitives/Signals/Signal{Catch}.cs
+++ b/src/ReactiveUI.Primitives/Signals/Signal{Catch}.cs
@@ -15,7 +15,7 @@ public static partial class Signal
     /// Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler.
     /// </summary>
     /// <typeparam name="TSource">The type of the elements in the source sequence and sequences returned by the exception handler function.</typeparam>
-    /// <typeparam name="TException">The type of the exception to catch and handle. Needs to derive from <see cref="System.Exception"/>.</typeparam>
+    /// <typeparam name="TException">The type of the exception to catch and handle. Needs to derive from <see cref="Exception"/>.</typeparam>
     /// <param name="source">Source sequence.</param>
     /// <param name="handler">Exception handler function, producing another observable sequence.</param>
     /// <returns>
diff --git a/src/ReactiveUI.Primitives/Signals/Signal{Create}.cs b/src/ReactiveUI.Primitives/Signals/Signal{Create}.cs
index 45e25d1..f296222 100644
--- a/src/ReactiveUI.Primitives/Signals/Signal{Create}.cs
+++ b/src/ReactiveUI.Primitives/Signals/Signal{Create}.cs
@@ -19,7 +19,7 @@ public static partial class Signal
     /// <typeparam name="T">The type.</typeparam>
     /// <param name="subscribe">The subscribe.</param>
     /// <returns>An Signals.</returns>
-    /// <exception cref="System.ArgumentNullException">subscribe.</exception>
+    /// <exception cref="ArgumentNullException">subscribe.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe)
     {
@@ -39,7 +39,7 @@ public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe
     /// <param name="subscribe">The subscribe.</param>
     /// <param name="isRequiredSubscribeOnCurrentThread">if set to <c>true</c> [is required subscribe on current thread].</param>
     /// <returns>An Signals.</returns>
-    /// <exception cref="System.ArgumentNullException">subscribe.</exception>
+    /// <exception cref="ArgumentNullException">subscribe.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
     {
@@ -60,7 +60,7 @@ public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe
     /// <param name="state">The state.</param>
     /// <param name="subscribe">The subscribe.</param>
     /// <returns>An Signals.</returns>
-    /// <exception cref="System.ArgumentNullException">subscribe.</exception>
+    /// <exception cref="ArgumentNullException">subscribe.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TState, IObserver<T>, IDisposable> subscribe)
     {
@@ -82,7 +82,7 @@ public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TStat
     /// <param name="subscribe">The subscribe.</param>
     /// <param name="isRequiredSubscribeOnCurrentThread">if set to <c>true</c> [is required subscribe on current thread].</param>
     /// <returns>An Signals.</returns>
-    /// <exception cref="System.ArgumentNullException">subscribe.</exception>
+    /// <exception cref="ArgumentNullException">subscribe.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TState, IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
     {
@@ -101,7 +101,7 @@ public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TStat
     /// <typeparam name="T">The type.</typeparam>
     /// <param name="subscribe">The subscribe.</param>
     /// <returns>An Signals.</returns>
-    /// <exception cref="System.ArgumentNullException">subscribe.</exception>
+    /// <exception cref="ArgumentNullException">subscribe.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe)
     {
@@ -121,7 +121,7 @@ public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subsc
     /// <param name="subscribe">The subscribe.</param>
     /// <param name="isRequiredSubscribeOnCurrentThread">if set to <c>true</c> [is required subscribe on current thread].</param>
     /// <returns>An Observable.</returns>
-    /// <exception cref="System.ArgumentNullException">subscribe.</exception>
+    /// <exception cref="ArgumentNullException">subscribe.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="subscribe" /> is <c>null</c>.</exception>
     public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
     {
diff --git a/src/ReactiveUI.Primitives/Signals/Signal{Factories}.cs b/src/ReactiveUI.Primitives/Signals/Signal{Factories}.cs
index e602933..a22ac19 100644
--- a/src/ReactiveUI.Primitives/Signals/Signal{Factories}.cs
+++ b/src/ReactiveUI.Primitives/Signals/Signal{Factories}.cs
@@ -184,6 +184,21 @@ public static IObservable<T> FromEnumerable<T>(IEnumerable<T> values)
         return new FromEnumerableSignal<T>(values);
     }
 
+    /// <summary>
+    /// Creates a signal from an enumerable sequence and stops enumeration when the token is cancelled.
+    /// </summary>
+    public static IObservable<T> FromEnumerable<T>(IEnumerable<T> values, CancellationToken cancellationToken)
+    {
+        if (values == null)
+        {
+            throw new ArgumentNullException(nameof(values));
+        }
+
+        return cancellationToken.CanBeCanceled
+            ? new FromEnumerableSignal<T>(values, cancellationToken)
+            : new FromEnumerableSignal<T>(values);
+    }
+
     /// <summary>
     /// Creates a signal from a task instance.
     /// </summary>
@@ -242,6 +257,38 @@ public static IObservable<T> FromTask<T>(Task<T> task)
         });
     }
 
+    /// <summary>
+    /// Creates a signal by invoking an asynchronous factory at subscription time.
+    /// </summary>
+    public static IObservable<T> FromAsync<T>(Func<Task<T>> taskFactory)
+    {
+        if (taskFactory == null)
+        {
+            throw new ArgumentNullException(nameof(taskFactory));
+        }
+
+        return Defer(() => FromTask(taskFactory()));
+    }
+
+    /// <summary>
+    /// Creates a signal by invoking an asynchronous factory at subscription time.
+    /// </summary>
+    public static IObservable<T> FromAsync<T>(Func<CancellationToken, Task<T>> taskFactory) =>
+        FromAsync(taskFactory, CancellationToken.None);
+
+    /// <summary>
+    /// Creates a signal by invoking an asynchronous factory at subscription time.
+    /// </summary>
+    public static IObservable<T> FromAsync<T>(Func<CancellationToken, Task<T>> taskFactory, CancellationToken cancellationToken)
+    {
+        if (taskFactory == null)
+        {
+            throw new ArgumentNullException(nameof(taskFactory));
+        }
+
+        return Defer(() => FromTask(taskFactory(cancellationToken)));
+    }
+
     /// <summary>
     /// Runs a function on the supplied scheduler and emits its result.
     /// </summary>
@@ -465,20 +512,36 @@ public static IObservable<long> Timer(TimeSpan dueTime, TimeSpan period, ISequen
     /// <summary>
     /// Concatenates the supplied signals.
     /// </summary>
-    public static IObservable<T> Concat<T>(params IObservable<T>[] sources) =>
-        FromEnumerable(ValidateSources(sources)).Concat();
+    public static IObservable<T> Concat<T>(params IObservable<T>[] sources)
+    {
+        var validated = ValidateSources(sources);
+        var rangeConcat = TryCreateRangeConcat(validated);
+        return rangeConcat == null ? FromEnumerable(validated).Concat() : (IObservable<T>)(object)rangeConcat;
+    }
 
     /// <summary>
     /// Merges the supplied signals.
     /// </summary>
-    public static IObservable<T> Merge<T>(params IObservable<T>[] sources) =>
-        FromEnumerable(ValidateSources(sources)).Merge();
+    public static IObservable<T> Merge<T>(params IObservable<T>[] sources)
+    {
+        var validated = ValidateSources(sources);
+        var rangeConcat = TryCreateRangeConcat(validated);
+        return rangeConcat == null ? FromEnumerable(validated).Merge() : (IObservable<T>)(object)rangeConcat;
+    }
 
     /// <summary>
     /// Races the supplied signals and mirrors the first one to produce a value or terminal signal.
     /// </summary>
-    public static IObservable<T> Race<T>(params IObservable<T>[] sources) =>
-        FromEnumerable(ValidateSources(sources)).Race();
+    public static IObservable<T> Race<T>(params IObservable<T>[] sources)
+    {
+        var validated = ValidateSources(sources);
+        if (validated.Length > 0 && validated[0] is RangeSignal)
+        {
+            return validated[0];
+        }
+
+        return FromEnumerable(validated).Race();
+    }
 
     /// <summary>
     /// Zips two signals with a result selector.
@@ -528,6 +591,33 @@ private static IObservable<T>[] ValidateSources<T>(IObservable<T>[] sources)
         return sources;
     }
 
+    /// <summary>
+    /// Creates a range concat signal when every source is a synchronous integer range.
+    /// </summary>
+    /// <typeparam name="T">The source value type.</typeparam>
+    /// <param name="sources">The validated sources.</param>
+    /// <returns>A range concat signal, or <see langword="null"/> when the fast path is not applicable.</returns>
+    private static RangeConcatSignal? TryCreateRangeConcat<T>(IObservable<T>[] sources)
+    {
+        if (typeof(T) != typeof(int) || sources.Length == 0)
+        {
+            return null;
+        }
+
+        var ranges = new RangeSignal[sources.Length];
+        for (var i = 0; i < sources.Length; i++)
+        {
+            if (sources[i] is not RangeSignal range)
+            {
+                return null;
+            }
+
+            ranges[i] = range;
+        }
+
+        return new RangeConcatSignal(ranges);
+    }
+
 #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_0_OR_GREATER || NET5_0_OR_GREATER
 
     /// <summary>
diff --git a/src/ReactiveUI.Primitives/Signals/Signal{GetAwaiter}.cs b/src/ReactiveUI.Primitives/Signals/Signal{GetAwaiter}.cs
index 33be3af..fc36d6c 100644
--- a/src/ReactiveUI.Primitives/Signals/Signal{GetAwaiter}.cs
+++ b/src/ReactiveUI.Primitives/Signals/Signal{GetAwaiter}.cs
@@ -16,7 +16,7 @@ public static partial class Signal
     /// <typeparam name="TSource">The type of the source.</typeparam>
     /// <param name="source">Source sequence to await.</param>
     /// <returns>An AsyncSignal.</returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
+    /// <exception cref="ArgumentNullException">source.</exception>
     public static IAwaitSignal<TSource> GetAwaiter<TSource>(this IObservable<TSource> source)
     {
         if (source == null)
@@ -37,7 +37,7 @@ public static IAwaitSignal<TSource> GetAwaiter<TSource>(this IObservable<TSource
     /// <returns>
     /// An AsyncSignal.
     /// </returns>
-    /// <exception cref="System.ArgumentNullException">source.</exception>
+    /// <exception cref="ArgumentNullException">source.</exception>
     public static IAwaitSignal<TSource> GetAwaiter<TSource>(this IObservable<TSource> source, CancellationToken cancellationToken)
     {
         if (source == null)
diff --git a/src/ReactiveUI.Primitives/Signals/Signal{Return}.cs b/src/ReactiveUI.Primitives/Signals/Signal{Return}.cs
index e1eab53..4797210 100644
--- a/src/ReactiveUI.Primitives/Signals/Signal{Return}.cs
+++ b/src/ReactiveUI.Primitives/Signals/Signal{Return}.cs
@@ -36,7 +36,7 @@ public static IObservable<T> Return<T>(T value, ISequencer scheduler)
     /// <param name="value">The value.</param>
     /// <returns>An Signals.</returns>
     public static IObservable<T> Return<T>(T value) =>
-        Return<T>(value, Sequencer.Immediate);
+        Return(value, Sequencer.Immediate);
 
     /// <summary>
     /// Return single sequence Immediately, optimized for RxVoid(no allocate memory).
diff --git a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/StatefulSignalBenchmarks.cs b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/StatefulSignalBenchmarks.cs
index fbccb26..e312196 100644
--- a/src/benchmarks/ReactiveUI.Primitives.Benchmarks/StatefulSignalBenchmarks.cs
+++ b/src/benchmarks/ReactiveUI.Primitives.Benchmarks/StatefulSignalBenchmarks.cs
@@ -83,7 +83,7 @@ public int R3BehaviorSubject1024()
     private static int EmitAndReadBehaviourSignal(int count)
     {
         var observer = new IntSignalObserver();
-        using var subject = new BehaviourSignal<int>(0);
+        using var subject = new BehaviorSignal<int>(0);
         using var subscription = subject.Subscribe(observer);
         for (var i = 1; i <= count; i++)
         {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/BehaviourSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/BehaviourSignalTests.cs
index 6a494f1..33d6f9c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/BehaviourSignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/BehaviourSignalTests.cs
@@ -38,14 +38,14 @@ public class BehaviourSignalTests
     /// </summary>
     [Test]
     public void Subscribe_ArgumentChecking() =>
-        Assert.Throws<ArgumentNullException>(() => new BehaviourSignal<int>(1).Subscribe(null!));
+        Assert.Throws<ArgumentNullException>(() => new BehaviorSignal<int>(1).Subscribe(null!));
 
     /// <summary>
     /// Called when [error argument checking].
     /// </summary>
     [Test]
     public void OnError_ArgumentChecking() =>
-        Assert.Throws<ArgumentNullException>(() => new BehaviourSignal<int>(1).OnError(null!));
+        Assert.Throws<ArgumentNullException>(() => new BehaviorSignal<int>(1).OnError(null!));
 
     /// <summary>
     /// Determines whether this instance has observers.
@@ -53,7 +53,7 @@ public void OnError_ArgumentChecking() =>
     [Test]
     public void HasObservers()
     {
-        var s = new BehaviourSignal<int>(42);
+        var s = new BehaviorSignal<int>(42);
         Assert.False(s.HasObservers);
 
         var d1 = s.Subscribe(_ => { });
@@ -81,7 +81,7 @@ public void HasObservers()
     [Test]
     public void HasObservers_Dispose1()
     {
-        var s = new BehaviourSignal<int>(42);
+        var s = new BehaviorSignal<int>(42);
         Assert.False(s.HasObservers);
         Assert.False(s.IsDisposed);
 
@@ -104,7 +104,7 @@ public void HasObservers_Dispose1()
     [Test]
     public void HasObservers_Dispose2()
     {
-        var s = new BehaviourSignal<int>(42);
+        var s = new BehaviorSignal<int>(42);
         Assert.False(s.HasObservers);
         Assert.False(s.IsDisposed);
 
@@ -127,7 +127,7 @@ public void HasObservers_Dispose2()
     [Test]
     public void HasObservers_Dispose3()
     {
-        var s = new BehaviourSignal<int>(42);
+        var s = new BehaviorSignal<int>(42);
         Assert.False(s.HasObservers);
         Assert.False(s.IsDisposed);
 
@@ -142,7 +142,7 @@ public void HasObservers_Dispose3()
     [Test]
     public void HasObservers_OnCompleted()
     {
-        var s = new BehaviourSignal<int>(42);
+        var s = new BehaviorSignal<int>(42);
         Assert.False(s.HasObservers);
 
         using var subscription = s.Subscribe(_ => { });
@@ -161,7 +161,7 @@ public void HasObservers_OnCompleted()
     [Test]
     public void HasObservers_OnError()
     {
-        var s = new BehaviourSignal<int>(42);
+        var s = new BehaviorSignal<int>(42);
         Assert.False(s.HasObservers);
 
         using var subscription = s.Subscribe(_ => { }, _ => { });
@@ -180,7 +180,7 @@ public void HasObservers_OnError()
     [Test]
     public void Value_Initial()
     {
-        var s = new BehaviourSignal<int>(InitialValue);
+        var s = new BehaviorSignal<int>(InitialValue);
         Assert.Equal(InitialValue, s.Value);
 
         Assert.True(s.TryGetValue(out var x));
@@ -193,7 +193,7 @@ public void Value_Initial()
     [Test]
     public void Value_First()
     {
-        var s = new BehaviourSignal<int>(InitialValue);
+        var s = new BehaviorSignal<int>(InitialValue);
         Assert.Equal(InitialValue, s.Value);
 
         Assert.True(s.TryGetValue(out var x));
@@ -212,7 +212,7 @@ public void Value_First()
     [Test]
     public void Value_Second()
     {
-        var s = new BehaviourSignal<int>(InitialValue);
+        var s = new BehaviorSignal<int>(InitialValue);
         Assert.Equal(InitialValue, s.Value);
 
         Assert.True(s.TryGetValue(out var x));
@@ -237,7 +237,7 @@ public void Value_Second()
     [Test]
     public void Value_FrozenAfterOnCompleted()
     {
-        var s = new BehaviourSignal<int>(InitialValue);
+        var s = new BehaviorSignal<int>(InitialValue);
         Assert.Equal(InitialValue, s.Value);
 
         Assert.True(s.TryGetValue(out var x));
@@ -274,7 +274,7 @@ public void Value_FrozenAfterOnCompleted()
     [Test]
     public void Value_ThrowsAfterOnError()
     {
-        var s = new BehaviourSignal<int>(InitialValue);
+        var s = new BehaviorSignal<int>(InitialValue);
         Assert.Equal(InitialValue, s.Value);
 
         s.OnError(new InvalidOperationException());
@@ -290,7 +290,7 @@ public void Value_ThrowsAfterOnError()
     [Test]
     public void Value_ThrowsOnDispose()
     {
-        var s = new BehaviourSignal<int>(InitialValue);
+        var s = new BehaviorSignal<int>(InitialValue);
         Assert.Equal(InitialValue, s.Value);
 
         s.Dispose();
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CoverageRuntimeTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CoverageRuntimeTests.cs
index 5043a32..f0b57bf 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/CoverageRuntimeTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/CoverageRuntimeTests.cs
@@ -441,6 +441,30 @@ public async Task SequencersCoverValidationAndExecutionBranches()
         Assert.Throws<ArgumentNullException>(() => ThreadPoolSequencer.Instance.Schedule(One, TimeSpan.Zero, null!));
     }
 
+    /// <summary>
+    /// Covers virtual-time extension validation and action scheduling.
+    /// </summary>
+    [Test]
+    public void VirtualTimeSequencerExtensionsValidateAndRunActions()
+    {
+        var clock = new TestClock(DateTimeOffset.UnixEpoch);
+        var invoked = 0;
+
+        Assert.Throws<ArgumentNullException>(() => VirtualTimeSequencerExtensions.ScheduleRelative<DateTimeOffset, TimeSpan>(null!, TimeSpan.Zero, () => { }));
+        Assert.Throws<ArgumentNullException>(() => clock.ScheduleRelative(TimeSpan.Zero, null!));
+        Assert.Throws<ArgumentNullException>(() => VirtualTimeSequencerExtensions.ScheduleAbsolute<DateTimeOffset, TimeSpan>(null!, DateTimeOffset.UnixEpoch, () => { }));
+        Assert.Throws<ArgumentNullException>(() => clock.ScheduleAbsolute(DateTimeOffset.UnixEpoch, null!));
+
+        clock.ScheduleRelative(TimeSpan.FromTicks(One), () => invoked += One);
+        clock.ScheduleAbsolute(DateTimeOffset.UnixEpoch.AddTicks(Two), () => invoked += Two);
+
+        clock.AdvanceBy(TimeSpan.FromTicks(One));
+        Assert.Equal(One, invoked);
+
+        clock.AdvanceBy(TimeSpan.FromTicks(One));
+        Assert.Equal(Three, invoked);
+    }
+
     /// <summary>
     /// Creates an iterator-backed enumerable for the non-indexable enumerable path.
     /// </summary>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/FactoryOperatorContractTests.cs b/src/tests/ReactiveUI.Primitives.Tests/FactoryOperatorContractTests.cs
index 0658cad..0890a11 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/FactoryOperatorContractTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/FactoryOperatorContractTests.cs
@@ -7,10 +7,12 @@
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using ReactiveUI.Primitives;
 using ReactiveUI.Primitives.Concurrency;
 using ReactiveUI.Primitives.Core;
 using ReactiveUI.Primitives.Disposables;
 using ReactiveUI.Primitives.Signals;
+using ReactiveUI.Primitives.Signals.Core;
 using TUnit.Core;
 
 namespace ReactiveUI.Primitives.Tests;
@@ -381,16 +383,42 @@ public void CombiningOperatorsPreserveCoreOrderingSemantics()
         var concatenated = new List<int>();
         var zipped = new List<int>();
         var latest = new List<string>();
-
+        var rangeConcatenated = new List<int>();
+        var rangeMerged = new List<int>();
+        var rangeRace = new List<int>();
+        var rangeLatest = new List<int>();
+        var rangeWithLatest = new List<int>();
+        var rangeForkJoin = new List<int>();
+        var rangeObserver = new RecordingObserver<int>();
+
+        var rangeConcatSignal = Signal.Concat(Signal.Range(FirstValue, SecondValue), Signal.Range(RetrySuccessAttempt, SecondValue));
         Signal.Merge(Signal.FromEnumerable(TakeWhileExpected), Signal.FromEnumerable([RetrySuccessAttempt, FourthValue])).Subscribe(merged.Add);
         Signal.Concat(Signal.FromEnumerable(TakeWhileExpected), Signal.FromEnumerable([RetrySuccessAttempt, FourthValue])).Subscribe(concatenated.Add);
         Signal.Zip(Signal.FromEnumerable(TakeWhileExpected), Signal.FromEnumerable([ProjectedFirstValue, ProjectedThirdValue]), (left, right) => left + right).Subscribe(zipped.Add);
         Signal.CombineLatest(Signal.FromEnumerable(TakeWhileExpected), Signal.FromEnumerable(["a", "b"]), (left, right) => left + right).Subscribe(latest.Add);
+        rangeConcatSignal.Subscribe(rangeConcatenated.Add);
+        rangeConcatSignal.Subscribe(rangeObserver);
+        Signal.Merge(Signal.Range(FirstValue, SecondValue), Signal.Range(RetrySuccessAttempt, SecondValue)).Subscribe(rangeMerged.Add);
+        Signal.Race(Signal.Range(FirstValue, SecondValue), Signal.Range(RetrySuccessAttempt, SecondValue)).Subscribe(rangeRace.Add);
+        Signal.CombineLatest(Signal.Range(FirstValue, SecondValue), Signal.Range(ProjectionMultiplier, SecondValue), static (left, right) => left + right).Subscribe(rangeLatest.Add);
+        Signal.Range(FirstValue, SecondValue).WithLatest(Signal.Range(ProjectionMultiplier, SecondValue), static (left, right) => left + right).Subscribe(rangeWithLatest.Add);
+        Signal.ForkJoin(Signal.Range(FirstValue, SecondValue), Signal.Range(ProjectionMultiplier, SecondValue), static (left, right) => left + right).Subscribe(rangeForkJoin.Add);
+        Assert.Throws<ArgumentNullException>(() => rangeConcatSignal.Subscribe((IObserver<int>)null!));
+        Assert.Throws<ArgumentNullException>(() => ((IInlineSignal<int>)rangeConcatSignal).Subscribe(null!, _ => { }, () => { }));
+        Assert.Throws<ArgumentNullException>(() => ((IInlineSignal<int>)rangeConcatSignal).Subscribe(_ => { }, _ => { }, null!));
 
         Assert.Equal(FourItemExpected, merged);
         Assert.Equal(FourItemExpected, concatenated);
         Assert.Equal(ZippedExpected, zipped);
         Assert.Equal(LatestExpected, latest);
+        Assert.Equal(FourItemExpected, rangeConcatenated);
+        Assert.Equal(FourItemExpected, rangeObserver.Values);
+        Assert.Equal(1, rangeObserver.Completed);
+        Assert.Equal(FourItemExpected, rangeMerged);
+        Assert.Equal(TakeWhileExpected, rangeRace);
+        Assert.Equal(new[] { ProjectedSecondBucketPeerValue, RangeZipShorterSecondResult }, rangeLatest);
+        Assert.Equal(new[] { ProjectedSecondBucketPeerValue, RangeZipShorterSecondResult }, rangeWithLatest);
+        Assert.Equal(new[] { RangeZipShorterSecondResult }, rangeForkJoin);
     }
 
     /// <summary>
@@ -590,10 +618,65 @@ public async Task TerminalTaskOperatorsCompleteWithExpectedSemantics()
         var first = await Signal.FromEnumerable([RetrySuccessAttempt, FourthValue]).FirstAsync();
         var collected = await Signal.FromEnumerable([FirstValue, SecondValue, RetrySuccessAttempt]).CollectArrayAsync();
         var none = await Signal.Empty<int>().FirstOrDefaultAsync(RetryResult);
+        var rangeFirst = await Signal.Range(FirstValue, FourthValue).FirstAsync();
+        var rangeLast = await Signal.Range(FirstValue, FourthValue).ToTask();
+        var rangeCollected = await Signal.Range(FirstValue, RetrySuccessAttempt).CollectListAsync();
+        var count = await Signal.Range(FirstValue, FourthValue).CountAsync();
+        var countEven = await Signal.Range(FirstValue, FourthValue).CountAsync(static value => value % 2 == 0);
+        var any = await Signal.Range(FirstValue, FourthValue).AnyAsync(static value => value == FourthValue);
 
         Assert.Equal(RetrySuccessAttempt, first);
         Assert.Equal(CollectedExpected, (IEnumerable<int>)collected);
         Assert.Equal(RetryResult, none);
+        Assert.Equal(FirstValue, rangeFirst);
+        Assert.Equal(FourthValue, rangeLast);
+        Assert.Equal(CollectedExpected, (IEnumerable<int>)rangeCollected);
+        Assert.Equal(FourthValue, count);
+        Assert.Equal(SecondValue, countEven);
+        Assert.True(any);
+    }
+
+    /// <summary>
+    /// Verifies factory guards, async aliases, and cancellation-aware enumerable conversion.
+    /// </summary>
+    /// <returns>A task that completes when asynchronous assertions finish.</returns>
+    [Test]
+    public async Task FactoryAliasesAndGuardsCoverParityBranches()
+    {
+        var values = new List<int>();
+        var errors = new List<Exception>();
+        var completed = 0;
+        using var cancelled = new CancellationTokenSource();
+        await cancelled.CancelAsync();
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => Signal.Range(FirstValue, -1));
+        Assert.Throws<ArgumentNullException>(() => Signal.Range(FirstValue, SecondValue, null!));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Signal.Repeat(FirstValue, -1));
+        Assert.Throws<ArgumentNullException>(() => Signal.Unfold<int, int>(0, null!, static state => state, static state => state));
+        Assert.Throws<ArgumentNullException>(() => Signal.Unfold<int, int>(0, static _ => true, null!, static state => state));
+        Assert.Throws<ArgumentNullException>(() => Signal.Unfold<int, int>(0, static _ => true, static state => state, null!));
+        Assert.Throws<ArgumentNullException>(() => Signal.Start((Func<int>)null!));
+        Assert.Throws<ArgumentNullException>(() => Signal.Start(static () => FirstValue, null!));
+        Assert.Throws<ArgumentNullException>(() => Signal.Start((Action)null!));
+        Assert.Throws<ArgumentNullException>(() => Signal.After(TimeSpan.Zero, null!));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Signal.Every(TimeSpan.FromTicks(-1)));
+        Assert.Throws<ArgumentNullException>(() => Signal.Timer(TimeSpan.Zero, TimeSpan.Zero, null!));
+        Assert.Throws<ArgumentNullException>(() => Signal.FromAsync<int>((Func<Task<int>>)null!));
+        Assert.Throws<ArgumentNullException>(() => Signal.FromAsync<int>((Func<CancellationToken, Task<int>>)null!));
+
+        Signal.Range(FirstValue, 0).Subscribe(values.Add, errors.Add, () => completed++);
+        Signal.Repeat(FirstValue, 0).Subscribe(values.Add, errors.Add, () => completed++);
+        new[] { FirstValue, SecondValue }.ToObservable(cancelled.Token).Subscribe(values.Add, errors.Add, () => completed++);
+        Signal.Start<int>(() => throw new InvalidOperationException("start failed"), Sequencer.Immediate).Subscribe(values.Add, errors.Add, () => completed++);
+
+        var fromAsync = await Signal.FromAsync(() => Task.FromResult(RetryResult)).ToTask();
+        var fromAsyncWithToken = await Signal.FromAsync(static token => Task.FromResult(token.IsCancellationRequested ? -1 : RetrySuccessAttempt)).ToTask();
+
+        Assert.Equal(RetryResult, fromAsync);
+        Assert.Equal(RetrySuccessAttempt, fromAsyncWithToken);
+        Assert.Equal(0, values.Count);
+        Assert.Equal(SecondValue, completed);
+        Assert.Equal(1, errors.Count);
     }
 
     /// <summary>
@@ -676,4 +759,30 @@ private static async Task VerifyTaskAliasOperators()
         Assert.Equal(RepeatValue, first);
         Assert.Equal(ProjectedSecondValue, started);
     }
+
+    /// <summary>
+    /// Records observer values and terminal signals.
+    /// </summary>
+    /// <typeparam name="T">The observed value type.</typeparam>
+    private sealed class RecordingObserver<T> : IObserver<T>
+    {
+        /// <summary>
+        /// Gets observed values.
+        /// </summary>
+        public List<T> Values { get; } = [];
+
+        /// <summary>
+        /// Gets completion count.
+        /// </summary>
+        public int Completed { get; private set; }
+
+        /// <inheritdoc/>
+        public void OnCompleted() => Completed++;
+
+        /// <inheritdoc/>
+        public void OnError(Exception error) => throw error;
+
+        /// <inheritdoc/>
+        public void OnNext(T value) => Values.Add(value);
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/StatefulSharingAndBridgeContractTests.cs b/src/tests/ReactiveUI.Primitives.Tests/StatefulSharingAndBridgeContractTests.cs
index c92a47b..e813659 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/StatefulSharingAndBridgeContractTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/StatefulSharingAndBridgeContractTests.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using ReactiveUI.Primitives;
+using ReactiveUI.Primitives.Disposables;
 using ReactiveUI.Primitives.R3Bridge.Generator;
 using ReactiveUI.Primitives.Signals;
 using ReactiveUI.Primitives.SystemReactiveBridge.Generator;
@@ -218,6 +219,96 @@ public async Task CommandSignalPublishesResultsFailuresAndRunningState()
         Assert.Equal("Command cannot run.", rejected!.Message);
     }
 
+    /// <summary>
+    /// Verifies connectable aliases, auto-connect validation, and replay window overloads.
+    /// </summary>
+    [Test]
+    public void ConnectableAliasesValidateAndConnectAtThreshold()
+    {
+        var source = new Signal<int>();
+        var sourceSubscriptions = 0;
+        var cold = Signal.Create<int>(observer =>
+        {
+            sourceSubscriptions++;
+            return source.Subscribe(observer);
+        });
+
+        var auto = cold.Publish().AutoConnect(2);
+        var first = new List<int>();
+        var second = new List<int>();
+        using var firstSubscription = auto.Subscribe(first.Add);
+        source.OnNext(FirstSharedValue);
+        using var secondSubscription = auto.Subscribe(second.Add);
+        source.OnNext(SecondSharedValue);
+
+        Assert.Equal(1, sourceSubscriptions);
+        Assert.Equal(ExpectedSecondSharedValues[1..], first);
+        Assert.Equal(ExpectedSecondSharedValues[1..], second);
+        Assert.Throws<ArgumentNullException>(() => ConnectableSignalMixins.Multicast(null!, new Signal<int>()));
+        Assert.Throws<ArgumentNullException>(() => Signal.Never<int>().Multicast(null!));
+        Assert.Throws<ArgumentNullException>(() => ConnectableSignalMixins.RefCount<int>(null!));
+        Assert.Throws<ArgumentNullException>(() => ConnectableSignalMixins.AutoConnect<int>(null!));
+        Assert.Throws<ArgumentOutOfRangeException>(() => cold.PublishLive().AutoConnect(-1));
+
+        var replayed = cold.Replay(1, TimeSpan.FromSeconds(1));
+        using var connection = replayed.Connect();
+        source.OnNext(FirstReplayValue);
+        var replayValues = new List<int>();
+        replayed.Subscribe(replayValues.Add);
+
+        Assert.Equal(ExpectedReplayValues[..1], replayValues);
+    }
+
+    /// <summary>
+    /// Verifies command aliases, sync execution failures, and disposal branches.
+    /// </summary>
+    /// <returns>A task that completes when command assertions finish.</returns>
+    [Test]
+    public async Task CommandSignalCoversSyncFaultAndDisposalBranches()
+    {
+        var behavior = new BehaviorSignal<int>(InitialStateValue);
+        var disposable = new MultipleDisposable(Disposable.Empty);
+        var fault = new InvalidOperationException("sync failed");
+        var command = new CommandSignal<int>(() => throw fault);
+        var results = new List<int>();
+        var faults = new List<Exception>();
+
+        command.Results.Subscribe(results.Add);
+        command.Faults.Subscribe(faults.Add);
+        behavior.OnNext(UpdatedStateValue);
+        disposable.Dispose();
+
+        InvalidOperationException? observed = null;
+        try
+        {
+            await command.ExecuteAsync();
+        }
+        catch (InvalidOperationException error)
+        {
+            observed = error;
+        }
+
+        command.Dispose();
+        command.Dispose();
+        ObjectDisposedException? disposed = null;
+        try
+        {
+            await command.ExecuteAsync();
+        }
+        catch (ObjectDisposedException error)
+        {
+            disposed = error;
+        }
+
+        Assert.Same(fault, observed!);
+        Assert.Equal(0, results.Count);
+        Assert.Equal(1, faults.Count);
+        Assert.Same(fault, faults[0]);
+        Assert.Equal(UpdatedStateValue, behavior.Value);
+        Assert.True(disposable.IsDisposed);
+        Assert.NotNull(disposed);
+    }
+
     /// <summary>
     /// Verifies bridge generators emit adapters when external shapes are present.
     /// </summary>
@@ -239,17 +330,50 @@ public static class Observable { }
 
 namespace R3
 {
+    public readonly struct Result
+    {
+        public static Result Success => default;
+
+        public static Result Failure(Exception exception) => new Result(exception);
+
+        private Result(Exception exception) => Exception = exception;
+
+        public Exception Exception { get; }
+
+        public bool IsFailure => Exception != null;
+    }
+
+    public abstract class Observer<T> : IDisposable
+    {
+        public void OnNext(T value) => OnNextCore(value);
+
+        public void OnErrorResume(Exception error) => OnErrorResumeCore(error);
+
+        public void OnCompleted(Result result) => OnCompletedCore(result);
+
+        public void Dispose() { }
+
+        protected abstract void OnNextCore(T value);
+
+        protected abstract void OnErrorResumeCore(Exception error);
+
+        protected abstract void OnCompletedCore(Result result);
+    }
+
     public abstract class Observable<T>
     {
-        public abstract IDisposable Subscribe(IObserver<T> observer);
+        public abstract IDisposable Subscribe(Observer<T> observer);
+    }
 
-        public static Observable<T> Create(Func<IObserver<T>, IDisposable> subscribe) => new DelegateObservable<T>(subscribe);
+    public static class Observable
+    {
+        public static Observable<T> Create<T>(Func<Observer<T>, IDisposable> subscribe) => new DelegateObservable<T>(subscribe);
 
         private sealed class DelegateObservable<TValue> : Observable<TValue>
         {
-            private readonly Func<IObserver<TValue>, IDisposable> _subscribe;
-            public DelegateObservable(Func<IObserver<TValue>, IDisposable> subscribe) => _subscribe = subscribe;
-            public override IDisposable Subscribe(IObserver<TValue> observer) => _subscribe(observer);
+            private readonly Func<Observer<TValue>, IDisposable> _subscribe;
+            public DelegateObservable(Func<Observer<TValue>, IDisposable> subscribe) => _subscribe = subscribe;
+            public override IDisposable Subscribe(Observer<TValue> observer) => _subscribe(observer);
         }
     }
 }