fix(jvm): ADR-0039 — resolve template.* attrs (Java + Kotlin), matching TS + C#

The prior JVM sweep KEPT template.* attr reads own-only ("cross-port
contract reads templates own"), but that reflected the pre-sweep state.
TS + C# now RESOLVE template attrs — a template is a registered type that
can be an `extends` target, so its attrs inherit; resolving
(includeParentData=true, the default) is the ADR-0039 default.

Flipped to resolving:
- MetaTemplate / OutputTemplate / PromptTemplate / ToolcallTemplate getters
  (@payloadRef/@textRef/@format/@maxChars/@owner/@since/@requiredTags/
  @promptStyle/@requiredSlots/@maxTokens/@model/@responseRef/@toolname).
- Render-helper + api-model template @kind/@subjectRef/@htmlBodyRef/
  @textBodyRef/@textref reads (SpringRenderHelperGenerator,
  JavaApiModelBuilder, KotlinRenderHelperGenerator, KotlinApiModelBuilder).
- Root-level template-node iteration → resolving getChildren(type, true)
  (Spring render/output-parser/output-prompt/payload + Kotlin
  render/output-prompt/output-parser/extractor/payload/api-model).

Left own (unchanged): ValidationPhase per-subtype required-attr checks
(eager-throw validation pass, analogous to source/origin/relationship
validation own-walks); field @objectref reads already resolve.

No golden change (no template-extends fixture exists yet).
Tests: metadata 1065, codegen-spring 158, codegen-kotlin 266 — all green.

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

@@ -71,10 +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>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {

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

@@ -81,10 +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>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {

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

@@ -74,10 +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>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {

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

@@ -63,10 +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
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        for (md in loader.root.getChildren(MetaTemplate::class.java, true)) {
             emit(md, loader, outRoot, emittedNestedFqns, emittedEnumFqns)
         }
     }

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

@@ -79,10 +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>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {
@@ -299,23 +297,23 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
     // Local helpers
     // -------------------------------------------------------------------------
 
-    // 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.
+    // ADR-0039: template.* attrs RESOLVE through extends (includeParentData=true, the
+    // default) — a template is a registered type that can be an `extends` target, so its
+    // refs inherit. Matches the TS reference + C#.
 
-    /** Resolve `@kind` (OWN attr — templates read own, ADR-0039), defaulting to `document`. */
+    /** Resolve `@kind` (RESOLVING attr — 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
+        if (template is OutputTemplate && template.hasMetaAttr(TemplateConstants.ATTR_KIND)) {
+            val v = template.getMetaAttr(TemplateConstants.ATTR_KIND).valueAsString
             if (!v.isNullOrEmpty()) return v
         }
         return TemplateConstants.KIND_DEFAULT
     }
 
-    /** Read an OWN template attr value, or null if absent (templates read own — ADR-0039). */
+    /** Read a template attr value (RESOLVING — ADR-0039), or null if absent. */
     private fun attr(template: MetaTemplate, attr: String): String? =
-        if (template.hasMetaAttr(attr, false))
-            template.getMetaAttr(attr, false).valueAsString
+        if (template.hasMetaAttr(attr))
+            template.getMetaAttr(attr).valueAsString
         else null
 
     /** Resolve a `@payloadRef` to its `object.value` (rejects entities — payloads must be VOs). */

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

@@ -77,12 +77,9 @@ class KotlinApiModelBuilder {
         }
 
         // Templates: one unit per template.output under the model root.
-        // ADR-0039: root-level declaration scan — root is never extended (matches the TS
-        // reference's root.ownChildren()), so own children is correct.
-        for (child in loader.root.children) {
-            if (child is OutputTemplate) {
-                units.add(buildTemplateUnit(child, loader))
-            }
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        for (child in loader.root.getChildren(OutputTemplate::class.java, true)) {
+            units.add(buildTemplateUnit(child, loader))
         }
 
         return KotlinApiModel(project, units)
@@ -437,10 +434,10 @@ class KotlinApiModelBuilder {
     }
 
     private fun isEmailKind(tmpl: MetaTemplate): Boolean {
-        // ADR-0039: template.* attrs read OWN-ONLY by cross-port contract (a template's
-        // declared refs are authored-here, not inherited into an effective form).
-        if (!tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) return false
-        val v = runCatching { tmpl.getMetaAttr(TemplateConstants.ATTR_KIND, false).valueAsString }.getOrNull()
+        // ADR-0039: template.* attrs RESOLVE through extends (includeParentData=true,
+        // the default) — matching the TS reference + C#.
+        if (!tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND)) return false
+        val v = runCatching { tmpl.getMetaAttr(TemplateConstants.ATTR_KIND).valueAsString }.getOrNull()
         return TemplateConstants.KIND_EMAIL.equals(v, ignoreCase = true)
     }
 }

server/java/codegen-spring/src/main/java/com/metaobjects/generator/apidocs/JavaApiModelBuilder.java

@@ -1,6 +1,5 @@
 package com.metaobjects.generator.apidocs;
 
-import com.metaobjects.MetaData;
 import com.metaobjects.generator.spring.LlmTraceHelperGenerator;
 import com.metaobjects.generator.spring.SpringControllerGenerator;
 import com.metaobjects.generator.spring.SpringDtoGenerator;
@@ -44,8 +43,8 @@
  *       read DTO only (no VALIDATION / DATA_ACCESS / REST / FILTER — those
  *       generators gate on a writable table entity and skip a projection). A value
  *       object ({@code object.value}) yields MODEL only.</li>
- *   <li><b>Templates</b> (iterated via {@code loader.getRoot().getChildren()}
- *       filtered to {@link MetaTemplate}): each template yields PAYLOAD / RENDER /
+ *   <li><b>Templates</b> (iterated via the resolving
+ *       {@code loader.getRoot().getChildren(MetaTemplate.class, true)}): each template yields PAYLOAD / RENDER /
  *       PROMPT / OUTPUT_PARSER symbols gated by the matching {@code appliesTo}.</li>
  * </ul>
  *
@@ -90,10 +89,9 @@ public JavaApiModel build(MetaDataLoader loader, String project) {
         }
 
         // Templates: one unit per template.* node under the model root.
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate tmpl) {
-                units.add(buildTemplateUnit(tmpl, loader));
-            }
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        for (MetaTemplate tmpl : loader.getRoot().getChildren(MetaTemplate.class, true)) {
+            units.add(buildTemplateUnit(tmpl, loader));
         }
 
         return new JavaApiModel(project, units);
@@ -289,13 +287,13 @@ parser, ApiSymbolKind.OUTPUT_PARSER, fqn(promptsPkg, parser),
 
     /**
      * True when the template's {@code @kind} is {@code email}. ADR-0039: template.*
-     * attrs read OWN-ONLY by cross-port contract (a template's declared refs are
-     * authored-here, not inherited); default {@code document}.
+     * attrs RESOLVE through extends (includeParentData=true, the default) — matching
+     * the TS reference + C#; default {@code document}.
      */
     private static boolean isEmailKind(MetaTemplate tmpl) {
         if (tmpl instanceof OutputTemplate
-                && tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) {
-            String v = tmpl.getMetaAttr(TemplateConstants.ATTR_KIND, false).getValueAsString();
+                && tmpl.hasMetaAttr(TemplateConstants.ATTR_KIND)) {
+            String v = tmpl.getMetaAttr(TemplateConstants.ATTR_KIND).getValueAsString();
             return TemplateConstants.KIND_EMAIL.equals(v);
         }
         return false;

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringOutputParserGenerator.java

@@ -116,9 +116,10 @@ public void execute(MetaDataLoader loader) {
         Path outRoot = Paths.get(outDir.getAbsolutePath());
 
         // Stable name order — matches the other ports' deterministic emission.
+        // ADR-0039: root-scan discipline — resolving children accessor.
         List<MetaTemplate> outputs = new ArrayList<>();
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate t && TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
+        for (MetaTemplate t : loader.getRoot().getChildren(MetaTemplate.class, true)) {
+            if (TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
                 outputs.add(t);
             }
         }

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringOutputPromptGenerator.java

@@ -82,9 +82,10 @@ public void execute(MetaDataLoader loader) {
         Path outRoot = Paths.get(outDir.getAbsolutePath());
 
         // Stable name order — matches the other ports' deterministic emission.
+        // ADR-0039: root-scan discipline — resolving children accessor.
         List<MetaTemplate> outputs = new ArrayList<>();
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate t && TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
+        for (MetaTemplate t : loader.getRoot().getChildren(MetaTemplate.class, true)) {
+            if (TemplateConstants.SUBTYPE_OUTPUT.equals(t.getSubType())) {
                 outputs.add(t);
             }
         }

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringPayloadGenerator.java

@@ -119,12 +119,9 @@ public void execute(MetaDataLoader loader) {
         // Stable name order — matches the other ports' deterministic emission.
         // Iterate ALL MetaTemplate subtypes (prompt / output / toolcall);
         // every template with a @payloadRef gets a payload record.
-        List<MetaTemplate> templates = new ArrayList<>();
-        for (MetaData child : loader.getRoot().getChildren()) {
-            if (child instanceof MetaTemplate t) {
-                templates.add(t);
-            }
-        }
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        List<MetaTemplate> templates =
+            new ArrayList<>(loader.getRoot().getChildren(MetaTemplate.class, true));
         templates.sort(Comparator.comparing(MetaTemplate::getName));
 
         for (MetaTemplate tmpl : templates) {