@@ -181,3 +181,14 @@ templateGenerator({
   template: "entity-doc",
 });
 ```
+
+The same declarative surface is available on the **JVM (Java + Kotlin)** via
+`TemplateScopeGenerator` (`com.metaobjects.generator.template`), a Maven-wirable
+generator over the byte-equivalent render engine. Wire it as a standard
+`<generator>` in `pom.xml` with `<template>`, `<scope>`, `<outputPattern>`,
+optional `<format>` (default `text`), and `<templatesDir>` args — no hand-written
+walk class. The three scope walks, the neutral data dict, and the output-pattern
+grammar are gated byte-identical against the same
+`fixtures/template-codegen-conformance/` corpus the TS port passes, so a template
+renders identically on either side. This is where **Kotlin** gains a template
+generator (it reuses the shared JVM engine — no KotlinPoet involvement).
@@ -0,0 +1,75 @@
+package com.metaobjects.generator.template;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Expands the cross-port output-pattern grammar (SP-1 §3.3): {@code {name}},
+ * {@code {Name}} (PascalCase), {@code {package}} ({@code ::} → {@code /}). An empty
+ * {@code {package}} collapses its trailing/leading slash so {@code {package}/{name}}
+ * with no package yields just {@code {name}}. Unknown placeholders are a hard error.
+ *
+ * <p>Byte-equivalent to the TypeScript {@code output-pattern.ts}.
+ */
+public final class OutputPattern {
+
+    private OutputPattern() {}
+
+    private static final Pattern TOKEN = Pattern.compile("\\{(\\w+)\\}");
+
+    /**
+     * @param pattern the output path pattern
+     * @param name    the entity name (may be null for perPackage/perModel scopes)
+     * @param pkg     the package (may be null/empty)
+     */
+    public static String expand(String pattern, String name, String pkg) {
+        Matcher m = TOKEN.matcher(pattern);
+        StringBuffer sb = new StringBuffer();
+        boolean pkgEmpty = false;
+        while (m.find()) {
+            String token = m.group(1);
+            String rep;
+            switch (token) {
+                case "package": {
+                    String p = pkg == null ? "" : pkg.replace("::", "/");
+                    if (p.isEmpty()) pkgEmpty = true;
+                    rep = p;
+                    break;
+                }
+                case "name":
+                    if (name == null) {
+                        throw new IllegalArgumentException(
+                            "output pattern '" + pattern + "' uses {name} but no entity name is in scope");
+                    }
+                    rep = name;
+                    break;
+                case "Name":
+                    if (name == null) {
+                        throw new IllegalArgumentException(
+                            "output pattern '" + pattern + "' uses {Name} but no entity name is in scope");
+                    }
+                    rep = pascal(name);
+                    break;
+                default:
+                    throw new IllegalArgumentException(
+                        "unknown placeholder {" + token + "} in output pattern '" + pattern + "'");
+            }
+            m.appendReplacement(sb, Matcher.quoteReplacement(rep));
+        }
+        m.appendTail(sb);
+        String out = sb.toString();
+        if (pkgEmpty) {
+            out = out.replaceAll("^/+", "").replaceAll("/{2,}", "/");
+        }
+        return out;
+    }
+
+    private static String pascal(String s) {
+        StringBuilder b = new StringBuilder();
+        for (String w : s.split("[^A-Za-z0-9]+")) {
+            if (w.isEmpty()) continue;
+            b.append(Character.toUpperCase(w.charAt(0))).append(w.substring(1));
+        }
+        return b.toString();
+    }
+}
@@ -0,0 +1,65 @@
+package com.metaobjects.generator.template;
+
+import com.metaobjects.object.MetaObject;
+import com.metaobjects.render.templategen.TemplateWalkResult;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.function.Function;
+
+/**
+ * The three built-in walk scopes (SP-1 §3.1): {@code perEntity}, {@code perPackage},
+ * {@code perModel}. Each yields the neutral data dict for its unit and names the
+ * file via {@link OutputPattern}. Same vocabulary as the TS engine helpers.
+ */
+public final class ScopeWalk {
+
+    private ScopeWalk() {}
+
+    public static final String PER_ENTITY = "perEntity";
+    public static final String PER_PACKAGE = "perPackage";
+    public static final String PER_MODEL = "perModel";
+
+    public static Function<List<MetaObject>, List<TemplateWalkResult>> forScope(
+            String scope, String outputPattern) {
+        return objects -> {
+            List<MetaObject> concrete = new ArrayList<>();
+            for (MetaObject o : objects) {
+                if (TemplateData.isConcrete(o)) concrete.add(o);
+            }
+            List<TemplateWalkResult> out = new ArrayList<>();
+            switch (scope) {
+                case PER_ENTITY:
+                    for (MetaObject o : concrete) {
+                        out.add(new TemplateWalkResult(
+                            TemplateData.entity(o),
+                            OutputPattern.expand(outputPattern, TemplateData.bareName(o), TemplateData.packageOf(o))));
+                    }
+                    return out;
+                case PER_PACKAGE: {
+                    Map<String, List<MetaObject>> byPkg = new TreeMap<>();
+                    for (MetaObject o : concrete) {
+                        byPkg.computeIfAbsent(TemplateData.packageOf(o), k -> new ArrayList<>()).add(o);
+                    }
+                    for (Map.Entry<String, List<MetaObject>> e : byPkg.entrySet()) {
+                        out.add(new TemplateWalkResult(
+                            TemplateData.pkg(e.getKey(), e.getValue()),
+                            OutputPattern.expand(outputPattern, null, e.getKey())));
+                    }
+                    return out;
+                }
+                case PER_MODEL:
+                    out.add(new TemplateWalkResult(
+                        TemplateData.model(objects),
+                        OutputPattern.expand(outputPattern, null, null)));
+                    return out;
+                default:
+                    throw new IllegalArgumentException(
+                        "unknown template scope '" + scope + "' (expected "
+                        + PER_ENTITY + " | " + PER_PACKAGE + " | " + PER_MODEL + ")");
+            }
+        };
+    }
+}
@@ -0,0 +1,139 @@
+package com.metaobjects.generator.template;
+
+import com.metaobjects.field.EnumField;
+import com.metaobjects.field.MetaField;
+import com.metaobjects.identity.MetaIdentity;
+import com.metaobjects.generator.util.GeneratorUtil;
+import com.metaobjects.object.MetaObject;
+import com.metaobjects.relationship.MetaRelationship;
+import com.metaobjects.validator.MetaValidator;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * The NEUTRAL, structural codegen template data dict (SP-1 §3.2) for the JVM.
+ * Built as {@link LinkedHashMap}/{@link ArrayList} so the JMustache render reads
+ * the same keys the TypeScript object exposes — the field names here are a
+ * byte-gated cross-port contract (verified against the TS-produced
+ * {@code fixtures/template-codegen-conformance/expected/}). Optional keys
+ * ({@code maxLength}, {@code enumValues}) are OMITTED when absent so a
+ * {@code {{#maxLength}}} section gates identically to TS.
+ */
+public final class TemplateData {
+
+    private TemplateData() {}
+
+    private static final String SUBTYPE_ENUM = "enum";
+    private static final String VALIDATOR_REQUIRED = "required";
+
+    /** Bare object name — {@code getName()} returns the FQN ({@code shop::Product}),
+     *  but the dict's {@code name} is the bare leaf ({@code Product}). */
+    public static String bareName(MetaObject o) {
+        String n = o.getName();
+        int i = n.lastIndexOf("::");
+        return i >= 0 ? n.substring(i + 2) : n;
+    }
+
+    /** Effective package — {@code getPackage()} already returns the file package
+     *  on the JVM (e.g. {@code shop}); null collapses to "". */
+    public static String packageOf(MetaObject o) {
+        String p = o.getPackage();
+        return p == null ? "" : p;
+    }
+
+    public static boolean isConcrete(MetaObject o) {
+        return !GeneratorUtil.isAbstract(o);
+    }
+
+    private static boolean isRequired(MetaField f) {
+        if (f.hasMetaAttr(MetaField.ATTR_REQUIRED, false)
+            && "true".equals(f.getMetaAttr(MetaField.ATTR_REQUIRED, false).getValueAsString())) {
+            return true;
+        }
+        for (MetaValidator v : f.getChildren(MetaValidator.class)) {
+            if (VALIDATOR_REQUIRED.equals(v.getSubType())) return true;
+        }
+        return false;
+    }
+
+    private static Map<String, Object> fieldData(MetaField f) {
+        Map<String, Object> d = new LinkedHashMap<>();
+        d.put("name", f.getName());
+        d.put("type", f.getSubType());
+        d.put("required", isRequired(f));
+        d.put("isArray", f.isArrayType());
+        if (f.hasMetaAttr(MetaField.ATTR_MAX_LENGTH, false)) {
+            d.put("maxLength", Integer.valueOf(f.getMetaAttr(MetaField.ATTR_MAX_LENGTH, false).getValueAsString()));
+        }
+        if (SUBTYPE_ENUM.equals(f.getSubType()) && f.hasMetaAttr(EnumField.ATTR_VALUES)) {
+            Object raw = f.getMetaAttr(EnumField.ATTR_VALUES).getValue();
+            List<String> values = new ArrayList<>();
+            if (raw instanceof List<?> list) {
+                for (Object v : list) values.add(String.valueOf(v));
+            } else if (raw instanceof Object[] arr) {
+                for (Object v : arr) values.add(String.valueOf(v));
+            }
+            d.put("enumValues", values);
+        }
+        return d;
+    }
+
+    public static Map<String, Object> entity(MetaObject o) {
+        Map<String, Object> d = new LinkedHashMap<>();
+        d.put("name", bareName(o));
+        d.put("package", packageOf(o));
+
+        List<Map<String, Object>> fields = new ArrayList<>();
+        for (MetaField f : o.getMetaFields()) fields.add(fieldData(f));
+        d.put("fields", fields);
+
+        List<Map<String, Object>> identities = new ArrayList<>();
+        for (MetaIdentity id : o.getChildren(MetaIdentity.class)) {
+            Map<String, Object> i = new LinkedHashMap<>();
+            i.put("kind", id.getSubType());
+            i.put("fields", new ArrayList<>(id.getFields()));
+            identities.add(i);
+        }
+        d.put("identities", identities);
+
+        List<Map<String, Object>> relationships = new ArrayList<>();
+        for (MetaRelationship r : o.getChildren(MetaRelationship.class)) {
+            Map<String, Object> rel = new LinkedHashMap<>();
+            rel.put("name", r.getName());
+            rel.put("cardinality", r.getCardinality() == null ? "" : r.getCardinality());
+            rel.put("targetRef", r.getObjectRef() == null ? "" : r.getObjectRef());
+            relationships.add(rel);
+        }
+        d.put("relationships", relationships);
+        return d;
+    }
+
+    public static Map<String, Object> pkg(String p, List<MetaObject> entities) {
+        Map<String, Object> d = new LinkedHashMap<>();
+        d.put("package", p);
+        List<Map<String, Object>> ents = new ArrayList<>();
+        for (MetaObject o : entities) ents.add(entity(o));
+        d.put("entities", ents);
+        return d;
+    }
+
+    /** Concrete-only, grouped by package ascending, entities in iteration order. */
+    public static Map<String, Object> model(List<MetaObject> objects) {
+        Map<String, List<MetaObject>> byPkg = new TreeMap<>();
+        for (MetaObject o : objects) {
+            if (!isConcrete(o)) continue;
+            byPkg.computeIfAbsent(packageOf(o), k -> new ArrayList<>()).add(o);
+        }
+        List<Map<String, Object>> packages = new ArrayList<>();
+        for (Map.Entry<String, List<MetaObject>> e : byPkg.entrySet()) {
+            packages.add(pkg(e.getKey(), e.getValue()));
+        }
+        Map<String, Object> d = new LinkedHashMap<>();
+        d.put("packages", packages);
+        return d;
+    }
+}
@@ -0,0 +1,81 @@
+package com.metaobjects.generator.template;
+
+import com.metaobjects.generator.GeneratorBase;
+import com.metaobjects.generator.GeneratorException;
+import com.metaobjects.loader.MetaDataLoader;
+import com.metaobjects.object.MetaObject;
+import com.metaobjects.render.FilesystemProvider;
+import com.metaobjects.render.Provider;
+import com.metaobjects.render.templategen.EmittedFile;
+import com.metaobjects.render.templategen.TemplateGenerator;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+
+/**
+ * Maven-wirable declarative Mustache template generator (SP-1b). Reads the
+ * cross-port spec fields as args — {@code template}, {@code scope},
+ * {@code outputPattern}, {@code format} (default {@code text}), {@code templatesDir}
+ * (the project templates root) — builds the named {@link ScopeWalk} over the
+ * loaded model, renders via the byte-equivalent {@link TemplateGenerator}, and
+ * writes each file under {@code outputDir}.
+ *
+ * <p>Wire in {@code pom.xml} via the standard generator mechanism:
+ * <pre>{@code
+ * <generator>
+ *   <classname>com.metaobjects.generator.template.TemplateScopeGenerator</classname>
+ *   <args>
+ *     <templatesDir>src/main/templates</templatesDir>
+ *     <template>service/entity-service</template>
+ *     <scope>perEntity</scope>
+ *     <outputPattern>{package}/{Name}Service.java</outputPattern>
+ *     <outputDir>${project.build.directory}/generated-sources/java</outputDir>
+ *   </args>
+ * </generator>
+ * }</pre>
+ */
+public class TemplateScopeGenerator extends GeneratorBase {
+
+    public static final String ARG_TEMPLATE = "template";
+    public static final String ARG_SCOPE = "scope";
+    public static final String ARG_OUTPUT_PATTERN = "outputPattern";
+    public static final String ARG_FORMAT = "format";
+    public static final String ARG_TEMPLATES_DIR = "templatesDir";
+
+    @Override
+    public void execute(MetaDataLoader loader) {
+        String template = getArg(ARG_TEMPLATE, true);
+        String scope = getArg(ARG_SCOPE, true);
+        String outputPattern = getArg(ARG_OUTPUT_PATTERN, true);
+        String format = getArg(ARG_FORMAT, "text");
+        String templatesDir = getArg(ARG_TEMPLATES_DIR, true);
+
+        Path templatesRoot = Paths.get(templatesDir);
+        Provider provider = new FilesystemProvider(templatesRoot);
+        File outDir = getOutputDir();
+
+        List<MetaObject> objects = loader.getMetaObjects();
+        List<EmittedFile> files = TemplateGenerator.generate(
+            scope,
+            template,
+            root -> ScopeWalk.forScope(scope, outputPattern).apply(objects),
+            provider,
+            format,
+            objects);
+
+        for (EmittedFile f : files) {
+            Path target = outDir.toPath().resolve(f.path());
+            try {
+                Files.createDirectories(target.getParent());
+                Files.writeString(target, f.content());
+            } catch (IOException e) {
+                throw new GeneratorException(
+                    "Failed to write template-codegen output [" + target + "]: " + e.getMessage(), e);
+            }
+        }
+    }
+}