diff --git a/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/NpgsqlStringEnumTypeMappingSourcePlugin.cs b/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/NpgsqlStringEnumTypeMappingSourcePlugin.cs
index da37450..1ba0445 100644
--- a/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/NpgsqlStringEnumTypeMappingSourcePlugin.cs
+++ b/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/NpgsqlStringEnumTypeMappingSourcePlugin.cs
@@ -10,16 +10,29 @@ namespace StrEnum.Npgsql.EntityFrameworkCore.Internal;
 ///   <item>property metadata — when EF passes a <c>storeType</c> (set by
 ///     <c>HasPostgresStringEnum&lt;TEnum&gt;()</c> on the property or
 ///     <c>MapStringEnumAsPostgresEnum&lt;TEnum&gt;()</c> on the model);</item>
-///   <item><see cref="StringEnumPgTypeRegistry"/> — on the raw-SQL parameter path
-///     (<c>DatabaseFacade.ExecuteSqlRawAsync(sql, object[])</c>), where EF asks for a mapping by
-///     CLR type alone and there is no property to carry the store type.</item>
+///   <item>the enums registered up-front through <see cref="StringEnumPostgresEnumRegistrar"/> — on
+///     the raw-SQL parameter path (<c>DatabaseFacade.ExecuteSqlRawAsync(sql, object[])</c>), where EF
+///     asks for a mapping by CLR type alone and there is no property to carry the store type.</item>
 /// </list>
 /// Plugins are consulted *before* EFCore.PG's built-in <c>NpgsqlTypeMappingSource</c>, so this is
 /// the hook that prevents EF from falling back to <c>NpgsqlStringTypeMapping</c> (which would force
 /// <c>NpgsqlDbType.Text</c> on the parameter and break the wire-level enum binding).
 /// </summary>
+/// <remarks>
+/// Registrations are held per service provider, not process-wide. EF Core memoises the first
+/// <c>FindMapping(typeof(TEnum), storeType: null)</c> result in a cache owned by the service provider,
+/// so shared state lets one context's miss — or another context's differently named enum — be served
+/// to a context that registered its own.
+/// </remarks>
 internal sealed class NpgsqlStringEnumTypeMappingSourcePlugin : IRelationalTypeMappingSourcePlugin
 {
+    private readonly IReadOnlyDictionary<string, string> _registrations;
+
+    public NpgsqlStringEnumTypeMappingSourcePlugin(IReadOnlyDictionary<string, string> registrations)
+    {
+        _registrations = registrations;
+    }
+
     public RelationalTypeMapping? FindMapping(in RelationalTypeMappingInfo mappingInfo)
     {
         var clrType = mappingInfo.ClrType;
@@ -31,7 +44,7 @@ internal sealed class NpgsqlStringEnumTypeMappingSourcePlugin : IRelationalTypeM
             return null;
 
         var storeType = mappingInfo.StoreTypeName;
-        if (storeType is null && !StringEnumPgTypeRegistry.TryGetPgTypeName(clrType, out storeType))
+        if (storeType is null && !_registrations.TryGetValue(StringEnumPgTypeKey.For(clrType), out storeType))
             return null;
 
         var mappingType = typeof(NpgsqlStringEnumTypeMapping<>).MakeGenericType(clrType);
diff --git a/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StrEnumNpgsqlOptionsExtension.cs b/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StrEnumNpgsqlOptionsExtension.cs
index 8505b64..1926af4 100644
--- a/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StrEnumNpgsqlOptionsExtension.cs
+++ b/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StrEnumNpgsqlOptionsExtension.cs
@@ -35,7 +35,8 @@ public StrEnumNpgsqlOptionsExtension(IReadOnlyDictionary<string, string> registr
 
     public void ApplyServices(IServiceCollection services)
     {
-        services.AddSingleton<IRelationalTypeMappingSourcePlugin, NpgsqlStringEnumTypeMappingSourcePlugin>();
+        services.AddSingleton<IRelationalTypeMappingSourcePlugin>(
+            new NpgsqlStringEnumTypeMappingSourcePlugin(Registrations));
     }
 
     public void Validate(IDbContextOptions options) { }
diff --git a/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StringEnumPgTypeKey.cs b/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StringEnumPgTypeKey.cs
new file mode 100644
index 0000000..652088b
--- /dev/null
+++ b/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StringEnumPgTypeKey.cs
@@ -0,0 +1,9 @@
+namespace StrEnum.Npgsql.EntityFrameworkCore.Internal;
+
+/// <summary>
+/// Keys a <see cref="StringEnum{TEnum}"/> CLR type in the per-service-provider registration map.
+/// </summary>
+internal static class StringEnumPgTypeKey
+{
+    public static string For(Type clrType) => clrType.AssemblyQualifiedName ?? clrType.FullName!;
+}
diff --git a/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StringEnumPgTypeRegistry.cs b/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StringEnumPgTypeRegistry.cs
deleted file mode 100644
index 4de0685..0000000
--- a/src/StrEnum.Npgsql.EntityFrameworkCore/Internal/StringEnumPgTypeRegistry.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-using System.Collections.Concurrent;
-
-namespace StrEnum.Npgsql.EntityFrameworkCore.Internal;
-
-/// <summary>
-/// Process-wide registry mapping a <see cref="StringEnum{TEnum}"/> CLR type to the Postgres enum
-/// type name that <see cref="ModelBuilderExtensions.MapStringEnumAsPostgresEnum{TEnum}"/> or the
-/// model-level <see cref="ModelBuilderExtensions.HasPostgresStringEnum{TEnum}"/> registered for it.
-/// Consulted by <see cref="NpgsqlStringEnumTypeMappingSourcePlugin"/> when EF Core asks for a
-/// mapping by CLR type alone — i.e. on the raw-SQL parameter path
-/// (<c>DatabaseFacade.ExecuteSqlRawAsync(sql, object[])</c>), where there is no property metadata
-/// and therefore no <c>storeType</c> to drive the mapping.
-/// </summary>
-/// <remarks>
-/// State is process-wide because EF Core type-mapping plugins are stateless from EF's perspective
-/// and have no access to the model. Within a process, a given <see cref="StringEnum{TEnum}"/> type
-/// is expected to map to a single Postgres enum — mapping the same CLR type to different enum
-/// names across multiple DbContexts in one process is not supported.
-/// </remarks>
-internal static class StringEnumPgTypeRegistry
-{
-    private static readonly ConcurrentDictionary<Type, string> _map = new();
-
-    public static void Register(Type clrType, string pgTypeName)
-    {
-        if (clrType is null) throw new ArgumentNullException(nameof(clrType));
-        if (pgTypeName is null) throw new ArgumentNullException(nameof(pgTypeName));
-
-        _map[clrType] = pgTypeName;
-    }
-
-    public static bool TryGetPgTypeName(Type clrType, out string? pgTypeName)
-    {
-        if (_map.TryGetValue(clrType, out var found))
-        {
-            pgTypeName = found;
-            return true;
-        }
-
-        pgTypeName = null;
-        return false;
-    }
-}
diff --git a/src/StrEnum.Npgsql.EntityFrameworkCore/ModelBuilderExtensions.cs b/src/StrEnum.Npgsql.EntityFrameworkCore/ModelBuilderExtensions.cs
index 33e5546..712b85e 100644
--- a/src/StrEnum.Npgsql.EntityFrameworkCore/ModelBuilderExtensions.cs
+++ b/src/StrEnum.Npgsql.EntityFrameworkCore/ModelBuilderExtensions.cs
@@ -22,12 +22,6 @@ public static ModelBuilder HasPostgresStringEnum<TEnum>(this ModelBuilder modelB
 
         var labels = StringEnumLabels.For<TEnum>();
         var enumName = name ?? PostgresNaming.ToSnakeCase(typeof(TEnum).Name);
-        var pgTypeName = schema is null ? enumName : $"{schema}.{enumName}";
-
-        // Register in the process-wide CLR-type → PG-type-name map so the EF Core type-mapping
-        // plugin can resolve the store type on the raw-SQL parameter path, where there's no
-        // property metadata to carry it.
-        StringEnumPgTypeRegistry.Register(typeof(TEnum), pgTypeName);
 
         return modelBuilder.HasPostgresEnum(schema, enumName, labels);
     }
diff --git a/src/StrEnum.Npgsql.EntityFrameworkCore/StringEnumPostgresEnumRegistrar.cs b/src/StrEnum.Npgsql.EntityFrameworkCore/StringEnumPostgresEnumRegistrar.cs
index f73d262..b0cf17a 100644
--- a/src/StrEnum.Npgsql.EntityFrameworkCore/StringEnumPostgresEnumRegistrar.cs
+++ b/src/StrEnum.Npgsql.EntityFrameworkCore/StringEnumPostgresEnumRegistrar.cs
@@ -38,8 +38,9 @@ public StringEnumPostgresEnumRegistrar MapStringEnum<TEnum>(string? name = null,
     {
         var enumName = name ?? PostgresNaming.ToSnakeCase(typeof(TEnum).Name);
         var pgTypeName = schema is null ? enumName : $"{schema}.{enumName}";
-        StringEnumPgTypeRegistry.Register(typeof(TEnum), pgTypeName);
-        _registrations[typeof(TEnum).AssemblyQualifiedName ?? typeof(TEnum).FullName!] = pgTypeName;
+
+        _registrations[StringEnumPgTypeKey.For(typeof(TEnum))] = pgTypeName;
+
         return this;
     }
 }
diff --git a/test/StrEnum.Npgsql.EntityFrameworkCore.IntegrationTests/RawSqlEnumParameterTests.cs b/test/StrEnum.Npgsql.EntityFrameworkCore.IntegrationTests/RawSqlEnumParameterTests.cs
index f3e23bc..b3aec93 100644
--- a/test/StrEnum.Npgsql.EntityFrameworkCore.IntegrationTests/RawSqlEnumParameterTests.cs
+++ b/test/StrEnum.Npgsql.EntityFrameworkCore.IntegrationTests/RawSqlEnumParameterTests.cs
@@ -10,7 +10,7 @@ namespace StrEnum.Npgsql.EntityFrameworkCore.IntegrationTests;
 /// Verifies that <see cref="StringEnum{TEnum}"/> parameters bind to native Postgres enum columns on
 /// the raw-SQL path — <c>DatabaseFacade.ExecuteSqlRawAsync(sql, object[])</c> — where EF Core has
 /// no property metadata to carry the column type. Without the
-/// <see cref="Internal.StringEnumPgTypeRegistry"/> fallback, EF would fall through to
+/// up-front registration, EF would fall through to
 /// <c>NpgsqlStringTypeMapping</c>, pin the parameter to <c>NpgsqlDbType.Text</c>, and the server
 /// would reject the UPDATE with <c>42804: column "x" is of type sport but expression is of type
 /// text</c>.
diff --git a/test/StrEnum.Npgsql.EntityFrameworkCore.UnitTests/NpgsqlStringEnumTypeMappingSourcePluginTests.cs b/test/StrEnum.Npgsql.EntityFrameworkCore.UnitTests/NpgsqlStringEnumTypeMappingSourcePluginTests.cs
index 3e38661..bce3382 100644
--- a/test/StrEnum.Npgsql.EntityFrameworkCore.UnitTests/NpgsqlStringEnumTypeMappingSourcePluginTests.cs
+++ b/test/StrEnum.Npgsql.EntityFrameworkCore.UnitTests/NpgsqlStringEnumTypeMappingSourcePluginTests.cs
@@ -18,10 +18,13 @@ public class UnregisteredEnum : StringEnum<UnregisteredEnum>
         public static readonly UnregisteredEnum One = Define("ONE");
     }
 
+    private static NpgsqlStringEnumTypeMappingSourcePlugin CreatePlugin(params (Type ClrType, string PgTypeName)[] registrations)
+        => new(registrations.ToDictionary(r => StringEnumPgTypeKey.For(r.ClrType), r => r.PgTypeName));
+
     [Fact]
     public void FindMapping_ReturnsNpgsqlStringEnumTypeMapping_ForStringEnumWithStoreType()
     {
-        var plugin = new NpgsqlStringEnumTypeMappingSourcePlugin();
+        var plugin = CreatePlugin();
         var info = new RelationalTypeMappingInfo(typeof(Sport), storeTypeName: "sport", unicode: null, size: null, precision: null, scale: null);
 
         var mapping = plugin.FindMapping(info);
@@ -32,11 +35,9 @@ public void FindMapping_ReturnsNpgsqlStringEnumTypeMapping_ForStringEnumWithStor
     }
 
     [Fact]
-    public void FindMapping_FallsBackToRegistry_WhenStoreTypeIsMissing()
+    public void FindMapping_FallsBackToTheRegisteredEnums_WhenStoreTypeIsMissing()
     {
-        StringEnumPgTypeRegistry.Register(typeof(Sport), "races.sport_kind");
-
-        var plugin = new NpgsqlStringEnumTypeMappingSourcePlugin();
+        var plugin = CreatePlugin((typeof(Sport), "races.sport_kind"));
         var info = new RelationalTypeMappingInfo(typeof(Sport));
 
         var mapping = plugin.FindMapping(info);
@@ -49,7 +50,7 @@ public void FindMapping_FallsBackToRegistry_WhenStoreTypeIsMissing()
     [Fact]
     public void FindMapping_ReturnsNull_WhenStoreTypeIsMissingAndNoRegistration()
     {
-        var plugin = new NpgsqlStringEnumTypeMappingSourcePlugin();
+        var plugin = CreatePlugin();
         var info = new RelationalTypeMappingInfo(typeof(UnregisteredEnum));
 
         plugin.FindMapping(info).Should().BeNull();
@@ -58,7 +59,7 @@ public void FindMapping_ReturnsNull_WhenStoreTypeIsMissingAndNoRegistration()
     [Fact]
     public void FindMapping_ReturnsNull_ForNonStringEnumClrType()
     {
-        var plugin = new NpgsqlStringEnumTypeMappingSourcePlugin();
+        var plugin = CreatePlugin();
         var info = new RelationalTypeMappingInfo(typeof(string), storeTypeName: "sport", unicode: null, size: null, precision: null, scale: null);
 
         plugin.FindMapping(info).Should().BeNull();