diff --git a/TUnit.Assertions.Tests/Bugs/Issue5706Tests.cs b/TUnit.Assertions.Tests/Bugs/Issue5706Tests.cs
new file mode 100644
index 0000000000..10dca85cc3
--- /dev/null
+++ b/TUnit.Assertions.Tests/Bugs/Issue5706Tests.cs
@@ -0,0 +1,188 @@
+namespace TUnit.Assertions.Tests.Bugs;
+
+/// <summary>
+/// Regression tests for GitHub issue #5706:
+/// ItemAt(...).Satisfies(...) should preserve specialised assertion sources for
+/// collection-like item values instead of exposing only IAssertionSource&lt;TItem&gt;.
+/// </summary>
+public class Issue5706Tests
+{
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_String_Item_Source()
+    {
+        IList<string> items = new List<string> { "alpha" };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Contains("pha"));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_Collection_Item_Source()
+    {
+        IList<IEnumerable<int>> items = new List<IEnumerable<int>> { new[] { 1, 2, 3 } };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_IList_Item_Source()
+    {
+        IList<IList<int>> items = new List<IList<int>> { new List<int> { 1, 2, 3 } };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_IReadOnlyList_Item_Source()
+    {
+        IList<IReadOnlyList<int>> items = new List<IReadOnlyList<int>> { new List<int> { 1, 2, 3 } };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_Array_Item_Source()
+    {
+        IList<int[]> items = new List<int[]> { new[] { 1, 2, 3 } };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_ConcreteList_Item_Source()
+    {
+        IList<List<int>> items = new List<List<int>> { new() { 1, 2, 3 } };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_Dictionary_Item_Source()
+    {
+        IList<IDictionary<string, int>> items = new List<IDictionary<string, int>>
+        {
+            new Dictionary<string, int> { ["answer"] = 42 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.ContainsKey("answer"));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_Concrete_Dictionary_Item_Source()
+    {
+        IList<Dictionary<string, int>> items = new List<Dictionary<string, int>>
+        {
+            new() { ["answer"] = 42 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.ContainsKey("answer"));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_Set_Item_Source()
+    {
+        IList<ISet<int>> items = new List<ISet<int>>
+        {
+            new HashSet<int> { 1, 2, 3 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.IsSupersetOf(new[] { 1, 2 }));
+    }
+
+    [Test]
+    public async Task List_ItemAt_Satisfies_Preserves_HashSet_Item_Source()
+    {
+        IList<HashSet<int>> items = new List<HashSet<int>>
+        {
+            new() { 1, 2, 3 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.IsSupersetOf(new[] { 1, 2 }));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_String_Item_Source()
+    {
+        IReadOnlyList<string> items = new List<string> { "alpha" };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Contains("pha"));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_Collection_Item_Source()
+    {
+        IReadOnlyList<List<int>> items = new List<List<int>>
+        {
+            new() { 1, 2, 3 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_IList_Item_Source()
+    {
+        IReadOnlyList<IList<int>> items = new List<IList<int>> { new List<int> { 1, 2, 3 } };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_IReadOnlyList_Item_Source()
+    {
+        IReadOnlyList<IReadOnlyList<int>> items = new List<IReadOnlyList<int>> { new List<int> { 1, 2, 3 } };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_Array_Item_Source()
+    {
+        IReadOnlyList<int[]> items = new List<int[]> { new[] { 1, 2, 3 } };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_Dictionary_Item_Source()
+    {
+        IReadOnlyList<Dictionary<string, int>> items = new List<Dictionary<string, int>>
+        {
+            new() { ["answer"] = 42 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.ContainsKey("answer"));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_ReadOnly_Dictionary_Item_Source()
+    {
+        IReadOnlyList<IReadOnlyDictionary<string, int>> items = new List<IReadOnlyDictionary<string, int>>
+        {
+            new Dictionary<string, int> { ["answer"] = 42 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.ContainsKey("answer"));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_Set_Item_Source()
+    {
+        IReadOnlyList<HashSet<int>> items = new List<HashSet<int>>
+        {
+            new() { 1, 2, 3 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.IsSupersetOf(new[] { 1, 2 }));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_ItemAt_Satisfies_Preserves_ReadOnly_Set_Item_Source()
+    {
+        IReadOnlyList<IReadOnlySet<int>> items = new List<IReadOnlySet<int>>
+        {
+            new HashSet<int> { 1, 2, 3 }
+        };
+
+        await Assert.That(items).ItemAt(0).Satisfies(item => item.IsSupersetOf(new[] { 1, 2 }));
+    }
+}
diff --git a/TUnit.Assertions.Tests/Bugs/Issue5778Tests.cs b/TUnit.Assertions.Tests/Bugs/Issue5778Tests.cs
new file mode 100644
index 0000000000..64f789bba0
--- /dev/null
+++ b/TUnit.Assertions.Tests/Bugs/Issue5778Tests.cs
@@ -0,0 +1,188 @@
+namespace TUnit.Assertions.Tests.Bugs;
+
+/// <summary>
+/// Regression tests mirroring <see cref="Issue5706Tests"/> for the LastItem path.
+/// LastItem(...).Satisfies(...) should preserve specialised assertion sources for
+/// collection-like item values instead of exposing only IAssertionSource&lt;TItem&gt;.
+/// </summary>
+public class Issue5778Tests
+{
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_String_Item_Source()
+    {
+        IList<string> items = new List<string> { "alpha" };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Contains("pha"));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_Collection_Item_Source()
+    {
+        IList<IEnumerable<int>> items = new List<IEnumerable<int>> { new[] { 1, 2, 3 } };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_IList_Item_Source()
+    {
+        IList<IList<int>> items = new List<IList<int>> { new List<int> { 1, 2, 3 } };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_IReadOnlyList_Item_Source()
+    {
+        IList<IReadOnlyList<int>> items = new List<IReadOnlyList<int>> { new List<int> { 1, 2, 3 } };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_Array_Item_Source()
+    {
+        IList<int[]> items = new List<int[]> { new[] { 1, 2, 3 } };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_ConcreteList_Item_Source()
+    {
+        IList<List<int>> items = new List<List<int>> { new() { 1, 2, 3 } };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_Dictionary_Item_Source()
+    {
+        IList<IDictionary<string, int>> items = new List<IDictionary<string, int>>
+        {
+            new Dictionary<string, int> { ["answer"] = 42 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.ContainsKey("answer"));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_Concrete_Dictionary_Item_Source()
+    {
+        IList<Dictionary<string, int>> items = new List<Dictionary<string, int>>
+        {
+            new() { ["answer"] = 42 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.ContainsKey("answer"));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_Set_Item_Source()
+    {
+        IList<ISet<int>> items = new List<ISet<int>>
+        {
+            new HashSet<int> { 1, 2, 3 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.IsSupersetOf(new[] { 1, 2 }));
+    }
+
+    [Test]
+    public async Task List_LastItem_Satisfies_Preserves_HashSet_Item_Source()
+    {
+        IList<HashSet<int>> items = new List<HashSet<int>>
+        {
+            new() { 1, 2, 3 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.IsSupersetOf(new[] { 1, 2 }));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_String_Item_Source()
+    {
+        IReadOnlyList<string> items = new List<string> { "alpha" };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Contains("pha"));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_Collection_Item_Source()
+    {
+        IReadOnlyList<List<int>> items = new List<List<int>>
+        {
+            new() { 1, 2, 3 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_IList_Item_Source()
+    {
+        IReadOnlyList<IList<int>> items = new List<IList<int>> { new List<int> { 1, 2, 3 } };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_IReadOnlyList_Item_Source()
+    {
+        IReadOnlyList<IReadOnlyList<int>> items = new List<IReadOnlyList<int>> { new List<int> { 1, 2, 3 } };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_Array_Item_Source()
+    {
+        IReadOnlyList<int[]> items = new List<int[]> { new[] { 1, 2, 3 } };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.Count().IsEqualTo(3));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_Dictionary_Item_Source()
+    {
+        IReadOnlyList<Dictionary<string, int>> items = new List<Dictionary<string, int>>
+        {
+            new() { ["answer"] = 42 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.ContainsKey("answer"));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_ReadOnly_Dictionary_Item_Source()
+    {
+        IReadOnlyList<IReadOnlyDictionary<string, int>> items = new List<IReadOnlyDictionary<string, int>>
+        {
+            new Dictionary<string, int> { ["answer"] = 42 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.ContainsKey("answer"));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_Set_Item_Source()
+    {
+        IReadOnlyList<HashSet<int>> items = new List<HashSet<int>>
+        {
+            new() { 1, 2, 3 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.IsSupersetOf(new[] { 1, 2 }));
+    }
+
+    [Test]
+    public async Task ReadOnlyList_LastItem_Satisfies_Preserves_ReadOnly_Set_Item_Source()
+    {
+        IReadOnlyList<IReadOnlySet<int>> items = new List<IReadOnlySet<int>>
+        {
+            new HashSet<int> { 1, 2, 3 }
+        };
+
+        await Assert.That(items).LastItem().Satisfies(item => item.IsSupersetOf(new[] { 1, 2 }));
+    }
+}
diff --git a/TUnit.Assertions/Conditions/ListAssertions.cs b/TUnit.Assertions/Conditions/ListAssertions.cs
index 904de2ad88..4ca5e25cc4 100644
--- a/TUnit.Assertions/Conditions/ListAssertions.cs
+++ b/TUnit.Assertions/Conditions/ListAssertions.cs
@@ -62,6 +62,9 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> me
 /// This enables patterns like: Assert.That(list).ItemAt(0).IsEqualTo(expected)
 /// </summary>
 public class ListItemAtSource<TList, TItem> : IAssertionSource<TItem>
+#if !NETSTANDARD2_0
+    , IItemSatisfiesSource<TItem, ListItemAtSatisfiesAssertion<TList, TItem>>
+#endif
     where TList : IList<TItem>
 {
     private readonly AssertionContext<TList> _listContext;
@@ -126,6 +129,33 @@ public ListItemAtNullAssertion<TList, TItem> IsNotNull()
     public ListItemAtSatisfiesAssertion<TList, TItem> Satisfies(
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion,
         [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+    {
+        return CreateSatisfiesAssertion(
+            (item, index) => assertion(new ValueAssertion<TItem>(item, $"item[{index}]")),
+            expression);
+    }
+
+#if !NETSTANDARD2_0
+    /// <summary>
+    /// Asserts that the item at the index satisfies the given assertion expressed against
+    /// a specialised assertion source <typeparamref name="TSource"/>. The source is constructed
+    /// per-item via its static <see cref="IAssertionSourceFor{TItem,TSelf}.Create"/> factory.
+    /// Specify <typeparamref name="TSource"/> explicitly or via a typed lambda parameter.
+    /// </summary>
+    public ListItemAtSatisfiesAssertion<TList, TItem> Satisfies<TSource>(
+        Func<TSource, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        where TSource : IAssertionSourceFor<TItem, TSource>
+    {
+        return CreateSatisfiesAssertion(
+            (item, index) => assertion(TSource.Create(item, $"item[{index}]")),
+            expression);
+    }
+#endif
+
+    internal ListItemAtSatisfiesAssertion<TList, TItem> CreateSatisfiesAssertion(
+        Func<TItem, int, IAssertion?> assertion,
+        string? expression)
     {
         _listContext.ExpressionBuilder.Append($".Satisfies({expression})");
         return new ListItemAtSatisfiesAssertion<TList, TItem>(_listContext, _index, assertion);
@@ -179,6 +209,9 @@ public IsNotAssignableFromAssertion<TExpected, TItem> IsNotAssignableFrom<TExpec
 /// This enables patterns like: Assert.That(list).LastItem().IsEqualTo(expected)
 /// </summary>
 public class ListLastItemSource<TList, TItem> : IAssertionSource<TItem>
+#if !NETSTANDARD2_0
+    , IItemSatisfiesSource<TItem, ListLastItemSatisfiesAssertion<TList, TItem>>
+#endif
     where TList : IList<TItem>
 {
     private readonly AssertionContext<TList> _listContext;
@@ -241,6 +274,33 @@ public ListLastItemNullAssertion<TList, TItem> IsNotNull()
     public ListLastItemSatisfiesAssertion<TList, TItem> Satisfies(
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion,
         [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+    {
+        return CreateSatisfiesAssertion(
+            item => assertion(new ValueAssertion<TItem>(item, "lastItem")),
+            expression);
+    }
+
+#if !NETSTANDARD2_0
+    /// <summary>
+    /// Asserts that the last item satisfies the given assertion expressed against
+    /// a specialised assertion source <typeparamref name="TSource"/>. The source is constructed
+    /// from the last item via its static <see cref="IAssertionSourceFor{TItem,TSelf}.Create"/> factory.
+    /// Specify <typeparamref name="TSource"/> explicitly or via a typed lambda parameter.
+    /// </summary>
+    public ListLastItemSatisfiesAssertion<TList, TItem> Satisfies<TSource>(
+        Func<TSource, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        where TSource : IAssertionSourceFor<TItem, TSource>
+    {
+        return CreateSatisfiesAssertion(
+            item => assertion(TSource.Create(item, "lastItem")),
+            expression);
+    }
+#endif
+
+    internal ListLastItemSatisfiesAssertion<TList, TItem> CreateSatisfiesAssertion(
+        Func<TItem, IAssertion?> assertion,
+        string? expression)
     {
         _listContext.ExpressionBuilder.Append($".Satisfies({expression})");
         return new ListLastItemSatisfiesAssertion<TList, TItem>(_listContext, assertion);
@@ -420,12 +480,30 @@ public class ListItemAtSatisfiesAssertion<TList, TItem> : ListAssertionBase<TLis
     where TList : IList<TItem>
 {
     private readonly int _index;
-    private readonly Func<IAssertionSource<TItem>, Assertion<TItem>?> _assertion;
+    private readonly Func<TItem, int, IAssertion?> _assertion;
 
+    /// <summary>
+    /// Backward-compatible constructor preserved for direct consumers from before the
+    /// internal refactor to a raw-item delegate. Wraps the supplied factory in a
+    /// <see cref="ValueAssertion{TItem}"/> — the unspecialised path. Internal callers should
+    /// use the <see cref="ListItemAtSource{TList,TItem}.Satisfies{TSource}"/> entry point
+    /// to get specialised assertion sources.
+    /// </summary>
     public ListItemAtSatisfiesAssertion(
         AssertionContext<TList> context,
         int index,
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion)
+        : this(
+            context,
+            index,
+            (item, itemIndex) => assertion(new ValueAssertion<TItem>(item, $"item[{itemIndex}]")))
+    {
+    }
+
+    internal ListItemAtSatisfiesAssertion(
+        AssertionContext<TList> context,
+        int index,
+        Func<TItem, int, IAssertion?> assertion)
         : base(context)
     {
         _index = index;
@@ -451,8 +529,7 @@ protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<TLi
         }
 
         var actualItem = metadata.Value[_index];
-        var itemSource = new ValueAssertion<TItem>(actualItem, $"item[{_index}]");
-        var resultingAssertion = _assertion(itemSource);
+        var resultingAssertion = _assertion(actualItem, _index);
 
         if (resultingAssertion != null)
         {
@@ -595,11 +672,25 @@ protected override string GetExpectation() =>
 public class ListLastItemSatisfiesAssertion<TList, TItem> : ListAssertionBase<TList, TItem>
     where TList : IList<TItem>
 {
-    private readonly Func<IAssertionSource<TItem>, Assertion<TItem>?> _assertion;
+    private readonly Func<TItem, IAssertion?> _assertion;
 
+    /// <summary>
+    /// Backward-compatible constructor preserved for direct consumers from before the
+    /// internal refactor to a raw-item delegate. Wraps the supplied factory in a
+    /// <see cref="ValueAssertion{TItem}"/> — the unspecialised path. Internal callers should
+    /// use the <see cref="ListLastItemSource{TList,TItem}.Satisfies{TSource}"/> entry point
+    /// to get specialised assertion sources.
+    /// </summary>
     public ListLastItemSatisfiesAssertion(
         AssertionContext<TList> context,
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion)
+        : this(context, item => assertion(new ValueAssertion<TItem>(item, "lastItem")))
+    {
+    }
+
+    internal ListLastItemSatisfiesAssertion(
+        AssertionContext<TList> context,
+        Func<TItem, IAssertion?> assertion)
         : base(context)
     {
         _assertion = assertion;
@@ -623,8 +714,7 @@ protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<TLi
         }
 
         var lastItem = metadata.Value[metadata.Value.Count - 1];
-        var itemSource = new ValueAssertion<TItem>(lastItem, "lastItem");
-        var resultingAssertion = _assertion(itemSource);
+        var resultingAssertion = _assertion(lastItem);
 
         if (resultingAssertion != null)
         {
diff --git a/TUnit.Assertions/Conditions/ReadOnlyListAssertions.cs b/TUnit.Assertions/Conditions/ReadOnlyListAssertions.cs
index 5d91d94373..f098cedeee 100644
--- a/TUnit.Assertions/Conditions/ReadOnlyListAssertions.cs
+++ b/TUnit.Assertions/Conditions/ReadOnlyListAssertions.cs
@@ -64,6 +64,9 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> me
 /// This enables patterns like: Assert.That(list).ItemAt(0).IsEqualTo(expected)
 /// </summary>
 public class ReadOnlyListItemAtSource<TList, TItem> : IAssertionSource<TItem>
+#if !NETSTANDARD2_0
+    , IItemSatisfiesSource<TItem, ReadOnlyListItemAtSatisfiesAssertion<TList, TItem>>
+#endif
     where TList : IReadOnlyList<TItem>
 {
     private readonly AssertionContext<TList> _listContext;
@@ -128,6 +131,33 @@ public ReadOnlyListItemAtNullAssertion<TList, TItem> IsNotNull()
     public ReadOnlyListItemAtSatisfiesAssertion<TList, TItem> Satisfies(
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion,
         [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+    {
+        return CreateSatisfiesAssertion(
+            (item, index) => assertion(new ValueAssertion<TItem>(item, $"item[{index}]")),
+            expression);
+    }
+
+#if !NETSTANDARD2_0
+    /// <summary>
+    /// Asserts that the item at the index satisfies the given assertion expressed against
+    /// a specialised assertion source <typeparamref name="TSource"/>. The source is constructed
+    /// per-item via its static <see cref="IAssertionSourceFor{TItem,TSelf}.Create"/> factory.
+    /// Specify <typeparamref name="TSource"/> explicitly or via a typed lambda parameter.
+    /// </summary>
+    public ReadOnlyListItemAtSatisfiesAssertion<TList, TItem> Satisfies<TSource>(
+        Func<TSource, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        where TSource : IAssertionSourceFor<TItem, TSource>
+    {
+        return CreateSatisfiesAssertion(
+            (item, index) => assertion(TSource.Create(item, $"item[{index}]")),
+            expression);
+    }
+#endif
+
+    internal ReadOnlyListItemAtSatisfiesAssertion<TList, TItem> CreateSatisfiesAssertion(
+        Func<TItem, int, IAssertion?> assertion,
+        string? expression)
     {
         _listContext.ExpressionBuilder.Append($".Satisfies({expression})");
         return new ReadOnlyListItemAtSatisfiesAssertion<TList, TItem>(_listContext, _index, assertion);
@@ -181,6 +211,9 @@ public IsNotAssignableFromAssertion<TExpected, TItem> IsNotAssignableFrom<TExpec
 /// This enables patterns like: Assert.That(list).LastItem().IsEqualTo(expected)
 /// </summary>
 public class ReadOnlyListLastItemSource<TList, TItem> : IAssertionSource<TItem>
+#if !NETSTANDARD2_0
+    , IItemSatisfiesSource<TItem, ReadOnlyListLastItemSatisfiesAssertion<TList, TItem>>
+#endif
     where TList : IReadOnlyList<TItem>
 {
     private readonly AssertionContext<TList> _listContext;
@@ -243,6 +276,33 @@ public ReadOnlyListLastItemNullAssertion<TList, TItem> IsNotNull()
     public ReadOnlyListLastItemSatisfiesAssertion<TList, TItem> Satisfies(
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion,
         [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+    {
+        return CreateSatisfiesAssertion(
+            item => assertion(new ValueAssertion<TItem>(item, "lastItem")),
+            expression);
+    }
+
+#if !NETSTANDARD2_0
+    /// <summary>
+    /// Asserts that the last item satisfies the given assertion expressed against
+    /// a specialised assertion source <typeparamref name="TSource"/>. The source is constructed
+    /// from the last item via its static <see cref="IAssertionSourceFor{TItem,TSelf}.Create"/> factory.
+    /// Specify <typeparamref name="TSource"/> explicitly or via a typed lambda parameter.
+    /// </summary>
+    public ReadOnlyListLastItemSatisfiesAssertion<TList, TItem> Satisfies<TSource>(
+        Func<TSource, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        where TSource : IAssertionSourceFor<TItem, TSource>
+    {
+        return CreateSatisfiesAssertion(
+            item => assertion(TSource.Create(item, "lastItem")),
+            expression);
+    }
+#endif
+
+    internal ReadOnlyListLastItemSatisfiesAssertion<TList, TItem> CreateSatisfiesAssertion(
+        Func<TItem, IAssertion?> assertion,
+        string? expression)
     {
         _listContext.ExpressionBuilder.Append($".Satisfies({expression})");
         return new ReadOnlyListLastItemSatisfiesAssertion<TList, TItem>(_listContext, assertion);
@@ -422,12 +482,30 @@ public class ReadOnlyListItemAtSatisfiesAssertion<TList, TItem> : ReadOnlyListAs
     where TList : IReadOnlyList<TItem>
 {
     private readonly int _index;
-    private readonly Func<IAssertionSource<TItem>, Assertion<TItem>?> _assertion;
+    private readonly Func<TItem, int, IAssertion?> _assertion;
 
+    /// <summary>
+    /// Backward-compatible constructor preserved for direct consumers from before the
+    /// internal refactor to a raw-item delegate. Wraps the supplied factory in a
+    /// <see cref="ValueAssertion{TItem}"/> — the unspecialised path. Internal callers should
+    /// use the <see cref="ReadOnlyListItemAtSource{TList,TItem}.Satisfies{TSource}"/> entry
+    /// point to get specialised assertion sources.
+    /// </summary>
     public ReadOnlyListItemAtSatisfiesAssertion(
         AssertionContext<TList> context,
         int index,
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion)
+        : this(
+            context,
+            index,
+            (item, itemIndex) => assertion(new ValueAssertion<TItem>(item, $"item[{itemIndex}]")))
+    {
+    }
+
+    internal ReadOnlyListItemAtSatisfiesAssertion(
+        AssertionContext<TList> context,
+        int index,
+        Func<TItem, int, IAssertion?> assertion)
         : base(context)
     {
         _index = index;
@@ -453,8 +531,7 @@ protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<TLi
         }
 
         var actualItem = metadata.Value[_index];
-        var itemSource = new ValueAssertion<TItem>(actualItem, $"item[{_index}]");
-        var resultingAssertion = _assertion(itemSource);
+        var resultingAssertion = _assertion(actualItem, _index);
 
         if (resultingAssertion != null)
         {
@@ -597,11 +674,25 @@ protected override string GetExpectation() =>
 public class ReadOnlyListLastItemSatisfiesAssertion<TList, TItem> : ReadOnlyListAssertionBase<TList, TItem>
     where TList : IReadOnlyList<TItem>
 {
-    private readonly Func<IAssertionSource<TItem>, Assertion<TItem>?> _assertion;
+    private readonly Func<TItem, IAssertion?> _assertion;
 
+    /// <summary>
+    /// Backward-compatible constructor preserved for direct consumers from before the
+    /// internal refactor to a raw-item delegate. Wraps the supplied factory in a
+    /// <see cref="ValueAssertion{TItem}"/> — the unspecialised path. Internal callers should
+    /// use the <see cref="ReadOnlyListLastItemSource{TList,TItem}.Satisfies{TSource}"/>
+    /// entry point to get specialised assertion sources.
+    /// </summary>
     public ReadOnlyListLastItemSatisfiesAssertion(
         AssertionContext<TList> context,
         Func<IAssertionSource<TItem>, Assertion<TItem>?> assertion)
+        : this(context, item => assertion(new ValueAssertion<TItem>(item, "lastItem")))
+    {
+    }
+
+    internal ReadOnlyListLastItemSatisfiesAssertion(
+        AssertionContext<TList> context,
+        Func<TItem, IAssertion?> assertion)
         : base(context)
     {
         _assertion = assertion;
@@ -625,8 +716,7 @@ protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<TLi
         }
 
         var lastItem = metadata.Value[metadata.Value.Count - 1];
-        var itemSource = new ValueAssertion<TItem>(lastItem, "lastItem");
-        var resultingAssertion = _assertion(itemSource);
+        var resultingAssertion = _assertion(lastItem);
 
         if (resultingAssertion != null)
         {
diff --git a/TUnit.Assertions/Core/IAssertionSourceFor.cs b/TUnit.Assertions/Core/IAssertionSourceFor.cs
new file mode 100644
index 0000000000..fff3664693
--- /dev/null
+++ b/TUnit.Assertions/Core/IAssertionSourceFor.cs
@@ -0,0 +1,34 @@
+#if !NETSTANDARD2_0
+namespace TUnit.Assertions.Core;
+
+/// <summary>
+/// Marks an assertion source as constructible from a raw value, enabling generic
+/// dispatch through <c>Satisfies&lt;TSource&gt;</c> on item-at and similar entry points.
+/// Implementations expose a static factory used to materialise the specialised source
+/// per-item without per-shape overload enumeration.
+/// </summary>
+/// <remarks>
+/// Intentionally does not extend <see cref="IAssertionSource{TItem}"/>: a single
+/// implementing class can implement multiple parameterisations of this interface
+/// (e.g. against both an interface item type and a matching concrete type) without
+/// triggering conflicting <c>Context</c> property requirements.
+/// </remarks>
+/// <typeparam name="TItem">The value type the source wraps.</typeparam>
+/// <typeparam name="TSelf">The implementing source type (CRTP).</typeparam>
+public interface IAssertionSourceFor<TItem, TSelf>
+    where TSelf : IAssertionSourceFor<TItem, TSelf>
+{
+    /// <summary>
+    /// Constructs the specialised assertion source wrapping <paramref name="item"/> with the
+    /// given <paramref name="label"/>.
+    /// </summary>
+    /// <remarks>
+    /// Implementations may receive a <see langword="null"/> <paramref name="item"/> when the
+    /// caller selects from a collection that allows nulls. Whether the resulting assertion
+    /// surfaces a graceful failure or throws on a subsequent operation is the implementer's
+    /// responsibility — the contract is "construct a source that callers can run assertions
+    /// against", not "validate non-null up front".
+    /// </remarks>
+    static abstract TSelf Create(TItem item, string label);
+}
+#endif
diff --git a/TUnit.Assertions/Core/IItemSatisfiesSource.cs b/TUnit.Assertions/Core/IItemSatisfiesSource.cs
new file mode 100644
index 0000000000..464851281b
--- /dev/null
+++ b/TUnit.Assertions/Core/IItemSatisfiesSource.cs
@@ -0,0 +1,24 @@
+#if !NETSTANDARD2_0
+namespace TUnit.Assertions.Core;
+
+/// <summary>
+/// Common shape for item-selector sources (ItemAt, LastItem, etc.) that expose a
+/// generic <c>Satisfies&lt;TSource&gt;</c> entry. Lets a single set of per-shape
+/// extension overloads dispatch across all selector variants by binding to this
+/// interface rather than each concrete source type.
+/// </summary>
+/// <remarks>
+/// Extends <see cref="IAssertionSource{TItem}"/> so that extension methods targeting
+/// this interface bind in preference to those targeting <see cref="IAssertionSource{TItem}"/>
+/// directly — without that, the predicate-style <c>Satisfies(Func&lt;TItem, bool&gt;)</c>
+/// extension can win overload resolution for items whose specialised assertion methods
+/// return <c>bool</c> (e.g. <c>IDictionary.ContainsKey</c>).
+/// </remarks>
+/// <typeparam name="TItem">The selected item's type.</typeparam>
+/// <typeparam name="TResult">The selector-specific assertion result type.</typeparam>
+public interface IItemSatisfiesSource<TItem, TResult> : IAssertionSource<TItem>
+{
+    TResult Satisfies<TSource>(Func<TSource, IAssertion?> assertion, string? expression = null)
+        where TSource : IAssertionSourceFor<TItem, TSource>;
+}
+#endif
diff --git a/TUnit.Assertions/Extensions/CollectionItemSatisfiesExtensions.cs b/TUnit.Assertions/Extensions/CollectionItemSatisfiesExtensions.cs
new file mode 100644
index 0000000000..3bb52670fc
--- /dev/null
+++ b/TUnit.Assertions/Extensions/CollectionItemSatisfiesExtensions.cs
@@ -0,0 +1,99 @@
+#if !NETSTANDARD2_0
+using System.Runtime.CompilerServices;
+using TUnit.Assertions.Core;
+using TUnit.Assertions.Sources;
+
+namespace TUnit.Assertions.Extensions;
+
+/// <summary>
+/// Specialised <c>Satisfies</c> overloads when the selected item (from <c>ItemAt</c>,
+/// <c>LastItem</c>, etc.) is itself a collection-like value. Each overload binds the
+/// matching <see cref="IAssertionSourceFor{TItem,TSelf}"/> implementation and dispatches
+/// through <see cref="IItemSatisfiesSource{TItem,TResult}.Satisfies{TSource}"/>,
+/// so a single set of per-shape overloads serves every item-selector source type.
+/// </summary>
+/// <remarks>
+/// Both interface-shaped (e.g. <c>IList&lt;T&gt;</c>) and concrete-shaped
+/// (e.g. <c>List&lt;T&gt;</c>) overloads are required because C# overload
+/// resolution performs exact type matching on the source's <c>TItem</c>:
+/// <c>IList&lt;List&lt;int&gt;&gt;</c> binds the <c>List&lt;TInner&gt;</c>
+/// overload, never the <c>IList&lt;TInner&gt;</c> one.
+///
+/// When introducing a new <see cref="IAssertionSourceFor{TItem,TSelf}"/>
+/// implementation, add the matching overload below; otherwise users must
+/// spell out the type argument explicitly: <c>.Satisfies&lt;MyAssertion&lt;T&gt;&gt;(...)</c>.
+/// </remarks>
+public static class CollectionItemSatisfiesExtensions
+{
+    public static TResult Satisfies<TInner, TResult>(
+        this IItemSatisfiesSource<IEnumerable<TInner>, TResult> source,
+        Func<CollectionAssertion<TInner>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        => source.Satisfies<CollectionAssertion<TInner>>(assertion, expression);
+
+    public static TResult Satisfies<TInner, TResult>(
+        this IItemSatisfiesSource<IList<TInner>, TResult> source,
+        Func<ListAssertion<TInner>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        => source.Satisfies<ListAssertion<TInner>>(assertion, expression);
+
+    public static TResult Satisfies<TInner, TResult>(
+        this IItemSatisfiesSource<IReadOnlyList<TInner>, TResult> source,
+        Func<ReadOnlyListAssertion<TInner>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        => source.Satisfies<ReadOnlyListAssertion<TInner>>(assertion, expression);
+
+    public static TResult Satisfies<TKey, TValue, TResult>(
+        this IItemSatisfiesSource<IReadOnlyDictionary<TKey, TValue>, TResult> source,
+        Func<DictionaryAssertion<TKey, TValue>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        where TKey : notnull
+        => source.Satisfies<DictionaryAssertion<TKey, TValue>>(assertion, expression);
+
+    public static TResult Satisfies<TKey, TValue, TResult>(
+        this IItemSatisfiesSource<IDictionary<TKey, TValue>, TResult> source,
+        Func<MutableDictionaryAssertion<TKey, TValue>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        where TKey : notnull
+        => source.Satisfies<MutableDictionaryAssertion<TKey, TValue>>(assertion, expression);
+
+    public static TResult Satisfies<TInner, TResult>(
+        this IItemSatisfiesSource<ISet<TInner>, TResult> source,
+        Func<SetAssertion<TInner>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        => source.Satisfies<SetAssertion<TInner>>(assertion, expression);
+
+#if NET5_0_OR_GREATER
+    public static TResult Satisfies<TInner, TResult>(
+        this IItemSatisfiesSource<IReadOnlySet<TInner>, TResult> source,
+        Func<ReadOnlySetAssertion<TInner>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        => source.Satisfies<ReadOnlySetAssertion<TInner>>(assertion, expression);
+#endif
+
+    public static TResult Satisfies<TInner, TResult>(
+        this IItemSatisfiesSource<TInner[], TResult> source,
+        Func<ArrayAssertion<TInner>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        => source.Satisfies<ArrayAssertion<TInner>>(assertion, expression);
+
+    public static TResult Satisfies<TInner, TResult>(
+        this IItemSatisfiesSource<List<TInner>, TResult> source,
+        Func<ListAssertion<TInner>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        => source.Satisfies<ListAssertion<TInner>>(assertion, expression);
+
+    public static TResult Satisfies<TInner, TResult>(
+        this IItemSatisfiesSource<HashSet<TInner>, TResult> source,
+        Func<HashSetAssertion<TInner>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        => source.Satisfies<HashSetAssertion<TInner>>(assertion, expression);
+
+    public static TResult Satisfies<TKey, TValue, TResult>(
+        this IItemSatisfiesSource<Dictionary<TKey, TValue>, TResult> source,
+        Func<MutableDictionaryAssertion<TKey, TValue>, IAssertion?> assertion,
+        [CallerArgumentExpression(nameof(assertion))] string? expression = null)
+        where TKey : notnull
+        => source.Satisfies<MutableDictionaryAssertion<TKey, TValue>>(assertion, expression);
+}
+#endif
diff --git a/TUnit.Assertions/Sources/ArrayAssertion.cs b/TUnit.Assertions/Sources/ArrayAssertion.cs
index 6efe0fc411..040a6f066e 100644
--- a/TUnit.Assertions/Sources/ArrayAssertion.cs
+++ b/TUnit.Assertions/Sources/ArrayAssertion.cs
@@ -10,6 +10,9 @@ namespace TUnit.Assertions.Sources;
 /// enabling generated assertions that target concrete array types (e.g., string[]).
 /// </summary>
 public class ArrayAssertion<TItem> : CollectionAssertionBase<TItem[], TItem>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<TItem[], ArrayAssertion<TItem>>
+#endif
 {
     public ArrayAssertion(TItem[]? value, string? expression)
         : base(new AssertionContext<TItem[]>(value!, CreateExpressionBuilder(expression)))
@@ -21,6 +24,10 @@ internal ArrayAssertion(AssertionContext<TItem[]> context)
     {
     }
 
+#if !NETSTANDARD2_0
+    public static ArrayAssertion<TItem> Create(TItem[] item, string label) => new(item, label);
+#endif
+
     private static StringBuilder CreateExpressionBuilder(string? expression)
     {
         var builder = new StringBuilder();
diff --git a/TUnit.Assertions/Sources/CollectionAssertion.cs b/TUnit.Assertions/Sources/CollectionAssertion.cs
index 9d91a042fe..8bddae8fa5 100644
--- a/TUnit.Assertions/Sources/CollectionAssertion.cs
+++ b/TUnit.Assertions/Sources/CollectionAssertion.cs
@@ -11,6 +11,9 @@ namespace TUnit.Assertions.Sources;
 /// that persist through And/Or continuations.
 /// </summary>
 public class CollectionAssertion<TItem> : CollectionAssertionBase<IEnumerable<TItem>, TItem>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<IEnumerable<TItem>, CollectionAssertion<TItem>>
+#endif
 {
     public CollectionAssertion(IEnumerable<TItem> value, string? expression)
         : base(new AssertionContext<IEnumerable<TItem>>(value, CreateExpressionBuilder(expression)))
@@ -22,6 +25,10 @@ internal CollectionAssertion(AssertionContext<IEnumerable<TItem>> context)
     {
     }
 
+#if !NETSTANDARD2_0
+    public static CollectionAssertion<TItem> Create(IEnumerable<TItem> item, string label) => new(item, label);
+#endif
+
     private static StringBuilder CreateExpressionBuilder(string? expression)
     {
         var builder = new StringBuilder();
diff --git a/TUnit.Assertions/Sources/DictionaryAssertion.cs b/TUnit.Assertions/Sources/DictionaryAssertion.cs
index d08ef3fcb5..74c7bb6d5a 100644
--- a/TUnit.Assertions/Sources/DictionaryAssertion.cs
+++ b/TUnit.Assertions/Sources/DictionaryAssertion.cs
@@ -11,6 +11,9 @@ namespace TUnit.Assertions.Sources;
 /// plus collection methods (Contains, IsEmpty, All, etc.) since dictionaries are collections of KeyValuePair items.
 /// </summary>
 public class DictionaryAssertion<TKey, TValue> : DictionaryAssertionBase<IReadOnlyDictionary<TKey, TValue>, TKey, TValue>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<IReadOnlyDictionary<TKey, TValue>, DictionaryAssertion<TKey, TValue>>
+#endif
     where TKey : notnull
 {
     public DictionaryAssertion(IReadOnlyDictionary<TKey, TValue>? value, string? expression)
@@ -18,6 +21,10 @@ public DictionaryAssertion(IReadOnlyDictionary<TKey, TValue>? value, string? exp
     {
     }
 
+#if !NETSTANDARD2_0
+    public static DictionaryAssertion<TKey, TValue> Create(IReadOnlyDictionary<TKey, TValue> item, string label) => new(item, label);
+#endif
+
     private static AssertionContext<IReadOnlyDictionary<TKey, TValue>> CreateContext(
         IReadOnlyDictionary<TKey, TValue>? value,
         string? expression)
diff --git a/TUnit.Assertions/Sources/ListAssertion.cs b/TUnit.Assertions/Sources/ListAssertion.cs
index 0dc4c587ea..cd34cf370e 100644
--- a/TUnit.Assertions/Sources/ListAssertion.cs
+++ b/TUnit.Assertions/Sources/ListAssertion.cs
@@ -10,6 +10,10 @@ namespace TUnit.Assertions.Sources;
 /// in addition to all standard collection methods.
 /// </summary>
 public class ListAssertion<TItem> : ListAssertionBase<IList<TItem>, TItem>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<IList<TItem>, ListAssertion<TItem>>
+    , IAssertionSourceFor<List<TItem>, ListAssertion<TItem>>
+#endif
 {
     public ListAssertion(IList<TItem>? value, string? expression)
         : base(CreateContext(value, expression))
@@ -21,6 +25,11 @@ internal ListAssertion(AssertionContext<IList<TItem>> context)
     {
     }
 
+#if !NETSTANDARD2_0
+    public static ListAssertion<TItem> Create(IList<TItem> item, string label) => new(item, label);
+    public static ListAssertion<TItem> Create(List<TItem> item, string label) => new(item, label);
+#endif
+
     private static AssertionContext<IList<TItem>> CreateContext(
         IList<TItem>? value,
         string? expression)
diff --git a/TUnit.Assertions/Sources/MutableDictionaryAssertion.cs b/TUnit.Assertions/Sources/MutableDictionaryAssertion.cs
index 2d0afd5ae0..3401c197de 100644
--- a/TUnit.Assertions/Sources/MutableDictionaryAssertion.cs
+++ b/TUnit.Assertions/Sources/MutableDictionaryAssertion.cs
@@ -11,6 +11,10 @@ namespace TUnit.Assertions.Sources;
 /// plus collection methods (Contains, IsEmpty, All, etc.) since dictionaries are collections of KeyValuePair items.
 /// </summary>
 public class MutableDictionaryAssertion<TKey, TValue> : MutableDictionaryAssertionBase<IDictionary<TKey, TValue>, TKey, TValue>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<IDictionary<TKey, TValue>, MutableDictionaryAssertion<TKey, TValue>>
+    , IAssertionSourceFor<Dictionary<TKey, TValue>, MutableDictionaryAssertion<TKey, TValue>>
+#endif
     where TKey : notnull
 {
     public MutableDictionaryAssertion(IDictionary<TKey, TValue>? value, string? expression)
@@ -18,6 +22,11 @@ public MutableDictionaryAssertion(IDictionary<TKey, TValue>? value, string? expr
     {
     }
 
+#if !NETSTANDARD2_0
+    public static MutableDictionaryAssertion<TKey, TValue> Create(IDictionary<TKey, TValue> item, string label) => new(item, label);
+    public static MutableDictionaryAssertion<TKey, TValue> Create(Dictionary<TKey, TValue> item, string label) => new(item, label);
+#endif
+
     private static AssertionContext<IDictionary<TKey, TValue>> CreateContext(
         IDictionary<TKey, TValue>? value,
         string? expression)
diff --git a/TUnit.Assertions/Sources/ReadOnlyListAssertion.cs b/TUnit.Assertions/Sources/ReadOnlyListAssertion.cs
index 367a079b6e..3645f0fe01 100644
--- a/TUnit.Assertions/Sources/ReadOnlyListAssertion.cs
+++ b/TUnit.Assertions/Sources/ReadOnlyListAssertion.cs
@@ -8,6 +8,9 @@ namespace TUnit.Assertions.Sources;
 /// </summary>
 /// <typeparam name="TItem">The type of items in the read-only list</typeparam>
 public class ReadOnlyListAssertion<TItem> : ReadOnlyListAssertionBase<IReadOnlyList<TItem>, TItem>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<IReadOnlyList<TItem>, ReadOnlyListAssertion<TItem>>
+#endif
 {
     public ReadOnlyListAssertion(IReadOnlyList<TItem>? value, string? expression)
         : base(CreateContext(value, expression))
@@ -19,6 +22,10 @@ internal ReadOnlyListAssertion(AssertionContext<IReadOnlyList<TItem>> context)
     {
     }
 
+#if !NETSTANDARD2_0
+    public static ReadOnlyListAssertion<TItem> Create(IReadOnlyList<TItem> item, string label) => new(item, label);
+#endif
+
     private static AssertionContext<IReadOnlyList<TItem>> CreateContext(
         IReadOnlyList<TItem>? value,
         string? expression)
diff --git a/TUnit.Assertions/Sources/SetAssertion.cs b/TUnit.Assertions/Sources/SetAssertion.cs
index 155b306051..9e9a3012cb 100644
--- a/TUnit.Assertions/Sources/SetAssertion.cs
+++ b/TUnit.Assertions/Sources/SetAssertion.cs
@@ -11,6 +11,9 @@ namespace TUnit.Assertions.Sources;
 /// </summary>
 /// <typeparam name="TItem">The type of items in the set.</typeparam>
 public class SetAssertion<TItem> : SetAssertionBase<ISet<TItem>, TItem>, IAssertionSource<ISet<TItem>>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<ISet<TItem>, SetAssertion<TItem>>
+#endif
 {
     /// <summary>
     /// Creates a new SetAssertion for the given set.
@@ -34,6 +37,10 @@ private protected SetAssertion(AssertionContext<ISet<TItem>> context)
     /// <inheritdoc />
     AssertionContext<ISet<TItem>> IAssertionSource<ISet<TItem>>.Context => Context;
 
+#if !NETSTANDARD2_0
+    public static SetAssertion<TItem> Create(ISet<TItem> item, string label) => new(item, label);
+#endif
+
     private static StringBuilder CreateExpressionBuilder(string? expression)
     {
         var builder = new StringBuilder();
@@ -49,6 +56,9 @@ private static StringBuilder CreateExpressionBuilder(string? expression)
 /// </summary>
 /// <typeparam name="TItem">The type of items in the set.</typeparam>
 public class ReadOnlySetAssertion<TItem> : SetAssertionBase<IReadOnlySet<TItem>, TItem>, IAssertionSource<IReadOnlySet<TItem>>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<IReadOnlySet<TItem>, ReadOnlySetAssertion<TItem>>
+#endif
 {
     /// <summary>
     /// Creates a new ReadOnlySetAssertion for the given read-only set.
@@ -72,6 +82,10 @@ private protected ReadOnlySetAssertion(AssertionContext<IReadOnlySet<TItem>> con
     /// <inheritdoc />
     AssertionContext<IReadOnlySet<TItem>> IAssertionSource<IReadOnlySet<TItem>>.Context => Context;
 
+#if !NETSTANDARD2_0
+    public static ReadOnlySetAssertion<TItem> Create(IReadOnlySet<TItem> item, string label) => new(item, label);
+#endif
+
     private static StringBuilder CreateExpressionBuilder(string? expression)
     {
         var builder = new StringBuilder();
@@ -87,6 +101,9 @@ private static StringBuilder CreateExpressionBuilder(string? expression)
 /// </summary>
 /// <typeparam name="TItem">The type of items in the set.</typeparam>
 public class HashSetAssertion<TItem> : SetAssertionBase<HashSet<TItem>, TItem>, IAssertionSource<HashSet<TItem>>
+#if !NETSTANDARD2_0
+    , IAssertionSourceFor<HashSet<TItem>, HashSetAssertion<TItem>>
+#endif
 {
     /// <summary>
     /// Creates a new HashSetAssertion for the given hash set.
@@ -110,6 +127,10 @@ private protected HashSetAssertion(AssertionContext<HashSet<TItem>> context)
     /// <inheritdoc />
     AssertionContext<HashSet<TItem>> IAssertionSource<HashSet<TItem>>.Context => Context;
 
+#if !NETSTANDARD2_0
+    public static HashSetAssertion<TItem> Create(HashSet<TItem> item, string label) => new(item, label);
+#endif
+
     private static StringBuilder CreateExpressionBuilder(string? expression)
     {
         var builder = new StringBuilder();
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
index 1923ab110f..fc2e65071d 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
@@ -1534,7 +1534,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ListItemAtSource<TList, TItem> : ., .<TItem>
+    public class ListItemAtSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ListItemAtSource(.<TList> listContext, int index) { }
@@ -1550,6 +1550,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     public class ListLastItemEqualsAssertion<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -1572,7 +1574,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ListLastItemSource<TList, TItem> : ., .<TItem>
+    public class ListLastItemSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ListLastItemSource(.<TList> listContext) { }
@@ -1588,6 +1590,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     [.("IsEqualTo", OverloadResolutionPriority=2)]
     public class LongEqualsAssertion : .<long, long>
@@ -1786,7 +1790,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ReadOnlyListItemAtSource<TList, TItem> : ., .<TItem>
+    public class ReadOnlyListItemAtSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ReadOnlyListItemAtSource(.<TList> listContext, int index) { }
@@ -1802,6 +1806,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     public class ReadOnlyListLastItemEqualsAssertion<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -1824,7 +1830,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ReadOnlyListLastItemSource<TList, TItem> : ., .<TItem>
+    public class ReadOnlyListLastItemSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ReadOnlyListLastItemSource(.<TList> listContext) { }
@@ -1840,6 +1846,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     [.<.Rune>("IsAscii", CustomName="IsNotAscii", ExpectationMessage="be ASCII", NegateLogic=true)]
     [.<.Rune>("IsAscii", ExpectationMessage="be ASCII")]
@@ -2501,6 +2509,11 @@ namespace .Core
         . AssertAsync();
     }
     public interface IAssertionSource { }
+    public interface IAssertionSourceFor<TItem, TSelf>
+        where TSelf : .<TItem, TSelf>
+    {
+        TSelf Create(TItem item, string label);
+    }
     public interface IAssertionSource<TValue> : .
     {
         .<TValue> Context { get; }
@@ -2512,6 +2525,11 @@ namespace .Core
         .<TValue, TExpected> IsTypeOf<TExpected>();
     }
     public interface IDelegateAssertionSource<TValue> : ., .<TValue> { }
+    public interface IItemSatisfiesSource<TItem, TResult> : ., .<TItem>
+    {
+        TResult Satisfies<TSource>(<TSource, .?> assertion, string? expression = null)
+            where TSource : .<TItem, TSource>;
+    }
     public class ListAndContinuation<TList, TItem> : .<TList, TItem>
         where TList : .<TItem> { }
     public class ListOrContinuation<TList, TItem> : .<TList, TItem>
@@ -3093,6 +3111,23 @@ namespace .Extensions
         public static .<TCollection, TItem> IsInOrder<TCollection, TItem>(this .<TCollection> source)
             where TCollection : .<TItem> { }
     }
+    public static class CollectionItemSatisfiesExtensions
+    {
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<TInner[], TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+    }
     public static class ComparisonAssertionExtensions
     {
         [.("Trimming", "IL2091", Justification="Generic type parameter is only used for property access, not instantiation")]
@@ -6088,9 +6123,10 @@ namespace .Extensions
 }
 namespace .Sources
 {
-    public class ArrayAssertion<TItem> : .<TItem[], TItem>
+    public class ArrayAssertion<TItem> : .<TItem[], TItem>, .<TItem[], .<TItem>>
     {
         public ArrayAssertion(TItem[]? value, string? expression) { }
+        public static .<TItem> Create(TItem[] item, string label) { }
     }
     public class AsyncDelegateAssertion : ., .<object?>, .<.>, .<object?>
     {
@@ -6221,9 +6257,10 @@ namespace .Sources
         public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TExpected> IsTypeOf<TExpected>() { }
     }
-    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>
+    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>
     {
         public CollectionAssertion(.<TItem> value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class DelegateAssertion : ., .<object?>, .<object?>
     {
@@ -6259,10 +6296,11 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
     }
-    public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
+    public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
     {
         public DictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
     }
     public class FuncAssertion<TValue> : ., .<TValue>, .<TValue>
     {
@@ -6287,10 +6325,11 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public HashSetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public abstract class ListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -6303,9 +6342,11 @@ namespace .Sources
         public .<TList, TItem> ItemAt(int index, [.("index")] string? expression = null) { }
         public .<TList, TItem> LastItem() { }
     }
-    public class ListAssertion<TItem> : .<.<TItem>, TItem>
+    public class ListAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>, .<.<TItem>, .<TItem>>
     {
         public ListAssertion(.<TItem>? value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class MemoryAndContinuation<TMemory, TItem> : .<TMemory, TItem>
     {
@@ -6370,10 +6411,12 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
     }
-    public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
+    public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
     {
         public MutableDictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
     }
     public abstract class ReadOnlyListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -6386,19 +6429,21 @@ namespace .Sources
         public .<TList, TItem> ItemAt(int index, [.("index")] string? indexExpression = null) { }
         public .<TList, TItem> LastItem() { }
     }
-    public class ReadOnlyListAssertion<TItem> : .<.<TItem>, TItem>
+    public class ReadOnlyListAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>
     {
         public ReadOnlyListAssertion(.<TItem>? value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class ReadOnlyMemoryAssertion<TItem> : .<<TItem>, TItem>, ., .<<TItem>>
     {
         public ReadOnlyMemoryAssertion(<TItem> value, string expression) { }
         protected override .<TItem> CreateAdapter(<TItem> value) { }
     }
-    public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public ReadOnlySetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class SetAndContinuation<TSet, TItem> : .<TSet, TItem>
         where TSet : .<TItem>
@@ -6421,10 +6466,11 @@ namespace .Sources
         public .<TSet, TItem> Overlaps(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> SetEquals(.<TItem> other, [.("other")] string? expression = null) { }
     }
-    public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public SetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class SetOrContinuation<TSet, TItem> : .<TSet, TItem>
         where TSet : .<TItem>
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
index c184337bb5..4874df1872 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
@@ -1517,7 +1517,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ListItemAtSource<TList, TItem> : ., .<TItem>
+    public class ListItemAtSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ListItemAtSource(.<TList> listContext, int index) { }
@@ -1533,6 +1533,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     public class ListLastItemEqualsAssertion<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -1555,7 +1557,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ListLastItemSource<TList, TItem> : ., .<TItem>
+    public class ListLastItemSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ListLastItemSource(.<TList> listContext) { }
@@ -1571,6 +1573,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     [.("IsEqualTo", OverloadResolutionPriority=2)]
     public class LongEqualsAssertion : .<long, long>
@@ -1769,7 +1773,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ReadOnlyListItemAtSource<TList, TItem> : ., .<TItem>
+    public class ReadOnlyListItemAtSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ReadOnlyListItemAtSource(.<TList> listContext, int index) { }
@@ -1785,6 +1789,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     public class ReadOnlyListLastItemEqualsAssertion<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -1807,7 +1813,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ReadOnlyListLastItemSource<TList, TItem> : ., .<TItem>
+    public class ReadOnlyListLastItemSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ReadOnlyListLastItemSource(.<TList> listContext) { }
@@ -1823,6 +1829,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     [.<.Rune>("IsAscii", CustomName="IsNotAscii", ExpectationMessage="be ASCII", NegateLogic=true)]
     [.<.Rune>("IsAscii", ExpectationMessage="be ASCII")]
@@ -2480,6 +2488,11 @@ namespace .Core
         . AssertAsync();
     }
     public interface IAssertionSource { }
+    public interface IAssertionSourceFor<TItem, TSelf>
+        where TSelf : .<TItem, TSelf>
+    {
+        TSelf Create(TItem item, string label);
+    }
     public interface IAssertionSource<TValue> : .
     {
         .<TValue> Context { get; }
@@ -2491,6 +2504,11 @@ namespace .Core
         .<TValue, TExpected> IsTypeOf<TExpected>();
     }
     public interface IDelegateAssertionSource<TValue> : ., .<TValue> { }
+    public interface IItemSatisfiesSource<TItem, TResult> : ., .<TItem>
+    {
+        TResult Satisfies<TSource>(<TSource, .?> assertion, string? expression = null)
+            where TSource : .<TItem, TSource>;
+    }
     public class ListAndContinuation<TList, TItem> : .<TList, TItem>
         where TList : .<TItem> { }
     public class ListOrContinuation<TList, TItem> : .<TList, TItem>
@@ -3058,6 +3076,23 @@ namespace .Extensions
         public static .<TCollection, TItem> IsInOrder<TCollection, TItem>(this .<TCollection> source)
             where TCollection : .<TItem> { }
     }
+    public static class CollectionItemSatisfiesExtensions
+    {
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<TInner[], TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+    }
     public static class ComparisonAssertionExtensions
     {
         [.("Trimming", "IL2091", Justification="Generic type parameter is only used for property access, not instantiation")]
@@ -6017,9 +6052,10 @@ namespace .Extensions
 }
 namespace .Sources
 {
-    public class ArrayAssertion<TItem> : .<TItem[], TItem>
+    public class ArrayAssertion<TItem> : .<TItem[], TItem>, .<TItem[], .<TItem>>
     {
         public ArrayAssertion(TItem[]? value, string? expression) { }
+        public static .<TItem> Create(TItem[] item, string label) { }
     }
     public class AsyncDelegateAssertion : ., .<object?>, .<.>, .<object?>
     {
@@ -6149,9 +6185,10 @@ namespace .Sources
         public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TExpected> IsTypeOf<TExpected>() { }
     }
-    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>
+    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>
     {
         public CollectionAssertion(.<TItem> value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class DelegateAssertion : ., .<object?>, .<object?>
     {
@@ -6187,10 +6224,11 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
     }
-    public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
+    public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
     {
         public DictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
     }
     public class FuncAssertion<TValue> : ., .<TValue>, .<TValue>
     {
@@ -6215,10 +6253,11 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public HashSetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public abstract class ListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -6231,9 +6270,11 @@ namespace .Sources
         public .<TList, TItem> ItemAt(int index, [.("index")] string? expression = null) { }
         public .<TList, TItem> LastItem() { }
     }
-    public class ListAssertion<TItem> : .<.<TItem>, TItem>
+    public class ListAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>, .<.<TItem>, .<TItem>>
     {
         public ListAssertion(.<TItem>? value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class MemoryAndContinuation<TMemory, TItem> : .<TMemory, TItem>
     {
@@ -6298,10 +6339,12 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
     }
-    public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
+    public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
     {
         public MutableDictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
     }
     public abstract class ReadOnlyListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -6314,19 +6357,21 @@ namespace .Sources
         public .<TList, TItem> ItemAt(int index, [.("index")] string? indexExpression = null) { }
         public .<TList, TItem> LastItem() { }
     }
-    public class ReadOnlyListAssertion<TItem> : .<.<TItem>, TItem>
+    public class ReadOnlyListAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>
     {
         public ReadOnlyListAssertion(.<TItem>? value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class ReadOnlyMemoryAssertion<TItem> : .<<TItem>, TItem>, ., .<<TItem>>
     {
         public ReadOnlyMemoryAssertion(<TItem> value, string expression) { }
         protected override .<TItem> CreateAdapter(<TItem> value) { }
     }
-    public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public ReadOnlySetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class SetAndContinuation<TSet, TItem> : .<TSet, TItem>
         where TSet : .<TItem>
@@ -6349,10 +6394,11 @@ namespace .Sources
         public .<TSet, TItem> Overlaps(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> SetEquals(.<TItem> other, [.("other")] string? expression = null) { }
     }
-    public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public SetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class SetOrContinuation<TSet, TItem> : .<TSet, TItem>
         where TSet : .<TItem>
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
index c49c22d3f6..54d39689d4 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
@@ -1534,7 +1534,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ListItemAtSource<TList, TItem> : ., .<TItem>
+    public class ListItemAtSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ListItemAtSource(.<TList> listContext, int index) { }
@@ -1550,6 +1550,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     public class ListLastItemEqualsAssertion<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -1572,7 +1574,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ListLastItemSource<TList, TItem> : ., .<TItem>
+    public class ListLastItemSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ListLastItemSource(.<TList> listContext) { }
@@ -1588,6 +1590,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     [.("IsEqualTo", OverloadResolutionPriority=2)]
     public class LongEqualsAssertion : .<long, long>
@@ -1786,7 +1790,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ReadOnlyListItemAtSource<TList, TItem> : ., .<TItem>
+    public class ReadOnlyListItemAtSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ReadOnlyListItemAtSource(.<TList> listContext, int index) { }
@@ -1802,6 +1806,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     public class ReadOnlyListLastItemEqualsAssertion<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -1824,7 +1830,7 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TList> metadata) { }
         protected override string GetExpectation() { }
     }
-    public class ReadOnlyListLastItemSource<TList, TItem> : ., .<TItem>
+    public class ReadOnlyListLastItemSource<TList, TItem> : ., .<TItem>, .<TItem, .<TList, TItem>>
         where TList : .<TItem>
     {
         public ReadOnlyListLastItemSource(.<TList> listContext) { }
@@ -1840,6 +1846,8 @@ namespace .Conditions
         public .<TList, TItem> IsNull() { }
         public .<TItem, TExpected> IsTypeOf<TExpected>() { }
         public .<TList, TItem> Satisfies(<.<TItem>, .<TItem>?> assertion, [.("assertion")] string? expression = null) { }
+        public .<TList, TItem> Satisfies<TSource>(<TSource, .?> assertion, [.("assertion")] string? expression = null)
+            where TSource : .<TItem, TSource> { }
     }
     [.<.Rune>("IsAscii", CustomName="IsNotAscii", ExpectationMessage="be ASCII", NegateLogic=true)]
     [.<.Rune>("IsAscii", ExpectationMessage="be ASCII")]
@@ -2501,6 +2509,11 @@ namespace .Core
         . AssertAsync();
     }
     public interface IAssertionSource { }
+    public interface IAssertionSourceFor<TItem, TSelf>
+        where TSelf : .<TItem, TSelf>
+    {
+        TSelf Create(TItem item, string label);
+    }
     public interface IAssertionSource<TValue> : .
     {
         .<TValue> Context { get; }
@@ -2512,6 +2525,11 @@ namespace .Core
         .<TValue, TExpected> IsTypeOf<TExpected>();
     }
     public interface IDelegateAssertionSource<TValue> : ., .<TValue> { }
+    public interface IItemSatisfiesSource<TItem, TResult> : ., .<TItem>
+    {
+        TResult Satisfies<TSource>(<TSource, .?> assertion, string? expression = null)
+            where TSource : .<TItem, TSource>;
+    }
     public class ListAndContinuation<TList, TItem> : .<TList, TItem>
         where TList : .<TItem> { }
     public class ListOrContinuation<TList, TItem> : .<TList, TItem>
@@ -3093,6 +3111,23 @@ namespace .Extensions
         public static .<TCollection, TItem> IsInOrder<TCollection, TItem>(this .<TCollection> source)
             where TCollection : .<TItem> { }
     }
+    public static class CollectionItemSatisfiesExtensions
+    {
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<.<TInner>, TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TInner, TResult>(this .<TInner[], TResult> source, <.<TInner>, .?> assertion, [.("assertion")] string? expression = null) { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+        public static TResult Satisfies<TKey, TValue, TResult>(this .<.<TKey, TValue>, TResult> source, <.<TKey, TValue>, .?> assertion, [.("assertion")] string? expression = null)
+            where TKey :  notnull { }
+    }
     public static class ComparisonAssertionExtensions
     {
         [.("Trimming", "IL2091", Justification="Generic type parameter is only used for property access, not instantiation")]
@@ -6088,9 +6123,10 @@ namespace .Extensions
 }
 namespace .Sources
 {
-    public class ArrayAssertion<TItem> : .<TItem[], TItem>
+    public class ArrayAssertion<TItem> : .<TItem[], TItem>, .<TItem[], .<TItem>>
     {
         public ArrayAssertion(TItem[]? value, string? expression) { }
+        public static .<TItem> Create(TItem[] item, string label) { }
     }
     public class AsyncDelegateAssertion : ., .<object?>, .<.>, .<object?>
     {
@@ -6221,9 +6257,10 @@ namespace .Sources
         public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TExpected> IsTypeOf<TExpected>() { }
     }
-    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>
+    public class CollectionAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>
     {
         public CollectionAssertion(.<TItem> value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class DelegateAssertion : ., .<object?>, .<object?>
     {
@@ -6259,10 +6296,11 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
     }
-    public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
+    public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
     {
         public DictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
     }
     public class FuncAssertion<TValue> : ., .<TValue>, .<TValue>
     {
@@ -6287,10 +6325,11 @@ namespace .Sources
         public .<TException> ThrowsExactly<TException>()
             where TException :  { }
     }
-    public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public HashSetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public abstract class ListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -6303,9 +6342,11 @@ namespace .Sources
         public .<TList, TItem> ItemAt(int index, [.("index")] string? expression = null) { }
         public .<TList, TItem> LastItem() { }
     }
-    public class ListAssertion<TItem> : .<.<TItem>, TItem>
+    public class ListAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>, .<.<TItem>, .<TItem>>
     {
         public ListAssertion(.<TItem>? value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class MemoryAndContinuation<TMemory, TItem> : .<TMemory, TItem>
     {
@@ -6370,10 +6411,12 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
     }
-    public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
+    public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
     {
         public MutableDictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
+        public static .<TKey, TValue> Create(.<TKey, TValue> item, string label) { }
     }
     public abstract class ReadOnlyListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -6386,19 +6429,21 @@ namespace .Sources
         public .<TList, TItem> ItemAt(int index, [.("index")] string? indexExpression = null) { }
         public .<TList, TItem> LastItem() { }
     }
-    public class ReadOnlyListAssertion<TItem> : .<.<TItem>, TItem>
+    public class ReadOnlyListAssertion<TItem> : .<.<TItem>, TItem>, .<.<TItem>, .<TItem>>
     {
         public ReadOnlyListAssertion(.<TItem>? value, string? expression) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class ReadOnlyMemoryAssertion<TItem> : .<<TItem>, TItem>, ., .<<TItem>>
     {
         public ReadOnlyMemoryAssertion(<TItem> value, string expression) { }
         protected override .<TItem> CreateAdapter(<TItem> value) { }
     }
-    public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public ReadOnlySetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class SetAndContinuation<TSet, TItem> : .<TSet, TItem>
         where TSet : .<TItem>
@@ -6421,10 +6466,11 @@ namespace .Sources
         public .<TSet, TItem> Overlaps(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> SetEquals(.<TItem> other, [.("other")] string? expression = null) { }
     }
-    public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
+    public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>, .<TItem>>, .<.<TItem>>
     {
         public SetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
+        public static .<TItem> Create(.<TItem> item, string label) { }
     }
     public class SetOrContinuation<TSet, TItem> : .<TSet, TItem>
         where TSet : .<TItem>