diff --git a/README.md b/README.md
index 0df3822..7ba73d7 100644
--- a/README.md
+++ b/README.md
@@ -173,6 +173,24 @@ independent parts separately and combine them with `Zip`. A `Then` lambda that r
 `invalid(...)` needs its type spelled out, `Then<int>(...)`, because union conversions take no part in type inference;
 a step that already returns a validation needs nothing.
 
+### Async
+
+```csharp
+Validated<User, string> user = await Login(form.Login)
+    .ThenAsync(login => repository.FindAsync(login));            // a dependent step that hits the database
+
+string message = await user.MatchAsync(
+    async found => await GreetAsync(found),
+    errors => string.Join("; ", errors));                         // a synchronous branch is fine too
+
+Validated<string, string> name = await user.MapAsync(found => LoadDisplayNameAsync(found));
+```
+
+The async members are deliberately few. The delegates return `Task<T>`; the methods return `ValueTask<T>`, already
+complete (and allocation-free) when the case passes through. Arguments are checked immediately; anything a delegate
+throws comes out when the result is awaited, and an `OperationCanceledException` for a requested token gives a
+canceled result.
+
 ### The uninitialized validation
 
 `Validated<T, TError>` is a struct, so `default(Validated<T, TError>)` exists, for example in a new array. It is
diff --git a/smoke/DotValid.AotSmoke/Program.cs b/smoke/DotValid.AotSmoke/Program.cs
index 562f760..5c6f151 100644
--- a/smoke/DotValid.AotSmoke/Program.cs
+++ b/smoke/DotValid.AotSmoke/Program.cs
@@ -53,6 +53,16 @@
 Check(mixed.Sequence() == invalid("empty", "too short") && mixed.Values().Sum() == 49 && mixed.Errors().Count() == 2, "Sequence, Values, Errors");
 var (passed, problems) = mixed.Partition();
 Check(passed is [42, 7] && problems is ["empty", "too short"], "Partition");
+var described = await age.MatchAsync(
+    static async value =>
+    {
+        await Task.Yield();
+        return $"valid {value}";
+    },
+    static errors => $"{errors.Length} errors");
+Check(described == "valid 42" && await failed.MatchAsync(static _ => Task.FromResult(0), static errors => errors.Length) == 2, "MatchAsync");
+Check(await age.MapAsync(static value => Task.FromResult(value + 1)) == valid(43) && await failed.MapAsync(static value => Task.FromResult(value)) == failed, "MapAsync");
+Check(await Parse("7").ThenAsync(static value => Task.FromResult(Adult(value))) == invalid("too young"), "ThenAsync");
 
 if (failures.Count > 0)
 {
diff --git a/src/DotValid/PublicAPI.Unshipped.txt b/src/DotValid/PublicAPI.Unshipped.txt
index f50924c..8eb88e7 100644
--- a/src/DotValid/PublicAPI.Unshipped.txt
+++ b/src/DotValid/PublicAPI.Unshipped.txt
@@ -25,12 +25,16 @@ DotValid.Validated<T, TError>.IUnionMembers.TryGetValue(out DotValid.Invalid<TEr
 DotValid.Validated<T, TError>.IUnionMembers.TryGetValue(out DotValid.Valid<T> value) -> bool
 DotValid.Validated<T, TError>.IUnionMembers.Value.get -> object?
 DotValid.Validated<T, TError>.Map<TResult>(System.Func<T, TResult>! map) -> DotValid.Validated<TResult, TError>
+DotValid.Validated<T, TError>.MapAsync<TResult>(System.Func<T, System.Threading.Tasks.Task<TResult>!>! map) -> System.Threading.Tasks.ValueTask<DotValid.Validated<TResult, TError>>
 DotValid.Validated<T, TError>.MapError<TNewError>(System.Func<TError, TNewError>! map) -> DotValid.Validated<T, TNewError>
 DotValid.Validated<T, TError>.Match<TResult>(System.Func<T, TResult>! valid, System.Func<System.Collections.Immutable.ImmutableArray<TError>, TResult>! invalid) -> TResult
+DotValid.Validated<T, TError>.MatchAsync<TResult>(System.Func<T, System.Threading.Tasks.Task<TResult>!>! valid, System.Func<System.Collections.Immutable.ImmutableArray<TError>, System.Threading.Tasks.Task<TResult>!>! invalid) -> System.Threading.Tasks.ValueTask<TResult>
+DotValid.Validated<T, TError>.MatchAsync<TResult>(System.Func<T, System.Threading.Tasks.Task<TResult>!>! valid, System.Func<System.Collections.Immutable.ImmutableArray<TError>, TResult>! invalid) -> System.Threading.Tasks.ValueTask<TResult>
 DotValid.Validated<T, TError>.OrDefault(System.Func<System.Collections.Immutable.ImmutableArray<TError>, T>! fallback) -> T
 DotValid.Validated<T, TError>.OrDefault(T fallback) -> T
 DotValid.Validated<T, TError>.Select<TResult>(System.Func<T, TResult>! selector) -> DotValid.Validated<TResult, TError>
 DotValid.Validated<T, TError>.Then<TResult>(System.Func<T, DotValid.Validated<TResult, TError>>! next) -> DotValid.Validated<TResult, TError>
+DotValid.Validated<T, TError>.ThenAsync<TResult>(System.Func<T, System.Threading.Tasks.Task<DotValid.Validated<TResult, TError>>!>! next) -> System.Threading.Tasks.ValueTask<DotValid.Validated<TResult, TError>>
 DotValid.Validated<T, TError>.Validated() -> void
 DotValid.Validated<T, TError>.Zip<TOther, TResult>(DotValid.Validated<TOther, TError> other, System.Func<T, TOther, TResult>! combine) -> DotValid.Validated<TResult, TError>
 DotValid.Validated<T, TError>.Zip<TOther>(DotValid.Validated<TOther, TError> other) -> DotValid.Validated<(T, TOther), TError>
diff --git a/src/DotValid/Validated.Async.cs b/src/DotValid/Validated.Async.cs
new file mode 100644
index 0000000..62517be
--- /dev/null
+++ b/src/DotValid/Validated.Async.cs
@@ -0,0 +1,154 @@
+using System.Collections.Immutable;
+
+namespace DotValid;
+
+/// <content>
+/// Asynchronous counterparts of <c>Match</c>, <c>Map</c> and <c>Then</c> (V10, minimal on purpose).
+/// </content>
+/// <remarks>
+/// <para>
+/// The delegates return <see cref="Task{TResult}"/>, so any async lambda or Task-returning method fits. The methods
+/// return <see cref="ValueTask{TResult}"/>: when there is nothing to wait for, the result is already complete and
+/// nothing is allocated.
+/// </para>
+/// <para>
+/// Arguments and the uninitialized default are rejected immediately, when the method is called. Anything a delegate
+/// does, including throwing before it returns a task, comes out when the result is awaited; an
+/// <see cref="OperationCanceledException"/> for a requested token gives a canceled result.
+/// </para>
+/// </remarks>
+public readonly partial struct Validated<T, TError>
+{
+    /// <summary>
+    /// Asynchronously reduces this validation to a single value: <paramref name="valid"/> runs on the value,
+    /// <paramref name="invalid"/> on the errors. Exactly one of them runs, exactly once.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the value both branches produce.</typeparam>
+    /// <param name="valid">Produces the value from the value of a valid validation.</param>
+    /// <param name="invalid">Produces the value from the errors, in order.</param>
+    /// <returns>The value produced by the branch that ran.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="valid"/> or <paramref name="invalid"/> is null.</exception>
+    /// <exception cref="InvalidOperationException">The validation is uninitialized (default).</exception>
+    public ValueTask<TResult> MatchAsync<TResult>(Func<T, Task<TResult>> valid, Func<ImmutableArray<TError>, Task<TResult>> invalid)
+    {
+        ArgumentNullException.ThrowIfNull(valid);
+        ArgumentNullException.ThrowIfNull(invalid);
+        return _case switch
+        {
+            ValidatedCase.Valid => Start(valid, _valid.Value),
+            ValidatedCase.Invalid => Start(invalid, _invalid.Errors),
+            _ => throw Uninitialized(),
+        };
+    }
+
+    /// <summary>
+    /// Asynchronously reduces this validation to a single value, with a synchronous <paramref name="invalid"/> branch
+    /// (typically turning the errors into a message). For an invalid validation the result is already complete.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the value both branches produce.</typeparam>
+    /// <param name="valid">Produces the value from the value of a valid validation.</param>
+    /// <param name="invalid">Produces the value from the errors, in order.</param>
+    /// <returns>The value produced by the branch that ran.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="valid"/> or <paramref name="invalid"/> is null.</exception>
+    /// <exception cref="InvalidOperationException">The validation is uninitialized (default).</exception>
+    public ValueTask<TResult> MatchAsync<TResult>(Func<T, Task<TResult>> valid, Func<ImmutableArray<TError>, TResult> invalid)
+    {
+        ArgumentNullException.ThrowIfNull(valid);
+        ArgumentNullException.ThrowIfNull(invalid);
+        return _case switch
+        {
+            ValidatedCase.Valid => Start(valid, _valid.Value),
+            ValidatedCase.Invalid => Evaluate(invalid, _invalid.Errors),
+            _ => throw Uninitialized(),
+        };
+    }
+
+    /// <summary>
+    /// Asynchronously transforms the value of a valid validation; the errors of an invalid one pass through at once,
+    /// without waiting.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the transformed value.</typeparam>
+    /// <param name="map">Transforms the value.</param>
+    /// <returns>A valid validation with the transformed value, or the same errors.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="map"/> is null.</exception>
+    /// <exception cref="InvalidOperationException">
+    /// The validation is uninitialized (default); or, when awaited, <paramref name="map"/> produced <see langword="null"/>.
+    /// </exception>
+    public ValueTask<Validated<TResult, TError>> MapAsync<TResult>(Func<T, Task<TResult>> map)
+        where TResult : notnull
+    {
+        ArgumentNullException.ThrowIfNull(map);
+        return _case switch
+        {
+            ValidatedCase.Valid => MapValueAsync(_valid.Value, map),
+            ValidatedCase.Invalid => ValueTask.FromResult(new Validated<TResult, TError>(_invalid)),
+            _ => throw Uninitialized(),
+        };
+
+        static async ValueTask<Validated<TResult, TError>> MapValueAsync(T value, Func<T, Task<TResult>> map) =>
+            new(new Valid<TResult>(Produced(await map(value).ConfigureAwait(false), nameof(map))));
+    }
+
+    /// <summary>
+    /// Continues a valid validation with an asynchronous step that depends on the value, for example a database check;
+    /// the errors of an invalid one pass through at once, without waiting. Like <see cref="Then{TResult}"/>, it never
+    /// accumulates errors.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the value produced by the next step.</typeparam>
+    /// <param name="next">The next step.</param>
+    /// <returns>The validation produced by the next step, or the same errors.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="next"/> is null.</exception>
+    /// <exception cref="InvalidOperationException">
+    /// The validation is uninitialized (default); or, when awaited, <paramref name="next"/> produced an uninitialized
+    /// validation.
+    /// </exception>
+    public ValueTask<Validated<TResult, TError>> ThenAsync<TResult>(Func<T, Task<Validated<TResult, TError>>> next)
+        where TResult : notnull
+    {
+        ArgumentNullException.ThrowIfNull(next);
+        return _case switch
+        {
+            ValidatedCase.Valid => ThenValueAsync(_valid.Value, next),
+            ValidatedCase.Invalid => ValueTask.FromResult(new Validated<TResult, TError>(_invalid)),
+            _ => throw Uninitialized(),
+        };
+
+        static async ValueTask<Validated<TResult, TError>> ThenValueAsync(
+            T value,
+            Func<T, Task<Validated<TResult, TError>>> next) =>
+            Validated<TResult, TError>.Initialized(await next(value).ConfigureAwait(false), nameof(next));
+    }
+
+    // R8: a delegate's synchronous throw comes out through the ValueTask; a requested cancellation cancels it.
+    private static ValueTask<TResult> Start<TArg, TResult>(Func<TArg, Task<TResult>> step, TArg arg)
+    {
+        try
+        {
+            return new ValueTask<TResult>(step(arg));
+        }
+        catch (OperationCanceledException canceled) when (canceled.CancellationToken.IsCancellationRequested)
+        {
+            return ValueTask.FromCanceled<TResult>(canceled.CancellationToken);
+        }
+        catch (Exception exception)
+        {
+            return ValueTask.FromException<TResult>(exception);
+        }
+    }
+
+    private static ValueTask<TResult> Evaluate<TArg, TResult>(Func<TArg, TResult> step, TArg arg)
+    {
+        try
+        {
+            return ValueTask.FromResult(step(arg));
+        }
+        catch (OperationCanceledException canceled) when (canceled.CancellationToken.IsCancellationRequested)
+        {
+            return ValueTask.FromCanceled<TResult>(canceled.CancellationToken);
+        }
+        catch (Exception exception)
+        {
+            return ValueTask.FromException<TResult>(exception);
+        }
+    }
+}
diff --git a/tests/DotValid.PropertyTests/AllocationProperties.cs b/tests/DotValid.PropertyTests/AllocationProperties.cs
index 5dde1e3..2d903d9 100644
--- a/tests/DotValid.PropertyTests/AllocationProperties.cs
+++ b/tests/DotValid.PropertyTests/AllocationProperties.cs
@@ -112,6 +112,19 @@ public void Building_blocks_on_the_valid_path_allocate_nothing(int value)
         Allocations.AssertNone("ValidationError", () => _ = new ValidationError("Name", "is empty"));
     }
 
+    [Property(Skip = Allocations.SkipInDebug)]
+    public void Async_members_with_completed_tasks_allocate_nothing(Validated<int, int> validated)
+    {
+        Allocations.AssertNone(
+            "MatchAsync(async, async)",
+            () => _ = validated.MatchAsync(static _ => CompletedOne, static _ => CompletedOne).IsCompleted);
+        Allocations.AssertNone(
+            "MatchAsync(async, sync)",
+            () => _ = validated.MatchAsync(static _ => CompletedOne, static errors => errors.Length).IsCompleted);
+        Allocations.AssertNone("MapAsync", () => _ = validated.MapAsync(static _ => CompletedOne).IsCompleted);
+        Allocations.AssertNone("ThenAsync", () => _ = validated.ThenAsync(static _ => CompletedValidOne).IsCompleted);
+    }
+
     [Property(Skip = Allocations.SkipInDebug)]
     public void Comparing_allocates_nothing(Validated<int, int> validated, Validated<int, int> other)
     {
@@ -124,6 +137,10 @@ public void Comparing_allocates_nothing(Validated<int, int> validated, Validated
 
     private const string? Text = "text";
 
+    // Tasks completed in advance: any allocation in the async tests comes from the library, not from the delegate.
+    private static readonly Task<int> CompletedOne = Task.FromResult(1);
+    private static readonly Task<Validated<int, int>> CompletedValidOne = Task.FromResult(Validations.Valid<int, int>(1));
+
     private static Validated<int, int> Succeed(int value) => valid(value);
 
     private static Validated<int, int> Fail(Invalid<int> failure) => failure;
diff --git a/tests/DotValid.PropertyTests/AsyncProperties.cs b/tests/DotValid.PropertyTests/AsyncProperties.cs
new file mode 100644
index 0000000..61a9af8
--- /dev/null
+++ b/tests/DotValid.PropertyTests/AsyncProperties.cs
@@ -0,0 +1,212 @@
+using System.Collections.Immutable;
+using FsCheck;
+using FsCheck.Xunit;
+
+namespace DotValid.PropertyTests;
+
+/// <summary>
+/// V10: the asynchronous members agree with their synchronous counterparts, with dotResult's R8 semantics. Arguments
+/// and the uninitialized default are checked immediately; whatever a delegate does, including throwing before it
+/// returns a task, comes out when the result is awaited; cancellation for a requested token gives a canceled result;
+/// and the case that passes through is already complete.
+/// </summary>
+public sealed class AsyncProperties : IDisposable
+{
+    private readonly CancellationTokenSource _source = new();
+
+    public AsyncProperties() => _source.Cancel();
+
+    private CancellationToken Canceled => _source.Token;
+
+    public void Dispose() => _source.Dispose();
+
+    [Property]
+    public async Task MatchAsync_agrees_with_Match(Validated<int, string> validated, bool yields)
+    {
+        var expected = validated.Match(value => $"valid {value}", errors => $"invalid {errors.Length}");
+
+        Assert.Equal(
+            expected,
+            await validated.MatchAsync(value => Deferred.Lift($"valid {value}", yields), errors => Deferred.Lift($"invalid {errors.Length}", yields)));
+        Assert.Equal(
+            expected,
+            await validated.MatchAsync(value => Deferred.Lift($"valid {value}", yields), errors => $"invalid {errors.Length}"));
+    }
+
+    [Property]
+    public async Task Exactly_one_branch_of_MatchAsync_runs_exactly_once(Validated<int, string> validated, bool yields)
+    {
+        var validCalls = 0;
+        var invalidCalls = 0;
+
+        _ = await validated.MatchAsync(_ => Deferred.Lift(++validCalls, yields), _ => Deferred.Lift(++invalidCalls, yields));
+        _ = await validated.MatchAsync(_ => Deferred.Lift(++validCalls, yields), _ => ++invalidCalls);
+
+        Assert.Equal(validated is Valid<int> ? 2 : 0, validCalls);
+        Assert.Equal(validated is Invalid<string> ? 2 : 0, invalidCalls);
+    }
+
+    [Property]
+    public async Task MapAsync_and_ThenAsync_agree_with_Map_and_Then(
+        Validated<int, string> validated,
+        Func<int, string> map,
+        Func<int, Validated<bool, string>> next,
+        bool yields)
+    {
+        Assert.Equal(validated.Map(map), await validated.MapAsync(value => Deferred.Lift(map(value), yields)));
+        Assert.Equal(validated.Then(next), await validated.ThenAsync(value => Deferred.Lift(next(value), yields)));
+    }
+
+    [Property]
+    public void An_invalid_validation_passes_through_at_once_and_nothing_runs(NonEmptyArray<int> errors)
+    {
+        var calls = 0;
+        var invalidated = Validations.Invalid<string, int>(errors.Get);
+
+        var mapped = invalidated.MapAsync(text => Task.FromResult(++calls));
+        var continued = invalidated.ThenAsync(text => Task.FromResult(Validations.Valid<int, int>(++calls)));
+        var matched = invalidated.MatchAsync(_ => Task.FromResult(++calls), all => all.Length);
+
+        Assert.True(mapped.IsCompletedSuccessfully && continued.IsCompletedSuccessfully && matched.IsCompletedSuccessfully);
+        ValidatedAssert.IsInvalid(errors.Get, mapped.Result);
+        ValidatedAssert.IsInvalid(errors.Get, continued.Result);
+        Assert.Equal(errors.Get.Length, matched.Result);
+        Assert.Equal(0, calls);
+    }
+
+    [Property]
+    public async Task What_a_delegate_throws_comes_out_only_when_awaited(Validated<int, string> validated)
+    {
+        var thrown = new InvalidOperationException("thrown by the delegate");
+        Func<int, Task<int>> throwingValid = _ => throw thrown;
+        Func<ImmutableArray<string>, Task<int>> throwingInvalid = _ => throw thrown;
+
+        await AssertFailsOnlyWhenAwaited(thrown, () => validated.MatchAsync(throwingValid, throwingInvalid));
+        if (validated is Valid<int>)
+        {
+            await AssertFailsOnlyWhenAwaited(thrown, () => validated.MapAsync(throwingValid));
+            await AssertFailsOnlyWhenAwaited(thrown, () => validated.ThenAsync<int>(_ => throw thrown));
+        }
+    }
+
+    [Property]
+    public async Task A_throwing_synchronous_invalid_branch_comes_out_only_when_awaited(NonEmptyArray<int> errors)
+    {
+        var thrown = new InvalidOperationException("thrown by the invalid branch");
+
+        await AssertFailsOnlyWhenAwaited(
+            thrown,
+            () => Validations.Invalid<string, int>(errors.Get).MatchAsync(_ => Task.FromResult(0), (Func<ImmutableArray<int>, int>)(_ => throw thrown)));
+    }
+
+    [Fact]
+    public async Task The_library_never_resumes_on_the_callers_synchronization_context()
+    {
+        var context = new CountingContext();
+        var validated = Validations.Valid<int, string>(1);
+        var map = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var next = new TaskCompletionSource<Validated<int, string>>(TaskCreationOptions.RunContinuationsAsynchronously);
+        ValueTask<Validated<int, string>> mapped;
+        ValueTask<Validated<int, string>> continued;
+
+        var previous = SynchronizationContext.Current;
+        SynchronizationContext.SetSynchronizationContext(context);
+        try
+        {
+            mapped = validated.MapAsync(_ => map.Task);
+            continued = validated.ThenAsync(_ => next.Task);
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(previous);
+        }
+
+        map.SetResult(2);
+        next.SetResult(Validations.Valid<int, string>(3));
+
+        Assert.Equal(Validations.Valid<int, string>(2), await mapped);
+        Assert.Equal(Validations.Valid<int, string>(3), await continued);
+        Assert.Equal(0, context.Posts);
+    }
+
+    [Property]
+    public async Task A_null_or_uninitialized_result_of_a_step_fails_when_awaited(int value)
+    {
+        var validated = Validations.Valid<int, string>(value);
+
+        var mapped = validated.MapAsync(_ => Task.FromResult((string)null!));
+        var continued = validated.ThenAsync(_ => Task.FromResult(default(Validated<int, string>)));
+
+        Assert.StartsWith("'map' returned null", (await Assert.ThrowsAsync<InvalidOperationException>(async () => await mapped)).Message, StringComparison.Ordinal);
+        Assert.StartsWith("'next' returned an uninitialized", (await Assert.ThrowsAsync<InvalidOperationException>(async () => await continued)).Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task Cancellation_for_a_requested_token_gives_a_canceled_result()
+    {
+        var validated = Validations.Valid<int, string>(1);
+        var invalidated = Validations.Invalid<int, string>("boom");
+        Func<int, Task<int>> throws = _ =>
+        {
+            Canceled.ThrowIfCancellationRequested();
+            return Task.FromResult(0);
+        };
+        Func<int, Task<int>> canceled = _ => Task.FromCanceled<int>(Canceled);
+        Func<ImmutableArray<string>, int> throwsSync = _ =>
+        {
+            Canceled.ThrowIfCancellationRequested();
+            return 0;
+        };
+
+        await AssertCanceled(validated.MatchAsync(throws, _ => 0));
+        await AssertCanceled(validated.MatchAsync(canceled, _ => Task.FromResult(0)));
+        await AssertCanceled(invalidated.MatchAsync(throws, throwsSync));
+        await AssertCanceled(invalidated.MatchAsync(throws, _ => Task.FromCanceled<int>(Canceled)));
+        await AssertCanceled(validated.MapAsync(throws));
+        await AssertCanceled(validated.MapAsync(canceled));
+        await AssertCanceled(validated.ThenAsync(_ => Task.FromCanceled<Validated<int, string>>(Canceled)));
+    }
+
+    [Property]
+    public void Missing_delegates_are_rejected_immediately_whatever_the_case(Validated<int, string> validated)
+    {
+        Assert.Equal("valid", Assert.Throws<ArgumentNullException>(() => validated.MatchAsync((Func<int, Task<int>>)null!, (Func<ImmutableArray<string>, Task<int>>)(_ => Task.FromResult(0)))).ParamName);
+        Assert.Equal("invalid", Assert.Throws<ArgumentNullException>(() => validated.MatchAsync(_ => Task.FromResult(0), (Func<ImmutableArray<string>, Task<int>>)null!)).ParamName);
+        Assert.Equal("valid", Assert.Throws<ArgumentNullException>(() => validated.MatchAsync(null!, _ => 0)).ParamName);
+        Assert.Equal("invalid", Assert.Throws<ArgumentNullException>(() => validated.MatchAsync(_ => Task.FromResult(0), (Func<ImmutableArray<string>, int>)null!)).ParamName);
+        Assert.Equal("map", Assert.Throws<ArgumentNullException>(() => validated.MapAsync((Func<int, Task<int>>)null!)).ParamName);
+        Assert.Equal("next", Assert.Throws<ArgumentNullException>(() => validated.ThenAsync((Func<int, Task<Validated<int, string>>>)null!)).ParamName);
+    }
+
+    // Counts continuations posted back to it; ConfigureAwait(false) in the library means none.
+    private sealed class CountingContext : SynchronizationContext
+    {
+        private int _posts;
+
+        public int Posts => Volatile.Read(ref _posts);
+
+        public override void Post(SendOrPostCallback d, object? state)
+        {
+            Interlocked.Increment(ref _posts);
+            base.Post(d, state);
+        }
+    }
+
+    private static async Task AssertFailsOnlyWhenAwaited<TResult>(Exception expected, Func<ValueTask<TResult>> call)
+    {
+        ValueTask<TResult> pending = default;
+
+        var thrownByTheCall = Record.Exception(() => { pending = call(); });
+
+        Assert.Null(thrownByTheCall);
+        Assert.Same(expected, await Assert.ThrowsAnyAsync<Exception>(async () => await pending));
+    }
+
+    private static async Task AssertCanceled<TResult>(ValueTask<TResult> pending)
+    {
+        var task = pending.AsTask();
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => task);
+        Assert.True(task.IsCanceled, "Expected the result to be canceled, not faulted or successful.");
+    }
+}
diff --git a/tests/DotValid.PropertyTests/UninitializedProperties.cs b/tests/DotValid.PropertyTests/UninitializedProperties.cs
index 040081b..65d0b93 100644
--- a/tests/DotValid.PropertyTests/UninitializedProperties.cs
+++ b/tests/DotValid.PropertyTests/UninitializedProperties.cs
@@ -154,6 +154,20 @@ public void Collections_throw_when_they_read_one()
         Assert.Equal(2, calls);
     }
 
+    [Fact]
+    public void Async_members_throw_immediately_and_run_nothing()
+    {
+        var calls = 0;
+
+        Assert.Throws<InvalidOperationException>(
+            () => Uninitialized.MatchAsync(_ => Task.FromResult(++calls), _ => Task.FromResult(++calls)));
+        Assert.Throws<InvalidOperationException>(() => Uninitialized.MatchAsync(_ => Task.FromResult(++calls), _ => ++calls));
+        Assert.Throws<InvalidOperationException>(() => Uninitialized.MapAsync(value => Task.FromResult(++calls + value)));
+        Assert.Throws<InvalidOperationException>(
+            () => Uninitialized.ThenAsync(value => Task.FromResult(Validations.Valid<int, string>(++calls))));
+        Assert.Equal(0, calls);
+    }
+
     [Fact]
     public void The_union_members_report_no_case()
     {