@@ -208,7 +208,9 @@ private ApiUnit BuildTemplateUnit(MetaData tmpl, MetaRoot root)
             {
                 // ADR-0039: resolving — @payloadRef may be inherited via an abstract template base.
                 var payloadRef = (string)tmpl.Attr(TEMPLATE_ATTR_PAYLOAD_REF)!;
-                var vo = PayloadGenerator.ResolvePayloadVo(root, payloadRef)!;
+                // ADR-0042: a bare @payloadRef resolves in the template's package.
+                var vo = PayloadGenerator.ResolvePayloadVo(
+                    root, payloadRef, global::MetaObjects.NamingRefs.EffectivePackage(tmpl))!;
                 symbols.Add(new ApiSymbol(
                     payloadRef, ApiSymbolKind.Payload, ns,
                     $"record {payloadRef}",
 
@@ -37,7 +37,9 @@ public virtual IEnumerable<EmittedFile> Generate(GenContext ctx)
             if (!AppliesTo(tmpl, ctx.Root)) continue;
             // ADR-0039: resolving — @payloadRef may be inherited via an abstract template base.
             var payloadRef = (string)tmpl.Attr(TEMPLATE_ATTR_PAYLOAD_REF)!;
-            var vo = ctx.Root.Children().First(c => c.Type == TYPE_OBJECT && c.Name == payloadRef);
+            // ADR-0042: a bare @payloadRef resolves in the template's package (else root-level).
+            var vo = global::MetaObjects.NamingRefs.ResolveObjectRef(
+                ctx.Root, payloadRef, global::MetaObjects.NamingRefs.EffectivePackage(tmpl))!;
             files.Add(EmitPrompt(tmpl, vo, payloadRef, ctx));
         }
         return files;
@@ -59,8 +61,9 @@ public static bool AppliesTo(MetaData tmpl, MetaRoot root)
             format.Equals("xml", StringComparison.OrdinalIgnoreCase);
         if (!supported) return false;
         if (tmpl.Attr(TEMPLATE_ATTR_PAYLOAD_REF) is not string payloadRef) return false;
-        // ADR-0039: Children() — resolving root scan (behavior-identical; root has no super).
-        return root.Children().Any(c => c.Type == TYPE_OBJECT && c.Name == payloadRef);
+        // ADR-0042: a bare @payloadRef resolves in the template's package (else root-level).
+        return global::MetaObjects.NamingRefs.ResolveObjectRef(
+            root, payloadRef, global::MetaObjects.NamingRefs.EffectivePackage(tmpl)) is not null;
     }
 
     protected virtual EmittedFile EmitPrompt(MetaData tmpl, MetaData vo, string payloadRef, GenContext ctx)
 
@@ -71,12 +71,15 @@ public static bool AppliesTo(MetaData tmpl, MetaRoot root)
         if (tmpl.Type != TYPE_TEMPLATE || tmpl.SubType != TEMPLATE_SUBTYPE_OUTPUT) return false;
         // ADR-0039: resolving — @payloadRef may be inherited via an abstract template base.
         if (tmpl.Attr(TEMPLATE_ATTR_PAYLOAD_REF) is not string payloadRef) return false;
-        return RenderHelperGenerator.ResolveValueObject(root, payloadRef) is not null;
+        // ADR-0042: a bare @payloadRef resolves in the template's package.
+        return RenderHelperGenerator.ResolveValueObject(
+            root, payloadRef, global::MetaObjects.NamingRefs.EffectivePackage(tmpl)) is not null;
     }
 
-    /// <summary>The root-level <c>object.value</c> a <c>@payloadRef</c> names, or null.</summary>
-    internal static MetaData? ResolvePayloadVo(MetaRoot root, string payloadRef) =>
-        RenderHelperGenerator.ResolveValueObject(root, payloadRef);
+    /// <summary>The <c>object.value</c> a <c>@payloadRef</c> names, or null. ADR-0042:
+    /// package-local — <paramref name="referrerPkg"/> is the declaring template's package.</summary>
+    internal static MetaData? ResolvePayloadVo(MetaRoot root, string payloadRef, string referrerPkg = "") =>
+        RenderHelperGenerator.ResolveValueObject(root, payloadRef, referrerPkg);
 
     protected virtual EmittedFile EmitPayload(string payloadRef, GenContext ctx)
     {
 
@@ -98,7 +98,8 @@ public virtual IEnumerable<EmittedFile> Generate(GenContext ctx)
             }
             // @payloadRef must resolve to an object.value (same contract as the
             // parser/prompt generators). The VO record name == payloadRef (PayloadCodegen).
-            var vo = ResolveValueObject(ctx.Root, payloadRef);
+            // ADR-0042: a bare @payloadRef resolves in the template's package.
+            var vo = ResolveValueObject(ctx.Root, payloadRef, global::MetaObjects.NamingRefs.EffectivePackage(tmpl));
             if (vo is null) continue;
 
             // EmitHelper runs the build-time drift gate first and THROWS (fails
@@ -108,11 +109,15 @@ public virtual IEnumerable<EmittedFile> Generate(GenContext ctx)
         return files;
     }
 
-    /// <summary>The root-level <c>object.value</c> a <c>@payloadRef</c> names, or null.</summary>
-    internal static MetaData? ResolveValueObject(MetaRoot root, string payloadRef) =>
-        // ADR-0039: Children() — resolving root scan (behavior-identical; root has no super).
-        root.Children().FirstOrDefault(c =>
-            c.Type == TYPE_OBJECT && c.SubType == OBJECT_SUBTYPE_VALUE && c.Name == payloadRef);
+    /// <summary>The <c>object.value</c> a <c>@payloadRef</c> names, or null. ADR-0042:
+    /// package-local — an FQN binds the exact package; a bare ref binds
+    /// <paramref name="referrerPkg"/> (the template's package) FIRST, else a root-level object.
+    /// Must resolve to an <c>object.value</c>.</summary>
+    internal static MetaData? ResolveValueObject(MetaRoot root, string payloadRef, string referrerPkg = "")
+    {
+        var obj = global::MetaObjects.NamingRefs.ResolveObjectRef(root, payloadRef, referrerPkg);
+        return obj is not null && obj.SubType == OBJECT_SUBTYPE_VALUE ? obj : null;
+    }
 
     /// <summary>
     /// True iff this generator emits a render helper for <paramref name="tmpl"/>: a
@@ -125,7 +130,8 @@ public static bool AppliesTo(MetaData tmpl, MetaRoot root)
         if (tmpl.Type != TYPE_TEMPLATE || tmpl.SubType != TEMPLATE_SUBTYPE_OUTPUT) return false;
         // ADR-0039: resolving — @payloadRef may be inherited via an abstract template base.
         if (tmpl.Attr(TEMPLATE_ATTR_PAYLOAD_REF) is not string payloadRef) return false;
-        return ResolveValueObject(root, payloadRef) is not null;
+        // ADR-0042: a bare @payloadRef resolves in the template's package.
+        return ResolveValueObject(root, payloadRef, global::MetaObjects.NamingRefs.EffectivePackage(tmpl)) is not null;
     }
 
     protected virtual EmittedFile EmitHelper(MetaData tmpl, MetaData vo, string payloadRef, GenContext ctx)
@@ -249,7 +255,13 @@ private static IReadOnlyList<PayloadField> DerivePayloadFieldTree(
                 // ADR-0039: resolving — @objectRef may be inherited via extends (TS reads f.attr).
                 f.Attr(FIELD_ATTR_OBJECT_REF) is string refName)
             {
-                var target = ResolveNestedObjectRef(root, refName);
+                // ADR-0042: a nested @objectRef resolves in the DECLARING field's package —
+                // 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).
+                var fieldPkg = f.Parent is not null
+                    ? global::MetaObjects.NamingRefs.EffectivePackage(f.Parent)
+                    : global::MetaObjects.NamingRefs.EffectivePackage(vo);
+                var target = ResolveNestedObjectRef(root, refName, fieldPkg);
                 if (target is not null && target.SubType == OBJECT_SUBTYPE_VALUE)
                 {
                     var children = DerivePayloadFieldTree(root, target, new HashSet<string>(seen, StringComparer.Ordinal));
@@ -263,25 +275,19 @@ private static IReadOnlyList<PayloadField> DerivePayloadFieldTree(
     }
 
     /// <summary>
-    /// Resolve a <c>field.object</c>'s <c>@objectRef</c> to its target
-    /// <c>object.value</c>. ADR-0041: a FULLY-QUALIFIED ref (contains <c>::</c>) resolves
-    /// EXACTLY on the package-qualified name (<c>ResolutionKey()</c>/<c>Fqn()</c>) — never
-    /// a bare-tail fallback that would bind a same-named <c>object.value</c> 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 <c>resolveNestedObjectRef</c> + TS
-    /// <c>refMatchesObject</c>. Returns null when no match is found.
+    /// Resolve a <c>field.object</c>'s <c>@objectRef</c> to its target <c>object.value</c>.
+    /// ADR-0042: package-local — an FQN ref (contains <c>::</c>) resolves EXACTLY on its
+    /// resolution key (never a bare-tail fallback that would bind a same-named
+    /// <c>object.value</c> in the WRONG package); a bare ref resolves in
+    /// <paramref name="referrerPkg"/> (the declaring field's package), else a root-level
+    /// object. Shares the single NamingRefs.ResolveObjectRef matcher (loader + codegen must
+    /// not drift). Returns null when no match is found.
     /// </summary>
-    private static MetaData? ResolveNestedObjectRef(MetaRoot root, string reference)
+    private static MetaData? ResolveNestedObjectRef(MetaRoot root, string reference, string referrerPkg)
     {
         if (string.IsNullOrEmpty(reference)) return null;
-        bool fqn = reference.Contains("::");
-        var refShort = CSharpNaming.StripPkg(reference);
-        // ADR-0039: Children() — resolving root scan (behavior-identical; root has no super).
-        return root.Children().FirstOrDefault(c =>
-            c.Type == TYPE_OBJECT && c.SubType == OBJECT_SUBTYPE_VALUE &&
-            (fqn
-                ? c.ResolutionKey() == reference || c.Fqn() == reference
-                : CSharpNaming.StripPkg(c.Name) == refShort));
+        var obj = global::MetaObjects.NamingRefs.ResolveObjectRef(root, reference, referrerPkg);
+        return obj is not null && obj.SubType == OBJECT_SUBTYPE_VALUE ? obj : null;
     }
 
     /// <summary>
 
@@ -492,6 +492,21 @@ private static void RegisterCoreTypeDefs(TypeRegistry registry)
                 IDENTITY_REFERENCE_ATTR_REFERENCES, TYPE_OBJECT, null, true, "ERR_INVALID_REFERENCE")];
         }
 
+        // ADR-0042 — a field.object / field.map @objectRef must resolve (a dangling target
+        // fails the load, closing the gap that surfaced downstream as a misleading runtime
+        // error; #191). The required-attr pass owns absence (ERR_OBJECT_FIELD_WITHOUT_OBJECT_REF);
+        // this descriptor fires only when @objectRef is PRESENT but resolves to nothing →
+        // ERR_UNRESOLVED_OBJECT_REF. Mirrors the TS core-types.ts registration.
+        foreach (string subType in new[] { FIELD_SUBTYPE_OBJECT, FIELD_SUBTYPE_MAP })
+        {
+            var fdef = registry.Find(TYPE_FIELD, subType);
+            if (fdef is not null)
+            {
+                fdef.References = [new MetaObjects.Validation.ReferenceDescriptor(
+                    FIELD_ATTR_OBJECT_REF, TYPE_OBJECT, null, false, "ERR_UNRESOLVED_OBJECT_REF")];
+            }
+        }
+
         // index — 1 subtype (lookup). Non-unique lookup indexes for query-performance.
         // Distinct from identity.secondary (which enforces uniqueness). A single
         // MetaIndex class backs the lookup subtype; physical attrs (@orders/@expr/
 
@@ -92,15 +92,12 @@ public enum ErrorCode
     // identity.reference @references names an FK target object that does not resolve
     // to any object in the loaded tree (a dangling cross-reference between metadata).
     ERR_INVALID_REFERENCE,
-    // ADR-0041 — cross-package reference contract. A BARE reference (no "::") names
-    // an object present in MORE THAN ONE package with NO match in the referrer's own
-    // package → ambiguous; the author must qualify it with the package (FQN). An FQN
-    // ref resolves exactly (never ambiguous); a bare ref unique anywhere, or matching
-    // the referrer's own package, resolves fine. Covers every object-ref-bearing attr
-    // (@objectRef / @references / @from|@of|@via heads / @payloadRef / @responseRef /
-    // @parameterRef). `extends` is EXCLUDED — its super-resolver is same-package/root-
-    // strict, so a bare cross-package extends is ERR_UNRESOLVED_SUPER, not ambiguous.
-    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. (ERR_AMBIGUOUS_REF is RETIRED: with bare = package-local,
+    // cross-package ambiguity is unreachable.)
+    ERR_UNRESOLVED_OBJECT_REF,
     ERR_BAD_ATTR_FILTER,
     ERR_STORAGE_WITHOUT_OBJECT_REF,
     // ADR-0013: a field.object REQUIRES @objectRef (open/untyped JSON uses the
 
@@ -482,10 +482,9 @@ public LoadResult Load(IReadOnlyList<IMetaDataSource> sources)
             // cardinality, extends/origin agreement)
             errors.AddRange(ValidationPasses.ValidateOriginPaths(root));
 
-            // Pass 5a: ADR-0041 — cross-package OBJECT-reference ambiguity. A bare
-            // ref (@objectRef/@references/@from|@of|@via head/@payloadRef/…) naming
-            // an object in multiple packages, none in the referrer's, → ERR_AMBIGUOUS_REF.
-            errors.AddRange(ValidationPasses.ValidateCrossPackageRefs(root));
+            // ADR-0042 — the cross-package ambiguity pass (ERR_AMBIGUOUS_REF) is RETIRED. A bare
+            // ref now resolves package-locally at every ref site via NamingRefs.ResolveObjectRef,
+            // so ambiguity is unreachable; an unresolved ref fails closed with its per-attr code.
 
             // Pass 5b: FR-024 B6 — derived-field providability on entities
             errors.AddRange(ValidationPasses.ValidateDerivedFieldProvidability(root));