fix(render,verify): close six divergences review found in the has-accessor change

Code review over the branch found that the change meant to END a cross-port
divergence had introduced four of its own, plus two verify defects. Fixing them is
the point; the lesson is that "one shared rule" written four times in four
languages is still four implementations.

A LIVE REGRESSION, worst first. TS rebuilt ANY non-array object from
Object.entries(), so anything carrying its own prototype was flattened: a Date
rendered as "[object Object]" and a class instance lost its getters. Confirmed by
running it. Now only PLAIN objects are rebuilt (prototype is Object.prototype or
null), which is also what the other ports do.

THE FOUR PORTS DID NOT AGREE:
  - C#  an IDictionary is IEnumerable, so it matched the collection arm and an
        empty nested object reported ABSENT where every other port says present.
        Dictionary is now matched first.
  - Java recursion covered Map/List only, so Set elements and array elements got no
        accessors -- contradicting the method's own javadoc; and an empty primitive
        array reported PRESENT because Object[] does not match int[]. Now every
        Collection recurses, arrays recurse by reflection, and length is read with
        Array.getLength.
  - Py   the numeric skip listed int/float/complex, missing Decimal and Fraction,
        so Python injected hasPrice where Java and C# inject nothing. Now
        numbers.Number.

TWO VERIFY DEFECTS:
  - The unclassified-file fail-open downgraded a broken @Verifiedby claim to a
    warning if the name appeared ANYWHERE in production source -- including the
    mountCrudRoutes case this file's own header cites as why the comment-only check
    exists. The downgrade now requires the file to look like a test by LOCATION or
    by CONTENT; production source with a matching name satisfies neither and stays
    a hard error.
  - The bare-name fallback for non-object claims reached into any package where the
    name was unique. resolveObjectRef's own bare fallback is root-level only; this
    now matches it.

GATED, not just fixed. The shared conformance fixture gains the empty-nested-object
case that catches the C# arm, so all five ports pin it rather than three agreeing by
luck. TS gains four regression tests (Date renders as a Date, class getters survive,
a Date-valued field still derives, nested plain objects still derive).

Verified after: TS render 327, cli 20 targeted; C# 291; Python 257; JVM render green
(snapshot regenerated for the extended fixture).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: dmealing

fixtures/render-conformance/render-derived-has-accessor/expected.txt

@@ -2,4 +2,5 @@ title:Party
 bio: (none)
 sponsor: Guild
 companions: (none)
-abilities: Fireball[fire aoe ] Mend[untagged]
+abilities: Fireball[fire aoe ] Mend[untagged]
+details: present

fixtures/render-conformance/render-derived-has-accessor/payload.json

@@ -2,9 +2,21 @@
   "title": "Party",
   "bio": "   ",
   "abilities": [
-    { "name": "Fireball", "tags": ["fire", "aoe"] },
-    { "name": "Mend", "tags": [] }
+    {
+      "name": "Fireball",
+      "tags": [
+        "fire",
+        "aoe"
+      ]
+    },
+    {
+      "name": "Mend",
+      "tags": []
+    }
   ],
   "companions": [],
-  "sponsor": { "name": "Guild" }
-}
+  "sponsor": {
+    "name": "Guild"
+  },
+  "emptyDetails": {}
+}

fixtures/render-conformance/render-derived-has-accessor/template.mustache

@@ -2,4 +2,5 @@ title:{{title}}
 bio:{{#hasBio}} {{bio}}{{/hasBio}}{{^hasBio}} (none){{/hasBio}}
 sponsor:{{#hasSponsor}} {{sponsor.name}}{{/hasSponsor}}
 companions:{{#hasCompanions}} some{{/hasCompanions}}{{^hasCompanions}} (none){{/hasCompanions}}
-abilities:{{#hasAbilities}}{{#abilities}} {{name}}{{#hasTags}}[{{#tags}}{{.}} {{/tags}}]{{/hasTags}}{{^hasTags}}[untagged]{{/hasTags}}{{/abilities}}{{/hasAbilities}}
+abilities:{{#hasAbilities}}{{#abilities}} {{name}}{{#hasTags}}[{{#tags}}{{.}} {{/tags}}]{{/hasTags}}{{^hasTags}}[untagged]{{/hasTags}}{{/abilities}}{{/hasAbilities}}
+details:{{#hasEmptyDetails}} present{{/hasEmptyDetails}}{{^hasEmptyDetails}} absent{{/hasEmptyDetails}}

server/csharp/MetaObjects.Render/PayloadAccessors.cs

@@ -76,6 +76,9 @@ public static bool IsBooleanAccessor(List<IReadOnlyList<PayloadField>> stack, st
             case bool: return null;
             case sbyte or byte or short or ushort or int or uint or long or ulong
                 or float or double or decimal: return null;
+            // A dictionary IS IEnumerable, so it must be matched FIRST — otherwise an
+            // empty nested object reports absent here and present in every other port.
+            case System.Collections.IDictionary: return true;
             case System.Collections.IEnumerable seq:
             {
                 foreach (var _ in seq) return true;

server/java/render/src/main/java/com/metaobjects/render/PayloadAccessors.java

@@ -61,8 +61,11 @@ public static Boolean accessorValue(Object value) {
         if (value == null) return Boolean.FALSE;
         if (value instanceof CharSequence cs) return !cs.toString().isBlank();
         if (value instanceof Boolean || value instanceof Number) return null;
+        if (value instanceof java.util.Map<?, ?>) return Boolean.TRUE;
         if (value instanceof java.util.Collection<?> c) return !c.isEmpty();
-        if (value instanceof Object[] a) return a.length > 0;
+        // getLength covers primitive arrays too; Object[] alone reported an empty
+        // int[] as present, where every other port reports absent.
+        if (value.getClass().isArray()) return java.lang.reflect.Array.getLength(value) > 0;
         return Boolean.TRUE;
     }
 
@@ -101,9 +104,17 @@ private static Object withDerivedAccessors(Object payload, int depth) {
             }
             return out;
         }
-        if (payload instanceof java.util.List<?> list) {
-            java.util.List<Object> out = new java.util.ArrayList<>(list.size());
-            for (Object item : list) out.add(withDerivedAccessors(item, depth + 1));
+        // Every Collection, not just List — a Set's elements are contexts too, which
+        // this method's own contract promises.
+        if (payload instanceof java.util.Collection<?> coll) {
+            java.util.List<Object> out = new java.util.ArrayList<>(coll.size());
+            for (Object item : coll) out.add(withDerivedAccessors(item, depth + 1));
+            return out;
+        }
+        if (payload.getClass().isArray() && !payload.getClass().getComponentType().isPrimitive()) {
+            int n = java.lang.reflect.Array.getLength(payload);
+            java.util.List<Object> out = new java.util.ArrayList<>(n);
+            for (int i = 0; i < n; i++) out.add(withDerivedAccessors(java.lang.reflect.Array.get(payload, i), depth + 1));
             return out;
         }
         return payload;

server/java/render/src/test/resources/snapshots/render-derived-has-accessor.txt

@@ -2,4 +2,5 @@ title:Party
 bio: (none)
 sponsor: Guild
 companions: (none)
-abilities: Fireball[fire aoe ] Mend[untagged]
+abilities: Fireball[fire aoe ] Mend[untagged]
+details: present

server/python/src/metaobjects/render/payload_accessors.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import numbers
 from collections.abc import Mapping, Sequence
 from typing import Any
 
@@ -71,7 +72,7 @@ def accessor_value(value: Any) -> bool | None:
     if isinstance(value, str):
         return bool(value.strip())
     # bool before int — bool IS an int in Python, and a boolean field gets no accessor.
-    if isinstance(value, (bool, int, float, complex)):
+    if isinstance(value, numbers.Number):
         return None
     if isinstance(value, Mapping):
         return True

server/typescript/packages/cli/src/lib/requirement-check.ts

@@ -183,7 +183,9 @@ function resolveClaimTarget(root: MetaData, owner: string, referrerPkg: string):
   // at the wrong thing without anyone noticing.
   const local = referrerPkg === "" ? [] : candidates.filter((c) => c.resolutionKey() === `${referrerPkg}${PACKAGE_SEPARATOR}${owner}`);
   if (local.length === 1) return local[0];
-  const bare = candidates.filter((c) => c.name === owner);
+  // Root-level (unpackaged) only, matching resolveObjectRef's own bare fallback. A bare
+  // ref must not reach into an arbitrary package just because the name is unique there.
+  const bare = candidates.filter((c) => c.name === owner && c.resolutionKey() === owner);
   return bare.length === 1 ? bare[0] : undefined;
 }
 

server/typescript/packages/cli/src/lib/verified-by-scan.ts

@@ -183,6 +183,20 @@ function walk(
  * per run. Returns the first unclassified source file containing the name, which is
  * enough to tell the author which pattern they are missing.
  */
+/** Does this path or body look like a test the corpus definition simply did not match?
+ *  Deliberately narrow: living under a test directory, or containing an assertion/test
+ *  declaration. Without this, a name occurring anywhere in PRODUCTION source downgrades a
+ *  genuinely broken claim to a warning — the exact failure the comment-only check exists
+ *  to catch. */
+const TESTISH_PATH = /(^|\/)(tests?|spec|__tests__|src\/test)(\/|$)/i;
+const TESTISH_BODY = /\b(assert\w*|expect|should|@Test|def test_|it\(|test\(|describe\()/;
+
+/** Test by LOCATION or by CONTENT — either is enough. Production source with a matching
+ *  name satisfies neither, which is the case that must stay a hard error. */
+function looksLikeTest(rel: string, lines: string[]): boolean {
+  return TESTISH_PATH.test(rel) || lines.some((l) => TESTISH_BODY.test(l));
+}
+
 function findOutsideCorpus(name: string, root: string, files: string[]): string | undefined {
   const rx = wordRx(name);
   for (const rel of files) {
@@ -192,7 +206,7 @@ function findOutsideCorpus(name: string, root: string, files: string[]): string
       const lines = readFileSync(abs, "utf8").split("\n");
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i] ?? "";
-        if (rx.test(line) && !isCommentLine(line, rel)) return rel;
+        if (rx.test(line) && !isCommentLine(line, rel) && looksLikeTest(rel, lines)) return rel;
       }
     } catch {
       /* unreadable file is not a finding */

server/typescript/packages/render/src/payload-accessors.ts

@@ -77,6 +77,12 @@ export function withDerivedAccessors<T>(payload: T, depth = 0): T {
     return payload.map((v) => withDerivedAccessors(v, depth + 1)) as unknown as T;
   }
   if (payload === null || typeof payload !== "object") return payload;
+  // PLAIN objects only. Rebuilding from Object.entries() would flatten anything with
+  // its own prototype — a Date stringifies to "[object Object]" and a class instance
+  // loses its getters — and the other ports only rebuild map-shaped values, so
+  // rebuilding more here would be a divergence as well as a regression.
+  const proto = Object.getPrototypeOf(payload);
+  if (proto !== Object.prototype && proto !== null) return payload;
 
   const src = payload as Record<string, unknown>;
   const out: Record<string, unknown> = {};