fix(jvm): ADR-0039 own-accessor sweep — remaining non-sanctioned own reads (Java + Kotlin)

Second-pass ADR-0039 sweep over the JVM tree (metadata, codegen-spring,
codegen-kotlin, omdb, core-spring): find every remaining own-only read, flip
the ones that read an INHERITABLE effective value/member set (bugs — extends is
a super-reference, so own drops inherited members), and comment every read that
is legitimately own.

BUGs flipped (own -> resolving):
- Kotlin controller/relations/m2m/exposed-table: identity + relationship member
  iteration was reading entity.children (own) via filterIsInstance — flipped to
  entity.getIdentities(true) / entity.relationships (identities & relationships
  ARE inheritable; an entity inheriting its PK identity or a relationship from a
  BaseEntity was silently dropped). Sites: KotlinSpringControllerGenerator PK,
  KotlinRelationsGenerator (manyRels, reverseFks, primaryKeyKotlinType),
  KotlinM2mSupport.primaryKeyField, KotlinExposedTableGenerator (composition FK +
  identity.reference decorations), KotlinPayloadGenerator @via relationship.
- KotlinStoredProcGenerator: @param (field) and @proc/@table/@procname (source)
  were own — flipped (@param is an inheritable field property; source attrs are
  inheritable).
- SpringRenderHelperGenerator.resolveNestedObjectRef: field @objectref was own —
  flipped (matches TS render-helper's resolving field .attr() and the already-
  resolving Kotlin sibling).
- M2MFields (shared codegen+runtime M:N FK derivation): junction
  identity.reference iteration and @references read were own — flipped to the
  resolving getIdentities()/getMetaAttr, matching the TS reference whose
  referenceIdentities() builds on the resolving identities() ("effective view,
  own + inherited"). Own would mis-derive M:N FK direction for an inherited
  junction reference.
- MetaSource.getPhysicalName: @proc/@table aliases were own — flipped to
  resolving, matching getTableName()/getEffectiveKind()/getRole() and the C#
  port's ADR-0039 resolving PhysicalName.

KEPT own + commented (sanctioned):
- template.* attr getters (MetaTemplate/OutputTemplate/PromptTemplate/
  ToolcallTemplate + render-helper/api-model @kind reads): templates read own by
  cross-port contract (TS/C# use ownAttr/OwnAttr) — a template's declared refs
  are authored-here, not inherited.
- origin.* reads (KotlinPayloadGenerator field.children<MetaOrigin>): origin
  NEVER inherits (ADR-0029).
- declaration-layer markers: @isAbstract (IOUtil/CanonicalJsonSerializer/
  KotlinGenUtil), TPH @discriminator/@discriminatorValue (TphPlan/KotlinTphPlan/
  TphHelper), @provided (Fr019SharedEnum) — describe THIS declaration, never
  inherited.
- @dbColumnType stays the physical own-only exception (validation site commented;
  the JVM type-mappers already resolve it in the codegen role, matching TS
  column-mapper — schema/migrate is TS-owned so no own-only schema reader exists
  on the JVM).
- root-level scans (MetaRoot.objects/fields/findObject, SymbolTable,
  Spring/omdb M2M findEntity, root.children template scans): root is never
  extended — own is the complete set (matches TS root.ownChildren()).
- super-resolution walks (MetaObject.getSources per-hop, discriminatorRoot) and
  the ValidationPhase structural tree-recursion + validate-own-declaration attr
  reads (class-level policy comment) + parser source-tagging.

Verification: Java metadata 1065, codegen-spring 158, omdb/core-spring 74,
Kotlin codegen 266, Java + Kotlin Testcontainers integration suites all green.
No golden/snapshot changed (only *.java/*.kt sources touched) — the flips only
affect INHERITED members, which no existing fixture exercised on these paths.

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/Fr019SharedEnum.kt

@@ -61,7 +61,11 @@ internal object Fr019SharedEnum {
         return sup
     }
 
-    /** Own-only read of `@provided` on an enum declaration. */
+    /**
+     * Read `@provided` on an enum declaration. ADR-0039: `@provided` is a
+     * declaration-layer marker (like `@isAbstract`) — describes THIS declaration,
+     * never inherited through extends. KEPT own-only.
+     */
     fun isProvided(decl: EnumField): Boolean {
         if (!decl.hasMetaAttr(EnumField.ATTR_PROVIDED, false)) return false
         val raw = runCatching { decl.getMetaAttr(EnumField.ATTR_PROVIDED, false).value }.getOrNull()

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

@@ -843,8 +843,9 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
 
         for (entity in loader.metaObjects) {
             if (entity.subType != MetaObject.SUBTYPE_ENTITY) continue
-            for (child in entity.children) {
-                if (child !is MetaRelationship) continue
+            // ADR-0039: relationships are inheritable — RESOLVE via entity.relationships;
+            // entity.children (own-only) would miss an inherited relationship.
+            for (child in entity.relationships) {
                 if (child.subType != CompositionRelationship.SUBTYPE_COMPOSITION) continue
 
                 val objectRef = child.objectRef ?: continue
@@ -1016,7 +1017,9 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         val acc = linkedMapOf<String, MutableMap<String, RefDecoration>>()
         for (entity in loader.metaObjects) {
             if (entity.subType != MetaObject.SUBTYPE_ENTITY) continue
-            for (child in entity.children) {
+            // ADR-0039: identity.reference children are inheritable — RESOLVE via
+            // getIdentities(true); entity.children (own-only) would miss inherited FK refs.
+            for (child in entity.getIdentities(true)) {
                 if (child !is ReferenceIdentity) continue
                 val fields = child.fields
                 if (fields.size != 1) {

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

@@ -71,6 +71,8 @@ open class KotlinExtractorGenerator : MultiFileDirectGeneratorBase<MetaObject>()
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches the sibling generators' deterministic emission.
+        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
+        // reference's root.ownChildren()), so own children is correct.
         val outputs = loader.root.children
             .filterIsInstance<OutputTemplate>()
             .sortedBy { it.name }

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

@@ -52,11 +52,12 @@ internal object KotlinGenUtil {
     }
 
     /**
-     * True if [obj] has an own `@isAbstract` attribute set to boolean-true. Reads only the
-     * own attribute (not inherited) — matches the ValidationPhase convention so concrete
-     * subtypes extending an abstract base still emit. Shared by every instance/write
-     * generator so the "never emit write artifacts for an abstract entity" invariant has a
-     * single definition.
+     * True if [obj] has an own `@isAbstract` attribute set to boolean-true. ADR-0039:
+     * `@isAbstract` is a declaration-layer marker — it describes THIS declaration and must
+     * NOT be inherited (a concrete subtype extending an abstract base is itself concrete
+     * and MUST emit). KEPT own-only, matching the ValidationPhase / GeneratorUtil.isAbstract
+     * convention. Shared by every instance/write generator so the "never emit write
+     * artifacts for an abstract entity" invariant has a single definition.
      */
     fun isAbstractEntity(obj: MetaObject): Boolean {
         if (!obj.hasMetaAttr(MetaData.ATTR_IS_ABSTRACT, false)) return false

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

@@ -108,7 +108,9 @@ object KotlinM2mSupport {
 
     /** The single primary-key field name of an entity (defaults to `id`). */
     private fun primaryKeyField(entity: MetaObject): String {
-        val pk = entity.children
+        // ADR-0039: identities are inheritable — RESOLVE via getIdentities(true);
+        // entity.children (own-only) would miss an inherited primary identity.
+        val pk = entity.getIdentities(true)
             .filterIsInstance<com.metaobjects.identity.MetaIdentity>()
             .firstOrNull { it.isPrimary }
         return pk?.fields?.firstOrNull() ?: "id"

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

@@ -81,6 +81,8 @@ open class KotlinOutputParserGenerator : MultiFileDirectGeneratorBase<MetaObject
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches TS/C#/Python deterministic emission.
+        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
+        // reference's root.ownChildren()), so own children is correct.
         val outputs = loader.root.children
             .filterIsInstance<OutputTemplate>()
             .sortedBy { it.name }

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

@@ -74,6 +74,8 @@ open class KotlinOutputPromptGenerator : MultiFileDirectGeneratorBase<MetaObject
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches TS/C#/Python/Java deterministic emission.
+        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
+        // reference's root.ownChildren()), so own children is correct.
         val outputs = loader.root.children
             .filterIsInstance<OutputTemplate>()
             .sortedBy { it.name }

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

@@ -63,6 +63,8 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         // typed as its generated enum class (reusing the entity enum scheme); two fields sharing an
         // abstract enum super collapse onto ONE emitted file.
         val emittedEnumFqns = mutableSetOf<String>()
+        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
+        // reference's root.ownChildren()), so own children is correct.
         for (md in loader.root.children) {
             if (md !is MetaTemplate) continue
             emit(md, loader, outRoot, emittedNestedFqns, emittedEnumFqns)
@@ -148,6 +150,8 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         emittedNestedFqns: MutableSet<String>,
         emittedEnumFqns: MutableSet<String>,
     ): TypeName {
+        // ADR-0039/ADR-0029: origin.* NEVER inherits — a derived field's origin is
+        // declared-here, so read OWN children (field.children), not resolving.
         val origin = field.children.filterIsInstance<MetaOrigin>().firstOrNull()
 
         if (origin != null) {
@@ -300,8 +304,9 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         val via = origin.via ?: return fallbackType()
         val (parentName, relName) = KotlinGenUtil.splitDottedRef(via) ?: return fallbackType()
         val parent = KotlinGenUtil.resolveObjectByShortOrFqn(loader, parentName) ?: return fallbackType()
-        val relationship = parent.children
-            .filterIsInstance<MetaRelationship>()
+        // ADR-0039: relationships are inheritable — RESOLVE via parent.relationships;
+        // parent.children (own-only) would miss a relationship inherited via extends.
+        val relationship = parent.relationships
             .firstOrNull { it.name == relName || it.name.substringAfterLast("::") == relName }
             ?: return fallbackType()
         val targetRef = relationship.objectRef ?: return fallbackType()

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

@@ -70,8 +70,9 @@ open class KotlinRelationsGenerator : MultiFileDirectGeneratorBase<MetaObject>()
             // ADR-0039: resolving (an inherited source.rdb still means the entity is persisted).
             if (!KotlinGenUtil.hasRdbSource(entity)) continue
 
-            val manyRels = entity.children
-                .filterIsInstance<MetaRelationship>()
+            // ADR-0039: relationships are inheritable — RESOLVE via entity.relationships;
+            // entity.children (own-only) would miss an inherited relationship.
+            val manyRels = entity.relationships
                 .filter {
                     it.subType == CompositionRelationship.SUBTYPE_COMPOSITION &&
                         it.cardinality == MetaRelationship.CARDINALITY_MANY
@@ -233,7 +234,9 @@ open class KotlinRelationsGenerator : MultiFileDirectGeneratorBase<MetaObject>()
      */
     protected open fun reverseFksFor(entity: MetaObject): List<ReverseFk> {
         val out = mutableListOf<ReverseFk>()
-        for (child in entity.children) {
+        // ADR-0039: identity.reference children are inheritable — RESOLVE via
+        // getIdentities(true); entity.children (own-only) would miss inherited FK refs.
+        for (child in entity.getIdentities(true)) {
             if (child !is ReferenceIdentity) continue
             val fields = child.fields
             if (fields.size != 1) continue // single-column FKs only
@@ -258,7 +261,9 @@ open class KotlinRelationsGenerator : MultiFileDirectGeneratorBase<MetaObject>()
      * metadata.
      */
     protected open fun primaryKeyKotlinType(entity: MetaObject): TypeName {
-        val primary = entity.children
+        // ADR-0039: identities are inheritable — RESOLVE via getIdentities(true);
+        // entity.children (own-only) would miss an inherited primary identity.
+        val primary = entity.getIdentities(true)
             .filterIsInstance<MetaIdentity>()
             .firstOrNull { it.isPrimary } ?: return LONG
         val pkFieldName = primary.fields.firstOrNull() ?: return LONG

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

@@ -79,6 +79,8 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
         val provider = FilesystemProvider(Paths.get(templateRoot))
 
         // Stable name order — matches the other ports' deterministic emission.
+        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
+        // reference's root.ownChildren()), so own children is correct.
         val outputs = loader.root.children
             .filterIsInstance<OutputTemplate>()
             .sortedBy { it.name }
@@ -254,6 +256,9 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
      * `object.value` is found.
      */
     private fun resolveNestedObjectRef(loader: MetaDataLoader, field: ObjectField): MetaObject? {
+        // ADR-0039: @objectRef is an inheritable effective field property — RESOLVE
+        // (includeParentData=true) so a field.object inheriting @objectRef via extends
+        // still resolves its target VO.
         if (!field.hasMetaAttr(MetaObject.ATTR_OBJECT_REF, true)) return null
         val ref = field.getMetaAttr(MetaObject.ATTR_OBJECT_REF, true).valueAsString
         if (ref.isNullOrEmpty()) return null
@@ -294,7 +299,11 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
     // Local helpers
     // -------------------------------------------------------------------------
 
-    /** Resolve `@kind` (own attr), defaulting to `document`. */
+    // ADR-0039: template.* attrs are read OWN-ONLY by cross-port contract (TS
+    // render-helper uses tmpl.ownAttr). A template's declared refs are authored-here,
+    // not inherited into an effective form. KEPT own to match the reference.
+
+    /** Resolve `@kind` (OWN attr — templates read own, ADR-0039), defaulting to `document`. */
     private fun kindOf(template: MetaTemplate): String {
         if (template is OutputTemplate && template.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) {
             val v = template.getMetaAttr(TemplateConstants.ATTR_KIND, false).valueAsString
@@ -303,7 +312,7 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
         return TemplateConstants.KIND_DEFAULT
     }
 
-    /** Read an own attr value, or null if absent. */
+    /** Read an OWN template attr value, or null if absent (templates read own — ADR-0039). */
     private fun attr(template: MetaTemplate, attr: String): String? =
         if (template.hasMetaAttr(attr, false))
             template.getMetaAttr(attr, false).valueAsString