metaobjects 0.13.0__tar.gz → 0.15.0__tar.gz

{metaobjects-0.13.0 → metaobjects-0.15.0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.13.0"
+version = "0.15.0"
 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.13.0 → metaobjects-0.15.0}/src/metaobjects/apidocs/builder.py

@@ -85,21 +85,21 @@ def _is_writable_table_entity(obj: MetaObject, object_index: dict[str, MetaObjec
 
 
 def _template_format(tmpl: MetaData) -> str:
-    fmt = tmpl.attr(tc.TEMPLATE_ATTR_FORMAT)
+    fmt = tmpl.get_meta_attr(tc.TEMPLATE_ATTR_FORMAT)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     return fmt if isinstance(fmt, str) and fmt else tc.TEMPLATE_FORMAT_DEFAULT
 
 
 def _payload_resolves(tmpl: MetaData, root: MetaData) -> MetaObject | None:
     """The payload VO a template resolves to (``@payloadRef`` → ``object.value``),
     or ``None`` — the shared gate for payload / render / prompt / parser / extractor."""
-    payload_ref = tmpl.attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)
+    payload_ref = tmpl.get_meta_attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     if not isinstance(payload_ref, str) or not payload_ref:
         return None
     return resolve_payload_vo(root, payload_ref)
 
 
 def _is_email_kind(tmpl: MetaData) -> bool:
-    kind = tmpl.attr(tc.TEMPLATE_ATTR_KIND)
+    kind = tmpl.get_meta_attr(tc.TEMPLATE_ATTR_KIND)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     return isinstance(kind, str) and kind.lower() == tc.TEMPLATE_KIND_EMAIL
 
 
@@ -113,6 +113,7 @@ class PythonApiModelBuilder:
 
     def build(self, root: MetaData, project: str) -> ApiModel:
         objects = [
+            # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
             c
             for c in root.own_children()
             if c.type == TYPE_OBJECT and isinstance(c, MetaObject)
@@ -127,6 +128,7 @@ class PythonApiModelBuilder:
 
         # Templates: only template.output is consumed by the payload/render/prompt/
         # parser/extractor generators (the other template subtypes emit nothing).
+        # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
         for tmpl in root.own_children():
             if tmpl.type == TYPE_TEMPLATE and tmpl.sub_type == tc.TEMPLATE_SUBTYPE_OUTPUT:
                 units.append(self._build_template_unit(tmpl, root))
@@ -353,7 +355,7 @@ class PythonApiModelBuilder:
                 values = type_map.effective_enum_values(f)
                 if values:
                     note = "allowed: " + " | ".join(values)
-            required = f.attr(fc.FIELD_ATTR_REQUIRED) is True
+            required = f.get_meta_attr(fc.FIELD_ATTR_REQUIRED) is True  # ADR-0039: resolving (@required may be inherited)
             rows.append(FieldShape(f.name, type_expr, optional=not required, note=note))
         return rows
 

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/apidocs/naming.py

@@ -39,6 +39,9 @@ __all__ = [
     "output_prompt_fn",
     "output_parser_fn",
     "extractor_fn",
+    "reverse_finder_fk_segment",
+    "reverse_finder_fn",
+    "reverse_finder_in_fn",
 ]
 
 
@@ -121,3 +124,75 @@ def output_parser_fn(template_name: str) -> str:
 def extractor_fn(template_name: str) -> str:
     """``OrderSummary`` → ``extract_order_summary`` (the strict extractor fn)."""
     return f"extract_{snake_case(template_name)}"
+
+
+# ---------------------------------------------------------------------------
+# ADR-0038 — reverse-relationship navigation as explicit FK finders.
+#
+# For each FK an entity ``E`` holds (an ``identity.reference`` over an FK field
+# referencing entity ``T``), ``E``'s repository surface gains a finder returning
+# the ``E`` rows matching a given ``T`` id — so ``T`` navigates to its referencing
+# ``E`` rows by calling the finder with a ``T`` id. Two variants: a single-value
+# finder and a batched (anti-N+1) ``…_in`` finder. Both are plain, framework-free
+# single queries (``WHERE <fk> = ?`` / ``WHERE <fk> IN (…)``) — NOT lazy ORM
+# collections (ADR-0038: lazy collections are impossible framework-free and are
+# the canonical N+1 anti-pattern).
+#
+# CANONICAL NAMING (the cross-port contract — idiomatic Python snake_case spelling
+# of the cross-port shape ``find<EPlural>By<FkField>`` / ``…In``):
+#
+#   find_<e_plural>_by_<fk_segment>(value)     → SELECT … FROM E WHERE <fk> = ?
+#   find_<e_plural>_by_<fk_segment>_in(values) → SELECT … FROM E WHERE <fk> IN (…)
+#
+# where:
+#   - <e_plural>   is the source entity name pluralized then snake_cased
+#     (``GameSession`` → ``game_sessions``).
+#   - <fk_segment> is the FK FIELD name (NOT the relationship/navigation name and
+#     NOT the raw column), snake_cased, with a single trailing ``_id`` dropped if
+#     present. The FK field name is unique within an entity, so the finder name is
+#     unique by construction — this dissolves the same-pair collision and removes
+#     any need for a naming attribute.
+#
+# SAME-PAIR EXAMPLE (``GameSession`` has THREE FKs to ``Scene``):
+#   FK field ``currentSceneId``               → find_game_sessions_by_current_scene
+#   FK field ``lastOpeningNarrativeSceneId``  → find_game_sessions_by_last_opening_narrative_scene
+#   FK field ``transitioningFromSceneId``     → find_game_sessions_by_transitioning_from_scene
+# Three distinct finders — no collision.
+# ---------------------------------------------------------------------------
+
+
+def _pluralize(name: str) -> str:
+    """Trivial cross-port pluralization (matches the TS ``pluralize`` /
+    ``MetaSource._pluralize``), applied to a PascalCase entity name BEFORE
+    snake-casing (``GameSession`` → ``GameSessions``)."""
+    if not name:
+        return name
+    lower = name.lower()
+    if lower.endswith(("s", "x", "z", "ch", "sh")):
+        return name + "es"
+    if len(name) >= 2 and lower[-1] == "y" and lower[-2] not in "aeiou":
+        return name[:-1] + "ies"
+    return name + "s"
+
+
+def reverse_finder_fk_segment(fk_field_name: str) -> str:
+    """Lower an FK field name to the ``<fk_segment>`` of a reverse finder name:
+    snake_case the field, then drop a single trailing ``_id`` if present.
+    E.g. ``currentSceneId`` → ``current_scene``, ``authorId`` → ``author``,
+    ``scene`` → ``scene``."""
+    snake = snake_case(fk_field_name)
+    # Drop a single trailing "_id" (but not a bare "id" — that would yield "").
+    if len(snake) > 3 and snake.endswith("_id"):
+        return snake[:-3]
+    return snake
+
+
+def reverse_finder_fn(source_entity_name: str, fk_field_name: str) -> str:
+    """Reverse single-value finder name: ``find_<e_plural>_by_<fk_segment>``."""
+    e_plural = snake_case(_pluralize(source_entity_name))
+    return f"find_{e_plural}_by_{reverse_finder_fk_segment(fk_field_name)}"
+
+
+def reverse_finder_in_fn(source_entity_name: str, fk_field_name: str) -> str:
+    """Reverse batched finder name: ``find_<e_plural>_by_<fk_segment>_in``."""
+    return f"{reverse_finder_fn(source_entity_name, fk_field_name)}_in"

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/cli.py

@@ -103,15 +103,33 @@ def _default_generators() -> list[Generator]:
     ]
 
 
-def _load_root(metadata_dir: str) -> tuple[MetaData | None, list[str]]:
-    """Load metadata; return ``(root, error_messages)``. ``root`` is None on error."""
-    result = MetaDataLoader.from_directory(metadata_dir)
+def _load_root(
+    metadata_dir: str, strict: bool = False
+) -> tuple[MetaData | None, list[str]]:
+    """Load metadata; return ``(root, error_messages)``. ``root`` is None on error.
+
+    ``strict`` (ADR-0023, #96) — when True, an undeclared own ``@attr`` →
+    ``ERR_UNKNOWN_ATTR``. Defaults False so ``gen`` / ``docs`` keep the legacy
+    open-attr load; only ``verify`` opts in (strict-by-default with a ``--lax``
+    escape).
+    """
+    result = MetaDataLoader.from_directory(metadata_dir, strict=strict)
     if result.errors:
         msgs = [f"{e.code}: {e.message}" for e in result.errors]
         return None, msgs
     return result.root, []
 
 
+def _strict_load_hint() -> str:
+    """Actionable next-steps when strict verify rejects an undeclared @attr."""
+    return (
+        "verify is strict (ADR-0023): every authored @attr must be declared. Fix: "
+        "register the attr on a metadata provider, OR move arbitrary author-supplied "
+        "properties into an `attr.properties` bag, OR re-run with `--lax` to keep the "
+        "legacy open-attr load."
+    )
+
+
 def _resolve_generators(names: str) -> tuple[list[Generator], list[str]]:
     """Resolve a comma-separated list of STABLE generator names via the registry.
 
@@ -174,6 +192,7 @@ def _generate(
     generators: list[Generator] | None = None,
     entity_filter: list[str] | None = None,
     emit_package_init: bool = True,
+    strict: bool = False,
 ) -> tuple[list[str], list[str]]:
     """Run the generator suite into ``out_dir``.
 
@@ -186,9 +205,10 @@ def _generate(
     output is text/markdown/csv/json/xml/html, never a Python package) so no
     spurious ``__init__.py`` is scattered through their output tree. Returns
     ``(written_paths, errors)``. On a load error, ``errors`` is non-empty and no
-    files are written.
+    files are written. ``strict`` (ADR-0023, #96) is threaded to the load — the
+    ``verify --codegen`` caller passes True; ``gen`` keeps the default False.
     """
-    root, errors = _load_root(metadata_dir)
+    root, errors = _load_root(metadata_dir, strict=strict)
     if root is None:
         return [], errors
     return _run_suite(root, out_dir, generators, entity_filter, emit_package_init), []
@@ -408,13 +428,20 @@ def _verify_codegen(args: argparse.Namespace) -> int:
     # Reuse the exact gen code path — regenerate into a throwaway temp dir. The
     # --entities filter must match the `gen` that produced --out, or the diff
     # reports the un-emitted entities as spurious drift.
+    # ADR-0023 strict-by-default (#96): verify loads strict unless --lax is given,
+    # so an undeclared/typo'd own @attr fails verify (matching Java's Maven goal).
+    strict = not getattr(args, "lax", False)
     with tempfile.TemporaryDirectory() as tmp:
         entities = _parse_entities(getattr(args, "entities", None))
-        written, errors = _generate(args.metadata_dir, tmp, None, entities)
+        written, errors = _generate(
+            args.metadata_dir, tmp, None, entities, strict=strict
+        )
         if errors:
             print("error: failed to load metadata:", file=sys.stderr)
             for msg in errors:
                 print(f"  {msg}", file=sys.stderr)
+            if strict and any("ERR_UNKNOWN_ATTR" in m for m in errors):
+                print(_strict_load_hint(), file=sys.stderr)
             return 1
 
         expected = _relative_set(Path(tmp))
@@ -478,17 +505,23 @@ def _verify_templates(args: argparse.Namespace) -> int:
         )
         return 2
 
-    root, errors = _load_root(args.metadata_dir)
+    # ADR-0023 strict-by-default (#96) — same as --codegen: an undeclared @attr
+    # fails verify unless --lax is passed.
+    strict = not getattr(args, "lax", False)
+    root, errors = _load_root(args.metadata_dir, strict=strict)
     if root is None:
         print("error: failed to load metadata:", file=sys.stderr)
         for msg in errors:
             print(f"  {msg}", file=sys.stderr)
+        if strict and any("ERR_UNKNOWN_ATTR" in m for m in errors):
+            print(_strict_load_hint(), file=sys.stderr)
         return 1
 
     provider = FilesystemProvider(template_root)
     # Toolcall templates have no renderable text body (the body IS the schema) —
     # skip them; there is no {{field}} drift to check.
     templates = [
+        # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
         c
         for c in root.own_children()
         if c.type == TYPE_TEMPLATE and c.sub_type != tc.TEMPLATE_SUBTYPE_TOOLCALL
@@ -501,7 +534,7 @@ def _verify_templates(args: argparse.Namespace) -> int:
     error_count = 0
     checked = 0
     for tmpl in sorted(templates, key=lambda c: c.name):
-        payload_ref = tmpl.attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)
+        payload_ref = tmpl.get_meta_attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
         if not isinstance(payload_ref, str) or not payload_ref:
             print(f"error: [{tmpl.name}] missing @payloadRef.", file=sys.stderr)
             error_count += 1
@@ -521,7 +554,8 @@ def _verify_templates(args: argparse.Namespace) -> int:
         refs = [
             val
             for a in _TEMPLATE_TEXT_REF_ATTRS
-            if isinstance(val := tmpl.attr(a), str) and val
+            # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
+            if isinstance(val := tmpl.get_meta_attr(a), str) and val
         ]
         if not refs:
             print(
@@ -760,6 +794,15 @@ def _build_parser() -> argparse.ArgumentParser:
         default=None,
         help="comma-separated entity allowlist for --codegen drift (match `gen --entities`)",
     )
+    verify.add_argument(
+        "--lax",
+        action="store_true",
+        help=(
+            "opt out of strict-attr load (ADR-0023, #96): verify is strict by "
+            "default — an undeclared/typo'd @attr fails. --lax restores the legacy "
+            "open-attr load."
+        ),
+    )
     verify.set_defaults(func=_cmd_verify)
 
     agent_docs = sub.add_parser(

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/codegen/extract_delegate_emitter.py

@@ -36,7 +36,12 @@ from metaobjects.shared.separators import PACKAGE_SEP
 
 
 def _find_object(root: MetaData, name: str) -> MetaData | None:
-    """The own-child ``object.*`` node named *name*, or ``None``."""
+    """The top-level ``object.*`` node named *name*, or ``None``.
+
+    ADR-0039 sanctioned own: top-level object lookup on the loader ROOT
+    (metadata.root is never extended, so own == effective) — mirrors the TS
+    reference (``root.ownChildren()``).
+    """
     for c in root.own_children():
         if c.type == TYPE_OBJECT and c.name == name:
             return c

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/codegen/fr010_field_mapping.py

@@ -22,7 +22,6 @@ from metaobjects.meta.core.field import field_constants as fc
 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
@@ -101,6 +106,9 @@ def scalar_kind(sub_type: str) -> str | None:
         fc.FIELD_SUBTYPE_DATE,
         fc.FIELD_SUBTYPE_TIME,
         fc.FIELD_SUBTYPE_TIMESTAMP,
+        # ADR-0036/0037 Wave 3: uri/inet are string scalars on the wire.
+        fc.FIELD_SUBTYPE_URI,
+        fc.FIELD_SUBTYPE_INET,
     ):
         return "STRING"
     if sub_type == fc.FIELD_SUBTYPE_INT:

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/codegen/generators/entity_model.py

@@ -48,6 +48,18 @@ def _is_sql_expr_default(value: object) -> bool:
     return isinstance(value, str) and any(p.search(value) for p in _SQL_EXPR_DEFAULT_PATTERNS)
 
 
+# ADR-0036/0037 Wave 3 — the CANONICAL hostname matcher for @stringFormat: hostname.
+# The matcher lives in codegen (NOT author validator.regex) so every port replicates
+# the SAME canonical form — cross-language regex engines diverge, so this one
+# expression is the byte-identical source of truth. RFC 1123 labels: 1–63 chars each,
+# alphanumeric + internal hyphens, dot-separated; total length 1–253; anchored.
+# Byte-identical to the TS zod-validators HOSTNAME_REGEX_LITERAL body.
+_HOSTNAME_REGEX = (
+    r"^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)"
+    r"(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
+)
+
+
 def _validators(field: MetaField, sub_type: str) -> list[MetaField]:
     """The field's own ``validator.<sub_type>`` children (effective, supers included)."""
     return [
@@ -60,6 +72,10 @@ def _validators(field: MetaField, sub_type: str) -> list[MetaField]:
 def _first_attr(field: MetaField, sub_type: str, attr_name: str) -> object | None:
     """First int-valued *attr_name* across the field's ``validator.<sub_type>`` children."""
     for v in _validators(field, sub_type):
+        # ADR-0039 sanctioned own: a validator's @min/@max are its own declared
+        # bounds (never inherited across a validator extends chain) — matches the TS
+        # MetaValidator.min/.max ownAttr reads. The validator nodes are located via
+        # the resolving field.children() in _validators().
         val = v.attr(attr_name)
         if _is_int(val):
             return val
@@ -106,11 +122,21 @@ def _validator_constraints(field: MetaField) -> dict[str, object]:
 
     # Regex: validator.regex @pattern -> pattern.
     for v in _validators(field, vc.VALIDATOR_SUBTYPE_REGEX):
+        # ADR-0039 sanctioned own: a validator's @pattern is its own declared value
+        # (matches the TS MetaValidator.pattern ownAttr read); the validator node is
+        # located via the resolving field.children() in _validators().
         pattern = v.attr(vc.VALIDATOR_ATTR_PATTERN)
         if isinstance(pattern, str):
             kwargs["pattern"] = pattern
             break
 
+    # ADR-0036/0037 Wave 3 — @stringFormat: hostname -> a codegen-owned canonical
+    # hostname pattern= (the matcher lives HERE, never author validator.regex, so
+    # every port replicates the byte-identical form). @stringFormat: email is bound
+    # as EmailStr in _field_line (a type, not a pattern), so it is not handled here.
+    if field.attrs().get(fc.FIELD_ATTR_STRING_FORMAT) == fc.STRING_FORMAT_HOSTNAME:
+        kwargs["pattern"] = _HOSTNAME_REGEX
+
     return kwargs
 
 
@@ -132,6 +158,17 @@ def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple
         pt = py_type_for(field)
         imports.update(pt.imports)
         type_expr = pt.expr
+    # ADR-0036/0037 Wave 3 — @stringFormat: email narrows a plain string to a
+    # validated email. Bind Pydantic's idiomatic EmailStr (the Python analogue of
+    # Zod .email()); hostname stays a plain str with a codegen-owned canonical
+    # pattern= (handled in _validator_constraints). The field stays a string.
+    if (
+        field.sub_type == fc.FIELD_SUBTYPE_STRING
+        and field.attrs().get(fc.FIELD_ATTR_STRING_FORMAT) == fc.STRING_FORMAT_EMAIL
+    ):
+        base_expr = "EmailStr"
+        imports.add("from pydantic import EmailStr")
+        type_expr = f"list[{base_expr}]" if field_is_array(field) else base_expr
     if field.sub_type in (fc.FIELD_SUBTYPE_OBJECT, fc.FIELD_SUBTYPE_MAP):
         # A field.object (-> VO) and a field.map with @objectRef (-> dict[str, VO])
         # both reference a value-object by name; import it so the annotation
@@ -238,6 +275,9 @@ class EntityModelGenerator:
         cfg = config if config is not None else GenConfig(out_dir="")
         uses_field = False
         lines: list[str] = []
+        # ADR-0039 SANCTIONED OWN — codegen subclass-emit: the generated model
+        # `extends` its generated base, so only OWN fields are emitted here (the base
+        # class already declares inherited ones). Pinned by test_entity_model.py.
         for f in entity.own_fields():
             line, used = _field_line(f, imports, cfg)
             uses_field = uses_field or used

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/codegen/generators/extractor_generator.py

@@ -151,14 +151,14 @@ def render_extractor(
     Returns ``None`` when the ``@payloadRef`` can't be resolved to an ``object.value``,
     or when the target ``@format`` is not json/xml (the extract tier requires the
     tolerant extract API, which only the json/xml output-parsers emit)."""
-    payload_ref = template.attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)
+    payload_ref = template.get_meta_attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     if not isinstance(payload_ref, str) or not payload_ref:
         return None
     payload = resolve_payload_vo(root, payload_ref)
     if payload is None:
         return None
 
-    fmt = template.attr(tc.TEMPLATE_ATTR_FORMAT)
+    fmt = template.get_meta_attr(tc.TEMPLATE_ATTR_FORMAT)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     fmt_str = fmt if isinstance(fmt, str) else tc.TEMPLATE_FORMAT_DEFAULT
     if fmt_str.lower() not in _EXTRACT_FORMATS:
         return None
@@ -278,6 +278,7 @@ class ExtractorGenerator:
         files: list[EmittedFile] = []
         outputs = sorted(
             (
+                # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
                 c
                 for c in root.own_children()
                 if c.type == TYPE_TEMPLATE and c.sub_type == tc.TEMPLATE_SUBTYPE_OUTPUT

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/codegen/generators/filter_allowlist_generator.py

@@ -64,8 +64,12 @@ def _effective_fqn(entity: MetaObject) -> str:
 
 
 def _primary_source_rdb(entity: MetaObject) -> MetaSource | None:
-    """Return the entity's ``source.rdb`` child (own only), or ``None``."""
-    for c in entity.own_children():
+    """Return the entity's ``source.rdb`` child, or ``None``.
+
+    ADR-0039 — RESOLVING (children()): an entity may inherit its source.rdb via
+    ``extends`` (BaseEntity); own_children() would miss it. Mirrors TS dbTable.
+    """
+    for c in entity.children():
         if c.type == TYPE_SOURCE and isinstance(c, MetaSource):
             return c
     return None
@@ -91,7 +95,11 @@ def ops_for_subtype_ordered(sub_type: str | None) -> tuple[str, ...]:
         return ()
     if sub_type in (fc.FIELD_SUBTYPE_STRING, fc.FIELD_SUBTYPE_ENUM):
         return _OPS_STRING
-    if sub_type == fc.FIELD_SUBTYPE_UUID:
+    # ADR-0036/0037 Wave 3 — field.uri is string-like (substring searchable);
+    # field.inet is uuid-like (identity value, no substring search, no ordering).
+    if sub_type == fc.FIELD_SUBTYPE_URI:
+        return _OPS_STRING
+    if sub_type in (fc.FIELD_SUBTYPE_UUID, fc.FIELD_SUBTYPE_INET):
         return _OPS_UUID
     if sub_type in (
         fc.FIELD_SUBTYPE_INT,
@@ -190,6 +198,10 @@ class FilterAllowlistGenerator:
             plan = tph_plan_for(entity, object_index)
             if plan is not None:
                 for st in plan.subtypes:
+                    # ADR-0039 sanctioned own: TPH subtype delta — the base's
+                    # effective fields are added above via entity.fields(); each
+                    # subtype contributes ONLY its own additional fields (inherited
+                    # base fields must not be re-added).
                     for f in st.entity.own_fields():
                         add(f)
         return out

{metaobjects-0.13.0 → metaobjects-0.15.0}/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:
@@ -99,7 +103,9 @@ def collect_shared_enums(entities: list) -> list[SharedEnum]:
     not materialized (no dangling type)."""
     out: dict[str, SharedEnum] = {}
     for entity in entities:
-        for f in entity.own_fields():
+        # ADR-0039 — RESOLVING (fields()): mirrors the TS collectSharedEnums
+        # (``entity.fields()``); an inherited field consuming a shared enum counts.
+        for f in entity.fields():
             shared = shared_enum_for_field(f)
             if shared is None:
                 continue

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/codegen/generators/m2m_codegen.py

@@ -72,7 +72,10 @@ def plural_lowercase(name: str) -> str:
 
 
 def _primary_source_rdb(entity: MetaObject) -> MetaSource | None:
-    for c in entity.own_children():
+    # ADR-0039 — RESOLVING (children()): an entity may inherit its source.rdb from
+    # an abstract base via extends (BaseEntity pattern); own_children() would emit
+    # nothing for such an entity. Mirrors the TS dbTable source lookup.
+    for c in entity.children():
         if c.type == TYPE_SOURCE and isinstance(c, MetaSource):
             return c
     return None
@@ -111,7 +114,7 @@ def _pk_field_name(entity: MetaObject) -> str:
     """The single PK field name (``identity.primary @fields``), default ``id``."""
     for c in entity.children():
         if c.type == TYPE_IDENTITY and c.sub_type == IDENTITY_SUBTYPE_PRIMARY:
-            fields = c.attr(IDENTITY_ATTR_FIELDS)
+            fields = c.get_meta_attr(IDENTITY_ATTR_FIELDS)  # ADR-0039: resolving (identity attr)
             if isinstance(fields, (list, tuple)) and fields:
                 first = fields[0]
                 if isinstance(first, str):
@@ -122,10 +125,14 @@ def _pk_field_name(entity: MetaObject) -> str:
 
 
 def m2m_relationships(entity: MetaObject) -> list[MetaRelationship]:
-    """The entity's own ``relationship.* @cardinality:"many" + @through`` children
-    (declaration order). 1:N relationships (no ``@through``) are excluded."""
+    """The entity's ``relationship.* @cardinality:"many" + @through`` children
+    (declaration order). 1:N relationships (no ``@through``) are excluded.
+
+    ADR-0039 — RESOLVING (children()): mirrors the TS ``relationships()`` (built on
+    the effective ``children()``); a relationship inherited via ``extends`` counts.
+    """
     out: list[MetaRelationship] = []
-    for c in entity.own_children():
+    for c in entity.children():
         if not isinstance(c, MetaRelationship):
             continue
         if c.cardinality() != CARDINALITY_MANY:

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/codegen/generators/output_parser_generator.py

@@ -54,7 +54,7 @@ def render_output_parser(template: MetaData, root: MetaData) -> str | None:
 
     Returns ``None`` when the ``@payloadRef`` can't be resolved (defensive;
     the loader's template-validation pass would normally catch this first)."""
-    payload_ref = template.attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)
+    payload_ref = template.get_meta_attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     if not isinstance(payload_ref, str) or not payload_ref:
         return None
     payload = resolve_payload_vo(root, payload_ref)
@@ -77,7 +77,7 @@ def render_output_parser(template: MetaData, root: MetaData) -> str | None:
     # template targets json/xml. Otherwise only the FR-006 strict parser is emitted
     # (text-format outputs get no extract). The mirror is a nullable twin of the
     # payload, so the strict ``parse_*`` is left exactly as FR-006 shipped it.
-    fmt = template.attr(tc.TEMPLATE_ATTR_FORMAT)
+    fmt = template.get_meta_attr(tc.TEMPLATE_ATTR_FORMAT)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     fmt_str = fmt if isinstance(fmt, str) else tc.TEMPLATE_FORMAT_DEFAULT
     emit_extract_lenient = fmt_str.lower() in _EXTRACT_FORMATS
     extracted_class = f"{payload_class}Extracted"
@@ -172,6 +172,8 @@ def render_output_parser(template: MetaData, root: MetaData) -> str | None:
         lines.append("    :param root: a loaded ``MetaRoot`` that declares the")
         lines.append(f'                 ``{payload.name}`` value-object."""')
         lines.append("    mo = None")
+        # Emits a root-scan into generated code: root is the loader ROOT (never
+        # extended, so own == effective) — ADR-0039 sanctioned own in emitted code.
         lines.append("    for child in root.own_children():")
         lines.append("        if (")
         lines.append("            isinstance(child, MetaObject)")
@@ -231,6 +233,7 @@ class OutputParserGenerator:
         files: list[EmittedFile] = []
         outputs = sorted(
             (
+                # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
                 c
                 for c in root.own_children()
                 if c.type == TYPE_TEMPLATE and c.sub_type == tc.TEMPLATE_SUBTYPE_OUTPUT

{metaobjects-0.13.0 → metaobjects-0.15.0}/src/metaobjects/codegen/generators/output_prompt_generator.py

@@ -60,12 +60,12 @@ def render_output_prompt(
     Returns ``None`` when the format is unsupported (not json/xml) or the
     ``@payloadRef`` can't be resolved to an ``object.value`` (defensive — the loader
     validation pass / the parser generator share this contract)."""
-    fmt = template.attr(tc.TEMPLATE_ATTR_FORMAT)
+    fmt = template.get_meta_attr(tc.TEMPLATE_ATTR_FORMAT)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     fmt_str = fmt if isinstance(fmt, str) else tc.TEMPLATE_FORMAT_DEFAULT
     if fmt_str.lower() not in _PROMPT_FORMATS:
         return None
 
-    payload_ref = template.attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)
+    payload_ref = template.get_meta_attr(tc.TEMPLATE_ATTR_PAYLOAD_REF)  # ADR-0039: template attr resolves via extends (not origin; templates CAN extend)
     if not isinstance(payload_ref, str) or not payload_ref:
         return None
     payload = resolve_payload_vo(root, payload_ref)
@@ -153,6 +153,7 @@ class OutputPromptGenerator:
         files: list[EmittedFile] = []
         outputs = sorted(
             (
+                # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
                 c
                 for c in root.own_children()
                 if c.type == TYPE_TEMPLATE and c.sub_type == tc.TEMPLATE_SUBTYPE_OUTPUT