fix(metadata): ADR-0039 — resolving accessors are the default (Python port)

extends is a super-REFERENCE, not a flatten: inherited attrs/children/isArray
live on the parent, reachable only through the resolving accessors. Reading an
effective property or member set through an own-only accessor silently dropped
everything inherited via extends. Python's naming is INVERTED vs TS/Java —
attr(name) is OWN-ONLY, attrs().get(name) resolves — so this port both fixes the
own reads and makes the resolving form the obvious/default-named call.

Naming (the durable hardening): a full attr()->own_attr() rename was too invasive
(148 call sites, many legitimately own-only in the loader-validation of authored
declarations, plus the own-mode serializer/merge which already use own_meta_attrs/
own_children — NOT attr()). Instead:
  - added MetaData.get_meta_attr(name) — the RESOLVING attr read (own + inherited
    via the super chain); the default read to prefer for any effective property.
  - added MetaData.resolved_is_array() — isArray is a native boolean property (not
    an attr), so it resolves the native flag through the super chain OR the loaded
    @isarray attr. Mirrors the TS resolvedIsArray().
  - re-documented attr() LOUDLY as OWN-ONLY, calling out the TS/Java inversion and
    naming the only sanctioned own uses (own-mode serialize, overlay/merge + super
    walks, validating the own declaration, @dbColumnType).

Fixed effective-property reads (own -> resolving):
  - meta_field.object_ref: attr()->get_meta_attr (unifies with codegen attrs().get
    @objectref — both now resolve).
  - codegen fr010_field_mapping: is_array->resolved_is_array; coerceDefault/default/
    normalize (_attr_string) -> get_meta_attr.
  - codegen type_map.field_is_array + template_codegen/template_data (isArray/
    required/maxLength) -> resolving.
  - codegen fr019_shared_enum.is_provided (@provided) -> get_meta_attr.
  - runtime object_manager: identity @fields (PK lookup), @localTime, @column,
    field-is-array -> resolving; @dbColumnType kept own-only (commented — the one
    deliberately never-inherited attribute).
  - loader validation_passes: field.object @objectRef/@storage/isArray + field.map
    @valueType/@objectref + effective-children iteration -> resolving (a concrete
    field.object inheriting @objectref from an abstract parent no longer falsely
    trips ERR_OBJECT_FIELD_WITHOUT_OBJECT_REF). The own-declaration validators
    (@values / @default / @dbColumnType membership) stay own-only, commented.
  - serializer_json: EFFECTIVE mode now resolves isArray through the super chain;
    own mode still emits the authored flag (round-trips the extends tree).

KEPT own-only (each commented): the sanctioned emit-declared-here case
(EntityModelGenerator.own_fields, pinned by test_entity_model.py — a Contact
subclass extends the generated BaseEntity and does NOT re-emit inherited id/
createdAt); the own-mode canonical serializer; overlay/merge + TPH discriminator
super-resolution walks; the loader's validate-the-own-declaration passes; and the
physical @dbColumnType.

The shared cross-port fixture fixtures/conformance/extends-abstract-field-
inheritance (unchanged) now passes — the effective serializer previously dropped
the inherited isArray:true on tags/addresses. New Python codegen gate
(test_extends_abstract_field_inheritance.py) asserts a concrete field extending an
abstract array/decimal/object field, and an entity inheriting fields via
BaseEntity, generate correctly (list[str] / list[Address] / Decimal / subclass-
emit). Existing goldens unchanged for non-abstract-extends inputs (full non-
integration suite green except 2 pre-existing, unrelated staleness-nudge failures).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GF9xLEQZaPus5Y6opk398n

Author: claude

server/python/src/metaobjects/codegen/fr010_field_mapping.py

@@ -22,7 +22,6 @@
 from metaobjects.meta.meta_data import MetaData
 from metaobjects.meta.template.template_constants import TEMPLATE_ATTR_XML_TEXT
 from metaobjects.shared.base_types import TYPE_FIELD
-from metaobjects.shared.structural import KEY_IS_ARRAY
 
 
 def fields(vo: MetaData) -> list[MetaData]:
@@ -32,9 +31,10 @@ def fields(vo: MetaData) -> list[MetaData]:
 
 
 def is_array(field: MetaData) -> bool:
-    """Array-ness from either form: the node property (programmatic build) or the
-    ``@isArray`` attr (how metadata loads from JSON)."""
-    return bool(field.is_array) or field.attrs().get(KEY_IS_ARRAY) is True
+    """Effective array-ness (ADR-0039 resolving): the native ``is_array`` flag OR the
+    ``@isArray`` attr, resolved through the ``extends`` super chain so a concrete field
+    inheriting array-ness from an abstract parent is honored."""
+    return field.resolved_is_array()
 
 
 def is_required(field: MetaData) -> bool:
@@ -63,31 +63,36 @@ def enum_values(field: MetaData) -> list[str]:
     return []
 
 
-def _own_attr_string(node: MetaData, name: str) -> str | None:
-    """The own (locally declared) string value of attr *name*, or ``None``."""
-    v = node.attr(name)
+def _attr_string(node: MetaData, name: str) -> str | None:
+    """The RESOLVING string value of attr *name* (own + inherited via ``extends``),
+    or ``None``.
+
+    ADR-0039 — effective read: a concrete enum field extending an abstract enum may
+    inherit ``@coerceDefault``/``@default``/``@normalize`` from the abstract parent,
+    so these resolve through the super chain (``get_meta_attr``), never own-only."""
+    v = node.get_meta_attr(name)
     return v if isinstance(v, str) else None
 
 
 def coerce_default(field: MetaData) -> str | None:
-    """FR-011: the enum field's own ``@coerceDefault`` member, or ``None``."""
-    return _own_attr_string(field, fc.FIELD_ATTR_COERCE_DEFAULT)
+    """FR-011: the enum field's effective ``@coerceDefault`` member, or ``None``."""
+    return _attr_string(field, fc.FIELD_ATTR_COERCE_DEFAULT)
 
 
 def default_value(field: MetaData) -> str | None:
-    """FR-011: the enum field's own ``@default`` absent-fill member, or ``None``."""
-    return _own_attr_string(field, fc.FIELD_ATTR_DEFAULT)
+    """FR-011: the enum field's effective ``@default`` absent-fill member, or ``None``."""
+    return _attr_string(field, fc.FIELD_ATTR_DEFAULT)
 
 
 def resolve_normalize(field: MetaData, owner: MetaData | None) -> str:
     """FR-011: resolve the enum normalization mode — field-level ``@normalize``, else the
     owning ``object.value``'s ``@normalize`` (the per-object default), else the global
     default (``"strip"``). Mirrors the Java/Kotlin/C#/TS ``resolveNormalize``."""
-    field_mode = _own_attr_string(field, fc.FIELD_ATTR_NORMALIZE)
+    field_mode = _attr_string(field, fc.FIELD_ATTR_NORMALIZE)
     if field_mode is not None:
         return field_mode
     if owner is not None:
-        owner_mode = _own_attr_string(owner, fc.FIELD_ATTR_NORMALIZE)
+        owner_mode = _attr_string(owner, fc.FIELD_ATTR_NORMALIZE)
         if owner_mode is not None:
             return owner_mode
     return fc.NORMALIZE_DEFAULT

server/python/src/metaobjects/codegen/generators/fr019_shared_enum.py

@@ -66,8 +66,12 @@ def resolve_shared_enum_decl(field: MetaField) -> MetaData | None:
 
 
 def is_provided(decl: MetaData) -> bool:
-    """Own ``@provided`` truth of an enum declaration."""
-    return decl.attr(fc.FIELD_ATTR_PROVIDED) is True
+    """Effective ``@provided`` truth of an enum declaration.
+
+    ADR-0039 — resolves through ``extends`` (``get_meta_attr``): a concrete enum
+    extending an abstract ``@provided`` enum inherits the flag, so an own-only read
+    would misclassify it."""
+    return decl.get_meta_attr(fc.FIELD_ATTR_PROVIDED) is True
 
 
 def _meta_package_of(decl: MetaData) -> str:

server/python/src/metaobjects/codegen/template_codegen/template_data.py

@@ -52,7 +52,8 @@ def is_concrete(o: Any) -> bool:
 
 
 def _is_required(f: Any) -> bool:
-    if f.own_attrs().get(_VALIDATOR_REQUIRED) is True:
+    # ADR-0039 resolving: @required / a validator.required child may be inherited via extends.
+    if f.attrs().get(_VALIDATOR_REQUIRED) is True:
         return True
     return any(
         c.type == TYPE_VALIDATOR and c.sub_type == _VALIDATOR_REQUIRED
@@ -65,11 +66,12 @@ def _field_data(f: Any) -> dict[str, Any]:
         "name": f.name,
         "type": f.sub_type,
         "required": _is_required(f),
-        "isArray": bool(f.is_array),
+        # ADR-0039 resolving: a concrete field may inherit isArray/@maxLength from an abstract parent.
+        "isArray": f.resolved_is_array(),
     }
-    own = f.own_attrs()
-    if "maxLength" in own:
-        d["maxLength"] = int(own["maxLength"])
+    eff = f.attrs()
+    if "maxLength" in eff:
+        d["maxLength"] = int(eff["maxLength"])
     if f.sub_type == _SUBTYPE_ENUM:
         values = f.attrs().get("values")
         if isinstance(values, list):

server/python/src/metaobjects/codegen/type_map.py

@@ -6,7 +6,6 @@
 from metaobjects.meta.core.field.meta_field import MetaField
 from metaobjects.meta.core.field import field_constants as fc
 from metaobjects.meta.persistence.db import db_constants as dbc
-from metaobjects.shared.structural import KEY_IS_ARRAY
 
 
 @dataclass(frozen=True)
@@ -43,9 +42,11 @@ class PyType:
 
 
 def field_is_array(field: MetaField) -> bool:
-    """Array-ness from either form: the node property (programmatic build) or the
-    `@isArray` attr (how metadata loads from JSON — the conformance-fixture form)."""
-    return field.is_array or field.attrs().get(KEY_IS_ARRAY) is True
+    """Effective array-ness (ADR-0039 resolving): the native ``is_array`` flag OR
+    the ``@isArray`` attr, resolved through the ``extends`` super chain — a concrete
+    field inheriting ``isArray:true`` from an abstract parent (whose flag lives on the
+    parent as a native property, not an attr) must generate a ``list[...]``."""
+    return field.resolved_is_array()
 
 
 def _py_str_literal(value: str) -> str:

server/python/src/metaobjects/loader/validation_passes.py

@@ -2108,7 +2108,10 @@ def _validate_field_object_storage(root: MetaData, errors: list[MetaError]) -> N
     for node in _walk(root):
         if node.type != TYPE_FIELD or node.sub_type != FIELD_SUBTYPE_OBJECT:
             continue
-        object_ref = node.attr(FIELD_ATTR_OBJECT_REF)
+        # ADR-0039 resolving: a concrete field.object may inherit @objectRef from an
+        # abstract parent field via extends — read the effective value, not own-only,
+        # or a valid inherited target falsely trips ERR_OBJECT_FIELD_WITHOUT_OBJECT_REF.
+        object_ref = node.get_meta_attr(FIELD_ATTR_OBJECT_REF)
         if not (isinstance(object_ref, str) and object_ref):
             errors.append(MetaError(
                 code=ErrorCode.ERR_OBJECT_FIELD_WITHOUT_OBJECT_REF,
@@ -2120,10 +2123,10 @@ def _validate_field_object_storage(root: MetaData, errors: list[MetaError]) -> N
                 envelope=node.source,
             ))
             continue
-        storage = node.attr(FIELD_ATTR_STORAGE)
+        storage = node.get_meta_attr(FIELD_ATTR_STORAGE)  # ADR-0039 resolving
         if storage is None:
             continue
-        if storage == "flattened" and getattr(node, "is_array", False):
+        if storage == "flattened" and node.resolved_is_array():  # ADR-0039 resolving isArray
             errors.append(MetaError(
                 code=ErrorCode.ERR_STORAGE_FLATTENED_ARRAY,
                 message=(
@@ -2163,14 +2166,17 @@ def _validate_field_object_storage(root: MetaData, errors: list[MetaError]) -> N
 
 
 def _validate_field_map(root: MetaData, errors: list[MetaError]) -> None:
-    for obj in (c for c in root.own_children() if c.type == TYPE_OBJECT):
-        for field in (c for c in obj.own_children() if c.type == TYPE_FIELD):
+    # ADR-0039: iterate EFFECTIVE members (children()) so an object inheriting a
+    # field.map through extends is still validated; and read @valueType/@objectRef
+    # via the resolving get_meta_attr (they may be inherited from an abstract parent).
+    for obj in (c for c in root.children() if c.type == TYPE_OBJECT):
+        for field in (c for c in obj.children() if c.type == TYPE_FIELD):
             if field.sub_type != FIELD_SUBTYPE_MAP:
                 continue
 
-            value_type = field.attr(FIELD_ATTR_VALUE_TYPE)
+            value_type = field.get_meta_attr(FIELD_ATTR_VALUE_TYPE)
             has_value_type = isinstance(value_type, str) and bool(value_type)
-            object_ref = field.attr(FIELD_ATTR_OBJECT_REF)
+            object_ref = field.get_meta_attr(FIELD_ATTR_OBJECT_REF)
             has_object_ref = isinstance(object_ref, str) and bool(object_ref)
 
             if has_value_type == has_object_ref:

server/python/src/metaobjects/meta/core/field/meta_field.py

@@ -44,8 +44,13 @@ def object_ref(self) -> str | None:
 
         The value is the package-folded form (e.g. ``com::example::om::Address``)
         — matching a target object's ``resolution_key()``.
+
+        ADR-0039 — RESOLVING (``get_meta_attr``): ``@objectRef`` is an effective
+        property, so a concrete ``field.object`` extending an abstract one inherits
+        its target. Unifies with the codegen ``attrs().get(@objectRef)`` path (both
+        now resolve through the ``extends`` super chain).
         """
-        v = self.attr(fc.FIELD_ATTR_OBJECT_REF)
+        v = self.get_meta_attr(fc.FIELD_ATTR_OBJECT_REF)
         return str(v) if v is not None else None
 
     def get_value(self, obj: object, name: str | None = None) -> object:

server/python/src/metaobjects/meta/meta_data.py

@@ -6,6 +6,7 @@
 from ..attr_class_map import attr_class_for
 from ..shared.base_types import SUBTYPE_BASE, TYPE_ATTR
 from ..shared.separators import PACKAGE_SEP
+from ..shared.structural import KEY_IS_ARRAY
 from ..source import CodeSource, ErrorSource
 
 T = TypeVar("T")
@@ -121,10 +122,54 @@ def own_meta_attrs(self) -> list[MetaData]:
         return list(self._attr_nodes.values())
 
     def attr(self, name: str) -> object:
-        """Own attr value for *name*, or ``None``."""
+        """OWN-ONLY attr value for *name*, or ``None``.
+
+        ADR-0039 — NAMING INVERSION (Python vs TS/Java): in Python ``attr()`` is
+        OWN-ONLY (reads only this node's locally-declared attr, never the super
+        chain), whereas TS/Java ``attr()`` RESOLVES. **Do not use ``attr()`` to
+        read an effective/semantic property** (``@objectRef``/``@column``/
+        ``@default``/``@maxLength``/``@precision``/``@storage``/``@required``/…) —
+        a value inherited through this node's ``extends`` chain would be silently
+        dropped. Use the resolving ``get_meta_attr(name)`` (or ``attrs().get(name)``)
+        instead. ``attr()`` is legitimate ONLY for: own-mode canonical
+        serialization, overlay/merge + super-resolution walks, validating the
+        *own* declaration, and the deliberately-never-inherited ``@dbColumnType``.
+        Every such call MUST carry a one-line comment naming the sanctioned case.
+        """
         node = self._attr_nodes.get(name)
         return getattr(node, "value", None) if node is not None else None
 
+    def get_meta_attr(self, name: str) -> object:
+        """RESOLVING attr value for *name* — own + inherited via the ``extends``
+        super chain (own wins on conflict), or ``None``.
+
+        ADR-0039 — this is the default/effective read. Prefer it over ``attr()``
+        (which is own-only in Python; see the inversion note there) for any
+        semantic property that may be inherited from an abstract parent.
+        """
+        return self.attrs().get(name)
+
+    def resolved_is_array(self) -> bool:
+        """RESOLVING array-ness — the effective ``isArray`` for this node.
+
+        ADR-0039 — mirrors the TS ``MetaData.resolvedIsArray()``. ``is_array`` is a
+        native boolean property (not an attr), so it is resolved two ways: the
+        native flag on this node OR any super in the chain has it set, OR the
+        loaded-from-JSON ``@isArray`` attr resolves true through ``attrs()``.
+        Reading the own ``is_array`` flag alone silently drops an array-ness
+        inherited from an abstract parent field.
+        """
+        if self.is_array:
+            return True
+        node = self.super_data
+        seen: set[MetaData] = {self}
+        while node is not None and node not in seen:
+            if node.is_array:
+                return True
+            seen.add(node)
+            node = node.super_data
+        return self.attrs().get(KEY_IS_ARRAY) is True
+
     def own_attrs(self) -> dict[str, object]:
         """Own attr value map — excludes inherited attrs."""
         return {

server/python/src/metaobjects/runtime/object_manager.py

@@ -39,7 +39,6 @@
 from ..meta.persistence.db import db_constants as dbc
 from ..meta.persistence.source.meta_source import MetaSource
 from ..meta.persistence.source import source_constants as sc
-from ..shared.structural import KEY_IS_ARRAY
 from .n2m_resolver import (
     N2mDescriptor,
     collect_column_ids,
@@ -563,7 +562,7 @@ def _primary_pk_field(self, entity: MetaObject) -> str:
         pi = entity.primary_identity()
         if pi is None:
             raise ValueError(f"Entity '{entity.name}' has no primary identity")
-        raw = pi.attr(ic.IDENTITY_ATTR_FIELDS)
+        raw = pi.get_meta_attr(ic.IDENTITY_ATTR_FIELDS)  # ADR-0039 resolving: identity @fields may be inherited
         if isinstance(raw, str):
             return raw
         if isinstance(raw, (list, tuple)) and raw:
@@ -645,14 +644,18 @@ def _op_clause(col: str, op: str, value: Any) -> tuple[str, list[Any]]:
 
 
 def _field_is_array(field: MetaField) -> bool:
-    """Array-ness from either form: the node property or the ``@isArray`` attr."""
-    return bool(field.is_array) or field.attr(KEY_IS_ARRAY) is True
+    """Effective array-ness (ADR-0039 resolving): the native ``is_array`` flag OR
+    the ``@isArray`` attr, resolved through the ``extends`` super chain so a concrete
+    field inheriting array-ness from an abstract parent is honored at write time."""
+    return field.resolved_is_array()
 
 
 def _coerce_write_value(field: MetaField, value: Any) -> Any:
     if value is None:
         return None
     sub = field.sub_type
+    # ADR-0039 own-only: @dbColumnType is a physical column-type override, never
+    # inherited via extends (the one deliberately own-only attribute).
     col_type = field.attr(dbc.FIELD_ATTR_DB_COLUMN_TYPE)
 
     # decimal / currency: a decimal authored as a string → Decimal (exact; never
@@ -684,7 +687,7 @@ def _coerce_write_value(field: MetaField, value: Any) -> Any:
     if sub == fc.FIELD_SUBTYPE_TIMESTAMP:
         if isinstance(value, _dt.datetime):
             return value
-        is_tz = field.attr(dbc.FIELD_ATTR_LOCAL_TIME) is not True
+        is_tz = field.get_meta_attr(dbc.FIELD_ATTR_LOCAL_TIME) is not True  # ADR-0039 resolving: @localTime may be inherited
         return _parse_datetime(str(value), tz_aware=is_tz)
 
     # field.object (jsonb storage): a dict/list passes through — pg8000 binds it
@@ -718,7 +721,7 @@ def _parse_datetime(text: str, *, tz_aware: bool) -> _dt.datetime:
 def _column_of(field: MetaField | None) -> str:
     if field is None:
         return ""
-    col = field.attr(fc.FIELD_ATTR_COLUMN)
+    col = field.get_meta_attr(fc.FIELD_ATTR_COLUMN)  # ADR-0039 resolving: @column may be inherited
     return col if isinstance(col, str) and col else field.name
 
 

server/python/src/metaobjects/serializer_json.py

@@ -66,7 +66,11 @@ def _body(node: MetaData, effective: bool = False) -> dict[str, object]:
         body[KEY_EXTENDS] = node.super_ref
     if node.is_abstract:
         body[KEY_ABSTRACT] = True
-    if node.is_array:
+    # ADR-0039 — isArray is a native property; in EFFECTIVE mode it must resolve
+    # through the extends super chain (a concrete field inheriting isArray:true
+    # from an abstract parent), whereas own-mode emits only the locally-declared
+    # flag (round-trips the authored form).
+    if node.resolved_is_array() if effective else node.is_array:
         body[KEY_IS_ARRAY] = True
 
     # In effective mode use attrs()/children() (own + inherited via the super