Orleans serialization errors with nullable ValueObject<string> fields

[Lukazoid]

Describe the bug

Was originally using Orleans 9, now Orleans 10 and the issue still occurs.
Using latest stable Vogen 8.0.4.

Steps to reproduce

With the following value object definition and request contract:

[ValueObject<string>]
public readonly partial record struct OrderId;

[GenerateSerializer]
public sealed record GetOrderRequest
{
    [Id(0)]
    public OrderId? OrderId { get; init; }
}

When I specify a non-null value for OrderId e.g. OrderId = OrderId.From("XYZ") I get the following from Orleans:

Orleans.Serialization.ReferenceNotFoundException : Reference with id 3 and type System.Nullable`1[GrainContracts.Orders.OrderId] not found.
   at Orleans.Serialization.Codecs.NullableCodec`1.ThrowInvalidReference(UInt32 reference) in /_/src/Orleans.Serialization/Codecs/NullableCodec.cs:line 62
   at Orleans.Serialization.Codecs.IFieldCodec`1.Orleans.Serialization.Codecs.IFieldCodec.ReadValue[TInput](Reader`1& reader, Field field) in /_/src/Orleans.Serialization/Codecs/IFieldCodec.cs:line 54
   at Orleans.Runtime.Messaging.MessageSerializer.ReadBodyObject[TInput](Message message, Reader`1& reader) in /_/src/Orleans.Core/Messaging/MessageSerializer.cs:line 142
   at Orleans.Runtime.Messaging.MessageSerializer.TryRead(ReadOnlySequence`1& input, Message& message) in /_/src/Orleans.Core/Messaging/MessageSerializer.cs:line 110
   at Orleans.Runtime.Messaging.Connection.ProcessIncoming() in /_/src/Orleans.Core/Networking/Connection.cs:line 294
--- End of stack trace from previous location ---
   at Orleans.Serialization.Invocation.ResponseCompletionSource`1.GetResult(Int16 token) in /_/src/Orleans.Serialization/Invocation/ResponseCompletionSource.cs:line 230
   at System.Threading.Tasks.ValueTask`1.ValueTaskSourceAsTask.<>c.<.cctor>b__4_0(Object state)
--- End of stack trace from previous location ---

I believe what is happening is that the Orleans NullableCodec only ever serializes the "null" value as WireType.Reference (see NullableCodec), so when the Vogen codec then decides to send a string reference, it doesn't get read back correctly.

Expected behaviour

Nullable fields of string primitives to round-trip successfully with Orleans.

[Lukazoid]

Here is the Vogen generated types for Orleans:

// ------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a source generator named Vogen (https://github.com/SteveDunn/Vogen)
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------

// Suppress warnings about [Obsolete] member usage in generated code.
#pragma warning disable CS0618

// Suppress warnings for 'Override methods on comparable types'.
#pragma warning disable CA1036

// Suppress Error MA0097 : A class that implements IComparable<T> or IComparable should override comparison operators
#pragma warning disable MA0097

// Suppress warning for 'The annotation for nullable reference types should only be used in code within a '#nullable' annotations context. Auto-generated code requires an explicit '#nullable' directive in source.'
// The generator copies signatures from the BCL, e.g. for `TryParse`, and some of those have nullable annotations.
#pragma warning disable CS8669, CS8632

#pragma warning disable CS8604 // Possible null reference argument.

// Suppress warnings about CS1591: Missing XML comment for publicly visible type or member 'Type_or_Member'
#pragma warning disable CS1591

[assembly: global::Orleans.Serialization.Configuration.TypeManifestProvider(typeof(GrainContracts.Orders.OrderIdOrleansProvider))]

namespace GrainContracts.Orders;
    
public sealed class OrderIdOrleansSerializer : global::Orleans.Serialization.Codecs.IFieldCodec<OrderId>
{
    public void WriteField<TBufferWriter>(ref global::Orleans.Serialization.Buffers.Writer<TBufferWriter> writer, uint fieldIdDelta, System.Type expectedType, OrderId value)
        where TBufferWriter : global::System.Buffers.IBufferWriter<byte>
    {
        var baseCodec = writer.Session.CodecProvider.GetCodec<global::System.String>();
        baseCodec.WriteField(ref writer, fieldIdDelta, typeof(global::System.String), value.Value);
    }

    public OrderId ReadValue<TInput>(ref global::Orleans.Serialization.Buffers.Reader<TInput> reader, global::Orleans.Serialization.WireProtocol.Field field)
    {
        var baseCodec = reader.Session.CodecProvider.GetCodec<global::System.String>();
        var baseValue = baseCodec.ReadValue(ref reader, field);
        return UnsafeDeserialize(default, baseValue);
    }
    
    [global::System.Runtime.CompilerServices.UnsafeAccessor(global::System.Runtime.CompilerServices.UnsafeAccessorKind.StaticMethod, Name = "__Deserialize")]
    static extern OrderId UnsafeDeserialize(OrderId @this, global::System.String value);      
    
}

public sealed class OrderIdOrleansCopier : global::Orleans.Serialization.Cloning.IDeepCopier<OrderId>
{
    public OrderId DeepCopy(OrderId input, global::Orleans.Serialization.Cloning.CopyContext context)
    {
        
        return OrderId.From(input.Value);
    }
}

public class OrderIdOrleansProvider : global::Orleans.Serialization.Configuration.TypeManifestProviderBase
{
    protected override void ConfigureInner(global::Orleans.Serialization.Configuration.TypeManifestOptions config)
    {
        config.Serializers.Add(typeof(OrderIdOrleansSerializer));
        config.Copiers.Add(typeof(OrderIdOrleansCopier));
    }
}

[ReubenBond]

The behavior in Orleans is correct here: only value types can be T in Nullable<T>, since it has a struct constraint. Still, I understand that being able to serialize these 'value objects' as their underlying type is attractive. It's possible the logic in NullableCodec<T> could be modified to pass-thru non-null references to the underlying codec. It would likely come at some efficiency cost (eg, copying the Reader<T> struct prior to calling ReadVarUInt32())