fix(nativeaot): generate self-writing RPC responses

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

@@ -131,6 +131,52 @@ 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
+
+The runtime invokes <xref:Orleans.Serialization.Invocation.IInvokable.Invoke*> with a shared, provider-owned <xref:Orleans.Serialization.Invocation.InvocationContext> in the ordinary, incoming-filter, and observer paths. Its default implementation copies successful responses using the context's selected response copier. For supported non-generic methods using the built-in task and value-task request bases, generated implementations bind the selected serialization dependencies and rent a concrete, non-generic response holder after copying a mutable result. Completed tasks and value tasks consume their result directly; pending operations use a separate asynchronous completion method. Immutable results retain their existing copy semantics. Isolation completes before incoming filters resume, and the generated path creates one pooled envelope for the successful result. Exception envelopes retain the original exception through filters and are copied at delivery for every invocation.
+
+Incoming filters receive an isolated result and can transform its envelope or nested payload references. The call-filter invoker 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. Generated and compatibility responses share the pool implementation keyed by their concrete envelope type. Returning a generated holder to its pool clears both its result and its provider-owned factory binding.
+
+The response factory constructor resolves and checks the selected result and response codecs and copiers. Subsequent invocations resolve the provider-owned factory through the existing transactional service cache without repeating those dependency lookups. Factory construction retains serializer initialization, recursive dependency resolution, and graph publication or rollback; a failed graph cannot publish a response factory.
+
+Successful remote write completion releases each response envelope and clears the message's reference to it after recording the send. A transport-write failure retains the envelope for retry or rerouting. Terminal message disposal and body replacement release the owned envelope; serialization failure replaces it with an exception response or releases it on a terminal drop.
+
+On receipt, the callback transfers envelope ownership to <xref:Orleans.Serialization.Invocation.IResponseCompletionSource.Complete*>. Typed completion extracts the result and releases the envelope, preserving the result payload for the caller. Untyped completion transfers a successful envelope to its awaiting consumer; void consumption releases it directly. Outgoing filters retain selected and superseded envelopes through their continuations, and the invocation releases them after extracting the final result or unwinding a failure. Application code calling `Complete` transfers ownership and leaves envelope disposal to the completion pipeline.
+
+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 services match the canonical implementations and the response codecs/copiers have the exact canonical types. Custom response subclasses retain their selected raw wire and copying behavior through the compatibility path.
+
+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.
+
+Every response-returning RPC also registers polymorphic codec and copier dispatch for the non-generic <xref:Orleans.Serialization.Invocation.Response> boundary used by the runtime client, including results supplied entirely by explicit closed contracts. 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.
+
+The generator prepares one response plan for holder naming, graph admission, and factory emission. Complete, partial, and referenced graphs share constructor-service descriptions and a registration emitter, so each dependency edge identifies the service consumed by its factory. Generated graphs register closed generic-argument metadata through <xref:Orleans.Serialization.Configuration.TypeManifestOptions.AddGenericArgumentMetadata*>. Candidate selection validates bound generic constraints before choosing an implementation, using the same validation for inferred defaults and ordinary lookup. Constructor-constrained reference arguments must be concrete types with public parameterless constructors on every target framework; invalid candidates yield to the next applicable registration before generic closure. Managed lookup retains runtime constraint validation for application-selected types whose metadata is supplied at runtime.
+
+Generated invocation fallbacks and runtime delivery boundaries share non-generic envelope copy-and-dispose ownership logic. The selected copier retains its typed or runtime-type dispatch behavior, including immutable exception envelopes and custom copiers that return their input. Raw response transport resolves one reader per result type; <xref:Orleans.Serialization.Invocation.ResponseCodec> adapts compatibility codecs to <xref:Orleans.Serialization.Invocation.IRawResponseReader>, and supported generated readers retain precedence.
+
+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";
 }