@@ -29,7 +29,9 @@
 //         HasConversion(ValueConverter, ValueComparer) overload, and a generic helper
 //         returning ValueConverter<Dictionary<string,T>,string>. A string-contains test
 //         cannot tell a real overload from a plausible-looking one.
-//   - object.projection ProgramSummary (view-kind source, keyless) → .ToView(...).HasNoKey()
+//   - object.projection ProgramSummary (view-kind source, keyless) → .ToView(...).HasNoKey(),
+//     carrying a field.map so the PROJECTION arm of the map config compiles too — its emitter
+//     is a separate call site from the entity one, and the property is emitted either way
 //   - object.entity Invoice — a #214 WRITE-THROUGH entity (table invoices + replica view
 //     v_invoice_with_client + a derived origin.passthrough clientName): the derived-free
 //     write entity, the view-mapped InvoiceView read model (.ToView), the InvoiceView DbSet,
@@ -90,7 +92,8 @@ public class DbContextCompileTests
       { "object.projection": { "name": "ProgramSummary", "children": [
         { "source.rdb": { "@kind": "view", "@table": "v_program_summary" } },
         { "field.long": { "name": "id" } },
-        { "field.int":  { "name": "weekCount" } }
+        { "field.int":  { "name": "weekCount" } },
+        { "field.map":  { "name": "tallies", "@valueType": "int" } }
       ]}},
       { "object.entity": { "name": "Client", "children": [
         { "source.rdb": { "@kind": "table", "@table": "clients" } },
 
@@ -133,6 +133,45 @@ public void Map_jsonb_helper_is_emitted_only_when_a_map_is_present()
         Assert.DoesNotContain("MapJsonb", without);
     }
 
+    [Fact]
+    public void A_read_only_projection_map_column_also_gets_its_jsonb_mapping()
+    {
+        // EntityGenerator emits the Dictionary property for a PROJECTION too, but the
+        // DbContext's projection loop emits only ToView + enum conversions — so a view
+        // exposing a field.map got a Dictionary property with no mapping at all. That is
+        // exactly the failure this whole mapping exists to prevent: a Dictionary<string,int>
+        // binds to nothing on Npgsql, so AppDbContext fails model building.
+        const string model = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.projection": { "name": "CustomerSummary", "children": [
+            { "source.rdb": { "@kind": "view", "@table": "v_customer_summary" } },
+            { "field.long":   { "name": "id" } },
+            { "field.map":    { "name": "tallies", "@valueType": "int" } }
+          ]}}
+        ]}}
+        """;
+        var r = new MetaDataLoader().Load([new InMemoryStringSource(model, id: "proj.json")]);
+        Assert.Empty(r.Errors);
+        var ctx = new GenContext
+        {
+            Entities = r.Root.Objects(), Root = r.Root,
+            Config = new GenConfig { OutDir = "/tmp", Namespace = "Acme.Generated" },
+        };
+
+        // The property is emitted...
+        var entity = Assert.Single(new EntityGenerator().Generate(ctx)).Content;
+        Assert.Contains("public Dictionary<string, int> Tallies { get; set; } = new();", entity);
+
+        // ...so the storage mapping must be too.
+        var dbCtx = Assert.Single(new DbContextGenerator().Generate(ctx)).Content;
+        Assert.Contains(
+            "modelBuilder.Entity<CustomerSummary>().Property(x => x.Tallies).HasColumnType(\"jsonb\")"
+                + ".HasConversion(MapJsonb.Converter<int>(), MapJsonb.Comparer<int>());",
+            dbCtx);
+        // ...and the helper it names must be declared, or the generated file will not compile.
+        Assert.Contains("private static class MapJsonb", dbCtx);
+    }
+
     [Fact]
     public void Generated_entities_and_value_objects_compile_together()
     {
 
@@ -109,6 +109,13 @@ public virtual IEnumerable<EmittedFile> Generate(GenContext ctx)
             // a string would fail materialization exactly as the ordinal default does here.
             foreach (var f in p.Fields().Where(f => f.SubType == FIELD_SUBTYPE_ENUM && !f.ResolvedIsArray()))
                 modelLines.Add($"        modelBuilder.Entity<{name}>().Property(x => x.{CSharpNaming.Pascal(f.Name)}).{EnumConversionCall(name, p, f, ctx.Config)};");
+            // A field.map column on a view needs its jsonb mapping for the SAME reason:
+            // EntityGenerator emits the Dictionary property for a projection too, and an
+            // unmapped Dictionary<string,int> binds to nothing on Npgsql, so the model fails
+            // to build. This loop and EmitFieldTypeConfig's are the two call sites
+            // NeedsMapJsonbHelper has to cover.
+            foreach (var f in p.Fields().Where(f => f.SubType == FIELD_SUBTYPE_MAP))
+                modelLines.Add(MapJsonbConfig(name, f, ctx));
         }
         foreach (var e in objects.Where(o => o.IsEntity() && !o.IsReadOnlyProjection()))
         {
@@ -622,6 +629,20 @@ private static void EmitUnmappedEnumHelper(StringBuilder sb)
         sb.AppendLine("            \"@intValueMap — the database holds a value the model does not describe.\");");
     }
 
+    /// <summary>
+    /// The EF config line pinning one <c>field.map</c> to its jsonb column: the column type
+    /// plus the shared converter/comparer pair. Shared by the entity/write-through path
+    /// (<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)
+    {
+        var valueType = MapValueTypeRef(f, ctx);
+        return $"        modelBuilder.Entity<{className}>().Property(x => x.{CSharpNaming.Pascal(f.Name)})"
+            + $".HasColumnType(\"jsonb\").HasConversion("
+            + $"{MapJsonbHelperName}.Converter<{valueType}>(), {MapJsonbHelperName}.Comparer<{valueType}>());";
+    }
+
     /// <summary>Name of the generated jsonb (de)serialization helper the field.map configs use.</summary>
     private const string MapJsonbHelperName = "MapJsonb";
 
@@ -841,14 +862,7 @@ private void EmitFieldTypeConfig(
         // no reliance on Npgsql's dynamic-JSON opt-in the generated code cannot make for a
         // consumer. The COMPARER is not optional -- see EmitMapJsonbHelper.
         foreach (var f in fieldList.Where(f => f.SubType == FIELD_SUBTYPE_MAP))
-        {
-            var prop = CSharpNaming.Pascal(f.Name);
-            var valueType = MapValueTypeRef(f, ctx);
-            modelLines.Add(
-                $"        modelBuilder.Entity<{className}>().Property(x => x.{prop})"
-                + $".HasColumnType(\"jsonb\").HasConversion("
-                + $"{MapJsonbHelperName}.Converter<{valueType}>(), {MapJsonbHelperName}.Comparer<{valueType}>());");
-        }
+            modelLines.Add(MapJsonbConfig(className, f, ctx));
 
         foreach (var f in fieldList.Where(f => f.SubType == FIELD_SUBTYPE_ENUM))
         {
@@ -1053,10 +1067,11 @@ private void EmitFieldTypeConfig(
             // default: a column the migration never creates (42703 at the engine).
             if (nf.SubType == FIELD_SUBTYPE_MAP)
             {
+                var mapValue = MapValueTypeRef(nf, ctx);
                 sb.AppendLine($"            b.Property(p => p.{CSharpNaming.Pascal(nf.Name)})"
                     + $".HasColumnName(\"{nestedColAny}\").HasColumnType(\"jsonb\").HasConversion("
-                    + $"{MapJsonbHelperName}.Converter<{MapValueTypeRef(nf, ctx)}>(), "
-                    + $"{MapJsonbHelperName}.Comparer<{MapValueTypeRef(nf, ctx)}>());");
+                    + $"{MapJsonbHelperName}.Converter<{mapValue}>(), "
+                    + $"{MapJsonbHelperName}.Comparer<{mapValue}>());");
                 continue;
             }
 
 
@@ -168,10 +168,14 @@ protected void emit(MetaObject entity, Path outRoot) {
         String pkType = SpringTypeMapper.primaryKeyJavaType(entity);
 
         // Sort allowlist: every scalar field is sortable. Skip ObjectField (no SQL column
-        // surface today; @storage controls a separate column shape).
+        // surface today; @storage controls a separate column shape) and MapField: a map is one
+        // jsonb column holding a JSON object, so ORDER BY over it sorts by Postgres' jsonb
+        // collation — meaningless as an ordering, and a 400 on the ports that reject it, which
+        // makes the api-contract diverge. The filter side already excludes maps by having no
+        // operator band for them.
         List<String> sortFields = new ArrayList<>();
         for (MetaField field : entity.getMetaFields()) {
-            if (field instanceof ObjectField) continue;
+            if (field instanceof ObjectField || field instanceof com.metaobjects.field.MapField) continue;
             sortFields.add(field.getName());
         }
 
@@ -426,6 +430,24 @@ private static void appendValueObjectValidation(StringBuilder src, MetaObject en
                 src.append("        }\n");
             }
         }
+        // A field.map @objectRef carries the same nested value objects, and the POST path now
+        // cascades into them via @Valid on the DTO component. PATCH validates field-by-field
+        // with validateValue, which does NOT cascade — so without this the two write paths
+        // disagree for maps where they agree for field.object, and a PATCH could write a
+        // nested VO that POST rejects. Validate each map VALUE (keys are plain strings).
+        for (MetaField vf : entity.getMetaFields()) {
+            if (SpringDtoGenerator.mapValueObjectRefOf(vf) == null) continue;
+            String name = vf.getName();
+            String cap = SpringNaming.capitalize(name);
+            src.append("        if (patch.has").append(cap).append("() && patch.")
+               .append(name).append("() != null) {\n");
+            src.append("            for (var __e : patch.").append(name).append("().values()) {\n");
+            src.append("                if (__e != null && !validator.validate(__e).isEmpty()) {\n");
+            src.append("                    return ResponseEntity.badRequest().body(Map.of(\"error\", \"validation\"));\n");
+            src.append("                }\n");
+            src.append("            }\n");
+            src.append("        }\n");
+        }
     }
 
     /**
 
@@ -267,7 +267,10 @@ public static MetaObject nestedTargetOf(MetaField<?> field, MetaDataLoader loade
             if (target == null || !MetaObject.SUBTYPE_VALUE.equals(target.getSubType())) return null;
             return target;
         }
-        return null;
+        // A field.map @objectRef carries a nested payload target exactly as field.object does
+        // (see resolveMapFieldType). This walk and the emission walk MUST agree on the target
+        // set — a target the closure misses is a record the name map never names.
+        return SpringDtoGenerator.mapValueObjectRefOf(field);
     }
 
     /**
@@ -477,6 +480,13 @@ public String resolveFieldType(MetaField<?> field,
         if (field instanceof ObjectField of) {
             return resolveObjectFieldType(of, loader, nestedPkg, outRoot, emittedNestedFqns, nameMap);
         }
+        // A field.map @objectRef must take the SAME nested-payload path a field.object does.
+        // Falling through to javaTypeName would type the component as the SOURCE value
+        // object's FQN — a type the payload path never emits — so the generated
+        // <Name>Payload would name a record that does not exist.
+        if (field instanceof com.metaobjects.field.MapField mf) {
+            return resolveMapFieldType(mf, loader, nestedPkg, outRoot, emittedNestedFqns, nameMap);
+        }
         // Scalar array (`isArray: true` on a non-object, non-enum field): the declared
         // contract is field.<subType> + @isArray, so wrap the element type as
         // java.util.List<ElementType> — matching Kotlin's scalar-array arm and Python's
@@ -517,6 +527,32 @@ protected String resolveObjectFieldType(ObjectField field,
         return emitNestedAndReturnType(target, loader, nestedPkg, outRoot, emittedNestedFqns, field.isArrayType(), nameMap);
     }
 
+    /**
+     * Declared {@code field.map @objectRef}: recursively emit
+     * {@code <CapitalizedTargetShortName>Payload} for the referenced value object and return
+     * {@code java.util.Map<String, TargetPayload>}. The map analog of
+     * {@link #resolveObjectFieldType} — a payload component must name a PAYLOAD record, never
+     * the source value object, and the target has to enter the emission closure or nothing
+     * generates it.
+     *
+     * <p>A scalar-valued map ({@code @valueType}) references no value object, so it falls
+     * through to the plain type mapper ({@code Map<String, Scalar>}). {@code isArray} does not
+     * apply to a map, so there is no list-wrapping arm here.</p>
+     */
+    protected String resolveMapFieldType(com.metaobjects.field.MapField field,
+                                         MetaDataLoader loader,
+                                         String nestedPkg,
+                                         Path outRoot,
+                                         Set<String> emittedNestedFqns,
+                                         Map<String, String> nameMap) {
+        MetaObject target = SpringDtoGenerator.mapValueObjectRefOf(field);
+        if (target == null) return SpringTypeMapper.javaTypeName(field);
+        // asList:false — the bare nested record name, which we wrap as the map VALUE.
+        String nested = emitNestedAndReturnType(
+            target, loader, nestedPkg, outRoot, emittedNestedFqns, false, nameMap);
+        return "java.util.Map<String, " + nested + ">";
+    }
+
     /**
      * Nested-payload emit path used by {@link #resolveObjectFieldType} (single or
      * list, depending on {@code asList}). Emits the record at most once per run via
 
@@ -181,7 +181,18 @@ private static String mapValueJavaType(MapField field) {
         // ADR-0039: @objectRef / @valueType are EFFECTIVE properties -- hasMetaAttr/getMetaAttr
         // (the one-arg, RESOLVING forms) so a value inherited via `extends` is not dropped.
         if (field.hasMetaAttr(MapField.ATTR_OBJECTREF)) {
-            MetaObject ref = field.getObjectRef();
+            MetaObject ref;
+            try {
+                ref = field.getObjectRef();
+            } catch (RuntimeException unresolved) {
+                // MetaDataUtil.getObjectRef THROWS MetaDataNotFoundException on a dangling ref
+                // rather than returning null. Caught so this method actually keeps the contract
+                // its javadoc states, and so it agrees with its sibling
+                // SpringDtoGenerator.mapValueObjectRefOf — otherwise one dangling ref produces
+                // a not-found from the type mapper and a silent skip from the @Valid /
+                // value-object-reachability path.
+                return null;
+            }
             if (ref == null) return null;
             String[] split = SpringNaming.splitFqn(ref.getName());
             return split[0].isEmpty() ? split[1] : split[0] + "." + split[1];
 
@@ -104,7 +104,11 @@ private void emit(MetaObject vo, Path outRoot) {
         boolean usesValid = false;
         for (MetaField field : fields) {
             String a = SpringDtoGenerator.validationAnnotations(field);
-            if (SpringDtoGenerator.isValueObjectJsonbField(field)) {
+            // valueObjectRefOf, not isValueObjectJsonbField: it spans BOTH shapes that carry a
+            // value object (field.object @objectRef and field.map @objectRef). The entity DTO
+            // cascades into a map of value objects; a VO nesting the same shape must too, or
+            // the nested constraints go unenforced one level down.
+            if (SpringDtoGenerator.valueObjectRefOf(field) != null) {
                 a = a.isEmpty() ? "@Valid" : "@Valid " + a;
                 usesValid = true;
             }