metaobjects 0.19.1__tar.gz → 0.19.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.19.1
+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.1 → metaobjects-0.19.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.19.1"
+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.1 → metaobjects-0.19.3}/src/metaobjects/codegen/generators/entity_model.py

@@ -99,7 +99,7 @@ def _first_attr(field: MetaField, sub_type: str, attr_name: str) -> object | Non
     return None
 
 
-def _validator_constraints(field: MetaField, wire: bool = False) -> dict[str, object]:
+def _validator_constraints(field: MetaField, *, wire: bool) -> dict[str, object]:
     """Map the field's ``validator.*`` children + field attrs to Pydantic ``Field``
     kwargs. Cross-port-canonical semantics (TS is the reference):
 
@@ -114,8 +114,13 @@ def _validator_constraints(field: MetaField, wire: bool = False) -> dict[str, ob
     every OTHER constraint above unconditionally but must not self-validate Pin 1
     at construction (that broke a downstream adopter's in-process prompt-payload
     ``object.value`` models on legitimately-empty slots). Callers building a read
-    model (``_field_line``) pass the default ``False``; callers building a wire
-    model (``_create_field_line``/``_patch_field_line``) pass ``True``.
+    model (``_field_line``) pass ``wire=False``; callers building a wire model
+    (``_create_field_line``/``_patch_field_line``) pass ``wire=True``.
+
+    *wire* is keyword-only and REQUIRED (no default, item 5 of the #224
+    cleanup): a forgotten flag at a future wire call site must fail loudly
+    (``TypeError``) at generation time rather than silently falling back to a
+    permissive read-model tier.
     """
     kwargs: dict[str, object] = {}
 
@@ -171,17 +176,26 @@ def _validator_constraints(field: MetaField, wire: bool = False) -> dict[str, ob
         kwargs["pattern"] = _HOSTNAME_REGEX
 
     # FR-036 Pin 1 (#224 — WIRE TIER ONLY) — a @required non-array string is
-    # non-empty: reject null / "" but ACCEPT whitespace-only. Emit an implicit
-    # min_length of 1, keeping the stricter floor if a validator.length @min
-    # already set one. Never applied to the in-process read model (wire=False).
+    # non-empty by default: reject null / "" but ACCEPT whitespace-only. Emit an
+    # implicit min_length of 1 ONLY when no validator.length @min was authored.
+    # Never applied to the in-process read model (wire=False).
+    #
+    # An explicitly authored @min is always AUTHORITATIVE over the implicit floor
+    # (ADR-0044 ruling on #224) — @min: 0 restores "must be provided, may be
+    # empty" by opting out of the non-empty floor entirely. Per the cross-port
+    # emission pin, an authored @min: 0 emits NO minimum constraint at all
+    # (cleanest, deterministic output across ports), so it is popped rather than
+    # kept as min_length=0.
     if (
         wire
         and field.sub_type == fc.FIELD_SUBTYPE_STRING
         and not field_is_array(field)
         and field.attrs().get(fc.FIELD_ATTR_REQUIRED) is True
     ):
-        existing_min = kwargs.get("min_length")
-        kwargs["min_length"] = max(1, existing_min) if isinstance(existing_min, int) else 1
+        if min_len is None:
+            kwargs["min_length"] = 1
+        elif min_len == 0:
+            kwargs.pop("min_length", None)
 
     return kwargs
 
@@ -196,7 +210,7 @@ def _constraint_parts(constraints: dict[str, object]) -> list[str]:
 
 
 def _type_expr_for_field(
-    field: MetaField, imports: set[str], config: GenConfig, wire: bool = False
+    field: MetaField, imports: set[str], config: GenConfig, *, wire: bool
 ) -> tuple[str, str | None]:
     """The Python annotation text for *field* (arrays wrapped in ``list[...]``) plus the
     shared-enum class name when the field resolves to one (used to render an enum
@@ -211,7 +225,10 @@ def _type_expr_for_field(
     ``@objectRef`` annotates with the referenced VO's own WIRE model (``<Ref>Create``)
     rather than its read model, so a required-string Pin 1 violation nested inside the
     VO still validates on the wire (api-contract jsonb r10). A VO's own Create lines
-    are emitted through this same wire path, so nested-VO-in-VO recurses naturally."""
+    are emitted through this same wire path, so nested-VO-in-VO recurses naturally.
+
+    *wire* is keyword-only and REQUIRED (no default, item 5 of the #224 cleanup)
+    — see ``_validator_constraints`` for the rationale."""
     shared = (
         fr019.shared_enum_for_field(field)
         if field.sub_type == fc.FIELD_SUBTYPE_ENUM
@@ -275,7 +292,7 @@ def origin_guaranteed_non_null(field: MetaField) -> bool:
 
 def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple[str, bool]:
     """Return (source line, uses_field). Collects required imports into *imports*."""
-    type_expr, enum_type_name = _type_expr_for_field(field, imports, config)
+    type_expr, enum_type_name = _type_expr_for_field(field, imports, config, wire=False)
     required = field.attrs().get(fc.FIELD_ATTR_REQUIRED) is True
     default_raw = field.attrs().get(fc.FIELD_ATTR_DEFAULT)
     # A server-side expression default (now(), gen_random_uuid(), CURRENT_TIMESTAMP)
@@ -283,7 +300,7 @@ def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple
     # its required/optional shape). Only literal defaults become Pydantic defaults.
     has_default = default_raw is not None and not _is_sql_expr_default(default_raw)
 
-    parts = _constraint_parts(_validator_constraints(field))
+    parts = _constraint_parts(_validator_constraints(field, wire=False))
     uses_field = bool(parts)
 
     # @default — render an enum member (Type.MEMBER, UPPER_CASE) or a Python literal.

{metaobjects-0.19.1 → 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.1 → 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.1 → metaobjects-0.19.3}/src/metaobjects/spec_metamodel/field.json

@@ -10,7 +10,7 @@
         { "type": "validator", "subType": "*", "name": "*", "min": 0, "max": null },
         { "type": "view", "subType": "*", "name": "*", "min": 0, "max": null },
         { "type": "origin", "subType": "*", "name": "*", "min": 0, "max": null },
-        { "type": "attr", "subType": "boolean", "name": "required", "min": 0, "max": 1, "description": "When true, the field is NOT NULL. Equivalent to attaching a validator.required child." },
+        { "type": "attr", "subType": "boolean", "name": "required", "min": 0, "max": 1, "description": "When true, the field is NOT NULL. Equivalent to attaching a validator.required child. On a non-array string, generated wire-tier input validation (create/patch) additionally rejects the empty string by default — whitespace is accepted — unless an explicit validator.length @min: 0 opts back to presence-only. In-process read models never enforce this at construction." },
         { "type": "attr", "subType": "boolean", "name": "readOnly", "min": 0, "max": 1, "description": "FR-013: when true, the field is read-only — codegen emits no setter / writable property, the persistence layer skips the column on INSERT/UPDATE, and Zod/Pydantic/class-validator schemas mark it read-only on input variants. The value is populated by the database (computed column, default expression, trigger), by replication, or by another external owner." },
         { "type": "attr", "name": "default", "min": 0, "max": 1, "description": "Default value applied to the column when no value is supplied. Its type follows the field's own subtype (string / boolean / number / ...). Converted at consumption time via MetaField.defaultValue()." },
         { "type": "attr", "subType": "boolean", "name": "unique", "min": 0, "max": 1, "description": "When true, the field gets a column-level UNIQUE constraint." }

{metaobjects-0.19.1 → metaobjects-0.19.3}/src/metaobjects/spec_metamodel/validator.json

@@ -13,8 +13,8 @@
     {
       "type": "validator",
       "subType": "required",
-      "description": "Fails when the value is null/empty (NOT NULL). Equivalent to @required on the owning field.",
-      "whenToUse": "A field must be present (NOT NULL). Declare it instead of hand-writing a null/empty check."
+      "description": "Fails when the value is null (NOT NULL). Equivalent to @required on the owning field: on a non-array string, generated wire-tier input validation also rejects the empty string by default unless an explicit validator.length @min: 0 opts back to presence-only.",
+      "whenToUse": "A field must be present (NOT NULL). Declare it instead of hand-writing a presence check."
     },
     {
       "type": "validator",

{metaobjects-0.19.1 → metaobjects-0.19.3}/tests/codegen/test_cli_staleness_nudge.py

@@ -47,7 +47,7 @@ def test_gen_nudges_on_stale_manifest(tmp_path, capsys, monkeypatch) -> None:
     assert rc == 0  # advisory: never changes the exit code
     err = capsys.readouterr().err
     assert "0.0.1-old" in err
-    assert "metaobjects agent-docs" in err
+    assert "npx meta agent-docs" in err
 
 
 def test_verify_nudges_on_stale_manifest(tmp_path, capsys, monkeypatch) -> None:
@@ -65,7 +65,7 @@ def test_verify_nudges_on_stale_manifest(tmp_path, capsys, monkeypatch) -> None:
     assert rc == 0
     err = capsys.readouterr().err
     assert "0.0.1-old" in err
-    assert "metaobjects agent-docs" in err
+    assert "npx meta agent-docs" in err
 
 
 def test_gen_silent_when_no_manifest(tmp_path, capsys, monkeypatch) -> None:
@@ -76,7 +76,7 @@ def test_gen_silent_when_no_manifest(tmp_path, capsys, monkeypatch) -> None:
     rc = main(["gen", meta_dir, "--out", str(out)])
     assert rc == 0
     err = capsys.readouterr().err
-    assert "metaobjects agent-docs" not in err
+    assert "npx meta agent-docs" not in err
 
 
 def test_gen_silent_on_corrupt_manifest(tmp_path, capsys, monkeypatch) -> None:
@@ -90,4 +90,4 @@ def test_gen_silent_on_corrupt_manifest(tmp_path, capsys, monkeypatch) -> None:
     rc = main(["gen", meta_dir, "--out", str(out)])
     assert rc == 0
     err = capsys.readouterr().err
-    assert "metaobjects agent-docs" not in err
+    assert "npx meta agent-docs" not in err

{metaobjects-0.19.1 → 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.
 # ---------------------------------------------------------------------------