metaobjects 0.19.2__tar.gz → 0.19.3__tar.gz

{metaobjects-0.19.2 → metaobjects-0.19.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.19.2
+Version: 0.19.3
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.19.2 → metaobjects-0.19.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.19.2"
+version = "0.19.3"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.19.2 → metaobjects-0.19.3}/src/metaobjects/codegen/generators/payload_vo_generator.py

@@ -69,6 +69,13 @@ from metaobjects.shared.separators import PACKAGE_SEP
 
 _GENERATOR_NAME = "payload-vo-generator"
 
+# ADR-0044 backstop error code — a codegen-time (not loader) error, peer of the
+# render tier's ERR_VAR_NOT_ON_PAYLOAD. Declared LOCALLY here for the same reason
+# the TS reference (codegen-ts/src/payload-codegen.ts) declares it locally rather
+# than in the shared cross-port ledger: promoting it to the ledger is coordinated
+# with the Java/Kotlin follow-up so no port reddens on a code it doesn't yet emit.
+ERR_PAYLOAD_NAME_COLLISION = "ERR_PAYLOAD_NAME_COLLISION"
+
 
 # ---------------------------------------------------------------------------
 # Naming helpers (snake_case mirrors the router/output-parser local helpers).
@@ -193,13 +200,17 @@ def _resolve_object_field_type(
     field: MetaField,
     root: MetaData,
     nested_emit_queue: list[tuple[MetaObject, str]],
-    emitted_nested_fqns: set[str],
+    emitted_nested_keys: set[str],
+    name_map: dict[str, str],
 ) -> tuple[str, set[str]]:
     """A plain ``field.object`` (``@objectRef``, no origin child) — resolve to the
-    nested ``<TargetShortName>Payload`` (single) or ``list[<TargetShortName>Payload]``
-    (array). The target VO is scheduled for in-file emission (per-file dedupe, same
-    mechanism as ``origin.collection``). Falls back to the bare type-map form when the
-    ``@objectRef`` can't be resolved (defensive — loader validation gates it first)."""
+    nested payload class (single) or ``list[...]`` (array). The class name comes
+    from the ADR-0044 *name_map* (bare ``<Short>Payload`` when unique in the module
+    closure, package-qualified on a cross-package short-name collision). The target
+    VO is scheduled for in-file emission, deduped by ``resolution_key()`` (NOT
+    ``fqn()``, which returns the bare name and would collapse two same-short-name
+    VOs from different packages into one). Falls back to the bare type-map form when
+    the ``@objectRef`` can't be resolved (defensive — loader validation gates it)."""
     ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
     if not isinstance(ref, str) or not ref:
         return _fallback_type(field)
@@ -211,12 +222,14 @@ def _resolve_object_field_type(
     # both loaded trees (file_default_package) and programmatic trees (root package).
     referrer_pkg = _pkg_of(field.parent) if field.parent is not None else ""
     target = resolve_object_ref(root, ref, referrer_pkg)
-    if target is None:
+    if not isinstance(target, MetaObject):  # narrows MetaData|None -> MetaObject
         return _fallback_type(field)
-    nested_class = payload_class_name(target.name)
-    target_fqn = target.fqn()
-    if target_fqn not in emitted_nested_fqns:
-        emitted_nested_fqns.add(target_fqn)
+    target_key = target.resolution_key()
+    # name_map was populated by the ADR-0044 closure walk (pass 1/2), which visits
+    # the identical targets; the fallback guards a defensive gap only.
+    nested_class = name_map.get(target_key) or payload_class_name(target.name)
+    if target_key not in emitted_nested_keys:
+        emitted_nested_keys.add(target_key)
         nested_emit_queue.append((target, nested_class))
     if type_map.field_is_array(field):
         return f"list[{nested_class}]", set()
@@ -345,16 +358,20 @@ def _resolve_collection_type(
     root: MetaData,
     fallback: MetaField,
     nested_emit_queue: list[tuple[MetaObject, str]],
-    emitted_nested_fqns: set[str],
+    emitted_nested_keys: set[str],
+    name_map: dict[str, str],
 ) -> tuple[str, set[str]]:
     """``origin.collection @via "Parent.rel"`` — walk Parent's relationship to
-    its ``@objectRef`` target, schedule a nested ``<TargetShortName>Payload``
-    for in-file emission, return ``list[<TargetShortName>Payload]``.
-
-    Dedupe is per-file via *emitted_nested_fqns* — if the same target is
-    referenced by two fields in the same payload module, only one nested
-    class is emitted. Cross-file dedupe would leave forward-references
-    dangling (see the module docstring)."""
+    its ``@objectRef`` target, schedule a nested payload class for in-file
+    emission, return ``list[<NestedClass>]``. The class name comes from the
+    ADR-0044 *name_map* (bare when unique in the module closure, package-qualified
+    on a cross-package short-name collision).
+
+    Dedupe is per-file via *emitted_nested_keys*, keyed by ``resolution_key()`` —
+    if the same target is referenced by two fields in the same payload module,
+    only one nested class is emitted; two same-short-name targets in DIFFERENT
+    packages are NOT collapsed (each keeps its own key + qualified name).
+    Cross-file dedupe would leave forward-references dangling (module docstring)."""
     via = origin.attr(ORIGIN_ATTR_VIA)  # ADR-0039 sanctioned own: origin.* never inherits (ADR-0029)
     if not isinstance(via, str) or not via:
         return _fallback_type(fallback)
@@ -374,11 +391,10 @@ def _resolve_collection_type(
     target = _resolve_object_by_short_or_fqn(root, target_ref)
     if target is None:
         return _fallback_type(fallback)
-    # MetaData.name is the short name (no `::`); see _resolve_object_by_short_or_fqn.
-    nested_class = payload_class_name(target.name)
-    target_fqn = target.fqn()
-    if target_fqn not in emitted_nested_fqns:
-        emitted_nested_fqns.add(target_fqn)
+    target_key = target.resolution_key()
+    nested_class = name_map.get(target_key) or payload_class_name(target.name)
+    if target_key not in emitted_nested_keys:
+        emitted_nested_keys.add(target_key)
         nested_emit_queue.append((target, nested_class))
     return f"list[{nested_class}]", set()
 
@@ -393,8 +409,9 @@ def _resolve_field_type(
     field: MetaField,
     root: MetaData,
     nested_emit_queue: list[tuple[MetaObject, str]],
-    emitted_nested_fqns: set[str],
+    emitted_nested_keys: set[str],
     enum_aliases: dict[str, str],
+    name_map: dict[str, str],
 ) -> tuple[str, set[str]]:
     """Resolve the Python annotation for one payload-VO field, honoring any
     ``origin.*`` child. Falls back to ``type_map.py_type_for`` when none.
@@ -415,7 +432,7 @@ def _resolve_field_type(
         # reference an undefined bare entity name (Pydantic "not fully defined").
         if field.sub_type == fc.FIELD_SUBTYPE_OBJECT:
             return _resolve_object_field_type(
-                field, root, nested_emit_queue, emitted_nested_fqns
+                field, root, nested_emit_queue, emitted_nested_keys, name_map
             )
         # A ``field.enum`` → Literal[...] (inline) or a named module alias (shared).
         enum_type = _enum_field_type(field, enum_aliases)
@@ -429,11 +446,142 @@ def _resolve_field_type(
         return _resolve_aggregate_type(origin, root, field)
     if origin.sub_type == "collection":
         return _resolve_collection_type(
-            origin, root, field, nested_emit_queue, emitted_nested_fqns
+            origin, root, field, nested_emit_queue, emitted_nested_keys, name_map
         )
     return _fallback_type(field)
 
 
+# ---------------------------------------------------------------------------
+# ADR-0044 — collision-scoped nested-payload naming (three-pass pipeline).
+#
+# A payload module is a SINGLE self-contained file, so its `@objectRef` /
+# `origin.collection` closure is the collision domain (ADR-0044's "closure of the
+# payload root(s) emitted into one artifact"). Two value-objects sharing a bare
+# short name across packages (`acme::alpha::Note` + `acme::beta::Note`, both
+# reachable from one payload) must emit as DISTINCT classes — the pre-ADR-0044
+# code deduped by `fqn()` (which returns the BARE name here), collapsing them to
+# one class, last-wins, silently dropping the second shape. Pass 1 collects the
+# closure keyed by `resolution_key()` (the true package-qualified FQN); pass 2
+# assigns names as a pure function of the closure (bare when unique, package-
+# qualified on collision, hard fail on a still-colliding derived name); pass 3
+# (the existing emit path) uses the name map for both declaration and reference.
+# ---------------------------------------------------------------------------
+
+
+def _package_qualified_name(pkg: str, short_name: str) -> str:
+    """ADR-0044 — PascalCase each ``::``-segment of *pkg*, concatenate, append the
+    bare *short_name* (``acme::alpha`` + ``Note`` → ``AcmeAlphaNote``). A root-level
+    (empty-package) node keeps its bare short name — the loader's own-package
+    uniqueness already precludes two root-level VOs sharing a name, so this can't
+    silently under-qualify."""
+    if pkg == "":
+        return short_name
+    return "".join(_pascal(seg) for seg in pkg.split(PACKAGE_SEP)) + short_name
+
+
+def _nested_target_of(field: MetaField, root: MetaData) -> MetaObject | None:
+    """The nested-payload target VO a *field* contributes to the module closure,
+    or ``None`` when it contributes no nested class. Mirrors the resolution in
+    :func:`_resolve_object_field_type` (a plain ``field.object`` ``@objectRef``)
+    and :func:`_resolve_collection_type` (``origin.collection`` ``@via``) EXACTLY,
+    so the ADR-0044 closure walk and the emission walk agree on the target set.
+    ``origin.passthrough`` / ``origin.aggregate`` yield scalar types (no nested
+    class) and so contribute nothing."""
+    origin = _find_origin_child(field)
+    if origin is None:
+        if field.sub_type != fc.FIELD_SUBTYPE_OBJECT:
+            return None
+        ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
+        if not isinstance(ref, str) or not ref:
+            return None
+        referrer_pkg = _pkg_of(field.parent) if field.parent is not None else ""
+        target = resolve_object_ref(root, ref, referrer_pkg)
+        return target if isinstance(target, MetaObject) else None
+    if origin.sub_type == "collection":
+        via = origin.attr(ORIGIN_ATTR_VIA)  # ADR-0039 sanctioned own: origin.* never inherits
+        if not isinstance(via, str) or not via:
+            return None
+        parts = _split_dotted_ref(via)
+        if parts is None:
+            return None
+        parent_name, rel_name = parts
+        parent = _resolve_object_by_short_or_fqn(root, parent_name)
+        if parent is None:
+            return None
+        rel = _find_relationship_on(parent, rel_name)
+        if rel is None:
+            return None
+        target_ref = rel.object_ref()
+        if not target_ref:
+            return None
+        return _resolve_object_by_short_or_fqn(root, target_ref)
+    return None
+
+
+def _collect_nested_closure(
+    root: MetaData,
+    payload_vo: MetaObject,
+    closure: dict[str, MetaObject],
+    seen: set[str],
+) -> None:
+    """ADR-0044 pass 1 — walk *payload_vo*'s transitive nested-payload closure,
+    collecting each target VO keyed by ``resolution_key()`` (never ``fqn()`` —
+    which returns the bare name and would collapse a cross-package short-name
+    collision). *seen* is seeded with the primary payload VO's key so the primary
+    (which is named after the TEMPLATE, outside the VO-short-name collision
+    domain) is never treated as a nested class, and doubles as the cycle guard."""
+    for field in payload_vo.fields():
+        if not isinstance(field, MetaField):
+            continue
+        target = _nested_target_of(field, root)
+        if target is None:
+            continue
+        key = target.resolution_key()
+        if key in seen:
+            continue
+        seen.add(key)
+        closure[key] = target
+        _collect_nested_closure(root, target, closure, seen)
+
+
+def _assign_nested_names(closure: dict[str, MetaObject]) -> dict[str, str]:
+    """ADR-0044 pass 2 — ``resolution_key()`` → emitted class name. A PURE function
+    of the closure's ``(key, short-name, package)`` triples, never of traversal
+    order: a bare short name unique in the closure emits ``<Short>Payload``
+    (byte-identical to pre-ADR-0044 output); a short-name collision emits EVERY
+    member under its package-qualified derived name
+    (``<PkgSegmentsPascal><Short>Payload``). If two distinct keys still derive the
+    same name, fail loud with ``ERR_PAYLOAD_NAME_COLLISION`` — never silently
+    collide a second time."""
+    by_short: dict[str, list[str]] = {}
+    for key, node in closure.items():
+        by_short.setdefault(node.name, []).append(key)
+
+    name_map: dict[str, str] = {}
+    for short, keys in by_short.items():
+        if len(keys) == 1:
+            name_map[keys[0]] = payload_class_name(short)
+            continue
+        for key in keys:
+            node = closure[key]
+            name_map[key] = payload_class_name(_package_qualified_name(_pkg_of(node), short))
+
+    # Backstop — sorted by key so both the emptiness of the colliding set and the
+    # pair named in the message are a pure function of the closure, not dict order.
+    owner: dict[str, str] = {}
+    for key in sorted(name_map):
+        emitted = name_map[key]
+        existing = owner.get(emitted)
+        if existing is not None and existing != key:
+            raise ValueError(
+                f"{ERR_PAYLOAD_NAME_COLLISION}: payload record name collision: "
+                f'"{emitted}" derives from both "{existing}" and "{key}" — rename one '
+                "value-object or move it to a package that derives a distinct name"
+            )
+        owner[emitted] = key
+    return name_map
+
+
 # ---------------------------------------------------------------------------
 # Class-block emission.
 # ---------------------------------------------------------------------------
@@ -444,10 +592,11 @@ def _emit_payload_class(
     payload_vo: MetaObject,
     root: MetaData,
     nested_emit_queue: list[tuple[MetaObject, str]],
-    emitted_nested_fqns: set[str],
+    emitted_nested_keys: set[str],
     extra_imports: set[str],
     enum_aliases: dict[str, str],
     docstring: str,
+    name_map: dict[str, str],
 ) -> list[str]:
     """Build the source lines for one Pydantic ``BaseModel`` subclass."""
     lines: list[str] = [f"class {class_name}(BaseModel):", f'    """{docstring}"""']
@@ -456,7 +605,7 @@ def _emit_payload_class(
         if not isinstance(field, MetaField):
             continue
         annotation, imports = _resolve_field_type(
-            field, root, nested_emit_queue, emitted_nested_fqns, enum_aliases
+            field, root, nested_emit_queue, emitted_nested_keys, enum_aliases, name_map
         )
         extra_imports.update(imports)
         # Optionality mirrors the cross-port (TS) payload-codegen: a ``@required``
@@ -515,9 +664,18 @@ def render_payload_vo(
     if payload is None:
         return None
 
+    # ADR-0044 pass 1/2 — the collision domain is this module's nested-payload
+    # closure. Seed `seen` with the primary VO's key so the primary (named after
+    # the TEMPLATE, not the VO) stays out of the VO-short-name collision domain.
+    closure: dict[str, MetaObject] = {}
+    _collect_nested_closure(root, payload, closure, {payload.resolution_key()})
+    name_map = _assign_nested_names(closure)
+
     # Per-file dedupe set: scoped to this single render call so each emitted
-    # module is self-contained (no cross-template forward references).
-    emitted_nested_fqns: set[str] = set()
+    # module is self-contained (no cross-template forward references). Keyed by
+    # ``resolution_key()`` (see _resolve_object_field_type) so two same-short-name
+    # VOs from different packages both emit.
+    emitted_nested_keys: set[str] = set()
     class_name = payload_class_name(template.name)
     extra_imports: set[str] = set()
     nested_emit_queue: list[tuple[MetaObject, str]] = []
@@ -541,13 +699,14 @@ def render_payload_vo(
         payload_vo=payload,
         root=root,
         nested_emit_queue=nested_emit_queue,
-        emitted_nested_fqns=emitted_nested_fqns,
+        emitted_nested_keys=emitted_nested_keys,
         extra_imports=extra_imports,
         enum_aliases=enum_aliases,
         docstring=(
             f"GENERATED payload for template ``{template.name}``.\n\n"
             f"    Field shape derived from the ``{payload.name}`` object.value."
         ),
+        name_map=name_map,
     )
     if strict_extras:
         primary_block = _with_strict_extras(primary_block)
@@ -564,12 +723,13 @@ def render_payload_vo(
             payload_vo=target,
             root=root,
             nested_emit_queue=nested_emit_queue,
-            emitted_nested_fqns=emitted_nested_fqns,
+            emitted_nested_keys=emitted_nested_keys,
             extra_imports=extra_imports,
             enum_aliases=enum_aliases,
             docstring=(
                 f"GENERATED nested payload for collection target ``{target.name}``."
             ),
+            name_map=name_map,
         )
         if strict_extras:
             block = _with_strict_extras(block)
@@ -650,10 +810,11 @@ class PayloadVoGenerator:
         payload_vo: MetaObject,
         root: MetaData,
         nested_emit_queue: list[tuple[MetaObject, str]],
-        emitted_nested_fqns: set[str],
+        emitted_nested_keys: set[str],
         extra_imports: set[str],
         enum_aliases: dict[str, str],
         docstring: str,
+        name_map: dict[str, str],
     ) -> list[str]:
         """EXTENSION SEAM — the source lines for one Pydantic ``BaseModel`` subclass
         (primary OR a nested collection target). Defaults to the module-level
@@ -664,10 +825,11 @@ class PayloadVoGenerator:
             payload_vo,
             root,
             nested_emit_queue,
-            emitted_nested_fqns,
+            emitted_nested_keys,
             extra_imports,
             enum_aliases,
             docstring,
+            name_map,
         )
 
     def _render_module(self, template: MetaTemplate, root: MetaData) -> str | None:

{metaobjects-0.19.2 → metaobjects-0.19.3}/src/metaobjects/errors.py

@@ -133,6 +133,9 @@ class ErrorCode(str, Enum):
     ERR_PARTIAL_UNRESOLVED = "ERR_PARTIAL_UNRESOLVED"
     ERR_REQUIRED_SLOT_UNUSED = "ERR_REQUIRED_SLOT_UNUSED"
     ERR_VAR_NOT_ON_PAYLOAD = "ERR_VAR_NOT_ON_PAYLOAD"
+    # Codegen (ADR-0044): two value-object FQNs in one payload artifact derive the same
+    # emitted record name even after package-qualification. Peer of ERR_VAR_NOT_ON_PAYLOAD.
+    ERR_PAYLOAD_NAME_COLLISION = "ERR_PAYLOAD_NAME_COLLISION"
     ERR_OUTPUT_TAG_MISSING = "ERR_OUTPUT_TAG_MISSING"
     # SP-H Unit9 — @filterable: true on a field subtype with no filter-operator
     # band (e.g. field.object). Would silently generate an empty-ops filter.

{metaobjects-0.19.2 → metaobjects-0.19.3}/tests/codegen/test_payload_vo_generator.py

@@ -8,10 +8,13 @@ same target).
 """
 from __future__ import annotations
 
+import pytest
+
 import metaobjects.core_types  # noqa: F401 — side-effect: registers attr classes
 from metaobjects.codegen.config import GenConfig
 from metaobjects.codegen.generator import GenContext
 from metaobjects.codegen.generators.payload_vo_generator import (
+    ERR_PAYLOAD_NAME_COLLISION,
     PayloadVoGenerator,
     payload_class_name,
     payload_module_name,
@@ -428,6 +431,92 @@ def test_plain_object_field_strips_fqn_to_bare_nested_payload() -> None:
     assert "::" not in code
 
 
+def test_cross_package_short_name_collision_qualifies_both_nested_classes() -> None:
+    """ADR-0044 — two ``object.value`` ``Note``s in different packages, both reachable
+    from one payload by FQN ``@objectRef``, emit as TWO distinct package-qualified
+    classes (``AcmeAlphaNotePayload`` / ``AcmeBetaNotePayload``) — never one shadowed
+    ``NotePayload`` that drops the second shape. The un-colliding ``Digest`` primary
+    stays bare (template-named)."""
+    alpha = _value_object("Note", [_field("alphaText", fc.FIELD_SUBTYPE_STRING)], package="acme::alpha")
+    beta = _value_object("Note", [_field("betaText", fc.FIELD_SUBTYPE_STRING)], package="acme::beta")
+    digest = _value_object(
+        "Digest",
+        [
+            _object_field("fromAlpha", "acme::alpha::Note"),
+            _object_field("fromBeta", "acme::beta::Note"),
+        ],
+        package="acme::app",
+    )
+    tmpl = _template("DigestOut", "Digest")
+    root = _root([alpha, beta, digest, tmpl])
+    out = render_payload_vo(tmpl, root)
+    assert out is not None
+    assert "class AcmeAlphaNotePayload(BaseModel):" in out
+    assert "class AcmeBetaNotePayload(BaseModel):" in out
+    assert "class NotePayload(BaseModel):" not in out
+    assert "fromAlpha: AcmeAlphaNotePayload | None = None" in out
+    assert "fromBeta: AcmeBetaNotePayload | None = None" in out
+    assert '__all__ = ["DigestOutPayload", "AcmeAlphaNotePayload", "AcmeBetaNotePayload"]' in out
+
+
+def test_nested_of_nested_collision_qualifies_across_depths() -> None:
+    """ADR-0044 — the collision domain is the WHOLE transitive closure, not one
+    depth. A ``Note`` reached at depth 2 (via ``Outer.inner``) collides with a
+    ``Note`` reached at depth 1; both qualify (``AcmeBetaNotePayload`` /
+    ``AcmeGammaNotePayload``) while the un-colliding intermediate ``Outer`` stays
+    bare. Guards the recursive `_collect_nested_closure` walk."""
+    beta_note = _value_object("Note", [_field("betaText", fc.FIELD_SUBTYPE_STRING)], package="acme::beta")
+    gamma_note = _value_object("Note", [_field("gammaText", fc.FIELD_SUBTYPE_STRING)], package="acme::gamma")
+    outer = _value_object(
+        "Outer", [_object_field("inner", "acme::beta::Note")], package="acme::alpha"
+    )
+    digest = _value_object(
+        "Digest",
+        [
+            _object_field("fromOuter", "acme::alpha::Outer"),
+            _object_field("fromGamma", "acme::gamma::Note"),
+        ],
+        package="acme::app",
+    )
+    tmpl = _template("DigestOut", "Digest")
+    root = _root([beta_note, gamma_note, outer, digest, tmpl])
+    out = render_payload_vo(tmpl, root)
+    assert out is not None
+    assert "class OuterPayload(BaseModel):" in out  # unique → bare
+    assert "class AcmeBetaNotePayload(BaseModel):" in out  # depth-2 collision member
+    assert "class AcmeGammaNotePayload(BaseModel):" in out  # depth-1 collision member
+    assert "class NotePayload(BaseModel):" not in out
+    assert "inner: AcmeBetaNotePayload | None = None" in out
+    assert "fromGamma: AcmeGammaNotePayload | None = None" in out
+
+
+def test_derived_name_still_colliding_fails_loud() -> None:
+    """ADR-0044 §4 backstop — two DISTINCT package FQNs whose package-qualified derived
+    names still collide (``acme::alpha`` and ``acmeAlpha`` both PascalCase-fold to
+    ``AcmeAlpha``) must fail loud with ``ERR_PAYLOAD_NAME_COLLISION``, never silently
+    emit one class twice."""
+    a = _value_object("Note", [_field("a", fc.FIELD_SUBTYPE_STRING)], package="acme::alpha")
+    b = _value_object("Note", [_field("b", fc.FIELD_SUBTYPE_STRING)], package="acmeAlpha")
+    digest = _value_object(
+        "Digest",
+        [
+            _object_field("fromA", "acme::alpha::Note"),
+            _object_field("fromB", "acmeAlpha::Note"),
+        ],
+        package="acme::app",
+    )
+    tmpl = _template("DigestOut", "Digest")
+    root = _root([a, b, digest, tmpl])
+    with pytest.raises(ValueError) as ei:
+        render_payload_vo(tmpl, root)
+    msg = str(ei.value)
+    assert ERR_PAYLOAD_NAME_COLLISION in msg
+    assert "AcmeAlphaNotePayload" in msg
+    # Both source FQNs are named so the author can find and rename one.
+    assert "acme::alpha::Note" in msg
+    assert "acmeAlpha::Note" in msg
+
+
 # ---------------------------------------------------------------------------
 # Resolution edge cases.
 # ---------------------------------------------------------------------------

{metaobjects-0.19.2 → metaobjects-0.19.3}/tests/codegen/test_render_helper_conformance.py

@@ -30,8 +30,8 @@ import metaobjects.core_types  # noqa: F401  — side-effect: registers attr cla
 from metaobjects import InMemoryStringSource, MetaDataLoader
 from metaobjects.codegen.config import GenConfig
 from metaobjects.codegen.generator import GenContext
+from metaobjects.codegen.generators.payload_vo_generator import PayloadVoGenerator
 from metaobjects.codegen.generators.render_helper_generator import RenderHelperGenerator
-from metaobjects.meta.template import template_constants as tc
 from metaobjects.render.email_document import EmailDocument
 from metaobjects.render.filesystem_provider import FilesystemProvider
 
@@ -194,6 +194,48 @@ def test_document_digest_doc_resolves_fqn_nested_object_ref_across_collision(tmp
     assert out == "Alpha=AA Beta=BB"
 
 
+def test_payload_vo_collision_emits_distinct_package_qualified_classes(tmp_path) -> None:
+    """ADR-0044 — the two colliding ``Note`` VOs (``acme::alpha`` / ``acme::beta``)
+    reachable from one payload module MUST emit as TWO distinct classes under their
+    package-qualified derived names (``AcmeAlphaNotePayload`` / ``AcmeBetaNotePayload``),
+    never one shadowed ``NotePayload`` (which dropped ``betaText`` and typed BOTH
+    fields against the alpha shape). The payload record is GENERATOR-emitted and
+    exercised by construction — the corpus README prohibits hand-authoring it."""
+    dir_root = CORPUS / "xpkg-collision"
+    root = _load_root_from_files(
+        dir_root / "meta.alpha.json",
+        dir_root / "meta.beta.json",
+        dir_root / "meta.app.json",
+    )
+    files = [f for f in PayloadVoGenerator().generate(_ctx(root))
+             if f.path == "digest_doc_payload.py"]
+    assert len(files) == 1
+    src = files[0].content
+    # Two DISTINCT package-qualified classes — and never the shadowed bare name.
+    assert "class AcmeAlphaNotePayload(BaseModel):" in src
+    assert "class AcmeBetaNotePayload(BaseModel):" in src
+    assert "class NotePayload(BaseModel):" not in src
+    # Each field binds to its OWN package's shape.
+    assert "fromAlpha: AcmeAlphaNotePayload | None = None" in src
+    assert "fromBeta: AcmeBetaNotePayload | None = None" in src
+
+    _materialize_and_import(files, tmp_path)
+    mod = import_module("_rh_conf_pkg.digest_doc_payload")
+    # The classes are real and DISTINCT: alpha carries alphaText, beta betaText.
+    alpha = mod.AcmeAlphaNotePayload(alphaText="AA")
+    beta = mod.AcmeBetaNotePayload(betaText="BB")
+    assert "alphaText" in mod.AcmeAlphaNotePayload.model_fields
+    assert "betaText" not in mod.AcmeAlphaNotePayload.model_fields
+    assert "betaText" in mod.AcmeBetaNotePayload.model_fields
+    assert "alphaText" not in mod.AcmeBetaNotePayload.model_fields
+    # No shadowed bare class leaked into the module namespace.
+    assert not hasattr(mod, "NotePayload")
+    # The primary payload composes the two distinct shapes.
+    digest = mod.DigestDocPayload(fromAlpha=alpha, fromBeta=beta)
+    assert digest.fromAlpha.alphaText == "AA"
+    assert digest.fromBeta.betaText == "BB"
+
+
 # ---------------------------------------------------------------------------
 # drift/ → codegen FAILS (ValueError) with ERR_VAR_NOT_ON_PAYLOAD.
 # ---------------------------------------------------------------------------