@kosdev-code/kos-codegen-core 0.1.0-next.790 → 0.1.0-next.796

package/index.js

@@ -537,6 +537,294 @@ function generateInit(codegenFs, options) {
   };
   writeJson(codegenFs, "nx.json", nxConfig);
 }
+const BUILD_SCRIPTS = [
+  "build/build-ui.sh",
+  "build/build-java.sh",
+  "build/build-release.sh",
+  "build/release_version_prebuild.sh",
+  "build/docker-build.sh"
+];
+function generatePolyglotWorkspace(codegenFs, templateDir, options) {
+  const normalized = normalizeAllValues({ name: options.name });
+  const vars = {
+    ...normalized,
+    keyset: options.keyset || "prod.kos",
+    appUiName: `${normalized.nameDashCase}-ui`,
+    nodeVersion: options.nodeVersion || process.version.replace(/^v/, ""),
+    jdkMajor: options.jdkMajor || "17",
+    mavenVersion: options.mavenVersion || "3.9.9"
+  };
+  generateFilesFromTemplates(
+    codegenFs,
+    path__namespace.join(templateDir, "root"),
+    ".",
+    vars
+  );
+  generateFilesFromTemplates(
+    codegenFs,
+    path__namespace.join(templateDir, "build"),
+    "build",
+    vars
+  );
+  generateFilesFromTemplates(
+    codegenFs,
+    path__namespace.join(templateDir, "github"),
+    ".github",
+    vars
+  );
+  generateFilesFromTemplates(
+    codegenFs,
+    path__namespace.join(templateDir, "java"),
+    "java",
+    vars
+  );
+  return { executablePaths: [...BUILD_SCRIPTS] };
+}
+const UI_PROJECT_DIRS = [
+  "apps",
+  "libs",
+  "plugins",
+  "splash",
+  "themes",
+  "content",
+  "translations"
+];
+function joinArtifactPath(outputPath, fileName) {
+  return `${outputPath.replace(/\/+$/, "")}/${fileName}`;
+}
+function discoverUiArtifacts(codegenFs) {
+  const artifacts = [];
+  for (const dir of UI_PROJECT_DIRS) {
+    for (const file of codegenFs.listFiles(`ui/${dir}`)) {
+      if (!file.endsWith("project.json")) continue;
+      const raw = codegenFs.read(file);
+      if (raw === null) continue;
+      let project;
+      try {
+        project = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      const name = project.name;
+      if (!name) continue;
+      const kabOptions = project.targets?.kab?.options;
+      if (kabOptions?.outputPath && kabOptions?.kabName) {
+        artifacts.push({
+          id: name,
+          filename: `ui/${joinArtifactPath(kabOptions.outputPath, kabOptions.kabName)}`
+        });
+      } else if (project.targets?.splash) {
+        artifacts.push({
+          id: name,
+          filename: `ui/dist/archives/packages/${name}/${name}.kab`,
+          layer: 1
+        });
+      }
+    }
+  }
+  for (const file of codegenFs.listFiles("ui/external")) {
+    if (!file.endsWith(".kab")) continue;
+    const base = file.slice(file.lastIndexOf("/") + 1, -".kab".length);
+    artifacts.push({ id: base, filename: file });
+  }
+  return artifacts;
+}
+function discoverJavaArtifacts(codegenFs) {
+  const aggregator = codegenFs.read("java/pom.xml");
+  if (aggregator === null) return [];
+  const artifacts = [];
+  for (const match of aggregator.matchAll(/<module>([^<]+)<\/module>/g)) {
+    const moduleDir = match[1];
+    const pom = codegenFs.read(`java/${moduleDir}/pom.xml`);
+    if (pom === null || !pom.includes("kos-kab-maven-plugin")) continue;
+    const withoutParent = pom.replace(/<parent>[\s\S]*?<\/parent>/, "");
+    const artifactId = withoutParent.match(
+      /<artifactId>([^<]+)<\/artifactId>/
+    )?.[1];
+    if (!artifactId) continue;
+    artifacts.push({
+      id: moduleDir,
+      // eslint-disable-next-line no-template-curly-in-string
+      filename: `java/${moduleDir}/target/${artifactId}-\${KOS_STD_VERSION_REGEX}.kab`
+    });
+  }
+  return artifacts;
+}
+function syncManifest(codegenFs, manifestPath, discovered, prune) {
+  const raw = codegenFs.read(manifestPath);
+  if (raw === null) return null;
+  const manifest = JSON.parse(raw);
+  const existing = manifest.artifacts ?? [];
+  const byFilename = new Map(discovered.map((d) => [d.filename, d]));
+  const kept = [];
+  const stale = [];
+  const pruned = [];
+  for (const entry of existing) {
+    if (byFilename.has(entry.filename)) {
+      kept.push(entry);
+      byFilename.delete(entry.filename);
+    } else if (prune) {
+      pruned.push(entry.id ?? entry.filename);
+    } else {
+      kept.push(entry);
+      stale.push(entry.id ?? entry.filename);
+    }
+  }
+  const added = [];
+  for (const artifact of byFilename.values()) {
+    kept.push({
+      id: artifact.id,
+      filename: artifact.filename,
+      artifactstore: "kos-cdn",
+      marketplace: 1,
+      ...artifact.layer !== void 0 ? { layer: artifact.layer } : {}
+    });
+    added.push(artifact.id);
+  }
+  if (added.length > 0 || pruned.length > 0) {
+    manifest.artifacts = kept;
+    codegenFs.write(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  }
+  return { added, stale, pruned };
+}
+function syncCiManifests(codegenFs, options = {}) {
+  const prune = options.prune ?? false;
+  const ui = discoverUiArtifacts(codegenFs);
+  const java = discoverJavaArtifacts(codegenFs);
+  const manifests = {};
+  const plan = [
+    [".github/build-ui.json", ui],
+    [".github/build-java.json", java],
+    [".github/build-release.json", [...ui, ...java]]
+  ];
+  for (const [manifestPath, discovered] of plan) {
+    const result = syncManifest(codegenFs, manifestPath, discovered, prune);
+    if (result) {
+      manifests[manifestPath] = result;
+    }
+  }
+  return { manifests, discovered: { ui, java } };
+}
+function ensureJavaAggregatorPom(codegenFs, options) {
+  const pomPath = "java/pom.xml";
+  const existing = codegenFs.read(pomPath);
+  if (existing === null) {
+    codegenFs.write(
+      pomPath,
+      `<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>${options.groupId}</groupId>
+  <artifactId>${options.artifactId}</artifactId>
+  <version>0.0.0-SNAPSHOT</version>
+  <packaging>pom</packaging>
+  <modules>
+    <module>${options.moduleName}</module>
+  </modules>
+</project>
+`
+    );
+    return;
+  }
+  if (existing.includes(`<module>${options.moduleName}</module>`)) {
+    return;
+  }
+  codegenFs.write(
+    pomPath,
+    existing.replace(
+      "</modules>",
+      `  <module>${options.moduleName}</module>
+  </modules>`
+    )
+  );
+}
+function finalizeArchetypeModule(codegenFs, options) {
+  const { moduleName, kosVersion, kabPluginVersion, apiInfoVersion } = options;
+  const notes = [];
+  const pomPath = `java/${moduleName}/pom.xml`;
+  let pom = codegenFs.read(pomPath);
+  if (pom === null) {
+    throw new Error(`Generated module pom not found: ${pomPath}`);
+  }
+  if (pom.includes("<kos.version>0.0.0-SNAPSHOT</kos.version>")) {
+    if (kosVersion) {
+      pom = pom.replace(
+        "<kos.version>0.0.0-SNAPSHOT</kos.version>",
+        `<kos.version>${kosVersion}</kos.version>`
+      );
+    } else {
+      notes.push(
+        "kos.version is 0.0.0-SNAPSHOT — set it to a released kos-bom version before building"
+      );
+    }
+  }
+  if (pom.includes("${kos-kab-maven-plugin.version}") && !pom.includes("<kos-kab-maven-plugin.version>")) {
+    if (kabPluginVersion) {
+      pom = pom.replace(
+        /(<kos\.version>[^<]*<\/kos\.version>)/,
+        `$1
+        <kos-kab-maven-plugin.version>${kabPluginVersion}</kos-kab-maven-plugin.version>`
+      );
+    } else {
+      notes.push(
+        "the ${kos-kab-maven-plugin.version} property is referenced but undefined — add it before building"
+      );
+    }
+  }
+  const unversionedApiInfo = /<artifactId>api-info<\/artifactId>(\s*)<\/dependency>/;
+  if (unversionedApiInfo.test(pom)) {
+    if (apiInfoVersion) {
+      pom = pom.replace(
+        unversionedApiInfo,
+        `<artifactId>api-info</artifactId>$1  <version>${apiInfoVersion}</version>$1</dependency>`
+      );
+    } else {
+      notes.push(
+        "api-info has no version and is not managed by the kos-bom — add one before building"
+      );
+    }
+  }
+  codegenFs.write(pomPath, pom);
+  const githubDir = `java/${moduleName}/github`;
+  if (codegenFs.exists(githubDir)) {
+    for (const file of codegenFs.listFiles(githubDir)) {
+      codegenFs.delete(file);
+    }
+  }
+  const gitignore = codegenFs.read(`java/${moduleName}/gitignore`);
+  if (gitignore !== null) {
+    codegenFs.write(`java/${moduleName}/.gitignore`, gitignore);
+    codegenFs.delete(`java/${moduleName}/gitignore`);
+  }
+  return notes;
+}
+function addJavaArtifactToManifests(codegenFs, options) {
+  const { moduleName } = options;
+  for (const manifestPath of [
+    ".github/build-java.json",
+    ".github/build-release.json"
+  ]) {
+    const raw = codegenFs.read(manifestPath);
+    if (raw === null) {
+      continue;
+    }
+    const manifest = JSON.parse(raw);
+    manifest.artifacts = manifest.artifacts ?? [];
+    if (manifest.artifacts.some(
+      (artifact) => artifact.id === moduleName
+    )) {
+      continue;
+    }
+    manifest.artifacts.push({
+      id: moduleName,
+      // eslint-disable-next-line no-template-curly-in-string
+      filename: `java/${moduleName}/target/${moduleName}-\${KOS_STD_VERSION_REGEX}.kab`,
+      artifactstore: "kos-cdn",
+      marketplace: 1
+    });
+    codegenFs.write(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  }
+}
 function normalizeOptions(codegenFs, options, projects) {
   const toNormalize = {
     name: options.name
@@ -582,6 +870,103 @@ function normalizeOptions(codegenFs, options, projects) {
     template: ""
   };
 }
+const UPDATE_RELEASE_VERSION_SCRIPT_PATH = "tools/scripts/update-release-version.mjs";
+function buildKabTargets(options) {
+  const {
+    name,
+    archiveDir = "packages",
+    descriptorDir,
+    buildTarget = "build"
+  } = options;
+  const outputPath = `dist/archives/${archiveDir}/${name}/`;
+  const targets = {
+    kab: {
+      command: `node tools/scripts/kabtool.mjs build ${name} && node tools/scripts/kabtool.mjs list ${name} `,
+      options: {
+        outputPath,
+        zipName: "ui.zip",
+        kabName: `${name}.kab`
+      },
+      dependsOn: ["zip"]
+    },
+    zip: {
+      command: `node tools/scripts/archiver.js ${name}`,
+      options: {
+        outputPath,
+        zipName: "ui.zip"
+      },
+      dependsOn: descriptorDir ? [buildTarget, "descriptor"] : [buildTarget]
+    }
+  };
+  if (descriptorDir) {
+    targets.descriptor = {
+      command: `node tools/scripts/descriptor.mjs ${name}`,
+      options: {
+        outputPath: `dist/${descriptorDir}`,
+        fileName: "descriptor.json"
+      },
+      dependsOn: ["build"]
+    };
+  }
+  targets.version = {
+    command: `node ${UPDATE_RELEASE_VERSION_SCRIPT_PATH} ${name} {args.ver}`,
+    options: {},
+    dependsOn: []
+  };
+  return targets;
+}
+const UPDATE_RELEASE_VERSION_SCRIPT = `import devkit from "@nx/devkit";
+import { resolve } from "path";
+import { readFileSync, writeFileSync } from "fs";
+import prettier from "prettier";
+
+// KOS artifact versioning: stamps the project's .kos.json "version" field
+// (which kabtool bakes into the KAB). Never touches package.json.
+// Driven by tag-based releases:
+//   nx run-many --target=version --args=--ver=$KOSBUILD_VERSION
+
+const { readCachedProjectGraph } = devkit;
+const [, , name, versionArg] = process.argv;
+
+// "{args.ver}" arrives literally when the target runs without --args=--ver=<v>;
+// treat that (or a missing arg) as "report current version, change nothing".
+const version =
+  versionArg && !versionArg.startsWith("{args") ? versionArg : undefined;
+
+if (!name) {
+  console.error("usage: update-release-version.mjs <project> <version>");
+  process.exit(1);
+}
+
+const graph = readCachedProjectGraph();
+const project = graph.nodes[name];
+if (!project) {
+  console.error("Unknown project: " + name);
+  process.exit(1);
+}
+
+const kosJsonPath = resolve(process.cwd(), project.data.root, ".kos.json");
+let kosJson;
+try {
+  kosJson = JSON.parse(readFileSync(kosJsonPath, "utf8"));
+} catch {
+  console.error("Missing or invalid .kos.json: " + kosJsonPath);
+  process.exit(1);
+}
+
+if (!version) {
+  console.log(name + ": " + kosJson.version + " (no --ver given; unchanged)");
+  process.exit(0);
+}
+
+const prettierOptions = await prettier.resolveConfig(kosJsonPath);
+const output = await prettier.format(
+  JSON.stringify({ ...kosJson, version }, null, 2),
+  { ...prettierOptions, parser: "json" }
+);
+writeFileSync(kosJsonPath, output);
+console.log(name + ": version -> " + version);
+`;
 function appendBarrelExport(codegenFs, indexPath, exportPath) {
   const exportLine = `export * from '${exportPath}'`;
   const content = codegenFs.read(indexPath) ?? "";
@@ -977,6 +1362,63 @@ function generateModel(params) {
     );
   }
 }
+function resolveModelFilePath(codegenFs, query, projects) {
+  const kosConfig = getKosProjectConfiguration(
+    codegenFs,
+    query.modelProject,
+    projects
+  );
+  const internal = !!kosConfig?.generator?.internal;
+  const project = findProjectByName(
+    codegenFs.root,
+    query.modelProject,
+    projects
+  );
+  const sourceRoot = project ? project.sourceRoot || path__namespace.join(project.root, "src") : void 0;
+  if (query.modelPath) {
+    return { modelFilePath: query.modelPath, internal, sourceRoot };
+  }
+  if (!project) {
+    throw new Error(
+      `Project not found: ${query.modelProject}. Ensure a project.json exists.`
+    );
+  }
+  const { modelNameDashCase } = normalizeAllValues({
+    modelName: query.modelName
+  });
+  const modelLocation = kosConfig?.generator?.defaults?.model?.folder || "";
+  const modelFilePath = path__namespace.join(
+    sourceRoot,
+    modelLocation,
+    modelNameDashCase,
+    `${modelNameDashCase}-model.ts`
+  );
+  if (codegenFs.exists(modelFilePath)) {
+    return { modelFilePath, internal, sourceRoot };
+  }
+  const discovered = findModelFileByName(
+    codegenFs,
+    path__namespace.join(sourceRoot, modelLocation),
+    modelNameDashCase
+  );
+  if (discovered) {
+    return { modelFilePath: discovered, internal, sourceRoot };
+  }
+  return { modelFilePath, internal, sourceRoot };
+}
+function findModelFileByName(codegenFs, searchRoot, modelNameDashCase) {
+  const fileName = `${modelNameDashCase}-model.ts`;
+  const candidates = codegenFs.listFiles(searchRoot).filter((f) => path__namespace.basename(f) === fileName).sort();
+  if (candidates.length === 0) return null;
+  if (candidates.length > 1) {
+    throw new Error(
+      `Model name '${modelNameDashCase}' is ambiguous — multiple files match ${fileName}:
+` + candidates.map((c) => `  - ${c}`).join("\n") + `
+Pass modelPath to pick one.`
+    );
+  }
+  return candidates[0];
+}
 function normalizeAddFutureOptions(codegenFs, options, projects) {
   const projectConfiguration = findProjectByName(
     codegenFs.root,
@@ -1005,9 +1447,12 @@ function normalizeAddFutureOptions(codegenFs, options, projects) {
   const nameLowerCase = normalizedValues.modelNameLowerCase;
   const projectRoot = projectConfiguration.root;
   const sourceRoot = projectConfiguration.sourceRoot || path__namespace.join(projectRoot, "src");
-  const modelLocation = kosConfig?.generator?.defaults?.model?.folder || "";
-  const modelDirectory = path__namespace.join(sourceRoot, modelLocation, nameDashCase);
-  const modelFilePath = path__namespace.join(modelDirectory, `${nameDashCase}-model.ts`);
+  const { modelFilePath } = resolveModelFilePath(
+    codegenFs,
+    { modelName: options.modelName, modelProject: options.modelProject },
+    projects
+  );
+  const modelDirectory = path__namespace.dirname(modelFilePath);
   const servicesDirectory = path__namespace.join(modelDirectory, "services");
   const servicesFilePath = codegenFs.exists(servicesDirectory) ? path__namespace.join(servicesDirectory, `${nameDashCase}-services.ts`) : void 0;
   const registrationFilePath = path__namespace.join(
@@ -1030,310 +1475,358 @@ function normalizeAddFutureOptions(codegenFs, options, projects) {
     internal
   };
 }
-class ModelFileTransformer {
-  constructor(codegenFs, options) {
-    this.codegenFs = codegenFs;
-    this.options = options;
-  }
-  codegenFs;
-  options;
-  transform() {
-    const { modelFilePath } = this.options;
-    if (!this.codegenFs.exists(modelFilePath)) {
-      throw new Error(`Model file not found: ${modelFilePath}`);
-    }
-    let content = this.codegenFs.read(modelFilePath);
-    content = this.addESLintDisable(content);
-    content = this.addImports(content);
-    content = this.addServiceImport(content);
-    content = this.addInterfaceMerging(content);
-    content = this.addDecorator(content);
-    content = this.updatePublicType(content);
-    content = this.removeLegacySetup(content);
-    content = this.addFutureMethod(content);
-    if (this.options.futureType === "complete") {
-      content = this.addOnFutureUpdateMethod(content);
-    }
-    this.codegenFs.write(modelFilePath, content);
-  }
-  addESLintDisable(content) {
-    if (content.includes("@typescript-eslint/no-unsafe-declaration-merging")) {
-      return content;
-    }
-    const eslintDisable = "/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */\n";
-    return eslintDisable + content;
-  }
-  addImports(content) {
-    const { internal, futureType } = this.options;
-    const isComplete = futureType === "complete";
-    const kosModelImportRegex = internal ? /import\s*{\s*([^}]*kosModel[^}]*)\s*}\s*from\s*"\.\.\/\.\.\/\.\.\/core\/core\/decorators"/ : /import\s*{\s*([^}]*kosModel[^}]*)\s*}\s*from\s*"@kosdev-code\/kos-ui-sdk"/;
-    const kosModelMatch = content.match(kosModelImportRegex);
-    if (kosModelMatch) {
-      const existingImportsStr = kosModelMatch[1] || "";
-      const newImports = [
-        "kosFuture",
-        "kosFutureAware",
-        isComplete ? "KosFutureAwareFull" : "KosFutureAwareMinimal"
-      ];
-      const existingImports = existingImportsStr.split(",").map((s) => s.trim()).filter(Boolean);
-      const importsToRemove = [
-        "setupCompleteFutureSupport",
-        "setupMinimalFutureSupport"
-      ];
-      const cleanedImports = existingImports.filter(
-        (imp) => !importsToRemove.includes(imp)
-      );
-      const importsToAdd = newImports.filter(
-        (imp) => !cleanedImports.includes(imp)
-      );
-      const allImports = [...cleanedImports, ...importsToAdd];
-      const newImportLine = internal ? `import { ${allImports.join(
-        ", "
-      )} } from "../../../core/core/decorators"` : `import { ${allImports.join(", ")} } from "@kosdev-code/kos-ui-sdk"`;
-      content = content.replace(kosModelImportRegex, newImportLine);
-    }
-    const typeImportsBase = internal ? "../../../models/types/future-interfaces" : "@kosdev-code/kos-ui-sdk";
-    const futureTypeImports = ["ExternalFutureInterface", "IFutureModel"];
-    const typeImportRegex = internal ? /import type {([^}]*)} from "\.\.\/\.\.\/\.\.\/models\/types\/future-interfaces"/ : /import type {([^}]*)} from "@kosdev-code\/kos-ui-sdk"/;
-    const typeImportMatch = content.match(typeImportRegex);
-    if (typeImportMatch) {
-      const existingTypes = typeImportMatch[1] || "";
-      const existingTypesList = existingTypes.split(",").map((s) => s.trim()).filter(Boolean);
-      const typesToRemove = [
-        "FutureAwareContainer",
-        "FutureHandlerContainer",
-        "FutureStateAccessor",
-        "FutureUpdateHandler"
-      ];
-      const cleanedTypes = existingTypesList.filter(
-        (type) => !typesToRemove.includes(type)
-      );
-      const typesToAdd = futureTypeImports.filter(
-        (type) => !cleanedTypes.includes(type)
-      );
-      const allTypes = [...cleanedTypes, ...typesToAdd].join(", ");
-      const newTypeImport = `import type { ${allTypes} } from "${typeImportsBase}"`;
-      content = content.replace(typeImportRegex, newTypeImport);
-    } else {
-      const importLines = content.split("\n");
-      const lastImportIndex = importLines.findLastIndex(
-        (line) => line.trim().startsWith("import")
-      );
-      if (lastImportIndex >= 0) {
-        const newTypeImport = `import type { ${futureTypeImports.join(
-          ", "
-        )} } from "${typeImportsBase}";`;
-        importLines.splice(lastImportIndex + 1, 0, newTypeImport);
-        content = importLines.join("\n");
-      }
-    }
-    return content;
-  }
-  addServiceImport(content) {
-    const { nameProperCase, updateServices } = this.options;
-    if (!updateServices) {
-      return content;
-    }
-    if (content.includes(`${nameProperCase}OperationProgress`)) {
-      return content;
-    }
-    const servicesImportRegex = /import\s*{([^}]*)}\s*from\s*["']\.\/services["'];?/s;
-    const servicesMatch = content.match(servicesImportRegex);
-    if (servicesMatch) {
-      const existingImports = servicesMatch[1];
-      const cleanedImports = existingImports.split(",").map((s) => s.trim()).filter(Boolean);
-      cleanedImports.push(`${nameProperCase}OperationProgress`);
-      const newImport = `import { ${cleanedImports.join(
-        ", "
-      )} } from "./services";`;
-      content = content.replace(servicesImportRegex, newImport);
-    } else {
-      const typesImportRegex = /import\s+type\s+{[^}]*}\s+from\s+["']\.\/types["'];?/;
-      const typesMatch = content.match(typesImportRegex);
-      if (typesMatch) {
-        const newImport = `
-import type { ${nameProperCase}OperationProgress } from "./services";`;
-        content = content.replace(typesMatch[0], typesMatch[0] + newImport);
-      }
-    }
-    return content;
-  }
-  addInterfaceMerging(content) {
-    const { nameProperCase, futureType } = this.options;
-    const isComplete = futureType === "complete";
-    const interfaceType = isComplete ? "KosFutureAwareFull" : "KosFutureAwareMinimal";
-    const progressType = this.options.updateServices ? `${nameProperCase}OperationProgress` : "Record<string, unknown>";
-    const classRegex = new RegExp(
-      `(@kosModel[^\\n]*\\n)([^\\n]*export\\s+class\\s+${nameProperCase}ModelImpl)`,
-      "m"
-    );
-    const classMatch = content.match(classRegex);
-    if (classMatch) {
-      const interfaceRegex = new RegExp(
-        `interface\\s+${nameProperCase}ModelImpl\\s+extends`
-      );
-      if (!content.match(interfaceRegex)) {
-        const interfaceMerging = `
-// Interface merging for Future Container type safety
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface ${nameProperCase}ModelImpl extends ${interfaceType}<${progressType}> {}
-
-`;
-        content = content.replace(
-          classMatch[0],
-          interfaceMerging + classMatch[0]
-        );
-      }
-    }
-    return content;
-  }
-  addDecorator(content) {
-    const { nameProperCase, futureType } = this.options;
-    const isComplete = futureType === "complete";
-    const classRegex = new RegExp(
-      `(@kosModel[^\\n]*\\n)((?:@[^\\n]*\\n)*)([^\\n]*export\\s+class\\s+${nameProperCase}ModelImpl)`,
-      "m"
-    );
-    const classMatch = content.match(classRegex);
-    if (classMatch) {
-      if (!classMatch[2].includes("@kosFutureAware")) {
-        const decoratorOptions = isComplete ? "" : "{ mode: 'minimal' }";
-        const futureDecorator = `@kosFutureAware(${decoratorOptions})
-`;
-        content = content.replace(
-          classMatch[0],
-          classMatch[1] + classMatch[2] + futureDecorator + classMatch[3]
-        );
-      }
-    }
-    return content;
-  }
-  updatePublicType(content) {
-    const { nameProperCase, updateServices } = this.options;
-    const progressType = updateServices ? `${nameProperCase}OperationProgress` : "Record<string, unknown>";
-    const typeRegex = new RegExp(
-      `export\\s+type\\s+${nameProperCase}Model\\s*=\\s*PublicModelInterface<${nameProperCase}ModelImpl>([^;]*);`,
-      "s"
-    );
-    const typeMatch = content.match(typeRegex);
-    if (typeMatch) {
-      if (!typeMatch[1].includes("ExternalFutureInterface")) {
-        const newType = `export type ${nameProperCase}Model = PublicModelInterface<${nameProperCase}ModelImpl> & ExternalFutureInterface<${progressType}>;`;
-        content = content.replace(typeMatch[0], newType);
-      }
-    }
-    return content;
-  }
-  removeLegacySetup(content) {
-    const setupRegex = /\s*setup(Complete|Minimal)FutureSupport\(this\);?\s*/g;
-    content = content.replace(setupRegex, "");
-    const propertyRegex = /\s*(public|private|protected)?\s*(declare\s+)?futureHandler[!?]?:\s*FutureAwareContainer[^;]*;\s*/g;
-    content = content.replace(propertyRegex, "");
-    const futurePropertyRegex = /\s*(public|private|protected)?\s*(declare\s+)?future\??:\s*IFutureModel[^;]*;\s*/g;
-    content = content.replace(futurePropertyRegex, "");
-    const implementsRegex = new RegExp(
-      `(implements\\s+[^{]*?)\\s*,?\\s*(FutureUpdateHandler|FutureHandlerContainer|FutureStateAccessor)`,
-      "g"
-    );
-    content = content.replace(implementsRegex, "$1");
-    content = content.replace(/,\s*,/g, ",");
-    content = content.replace(/implements\s*,/g, "implements");
-    return content;
+function transformSourceFile(codegenFs, filePath, mutate) {
+  const content = codegenFs.read(filePath);
+  if (content === null) {
+    throw new Error(`File not found: ${filePath}`);
   }
-  addFutureMethod(content) {
-    const { nameProperCase } = this.options;
-    if (content.includes("@kosFuture()")) {
-      return content;
+  const project = new tsMorph.Project({
+    useInMemoryFileSystem: true,
+    manipulationSettings: {
+      indentationText: tsMorph.IndentationText.TwoSpaces,
+      quoteKind: tsMorph.QuoteKind.Double
     }
-    const classRegex = new RegExp(
-      `class\\s+${nameProperCase}ModelImpl[^{]*{([\\s\\S]*)}\\s*$`,
-      "m"
-    );
-    const classMatch = content.match(classRegex);
-    if (classMatch) {
-      const methodCode = `
-  /**
-   * Placeholder method for Future operations
-   * Replace this with your actual long-running operation
-   */
-  @kosFuture()
-  async performLongRunningOperation(): Promise<void> {
-    // TODO: Implement your long-running operation here
-    // This method should use a service that returns a Future for progress tracking
-
-    this.logger.debug(\`Starting long-running operation for \${this.id}\`);
-
-    // Example implementation pattern using services:
-    // import { perform${nameProperCase}Operation } from './services';
-    //
-    // const future = await perform${nameProperCase}Operation();
-    // return this.futureHandler.setFuture(future);
-
-    // Placeholder that doesn't actually do anything
-    await new Promise(resolve => setTimeout(resolve, 1000));
-
-    this.logger.debug(\`Completed long-running operation for \${this.id}\`);
+  });
+  const sourceFile = project.createSourceFile(filePath, content, {
+    overwrite: true
+  });
+  mutate(sourceFile);
+  codegenFs.write(filePath, sourceFile.getFullText());
+}
+function ensureNamedImport(sourceFile, moduleSpecifier, names) {
+  const decls = sourceFile.getImportDeclarations().filter((d) => d.getModuleSpecifierValue() === moduleSpecifier);
+  const existing = /* @__PURE__ */ new Set();
+  for (const d of decls) {
+    for (const n of d.getNamedImports()) existing.add(n.getName());
   }
-`;
-      const classContent = classMatch[1];
-      const lastBraceIndex = classContent.lastIndexOf("}");
-      if (lastBraceIndex >= 0) {
-        const updatedContent = classContent.slice(0, lastBraceIndex) + methodCode + classContent.slice(lastBraceIndex);
-        content = content.replace(
-          classMatch[0],
-          `class ${nameProperCase}ModelImpl${classMatch[0].match(/[^{]*/)?.[0]}{${updatedContent}}`
-        );
-      }
-    }
-    return content;
+  let target = decls.find((d) => !d.isTypeOnly());
+  if (!target) {
+    target = sourceFile.addImportDeclaration({ moduleSpecifier });
   }
-  addOnFutureUpdateMethod(content) {
-    const { nameProperCase, updateServices } = this.options;
-    const progressType = updateServices ? `${nameProperCase}OperationProgress` : "Record<string, unknown>";
-    if (content.includes("onFutureUpdate")) {
-      return content;
-    }
-    const futureMethodRegex = /@kosFuture\(\)[^}]*}/s;
-    const futureMethodMatch = content.match(futureMethodRegex);
-    if (futureMethodMatch) {
-      const methodCode = `
-
-  /**
-   * Optional: Custom Future update handling
-   * Called whenever the Future state changes (progress, status, completion, etc.)
-   */
-  onFutureUpdate?(update: IFutureModel<${progressType}>): void {
-    // Add custom Future update logic here
-    // Examples:
-    // - Log progress milestones
-    // - Update derived state based on progress
-    // - Handle specific error conditions
-    // - Trigger notifications at certain thresholds
-
-    this.logger.debug(\`Future update for \${this.id}:\`, {
-      progress: update.progress,
-      status: update.status,
-      endState: update.endState,
-      clientData: update.clientData
-    });
-  }`;
-      content = content.replace(
-        futureMethodMatch[0],
-        futureMethodMatch[0] + methodCode
-      );
-    }
-    return content;
+  for (const { name, isTypeOnly } of names) {
+    if (existing.has(name)) continue;
+    target.addNamedImport({ name, isTypeOnly: !!isTypeOnly });
+    existing.add(name);
   }
 }
-class ServiceFileTransformer {
-  constructor(codegenFs, options) {
-    this.codegenFs = codegenFs;
-    this.options = options;
-  }
-  codegenFs;
-  options;
-  transform() {
-    const { servicesFilePath } = this.options;
+function resolveSdkModuleSpecifier(sourceFile) {
+  const decl = sourceFile.getImportDeclarations().find((d) => d.getNamedImports().some((n) => n.getName() === "kosModel"));
+  return decl?.getModuleSpecifierValue() ?? "@kosdev-code/kos-ui-sdk";
+}
+function getModelClass(sourceFile, preferName) {
+  const classes = sourceFile.getClasses();
+  const byName = preferName ? classes.find((c) => c.getName() === preferName) : void 0;
+  if (byName) return byName;
+  const impl = classes.find((c) => /ModelImpl$/.test(c.getName() ?? ""));
+  if (impl) return impl;
+  const exported = classes.find((c) => c.isExported());
+  if (exported) return exported;
+  if (classes.length > 0) return classes[0];
+  throw new Error("No class declaration found in model file.");
+}
+function addClassDecorator(cls, name, opts) {
+  if (cls.getDecorator(name)) return;
+  const typeArgs = opts?.typeArgs?.length ? `<${opts.typeArgs.join(", ")}>` : "";
+  const args = opts?.argsText ?? "";
+  const decorators = cls.getDecorators();
+  const kosModelIdx = decorators.findIndex((d) => d.getName() === "kosModel");
+  const insertIdx = kosModelIdx >= 0 ? kosModelIdx + 1 : decorators.length;
+  cls.insertDecorator(insertIdx, {
+    name: `${name}${typeArgs}`,
+    arguments: args ? [args] : []
+  });
+}
+function ensureDeclarationMerge(sourceFile, interfaceName, extendsExpr, typeParameters = []) {
+  const baseType = extendsExpr.split("<")[0].trim();
+  let iface = sourceFile.getInterface(interfaceName);
+  if (iface) {
+    const already = iface.getExtends().some((e) => e.getText().split("<")[0].trim() === baseType);
+    if (!already) iface.addExtends(extendsExpr);
+    return;
+  }
+  iface = sourceFile.addInterface({
+    name: interfaceName,
+    isExported: true,
+    typeParameters,
+    extends: [extendsExpr]
+  });
+  sourceFile.insertText(
+    iface.getStart(),
+    "// eslint-disable-next-line @typescript-eslint/no-empty-interface\n"
+  );
+}
+function ensureFileEslintDisable(sourceFile, rule) {
+  if (sourceFile.getFullText().includes(rule)) return;
+  sourceFile.insertText(0, `/* eslint-disable ${rule} */
+`);
+}
+function addDecoratedMethod(cls, spec) {
+  if (cls.getMethod(spec.name)) return false;
+  cls.addMethod({
+    name: spec.name,
+    isAsync: spec.isAsync,
+    returnType: spec.returnType,
+    parameters: spec.parameters?.map((p) => {
+      return { name: p.name, type: p.type };
+    }),
+    statements: spec.statements,
+    decorators: [
+      {
+        name: spec.decoratorName,
+        arguments: spec.decoratorArgsText ? [spec.decoratorArgsText] : []
+      }
+    ]
+  });
+  return true;
+}
+function propertyInsertIndex(cls) {
+  const props = cls.getProperties();
+  if (props.length === 0) return 0;
+  return props[props.length - 1].getChildIndex() + 1;
+}
+function addPlainProperty(cls, spec) {
+  if (cls.getProperty(spec.name)) return false;
+  cls.insertProperty(propertyInsertIndex(cls), {
+    name: spec.name,
+    type: spec.type,
+    initializer: spec.initializer,
+    isReadonly: !!spec.readonly,
+    scope: spec.scope ? SCOPE_MAP[spec.scope] : void 0,
+    hasExclamationToken: spec.initializer ? false : !!spec.hasExclamation
+  });
+  return true;
+}
+const SCOPE_MAP = {
+  private: tsMorph.Scope.Private,
+  protected: tsMorph.Scope.Protected,
+  public: tsMorph.Scope.Public
+};
+function addDecoratedProperty(cls, spec) {
+  if (cls.getProperty(spec.name)) return false;
+  cls.insertProperty(propertyInsertIndex(cls), {
+    name: spec.name,
+    type: spec.type,
+    initializer: spec.initializer,
+    scope: spec.scope ? SCOPE_MAP[spec.scope] : void 0,
+    hasExclamationToken: spec.initializer ? false : !!spec.hasExclamation,
+    decorators: [
+      spec.bare && !spec.decoratorArgsText ? { name: spec.decoratorName } : {
+        name: spec.decoratorName,
+        arguments: spec.decoratorArgsText ? [spec.decoratorArgsText] : []
+      }
+    ]
+  });
+  return true;
+}
+function addGetter(cls, spec) {
+  if (cls.getGetAccessor(spec.name)) return false;
+  const ctor = cls.getConstructors()[0];
+  const index = ctor ? ctor.getChildIndex() + 1 : propertyInsertIndex(cls);
+  cls.insertGetAccessor(index, {
+    name: spec.name,
+    returnType: spec.returnType,
+    statements: spec.statements ?? "// TODO: derive and return the computed value"
+  });
+  return true;
+}
+const LEGACY_IMPORTS = /* @__PURE__ */ new Set([
+  "setupCompleteFutureSupport",
+  "setupMinimalFutureSupport",
+  "FutureAwareContainer",
+  "FutureHandlerContainer",
+  "FutureStateAccessor",
+  "FutureUpdateHandler"
+]);
+const LEGACY_IMPLEMENTS = /* @__PURE__ */ new Set([
+  "FutureUpdateHandler",
+  "FutureHandlerContainer",
+  "FutureStateAccessor"
+]);
+class ModelFileTransformer {
+  constructor(codegenFs, options) {
+    this.codegenFs = codegenFs;
+    this.options = options;
+  }
+  codegenFs;
+  options;
+  get progressType() {
+    const { nameProperCase, updateServices } = this.options;
+    return updateServices ? `${nameProperCase}OperationProgress` : "Record<string, unknown>";
+  }
+  transform() {
+    const { modelFilePath } = this.options;
+    if (!this.codegenFs.exists(modelFilePath)) {
+      throw new Error(`Model file not found: ${modelFilePath}`);
+    }
+    transformSourceFile(this.codegenFs, modelFilePath, (sf) => {
+      this.removeLegacyImports(sf);
+      this.addImports(sf);
+      const cls = getModelClass(sf, `${this.options.nameProperCase}ModelImpl`);
+      this.removeLegacyClassMembers(cls);
+      this.addDecorator(cls);
+      this.addFutureMethod(cls);
+      if (this.options.futureType === "complete") {
+        this.addOnFutureUpdateMethod(cls);
+      }
+      this.updatePublicType(sf);
+      ensureDeclarationMerge(
+        sf,
+        `${this.options.nameProperCase}ModelImpl`,
+        `${this.options.futureType === "complete" ? "KosFutureAwareFull" : "KosFutureAwareMinimal"}<${this.progressType}>`
+      );
+      ensureFileEslintDisable(
+        sf,
+        "@typescript-eslint/no-unsafe-declaration-merging"
+      );
+    });
+  }
+  removeLegacyImports(sf) {
+    for (const decl of sf.getImportDeclarations()) {
+      for (const named of decl.getNamedImports()) {
+        if (LEGACY_IMPORTS.has(named.getName())) named.remove();
+      }
+      if (decl.getNamedImports().length === 0 && !decl.getDefaultImport() && !decl.getNamespaceImport()) {
+        decl.remove();
+      }
+    }
+  }
+  addImports(sf) {
+    const { internal, futureType, updateServices, nameProperCase } = this.options;
+    const isComplete = futureType === "complete";
+    const sdkSpec = resolveSdkModuleSpecifier(sf);
+    ensureNamedImport(sf, sdkSpec, [
+      { name: "kosFuture" },
+      { name: "kosFutureAware" },
+      {
+        name: isComplete ? "KosFutureAwareFull" : "KosFutureAwareMinimal",
+        isTypeOnly: true
+      }
+    ]);
+    const typeSpec = internal ? "../../../models/types/future-interfaces" : sdkSpec;
+    ensureNamedImport(sf, typeSpec, [
+      { name: "ExternalFutureInterface", isTypeOnly: true },
+      ...isComplete ? [{ name: "IFutureModel", isTypeOnly: true }] : []
+    ]);
+    if (updateServices) {
+      ensureNamedImport(sf, "./services", [
+        { name: `${nameProperCase}OperationProgress`, isTypeOnly: true }
+      ]);
+    }
+  }
+  removeLegacyClassMembers(cls) {
+    for (const ctor of cls.getConstructors()) {
+      for (const stmt of ctor.getStatements()) {
+        if (/setup(Complete|Minimal)FutureSupport\s*\(\s*this\s*\)/.test(
+          stmt.getText()
+        )) {
+          stmt.remove();
+        }
+      }
+    }
+    const futureHandler = cls.getProperty("futureHandler");
+    if (futureHandler?.getTypeNode()?.getText().includes("FutureAwareContainer")) {
+      futureHandler.remove();
+    }
+    const future = cls.getProperty("future");
+    if (future?.getTypeNode()?.getText().includes("IFutureModel")) {
+      future.remove();
+    }
+    const impls = cls.getImplements();
+    for (let i = impls.length - 1; i >= 0; i--) {
+      const base = impls[i].getText().split("<")[0].trim();
+      if (LEGACY_IMPLEMENTS.has(base)) cls.removeImplements(i);
+    }
+  }
+  addDecorator(cls) {
+    const argsText = this.options.futureType === "complete" ? "" : `{ mode: "minimal" }`;
+    addClassDecorator(cls, "kosFutureAware", { argsText });
+  }
+  updatePublicType(sf) {
+    const { nameProperCase } = this.options;
+    const alias = sf.getTypeAlias(`${nameProperCase}Model`);
+    if (!alias) return;
+    const text = alias.getTypeNode()?.getText() ?? "";
+    if (!text.includes(`PublicModelInterface<${nameProperCase}ModelImpl>`) || text.includes("ExternalFutureInterface")) {
+      return;
+    }
+    alias.setType(
+      `PublicModelInterface<${nameProperCase}ModelImpl> & ExternalFutureInterface<${this.progressType}>`
+    );
+  }
+  addFutureMethod(cls) {
+    const { nameProperCase } = this.options;
+    const hasFutureMethod = cls.getMethods().some((m) => m.getDecorator("kosFuture"));
+    if (hasFutureMethod || cls.getMethod("performLongRunningOperation")) return;
+    cls.addMethod({
+      name: "performLongRunningOperation",
+      isAsync: true,
+      returnType: "Promise<void>",
+      decorators: [{ name: "kosFuture", arguments: [] }],
+      docs: [
+        {
+          description: "Placeholder method for Future operations\nReplace this with your actual long-running operation"
+        }
+      ],
+      statements: [
+        "// TODO: Implement your long-running operation here",
+        "// This method should use a service that returns a Future for progress tracking",
+        "",
+        "this.logger.debug(`Starting long-running operation for ${this.id}`);",
+        "",
+        "// Example implementation pattern using services:",
+        `// import { perform${nameProperCase}Operation } from './services';`,
+        "//",
+        `// const future = await perform${nameProperCase}Operation();`,
+        "// return this.futureHandler.setFuture(future);",
+        "",
+        "// Placeholder that doesn't actually do anything",
+        "await new Promise((resolve) => setTimeout(resolve, 1000));",
+        "",
+        "this.logger.debug(`Completed long-running operation for ${this.id}`);"
+      ]
+    });
+  }
+  addOnFutureUpdateMethod(cls) {
+    if (cls.getMethod("onFutureUpdate")) return;
+    cls.addMethod({
+      name: "onFutureUpdate",
+      hasQuestionToken: true,
+      returnType: "void",
+      parameters: [
+        { name: "update", type: `IFutureModel<${this.progressType}>` }
+      ],
+      docs: [
+        {
+          description: "Optional: Custom Future update handling\nCalled whenever the Future state changes (progress, status, completion, etc.)"
+        }
+      ],
+      statements: [
+        "// Add custom Future update logic here",
+        "// Examples:",
+        "// - Log progress milestones",
+        "// - Update derived state based on progress",
+        "// - Handle specific error conditions",
+        "// - Trigger notifications at certain thresholds",
+        "",
+        "this.logger.debug(`Future update for ${this.id}:`, {",
+        "  progress: update.progress,",
+        "  status: update.status,",
+        "  endState: update.endState,",
+        "  clientData: update.clientData,",
+        "});"
+      ]
+    });
+  }
+}
+class ServiceFileTransformer {
+  constructor(codegenFs, options) {
+    this.codegenFs = codegenFs;
+    this.options = options;
+  }
+  codegenFs;
+  options;
+  transform() {
+    const { servicesFilePath } = this.options;
     if (!servicesFilePath || !this.codegenFs.exists(servicesFilePath)) {
       this.createServicesFile();
       return;
@@ -1505,9 +1998,16 @@ class RegistrationFileTransformer {
       logger.warn("Registration file not found, skipping registration updates");
       return;
     }
-    let content = this.codegenFs.read(registrationFilePath);
+    const original = this.codegenFs.read(registrationFilePath);
+    let content = original;
     content = this.addTypeCast(content);
     content = this.updateDocumentation(content);
+    if (content === original) {
+      logger.info(
+        "Registration file has no legacy future patterns — leaving it untouched"
+      );
+      return;
+    }
     this.codegenFs.write(registrationFilePath, content);
   }
   addTypeCast(content) {
@@ -1575,7 +2075,7 @@ function addFutureToModel(codegenFs, options, projects) {
     }
     if (normalized.registrationFilePath) {
       logger.info(
-        `Would modify registration file: ${normalized.registrationFilePath}`
+        `Would update registration file (only if legacy patterns are present): ${normalized.registrationFilePath}`
       );
     }
     return;
@@ -1626,191 +2126,6 @@ function addFutureToModel(codegenFs, options, projects) {
     throw error;
   }
 }
-function resolveModelFilePath(codegenFs, query, projects) {
-  const kosConfig = getKosProjectConfiguration(
-    codegenFs,
-    query.modelProject,
-    projects
-  );
-  const internal = !!kosConfig?.generator?.internal;
-  const project = findProjectByName(
-    codegenFs.root,
-    query.modelProject,
-    projects
-  );
-  const sourceRoot = project ? project.sourceRoot || path__namespace.join(project.root, "src") : void 0;
-  if (query.modelPath) {
-    return { modelFilePath: query.modelPath, internal, sourceRoot };
-  }
-  if (!project) {
-    throw new Error(
-      `Project not found: ${query.modelProject}. Ensure a project.json exists.`
-    );
-  }
-  const { modelNameDashCase } = normalizeAllValues({
-    modelName: query.modelName
-  });
-  const modelLocation = kosConfig?.generator?.defaults?.model?.folder || "";
-  const modelFilePath = path__namespace.join(
-    sourceRoot,
-    modelLocation,
-    modelNameDashCase,
-    `${modelNameDashCase}-model.ts`
-  );
-  return { modelFilePath, internal, sourceRoot };
-}
-function transformSourceFile(codegenFs, filePath, mutate) {
-  const content = codegenFs.read(filePath);
-  if (content === null) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-  const project = new tsMorph.Project({
-    useInMemoryFileSystem: true,
-    manipulationSettings: {
-      indentationText: tsMorph.IndentationText.TwoSpaces,
-      quoteKind: tsMorph.QuoteKind.Double
-    }
-  });
-  const sourceFile = project.createSourceFile(filePath, content, {
-    overwrite: true
-  });
-  mutate(sourceFile);
-  codegenFs.write(filePath, sourceFile.getFullText());
-}
-function ensureNamedImport(sourceFile, moduleSpecifier, names) {
-  const decls = sourceFile.getImportDeclarations().filter((d) => d.getModuleSpecifierValue() === moduleSpecifier);
-  const existing = /* @__PURE__ */ new Set();
-  for (const d of decls) {
-    for (const n of d.getNamedImports()) existing.add(n.getName());
-  }
-  let target = decls.find((d) => !d.isTypeOnly());
-  if (!target) {
-    target = sourceFile.addImportDeclaration({ moduleSpecifier });
-  }
-  for (const { name, isTypeOnly } of names) {
-    if (existing.has(name)) continue;
-    target.addNamedImport({ name, isTypeOnly: !!isTypeOnly });
-    existing.add(name);
-  }
-}
-function resolveSdkModuleSpecifier(sourceFile) {
-  const decl = sourceFile.getImportDeclarations().find((d) => d.getNamedImports().some((n) => n.getName() === "kosModel"));
-  return decl?.getModuleSpecifierValue() ?? "@kosdev-code/kos-ui-sdk";
-}
-function getModelClass(sourceFile, preferName) {
-  const classes = sourceFile.getClasses();
-  const impl = classes.find((c) => /ModelImpl$/.test(c.getName() ?? ""));
-  if (impl) return impl;
-  const exported = classes.find((c) => c.isExported());
-  if (exported) return exported;
-  if (classes.length > 0) return classes[0];
-  throw new Error("No class declaration found in model file.");
-}
-function addClassDecorator(cls, name, opts) {
-  if (cls.getDecorator(name)) return;
-  const typeArgs = opts?.typeArgs?.length ? `<${opts.typeArgs.join(", ")}>` : "";
-  const args = opts?.argsText ?? "";
-  const decorators = cls.getDecorators();
-  const kosModelIdx = decorators.findIndex((d) => d.getName() === "kosModel");
-  const insertIdx = kosModelIdx >= 0 ? kosModelIdx + 1 : decorators.length;
-  cls.insertDecorator(insertIdx, {
-    name: `${name}${typeArgs}`,
-    arguments: args ? [args] : []
-  });
-}
-function ensureDeclarationMerge(sourceFile, interfaceName, extendsExpr, typeParameters = []) {
-  const baseType = extendsExpr.split("<")[0].trim();
-  let iface = sourceFile.getInterface(interfaceName);
-  if (iface) {
-    const already = iface.getExtends().some((e) => e.getText().split("<")[0].trim() === baseType);
-    if (!already) iface.addExtends(extendsExpr);
-    return;
-  }
-  iface = sourceFile.addInterface({
-    name: interfaceName,
-    isExported: true,
-    typeParameters,
-    extends: [extendsExpr]
-  });
-  sourceFile.insertText(
-    iface.getStart(),
-    "// eslint-disable-next-line @typescript-eslint/no-empty-interface\n"
-  );
-}
-function ensureFileEslintDisable(sourceFile, rule) {
-  if (sourceFile.getFullText().includes(rule)) return;
-  sourceFile.insertText(0, `/* eslint-disable ${rule} */
-`);
-}
-function addDecoratedMethod(cls, spec) {
-  if (cls.getMethod(spec.name)) return false;
-  cls.addMethod({
-    name: spec.name,
-    isAsync: spec.isAsync,
-    returnType: spec.returnType,
-    parameters: spec.parameters?.map((p) => {
-      return { name: p.name, type: p.type };
-    }),
-    statements: spec.statements,
-    decorators: [
-      {
-        name: spec.decoratorName,
-        arguments: spec.decoratorArgsText ? [spec.decoratorArgsText] : []
-      }
-    ]
-  });
-  return true;
-}
-function propertyInsertIndex(cls) {
-  const props = cls.getProperties();
-  if (props.length === 0) return 0;
-  return props[props.length - 1].getChildIndex() + 1;
-}
-function addPlainProperty(cls, spec) {
-  if (cls.getProperty(spec.name)) return false;
-  cls.insertProperty(propertyInsertIndex(cls), {
-    name: spec.name,
-    type: spec.type,
-    initializer: spec.initializer,
-    isReadonly: !!spec.readonly,
-    scope: spec.scope ? SCOPE_MAP[spec.scope] : void 0,
-    hasExclamationToken: spec.initializer ? false : !!spec.hasExclamation
-  });
-  return true;
-}
-const SCOPE_MAP = {
-  private: tsMorph.Scope.Private,
-  protected: tsMorph.Scope.Protected,
-  public: tsMorph.Scope.Public
-};
-function addDecoratedProperty(cls, spec) {
-  if (cls.getProperty(spec.name)) return false;
-  cls.insertProperty(propertyInsertIndex(cls), {
-    name: spec.name,
-    type: spec.type,
-    initializer: spec.initializer,
-    scope: spec.scope ? SCOPE_MAP[spec.scope] : void 0,
-    hasExclamationToken: spec.initializer ? false : !!spec.hasExclamation,
-    decorators: [
-      spec.bare && !spec.decoratorArgsText ? { name: spec.decoratorName } : {
-        name: spec.decoratorName,
-        arguments: spec.decoratorArgsText ? [spec.decoratorArgsText] : []
-      }
-    ]
-  });
-  return true;
-}
-function addGetter(cls, spec) {
-  if (cls.getGetAccessor(spec.name)) return false;
-  const ctor = cls.getConstructors()[0];
-  const index = ctor ? ctor.getChildIndex() + 1 : propertyInsertIndex(cls);
-  cls.insertGetAccessor(index, {
-    name: spec.name,
-    returnType: spec.returnType,
-    statements: spec.statements ?? "// TODO: derive and return the computed value"
-  });
-  return true;
-}
 function buildDecoratorArgs(options) {
   const top = [];
   if (options.containerProperty) {
@@ -3076,6 +3391,8 @@ exports.LOCALIZED_PLUGIN_TYPES = LOCALIZED_PLUGIN_TYPES;
 exports.PLUGIN_TYPES = PLUGIN_TYPES;
 exports.PluginHandlerFactory = PluginHandlerFactory;
 exports.TrackingFileSystem = TrackingFileSystem;
+exports.UPDATE_RELEASE_VERSION_SCRIPT = UPDATE_RELEASE_VERSION_SCRIPT;
+exports.UPDATE_RELEASE_VERSION_SCRIPT_PATH = UPDATE_RELEASE_VERSION_SCRIPT_PATH;
 exports.ValidationError = ValidationError;
 exports.addChildToModel = addChildToModel;
 exports.addComputedToModel = addComputedToModel;
@@ -3083,17 +3400,23 @@ exports.addConfigPropertyToModel = addConfigPropertyToModel;
 exports.addContainerSupportToModel = addContainerSupportToModel;
 exports.addDependencyToModel = addDependencyToModel;
 exports.addFutureToModel = addFutureToModel;
+exports.addJavaArtifactToManifests = addJavaArtifactToManifests;
 exports.addKosModelConfiguration = addKosModelConfiguration;
 exports.addModelEffectToModel = addModelEffectToModel;
 exports.addPropertyToModel = addPropertyToModel;
 exports.addServiceRequestToModel = addServiceRequestToModel;
 exports.addTopicHandlerToModel = addTopicHandlerToModel;
 exports.appendBarrelExport = appendBarrelExport;
+exports.buildKabTargets = buildKabTargets;
 exports.camelCase = camelCase;
 exports.constantCase = constantCase;
 exports.dashCase = dashCase;
 exports.describeModel = describeModel;
+exports.discoverJavaArtifacts = discoverJavaArtifacts;
 exports.discoverProjects = discoverProjects;
+exports.discoverUiArtifacts = discoverUiArtifacts;
+exports.ensureJavaAggregatorPom = ensureJavaAggregatorPom;
+exports.finalizeArchetypeModule = finalizeArchetypeModule;
 exports.findProjectByName = findProjectByName;
 exports.findProjectForPath = findProjectForPath;
 exports.formatFiles = formatFiles;
@@ -3105,6 +3428,7 @@ exports.generateFilesFromTemplates = generateFilesFromTemplates;
 exports.generateHook = generateHook;
 exports.generateInit = generateInit;
 exports.generateModel = generateModel;
+exports.generatePolyglotWorkspace = generatePolyglotWorkspace;
 exports.generateSplashProject = generateSplashProject;
 exports.getCodegenLogger = getCodegenLogger;
 exports.getCurrentDirectoryName = getCurrentDirectoryName;
@@ -3120,7 +3444,9 @@ exports.pascalCase = pascalCase;
 exports.properCase = properCase;
 exports.readJson = readJson;
 exports.readNxJson = readNxJson;
+exports.resolveModelFilePath = resolveModelFilePath;
 exports.setCodegenLogger = setCodegenLogger;
+exports.syncCiManifests = syncCiManifests;
 exports.updateJson = updateJson;
 exports.updateModelIndex = updateModelIndex;
 exports.validateModel = validateModel;