diff --git a/DeepClone.Test/EnumerableCloneTests.cs b/DeepClone.Test/EnumerableCloneTests.cs
new file mode 100644
index 0000000..73714d7
--- /dev/null
+++ b/DeepClone.Test/EnumerableCloneTests.cs
@@ -0,0 +1,75 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.DeepClone.Test;
+
+/// <summary>
+/// Tests for deep cloning plain sequences and stacks through their extension methods.
+/// </summary>
+[TestClass]
+public class EnumerableCloneTests
+{
+#pragma warning disable CA1851 // Enumerating the clone more than once is what these tests check
+	/// <summary>
+	/// Tests that edits to the items of a cloned sequence survive a second enumeration.
+	/// </summary>
+	[TestMethod]
+	public void Enumerable_DeepClone_ShouldKeepEditsAcrossEnumerations()
+	{
+		// Arrange
+		List<SimpleObject> original = [new() { Id = 1, Name = "Item1" }];
+
+		// Act
+		IEnumerable<SimpleObject> clone = original.DeepClone();
+		foreach (SimpleObject item in clone)
+		{
+			item.Name = "Edited";
+		}
+
+		// Assert
+		Assert.AreEqual("Edited", clone.First().Name);
+		Assert.AreSame(clone.First(), clone.First());
+		Assert.AreEqual("Item1", original[0].Name);
+	}
+
+	/// <summary>
+	/// Tests that a cloned sequence does not change when the source changes afterwards.
+	/// </summary>
+	[TestMethod]
+	public void Enumerable_DeepClone_ShouldNotTrackSourceChanges()
+	{
+		// Arrange
+		List<SimpleObject> original =
+		[
+			new() { Id = 1, Name = "Item1" },
+			new() { Id = 2, Name = "Item2" },
+		];
+
+		// Act
+		IEnumerable<SimpleObject> clone = original.DeepClone();
+		original.Clear();
+
+		// Assert
+		Assert.AreEqual(2, clone.Count());
+	}
+#pragma warning restore CA1851
+
+	/// <summary>
+	/// Tests that deep cloning a null sequence throws ArgumentNullException.
+	/// </summary>
+	[TestMethod]
+	public void Enumerable_DeepClone_NullSource_ShouldThrow()
+	{
+		IEnumerable<SimpleObject> source = null!;
+		Assert.ThrowsExactly<ArgumentNullException>(() => source.DeepClone());
+	}
+
+	/// <summary>
+	/// Tests that deep cloning a null stack throws ArgumentNullException.
+	/// </summary>
+	[TestMethod]
+	public void Stack_DeepClone_NullSource_ShouldThrow()
+	{
+		Stack<SimpleObject> source = null!;
+		Assert.ThrowsExactly<ArgumentNullException>(() => source.DeepClone());
+	}
+}
diff --git a/DeepClone/DeepCloneContainerExtensions.cs b/DeepClone/DeepCloneContainerExtensions.cs
index 11d5f80..3d46d5f 100644
--- a/DeepClone/DeepCloneContainerExtensions.cs
+++ b/DeepClone/DeepCloneContainerExtensions.cs
@@ -104,8 +104,9 @@ public static void DeepCloneFrom<TKey, TValue>(this IDictionary<TKey, TValue> de
 	/// <returns>A new collection containing deep clones of the original items if they implement IDeepCloneable,
 	/// otherwise containing the original items.</returns>
 	/// <remarks>
-	/// This method returns an IEnumerable sequence of cloned items. To get a specific collection type,
-	/// you'll need to convert the result (for example using ToList() or ToArray()).
+	/// The items are cloned when this method is called, so the result is a snapshot: it does not change
+	/// when the source changes, and enumerating it again yields the same cloned instances. To get a
+	/// specific collection type, convert the result (for example using ToList() or ToArray()).
 	///
 	/// Example usage:
 	/// <code>
@@ -113,8 +114,13 @@ public static void DeepCloneFrom<TKey, TValue>(this IDictionary<TKey, TValue> de
 	/// var clonedArray = originalArray.DeepClone().ToArray();
 	/// </code>
 	/// </remarks>
-	public static IEnumerable<T> DeepClone<T>(this IEnumerable<T> source) =>
-		source.Select(DeepClone);
+	/// <exception cref="ArgumentNullException">Thrown if source is null.</exception>
+	public static IEnumerable<T> DeepClone<T>(this IEnumerable<T> source)
+	{
+		Ensure.NotNull(source);
+
+		return [.. source.Select(DeepClone)];
+	}
 
 	/// <summary>
 	/// Deep clones a dictionary.
@@ -314,6 +320,11 @@ public static SortedSet<T> DeepClone<T>(this SortedSet<T> source)
 	/// var clonedStack = originalStack.DeepClone();
 	/// </code>
 	/// </remarks>
-	public static Stack<T> DeepClone<T>(this Stack<T> source) =>
-		new(source.Reverse().Select(DeepClone));
+	/// <exception cref="ArgumentNullException">Thrown if source is null.</exception>
+	public static Stack<T> DeepClone<T>(this Stack<T> source)
+	{
+		Ensure.NotNull(source);
+
+		return new(source.Reverse().Select(DeepClone));
+	}
 }