diff --git a/README.md b/README.md
index 884d6426..b72bdbc2 100644
--- a/README.md
+++ b/README.md
@@ -1142,6 +1142,7 @@ share one subscription instead of starting the work over each time.
 | `IObserver<T>.FastForEach(source)` | Pushes a whole collection into an observer and indexes arrays and lists directly. | - |
 | `ObserveOn(sequencer)` | Delivers notifications to subscribers on the sequencer you name. | `ObserveOn` |
 | `WitnessOn(sequencer)` | Another name for `ObserveOn`. | `ObserveOn` |
+| `WitnessLatestOn(sequencer)` | Delivers notifications on the sequencer you name. Keeps only the newest value that is waiting and drops the older ones. | - |
 | `SubscribeOn(sequencer)` | Runs the subscription itself on the sequencer you name. | `SubscribeOn` |
 | `Synchronize()`, `Synchronize(object gate)` | Delivers notifications one at a time behind a lock, which you can share with other signals. | `Synchronize` |
 | `Synchronize(Lock gate)` | The same, taking a `System.Threading.Lock`. Available on net9.0 and later only. | `Synchronize` |
@@ -2211,18 +2212,36 @@ conveniences that take an action, with or without a delay.
 
 | Sequencer | What it does |
 |---|---|
-| `Sequencer.CurrentThread` | Queues work on the calling thread and runs it in order. Also available as `CurrentThreadSequencer.Instance`. |
-| `Sequencer.Immediate` | Runs the work right away on the calling thread. Also available as `ImmediateSequencer.Instance`. |
+| `Sequencer.CurrentThread` | Queues work on the calling thread and runs it in order. Also available as `CurrentThreadSequencer.Instance`. `new CurrentThreadSequencer(timeProvider)` waits through a `TimeProvider`. |
+| `Sequencer.Immediate` | Runs the work right away on the calling thread. Also available as `ImmediateSequencer.Instance`. `new ImmediateSequencer(timeProvider)` waits through a `TimeProvider`. |
 | `Sequencer.Default` | The default choice for background work. It is `TaskPoolSequencer.Default`. |
-| `TaskPoolSequencer` | Runs work through a `TaskFactory`. Use `TaskPoolSequencer.Instance`, or pass your own factory. |
-| `ThreadPoolSequencer` | Runs work on the thread pool. Use `ThreadPoolSequencer.Instance`. |
-| `SynchronizationContextSequencer` | Posts work to a `SynchronizationContext`. Use `SynchronizationContextSequencer.Current`, or pass a context. |
-| `WasmSequencer` | Runs work on a browser's single-threaded event loop. Use `WasmSequencer.Default`. |
-| `VirtualClock` | Controls time in a test, using `DateTimeOffset` and `TimeSpan`. You advance the clock, so nothing sleeps. |
+| `TaskPoolSequencer` | Runs work through a `TaskFactory`. Use `TaskPoolSequencer.Instance`, or pass your own factory. `new TaskPoolSequencer(factory, timeProvider)` takes its time from a `TimeProvider`. |
+| `ThreadPoolSequencer` | Runs work on the thread pool. Use `ThreadPoolSequencer.Instance`. `new ThreadPoolSequencer(timeProvider)` takes its time and delay timer from a `TimeProvider`. |
+| `SynchronizationContextSequencer` | Posts work to a `SynchronizationContext`. Use `SynchronizationContextSequencer.Current`, or pass a context. `new SynchronizationContextSequencer(context, timeProvider)` takes its time from a `TimeProvider`. |
+| `WasmSequencer` | Runs work on a browser's single-threaded event loop. Use `WasmSequencer.Default`. `new WasmSequencer(timeProvider)` takes its time and timers from a `TimeProvider`. |
+| `VirtualClock` | Controls time in a test, using `DateTimeOffset` and `TimeSpan`. You advance the clock, so nothing sleeps. It is also a `TimeProvider`. |
 | `VirtualTimeSequencer<TAbsolute, TRelative>` | Controls time in a test using your own clock types. |
+| `sequencer.IsImmediate` | Returns `true` when the sequencer is the immediate sequencer and `false` for any other sequencer or for `null`. Use it instead of comparing against `Sequencer.Immediate`. It comes from `SequencerImmediacyExtensions`. |
 
 Use a virtual sequencer for a time-based test. Do not sleep a real thread.
 
+To run a built-in sequencer from a fake clock, pass a `TimeProvider` to its constructor. `VirtualClock` is a
+`TimeProvider`, so `clock.AdvanceBy` fires the sequencer's timers.
+
+```csharp
+var clock = new VirtualClock();
+var sequencer = new ThreadPoolSequencer(clock);
+var results = new List<int>();
+
+using var subscription = source
+    .Throttle(TimeSpan.FromSeconds(1), sequencer)
+    .Subscribe(results.Add);
+
+source.OnNext(1);
+clock.AdvanceBy(TimeSpan.FromSeconds(1));
+// results now holds 1
+```
+
 ### Platform sequencers
 
 Each UI framework gets its own package, so the core package pulls in none of them.
@@ -3042,6 +3061,7 @@ the same thing.
 | `DeferSignal<T>` | `Signal.Lazy` / `Signal.Defer` |
 | `CatchSignal<T>` | `Catch` |
 | `WitnessOnSignal<T>` | `WitnessOn` / `ObserveOn` |
+| `WitnessLatestOnSignal<T>` | `WitnessLatestOn` |
 | `SelectManyThenCoordinator<TSource, TMid, TResult>` | `SelectManyThen`, both projection stages in one sink |
 | `CalmCoordinator<T>` | `Calm` / `Throttle` |
 | `ReattemptCoordinator<T>` | `Reattempt` |
diff --git a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
index 6045ef6d..9647b7cb 100644
--- a/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
+++ b/src/Primitives.Extensions.Shared/Operators/ObserveOnObservable.cs
@@ -23,7 +23,7 @@ public IDisposable Subscribe(IObserver<T> observer)
         InvalidOperationExceptionHelper.ThrowIfNull(scheduler);
         ArgumentExceptionHelper.ThrowIfNull(observer);
 
-        if (ReferenceEquals(scheduler, Sequencer.Immediate))
+        if (scheduler.IsImmediate)
         {
             return source.Subscribe(observer);
         }
diff --git a/src/Primitives.Shared/Advanced/EmptySignal{T}.cs b/src/Primitives.Shared/Advanced/EmptySignal{T}.cs
index bf749610..8ed6deaf 100644
--- a/src/Primitives.Shared/Advanced/EmptySignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/EmptySignal{T}.cs
@@ -42,7 +42,7 @@ private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         observer = new GuardedWitness<T>(observer, cancel);
 
-        if (_scheduler == Sequencer.Immediate)
+        if (_scheduler.IsImmediate)
         {
             observer.OnCompleted();
             return EmptyDisposable.Instance;
diff --git a/src/Primitives.Shared/Advanced/ReturnSignal{T}.cs b/src/Primitives.Shared/Advanced/ReturnSignal{T}.cs
index 5ea4ccb1..c79cbeb2 100644
--- a/src/Primitives.Shared/Advanced/ReturnSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ReturnSignal{T}.cs
@@ -54,7 +54,7 @@ private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         observer = new GuardedWitness<T>(observer, cancel);
 
-        if (_scheduler == Sequencer.Immediate)
+        if (_scheduler.IsImmediate)
         {
             observer.OnNext(_value);
             observer.OnCompleted();
diff --git a/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs b/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
index 98b6c117..99e798fb 100644
--- a/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
+++ b/src/Primitives.Shared/Advanced/SubscriptionScheduling.cs
@@ -42,7 +42,7 @@ internal static IDisposable OnCurrentThread<TState>(TState state, Func<TState, I
     /// <returns>A disposable that cancels the scheduled work, best effort.</returns>
     internal static IDisposable RunOn<TState>(ISequencer sequencer, TState state, Action<TState> run)
     {
-        if (sequencer == Sequencer.Immediate)
+        if (sequencer.IsImmediate)
         {
             run(state);
             return EmptyDisposable.Instance;
diff --git a/src/Primitives.Shared/Advanced/ThrowSignal{T}.cs b/src/Primitives.Shared/Advanced/ThrowSignal{T}.cs
index f1d49f1d..1c5588a8 100644
--- a/src/Primitives.Shared/Advanced/ThrowSignal{T}.cs
+++ b/src/Primitives.Shared/Advanced/ThrowSignal{T}.cs
@@ -64,7 +64,7 @@ private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
     {
         observer = new GuardedWitness<T>(observer, cancel);
 
-        if (_scheduler == Sequencer.Immediate)
+        if (_scheduler.IsImmediate)
         {
             observer.OnError(_error);
             return EmptyDisposable.Instance;
diff --git a/src/Primitives.Shared/Advanced/WitnessLatestOnSignal{T}.cs b/src/Primitives.Shared/Advanced/WitnessLatestOnSignal{T}.cs
new file mode 100644
index 00000000..4200f294
--- /dev/null
+++ b/src/Primitives.Shared/Advanced/WitnessLatestOnSignal{T}.cs
@@ -0,0 +1,244 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+
+#if REACTIVE_SHIM
+namespace ReactiveUI.Primitives.Reactive.Advanced;
+#else
+namespace ReactiveUI.Primitives.Advanced;
+#endif
+
+/// <summary>Re-dispatches source notifications onto a sequencer, delivering only the newest value that is waiting.</summary>
+/// <typeparam name="T">The value type.</typeparam>
+/// <param name="source">The source observable.</param>
+/// <param name="scheduler">The sequencer that dispatches the notifications.</param>
+[System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+public sealed class WitnessLatestOnSignal<T>(IObservable<T> source, ISequencer scheduler) : IRequireCurrentThread<T>
+{
+    /// <summary>The source observable.</summary>
+    private readonly IObservable<T> _source = source;
+
+    /// <summary>The sequencer that dispatches the notifications.</summary>
+    private readonly ISequencer _scheduler = scheduler;
+
+    /// <summary>Reports that subscription is dispatched through the current-thread sequencer.</summary>
+    /// <returns>Always <see langword="true"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool IsRequiredSubscribeOnCurrentThread() => true;
+
+    /// <summary>Subscribes an observer through the current-thread sequencer.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <returns>The subscription.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public IDisposable Subscribe(IObserver<T> observer) =>
+        SignalSubscription.Subscribe(observer, true, SubscribeCore);
+
+    /// <summary>Builds the dispatching sink and subscribes it to the source.</summary>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The subscription handle owned by the subscription helper.</param>
+    /// <returns>The source subscription together with the sink.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel) =>
+        new WitnessLatestOn(this, observer, cancel).Run();
+
+    /// <summary>Holds the newest source value and delivers it on the sequencer.</summary>
+    /// <param name="parent">The owning signal.</param>
+    /// <param name="observer">The downstream observer.</param>
+    /// <param name="cancel">The subscription handle released on teardown.</param>
+    private sealed class WitnessLatestOn(WitnessLatestOnSignal<T> parent, IObserver<T> observer, IDisposable cancel) : IObserver<T>, IWorkItem, IsDisposed
+    {
+        /// <summary>The owning signal.</summary>
+        private readonly WitnessLatestOnSignal<T> _parent = parent;
+
+        /// <summary>The downstream observer.</summary>
+        private readonly IObserver<T> _observer = observer;
+
+        /// <summary>Synchronization gate guarding the pending slot and scheduling state.</summary>
+        private readonly Lock _gate = new();
+
+        /// <summary>Upstream subscription disposed on teardown.</summary>
+        private readonly IDisposable _cancel = cancel;
+
+        /// <summary>The newest value awaiting delivery.</summary>
+        private T _pending = default!;
+
+        /// <summary>The error awaiting delivery.</summary>
+        private Exception? _error;
+
+        /// <summary>Whether <see cref="_pending"/> holds a value.</summary>
+        private bool _hasPending;
+
+        /// <summary>Whether completion is awaiting delivery.</summary>
+        private bool _hasCompleted;
+
+        /// <summary>Whether the sink has been torn down.</summary>
+        private bool _isDisposed;
+
+        /// <summary>Tracks whether a drain is scheduled or running.</summary>
+        private bool _isScheduled;
+
+        /// <inheritdoc/>
+        public bool IsDisposed
+        {
+            get
+            {
+                lock (_gate)
+                {
+                    return _isDisposed;
+                }
+            }
+        }
+
+        /// <summary>Subscribes to the source.</summary>
+        /// <returns>The source subscription together with this sink.</returns>
+        public MultipleDisposable Run()
+        {
+            var sourceDisposable = _parent._source.Subscribe(this);
+
+            return new(sourceDisposable, this);
+        }
+
+        /// <summary>Stores a value as the newest pending value.</summary>
+        /// <param name="value">The value to store.</param>
+        public void OnNext(T value)
+        {
+            lock (_gate)
+            {
+                if (_isDisposed || _hasCompleted || _error is not null)
+                {
+                    return;
+                }
+
+                _pending = value;
+                _hasPending = true;
+                if (_isScheduled)
+                {
+                    return;
+                }
+
+                _isScheduled = true;
+            }
+
+            _parent._scheduler.Schedule(this);
+        }
+
+        /// <summary>Stores the error for delivery after any pending value.</summary>
+        /// <param name="error">The error to store.</param>
+        public void OnError(Exception error)
+        {
+            lock (_gate)
+            {
+                if (_isDisposed || _error is not null)
+                {
+                    return;
+                }
+
+                _error = error;
+                if (_isScheduled)
+                {
+                    return;
+                }
+
+                _isScheduled = true;
+            }
+
+            _parent._scheduler.Schedule(this);
+        }
+
+        /// <summary>Stores completion for delivery after any pending value.</summary>
+        public void OnCompleted()
+        {
+            lock (_gate)
+            {
+                if (_isDisposed || _hasCompleted || _error is not null)
+                {
+                    return;
+                }
+
+                _hasCompleted = true;
+                if (_isScheduled)
+                {
+                    return;
+                }
+
+                _isScheduled = true;
+            }
+
+            _parent._scheduler.Schedule(this);
+        }
+
+        /// <summary>Executes the scheduled drain.</summary>
+        public void Execute()
+        {
+            while (true)
+            {
+                var value = default(T)!;
+                Exception? error = null;
+                var isValue = false;
+                lock (_gate)
+                {
+                    if (_isDisposed)
+                    {
+                        _isScheduled = false;
+                        return;
+                    }
+
+                    if (_hasPending)
+                    {
+                        value = _pending;
+                        _pending = default!;
+                        _hasPending = false;
+                        isValue = true;
+                    }
+                    else if (_error is not null)
+                    {
+                        error = _error;
+                    }
+                    else if (!_hasCompleted)
+                    {
+                        _isScheduled = false;
+                        return;
+                    }
+                }
+
+                if (isValue)
+                {
+                    _observer.OnNext(value);
+                    continue;
+                }
+
+                if (error is not null)
+                {
+                    _observer.OnError(error);
+                }
+                else
+                {
+                    _observer.OnCompleted();
+                }
+
+                Dispose();
+                return;
+            }
+        }
+
+        /// <summary>Drops the pending value and releases the upstream subscription, once.</summary>
+        public void Dispose()
+        {
+            lock (_gate)
+            {
+                if (_isDisposed)
+                {
+                    return;
+                }
+
+                _isDisposed = true;
+                _pending = default!;
+                _hasPending = false;
+            }
+
+            _cancel.Dispose();
+        }
+    }
+}
diff --git a/src/Primitives.Shared/Concurrency/SequencerImmediacyExtensions.cs b/src/Primitives.Shared/Concurrency/SequencerImmediacyExtensions.cs
new file mode 100644
index 00000000..b0f1d5cd
--- /dev/null
+++ b/src/Primitives.Shared/Concurrency/SequencerImmediacyExtensions.cs
@@ -0,0 +1,33 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+
+#if REACTIVE_SHIM
+namespace ReactiveUI.Primitives.Reactive.Concurrency;
+#else
+namespace ReactiveUI.Primitives.Concurrency;
+#endif
+
+/// <summary>Reports whether a sequencer runs work inline on the calling thread.</summary>
+public static class SequencerImmediacyExtensions
+{
+    /// <summary>Immediacy check for a sequencer.</summary>
+    /// <param name="sequencer">The sequencer to test; may be <see langword="null"/>.</param>
+    extension(ISequencer? sequencer)
+    {
+        /// <summary>Gets a value indicating whether the sequencer is the immediate sequencer.</summary>
+        /// <value><see langword="true"/> when the sequencer runs work inline on the calling thread; <see langword="false"/> for any other sequencer or <see langword="null"/>.</value>
+        public bool IsImmediate
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get =>
+#if REACTIVE_SHIM
+                sequencer is global::System.Reactive.Concurrency.ImmediateScheduler;
+#else
+                sequencer is ImmediateSequencer;
+#endif
+        }
+    }
+}
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs b/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
index 317412cb..99a7d306 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.Helpers.cs
@@ -163,7 +163,7 @@ public IDisposable Subscribe(Action<Moment<T>> onNext, Action<Exception> onError
         /// <param name="onNext">The next callback.</param>
         private void Emit(Action<Moment<T>> onNext)
         {
-            if (_sequencer == Sequencer.Immediate)
+            if (_sequencer.IsImmediate)
             {
                 var timestamp = _sequencer.Now;
                 for (var i = 0; i < _range.Count; i++)
@@ -184,7 +184,7 @@ private void Emit(Action<Moment<T>> onNext)
         /// <param name="observer">The downstream observer.</param>
         private void Emit(IObserver<Moment<T>> observer)
         {
-            if (_sequencer == Sequencer.Immediate)
+            if (_sequencer.IsImmediate)
             {
                 var timestamp = _sequencer.Now;
                 for (var i = 0; i < _range.Count; i++)
@@ -238,7 +238,7 @@ public IDisposable Subscribe(Action<TimeInterval<T>> onNext, Action<Exception> o
         /// <param name="onNext">The next callback.</param>
         private void Emit(Action<TimeInterval<T>> onNext)
         {
-            if (_sequencer == Sequencer.Immediate)
+            if (_sequencer.IsImmediate)
             {
                 for (var i = 0; i < _range.Count; i++)
                 {
@@ -262,7 +262,7 @@ private void Emit(Action<TimeInterval<T>> onNext)
         /// <param name="observer">The downstream observer.</param>
         private void Emit(IObserver<TimeInterval<T>> observer)
         {
-            if (_sequencer == Sequencer.Immediate)
+            if (_sequencer.IsImmediate)
             {
                 for (var i = 0; i < _range.Count; i++)
                 {
diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.cs b/src/Primitives.Shared/SignalOperatorParityMixins.cs
index 90dee19e..362fc1ce 100644
--- a/src/Primitives.Shared/SignalOperatorParityMixins.cs
+++ b/src/Primitives.Shared/SignalOperatorParityMixins.cs
@@ -36,7 +36,7 @@ public IObservable<T> ToObservable(ISequencer scheduler)
 
             ArgumentExceptionHelper.ThrowIfNull(scheduler);
 
-            return scheduler == Sequencer.Immediate || scheduler == Sequencer.CurrentThread
+            return scheduler.IsImmediate || scheduler == Sequencer.CurrentThread
                 ? new FromEnumerableSignal<T>(values)
                 : new ScheduledEnumerableSignal<T>(values, scheduler);
         }
@@ -149,7 +149,7 @@ public IObservable<T> ObserveOn(ISequencer scheduler)
 
             ArgumentExceptionHelper.ThrowIfNull(scheduler);
 
-            return scheduler == Sequencer.Immediate ? source : new WitnessOnSignal<T>(source, scheduler);
+            return scheduler.IsImmediate ? source : new WitnessOnSignal<T>(source, scheduler);
         }
 
         /// <summary>Schedules source subscription on the supplied sequencer.</summary>
diff --git a/src/Primitives.Shared/Signals/ScheduledSignal{T}.cs b/src/Primitives.Shared/Signals/ScheduledSignal{T}.cs
index 185a6fd7..13022661 100644
--- a/src/Primitives.Shared/Signals/ScheduledSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/ScheduledSignal{T}.cs
@@ -65,7 +65,7 @@ public ScheduledSignal(ISequencer scheduler, IObserver<T>? defaultObserver, ISig
 
         _defaultObserver = defaultObserver;
         _subject = defaultSubject ?? new Signal<T>();
-        _observed = scheduler == Sequencer.Immediate
+        _observed = scheduler.IsImmediate
             ? _subject
             : new WitnessOnSignal<T>(_subject, scheduler);
         _defaultObserverSub = defaultObserver is null ? null : SubscribeDefaultObserver(defaultObserver);
diff --git a/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs b/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
index c95d7065..161ff52a 100644
--- a/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
+++ b/src/Primitives.Shared/Signals/SignalExtensions{Create}.cs
@@ -26,6 +26,13 @@ public static partial class SignalExtensions
         public IObservable<T> WitnessOn(ISequencer scheduler) =>
             new WitnessOnSignal<T>(source, scheduler);
 
+        /// <summary>Delivers only the newest waiting source value on the supplied sequencer.</summary>
+        /// <param name="scheduler">The sequencer that notifications are delivered on.</param>
+        /// <returns>A signal that forwards the latest source value on <paramref name="scheduler"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IObservable<T> WitnessLatestOn(ISequencer scheduler) =>
+            new WitnessLatestOnSignal<T>(source, scheduler);
+
         /// <summary>Blocks until the signal completes and returns the observed values.</summary>
         /// <returns>The values observed before completion.</returns>
         /// <exception cref="ArgumentExceptionHelper"><paramref name="source"/> is <see langword="null"/>.</exception>
diff --git a/src/Primitives.Shared/Signals/Signal{Emit}.cs b/src/Primitives.Shared/Signals/Signal{Emit}.cs
index b2af64bd..fe7ce9dd 100644
--- a/src/Primitives.Shared/Signals/Signal{Emit}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Emit}.cs
@@ -18,7 +18,7 @@ public static partial class Signal
     /// <param name="value">The value to emit.</param>
     /// <param name="scheduler">The scheduler the value is emitted on.</param>
     /// <returns>A signal that emits <paramref name="value"/> and completes.</returns>
-    public static IObservable<T> Emit<T>(T value, ISequencer scheduler) => scheduler == Sequencer.Immediate
+    public static IObservable<T> Emit<T>(T value, ISequencer scheduler) => scheduler.IsImmediate
         ? new ImmediateReturnSignal<T>(value)
         : new ReturnSignal<T>(value, scheduler);
 
diff --git a/src/Primitives.Shared/Signals/Signal{Factories}.cs b/src/Primitives.Shared/Signals/Signal{Factories}.cs
index 4b56892a..b5aff0b2 100644
--- a/src/Primitives.Shared/Signals/Signal{Factories}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Factories}.cs
@@ -42,7 +42,7 @@ public static IObservable<int> Sequence(int start, int count, ISequencer schedul
             return ImmutableEmptySignal<int>.Instance;
         }
 
-        return scheduler == Sequencer.Immediate || scheduler == Sequencer.CurrentThread
+        return scheduler.IsImmediate || scheduler == Sequencer.CurrentThread
             ? new RangeSignal(start, count)
             : new SequenceSignal(start, count, scheduler);
     }
diff --git a/src/Primitives.Shared/Signals/Signal{Fail}.cs b/src/Primitives.Shared/Signals/Signal{Fail}.cs
index b807ac05..9556080d 100644
--- a/src/Primitives.Shared/Signals/Signal{Fail}.cs
+++ b/src/Primitives.Shared/Signals/Signal{Fail}.cs
@@ -22,7 +22,7 @@ public static partial class Signal
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
         Justification = "The element type cannot be inferred from the arguments.")]
-    public static IObservable<T> Fail<T>(Exception error, ISequencer scheduler) => scheduler == Sequencer.Immediate
+    public static IObservable<T> Fail<T>(Exception error, ISequencer scheduler) => scheduler.IsImmediate
         ? new ImmediateThrowSignal<T>(error)
         : new ThrowSignal<T>(error, scheduler);
 
@@ -62,7 +62,7 @@ public static IObservable<T> Fail<T>(Exception error, T witness) =>
         "SST2318:Members should not have identical bodies",
         Justification = "The witness parameter only fixes the element type, so this overload builds the same signal.")]
     public static IObservable<T> Fail<T>(Exception error, ISequencer scheduler, T witness) =>
-        scheduler == Sequencer.Immediate
+        scheduler.IsImmediate
             ? new ImmediateThrowSignal<T>(error)
             : new ThrowSignal<T>(error, scheduler);
 }
diff --git a/src/Primitives.Shared/Signals/Signal{FromTask}.cs b/src/Primitives.Shared/Signals/Signal{FromTask}.cs
index 7c02fbf6..623edd2b 100644
--- a/src/Primitives.Shared/Signals/Signal{FromTask}.cs
+++ b/src/Primitives.Shared/Signals/Signal{FromTask}.cs
@@ -139,7 +139,7 @@ private static ITaskSignal<TResult> CreateTaskSignal<TResult>(
         Func<CancellationTokenSource, Task<TResult>> execution,
         ISequencer? scheduler,
         CancellationTokenSource? cancellationTokenSource) =>
-        ReferenceEquals(scheduler, Sequencer.Immediate)
+        scheduler.IsImmediate
             ? new ImmediateTaskSignal<TResult>(execution, cancellationTokenSource)
             : TaskSignal.Create<TResult>(
                 ao => Lazy(() => Create<TResult>(observer => SubscribeTask(ao, execution, observer))),
diff --git a/src/Primitives.Shared/Signals/Signal{None}.cs b/src/Primitives.Shared/Signals/Signal{None}.cs
index f87bdb8e..72fde571 100644
--- a/src/Primitives.Shared/Signals/Signal{None}.cs
+++ b/src/Primitives.Shared/Signals/Signal{None}.cs
@@ -21,7 +21,7 @@ public static partial class Signal
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
         Justification = "The element type cannot be inferred from the arguments.")]
-    public static IObservable<T> None<T>(ISequencer scheduler) => scheduler == Sequencer.Immediate
+    public static IObservable<T> None<T>(ISequencer scheduler) => scheduler.IsImmediate
         ? ImmutableEmptySignal<T>.Instance
         : new EmptySignal<T>(scheduler);
 
@@ -34,7 +34,7 @@ public static IObservable<T> None<T>(ISequencer scheduler) => scheduler == Seque
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification = "The witness parameter only fixes the element type, so this overload builds the same signal.")]
-    public static IObservable<T> None<T>(ISequencer scheduler, T witness) => scheduler == Sequencer.Immediate
+    public static IObservable<T> None<T>(ISequencer scheduler, T witness) => scheduler.IsImmediate
         ? ImmutableEmptySignal<T>.Instance
         : new EmptySignal<T>(scheduler);
 
diff --git a/src/Primitives.Shared/Signals/Signal{RxAliases}.cs b/src/Primitives.Shared/Signals/Signal{RxAliases}.cs
index b1bfaa7d..846f5284 100644
--- a/src/Primitives.Shared/Signals/Signal{RxAliases}.cs
+++ b/src/Primitives.Shared/Signals/Signal{RxAliases}.cs
@@ -105,7 +105,7 @@ public static IObservable<T> Return<T>(T value, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
 
-        return scheduler == Sequencer.Immediate
+        return scheduler.IsImmediate
             ? new ImmediateReturnSignal<T>(value)
             : new ReturnSignal<T>(value, scheduler);
     }
@@ -152,7 +152,7 @@ public static IObservable<T> Empty<T>(ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
 
-        return scheduler == Sequencer.Immediate ? ImmutableEmptySignal<T>.Instance : new EmptySignal<T>(scheduler);
+        return scheduler.IsImmediate ? ImmutableEmptySignal<T>.Instance : new EmptySignal<T>(scheduler);
     }
 
     /// <summary>Returns a non-terminating observable sequence.</summary>
@@ -189,7 +189,7 @@ public static IObservable<T> Throw<T>(Exception error, ISequencer scheduler)
     {
         ArgumentExceptionHelper.ThrowIfNull(scheduler);
 
-        return scheduler == Sequencer.Immediate
+        return scheduler.IsImmediate
             ? new ImmediateThrowSignal<T>(error)
             : new ThrowSignal<T>(error, scheduler);
     }
@@ -221,7 +221,7 @@ public static IObservable<int> Range(int start, int count, ISequencer scheduler)
             return ImmutableEmptySignal<int>.Instance;
         }
 
-        return scheduler == Sequencer.Immediate || scheduler == Sequencer.CurrentThread
+        return scheduler.IsImmediate || scheduler == Sequencer.CurrentThread
             ? new RangeSignal(start, count)
             : new SequenceSignal(start, count, scheduler);
     }
diff --git a/src/Primitives.Shared/Signals/TaskSignal{T}.cs b/src/Primitives.Shared/Signals/TaskSignal{T}.cs
index b5726514..1f3da471 100644
--- a/src/Primitives.Shared/Signals/TaskSignal{T}.cs
+++ b/src/Primitives.Shared/Signals/TaskSignal{T}.cs
@@ -58,7 +58,7 @@ public void GetOperationCanceled(IObserver<Exception> observer) =>
     /// <returns>A disposable that ends the subscription.</returns>
     public IDisposable Subscribe(IObserver<T> observer)
     {
-        var subscription = ReferenceEquals(_sequencer, Sequencer.Immediate)
+        var subscription = _sequencer.IsImmediate
             ? Source!.Subscribe(observer)
             : new WitnessOnSignal<T>(Source!, _sequencer).Subscribe(observer);
 
diff --git a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
index eda9897e..2fbeaeff 100644
--- a/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
+++ b/src/ReactiveUI.Primitives.Reactive/Concurrency/WasmScheduler.cs
@@ -43,16 +43,19 @@ public sealed class WasmScheduler : LocalScheduler, ISchedulerPeriodic, IDisposa
     /// <summary>Non-zero once <see cref="Dispose"/> has released the drain timer and the ready queue.</summary>
     private int _isDisposed;
 
-    /// <summary>Initializes a new instance of the <see cref="WasmScheduler"/> class.</summary>
-    /// <param name="timeProvider">Timer provider; null selects the system provider.</param>
+    /// <summary>Initializes a new instance of the <see cref="WasmScheduler"/> class that reads time and arms its timers through a <see cref="TimeProvider"/>.</summary>
+    /// <param name="timeProvider">The provider supplying the current time and timers.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="timeProvider"/> is <see langword="null"/>.</exception>
     [System.Diagnostics.CodeAnalysis.SuppressMessage(
         "Correctness",
         "SST2403:Do not let 'this' escape from a constructor",
         Justification =
             "The drain timer is created disarmed, so nothing can call back into it until Schedule arms it after construction.")]
-    internal WasmScheduler(TimeProvider? timeProvider = null)
+    public WasmScheduler(TimeProvider timeProvider)
     {
-        _timeProvider = timeProvider ?? TimeProvider.System;
+        ArgumentExceptionHelper.ThrowIfNull(timeProvider);
+
+        _timeProvider = timeProvider;
         _drainTimer = CreateTimer(
             _timeProvider,
             static state => ((WasmScheduler)state!).RunDrain(),
@@ -69,7 +72,10 @@ internal interface IReadyWorkItem : IDisposable
     }
 
     /// <summary>Gets the shared WebAssembly scheduler.</summary>
-    public static WasmScheduler Default { get; } = new();
+    public static WasmScheduler Default { get; } = new(TimeProvider.System);
+
+    /// <summary>Gets the scheduler's notion of current time.</summary>
+    public override DateTimeOffset Now => _timeProvider.GetUtcNow();
 
     /// <summary>Gets a value indicating whether the scheduler has been disposed.</summary>
     private bool IsDisposed => Volatile.Read(ref _isDisposed) != 0;
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.txt
index 3893e7c0..1e2f8564 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2067,9 +2076,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2376,6 +2394,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.txt
index b53be531..19c13335 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2065,9 +2074,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2374,6 +2392,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.txt
index 5ef2122e..35d93411 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2065,9 +2074,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2374,6 +2392,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.txt
index f3bb6650..82d04082 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2065,9 +2074,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2374,6 +2392,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.txt
index c635e290..b242d7ce 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2065,9 +2074,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2374,6 +2392,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.txt
index 4b7339c3..eb28d219 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.txt
@@ -2001,6 +2001,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2054,9 +2063,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2363,6 +2381,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.txt
index 3893e7c0..1e2f8564 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2067,9 +2076,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2376,6 +2394,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.txt
index b53be531..19c13335 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2065,9 +2074,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2374,6 +2392,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.txt
index 5ef2122e..35d93411 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2065,9 +2074,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2374,6 +2392,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.txt
index f3bb6650..82d04082 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2065,9 +2074,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2374,6 +2392,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.txt
index c635e290..b242d7ce 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.txt
@@ -2002,6 +2002,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2065,9 +2074,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2374,6 +2392,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.txt
index 4b7339c3..eb28d219 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.txt
@@ -2001,6 +2001,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2054,9 +2063,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2363,6 +2381,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.txt
index 47c86d66..153f70da 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.txt
@@ -1967,6 +1967,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2020,9 +2029,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2327,6 +2345,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.txt
index 47c86d66..153f70da 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.txt
@@ -1967,6 +1967,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2020,9 +2029,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2327,6 +2345,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.txt
index 47c86d66..153f70da 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.txt
@@ -1967,6 +1967,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2020,9 +2029,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2327,6 +2345,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.txt
index 47c86d66..153f70da 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.txt
@@ -1967,6 +1967,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2020,9 +2029,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2327,6 +2345,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.txt
index 7773dd1e..3b1f7004 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.txt
@@ -1967,6 +1967,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2020,9 +2029,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2329,6 +2347,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.txt
index 4b7339c3..eb28d219 100644
--- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.txt
@@ -2001,6 +2001,15 @@ namespace ReactiveUI.Primitives.Reactive.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, System.Reactive.Concurrency.IScheduler scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -2054,9 +2063,18 @@ namespace ReactiveUI.Primitives.Reactive.Concurrency
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime) where TAbsolute : System.IComparable<TAbsolute> { }
         public static ReactiveUI.Primitives.Concurrency.ScheduledItem<TAbsolute> Create<TAbsolute, TValue>(System.Reactive.Concurrency.IScheduler scheduler, TValue state, System.Func<System.Reactive.Concurrency.IScheduler, TValue, System.IDisposable> action, TAbsolute dueTime, System.Collections.Generic.IComparer<TAbsolute> comparer) where TAbsolute : System.IComparable<TAbsolute> { }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(System.Reactive.Concurrency.IScheduler? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("WasmScheduler: ReadyCount = {_readyCount}, DrainState = {_drainState}, Disposed = {_isDisposed}")]
     public sealed class WasmScheduler : System.Reactive.Concurrency.LocalScheduler, System.IDisposable, System.Reactive.Concurrency.ISchedulerPeriodic
     {
+        public WasmScheduler(System.TimeProvider timeProvider) { }
+        public override System.DateTimeOffset Now { get; }
         public static ReactiveUI.Primitives.Reactive.Concurrency.WasmScheduler Default { get; }
         public void Dispose() { }
         public override System.IDisposable Schedule<TState>(TState state, System.Func<System.Reactive.Concurrency.IScheduler, TState, System.IDisposable> action) { }
@@ -2363,6 +2381,8 @@ namespace ReactiveUI.Primitives.Reactive.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(System.Reactive.Concurrency.IScheduler scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(System.Reactive.Concurrency.IScheduler scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs b/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
index 7cb29a38..d1a0feca 100644
--- a/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
+++ b/src/ReactiveUI.Primitives/Advanced/DispatchSequencerState.cs
@@ -36,6 +36,9 @@ public record struct DispatchSequencerState
     /// <summary>Schedules delayed work when the platform provides no override.</summary>
     private readonly ISequencer _sharedTimer;
 
+    /// <summary>Clock deciding whether a due timestamp has already passed.</summary>
+    private readonly SequencerClock _clock;
+
     /// <summary>Approximate number of ready items; snapshots a drain batch.</summary>
     private int _readyCount;
 
@@ -77,6 +80,24 @@ internal DispatchSequencerState(
         Action drain,
         Action<IWorkItem, long>? scheduleDelayed,
         ISequencer sharedTimer)
+        : this(owner, post, drain, scheduleDelayed, sharedTimer, SequencerClock.Default)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="DispatchSequencerState"/> struct.</summary>
+    /// <param name="owner">The owning sequencer.</param>
+    /// <param name="post">Posts the cached drain.</param>
+    /// <param name="drain">The cached drain callback.</param>
+    /// <param name="scheduleDelayed">The optional platform delay override.</param>
+    /// <param name="sharedTimer">Schedules work without a platform delay override.</param>
+    /// <param name="clock">The clock that decides whether a due timestamp has already passed.</param>
+    internal DispatchSequencerState(
+        ISequencer owner,
+        Func<Action, bool> post,
+        Action drain,
+        Action<IWorkItem, long>? scheduleDelayed,
+        ISequencer sharedTimer,
+        SequencerClock clock)
     {
         _ready = new();
         _owner = owner;
@@ -84,6 +105,7 @@ internal DispatchSequencerState(
         _drain = drain;
         _scheduleDelayed = scheduleDelayed;
         _sharedTimer = sharedTimer;
+        _clock = clock;
     }
 
     /// <summary>Gets the sequencer's notion of current time.</summary>
@@ -130,7 +152,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
     {
         ArgumentExceptionHelper.ThrowIfNull(item);
 
-        if (dueTimestamp <= Sequencer.Timestamp)
+        if (dueTimestamp <= _clock.GetTimestamp())
         {
             Schedule(item);
             return;
diff --git a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
index 652b2cd8..d77ecac7 100644
--- a/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/CurrentThreadSequencer.cs
@@ -28,11 +28,43 @@ public sealed class CurrentThreadSequencer : ISequencer
     [ThreadStatic]
     private static SequencerQueue<long>? _threadLocalQueue;
 
-    /// <summary>Initializes a new instance of the <see cref="CurrentThreadSequencer"/> class.</summary>
+    /// <summary>The clock of the sequencer whose call started the trampoline running on the current thread.</summary>
+    [ThreadStatic]
+    private static SequencerClock? _runningClock;
+
+    /// <summary>The clock supplying time and blocking waits.</summary>
+    private readonly SequencerClock _clock;
+
+    /// <summary>Reads the monotonic clock.</summary>
+    private readonly Func<long> _timestamp;
+
+    /// <summary>Blocks the scheduling thread for a delay measured by the clock.</summary>
+    private readonly Action<TimeSpan> _wait;
+
+    /// <summary>Initializes a new instance of the <see cref="CurrentThreadSequencer"/> class that reads time and waits through a <see cref="TimeProvider"/>.</summary>
+    /// <param name="timeProvider">The provider supplying the current time, timestamps and timers.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="timeProvider"/> is <see langword="null"/>.</exception>
+    /// <remarks>Work scheduled while another sequencer instance is running on the same thread joins that instance's trampoline and waits on its provider.</remarks>
+    public CurrentThreadSequencer(TimeProvider timeProvider)
+        : this(new SequencerClock(timeProvider))
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="CurrentThreadSequencer"/> class; callers use <see cref="Instance"/>.</summary>
     private CurrentThreadSequencer()
+        : this(SequencerClock.Default)
     {
     }
 
+    /// <summary>Initializes a new instance of the <see cref="CurrentThreadSequencer"/> class.</summary>
+    /// <param name="clock">The clock supplying time and blocking waits.</param>
+    private CurrentThreadSequencer(SequencerClock clock)
+    {
+        _clock = clock;
+        _timestamp = clock.GetTimestamp;
+        _wait = clock.Wait;
+    }
+
     /// <summary>Gets the singleton instance of the current thread scheduler.</summary>
     public static CurrentThreadSequencer Instance => StaticInstance.Value;
 
@@ -41,10 +73,10 @@ private CurrentThreadSequencer()
     public static bool IsScheduleRequired => !_running;
 
     /// <summary>Gets the scheduler's notion of current time.</summary>
-    public DateTimeOffset Now => Sequencer.Now;
+    public DateTimeOffset Now => _clock.GetUtcNow();
 
     /// <summary>Gets the scheduler's monotonic timestamp.</summary>
-    public long Timestamp => Sequencer.Timestamp;
+    public long Timestamp => _clock.GetTimestamp();
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -61,14 +93,14 @@ public IDisposable Schedule(Action action)
 
         if (!_running)
         {
-            SetRunning(true);
+            StartRunning();
             try
             {
                 action();
                 var queue = GetQueue();
                 if (queue is not null)
                 {
-                    Trampoline.Run(queue);
+                    Trampoline.Run(queue, _timestamp, _wait);
                 }
             }
             finally
@@ -108,11 +140,11 @@ public void Schedule(IWorkItem item, long dueTimestamp)
         // Initial work executes before Schedule returns.
         if (!_running)
         {
-            SetRunning(true);
+            StartRunning();
 
             try
             {
-                WaitIfNeeded(Sequencer.TimeUntil(dueTimestamp), Wait);
+                WaitIfNeeded(_clock.TimeUntil(dueTimestamp), _wait);
 
                 if (!Sequencer.IsCancelled(item))
                 {
@@ -132,7 +164,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
             {
                 try
                 {
-                    Trampoline.Run(queue);
+                    Trampoline.Run(queue, _timestamp, _wait);
                 }
                 finally
                 {
@@ -157,7 +189,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
             SetQueue(queue);
         }
 
-        ScheduledItem<long> si = new(dueTimestamp, Comparer<long>.Default, _ =>
+        ScheduledItem<long> si = new(ToRunningTimeline(dueTimestamp), Comparer<long>.Default, _ =>
         {
             if (!Sequencer.IsCancelled(item))
             {
@@ -195,20 +227,27 @@ internal static void WaitIfNeeded(TimeSpan dueTime, Action<TimeSpan> wait)
     /// <param name="running">Value indicating whether work is running.</param>
     private static void SetRunning(bool running) => _running = running;
 
-    /// <summary>Blocks the scheduling thread until delayed work becomes due.</summary>
-    /// <param name="dueTime">The remaining delay.</param>
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void Wait(TimeSpan dueTime) => Thread.Sleep(dueTime);
+    /// <summary>Marks the current thread as running scheduled work on behalf of this sequencer.</summary>
+    private void StartRunning()
+    {
+        _running = true;
+        _runningClock = _clock;
+    }
+
+    /// <summary>Expresses a due timestamp on the clock of the sequencer that started the running trampoline.</summary>
+    /// <param name="dueTimestamp">The absolute due timestamp on this sequencer's clock.</param>
+    /// <returns>The equivalent due timestamp on the running trampoline's clock.</returns>
+    private long ToRunningTimeline(long dueTimestamp)
+    {
+        var runningClock = _runningClock!;
+        return ReferenceEquals(runningClock, _clock)
+            ? dueTimestamp
+            : Sequencer.AddTimestamp(runningClock.GetTimestamp(), _clock.TimeUntil(dueTimestamp));
+    }
 
     /// <summary>Runs queued current-thread work.</summary>
     internal static class Trampoline
     {
-        /// <summary>Runs all work currently in the queue.</summary>
-        /// <param name="queue">Queue to drain.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static void Run(SequencerQueue<long> queue) => Run(queue, static () => Sequencer.Timestamp, Wait);
-
         /// <summary>Drains work using the supplied clock and wait operation.</summary>
         /// <param name="queue">The pending work.</param>
         /// <param name="timestamp">The monotonic clock.</param>
diff --git a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
index 5c6db1eb..85ac7e99 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ImmediateSequencer.cs
@@ -14,19 +14,42 @@ public sealed class ImmediateSequencer : ISequencer
     /// <summary>Singleton holder for the immediate sequencer.</summary>
     private static readonly Lazy<ImmediateSequencer> StaticInstance = new(static () => new());
 
-    /// <summary>Initializes a new instance of the <see cref="ImmediateSequencer"/> class.</summary>
+    /// <summary>The clock supplying time and blocking waits.</summary>
+    private readonly SequencerClock _clock;
+
+    /// <summary>Blocks the scheduling thread for a delay measured by the clock.</summary>
+    private readonly Action<TimeSpan> _wait;
+
+    /// <summary>Initializes a new instance of the <see cref="ImmediateSequencer"/> class that reads time and waits through a <see cref="TimeProvider"/>.</summary>
+    /// <param name="timeProvider">The provider supplying the current time, timestamps and timers.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="timeProvider"/> is <see langword="null"/>.</exception>
+    public ImmediateSequencer(TimeProvider timeProvider)
+        : this(new SequencerClock(timeProvider))
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="ImmediateSequencer"/> class; callers use <see cref="Instance"/>.</summary>
     private ImmediateSequencer()
+        : this(SequencerClock.Default)
     {
     }
 
+    /// <summary>Initializes a new instance of the <see cref="ImmediateSequencer"/> class.</summary>
+    /// <param name="clock">The clock supplying time and blocking waits.</param>
+    private ImmediateSequencer(SequencerClock clock)
+    {
+        _clock = clock;
+        _wait = clock.Wait;
+    }
+
     /// <summary>Gets the singleton instance of the immediate scheduler.</summary>
     public static ImmediateSequencer Instance => StaticInstance.Value;
 
     /// <summary>Gets the scheduler's notion of current time.</summary>
-    public DateTimeOffset Now => Sequencer.Now;
+    public DateTimeOffset Now => _clock.GetUtcNow();
 
     /// <summary>Gets the scheduler's monotonic timestamp.</summary>
-    public long Timestamp => Sequencer.Timestamp;
+    public long Timestamp => _clock.GetTimestamp();
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -68,7 +91,7 @@ public void Schedule(IWorkItem item, long dueTimestamp)
     {
         ArgumentExceptionHelper.ThrowIfNull(item);
 
-        RunScheduled(item, Sequencer.TimeUntil(dueTimestamp), Wait);
+        RunScheduled(item, _clock.TimeUntil(dueTimestamp), _wait);
     }
 
     /// <summary>Waits for a relative delay and executes work that remains active.</summary>
@@ -89,10 +112,4 @@ internal static void RunScheduled(IWorkItem item, TimeSpan dueTime, Action<TimeS
 
         item.Execute();
     }
-
-    /// <summary>Blocks the scheduling thread for the remaining delay.</summary>
-    /// <param name="dueTime">The remaining delay.</param>
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-    private static void Wait(TimeSpan dueTime) => Thread.Sleep(dueTime);
 }
diff --git a/src/ReactiveUI.Primitives/Concurrency/SequencerClock.cs b/src/ReactiveUI.Primitives/Concurrency/SequencerClock.cs
new file mode 100644
index 00000000..f90231c5
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Concurrency/SequencerClock.cs
@@ -0,0 +1,101 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace ReactiveUI.Primitives.Concurrency;
+
+/// <summary>Reads time, blocks and creates timers through a <see cref="TimeProvider"/> while reporting timestamps at <see cref="Stopwatch.Frequency"/>.</summary>
+internal sealed class SequencerClock
+{
+    /// <summary>Timer used by a blocking wait to release its waiter.</summary>
+    private static readonly TimerCallback ReleaseWaiter = static state => ((ManualResetEventSlim)state!).Set();
+
+    /// <summary>The provider supplying the current time, timestamps and timers.</summary>
+    private readonly TimeProvider _provider;
+
+    /// <summary>The provider's timestamp ticks per second.</summary>
+    private readonly long _frequency;
+
+    /// <summary>The provider timestamp treated as zero when rescaling; zero when the provider already counts at <see cref="Stopwatch.Frequency"/>.</summary>
+    private readonly long _origin;
+
+    /// <summary>Whether the provider is <see cref="TimeProvider.System"/>, which waits on the calling thread.</summary>
+    private readonly bool _isSystem;
+
+    /// <summary>Initializes a new instance of the <see cref="SequencerClock"/> class.</summary>
+    /// <param name="timeProvider">The provider supplying time, timestamps and timers.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="timeProvider"/> is <see langword="null"/>.</exception>
+    internal SequencerClock(TimeProvider timeProvider)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(timeProvider);
+
+        _provider = timeProvider;
+        _frequency = timeProvider.TimestampFrequency;
+        _origin = _frequency == Stopwatch.Frequency ? 0 : timeProvider.GetTimestamp();
+        _isSystem = ReferenceEquals(timeProvider, TimeProvider.System);
+    }
+
+    /// <summary>Gets the clock backed by <see cref="TimeProvider.System"/>.</summary>
+    internal static SequencerClock Default { get; } = new(TimeProvider.System);
+
+    /// <summary>Gets the current UTC time.</summary>
+    /// <returns>The provider's current UTC time.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal DateTimeOffset GetUtcNow() => _provider.GetUtcNow();
+
+    /// <summary>Gets the monotonic timestamp in <see cref="Stopwatch.Frequency"/> ticks per second.</summary>
+    /// <returns>The provider's timestamp rescaled to <see cref="Stopwatch.Frequency"/> units.</returns>
+    internal long GetTimestamp()
+    {
+        var timestamp = _provider.GetTimestamp();
+        return _frequency == Stopwatch.Frequency ? timestamp : Rescale(timestamp - _origin, _frequency);
+    }
+
+    /// <summary>Calculates the remaining time until a monotonic timestamp.</summary>
+    /// <param name="dueTimestamp">Absolute timestamp in <see cref="Stopwatch.Frequency"/> units.</param>
+    /// <returns>The nonnegative remaining time.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal TimeSpan TimeUntil(long dueTimestamp) => Sequencer.TimeUntil(dueTimestamp, GetTimestamp());
+
+    /// <summary>Blocks the calling thread for a delay measured by the provider.</summary>
+    /// <param name="dueTime">The delay.</param>
+    internal void Wait(TimeSpan dueTime)
+    {
+        if (_isSystem)
+        {
+            SleepOnSystemClock(dueTime);
+            return;
+        }
+
+        using ManualResetEventSlim released = new(false);
+        using var timer = _provider.CreateTimer(ReleaseWaiter, released, dueTime, Timeout.InfiniteTimeSpan);
+        released.Wait();
+    }
+
+    /// <summary>Creates a timer through the provider.</summary>
+    /// <param name="callback">The callback invoked when the timer fires.</param>
+    /// <param name="state">The callback state.</param>
+    /// <param name="dueTime">The delay before the first firing.</param>
+    /// <param name="period">The interval between later firings.</param>
+    /// <returns>The timer.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period) =>
+        _provider.CreateTimer(callback, state, dueTime, period);
+
+    /// <summary>Converts a timestamp delta counted at <paramref name="frequency"/> ticks per second to <see cref="Stopwatch.Frequency"/> units.</summary>
+    /// <param name="delta">The timestamp delta.</param>
+    /// <param name="frequency">Ticks per second of <paramref name="delta"/>.</param>
+    /// <returns>The delta in <see cref="Stopwatch.Frequency"/> units.</returns>
+    private static long Rescale(long delta, long frequency) =>
+        (delta / frequency * Stopwatch.Frequency) + (long)((decimal)(delta % frequency) * Stopwatch.Frequency / frequency);
+
+    /// <summary>Blocks the calling thread on the system clock.</summary>
+    /// <param name="dueTime">The delay.</param>
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void SleepOnSystemClock(TimeSpan dueTime) => Thread.Sleep(dueTime);
+}
diff --git a/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
index 91adaf2a..f7ca5886 100644
--- a/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/SynchronizationContextSequencer.cs
@@ -20,6 +20,15 @@ public SynchronizationContextSequencer(SynchronizationContext context)
     {
     }
 
+    /// <summary>Initializes a new instance of the <see cref="SynchronizationContextSequencer"/> class that reads time and arms its delay timer through a <see cref="TimeProvider"/>.</summary>
+    /// <param name="context">The synchronization context used to schedule work.</param>
+    /// <param name="timeProvider">The provider supplying the current time, timestamps and the delay timer.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="context"/> or <paramref name="timeProvider"/> is <see langword="null"/>.</exception>
+    public SynchronizationContextSequencer(SynchronizationContext context, TimeProvider timeProvider)
+        : this(context, new ThreadPoolSequencer(timeProvider))
+    {
+    }
+
     /// <summary>Initializes a new instance of the <see cref="SynchronizationContextSequencer"/> class.</summary>
     /// <param name="context">The context receiving ready work.</param>
     /// <param name="delaySequencer">The scheduler delivering delayed callbacks.</param>
diff --git a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
index faf6e216..14ae2aca 100644
--- a/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/TaskPoolSequencer.cs
@@ -25,6 +25,15 @@ public TaskPoolSequencer(TaskFactory taskFactory)
     {
     }
 
+    /// <summary>Initializes a new instance of the <see cref="TaskPoolSequencer"/> class that reads time and arms its delay timer through a <see cref="TimeProvider"/>.</summary>
+    /// <param name="taskFactory">The task factory.</param>
+    /// <param name="timeProvider">The provider supplying the current time, timestamps and the delay timer.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="taskFactory"/> or <paramref name="timeProvider"/> is <see langword="null"/>.</exception>
+    public TaskPoolSequencer(TaskFactory taskFactory, TimeProvider timeProvider)
+        : this(taskFactory, new ThreadPoolSequencer(timeProvider))
+    {
+    }
+
     /// <summary>Initializes a new instance of the <see cref="TaskPoolSequencer"/> class.</summary>
     /// <param name="taskFactory">The factory dispatching ready work.</param>
     /// <param name="delaySequencer">The scheduler delivering delayed callbacks.</param>
diff --git a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
index a543a2c3..843647d3 100644
--- a/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/ThreadPoolSequencer.cs
@@ -4,7 +4,6 @@
 
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
-using Timer = System.Threading.Timer;
 
 namespace ReactiveUI.Primitives.Concurrency;
 
@@ -25,8 +24,8 @@ public sealed class ThreadPoolSequencer : ISequencer, IDisposable
     /// <summary>Pending delayed work, ordered by monotonic due timestamp.</summary>
     private readonly PriorityQueue<TimedWorkItem> _queue = new();
 
-    /// <summary>Single timer owned by the sequencer for all delayed work.</summary>
-    private readonly Timer? _timer;
+    /// <summary>The clock supplying time and the delay timer.</summary>
+    private readonly SequencerClock _clock;
 
     /// <summary>Reads the monotonic clock used by the delay queue.</summary>
     private readonly Func<long> _timestamp;
@@ -37,21 +36,39 @@ public sealed class ThreadPoolSequencer : ISequencer, IDisposable
     /// <summary>Updates the delay timer.</summary>
     private readonly Action<TimeSpan> _changeTimer;
 
+    /// <summary>Single timer owned by the sequencer for all delayed work, created when the first delayed item arrives.</summary>
+    private ITimer? _timer;
+
     /// <summary>Non-zero after disposal; writes hold the gate, and immediate scheduling reads without it.</summary>
     private int _isDisposed;
 
+    /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class that reads time and arms its delay timer through a <see cref="TimeProvider"/>.</summary>
+    /// <param name="timeProvider">The provider supplying the current time, timestamps and the delay timer.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="timeProvider"/> is <see langword="null"/>.</exception>
+    public ThreadPoolSequencer(TimeProvider timeProvider)
+        : this(new SequencerClock(timeProvider), QueueOnThreadPool)
+    {
+    }
+
     /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class; callers use <see cref="Instance"/>.</summary>
-    [System.Diagnostics.CodeAnalysis.SuppressMessage(
-        "Correctness",
-        "SST2403:Do not let 'this' escape from a constructor",
-        Justification =
-            "The timer is created disarmed, so nothing can call back into it until Schedule arms it after construction.")]
     internal ThreadPoolSequencer()
+        : this(SequencerClock.Default, QueueOnThreadPool)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class.</summary>
+    /// <param name="timeProvider">The provider supplying the current time, timestamps and the delay timer.</param>
+    /// <param name="queueImmediate">Queues an immediate callback.</param>
+    internal ThreadPoolSequencer(TimeProvider timeProvider, Action<WaitCallback, object> queueImmediate)
+        : this(new SequencerClock(timeProvider), queueImmediate)
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class that shares an existing clock.</summary>
+    /// <param name="clock">The clock supplying time and the delay timer.</param>
+    internal ThreadPoolSequencer(SequencerClock clock)
+        : this(clock, QueueOnThreadPool)
     {
-        _timer = CreateTimer(this);
-        _timestamp = static () => Sequencer.Timestamp;
-        _queueImmediate = QueueOnThreadPool;
-        _changeTimer = ChangeTimer;
     }
 
     /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class.</summary>
@@ -63,13 +80,25 @@ internal ThreadPoolSequencer(
         Action<WaitCallback, object> queueImmediate,
         Action<TimeSpan> changeTimer)
     {
+        _clock = SequencerClock.Default;
         _timestamp = timestamp;
         _queueImmediate = queueImmediate;
         _changeTimer = changeTimer;
     }
 
+    /// <summary>Initializes a new instance of the <see cref="ThreadPoolSequencer"/> class.</summary>
+    /// <param name="clock">The clock supplying time and the delay timer.</param>
+    /// <param name="queueImmediate">Queues an immediate callback.</param>
+    internal ThreadPoolSequencer(SequencerClock clock, Action<WaitCallback, object> queueImmediate)
+    {
+        _clock = clock;
+        _timestamp = clock.GetTimestamp;
+        _queueImmediate = queueImmediate;
+        _changeTimer = ChangeTimer;
+    }
+
     /// <summary>Gets the scheduler's notion of current time.</summary>
-    public DateTimeOffset Now => Sequencer.Now;
+    public DateTimeOffset Now => _clock.GetUtcNow();
 
     /// <summary>Gets the scheduler's monotonic timestamp.</summary>
     public long Timestamp => _timestamp();
@@ -161,13 +190,6 @@ internal void RunDue()
     private static void QueueOnThreadPool(WaitCallback callback, object state) =>
         ThreadPool.UnsafeQueueUserWorkItem(callback, state);
 
-    /// <summary>Creates a disarmed timer that drains due work.</summary>
-    /// <param name="owner">The sequencer receiving timer callbacks.</param>
-    /// <returns>The disarmed timer.</returns>
-    [ExcludeFromCodeCoverage]
-    private static Timer CreateTimer(ThreadPoolSequencer owner) =>
-        new(static state => ((ThreadPoolSequencer)state!).RunDue(), owner, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
-
     /// <summary>Executes the work item unless it has been cancelled.</summary>
     /// <param name="item">Work item to execute.</param>
     private static void ExecuteQueued(IWorkItem item)
@@ -242,11 +264,17 @@ private void ArmTimerNoLock()
         _changeTimer(Sequencer.TimeUntil(_queue.Peek().DueTimestamp, Timestamp));
     }
 
-    /// <summary>Arms the runtime delay timer.</summary>
+    /// <summary>Arms the delay timer, creating it disarmed on first use.</summary>
     /// <param name="dueTime">The remaining delay.</param>
-    [ExcludeFromCodeCoverage]
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void ChangeTimer(TimeSpan dueTime) => _timer!.Change(dueTime, Timeout.InfiniteTimeSpan);
+    private void ChangeTimer(TimeSpan dueTime)
+    {
+        _timer ??= _clock.CreateTimer(
+            static state => ((ThreadPoolSequencer)state!).RunDue(),
+            this,
+            Timeout.InfiniteTimeSpan,
+            Timeout.InfiniteTimeSpan);
+        _ = _timer.Change(dueTime, Timeout.InfiniteTimeSpan);
+    }
 
     /// <summary>Delayed thread-pool work item queued in the sequencer heap.</summary>
     internal readonly struct TimedWorkItem : IComparable<TimedWorkItem>, IEquatable<TimedWorkItem>
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
index 0addf589..080e7a53 100644
--- a/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualClock.cs
@@ -2,13 +2,19 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace ReactiveUI.Primitives.Concurrency;
 
-/// <summary>Deterministic virtual scheduler backed by <see cref="DateTimeOffset"/> and <see cref="TimeSpan"/>.</summary>
+/// <summary>Deterministic virtual scheduler backed by <see cref="DateTimeOffset"/> and <see cref="TimeSpan"/> that also serves as a <see cref="TimeProvider"/>.</summary>
+/// <remarks>
+/// As a <see cref="TimeProvider"/> the clock reports <see cref="Now"/> as UTC time and counts timestamps in ticks of <see cref="Now"/>.
+/// Its timers fire when <see cref="AdvanceBy"/>, <see cref="AdvanceTo"/> or <see cref="Start"/> reaches them.
+/// </remarks>
 [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-public sealed class VirtualClock : ISequencer, IServiceProvider, IStopwatchProvider
+public sealed class VirtualClock : TimeProvider, ISequencer, IServiceProvider, IStopwatchProvider
 {
     /// <summary>Adds a normalized relative time to an absolute time.</summary>
     private static readonly Func<DateTimeOffset, TimeSpan, DateTimeOffset> Adder = static (absolute, relative) =>
@@ -46,9 +52,12 @@ public VirtualClock(DateTimeOffset initialClock) =>
     /// <inheritdoc/>
     public long Timestamp => _state.Timestamp;
 
+    /// <summary>Gets the number of timestamp ticks per second, which is <see cref="TimeSpan.TicksPerSecond"/>.</summary>
+    public override long TimestampFrequency => TimeSpan.TicksPerSecond;
+
     /// <summary>Gets the debugger display text.</summary>
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+    [ExcludeFromCodeCoverage]
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => ToString() ?? string.Empty;
 
     /// <summary>Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan.</summary>
@@ -108,7 +117,7 @@ public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<ISequen
     /// <param name="action">Action to be executed.</param>
     /// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+    [SuppressMessage(
         "Design",
         "SST2318:Members should not have identical bodies",
         Justification =
@@ -147,6 +156,25 @@ public IDisposable ScheduleRelative<TState>(
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public IStopwatch StartStopwatch() => new VirtualTimeStopwatch(() => Now, Now);
 
+    /// <summary>Gets the virtual time as a UTC time.</summary>
+    /// <returns><see cref="Now"/>.</returns>
+    public override DateTimeOffset GetUtcNow() => Now;
+
+    /// <summary>Gets the virtual time as a timestamp counted at <see cref="TimestampFrequency"/>.</summary>
+    /// <returns>The ticks of <see cref="Now"/>.</returns>
+    public override long GetTimestamp() => Timestamp;
+
+    /// <summary>Creates a timer whose firings run when the virtual clock advances to them.</summary>
+    /// <param name="callback">The callback invoked at each firing.</param>
+    /// <param name="state">The state passed to <paramref name="callback"/>.</param>
+    /// <param name="dueTime">The virtual delay before the first firing, or <see cref="Timeout.InfiniteTimeSpan"/> to leave the timer stopped.</param>
+    /// <param name="period">The virtual interval between later firings, or <see cref="Timeout.InfiniteTimeSpan"/> or <see cref="TimeSpan.Zero"/> for a single firing.</param>
+    /// <returns>The timer.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="callback"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="dueTime"/> or <paramref name="period"/> is negative and not <see cref="Timeout.InfiniteTimeSpan"/>.</exception>
+    public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period) =>
+        VirtualClockTimer.Start(this, callback, state, dueTime, period);
+
     /// <inheritdoc/>
     object? IServiceProvider.GetService(Type serviceType) =>
         serviceType == typeof(IStopwatchProvider) ? this : null;
diff --git a/src/ReactiveUI.Primitives/Concurrency/VirtualClockTimer.cs b/src/ReactiveUI.Primitives/Concurrency/VirtualClockTimer.cs
new file mode 100644
index 00000000..2d748474
--- /dev/null
+++ b/src/ReactiveUI.Primitives/Concurrency/VirtualClockTimer.cs
@@ -0,0 +1,136 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Concurrency;
+
+/// <summary>A timer whose firings are queued on a <see cref="VirtualClock"/> and run when the clock advances.</summary>
+internal sealed class VirtualClockTimer : ITimer
+{
+    /// <summary>Serializes changes to the pending firing.</summary>
+    private readonly Lock _gate = new();
+
+    /// <summary>The clock whose virtual time schedules the firings.</summary>
+    private readonly VirtualClock _clock;
+
+    /// <summary>The callback invoked at each firing.</summary>
+    private readonly TimerCallback _callback;
+
+    /// <summary>The state passed to the callback.</summary>
+    private readonly object? _state;
+
+    /// <summary>The queued firing that has not run yet, or <see langword="null"/> when none is queued.</summary>
+    private IDisposable? _pending;
+
+    /// <summary>The interval between firings after the first, or <see cref="TimeSpan.Zero"/> for a one-shot timer.</summary>
+    private TimeSpan _period;
+
+    /// <summary>Whether the timer has been disposed.</summary>
+    private bool _isDisposed;
+
+    /// <summary>Initializes a new instance of the <see cref="VirtualClockTimer"/> class.</summary>
+    /// <param name="clock">The clock whose virtual time schedules the firings.</param>
+    /// <param name="callback">The callback invoked at each firing.</param>
+    /// <param name="state">The state passed to the callback.</param>
+    private VirtualClockTimer(VirtualClock clock, TimerCallback callback, object? state)
+    {
+        _clock = clock;
+        _callback = callback;
+        _state = state;
+    }
+
+    /// <inheritdoc/>
+    public bool Change(TimeSpan dueTime, TimeSpan period)
+    {
+        ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(dueTime, Timeout.InfiniteTimeSpan);
+        ArgumentOutOfRangeExceptionHelper.ThrowIfLessThan(period, Timeout.InfiniteTimeSpan);
+
+        IDisposable? previous;
+        lock (_gate)
+        {
+            if (_isDisposed)
+            {
+                return false;
+            }
+
+            previous = _pending;
+            _period = period > TimeSpan.Zero ? period : TimeSpan.Zero;
+            _pending = dueTime == Timeout.InfiniteTimeSpan ? null : Queue(dueTime);
+        }
+
+        previous?.Dispose();
+        return true;
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        IDisposable? previous;
+        lock (_gate)
+        {
+            _isDisposed = true;
+            previous = _pending;
+            _pending = null;
+        }
+
+        previous?.Dispose();
+    }
+
+    /// <inheritdoc/>
+    public ValueTask DisposeAsync()
+    {
+        Dispose();
+        return default;
+    }
+
+    /// <summary>Creates a timer and queues its first firing.</summary>
+    /// <param name="clock">The clock whose virtual time schedules the firings.</param>
+    /// <param name="callback">The callback invoked at each firing.</param>
+    /// <param name="state">The state passed to the callback.</param>
+    /// <param name="dueTime">The delay before the first firing, or <see cref="Timeout.InfiniteTimeSpan"/> to leave the timer stopped.</param>
+    /// <param name="period">The interval between later firings, or <see cref="Timeout.InfiniteTimeSpan"/> or <see cref="TimeSpan.Zero"/> for a single firing.</param>
+    /// <returns>The timer.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="callback"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="dueTime"/> or <paramref name="period"/> is negative and not <see cref="Timeout.InfiniteTimeSpan"/>.</exception>
+    internal static VirtualClockTimer Start(
+        VirtualClock clock,
+        TimerCallback callback,
+        object? state,
+        TimeSpan dueTime,
+        TimeSpan period)
+    {
+        ArgumentExceptionHelper.ThrowIfNull(callback);
+
+        VirtualClockTimer timer = new(clock, callback, state);
+        _ = timer.Change(dueTime, period);
+        return timer;
+    }
+
+    /// <summary>Queues the next periodic firing, then invokes the callback unless the timer is disposed.</summary>
+    /// <returns>An empty disposable; the queued firing needs no further cancellation.</returns>
+    internal EmptyDisposable Fire()
+    {
+        lock (_gate)
+        {
+            if (_isDisposed)
+            {
+                return EmptyDisposable.Instance;
+            }
+
+            _pending = _period > TimeSpan.Zero ? Queue(_period) : null;
+        }
+
+        _callback(_state);
+        return EmptyDisposable.Instance;
+    }
+
+    /// <summary>Queues a firing on the virtual clock.</summary>
+    /// <param name="dueTime">The virtual delay before the firing.</param>
+    /// <returns>The handle that cancels the queued firing.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private IDisposable Queue(TimeSpan dueTime) =>
+        _clock.Schedule(this, dueTime, static (_, timer) => timer.Fire());
+}
diff --git a/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs b/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
index ad675efd..53bde083 100644
--- a/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
+++ b/src/ReactiveUI.Primitives/Concurrency/WasmSequencer.cs
@@ -4,7 +4,6 @@
 
 using System.Runtime.CompilerServices;
 using ReactiveUI.Primitives.Advanced;
-using Timer = System.Threading.Timer;
 
 namespace ReactiveUI.Primitives.Concurrency;
 
@@ -17,8 +16,8 @@ public sealed class WasmSequencer : ISequencer, IDisposable
     /// <summary>Serializes timer arming and disposal.</summary>
     private readonly Lock _gate = new();
 
-    /// <summary>One-shot timer used to yield a drain to the event loop.</summary>
-    private readonly Timer? _timer;
+    /// <summary>The clock supplying time and the drain timer.</summary>
+    private readonly SequencerClock _clock;
 
     /// <summary>Posts a drain to the event loop.</summary>
     private readonly Func<Action, bool> _postDrain;
@@ -26,24 +25,27 @@ public sealed class WasmSequencer : ISequencer, IDisposable
     /// <summary>Schedules the delayed marshal callback.</summary>
     private readonly Action<IWorkItem, long> _scheduleDelayed;
 
+    /// <summary>One-shot timer used to yield a drain to the event loop, created when the first drain is posted.</summary>
+    private ITimer? _timer;
+
     /// <summary>Coalescing dispatch engine.</summary>
     private DispatchSequencerState _state;
 
     /// <summary>Non-zero after disposal releases the timer and queue; timer access is serialized by the gate.</summary>
     private int _isDisposed;
 
+    /// <summary>Initializes a new instance of the <see cref="WasmSequencer"/> class that reads time and arms its timers through a <see cref="TimeProvider"/>.</summary>
+    /// <param name="timeProvider">The provider supplying the current time, timestamps and timers.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="timeProvider"/> is <see langword="null"/>.</exception>
+    public WasmSequencer(TimeProvider timeProvider)
+        : this(new SequencerClock(timeProvider))
+    {
+    }
+
     /// <summary>Initializes a new instance of the <see cref="WasmSequencer"/> class.</summary>
-    [System.Diagnostics.CodeAnalysis.SuppressMessage(
-        "Correctness",
-        "SST2403:Do not let 'this' escape from a constructor",
-        Justification =
-            "The timer is created disarmed, and _state is a struct held inline in this object, so neither reference escapes.")]
     internal WasmSequencer()
+        : this(SequencerClock.Default, ThreadPoolSequencer.Instance)
     {
-        _timer = CreateTimer(this);
-        _postDrain = ArmDrainTimer;
-        _scheduleDelayed = ThreadPoolSequencer.Instance.Schedule;
-        _state = new(this, Post, RunDrain, ScheduleDelayed);
     }
 
     /// <summary>Initializes a new instance of the <see cref="WasmSequencer"/> class.</summary>
@@ -51,19 +53,38 @@ internal WasmSequencer()
     /// <param name="scheduleDelayed">Schedules the delayed marshal callback.</param>
     internal WasmSequencer(Func<Action, bool> postDrain, Action<IWorkItem, long> scheduleDelayed)
     {
+        _clock = SequencerClock.Default;
         _postDrain = postDrain;
         _scheduleDelayed = scheduleDelayed;
         _state = new(this, Post, RunDrain, ScheduleDelayed);
     }
 
+    /// <summary>Initializes a new instance of the <see cref="WasmSequencer"/> class whose delay queue shares its clock.</summary>
+    /// <param name="clock">The clock supplying time and timers.</param>
+    private WasmSequencer(SequencerClock clock)
+        : this(clock, new ThreadPoolSequencer(clock))
+    {
+    }
+
+    /// <summary>Initializes a new instance of the <see cref="WasmSequencer"/> class.</summary>
+    /// <param name="clock">The clock supplying time and the drain timer.</param>
+    /// <param name="delaySequencer">The sequencer whose timestamps use <paramref name="clock"/> and that delivers delayed callbacks.</param>
+    private WasmSequencer(SequencerClock clock, ISequencer delaySequencer)
+    {
+        _clock = clock;
+        _postDrain = ArmDrainTimer;
+        _scheduleDelayed = delaySequencer.Schedule;
+        _state = new(this, Post, RunDrain, ScheduleDelayed, delaySequencer, clock);
+    }
+
     /// <summary>Gets the shared WebAssembly sequencer.</summary>
     public static WasmSequencer Default { get; } = new();
 
     /// <inheritdoc/>
-    public DateTimeOffset Now => DispatchSequencerState.Now;
+    public DateTimeOffset Now => _clock.GetUtcNow();
 
     /// <inheritdoc/>
-    public long Timestamp => DispatchSequencerState.Timestamp;
+    public long Timestamp => _clock.GetTimestamp();
 
     /// <summary>Gets the debugger display text.</summary>
     [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
@@ -118,13 +139,6 @@ internal void ScheduleReady(IWorkItem item)
         ReleaseQueuedIfDisposed();
     }
 
-    /// <summary>Creates a disarmed timer that drains ready work.</summary>
-    /// <param name="owner">The sequencer receiving timer callbacks.</param>
-    /// <returns>The disarmed timer.</returns>
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    private static Timer CreateTimer(WasmSequencer owner) =>
-        new(static state => ((WasmSequencer)state!).RunDrain(), owner, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
-
     /// <summary>Arms the drain timer to fire on the next event-loop turn.</summary>
     /// <param name="drain">The callback to post.</param>
     /// <returns><see langword="true"/> when the timer accepted the change.</returns>
@@ -143,12 +157,18 @@ private bool Post(Action drain)
     private void ScheduleDelayed(IWorkItem item, long dueTimestamp) =>
         _scheduleDelayed(new DelayedWorkItem(this, item), dueTimestamp);
 
-    /// <summary>Arms the runtime drain timer.</summary>
+    /// <summary>Arms the drain timer, creating it disarmed on first use.</summary>
     /// <param name="drain">The cached callback carried by the timer.</param>
     /// <returns>Whether the timer accepted the callback.</returns>
-    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private bool ArmDrainTimer(Action drain) => _timer!.Change(TimeSpan.Zero, Timeout.InfiniteTimeSpan);
+    private bool ArmDrainTimer(Action drain)
+    {
+        _timer ??= _clock.CreateTimer(
+            static state => ((WasmSequencer)state!).RunDrain(),
+            this,
+            Timeout.InfiniteTimeSpan,
+            Timeout.InfiniteTimeSpan);
+        return _timer.Change(TimeSpan.Zero, Timeout.InfiniteTimeSpan);
+    }
 
     /// <summary>Forwards the cached drain callback to the engine.</summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.txt
index 4d056576..fbc41d3c 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1740,6 +1750,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1777,10 +1788,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1792,6 +1811,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1803,6 +1823,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1811,7 +1832,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1819,10 +1840,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1899,6 +1924,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2519,6 +2545,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.txt
index 8dcd9fb8..82235149 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1726,6 +1736,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1775,10 +1786,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1790,6 +1809,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1801,6 +1821,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1809,7 +1830,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1817,10 +1838,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1897,6 +1922,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2517,6 +2543,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.txt
index 807ac2a0..99149615 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1726,6 +1736,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1775,10 +1786,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1790,6 +1809,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1801,6 +1821,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1809,7 +1830,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1817,10 +1838,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1897,6 +1922,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2517,6 +2543,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.txt
index 1bcf9c47..f69580a3 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1726,6 +1736,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1775,10 +1786,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1790,6 +1809,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1801,6 +1821,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1809,7 +1830,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1817,10 +1838,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1897,6 +1922,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2517,6 +2543,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.txt
index cb50ee36..61d2d1da 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1726,6 +1736,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1775,10 +1786,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1790,6 +1809,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1801,6 +1821,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1809,7 +1830,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1817,10 +1838,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1897,6 +1922,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2517,6 +2543,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.txt
index 4912d27c..c99a42df 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.txt
@@ -1685,6 +1685,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1706,6 +1715,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1725,6 +1735,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1762,10 +1773,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1777,6 +1796,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1788,6 +1808,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1796,7 +1817,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1804,10 +1825,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1884,6 +1909,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2504,6 +2530,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.txt
index 4d056576..fbc41d3c 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1740,6 +1750,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1777,10 +1788,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1792,6 +1811,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1803,6 +1823,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1811,7 +1832,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1819,10 +1840,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1899,6 +1924,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2519,6 +2545,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.txt
index 8dcd9fb8..82235149 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1726,6 +1736,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1775,10 +1786,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1790,6 +1809,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1801,6 +1821,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1809,7 +1830,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1817,10 +1838,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1897,6 +1922,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2517,6 +2543,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.txt
index 807ac2a0..99149615 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1726,6 +1736,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1775,10 +1786,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1790,6 +1809,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1801,6 +1821,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1809,7 +1830,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1817,10 +1838,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1897,6 +1922,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2517,6 +2543,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.txt
index 1bcf9c47..f69580a3 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1726,6 +1736,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1775,10 +1786,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1790,6 +1809,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1801,6 +1821,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1809,7 +1830,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1817,10 +1838,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1897,6 +1922,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2517,6 +2543,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.txt
index cb50ee36..61d2d1da 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.txt
@@ -1686,6 +1686,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1707,6 +1716,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1726,6 +1736,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1775,10 +1786,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1790,6 +1809,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1801,6 +1821,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1809,7 +1830,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1817,10 +1838,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1897,6 +1922,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2517,6 +2543,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.txt
index 4912d27c..c99a42df 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.txt
@@ -1685,6 +1685,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1706,6 +1715,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1725,6 +1735,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1762,10 +1773,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1777,6 +1796,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1788,6 +1808,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1796,7 +1817,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1804,10 +1825,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1884,6 +1909,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2504,6 +2530,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.txt
index d1d5757a..22390c8a 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.txt
@@ -1651,6 +1651,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1672,6 +1681,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1691,6 +1701,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1728,10 +1739,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1743,6 +1762,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1754,6 +1774,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1762,7 +1783,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1770,10 +1791,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1850,6 +1875,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2468,6 +2494,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.txt
index d1d5757a..22390c8a 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.txt
@@ -1651,6 +1651,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1672,6 +1681,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1691,6 +1701,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1728,10 +1739,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1743,6 +1762,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1754,6 +1774,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1762,7 +1783,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1770,10 +1791,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1850,6 +1875,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2468,6 +2494,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.txt
index d1d5757a..22390c8a 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.txt
@@ -1651,6 +1651,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1672,6 +1681,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1691,6 +1701,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1728,10 +1739,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1743,6 +1762,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1754,6 +1774,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1762,7 +1783,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1770,10 +1791,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1850,6 +1875,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2468,6 +2494,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.txt
index d1d5757a..22390c8a 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.txt
@@ -1651,6 +1651,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1672,6 +1681,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1691,6 +1701,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1728,10 +1739,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1743,6 +1762,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1754,6 +1774,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1762,7 +1783,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1770,10 +1791,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1850,6 +1875,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2468,6 +2494,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.txt
index 2233e26d..e1f12461 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.txt
@@ -1651,6 +1651,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1672,6 +1681,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1691,6 +1701,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1728,10 +1739,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1743,6 +1762,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1754,6 +1774,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1762,7 +1783,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1770,10 +1791,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1850,6 +1875,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2470,6 +2496,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.txt b/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.txt
index 4912d27c..c99a42df 100644
--- a/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.txt
+++ b/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.txt
@@ -1685,6 +1685,15 @@ namespace ReactiveUI.Primitives.Advanced
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void SetSubscription(System.IDisposable subscription) { }
     }
+    [System.Diagnostics.DebuggerDisplay("WitnessLatestOnSignal<{typeof(T).Name,nq}>")]
+    public sealed class WitnessLatestOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
+    {
+        public WitnessLatestOnSignal(System.IObservable<T> source, ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public bool IsRequiredSubscribeOnCurrentThread() { }
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+        public System.IDisposable Subscribe(System.IObserver<T> observer) { }
+    }
     [System.Diagnostics.DebuggerDisplay("WitnessOnSignal<{typeof(T).Name,nq}>")]
     public sealed class WitnessOnSignal<T> : ReactiveUI.Primitives.Advanced.IRequireCurrentThread<T>
     {
@@ -1706,6 +1715,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class CurrentThreadSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public CurrentThreadSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.CurrentThreadSequencer Instance { get; }
@@ -1725,6 +1735,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ImmediateSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
+        public ImmediateSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.ImmediateSequencer Instance { get; }
@@ -1762,10 +1773,18 @@ namespace ReactiveUI.Primitives.Concurrency
             public System.IDisposable ScheduleAction<TState>(TState state, System.Action<TState> action) { }
         }
     }
+    public static class SequencerImmediacyExtensions
+    {
+        extension(ReactiveUI.Primitives.Concurrency.ISequencer? sequencer)
+        {
+            public bool IsImmediate { get; }
+        }
+    }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class SynchronizationContextSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public SynchronizationContextSequencer(System.Threading.SynchronizationContext context) { }
+        public SynchronizationContextSequencer(System.Threading.SynchronizationContext context, System.TimeProvider timeProvider) { }
         public System.Threading.SynchronizationContext Context { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1777,6 +1796,7 @@ namespace ReactiveUI.Primitives.Concurrency
     public sealed class TaskPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer
     {
         public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory) { }
+        public TaskPoolSequencer(System.Threading.Tasks.TaskFactory taskFactory, System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public System.Action<System.Exception>? UnhandledExceptionHandler { get; set; }
@@ -1788,6 +1808,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class ThreadPoolSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public ThreadPoolSequencer(System.TimeProvider timeProvider) { }
         public static readonly ReactiveUI.Primitives.Concurrency.ThreadPoolSequencer Instance;
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
@@ -1796,7 +1817,7 @@ namespace ReactiveUI.Primitives.Concurrency
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item, long dueTimestamp) { }
     }
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
-    public sealed class VirtualClock : ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
+    public sealed class VirtualClock : System.TimeProvider, ReactiveUI.Primitives.Concurrency.ISequencer, ReactiveUI.Primitives.Concurrency.IStopwatchProvider, System.IServiceProvider
     {
         public VirtualClock() { }
         public VirtualClock(System.DateTimeOffset initialClock) { }
@@ -1804,10 +1825,14 @@ namespace ReactiveUI.Primitives.Concurrency
         public bool IsEnabled { get; }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
+        public override long TimestampFrequency { get; }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceBy(System.TimeSpan time) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void AdvanceTo(System.DateTimeOffset time) { }
+        public override System.Threading.ITimer CreateTimer(System.Threading.TimerCallback callback, object? state, System.TimeSpan dueTime, System.TimeSpan period) { }
+        public override long GetTimestamp() { }
+        public override System.DateTimeOffset GetUtcNow() { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public void Schedule(ReactiveUI.Primitives.Concurrency.IWorkItem item) { }
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -1884,6 +1909,7 @@ namespace ReactiveUI.Primitives.Concurrency
     [System.Diagnostics.DebuggerDisplay("{DebuggerDisplay,nq}")]
     public sealed class WasmSequencer : ReactiveUI.Primitives.Concurrency.ISequencer, System.IDisposable
     {
+        public WasmSequencer(System.TimeProvider timeProvider) { }
         public System.DateTimeOffset Now { get; }
         public long Timestamp { get; }
         public static ReactiveUI.Primitives.Concurrency.WasmSequencer Default { get; }
@@ -2504,6 +2530,8 @@ namespace ReactiveUI.Primitives.Signals
         {
             public System.Collections.Generic.IEnumerable<T> ToEnumerable() { }
             [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
+            public System.IObservable<T> WitnessLatestOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
+            [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
             public System.IObservable<T> WitnessOn(ReactiveUI.Primitives.Concurrency.ISequencer scheduler) { }
         }
         extension<TResult>(System.IObservable<TResult> asyncTask)
diff --git a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs
index 4f708c67..34319ff0 100644
--- a/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Extensions.Tests/Operators/ThrottleObservableTests.cs
@@ -17,6 +17,9 @@ public class ThrottleObservableTests
     /// <summary>Tick window for the throttle itself.</summary>
     private const int ThrottleTicks = 10;
 
+    /// <summary>Tick offset that lands inside the throttle window.</summary>
+    private const int HalfWindowTicks = 5;
+
     /// <summary>Verifies stale, duplicate, and disposed throttle callbacks cannot emit.</summary>
     /// <returns>A task representing the asynchronous test operation.</returns>
     [Test]
@@ -100,4 +103,27 @@ public async Task WhenOnCompletedAfterError_ThenDropped()
         await Assert.That(caught).IsSameReferenceAs(expected);
         await Assert.That(completed).IsFalse();
     }
+
+    /// <summary>Verifies a thread-pool sequencer driven by a virtual clock used as a time provider emits the latest value once the throttle window has passed.</summary>
+    /// <returns>A <see cref = "Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSequencerRunsFromATimeProvider_ThenEmitsTheLatestValueAfterTheWindow()
+    {
+        const int Earlier = 1;
+        const int Latest = 2;
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        ThreadPoolSequencer sequencer = new(clock);
+        SyncDirectSource<int> source = new();
+        List<int> values = [];
+        using var sub = source.ThrottleOnScheduler(TimeSpan.FromTicks(ThrottleTicks), sequencer).Subscribe(values.Add);
+
+        source.Observer.OnNext(Earlier);
+        clock.AdvanceBy(TimeSpan.FromTicks(HalfWindowTicks));
+        source.Observer.OnNext(Latest);
+        clock.AdvanceBy(TimeSpan.FromTicks(ThrottleTicks - 1));
+        await Assert.That(values).IsEmpty();
+
+        clock.AdvanceBy(TimeSpan.FromTicks(1));
+        await Assert.That(values).IsCollectionEqualTo([Latest]);
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerImmediacyExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerImmediacyExtensionsTests.cs
new file mode 100644
index 00000000..38c6e1a4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/SequencerImmediacyExtensionsTests.cs
@@ -0,0 +1,68 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Concurrency;
+using ReactiveUI.Primitives.Reactive.Concurrency;
+
+namespace ReactiveUI.Primitives.Reactive.Tests;
+
+/// <summary>Tests <see cref="SequencerImmediacyExtensions"/> immediacy detection against System.Reactive schedulers.</summary>
+public class SequencerImmediacyExtensionsTests
+{
+    /// <summary>The immediate scheduler instance reports itself as immediate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerIsImmediateInstance_ThenIsImmediateIsTrue() =>
+        await Assert.That(ImmediateScheduler.Instance.IsImmediate).IsTrue();
+
+    /// <summary>The scheduler exposed as the immediate scheduler reports itself as immediate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerIsSchedulerImmediate_ThenIsImmediateIsTrue() =>
+        await Assert.That(System.Reactive.Concurrency.Scheduler.Immediate.IsImmediate).IsTrue();
+
+    /// <summary>The library's immediate sequencer reports itself as immediate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerIsSequencerImmediate_ThenIsImmediateIsTrue() =>
+        await Assert.That(Sequencer.Immediate.IsImmediate).IsTrue();
+
+    /// <summary>The current-thread scheduler is not immediate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerIsCurrentThread_ThenIsImmediateIsFalse() =>
+        await Assert.That(System.Reactive.Concurrency.Scheduler.CurrentThread.IsImmediate).IsFalse();
+
+    /// <summary>The default scheduler is not immediate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerIsDefault_ThenIsImmediateIsFalse() =>
+        await Assert.That(System.Reactive.Concurrency.Scheduler.Default.IsImmediate).IsFalse();
+
+    /// <summary>The thread-pool sequencer is not immediate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerIsThreadPool_ThenIsImmediateIsFalse() =>
+        await Assert.That(ThreadPoolSequencer.Instance.IsImmediate).IsFalse();
+
+    /// <summary>A virtual-time scheduler is not immediate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerIsVirtualTime_ThenIsImmediateIsFalse()
+    {
+        HistoricalScheduler scheduler = new();
+
+        await Assert.That(scheduler.IsImmediate).IsFalse();
+    }
+
+    /// <summary>A null scheduler is not immediate.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test operation.</returns>
+    [Test]
+    public async Task WhenSchedulerIsNull_ThenIsImmediateIsFalse()
+    {
+        IScheduler? scheduler = null;
+
+        await Assert.That(scheduler.IsImmediate).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
index f3696308..e3a5429b 100644
--- a/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Reactive.Tests/WasmSchedulerTests.cs
@@ -44,6 +44,27 @@ public sealed class WasmSchedulerTests
     public async Task DefaultReturnsSingleton() =>
         await Assert.That(WasmScheduler.Default).IsSameReferenceAs(WasmScheduler.Default);
 
+    /// <summary>Verifies the provider constructor rejects a missing provider.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ConstructorRejectsANullTimeProvider() =>
+        await Assert.That(static () => new WasmScheduler(null!)).ThrowsExactly<ArgumentNullException>();
+
+    /// <summary>Verifies the scheduler reports the provider's current time.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task NowFollowsTheTimeProvider()
+    {
+        ManualTimeProvider timeProvider = new();
+        using WasmScheduler scheduler = new(timeProvider);
+
+        await Assert.That(scheduler.Now).IsEqualTo(DateTimeOffset.UnixEpoch);
+
+        timeProvider.UtcNow = DateTimeOffset.UnixEpoch + ValidInterval;
+
+        await Assert.That(scheduler.Now).IsEqualTo(DateTimeOffset.UnixEpoch + ValidInterval);
+    }
+
     /// <summary>Verifies scheduling rejects null actions.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -601,6 +622,12 @@ private sealed class ManualTimeProvider : TimeProvider
         /// <summary>Gets the most recently requested timer period.</summary>
         public TimeSpan LastPeriod => _timers[^1].Period;
 
+        /// <summary>Gets or sets the time reported as the current UTC time.</summary>
+        public DateTimeOffset UtcNow { get; set; } = DateTimeOffset.UnixEpoch;
+
+        /// <inheritdoc/>
+        public override DateTimeOffset GetUtcNow() => UtcNow;
+
         /// <inheritdoc/>
         public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
         {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CalmCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CalmCoordinatorTests.cs
index 57b5c445..66f6b7d7 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/CalmCoordinatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/CalmCoordinatorTests.cs
@@ -2,6 +2,8 @@
 // ReactiveUI Association Incorporated licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using ReactiveUI.Primitives.Concurrency;
+
 namespace ReactiveUI.Primitives.Tests;
 
 /// <summary>Tests for the quiet-period coordinator behind <c>Calm</c> and its <c>Throttle</c> alias.</summary>
@@ -211,4 +213,30 @@ public async Task CalmErrorRaisedDuringEmissionFollowsTheValue()
         await Assert.That(values.SequenceEqual([One])).IsTrue();
         await Assert.That(downstream.Error).IsSameReferenceAs(expected);
     }
+
+    /// <summary>Verifies a sequencer driven by a virtual clock used as a time provider emits the latest value once the quiet period has passed.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ThrottleOverATimeProviderSequencerEmitsTheLatestValueWhenTheClockPassesTheQuietPeriod()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        var sequencer = InlineThreadPool.Create(clock);
+        IObserver<int>? source = null;
+        RecordingWitness<int> witness = new();
+        using var subscription = new ScriptedObservable<int>(observer => source = observer)
+            .Throttle(QuietPeriod, sequencer)
+            .Subscribe(witness);
+
+        source!.OnNext(One);
+        clock.AdvanceBy(QuietPeriod / Two);
+        source.OnNext(Two);
+        clock.AdvanceBy(QuietPeriod / Two);
+        await Assert.That(witness.Values).IsEmpty();
+
+        clock.AdvanceBy((QuietPeriod / Two) - TimeSpan.FromTicks(One));
+        await Assert.That(witness.Values).IsEmpty();
+
+        clock.AdvanceBy(TimeSpan.FromTicks(One));
+        await Assert.That(witness.Values.SequenceEqual([Two])).IsTrue();
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/InlineThreadPool.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/InlineThreadPool.cs
new file mode 100644
index 00000000..d7d72bea
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/InlineThreadPool.cs
@@ -0,0 +1,17 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Builds thread-pool sequencers whose immediate work runs on the calling thread.</summary>
+internal static class InlineThreadPool
+{
+    /// <summary>Creates a sequencer that reads time and arms delays through <paramref name="timeProvider"/> and runs immediate work inline.</summary>
+    /// <param name="timeProvider">The provider supplying time and the delay timer.</param>
+    /// <returns>The sequencer.</returns>
+    internal static ThreadPoolSequencer Create(TimeProvider timeProvider) =>
+        new(timeProvider, static (callback, state) => callback(state));
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/RecordingWorkItem.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/RecordingWorkItem.cs
new file mode 100644
index 00000000..cbb1056c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/RecordingWorkItem.cs
@@ -0,0 +1,33 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Disposables;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>A cancellable work item that counts its executions.</summary>
+internal sealed class RecordingWorkItem : IWorkItem, IsDisposed
+{
+    /// <summary>The number of executions.</summary>
+    private int _executeCount;
+
+    /// <summary>Non-zero after cancellation.</summary>
+    private int _isDisposed;
+
+    /// <inheritdoc/>
+    public bool IsDisposed => Volatile.Read(ref _isDisposed) != 0;
+
+    /// <summary>Gets the number of times the item executed.</summary>
+    internal int ExecuteCount => Volatile.Read(ref _executeCount);
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Dispose() => Volatile.Write(ref _isDisposed, 1);
+
+    /// <inheritdoc/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Execute() => Interlocked.Increment(ref _executeCount);
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/ScaledTimeProvider.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/ScaledTimeProvider.cs
new file mode 100644
index 00000000..4cde500f
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/ScaledTimeProvider.cs
@@ -0,0 +1,58 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.Concurrent;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>A time provider over a <see cref="VirtualClock"/> that counts timestamps at a chosen frequency and reports the timers it creates.</summary>
+internal sealed class ScaledTimeProvider : TimeProvider
+{
+    /// <summary>The virtual clock supplying time and timers.</summary>
+    private readonly VirtualClock _clock;
+
+    /// <summary>The number of virtual clock ticks in one timestamp tick.</summary>
+    private readonly long _ticksPerTimestamp;
+
+    /// <summary>Completes when the first timer is created.</summary>
+    private readonly TaskCompletionSource _timerCreated = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    /// <summary>Records the due time of each timer created.</summary>
+    private readonly ConcurrentQueue<TimeSpan> _timerDueTimes = new();
+
+    /// <summary>Initializes a new instance of the <see cref="ScaledTimeProvider"/> class.</summary>
+    /// <param name="clock">The virtual clock supplying time and timers.</param>
+    /// <param name="frequency">The timestamp ticks per second, a divisor of <see cref="TimeSpan.TicksPerSecond"/>.</param>
+    internal ScaledTimeProvider(VirtualClock clock, long frequency)
+    {
+        _clock = clock;
+        TimestampFrequency = frequency;
+        _ticksPerTimestamp = TimeSpan.TicksPerSecond / frequency;
+    }
+
+    /// <inheritdoc/>
+    public override long TimestampFrequency { get; }
+
+    /// <summary>Gets a task that completes when the first timer is created.</summary>
+    internal Task TimerCreated => _timerCreated.Task;
+
+    /// <summary>Gets the due times of the timers created so far, in creation order.</summary>
+    internal TimeSpan[] TimerDueTimes => [.. _timerDueTimes];
+
+    /// <inheritdoc/>
+    public override DateTimeOffset GetUtcNow() => _clock.Now;
+
+    /// <inheritdoc/>
+    public override long GetTimestamp() => _clock.Now.UtcTicks / _ticksPerTimestamp;
+
+    /// <inheritdoc/>
+    public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
+    {
+        var timer = _clock.CreateTimer(callback, state, dueTime, period);
+        _timerDueTimes.Enqueue(dueTime);
+        _ = _timerCreated.TrySetResult();
+        return timer;
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/Common/SettableTimeProvider.cs b/src/tests/ReactiveUI.Primitives.Tests/Common/SettableTimeProvider.cs
new file mode 100644
index 00000000..f677c1b4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/Common/SettableTimeProvider.cs
@@ -0,0 +1,19 @@
+// 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.Tests;
+
+/// <summary>A time provider whose timestamp and frequency are set directly by the test.</summary>
+/// <param name="frequency">The timestamp ticks per second.</param>
+internal sealed class SettableTimeProvider(long frequency) : TimeProvider
+{
+    /// <inheritdoc/>
+    public override long TimestampFrequency { get; } = frequency;
+
+    /// <summary>Gets or sets the value returned by <see cref="GetTimestamp"/>.</summary>
+    internal long Timestamp { get; set; }
+
+    /// <inheritdoc/>
+    public override long GetTimestamp() => Timestamp;
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/CurrentThreadSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/CurrentThreadSequencerTests.cs
index 831d03a4..1c608f9f 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/CurrentThreadSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/CurrentThreadSequencerTests.cs
@@ -6,9 +6,12 @@
 
 namespace ReactiveUI.Primitives.Tests;
 
-/// <summary>Tests current-thread scheduling recovery after an interrupted initial wait.</summary>
+/// <summary>Tests current-thread scheduling recovery after an interrupted initial wait, and provider-driven timing.</summary>
 public class CurrentThreadSequencerTests
 {
+    /// <summary>The delay the blocking tests wait for.</summary>
+    private static readonly TimeSpan OneSecond = TimeSpan.FromSeconds(1);
+
     /// <summary>An interrupted initial wait clears the trampoline state so later work on that thread still executes.</summary>
     /// <returns>A task representing the asynchronous test.</returns>
     [Test]
@@ -55,4 +58,105 @@ public async Task Schedule_InterruptedInitialWait_AllowsSubsequentWork()
         await Assert.That(subsequentWorkRan).IsTrue();
         await Assert.That(resetAfterWork).IsTrue();
     }
+
+    /// <summary>A sequencer rejects a missing provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ConstructorRejectsANullProvider() =>
+        await Assert.That(static () => new CurrentThreadSequencer(null!)).ThrowsExactly<ArgumentNullException>();
+
+    /// <summary>The current time and timestamp follow the provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task NowAndTimestampFollowTheProvider()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        CurrentThreadSequencer sequencer = new(clock);
+        var start = sequencer.Timestamp;
+
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(sequencer.Now).IsEqualTo(DateTimeOffset.UnixEpoch + OneSecond);
+        await Assert.That(sequencer.Timestamp - start).IsEqualTo(Sequencer.ToTimestampDelta(OneSecond));
+    }
+
+    /// <summary>Work already due runs on the calling thread without waiting.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WorkAlreadyDueRunsWithoutCreatingATimer()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, TimeSpan.TicksPerSecond);
+        CurrentThreadSequencer sequencer = new(provider);
+        RecordingWorkItem item = new();
+        RecordingWorkItem cancelled = new();
+        cancelled.Dispose();
+
+        sequencer.Schedule(item);
+        sequencer.Schedule(cancelled, sequencer.Timestamp);
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+        await Assert.That(cancelled.ExecuteCount).IsEqualTo(0);
+        await Assert.That(provider.TimerDueTimes).IsEmpty();
+    }
+
+    /// <summary>Delayed work blocks the calling thread until the provider's timer fires, then runs.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DelayedWorkBlocksUntilTheProviderIsAdvancedPastTheDueTime()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, TimeSpan.TicksPerSecond);
+        CurrentThreadSequencer sequencer = new(provider);
+        RecordingWorkItem item = new();
+        var due = sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond);
+
+        var blocked = Task.Run(() => sequencer.Schedule(item, due));
+        await provider.TimerCreated;
+
+        await Assert.That(provider.TimerDueTimes.SequenceEqual([OneSecond])).IsTrue();
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(OneSecond - TimeSpan.FromTicks(1));
+
+        await Assert.That(blocked.IsCompleted).IsFalse();
+
+        clock.AdvanceBy(TimeSpan.FromTicks(1));
+        await blocked;
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Work scheduled on another instance while a trampoline runs joins that trampoline.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WorkFromAnotherInstanceJoinsTheRunningTrampoline()
+    {
+        CurrentThreadSequencer running = new(new VirtualClock());
+        CurrentThreadSequencer other = new(new VirtualClock());
+        RecordingWorkItem nested = new();
+        var ranAfterOuter = false;
+
+        _ = running.Schedule(() =>
+        {
+            other.Schedule(nested, other.Timestamp);
+            ranAfterOuter = nested.ExecuteCount == 0;
+        });
+
+        await Assert.That(ranAfterOuter).IsTrue();
+        await Assert.That(nested.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Work scheduled on the same instance while its trampoline runs keeps its own timestamp.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WorkFromTheRunningInstanceJoinsTheTrampolineAtItsOwnTimestamp()
+    {
+        CurrentThreadSequencer sequencer = new(new VirtualClock());
+        RecordingWorkItem nested = new();
+
+        _ = sequencer.Schedule(() => sequencer.Schedule(nested, sequencer.Timestamp));
+
+        await Assert.That(nested.ExecuteCount).IsEqualTo(1);
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
index 10718ba5..de4c9bed 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/EverySignalTests.cs
@@ -42,6 +42,29 @@ public async Task EveryRetainsTheTickArmedByAnInlineFirstTick()
         await Assert.That(ticks.SequenceEqual([0L, 1L])).IsTrue();
     }
 
+    /// <summary>Verifies a sequencer driven by a virtual clock used as a time provider emits one tick per period as the clock advances.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task EveryOverATimeProviderSequencerTicksOncePerPeriodAsTheClockAdvances()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        var sequencer = InlineThreadPool.Create(clock);
+        List<long> ticks = [];
+        using var subscription = Signal.Every(TickPeriod, sequencer).Subscribe(ticks.Add);
+
+        clock.AdvanceBy(TickPeriod - TimeSpan.FromTicks(1));
+
+        await Assert.That(ticks).IsEmpty();
+
+        clock.AdvanceBy(TimeSpan.FromTicks(1));
+
+        await Assert.That(ticks.SequenceEqual([0L])).IsTrue();
+
+        clock.AdvanceBy(TickPeriod + TickPeriod);
+
+        await Assert.That(ticks.SequenceEqual(ExpectedTicks)).IsTrue();
+    }
+
     /// <summary>Verifies a bounded <c>Every</c> on the current-thread sequencer terminates instead of livelocking.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
index b060c7eb..ced9d4ad 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/ExpireCoordinatorTests.cs
@@ -97,6 +97,31 @@ public async Task TimeoutExpiresWhenSilenceExceedsDueTimeAfterAValue()
         await Assert.That(errors.SequenceEqual([nameof(TimeoutException)])).IsTrue();
     }
 
+    /// <summary>Verifies a sequencer driven by a virtual clock used as a time provider expires the sequence exactly when the clock reaches the timeout.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ExpireOverATimeProviderSequencerFiresWhenTheClockReachesTheTimeout()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        var sequencer = InlineThreadPool.Create(clock);
+        Signal<int> source = new();
+        List<int> values = [];
+        List<string> errors = [];
+        using var subscription = source.Expire(TimeSpan.FromTicks(DueTicks), sequencer)
+            .Subscribe(values.Add, ex => errors.Add(ex.GetType().Name));
+
+        clock.AdvanceBy(TimeSpan.FromTicks(ShortGapTicks));
+        source.OnNext(One);
+        clock.AdvanceBy(TimeSpan.FromTicks(DueTicks - One));
+
+        await Assert.That(errors).IsEmpty();
+
+        clock.AdvanceBy(TimeSpan.FromTicks(One));
+
+        await Assert.That(values.SequenceEqual([One])).IsTrue();
+        await Assert.That(errors.SequenceEqual([nameof(TimeoutException)])).IsTrue();
+    }
+
     /// <summary>Verifies no timer fires once the source has terminated.</summary>
     /// <returns>A task representing the asynchronous operation.</returns>
     [Test]
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ImmediateSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ImmediateSequencerTests.cs
new file mode 100644
index 00000000..65ed142e
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/ImmediateSequencerTests.cs
@@ -0,0 +1,118 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests <see cref="ImmediateSequencer"/> driven by a <see cref="TimeProvider"/>.</summary>
+public class ImmediateSequencerTests
+{
+    /// <summary>The delay the blocking tests wait for.</summary>
+    private static readonly TimeSpan OneSecond = TimeSpan.FromSeconds(1);
+
+    /// <summary>The smallest step of the virtual clock.</summary>
+    private static readonly TimeSpan OneTick = TimeSpan.FromTicks(1);
+
+    /// <summary>A sequencer rejects a missing provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ConstructorRejectsANullProvider() =>
+        await Assert.That(static () => new ImmediateSequencer(null!)).ThrowsExactly<ArgumentNullException>();
+
+    /// <summary>The current time and timestamp follow the provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task NowAndTimestampFollowTheProvider()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        ImmediateSequencer sequencer = new(clock);
+        var start = sequencer.Timestamp;
+
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(sequencer.Now).IsEqualTo(DateTimeOffset.UnixEpoch + OneSecond);
+        await Assert.That(sequencer.Timestamp - start).IsEqualTo(Sequencer.ToTimestampDelta(OneSecond));
+    }
+
+    /// <summary>Work runs before the call returns, and cancelled work is skipped.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ImmediateWorkRunsInlineUnlessCancelled()
+    {
+        ImmediateSequencer sequencer = new(new VirtualClock());
+        RecordingWorkItem item = new();
+        RecordingWorkItem cancelled = new();
+        cancelled.Dispose();
+
+        sequencer.Schedule(item);
+        sequencer.Schedule(cancelled);
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+        await Assert.That(cancelled.ExecuteCount).IsEqualTo(0);
+    }
+
+    /// <summary>Work already due runs without waiting.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WorkAlreadyDueRunsWithoutCreatingATimer()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, TimeSpan.TicksPerSecond);
+        ImmediateSequencer sequencer = new(provider);
+        RecordingWorkItem item = new();
+
+        sequencer.Schedule(item, sequencer.Timestamp);
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+        await Assert.That(provider.TimerDueTimes).IsEmpty();
+    }
+
+    /// <summary>Delayed work blocks the caller until the provider's timer fires, then runs.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DelayedWorkBlocksUntilTheProviderIsAdvancedPastTheDueTime()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, TimeSpan.TicksPerSecond);
+        ImmediateSequencer sequencer = new(provider);
+        RecordingWorkItem item = new();
+        var due = sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond);
+
+        var blocked = Task.Run(() => sequencer.Schedule(item, due));
+        await provider.TimerCreated;
+
+        await Assert.That(provider.TimerDueTimes.SequenceEqual([OneSecond])).IsTrue();
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(OneSecond - OneTick);
+
+        await Assert.That(blocked.IsCompleted).IsFalse();
+
+        clock.AdvanceBy(OneTick);
+        await blocked;
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Delayed work cancelled while its caller is blocked does not run.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DelayedWorkCancelledWhileBlockedDoesNotRun()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, TimeSpan.TicksPerSecond);
+        ImmediateSequencer sequencer = new(provider);
+        RecordingWorkItem item = new();
+        var due = sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond);
+
+        var blocked = Task.Run(() => sequencer.Schedule(item, due));
+        await provider.TimerCreated;
+        item.Dispose();
+        clock.AdvanceBy(OneSecond);
+        await blocked;
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerClockTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerClockTests.cs
new file mode 100644
index 00000000..d0b9273f
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerClockTests.cs
@@ -0,0 +1,155 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests <see cref="SequencerClock"/> timestamp scaling, waiting and timer creation.</summary>
+public class SequencerClockTests
+{
+    /// <summary>Timestamp ticks per second of a provider that differs from <see cref="Stopwatch.Frequency"/> and divides evenly into it.</summary>
+    private const long MillisecondFrequency = 1000;
+
+    /// <summary>Timestamp ticks per second of a provider whose scale factor is not a whole number.</summary>
+    private const long ThirdsFrequency = 3;
+
+    /// <summary>The provider timestamp at which a rescaling clock is created.</summary>
+    private const long OriginTimestamp = 5_000_000;
+
+    /// <summary>Elapsed provider ticks used by the rescaling tests.</summary>
+    private const long ElapsedMilliseconds = 1500;
+
+    /// <summary>The delay used by the waiting and timer tests.</summary>
+    private static readonly TimeSpan OneSecond = TimeSpan.FromSeconds(1);
+
+    /// <summary>A clock rejects a missing provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ConstructorRejectsANullProvider() =>
+        await Assert.That(static () => new SequencerClock(null!)).ThrowsExactly<ArgumentNullException>();
+
+    /// <summary>A provider counting at <see cref="Stopwatch.Frequency"/> passes its timestamps through unchanged.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ProviderAtStopwatchFrequencyPassesTimestampsThrough()
+    {
+        SettableTimeProvider provider = new(Stopwatch.Frequency) { Timestamp = OriginTimestamp };
+        SequencerClock clock = new(provider);
+
+        await Assert.That(clock.GetTimestamp()).IsEqualTo(OriginTimestamp);
+
+        provider.Timestamp += Stopwatch.Frequency;
+
+        await Assert.That(clock.GetTimestamp()).IsEqualTo(OriginTimestamp + Stopwatch.Frequency);
+    }
+
+    /// <summary>A provider with another frequency reports timestamps in stopwatch units counted from the clock's creation.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ProviderWithAnotherFrequencyIsRescaledFromItsCreationTimestamp()
+    {
+        SettableTimeProvider provider = new(MillisecondFrequency) { Timestamp = OriginTimestamp };
+        SequencerClock clock = new(provider);
+
+        await Assert.That(clock.GetTimestamp()).IsEqualTo(0);
+
+        provider.Timestamp += ElapsedMilliseconds;
+
+        await Assert.That(clock.GetTimestamp()).IsEqualTo(Stopwatch.Frequency * ElapsedMilliseconds / MillisecondFrequency);
+    }
+
+    /// <summary>A scale factor that is not a whole number truncates the fractional stopwatch unit.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task RescalingTruncatesAFractionalStopwatchUnit()
+    {
+        SettableTimeProvider provider = new(ThirdsFrequency);
+        SequencerClock clock = new(provider);
+
+        provider.Timestamp = 1;
+
+        await Assert.That(clock.GetTimestamp()).IsEqualTo(Stopwatch.Frequency / ThirdsFrequency);
+    }
+
+    /// <summary>The remaining time is measured on the provider's clock and never goes negative.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TimeUntilMeasuresTheRemainingTimeOnTheProvidersClock()
+    {
+        SettableTimeProvider provider = new(MillisecondFrequency) { Timestamp = OriginTimestamp };
+        SequencerClock clock = new(provider);
+        var due = clock.GetTimestamp() + Sequencer.ToTimestampDelta(OneSecond);
+
+        await Assert.That(clock.TimeUntil(due)).IsEqualTo(OneSecond);
+
+        provider.Timestamp += MillisecondFrequency;
+
+        await Assert.That(clock.TimeUntil(due)).IsEqualTo(TimeSpan.Zero);
+    }
+
+    /// <summary>The current time comes from the provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task GetUtcNowReadsTheProvider()
+    {
+        VirtualClock virtualClock = new(DateTimeOffset.UnixEpoch);
+        SequencerClock clock = new(virtualClock);
+
+        virtualClock.AdvanceBy(OneSecond);
+
+        await Assert.That(clock.GetUtcNow()).IsEqualTo(DateTimeOffset.UnixEpoch + OneSecond);
+    }
+
+    /// <summary>Timers are created through the provider and fire when the provider's time reaches them.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CreateTimerUsesTheProvider()
+    {
+        VirtualClock virtualClock = new();
+        SequencerClock clock = new(virtualClock);
+        var fired = 0;
+
+        await using var timer = clock.CreateTimer(_ => fired++, null, OneSecond, Timeout.InfiniteTimeSpan);
+        virtualClock.AdvanceBy(OneSecond - TimeSpan.FromTicks(1));
+
+        await Assert.That(fired).IsEqualTo(0);
+
+        virtualClock.AdvanceBy(TimeSpan.FromTicks(1));
+
+        await Assert.That(fired).IsEqualTo(1);
+    }
+
+    /// <summary>The system clock waits on the calling thread and returns immediately for an empty delay.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task SystemClockWaitReturnsForAnEmptyDelay()
+    {
+        SequencerClock.Default.Wait(TimeSpan.Zero);
+
+        await Assert.That(SequencerClock.Default.GetTimestamp()).IsGreaterThan(0);
+    }
+
+    /// <summary>A wait on another provider blocks until that provider's timer fires.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WaitBlocksUntilTheProvidersTimerFires()
+    {
+        VirtualClock virtualClock = new();
+        ScaledTimeProvider provider = new(virtualClock, TimeSpan.TicksPerSecond);
+        SequencerClock clock = new(provider);
+
+        var waiter = Task.Run(() => clock.Wait(OneSecond));
+        await provider.TimerCreated;
+
+        await Assert.That(waiter.IsCompleted).IsFalse();
+        await Assert.That(provider.TimerDueTimes.SequenceEqual([OneSecond])).IsTrue();
+
+        virtualClock.AdvanceBy(OneSecond);
+        await waiter;
+
+        await Assert.That(waiter.IsCompletedSuccessfully).IsTrue();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SequencerImmediacyExtensionsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SequencerImmediacyExtensionsTests.cs
new file mode 100644
index 00000000..5f11161c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SequencerImmediacyExtensionsTests.cs
@@ -0,0 +1,71 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests <see cref="SequencerImmediacyExtensions"/> immediacy detection.</summary>
+public class SequencerImmediacyExtensionsTests
+{
+    /// <summary>The immediate sequencer reports itself as immediate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task IsImmediateIsTrueForTheImmediateSequencer() =>
+        await Assert.That(Sequencer.Immediate.IsImmediate).IsTrue();
+
+    /// <summary>The immediate sequencer reports itself as immediate when held as the sequencer interface.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task IsImmediateIsTrueForTheImmediateSequencerBehindTheInterface()
+    {
+        ISequencer sequencer = ImmediateSequencer.Instance;
+
+        await Assert.That(sequencer.IsImmediate).IsTrue();
+    }
+
+    /// <summary>The current-thread sequencer is not immediate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task IsImmediateIsFalseForTheCurrentThreadSequencer() =>
+        await Assert.That(Sequencer.CurrentThread.IsImmediate).IsFalse();
+
+    /// <summary>The thread-pool sequencer is not immediate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task IsImmediateIsFalseForTheThreadPoolSequencer() =>
+        await Assert.That(ThreadPoolSequencer.Instance.IsImmediate).IsFalse();
+
+    /// <summary>The task-pool sequencer is not immediate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task IsImmediateIsFalseForTheTaskPoolSequencer() =>
+        await Assert.That(TaskPoolSequencer.Instance.IsImmediate).IsFalse();
+
+    /// <summary>The default sequencer is not immediate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task IsImmediateIsFalseForTheDefaultSequencer() =>
+        await Assert.That(Sequencer.Default.IsImmediate).IsFalse();
+
+    /// <summary>A virtual clock is not immediate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task IsImmediateIsFalseForAVirtualClock()
+    {
+        VirtualClock clock = new();
+
+        await Assert.That(clock.IsImmediate).IsFalse();
+    }
+
+    /// <summary>A null sequencer is not immediate.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task IsImmediateIsFalseForNull()
+    {
+        ISequencer? sequencer = null;
+
+        await Assert.That(sequencer.IsImmediate).IsFalse();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
index d50d6662..c4ca2d67 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Delay.cs
@@ -176,6 +176,35 @@ public async Task ShiftReschedulesWhenNextNotificationIsNotYetDue()
         await Assert.That(sequencer.ScheduledCount).IsEqualTo(0);
     }
 
+    /// <summary>Verifies shift over a sequencer driven by a virtual clock used as a time provider delivers each value one due time after it arrived.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ShiftOverATimeProviderSequencerDeliversEachValueOneDueTimeLater()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        var sequencer = InlineThreadPool.Create(clock);
+        var step = TimeSpan.FromTicks(Five);
+        var dueTime = TimeSpan.FromTicks(Ten);
+        Signal<int> source = new();
+        RecordingWitness<int> observer = new();
+        using var subscription = source.Shift(dueTime, sequencer).Subscribe(observer);
+
+        source.OnNext(One);
+        clock.AdvanceBy(step);
+        source.OnNext(Two);
+        clock.AdvanceBy(step - TimeSpan.FromTicks(One));
+
+        await Assert.That(observer.Values.Count).IsEqualTo(0);
+
+        clock.AdvanceBy(TimeSpan.FromTicks(One));
+
+        await Assert.That(observer.Values.SequenceEqual([One])).IsTrue();
+
+        clock.AdvanceBy(step);
+
+        await Assert.That(observer.Values.SequenceEqual([One, Two])).IsTrue();
+    }
+
     /// <summary>Sequencer that records scheduled work for deterministic execution.</summary>
     private sealed class RecordingSequencer : ISequencer
     {
diff --git a/src/tests/ReactiveUI.Primitives.Tests/SynchronizationContextSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SynchronizationContextSequencerTests.cs
new file mode 100644
index 00000000..e0c33ef5
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/SynchronizationContextSequencerTests.cs
@@ -0,0 +1,100 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests <see cref="SynchronizationContextSequencer"/> driven by a <see cref="TimeProvider"/>.</summary>
+public class SynchronizationContextSequencerTests
+{
+    /// <summary>The delay used for scheduled work.</summary>
+    private static readonly TimeSpan OneSecond = TimeSpan.FromSeconds(1);
+
+    /// <summary>The smallest step of the virtual clock.</summary>
+    private static readonly TimeSpan OneTick = TimeSpan.FromTicks(1);
+
+    /// <summary>A sequencer rejects a missing context or provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ConstructorRejectsANullContextOrProvider()
+    {
+        await Assert.That(static () => new SynchronizationContextSequencer(null!, (TimeProvider)new VirtualClock()))
+            .ThrowsExactly<ArgumentNullException>();
+        await Assert.That(static () => new SynchronizationContextSequencer(new(), (TimeProvider)null!))
+            .ThrowsExactly<ArgumentNullException>();
+    }
+
+    /// <summary>The current time and timestamp follow the provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task NowAndTimestampFollowTheProvider()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        TimeProvider provider = clock;
+        SynchronizationContextSequencer sequencer = new(new(), provider);
+        var start = sequencer.Timestamp;
+
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(sequencer.Now).IsEqualTo(DateTimeOffset.UnixEpoch + OneSecond);
+        await Assert.That(sequencer.Timestamp - start).IsEqualTo(Sequencer.ToTimestampDelta(OneSecond));
+    }
+
+    /// <summary>Delayed work is posted to the context only once the provider is advanced to its timestamp.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DelayedWorkIsPostedWhenTheProviderReachesItsTimestamp()
+    {
+        VirtualClock clock = new();
+        TimeProvider provider = clock;
+        InlineContext context = new();
+        SynchronizationContextSequencer sequencer = new(context, provider);
+        RecordingWorkItem item = new();
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        clock.AdvanceBy(OneSecond - OneTick);
+
+        await Assert.That(context.PostCount).IsEqualTo(0);
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(OneTick);
+
+        await Assert.That(context.PostCount).IsEqualTo(1);
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Delayed work cancelled before it is due never reaches the context.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CancelledDelayedWorkIsNotPosted()
+    {
+        VirtualClock clock = new();
+        TimeProvider provider = clock;
+        InlineContext context = new();
+        SynchronizationContextSequencer sequencer = new(context, provider);
+        RecordingWorkItem item = new();
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        item.Dispose();
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(context.PostCount).IsEqualTo(0);
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+    }
+
+    /// <summary>A synchronization context that runs posted work inline and counts the posts.</summary>
+    private sealed class InlineContext : SynchronizationContext
+    {
+        /// <summary>Gets the number of posted callbacks.</summary>
+        internal int PostCount { get; private set; }
+
+        /// <inheritdoc/>
+        public override void Post(SendOrPostCallback d, object? state)
+        {
+            PostCount++;
+            d(state);
+        }
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
index aa252f0e..fd682a2c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/TaskPoolSequencerTests.cs
@@ -157,4 +157,77 @@ public async Task Schedule_AdvanceClockToDue_DispatchesOnce()
     [Test]
     public async Task Constructor_NullTaskFactory_ThrowsArgumentNull() =>
         await Assert.That(static () => new TaskPoolSequencer(null!)).ThrowsExactly<ArgumentNullException>();
+
+    /// <summary>A null task factory or time provider is rejected by the provider constructor.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ProviderConstructorRejectsANullTaskFactoryOrProvider()
+    {
+        TimeProvider provider = new VirtualClock();
+
+        await Assert.That(() => new TaskPoolSequencer(null!, provider)).ThrowsExactly<ArgumentNullException>();
+        await Assert.That(static () => new TaskPoolSequencer(new(new ManualTaskScheduler()), (TimeProvider)null!))
+            .ThrowsExactly<ArgumentNullException>();
+    }
+
+    /// <summary>The current time and timestamp follow the provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task NowAndTimestampFollowTheProvider()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        TimeProvider provider = clock;
+        TaskPoolSequencer sequencer = new(new(new ManualTaskScheduler()), provider);
+        var start = sequencer.Timestamp;
+
+        clock.AdvanceBy(TimeSpan.FromSeconds(1));
+
+        await Assert.That(sequencer.Now).IsEqualTo(DateTimeOffset.UnixEpoch + TimeSpan.FromSeconds(1));
+        await Assert.That(sequencer.Timestamp - start).IsEqualTo(Sequencer.ToTimestampDelta(TimeSpan.FromSeconds(1)));
+    }
+
+    /// <summary>Delayed work reaches the task factory only when the provider is advanced to its timestamp.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DelayedWorkIsDispatchedWhenTheProviderReachesItsTimestamp()
+    {
+        VirtualClock clock = new();
+        TimeProvider provider = clock;
+        ManualTaskScheduler tasks = new();
+        TaskPoolSequencer sequencer = new(new(tasks), provider);
+        RecordingWorkItem item = new();
+        var oneSecond = TimeSpan.FromSeconds(1);
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(oneSecond));
+        clock.AdvanceBy(oneSecond - TimeSpan.FromTicks(1));
+        tasks.RunPending();
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(TimeSpan.FromTicks(1));
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+        tasks.RunPending();
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Delayed work cancelled before its timestamp never runs.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CancelledDelayedWorkIsNotDispatched()
+    {
+        VirtualClock clock = new();
+        TimeProvider provider = clock;
+        ManualTaskScheduler tasks = new();
+        TaskPoolSequencer sequencer = new(new(tasks), provider);
+        RecordingWorkItem item = new();
+        var oneSecond = TimeSpan.FromSeconds(1);
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(oneSecond));
+        item.Dispose();
+        clock.AdvanceBy(oneSecond);
+        tasks.RunPending();
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+    }
 }
diff --git a/src/tests/ReactiveUI.Primitives.Tests/ThreadPoolSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ThreadPoolSequencerTests.cs
new file mode 100644
index 00000000..a01390f5
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/ThreadPoolSequencerTests.cs
@@ -0,0 +1,211 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Diagnostics;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests <see cref="ThreadPoolSequencer"/> driven by a <see cref="TimeProvider"/>.</summary>
+public class ThreadPoolSequencerTests
+{
+    /// <summary>Timestamp ticks per second of a provider that counts milliseconds.</summary>
+    private const long MillisecondFrequency = 1000;
+
+    /// <summary>Name recorded by the work due after one second.</summary>
+    private const string First = "first";
+
+    /// <summary>Name recorded by the work due after two seconds.</summary>
+    private const string Second = "second";
+
+    /// <summary>A short delay used for scheduled work.</summary>
+    private static readonly TimeSpan OneSecond = TimeSpan.FromSeconds(1);
+
+    /// <summary>A delay later than <see cref="OneSecond"/>.</summary>
+    private static readonly TimeSpan TwoSeconds = TimeSpan.FromSeconds(2);
+
+    /// <summary>The smallest step of the virtual clock.</summary>
+    private static readonly TimeSpan OneTick = TimeSpan.FromTicks(1);
+
+    /// <summary>A sequencer rejects a missing provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ConstructorRejectsANullProvider() =>
+        await Assert.That(static () => new ThreadPoolSequencer((TimeProvider)null!)).ThrowsExactly<ArgumentNullException>();
+
+    /// <summary>The current time and timestamp follow the provider.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task NowAndTimestampFollowTheProvider()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        var sequencer = InlineThreadPool.Create(clock);
+        var start = sequencer.Timestamp;
+
+        clock.AdvanceBy(TwoSeconds);
+
+        await Assert.That(sequencer.Now).IsEqualTo(DateTimeOffset.UnixEpoch + TwoSeconds);
+        await Assert.That(sequencer.Timestamp - start).IsEqualTo(Sequencer.ToTimestampDelta(TwoSeconds));
+    }
+
+    /// <summary>Work scheduled for a timestamp runs when the provider is advanced to it and not before.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ScheduledWorkRunsExactlyWhenTheProviderReachesItsTimestamp()
+    {
+        VirtualClock clock = new();
+        var sequencer = InlineThreadPool.Create(clock);
+        RecordingWorkItem item = new();
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        clock.AdvanceBy(OneSecond - OneTick);
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(OneTick);
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+
+        clock.AdvanceBy(TwoSeconds);
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Work due at several timestamps runs in due order as the provider advances.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ScheduledWorkRunsInDueOrder()
+    {
+        VirtualClock clock = new();
+        var sequencer = InlineThreadPool.Create(clock);
+        List<string> order = [];
+
+        _ = sequencer.Schedule(order, TwoSeconds, static names => names.Add(Second));
+        _ = sequencer.Schedule(order, OneSecond, static names => names.Add(First));
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(order.SequenceEqual([First])).IsTrue();
+
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(order.SequenceEqual([First, Second])).IsTrue();
+    }
+
+    /// <summary>Work scheduled by due work re-arms the delay timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task WorkScheduledByDueWorkRunsWhenItsOwnTimestampIsReached()
+    {
+        VirtualClock clock = new();
+        var sequencer = InlineThreadPool.Create(clock);
+        RecordingWorkItem later = new();
+
+        _ = sequencer.Schedule(
+            (Owner: sequencer, Later: later),
+            OneSecond,
+            static state => state.Owner.Schedule(state.Later, state.Owner.Timestamp + Sequencer.ToTimestampDelta(OneSecond)));
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(later.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(later.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Cancelled work never runs.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task CancelledWorkDoesNotRun()
+    {
+        VirtualClock clock = new();
+        var sequencer = InlineThreadPool.Create(clock);
+        RecordingWorkItem cancelled = new();
+        RecordingWorkItem kept = new();
+
+        sequencer.Schedule(cancelled, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        sequencer.Schedule(kept, sequencer.Timestamp + Sequencer.ToTimestampDelta(TwoSeconds));
+        cancelled.Dispose();
+        clock.AdvanceBy(TwoSeconds);
+
+        await Assert.That(cancelled.ExecuteCount).IsEqualTo(0);
+        await Assert.That(kept.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Immediate work runs through the immediate queue without touching the delay timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ImmediateWorkDoesNotCreateAnyTimer()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, TimeSpan.TicksPerSecond);
+        var sequencer = InlineThreadPool.Create(provider);
+        RecordingWorkItem now = new();
+        RecordingWorkItem elapsed = new();
+
+        sequencer.Schedule(now);
+        sequencer.Schedule(elapsed, sequencer.Timestamp);
+
+        await Assert.That(now.ExecuteCount).IsEqualTo(1);
+        await Assert.That(elapsed.ExecuteCount).IsEqualTo(1);
+        await Assert.That(provider.TimerDueTimes).IsEmpty();
+    }
+
+    /// <summary>All delayed work shares one timer created by the provider on first use.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DelayedWorkSharesOneProviderTimerCreatedOnFirstUse()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, TimeSpan.TicksPerSecond);
+        var sequencer = InlineThreadPool.Create(provider);
+
+        await Assert.That(provider.TimerDueTimes).IsEmpty();
+
+        sequencer.Schedule(new RecordingWorkItem(), sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        sequencer.Schedule(new RecordingWorkItem(), sequencer.Timestamp + Sequencer.ToTimestampDelta(TwoSeconds));
+
+        await Assert.That(provider.TimerDueTimes.Length).IsEqualTo(1);
+    }
+
+    /// <summary>A provider counting at a different frequency drives delayed work at the right wall time.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ProviderWithAnotherFrequencyDrivesDelayedWork()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, MillisecondFrequency);
+        var sequencer = InlineThreadPool.Create(provider);
+        RecordingWorkItem item = new();
+
+        await Assert.That(provider.TimestampFrequency).IsNotEqualTo(Stopwatch.Frequency);
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        clock.AdvanceBy(OneSecond - TimeSpan.FromMilliseconds(1));
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(TimeSpan.FromMilliseconds(1));
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+        await Assert.That(sequencer.Timestamp).IsEqualTo(Sequencer.ToTimestampDelta(OneSecond));
+    }
+
+    /// <summary>Disposal cancels pending delayed work and stops the delay timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DisposeCancelsPendingWorkAndStopsTheTimer()
+    {
+        VirtualClock clock = new();
+        var sequencer = InlineThreadPool.Create(clock);
+        RecordingWorkItem pending = new();
+
+        sequencer.Schedule(pending, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        sequencer.Dispose();
+        clock.AdvanceBy(TwoSeconds);
+
+        await Assert.That(pending.IsDisposed).IsTrue();
+        await Assert.That(pending.ExecuteCount).IsEqualTo(0);
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/VirtualClockTests.cs b/src/tests/ReactiveUI.Primitives.Tests/VirtualClockTests.cs
new file mode 100644
index 00000000..1b044f1c
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/VirtualClockTests.cs
@@ -0,0 +1,328 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI.Primitives.Concurrency;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Tests <see cref="VirtualClock"/> as a <see cref="TimeProvider"/>.</summary>
+public class VirtualClockTests
+{
+    /// <summary>The delay of the first firing in the timer tests.</summary>
+    private static readonly TimeSpan OneSecond = TimeSpan.FromSeconds(1);
+
+    /// <summary>The interval between periodic firings in the timer tests.</summary>
+    private static readonly TimeSpan TwoSeconds = TimeSpan.FromSeconds(2);
+
+    /// <summary>A delay later than every firing the timer tests expect.</summary>
+    private static readonly TimeSpan TenSeconds = TimeSpan.FromSeconds(10);
+
+    /// <summary>The virtual time starts at the unix epoch.</summary>
+    private static readonly DateTimeOffset Epoch = DateTimeOffset.UnixEpoch;
+
+    /// <summary>The times a timer that first fires after one second and then every two seconds reaches within ten seconds.</summary>
+    private static readonly TimeSpan[] OddSeconds =
+    [
+        TimeSpan.FromSeconds(1),
+        TimeSpan.FromSeconds(3),
+        TimeSpan.FromSeconds(5),
+        TimeSpan.FromSeconds(7),
+        TimeSpan.FromSeconds(9),
+    ];
+
+    /// <summary>The clock is usable wherever a time provider is expected.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ClockIsATimeProvider()
+    {
+        TimeProvider provider = new VirtualClock();
+
+        await Assert.That(provider).IsTypeOf<VirtualClock>();
+    }
+
+    /// <summary>The UTC time follows the virtual clock as it advances.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task GetUtcNowFollowsTheVirtualClock()
+    {
+        VirtualClock clock = new(Epoch);
+        TimeProvider provider = clock;
+
+        await Assert.That(provider.GetUtcNow()).IsEqualTo(Epoch);
+
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(provider.GetUtcNow()).IsEqualTo(Epoch + TenSeconds);
+        await Assert.That(provider.GetUtcNow()).IsEqualTo(clock.Now);
+    }
+
+    /// <summary>Timestamps count ticks of the virtual clock at <see cref="TimeSpan.TicksPerSecond"/>.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task GetTimestampCountsTicksOfTheVirtualClock()
+    {
+        VirtualClock clock = new(Epoch);
+        TimeProvider provider = clock;
+
+        await Assert.That(provider.TimestampFrequency).IsEqualTo(TimeSpan.TicksPerSecond);
+        await Assert.That(provider.GetTimestamp()).IsEqualTo(Epoch.UtcTicks);
+
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(provider.GetTimestamp()).IsEqualTo((Epoch + OneSecond).UtcTicks);
+    }
+
+    /// <summary>Elapsed time between two timestamps equals the virtual time that passed.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task GetElapsedTimeMeasuresVirtualTime()
+    {
+        VirtualClock clock = new(Epoch);
+        TimeProvider provider = clock;
+        var start = provider.GetTimestamp();
+
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(provider.GetElapsedTime(start)).IsEqualTo(TenSeconds);
+    }
+
+    /// <summary>A one-shot timer fires exactly once, when the clock reaches its due time.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task OneShotTimerFiresOnceWhenTheClockReachesItsDueTime()
+    {
+        VirtualClock clock = new(Epoch);
+        List<DateTimeOffset> fired = [];
+        await using var timer =clock.CreateTimer(_ => fired.Add(clock.Now), null, OneSecond, Timeout.InfiniteTimeSpan);
+
+        clock.AdvanceBy(OneSecond - TimeSpan.FromTicks(1));
+
+        await Assert.That(fired).IsEmpty();
+
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired.SequenceEqual([Epoch + OneSecond])).IsTrue();
+    }
+
+    /// <summary>A timer hands its state to the callback.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TimerPassesItsStateToTheCallback()
+    {
+        VirtualClock clock = new(Epoch);
+        object state = new();
+        object? received = null;
+        await using var timer =clock.CreateTimer(s => received = s, state, OneSecond, Timeout.InfiniteTimeSpan);
+
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(received).IsSameReferenceAs(state);
+    }
+
+    /// <summary>A periodic timer fires after its due time and then once per period.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task PeriodicTimerFiresOnceEveryPeriod()
+    {
+        VirtualClock clock = new(Epoch);
+        List<TimeSpan> fired = [];
+        await using var timer =clock.CreateTimer(_ => fired.Add(clock.Now - Epoch), null, OneSecond, TwoSeconds);
+
+        clock.AdvanceBy(TenSeconds - TimeSpan.FromTicks(1));
+
+        await Assert.That(fired.SequenceEqual(OddSeconds)).IsTrue();
+    }
+
+    /// <summary>A timer with a zero period fires once.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TimerWithAZeroPeriodFiresOnce()
+    {
+        VirtualClock clock = new(Epoch);
+        var fired = 0;
+        await using var timer =clock.CreateTimer(_ => fired++, null, OneSecond, TimeSpan.Zero);
+
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired).IsEqualTo(1);
+    }
+
+    /// <summary>A timer with a zero due time fires when the clock next runs work.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TimerWithAZeroDueTimeFiresWhenTheClockStarts()
+    {
+        VirtualClock clock = new(Epoch);
+        var fired = 0;
+        await using var timer =clock.CreateTimer(_ => fired++, null, TimeSpan.Zero, Timeout.InfiniteTimeSpan);
+
+        await Assert.That(fired).IsEqualTo(0);
+
+        clock.Start();
+
+        await Assert.That(fired).IsEqualTo(1);
+    }
+
+    /// <summary>A timer created with an infinite due time stays stopped until it is changed.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TimerWithAnInfiniteDueTimeStaysStoppedUntilChanged()
+    {
+        VirtualClock clock = new(Epoch);
+        var fired = 0;
+        await using var timer =clock.CreateTimer(_ => fired++, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired).IsEqualTo(0);
+
+        await Assert.That(timer.Change(OneSecond, Timeout.InfiniteTimeSpan)).IsTrue();
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired).IsEqualTo(1);
+    }
+
+    /// <summary>Changing a timer replaces its pending firing.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ChangeReplacesThePendingFiring()
+    {
+        VirtualClock clock = new(Epoch);
+        List<TimeSpan> fired = [];
+        await using var timer =clock.CreateTimer(_ => fired.Add(clock.Now - Epoch), null, TenSeconds, Timeout.InfiniteTimeSpan);
+
+        await Assert.That(timer.Change(TwoSeconds, Timeout.InfiniteTimeSpan)).IsTrue();
+        clock.AdvanceBy(TenSeconds + TenSeconds);
+
+        await Assert.That(fired.SequenceEqual([TwoSeconds])).IsTrue();
+    }
+
+    /// <summary>Changing a timer to an infinite due time cancels its pending firing.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ChangeToAnInfiniteDueTimeCancelsThePendingFiring()
+    {
+        VirtualClock clock = new(Epoch);
+        var fired = 0;
+        await using var timer =clock.CreateTimer(_ => fired++, null, OneSecond, OneSecond);
+
+        _ = timer.Change(Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired).IsEqualTo(0);
+    }
+
+    /// <summary>A timer that changes its own period from inside the callback keeps firing at the new period.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task ChangeInsideTheCallbackSetsTheNextFiring()
+    {
+        VirtualClock clock = new(Epoch);
+        List<TimeSpan> fired = [];
+        ITimer? timer = null;
+        timer = clock.CreateTimer(
+            _ =>
+            {
+                fired.Add(clock.Now - Epoch);
+                _ = timer!.Change(TwoSeconds, Timeout.InfiniteTimeSpan);
+            },
+            null,
+            OneSecond,
+            Timeout.InfiniteTimeSpan);
+
+        clock.AdvanceBy(TenSeconds);
+        await timer.DisposeAsync();
+
+        await Assert.That(fired.SequenceEqual(OddSeconds)).IsTrue();
+    }
+
+    /// <summary>Disposing a timer cancels its pending firing and makes later changes report failure.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DisposeCancelsThePendingFiringAndRejectsChanges()
+    {
+        VirtualClock clock = new(Epoch);
+        var fired = 0;
+        var timer = clock.CreateTimer(_ => fired++, null, OneSecond, OneSecond);
+
+        timer.Dispose();
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired).IsEqualTo(0);
+        await Assert.That(timer.Change(OneSecond, OneSecond)).IsFalse();
+    }
+
+    /// <summary>Disposing a periodic timer from its callback stops later firings.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DisposeInsideTheCallbackStopsAPeriodicTimer()
+    {
+        VirtualClock clock = new(Epoch);
+        var fired = 0;
+        ITimer? timer = null;
+        timer = clock.CreateTimer(
+            _ =>
+            {
+                fired++;
+                timer!.Dispose();
+            },
+            null,
+            OneSecond,
+            OneSecond);
+
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired).IsEqualTo(1);
+    }
+
+    /// <summary>A firing that was already dequeued when the timer is disposed does not invoke the callback or queue another firing.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task FiringAfterDisposeDoesNothing()
+    {
+        VirtualClock clock = new(Epoch);
+        var fired = 0;
+        var timer = (VirtualClockTimer)clock.CreateTimer(_ => fired++, null, OneSecond, OneSecond);
+
+        await timer.DisposeAsync();
+        _ = timer.Fire();
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired).IsEqualTo(0);
+    }
+
+    /// <summary>Asynchronous disposal cancels the timer.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task DisposeAsyncCancelsThePendingFiring()
+    {
+        VirtualClock clock = new(Epoch);
+        var fired = 0;
+        var timer = clock.CreateTimer(_ => fired++, null, OneSecond, Timeout.InfiniteTimeSpan);
+
+        await timer.DisposeAsync();
+        clock.AdvanceBy(TenSeconds);
+
+        await Assert.That(fired).IsEqualTo(0);
+    }
+
+    /// <summary>Timers reject a missing callback and negative times other than the infinite time span.</summary>
+    /// <returns>A task representing the asynchronous test.</returns>
+    [Test]
+    public async Task TimersRejectInvalidArguments()
+    {
+        VirtualClock clock = new(Epoch);
+        TimeProvider provider = clock;
+        await using var timer =provider.CreateTimer(static _ => { }, null, OneSecond, Timeout.InfiniteTimeSpan);
+
+        await Assert.That(() => provider.CreateTimer(null!, null, OneSecond, Timeout.InfiniteTimeSpan))
+            .ThrowsExactly<ArgumentNullException>();
+        await Assert.That(() => provider.CreateTimer(static _ => { }, null, -TwoSeconds, Timeout.InfiniteTimeSpan))
+            .ThrowsExactly<ArgumentOutOfRangeException>();
+        await Assert.That(() => provider.CreateTimer(static _ => { }, null, OneSecond, -TwoSeconds))
+            .ThrowsExactly<ArgumentOutOfRangeException>();
+        await Assert.That(() => timer.Change(-TwoSeconds, Timeout.InfiniteTimeSpan))
+            .ThrowsExactly<ArgumentOutOfRangeException>();
+    }
+}
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs b/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
index 5442995f..e360f16c 100644
--- a/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
+++ b/src/tests/ReactiveUI.Primitives.Tests/WasmSequencerTests.cs
@@ -11,9 +11,15 @@ namespace ReactiveUI.Primitives.Tests;
 /// <summary>Tests for <see cref="WasmSequencer"/>.</summary>
 public sealed class WasmSequencerTests
 {
+    /// <summary>Timestamp ticks per second of a provider that counts milliseconds.</summary>
+    private const long MillisecondFrequency = 1000;
+
     /// <summary>Expected values produced by an immediate burst, in FIFO order.</summary>
     private static readonly int[] ExpectedBurst = [1, 2, 3];
 
+    /// <summary>The delay used for scheduled work.</summary>
+    private static readonly TimeSpan OneSecond = TimeSpan.FromSeconds(1);
+
     /// <summary>Verifies the shared instance is a singleton.</summary>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
     [Test]
@@ -222,6 +228,121 @@ public async Task DisposeDropsDelayedNonDisposableWorkThatComesDueAfterwards()
         await Assert.That(ran).IsEqualTo(0);
     }
 
+    /// <summary>A sequencer rejects a missing provider.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ProviderConstructorRejectsANullProvider() =>
+        await Assert.That(static () => new WasmSequencer(null!)).ThrowsExactly<ArgumentNullException>();
+
+    /// <summary>The current time and timestamp follow the provider.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task NowAndTimestampFollowTheProvider()
+    {
+        VirtualClock clock = new(DateTimeOffset.UnixEpoch);
+        using WasmSequencer sequencer = new(clock);
+        var start = sequencer.Timestamp;
+
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(sequencer.Now).IsEqualTo(DateTimeOffset.UnixEpoch + OneSecond);
+        await Assert.That(sequencer.Timestamp - start).IsEqualTo(Sequencer.ToTimestampDelta(OneSecond));
+    }
+
+    /// <summary>Immediate work runs on the provider's next timer turn.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ImmediateWorkRunsWhenTheProviderFiresItsDrainTimer()
+    {
+        VirtualClock clock = new();
+        using WasmSequencer sequencer = new(clock);
+        RecordingWorkItem item = new();
+        RecordingWorkItem cancelled = new();
+        cancelled.Dispose();
+
+        sequencer.Schedule(cancelled);
+        sequencer.Schedule(item);
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(TimeSpan.FromTicks(1));
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+        await Assert.That(cancelled.ExecuteCount).IsEqualTo(0);
+    }
+
+    /// <summary>Delayed work runs when the provider reaches its timestamp and not before.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task DelayedWorkRunsExactlyWhenTheProviderReachesItsTimestamp()
+    {
+        VirtualClock clock = new();
+        using WasmSequencer sequencer = new(clock);
+        RecordingWorkItem item = new();
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        clock.AdvanceBy(OneSecond - TimeSpan.FromTicks(1));
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(TimeSpan.FromTicks(1));
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Delayed work cancelled before its timestamp never runs.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task DelayedWorkCancelledBeforeItsTimestampDoesNotRun()
+    {
+        VirtualClock clock = new();
+        using WasmSequencer sequencer = new(clock);
+        RecordingWorkItem item = new();
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        item.Dispose();
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+    }
+
+    /// <summary>A provider counting at another frequency drives delayed work at the right wall time.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ProviderWithAnotherFrequencyDrivesDelayedWork()
+    {
+        VirtualClock clock = new();
+        ScaledTimeProvider provider = new(clock, MillisecondFrequency);
+        using WasmSequencer sequencer = new(provider);
+        RecordingWorkItem item = new();
+
+        sequencer.Schedule(item, sequencer.Timestamp + Sequencer.ToTimestampDelta(OneSecond));
+        clock.AdvanceBy(OneSecond - TimeSpan.FromMilliseconds(1));
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+
+        clock.AdvanceBy(TimeSpan.FromMilliseconds(1));
+
+        await Assert.That(item.ExecuteCount).IsEqualTo(1);
+    }
+
+    /// <summary>Disposal cancels queued immediate work before the provider's drain timer fires.</summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Test]
+    public async Task DisposeCancelsQueuedWorkBeforeTheDrainTimerFires()
+    {
+        VirtualClock clock = new();
+        WasmSequencer sequencer = new(clock);
+        RecordingWorkItem item = new();
+
+        sequencer.Schedule(item);
+        sequencer.Dispose();
+        clock.AdvanceBy(OneSecond);
+
+        await Assert.That(item.IsDisposed).IsTrue();
+        await Assert.That(item.ExecuteCount).IsEqualTo(0);
+    }
+
     /// <summary>Creates a sequencer whose event loop is driven explicitly.</summary>
     /// <param name="drains">The queued drain callbacks.</param>
     /// <param name="delays">The delayed callback queue.</param>
diff --git a/src/tests/ReactiveUI.Primitives.Tests/WitnessLatestOnSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/WitnessLatestOnSignalTests.cs
new file mode 100644
index 00000000..fd1f23f4
--- /dev/null
+++ b/src/tests/ReactiveUI.Primitives.Tests/WitnessLatestOnSignalTests.cs
@@ -0,0 +1,476 @@
+// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved.
+// ReactiveUI Association Incorporated licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+using ReactiveUI.Primitives.Advanced;
+using ReactiveUI.Primitives.Concurrency;
+using ReactiveUI.Primitives.Signals;
+
+namespace ReactiveUI.Primitives.Tests;
+
+/// <summary>Verifies the <c>WitnessLatestOn</c> signal, which keeps one pending slot and delivers only the newest value on a sequencer.</summary>
+public sealed class WitnessLatestOnSignalTests
+{
+    /// <summary>The first value pushed through the signal.</summary>
+    private const int First = 1;
+
+    /// <summary>The second value pushed through the signal.</summary>
+    private const int Second = 2;
+
+    /// <summary>The third value pushed through the signal.</summary>
+    private const int Third = 3;
+
+    /// <summary>A single virtual tick, enough to drain the sequencer queue.</summary>
+    private static readonly TimeSpan SingleTick = TimeSpan.FromTicks(1);
+
+    /// <summary>The longest a cross-thread push may take before the sink lock is considered held.</summary>
+    private static readonly TimeSpan ProbeTimeout = TimeSpan.FromSeconds(30);
+
+    /// <summary>The signal is built directly from a source and a sequencer and subscribes on the current thread.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ExtensionBuildsTheSignalThatRequiresTheCurrentThread()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+
+        var viaExtension = source.WitnessLatestOn(clock);
+        WitnessLatestOnSignal<int> direct = new(source, clock);
+
+        await Assert.That(viaExtension).IsTypeOf<WitnessLatestOnSignal<int>>();
+        await Assert.That(viaExtension.GetType()).IsEqualTo(direct.GetType());
+        await Assert.That(direct.IsRequiredSubscribeOnCurrentThread()).IsTrue();
+    }
+
+    /// <summary>Values that arrive while a drain is pending overwrite the single slot, so only the newest is delivered.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task PendingValuesAreOverwrittenAndOnlyTheLatestIsDelivered()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+        LogObserver log = new();
+
+        using var subscription = source.WitnessLatestOn(clock).Subscribe(log);
+        source.OnNext(First);
+        source.OnNext(Second);
+        source.OnNext(Third);
+
+        await Assert.That(log.Entries.Count).IsEqualTo(0);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N3"])).IsTrue();
+    }
+
+    /// <summary>A value that arrives after a drain finished schedules a fresh drain.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ValueAfterAFinishedDrainIsDeliveredByANewDrain()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+        LogObserver log = new();
+
+        using var subscription = source.WitnessLatestOn(clock).Subscribe(log);
+        source.OnNext(First);
+        clock.AdvanceBy(SingleTick);
+        source.OnNext(Second);
+        clock.AdvanceBy(SingleTick);
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1", "N2"])).IsTrue();
+    }
+
+    /// <summary>A value pushed re-entrantly during delivery is held, then delivered once by the same drain.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ValueArrivingDuringDeliveryIsHeldAndDeliveredOnceByTheSameDrain()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+        LogObserver log = new();
+        log.OnValue = value =>
+        {
+            if (value == First)
+            {
+                source.OnNext(Second);
+                source.OnNext(Third);
+            }
+        };
+
+        using var subscription = source.WitnessLatestOn(clock).Subscribe(log);
+        source.OnNext(First);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1", "N3"])).IsTrue();
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1", "N3"])).IsTrue();
+    }
+
+    /// <summary>Completion that arrives during delivery is delivered after the value being delivered.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task CompletionArrivingDuringDeliveryFollowsTheCurrentValue()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+        LogObserver log = new();
+        log.OnValue = _ => source.OnCompleted();
+
+        using var subscription = source.WitnessLatestOn(clock).Subscribe(log);
+        source.OnNext(First);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1", "C"])).IsTrue();
+    }
+
+    /// <summary>Completion delivers the pending value first and then completes.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task CompletionDeliversThePendingValueThenCompletes()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+        LogObserver log = new();
+
+        using var subscription = source.WitnessLatestOn(clock).Subscribe(log);
+        source.OnNext(First);
+        source.OnNext(Second);
+        source.OnCompleted();
+
+        await Assert.That(log.Entries.Count).IsEqualTo(0);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N2", "C"])).IsTrue();
+    }
+
+    /// <summary>Completion with no pending value is deferred to the sequencer and delivered alone.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task CompletionWithoutAPendingValueIsDeliveredOnTheSequencer()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+        LogObserver log = new();
+
+        using var subscription = source.WitnessLatestOn(clock).Subscribe(log);
+        source.OnCompleted();
+
+        await Assert.That(log.Entries.Count).IsEqualTo(0);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["C"])).IsTrue();
+    }
+
+    /// <summary>An error delivers the pending value first and then the error.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ErrorDeliversThePendingValueThenTheError()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+        LogObserver log = new();
+        InvalidOperationException expected = new("latest");
+
+        using var subscription = source.WitnessLatestOn(clock).Subscribe(log);
+        source.OnNext(First);
+        source.OnNext(Second);
+        source.OnError(expected);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N2", "E"])).IsTrue();
+        await Assert.That(log.Errors[0]).IsSameReferenceAs(expected);
+    }
+
+    /// <summary>An error wins over a completion that arrived before it.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ErrorWinsOverAnEarlierCompletion()
+    {
+        VirtualClock clock = new();
+        IObserver<int>? upstream = null;
+        LogObserver log = new();
+
+        using var subscription = new ScriptedObservable<int>(observer => upstream = observer)
+            .WitnessLatestOn(clock)
+            .Subscribe(log);
+        upstream!.OnNext(First);
+        upstream.OnCompleted();
+        upstream.OnError(new InvalidOperationException("late"));
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1", "E"])).IsTrue();
+    }
+
+    /// <summary>A completion that arrives after an error is dropped.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task CompletionAfterAnErrorIsDropped()
+    {
+        VirtualClock clock = new();
+        IObserver<int>? upstream = null;
+        LogObserver log = new();
+
+        using var subscription = new ScriptedObservable<int>(observer => upstream = observer)
+            .WitnessLatestOn(clock)
+            .Subscribe(log);
+        upstream!.OnError(new InvalidOperationException("first"));
+        upstream.OnCompleted();
+        upstream.OnNext(First);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["E"])).IsTrue();
+    }
+
+    /// <summary>Values that arrive after completion are dropped.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ValuesAfterCompletionAreDropped()
+    {
+        VirtualClock clock = new();
+        IObserver<int>? upstream = null;
+        LogObserver log = new();
+
+        using var subscription = new ScriptedObservable<int>(observer => upstream = observer)
+            .WitnessLatestOn(clock)
+            .Subscribe(log);
+        upstream!.OnCompleted();
+        upstream.OnCompleted();
+        upstream.OnNext(First);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["C"])).IsTrue();
+    }
+
+    /// <summary>A delivered completion disposes the upstream subscription and nothing more is delivered.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task DeliveredCompletionDisposesUpstreamAndStopsDelivery()
+    {
+        VirtualClock clock = new();
+        IObserver<int>? upstream = null;
+        CountingDisposable upstreamSubscription = new();
+        LogObserver log = new();
+
+        using var subscription = new ScriptedObservable<int>(observer => upstream = observer, upstreamSubscription)
+            .WitnessLatestOn(clock)
+            .Subscribe(log);
+        upstream!.OnNext(First);
+        upstream.OnCompleted();
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(upstreamSubscription.DisposeCount).IsEqualTo(1);
+
+        upstream.OnNext(Second);
+        upstream.OnCompleted();
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1", "C"])).IsTrue();
+        await Assert.That(upstreamSubscription.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>A delivered error disposes the upstream subscription and nothing more is delivered.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task DeliveredErrorDisposesUpstreamAndStopsDelivery()
+    {
+        VirtualClock clock = new();
+        IObserver<int>? upstream = null;
+        CountingDisposable upstreamSubscription = new();
+        LogObserver log = new();
+
+        using var subscription = new ScriptedObservable<int>(observer => upstream = observer, upstreamSubscription)
+            .WitnessLatestOn(clock)
+            .Subscribe(log);
+        upstream!.OnError(new InvalidOperationException("boom"));
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(upstreamSubscription.DisposeCount).IsEqualTo(1);
+
+        upstream.OnNext(First);
+        upstream.OnError(new InvalidOperationException("again"));
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["E"])).IsTrue();
+    }
+
+    /// <summary>Dispose drops the pending value and disposes the upstream subscription exactly once.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task DisposeDropsThePendingValueAndDisposesUpstreamOnce()
+    {
+        VirtualClock clock = new();
+        IObserver<int>? upstream = null;
+        CountingDisposable upstreamSubscription = new();
+        LogObserver log = new();
+
+        var subscription = new ScriptedObservable<int>(observer => upstream = observer, upstreamSubscription)
+            .WitnessLatestOn(clock)
+            .Subscribe(log);
+        upstream!.OnNext(First);
+        subscription.Dispose();
+        subscription.Dispose();
+
+        upstream.OnNext(Second);
+        upstream.OnCompleted();
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.Count).IsEqualTo(0);
+        await Assert.That(upstreamSubscription.DisposeCount).IsEqualTo(1);
+    }
+
+    /// <summary>Disposing from inside a delivery drops the value that arrived during it.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task DisposeDuringDeliveryDropsTheHeldValue()
+    {
+        VirtualClock clock = new();
+        Signal<int> source = new();
+        LogObserver log = new();
+        IDisposable? subscription = null;
+        log.OnValue = _ =>
+        {
+            source.OnNext(Second);
+            subscription?.Dispose();
+        };
+
+        subscription = source.WitnessLatestOn(clock).Subscribe(log);
+        source.OnNext(First);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1"])).IsTrue();
+    }
+
+    /// <summary>Values and completion reach the observer without the sink's lock held, so another thread can push meanwhile.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ValuesAndCompletionAreDeliveredOutsideTheSinkLock()
+    {
+        VirtualClock clock = new();
+        IObserver<int>? upstream = null;
+        List<bool> nonBlocking = [];
+        LogObserver log = new();
+        log.OnValue = value => nonBlocking.Add(value == First
+            ? IsNonBlocking(() => upstream!.OnNext(Second))
+            : IsNonBlocking(() => upstream!.OnCompleted()));
+        log.OnTerminal = () => nonBlocking.Add(IsNonBlocking(() => upstream!.OnNext(Third)));
+
+        using var subscription = new ScriptedObservable<int>(observer =>
+            {
+                upstream = observer;
+                observer.OnNext(First);
+            })
+            .WitnessLatestOn(clock)
+            .Subscribe(log);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1", "N2", "C"])).IsTrue();
+        await Assert.That(nonBlocking.SequenceEqual([true, true, true])).IsTrue();
+    }
+
+    /// <summary>An error reaches the observer without the sink's lock held, so another thread can push meanwhile.</summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    [Test]
+    public async Task ErrorsAreDeliveredOutsideTheSinkLock()
+    {
+        VirtualClock clock = new();
+        IObserver<int>? upstream = null;
+        List<bool> nonBlocking = [];
+        LogObserver log = new();
+        log.OnValue = _ => nonBlocking.Add(IsNonBlocking(() => upstream!.OnError(new InvalidOperationException("gate"))));
+        log.OnTerminal = () => nonBlocking.Add(IsNonBlocking(() => upstream!.OnNext(Second)));
+
+        using var subscription = new ScriptedObservable<int>(observer =>
+            {
+                upstream = observer;
+                observer.OnNext(First);
+            })
+            .WitnessLatestOn(clock)
+            .Subscribe(log);
+
+        clock.AdvanceBy(SingleTick);
+
+        await Assert.That(log.Entries.SequenceEqual(["N1", "E"])).IsTrue();
+        await Assert.That(nonBlocking.SequenceEqual([true, true])).IsTrue();
+    }
+
+    /// <summary>Runs an action on another thread and reports whether it finished, which it cannot while this thread holds the sink lock.</summary>
+    /// <param name="push">The action that pushes into the sink.</param>
+    /// <returns>True when the other thread finished within the timeout; otherwise, false.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsNonBlocking(Action push)
+    {
+        Thread pusher = new(() => push()) { IsBackground = true };
+        pusher.Start();
+        return pusher.Join(ProbeTimeout);
+    }
+
+    /// <summary>An observer that records values, errors and completion in arrival order.</summary>
+    private sealed class LogObserver : IObserver<int>
+    {
+        /// <summary>Gets the ordered log; values are <c>N&lt;value&gt;</c>, errors are <c>E</c> and completion is <c>C</c>.</summary>
+        internal List<string> Entries { get; } = [];
+
+        /// <summary>Gets the recorded errors.</summary>
+        internal List<Exception> Errors { get; } = [];
+
+        /// <summary>Gets or sets the action invoked after each value is recorded.</summary>
+        internal Action<int>? OnValue { get; set; }
+
+        /// <summary>Gets or sets the action invoked after an error or completion is recorded.</summary>
+        internal Action? OnTerminal { get; set; }
+
+        /// <summary>Records a completion callback and runs <see cref="OnTerminal"/>.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void OnCompleted()
+        {
+            Entries.Add("C");
+            OnTerminal?.Invoke();
+        }
+
+        /// <summary>Records an error callback and runs <see cref="OnTerminal"/>.</summary>
+        /// <param name="error">The error to record.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void OnError(Exception error)
+        {
+            Entries.Add("E");
+            Errors.Add(error);
+            OnTerminal?.Invoke();
+        }
+
+        /// <summary>Records a value callback and runs <see cref="OnValue"/>.</summary>
+        /// <param name="value">The value to record.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void OnNext(int value)
+        {
+            Entries.Add($"N{value}");
+            OnValue?.Invoke(value);
+        }
+    }
+
+    /// <summary>A disposable that counts how many times it has been disposed.</summary>
+    private sealed class CountingDisposable : IDisposable
+    {
+        /// <summary>Gets the number of dispose calls.</summary>
+        internal int DisposeCount { get; private set; }
+
+        /// <summary>Counts a dispose call.</summary>
+        public void Dispose() => DisposeCount++;
+    }
+}