diff --git a/DeepClone.Test/DirectDictionaryOverloadTests.cs b/DeepClone.Test/DirectDictionaryOverloadTests.cs
new file mode 100644
index 0000000..e8c22a7
--- /dev/null
+++ b/DeepClone.Test/DirectDictionaryOverloadTests.cs
@@ -0,0 +1,81 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.DeepClone.Test;
+
+using System.Collections.Immutable;
+
+/// <summary>
+/// Tests that <c>.DeepClone()</c> can be called directly on dictionary types that implement both
+/// <see cref="IDictionary{TKey, TValue}"/> and <see cref="IReadOnlyDictionary{TKey, TValue}"/>, and that the
+/// result has the source's type and comparer (ktsu-dev/DeepClone#86). Each test calls the extension without
+/// a cast, so this file stops compiling if the overloads become ambiguous again.
+/// </summary>
+[TestClass]
+public class DirectDictionaryOverloadTests
+{
+	private static readonly string[] DescendingKeys = ["c", "b", "a"];
+
+	/// <summary>
+	/// Tests that a sorted list clones to a sorted list with the source's comparer and deep-cloned values.
+	/// </summary>
+	[TestMethod]
+	public void SortedList_DeepClone_KeepsTypeComparerAndClonesValues()
+	{
+		Comparer<string> descending = Comparer<string>.Create((x, y) => string.CompareOrdinal(y, x));
+		SortedList<string, SimpleObject> original = new(descending)
+		{
+			["a"] = new SimpleObject { Id = 1, Name = "A" },
+			["c"] = new SimpleObject { Id = 3, Name = "C" },
+		};
+
+		SortedList<string, SimpleObject> clone = original.DeepClone();
+		clone["b"] = new SimpleObject { Id = 2, Name = "B" };
+
+		Assert.AreSame(descending, clone.Comparer);
+		Assert.AreSequenceEqual(DescendingKeys, clone.Keys);
+		Assert.AreNotSame(original["a"], clone["a"]);
+		Assert.AreEqual(1, clone["a"].Id);
+	}
+
+	/// <summary>
+	/// Tests that an immutable dictionary clones to an immutable dictionary with the source's key and value
+	/// comparers and deep-cloned values.
+	/// </summary>
+	[TestMethod]
+	public void ImmutableDictionary_DeepClone_KeepsTypeComparersAndClonesValues()
+	{
+		ImmutableDictionary<string, SimpleObject> original = ImmutableDictionary
+			.Create<string, SimpleObject>(StringComparer.OrdinalIgnoreCase, ReferenceEqualityComparer.Instance)
+			.Add("Key", new SimpleObject { Id = 1, Name = "One" });
+
+		ImmutableDictionary<string, SimpleObject> clone = original.DeepClone();
+
+		Assert.AreSame(StringComparer.OrdinalIgnoreCase, clone.KeyComparer);
+		Assert.AreSame(ReferenceEqualityComparer.Instance, clone.ValueComparer);
+		Assert.IsTrue(clone.ContainsKey("KEY"));
+		Assert.AreNotSame(original["Key"], clone["Key"]);
+		Assert.AreEqual(1, clone["Key"].Id);
+	}
+
+	/// <summary>
+	/// Tests that an immutable sorted dictionary clones to an immutable sorted dictionary with the source's
+	/// key and value comparers and deep-cloned values.
+	/// </summary>
+	[TestMethod]
+	public void ImmutableSortedDictionary_DeepClone_KeepsTypeComparersAndClonesValues()
+	{
+		Comparer<string> descending = Comparer<string>.Create((x, y) => string.CompareOrdinal(y, x));
+		ImmutableSortedDictionary<string, SimpleObject> original = ImmutableSortedDictionary
+			.Create<string, SimpleObject>(descending, ReferenceEqualityComparer.Instance)
+			.Add("a", new SimpleObject { Id = 1, Name = "A" })
+			.Add("c", new SimpleObject { Id = 3, Name = "C" });
+
+		ImmutableSortedDictionary<string, SimpleObject> clone = original.DeepClone().Add("b", new SimpleObject { Id = 2, Name = "B" });
+
+		Assert.AreSame(descending, clone.KeyComparer);
+		Assert.AreSame(ReferenceEqualityComparer.Instance, clone.ValueComparer);
+		Assert.AreSequenceEqual(DescendingKeys, clone.Keys);
+		Assert.AreNotSame(original["a"], clone["a"]);
+		Assert.AreEqual(1, clone["a"].Id);
+	}
+}
diff --git a/DeepClone/DeepCloneContainerExtensions.cs b/DeepClone/DeepCloneContainerExtensions.cs
index 1f677e8..09b84aa 100644
--- a/DeepClone/DeepCloneContainerExtensions.cs
+++ b/DeepClone/DeepCloneContainerExtensions.cs
@@ -255,6 +255,86 @@ public static SortedDictionary<TKey, TValue> DeepClone<TKey, TValue>(this Sorted
 		return clone;
 	}
 
+	/// <summary>
+	/// Deep clones a sorted list, keeping its key comparer.
+	/// </summary>
+	/// <typeparam name="TKey">The type of keys in the list.</typeparam>
+	/// <typeparam name="TValue">The type of values in the list.</typeparam>
+	/// <param name="source">The source list to clone.</param>
+	/// <returns>A new sorted list with the source's comparer, containing deep clones of the keys and values
+	/// if they implement IDeepCloneable, otherwise containing the original keys and values.</returns>
+	/// <remarks>
+	/// <see cref="SortedList{TKey, TValue}"/> implements both <see cref="IDictionary{TKey, TValue}"/> and
+	/// <see cref="IReadOnlyDictionary{TKey, TValue}"/>, so this overload is also what lets
+	/// <c>sortedList.DeepClone()</c> compile without a cast.
+	/// </remarks>
+	/// <exception cref="ArgumentNullException">Thrown if source is null.</exception>
+	public static SortedList<TKey, TValue> DeepClone<TKey, TValue>(this SortedList<TKey, TValue> source)
+		where TKey : notnull
+	{
+		Ensure.NotNull(source);
+
+		SortedList<TKey, TValue> clone = new(source.Count, source.Comparer);
+		AddClonedPairs(clone, source);
+		return clone;
+	}
+
+#if NET
+	/// <summary>
+	/// Deep clones an immutable dictionary, keeping its key and value comparers.
+	/// </summary>
+	/// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+	/// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
+	/// <param name="source">The source dictionary to clone.</param>
+	/// <returns>A new immutable dictionary with the source's comparers, containing deep clones of the keys and values
+	/// if they implement IDeepCloneable, otherwise containing the original keys and values.</returns>
+	/// <remarks>
+	/// <see cref="ImmutableDictionary{TKey, TValue}"/> implements both <see cref="IDictionary{TKey, TValue}"/> and
+	/// <see cref="IReadOnlyDictionary{TKey, TValue}"/>, so this overload is also what lets
+	/// <c>immutableDictionary.DeepClone()</c> compile without a cast.
+	/// </remarks>
+	/// <exception cref="ArgumentNullException">Thrown if source is null.</exception>
+	public static ImmutableDictionary<TKey, TValue> DeepClone<TKey, TValue>(this ImmutableDictionary<TKey, TValue> source)
+		where TKey : notnull
+	{
+		Ensure.NotNull(source);
+
+		return ImmutableDictionary.CreateRange(source.KeyComparer, source.ValueComparer, ClonePairs(source));
+	}
+
+	/// <summary>
+	/// Deep clones an immutable sorted dictionary, keeping its key and value comparers.
+	/// </summary>
+	/// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+	/// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
+	/// <param name="source">The source dictionary to clone.</param>
+	/// <returns>A new immutable sorted dictionary with the source's comparers, containing deep clones of the keys and
+	/// values if they implement IDeepCloneable, otherwise containing the original keys and values.</returns>
+	/// <remarks>
+	/// <see cref="ImmutableSortedDictionary{TKey, TValue}"/> implements both <see cref="IDictionary{TKey, TValue}"/>
+	/// and <see cref="IReadOnlyDictionary{TKey, TValue}"/>, so this overload is also what lets
+	/// <c>immutableSortedDictionary.DeepClone()</c> compile without a cast.
+	/// </remarks>
+	/// <exception cref="ArgumentNullException">Thrown if source is null.</exception>
+	public static ImmutableSortedDictionary<TKey, TValue> DeepClone<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue> source)
+		where TKey : notnull
+	{
+		Ensure.NotNull(source);
+
+		return ImmutableSortedDictionary.CreateRange(source.KeyComparer, source.ValueComparer, ClonePairs(source));
+	}
+
+	/// <summary>
+	/// Deep clones the key and value of each pair.
+	/// </summary>
+	/// <typeparam name="TKey">The type of the keys.</typeparam>
+	/// <typeparam name="TValue">The type of the values.</typeparam>
+	/// <param name="pairs">The key-value pairs to clone.</param>
+	/// <returns>The cloned pairs.</returns>
+	private static IEnumerable<KeyValuePair<TKey, TValue>> ClonePairs<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> pairs) =>
+		pairs.Select(p => new KeyValuePair<TKey, TValue>(DeepClone(p.Key), DeepClone(p.Value)));
+#endif
+
 	/// <summary>
 	/// Deep clones a concurrent dictionary, keeping its key comparer where the target framework exposes it.
 	/// </summary>
diff --git a/README.md b/README.md
index 9feccba..0c197b2 100644
--- a/README.md
+++ b/README.md
@@ -603,13 +603,14 @@ Extension methods for deep cloning various container types.
 | `DeepClone<T>` | `IEnumerable<T?>?` | Creates a deep clone of an enumerable collection |
 | `DeepClone<TKey, TValue>` | `IDictionary<TKey, TValue?>?` | Creates a deep clone of a dictionary, preserving the key comparer where the runtime type exposes one |
 | `DeepClone<TKey, TValue>` | `IReadOnlyDictionary<TKey, TValue?>?` | Creates a deep clone of a read-only dictionary, preserving the key comparer where the runtime type exposes one |
+| `DeepClone<TKey, TValue>` | `SortedList<TKey, TValue>` | Creates a deep clone of a sorted list, preserving the key comparer |
 | `DeepClone<T>` | `HashSet<T?>?` | Creates a deep clone of a hash set, preserving the comparer |
 | `DeepClone<T>` | `SortedSet<T?>?` | Creates a deep clone of a sorted set, preserving the comparer |
 | `DeepClone<T>` | `Stack<T?>?` | Creates a deep clone of a stack, preserving the element order |
 | `DeepClone<T>` | `ImmutableArray<T>` | Creates a deep clone of an immutable array |
 | `DeepClone<T>` | `ImmutableList<T>` | Creates a deep clone of an immutable list |
-| `DeepClone<TKey, TValue>` | `ImmutableDictionary<TKey, TValue>` | Creates a deep clone of an immutable dictionary |
-| `DeepClone<TKey, TValue>` | `ImmutableSortedDictionary<TKey, TValue>` | Creates a deep clone of an immutable sorted dictionary |
+| `DeepClone<TKey, TValue>` | `ImmutableDictionary<TKey, TValue>` | Creates a deep clone of an immutable dictionary, preserving the key and value comparers (.NET only) |
+| `DeepClone<TKey, TValue>` | `ImmutableSortedDictionary<TKey, TValue>` | Creates a deep clone of an immutable sorted dictionary, preserving the key and value comparers (.NET only) |
 | `DeepClone<T>` | `ImmutableHashSet<T>` | Creates a deep clone of an immutable hash set |
 | `DeepClone<T>` | `ImmutableSortedSet<T>` | Creates a deep clone of an immutable sorted set |
 | `DeepClone<T>` | `ImmutableStack<T>` | Creates a deep clone of an immutable stack |