metaobjects 0.15.10__tar.gz → 0.15.12__tar.gz

{metaobjects-0.15.10 → metaobjects-0.15.12}/LICENSE

@@ -1,3 +1,4 @@
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -32,33 +33,36 @@
       not limited to compiled object code, generated documentation,
       and conversions to other media types.
 
-      "Work" shall mean the work of authorship made available under
-      the License, as indicated by a copyright notice that is included in
-      or attached to the work (an example is provided in the Appendix below).
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
 
       "Derivative Works" shall mean any work, whether in Source or Object
       form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other transformations
+      editorial revisions, annotations, elaborations, or other modifications
       represent, as a whole, an original work of authorship. For the purposes
       of this License, Derivative Works shall not include works that remain
       separable from, or merely link (or bind by name) to the interfaces of,
       the Work and Derivative Works thereof.
 
-      "Contribution" shall mean, as submitted to the Licensor for inclusion
-      in the Work by the copyright owner or by an individual or Legal Entity
-      authorized to submit on behalf of the copyright owner. For the purposes
-      of this definition, "submitted" means any form of electronic, verbal,
-      or written communication sent to the Licensor or its representatives,
-      including but not limited to communication on electronic mailing lists,
-      source code control systems, and issue tracking systems that are managed
-      by, or on behalf of, the Licensor for the purpose of recording and
-      discussing modifications to the Work, but excluding communication that
-      is conspicuously marked or designated in writing by the copyright owner
-      as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any Legal Entity on behalf of
-      whom a Contribution has been received by the Licensor and included
-      within the Work.
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
 
    2. Grant of Copyright License. Subject to the terms and conditions of
       this License, each Contributor hereby grants to You a perpetual,
@@ -74,22 +78,22 @@
       use, offer to sell, sell, import, and otherwise transfer the Work,
       where such license applies only to those patent claims licensable
       by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by the combination of their Contribution(s)
+      Contribution(s) alone or by combination of their Contribution(s)
       with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a cross-claim
-      or counterclaim in a lawsuit) alleging that the Work or any
-      Contribution embodied within the Work constitutes direct or contributory
-      patent infringement, then any patent licenses granted to You under
-      this License for that Work shall terminate as of the date such
-      litigation is filed.
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
 
    4. Redistribution. You may reproduce and distribute copies of the
       Work or Derivative Works thereof in any medium, with or without
       modifications, and in Source or Object form, provided that You
       meet the following conditions:
 
-      (a) You must give any other recipients of the Work or Derivative
-          Works a copy of this License; and
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
 
       (b) You must cause any modified files to carry prominent notices
           stating that You changed the files; and
@@ -101,24 +105,28 @@
           the Derivative Works; and
 
       (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, You must include a readable copy of the
-          attribution notices contained within such NOTICE file, in
-          at least one of the following places: within a NOTICE text
-          file distributed as part of the Derivative Works; within
-          the Source form or documentation, if provided along with the
-          Derivative Works; or, within a display generated by the
-          Derivative Works, if and wherever such third-party notices
-          normally appear. The contents of the NOTICE file are for
-          informational purposes only and do not modify the License.
-          You may add Your own attribution notices within Derivative
-          Works that You distribute, alongside or in addition to the
-          NOTICE text from the Work, provided that such additional
-          attribution notices cannot be construed as modifying the License.
-
-      You may add Your own license statement for Your modifications and
-      may provide additional grant of rights to use, reproduce, modify,
-      prepare derivative works of, distribute, and sublicense such modifications,
-      as an additional requirement of this License.
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
 
    5. Submission of Contributions. Unless You explicitly state otherwise,
       any Contribution intentionally submitted for inclusion in the Work
@@ -137,10 +145,10 @@
       agreed to in writing, Licensor provides the Work (and each
       Contributor provides its Contributions) on an "AS IS" BASIS,
       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any conditions of TITLE,
-      NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
-      PURPOSE. You are solely responsible for determining the
-      appropriateness of using or reproducing the Work and assume any
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
       risks associated with Your exercise of permissions under this License.
 
    8. Limitation of Liability. In no event and under no legal theory,
@@ -148,20 +156,23 @@
       unless required by applicable law (such as deliberate and grossly
       negligent acts) or agreed to in writing, shall any Contributor be
       liable to You for damages, including any direct, indirect, special,
-      incidental, or exemplary damages of any character arising as a
+      incidental, or consequential damages of any character arising as a
       result of this License or out of the use or inability to use the
       Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or all other
-      commercial damages or losses), even if such Contributor has been
-      advised of the possibility of such damages.
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
 
    9. Accepting Warranty or Additional Liability. While redistributing
       the Work or Derivative Works thereof, You may choose to offer,
       and charge a fee for, acceptance of support, warranty, indemnity,
       or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may offer
-      only obligations consistent to this License provided that the
-      obligations are consistent with this License.
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
 
    END OF TERMS AND CONDITIONS
 
@@ -171,19 +182,21 @@
       boilerplate notice, with the fields enclosed by brackets "[]"
       replaced with your own identifying information. (Don't include
       the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format in question. Also add information
-      on how to contact you electronically and/or by mail.
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
 
-      Copyright 2026 MetaObjects Contributors
+   Copyright 2026 MetaObjects Contributors
 
-      Licensed under the Apache License, Version 2.0 (the "License");
-      you may not use this file except in compliance with the License.
-      You may obtain a copy of the License at
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
 
-          http://www.apache.org/licenses/LICENSE-2.0
+       http://www.apache.org/licenses/LICENSE-2.0
 
-      Unless required by applicable law or agreed to in writing, software
-      distributed under the License is distributed on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-      See the License for the specific language governing permissions and
-      limitations under the License.
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

{metaobjects-0.15.10 → metaobjects-0.15.12}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.15.10"
+version = "0.15.12"
 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.10 → metaobjects-0.15.12}/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.10 → metaobjects-0.15.12}/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.10 → metaobjects-0.15.12}/src/metaobjects/core_types.py

@@ -6,6 +6,7 @@ from .attr_class_map import attr_class_for
 from .meta.core.attr import meta_attr as _attr  # noqa: F401
 from .meta.core.attr.attr_constants import (
     ATTR_SUBTYPE_BOOLEAN,
+    ATTR_SUBTYPE_FILTER,
     ATTR_SUBTYPE_INT,
     ATTR_SUBTYPE_STRING,
     ATTR_SUBTYPES,
@@ -76,6 +77,7 @@ from .meta.persistence.origin.meta_origin import MetaOrigin
 from .meta.persistence.origin.origin_constants import (
     ORIGIN_ATTR_AGG,
     ORIGIN_ATTR_CONVERT,
+    ORIGIN_ATTR_FILTER,
     ORIGIN_ATTR_FROM,
     ORIGIN_ATTR_OF,
     ORIGIN_ATTR_VIA,
@@ -372,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
@@ -631,6 +649,7 @@ core_provider.add(
             ),
             AttrSchema(name=ORIGIN_ATTR_OF, value_type=ATTR_SUBTYPE_STRING, required=True),
             AttrSchema(name=ORIGIN_ATTR_VIA, value_type=ATTR_SUBTYPE_STRING, required=False),
+            AttrSchema(name=ORIGIN_ATTR_FILTER, value_type=ATTR_SUBTYPE_FILTER, required=False),
         ],
         child_rules=[ChildRule(TYPE_ATTR, "*")],
     )

{metaobjects-0.15.10 → metaobjects-0.15.12}/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.10 → metaobjects-0.15.12}/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)

{metaobjects-0.15.10 → metaobjects-0.15.12}/src/metaobjects/loader/validate_source_parameter_ref.py

@@ -34,40 +34,27 @@ from ..meta.core.object.object_constants import (
     OBJECT_SUBTYPE_ENTITY,
     OBJECT_SUBTYPE_VALUE,
 )
+from ..naming_refs import resolve_object_ref
 from ..shared.base_types import TYPE_OBJECT, TYPE_SOURCE
-from ..shared.separators import PACKAGE_SEP
 
 _CALLABLE_KINDS = frozenset({SOURCE_KIND_STORED_PROC, SOURCE_KIND_TABLE_FUNCTION})
 
 
 def validate_source_parameter_ref(root: MetaData, errors: list[MetaError]) -> None:
-    # Pre-index every object by name, fqn AND resolution key so resolution costs
-    # O(1) per source. FR-032 (ADR-0032): @parameterRef is FULLY QUALIFIED after
-    # the desugar/sweep (e.g. ``acme::ParamVO``), which is the package-folded
-    # resolution_key() (objects keep a bare fqn() per FR5d), so the index must
-    # carry that key too. Mirrors the C# @parameterRef ResolutionKey() index.
     # ADR-0039 (mirrors the TS validate-source-parameter-ref): resolving is the
     # default. Root has no super, so children()==own_children() here, but the
     # inheritable reads below RESOLVE — @parameterRef on the source, the parameter
     # value-object's fields, and the referenced entity's field can all be inherited
     # via extends. The SOURCE iteration stays own (a source is validated on the
     # entity that declares it), as does origin.* (never inherits; ADR-0029).
-    object_index: dict[str, MetaData] = {}
-    for obj in root.children():
-        if obj.type != TYPE_OBJECT:
-            continue
-        object_index[obj.name] = obj
-        fqn = (
-            f"{obj.package}{PACKAGE_SEP}{obj.name}"
-            if obj.package
-            else obj.name
-        )
-        object_index[fqn] = obj
-        object_index[obj.resolution_key()] = obj
-
     for obj in root.children():
         if obj.type != TYPE_OBJECT:
             continue
+        # ADR-0042 — a bare @parameterRef resolves package-local (this object's
+        # package, else root-level); an FQN resolves exactly. Shares the single
+        # resolve_object_ref matcher — NO bare-name-anywhere fallback (which would
+        # silently bind a same-named value-object in another package).
+        referrer_pkg = obj.package or obj.file_default_package or ""
         for source in obj.own_children():
             if source.type != TYPE_SOURCE or source.sub_type != SOURCE_SUBTYPE_RDB:
                 continue
@@ -93,7 +80,7 @@ def validate_source_parameter_ref(root: MetaData, errors: list[MetaError]) -> No
                 )
                 continue
 
-            target = object_index.get(ref)
+            target = resolve_object_ref(root, ref, referrer_pkg)
             if target is None:
                 errors.append(
                     MetaError(