fix(java): source+identity auto-name; emit byte-parity with TS canonical output

CanonicalJsonParser.processNode used to fall back to name = subType for
every node missing an authored name -- a Java convention TS does not share.
TS leaves name='' and the serializer omits the name key on emit. Java's
fallback spuriously emitted a name key on every nameless source.rdb and
identity.primary, breaking byte-parity with the shared conformance corpus
(e.g. source.rdb without an authored name emitted "name": "rdb"; identity
.primary without one emitted "name": "primary").

Targeted fix: the parser fallback now skips types in isAutoNamingType. We
add MetaSource.TYPE_SOURCE and MetaIdentity.TYPE_IDENTITY to that set
alongside the existing validator/view entries -- both go through
createOrOverlayMetaData's sequential auto-naming (rdb1, primary1, ...) and
the serializer's existing isAutoGeneratedName check then suppresses the
emitted name (matching the ^<subType>\d+$ pattern), preserving the TS
oracle byte form. Explicitly-named identity.secondary children (e.g. name:
"byEmail") continue to emit their authored name.

Also bundles a previously-uncommitted ConformanceTest improvement: the
canonical-serialization-mismatch failure now includes the expected/got
diff, not just a one-line label -- essential for diagnosing the next set
of remaining gaps.

Tests:
  * Adds MetaSourceTest.sourceRdbWithoutNameRoundTripsByteIdentical -- a
    focused round-trip smoke confirming the source.rdb body is emitted
    as exactly {"@table": "..."} with no name key.
  * Updates two existing lookups (MetaSourceTest, CanonicalJsonParserTest)
    that asserted the old "subType-as-name" qualified form; they now look
    up the auto-named form.

Un-gates 31 source-v2 stage-1 conformance fixtures (now pass on the Java
loader/serializer pipeline):
  attr-default-polymorphic, auto-set-on-create, auto-set-on-create-and-update,
  auto-set-on-update, enum-array, enum-inline, extends-multi-level,
  extends-single-level, field-decimal-precision-scale,
  field-object-storage-flattened, field-object-storage-flattened-nullable,
  field-object-storage-jsonb-array, field-object-storage-jsonb-single,
  field-string-maxlength, identity-primary-and-secondary,
  identity-reference-simple, loader-basic-explicit-subtype,
  loader-basic-multi-file-same-package, loader-basic-single-entity,
  loader-filterable-on-indexed-no-warning, overlay-attr-last-writer-wins,
  overlay-merge-flag-explicit, overlay-same-object-different-files,
  relationship-one-to-many, source-db-table-default-schema-omitted,
  source-db-table-explicit, source-db-table-with-schema,
  source-db-view-with-schema, source-rdb-column,
  source-rdb-referential-actions, subtype-entity-with-identity.

567/567 pass in metadata; full reactor BUILD SUCCESS across all 18 modules.

The remaining 41 ledger entries represent honest gaps in Java metatype
coverage (origin/layout/template/currency), validator implementations
(error-* expecting specific ERR_* codes Java does not emit yet),
warnings surface (no Java implementation), and the loader-root-name leak
(known H3a gap).

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

Author: dmealing

server/java/metadata/conformance-expected-failures.json

@@ -1,19 +1,13 @@
 {
   "language": "java",
   "fixtures": [
-    "attr-default-polymorphic",
     "attr-filter-explicit-ops",
     "attr-filter-shorthand",
     "attr-properties-basic",
-    "auto-set-on-create",
-    "auto-set-on-create-and-update",
-    "auto-set-on-update",
     "currency-default-usd",
     "currency-explicit-jpy",
     "currency-precedence-field-vs-view",
     "enum-abstract-extends",
-    "enum-array",
-    "enum-inline",
     "error-attr-bad-allowed-value",
     "error-attr-filter-bad-field",
     "error-attr-filter-bad-op",
@@ -34,42 +28,17 @@
     "error-unknown-relationship-subtype",
     "extends-abstract-base",
     "extends-cross-file",
-    "extends-multi-level",
-    "extends-single-level",
-    "field-decimal-precision-scale",
-    "field-object-storage-flattened",
-    "field-object-storage-flattened-nullable",
-    "field-object-storage-jsonb-array",
-    "field-object-storage-jsonb-single",
-    "field-string-maxlength",
-    "identity-primary-and-secondary",
-    "identity-reference-simple",
     "layout-data-grid-basic",
     "layout-data-grid-multiple-named",
-    "loader-basic-explicit-subtype",
-    "loader-basic-multi-file-same-package",
-    "loader-basic-single-entity",
-    "loader-filterable-on-indexed-no-warning",
     "origin-aggregate-count",
     "origin-aggregate-sum",
     "origin-collection-simple",
     "origin-multi-level-via",
     "origin-passthrough-simple",
-    "overlay-attr-last-writer-wins",
-    "overlay-merge-flag-explicit",
-    "overlay-same-object-different-files",
-    "relationship-one-to-many",
     "smoke-empty-metadata",
-    "source-db-table-default-schema-omitted",
-    "source-db-table-explicit",
-    "source-db-table-with-schema",
     "source-db-view-projection",
-    "source-db-view-with-schema",
     "source-multi-source-roles",
-    "source-rdb-column",
-    "source-rdb-referential-actions",
     "subtype-entity-missing-primary-warning",
-    "subtype-entity-with-identity",
     "template-output-and-prompt",
     "template-prompt-simple",
     "warning-filterable-no-index"

server/java/metadata/src/main/java/com/metaobjects/loader/parser/BaseMetaDataParser.java

@@ -14,6 +14,7 @@
 import com.metaobjects.registry.TypeDefinition;
 import com.metaobjects.registry.ChildRequirement;
 import com.metaobjects.relationship.MetaRelationship;
+import com.metaobjects.source.MetaSource;
 import com.metaobjects.util.MetaDataUtil;
 import com.metaobjects.validator.MetaValidator;
 import com.metaobjects.view.MetaView;
@@ -905,17 +906,28 @@ protected String determineAttributeSubType(String attrName, String stringValue)
      * Returns {@code true} if nodes of the given type use auto-naming (i.e. the parser
      * may generate a sequential name when no explicit name is provided).
      *
-     * <p>Currently only {@link MetaValidator#TYPE_VALIDATOR} and {@link MetaView#TYPE_VIEW}
-     * nodes are auto-named.  All other types require an explicit name.  This predicate is
-     * the single source of truth for the auto-naming type set — both the parser and the
+     * <p>Currently {@link MetaValidator#TYPE_VALIDATOR}, {@link MetaView#TYPE_VIEW},
+     * {@link MetaSource#TYPE_SOURCE}, and {@link MetaIdentity#TYPE_IDENTITY} nodes are
+     * auto-named.  All other types require an explicit name.  This predicate is the
+     * single source of truth for the auto-naming type set — both the parser and the
      * serializer ({@link com.metaobjects.io.json.CanonicalJsonSerializer}) consume it so
      * the two stay in sync automatically.</p>
      *
+     * <p><b>Cross-language parity:</b> The TS oracle does not synthesize {@code name = subType}
+     * when no name is authored; it leaves the name empty and the canonical serializer omits
+     * the {@code name} key on emit. To preserve byte-parity with the shared conformance corpus,
+     * types listed here participate in auto-naming (sequential {@code subTypeN}) AND have the
+     * auto-name suppressed on emit by {@code isAutoGeneratedName}. Types NOT in this set fall
+     * back to {@code name = subType}.</p>
+     *
      * @param typeName the type string as it appears in metadata (e.g. {@code "validator"})
      * @return {@code true} if the type participates in auto-naming
      */
     public static boolean isAutoNamingType(String typeName) {
-        return MetaValidator.TYPE_VALIDATOR.equals(typeName) || MetaView.TYPE_VIEW.equals(typeName);
+        return MetaValidator.TYPE_VALIDATOR.equals(typeName)
+            || MetaView.TYPE_VIEW.equals(typeName)
+            || MetaSource.TYPE_SOURCE.equals(typeName)
+            || MetaIdentity.TYPE_IDENTITY.equals(typeName);
     }
 
 

server/java/metadata/src/main/java/com/metaobjects/loader/parser/json/CanonicalJsonParser.java

@@ -366,8 +366,17 @@ private void processNode(MetaData parent, String type, String subType,
         // This handles identity.primary (no name → name = "primary") and any other
         // type that follows the subType-as-name convention. Registry-driven: no
         // per-type hardcoding.
+        //
+        // EXCEPTION: types that participate in auto-naming (validator, view, source)
+        // skip this fallback. They receive a sequential auto-name from
+        // createOrOverlayMetaData (rdb1, rdb2, …) and the serializer's
+        // isAutoGeneratedName check suppresses emission of that auto-name on the way
+        // out. This preserves byte-parity with the TS oracle, which leaves the name
+        // empty and omits the `name` key in canonical output.
         if (name == null || name.isEmpty()) {
-            name = subType;
+            if (!BaseMetaDataParser.isAutoNamingType(type)) {
+                name = subType;
+            }
         }
 
         // Create or overlay the MetaData via the format-agnostic base method.

server/java/metadata/src/test/java/com/metaobjects/conformance/ConformanceTest.java

@@ -250,7 +250,8 @@ private static void runConformanceChecks(FixtureDiscovery.Fixture fix,
             }
             String got = CanonicalJsonSerializer.canonicalSerialize(loader.getRoot()).trim();
             if (!want.equals(got)) {
-                failures.add("canonical serialization mismatch");
+                failures.add("canonical serialization mismatch:\n--- expected ---\n"
+                    + want + "\n--- got ---\n" + got);
             }
         }
 

server/java/metadata/src/test/java/com/metaobjects/loader/parser/json/CanonicalJsonParserTest.java

@@ -86,8 +86,11 @@ public void readsCanonicalSingleEntity() {
         assertEquals("entity", product.getSubType());
         assertEquals("long", product.getChildOfType("field", "id").getSubType());
         assertEquals("string", product.getChildOfType("field", "name").getSubType());
-        // Identity nodes get the document package prefix (same as other non-field children)
-        assertNotNull(product.getChildOfType("identity", "acme::commerce::primary"));
+        // Identity nodes are auto-named when no explicit name is authored (the canonical
+        // serializer suppresses the auto-name on emit to match the TS oracle byte form).
+        // First identity.primary under the entity gets auto-name "primary1", qualified
+        // with the document package: "acme::commerce::primary1".
+        assertNotNull(product.getChildOfType("identity", "acme::commerce::primary1"));
     }
 
     // -----------------------------------------------------------------------
@@ -273,8 +276,10 @@ public void deserializesBareStringAsArrayForIdentityFields() {
         parser.loadFromStream(new ByteArrayInputStream(canonical.getBytes(StandardCharsets.UTF_8)));
 
         MetaData item = loader.getRoot().getChildOfType("object", "acme::Item");
-        // Identity nodes get the document package prefix (base parser behavior for non-field children)
-        MetaData identity = item.getChildOfType("identity", "acme::primary");
+        // Identity nodes are auto-named when no explicit name is authored
+        // (sequential <subType>N — first unnamed identity.primary → "primary1").
+        // The base parser's package-qualification applies on top.
+        MetaData identity = item.getChildOfType("identity", "acme::primary1");
         assertNotNull("primary identity should exist", identity);
 
         // The fields attribute should exist and hold "id"

server/java/metadata/src/test/java/com/metaobjects/source/MetaSourceTest.java

@@ -78,18 +78,19 @@ public void sourceRdbIsRegistered() {
 
     @Test
     public void rdbSourceWithTableLoads() {
-        // When no explicit "name" key is provided, the parser uses the subType as node name.
-        // So { "source.rdb": { "@table": "products" } } creates a node named "acme::rdb"
-        // (package is inherited from the document default package "acme").
+        // When no explicit "name" key is provided, source nodes participate in
+        // auto-naming (sequential <subType>N) — the canonical serializer suppresses
+        // the auto-name on emit so the output stays byte-identical to the TS oracle.
+        // First source.rdb under the entity gets auto-name "rdb1", qualified with the
+        // document's default package "acme" → "acme::rdb1".
         String canonical = entityWith("{ \"source.rdb\": { \"@table\": \"products\" } }");
         MetaDataLoader loader = loadThrough(canonical, "source-rdb-table-test.json");
 
         MetaData product = loader.getRoot().getChildOfType("object", "acme::Product");
         assertNotNull("Product entity should exist", product);
 
-        // The parser qualifies the node name with the document package: "acme::rdb".
-        MetaData src = product.getChildOfType(MetaSource.TYPE_SOURCE, "acme::rdb");
-        assertNotNull("source.rdb child 'acme::rdb' should exist", src);
+        MetaData src = product.getChildOfType(MetaSource.TYPE_SOURCE, "acme::rdb1");
+        assertNotNull("source.rdb child 'acme::rdb1' should exist", src);
         assertEquals("subtype should be rdb", RdbSource.SUBTYPE_RDB, src.getSubType());
         assertTrue("src must be a MetaSource", src instanceof MetaSource);
         assertEquals("@table attr should be 'products'",
@@ -265,9 +266,10 @@ public void schemaRoundTripsThroughLoader() {
         MetaData product = loader.getRoot().getChildOfType("object", "acme::Product");
         assertNotNull("Product entity should exist", product);
 
-        // The parser qualifies the node name with the document package: "acme::rdb".
-        MetaData src = product.getChildOfType(MetaSource.TYPE_SOURCE, "acme::rdb");
-        assertNotNull("source.rdb child 'acme::rdb' should exist", src);
+        // Source nodes are auto-named (sequential <subType>N); auto-name is suppressed
+        // on canonical serialization. Lookup by the resolved qualified auto-name.
+        MetaData src = product.getChildOfType(MetaSource.TYPE_SOURCE, "acme::rdb1");
+        assertNotNull("source.rdb child 'acme::rdb1' should exist", src);
         assertTrue("src must be a MetaSource", src instanceof MetaSource);
         assertEquals("@schema should round-trip as 'public'",
             "public", ((MetaSource) src).getSchema());
@@ -364,4 +366,78 @@ public void registryCreatesRdbSource() {
         assertEquals("SubType must be rdb", RdbSource.SUBTYPE_RDB, src.getSubType());
         assertEquals("Name must be set", "registryTest", src.getName());
     }
+
+    // -----------------------------------------------------------------------
+    // 12 — Canonical byte-parity: source.rdb with no authored name round-trips
+    //      cleanly without emitting a spurious "name" key.
+    //
+    // This is the regression test for the cross-language divergence where Java's
+    // parser used to fall back to name = subType for every nameless node, causing
+    // the canonical serializer to emit `"name": "rdb"` on every source.rdb that
+    // wasn't authored with a name — diverging from the TS oracle by exactly that
+    // one key.
+    // -----------------------------------------------------------------------
+
+    @Test
+    public void sourceRdbWithoutNameRoundTripsByteIdentical() throws Exception {
+        // Authored shape — note the absence of any "name" key on the source.rdb body.
+        // The canonical serializer must NOT emit a spurious "name" key on the
+        // source.rdb node — that's the cross-language divergence this test guards.
+        String authored =
+            "{\n" +
+            "  \"metadata.root\": {\n" +
+            "    \"package\": \"acme::commerce\",\n" +
+            "    \"children\": [\n" +
+            "      {\n" +
+            "        \"object.entity\": {\n" +
+            "          \"name\": \"Customer\",\n" +
+            "          \"children\": [\n" +
+            "            { \"source.rdb\": { \"@table\": \"customers\" } },\n" +
+            "            { \"field.long\": { \"name\": \"id\" } },\n" +
+            "            { \"identity.primary\": { \"@fields\": [\"id\"] } }\n" +
+            "          ]\n" +
+            "        }\n" +
+            "      }\n" +
+            "    ]\n" +
+            "  }\n" +
+            "}";
+
+        MetaDataLoader loader = loadThrough(authored, "source-rdb-byte-parity-test.json");
+
+        String got =
+            com.metaobjects.io.json.CanonicalJsonSerializer.canonicalSerialize(
+                loader.getRoot()).trim();
+
+        // The root-level divergence guard: no "name": "rdb..." anywhere in the
+        // serialized output. Before the fix, this string would appear inside
+        // the source.rdb body as "name": "rdb".
+        assertFalse(
+            "Serializer must NOT emit a spurious 'name' key for a nameless source.rdb:\n" + got,
+            got.contains("\"name\": \"rdb"));
+
+        // Extract the source.rdb body and assert it is exactly {"@table": "customers"}.
+        com.google.gson.JsonObject gotRoot =
+            com.google.gson.JsonParser.parseString(got).getAsJsonObject();
+        com.google.gson.JsonObject metadataRoot =
+            gotRoot.getAsJsonObject("metadata.root");
+        com.google.gson.JsonArray rootChildren = metadataRoot.getAsJsonArray("children");
+        com.google.gson.JsonObject entity = rootChildren.get(0).getAsJsonObject()
+            .getAsJsonObject("object.entity");
+        com.google.gson.JsonArray entityChildren = entity.getAsJsonArray("children");
+
+        com.google.gson.JsonObject sourceBody = null;
+        for (com.google.gson.JsonElement child : entityChildren) {
+            com.google.gson.JsonObject wrapper = child.getAsJsonObject();
+            if (wrapper.has("source.rdb")) {
+                sourceBody = wrapper.getAsJsonObject("source.rdb");
+                break;
+            }
+        }
+        assertNotNull("serialized output must contain a source.rdb child", sourceBody);
+        assertFalse("source.rdb body must NOT carry a 'name' key", sourceBody.has("name"));
+        assertEquals("source.rdb body must carry only @table",
+            "customers", sourceBody.get("@table").getAsString());
+        assertEquals("source.rdb body must be exactly {@table: ...}",
+            1, sourceBody.size());
+    }
 }