@@ -11,11 +11,11 @@
 
 namespace Npgsql.BackendMessages;
 
-readonly struct ColumnInfo(PgConverterInfo converterInfo, DataFormat dataFormat, bool asObject)
+readonly struct ReadConversionContext(PgConcreteTypeInfo typeInfo, PgFieldBinding binding)
 {
-    public PgConverterInfo ConverterInfo { get; } = converterInfo;
-    public DataFormat DataFormat { get; } = dataFormat;
-    public bool AsObject { get; } = asObject;
+    public bool IsDefault => TypeInfo is null;
+    public PgConcreteTypeInfo TypeInfo { get; } = typeInfo;
+    public PgFieldBinding Binding { get; } = binding;
 }
 
 /// <summary>
@@ -36,7 +36,7 @@ sealed class RowDescriptionMessage : IBackendMessage
     FieldDescription?[] _fields;
     readonly Dictionary<string, int> _nameIndex;
     Dictionary<string, int>? _insensitiveIndex;
-    ColumnInfo[]? _lastConverterInfoCache;
+    ReadConversionContext[]? _lastConverterInfoCache;
 
     internal RowDescriptionMessage(bool connectorOwned, int numFields = 10)
     {
@@ -135,14 +135,18 @@ public FieldDescription this[int ordinal]
         }
     }
 
-    internal void SetColumnInfoCache(ReadOnlySpan<ColumnInfo> values)
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    internal void GetConversionContext(int ordinal, Type type, ref ReadConversionContext result)
+        => this[ordinal].GetConversionContext(type, ref result);
+
+    internal void SetColumnInfoCache(ReadOnlySpan<ReadConversionContext> values)
     {
         if (_connectorOwned || _lastConverterInfoCache is not null)
             return;
         Interlocked.CompareExchange(ref _lastConverterInfoCache, values.ToArray(), null);
     }
 
-    internal void LoadColumnInfoCache(PgSerializerOptions options, ColumnInfo[] values)
+    internal void LoadColumnInfoCache(PgSerializerOptions options, ReadConversionContext[] values)
     {
         if (_lastConverterInfoCache is not { } cache)
             return;
@@ -232,7 +236,7 @@ internal FieldDescription(FieldDescription source)
         DataFormat = source.DataFormat;
         PostgresType = source.PostgresType;
         Field = source.Field;
-        _objectInfo = source._objectInfo;
+        _objectConversionContext = source._objectConversionContext;
     }
 
     internal void Populate(
@@ -250,7 +254,7 @@ internal void Populate(
         DataFormat = dataFormat;
         PostgresType = _serializerOptions.DatabaseInfo.FindPostgresType((Oid)TypeOID)?.GetRepresentationalType() ?? UnknownBackendType.Instance;
         Field = new(Name, _serializerOptions.ToCanonicalTypeId(PostgresType), TypeModifier);
-        _objectInfo = default;
+        _objectConversionContext = default;
     }
 
     /// <summary>
@@ -290,25 +294,35 @@ internal void Populate(
     /// </summary>
     internal DataFormat DataFormat { get; set; }
 
+    /// <summary>
+    /// Whether this field's data was requested in text format because the user opted into UnknownResultType
+    /// (via NpgsqlCommand.UnknownResultTypeList or AllResultTypesAreUnknown). Bindings for such fields are
+    /// expected to reinterpret the text bytes through a converter that could potentially only support binary formats.
+    /// </summary>
+    /// <remarks>
+    /// DataFormat.Text today exclusively signals that we executed with an UnknownResultTypeList.
+    /// If we ever want to fully support DataFormat.Text we'll need to flow UnknownResultType status separately.
+    /// </remarks>
+    internal bool IsUnknownResultType => DataFormat is DataFormat.Text;
+
     internal Field Field { get; private set; }
 
     internal string TypeDisplayName => PostgresType.GetDisplayNameWithFacets(TypeModifier);
 
     internal PostgresType PostgresType { get; private set; }
 
-    internal Type FieldType => ObjectInfo.TypeToConvert;
+    internal Type FieldType => ObjectConversionContext.TypeInfo.Type;
 
-    ColumnInfo _objectInfo;
-    internal PgConverterInfo ObjectInfo
+    ReadConversionContext _objectConversionContext;
+    internal ReadConversionContext ObjectConversionContext
     {
         get
         {
-            if (!_objectInfo.ConverterInfo.IsDefault)
-                return _objectInfo.ConverterInfo;
+            if (!_objectConversionContext.IsDefault)
+                return _objectConversionContext;
 
-            ref var info = ref _objectInfo;
-            GetInfoCore(null, ref _objectInfo);
-            return info.ConverterInfo;
+            GetInfoAndBind(null, ref _objectConversionContext);
+            return _objectConversionContext;
         }
     }
 
@@ -320,84 +334,74 @@ internal FieldDescription Clone()
         return field;
     }
 
-    internal void GetInfo(Type type, ref ColumnInfo lastColumnInfo) => GetInfoCore(type, ref lastColumnInfo);
-    void GetInfoCore(Type? type, ref ColumnInfo lastColumnInfo)
+    internal void GetConversionContext(Type type, ref ReadConversionContext result) => GetInfoAndBind(type, ref result);
+    void GetInfoAndBind(Type? type, ref ReadConversionContext result)
     {
-        Debug.Assert(lastColumnInfo.ConverterInfo.IsDefault || (
-            ReferenceEquals(_serializerOptions, lastColumnInfo.ConverterInfo.TypeInfo.Options) && (
-                IsUnknownResultType() && lastColumnInfo.ConverterInfo.TypeInfo.PgTypeId == _serializerOptions.TextPgTypeId ||
+        Debug.Assert(result.IsDefault || (
+            ReferenceEquals(_serializerOptions, result.TypeInfo.Options) && (
+                IsUnknownResultType && result.TypeInfo.PgTypeId == _serializerOptions.TextPgTypeId ||
                 // Normal resolution
-                lastColumnInfo.ConverterInfo.TypeInfo.PgTypeId == _serializerOptions.ToCanonicalTypeId(PostgresType))
+                result.TypeInfo.PgTypeId == _serializerOptions.ToCanonicalTypeId(PostgresType))
             ), "Cache is bleeding over");
 
-        if (!lastColumnInfo.ConverterInfo.IsDefault && lastColumnInfo.ConverterInfo.TypeToConvert == type)
+        if (result is { IsDefault: false, TypeInfo.Type: var typeToConvert } && typeToConvert == type)
             return;
 
-        var objectInfo = DataFormat is DataFormat.Text && type is not null ? ObjectInfo : _objectInfo.ConverterInfo;
-        if (objectInfo is { IsDefault: false })
+        var objectInfo = DataFormat is DataFormat.Text && type is not null ? ObjectConversionContext : _objectConversionContext;
+        if (objectInfo.TypeInfo is not null && (typeof(object) == type || objectInfo.TypeInfo.Type == type))
         {
-            if (typeof(object) == type)
-            {
-                lastColumnInfo = new(objectInfo, DataFormat, true);
-                return;
-            }
-            if (objectInfo.TypeToConvert == type)
-            {
-                // As TypeInfoMappingCollection is always adding object mappings for
-                // default/datatypename mappings, we'll also check Converter.TypeToConvert.
-                // If we have an exact match we are still able to use e.g. a converter for ints in an unboxed fashion.
-                lastColumnInfo = new(objectInfo, DataFormat, objectInfo.IsBoxingConverter && objectInfo.Converter.TypeToConvert != type);
-                return;
-            }
+            result = objectInfo;
+            return;
         }
 
-        GetInfoSlow(type, out lastColumnInfo);
+        Core(type, out result);
+        if (!result.IsDefault && result.Binding.DataFormat != DataFormat)
+            ThrowHelper.ThrowInvalidOperationException(
+                $"Binding for column '{Name}' produced format '{result.Binding.DataFormat}' but the field format is '{DataFormat}'.");
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        void GetInfoSlow(Type? type, out ColumnInfo lastColumnInfo)
+        void Core(Type? type, out ReadConversionContext lastReadConversionContext)
         {
-            PgConverterInfo converterInfo;
+            PgFieldBinding binding;
             switch (DataFormat)
             {
-            case DataFormat.Text when IsUnknownResultType():
+            case DataFormat.Text when IsUnknownResultType:
             {
-                // Try to resolve some 'pg_catalog.text' type info for the expected clr type.
+                // Resolve the converter against pg_catalog.text, UnknownResultType reads text bytes
+                // for any column type. Every pg_catalog.text mapping we own declares text-format support, so a converter that
+                // can't bind to text here throws and surfaces as a missing mapping rather than getting silently reinterpreted.
                 var typeInfo = AdoSerializerHelpers.GetTypeInfoForReading(type ?? typeof(string), _serializerOptions.TextPgTypeId, _serializerOptions);
+                var concreteTypeInfo = typeInfo.MakeConcreteForField(Field);
+                if (!concreteTypeInfo.SupportsReading)
+                    AdoSerializerHelpers.ThrowReadingNotSupported(type, _serializerOptions, _serializerOptions.TextPgTypeId, resolved: true);
 
-                // We start binding to DataFormat.Binary as it's the broadest supported format.
-                // The format however is irrelevant as 'pg_catalog.text' data is identical across either.
-                // Given we did a resolution against 'pg_catalog.text' and not the actual field type we're in reinterpretation territory anyway.
-                if (!typeInfo.TryBind(Field, DataFormat.Binary, out converterInfo))
-                    converterInfo = typeInfo.Bind(Field, DataFormat.Text);
-
-                lastColumnInfo = new(converterInfo, DataFormat, type != converterInfo.TypeToConvert || converterInfo.IsBoxingConverter);
-
+                binding = concreteTypeInfo.BindField(DataFormat.Text);
+                lastReadConversionContext = new(concreteTypeInfo, binding);
                 break;
             }
             case DataFormat.Binary or DataFormat.Text:
             {
                 var typeInfo = AdoSerializerHelpers.GetTypeInfoForReading(type ?? typeof(object), _serializerOptions.ToCanonicalTypeId(PostgresType), _serializerOptions);
+                var concreteTypeInfo = typeInfo.MakeConcreteForField(Field);
+                if (!concreteTypeInfo.SupportsReading)
+                    AdoSerializerHelpers.ThrowReadingNotSupported(type, _serializerOptions, _serializerOptions.ToCanonicalTypeId(PostgresType), resolved: true);
 
                 // If we don't support the DataFormat we'll just throw.
-                converterInfo = typeInfo.Bind(Field, DataFormat);
-                lastColumnInfo = new(converterInfo, DataFormat, typeof(object) == type || converterInfo.IsBoxingConverter);
+                binding = concreteTypeInfo.BindField(DataFormat);
+                lastReadConversionContext = new(concreteTypeInfo, binding);
                 break;
             }
             default:
                 ThrowHelper.ThrowUnreachableException("Unknown data format {0}", DataFormat);
-                lastColumnInfo = default;
+                lastReadConversionContext = default;
                 break;
             }
 
             // We delay initializing ObjectOrDefaultInfo until after the first lookup (unless it is itself the first lookup).
             // When passed in an unsupported type it allows the error to be more specific, instead of just having object/null to deal with.
-            if (_objectInfo.ConverterInfo.IsDefault && type is not null)
-                _ = ObjectInfo;
+            if (_objectConversionContext.TypeInfo is null && type is not null)
+                _ = ObjectConversionContext;
         }
-
-        // DataFormat.Text today exclusively signals that we executed with an UnknownResultTypeList.
-        // If we ever want to fully support DataFormat.Text we'll need to flow UnknownResultType status separately.
-        bool IsUnknownResultType() => DataFormat is DataFormat.Text;
     }
 
     /// <summary>
 
@@ -15,23 +15,12 @@ public static PgTypeInfo GetTypeInfoForReading(Type type, PgTypeId pgTypeId, PgS
         try
         {
             typeInfo = options.GetTypeInfoInternal(type, pgTypeId);
-            if (typeInfo is { SupportsReading: false })
-                typeInfo = null;
         }
         catch (Exception ex)
         {
             inner = ex;
         }
         return typeInfo ?? ThrowReadingNotSupported(type, options, pgTypeId, inner);
-
-        // InvalidCastException thrown to align with ADO.NET convention.
-        [DoesNotReturn]
-        static PgTypeInfo ThrowReadingNotSupported(Type? type, PgSerializerOptions options, PgTypeId pgTypeId, Exception? inner = null)
-        {
-            throw new InvalidCastException(
-                $"Reading{(type is null ? "" : $" as '{type.FullName}'")} is not supported for fields having DataTypeName '{options.DatabaseInfo.FindPostgresType(pgTypeId)?.DisplayName ?? "unknown"}'",
-                inner);
-        }
     }
 
     public static PgTypeInfo GetTypeInfoForWriting(Type? type, PgTypeId? pgTypeId, PgSerializerOptions options, NpgsqlDbType? npgsqlDbType = null)
@@ -43,27 +32,40 @@ public static PgTypeInfo GetTypeInfoForWriting(Type? type, PgTypeId? pgTypeId, P
         try
         {
             typeInfo = options.GetTypeInfoInternal(type, pgTypeId);
-            if (typeInfo is { SupportsWriting: false })
-                typeInfo = null;
         }
         catch (Exception ex)
         {
             inner = ex;
         }
-        return typeInfo ?? ThrowWritingNotSupported(type, options, pgTypeId, npgsqlDbType, inner);
+        return typeInfo ?? ThrowWritingNotSupported(type, options, pgTypeId, npgsqlDbType, inner: inner);
+    }
 
-        // InvalidCastException thrown to align with ADO.NET convention.
-        [DoesNotReturn]
-        static PgTypeInfo ThrowWritingNotSupported(Type? type, PgSerializerOptions options, PgTypeId? pgTypeId, NpgsqlDbType? npgsqlDbType, Exception? inner = null)
-        {
-            var pgTypeString = pgTypeId is null
-                ? "no NpgsqlDbType or DataTypeName. Try setting one of these values to the expected database type."
-                : npgsqlDbType is null
-                    ? $"DataTypeName '{options.DatabaseInfo.FindPostgresType(pgTypeId.GetValueOrDefault())?.DisplayName ?? "unknown"}'"
-                    : $"NpgsqlDbType '{npgsqlDbType}'";
+    // InvalidCastException thrown to align with ADO.NET convention.
+    // resolved=true distinguishes the "resolution succeeded but the resolved converter opted out of this
+    // direction" case (e.g. read-only converters) from the "no converter could be found / resolution threw"
+    // case — important for diagnosing user reports.
+    [DoesNotReturn]
+    internal static PgTypeInfo ThrowReadingNotSupported(Type? type, PgSerializerOptions options, PgTypeId pgTypeId, Exception? inner = null, bool resolved = false)
+    {
+        var typeFragment = type is null ? "" : $" as '{type.FullName}'{(resolved ? " (resolved)" : "")}";
+        var dataTypeNameFragment = $"DataTypeName '{options.DatabaseInfo.FindPostgresType(pgTypeId)?.DisplayName ?? "unknown"}'";
+        var innerHint = inner is null ? "" : " See the inner exception for details.";
 
-            throw new InvalidCastException(
-                $"Writing{(type is null ? "" : $" values of '{type.FullName}'")} is not supported for parameters having {pgTypeString}.", inner);
-        }
+        throw new InvalidCastException($"Reading{typeFragment} is not supported for fields having {dataTypeNameFragment}.{innerHint}", inner);
+    }
+
+    [DoesNotReturn]
+    internal static PgTypeInfo ThrowWritingNotSupported(Type? type, PgSerializerOptions options, PgTypeId? pgTypeId, NpgsqlDbType? npgsqlDbType = null, string? parameterName = null, Exception? inner = null, bool resolved = false)
+    {
+        var pgTypeFragment = pgTypeId is null
+            ? "no NpgsqlDbType or DataTypeName. Try setting one of these values to the expected database type."
+            : npgsqlDbType is null
+                ? $"DataTypeName '{options.DatabaseInfo.FindPostgresType(pgTypeId.GetValueOrDefault())?.DisplayName ?? "unknown"}'"
+                : $"NpgsqlDbType '{npgsqlDbType}'";
+        var parameterFragment = parameterName is null ? "parameters" : $"parameter '{parameterName}'";
+        var typeFragment = type is null ? "" : $" values of type '{type.FullName}'{(resolved ? " (resolved)" : "")}";
+        var innerHint = inner is null ? "" : " See the inner exception for details.";
+
+        throw new InvalidCastException($"Writing{typeFragment} is not supported for {parameterFragment} having {pgTypeFragment}.{innerHint}", inner);
     }
 }