feat(networking): add Linux io_uring transport

docs/site/src/content/docs/implementation/serialization.md

@@ -131,6 +131,42 @@ For a return type marked through <xref:Orleans.Invocation.ReturnValueProxyAttrib
 
 Arguments and result values use normal Orleans.Serialization codecs and copiers. Exceptions are represented by exception responses and rethrown by the caller completion source. A grain call with a `CancellationToken` exposes cancellation through the generated request, allowing the runtime to propagate cooperative cancellation. Void methods set the one-way invocation option in their request base, so no response completion source waits for a result.
 
+### Closed RPC response factories
+
+For supported non-generic methods using the built-in task and value-task request bases, generated invokables also implement <xref:Orleans.Serialization.Invocation.IResponseInvokable>. The runtime selects this contract in the ordinary, incoming-filter, and observer paths. The invokable binds the selected serialization dependencies and rents a concrete, non-generic response holder after copying a mutable result. Immutable results retain their existing copy semantics. Isolation completes before incoming filters resume, and this path creates one pooled envelope for the successful result.
+
+Incoming filters receive an isolated result and can transform its envelope or nested payload references. The invocation context retains each superseded response until completion, allowing filters to restore an earlier selection and releasing every unselected wrapper exactly once. After the filter chain completes, the runtime copies the selected result for delivery, preserving isolation for both local callers and deferred message serialization. Calls with no incoming filters transfer their invocation-time copy directly to the messaging pipeline. Expired and one-way requests release their owned response without an outgoing copy.
+
+Generated holders implement <xref:Orleans.Serialization.Invocation.IRawResponseWriter>. The message serializer selects their direct writer before runtime-type codec lookup. Primitive holders call the existing static primitive codecs; reference holders use their bound concrete result codec and the message's serialization session. The wire representation retains the result-type header, field zero, end marker, null behavior, cycles, and shared references. Returning a holder to its pool clears both its result and its provider-owned factory binding.
+
+The receiving message serializer first consults <xref:Orleans.Serialization.Serializers.CodecProvider.TryGetRawResponseReader*> using the result type from the wire header. Generated <xref:Orleans.Serialization.Invocation.IRawResponseReader> registrations reconstruct a bound holder directly. Compatibility paths retain ordinary response codecs for custom response/payload implementations, custom invokable bases, and unresolved generic contracts. Generated direct factories activate only when the selected result and response codecs/copiers match the canonical implementations, so explicit application behavior retains precedence.
+
+For concrete `Task<TResult>` and `ValueTask<TResult>` method results, the generator emits identical invocation code and closed response registrations for JIT and NativeAOT execution. Provider registration precedence selects the services in both execution modes. The graph uses the concrete result implementations in <xref:Orleans.Serialization.Invocation.PooledResponseCodec`2> and <xref:Orleans.Serialization.Invocation.PooledResponseCopier`2>. Recursive result dependencies resolve with a construction caller after the response implementation has been allocated. Reference payload codecs and copiers preserve payload cycles and shared references, and the pooled response envelope retains the existing field and raw-message encoding.
+
+The graph also registers polymorphic codec and copier dispatch for the non-generic <xref:Orleans.Serialization.Invocation.Response> boundary used by the runtime client. That dispatch selects the closed implementation for the actual response type and preserves the identity of immutable completed and exception responses. The native smoke uses <xref:Orleans.Serialization.DeepCopier`1> with `Response`, matching the runtime's response-copy boundary.
+
+Completed response transport uses the existing generated codec and its canonical singleton activator, restoring <xref:Orleans.Serialization.Invocation.CompletedResponse.Instance> after a round-trip. Interfaces containing only non-generic `Task` or `ValueTask` methods also generate this shared response/completion graph.
+
+The finite response graph supplies successful typed results and completed-response transport, plus immutable exception-envelope copying. Exception transport uses the selected <xref:Orleans.Serialization.Invocation.ExceptionResponse> codec and the exception and `Data` value dependencies. Closed factories provide statically compiled implementations; registered metadata and the existing exception codecs provide the remaining supported serialization contracts.
+
+These supplemental registrations are emitted unconditionally and are defaults: explicit closed factory registrations take precedence in either configuration order. Inferred parent factories preserve each child's selected service: replacing a child contract selects parent construction through that contract, while parents consuming the explicit contract directly remain eligible. This applies throughout the dependency graph, including concrete canonical services and their codec, copier, and activator aliases. Generated factories and registered metadata use one resolution pipeline, with closed services selected first. Direct-holder factories and raw-reader registrations bind the selected provider implementations in both JIT and native execution. Custom application codec/copier selection uses the compatibility invocation and serialization path.
+
+Generated metadata also supplies static response factories for closed generated result models. These factories construct the model's canonical generated codec and copier using their actual constructor signatures, including closed generic generated activators and available generated activators from referenced assemblies. Source-known arrays, tuples, collections, and surrogate value serializers contribute their closed construction services. Interface contracts retain registered metadata dispatch and propagate their dependency requirements. Reference-assembly construction uses the producer's available constructor contracts and explicitly identified members.
+
+Inferred defaults participate when their complete construction graph uses closed service factories and provider-owned services. Admission compares matching metadata implementation identities, and the closed factories supply the executable services. Automatic metadata construction retains ordinary dependency-injection resolution throughout its call chain. Closed default roots start their own construction transactions, and explicit factories participate in the declared transaction. Constructor dependencies supplied by ordinary dependency-injection registrations select canonical metadata activation before the provider starts a serialization construction transaction. <xref:Orleans.Serialization.Configuration.TypeManifestOptions.AddDefaultSerializerService*> carries these dependency edges, preserving explicit registration priority, canonical service identity, and graph rollback. Default activation uses the existing reference- or value-type activator implementation, and custom activation retains its declared contract. Serializer contexts contribute their complete finite dependency graphs and validate each declared member shape.
+
+The same collector closes source-known argument construction dependencies selected by generated proxy constructors. Reference and value tuples use their existing closed codec and copier implementations with their declared element services. Parameter-only one-way contracts register the required construction services while completion and result contracts also register their response graphs.
+
+`OrleansValidateRpcResponseFactories` enables compile-time validation of the response graph and defaults to the executable project's `PublishAot` setting. Diagnostic `ORLEANS0116` identifies an unresolved generic result, a custom return adapter requiring an explicit response contract, or a result dependency outside the supported finite graph. Applications with runtime-selected generic results register every permitted closed <xref:Orleans.Serialization.Invocation.Response`1> graph explicitly through <xref:Orleans.Serialization.Configuration.TypeManifestOptions.AddSerializer*> and <xref:Orleans.Serialization.Configuration.TypeManifestOptions.AddSerializerService*> in a <xref:Orleans.Serialization.SerializerContext>, and set `OrleansValidateRpcResponseFactories=false` for the project supplying that contract. A missing native response registration reports the closed response type and requested serialization service at lookup.
+
+The combined inferred response graph supports up to 1,024 closed executable types. RPC admission counts the codec/copier construction graph; explicit serializer contexts also validate their separate metadata traversal limits. A larger union produces `ORLEANS0116` in both managed and native builds, even when each method's graph fits individually. The generator retains response holder declarations so the size diagnostic identifies the admission failure directly. Argument admission failures use an argument-specific `ORLEANS0116` message directing the application to register the argument's closed codec, copier, and serialization service dependencies, including for one-way methods.
+
+Dictionary results and dictionary members require an explicit closed registration which preserves the application's comparer contract. A dictionary's comparer is selected per value, so the method's declared result type alone supplies the key/value shape while the registration supplies comparer serialization and copying.
+
+The focused .NET 10 NativeAOT smoke exercises the generated response graph for boolean, integer, and reference results, including recursive factory dependencies and payload identity. Full silo startup and RPC execution additionally require the native support for activation, request serialization, grain references, and runtime metadata. Managed .NET 8 tests exercise JIT compatibility and compiled-reference contracts.
+
+Source: [RPC response factory generation](https://github.com/dotnet/orleans/blob/main/src/Orleans.CodeGenerator/RpcResponseGenerator.cs), [closed serializer factory graphs](https://github.com/dotnet/orleans/blob/main/src/Orleans.CodeGenerator/SerializerFactoryGenerator.cs), and [native response smoke](https://github.com/dotnet/orleans/blob/main/test/Orleans.NativeAotSmoke/RpcResponses.Contracts.cs).
+
 ### Request identity and dispatch
 
 Generated request names are implementation details. Their wire identity is a compound alias containing:

src/Orleans.CodeGenerator/AnalyzerReleases.Unshipped.md

@@ -12,3 +12,4 @@ ORLEANS0112 | Usage | Error | Invalid RPC parameter field identifier
 ORLEANS0113 | Usage | Warning | CancellationToken parameter is not last
 ORLEANS0114 | Usage | Error | Invalid serializer context declaration
 ORLEANS0115 | Usage | Error | Unsupported serializer context dependency
+ORLEANS0116 | Usage | Error | RPC response requires a closed serializer factory

src/Orleans.CodeGenerator/Diagnostics/DiagnosticRuleId.cs

@@ -18,4 +18,5 @@ internal static class DiagnosticRuleId
     public const string CancellationTokenNotLast = "ORLEANS0113";
     public const string InvalidSerializerContext = "ORLEANS0114";
     public const string UnsupportedSerializerContextType = "ORLEANS0115";
+    public const string UnsupportedRpcResponseFactory = "ORLEANS0116";
 }

src/Orleans.CodeGenerator/InvokableGenerator.cs

@@ -153,6 +153,50 @@ private ClassDeclarationSyntax GetClassDeclarationSyntax(
                 GenerateTryCancelMethod(method, fieldDescriptions),
                 GenerateIsCancellableProperty(method));
 
+        if (method.AllTypeParameters.Count == 0
+            && method.Method.ReturnType is INamedTypeSymbol { TypeArguments.Length: 1 } result
+            && baseClassType.OriginalDefinition.ToDisplayString() is "Orleans.Runtime.TaskRequest<TResult>" or "Orleans.Runtime.Request<TResult>"
+            && _generationContext.RpcResponseNames.TryGetValue(
+                result.TypeArguments[0].ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), out var responseName))
+        {
+            var type = result.TypeArguments[0].ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+            var factory = $"global::{RpcResponseHolderGenerator.GetNamespace(_generationContext.Compilation)}.{responseName}Factory";
+            classDeclaration = classDeclaration.AddBaseListTypes(SimpleBaseType(ParseTypeName("global::Orleans.Serialization.Invocation.IResponseInvokable")));
+            classDeclaration = classDeclaration.AddMembers(ParseMemberDeclaration($$"""
+                async global::System.Threading.Tasks.ValueTask<global::Orleans.Serialization.Invocation.Response>
+                    global::Orleans.Serialization.Invocation.IResponseInvokable.InvokeAndCopy(
+                        global::Orleans.Serialization.Serializers.ICodecProvider provider,
+                        global::Orleans.Serialization.Cloning.CopyContextPool contexts,
+                        global::Orleans.Serialization.DeepCopier<global::Orleans.Serialization.Invocation.Response> responseCopier)
+                {
+                    try
+                    {
+                        var factory = {{factory}}.Resolve(provider);
+                        if (!factory.IsSupported)
+                        {
+                            var original = await Invoke();
+                            global::Orleans.Serialization.Invocation.Response copy = null;
+                            try
+                            {
+                                return copy = responseCopier.Copy(original);
+                            }
+                            finally
+                            {
+                                if (!global::System.Object.ReferenceEquals(original, copy))
+                                    original.Dispose();
+                            }
+                        }
+                        {{type}} value = await InvokeInner();
+                        return factory.RentCopied(value, contexts);
+                    }
+                    catch (global::System.Exception exception)
+                    {
+                        return global::Orleans.Serialization.Invocation.Response.FromException(exception);
+                    }
+                }
+                """)!);
+        }
+
         if (method.AllTypeParameters.Count > 0)
         {
             classDeclaration = SyntaxFactoryUtility.AddGenericTypeParameters(classDeclaration, method.AllTypeParameters);
@@ -738,21 +782,24 @@ MemberDeclarationSyntax GetFieldDeclaration(InvokerFieldDescription description)
             {
                 var methodTypeArguments = GetTypesArray(method, method.MethodTypeParameters.Select(p => p.Parameter));
                 var parameterTypes = GetTypesArray(method, method.Method.Parameters.Select(p => p.Type));
+                var methodLookup = method.AllTypeParameters.Count == 0
+                    ? ParseExpression($"typeof({method.Method.ContainingType.ToTypeSyntax(method.TypeParameterSubstitutions)}).GetMethod({method.Method.Name.GetLiteralExpression()}, 0, global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.NonPublic | global::System.Reflection.BindingFlags.Instance, null, {(method.Method.Parameters.Length == 0 ? "global::System.Type.EmptyTypes" : parameterTypes.ToString())}, null)")
+                    : InvocationExpression(
+                        IdentifierName("OrleansGeneratedCodeHelper").Member("GetMethodInfoOrDefault"),
+                        ArgumentList(SeparatedList(
+                        [
+                            Argument(TypeOfExpression(method.Method.ContainingType.ToTypeSyntax(method.TypeParameterSubstitutions))),
+                            Argument(method.Method.Name.GetLiteralExpression()),
+                            Argument(methodTypeArguments),
+                            Argument(parameterTypes),
+                        ])));
 
                 field = FieldDeclaration(
                     VariableDeclaration(
                         LibraryTypes.MethodInfo.ToTypeSyntax(),
                         SingletonSeparatedList(VariableDeclarator(description.FieldName)
                         .WithInitializer(EqualsValueClause(
-                            InvocationExpression(
-                                IdentifierName("OrleansGeneratedCodeHelper").Member("GetMethodInfoOrDefault"),
-                                ArgumentList(SeparatedList(
-                                [
-                                    Argument(TypeOfExpression(method.Method.ContainingType.ToTypeSyntax(method.TypeParameterSubstitutions))),
-                                    Argument(method.Method.Name.GetLiteralExpression()),
-                                    Argument(methodTypeArguments),
-                                    Argument(parameterTypes),
-                                ]))))))))
+                            methodLookup)))))
                     .AddModifiers(Token(SyntaxKind.PrivateKeyword), Token(SyntaxKind.StaticKeyword), Token(SyntaxKind.ReadOnlyKeyword));
             }
             else