fix(jvm): ADR-0039 — resolving accessors are the default (Java + Kotlin port)

extends is a super-REFERENCE, not a flatten: inherited attrs/children/isArray
live on the parent, reachable only through the resolving accessors. Reading a
field/node's effective property or member set through an own-only accessor
silently dropped everything inherited via extends — corrupting codegen (an
entity inheriting its source.rdb emitted NOTHING), effective serialization,
and loader validation. Mirrors the TS reference.

The isArray resolver
- MetaField.isArrayType() now FULLY resolves: it walks the extends super chain
  for the native isArray flag (resolvedNativeIsArray) as well as the @isarray
  attr, so a concrete field extending an abstract array field is array-typed.
  isArray() stays the own-only raw flag; all codegen array reads route through
  isArrayType().

Metadata core
- MetaObject.getSources() no-arg now RESOLVES (getSources(true)), matching
  getMetaFields()/getIdentities()/getRelationships(). The declaration-layer
  one-primary-source validation keeps own-only via explicit getSources(false).
- ValidationPhase: field.object @objectRef/@storage and field.map
  @valueType/@objectref reads flipped own→resolving (fixed the shared fixture's
  false ERR_OBJECT_FIELD_WITHOUT_OBJECT_REF for a field.object extending an
  abstract AddressBag). @dbColumnType stays own-only (commented).
- CanonicalJsonSerializer: effective mode now inlines inherited array-ness
  (getNativeIsArray resolves via isArrayType in effective mode; own mode keeps
  the raw flag so the authored form round-trips).

Java codegen (codegen-spring)
- SpringTypeMapper / SpringPayloadGenerator / OutputFormatSpecEmitter: raw
  field.isArray() → resolving isArrayType(); OutputFormatSpecEmitter
  @enumDoc/@example/@Instruction flipped own→resolving (consistent with the
  already-resolving @values/@required).

Kotlin codegen (codegen-kotlin)
- New resolving source lookup KotlinGenUtil.firstRdbSource/hasRdbSource
  (getSources(true)); routed ALL 8 generators' own-only
  entity.children.filterIsInstance<RdbSource>() reads through it — an entity
  inheriting its source.rdb via extends now emits its table/controller/etc.
- KotlinTypeMapper: intAttr (@precision/@scale) and stringAttr default
  (@valueType) flipped own→resolving (consistent with stringMaxLength).
- KotlinExtractSchemaEmitter / KotlinOutputFormatSpecEmitter: raw .isArray →
  isArrayType(); @enumDoc/@example/@Instruction → resolving.
- KotlinEntityGenerator.validator(): raw field.children →
  getChildren(MetaValidator, true).

Kept own-only (each commented): @dbColumnType (never inherited by policy);
one-primary-source validation (declaration-layer); @isAbstract/@discriminator/
@provided/@kind/template-ref reads; origin.* reads (origin never inherits).

Tests
- New KotlinAbstractFieldExtendsInheritanceTest gates the two ADR-0039 shapes:
  a concrete entity inheriting its source.rdb via extends emits an Exposed
  table, and concrete fields extending an abstract array field / abstract
  decimal field inherit isArray / @precision+@scale. Verified it FAILS on
  pre-fix code.
- Shared fixtures/conformance/extends-abstract-field-inheritance now passes in
  the Java conformance runner (loader + effective serializer). Fixture unchanged.

All green: Java metadata+codegen-spring 158, Java conformance 394, Kotlin
codegen 266, Kotlin integration (Testcontainers) 92, Java integration
(Testcontainers) 86. No existing goldens/snapshots changed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GF9xLEQZaPus5Y6opk398n

Author: claude

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGenerator.kt

@@ -371,7 +371,10 @@ open class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
     }
 
     private fun <V : MetaValidator> validator(field: MetaField<*>, type: Class<V>): V? {
-        for (child in field.children) {
+        // ADR-0039: resolving member iteration — getChildren(type) walks the extends
+        // super chain, so a concrete field inherits validators from an abstract base.
+        // A raw field.children read would miss inherited validators.
+        for (child in field.getChildren(MetaValidator::class.java, true)) {
             if (type.isInstance(child)) return type.cast(child)
         }
         return null

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGenerator.kt

@@ -81,7 +81,9 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
                 entity.subType != MetaObject.SUBTYPE_PROJECTION) continue
             // Abstract entities are inheritance scaffolding — never emit a persistence table.
             if (KotlinGenUtil.isAbstractEntity(entity)) continue
-            val sourceRdb = entity.children.filterIsInstance<RdbSource>().firstOrNull() ?: continue
+            // ADR-0039: resolving source lookup — an entity inheriting its source.rdb via
+            // extends must still emit a table (own-only .children returned null → no table).
+            val sourceRdb = KotlinGenUtil.firstRdbSource(entity) ?: continue
             val kind = sourceRdb.effectiveKind
             // table + view + materializedView → emit; view-like kinds are emitted read-only.
             // storedProc → skip; consumer should wire KotlinStoredProcGenerator for those entities.
@@ -927,7 +929,8 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
      */
     private fun buildInverseFkSpec(owner: MetaObject, rel: MetaRelationship): FkColumnSpec? {
         // Skip when the owner has no rdb source — there would be no OwnerTable to reference.
-        if (owner.children.filterIsInstance<RdbSource>().firstOrNull() == null) return null
+        // ADR-0039: resolving (an inherited source.rdb still means the owner is persisted).
+        if (!KotlinGenUtil.hasRdbSource(owner)) return null
         val ownerShort = PackageMapping.splitFqn(owner.name).second
         val ownerTable = ownerShort + "Table"
         val propertyName = ownerShort.replaceFirstChar { it.lowercaseChar() } + "Id"
@@ -1027,7 +1030,8 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
                 val targetEntityName = child.targetEntity ?: continue
                 val target = KotlinGenUtil.resolveObjectByShortOrFqn(loader, targetEntityName) ?: continue
                 // Skip when the target has no rdb source — Exposed cannot reference a non-table.
-                if (target.children.filterIsInstance<RdbSource>().firstOrNull() == null) continue
+                // ADR-0039: resolving (an inherited source.rdb still means the target is a table).
+                if (!KotlinGenUtil.hasRdbSource(target)) continue
                 // Soft references register a null-targetTable entry so dedup-vs-inferred works,
                 // but column emission will skip the `.references(...)` decoration.
                 val targetTable = if (child.isEnforced)

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExtractSchemaEmitter.kt

@@ -143,7 +143,8 @@ internal object KotlinExtractSchemaEmitter {
      * Mirrors [KotlinTypeMapper.kotlinTypeName] but always nullable with `= null` defaults.
      */
     private fun nullableTypeName(field: MetaField<*>): String = when {
-        field.isArray                -> "List<String>?"
+        // ADR-0039: resolving array-ness (isArray is the own-only native flag).
+        field.isArrayType()          -> "List<String>?"
         field is EnumField           -> "String?"
         field is StringField         -> "String?"
         field is IntegerField        -> "Int?"

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinFilterAllowlistGenerator.kt

@@ -55,7 +55,8 @@ open class KotlinFilterAllowlistGenerator : MultiFileDirectGeneratorBase<MetaObj
         val outRoot = Paths.get(outDir.absolutePath)
         for (entity in loader.metaObjects) {
             if (entity.subType != MetaObject.SUBTYPE_ENTITY) continue
-            val sourceRdb = entity.children.filterIsInstance<RdbSource>().firstOrNull() ?: continue
+            // ADR-0039: resolving source lookup (inherited source.rdb via extends).
+            val sourceRdb = KotlinGenUtil.firstRdbSource(entity) ?: continue
             // Only writable tables get a filter allowlist (the controller is also
             // table-only). View / materializedView are read-only; storedProc has its
             // own dispatch; tableFunction has no controller surface today.

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinGenUtil.kt

@@ -4,6 +4,7 @@ import com.metaobjects.MetaData
 import com.metaobjects.field.MetaField
 import com.metaobjects.loader.MetaDataLoader
 import com.metaobjects.`object`.MetaObject
+import com.metaobjects.source.RdbSource
 
 /**
  * Internal helpers shared by the codegen-kotlin generators. Extracted to keep
@@ -23,6 +24,23 @@ internal object KotlinGenUtil {
         return null
     }
 
+    /**
+     * The first `source.rdb` child of [obj], RESOLVED through the `extends` super chain
+     * (ADR-0039). `MetaObject.getSources(true)` walks the inheritance chain, so an entity
+     * that inherits its `source.rdb` from a base entity still resolves a source — a raw
+     * `obj.children.filterIsInstance<RdbSource>()` read returned null for such entities and
+     * the generators emitted NOTHING for them (the high-blast-radius own-accessor bug).
+     * Returns null when neither the object nor any ancestor declares an `source.rdb`.
+     */
+    fun firstRdbSource(obj: MetaObject): RdbSource? =
+        obj.getSources(true).filterIsInstance<RdbSource>().firstOrNull()
+
+    /**
+     * True iff [obj] (or any ancestor via `extends`) declares a `source.rdb` — i.e. it is
+     * persisted. Resolving (ADR-0039). See [firstRdbSource].
+     */
+    fun hasRdbSource(obj: MetaObject): Boolean = firstRdbSource(obj) != null
+
     /**
      * Split `"A.b"` into `("A","b")`; null if the ref isn't a single-dot ref
      * (no dot, leading dot, or trailing dot).

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputFormatSpecEmitter.kt

@@ -102,7 +102,8 @@ internal object KotlinOutputFormatSpecEmitter {
     private fun promptFieldLiteral(field: MetaField<*>): String {
         val name = field.name
         val required = KotlinExtractSchemaEmitter.isRequired(field)
-        val array = field.isArray
+        // ADR-0039: resolving array-ness (isArray is the own-only native flag).
+        val array = field.isArrayType()
 
         // Nested object OR open-keyed map — both structured JSON values; bounded
         // deferral (mirrors Java plan 3.1). FieldKind.OBJECT, nested prompt deferred.
@@ -138,9 +139,10 @@ internal object KotlinOutputFormatSpecEmitter {
         val valuesLit = "listOf($valuesList)"
 
         // @enumDoc — optional; null when absent or empty.
+        // ADR-0039: @enumDoc is an effective property — resolve (consistent with @values above).
         val enumDocLit: String = run {
-            if (!field.hasMetaAttr(EnumField.ATTR_ENUM_DOC, false)) return@run "null"
-            val v = field.getMetaAttr(EnumField.ATTR_ENUM_DOC, false).value
+            if (!field.hasMetaAttr(EnumField.ATTR_ENUM_DOC)) return@run "null"
+            val v = field.getMetaAttr(EnumField.ATTR_ENUM_DOC).value
             if (v is Properties && v.isNotEmpty()) KotlinExtractSchemaEmitter.buildMapOfLiteral(v) else "null"
         }
 
@@ -160,8 +162,10 @@ internal object KotlinOutputFormatSpecEmitter {
      * example/instruction free-text containing quotes or newlines embeds safely in Kotlin source.
      */
     private fun optStringAttr(field: MetaField<*>, attrName: String): String {
-        if (!field.hasMetaAttr(attrName, false)) return "null"
-        val v = field.getMetaAttr(attrName, false).valueAsString ?: return "null"
+        // ADR-0039: @example/@instruction are effective properties — resolve (consistent
+        // with @values/@required which resolve).
+        if (!field.hasMetaAttr(attrName)) return "null"
+        val v = field.getMetaAttr(attrName).valueAsString ?: return "null"
         return "\"${KotlinExtractSchemaEmitter.kotlinStringLiteral(v)}\""
     }
 

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinRelationsGenerator.kt

@@ -8,7 +8,6 @@ import com.metaobjects.loader.MetaDataLoader
 import com.metaobjects.`object`.MetaObject
 import com.metaobjects.relationship.CompositionRelationship
 import com.metaobjects.relationship.MetaRelationship
-import com.metaobjects.source.RdbSource
 import com.squareup.kotlinpoet.LONG
 import com.squareup.kotlinpoet.TypeName
 import java.io.OutputStream
@@ -68,7 +67,8 @@ open class KotlinRelationsGenerator : MultiFileDirectGeneratorBase<MetaObject>()
             // Abstract entities are inheritance scaffolding — never emit relation helpers.
             if (KotlinGenUtil.isAbstractEntity(entity)) continue
             // No source.rdb → no persistence layer → no FK column to query against.
-            entity.children.filterIsInstance<RdbSource>().firstOrNull() ?: continue
+            // ADR-0039: resolving (an inherited source.rdb still means the entity is persisted).
+            if (!KotlinGenUtil.hasRdbSource(entity)) continue
 
             val manyRels = entity.children
                 .filterIsInstance<MetaRelationship>()

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinSpringControllerGenerator.kt

@@ -91,7 +91,8 @@ open class KotlinSpringControllerGenerator : MultiFileDirectGeneratorBase<MetaOb
             // FR-017 TPH: a subtype is folded into its base's single table + base controller (it
             // also carries no own source.rdb, so the guard below would skip it too).
             if (KotlinTphPlan.isTphSubtype(entity)) continue
-            val sourceRdb = entity.children.filterIsInstance<RdbSource>().firstOrNull() ?: continue
+            // ADR-0039: resolving source lookup (inherited source.rdb via extends).
+            val sourceRdb = KotlinGenUtil.firstRdbSource(entity) ?: continue
             val kind = sourceRdb.effectiveKind
             // Only writable tables get a CRUD controller. View / materializedView are
             // read-only (would need a different controller shape — list + get only);

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinStoredProcGenerator.kt

@@ -76,7 +76,8 @@ open class KotlinStoredProcGenerator : MultiFileDirectGeneratorBase<MetaObject>(
                 entity.subType != MetaObject.SUBTYPE_PROJECTION) continue
             // Abstract entities are inheritance scaffolding — never emit a stored-proc binding.
             if (KotlinGenUtil.isAbstractEntity(entity)) continue
-            val sourceRdb = entity.children.filterIsInstance<RdbSource>().firstOrNull() ?: continue
+            // ADR-0039: resolving source lookup (inherited source.rdb via extends).
+            val sourceRdb = KotlinGenUtil.firstRdbSource(entity) ?: continue
             if (sourceRdb.effectiveKind != MetaSource.KIND_STORED_PROC) continue
             emit(entity, sourceRdb, outRoot)
         }

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapper.kt

@@ -321,7 +321,8 @@ object KotlinTypeMapper {
      * `@valueType` / `@objectRef` is set and that `@valueType` names a scalar subtype.
      */
     fun mapValueScalarTypeName(field: MapField): TypeName? =
-        when (stringAttr(field, MapField.ATTR_VALUE_TYPE)) {
+        // ADR-0039: @valueType is an effective property — resolve through extends.
+        when (stringAttr(field, MapField.ATTR_VALUE_TYPE, includeParent = true)) {
             StringField.SUBTYPE_STRING    -> STRING
             IntegerField.SUBTYPE_INT      -> INT
             LongField.SUBTYPE_LONG        -> LONG
@@ -583,8 +584,10 @@ object KotlinTypeMapper {
      * [includeParent] = true also walks the `extends` super-field chain). Returns null when
      * the attribute is absent, throws during lookup, or isn't a [com.metaobjects.attr.MetaAttribute].
      * Used for non-typed dispatch keys (e.g. `@dbColumnType`, `@valueType`) read off a field.
+     * ADR-0039: [includeParent] defaults to true (resolving is the default); pass false only
+     * for the rare own-only case.
      */
-    private fun stringAttr(field: MetaField<*>, name: String, includeParent: Boolean = false): String? {
+    private fun stringAttr(field: MetaField<*>, name: String, includeParent: Boolean = true): String? {
         if (!field.hasMetaAttr(name, includeParent)) return null
         val attr = runCatching {
             field.getMetaAttr(name, includeParent)
@@ -610,10 +613,15 @@ object KotlinTypeMapper {
     private fun decimalScale(field: DecimalField): Int =
         intAttr(field, DecimalField.ATTR_SCALE) ?: DECIMAL_DEFAULT_SCALE
 
-    /** Best-effort read of a named int-valued attribute (own-only) on [field]; null when absent/unparseable. */
+    /**
+     * Best-effort read of a named int-valued attribute on [field], resolved THROUGH the
+     * `extends` super-field chain (own value wins); null when absent/unparseable. ADR-0039:
+     * `@precision`/`@scale` are effective properties — a concrete field extending an abstract
+     * decimal must inherit them (consistent with [stringMaxLengthOrNull] which resolves).
+     */
     private fun intAttr(field: MetaField<*>, name: String): Int? {
-        if (!field.hasMetaAttr(name, false)) return null
-        val raw = runCatching { field.getMetaAttr(name, false).value }.getOrNull()
+        if (!field.hasMetaAttr(name, true)) return null
+        val raw = runCatching { field.getMetaAttr(name, true).value }.getOrNull()
         return when (raw) {
             is Number -> raw.toInt()
             is String -> raw.toIntOrNull()