@@ -28,6 +28,7 @@ public class MapFieldCodegenTests
         { "field.string": { "name": "name", "@required": true } },
         { "field.map":    { "name": "labels", "@valueType": "string" } },
         { "field.map":    { "name": "addresses", "@objectRef": "Address" } },
+        { "field.map":    { "name": "channels", "@valueType": "string", "@required": true } },
         { "identity.primary": { "@fields": "id" } }
       ]}}
     ]}}
@@ -55,9 +56,17 @@ public void Scalar_valued_map_emits_a_string_value_dictionary()
         var files = new EntityGenerator().Generate(Ctx(Load())).ToList();
         var customer = files.Single(f => f.Path == "Customer.g.cs").Content;
 
-        // @valueType:string → Dictionary<string, string>, [Column]-mapped, never null.
+        // @valueType:string → Dictionary<string, string>, [Column]-mapped. NULLABILITY
+        // FOLLOWS THE COLUMN (ObjectNavProperty's rule): the migration creates a map
+        // column NULLABLE by default, and a non-nullable property over it made EF Core 8
+        // skip the shaper's IsDBNull check — a 500 on every read of a NULL-map row (the
+        // MapNullColumnGeneratedServerTest lane drives that end-to-end). So a
+        // non-required map is NULLABLE with NO initializer (absent stays null, round-trips
+        // as SQL NULL — never silently rewritten to {}), while a @required map keeps the
+        // non-null empty-dictionary initializer.
         Assert.Contains("[Column(CustomerNames.LabelsColumn)]", customer); // §A6 (task 4)
-        Assert.Contains("public Dictionary<string, string> Labels { get; set; } = new();", customer);
+        Assert.Contains("public Dictionary<string, string>? Labels { get; set; }", customer);
+        Assert.Contains("public Dictionary<string, string> Channels { get; set; } = new();", customer);
     }
 
     [Fact]
@@ -66,9 +75,10 @@ public void Object_valued_map_emits_a_value_object_value_dictionary()
         var files = new EntityGenerator().Generate(Ctx(Load())).ToList();
         var customer = files.Single(f => f.Path == "Customer.g.cs").Content;
 
-        // @objectRef:Address → Dictionary<string, Address>; the VO is emitted as a POCO.
+        // @objectRef:Address → Dictionary<string, Address> (nullable — see the scalar test
+        // for the column-following rule); the VO is emitted as a POCO.
         Assert.Contains("[Column(CustomerNames.AddressesColumn)]", customer); // §A6 (task 4)
-        Assert.Contains("public Dictionary<string, Address> Addresses { get; set; } = new();", customer);
+        Assert.Contains("public Dictionary<string, Address>? Addresses { get; set; }", customer);
         Assert.Contains("public class Address", files.Single(f => f.Path == "Address.g.cs").Content);
     }
 
@@ -84,6 +94,13 @@ public void Scalar_valued_map_gets_a_jsonb_storage_mapping_in_the_DbContext()
             "modelBuilder.Entity<Customer>().Property(x => x.Labels).HasColumnType(\"jsonb\")"
                 + ".HasConversion(MapJsonb.Converter<string>(), MapJsonb.Comparer<string>());",
             dbCtx);
+        // The @required map's property is non-null, so its converter is the non-null
+        // factory — EF Core 8's nullability-aware HasConversion checks the converter's
+        // model type against the property's own annotation (a mismatch is CS8620).
+        Assert.Contains(
+            "modelBuilder.Entity<Customer>().Property(x => x.Channels).HasColumnType(\"jsonb\")"
+                + ".HasConversion(MapJsonb.RequiredConverter<string>(), MapJsonb.Comparer<string>());",
+            dbCtx);
     }
 
     [Fact]
@@ -108,8 +125,10 @@ public void Map_jsonb_helper_is_emitted_only_when_a_map_is_present()
         // in-place `entity.Labels["k"] = v` is never detected and the UPDATE never fires --
         // the same silent non-persistence this mapping exists to fix.
         Assert.Contains("private static class MapJsonb", withMap);
-        Assert.Contains("Dictionary<string, TValue>, string> Converter<TValue>()", withMap);
-        Assert.Contains("Dictionary<string, TValue>> Comparer<TValue>()", withMap);
+        // The nullable type arguments match the nullable map property (EF Core 8's
+        // nullability-aware HasConversion expects them; see EmitMapJsonbHelper remarks).
+        Assert.Contains("Dictionary<string, TValue>?, string> Converter<TValue>()", withMap);
+        Assert.Contains("Dictionary<string, TValue>?> Comparer<TValue>()", withMap);
 
         // Equality must be ENTRY-WISE, not a comparison of serialized JSON. JSON string
         // equality is key-ORDER sensitive, so a dictionary rebuilt in a different order would
@@ -156,9 +175,10 @@ public void A_read_only_projection_map_column_also_gets_its_jsonb_mapping()
         """;
         var ctx = Ctx(Load(model, "proj.json"));
 
-        // The property is emitted...
+        // The property is emitted... (nullable, no initializer — the view's map column is
+        // nullable like any other, and a NULL cell must read as null, not 500.)
         var entity = Assert.Single(new EntityGenerator().Generate(ctx)).Content;
-        Assert.Contains("public Dictionary<string, int> Tallies { get; set; } = new();", entity);
+        Assert.Contains("public Dictionary<string, int>? Tallies { get; set; }", entity);
 
         // ...so the storage mapping must be too.
         var dbCtx = Assert.Single(new DbContextGenerator().Generate(ctx)).Content;
 
@@ -115,7 +115,7 @@ public virtual IEnumerable<EmittedFile> Generate(GenContext ctx)
             // explicit mapping makes EF agree with the jsonb column the TS-owned migration
             // creates (ADR-0015).
             foreach (var f in p.Fields().Where(f => f.SubType == FIELD_SUBTYPE_MAP))
-                modelLines.Add(MapJsonbConfig(name, f, ctx));
+                modelLines.Add(MapJsonbConfig(name, p, f, ctx));
         }
         foreach (var e in objects.Where(o => o.IsEntity() && !o.IsReadOnlyProjection()))
         {
@@ -641,9 +641,9 @@ private static void EmitUnmappedEnumHelper(StringBuilder sb)
     /// (<see cref="EmitFieldTypeConfig"/>) and the read-only-projection path, which both emit
     /// a <c>Dictionary&lt;string, V&gt;</c> property and so both need the mapping.
     /// </summary>
-    private static string MapJsonbConfig(string className, MetaField f, GenContext ctx) =>
+    private static string MapJsonbConfig(string className, MetaObject owner, MetaField f, GenContext ctx) =>
         $"        modelBuilder.Entity<{className}>().Property(x => x.{CSharpNaming.Pascal(f.Name)})"
-            + MapJsonbSuffix(f, ctx) + ";";
+            + MapJsonbSuffix(owner, f, ctx) + ";";
 
     /// <summary>
     /// The column-type + converter/comparer suffix every <c>field.map</c> mapping ends in, whatever
@@ -652,11 +652,18 @@ private static string MapJsonbConfig(string className, MetaField f, GenContext c
     /// a converter change fixed in one tier only is exactly the failure the flattened tier's old
     /// known-gap entry described.
     /// </summary>
-    private static string MapJsonbSuffix(MetaField f, GenContext ctx)
+    private static string MapJsonbSuffix(MetaObject owner, MetaField f, GenContext ctx)
     {
         var valueType = MapValueTypeRef(f, ctx);
+        // The SAME requiredness predicate the property emission uses (MapProperty), so the
+        // converter's nullability annotation always matches the property it converts: EF Core
+        // 8's nullability-aware HasConversion signature checks the converter's model type
+        // against the property's own annotation, and a mismatch is a CS8620 warning.
+        var converter = CSharpNaming.IsRequired(owner, f)
+            ? $"{MapJsonbHelperName}.RequiredConverter<{valueType}>()"
+            : $"{MapJsonbHelperName}.Converter<{valueType}>()";
         return $".HasColumnType(\"jsonb\").HasConversion("
-            + $"{MapJsonbHelperName}.Converter<{valueType}>(), {MapJsonbHelperName}.Comparer<{valueType}>())";
+            + $"{converter}, {MapJsonbHelperName}.Comparer<{valueType}>())";
     }
 
     /// <summary>Name of the generated jsonb (de)serialization helper the field.map configs use.</summary>
@@ -710,6 +717,12 @@ private static string MapValueTypeRef(MetaField f, GenContext ctx)
     /// <para>Fully qualified throughout: the generated file's usings are a fixed set
     /// (<see cref="EmitUsings"/>), and widening it would change byte-identical output for
     /// every model.</para>
+    /// <para>The converter/comparer type arguments are the NULLABLE dictionary: a
+    /// non-required map's property is nullable (nullability follows the column), and EF
+    /// Core 8's nullability-aware <c>HasConversion</c> signature expects the converter's
+    /// model type to match. Annotation-only — EF passes null through a value converter
+    /// untranslated and never invokes the expressions on it, so the lambdas' bodies are
+    /// unchanged.</para>
     /// </remarks>
     private static void EmitMapJsonbHelper(StringBuilder sb)
     {
@@ -727,14 +740,24 @@ private static void EmitMapJsonbHelper(StringBuilder sb)
         sb.AppendLine("        };");
         sb.AppendLine();
         sb.AppendLine("        internal static Microsoft.EntityFrameworkCore.Storage.ValueConversion.ValueConverter<");
-        sb.AppendLine("            System.Collections.Generic.Dictionary<string, TValue>, string> Converter<TValue>() => new(");
+        sb.AppendLine("            System.Collections.Generic.Dictionary<string, TValue>, string> RequiredConverter<TValue>() => new(");
+        sb.AppendLine("                v => System.Text.Json.JsonSerializer.Serialize(v, Options),");
+        sb.AppendLine("                v => System.Text.Json.JsonSerializer.Deserialize<");
+        sb.AppendLine("                    System.Collections.Generic.Dictionary<string, TValue>>(v, Options)!);");
+        sb.AppendLine();
+        sb.AppendLine("        /// <summary>Same conversion as RequiredConverter, over the NULLABLE dictionary a");
+        sb.AppendLine("        /// non-required map's property carries — keep the two bodies identical. EF Core's");
+        sb.AppendLine("        /// nullability-aware HasConversion checks the converter's model type against the");
+        sb.AppendLine("        /// property's own annotation, so one factory cannot serve both arms.</summary>");
+        sb.AppendLine("        internal static Microsoft.EntityFrameworkCore.Storage.ValueConversion.ValueConverter<");
+        sb.AppendLine("            System.Collections.Generic.Dictionary<string, TValue>?, string> Converter<TValue>() => new(");
         sb.AppendLine("                v => System.Text.Json.JsonSerializer.Serialize(v, Options),");
         sb.AppendLine("                v => System.Text.Json.JsonSerializer.Deserialize<");
         sb.AppendLine("                    System.Collections.Generic.Dictionary<string, TValue>>(v, Options)!);");
         sb.AppendLine();
         sb.AppendLine("        internal static Microsoft.EntityFrameworkCore.ChangeTracking.ValueComparer<");
-        sb.AppendLine("            System.Collections.Generic.Dictionary<string, TValue>> Comparer<TValue>() => new(");
-        sb.AppendLine("                (a, b) => Eq(a, b), v => Hash(v), v => Snap(v)!);");
+        sb.AppendLine("            System.Collections.Generic.Dictionary<string, TValue>?> Comparer<TValue>() => new(");
+        sb.AppendLine("                (a, b) => Eq(a, b), v => Hash(v), v => Snap(v));");
         sb.AppendLine();
         sb.AppendLine("        /// <summary>Order-INDEPENDENT equality: a dictionary rebuilt in a different key");
         sb.AppendLine("        /// order holds the same value, and comparing serialized JSON would call it changed");
@@ -908,7 +931,7 @@ private void EmitFieldTypeConfig(
         // the generated code cannot make on a consumer's behalf. The COMPARER is not optional --
         // see EmitMapJsonbHelper.
         foreach (var f in fieldList.Where(f => f.SubType == FIELD_SUBTYPE_MAP))
-            modelLines.Add(MapJsonbConfig(className, f, ctx));
+            modelLines.Add(MapJsonbConfig(className, entity, f, ctx));
 
         foreach (var f in fieldList.Where(f => f.SubType == FIELD_SUBTYPE_ENUM))
         {
@@ -1114,7 +1137,7 @@ private void EmitFieldTypeConfig(
             if (nf.SubType == FIELD_SUBTYPE_MAP)
             {
                 sb.AppendLine($"            b.Property(p => p.{CSharpNaming.Pascal(nf.Name)})"
-                    + $".HasColumnName(\"{nestedColAny}\")" + MapJsonbSuffix(nf, ctx) + ";");
+                    + $".HasColumnName(\"{nestedColAny}\")" + MapJsonbSuffix(vo, nf, ctx) + ";");
                 continue;
             }
 
 
@@ -1351,18 +1351,30 @@ protected static string EscapeAttrString(string s) =>
     // Dictionary<string, V> property stored in one json column — the map analog of
     // ObjectNavProperty's single-jsonb-column object field. Keys are always strings;
     // V is a value-object (@objectRef) or a scalar (@valueType, defaulting to string).
-    // isArray does not apply (a map is never wrapped in a collection-of-maps), so the
-    // property is a non-null dictionary with an empty-dictionary initializer (matching
-    // the array/enum-array convention — the dictionary itself is never null in C#).
+    // isArray does not apply (a map is never wrapped in a collection-of-maps).
+    // Nullability follows the COLUMN, exactly as ObjectNavProperty's single/array arms
+    // do: the TS-owned migration creates the map column NULLABLE by default (ADR-0015),
+    // and a NULL cell is ordinary cross-port state (a row written by another port or
+    // raw SQL). A NON-nullable property over that column makes EF Core 8 skip the
+    // shaper's IsDBNull check, so every read arm 500s on a single NULL-map row — the
+    // initializer never runs, and MapJsonb's null-guarded comparer sits after the crash
+    // point. So a @required map is a non-null dictionary with an empty-dictionary
+    // initializer, and a non-required map is a NULLABLE dictionary with NO initializer:
+    // an absent value stays null, reads back as null, and round-trips as SQL NULL
+    // rather than being silently rewritten to an empty object (a present {} stays a
+    // distinct empty map).
     // When @objectRef names a value object, the resolved VO becomes a referenced POCO
     // via the normal ReferencedValueObjects walk. withAttributes adds the EF [Column]
     // mapping; value-object POCOs (no EF mapping) pass false.
     protected string MapProperty(MetaObject owner, MetaField field, GenContext ctx, bool withAttributes = true)
     {
         var valueType = CSharpNaming.MapValueType(field);
         var propName = PropertyName(field);
+        var required = CSharpNaming.IsRequired(owner, field);
         var colAttr = withAttributes ? $"    [Column({CSharpNaming.ColumnRef(owner, field, ctx.Config.ColumnNamingStrategy, ctx.Config.IncludeNames)})]\n" : "";
-        return $"{colAttr}    public Dictionary<string, {valueType}> {propName} {{ get; set; }} = new();";
+        return required
+            ? $"{colAttr}    public Dictionary<string, {valueType}> {propName} {{ get; set; }} = new();"
+            : $"{colAttr}    public Dictionary<string, {valueType}>? {propName} {{ get; set; }}";
     }
 
     // The CLR scalar type for a projection field whose value is a MIN/MAX aggregate: