metaobjects 0.15.11__tar.gz → 0.15.13__tar.gz

{metaobjects-0.15.11 → metaobjects-0.15.13}/PKG-INFO

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

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

@@ -110,7 +110,7 @@ def _field_named(entity: MetaObject, field_name: str) -> MetaField | None:
     return None
 
 
-def _pk_field_name(entity: MetaObject) -> str:
+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:
@@ -184,8 +184,8 @@ def resolve_m2m_descriptors(
                 source_column=_column_of(source_fk, fields.source_field),
                 target_column=_column_of(target_fk, fields.target_field),
                 target_pk_column=_column_of(
-                    _field_named(target, _pk_field_name(target)),
-                    _pk_field_name(target),
+                    _field_named(target, pk_field_name(target)),
+                    pk_field_name(target),
                 ),
                 symmetric=rel.symmetric(),
             )

{metaobjects-0.15.11 → metaobjects-0.15.13}/src/metaobjects/codegen/generators/payload_vo_generator.py

@@ -63,6 +63,7 @@ from metaobjects.meta.persistence.origin.origin_constants import (
 )
 from metaobjects.meta.template import template_constants as tc
 from metaobjects.meta.template.meta_template import MetaTemplate
+from metaobjects.naming_refs import resolve_object_ref
 from metaobjects.shared.base_types import TYPE_OBJECT, TYPE_TEMPLATE
 from metaobjects.shared.separators import PACKAGE_SEP
 
@@ -104,6 +105,16 @@ def payload_module_name(template_name: str) -> str:
 # ---------------------------------------------------------------------------
 
 
+def _pkg_of(node: MetaData) -> str:
+    """The effective package of an object — its ``resolution_key()`` minus the
+    trailing ``::<name>`` ("" for a root-level object). Derived from the resolution
+    key so it is correct for BOTH loaded trees (file_default_package) and
+    programmatically-built trees (package only on the root)."""
+    key = node.resolution_key()
+    i = key.rfind(PACKAGE_SEP)
+    return "" if i == -1 else key[:i]
+
+
 def _resolve_object_by_short_or_fqn(root: MetaData, ref: str) -> MetaObject | None:
     """Find a ``MetaObject`` child satisfying an (already-expanded) object ref.
 
@@ -192,9 +203,14 @@ def _resolve_object_field_type(
     ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
     if not isinstance(ref, str) or not ref:
         return _fallback_type(field)
-    target = _resolve_object_by_short_or_fqn(root, ref)
-    if target is None and PACKAGE_SEP in ref:
-        target = _resolve_object_by_short_or_fqn(root, ref.rsplit(PACKAGE_SEP, 1)[-1])
+    # ADR-0042 — a nested @objectRef resolves in the DECLARING field's package
+    # (correct for a field.object inherited via extends across packages); an FQN
+    # resolves exactly. NO bare-tail short-name fallback that would bind a same-named
+    # VO in the wrong package on a cross-package collision (#191). The declaring
+    # package is taken from the parent object's resolution key so it is correct for
+    # 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:
         return _fallback_type(field)
     nested_class = payload_class_name(target.name)

{metaobjects-0.15.11 → metaobjects-0.15.13}/src/metaobjects/codegen/generators/render_helper_generator.py

@@ -62,7 +62,8 @@ from metaobjects.render.verify import (
     PayloadField,
     verify,
 )
-from metaobjects.shared.base_types import TYPE_FIELD, TYPE_OBJECT, TYPE_TEMPLATE
+from metaobjects.naming_refs import resolve_object_ref
+from metaobjects.shared.base_types import TYPE_FIELD, TYPE_TEMPLATE
 from metaobjects.shared.separators import PACKAGE_SEP
 
 _GENERATOR_NAME = "render-helper-generator"
@@ -81,30 +82,34 @@ def _py_str(s: str) -> str:
 # ---------------------------------------------------------------------------
 
 
-def _resolve_nested_object_ref(root: MetaData, reference: str) -> MetaObject | None:
+def _pkg_of(node: MetaData) -> str:
+    """The effective package of an object — its ``resolution_key()`` minus the
+    trailing ``::<name>`` ("" for a root-level object). Derived from the resolution
+    key so it is correct for BOTH loaded trees (file_default_package) and
+    programmatically-built trees (package only on the root, folded via the ancestor
+    walk in ``resolution_key()``)."""
+    key = node.resolution_key()
+    i = key.rfind(PACKAGE_SEP)
+    return "" if i == -1 else key[:i]
+
+
+def _resolve_nested_object_ref(
+    root: MetaData, reference: str, referrer_pkg: str
+) -> MetaObject | None:
     """Resolve a ``field.object``'s ``@objectRef`` to its target ``object.value``.
 
-    ADR-0041: a FULLY-QUALIFIED ref (contains ``::``) resolves EXACTLY on the
-    package-qualified name (``resolution_key()``/``fqn()``) — never a bare-tail
-    fallback that would bind a same-named ``object.value`` in the WRONG package on a
-    cross-package short-name collision. A bare ref still matches by short name
-    (first-wins). Mirrors the Java/Kotlin ``resolveNestedObjectRef`` + TS
-    ``refMatchesObject``."""
+    ADR-0042: package-local — an FQN ref (contains ``::``) resolves EXACTLY on the
+    package-qualified name; a bare ref resolves in the referrer's package FIRST
+    (else a root-level object), never a same-named ``object.value`` in another
+    package via a bare-tail fallback. *referrer_pkg* is the DECLARING field's
+    package (which differs from the VO's when the field is inherited via extends
+    from an abstract VO in another package). Shares the single ``resolve_object_ref``
+    matcher. Mirrors the TS ``findObject`` in payload-field-tree.ts."""
     if not reference:
         return None
-    fqn = PACKAGE_SEP in reference
-    ref_short = reference.rsplit(PACKAGE_SEP, 1)[-1]
-    # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
-    for child in root.own_children():
-        if child.type != TYPE_OBJECT or not isinstance(child, MetaObject):
-            continue
-        if child.sub_type != OBJECT_SUBTYPE_VALUE:
-            continue
-        if fqn:
-            if child.resolution_key() == reference or child.fqn() == reference:
-                return child
-        elif child.name.rsplit(PACKAGE_SEP, 1)[-1] == ref_short:
-            return child
+    target = resolve_object_ref(root, reference, referrer_pkg)
+    if target is not None and target.sub_type == OBJECT_SUBTYPE_VALUE:
+        return target  # type: ignore[return-value]
     return None
 
 
@@ -118,6 +123,10 @@ def _derive_payload_field_tree(
     if vo is None or vo.resolution_key() in seen:
         return []
     next_seen = seen | {vo.resolution_key()}
+    # A nested @objectRef resolves in the FIELD's own declaring package (below),
+    # which differs from this VO's when the field is inherited via extends from an
+    # abstract VO in another package (the bare ref was authored there).
+    vo_pkg = _pkg_of(vo)
     fields: list[PayloadField] = []
     for f in vo.children():
         if f.type != TYPE_FIELD or not isinstance(f, MetaField):
@@ -125,7 +134,8 @@ def _derive_payload_field_tree(
         if f.sub_type == fc.FIELD_SUBTYPE_OBJECT:
             ref = f.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
             if isinstance(ref, str) and ref:
-                target = _resolve_nested_object_ref(root, ref)
+                field_pkg = _pkg_of(f.parent) if f.parent is not None else vo_pkg
+                target = _resolve_nested_object_ref(root, ref, field_pkg)
                 if target is not None and target.sub_type == OBJECT_SUBTYPE_VALUE:
                     children = _derive_payload_field_tree(root, target, next_seen)
                     fields.append(PayloadField(f.name, children))
@@ -152,16 +162,20 @@ def _field_tree_literal(fields: list[PayloadField]) -> str:
 
 
 def _resolve_payload_vo(root: MetaData, payload_ref: str) -> MetaObject | None:
-    """``@payloadRef`` must resolve to an ``object.value`` (same contract as the
-    parser/prompt generators). Matches a value-object child by short name OR by the
-    last segment of a fully-qualified ``a::b::Name`` ref (FR-026 expands refs to FQN,
-    while the child node still carries the short ``name``)."""
-    ref_short = payload_ref.rsplit("::", 1)[-1]
+    """``@payloadRef`` must resolve to an ``object.value``. Package-local (ADR-0042):
+    the referrer's own package first (else a root-level object), FQN exact. The
+    referrer package is derived from the resolved match's own resolution key, so this
+    keeps the same behavior for the single-package + FQN codegen fixtures while never
+    binding a same-named VO in the wrong package (the nested @objectRef path is the
+    one #191 named — see _resolve_nested_object_ref). Matches a value-object child by
+    the package-folded resolution key OR the bare short name (FR-026 expands refs to
+    FQN, while the child node still carries the short ``name``)."""
+    ref_short = payload_ref.rsplit(PACKAGE_SEP, 1)[-1]
     # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
     for child in root.own_children():
-        if child.type != TYPE_OBJECT or not isinstance(child, MetaObject):
+        if not isinstance(child, MetaObject) or child.sub_type != OBJECT_SUBTYPE_VALUE:
             continue
-        if child.sub_type == OBJECT_SUBTYPE_VALUE and child.name in (payload_ref, ref_short):
+        if child.resolution_key() == payload_ref or child.name == ref_short:
             return child
     return None
 

{metaobjects-0.15.11 → metaobjects-0.15.13}/src/metaobjects/codegen/generators/router_generator.py

@@ -43,10 +43,12 @@ from metaobjects.codegen.generator import EmittedFile, GenContext, Generator, pe
 from metaobjects.codegen.generators.m2m_codegen import (
     M2mDescriptor,
     build_object_index,
+    pk_field_name,
     resolve_m2m_descriptors,
 )
 from metaobjects.codegen.generators.tph_plan import TphPlan, is_tph_subtype, tph_plan_for
 from metaobjects.codegen.instance_artifacts import emits_instance_artifacts
+from metaobjects.codegen.type_map import PyType, py_type_for
 from metaobjects.meta.core.field import field_constants as fc
 from metaobjects.meta.core.field.meta_field import MetaField
 from metaobjects.meta.core.identity.identity_constants import (
@@ -87,6 +89,23 @@ def _scalar_fields(entity: MetaObject) -> list[MetaField]:
     return [f for f in entity.fields() if f.sub_type != fc.FIELD_SUBTYPE_OBJECT]
 
 
+def _pk_py_type(entity: MetaObject) -> PyType:
+    """The Python type of the entity's primary-key path/id parameter, derived
+    from the PK field's declared subtype via ``type_map.py_type_for`` — the same
+    mapper the Pydantic entity model uses, so ``field.uuid`` binds ``uuid.UUID``
+    on the route exactly as it does on the model (mirrors the C#
+    RoutesGenerator's ``CSharpNaming.ScalarFor(pkField.SubType)``).
+
+    Composite PK → ``@fields[0]`` (the TS ``getPkInfo`` behavior); no primary
+    identity / unresolvable field → ``int`` (the ``field.long`` default).
+    """
+    name = pk_field_name(entity)
+    pk_field = next((f for f in entity.fields() if f.name == name), None)
+    if pk_field is None:
+        return PyType("int")
+    return py_type_for(pk_field)
+
+
 @dataclass(frozen=True)
 class ReverseFk:
     """One FK an entity ``E`` holds (ADR-0038): the FK FIELD name on ``E`` and the
@@ -140,13 +159,15 @@ class RouterGenerator:
 
     Override points:
 
-    * ``_emit_repository_protocol(repo_class, m2m)`` — the consumer-implemented
-      ``Repository`` ``Protocol`` block (CRUD finders + M:N ``find_related_*``).
+    * ``_emit_repository_protocol(repo_class, m2m, pk_type)`` — the consumer-
+      implemented ``Repository`` ``Protocol`` block (CRUD finders + M:N
+      ``find_related_*``); ``pk_type`` is the PK's Python annotation text.
     * ``_emit_reverse_finders(entity)`` — the ADR-0038 reverse-FK finder pair
       (``find_<e_plural>_by_<fk_segment>`` + ``…_in``) appended to the ``Protocol``.
     * ``_emit_route_handler(name, ...)`` — the CRUD route handlers (list / get /
       create / update / delete), keyed by ``name``.
-    * ``_emit_m2m_route(d, snake, pk_param, repo_class)`` — one M:N traversal route.
+    * ``_emit_m2m_route(d, snake, pk_param, pk_type, repo_class)`` — one M:N
+      traversal route.
     * ``render_router(entity, object_index)`` — the whole module (last resort).
 
     Skips entities without a ``source.rdb`` child and read-only kinds
@@ -156,11 +177,12 @@ class RouterGenerator:
     name = "router-generator"
 
     def _emit_repository_protocol(
-        self, repo_class: str, m2m: list[M2mDescriptor]
+        self, repo_class: str, m2m: list[M2mDescriptor], pk_type: str
     ) -> list[str]:
         """The repository ``Protocol`` block. Returns/accepts ``Any`` so this module
-        stays decoupled from the entity-model import. Override to add custom finder
-        signatures or change the seam shape."""
+        stays decoupled from the entity-model import; *pk_type* is the PK's Python
+        annotation text (metadata-derived — e.g. ``uuid.UUID`` / ``int`` / ``str``).
+        Override to add custom finder signatures or change the seam shape."""
         lines: list[str] = [
             f"class {repo_class}(Protocol):",
             '    """GENERATED — consumer implements with their preferred persistence layer."""',
@@ -172,14 +194,14 @@ class RouterGenerator:
             "        filters: list[FilterPredicate],",
             "    ) -> list[Any]: ...",
             "    def count(self, filters: list[FilterPredicate]) -> int: ...",
-            "    def find_by_id(self, id: int) -> Any | None: ...",
+            f"    def find_by_id(self, id: {pk_type}) -> Any | None: ...",
             "    def create(self, dto: Any) -> Any: ...",
-            "    def update(self, id: int, dto: Any) -> Any | None: ...",
-            "    def delete(self, id: int) -> bool: ...",
+            f"    def update(self, id: {pk_type}, dto: Any) -> Any | None: ...",
+            f"    def delete(self, id: {pk_type}) -> bool: ...",
         ]
         for d in m2m:
             lines.append(
-                f"    def find_related_{d.relation_name}(self, id: int) -> list[Any]: ..."
+                f"    def find_related_{d.relation_name}(self, id: {pk_type}) -> list[Any]: ..."
             )
         return lines
 
@@ -212,6 +234,7 @@ class RouterGenerator:
         snake: str,
         plural: str,
         pk_param: str,
+        pk_type: str,
         repo_class: str,
         fields_const: str,
         ops_const: str,
@@ -251,7 +274,7 @@ class RouterGenerator:
             return [
                 f'@router.get("/{{{pk_param}}}")',
                 f"def get_{snake}(",
-                f"    {pk_param}: int,",
+                f"    {pk_param}: {pk_type},",
                 f"    repo: Annotated[{repo_class}, Depends(get_repository)],",
                 ") -> Any:",
                 f"    row = repo.find_by_id({pk_param})",
@@ -273,7 +296,7 @@ class RouterGenerator:
                 f'@router.patch("/{{{pk_param}}}")',
                 f'@router.put("/{{{pk_param}}}")',
                 f"def update_{snake}(",
-                f"    {pk_param}: int,",
+                f"    {pk_param}: {pk_type},",
                 "    dto: dict[str, Any],",
                 f"    repo: Annotated[{repo_class}, Depends(get_repository)],",
                 ") -> Any:",
@@ -286,7 +309,7 @@ class RouterGenerator:
             return [
                 f'@router.delete("/{{{pk_param}}}", status_code=status.HTTP_204_NO_CONTENT)',
                 f"def delete_{snake}(",
-                f"    {pk_param}: int,",
+                f"    {pk_param}: {pk_type},",
                 f"    repo: Annotated[{repo_class}, Depends(get_repository)],",
                 ") -> None:",
                 f"    if not repo.delete({pk_param}):",
@@ -295,7 +318,7 @@ class RouterGenerator:
         raise ValueError(f"unknown route handler '{name}'")
 
     def _emit_m2m_route(
-        self, d: M2mDescriptor, snake: str, pk_param: str, repo_class: str
+        self, d: M2mDescriptor, snake: str, pk_param: str, pk_type: str, repo_class: str
     ) -> list[str]:
         """One M:N traversal route ``GET /{id}/<relationName>`` — a thin pass-through
         to the repository's ``find_related_*`` finder. Override to add filtering /
@@ -303,7 +326,7 @@ class RouterGenerator:
         return [
             f'@router.get("/{{{pk_param}}}/{d.relation_name}")',
             f"def list_{snake}_{d.relation_name}(",
-            f"    {pk_param}: int,",
+            f"    {pk_param}: {pk_type},",
             f"    repo: Annotated[{repo_class}, Depends(get_repository)],",
             ") -> list[Any]:",
             f"    return repo.find_related_{d.relation_name}({pk_param})",
@@ -343,6 +366,10 @@ class RouterGenerator:
         snake = _snake_case(short_name)
         plural = _plural_lowercase(short_name)
         pk_param = f"{snake}_id"
+        # PK type from the BASE's declared primary key (subtypes share the
+        # base's single table — mirrors the C# TPH pkType threading).
+        pk = _pk_py_type(entity)
+        pk_type = pk.expr
         repo_class = f"{short_name}Repository"
         upper = short_name.upper()
         fields_const = f"{upper}_FILTER_FIELDS"
@@ -371,6 +398,10 @@ class RouterGenerator:
         )
         parts.append("from __future__ import annotations")
         parts.append("")
+        for import_line in sorted(pk.imports):
+            parts.append(import_line)
+        if pk.imports:
+            parts.append("")
         parts.append("from typing import Annotated, Any, Protocol")
         parts.append("")
         parts.append("from fastapi import APIRouter, Depends, Query, Request, status")
@@ -420,10 +451,10 @@ class RouterGenerator:
         parts.append("        filters: list[FilterPredicate],")
         parts.append("    ) -> list[Any]: ...")
         parts.append("    def count(self, subtype: str | None, filters: list[FilterPredicate]) -> int: ...")
-        parts.append("    def find_by_id(self, subtype: str | None, id: int) -> Any | None: ...")
+        parts.append(f"    def find_by_id(self, subtype: str | None, id: {pk_type}) -> Any | None: ...")
         parts.append("    def create(self, subtype: str, dto: Any) -> Any: ...")
-        parts.append("    def update(self, subtype: str, id: int, dto: Any) -> Any | None: ...")
-        parts.append("    def delete(self, subtype: str, id: int) -> bool: ...")
+        parts.append(f"    def update(self, subtype: str, id: {pk_type}, dto: Any) -> Any | None: ...")
+        parts.append(f"    def delete(self, subtype: str, id: {pk_type}) -> bool: ...")
         parts.append("")
         parts.append("")
         parts.append(f"def get_repository() -> {repo_class}:")
@@ -445,7 +476,7 @@ class RouterGenerator:
                 ") -> Any:",
             ]
 
-        # --- Per-subtype routes FIRST (literal segments match before /{id:int}). ---
+        # --- Per-subtype routes FIRST (literal segments match before /{id}). ---
         for st in plan.subtypes:
             seg = st.route_segment
             val = st.value
@@ -464,7 +495,7 @@ class RouterGenerator:
             parts.append("")
             parts.append(f'@router.get("/{seg}/{{{pk_param}}}")')
             parts.append(f"def get_{plural}_{sfx}(")
-            parts.append(f"    {pk_param}: int,")
+            parts.append(f"    {pk_param}: {pk_type},")
             parts.append(f"    repo: Annotated[{repo_class}, Depends(get_repository)],")
             parts.append(") -> Any:")
             parts.append(f'    row = repo.find_by_id("{val}", {pk_param})')
@@ -476,7 +507,7 @@ class RouterGenerator:
             parts.append(f'@router.patch("/{seg}/{{{pk_param}}}")')
             parts.append(f'@router.put("/{seg}/{{{pk_param}}}")')
             parts.append(f"def update_{plural}_{sfx}(")
-            parts.append(f"    {pk_param}: int,")
+            parts.append(f"    {pk_param}: {pk_type},")
             parts.append("    dto: dict[str, Any],")
             parts.append(f"    repo: Annotated[{repo_class}, Depends(get_repository)],")
             parts.append(") -> Any:")
@@ -488,7 +519,7 @@ class RouterGenerator:
             parts.append("")
             parts.append(f'@router.delete("/{seg}/{{{pk_param}}}", status_code=status.HTTP_204_NO_CONTENT)')
             parts.append(f"def delete_{plural}_{sfx}(")
-            parts.append(f"    {pk_param}: int,")
+            parts.append(f"    {pk_param}: {pk_type},")
             parts.append(f"    repo: Annotated[{repo_class}, Depends(get_repository)],")
             parts.append(") -> None:")
             parts.append(f'    if not repo.delete("{val}", {pk_param}):')
@@ -496,14 +527,14 @@ class RouterGenerator:
             parts.append("")
             parts.append("")
 
-        # --- Polymorphic base routes LAST (so /{id:int} doesn't shadow /<segment>). ---
+        # --- Polymorphic base routes LAST (so /{id} doesn't shadow /<segment>). ---
         parts.extend(list_sig(f"list_{plural}", ""))
         parts.extend(self._emit_tph_list_body("None", fields_const, ops_const))
         parts.append("")
         parts.append("")
         parts.append(f'@router.get("/{{{pk_param}}}")')
         parts.append(f"def get_{snake}(")
-        parts.append(f"    {pk_param}: int,")
+        parts.append(f"    {pk_param}: {pk_type},")
         parts.append(f"    repo: Annotated[{repo_class}, Depends(get_repository)],")
         parts.append(") -> Any:")
         parts.append(f"    row = repo.find_by_id(None, {pk_param})")
@@ -560,6 +591,8 @@ class RouterGenerator:
         snake = _snake_case(short_name)
         plural = _plural_lowercase(short_name)
         pk_param = f"{snake}_id"
+        pk = _pk_py_type(entity)
+        pk_type = pk.expr
         repo_class = f"{short_name}Repository"
         sort_fields = [f.name for f in _scalar_fields(entity)]
         upper = short_name.upper()
@@ -578,6 +611,10 @@ class RouterGenerator:
         )
         parts.append("from __future__ import annotations")
         parts.append("")
+        for import_line in sorted(pk.imports):
+            parts.append(import_line)
+        if pk.imports:
+            parts.append("")
         parts.append("from typing import Annotated, Any, Protocol")
         parts.append("")
         parts.append("from fastapi import APIRouter, Depends, Query, Request, status")
@@ -616,7 +653,7 @@ class RouterGenerator:
         parts.append("    return _SortClause(field=parts[0], direction=direction)")
         parts.append("")
         parts.append("")
-        proto_lines = self._emit_repository_protocol(repo_class, m2m)
+        proto_lines = self._emit_repository_protocol(repo_class, m2m, pk_type)
         proto_lines.extend(self._emit_reverse_finders(entity))
         parts.extend(proto_lines)
         parts.append("")
@@ -631,6 +668,7 @@ class RouterGenerator:
             snake=snake,
             plural=plural,
             pk_param=pk_param,
+            pk_type=pk_type,
             repo_class=repo_class,
             fields_const=fields_const,
             ops_const=ops_const,
@@ -649,7 +687,7 @@ class RouterGenerator:
         # array for an orphan source — never a 404).
         for d in m2m:
             parts.append("")
-            parts.extend(self._emit_m2m_route(d, snake, pk_param, repo_class))
+            parts.extend(self._emit_m2m_route(d, snake, pk_param, pk_type, repo_class))
             parts.append("")
 
         return "\n".join(parts)

{metaobjects-0.15.11 → metaobjects-0.15.13}/src/metaobjects/core_types.py

@@ -374,6 +374,22 @@ for _def in core_provider._defs:  # noqa: SLF001 (provider build-time enrichment
         )
         break
 
+# ADR-0042 — a field.object / field.map @objectRef must RESOLVE (a dangling target
+# fails the load, closing the gap #191 surfaced as a misleading downstream error).
+# The required-attr pass owns absence (ERR_OBJECT_FIELD_WITHOUT_OBJECT_REF); this
+# reference descriptor fires only when @objectRef is present but resolves to nothing
+# → ERR_UNRESOLVED_OBJECT_REF. Mirrors the TS core-types.ts registerCoreTypeDefs.
+for _def in core_provider._defs:  # noqa: SLF001 (provider build-time enrichment)
+    if _def.type == TYPE_FIELD and _def.sub_type in (
+        fc.FIELD_SUBTYPE_OBJECT,
+        fc.FIELD_SUBTYPE_MAP,
+    ):
+        _def.references.append(
+            ReferenceDescriptor(
+                FIELD_ATTR_OBJECT_REF, TYPE_OBJECT, None, False, "ERR_UNRESOLVED_OBJECT_REF"
+            )
+        )
+
 # field.enum — dedicated registration with required @values attr.
 # Inherits every common field attr (column / required / unique / default /
 # maxLength / filterable / sortable / etc.) so the D2 type-coercion guard

{metaobjects-0.15.11 → metaobjects-0.15.13}/src/metaobjects/errors.py

@@ -138,17 +138,13 @@ class ErrorCode(str, Enum):
     # emit this yet (the T6 guard is deferred — like TS, it belongs in the parser);
     # the enum tracks the shared corpus code so resolution/desugar stay aligned.
     ERR_RELATIVE_REF_IN_CANONICAL = "ERR_RELATIVE_REF_IN_CANONICAL"
-    # ADR-0041 — cross-package reference resolution contract. A BARE object
-    # reference (no ``::``) that names an object present in MORE THAN ONE package,
-    # with NO match in the referrer's own package, is ambiguous — the author must
-    # qualify it with the package (FQN). Applies to every object-ref-bearing attr
-    # (@objectRef / @references / @from / @of / @via heads / @parameterRef /
-    # @payloadRef / @responseRef). An FQN ref resolves exactly and is never
-    # ambiguous; a bare ref that matches the referrer's own package, or exactly one
-    # package anywhere, resolves fine. ``extends`` is intentionally NOT covered
-    # (its same-package/root-strict super-resolver yields ERR_UNRESOLVED_SUPER on a
-    # bare cross-package miss, not ambiguity).
-    ERR_AMBIGUOUS_REF = "ERR_AMBIGUOUS_REF"
+    # ADR-0042 — a field.object / field.map @objectRef does not resolve to any
+    # object in the loaded tree (a dangling target). Bare refs resolve
+    # package-locally (referrer's package, else root-level); FQN refs resolve
+    # exactly — a bare cross-package ref no longer binds elsewhere. Supersedes the
+    # retired ADR-0041 ERR_AMBIGUOUS_REF (bare = package-local ⇒ ambiguity is
+    # unreachable, so every unresolved ref fails closed with its per-attr code).
+    ERR_UNRESOLVED_OBJECT_REF = "ERR_UNRESOLVED_OBJECT_REF"
     # FR-033 — strict structural-placement vocabulary. ERR_CHILD_NOT_ALLOWED: a
     # structural child (field/identity/source/validator/… — not an attr) is placed
     # under a parent whose registered childRules do not admit it (the structural

{metaobjects-0.15.11 → metaobjects-0.15.13}/src/metaobjects/loader/registered_validation.py

@@ -12,8 +12,10 @@ from ..errors import ErrorCode, MetaError
 from ..meta.core.object.meta_object import MetaObject
 from ..meta.meta_data import MetaData
 from ..meta.meta_root import MetaRoot
+from ..naming_refs import did_you_mean_hint
 from ..registry import TypeRegistry
 from ..shared.base_types import TYPE_OBJECT
+from ..shared.separators import PACKAGE_SEP
 
 
 class SymbolTable:
@@ -29,19 +31,29 @@ class SymbolTable:
         # extended, own == effective) — mirrors the TS validation-registry.
         for child in root.own_children():
             if child.type == TYPE_OBJECT and isinstance(child, MetaObject):
-                if child.name:
-                    t._index[child.name] = child
-                t._index[child.fqn()] = child
+                # ADR-0042: key by the canonical resolution key ONLY (the FQN, or
+                # the bare name for a root-level/empty-package object) — NO bare-name
+                # fallback, so a bare ref never binds a same-named object in another
+                # package. Mirrors the TS validation-registry symbol table.
                 t._index[child.resolution_key()] = child
         return t
 
-    def resolve_object(self, reference: str) -> MetaData | None:
-        return self._index.get(reference)
+    def resolve_object(self, reference: str, referrer_pkg: str) -> MetaData | None:
+        """ADR-0042 package-local resolution: FQN → exact resolution-key match;
+        bare → the referrer's own package (``<referrer_pkg>::<ref>``), else a
+        root-level object. Mirrors the TS ``resolveObject``."""
+        if PACKAGE_SEP in reference:
+            return self._index.get(reference)
+        local_key = (
+            f"{referrer_pkg}{PACKAGE_SEP}{reference}" if referrer_pkg else reference
+        )
+        return self._index.get(local_key) or self._index.get(reference)
 
 
 class ValidationContext:
-    def __init__(self, symbols: SymbolTable) -> None:
+    def __init__(self, symbols: SymbolTable, root: MetaData) -> None:
         self.symbols = symbols
+        self.root = root
         self.errors: list[MetaError] = []
 
     def error(self, code: str, node: MetaData, message: str) -> None:
@@ -55,12 +67,23 @@ class ValidationContext:
 
 
 def run(root: MetaRoot, registry: TypeRegistry) -> list[MetaError]:
-    ctx = ValidationContext(SymbolTable.build(root))
-    _walk(root, registry, ctx)
+    ctx = ValidationContext(SymbolTable.build(root), root)
+    _walk(root, registry, ctx, "")
     return ctx.errors
 
 
-def _walk(node: MetaData, registry: TypeRegistry, ctx: ValidationContext) -> None:
+def _walk(
+    node: MetaData, registry: TypeRegistry, ctx: ValidationContext, referrer_pkg: str
+) -> None:
+    # ADR-0042: a top-level object establishes the package context for its subtree;
+    # nested ref-bearing nodes (relationship/field.object/identity.reference) resolve
+    # BARE refs against it. Nested nodes carry no `package`, so they inherit the
+    # enclosing object's (via file_default_package, else the threaded context).
+    pkg = (
+        (node.package or node.file_default_package or referrer_pkg)
+        if node.type == TYPE_OBJECT
+        else referrer_pkg
+    )
     type_def = registry.find(node.type, node.sub_type)
     if type_def is not None:
         for desc in type_def.references:
@@ -72,7 +95,8 @@ def _walk(node: MetaData, registry: TypeRegistry, ctx: ValidationContext) -> Non
             if not isinstance(raw, str) or raw == "":
                 continue  # absence is the required-attr pass's job
             entity_ref = raw.split(".", 1)[0] if desc.dotted_field_path else raw
-            target = ctx.symbols.resolve_object(entity_ref)
+            # ADR-0042: bare refs resolve package-local against the enclosing object.
+            target = ctx.symbols.resolve_object(entity_ref, pkg)
             # Qualify the node name with its owning entity (e.g. "Order.items") so the error
             # is locatable from the message alone, not just the source envelope.
             qname = f"{node.parent.name}.{node.name}" if node.parent and node.parent.name else node.name
@@ -80,7 +104,7 @@ def _walk(node: MetaData, registry: TypeRegistry, ctx: ValidationContext) -> Non
                 ctx.error(
                     desc.error_code, node,
                     f'{node.type}.{node.sub_type} "{qname}" @{desc.attr} "{raw}" '
-                    f"does not resolve to an object.",
+                    f"does not resolve to an object.{did_you_mean_hint(ctx.root, entity_ref)}",
                 )
             elif target.type != desc.target_type or (
                 desc.target_sub_type is not None and target.sub_type != desc.target_sub_type
@@ -101,4 +125,4 @@ def _walk(node: MetaData, registry: TypeRegistry, ctx: ValidationContext) -> Non
     # node once at its declaration site (own children); inherited nodes are
     # validated where they are declared. Mirrors the TS ``node.ownChildren()`` walk.
     for child in node.own_children():
-        _walk(child, registry, ctx)
+        _walk(child, registry, ctx, pkg)