fix(codegen-spring): close two cross-port parity gaps in SpringPayloadGenerator

Two divergences from Kotlin's `KotlinPayloadGenerator` discovered when
running against a non-trivial payload with `field.object` children:

## Gap 1 — `scalarFields()` filter dropped every `ObjectField`

Previously `SpringPayloadGenerator.emitPayloadRecord` routed VO fields through
a `scalarFields()` filter that excluded every `ObjectField`. Effect: a payload
with a naked `field.object @objectRef` (no `origin.*`) silently lost that
component. The class's own Javadoc promised a "no origin child — fall back to
SpringTypeMapper" path, but the fallback never ran because the field was
filtered before `resolveFieldType` saw it.

Kotlin's reference iterates `voObject.metaFields` with no filter and resolves
plain `ObjectField` via the same nested-payload recursion `origin.collection`
already uses.

**Fix:**
- Drop the `scalarFields()` filter; route every field through
  `resolveFieldType` directly.
- Add a `field.object` arm to `resolveFieldType` (lower precedence than
  `origin.*`): single ref → emit `<TargetShortName>Payload` and return that
  type; `isArray: true` → return `java.util.List<TargetPayload>`.
- Extract the nested-emit-and-return-type logic into a shared
  `emitNestedAndReturnType(target, loader, nestedPkg, outRoot,
  emittedNestedFqns, asList)` helper, used by both `resolveCollectionType`
  and the new `resolveObjectFieldType` arm. Dedupe by target FQN per-run as
  before.
- Update class Javadoc — drop the "ObjectField children are skipped" bullet;
  document the new `field.object` precedence + the PascalCase naming rule.

## Gap 2 — generated class names not PascalCase-capitalised

Templates declared in `camelCase` (e.g. `npcTurn`, `lookupWeather`,
`adjudicationUser`) produced lowercase-first record file names
(`npcTurnPayload.java`) — compiles, but violates Java's PascalCase
class-naming convention and diverges from Kotlin/C#/TS/Python.

**Fix:**
- Add `capitalizeFirst(s)` helper in both `SpringPayloadGenerator` and
  `SpringOutputParserGenerator` (paired so the parser's payload-class
  reference matches the actual generated file name).
- Apply to: the top-level record name, every nested record name in
  `emitNestedAndReturnType`, and the `getSingleOutputFilename` overrides
  on both generators. Already-PascalCase names pass through unchanged.

## Tests

- Existing `emitsRecordForPromptTemplate` (template `npcTurn`) and
  `emitsRecordForToolcallTemplate` (template `lookupWeather`) rebaselined
  from `npcTurnPayload.java` / `lookupWeatherPayload.java` to
  `NpcTurnPayload.java` / `LookupWeatherPayload.java`.
- 4 new tests for the `field.object` arm:
  - `fieldObjectSingleRefEmitsNestedPayloadAndRecordReferenceType` — single ref,
    nested payload emitted, parent component is `<TargetPayload>` (NOT List).
  - `fieldObjectIsArrayEmitsListType` — isArray:true emits
    `java.util.List<<TargetPayload>>`, nested payload emitted once.
  - `fieldObjectMixedFieldsAllSurviveIntoParent` — scalar + single ref +
    isArray ref + passthrough origin all coexist in one payload.
  - `camelCaseTemplateNameYieldsPascalCaseRecord` — pins Gap 2 directly:
    template `adjudicationUser` → record `AdjudicationUserPayload`; nested VO
    `userContext` → file `UserContextPayload.java`.

Test count: 37 → 41 in codegen-spring (full suite green). Wider reactor
smoke (`maven-plugin` depends on `codegen-spring` transitively) still green.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dmealing

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringOutputParserGenerator.java

@@ -114,8 +114,14 @@ private void emit(MetaTemplate template, MetaDataLoader loader, Path outRoot) {
         String templatePkg = split[0];
         String templateShort = split[1];
         String outPkg = templatePkg.isEmpty() ? "prompts" : templatePkg + ".prompts";
-        String parserClass = templateShort + "Parser";
-        String payloadClass = templateShort + "Payload";
+        // PascalCase the class names — templates authored in camelCase
+        // (e.g. `npcTurn`) yield Java-idiomatic `NpcTurnParser` /
+        // `NpcTurnPayload`. Pairs with SpringPayloadGenerator's matching
+        // capitalisation so the parser's payload-class reference stays
+        // consistent.
+        String capitalized = capitalizeFirst(templateShort);
+        String parserClass = capitalized + "Parser";
+        String payloadClass = capitalized + "Payload";
 
         StringBuilder src = new StringBuilder();
         src.append("// GENERATED — DO NOT EDIT — parser for template.output `")
@@ -149,6 +155,19 @@ private void emit(MetaTemplate template, MetaDataLoader loader, Path outRoot) {
         }
     }
 
+    /**
+     * Uppercase the first character of {@code s}; pass through unchanged when
+     * empty or already capitalised. Pairs with {@link SpringPayloadGenerator}'s
+     * matching helper so the {@code <PayloadClass>} reference in the parser
+     * matches the actual generated file name.
+     */
+    private static String capitalizeFirst(String s) {
+        if (s == null || s.isEmpty()) return s;
+        char c0 = s.charAt(0);
+        if (Character.isUpperCase(c0)) return s;
+        return Character.toUpperCase(c0) + s.substring(1);
+    }
+
     /** Resolve {@code @payloadRef} to its {@code object.value} target (rejects entities). */
     private static MetaObject resolveValueObject(MetaDataLoader loader, String ref) {
         for (MetaObject obj : loader.getMetaObjects()) {
@@ -188,6 +207,6 @@ protected String getSingleOutputFilePath(MetaObject md) {
 
     @Override
     protected String getSingleOutputFilename(MetaObject md) {
-        return SpringNaming.splitFqn(md.getName())[1] + "Parser.java";
+        return capitalizeFirst(SpringNaming.splitFqn(md.getName())[1]) + "Parser.java";
     }
 }

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringPayloadGenerator.java

@@ -67,17 +67,30 @@
  *   <li>{@code origin.collection} ({@code @via "Parent.rel"}) —
  *       {@code List<TargetPayload>}, and the nested payload class is recursively
  *       emitted alongside (deduped per {@link #execute(MetaDataLoader)} run).</li>
- *   <li>No origin child — fall back to {@link SpringTypeMapper#javaTypeName(MetaField)}.</li>
+ *   <li>{@code field.object} with {@code @objectRef} (no {@code origin.*} child) —
+ *       recursively emit {@code <TargetShortName>Payload} (per-run deduped) and
+ *       return that type, or {@code java.util.List<TargetPayload>} when the field
+ *       is {@code isArray: true}. Mirrors Kotlin's plain {@code ObjectField}
+ *       arm.</li>
+ *   <li>No origin child and not a {@code field.object} — fall back to
+ *       {@link SpringTypeMapper#javaTypeName(MetaField)}.</li>
  * </ul>
  *
+ * <p>Class-naming convention: the emitted record name is
+ * {@code <PascalCaseTemplateShortName>Payload}. Templates declared in
+ * {@code camelCase} (e.g. {@code adjudicationUser}) are capitalised before
+ * appending {@code Payload}, matching Kotlin/C#/TS/Python and Java's own
+ * PascalCase class-naming convention. Nested payload class names from
+ * {@code origin.collection} / {@code field.object} arms are capitalised the
+ * same way.
+ *
  * <p>Skips and defensive cases:
  * <ul>
  *   <li>Missing {@code @payloadRef} — skipped (loader's validation pass
  *       normally rejects this first; defensive only).</li>
  *   <li>{@code @payloadRef} resolves to a non-VO target — skipped (payloads
  *       must be {@code object.value}; matches the cross-port contract).</li>
  *   <li>Templates are processed in stable name order for deterministic emission.</li>
- *   <li>{@link ObjectField} children are skipped (mirrors {@link SpringDtoGenerator}).</li>
  * </ul>
  *
  * <p>Args:
@@ -133,7 +146,7 @@ private void emit(MetaTemplate template, MetaDataLoader loader, Path outRoot,
         String templatePkg = split[0];
         String templateShort = split[1];
         String outPkg = templatePkg.isEmpty() ? "prompts" : templatePkg + ".prompts";
-        String recordName = templateShort + "Payload";
+        String recordName = capitalizeFirst(templateShort) + "Payload";
 
         emitPayloadRecord(
             outPkg,
@@ -165,8 +178,12 @@ private void emitPayloadRecord(String outPkg,
         src.append("/** ").append(banner).append(" */\n");
         src.append("public record ").append(recordName).append("(\n");
 
-        List<MetaField> fields = scalarFields(voObject);
-        Iterator<MetaField> it = fields.iterator();
+        // Route every field through resolveFieldType — including ObjectField,
+        // which needs the field.object arm (single ref or isArray list). The
+        // previous scalarFields() filter dropped ObjectField entirely; mirror
+        // KotlinPayloadGenerator's no-filter iteration. getMetaFields()
+        // returns Collection, so go through the iterator directly.
+        Iterator<MetaField> it = voObject.getMetaFields().iterator();
         while (it.hasNext()) {
             MetaField field = it.next();
             String type = resolveFieldType(field, loader, outPkg, outRoot, emittedNestedFqns);
@@ -187,19 +204,17 @@ private void emitPayloadRecord(String outPkg,
     }
 
     /**
-     * Resolve the Java type expression of a single payload-VO field, honoring
-     * any {@code origin.*} child. Falls back to
-     * {@link SpringTypeMapper#javaTypeName} when no origin is present.
+     * Resolve the Java type expression of a single payload-VO field. Precedence:
+     * (1) {@code origin.*} child wins if present; (2) otherwise a
+     * {@code field.object} routes through the nested-payload emission arm; (3)
+     * otherwise the scalar fallback via {@link SpringTypeMapper#javaTypeName}.
      */
     private String resolveFieldType(MetaField<?> field,
                                     MetaDataLoader loader,
                                     String nestedPkg,
                                     Path outRoot,
                                     Set<String> emittedNestedFqns) {
         MetaOrigin origin = firstOriginChild(field);
-        if (origin == null) {
-            return SpringTypeMapper.javaTypeName(field);
-        }
         if (origin instanceof PassthroughOrigin pt) {
             return resolvePassthroughType(pt, loader, field);
         }
@@ -209,9 +224,35 @@ private String resolveFieldType(MetaField<?> field,
         if (origin instanceof CollectionOrigin co) {
             return resolveCollectionType(co, loader, nestedPkg, outRoot, emittedNestedFqns, field);
         }
+        if (field instanceof ObjectField of) {
+            return resolveObjectFieldType(of, loader, nestedPkg, outRoot, emittedNestedFqns);
+        }
         return SpringTypeMapper.javaTypeName(field);
     }
 
+    /**
+     * Naked {@code field.object @objectRef}: recursively emit
+     * {@code <CapitalizedTargetShortName>Payload} for the referenced VO, and
+     * return that type — or {@code java.util.List<TargetPayload>} when
+     * {@code isArray: true}. Mirrors Kotlin's plain-{@code ObjectField} arm in
+     * {@code KotlinPayloadGenerator.resolveFieldType}.
+     */
+    private String resolveObjectFieldType(ObjectField field,
+                                          MetaDataLoader loader,
+                                          String nestedPkg,
+                                          Path outRoot,
+                                          Set<String> emittedNestedFqns) {
+        MetaObject target = field.getObjectRef();
+        if (target == null) return SpringTypeMapper.javaTypeName(field);
+        if (!MetaObject.SUBTYPE_VALUE.equals(target.getSubType())) {
+            // Same payload-VO contract as @payloadRef — nested payloads must
+            // themselves be object.value. Loader validation normally catches
+            // this; defensive fallback to scalar type.
+            return SpringTypeMapper.javaTypeName(field);
+        }
+        return emitNestedAndReturnType(target, loader, nestedPkg, outRoot, emittedNestedFqns, field.isArray());
+    }
+
     /**
      * {@code origin.passthrough @from "Entity.field"}: resolve to the source
      * field's Java type. Falls back to the payload field's own type if the
@@ -293,22 +334,39 @@ private String resolveCollectionType(CollectionOrigin origin,
 
         MetaObject target = resolveObjectByShortOrFqn(loader, targetRef);
         if (target == null) return SpringTypeMapper.javaTypeName(fallbackField);
+        return emitNestedAndReturnType(target, loader, nestedPkg, outRoot, emittedNestedFqns, true);
+    }
 
-        String nestedShort = SpringNaming.splitFqn(target.getName())[1];
+    /**
+     * Shared nested-payload emit path used by {@link #resolveCollectionType}
+     * (always a list) and {@link #resolveObjectFieldType} (single or list,
+     * depending on {@code asList}). Emits the record at most once per run via
+     * the {@code emittedNestedFqns} dedupe set, and returns the type expression
+     * to use as the parent field's component type. Returns
+     * {@code java.util.List<TargetPayload>} (fully-qualified to sidestep any
+     * potential {@code List} import collision in generated code) when
+     * {@code asList} is true, else just {@code TargetPayload}.
+     */
+    private String emitNestedAndReturnType(MetaObject target,
+                                           MetaDataLoader loader,
+                                           String nestedPkg,
+                                           Path outRoot,
+                                           Set<String> emittedNestedFqns,
+                                           boolean asList) {
+        String nestedShort = capitalizeFirst(SpringNaming.splitFqn(target.getName())[1]);
         String nestedRecord = nestedShort + "Payload";
-
         if (emittedNestedFqns.add(target.getName())) {
             emitPayloadRecord(
                 nestedPkg,
                 nestedRecord,
-                "GENERATED — nested payload for collection target `" + target.getName() + "`. "
+                "GENERATED — nested payload for `" + target.getName() + "`. "
                     + "Do not hand-edit; regenerated from metadata.",
                 target,
                 loader,
                 outRoot,
                 emittedNestedFqns);
         }
-        return "java.util.List<" + nestedRecord + ">";
+        return asList ? "java.util.List<" + nestedRecord + ">" : nestedRecord;
     }
 
     // -------------------------------------------------------------------------
@@ -380,14 +438,18 @@ private static String shortName(String fqn) {
         return idx < 0 ? fqn : fqn.substring(idx + 2);
     }
 
-    /** Scalar payload fields — same filter SpringDtoGenerator uses (skips ObjectField). */
-    private static List<MetaField> scalarFields(MetaObject vo) {
-        List<MetaField> out = new ArrayList<>();
-        for (MetaField field : vo.getMetaFields()) {
-            if (field instanceof ObjectField) continue;
-            out.add(field);
-        }
-        return out;
+    /**
+     * Uppercase the first character of {@code s}; pass {@code s} through
+     * unchanged when empty or already capitalised. Used to PascalCase the
+     * payload record name regardless of whether the template short name was
+     * authored as {@code camelCase} or {@code PascalCase}, matching Kotlin /
+     * C# / TS / Python convention + Java's PascalCase class-naming rule.
+     */
+    private static String capitalizeFirst(String s) {
+        if (s == null || s.isEmpty()) return s;
+        char c0 = s.charAt(0);
+        if (Character.isUpperCase(c0)) return s;
+        return Character.toUpperCase(c0) + s.substring(1);
     }
 
     // === MultiFileDirectGeneratorBase abstract-method stubs ====================
@@ -418,6 +480,6 @@ protected String getSingleOutputFilePath(MetaObject md) {
 
     @Override
     protected String getSingleOutputFilename(MetaObject md) {
-        return SpringNaming.splitFqn(md.getName())[1] + "Payload.java";
+        return capitalizeFirst(SpringNaming.splitFqn(md.getName())[1]) + "Payload.java";
     }
 }