diff --git a/Source/Mockolate.Analyzers/MockabilityAnalyzer.cs b/Source/Mockolate.Analyzers/MockabilityAnalyzer.cs
index 6f92f67c..5d3a4095 100644
--- a/Source/Mockolate.Analyzers/MockabilityAnalyzer.cs
+++ b/Source/Mockolate.Analyzers/MockabilityAnalyzer.cs
@@ -116,7 +116,7 @@ private static void ReportRefStructIssuesForType(SyntaxNodeAnalysisContext conte
 		if (type.TypeKind == TypeKind.Delegate)
 		{
 			if (type is INamedTypeSymbol { DelegateInvokeMethod: { } invoke, } &&
-			    TryGetRefStructIssue(invoke, pipelineUnsupportedReason, out string? delegateIssue))
+			    TryGetRefStructIssue(invoke, pipelineUnsupportedReason, out string? delegateIssue, isDelegate: true))
 			{
 				context.ReportDiagnostic(Diagnostic.Create(
 					s_refStructRule,
@@ -292,7 +292,7 @@ private static bool NeedsRefStructPipeline(ITypeSymbol type)
 	}
 
 	private static bool TryGetRefStructIssue(IMethodSymbol method, string? pipelineUnsupportedReason,
-		out string? issue)
+		out string? issue, bool isDelegate = false)
 	{
 		bool hasRefStructParam = false;
 		foreach (IParameterSymbol p in method.Parameters)
@@ -304,9 +304,14 @@ private static bool TryGetRefStructIssue(IMethodSymbol method, string? pipelineU
 
 			hasRefStructParam = true;
 
-			if (p.RefKind is RefKind.Out or RefKind.Ref or RefKind.RefReadOnlyParameter)
+			// Delegates don't go through the ref-struct setup pipeline at all, so any ref-struct
+			// parameter (by-value or by-ref) is unsupported on delegate Invoke methods — the
+			// emitted VoidMethodSetup<T> / ReturnMethodSetup<T> lacks an 'allows ref struct'
+			// constraint. Interface/class methods route through the IOutRefStructParameter /
+			// IRefRefStructParameter pipeline.
+			if (isDelegate)
 			{
-				issue = "out/ref ref-struct parameters are not supported";
+				issue = "ref-struct parameters are not supported on delegate types";
 				return true;
 			}
 		}
diff --git a/Source/Mockolate.SourceGenerators/Helpers.cs b/Source/Mockolate.SourceGenerators/Helpers.cs
index cda85ac2..d157d52d 100644
--- a/Source/Mockolate.SourceGenerators/Helpers.cs
+++ b/Source/Mockolate.SourceGenerators/Helpers.cs
@@ -130,8 +130,25 @@ public static bool NeedsRefStructPipeline(this Type type)
 		=> type.IsRefStruct
 		   && type.SpecialGenericType is not (SpecialGenericType.Span or SpecialGenericType.ReadOnlySpan);
 
+	/// <summary>
+	///     Returns true if the parameter must flow through the ref-struct setup pipeline. The
+	///     <see cref="Type" /> overload excludes <c>Span&lt;T&gt;</c> and <c>ReadOnlySpan&lt;T&gt;</c>
+	///     because <c>by-value</c>, <c>out</c>, and <c>ref</c> positions use the
+	///     <c>SpanWrapper&lt;T&gt;</c> / <c>ReadOnlySpanWrapper&lt;T&gt;</c> non-ref-struct carve-out.
+	///     <c>ref readonly</c> Span/ROS, however, has no dedicated wrapper-based emit branch, so it
+	///     falls back to the generic ref-struct pipeline.
+	/// </summary>
 	public static bool NeedsRefStructPipeline(this MethodParameter parameter)
-		=> parameter.Type.NeedsRefStructPipeline();
+	{
+		if (parameter.Type.NeedsRefStructPipeline())
+		{
+			return true;
+		}
+
+		return parameter.RefKind == RefKind.RefReadOnlyParameter
+			&& parameter.Type.IsRefStruct
+			&& parameter.Type.SpecialGenericType is (SpecialGenericType.Span or SpecialGenericType.ReadOnlySpan);
+	}
 
 	extension(ITypeSymbol typeSymbol)
 	{
@@ -454,24 +471,47 @@ public string ToTypeOrWrapper()
 
 		public string ToParameter()
 		{
-			return (parameter.RefKind, parameter.Type.SpecialGenericType) switch
+			bool needsRefStructPipeline = parameter.NeedsRefStructPipeline();
+			return (parameter.RefKind, parameter.Type.SpecialGenericType, needsRefStructPipeline) switch
 			{
-				(RefKind.Ref, _) => $"global::Mockolate.Parameters.IRefParameter<{GetMethodParameterType(parameter)}>",
-				(RefKind.Out, _) => $"global::Mockolate.Parameters.IOutParameter<{GetMethodParameterType(parameter)}>",
-				(RefKind.RefReadOnlyParameter, _) => $"global::Mockolate.Parameters.IRefParameter<{GetMethodParameterType(parameter)}>",
-				(_, SpecialGenericType.Span) => $"global::Mockolate.Parameters.ISpanParameter<{GetMethodParameterType(parameter)}>",
-				(_, SpecialGenericType.ReadOnlySpan) =>
+				(RefKind.Ref, _, true) =>
+					$"global::Mockolate.Parameters.IRefRefStructParameter<{GetMethodParameterType(parameter)}>",
+				(RefKind.Out, _, true) =>
+					$"global::Mockolate.Parameters.IOutRefStructParameter<{GetMethodParameterType(parameter)}>",
+				(RefKind.RefReadOnlyParameter, _, true) =>
+					$"global::Mockolate.Parameters.IRefRefStructParameter<{GetMethodParameterType(parameter)}>",
+				(RefKind.Out, SpecialGenericType.Span, _) =>
+					$"global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.SpanWrapper<{parameter.Type.GenericTypeParameters!.Value.First().Fullname}>>",
+				(RefKind.Out, SpecialGenericType.ReadOnlySpan, _) =>
+					$"global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<{parameter.Type.GenericTypeParameters!.Value.First().Fullname}>>",
+				(RefKind.Ref, SpecialGenericType.Span, _) =>
+					$"global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.SpanWrapper<{parameter.Type.GenericTypeParameters!.Value.First().Fullname}>>",
+				(RefKind.Ref, SpecialGenericType.ReadOnlySpan, _) =>
+					$"global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<{parameter.Type.GenericTypeParameters!.Value.First().Fullname}>>",
+				(RefKind.Ref, _, _) => $"global::Mockolate.Parameters.IRefParameter<{GetMethodParameterType(parameter)}>",
+				(RefKind.Out, _, _) => $"global::Mockolate.Parameters.IOutParameter<{GetMethodParameterType(parameter)}>",
+				(RefKind.RefReadOnlyParameter, _, _) =>
+					$"global::Mockolate.Parameters.IRefParameter<{GetMethodParameterType(parameter)}>",
+				(_, SpecialGenericType.Span, _) =>
+					$"global::Mockolate.Parameters.ISpanParameter<{GetMethodParameterType(parameter)}>",
+				(_, SpecialGenericType.ReadOnlySpan, _) =>
 					$"global::Mockolate.Parameters.IReadOnlySpanParameter<{GetMethodParameterType(parameter)}>",
-				(_, _) => $"global::Mockolate.Parameters.IParameter<{GetMethodParameterType(parameter)}>",
+				(_, _, _) => $"global::Mockolate.Parameters.IParameter<{GetMethodParameterType(parameter)}>",
 			};
 
 			static string GetMethodParameterType(MethodParameter parameter)
 			{
+				// The non-ref-struct routes for Span/ROS use the SpanWrapper / ReadOnlySpanWrapper
+				// matcher, so the relevant generic argument is the element type. The ref-struct
+				// pipeline, by contrast, handles the bare Span<T> / ReadOnlySpan<T> directly, so we
+				// must preserve the full type there.
+				bool stripSpanToElement = !parameter.NeedsRefStructPipeline();
 				return (parameter.Type.SpecialGenericType,
 						parameter.IsNullableAnnotated && !parameter.Type.Fullname.EndsWith("?")) switch
 					{
-						(SpecialGenericType.Span, _) => parameter.Type.GenericTypeParameters!.Value.First().Fullname,
-						(SpecialGenericType.ReadOnlySpan, _) =>
+						(SpecialGenericType.Span, _) when stripSpanToElement =>
+							parameter.Type.GenericTypeParameters!.Value.First().Fullname,
+						(SpecialGenericType.ReadOnlySpan, _) when stripSpanToElement =>
 							parameter.Type.GenericTypeParameters!.Value.First().Fullname,
 						(_, false) => parameter.Type.Fullname,
 						(_, true) => $"{parameter.Type.Fullname}?",
diff --git a/Source/Mockolate.SourceGenerators/Sources/Sources.MockClass.cs b/Source/Mockolate.SourceGenerators/Sources/Sources.MockClass.cs
index 027236aa..4383f3b4 100644
--- a/Source/Mockolate.SourceGenerators/Sources/Sources.MockClass.cs
+++ b/Source/Mockolate.SourceGenerators/Sources/Sources.MockClass.cs
@@ -2267,8 +2267,9 @@ private static void AppendMockSubject_ImplementClass_AddMethod(StringBuilder sb,
 				sb.Append("\t\t\tvar ").Append(paramRef).Append(" = ").Append(p.Name).Append(';').AppendLine();
 				sb2.Append(paramRef);
 			}
-			else if (p.Type.SpecialGenericType == SpecialGenericType.Span ||
-			         p.Type.SpecialGenericType == SpecialGenericType.ReadOnlySpan)
+			else if (p.RefKind != RefKind.Out &&
+			         (p.Type.SpecialGenericType == SpecialGenericType.Span ||
+			          p.Type.SpecialGenericType == SpecialGenericType.ReadOnlySpan))
 			{
 				string paramRef = Helpers.GetUniqueLocalVariableName($"ref_{p.Name}", method.Parameters);
 
@@ -2440,6 +2441,7 @@ private static void AppendMockSubject_ImplementClass_AddMethod(StringBuilder sb,
 		{
 			string outParamBase = Helpers.GetUniqueIndexedLocalVariableBase("outParam", method.Parameters);
 			string refParamBase = Helpers.GetUniqueIndexedLocalVariableBase("refParam", method.Parameters);
+			string outTempBase = Helpers.GetUniqueIndexedLocalVariableBase("outTemp", method.Parameters);
 			sb.Append("\t\t\t\tif (!").Append(hasWrappedResult).Append(" || ").Append(methodSetup).Append(" is ")
 				.Append(methodSetupType)
 				.Append(".WithParameterCollection)")
@@ -2454,17 +2456,45 @@ private static void AppendMockSubject_ImplementClass_AddMethod(StringBuilder sb,
 				parameterIndex++;
 				if (parameter.RefKind == RefKind.Out)
 				{
-					sb.Append("\t\t\t\t\t\tif (").Append(wpc).Append(".Parameter").Append(parameterIndex)
-						.Append(" is not global::Mockolate.Parameters.IOutParameter<")
-						.Append(parameter.Type.ToTypeOrWrapper()).Append("> ").Append(outParamBase)
-						.Append(parameterIndex)
-						.Append(" || !").Append(outParamBase).Append(parameterIndex).Append(".TryGetValue(out ")
-						.Append(parameter.Name).Append("))").AppendLine();
-					sb.Append("\t\t\t\t\t\t{").AppendLine();
-					sb.Append("\t\t\t\t\t\t\t").Append(parameter.Name).Append(" = ")
-						.AppendDefaultValueGeneratorFor(parameter.Type, $"{mockRegistry}.Behavior.DefaultValue")
-						.Append(';').AppendLine();
-					sb.Append("\t\t\t\t\t\t}").AppendLine();
+					bool isSpanOrReadOnlySpan = parameter.Type.SpecialGenericType
+						is SpecialGenericType.Span or SpecialGenericType.ReadOnlySpan;
+					if (isSpanOrReadOnlySpan)
+					{
+						// C# does not insert user-defined implicit conversions across `out`, so the
+						// wrapper-typed slot must be unpacked into a wrapper-typed temp local first,
+						// then assigned to the bare-typed parameter (which triggers the implicit op).
+						sb.Append("\t\t\t\t\t\tif (").Append(wpc).Append(".Parameter").Append(parameterIndex)
+							.Append(" is not global::Mockolate.Parameters.IOutParameter<")
+							.Append(parameter.Type.ToTypeOrWrapper()).Append("> ").Append(outParamBase)
+							.Append(parameterIndex)
+							.Append(" || !").Append(outParamBase).Append(parameterIndex)
+							.Append(".TryGetValue(out ").Append(parameter.Type.ToTypeOrWrapper())
+							.Append(' ').Append(outTempBase).Append(parameterIndex).Append("))").AppendLine();
+						sb.Append("\t\t\t\t\t\t{").AppendLine();
+						sb.Append("\t\t\t\t\t\t\t").Append(parameter.Name).Append(" = ")
+							.AppendDefaultValueGeneratorFor(parameter.Type, $"{mockRegistry}.Behavior.DefaultValue")
+							.Append(';').AppendLine();
+						sb.Append("\t\t\t\t\t\t}").AppendLine();
+						sb.Append("\t\t\t\t\t\telse").AppendLine();
+						sb.Append("\t\t\t\t\t\t{").AppendLine();
+						sb.Append("\t\t\t\t\t\t\t").Append(parameter.Name).Append(" = ").Append(outTempBase)
+							.Append(parameterIndex).Append(';').AppendLine();
+						sb.Append("\t\t\t\t\t\t}").AppendLine();
+					}
+					else
+					{
+						sb.Append("\t\t\t\t\t\tif (").Append(wpc).Append(".Parameter").Append(parameterIndex)
+							.Append(" is not global::Mockolate.Parameters.IOutParameter<")
+							.Append(parameter.Type.ToTypeOrWrapper()).Append("> ").Append(outParamBase)
+							.Append(parameterIndex)
+							.Append(" || !").Append(outParamBase).Append(parameterIndex).Append(".TryGetValue(out ")
+							.Append(parameter.Name).Append("))").AppendLine();
+						sb.Append("\t\t\t\t\t\t{").AppendLine();
+						sb.Append("\t\t\t\t\t\t\t").Append(parameter.Name).Append(" = ")
+							.AppendDefaultValueGeneratorFor(parameter.Type, $"{mockRegistry}.Behavior.DefaultValue")
+							.Append(';').AppendLine();
+						sb.Append("\t\t\t\t\t\t}").AppendLine();
+					}
 				}
 				else if (parameter.RefKind == RefKind.Ref)
 				{
@@ -2593,21 +2623,15 @@ private static void AppendMockSubject_ImplementClass_AddRefStructMethodBody(
 	{
 		sb.Append("#if NET9_0_OR_GREATER").AppendLine();
 
-		bool hasUnsupportedParameter =
-			method.Parameters.Any(p =>
-				(p.RefKind == RefKind.Out || p.RefKind == RefKind.Ref ||
-				 p.RefKind == RefKind.RefReadOnlyParameter) && p.NeedsRefStructPipeline());
 		bool returnsUnsupportedRefStruct = method.ReturnType.IsRefStruct &&
 		                                   method.ReturnType.SpecialGenericType is not
 			                                   (SpecialGenericType.Span or SpecialGenericType.ReadOnlySpan);
 
-		if (hasUnsupportedParameter || returnsUnsupportedRefStruct)
+		if (returnsUnsupportedRefStruct)
 		{
-			string reason = returnsUnsupportedRefStruct
-				? "methods returning a non-span ref struct are not supported"
-				: "out/ref ref-struct parameters are not supported";
 			sb.Append("\t\t\tthrow new global::System.NotSupportedException(\"Mockolate: ")
-				.Append(reason).Append(". Method '").Append(method.ContainingType).Append('.')
+				.Append("methods returning a non-span ref struct are not supported")
+				.Append(". Method '").Append(method.ContainingType).Append('.')
 				.Append(method.Name).Append("'.\");").AppendLine();
 			sb.Append("#else").AppendLine();
 			sb.Append(
@@ -2634,6 +2658,15 @@ method.ReturnType.SpecialGenericType is not
 
 		sb.Append("));").AppendLine();
 
+		// Pre-default any `out` ref-struct slot. The MockBehavior.DefaultValue generator returns
+		// object? and cannot produce ref-struct values, so we assign default! directly. If a
+		// matching setup later supplies a value via IOutRefStructParameter<T>.TryGetValue, that
+		// value overwrites this; otherwise the default! sticks.
+		foreach (MethodParameter outParameter in method.Parameters.Where(p => p.RefKind == RefKind.Out))
+		{
+			sb.Append("\t\t\t").Append(outParameter.Name).Append(" = default!;").AppendLine();
+		}
+
 		// Iterate setups in latest-registered-first order (scenario-scoped first, default-scope
 		// after — GetMethodSetups<T> preserves that ordering). Stop on the first matcher that
 		// accepts every positional argument. The matching runs synchronously on the stack so
@@ -2654,6 +2687,37 @@ method.ReturnType.SpecialGenericType is not
 		sb.AppendLine();
 		sb.Append("\t\t\t\t").Append(matchedVar).Append(" = true;").AppendLine();
 
+		// Per-slot write-back for out/ref ref-struct parameters. ref-readonly is read-only by
+		// definition and needs no write-back.
+		int refStructSlotIndex = 0;
+		foreach (MethodParameter parameter in method.Parameters)
+		{
+			refStructSlotIndex++;
+			if (parameter.RefKind == RefKind.Out)
+			{
+				string outVar = Helpers.GetUniqueLocalVariableName($"outParam{refStructSlotIndex}", method.Parameters);
+				sb.Append("\t\t\t\tif (").Append(setupVar).Append(".GetMatcher").Append(refStructSlotIndex)
+					.Append("() is global::Mockolate.Parameters.IOutRefStructParameter<")
+					.Append(parameter.Type.Fullname).Append("> ").Append(outVar).Append(" && ").Append(outVar)
+					.Append(".TryGetValue(out ").Append(parameter.Name).Append(")) { }").AppendLine();
+				sb.Append("\t\t\t\telse").AppendLine();
+				sb.Append("\t\t\t\t{").AppendLine();
+				sb.Append("\t\t\t\t\t").Append(parameter.Name).Append(" = default!;").AppendLine();
+				sb.Append("\t\t\t\t}").AppendLine();
+			}
+			else if (parameter.RefKind == RefKind.Ref)
+			{
+				string refVar = Helpers.GetUniqueLocalVariableName($"refParam{refStructSlotIndex}", method.Parameters);
+				sb.Append("\t\t\t\tif (").Append(setupVar).Append(".GetMatcher").Append(refStructSlotIndex)
+					.Append("() is global::Mockolate.Parameters.IRefRefStructParameter<")
+					.Append(parameter.Type.Fullname).Append("> ").Append(refVar).Append(")").AppendLine();
+				sb.Append("\t\t\t\t{").AppendLine();
+				sb.Append("\t\t\t\t\t").Append(parameter.Name).Append(" = ").Append(refVar).Append(".GetValue(")
+					.Append(parameter.Name).Append(");").AppendLine();
+				sb.Append("\t\t\t\t}").AppendLine();
+			}
+		}
+
 		if (method.ReturnType == Type.Void)
 		{
 			sb.Append("\t\t\t\t").Append(setupVar).Append(".Invoke(").Append(paramNames).Append(");").AppendLine();
@@ -3774,16 +3838,19 @@ private static void AppendMethodSetupImplementation(StringBuilder sb, Method met
 	private static void AppendRefStructMethodSetupDefinition(StringBuilder sb, Method method,
 		string? methodNameOverride)
 	{
+		// Out/ref/ref-readonly slots that don't go through the ref-struct setup pipeline have no setup
+		// surface today. That includes regular non-ref-struct types and out/ref Span/ReadOnlySpan
+		// (which route through the SpanWrapper/ReadOnlySpanWrapper carve-out, not IParameterMatch<T>).
+		// The ref-struct narrow setup uses IParameterMatch<T> slots; mixing in a wrapper-based or
+		// non-ref-struct IOutParameter<T> would require a wider pipeline. Continue to skip those.
 		bool unsupported = method.Parameters.Any(p =>
-			                   p.RefKind == RefKind.Out || p.RefKind == RefKind.Ref ||
-			                   p.RefKind == RefKind.RefReadOnlyParameter) ||
+			                   (p.RefKind == RefKind.Out || p.RefKind == RefKind.Ref ||
+			                    p.RefKind == RefKind.RefReadOnlyParameter)
+			                   && !p.NeedsRefStructPipeline()) ||
 		                   (method.ReturnType.IsRefStruct && method.ReturnType.SpecialGenericType is not
 			                   (SpecialGenericType.Span or SpecialGenericType.ReadOnlySpan));
 		if (unsupported)
 		{
-			// No setup surface — the mock method body throws NotSupportedException at runtime and
-			// the analyzer flags the signature at build time. Skipping the declaration entirely
-			// keeps the setup interface clean.
 			return;
 		}
 
@@ -3806,8 +3873,7 @@ private static void AppendRefStructMethodSetupDefinition(StringBuilder sb, Metho
 				sb.Append(", ");
 			}
 
-			sb.Append("global::Mockolate.Parameters.IParameter<").Append(parameter.Type.Fullname)
-				.Append(">? ").Append(parameter.Name);
+			sb.Append(parameter.ToParameter()).Append("? ").Append(parameter.Name);
 		}
 
 		sb.Append(");").AppendLine();
@@ -3828,8 +3894,9 @@ private static void AppendRefStructMethodSetupImplementation(StringBuilder sb, M
 #pragma warning restore S107
 	{
 		bool unsupported = method.Parameters.Any(p =>
-			                   p.RefKind == RefKind.Out || p.RefKind == RefKind.Ref ||
-			                   p.RefKind == RefKind.RefReadOnlyParameter) ||
+			                   (p.RefKind == RefKind.Out || p.RefKind == RefKind.Ref ||
+			                    p.RefKind == RefKind.RefReadOnlyParameter)
+			                   && !p.NeedsRefStructPipeline()) ||
 		                   (method.ReturnType.IsRefStruct && method.ReturnType.SpecialGenericType is not
 			                   (SpecialGenericType.Span or SpecialGenericType.ReadOnlySpan));
 		if (unsupported)
@@ -3859,8 +3926,7 @@ private static void AppendRefStructMethodSetupImplementation(StringBuilder sb, M
 				sb.Append(", ");
 			}
 
-			sb.Append("global::Mockolate.Parameters.IParameter<").Append(parameter.Type.Fullname)
-				.Append(">? ").Append(parameter.Name);
+			sb.Append(parameter.ToParameter()).Append("? ").Append(parameter.Name);
 		}
 
 		sb.Append(")").AppendLine();
diff --git a/Source/Mockolate.SourceGenerators/Sources/Sources.RefStructMethodSetups.cs b/Source/Mockolate.SourceGenerators/Sources/Sources.RefStructMethodSetups.cs
index 16b35a21..084bcd62 100644
--- a/Source/Mockolate.SourceGenerators/Sources/Sources.RefStructMethodSetups.cs
+++ b/Source/Mockolate.SourceGenerators/Sources/Sources.RefStructMethodSetups.cs
@@ -179,6 +179,19 @@ private static void AppendRefStructVoidMethodSetup(StringBuilder sb, int numberO
 		sb.Append(';').AppendLine();
 		sb.AppendLine();
 
+		// Per-slot matcher accessors. Used by generated mock bodies to access
+		// IOutRefStructParameter<T>/IRefRefStructParameter<T> payloads on out/ref slots.
+		for (int i = 1; i <= numberOfParameters; i++)
+		{
+			sb.Append(
+					"\t\t[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]")
+				.AppendLine();
+			sb.Append("\t\tpublic global::Mockolate.Parameters.IParameterMatch<T").Append(i)
+				.Append(">? GetMatcher").Append(i).Append("() => _matcher").Append(i).Append(';').AppendLine();
+		}
+
+		sb.AppendLine();
+
 		// Invoke.
 		sb.Append("\t\tpublic void Invoke(");
 		for (int i = 1; i <= numberOfParameters; i++)
@@ -386,6 +399,19 @@ private static void AppendRefStructReturnMethodSetup(StringBuilder sb, int numbe
 		sb.Append(';').AppendLine();
 		sb.AppendLine();
 
+		// Per-slot matcher accessors. Used by generated mock bodies to access
+		// IOutRefStructParameter<T>/IRefRefStructParameter<T> payloads on out/ref slots.
+		for (int i = 1; i <= numberOfParameters; i++)
+		{
+			sb.Append(
+					"\t\t[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]")
+				.AppendLine();
+			sb.Append("\t\tpublic global::Mockolate.Parameters.IParameterMatch<T").Append(i)
+				.Append(">? GetMatcher").Append(i).Append("() => _matcher").Append(i).Append(';').AppendLine();
+		}
+
+		sb.AppendLine();
+
 		// Invoke.
 		sb.Append("\t\tpublic TReturn Invoke(");
 		for (int i = 1; i <= numberOfParameters; i++)
diff --git a/Source/Mockolate/It.IsOut.cs b/Source/Mockolate/It.IsOut.cs
index 7ce4979c..f6cdde4f 100644
--- a/Source/Mockolate/It.IsOut.cs
+++ b/Source/Mockolate/It.IsOut.cs
@@ -57,6 +57,69 @@ public static IOutParameter<T> IsOut<T>(Func<T> setter,
 	public static IOutParameter<T> IsAnyOut<T>()
 		=> new AnyOutParameterMatch<T>();
 
+#if NET8_0_OR_GREATER
+	/// <summary>
+	///     Matches any <see langword="out" /> <see cref="Span{T}" /> parameter in a <c>Setup</c> and uses
+	///     <paramref name="setter" /> to produce the value assigned to the caller's variable when the
+	///     method is invoked.
+	/// </summary>
+	/// <remarks>
+	///     <see cref="Span{T}" /> is a ref struct, so the setup-side payload is the non-ref-struct
+	///     <see cref="global::Mockolate.Setup.SpanWrapper{T}" />. The generated mock unpacks the wrapper
+	///     into a temp local and assigns it to the caller's <see cref="Span{T}" /> via the wrapper's
+	///     implicit conversion operator. Pair with
+	///     <see cref="IOutParameter{T}.Do(Action{T})" /> to observe each produced wrapper.
+	/// </remarks>
+	/// <typeparam name="T">The element type of the out-<see cref="Span{T}" /> parameter.</typeparam>
+	/// <param name="setter">Factory that produces the wrapper to assign to the caller's out-variable.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IOutParameter{T}" /> over <see cref="global::Mockolate.Setup.SpanWrapper{T}" />.</returns>
+	public static IOutParameter<Setup.SpanWrapper<T>> IsOutSpan<T>(
+		Func<Setup.SpanWrapper<T>> setter,
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue = "")
+		=> new OutParameterMatch<Setup.SpanWrapper<T>>(setter, doNotPopulateThisValue);
+
+	/// <summary>
+	///     Matches any <see langword="out" /> <see cref="Span{T}" /> parameter in a <c>Setup</c> and
+	///     assigns the default <see cref="global::Mockolate.Setup.SpanWrapper{T}" /> produced by the
+	///     mock's <see cref="MockBehavior.DefaultValue" /> generator (which yields an empty
+	///     <see cref="Span{T}" /> at the call site via the implicit conversion operator).
+	/// </summary>
+	/// <typeparam name="T">The element type of the out-<see cref="Span{T}" /> parameter.</typeparam>
+	/// <returns>An <see cref="IOutParameter{T}" /> over <see cref="global::Mockolate.Setup.SpanWrapper{T}" />.</returns>
+	public static IOutParameter<Setup.SpanWrapper<T>> IsAnyOutSpan<T>()
+		=> new AnyOutParameterMatch<Setup.SpanWrapper<T>>();
+
+	/// <summary>
+	///     Matches any <see langword="out" /> <see cref="ReadOnlySpan{T}" /> parameter in a <c>Setup</c>
+	///     and uses <paramref name="setter" /> to produce the value assigned to the caller's variable
+	///     when the method is invoked.
+	/// </summary>
+	/// <remarks>
+	///     <see cref="ReadOnlySpan{T}" /> is a ref struct, so the setup-side payload is the non-ref-struct
+	///     <see cref="global::Mockolate.Setup.ReadOnlySpanWrapper{T}" />. Pair with
+	///     <see cref="IOutParameter{T}.Do(Action{T})" /> to observe each produced wrapper.
+	/// </remarks>
+	/// <typeparam name="T">The element type of the out-<see cref="ReadOnlySpan{T}" /> parameter.</typeparam>
+	/// <param name="setter">Factory that produces the wrapper to assign to the caller's out-variable.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IOutParameter{T}" /> over <see cref="global::Mockolate.Setup.ReadOnlySpanWrapper{T}" />.</returns>
+	public static IOutParameter<Setup.ReadOnlySpanWrapper<T>> IsOutReadOnlySpan<T>(
+		Func<Setup.ReadOnlySpanWrapper<T>> setter,
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue = "")
+		=> new OutParameterMatch<Setup.ReadOnlySpanWrapper<T>>(setter, doNotPopulateThisValue);
+
+	/// <summary>
+	///     Matches any <see langword="out" /> <see cref="ReadOnlySpan{T}" /> parameter in a <c>Setup</c>
+	///     and assigns the default <see cref="global::Mockolate.Setup.ReadOnlySpanWrapper{T}" /> produced
+	///     by the mock's <see cref="MockBehavior.DefaultValue" /> generator.
+	/// </summary>
+	/// <typeparam name="T">The element type of the out-<see cref="ReadOnlySpan{T}" /> parameter.</typeparam>
+	/// <returns>An <see cref="IOutParameter{T}" /> over <see cref="global::Mockolate.Setup.ReadOnlySpanWrapper{T}" />.</returns>
+	public static IOutParameter<Setup.ReadOnlySpanWrapper<T>> IsAnyOutReadOnlySpan<T>()
+		=> new AnyOutParameterMatch<Setup.ReadOnlySpanWrapper<T>>();
+#endif
+
 	/// <summary>
 	///     Matches an <see langword="out" /> parameter against an expectation.
 	/// </summary>
@@ -102,6 +165,9 @@ public override bool TryGetValue(out T value)
 	[System.Diagnostics.DebuggerNonUserCode]
 #endif
 	private sealed class InvokedOutParameterMatch<T> : IVerifyOutParameter<T>, IParameterMatch<T>
+#if NET9_0_OR_GREATER
+		where T : allows ref struct
+#endif
 	{
 		/// <inheritdoc cref="object.ToString()" />
 		public override string ToString() => $"It.IsOut<{typeof(T).FormatType()}>()";
@@ -151,6 +217,112 @@ public void InvokeCallbacks(T value)
 			}
 		}
 	}
+
+#if NET9_0_OR_GREATER
+	/// <summary>
+	///     Matches any <see langword="out" /> parameter of a ref struct type
+	///     <typeparamref name="T" /> in a <c>Setup</c> and uses <paramref name="setter" /> to
+	///     produce the value assigned to the caller's variable when the method is invoked.
+	/// </summary>
+	/// <remarks>
+	///     <paramref name="setter" /> runs on every matching invocation, so you can return a fresh
+	///     value per call. The ref-struct-safe counterpart to
+	///     <see cref="IsOut{T}(System.Func{T}, string)" /> does not support
+	///     <see cref="IOutParameter{T}.Do(System.Action{T})" /> callbacks because
+	///     <see cref="System.Action{T}" /> cannot carry the <c>allows ref struct</c> anti-constraint.
+	///     <see cref="System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute" /> defers
+	///     to the <see cref="System.Func{T}" /> overload when both are viable.
+	/// </remarks>
+	/// <typeparam name="T">The out-parameter's ref struct type.</typeparam>
+	/// <param name="setter">Factory that produces the value to assign to the caller's out-variable.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IOutRefStructParameter{T}" /> that produces a value via <paramref name="setter" />.</returns>
+	[OverloadResolutionPriority(-1)]
+	public static IOutRefStructParameter<T> IsOut<T>(RefStructFactory<T> setter,
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue = "")
+		where T : allows ref struct
+		=> new OutRefStructParameterMatch<T>(setter, doNotPopulateThisValue);
+
+	/// <summary>
+	///     Matches any <see langword="out" /> parameter of a ref struct type
+	///     <typeparamref name="T" /> in a <c>Setup</c> and assigns
+	///     <see langword="default" />(<typeparamref name="T" />) to the caller's variable.
+	/// </summary>
+	/// <remarks>
+	///     Use this when the caller's out value is irrelevant to the test and you just need the
+	///     method call to return. Unlike the non-ref-struct <see cref="IsAnyOut{T}" /> overload,
+	///     the value is always <see langword="default" />(<typeparamref name="T" />) because
+	///     <see cref="MockBehavior.DefaultValue" /> cannot produce ref-struct values.
+	/// </remarks>
+	/// <typeparam name="T">The out-parameter's ref struct type.</typeparam>
+	/// <returns>An <see cref="IOutRefStructParameter{T}" /> that produces <see langword="default" />.</returns>
+	public static IOutRefStructParameter<T> IsAnyOutRefStruct<T>()
+		where T : allows ref struct
+		=> new AnyOutRefStructParameterMatch<T>();
+
+	/// <summary>
+	///     Matches an <see langword="out" /> parameter of a ref struct type against an expectation.
+	/// </summary>
+#if !DEBUG
+	[System.Diagnostics.DebuggerNonUserCode]
+#endif
+	private sealed class OutRefStructParameterMatch<T>(RefStructFactory<T> setter, string setterExpression)
+		: IOutRefStructParameter<T>, IParameterMatch<T>
+		where T : allows ref struct
+	{
+		/// <inheritdoc cref="IOutRefStructParameter{T}.TryGetValue(out T)" />
+		public bool TryGetValue(out T value)
+		{
+			value = setter();
+			return true;
+		}
+
+		/// <inheritdoc cref="IParameterMatch{T}.Matches(T)" />
+		public bool Matches(T value)
+			=> true;
+
+		/// <inheritdoc cref="IParameterMatch{T}.InvokeCallbacks(T)" />
+		public void InvokeCallbacks(T value)
+		{
+			// No callbacks: Action<T> cannot carry the 'allows ref struct' anti-constraint.
+		}
+
+		/// <inheritdoc cref="object.ToString()" />
+		public override string ToString() => $"It.IsOut<{typeof(T).FormatType()}>({setterExpression})";
+	}
+
+	/// <summary>
+	///     Matches any <see langword="out" /> parameter of a ref struct type and assigns
+	///     <see langword="default" /> to the caller's variable.
+	/// </summary>
+#if !DEBUG
+	[System.Diagnostics.DebuggerNonUserCode]
+#endif
+	private sealed class AnyOutRefStructParameterMatch<T> : IOutRefStructParameter<T>, IParameterMatch<T>
+		where T : allows ref struct
+	{
+		/// <inheritdoc cref="IOutRefStructParameter{T}.TryGetValue(out T)" />
+		public bool TryGetValue(out T value)
+		{
+			value = default!;
+			return false;
+		}
+
+		/// <inheritdoc cref="IParameterMatch{T}.Matches(T)" />
+		public bool Matches(T value)
+			=> true;
+
+		/// <inheritdoc cref="IParameterMatch{T}.InvokeCallbacks(T)" />
+		public void InvokeCallbacks(T value)
+		{
+			// No callbacks: Action<T> cannot carry the 'allows ref struct' anti-constraint.
+		}
+
+		/// <inheritdoc cref="object.ToString()" />
+		public override string ToString() => $"It.IsAnyOutRefStruct<{typeof(T).FormatType()}>()";
+	}
+
+#endif
 }
 #pragma warning restore S3218 // Inner class members should not shadow outer class "static" or type members
 #pragma warning restore S3453 // This class can't be instantiated; make its constructor 'public'.
diff --git a/Source/Mockolate/It.IsRef.cs b/Source/Mockolate/It.IsRef.cs
index 889d62dc..bc25739b 100644
--- a/Source/Mockolate/It.IsRef.cs
+++ b/Source/Mockolate/It.IsRef.cs
@@ -89,6 +89,122 @@ public static IVerifyRefParameter<T> IsRef<T>()
 	public static IRefParameter<T> IsAnyRef<T>()
 		=> new AnyRefParameterMatch<T>();
 
+#if NET8_0_OR_GREATER
+	/// <summary>
+	///     Matches any <see langword="ref" /> <see cref="Span{T}" /> parameter and replaces its value
+	///     with the result of <paramref name="setter" /> when the method is invoked.
+	/// </summary>
+	/// <remarks>
+	///     <see cref="Span{T}" /> is a ref struct, so the setup-side payload is the non-ref-struct
+	///     <see cref="global::Mockolate.Setup.SpanWrapper{T}" />. The wrapper's implicit conversion
+	///     operators carry the value across the ref boundary in both directions.
+	/// </remarks>
+	/// <typeparam name="T">The element type of the ref-<see cref="Span{T}" /> parameter.</typeparam>
+	/// <param name="setter">Factory that takes the caller's wrapped current value and returns the replacement wrapper.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefParameter{T}" /> over <see cref="global::Mockolate.Setup.SpanWrapper{T}" />.</returns>
+	public static IRefParameter<Setup.SpanWrapper<T>> IsRefSpan<T>(
+		Func<Setup.SpanWrapper<T>, Setup.SpanWrapper<T>> setter,
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue = "")
+		=> new RefParameterMatch<Setup.SpanWrapper<T>>(_ => true, setter, null, doNotPopulateThisValue);
+
+	/// <summary>
+	///     Matches a <see langword="ref" /> <see cref="Span{T}" /> parameter whose wrapped current value
+	///     satisfies <paramref name="predicate" />, and replaces its value with the result of
+	///     <paramref name="setter" />.
+	/// </summary>
+	/// <typeparam name="T">The element type of the ref-<see cref="Span{T}" /> parameter.</typeparam>
+	/// <param name="predicate">The predicate evaluated against the caller's wrapped current value.</param>
+	/// <param name="setter">Factory that takes the caller's wrapped current value and returns the replacement wrapper.</param>
+	/// <param name="doNotPopulateThisValue1">Do not populate - captured automatically by the compiler.</param>
+	/// <param name="doNotPopulateThisValue2">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefParameter{T}" /> over <see cref="global::Mockolate.Setup.SpanWrapper{T}" />.</returns>
+	public static IRefParameter<Setup.SpanWrapper<T>> IsRefSpan<T>(
+		Func<Setup.SpanWrapper<T>, bool> predicate,
+		Func<Setup.SpanWrapper<T>, Setup.SpanWrapper<T>> setter,
+		[CallerArgumentExpression("predicate")]
+		string doNotPopulateThisValue1 = "",
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "")
+		=> new RefParameterMatch<Setup.SpanWrapper<T>>(predicate, setter, doNotPopulateThisValue1, doNotPopulateThisValue2);
+
+	/// <summary>
+	///     Matches a <see langword="ref" /> <see cref="Span{T}" /> parameter whose wrapped current value
+	///     satisfies <paramref name="predicate" />, without replacing it.
+	/// </summary>
+	/// <typeparam name="T">The element type of the ref-<see cref="Span{T}" /> parameter.</typeparam>
+	/// <param name="predicate">The predicate evaluated against the caller's wrapped current value.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefParameter{T}" /> over <see cref="global::Mockolate.Setup.SpanWrapper{T}" />.</returns>
+	public static IRefParameter<Setup.SpanWrapper<T>> IsRefSpan<T>(
+		Func<Setup.SpanWrapper<T>, bool> predicate,
+		[CallerArgumentExpression("predicate")]
+		string doNotPopulateThisValue = "")
+		=> new RefParameterMatch<Setup.SpanWrapper<T>>(predicate, null, doNotPopulateThisValue, null);
+
+	/// <summary>
+	///     Matches any <see langword="ref" /> <see cref="Span{T}" /> parameter without replacing its value.
+	/// </summary>
+	/// <typeparam name="T">The element type of the ref-<see cref="Span{T}" /> parameter.</typeparam>
+	/// <returns>An <see cref="IRefParameter{T}" /> over <see cref="global::Mockolate.Setup.SpanWrapper{T}" />.</returns>
+	public static IRefParameter<Setup.SpanWrapper<T>> IsAnyRefSpan<T>()
+		=> new AnyRefParameterMatch<Setup.SpanWrapper<T>>();
+
+	/// <summary>
+	///     Matches any <see langword="ref" /> <see cref="ReadOnlySpan{T}" /> parameter and replaces its
+	///     value with the result of <paramref name="setter" /> when the method is invoked.
+	/// </summary>
+	/// <typeparam name="T">The element type of the ref-<see cref="ReadOnlySpan{T}" /> parameter.</typeparam>
+	/// <param name="setter">Factory that takes the caller's wrapped current value and returns the replacement wrapper.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefParameter{T}" /> over <see cref="global::Mockolate.Setup.ReadOnlySpanWrapper{T}" />.</returns>
+	public static IRefParameter<Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(
+		Func<Setup.ReadOnlySpanWrapper<T>, Setup.ReadOnlySpanWrapper<T>> setter,
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue = "")
+		=> new RefParameterMatch<Setup.ReadOnlySpanWrapper<T>>(_ => true, setter, null, doNotPopulateThisValue);
+
+	/// <summary>
+	///     Matches a <see langword="ref" /> <see cref="ReadOnlySpan{T}" /> parameter whose wrapped current
+	///     value satisfies <paramref name="predicate" />, and replaces its value with the result of
+	///     <paramref name="setter" />.
+	/// </summary>
+	/// <typeparam name="T">The element type of the ref-<see cref="ReadOnlySpan{T}" /> parameter.</typeparam>
+	/// <param name="predicate">The predicate evaluated against the caller's wrapped current value.</param>
+	/// <param name="setter">Factory that takes the caller's wrapped current value and returns the replacement wrapper.</param>
+	/// <param name="doNotPopulateThisValue1">Do not populate - captured automatically by the compiler.</param>
+	/// <param name="doNotPopulateThisValue2">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefParameter{T}" /> over <see cref="global::Mockolate.Setup.ReadOnlySpanWrapper{T}" />.</returns>
+	public static IRefParameter<Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(
+		Func<Setup.ReadOnlySpanWrapper<T>, bool> predicate,
+		Func<Setup.ReadOnlySpanWrapper<T>, Setup.ReadOnlySpanWrapper<T>> setter,
+		[CallerArgumentExpression("predicate")]
+		string doNotPopulateThisValue1 = "",
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "")
+		=> new RefParameterMatch<Setup.ReadOnlySpanWrapper<T>>(predicate, setter, doNotPopulateThisValue1, doNotPopulateThisValue2);
+
+	/// <summary>
+	///     Matches a <see langword="ref" /> <see cref="ReadOnlySpan{T}" /> parameter whose wrapped current
+	///     value satisfies <paramref name="predicate" />, without replacing it.
+	/// </summary>
+	/// <typeparam name="T">The element type of the ref-<see cref="ReadOnlySpan{T}" /> parameter.</typeparam>
+	/// <param name="predicate">The predicate evaluated against the caller's wrapped current value.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefParameter{T}" /> over <see cref="global::Mockolate.Setup.ReadOnlySpanWrapper{T}" />.</returns>
+	public static IRefParameter<Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(
+		Func<Setup.ReadOnlySpanWrapper<T>, bool> predicate,
+		[CallerArgumentExpression("predicate")]
+		string doNotPopulateThisValue = "")
+		=> new RefParameterMatch<Setup.ReadOnlySpanWrapper<T>>(predicate, null, doNotPopulateThisValue, null);
+
+	/// <summary>
+	///     Matches any <see langword="ref" /> <see cref="ReadOnlySpan{T}" /> parameter without replacing
+	///     its value.
+	/// </summary>
+	/// <typeparam name="T">The element type of the ref-<see cref="ReadOnlySpan{T}" /> parameter.</typeparam>
+	/// <returns>An <see cref="IRefParameter{T}" /> over <see cref="global::Mockolate.Setup.ReadOnlySpanWrapper{T}" />.</returns>
+	public static IRefParameter<Setup.ReadOnlySpanWrapper<T>> IsAnyRefReadOnlySpan<T>()
+		=> new AnyRefParameterMatch<Setup.ReadOnlySpanWrapper<T>>();
+#endif
+
 	/// <summary>
 	///     Matches a method <see langword="ref" /> parameter against an expectation.
 	/// </summary>
@@ -144,14 +260,17 @@ protected override bool Matches(T value)
 	}
 
 	/// <summary>
-	///     Matches a method <see langword="out" /> parameter against an expectation.
+	///     Matches a method <see langword="ref" /> parameter against an expectation.
 	/// </summary>
 #if !DEBUG
 	[System.Diagnostics.DebuggerNonUserCode]
 #endif
 	private sealed class InvokedRefParameterMatch<T> : IVerifyRefParameter<T>, IParameterMatch<T>
+#if NET9_0_OR_GREATER
+		where T : allows ref struct
+#endif
 	{
-		/// <inheritdoc cref="IParameterMatch{T}.InvokeCallbacks(T)" />
+		/// <inheritdoc cref="IParameterMatch{T}.Matches(T)" />
 		bool IParameterMatch<T>.Matches(T value)
 			=> true;
 
@@ -205,6 +324,147 @@ public IRefParameter<T> Do(Action<T> callback)
 		/// </summary>
 		protected abstract bool Matches(T value);
 	}
+
+#if NET9_0_OR_GREATER
+	/// <summary>
+	///     Matches any <see langword="ref" /> parameter of a ref struct type
+	///     <typeparamref name="T" /> and replaces its value with the result of
+	///     <paramref name="setter" /> when the method is invoked.
+	/// </summary>
+	/// <remarks>
+	///     The ref-struct-safe counterpart to <see cref="IsRef{T}(System.Func{T, T}, string)" /> does
+	///     not support <see cref="IRefParameter{T}.Do(System.Action{T})" /> callbacks because
+	///     <see cref="System.Action{T}" /> cannot carry the <c>allows ref struct</c> anti-constraint.
+	///     <see cref="System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute" /> defers
+	///     to the <see cref="System.Func{T, T}" /> overload when both are viable.
+	/// </remarks>
+	/// <typeparam name="T">The ref-parameter's ref struct type.</typeparam>
+	/// <param name="setter">Factory that takes the caller's current value and returns the replacement value.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefRefStructParameter{T}" /> that mutates the caller's ref-variable via <paramref name="setter" />.</returns>
+	[OverloadResolutionPriority(-1)]
+	public static IRefRefStructParameter<T> IsRef<T>(RefStructTransform<T> setter,
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue = "")
+		where T : allows ref struct
+		=> new RefRefStructParameterMatch<T>(static _ => true, setter, null, doNotPopulateThisValue);
+
+	/// <summary>
+	///     Matches a <see langword="ref" /> parameter of a ref struct type whose current value
+	///     satisfies <paramref name="predicate" />, and replaces its value with the result of
+	///     <paramref name="setter" />.
+	/// </summary>
+	/// <typeparam name="T">The ref-parameter's ref struct type.</typeparam>
+	/// <param name="predicate">The predicate evaluated against the caller's current value.</param>
+	/// <param name="setter">Factory that takes the caller's current value and returns the replacement value.</param>
+	/// <param name="doNotPopulateThisValue1">Do not populate - captured automatically by the compiler.</param>
+	/// <param name="doNotPopulateThisValue2">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefRefStructParameter{T}" /> that matches when <paramref name="predicate" /> is satisfied and mutates via <paramref name="setter" />.</returns>
+	[OverloadResolutionPriority(-1)]
+	public static IRefRefStructParameter<T> IsRef<T>(RefStructPredicate<T> predicate, RefStructTransform<T> setter,
+		[CallerArgumentExpression("predicate")]
+		string doNotPopulateThisValue1 = "",
+		[CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "")
+		where T : allows ref struct
+		=> new RefRefStructParameterMatch<T>(predicate, setter, doNotPopulateThisValue1, doNotPopulateThisValue2);
+
+	/// <summary>
+	///     Matches a <see langword="ref" /> parameter of a ref struct type whose current value
+	///     satisfies <paramref name="predicate" />, without replacing it.
+	/// </summary>
+	/// <typeparam name="T">The ref-parameter's ref struct type.</typeparam>
+	/// <param name="predicate">The predicate evaluated against the caller's current value.</param>
+	/// <param name="doNotPopulateThisValue">Do not populate - captured automatically by the compiler.</param>
+	/// <returns>An <see cref="IRefRefStructParameter{T}" /> that matches when <paramref name="predicate" /> is satisfied and does not mutate the ref-variable.</returns>
+	[OverloadResolutionPriority(-1)]
+	public static IRefRefStructParameter<T> IsRef<T>(RefStructPredicate<T> predicate,
+		[CallerArgumentExpression("predicate")]
+		string doNotPopulateThisValue = "")
+		where T : allows ref struct
+		=> new RefRefStructParameterMatch<T>(predicate, null, doNotPopulateThisValue, null);
+
+	/// <summary>
+	///     Matches any <see langword="ref" /> parameter of a ref struct type
+	///     <typeparamref name="T" /> without replacing its value.
+	/// </summary>
+	/// <typeparam name="T">The ref-parameter's ref struct type.</typeparam>
+	/// <returns>An <see cref="IRefRefStructParameter{T}" /> that matches any ref-argument and leaves it unchanged.</returns>
+	public static IRefRefStructParameter<T> IsAnyRefRefStruct<T>()
+		where T : allows ref struct
+		=> new AnyRefRefStructParameterMatch<T>();
+
+	/// <summary>
+	///     Matches a method <see langword="ref" /> parameter of a ref struct type against an expectation.
+	/// </summary>
+#if !DEBUG
+	[System.Diagnostics.DebuggerNonUserCode]
+#endif
+	private sealed class RefRefStructParameterMatch<T>(
+		RefStructPredicate<T> predicate,
+		RefStructTransform<T>? setter,
+		string? predicateExpression,
+		string? setterExpression) : IRefRefStructParameter<T>, IParameterMatch<T>
+		where T : allows ref struct
+	{
+		/// <inheritdoc cref="IRefRefStructParameter{T}.GetValue(T)" />
+		public T GetValue(T value)
+		{
+			if (setter is null)
+			{
+				return value;
+			}
+
+			return setter(value);
+		}
+
+		/// <inheritdoc cref="IParameterMatch{T}.Matches(T)" />
+		public bool Matches(T value)
+			=> predicate(value);
+
+		/// <inheritdoc cref="IParameterMatch{T}.InvokeCallbacks(T)" />
+		public void InvokeCallbacks(T value)
+		{
+			// No callbacks: Action<T> cannot carry the 'allows ref struct' anti-constraint.
+		}
+
+		/// <inheritdoc cref="object.ToString()" />
+		public override string ToString()
+			=> (predicateExpression is not null, setterExpression is not null) switch
+			{
+				(true, true) => $"It.IsRef<{typeof(T).FormatType()}>({predicateExpression}, {setterExpression})",
+				(true, false) => $"It.IsRef<{typeof(T).FormatType()}>({predicateExpression})",
+				(false, _) => $"It.IsRef<{typeof(T).FormatType()}>({setterExpression})",
+			};
+	}
+
+	/// <summary>
+	///     Matches any method <see langword="ref" /> parameter of a ref struct type without
+	///     mutating the value.
+	/// </summary>
+#if !DEBUG
+	[System.Diagnostics.DebuggerNonUserCode]
+#endif
+	private sealed class AnyRefRefStructParameterMatch<T> : IRefRefStructParameter<T>, IParameterMatch<T>
+		where T : allows ref struct
+	{
+		/// <inheritdoc cref="IRefRefStructParameter{T}.GetValue(T)" />
+		public T GetValue(T value)
+			=> value;
+
+		/// <inheritdoc cref="IParameterMatch{T}.Matches(T)" />
+		public bool Matches(T value)
+			=> true;
+
+		/// <inheritdoc cref="IParameterMatch{T}.InvokeCallbacks(T)" />
+		public void InvokeCallbacks(T value)
+		{
+			// No callbacks: Action<T> cannot carry the 'allows ref struct' anti-constraint.
+		}
+
+		/// <inheritdoc cref="object.ToString()" />
+		public override string ToString() => $"It.IsAnyRefRefStruct<{typeof(T).FormatType()}>()";
+	}
+
+#endif
 }
 #pragma warning restore S3218 // Inner class members should not shadow outer class "static" or type members
 #pragma warning restore S3453 // This class can't be instantiated; make its constructor 'public'.
diff --git a/Source/Mockolate/Parameters/IOutRefStructParameter.cs b/Source/Mockolate/Parameters/IOutRefStructParameter.cs
new file mode 100644
index 00000000..b4382787
--- /dev/null
+++ b/Source/Mockolate/Parameters/IOutRefStructParameter.cs
@@ -0,0 +1,28 @@
+#if NET9_0_OR_GREATER
+namespace Mockolate.Parameters;
+
+/// <summary>
+///     Matches an <see langword="out" /> parameter of a ref struct type
+///     <typeparamref name="T" /> against an expectation.
+/// </summary>
+/// <remarks>
+///     The ref-struct-safe counterpart to <see cref="IOutParameter{T}" />. The surface is
+///     deliberately narrower: no <c>Do(Action&lt;T&gt;)</c> callback because
+///     <see cref="System.Action{T}" /> cannot carry the <c>allows ref struct</c> anti-constraint.
+///     Use a non-ref-struct <see cref="IOutParameter{T}" /> for types that are not ref structs.
+/// </remarks>
+public interface IOutRefStructParameter<T>
+	where T : allows ref struct
+{
+	/// <summary>
+	///     Tries to get the value to which the <see langword="out" /> parameter should be set.
+	/// </summary>
+	/// <remarks>
+	///     When the method returns <see langword="true" />, <paramref name="value" /> is the value
+	///     the mock should write back to the <see langword="out" /> parameter. When it returns
+	///     <see langword="false" />, the mock writes <see langword="default" />(<typeparamref name="T" />)
+	///     instead.
+	/// </remarks>
+	bool TryGetValue(out T value);
+}
+#endif
diff --git a/Source/Mockolate/Parameters/IRefRefStructParameter.cs b/Source/Mockolate/Parameters/IRefRefStructParameter.cs
new file mode 100644
index 00000000..f62adaee
--- /dev/null
+++ b/Source/Mockolate/Parameters/IRefRefStructParameter.cs
@@ -0,0 +1,23 @@
+#if NET9_0_OR_GREATER
+namespace Mockolate.Parameters;
+
+/// <summary>
+///     Matches a <see langword="ref" /> parameter of a ref struct type
+///     <typeparamref name="T" /> against an expectation.
+/// </summary>
+/// <remarks>
+///     The ref-struct-safe counterpart to <see cref="IRefParameter{T}" />. The surface is
+///     deliberately narrower: no <c>Do(Action&lt;T&gt;)</c> callback because
+///     <see cref="System.Action{T}" /> cannot carry the <c>allows ref struct</c> anti-constraint.
+///     Use a non-ref-struct <see cref="IRefParameter{T}" /> for types that are not ref structs.
+/// </remarks>
+public interface IRefRefStructParameter<T>
+	where T : allows ref struct
+{
+	/// <summary>
+	///     Retrieves the value to which the <see langword="ref" /> parameter should be set,
+	///     given the caller's current <paramref name="value" />.
+	/// </summary>
+	T GetValue(T value);
+}
+#endif
diff --git a/Source/Mockolate/Parameters/IVerifyOutParameter.cs b/Source/Mockolate/Parameters/IVerifyOutParameter.cs
index 8db51973..4e92234a 100644
--- a/Source/Mockolate/Parameters/IVerifyOutParameter.cs
+++ b/Source/Mockolate/Parameters/IVerifyOutParameter.cs
@@ -5,5 +5,9 @@ namespace Mockolate.Parameters;
 /// <summary>
 ///     Matches any <see langword="out" /> parameter.
 /// </summary>
-public interface IVerifyOutParameter<out T>;
+public interface IVerifyOutParameter<out T>
+#if NET9_0_OR_GREATER
+	where T : allows ref struct
+#endif
+;
 #pragma warning restore S2326 // Unused type parameters should be removed
diff --git a/Source/Mockolate/Parameters/IVerifyRefParameter.cs b/Source/Mockolate/Parameters/IVerifyRefParameter.cs
index 3287e454..9c576c3a 100644
--- a/Source/Mockolate/Parameters/IVerifyRefParameter.cs
+++ b/Source/Mockolate/Parameters/IVerifyRefParameter.cs
@@ -5,5 +5,9 @@ namespace Mockolate.Parameters;
 /// <summary>
 ///     Matches any <see langword="ref" /> parameter.
 /// </summary>
-public interface IVerifyRefParameter<T>;
+public interface IVerifyRefParameter<T>
+#if NET9_0_OR_GREATER
+	where T : allows ref struct
+#endif
+;
 #pragma warning restore S2326 // Unused type parameters should be removed
diff --git a/Source/Mockolate/RefStructFactory.cs b/Source/Mockolate/RefStructFactory.cs
new file mode 100644
index 00000000..ca24513a
--- /dev/null
+++ b/Source/Mockolate/RefStructFactory.cs
@@ -0,0 +1,17 @@
+#if NET9_0_OR_GREATER
+namespace Mockolate;
+
+/// <summary>
+///     Produces a ref struct value of type <typeparamref name="T" />.
+/// </summary>
+/// <remarks>
+///     Unlike <see cref="System.Func{TResult}" />, this delegate carries the
+///     <c>allows ref struct</c> anti-constraint on the return type, so
+///     <typeparamref name="T" /> can be a ref struct such as <see cref="System.Span{T}" />
+///     or a user-defined <c>ref struct</c>. Used by
+///     <see cref="It.IsOut{T}(RefStructFactory{T}, string)" /> to produce the value assigned to
+///     a caller's <see langword="out" /> variable when the mock is invoked.
+/// </remarks>
+public delegate T RefStructFactory<out T>()
+	where T : allows ref struct;
+#endif
diff --git a/Source/Mockolate/RefStructTransform.cs b/Source/Mockolate/RefStructTransform.cs
new file mode 100644
index 00000000..d701c839
--- /dev/null
+++ b/Source/Mockolate/RefStructTransform.cs
@@ -0,0 +1,16 @@
+#if NET9_0_OR_GREATER
+namespace Mockolate;
+
+/// <summary>
+///     Transforms a ref struct value of type <typeparamref name="T" /> into a replacement of
+///     the same type.
+/// </summary>
+/// <remarks>
+///     Unlike <see cref="System.Func{T, TResult}" />, this delegate carries the
+///     <c>allows ref struct</c> anti-constraint, so <typeparamref name="T" /> can be a ref
+///     struct. Used by <see cref="It.IsRef{T}(RefStructTransform{T}, string)" /> to compute the
+///     replacement value for a caller's <see langword="ref" /> variable when the mock is invoked.
+/// </remarks>
+public delegate T RefStructTransform<T>(T value)
+	where T : allows ref struct;
+#endif
diff --git a/Source/Mockolate/Setup/ReadOnlySpanWrapper.cs b/Source/Mockolate/Setup/ReadOnlySpanWrapper.cs
index f3f50e38..60f79584 100644
--- a/Source/Mockolate/Setup/ReadOnlySpanWrapper.cs
+++ b/Source/Mockolate/Setup/ReadOnlySpanWrapper.cs
@@ -25,10 +25,11 @@ public ReadOnlySpanWrapper(ReadOnlySpan<T> span)
 
 	/// <summary>
 	///     Implicitly converts a <see cref="ReadOnlySpanWrapper{T}" /> to a <see cref="ReadOnlySpan{T}" />.
+	///     A <see langword="null" /> wrapper yields <see langword="default" />(<see cref="ReadOnlySpan{T}" />).
 	/// </summary>
-	public static implicit operator ReadOnlySpan<T>(ReadOnlySpanWrapper<T> wrapper)
+	public static implicit operator ReadOnlySpan<T>(ReadOnlySpanWrapper<T>? wrapper)
 	{
-		return new ReadOnlySpan<T>(wrapper.ReadOnlySpanValues);
+		return wrapper is null ? default : new ReadOnlySpan<T>(wrapper.ReadOnlySpanValues);
 	}
 
 	/// <summary>
diff --git a/Source/Mockolate/Setup/RefStructIndexerSetup.cs b/Source/Mockolate/Setup/RefStructIndexerSetup.cs
index 891131f1..66da26f8 100644
--- a/Source/Mockolate/Setup/RefStructIndexerSetup.cs
+++ b/Source/Mockolate/Setup/RefStructIndexerSetup.cs
@@ -66,7 +66,7 @@ public RefStructIndexerSetup(string getterName, string setterName, IParameterMat
 	///     abstract contract and returns <see langword="false" /> so the combined instance never
 	///     participates in <see cref="MockRegistry.GetMethodSetups{T}" /> lookups.
 	/// </remarks>
-	protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) => false;
+	protected override bool MatchesInteraction(Interactions.IMethodInteraction interaction) => false;
 
 	IRefStructIndexerSetup<TValue, T> IRefStructIndexerSetup<TValue, T>.SkippingBaseClass(bool skipBaseClass)
 	{
@@ -147,7 +147,7 @@ public RefStructIndexerSetup(string getterName, string setterName,
 	}
 
 	/// <inheritdoc cref="RefStructIndexerSetup{TValue, T}.MatchesInteraction(Mockolate.Interactions.IMethodInteraction)" />
-	protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) => false;
+	protected override bool MatchesInteraction(Interactions.IMethodInteraction interaction) => false;
 
 	IRefStructIndexerSetup<TValue, T1, T2> IRefStructIndexerSetup<TValue, T1, T2>.SkippingBaseClass(bool skipBaseClass)
 	{
@@ -231,7 +231,7 @@ public RefStructIndexerSetup(string getterName, string setterName,
 	}
 
 	/// <inheritdoc cref="RefStructIndexerSetup{TValue, T}.MatchesInteraction(Mockolate.Interactions.IMethodInteraction)" />
-	protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) => false;
+	protected override bool MatchesInteraction(Interactions.IMethodInteraction interaction) => false;
 
 	IRefStructIndexerSetup<TValue, T1, T2, T3> IRefStructIndexerSetup<TValue, T1, T2, T3>.SkippingBaseClass(bool skipBaseClass)
 	{
@@ -317,7 +317,7 @@ public RefStructIndexerSetup(string getterName, string setterName,
 	}
 
 	/// <inheritdoc cref="RefStructIndexerSetup{TValue, T}.MatchesInteraction(Mockolate.Interactions.IMethodInteraction)" />
-	protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) => false;
+	protected override bool MatchesInteraction(Interactions.IMethodInteraction interaction) => false;
 
 	IRefStructIndexerSetup<TValue, T1, T2, T3, T4> IRefStructIndexerSetup<TValue, T1, T2, T3, T4>.SkippingBaseClass(bool skipBaseClass)
 	{
diff --git a/Source/Mockolate/Setup/RefStructReturnMethodSetup.cs b/Source/Mockolate/Setup/RefStructReturnMethodSetup.cs
index 45ea5e99..979763ab 100644
--- a/Source/Mockolate/Setup/RefStructReturnMethodSetup.cs
+++ b/Source/Mockolate/Setup/RefStructReturnMethodSetup.cs
@@ -37,6 +37,13 @@ public RefStructReturnMethodSetup(string name, IParameterMatch<T>? matcher = nul
 	public bool Matches(T value)
 		=> _matcher is null || _matcher.Matches(value);
 
+	/// <summary>
+	///     Returns the matcher for the first (and only) parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T>? GetMatcher1()
+		=> _matcher;
+
 	/// <summary>
 	///     Invokes matcher callbacks, applies any configured throw, and returns the configured
 	///     value. If no return value is configured, falls back to <paramref name="defaultFactory" />
@@ -156,6 +163,20 @@ public bool Matches(T1 value1, T2 value2)
 		=> (_matcher1 is null || _matcher1.Matches(value1))
 		   && (_matcher2 is null || _matcher2.Matches(value2));
 
+	/// <summary>
+	///     Returns the matcher for the first parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T1>? GetMatcher1()
+		=> _matcher1;
+
+	/// <summary>
+	///     Returns the matcher for the second parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T2>? GetMatcher2()
+		=> _matcher2;
+
 	/// <inheritdoc cref="RefStructReturnMethodSetup{TReturn, T}.Invoke(T, Func{TReturn})" />
 	public TReturn Invoke(T1 value1, T2 value2, Func<TReturn>? defaultFactory = null)
 	{
@@ -267,6 +288,27 @@ public bool Matches(T1 value1, T2 value2, T3 value3)
 		   && (_matcher2 is null || _matcher2.Matches(value2))
 		   && (_matcher3 is null || _matcher3.Matches(value3));
 
+	/// <summary>
+	///     Returns the matcher for the first parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T1>? GetMatcher1()
+		=> _matcher1;
+
+	/// <summary>
+	///     Returns the matcher for the second parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T2>? GetMatcher2()
+		=> _matcher2;
+
+	/// <summary>
+	///     Returns the matcher for the third parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T3>? GetMatcher3()
+		=> _matcher3;
+
 	/// <inheritdoc cref="RefStructReturnMethodSetup{TReturn, T}.Invoke(T, Func{TReturn})" />
 	public TReturn Invoke(T1 value1, T2 value2, T3 value3, Func<TReturn>? defaultFactory = null)
 	{
@@ -384,6 +426,34 @@ public bool Matches(T1 value1, T2 value2, T3 value3, T4 value4)
 		   && (_matcher3 is null || _matcher3.Matches(value3))
 		   && (_matcher4 is null || _matcher4.Matches(value4));
 
+	/// <summary>
+	///     Returns the matcher for the first parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T1>? GetMatcher1()
+		=> _matcher1;
+
+	/// <summary>
+	///     Returns the matcher for the second parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T2>? GetMatcher2()
+		=> _matcher2;
+
+	/// <summary>
+	///     Returns the matcher for the third parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T3>? GetMatcher3()
+		=> _matcher3;
+
+	/// <summary>
+	///     Returns the matcher for the fourth parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T4>? GetMatcher4()
+		=> _matcher4;
+
 	/// <inheritdoc cref="RefStructReturnMethodSetup{TReturn, T}.Invoke(T, Func{TReturn})" />
 	public TReturn Invoke(T1 value1, T2 value2, T3 value3, T4 value4, Func<TReturn>? defaultFactory = null)
 	{
diff --git a/Source/Mockolate/Setup/RefStructVoidMethodSetup.cs b/Source/Mockolate/Setup/RefStructVoidMethodSetup.cs
index 3d743905..938aa172 100644
--- a/Source/Mockolate/Setup/RefStructVoidMethodSetup.cs
+++ b/Source/Mockolate/Setup/RefStructVoidMethodSetup.cs
@@ -58,6 +58,15 @@ public RefStructVoidMethodSetup(string name, IParameterMatch<T>? matcher = null)
 	public bool Matches(T value)
 		=> _matcher is null || _matcher.Matches(value);
 
+	/// <summary>
+	///     Returns the matcher for the first (and only) parameter slot, or <see langword="null" />
+	///     when the slot has no matcher configured. Used by generated mock bodies to access ref-struct
+	///     <c>out</c>/<c>ref</c> matcher payloads (e.g. <see cref="IOutRefStructParameter{T}" />).
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T>? GetMatcher1()
+		=> _matcher;
+
 	/// <summary>
 	///     Invokes any matcher-level callbacks against the live <paramref name="value" /> and then
 	///     applies the currently configured throw (if any).
@@ -162,6 +171,20 @@ public bool Matches(T1 value1, T2 value2)
 		=> (_matcher1 is null || _matcher1.Matches(value1))
 		   && (_matcher2 is null || _matcher2.Matches(value2));
 
+	/// <summary>
+	///     Returns the matcher for the first parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T1>? GetMatcher1()
+		=> _matcher1;
+
+	/// <summary>
+	///     Returns the matcher for the second parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T2>? GetMatcher2()
+		=> _matcher2;
+
 	/// <summary>
 	///     Invokes any matcher-level callbacks and applies the currently configured throw (if any).
 	/// </summary>
@@ -269,6 +292,27 @@ public bool Matches(T1 value1, T2 value2, T3 value3)
 		   && (_matcher2 is null || _matcher2.Matches(value2))
 		   && (_matcher3 is null || _matcher3.Matches(value3));
 
+	/// <summary>
+	///     Returns the matcher for the first parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T1>? GetMatcher1()
+		=> _matcher1;
+
+	/// <summary>
+	///     Returns the matcher for the second parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T2>? GetMatcher2()
+		=> _matcher2;
+
+	/// <summary>
+	///     Returns the matcher for the third parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T3>? GetMatcher3()
+		=> _matcher3;
+
 	/// <summary>
 	///     Invokes any matcher-level callbacks and applies the currently configured throw (if any).
 	/// </summary>
@@ -382,6 +426,34 @@ public bool Matches(T1 value1, T2 value2, T3 value3, T4 value4)
 		   && (_matcher3 is null || _matcher3.Matches(value3))
 		   && (_matcher4 is null || _matcher4.Matches(value4));
 
+	/// <summary>
+	///     Returns the matcher for the first parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T1>? GetMatcher1()
+		=> _matcher1;
+
+	/// <summary>
+	///     Returns the matcher for the second parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T2>? GetMatcher2()
+		=> _matcher2;
+
+	/// <summary>
+	///     Returns the matcher for the third parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T3>? GetMatcher3()
+		=> _matcher3;
+
+	/// <summary>
+	///     Returns the matcher for the fourth parameter slot.
+	/// </summary>
+	[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+	public IParameterMatch<T4>? GetMatcher4()
+		=> _matcher4;
+
 	/// <summary>
 	///     Invokes any matcher-level callbacks and applies the currently configured throw (if any).
 	/// </summary>
diff --git a/Source/Mockolate/Setup/SpanWrapper.cs b/Source/Mockolate/Setup/SpanWrapper.cs
index 7f333f23..8b77adb0 100644
--- a/Source/Mockolate/Setup/SpanWrapper.cs
+++ b/Source/Mockolate/Setup/SpanWrapper.cs
@@ -24,11 +24,12 @@ public SpanWrapper(Span<T> span)
 	public T[] SpanValues { get; }
 
 	/// <summary>
-	///     Implicitly converts a <see cref="SpanWrapper{T}" /> to a <see cref="Span{T}" />.
+	///     Implicitly converts a <see cref="SpanWrapper{T}" /> to a <see cref="Span{T}" />. A
+	///     <see langword="null" /> wrapper yields <see langword="default" />(<see cref="Span{T}" />).
 	/// </summary>
-	public static implicit operator Span<T>(SpanWrapper<T> wrapper)
+	public static implicit operator Span<T>(SpanWrapper<T>? wrapper)
 	{
-		return new Span<T>(wrapper.SpanValues);
+		return wrapper is null ? default : new Span<T>(wrapper.SpanValues);
 	}
 
 	/// <summary>
diff --git a/Tests/Mockolate.Analyzers.Tests/MockabilityAnalyzerRefStructTests.cs b/Tests/Mockolate.Analyzers.Tests/MockabilityAnalyzerRefStructTests.cs
index 11fd9644..711c58e4 100644
--- a/Tests/Mockolate.Analyzers.Tests/MockabilityAnalyzerRefStructTests.cs
+++ b/Tests/Mockolate.Analyzers.Tests/MockabilityAnalyzerRefStructTests.cs
@@ -84,7 +84,7 @@ public void MyTest()
 		);
 
 	[Fact]
-	public async Task WhenMockingAbstractClassWithInheritedRefStructViolation_ShouldBeFlagged() => await Verifier
+	public async Task WhenMockingAbstractClassWithInheritedRefStructOutParameter_ShouldNotBeFlagged() => await Verifier
 		.VerifyAnalyzerAsync(
 			$$"""
 			  {{GeneratedPrefix("MyNamespace.DerivedProducer")}}
@@ -95,7 +95,7 @@ namespace MyNamespace
 
 			  	public abstract class BaseProducer
 			  	{
-			  		// Virtual members on a base class are also walked and must trip the analyzer.
+			  		// Out ref-struct parameters are supported via IOutRefStructParameter<T>.
 			  		public abstract void Produce(out Packet packet);
 			  	}
 
@@ -108,15 +108,11 @@ public class MyClass
 			  	{
 			  		public void MyTest()
 			  		{
-			  			{|#0:DerivedProducer|}.CreateMock();
+			  			DerivedProducer.CreateMock();
 			  		}
 			  	}
 			  }
-			  """,
-			new DiagnosticResult("Mockolate0003", DiagnosticSeverity.Warning)
-				.WithLocation(0)
-				.WithArguments("MyNamespace.DerivedProducer", "Produce",
-					"out/ref ref-struct parameters are not supported")
+			  """
 		);
 
 	[Fact]
@@ -158,8 +154,9 @@ namespace MyNamespace
 			  {
 			  	public readonly ref struct Packet(int id) { public int Id { get; } = id; }
 
-			  	// Delegate Invoke methods are analyzed the same as interface methods; out/ref on
-			  	// a ref-struct parameter must be rejected.
+			  	// Delegate Invoke methods are analyzed the same as interface methods; ref-struct
+			  	// parameters (any RefKind) must be rejected because the emitted VoidMethodSetup
+			  	// has no 'allows ref struct' constraint.
 			  	public delegate void PacketProducerDelegate(out Packet packet);
 
 			  	public class MyClass
@@ -174,11 +171,11 @@ public void MyTest()
 			new DiagnosticResult("Mockolate0003", DiagnosticSeverity.Warning)
 				.WithLocation(0)
 				.WithArguments("MyNamespace.PacketProducerDelegate", "Invoke",
-					"out/ref ref-struct parameters are not supported")
+					"ref-struct parameters are not supported on delegate types")
 		);
 
 	[Fact]
-	public async Task WhenMockingDelegateWithPlainRefStructParameter_ShouldNotBeFlagged() => await Verifier
+	public async Task WhenMockingDelegateWithPlainRefStructParameter_ShouldBeFlagged() => await Verifier
 		.VerifyAnalyzerAsync(
 			$$"""
 			  {{GeneratedPrefix("MyNamespace.PacketHandler")}}
@@ -187,23 +184,28 @@ namespace MyNamespace
 			  {
 			  	public readonly ref struct Packet(int id) { public int Id { get; } = id; }
 
-			  	// Delegate Invoke with a plain ref-struct parameter — routed through the
-			  	// generator's ref-struct pipeline, no diagnostic expected.
+			  	// Delegate Invoke with a plain ref-struct parameter — the generator emits
+			  	// VoidMethodSetup<Packet>, which lacks 'allows ref struct' and therefore fails
+			  	// to compile. The analyzer must reject this case as well.
 			  	public delegate void PacketHandler(Packet packet);
 
 			  	public class MyClass
 			  	{
 			  		public void MyTest()
 			  		{
-			  			PacketHandler.CreateMock();
+			  			{|#0:PacketHandler|}.CreateMock();
 			  		}
 			  	}
 			  }
-			  """
+			  """,
+			new DiagnosticResult("Mockolate0003", DiagnosticSeverity.Warning)
+				.WithLocation(0)
+				.WithArguments("MyNamespace.PacketHandler", "Invoke",
+					"ref-struct parameters are not supported on delegate types")
 		);
 
 	[Fact]
-	public async Task WhenMockingInterfaceInheritingFromInterfaceWithBadMethod_ShouldBeFlagged() => await Verifier
+	public async Task WhenMockingInterfaceInheritingRefStructOutMethod_ShouldNotBeFlagged() => await Verifier
 		.VerifyAnalyzerAsync(
 			$$"""
 			  {{GeneratedPrefix("MyNamespace.IDerivedSink")}}
@@ -217,8 +219,6 @@ public interface IBaseSink
 			  		void Produce(out Packet packet);
 			  	}
 
-			  	// Inherited members are walked via ITypeSymbol.AllInterfaces — the violation on
-			  	// the base must surface against the derived interface being mocked.
 			  	public interface IDerivedSink : IBaseSink
 			  	{
 			  		void Extra();
@@ -228,15 +228,11 @@ public class MyClass
 			  	{
 			  		public void MyTest()
 			  		{
-			  			{|#0:IDerivedSink|}.CreateMock();
+			  			IDerivedSink.CreateMock();
 			  		}
 			  	}
 			  }
-			  """,
-			new DiagnosticResult("Mockolate0003", DiagnosticSeverity.Warning)
-				.WithLocation(0)
-				.WithArguments("MyNamespace.IDerivedSink", "Produce",
-					"out/ref ref-struct parameters are not supported")
+			  """
 		);
 
 	[Fact]
@@ -270,7 +266,7 @@ public void MyTest()
 		);
 
 	[Fact]
-	public async Task WhenMockingInterfaceWithOutRefStructParameter_ShouldBeFlagged() => await Verifier
+	public async Task WhenMockingInterfaceWithOutRefStructParameter_ShouldNotBeFlagged() => await Verifier
 		.VerifyAnalyzerAsync(
 			$$"""
 			  {{GeneratedPrefix("MyNamespace.IPacketProducer")}}
@@ -288,19 +284,15 @@ public class MyClass
 			  	{
 			  		public void MyTest()
 			  		{
-			  			{|#0:IPacketProducer|}.CreateMock();
+			  			IPacketProducer.CreateMock();
 			  		}
 			  	}
 			  }
-			  """,
-			new DiagnosticResult("Mockolate0003", DiagnosticSeverity.Warning)
-				.WithLocation(0)
-				.WithArguments("MyNamespace.IPacketProducer", "Produce",
-					"out/ref ref-struct parameters are not supported")
+			  """
 		);
 
 	[Fact]
-	public async Task WhenMockingInterfaceWithOverloads_OnlyViolatingOverloadIsFlagged() => await Verifier
+	public async Task WhenMockingInterfaceWithRefStructOutAndPlainOverloads_ShouldNotBeFlagged() => await Verifier
 		.VerifyAnalyzerAsync(
 			$$"""
 			  {{GeneratedPrefix("MyNamespace.IOverloadedSink")}}
@@ -309,9 +301,8 @@ namespace MyNamespace
 			  {
 			  	public readonly ref struct Packet(int id) { public int Id { get; } = id; }
 
-			  	// Two overloads share a name; GetSignatureKey includes RefKind so de-duplication
-			  	// does not collapse them. The plain-parameter overload is fine; the out-parameter
-			  	// overload must produce exactly one diagnostic.
+			  	// Both overloads are now supported — the by-value variant via the standard
+			  	// ref-struct pipeline, the out variant via IOutRefStructParameter<T>.
 			  	public interface IOverloadedSink
 			  	{
 			  		void Consume(Packet packet);
@@ -322,15 +313,11 @@ public class MyClass
 			  	{
 			  		public void MyTest()
 			  		{
-			  			{|#0:IOverloadedSink|}.CreateMock();
+			  			IOverloadedSink.CreateMock();
 			  		}
 			  	}
 			  }
-			  """,
-			new DiagnosticResult("Mockolate0003", DiagnosticSeverity.Warning)
-				.WithLocation(0)
-				.WithArguments("MyNamespace.IOverloadedSink", "Consume",
-					"out/ref ref-struct parameters are not supported")
+			  """
 		);
 
 	[Fact]
@@ -360,7 +347,7 @@ public void MyTest()
 		);
 
 	[Fact]
-	public async Task WhenMockingInterfaceWithRefReadonlyRefStructParameter_ShouldBeFlagged() => await Verifier
+	public async Task WhenMockingInterfaceWithRefReadonlyRefStructParameter_ShouldNotBeFlagged() => await Verifier
 		.VerifyAnalyzerAsync(
 			$$"""
 			  {{GeneratedPrefix("MyNamespace.IPacketInspector")}}
@@ -371,8 +358,6 @@ namespace MyNamespace
 
 			  	public interface IPacketInspector
 			  	{
-			  		// `ref readonly` on a parameter produces RefKind.RefReadOnlyParameter, which
-			  		// is explicitly listed alongside Out and Ref in MockabilityAnalyzer.
 			  		void Inspect(ref readonly Packet packet);
 			  	}
 
@@ -380,19 +365,15 @@ public class MyClass
 			  	{
 			  		public void MyTest()
 			  		{
-			  			{|#0:IPacketInspector|}.CreateMock();
+			  			IPacketInspector.CreateMock();
 			  		}
 			  	}
 			  }
-			  """,
-			new DiagnosticResult("Mockolate0003", DiagnosticSeverity.Warning)
-				.WithLocation(0)
-				.WithArguments("MyNamespace.IPacketInspector", "Inspect",
-					"out/ref ref-struct parameters are not supported")
+			  """
 		);
 
 	[Fact]
-	public async Task WhenMockingInterfaceWithRefRefStructParameter_ShouldBeFlagged() => await Verifier
+	public async Task WhenMockingInterfaceWithRefRefStructParameter_ShouldNotBeFlagged() => await Verifier
 		.VerifyAnalyzerAsync(
 			$$"""
 			  {{GeneratedPrefix("MyNamespace.IPacketMutator")}}
@@ -410,15 +391,11 @@ public class MyClass
 			  	{
 			  		public void MyTest()
 			  		{
-			  			{|#0:IPacketMutator|}.CreateMock();
+			  			IPacketMutator.CreateMock();
 			  		}
 			  	}
 			  }
-			  """,
-			new DiagnosticResult("Mockolate0003", DiagnosticSeverity.Warning)
-				.WithLocation(0)
-				.WithArguments("MyNamespace.IPacketMutator", "Mutate",
-					"out/ref ref-struct parameters are not supported")
+			  """
 		);
 
 	[Fact]
diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt
index 1a087e99..9335d2df 100644
--- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt
+++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt
@@ -97,8 +97,14 @@ namespace Mockolate
         public static Mockolate.It.IIsParameter<T> Is<T>(T value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IParameterWithCallback<T> IsAny<T>() { }
         public static Mockolate.Parameters.IOutParameter<T> IsAnyOut<T>() { }
+        public static Mockolate.Parameters.IOutParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsAnyOutReadOnlySpan<T>() { }
+        public static Mockolate.Parameters.IOutRefStructParameter<T> IsAnyOutRefStruct<T>() { }
+        public static Mockolate.Parameters.IOutParameter<Mockolate.Setup.SpanWrapper<T>> IsAnyOutSpan<T>() { }
         public static Mockolate.Parameters.IVerifyReadOnlySpanParameter<T> IsAnyReadOnlySpan<T>() { }
         public static Mockolate.Parameters.IRefParameter<T> IsAnyRef<T>() { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsAnyRefReadOnlySpan<T>() { }
+        public static Mockolate.Parameters.IRefRefStructParameter<T> IsAnyRefRefStruct<T>() { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.SpanWrapper<T>> IsAnyRefSpan<T>() { }
         public static Mockolate.Parameters.IParameter<T> IsAnyRefStruct<T>() { }
         public static Mockolate.Parameters.IVerifySpanParameter<T> IsAnySpan<T>() { }
         public static Mockolate.Parameters.IParameterWithCallback<bool> IsFalse() { }
@@ -110,12 +116,24 @@ namespace Mockolate
         public static Mockolate.Parameters.IParameterWithCallback<T> IsNull<T>(string? toString = null) { }
         public static Mockolate.It.IIsOneOfParameter<T> IsOneOf<T>(System.Collections.Generic.IEnumerable<T> values) { }
         public static Mockolate.Parameters.IVerifyOutParameter<T> IsOut<T>() { }
+        public static Mockolate.Parameters.IOutRefStructParameter<T> IsOut<T>(Mockolate.RefStructFactory<T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IOutParameter<T> IsOut<T>(System.Func<T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IOutParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsOutReadOnlySpan<T>(System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IOutParameter<Mockolate.Setup.SpanWrapper<T>> IsOutSpan<T>(System.Func<Mockolate.Setup.SpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IVerifyReadOnlySpanParameter<T> IsReadOnlySpan<T>(System.Func<T[], bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IVerifyRefParameter<T> IsRef<T>() { }
+        public static Mockolate.Parameters.IRefRefStructParameter<T> IsRef<T>(Mockolate.RefStructPredicate<T> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefRefStructParameter<T> IsRef<T>(Mockolate.RefStructTransform<T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IRefParameter<T> IsRef<T>(System.Func<T, T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IRefParameter<T> IsRef<T>(System.Func<T, bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefRefStructParameter<T> IsRef<T>(Mockolate.RefStructPredicate<T> predicate, Mockolate.RefStructTransform<T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue1 = "", [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "") { }
         public static Mockolate.Parameters.IRefParameter<T> IsRef<T>(System.Func<T, bool> predicate, System.Func<T, T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue1 = "", [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>, Mockolate.Setup.ReadOnlySpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>, bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>, bool> predicate, System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>, Mockolate.Setup.ReadOnlySpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue1 = "", [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.SpanWrapper<T>> IsRefSpan<T>(System.Func<Mockolate.Setup.SpanWrapper<T>, Mockolate.Setup.SpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.SpanWrapper<T>> IsRefSpan<T>(System.Func<Mockolate.Setup.SpanWrapper<T>, bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.SpanWrapper<T>> IsRefSpan<T>(System.Func<Mockolate.Setup.SpanWrapper<T>, bool> predicate, System.Func<Mockolate.Setup.SpanWrapper<T>, Mockolate.Setup.SpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue1 = "", [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "") { }
         public static Mockolate.Parameters.IParameter<T> IsRefStruct<T>(Mockolate.RefStructPredicate<T> predicate) { }
         public static Mockolate.Parameters.IParameter<T> IsRefStructBy<T, TProjected>(Mockolate.RefStructProjection<T, TProjected> projection)
             where TProjected :  notnull { }
@@ -285,8 +303,10 @@ namespace Mockolate
         public static Mockolate.Parameters.IParameterWithCallback<T> Monitor<T>(this Mockolate.Parameters.IParameterWithCallback<T> parameter, out Mockolate.Parameters.IParameterMonitor<T> monitor) { }
         public static Mockolate.Parameters.IRefParameter<T> Monitor<T>(this Mockolate.Parameters.IRefParameter<T> parameter, out Mockolate.Parameters.IParameterMonitor<T> monitor) { }
     }
+    public delegate T RefStructFactory<out T>();
     public delegate bool RefStructPredicate<in T>(T value);
     public delegate TProjected RefStructProjection<in T, out TProjected>(T value);
+    public delegate T RefStructTransform<T>(T value);
     public static class ReturnsThrowsAsyncExtensions
     {
         public static Mockolate.Setup.IReturnMethodSetupReturnBuilder<System.Threading.Tasks.Task<TReturn>> ReturnsAsync<TReturn>(this Mockolate.Setup.IReturnMethodSetup<System.Threading.Tasks.Task<TReturn>> setup, System.Func<TReturn> callback) { }
@@ -1065,6 +1085,10 @@ namespace Mockolate.Parameters
         Mockolate.Parameters.IOutParameter<T> Do(System.Action<T> callback);
         bool TryGetValue(out T value);
     }
+    public interface IOutRefStructParameter<T>
+    {
+        bool TryGetValue(out T value);
+    }
     public interface IParameter
     {
         void InvokeCallbacks(object? value);
@@ -1095,6 +1119,10 @@ namespace Mockolate.Parameters
         Mockolate.Parameters.IRefParameter<T> Do(System.Action<T> callback);
         T GetValue(T value);
     }
+    public interface IRefRefStructParameter<T>
+    {
+        T GetValue(T value);
+    }
     public interface IRefStructProjectionMatch<in T> : Mockolate.Parameters.IParameterMatch<T>
     {
         object Project(T value);
@@ -2395,7 +2423,7 @@ namespace Mockolate.Setup
     {
         public ReadOnlySpanWrapper(System.ReadOnlySpan<T> span) { }
         public T[] ReadOnlySpanValues { get; }
-        public static System.ReadOnlySpan<T> op_Implicit(Mockolate.Setup.ReadOnlySpanWrapper<T> wrapper) { }
+        public static System.ReadOnlySpan<T> op_Implicit(Mockolate.Setup.ReadOnlySpanWrapper<T>? wrapper) { }
         public static Mockolate.Setup.ReadOnlySpanWrapper<T> op_Implicit(System.ReadOnlySpan<T> span) { }
     }
     public sealed class RefStructIndexerGetterSetup<TValue, T> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IRefStructIndexerGetterSetup<TValue, T>, Mockolate.Setup.ISetup
@@ -2506,6 +2534,7 @@ namespace Mockolate.Setup
     {
         public RefStructReturnMethodSetup(string name, Mockolate.Parameters.IParameterMatch<T>? matcher = null) { }
         public bool HasReturnValue { get; }
+        public Mockolate.Parameters.IParameterMatch<T>? GetMatcher1() { }
         public TReturn Invoke(T value, System.Func<TReturn>? defaultFactory = null) { }
         public bool Matches(T value) { }
         protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) { }
@@ -2516,6 +2545,8 @@ namespace Mockolate.Setup
     {
         public RefStructReturnMethodSetup(string name, Mockolate.Parameters.IParameterMatch<T1>? matcher1 = null, Mockolate.Parameters.IParameterMatch<T2>? matcher2 = null) { }
         public bool HasReturnValue { get; }
+        public Mockolate.Parameters.IParameterMatch<T1>? GetMatcher1() { }
+        public Mockolate.Parameters.IParameterMatch<T2>? GetMatcher2() { }
         public TReturn Invoke(T1 value1, T2 value2, System.Func<TReturn>? defaultFactory = null) { }
         public bool Matches(T1 value1, T2 value2) { }
         protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) { }
@@ -2526,6 +2557,9 @@ namespace Mockolate.Setup
     {
         public RefStructReturnMethodSetup(string name, Mockolate.Parameters.IParameterMatch<T1>? matcher1 = null, Mockolate.Parameters.IParameterMatch<T2>? matcher2 = null, Mockolate.Parameters.IParameterMatch<T3>? matcher3 = null) { }
         public bool HasReturnValue { get; }
+        public Mockolate.Parameters.IParameterMatch<T1>? GetMatcher1() { }
+        public Mockolate.Parameters.IParameterMatch<T2>? GetMatcher2() { }
+        public Mockolate.Parameters.IParameterMatch<T3>? GetMatcher3() { }
         public TReturn Invoke(T1 value1, T2 value2, T3 value3, System.Func<TReturn>? defaultFactory = null) { }
         public bool Matches(T1 value1, T2 value2, T3 value3) { }
         protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) { }
@@ -2536,6 +2570,10 @@ namespace Mockolate.Setup
     {
         public RefStructReturnMethodSetup(string name, Mockolate.Parameters.IParameterMatch<T1>? matcher1 = null, Mockolate.Parameters.IParameterMatch<T2>? matcher2 = null, Mockolate.Parameters.IParameterMatch<T3>? matcher3 = null, Mockolate.Parameters.IParameterMatch<T4>? matcher4 = null) { }
         public bool HasReturnValue { get; }
+        public Mockolate.Parameters.IParameterMatch<T1>? GetMatcher1() { }
+        public Mockolate.Parameters.IParameterMatch<T2>? GetMatcher2() { }
+        public Mockolate.Parameters.IParameterMatch<T3>? GetMatcher3() { }
+        public Mockolate.Parameters.IParameterMatch<T4>? GetMatcher4() { }
         public TReturn Invoke(T1 value1, T2 value2, T3 value3, T4 value4, System.Func<TReturn>? defaultFactory = null) { }
         public bool Matches(T1 value1, T2 value2, T3 value3, T4 value4) { }
         protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) { }
@@ -2553,6 +2591,7 @@ namespace Mockolate.Setup
     public sealed class RefStructVoidMethodSetup<T> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IRefStructVoidMethodSetup<T>, Mockolate.Setup.ISetup
     {
         public RefStructVoidMethodSetup(string name, Mockolate.Parameters.IParameterMatch<T>? matcher = null) { }
+        public Mockolate.Parameters.IParameterMatch<T>? GetMatcher1() { }
         public void Invoke(T value) { }
         public bool Matches(T value) { }
         protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) { }
@@ -2562,6 +2601,8 @@ namespace Mockolate.Setup
     public sealed class RefStructVoidMethodSetup<T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IRefStructVoidMethodSetup<T1, T2>, Mockolate.Setup.ISetup
     {
         public RefStructVoidMethodSetup(string name, Mockolate.Parameters.IParameterMatch<T1>? matcher1 = null, Mockolate.Parameters.IParameterMatch<T2>? matcher2 = null) { }
+        public Mockolate.Parameters.IParameterMatch<T1>? GetMatcher1() { }
+        public Mockolate.Parameters.IParameterMatch<T2>? GetMatcher2() { }
         public void Invoke(T1 value1, T2 value2) { }
         public bool Matches(T1 value1, T2 value2) { }
         protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) { }
@@ -2571,6 +2612,9 @@ namespace Mockolate.Setup
     public sealed class RefStructVoidMethodSetup<T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IRefStructVoidMethodSetup<T1, T2, T3>, Mockolate.Setup.ISetup
     {
         public RefStructVoidMethodSetup(string name, Mockolate.Parameters.IParameterMatch<T1>? matcher1 = null, Mockolate.Parameters.IParameterMatch<T2>? matcher2 = null, Mockolate.Parameters.IParameterMatch<T3>? matcher3 = null) { }
+        public Mockolate.Parameters.IParameterMatch<T1>? GetMatcher1() { }
+        public Mockolate.Parameters.IParameterMatch<T2>? GetMatcher2() { }
+        public Mockolate.Parameters.IParameterMatch<T3>? GetMatcher3() { }
         public void Invoke(T1 value1, T2 value2, T3 value3) { }
         public bool Matches(T1 value1, T2 value2, T3 value3) { }
         protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) { }
@@ -2580,6 +2624,10 @@ namespace Mockolate.Setup
     public sealed class RefStructVoidMethodSetup<T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IRefStructVoidMethodSetup<T1, T2, T3, T4>, Mockolate.Setup.ISetup
     {
         public RefStructVoidMethodSetup(string name, Mockolate.Parameters.IParameterMatch<T1>? matcher1 = null, Mockolate.Parameters.IParameterMatch<T2>? matcher2 = null, Mockolate.Parameters.IParameterMatch<T3>? matcher3 = null, Mockolate.Parameters.IParameterMatch<T4>? matcher4 = null) { }
+        public Mockolate.Parameters.IParameterMatch<T1>? GetMatcher1() { }
+        public Mockolate.Parameters.IParameterMatch<T2>? GetMatcher2() { }
+        public Mockolate.Parameters.IParameterMatch<T3>? GetMatcher3() { }
+        public Mockolate.Parameters.IParameterMatch<T4>? GetMatcher4() { }
         public void Invoke(T1 value1, T2 value2, T3 value3, T4 value4) { }
         public bool Matches(T1 value1, T2 value2, T3 value3, T4 value4) { }
         protected override bool MatchesInteraction(Mockolate.Interactions.IMethodInteraction interaction) { }
@@ -2732,7 +2780,7 @@ namespace Mockolate.Setup
     {
         public SpanWrapper(System.Span<T> span) { }
         public T[] SpanValues { get; }
-        public static System.Span<T> op_Implicit(Mockolate.Setup.SpanWrapper<T> wrapper) { }
+        public static System.Span<T> op_Implicit(Mockolate.Setup.SpanWrapper<T>? wrapper) { }
         public static Mockolate.Setup.SpanWrapper<T> op_Implicit(System.Span<T> span) { }
     }
     public abstract class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.ISetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupParallelCallbackBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder
diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt
index a02916fd..5956d0d4 100644
--- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt
+++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt
@@ -96,8 +96,12 @@ namespace Mockolate
         public static Mockolate.It.IIsParameter<T> Is<T>(T value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IParameterWithCallback<T> IsAny<T>() { }
         public static Mockolate.Parameters.IOutParameter<T> IsAnyOut<T>() { }
+        public static Mockolate.Parameters.IOutParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsAnyOutReadOnlySpan<T>() { }
+        public static Mockolate.Parameters.IOutParameter<Mockolate.Setup.SpanWrapper<T>> IsAnyOutSpan<T>() { }
         public static Mockolate.Parameters.IVerifyReadOnlySpanParameter<T> IsAnyReadOnlySpan<T>() { }
         public static Mockolate.Parameters.IRefParameter<T> IsAnyRef<T>() { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsAnyRefReadOnlySpan<T>() { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.SpanWrapper<T>> IsAnyRefSpan<T>() { }
         public static Mockolate.Parameters.IVerifySpanParameter<T> IsAnySpan<T>() { }
         public static Mockolate.Parameters.IParameterWithCallback<bool> IsFalse() { }
         public static Mockolate.It.IInRangeParameter<T> IsInRange<T>(T minimum, T maximum, [System.Runtime.CompilerServices.CallerArgumentExpression("minimum")] string doNotPopulateThisValue1 = "", [System.Runtime.CompilerServices.CallerArgumentExpression("maximum")] string doNotPopulateThisValue2 = "")
@@ -109,11 +113,19 @@ namespace Mockolate
         public static Mockolate.It.IIsOneOfParameter<T> IsOneOf<T>(System.Collections.Generic.IEnumerable<T> values) { }
         public static Mockolate.Parameters.IVerifyOutParameter<T> IsOut<T>() { }
         public static Mockolate.Parameters.IOutParameter<T> IsOut<T>(System.Func<T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IOutParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsOutReadOnlySpan<T>(System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IOutParameter<Mockolate.Setup.SpanWrapper<T>> IsOutSpan<T>(System.Func<Mockolate.Setup.SpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IVerifyReadOnlySpanParameter<T> IsReadOnlySpan<T>(System.Func<T[], bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IVerifyRefParameter<T> IsRef<T>() { }
         public static Mockolate.Parameters.IRefParameter<T> IsRef<T>(System.Func<T, T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IRefParameter<T> IsRef<T>(System.Func<T, bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IRefParameter<T> IsRef<T>(System.Func<T, bool> predicate, System.Func<T, T> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue1 = "", [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>, Mockolate.Setup.ReadOnlySpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>, bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.ReadOnlySpanWrapper<T>> IsRefReadOnlySpan<T>(System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>, bool> predicate, System.Func<Mockolate.Setup.ReadOnlySpanWrapper<T>, Mockolate.Setup.ReadOnlySpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue1 = "", [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.SpanWrapper<T>> IsRefSpan<T>(System.Func<Mockolate.Setup.SpanWrapper<T>, Mockolate.Setup.SpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.SpanWrapper<T>> IsRefSpan<T>(System.Func<Mockolate.Setup.SpanWrapper<T>, bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
+        public static Mockolate.Parameters.IRefParameter<Mockolate.Setup.SpanWrapper<T>> IsRefSpan<T>(System.Func<Mockolate.Setup.SpanWrapper<T>, bool> predicate, System.Func<Mockolate.Setup.SpanWrapper<T>, Mockolate.Setup.SpanWrapper<T>> setter, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue1 = "", [System.Runtime.CompilerServices.CallerArgumentExpression("setter")] string doNotPopulateThisValue2 = "") { }
         public static Mockolate.Parameters.IVerifySpanParameter<T> IsSpan<T>(System.Func<T[], bool> predicate, [System.Runtime.CompilerServices.CallerArgumentExpression("predicate")] string doNotPopulateThisValue = "") { }
         public static Mockolate.Parameters.IParameterWithCallback<bool> IsTrue() { }
         public static Mockolate.It.IIsParameter<T> IsValue<T>(T value) { }
@@ -2173,7 +2185,7 @@ namespace Mockolate.Setup
     {
         public ReadOnlySpanWrapper(System.ReadOnlySpan<T> span) { }
         public T[] ReadOnlySpanValues { get; }
-        public static System.ReadOnlySpan<T> op_Implicit(Mockolate.Setup.ReadOnlySpanWrapper<T> wrapper) { }
+        public static System.ReadOnlySpan<T> op_Implicit(Mockolate.Setup.ReadOnlySpanWrapper<T>? wrapper) { }
         public static Mockolate.Setup.ReadOnlySpanWrapper<T> op_Implicit(System.ReadOnlySpan<T> span) { }
     }
     public abstract class ReturnMethodSetup<TReturn> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupParallelCallbackBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>, Mockolate.Setup.ISetup
@@ -2322,7 +2334,7 @@ namespace Mockolate.Setup
     {
         public SpanWrapper(System.Span<T> span) { }
         public T[] SpanValues { get; }
-        public static System.Span<T> op_Implicit(Mockolate.Setup.SpanWrapper<T> wrapper) { }
+        public static System.Span<T> op_Implicit(Mockolate.Setup.SpanWrapper<T>? wrapper) { }
         public static Mockolate.Setup.SpanWrapper<T> op_Implicit(System.Span<T> span) { }
     }
     public abstract class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.ISetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupParallelCallbackBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder
diff --git a/Tests/Mockolate.SourceGenerators.Tests/MockTests.RefStructTests.cs b/Tests/Mockolate.SourceGenerators.Tests/MockTests.RefStructTests.cs
index 9804b78d..5873deb8 100644
--- a/Tests/Mockolate.SourceGenerators.Tests/MockTests.RefStructTests.cs
+++ b/Tests/Mockolate.SourceGenerators.Tests/MockTests.RefStructTests.cs
@@ -515,7 +515,7 @@ await That(result.Sources["Mock.IPacketTransformer.g.cs"])
 		}
 
 		[Fact]
-		public async Task MethodWithOutRefStructParameter_ShouldEmitNotSupportedExceptionAndSkipSetupSurface()
+		public async Task MethodWithOutRefStructParameter_ShouldEmitRefStructOutParameterPipeline()
 		{
 			GeneratorResult result = Generator
 				.Run("""
@@ -542,12 +542,12 @@ public static void Main(string[] args)
 
 			await That(result.Sources).ContainsKey("Mock.IPacketBag.g.cs");
 			await That(result.Sources["Mock.IPacketBag.g.cs"])
-				.Contains("Mockolate: out/ref ref-struct parameters are not supported. Method 'global::MyCode.IPacketBag.Take'.")
-				.Because("the method body must throw NotSupportedException because the ref-struct out parameter cannot flow through the setup pipeline").And
-				.DoesNotContain("IRefStructVoidMethodSetup<global::MyCode.Packet>")
-				.Because("the setup-interface declaration must be skipped for unsupported ref-struct signatures").And
-				.DoesNotContain("new global::Mockolate.Setup.RefStructVoidMethodSetup<global::MyCode.Packet>")
-				.Because("the setup-interface implementation must be skipped for unsupported ref-struct signatures");
+				.Contains("IRefStructVoidMethodSetup<global::MyCode.Packet>")
+				.Because("the setup-interface declaration is now emitted for out ref-struct parameters").And
+				.Contains("new global::Mockolate.Setup.RefStructVoidMethodSetup<global::MyCode.Packet>")
+				.Because("the setup-builder constructs the ref-struct setup type").And
+				.Contains("global::Mockolate.Parameters.IOutRefStructParameter<global::MyCode.Packet>")
+				.Because("the mock body routes the out slot through IOutRefStructParameter<T> instead of IOutParameter<T>");
 		}
 
 		[Fact]
diff --git a/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/RefStructConsumer_CanBeCreated/Mock.IRefStructConsumer.g.cs b/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/RefStructConsumer_CanBeCreated/Mock.IRefStructConsumer.g.cs
index 76840834..1c809374 100644
--- a/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/RefStructConsumer_CanBeCreated/Mock.IRefStructConsumer.g.cs
+++ b/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/RefStructConsumer_CanBeCreated/Mock.IRefStructConsumer.g.cs
@@ -24,7 +24,15 @@ internal class IRefStructConsumer :
 		internal const int MemberId_Indexer_global__Mockolate_Tests_GeneratorCoverage_Packet_int_global__Mockolate_Tests_GeneratorCoverage_Packet_int_global__Mockolate_Tests_GeneratorCoverage_Packet_Get = 0;
 		internal const int MemberId_Indexer_global__Mockolate_Tests_GeneratorCoverage_Packet_int_global__Mockolate_Tests_GeneratorCoverage_Packet_int_global__Mockolate_Tests_GeneratorCoverage_Packet_Set = 1;
 		internal const int MemberId_Consume5 = 2;
-		internal const int MemberCount = 3;
+		internal const int MemberId_Produce = 3;
+		internal const int MemberId_Mutate = 4;
+		internal const int MemberId_Inspect = 5;
+		internal const int MemberId_ProduceSpan = 6;
+		internal const int MemberId_MutateSpan = 7;
+		internal const int MemberId_ProduceReadOnlySpan = 8;
+		internal const int MemberId_MutateReadOnlySpan = 9;
+		internal const int MemberId_InspectSpan = 10;
+		internal const int MemberCount = 11;
 
 		/// <summary>
 		///     Creates a <see cref="global::Mockolate.Interactions.FastMockInteractions">FastMockInteractions</see> sized to <see cref="MemberCount">MemberCount</see> for use as the mock's interaction store.
@@ -47,6 +55,18 @@ internal class IRefStructConsumer :
 		global::Mockolate.MockRegistry global::Mockolate.IMock.MockRegistry => this.MockRegistry;
 		private global::Mockolate.MockRegistry MockRegistry { get; }
 
+		[global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)]
+		private global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.SpanWrapper<int>> MockolateBuffer_ProduceSpan
+			=> field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer<global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.SpanWrapper<int>>>(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, static fast => new global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.SpanWrapper<int>>(fast)));
+		[global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)]
+		private global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.SpanWrapper<int>> MockolateBuffer_MutateSpan
+			=> field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer<global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.SpanWrapper<int>>>(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, static fast => new global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.SpanWrapper<int>>(fast)));
+		[global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)]
+		private global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> MockolateBuffer_ProduceReadOnlySpan
+			=> field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer<global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, static fast => new global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>(fast)));
+		[global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)]
+		private global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> MockolateBuffer_MutateReadOnlySpan
+			=> field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer<global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, static fast => new global::Mockolate.Interactions.FastMethod1Buffer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>(fast)));
 
 		/// <inheritdoc />
 		[global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)]
@@ -187,6 +207,402 @@ public void Consume5(global::Mockolate.Tests.GeneratorCoverage.Packet p1, global
 #endif
 		}
 
+		/// <inheritdoc cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Produce(out global::Mockolate.Tests.GeneratorCoverage.Packet)" />
+		public void Produce(out global::Mockolate.Tests.GeneratorCoverage.Packet packet)
+		{
+#if NET9_0_OR_GREATER
+			this.MockRegistry.RegisterInteraction(new global::Mockolate.Interactions.RefStructMethodInvocation("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Produce", "packet"));
+			packet = default!;
+			bool matched = false;
+			foreach (global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> setup in this.MockRegistry.GetMethodSetups<global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Produce"))
+			{
+				if (!setup.Matches(packet))
+				{
+					continue;
+				}
+
+				matched = true;
+				if (setup.GetMatcher1() is global::Mockolate.Parameters.IOutRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet> outParam1 && outParam1.TryGetValue(out packet)) { }
+				else
+				{
+					packet = default!;
+				}
+				setup.Invoke(packet);
+				return;
+			}
+			if (!matched && this.MockRegistry.Behavior.ThrowWhenNotSetup)
+			{
+				throw new global::Mockolate.Exceptions.MockNotSetupException("The method 'global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Produce(Packet)' was invoked without prior setup.");
+			}
+#else
+#error Mockolate: methods with ref-struct parameters require .NET 9 or later (uses the 'allows ref struct' anti-constraint).
+			throw new global::System.NotSupportedException();
+#endif
+		}
+
+		/// <inheritdoc cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Mutate(ref global::Mockolate.Tests.GeneratorCoverage.Packet)" />
+		public void Mutate(ref global::Mockolate.Tests.GeneratorCoverage.Packet packet)
+		{
+#if NET9_0_OR_GREATER
+			this.MockRegistry.RegisterInteraction(new global::Mockolate.Interactions.RefStructMethodInvocation("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Mutate", "packet"));
+			bool matched = false;
+			foreach (global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> setup in this.MockRegistry.GetMethodSetups<global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Mutate"))
+			{
+				if (!setup.Matches(packet))
+				{
+					continue;
+				}
+
+				matched = true;
+				if (setup.GetMatcher1() is global::Mockolate.Parameters.IRefRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet> refParam1)
+				{
+					packet = refParam1.GetValue(packet);
+				}
+				setup.Invoke(packet);
+				return;
+			}
+			if (!matched && this.MockRegistry.Behavior.ThrowWhenNotSetup)
+			{
+				throw new global::Mockolate.Exceptions.MockNotSetupException("The method 'global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Mutate(Packet)' was invoked without prior setup.");
+			}
+#else
+#error Mockolate: methods with ref-struct parameters require .NET 9 or later (uses the 'allows ref struct' anti-constraint).
+			throw new global::System.NotSupportedException();
+#endif
+		}
+
+		/// <inheritdoc cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Inspect(ref readonly global::Mockolate.Tests.GeneratorCoverage.Packet)" />
+		public void Inspect(ref readonly global::Mockolate.Tests.GeneratorCoverage.Packet packet)
+		{
+#if NET9_0_OR_GREATER
+			this.MockRegistry.RegisterInteraction(new global::Mockolate.Interactions.RefStructMethodInvocation("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Inspect", "packet"));
+			bool matched = false;
+			foreach (global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> setup in this.MockRegistry.GetMethodSetups<global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Inspect"))
+			{
+				if (!setup.Matches(packet))
+				{
+					continue;
+				}
+
+				matched = true;
+				setup.Invoke(packet);
+				return;
+			}
+			if (!matched && this.MockRegistry.Behavior.ThrowWhenNotSetup)
+			{
+				throw new global::Mockolate.Exceptions.MockNotSetupException("The method 'global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Inspect(Packet)' was invoked without prior setup.");
+			}
+#else
+#error Mockolate: methods with ref-struct parameters require .NET 9 or later (uses the 'allows ref struct' anti-constraint).
+			throw new global::System.NotSupportedException();
+#endif
+		}
+
+		/// <inheritdoc cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan(out global::System.Span{int})" />
+		public void ProduceSpan(out global::System.Span<int> span)
+		{
+			global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>? methodSetup = null;
+			if (string.IsNullOrEmpty(this.MockRegistry.Scenario))
+			{
+				global::Mockolate.Setup.MethodSetup[]? snapshot_methodSetup = this.MockRegistry.GetMethodSetupSnapshot(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan);
+				if (snapshot_methodSetup is not null)
+				{
+					for (int i_methodSetup = snapshot_methodSetup.Length - 1; i_methodSetup >= 0; i_methodSetup--)
+					{
+						if (snapshot_methodSetup[i_methodSetup] is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>> s_methodSetup && s_methodSetup.Matches(default))
+						{
+							methodSetup = s_methodSetup;
+							break;
+						}
+					}
+				}
+			}
+			if (methodSetup is null)
+			{
+				foreach (global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>> s_methodSetup in this.MockRegistry.GetMethodSetups<global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan"))
+				{
+					if (s_methodSetup.Matches(default))
+					{
+						methodSetup = s_methodSetup;
+						break;
+					}
+				}
+			}
+			bool hasWrappedResult = false;
+			span = default!;
+			if (this.MockRegistry.Behavior.SkipInteractionRecording == false)
+			{
+				this.MockolateBuffer_ProduceSpan.Append("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", new global::Mockolate.Setup.SpanWrapper<int>(span));
+			}
+			try
+			{
+				if (this.MockRegistry.Wraps is global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer wraps)
+				{
+					wraps.ProduceSpan(out span);
+					hasWrappedResult = true;
+				}
+				if (!hasWrappedResult || methodSetup is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameterCollection)
+				{
+					if (methodSetup is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameterCollection wpc)
+					{
+						if (wpc.Parameter1 is not global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.SpanWrapper<int>> outParam1 || !outParam1.TryGetValue(out global::Mockolate.Setup.SpanWrapper<int> outTemp1))
+						{
+							span = this.MockRegistry.Behavior.DefaultValue.Generate(default(global::Mockolate.Setup.SpanWrapper<int>)!);
+						}
+						else
+						{
+							span = outTemp1;
+						}
+					}
+					else
+					{
+						span = this.MockRegistry.Behavior.DefaultValue.Generate(default(global::Mockolate.Setup.SpanWrapper<int>)!);
+					}
+				}
+			}
+			finally
+			{
+				methodSetup?.TriggerCallbacks(new global::Mockolate.Setup.SpanWrapper<int>(span));
+			}
+			if (methodSetup is null && !hasWrappedResult && this.MockRegistry.Behavior.ThrowWhenNotSetup)
+			{
+				throw new global::Mockolate.Exceptions.MockNotSetupException("The method 'global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan(Span<int>)' was invoked without prior setup.");
+			}
+		}
+
+		/// <inheritdoc cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan(ref global::System.Span{int})" />
+		public void MutateSpan(ref global::System.Span<int> span)
+		{
+			var ref_span = span;
+			global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>? methodSetup = null;
+			if (string.IsNullOrEmpty(this.MockRegistry.Scenario))
+			{
+				global::Mockolate.Setup.MethodSetup[]? snapshot_methodSetup = this.MockRegistry.GetMethodSetupSnapshot(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan);
+				if (snapshot_methodSetup is not null)
+				{
+					for (int i_methodSetup = snapshot_methodSetup.Length - 1; i_methodSetup >= 0; i_methodSetup--)
+					{
+						if (snapshot_methodSetup[i_methodSetup] is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>> s_methodSetup && s_methodSetup.Matches(ref_span))
+						{
+							methodSetup = s_methodSetup;
+							break;
+						}
+					}
+				}
+			}
+			if (methodSetup is null)
+			{
+				foreach (global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>> s_methodSetup in this.MockRegistry.GetMethodSetups<global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan"))
+				{
+					if (s_methodSetup.Matches(ref_span))
+					{
+						methodSetup = s_methodSetup;
+						break;
+					}
+				}
+			}
+			bool hasWrappedResult = false;
+			if (this.MockRegistry.Behavior.SkipInteractionRecording == false)
+			{
+				this.MockolateBuffer_MutateSpan.Append("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", new global::Mockolate.Setup.SpanWrapper<int>(span));
+			}
+			try
+			{
+				if (this.MockRegistry.Wraps is global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer wraps)
+				{
+					wraps.MutateSpan(ref span);
+					hasWrappedResult = true;
+				}
+				if (!hasWrappedResult || methodSetup is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameterCollection)
+				{
+					if (methodSetup is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameterCollection wpc)
+					{
+						if (wpc.Parameter1 is global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.SpanWrapper<int>> refParam1)
+						{
+							span = refParam1.GetValue(span);
+						}
+					}
+					else
+					{
+					}
+				}
+			}
+			finally
+			{
+				methodSetup?.TriggerCallbacks(new global::Mockolate.Setup.SpanWrapper<int>(span));
+			}
+			if (methodSetup is null && !hasWrappedResult && this.MockRegistry.Behavior.ThrowWhenNotSetup)
+			{
+				throw new global::Mockolate.Exceptions.MockNotSetupException("The method 'global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan(Span<int>)' was invoked without prior setup.");
+			}
+		}
+
+		/// <inheritdoc cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan(out global::System.ReadOnlySpan{int})" />
+		public void ProduceReadOnlySpan(out global::System.ReadOnlySpan<int> span)
+		{
+			global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>? methodSetup = null;
+			if (string.IsNullOrEmpty(this.MockRegistry.Scenario))
+			{
+				global::Mockolate.Setup.MethodSetup[]? snapshot_methodSetup = this.MockRegistry.GetMethodSetupSnapshot(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan);
+				if (snapshot_methodSetup is not null)
+				{
+					for (int i_methodSetup = snapshot_methodSetup.Length - 1; i_methodSetup >= 0; i_methodSetup--)
+					{
+						if (snapshot_methodSetup[i_methodSetup] is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> s_methodSetup && s_methodSetup.Matches(default))
+						{
+							methodSetup = s_methodSetup;
+							break;
+						}
+					}
+				}
+			}
+			if (methodSetup is null)
+			{
+				foreach (global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> s_methodSetup in this.MockRegistry.GetMethodSetups<global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan"))
+				{
+					if (s_methodSetup.Matches(default))
+					{
+						methodSetup = s_methodSetup;
+						break;
+					}
+				}
+			}
+			bool hasWrappedResult = false;
+			span = default!;
+			if (this.MockRegistry.Behavior.SkipInteractionRecording == false)
+			{
+				this.MockolateBuffer_ProduceReadOnlySpan.Append("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", new global::Mockolate.Setup.ReadOnlySpanWrapper<int>(span));
+			}
+			try
+			{
+				if (this.MockRegistry.Wraps is global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer wraps)
+				{
+					wraps.ProduceReadOnlySpan(out span);
+					hasWrappedResult = true;
+				}
+				if (!hasWrappedResult || methodSetup is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameterCollection)
+				{
+					if (methodSetup is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameterCollection wpc)
+					{
+						if (wpc.Parameter1 is not global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> outParam1 || !outParam1.TryGetValue(out global::Mockolate.Setup.ReadOnlySpanWrapper<int> outTemp1))
+						{
+							span = this.MockRegistry.Behavior.DefaultValue.Generate(default(global::Mockolate.Setup.ReadOnlySpanWrapper<int>)!);
+						}
+						else
+						{
+							span = outTemp1;
+						}
+					}
+					else
+					{
+						span = this.MockRegistry.Behavior.DefaultValue.Generate(default(global::Mockolate.Setup.ReadOnlySpanWrapper<int>)!);
+					}
+				}
+			}
+			finally
+			{
+				methodSetup?.TriggerCallbacks(new global::Mockolate.Setup.ReadOnlySpanWrapper<int>(span));
+			}
+			if (methodSetup is null && !hasWrappedResult && this.MockRegistry.Behavior.ThrowWhenNotSetup)
+			{
+				throw new global::Mockolate.Exceptions.MockNotSetupException("The method 'global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan(ReadOnlySpan<int>)' was invoked without prior setup.");
+			}
+		}
+
+		/// <inheritdoc cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan(ref global::System.ReadOnlySpan{int})" />
+		public void MutateReadOnlySpan(ref global::System.ReadOnlySpan<int> span)
+		{
+			var ref_span = span;
+			global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>? methodSetup = null;
+			if (string.IsNullOrEmpty(this.MockRegistry.Scenario))
+			{
+				global::Mockolate.Setup.MethodSetup[]? snapshot_methodSetup = this.MockRegistry.GetMethodSetupSnapshot(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan);
+				if (snapshot_methodSetup is not null)
+				{
+					for (int i_methodSetup = snapshot_methodSetup.Length - 1; i_methodSetup >= 0; i_methodSetup--)
+					{
+						if (snapshot_methodSetup[i_methodSetup] is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> s_methodSetup && s_methodSetup.Matches(ref_span))
+						{
+							methodSetup = s_methodSetup;
+							break;
+						}
+					}
+				}
+			}
+			if (methodSetup is null)
+			{
+				foreach (global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> s_methodSetup in this.MockRegistry.GetMethodSetups<global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan"))
+				{
+					if (s_methodSetup.Matches(ref_span))
+					{
+						methodSetup = s_methodSetup;
+						break;
+					}
+				}
+			}
+			bool hasWrappedResult = false;
+			if (this.MockRegistry.Behavior.SkipInteractionRecording == false)
+			{
+				this.MockolateBuffer_MutateReadOnlySpan.Append("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", new global::Mockolate.Setup.ReadOnlySpanWrapper<int>(span));
+			}
+			try
+			{
+				if (this.MockRegistry.Wraps is global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer wraps)
+				{
+					wraps.MutateReadOnlySpan(ref span);
+					hasWrappedResult = true;
+				}
+				if (!hasWrappedResult || methodSetup is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameterCollection)
+				{
+					if (methodSetup is global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameterCollection wpc)
+					{
+						if (wpc.Parameter1 is global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> refParam1)
+						{
+							span = refParam1.GetValue(span);
+						}
+					}
+					else
+					{
+					}
+				}
+			}
+			finally
+			{
+				methodSetup?.TriggerCallbacks(new global::Mockolate.Setup.ReadOnlySpanWrapper<int>(span));
+			}
+			if (methodSetup is null && !hasWrappedResult && this.MockRegistry.Behavior.ThrowWhenNotSetup)
+			{
+				throw new global::Mockolate.Exceptions.MockNotSetupException("The method 'global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan(ReadOnlySpan<int>)' was invoked without prior setup.");
+			}
+		}
+
+		/// <inheritdoc cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.InspectSpan(ref readonly global::System.Span{int})" />
+		public void InspectSpan(ref readonly global::System.Span<int> span)
+		{
+#if NET9_0_OR_GREATER
+			this.MockRegistry.RegisterInteraction(new global::Mockolate.Interactions.RefStructMethodInvocation("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.InspectSpan", "span"));
+			bool matched = false;
+			foreach (global::Mockolate.Setup.RefStructVoidMethodSetup<global::System.Span<int>> setup in this.MockRegistry.GetMethodSetups<global::Mockolate.Setup.RefStructVoidMethodSetup<global::System.Span<int>>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.InspectSpan"))
+			{
+				if (!setup.Matches(span))
+				{
+					continue;
+				}
+
+				matched = true;
+				setup.Invoke(span);
+				return;
+			}
+			if (!matched && this.MockRegistry.Behavior.ThrowWhenNotSetup)
+			{
+				throw new global::Mockolate.Exceptions.MockNotSetupException("The method 'global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.InspectSpan(Span<int>)' was invoked without prior setup.");
+			}
+#else
+#error Mockolate: methods with ref-struct parameters require .NET 9 or later (uses the 'allows ref struct' anti-constraint).
+			throw new global::System.NotSupportedException();
+#endif
+		}
+
 		#endregion Mockolate.Tests.GeneratorCoverage.IRefStructConsumer
 
 		#region IMockSetupForIRefStructConsumer
@@ -215,10 +631,162 @@ public void Consume5(global::Mockolate.Tests.GeneratorCoverage.Packet p1, global
 		}
 #endif
 
+#if NET9_0_OR_GREATER
+		/// <inheritdoc />
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.Produce(global::Mockolate.Parameters.IOutRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet)
+		{
+			var methodSetup = new global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Produce", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Tests.GeneratorCoverage.Packet>?)packet);
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_Produce, methodSetup);
+			return methodSetup;
+		}
+#endif
+
+#if NET9_0_OR_GREATER
+		/// <inheritdoc />
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.Mutate(global::Mockolate.Parameters.IRefRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet)
+		{
+			var methodSetup = new global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Mutate", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Tests.GeneratorCoverage.Packet>?)packet);
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_Mutate, methodSetup);
+			return methodSetup;
+		}
+#endif
+
+#if NET9_0_OR_GREATER
+		/// <inheritdoc />
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.Inspect(global::Mockolate.Parameters.IRefRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet)
+		{
+			var methodSetup = new global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Inspect", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Tests.GeneratorCoverage.Packet>?)packet);
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_Inspect, methodSetup);
+			return methodSetup;
+		}
+#endif
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.ProduceSpan(global::Mockolate.Parameters.IParameters parameters)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameters(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", parameters, "span");
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.ProduceSpan(global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.SpanWrapper<int>> span)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameterCollection(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.SpanWrapper<int>>)(span));
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.MutateSpan(global::Mockolate.Parameters.IParameters parameters)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameters(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", parameters, "span");
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.MutateSpan(global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.SpanWrapper<int>> span)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameterCollection(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.SpanWrapper<int>>)(span));
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.ProduceReadOnlySpan(global::Mockolate.Parameters.IParameters parameters)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameters(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", parameters, "span");
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.ProduceReadOnlySpan(global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> span)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameterCollection(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>)(span));
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.MutateReadOnlySpan(global::Mockolate.Parameters.IParameters parameters)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameters(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", parameters, "span");
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.MutateReadOnlySpan(global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> span)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameterCollection(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>)(span));
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, methodSetup);
+			return methodSetup;
+		}
+
+#if NET9_0_OR_GREATER
+		/// <inheritdoc />
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::System.Span<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.InspectSpan(global::Mockolate.Parameters.IRefRefStructParameter<global::System.Span<int>>? span)
+		{
+			var methodSetup = new global::Mockolate.Setup.RefStructVoidMethodSetup<global::System.Span<int>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.InspectSpan", (global::Mockolate.Parameters.IParameterMatch<global::System.Span<int>>?)span);
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_InspectSpan, methodSetup);
+			return methodSetup;
+		}
+#endif
+
 		#endregion IMockSetupForIRefStructConsumer
 
 		#region IMockVerifyForIRefStructConsumer
 
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.ProduceSpan(global::Mockolate.Parameters.IParameters parameters)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.SpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", __i => parameters switch
+				{
+					global::Mockolate.Parameters.IParametersMatch m => m.Matches([__i.Parameter1]),
+					global::Mockolate.Parameters.INamedParametersMatch m => m.Matches([("span", __i.Parameter1)]),
+					_ => true
+				}, () => $"ProduceSpan({parameters})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.ProduceSpan(global::Mockolate.Parameters.IVerifyOutParameter<int> span)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.SpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", __i => 
+				(span is global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.SpanWrapper<int>> spanMatch ? spanMatch.Matches(__i.Parameter1) : global::System.Collections.Generic.EqualityComparer<global::Mockolate.Setup.SpanWrapper<int>>.Default.Equals(__i.Parameter1, default(global::Mockolate.Setup.SpanWrapper<int>))), () => $"ProduceSpan({span})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.MutateSpan(global::Mockolate.Parameters.IParameters parameters)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.SpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", __i => parameters switch
+				{
+					global::Mockolate.Parameters.IParametersMatch m => m.Matches([__i.Parameter1]),
+					global::Mockolate.Parameters.INamedParametersMatch m => m.Matches([("span", __i.Parameter1)]),
+					_ => true
+				}, () => $"MutateSpan({parameters})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.MutateSpan(global::Mockolate.Parameters.IVerifyRefParameter<int> span)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.SpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", __i => 
+				(span is global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.SpanWrapper<int>> spanMatch ? spanMatch.Matches(__i.Parameter1) : global::System.Collections.Generic.EqualityComparer<global::Mockolate.Setup.SpanWrapper<int>>.Default.Equals(__i.Parameter1, default(global::Mockolate.Setup.SpanWrapper<int>))), () => $"MutateSpan({span})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.ProduceReadOnlySpan(global::Mockolate.Parameters.IParameters parameters)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", __i => parameters switch
+				{
+					global::Mockolate.Parameters.IParametersMatch m => m.Matches([__i.Parameter1]),
+					global::Mockolate.Parameters.INamedParametersMatch m => m.Matches([("span", __i.Parameter1)]),
+					_ => true
+				}, () => $"ProduceReadOnlySpan({parameters})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.ProduceReadOnlySpan(global::Mockolate.Parameters.IVerifyOutParameter<int> span)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", __i => 
+				(span is global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> spanMatch ? spanMatch.Matches(__i.Parameter1) : global::System.Collections.Generic.EqualityComparer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.Default.Equals(__i.Parameter1, default(global::Mockolate.Setup.ReadOnlySpanWrapper<int>))), () => $"ProduceReadOnlySpan({span})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.MutateReadOnlySpan(global::Mockolate.Parameters.IParameters parameters)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", __i => parameters switch
+				{
+					global::Mockolate.Parameters.IParametersMatch m => m.Matches([__i.Parameter1]),
+					global::Mockolate.Parameters.INamedParametersMatch m => m.Matches([("span", __i.Parameter1)]),
+					_ => true
+				}, () => $"MutateReadOnlySpan({parameters})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.MutateReadOnlySpan(global::Mockolate.Parameters.IVerifyRefParameter<int> span)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", __i => 
+				(span is global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> spanMatch ? spanMatch.Matches(__i.Parameter1) : global::System.Collections.Generic.EqualityComparer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.Default.Equals(__i.Parameter1, default(global::Mockolate.Setup.ReadOnlySpanWrapper<int>))), () => $"MutateReadOnlySpan({span})");
 		#endregion IMockVerifyForIRefStructConsumer
 	}
 
@@ -229,6 +797,54 @@ private sealed class VerifyMonitorIRefStructConsumer(global::Mockolate.MockRegis
 
 		#region IMockVerifyForIRefStructConsumer
 
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.ProduceSpan(global::Mockolate.Parameters.IParameters parameters)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.SpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", __i => parameters switch
+				{
+					global::Mockolate.Parameters.IParametersMatch m => m.Matches([__i.Parameter1]),
+					global::Mockolate.Parameters.INamedParametersMatch m => m.Matches([("span", __i.Parameter1)]),
+					_ => true
+				}, () => $"ProduceSpan({parameters})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.ProduceSpan(global::Mockolate.Parameters.IVerifyOutParameter<int> span)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.SpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", __i => 
+				(span is global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.SpanWrapper<int>> spanMatch ? spanMatch.Matches(__i.Parameter1) : global::System.Collections.Generic.EqualityComparer<global::Mockolate.Setup.SpanWrapper<int>>.Default.Equals(__i.Parameter1, default(global::Mockolate.Setup.SpanWrapper<int>))), () => $"ProduceSpan({span})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.MutateSpan(global::Mockolate.Parameters.IParameters parameters)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.SpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", __i => parameters switch
+				{
+					global::Mockolate.Parameters.IParametersMatch m => m.Matches([__i.Parameter1]),
+					global::Mockolate.Parameters.INamedParametersMatch m => m.Matches([("span", __i.Parameter1)]),
+					_ => true
+				}, () => $"MutateSpan({parameters})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.MutateSpan(global::Mockolate.Parameters.IVerifyRefParameter<int> span)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.SpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", __i => 
+				(span is global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.SpanWrapper<int>> spanMatch ? spanMatch.Matches(__i.Parameter1) : global::System.Collections.Generic.EqualityComparer<global::Mockolate.Setup.SpanWrapper<int>>.Default.Equals(__i.Parameter1, default(global::Mockolate.Setup.SpanWrapper<int>))), () => $"MutateSpan({span})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.ProduceReadOnlySpan(global::Mockolate.Parameters.IParameters parameters)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", __i => parameters switch
+				{
+					global::Mockolate.Parameters.IParametersMatch m => m.Matches([__i.Parameter1]),
+					global::Mockolate.Parameters.INamedParametersMatch m => m.Matches([("span", __i.Parameter1)]),
+					_ => true
+				}, () => $"ProduceReadOnlySpan({parameters})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.ProduceReadOnlySpan(global::Mockolate.Parameters.IVerifyOutParameter<int> span)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", __i => 
+				(span is global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> spanMatch ? spanMatch.Matches(__i.Parameter1) : global::System.Collections.Generic.EqualityComparer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.Default.Equals(__i.Parameter1, default(global::Mockolate.Setup.ReadOnlySpanWrapper<int>))), () => $"ProduceReadOnlySpan({span})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.MutateReadOnlySpan(global::Mockolate.Parameters.IParameters parameters)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", __i => parameters switch
+				{
+					global::Mockolate.Parameters.IParametersMatch m => m.Matches([__i.Parameter1]),
+					global::Mockolate.Parameters.INamedParametersMatch m => m.Matches([("span", __i.Parameter1)]),
+					_ => true
+				}, () => $"MutateReadOnlySpan({parameters})");
+		/// <inheritdoc />
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> IMockVerifyForIRefStructConsumer.MutateReadOnlySpan(global::Mockolate.Parameters.IVerifyRefParameter<int> span)
+			=> this.MockRegistry.VerifyMethod<IMockVerifyForIRefStructConsumer, global::Mockolate.Interactions.MethodInvocation<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>>(this, global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", __i => 
+				(span is global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> spanMatch ? spanMatch.Matches(__i.Parameter1) : global::System.Collections.Generic.EqualityComparer<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.Default.Equals(__i.Parameter1, default(global::Mockolate.Setup.ReadOnlySpanWrapper<int>))), () => $"MutateReadOnlySpan({span})");
 		#endregion IMockVerifyForIRefStructConsumer
 	}
 
@@ -274,6 +890,110 @@ public MockInScenarioForIRefStructConsumer(global::Mockolate.MockRegistry mockRe
 		}
 #endif
 
+#if NET9_0_OR_GREATER
+		/// <inheritdoc />
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.Produce(global::Mockolate.Parameters.IOutRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet)
+		{
+			var methodSetup = new global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Produce", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Tests.GeneratorCoverage.Packet>?)packet);
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_Produce, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+#endif
+
+#if NET9_0_OR_GREATER
+		/// <inheritdoc />
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.Mutate(global::Mockolate.Parameters.IRefRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet)
+		{
+			var methodSetup = new global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Mutate", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Tests.GeneratorCoverage.Packet>?)packet);
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_Mutate, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+#endif
+
+#if NET9_0_OR_GREATER
+		/// <inheritdoc />
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.Inspect(global::Mockolate.Parameters.IRefRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet)
+		{
+			var methodSetup = new global::Mockolate.Setup.RefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Inspect", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Tests.GeneratorCoverage.Packet>?)packet);
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_Inspect, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+#endif
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.ProduceSpan(global::Mockolate.Parameters.IParameters parameters)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameters(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", parameters, "span");
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.ProduceSpan(global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.SpanWrapper<int>> span)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameterCollection(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.SpanWrapper<int>>)(span));
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceSpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.MutateSpan(global::Mockolate.Parameters.IParameters parameters)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameters(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", parameters, "span");
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.MutateSpan(global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.SpanWrapper<int>> span)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.SpanWrapper<int>>.WithParameterCollection(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.SpanWrapper<int>>)(span));
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateSpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.ProduceReadOnlySpan(global::Mockolate.Parameters.IParameters parameters)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameters(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", parameters, "span");
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.ProduceReadOnlySpan(global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> span)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameterCollection(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>)(span));
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_ProduceReadOnlySpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.MutateReadOnlySpan(global::Mockolate.Parameters.IParameters parameters)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameters(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", parameters, "span");
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+
+		/// <inheritdoc />
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.MutateReadOnlySpan(global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> span)
+		{
+			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>.WithParameterCollection(MockRegistry, "global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan", (global::Mockolate.Parameters.IParameterMatch<global::Mockolate.Setup.ReadOnlySpanWrapper<int>>)(span));
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_MutateReadOnlySpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+
+#if NET9_0_OR_GREATER
+		/// <inheritdoc />
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::System.Span<int>> global::Mockolate.Mock.IMockSetupForIRefStructConsumer.InspectSpan(global::Mockolate.Parameters.IRefRefStructParameter<global::System.Span<int>>? span)
+		{
+			var methodSetup = new global::Mockolate.Setup.RefStructVoidMethodSetup<global::System.Span<int>>("global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.InspectSpan", (global::Mockolate.Parameters.IParameterMatch<global::System.Span<int>>?)span);
+			this.MockRegistry.SetupMethod(global::Mockolate.Mock.IRefStructConsumer.MemberId_InspectSpan, _scenarioName, methodSetup);
+			return methodSetup;
+		}
+#endif
+
 		#endregion IMockSetupForIRefStructConsumer
 	}
 
@@ -411,6 +1131,106 @@ internal interface IMockSetupForIRefStructConsumer : global::Mockolate.Setup.IMo
 		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet, global::Mockolate.Tests.GeneratorCoverage.Packet, global::Mockolate.Tests.GeneratorCoverage.Packet, global::Mockolate.Tests.GeneratorCoverage.Packet, global::Mockolate.Tests.GeneratorCoverage.Packet> Consume5(global::Mockolate.Parameters.IParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? p1, global::Mockolate.Parameters.IParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? p2, global::Mockolate.Parameters.IParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? p3, global::Mockolate.Parameters.IParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? p4, global::Mockolate.Parameters.IParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? p5);
 #endif
 
+#if NET9_0_OR_GREATER
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Produce(global::Mockolate.Tests.GeneratorCoverage.Packet)">Produce(Packet)</see> — ref-struct parameter pipeline (narrow setup surface).
+		/// </summary>
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> Produce(global::Mockolate.Parameters.IOutRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet);
+#endif
+
+#if NET9_0_OR_GREATER
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Mutate(global::Mockolate.Tests.GeneratorCoverage.Packet)">Mutate(Packet)</see> — ref-struct parameter pipeline (narrow setup surface).
+		/// </summary>
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> Mutate(global::Mockolate.Parameters.IRefRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet);
+#endif
+
+#if NET9_0_OR_GREATER
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.Inspect(global::Mockolate.Tests.GeneratorCoverage.Packet)">Inspect(Packet)</see> — ref-struct parameter pipeline (narrow setup surface).
+		/// </summary>
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::Mockolate.Tests.GeneratorCoverage.Packet> Inspect(global::Mockolate.Parameters.IRefRefStructParameter<global::Mockolate.Tests.GeneratorCoverage.Packet>? packet);
+#endif
+
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan(out global::System.Span{int})">ProduceSpan(out Span&lt;int&gt;)</see> with the given <paramref name="parameters" />.
+		/// </summary>
+		/// <remarks>
+		///     This overload configures the setup via a custom <see cref="global::Mockolate.Match">Match</see> predicate (for example <see cref="global::Mockolate.Match.AnyParameters()">AnyParameters()</see> or <see cref="global::Mockolate.Match.Parameters(global::System.Func{object?[], bool}, string)">Parameters(Func&lt;object?[], bool&gt;, string)</see>) rather than per-parameter matchers.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue - 1)]
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> ProduceSpan(global::Mockolate.Parameters.IParameters parameters);
+
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan(out global::System.Span{int})">ProduceSpan(out Span&lt;int&gt;)</see> with the given <paramref name="span"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload takes <see cref="global::Mockolate.It">It</see> argument matchers (e.g. <c>It.IsAny&lt;T&gt;()</c>, <c>It.Is&lt;T&gt;(value)</c>) for every parameter.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(1)]
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> ProduceSpan(global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.SpanWrapper<int>> span);
+
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan(ref global::System.Span{int})">MutateSpan(ref Span&lt;int&gt;)</see> with the given <paramref name="parameters" />.
+		/// </summary>
+		/// <remarks>
+		///     This overload configures the setup via a custom <see cref="global::Mockolate.Match">Match</see> predicate (for example <see cref="global::Mockolate.Match.AnyParameters()">AnyParameters()</see> or <see cref="global::Mockolate.Match.Parameters(global::System.Func{object?[], bool}, string)">Parameters(Func&lt;object?[], bool&gt;, string)</see>) rather than per-parameter matchers.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue - 1)]
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> MutateSpan(global::Mockolate.Parameters.IParameters parameters);
+
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan(ref global::System.Span{int})">MutateSpan(ref Span&lt;int&gt;)</see> with the given <paramref name="span"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload takes <see cref="global::Mockolate.It">It</see> argument matchers (e.g. <c>It.IsAny&lt;T&gt;()</c>, <c>It.Is&lt;T&gt;(value)</c>) for every parameter.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(1)]
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.SpanWrapper<int>> MutateSpan(global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.SpanWrapper<int>> span);
+
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan(out global::System.ReadOnlySpan{int})">ProduceReadOnlySpan(out ReadOnlySpan&lt;int&gt;)</see> with the given <paramref name="parameters" />.
+		/// </summary>
+		/// <remarks>
+		///     This overload configures the setup via a custom <see cref="global::Mockolate.Match">Match</see> predicate (for example <see cref="global::Mockolate.Match.AnyParameters()">AnyParameters()</see> or <see cref="global::Mockolate.Match.Parameters(global::System.Func{object?[], bool}, string)">Parameters(Func&lt;object?[], bool&gt;, string)</see>) rather than per-parameter matchers.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue - 1)]
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> ProduceReadOnlySpan(global::Mockolate.Parameters.IParameters parameters);
+
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan(out global::System.ReadOnlySpan{int})">ProduceReadOnlySpan(out ReadOnlySpan&lt;int&gt;)</see> with the given <paramref name="span"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload takes <see cref="global::Mockolate.It">It</see> argument matchers (e.g. <c>It.IsAny&lt;T&gt;()</c>, <c>It.Is&lt;T&gt;(value)</c>) for every parameter.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(1)]
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> ProduceReadOnlySpan(global::Mockolate.Parameters.IOutParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> span);
+
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan(ref global::System.ReadOnlySpan{int})">MutateReadOnlySpan(ref ReadOnlySpan&lt;int&gt;)</see> with the given <paramref name="parameters" />.
+		/// </summary>
+		/// <remarks>
+		///     This overload configures the setup via a custom <see cref="global::Mockolate.Match">Match</see> predicate (for example <see cref="global::Mockolate.Match.AnyParameters()">AnyParameters()</see> or <see cref="global::Mockolate.Match.Parameters(global::System.Func{object?[], bool}, string)">Parameters(Func&lt;object?[], bool&gt;, string)</see>) rather than per-parameter matchers.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue - 1)]
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> MutateReadOnlySpan(global::Mockolate.Parameters.IParameters parameters);
+
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan(ref global::System.ReadOnlySpan{int})">MutateReadOnlySpan(ref ReadOnlySpan&lt;int&gt;)</see> with the given <paramref name="span"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload takes <see cref="global::Mockolate.It">It</see> argument matchers (e.g. <c>It.IsAny&lt;T&gt;()</c>, <c>It.Is&lt;T&gt;(value)</c>) for every parameter.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(1)]
+		global::Mockolate.Setup.IVoidMethodSetupWithCallback<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> MutateReadOnlySpan(global::Mockolate.Parameters.IRefParameter<global::Mockolate.Setup.ReadOnlySpanWrapper<int>> span);
+
+#if NET9_0_OR_GREATER
+		/// <summary>
+		///     Setup for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.InspectSpan(global::System.Span{int})">InspectSpan(Span&lt;int&gt;)</see> — ref-struct parameter pipeline (narrow setup surface).
+		/// </summary>
+		global::Mockolate.Setup.IRefStructVoidMethodSetup<global::System.Span<int>> InspectSpan(global::Mockolate.Parameters.IRefRefStructParameter<global::System.Span<int>>? span);
+#endif
+
 	}
 
 	/// <summary>
@@ -418,6 +1238,78 @@ internal interface IMockSetupForIRefStructConsumer : global::Mockolate.Setup.IMo
 	/// </summary>
 	internal interface IMockVerifyForIRefStructConsumer : global::Mockolate.Verify.IMockVerify<global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer>
 	{
+		/// <summary>
+		///     Verify invocations for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan(out global::System.Span{int})">ProduceSpan(out Span&lt;int&gt;)</see> with the given <paramref name="parameters"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload matches invocations via a custom <see cref="global::Mockolate.Match">Match</see> predicate (for example <see cref="global::Mockolate.Match.AnyParameters()">AnyParameters()</see> or <see cref="global::Mockolate.Match.Parameters(global::System.Func{object?[], bool}, string)">Parameters(Func&lt;object?[], bool&gt;, string)</see>) rather than per-parameter matchers.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue - 1)]
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> ProduceSpan(global::Mockolate.Parameters.IParameters parameters);
+
+		/// <summary>
+		///     Verify invocations for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceSpan(out global::System.Span{int})">ProduceSpan(out Span&lt;int&gt;)</see> with the given <paramref name="span"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload takes <see cref="global::Mockolate.It">It</see> argument matchers (e.g. <c>It.IsAny&lt;T&gt;()</c>, <c>It.Is&lt;T&gt;(value)</c>) for every parameter.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(1)]
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> ProduceSpan(global::Mockolate.Parameters.IVerifyOutParameter<int> span);
+
+		/// <summary>
+		///     Verify invocations for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan(ref global::System.Span{int})">MutateSpan(ref Span&lt;int&gt;)</see> with the given <paramref name="parameters"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload matches invocations via a custom <see cref="global::Mockolate.Match">Match</see> predicate (for example <see cref="global::Mockolate.Match.AnyParameters()">AnyParameters()</see> or <see cref="global::Mockolate.Match.Parameters(global::System.Func{object?[], bool}, string)">Parameters(Func&lt;object?[], bool&gt;, string)</see>) rather than per-parameter matchers.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue - 1)]
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> MutateSpan(global::Mockolate.Parameters.IParameters parameters);
+
+		/// <summary>
+		///     Verify invocations for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateSpan(ref global::System.Span{int})">MutateSpan(ref Span&lt;int&gt;)</see> with the given <paramref name="span"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload takes <see cref="global::Mockolate.It">It</see> argument matchers (e.g. <c>It.IsAny&lt;T&gt;()</c>, <c>It.Is&lt;T&gt;(value)</c>) for every parameter.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(1)]
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> MutateSpan(global::Mockolate.Parameters.IVerifyRefParameter<int> span);
+
+		/// <summary>
+		///     Verify invocations for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan(out global::System.ReadOnlySpan{int})">ProduceReadOnlySpan(out ReadOnlySpan&lt;int&gt;)</see> with the given <paramref name="parameters"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload matches invocations via a custom <see cref="global::Mockolate.Match">Match</see> predicate (for example <see cref="global::Mockolate.Match.AnyParameters()">AnyParameters()</see> or <see cref="global::Mockolate.Match.Parameters(global::System.Func{object?[], bool}, string)">Parameters(Func&lt;object?[], bool&gt;, string)</see>) rather than per-parameter matchers.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue - 1)]
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> ProduceReadOnlySpan(global::Mockolate.Parameters.IParameters parameters);
+
+		/// <summary>
+		///     Verify invocations for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.ProduceReadOnlySpan(out global::System.ReadOnlySpan{int})">ProduceReadOnlySpan(out ReadOnlySpan&lt;int&gt;)</see> with the given <paramref name="span"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload takes <see cref="global::Mockolate.It">It</see> argument matchers (e.g. <c>It.IsAny&lt;T&gt;()</c>, <c>It.Is&lt;T&gt;(value)</c>) for every parameter.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(1)]
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> ProduceReadOnlySpan(global::Mockolate.Parameters.IVerifyOutParameter<int> span);
+
+		/// <summary>
+		///     Verify invocations for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan(ref global::System.ReadOnlySpan{int})">MutateReadOnlySpan(ref ReadOnlySpan&lt;int&gt;)</see> with the given <paramref name="parameters"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload matches invocations via a custom <see cref="global::Mockolate.Match">Match</see> predicate (for example <see cref="global::Mockolate.Match.AnyParameters()">AnyParameters()</see> or <see cref="global::Mockolate.Match.Parameters(global::System.Func{object?[], bool}, string)">Parameters(Func&lt;object?[], bool&gt;, string)</see>) rather than per-parameter matchers.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue - 1)]
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> MutateReadOnlySpan(global::Mockolate.Parameters.IParameters parameters);
+
+		/// <summary>
+		///     Verify invocations for the method <see cref="global::Mockolate.Tests.GeneratorCoverage.IRefStructConsumer.MutateReadOnlySpan(ref global::System.ReadOnlySpan{int})">MutateReadOnlySpan(ref ReadOnlySpan&lt;int&gt;)</see> with the given <paramref name="span"/>.
+		/// </summary>
+		/// <remarks>
+		///     This overload takes <see cref="global::Mockolate.It">It</see> argument matchers (e.g. <c>It.IsAny&lt;T&gt;()</c>, <c>It.Is&lt;T&gt;(value)</c>) for every parameter.
+		/// </remarks>
+		[global::System.Runtime.CompilerServices.OverloadResolutionPriority(1)]
+		global::Mockolate.Verify.VerificationResult<IMockVerifyForIRefStructConsumer> MutateReadOnlySpan(global::Mockolate.Parameters.IVerifyRefParameter<int> span);
+
 	}
 }
 /// <summary>
diff --git a/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/RefStructConsumer_CanBeCreated/RefStructMethodSetups.g.cs b/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/RefStructConsumer_CanBeCreated/RefStructMethodSetups.g.cs
index 869bd79b..9a801a50 100644
--- a/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/RefStructConsumer_CanBeCreated/RefStructMethodSetups.g.cs
+++ b/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/RefStructConsumer_CanBeCreated/RefStructMethodSetups.g.cs
@@ -65,6 +65,17 @@ public bool Matches(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
 			   && (_matcher4 is null || _matcher4.Matches(value4))
 			   && (_matcher5 is null || _matcher5.Matches(value5));
 
+		[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+		public global::Mockolate.Parameters.IParameterMatch<T1>? GetMatcher1() => _matcher1;
+		[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+		public global::Mockolate.Parameters.IParameterMatch<T2>? GetMatcher2() => _matcher2;
+		[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+		public global::Mockolate.Parameters.IParameterMatch<T3>? GetMatcher3() => _matcher3;
+		[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+		public global::Mockolate.Parameters.IParameterMatch<T4>? GetMatcher4() => _matcher4;
+		[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+		public global::Mockolate.Parameters.IParameterMatch<T5>? GetMatcher5() => _matcher5;
+
 		public void Invoke(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
 		{
 			_matcher1?.InvokeCallbacks(value1);
diff --git a/Tests/Mockolate.SourceGenerators.Tests/Snapshot/MockGenerationSnapshotTests.cs b/Tests/Mockolate.SourceGenerators.Tests/Snapshot/MockGenerationSnapshotTests.cs
index 463061c0..b6297d62 100644
--- a/Tests/Mockolate.SourceGenerators.Tests/Snapshot/MockGenerationSnapshotTests.cs
+++ b/Tests/Mockolate.SourceGenerators.Tests/Snapshot/MockGenerationSnapshotTests.cs
@@ -41,7 +41,7 @@ await That(SnapshotStorage.StripConfigSpecificLines(generated[fileName]))
     [
         new(
             "BaseClass_WithMultipleAdditionalInterfaces_CanBeCreated",
-            ["ComprehensiveAbstractClass.cs", "ICombinationParts.cs",],
+            ["ComprehensiveAbstractClass.cs", "MyAbstractBase.cs", "ICombinationMockA.cs", "ICombinationMockB.cs",],
             """
             ComprehensiveAbstractClass sut = ComprehensiveAbstractClass.CreateMock()
             	.Implementing<ICombinationMockA>()
@@ -50,7 +50,7 @@ await That(SnapshotStorage.StripConfigSpecificLines(generated[fileName]))
             []),
         new(
             "ComprehensiveAbstractClass_CanBeCreated",
-            ["ComprehensiveAbstractClass.cs",],
+            ["ComprehensiveAbstractClass.cs", "MyAbstractBase.cs",],
             """
             ComprehensiveAbstractClass sut = ComprehensiveAbstractClass.CreateMock();
             """,
@@ -64,7 +64,10 @@ await That(SnapshotStorage.StripConfigSpecificLines(generated[fileName]))
             []),
         new(
             "ComprehensiveInterface_CanBeCreated",
-            ["ComprehensiveDelegate.cs", "IComprehensiveInterface.cs",],
+            [
+                "ComprehensiveDelegate.cs", "IComprehensiveInterface.cs",
+                "MyBase.cs", "MyEnum.cs", "MyEventArgs.cs", "MyStruct.cs",
+            ],
             """
             IComprehensiveInterface sut = IComprehensiveInterface.CreateMock();
             """,
@@ -78,14 +81,14 @@ await That(SnapshotStorage.StripConfigSpecificLines(generated[fileName]))
             [typeof(HttpClient), typeof(HttpStatusCode),]),
         new(
             "KeywordEdgeCases_CanBeCreated",
-            ["KeywordEdgeCases.cs",],
+            ["IKeywordEdgeCases.cs",],
             """
             IKeywordEdgeCases sut = IKeywordEdgeCases.CreateMock();
             """,
             []),
         new(
             "RefStructConsumer_CanBeCreated",
-            ["IRefStructConsumer.cs",],
+            ["IRefStructConsumer.cs", "Packet.cs",],
             """
             IRefStructConsumer sut = IRefStructConsumer.CreateMock();
             """,
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/ComprehensiveAbstractClass.cs b/Tests/Mockolate.Tests/GeneratorCoverage/ComprehensiveAbstractClass.cs
index 94b99d3d..ce4f9505 100644
--- a/Tests/Mockolate.Tests/GeneratorCoverage/ComprehensiveAbstractClass.cs
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/ComprehensiveAbstractClass.cs
@@ -3,17 +3,6 @@
 
 namespace Mockolate.Tests.GeneratorCoverage;
 
-/// <summary>
-///     Base class without a parameterless constructor — forces the mock to chain a
-///     <c>: base(...)</c> call from every generated constructor.
-/// </summary>
-public abstract class MyAbstractBase
-{
-	protected MyAbstractBase(int seed) { Seed = seed; }
-
-	public int Seed { get; }
-}
-
 /// <summary>
 ///     Class-only generator branches: multiple constructors with different shapes,
 ///     a constructor parameter named <c>mockRegistry</c> that collides with the
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/ICombinationParts.cs b/Tests/Mockolate.Tests/GeneratorCoverage/ICombinationMockA.cs
similarity index 85%
rename from Tests/Mockolate.Tests/GeneratorCoverage/ICombinationParts.cs
rename to Tests/Mockolate.Tests/GeneratorCoverage/ICombinationMockA.cs
index 1597ac02..ba73f762 100644
--- a/Tests/Mockolate.Tests/GeneratorCoverage/ICombinationParts.cs
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/ICombinationMockA.cs
@@ -12,9 +12,4 @@ public interface ICombinationMockA
 	void Run();
 }
 
-public interface ICombinationMockB
-{
-	int Value { get; }
-	void Run();
-}
 #endif
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/ICombinationMockB.cs b/Tests/Mockolate.Tests/GeneratorCoverage/ICombinationMockB.cs
new file mode 100644
index 00000000..3bf7a2bd
--- /dev/null
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/ICombinationMockB.cs
@@ -0,0 +1,7 @@
+namespace Mockolate.Tests.GeneratorCoverage;
+
+public interface ICombinationMockB
+{
+	int Value { get; }
+	void Run();
+}
\ No newline at end of file
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/IComprehensiveInterface.cs b/Tests/Mockolate.Tests/GeneratorCoverage/IComprehensiveInterface.cs
index 9e2dfc36..2c27058c 100644
--- a/Tests/Mockolate.Tests/GeneratorCoverage/IComprehensiveInterface.cs
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/IComprehensiveInterface.cs
@@ -4,22 +4,6 @@
 
 namespace Mockolate.Tests.GeneratorCoverage;
 
-public class MyBase
-{
-}
-
-public enum MyEnum { A, B, C, }
-
-public struct MyStruct
-{
-	public int X;
-}
-
-public class MyEventArgs : EventArgs
-{
-	public int N;
-}
-
 /// <summary>
 ///     Squeezes every interface-shaped generator branch we can fit into a single type:
 ///     property accessor combinations, indexers (single + arity-5), all three event flavors,
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/KeywordEdgeCases.cs b/Tests/Mockolate.Tests/GeneratorCoverage/IKeywordEdgeCases.cs
similarity index 100%
rename from Tests/Mockolate.Tests/GeneratorCoverage/KeywordEdgeCases.cs
rename to Tests/Mockolate.Tests/GeneratorCoverage/IKeywordEdgeCases.cs
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/IRefStructConsumer.cs b/Tests/Mockolate.Tests/GeneratorCoverage/IRefStructConsumer.cs
index a9fd02c9..3c176e8c 100644
--- a/Tests/Mockolate.Tests/GeneratorCoverage/IRefStructConsumer.cs
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/IRefStructConsumer.cs
@@ -1,11 +1,6 @@
 #if NET10_0_OR_GREATER
 namespace Mockolate.Tests.GeneratorCoverage;
 
-public readonly ref struct Packet(int id)
-{
-	public int Id { get; } = id;
-}
-
 /// <summary>
 ///     Isolates the ref-struct setup pipeline: ref-struct method parameters at arity &gt; 4
 ///     trigger <c>RefStructMethodSetups.g.cs</c>, and ref-struct indexer keys at arity &gt; 4
@@ -15,5 +10,13 @@ public interface IRefStructConsumer
 {
 	string this[Packet k1, int k2, Packet k3, int k4, Packet k5] { get; set; }
 	void Consume5(Packet p1, Packet p2, Packet p3, Packet p4, Packet p5);
+	void Produce(out Packet packet);
+	void Mutate(ref Packet packet);
+	void Inspect(ref readonly Packet packet);
+	void ProduceSpan(out System.Span<int> span);
+	void MutateSpan(ref System.Span<int> span);
+	void ProduceReadOnlySpan(out System.ReadOnlySpan<int> span);
+	void MutateReadOnlySpan(ref System.ReadOnlySpan<int> span);
+	void InspectSpan(ref readonly System.Span<int> span);
 }
 #endif
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/MyAbstractBase.cs b/Tests/Mockolate.Tests/GeneratorCoverage/MyAbstractBase.cs
new file mode 100644
index 00000000..a7e00e7e
--- /dev/null
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/MyAbstractBase.cs
@@ -0,0 +1,12 @@
+namespace Mockolate.Tests.GeneratorCoverage;
+
+/// <summary>
+///     Base class without a parameterless constructor — forces the mock to chain a
+///     <c>: base(...)</c> call from every generated constructor.
+/// </summary>
+public abstract class MyAbstractBase
+{
+	protected MyAbstractBase(int seed) { Seed = seed; }
+
+	public int Seed { get; }
+}
\ No newline at end of file
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/MyBase.cs b/Tests/Mockolate.Tests/GeneratorCoverage/MyBase.cs
new file mode 100644
index 00000000..1d87bc33
--- /dev/null
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/MyBase.cs
@@ -0,0 +1,5 @@
+namespace Mockolate.Tests.GeneratorCoverage;
+
+public class MyBase
+{
+}
\ No newline at end of file
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/MyEnum.cs b/Tests/Mockolate.Tests/GeneratorCoverage/MyEnum.cs
new file mode 100644
index 00000000..3350484e
--- /dev/null
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/MyEnum.cs
@@ -0,0 +1,3 @@
+namespace Mockolate.Tests.GeneratorCoverage;
+
+public enum MyEnum { A, B, C, }
\ No newline at end of file
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/MyEventArgs.cs b/Tests/Mockolate.Tests/GeneratorCoverage/MyEventArgs.cs
new file mode 100644
index 00000000..d46ab095
--- /dev/null
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/MyEventArgs.cs
@@ -0,0 +1,6 @@
+namespace Mockolate.Tests.GeneratorCoverage;
+
+public class MyEventArgs : EventArgs
+{
+	public int N;
+}
\ No newline at end of file
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/MyStruct.cs b/Tests/Mockolate.Tests/GeneratorCoverage/MyStruct.cs
new file mode 100644
index 00000000..4d85fecd
--- /dev/null
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/MyStruct.cs
@@ -0,0 +1,6 @@
+namespace Mockolate.Tests.GeneratorCoverage;
+
+public struct MyStruct
+{
+	public int X;
+}
\ No newline at end of file
diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/Packet.cs b/Tests/Mockolate.Tests/GeneratorCoverage/Packet.cs
new file mode 100644
index 00000000..06e366a5
--- /dev/null
+++ b/Tests/Mockolate.Tests/GeneratorCoverage/Packet.cs
@@ -0,0 +1,8 @@
+#if NET10_0_OR_GREATER
+namespace Mockolate.Tests.GeneratorCoverage;
+
+public readonly ref struct Packet(int id)
+{
+	public int Id { get; } = id;
+}
+#endif
\ No newline at end of file
diff --git a/Tests/Mockolate.Tests/ItTests.IsAnyOutReadOnlySpanTests.cs b/Tests/Mockolate.Tests/ItTests.IsAnyOutReadOnlySpanTests.cs
new file mode 100644
index 00000000..9429d813
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsAnyOutReadOnlySpanTests.cs
@@ -0,0 +1,33 @@
+#if NET8_0_OR_GREATER
+using Mockolate.Parameters;
+using Mockolate.Setup;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsAnyOutReadOnlySpanTests
+	{
+		[Fact]
+		public async Task ToString_ShouldReturnExpectedValue()
+		{
+			IOutParameter<ReadOnlySpanWrapper<int>> sut = It.IsAnyOutReadOnlySpan<int>();
+			string expectedValue = "It.IsAnyOut<ReadOnlySpanWrapper<int>>()";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task TryGetValue_ShouldReturnFalse()
+		{
+			IOutParameter<ReadOnlySpanWrapper<int>> sut = It.IsAnyOutReadOnlySpan<int>();
+
+			bool result = sut.TryGetValue(out _);
+
+			await That(result).IsFalse();
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsAnyOutRefStructTests.cs b/Tests/Mockolate.Tests/ItTests.IsAnyOutRefStructTests.cs
new file mode 100644
index 00000000..5b67dc7a
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsAnyOutRefStructTests.cs
@@ -0,0 +1,32 @@
+#if NET9_0_OR_GREATER
+using Mockolate.Parameters;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsAnyOutRefStructTests
+	{
+		[Fact]
+		public async Task ToString_ShouldReturnExpectedValue()
+		{
+			IOutRefStructParameter<Span<int>> sut = It.IsAnyOutRefStruct<Span<int>>();
+			string expectedValue = "It.IsAnyOutRefStruct<Span<int>>()";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task TryGetValue_ShouldReturnFalse()
+		{
+			IOutRefStructParameter<Span<int>> sut = It.IsAnyOutRefStruct<Span<int>>();
+
+			bool result = sut.TryGetValue(out _);
+
+			await That(result).IsFalse();
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsAnyOutSpanTests.cs b/Tests/Mockolate.Tests/ItTests.IsAnyOutSpanTests.cs
new file mode 100644
index 00000000..a9536030
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsAnyOutSpanTests.cs
@@ -0,0 +1,33 @@
+#if NET8_0_OR_GREATER
+using Mockolate.Parameters;
+using Mockolate.Setup;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsAnyOutSpanTests
+	{
+		[Fact]
+		public async Task ToString_ShouldReturnExpectedValue()
+		{
+			IOutParameter<SpanWrapper<int>> sut = It.IsAnyOutSpan<int>();
+			string expectedValue = "It.IsAnyOut<SpanWrapper<int>>()";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task TryGetValue_ShouldReturnFalse()
+		{
+			IOutParameter<SpanWrapper<int>> sut = It.IsAnyOutSpan<int>();
+
+			bool result = sut.TryGetValue(out _);
+
+			await That(result).IsFalse();
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsAnyRefReadOnlySpanTests.cs b/Tests/Mockolate.Tests/ItTests.IsAnyRefReadOnlySpanTests.cs
new file mode 100644
index 00000000..a62285fe
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsAnyRefReadOnlySpanTests.cs
@@ -0,0 +1,37 @@
+#if NET8_0_OR_GREATER
+using Mockolate.Parameters;
+using Mockolate.Setup;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsAnyRefReadOnlySpanTests
+	{
+		[Fact]
+		public async Task GetValue_ShouldReturnSameValue()
+		{
+			IRefParameter<ReadOnlySpanWrapper<int>> sut = It.IsAnyRefReadOnlySpan<int>();
+			ReadOnlySpanWrapper<int> input = new(new[]
+			{
+				1, 2, 3,
+			});
+
+			ReadOnlySpanWrapper<int> result = sut.GetValue(input);
+
+			await That(result.ReadOnlySpanValues.Length).IsEqualTo(3);
+		}
+
+		[Fact]
+		public async Task ToString_ShouldReturnExpectedValue()
+		{
+			IRefParameter<ReadOnlySpanWrapper<int>> sut = It.IsAnyRefReadOnlySpan<int>();
+			string expectedValue = "It.IsAnyRef<ReadOnlySpanWrapper<int>>()";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsAnyRefRefStructTests.cs b/Tests/Mockolate.Tests/ItTests.IsAnyRefRefStructTests.cs
new file mode 100644
index 00000000..97df2be2
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsAnyRefRefStructTests.cs
@@ -0,0 +1,36 @@
+#if NET9_0_OR_GREATER
+using Mockolate.Parameters;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsAnyRefRefStructTests
+	{
+		[Fact]
+		public async Task ToString_ShouldReturnExpectedValue()
+		{
+			IRefRefStructParameter<Span<int>> sut = It.IsAnyRefRefStruct<Span<int>>();
+			string expectedValue = "It.IsAnyRefRefStruct<Span<int>>()";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task GetValue_ShouldReturnSameValue()
+		{
+			IRefRefStructParameter<Span<int>> sut = It.IsAnyRefRefStruct<Span<int>>();
+			int[] backing = [1, 2, 3];
+
+			Span<int> roundTripped = sut.GetValue(backing.AsSpan());
+			int length = roundTripped.Length;
+			int first = roundTripped[0];
+
+			await That(length).IsEqualTo(3);
+			await That(first).IsEqualTo(1);
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsAnyRefSpanTests.cs b/Tests/Mockolate.Tests/ItTests.IsAnyRefSpanTests.cs
new file mode 100644
index 00000000..91029daf
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsAnyRefSpanTests.cs
@@ -0,0 +1,37 @@
+#if NET8_0_OR_GREATER
+using Mockolate.Parameters;
+using Mockolate.Setup;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsAnyRefSpanTests
+	{
+		[Fact]
+		public async Task GetValue_ShouldReturnSameValue()
+		{
+			IRefParameter<SpanWrapper<int>> sut = It.IsAnyRefSpan<int>();
+			SpanWrapper<int> input = new(new[]
+			{
+				1, 2, 3,
+			});
+
+			SpanWrapper<int> result = sut.GetValue(input);
+
+			await That(result.SpanValues.Length).IsEqualTo(3);
+		}
+
+		[Fact]
+		public async Task ToString_ShouldReturnExpectedValue()
+		{
+			IRefParameter<SpanWrapper<int>> sut = It.IsAnyRefSpan<int>();
+			string expectedValue = "It.IsAnyRef<SpanWrapper<int>>()";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsOutReadOnlySpanTests.cs b/Tests/Mockolate.Tests/ItTests.IsOutReadOnlySpanTests.cs
new file mode 100644
index 00000000..6412ee98
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsOutReadOnlySpanTests.cs
@@ -0,0 +1,37 @@
+#if NET8_0_OR_GREATER
+using Mockolate.Parameters;
+using Mockolate.Setup;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsOutReadOnlySpanTests
+	{
+		[Fact]
+		public async Task ToString_ShouldReturnExpectedValue()
+		{
+			IOutParameter<ReadOnlySpanWrapper<int>> sut =
+				It.IsOutReadOnlySpan(() => new ReadOnlySpanWrapper<int>([1, 2,]));
+			string expectedValue = "It.IsOut<ReadOnlySpanWrapper<int>>(() => new ReadOnlySpanWrapper<int>([1, 2,]))";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task TryGetValue_ShouldReturnSetterValue()
+		{
+			IOutParameter<ReadOnlySpanWrapper<int>> sut =
+				It.IsOutReadOnlySpan(() => new ReadOnlySpanWrapper<int>([7, 8,]));
+
+			bool found = sut.TryGetValue(out ReadOnlySpanWrapper<int> value);
+
+			await That(found).IsTrue();
+			await That(value.ReadOnlySpanValues.Length).IsEqualTo(2);
+			await That(value.ReadOnlySpanValues[0]).IsEqualTo(7);
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsOutSpanTests.cs b/Tests/Mockolate.Tests/ItTests.IsOutSpanTests.cs
new file mode 100644
index 00000000..e6af9e63
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsOutSpanTests.cs
@@ -0,0 +1,37 @@
+#if NET8_0_OR_GREATER
+using Mockolate.Parameters;
+using Mockolate.Setup;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsOutSpanTests
+	{
+		[Fact]
+		public async Task ToString_ShouldReturnExpectedValue()
+		{
+			IOutParameter<SpanWrapper<int>> sut =
+				It.IsOutSpan(() => new SpanWrapper<int>([1, 2, 3,]));
+			string expectedValue = "It.IsOut<SpanWrapper<int>>(() => new SpanWrapper<int>([1, 2, 3,]))";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task TryGetValue_ShouldReturnSetterValue()
+		{
+			IOutParameter<SpanWrapper<int>> sut =
+				It.IsOutSpan(() => new SpanWrapper<int>([7, 8,]));
+
+			bool found = sut.TryGetValue(out SpanWrapper<int> value);
+
+			await That(found).IsTrue();
+			await That(value.SpanValues.Length).IsEqualTo(2);
+			await That(value.SpanValues[0]).IsEqualTo(7);
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsOutTests.cs b/Tests/Mockolate.Tests/ItTests.IsOutTests.cs
index 55573e05..995fe868 100644
--- a/Tests/Mockolate.Tests/ItTests.IsOutTests.cs
+++ b/Tests/Mockolate.Tests/ItTests.IsOutTests.cs
@@ -28,6 +28,19 @@ public async Task ToString_Verify_ShouldReturnExpectedValue()
 			await That(result).IsEqualTo(expectedValue);
 		}
 
+#if NET9_0_OR_GREATER
+		[Fact]
+		public async Task ToString_WithRefStructFactory_ShouldReturnExpectedValue()
+		{
+			IOutRefStructParameter<Span<int>> sut = It.IsOut<Span<int>>(() => default);
+			string expectedValue = "It.IsOut<Span<int>>(() => default)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+#endif
+
 		[Theory]
 		[InlineData(42)]
 		[InlineData(-2)]
diff --git a/Tests/Mockolate.Tests/ItTests.IsRefReadOnlySpanTests.cs b/Tests/Mockolate.Tests/ItTests.IsRefReadOnlySpanTests.cs
new file mode 100644
index 00000000..5b6b9229
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsRefReadOnlySpanTests.cs
@@ -0,0 +1,50 @@
+#if NET8_0_OR_GREATER
+using Mockolate.Parameters;
+using Mockolate.Setup;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsRefReadOnlySpanTests
+	{
+		[Fact]
+		public async Task ToString_WithPredicateAndSetter_ShouldReturnExpectedValue()
+		{
+			IRefParameter<ReadOnlySpanWrapper<int>> sut = It.IsRefReadOnlySpan<int>(
+				value => value.ReadOnlySpanValues.Length > 0,
+				value => value);
+			string expectedValue =
+				"It.IsRef<ReadOnlySpanWrapper<int>>(value => value.ReadOnlySpanValues.Length > 0, value => value)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task ToString_WithPredicateOnly_ShouldReturnExpectedValue()
+		{
+			IRefParameter<ReadOnlySpanWrapper<int>> sut =
+				It.IsRefReadOnlySpan<int>(value => value.ReadOnlySpanValues.Length > 0);
+			string expectedValue =
+				"It.IsRef<ReadOnlySpanWrapper<int>>(value => value.ReadOnlySpanValues.Length > 0)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task ToString_WithSetterOnly_ShouldReturnExpectedValue()
+		{
+			IRefParameter<ReadOnlySpanWrapper<int>> sut = It.IsRefReadOnlySpan<int>(value => value);
+			string expectedValue = "It.IsRef<ReadOnlySpanWrapper<int>>(value => value)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsRefSpanTests.cs b/Tests/Mockolate.Tests/ItTests.IsRefSpanTests.cs
new file mode 100644
index 00000000..832da341
--- /dev/null
+++ b/Tests/Mockolate.Tests/ItTests.IsRefSpanTests.cs
@@ -0,0 +1,49 @@
+#if NET8_0_OR_GREATER
+using Mockolate.Parameters;
+using Mockolate.Setup;
+
+namespace Mockolate.Tests;
+
+public sealed partial class ItTests
+{
+	public sealed class IsRefSpanTests
+	{
+		[Fact]
+		public async Task ToString_WithPredicateAndSetter_ShouldReturnExpectedValue()
+		{
+			IRefParameter<SpanWrapper<int>> sut = It.IsRefSpan<int>(
+				value => value.SpanValues.Length > 0,
+				value => value);
+			string expectedValue =
+				"It.IsRef<SpanWrapper<int>>(value => value.SpanValues.Length > 0, value => value)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task ToString_WithPredicateOnly_ShouldReturnExpectedValue()
+		{
+			IRefParameter<SpanWrapper<int>> sut =
+				It.IsRefSpan<int>(value => value.SpanValues.Length > 0);
+			string expectedValue = "It.IsRef<SpanWrapper<int>>(value => value.SpanValues.Length > 0)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task ToString_WithSetterOnly_ShouldReturnExpectedValue()
+		{
+			IRefParameter<SpanWrapper<int>> sut = It.IsRefSpan<int>(value => value);
+			string expectedValue = "It.IsRef<SpanWrapper<int>>(value => value)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+	}
+}
+#endif
diff --git a/Tests/Mockolate.Tests/ItTests.IsRefTests.cs b/Tests/Mockolate.Tests/ItTests.IsRefTests.cs
index d670e769..70c9d714 100644
--- a/Tests/Mockolate.Tests/ItTests.IsRefTests.cs
+++ b/Tests/Mockolate.Tests/ItTests.IsRefTests.cs
@@ -38,5 +38,41 @@ public async Task Verify_ShouldAlwaysMatch()
 			await That(result).IsTrue();
 			await That(() => ((IParameterMatch<int?>)sut).InvokeCallbacks(0)).DoesNotThrow();
 		}
+
+#if NET9_0_OR_GREATER
+		[Fact]
+		public async Task ToString_WithRefStructTransform_ShouldReturnExpectedValue()
+		{
+			IRefRefStructParameter<Span<int>> sut = It.IsRef<Span<int>>(value => value);
+			string expectedValue = "It.IsRef<Span<int>>(value => value)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task ToString_WithRefStructPredicateAndTransform_ShouldReturnExpectedValue()
+		{
+			IRefRefStructParameter<Span<int>> sut =
+				It.IsRef<Span<int>>(value => value.Length > 0, value => value);
+			string expectedValue = "It.IsRef<Span<int>>(value => value.Length > 0, value => value)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+
+		[Fact]
+		public async Task ToString_WithRefStructPredicateOnly_ShouldReturnExpectedValue()
+		{
+			IRefRefStructParameter<Span<int>> sut = It.IsRef<Span<int>>(value => value.Length > 0);
+			string expectedValue = "It.IsRef<Span<int>>(value => value.Length > 0)";
+
+			string? result = sut.ToString();
+
+			await That(result).IsEqualTo(expectedValue);
+		}
+#endif
 	}
 }
diff --git a/Tests/Mockolate.Tests/RefStruct/RefStructOutRefParameterTests.cs b/Tests/Mockolate.Tests/RefStruct/RefStructOutRefParameterTests.cs
new file mode 100644
index 00000000..23cb3a14
--- /dev/null
+++ b/Tests/Mockolate.Tests/RefStruct/RefStructOutRefParameterTests.cs
@@ -0,0 +1,363 @@
+#if NET9_0_OR_GREATER
+using GcPacket = Mockolate.Tests.GeneratorCoverage.Packet;
+using Mockolate.Setup;
+using Mockolate.Tests.GeneratorCoverage;
+
+namespace Mockolate.Tests.RefStruct;
+
+/// <summary>
+///     End-to-end coverage for `out`, `ref`, and `ref readonly` ref-struct parameters routed
+///     through <see cref="Mockolate.Parameters.IOutRefStructParameter{T}" /> /
+///     <see cref="Mockolate.Parameters.IRefRefStructParameter{T}" />. Uses the
+///     <see cref="GeneratorCoverage.Packet" /> ref struct (single-int ctor) to isolate this
+///     scenario from the payload-carrying <see cref="Packet" /> used by other RefStruct tests.
+/// </summary>
+/// <remarks>
+///     Ref struct values cannot survive an <c>await</c> boundary, so each test captures
+///     <see cref="GeneratorCoverage.Packet.Id" /> into an int before awaiting the assertion.
+/// </remarks>
+public sealed class RefStructOutRefParameterTests
+{
+	[Fact]
+	public async Task OutRefStruct_WithIsOut_AssignsSetterValue()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.Produce(It.IsOut<GcPacket>(() => new GcPacket(7)));
+
+		GcPacket packet = default;
+		sut.Produce(out packet);
+		int id = packet.Id;
+
+		await That(id).IsEqualTo(7);
+	}
+
+	[Fact]
+	public async Task OutRefStruct_WithIsAnyOutRefStruct_AssignsDefault()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.Produce(It.IsAnyOutRefStruct<GcPacket>());
+
+		GcPacket packet = new(99);
+		sut.Produce(out packet);
+		int id = packet.Id;
+
+		await That(id).IsEqualTo(0);
+	}
+
+	[Fact]
+	public async Task OutRefStruct_NoSetup_AssignsDefault()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+
+		GcPacket packet = new(99);
+		sut.Produce(out packet);
+		int id = packet.Id;
+
+		await That(id).IsEqualTo(0);
+	}
+
+	[Fact]
+	public async Task RefRefStruct_WithIsRef_TransformsValue()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.Mutate(It.IsRef<GcPacket>(p => new GcPacket(p.Id + 1)));
+
+		GcPacket packet = new(41);
+		sut.Mutate(ref packet);
+		int id = packet.Id;
+
+		await That(id).IsEqualTo(42);
+	}
+
+	[Fact]
+	public async Task RefRefStruct_WithIsAnyRefRefStruct_LeavesValueUnchanged()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.Mutate(It.IsAnyRefRefStruct<GcPacket>());
+
+		GcPacket packet = new(13);
+		sut.Mutate(ref packet);
+		int id = packet.Id;
+
+		await That(id).IsEqualTo(13);
+	}
+
+	[Fact]
+	public async Task RefRefStruct_WithPredicate_OnlyTransformsWhenPredicateHolds()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.Mutate(It.IsRef<GcPacket>(p => p.Id == 41, _ => new GcPacket(99)));
+
+		GcPacket matching = new(41);
+		sut.Mutate(ref matching);
+		int matchingId = matching.Id;
+
+		GcPacket nonMatching = new(1);
+		sut.Mutate(ref nonMatching);
+		int nonMatchingId = nonMatching.Id;
+
+		await That(matchingId).IsEqualTo(99);
+		await That(nonMatchingId).IsEqualTo(1);
+	}
+
+	[Fact]
+	public async Task RefReadOnlyRefStruct_PassesValueUnchanged()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+
+		GcPacket packet = new(17);
+		sut.Inspect(in packet);
+		int idAfter = packet.Id;
+
+		await That(idAfter).IsEqualTo(17);
+	}
+
+	[Fact]
+	public async Task OutSpan_WithIsOutSpan_AssignsSetterArray()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.ProduceSpan(It.IsOutSpan(() => new SpanWrapper<int>(new[] { 1, 2, 3 })));
+
+		Span<int> span = default;
+		sut.ProduceSpan(out span);
+		int length = span.Length;
+		int first = span[0];
+		int last = span[2];
+
+		await That(length).IsEqualTo(3);
+		await That(first).IsEqualTo(1);
+		await That(last).IsEqualTo(3);
+	}
+
+	[Fact]
+	public async Task OutSpan_WithIsAnyOutSpan_AssignsDefault()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.ProduceSpan(It.IsAnyOutSpan<int>());
+
+		Span<int> span = new[] { 99 };
+		sut.ProduceSpan(out span);
+		int length = span.Length;
+
+		await That(length).IsEqualTo(0);
+	}
+
+	[Fact]
+	public async Task OutSpan_NoSetup_AssignsDefault()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+
+		Span<int> span = new[] { 99 };
+		sut.ProduceSpan(out span);
+		int length = span.Length;
+
+		await That(length).IsEqualTo(0);
+	}
+
+	[Fact]
+	public async Task OutSpan_WithDoCallback_RunsAction()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		int observedFirst = 0;
+		int observedLength = 0;
+		sut.Mock.Setup.ProduceSpan(
+			It.IsOutSpan(() => new SpanWrapper<int>(new[] { 7, 8 }))
+				.Do(w =>
+				{
+					observedFirst = w.SpanValues[0];
+					observedLength = w.SpanValues.Length;
+				}));
+
+		Span<int> span = default;
+		sut.ProduceSpan(out span);
+
+		await That(observedFirst).IsEqualTo(7);
+		await That(observedLength).IsEqualTo(2);
+	}
+
+	[Fact]
+	public async Task RefSpan_WithIsRefSpan_TransformsArray()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.MutateSpan(It.IsRefSpan<int>(w => new SpanWrapper<int>(new[] { w.SpanValues[0] + 1 })));
+
+		Span<int> span = new[] { 41 };
+		sut.MutateSpan(ref span);
+		int first = span[0];
+		int length = span.Length;
+
+		await That(first).IsEqualTo(42);
+		await That(length).IsEqualTo(1);
+	}
+
+	[Fact]
+	public async Task RefSpan_WithIsAnyRefSpan_LeavesValueUnchanged()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.MutateSpan(It.IsAnyRefSpan<int>());
+
+		Span<int> span = new[] { 13, 14 };
+		sut.MutateSpan(ref span);
+		int first = span[0];
+		int length = span.Length;
+
+		await That(first).IsEqualTo(13);
+		await That(length).IsEqualTo(2);
+	}
+
+	[Fact]
+	public async Task RefSpan_WithPredicate_OnlyTransformsWhenPredicateHolds()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.MutateSpan(
+			It.IsRefSpan<int>(
+				w => w.SpanValues.Length > 0 && w.SpanValues[0] == 41,
+				_ => new SpanWrapper<int>(new[] { 99 })));
+
+		Span<int> matching = new[] { 41 };
+		sut.MutateSpan(ref matching);
+		int matchingFirst = matching[0];
+
+		Span<int> nonMatching = new[] { 1 };
+		sut.MutateSpan(ref nonMatching);
+		int nonMatchingFirst = nonMatching[0];
+
+		await That(matchingFirst).IsEqualTo(99);
+		await That(nonMatchingFirst).IsEqualTo(1);
+	}
+
+	[Fact]
+	public async Task OutReadOnlySpan_WithIsOutReadOnlySpan_AssignsSetterArray()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.ProduceReadOnlySpan(
+			It.IsOutReadOnlySpan(() => new ReadOnlySpanWrapper<int>(new[] { 5, 6, 7 })));
+
+		ReadOnlySpan<int> span = default;
+		sut.ProduceReadOnlySpan(out span);
+		int length = span.Length;
+		int first = span[0];
+
+		await That(length).IsEqualTo(3);
+		await That(first).IsEqualTo(5);
+	}
+
+	[Fact]
+	public async Task OutReadOnlySpan_WithIsAnyOutReadOnlySpan_AssignsDefault()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.ProduceReadOnlySpan(It.IsAnyOutReadOnlySpan<int>());
+
+		ReadOnlySpan<int> span = new[] { 99 };
+		sut.ProduceReadOnlySpan(out span);
+		int length = span.Length;
+
+		await That(length).IsEqualTo(0);
+	}
+
+	[Fact]
+	public async Task OutReadOnlySpan_NoSetup_AssignsDefault()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+
+		ReadOnlySpan<int> span = new[] { 99 };
+		sut.ProduceReadOnlySpan(out span);
+		int length = span.Length;
+
+		await That(length).IsEqualTo(0);
+	}
+
+	[Fact]
+	public async Task RefReadOnlySpan_WithIsRefReadOnlySpan_TransformsArray()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.MutateReadOnlySpan(
+			It.IsRefReadOnlySpan<int>(
+				w => new ReadOnlySpanWrapper<int>(new[] { w.ReadOnlySpanValues[0] + 1 })));
+
+		ReadOnlySpan<int> span = new[] { 41 };
+		sut.MutateReadOnlySpan(ref span);
+		int first = span[0];
+
+		await That(first).IsEqualTo(42);
+	}
+
+	[Fact]
+	public async Task RefReadOnlySpan_WithIsAnyRefReadOnlySpan_LeavesValueUnchanged()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.MutateReadOnlySpan(It.IsAnyRefReadOnlySpan<int>());
+
+		ReadOnlySpan<int> span = new[] { 13 };
+		sut.MutateReadOnlySpan(ref span);
+		int first = span[0];
+
+		await That(first).IsEqualTo(13);
+	}
+
+	[Fact]
+	public async Task RefReadOnlySpan_WithPredicateOnly_GatesMatchWithoutMutating()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.MutateReadOnlySpan(
+				It.IsRefReadOnlySpan<int>(w => w.ReadOnlySpanValues.Length == 1))
+			.Throws(new InvalidOperationException("matched"));
+
+		ReadOnlySpan<int> matching = new[] { 42 };
+		Exception? matchingThrew = null;
+		try
+		{
+			sut.MutateReadOnlySpan(ref matching);
+		}
+		catch (Exception ex)
+		{
+			matchingThrew = ex;
+		}
+		int matchingFirst = matching[0];
+		int matchingLength = matching.Length;
+
+		ReadOnlySpan<int> nonMatching = new[] { 13, 14 };
+		Exception? nonMatchingThrew = null;
+		try
+		{
+			sut.MutateReadOnlySpan(ref nonMatching);
+		}
+		catch (Exception ex)
+		{
+			nonMatchingThrew = ex;
+		}
+		int nonMatchingFirst = nonMatching[0];
+
+		await That(matchingThrew).IsNotNull();
+		await That(matchingFirst).IsEqualTo(42);
+		await That(matchingLength).IsEqualTo(1);
+		await That(nonMatchingThrew).IsNull();
+		await That(nonMatchingFirst).IsEqualTo(13);
+	}
+
+	[Fact]
+	public async Task RefReadOnlySpan_WithIsAnyRefRefStruct_MatchesViaRefStructPipeline()
+	{
+		IRefStructConsumer sut = IRefStructConsumer.CreateMock();
+		sut.Mock.Setup.InspectSpan(It.IsAnyRefRefStruct<Span<int>>())
+			.Throws(new InvalidOperationException("matched"));
+
+		Span<int> span = new[] { 17, 18, 19 };
+		Exception? thrown = null;
+		try
+		{
+			sut.InspectSpan(in span);
+		}
+		catch (Exception ex)
+		{
+			thrown = ex;
+		}
+		int length = span.Length;
+		int first = span[0];
+
+		await That(thrown).IsNotNull();
+		await That(length).IsEqualTo(3);
+		await That(first).IsEqualTo(17);
+	}
+}
+#endif