fr5c(java): merge-phase contributors + ERR_MERGE_CONFLICT envelope + WARN_DUPLICATE_DECLARATION

Java port of the FR5c TS reference (`329ba34`) per ADR-0009:

  - Overlay-merge phase in `CanonicalJsonParser.processNode` snapshots a
    node's pre-merge canonical shape + own-attrs map BEFORE re-applying
    the new contribution. When two or more files contribute to the same
    logical node AND the merge produces a semantic change (via FR5a
    `SemanticDiff`), the merged node's `source` is upgraded to
    `format: "merged"` with an alphabetically-ordered `files[]` and a
    `contributors[]` whose first entry is role `overlay-base` and all
    subsequent entries are `overlay-extension`. Single-file nodes keep
    their FR5a parse-time `JsonSource`/`YamlSource` unchanged.

  - `ERR_MERGE_CONFLICT` (new ErrorCode) raised when two contributors
    set the same `@attr` to different non-empty values on the same node.
    Envelope is `format: "merged"` with both contributors listed and
    `jsonPath` pointing at the conflicting attr. Last-writer-wins remains
    the merge default for non-conflicting cases (one side unset, same
    value); the recorded error surfaces the divergence so a consumer can
    fix it. Array-shaped JSON values (e.g. `["a","b"]`) are normalized to
    the same comma-delimited form `MetaAttribute.getValueAsString()`
    emits, so identical-array contributions are not flagged spuriously.

  - `WARN_DUPLICATE_DECLARATION` emitted at the merge boundary when a
    second contribution declares the same node with no semantic change
    (`SemanticDiff` returns false on pre/post canonical-serialize). The
    node's `source` is NOT upgraded to merged in this case — only the
    new envelope-warning channel surfaces it.

  - `MetaDataLoader` gains a parallel `envelopeWarnings: List<LoaderWarning>`
    channel (cross-port aligned with TS `ParseResult.envelopeWarnings`).
    `addEnvelopeWarning` also pushes the warning's message into the
    legacy `warnings: List<String>` channel so the existing conformance
    harness — which reads warnings as a flat string list — picks up
    FR5c warnings without needing a new contract. Both `addError` and
    `addEnvelopeWarning` are now `public` to support the cross-subpackage
    parser call sites (matching the precedent set by `addPendingExtends`).

  - `tagNodeWithJsonSource` now preserves `MergedSource` in addition to
    `JsonSource`/`YamlSource`, so a third contributor cannot revert an
    already-upgraded source envelope back to a single-file shape.

  - Conformance runner relaxes a too-strict guard that aborted tree-
    dependent checks when any error was recorded. FR5c records errors
    non-fatally via `addError`, and existing fixtures (e.g.
    `overlay-attr-last-writer-wins`) now legitimately produce a recorded
    `ERR_MERGE_CONFLICT` alongside a valid tree. TS conformance behaves
    the same way — only `expected-errors.json` fixtures check the error
    set. Only a thrown exception now aborts tree checks.

  - `EntityHasPrimaryIdentityValidationTest.warningsResetAcrossLoadCalls`
    reuses the same source id across two `load()` calls so the merge-
    attribution code does not see a NEW contributor on the second load
    and emit a `WARN_DUPLICATE_DECLARATION` orthogonal to the test's
    intent (which is verifying the per-batch warning accumulator reset).

Three shared conformance fixtures all green:
  - `error-merge-conflict-attr` — `ERR_MERGE_CONFLICT` envelope with
    both contributors listed alphabetically.
  - `warning-duplicate-declaration` — three duplicate-declaration
    warning strings (one per merged sub-node).
  - `merge-three-way-no-conflict` — three-file overlay produces a
    `MergedSource` with all three files in alphabetical order.

Tests: 717 → 727 metadata module (+10 unit tests in `Fr5cMergeAttributionTest`,
+1 conformance lint pair via the two new fixtures); full Java suite 21/21
modules green. Cross-port aligned with the TS reference behaviour.

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

Author: dmealing

server/java/metadata/src/main/java/com/metaobjects/ErrorCode.java

@@ -133,6 +133,13 @@ public enum ErrorCode {
     /** An object declares more than one source node with role=primary. */
     ERR_SOURCE_MULTIPLE_PRIMARY,
 
+    /**
+     * Two contributing files set the same {@code @attr} on the same node to
+     * different non-empty values during overlay merge (FR5c). Envelope is
+     * {@code format: "merged"} with both contributors listed.
+     */
+    ERR_MERGE_CONFLICT,
+
     /** An internal loader error with no stable error code. */
     ERR_UNKNOWN,
 }

server/java/metadata/src/main/java/com/metaobjects/loader/MetaDataLoader.java

@@ -146,6 +146,23 @@ public class MetaDataLoader implements LoaderConfigurable {
     // merges the two into a single per-fixture error set.
     private final List<MetaDataException> errors = new ArrayList<>();
 
+    // FR5c — envelope-shaped warnings accumulator (cross-port parallel channel).
+    //
+    // Distinct from the {@link #warnings} legacy-string channel: envelope
+    // warnings already carry their own {@code WARN_*} code + {@link
+    // com.metaobjects.source.ErrorSource} provenance and are produced by
+    // FR5c-onward sites (the canonical first emitter is the duplicate-
+    // declaration site in {@code CanonicalJsonParser}). The conformance harness
+    // today reads warnings as a flat string list via {@link #getWarnings()};
+    // FR5c parser sites also push the {@link com.metaobjects.source.LoaderWarning#message()}
+    // string into the legacy channel so the harness sees both forms without
+    // needing a new contract.
+    //
+    // Cleared at the start of every {@link #load(List)} so a subsequent load on
+    // the same loader does not see stale warnings. Mirrors the TS
+    // {@code envelopeWarnings: LoaderWarning[]} channel on {@code ParseResult}.
+    private final List<com.metaobjects.source.LoaderWarning> envelopeWarnings = new ArrayList<>();
+
     /**
      * Deferred-extends queue. The parser cannot always resolve a node's
      * {@code extends} ref at parse time (e.g. cross-file forward references).
@@ -548,12 +565,16 @@ public List<MetaDataException> getErrors() {
     }
 
     /**
-     * Append a validation error. Package-private — only the loader-package
-     * validation passes should be calling this.
+     * Append a validation error. Loader-internal API — callers are the
+     * loader's validation passes and the FR5c merge-attribution site in
+     * {@link com.metaobjects.loader.parser.json.CanonicalJsonParser} (which
+     * lives in a sub-package, so this method must be {@code public} for
+     * cross-package access — mirroring the precedent set by
+     * {@link #addPendingExtends(PendingExtends)}).
      *
      * @param error the error to record; ignored when {@code null}
      */
-    void addError(MetaDataException error) {
+    public void addError(MetaDataException error) {
         if (error == null) return;
         errors.add(error);
     }
@@ -567,6 +588,55 @@ void clearErrors() {
         errors.clear();
     }
 
+    /**
+     * Returns the FR5c envelope-shaped warnings accumulated during the most
+     * recent {@link #load(List)}. Each entry carries a {@code WARN_*} code
+     * plus a {@link com.metaobjects.source.ErrorSource} envelope (canonical
+     * first emitter: {@code WARN_DUPLICATE_DECLARATION} with
+     * {@link com.metaobjects.source.MergedSource}).
+     *
+     * <p>Cross-port aligned with the TS {@code ParseResult.envelopeWarnings}
+     * channel and the C# / Python {@code LoaderWarning[]} return surfaces.</p>
+     *
+     * @return an unmodifiable snapshot of envelope warnings (never {@code null})
+     */
+    public List<com.metaobjects.source.LoaderWarning> getEnvelopeWarnings() {
+        return Collections.unmodifiableList(new ArrayList<>(envelopeWarnings));
+    }
+
+    /**
+     * Append a FR5c envelope-shaped warning. Loader-internal API — callers
+     * are the loader pipeline plus the FR5c merge-attribution site in
+     * {@link com.metaobjects.loader.parser.json.CanonicalJsonParser} (which
+     * lives in a sub-package, so this method must be {@code public} for
+     * cross-package access — mirroring the precedent set by
+     * {@link #addPendingExtends(PendingExtends)}).
+     *
+     * <p>This method ALSO pushes the warning's {@link
+     * com.metaobjects.source.LoaderWarning#message()} into the legacy
+     * {@link #warnings} channel so the existing conformance harness — which
+     * reads a flat string list via {@link #getWarnings()} — picks up FR5c
+     * warnings without needing a new contract. The envelope is available
+     * separately via {@link #getEnvelopeWarnings()} for callers that want
+     * the full provenance.</p>
+     *
+     * @param warning the envelope warning; ignored when {@code null}
+     */
+    public void addEnvelopeWarning(com.metaobjects.source.LoaderWarning warning) {
+        if (warning == null) return;
+        envelopeWarnings.add(warning);
+        // Mirror into the legacy channel for the conformance harness.
+        warnings.add(warning.message());
+    }
+
+    /**
+     * Clear accumulated envelope warnings. Called at the start of
+     * {@link #load(List)} so a fresh batch does not see stale entries.
+     */
+    void clearEnvelopeWarnings() {
+        envelopeWarnings.clear();
+    }
+
     ///////////////////////////////////////////////////////////////////////
     // ClassLoader
 
@@ -1131,6 +1201,7 @@ public MetaDataLoader load(List<MetaDataSource> sources) {
         // diagnostics produced by THIS batch.
         clearWarnings();
         clearErrors();
+        clearEnvelopeWarnings();
         pendingExtends.clear();
 
         for (MetaDataSource source : sources) {