@typemf/generator 0.5.0

package/dist/index.js

@@ -0,0 +1,1678 @@
+// src/cli-config.ts
+import { readFile } from "fs/promises";
+async function loadConfig(configPath) {
+  let raw;
+  try {
+    raw = await readFile(configPath, "utf-8");
+  } catch (err) {
+    throw new Error(`Could not read config file '${configPath}': ${err.message}`, { cause: err });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse '${configPath}' as JSON: ${err.message}`, { cause: err });
+  }
+  return validateConfig(parsed, configPath);
+}
+function validateConfig(value, configPath) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`'${configPath}' must contain a JSON object.`);
+  }
+  const obj = value;
+  for (const key of ["ecoreFile", "outputDir", "templateSet"]) {
+    if (typeof obj[key] !== "string" || obj[key] === "") {
+      throw new Error(`'${configPath}': "${key}" is required and must be a non-empty string.`);
+    }
+  }
+  if (obj.options !== void 0 && (typeof obj.options !== "object" || obj.options === null || Array.isArray(obj.options))) {
+    throw new Error(`'${configPath}': "options", if present, must be a JSON object.`);
+  }
+  return {
+    ecoreFile: obj.ecoreFile,
+    outputDir: obj.outputDir,
+    templateSet: obj.templateSet,
+    options: obj.options ?? {}
+  };
+}
+
+// src/ecore-loader.ts
+import { EcorePackageImpl as EcorePackageImpl2, ResourceSetImpl, URI } from "@typemf/core";
+import { NodeFileUriConverter } from "@typemf/node";
+import { registerXmiFormat } from "@typemf/xmi";
+
+// src/ecore-dynamic-to-typed.ts
+import {
+  EAnnotationImpl,
+  EAttributeImpl,
+  setDetailValue,
+  EClassImpl,
+  EcorePackageImpl,
+  EDataTypeImpl,
+  EEnumImpl,
+  EEnumLiteralImpl,
+  EGenericTypeImpl,
+  EOperationImpl,
+  EPackageImpl,
+  ETypeParameterImpl,
+  EParameterImpl,
+  EReferenceImpl,
+  isEClassifier,
+  resolveAgainstPackage
+} from "@typemf/core";
+function convertDynamicEcoreToTyped(dynamicPkg) {
+  const realPkg = new EPackageImpl();
+  realPkg.setName(byName(dynamicPkg, "name") ?? "");
+  realPkg.setNsURI(byName(dynamicPkg, "nsURI") ?? "");
+  realPkg.setNsPrefix(byName(dynamicPkg, "nsPrefix") ?? "");
+  copyAnnotations(dynamicPkg, realPkg);
+  const dynamicClassifiers = listByName(dynamicPkg, "eClassifiers");
+  const classifierMap = /* @__PURE__ */ new Map();
+  const featureMap = /* @__PURE__ */ new Map();
+  const typeParameterMap = /* @__PURE__ */ new Map();
+  for (const dyn of dynamicClassifiers) {
+    const kind = dyn.eClass().getName();
+    const name = byName(dyn, "name") ?? "";
+    if (name === "EObject") {
+      classifierMap.set(dyn, void 0);
+      continue;
+    }
+    if (kind === "EClass") {
+      const c = new EClassImpl();
+      c.setName(name);
+      copyAnnotations(dyn, c);
+      classifierMap.set(dyn, c);
+    } else if (kind === "EEnum") {
+      const e = new EEnumImpl();
+      e.setName(name);
+      copyAnnotations(dyn, e);
+      classifierMap.set(dyn, e);
+    } else {
+      const d = new EDataTypeImpl();
+      d.setName(name);
+      copyAnnotations(dyn, d);
+      classifierMap.set(dyn, d);
+    }
+  }
+  function classifierOf(dynClassifier) {
+    if (classifierMap.has(dynClassifier)) return classifierMap.get(dynClassifier);
+    const uri = dynClassifier.eIsProxy() ? dynClassifier.getProxyURI() : void 0;
+    const ecore = EcorePackageImpl.eINSTANCE;
+    if (uri && uri.trimFragment().toString() === ecore.getNsURI()) {
+      const fragment = uri.getFragment() ?? "";
+      if (fragment === "//EObject") return void 0;
+      const resolved = resolveAgainstPackage(ecore, fragment);
+      if (isEClassifier(resolved)) return resolved;
+    }
+    throw new Error(
+      `Cannot resolve the classifier reference '${uri?.toString() ?? dynClassifier.fullId()}': only classifiers of this package and of Ecore are supported.`
+    );
+  }
+  function resolveType(dynFeature) {
+    const dynType = byNameRaw(dynFeature, "eType");
+    if (dynType) return classifierOf(dynType);
+    const dynGeneric = byNameRaw(dynFeature, "eGenericType");
+    if (dynGeneric) {
+      const dynClassifier = byNameRaw(dynGeneric, "eClassifier");
+      if (dynClassifier) return classifierOf(dynClassifier);
+    }
+    return void 0;
+  }
+  function convertGenericType(dynGeneric) {
+    const gt = new EGenericTypeImpl();
+    const dynClassifier = byNameRaw(dynGeneric, "eClassifier");
+    if (dynClassifier) gt.setEClassifier(classifierOf(dynClassifier));
+    const dynParameter = byNameRaw(dynGeneric, "eTypeParameter");
+    if (dynParameter) gt.setETypeParameter(typeParameterMap.get(dynParameter));
+    for (const dynArgument of listByName(dynGeneric, "eTypeArguments")) {
+      gt.getETypeArguments().add(convertGenericType(dynArgument));
+    }
+    return gt;
+  }
+  function applyType(dynTyped, real) {
+    const dynGeneric = byNameRaw(dynTyped, "eGenericType");
+    if (dynGeneric) {
+      real.setEGenericType(convertGenericType(dynGeneric));
+      return;
+    }
+    const type = resolveType(dynTyped);
+    if (type) real.setEType(type);
+  }
+  for (const dyn of dynamicClassifiers) {
+    const real = classifierMap.get(dyn);
+    if (!real) continue;
+    const kind = dyn.eClass().getName();
+    for (const dynParameter of listByName(dyn, "eTypeParameters")) {
+      const parameter = new ETypeParameterImpl();
+      parameter.setName(byName(dynParameter, "name") ?? "");
+      real.getETypeParameters().add(parameter);
+      typeParameterMap.set(dynParameter, parameter);
+    }
+    const instanceClassName = byName(dyn, "instanceClassName");
+    if (instanceClassName !== void 0 && instanceClassName !== "") real.setInstanceClassName(instanceClassName);
+    if (kind === "EClass") {
+      const c = real;
+      if (byName(dyn, "abstract")) c.setAbstract(true);
+      if (byName(dyn, "interface")) c.setInterface(true);
+      for (const dynSuper of listByName(dyn, "eSuperTypes")) {
+        const realSuper = classifierOf(dynSuper);
+        if (realSuper) c.getESuperTypes().add(realSuper);
+      }
+    }
+  }
+  for (const dyn of dynamicClassifiers) {
+    const real = classifierMap.get(dyn);
+    if (!real || dyn.eClass().getName() !== "EClass") continue;
+    const realClass = real;
+    for (const dynFeature of listByName(dyn, "eStructuralFeatures")) {
+      const featureKind = dynFeature.eClass().getName();
+      const name = byName(dynFeature, "name") ?? "";
+      const lowerBound = byName(dynFeature, "lowerBound");
+      const upperBound = byName(dynFeature, "upperBound");
+      if (featureKind === "EReference") {
+        const r = new EReferenceImpl();
+        r.setName(name);
+        applyType(dynFeature, r);
+        if (typeof lowerBound === "number") r.setLowerBound(lowerBound);
+        if (typeof upperBound === "number") r.setUpperBound(upperBound);
+        if (byName(dynFeature, "containment")) r.setContainment(true);
+        if (byName(dynFeature, "resolveProxies") === false) r.setResolveProxies(false);
+        r.setEContainingClass(realClass);
+        copyFeatureFlags(dynFeature, r);
+        copyAnnotations(dynFeature, r);
+        realClass.getEStructuralFeatures().add(r);
+        featureMap.set(dynFeature, r);
+      } else {
+        const a = new EAttributeImpl();
+        a.setName(name);
+        applyType(dynFeature, a);
+        if (typeof lowerBound === "number") a.setLowerBound(lowerBound);
+        if (typeof upperBound === "number") a.setUpperBound(upperBound);
+        if (byName(dynFeature, "iD")) a.setID(true);
+        copyFeatureFlags(dynFeature, a);
+        a.setEContainingClass(realClass);
+        copyAnnotations(dynFeature, a);
+        realClass.getEStructuralFeatures().add(a);
+        featureMap.set(dynFeature, a);
+      }
+    }
+    for (const dynOp of listByName(dyn, "eOperations")) {
+      const op = new EOperationImpl();
+      op.setName(byName(dynOp, "name") ?? "");
+      applyType(dynOp, op);
+      copyAnnotations(dynOp, op);
+      const opLowerBound = byName(dynOp, "lowerBound");
+      const opUpperBound = byName(dynOp, "upperBound");
+      if (typeof opLowerBound === "number") op.setLowerBound(opLowerBound);
+      if (typeof opUpperBound === "number") op.setUpperBound(opUpperBound);
+      for (const dynParam of listByName(dynOp, "eParameters")) {
+        const param = new EParameterImpl();
+        param.setName(byName(dynParam, "name") ?? "");
+        applyType(dynParam, param);
+        const paramLowerBound = byName(dynParam, "lowerBound");
+        const paramUpperBound = byName(dynParam, "upperBound");
+        if (typeof paramLowerBound === "number") param.setLowerBound(paramLowerBound);
+        if (typeof paramUpperBound === "number") param.setUpperBound(paramUpperBound);
+        op.getEParameters().add(param);
+      }
+      realClass.getEOperations().add(op);
+    }
+  }
+  for (const dyn of dynamicClassifiers) {
+    const real = classifierMap.get(dyn);
+    if (!real || dyn.eClass().getName() !== "EEnum") continue;
+    for (const dynLiteral of listByName(dyn, "eLiterals")) {
+      const lit = new EEnumLiteralImpl();
+      lit.setName(byName(dynLiteral, "name") ?? "");
+      lit.setValue(byName(dynLiteral, "value") ?? 0);
+      lit.setLiteral(byName(dynLiteral, "literal") ?? byName(dynLiteral, "name") ?? "");
+      copyAnnotations(dynLiteral, lit);
+      real.getELiterals().add(lit);
+    }
+  }
+  for (const [dynFeature, realFeature] of featureMap) {
+    const dynOpposite = byNameRaw(dynFeature, "eOpposite");
+    if (!dynOpposite) continue;
+    const realOpposite = featureMap.get(dynOpposite);
+    if (realOpposite && "setEOpposite" in realFeature) {
+      realFeature.setEOpposite(realOpposite);
+    }
+  }
+  for (const real of classifierMap.values()) {
+    if (real) realPkg.getEClassifiers().add(real);
+  }
+  return realPkg;
+}
+function copyAnnotations(dyn, real) {
+  for (const dynAnnotation of listByName(dyn, "eAnnotations")) {
+    const annotation = new EAnnotationImpl();
+    const source = byName(dynAnnotation, "source");
+    if (source !== void 0) annotation.setSource(source);
+    for (const dynDetail of listByName(dynAnnotation, "details")) {
+      const key = byName(dynDetail, "key");
+      const value = byName(dynDetail, "value");
+      if (key !== void 0 && value !== void 0) {
+        setDetailValue(annotation.getDetails(), key, value);
+      }
+    }
+    real.getEAnnotations().add(annotation);
+  }
+}
+function copyFeatureFlags(dyn, real) {
+  const changeable = byName(dyn, "changeable");
+  if (changeable === false) real.setChangeable(false);
+  if (byName(dyn, "volatile")) real.setVolatile(true);
+  if (byName(dyn, "transient")) real.setTransient(true);
+  if (byName(dyn, "derived")) real.setDerived(true);
+  if (byName(dyn, "unsettable")) real.setUnsettable(true);
+  const defaultValueLiteral = byName(dyn, "defaultValueLiteral");
+  if (defaultValueLiteral !== void 0) real.setDefaultValueLiteral(defaultValueLiteral);
+}
+function byNameRaw(obj, featureName) {
+  const feature = obj.eClass().getEStructuralFeature(featureName);
+  if (!feature) return void 0;
+  return obj.eGet(feature);
+}
+function byName(obj, featureName) {
+  return byNameRaw(obj, featureName);
+}
+function listByName(obj, featureName) {
+  const value = byNameRaw(obj, featureName);
+  if (!value) return [];
+  return [...value];
+}
+
+// src/ecore-meta-schema.ts
+import {
+  DynamicEFactoryImpl,
+  EAttributeImpl as EAttributeImpl2,
+  EClassImpl as EClassImpl2,
+  EDataTypeImpl as EDataTypeImpl2,
+  EPackageImpl as EPackageImpl2,
+  EReferenceImpl as EReferenceImpl2
+} from "@typemf/core";
+
+// src/id-assignment.ts
+function assignFreshIds(pkg) {
+  let classifierId = 0;
+  for (const classifier of pkg.getEClassifiers()) {
+    classifier.setClassifierID(classifierId++);
+  }
+  for (const classifier of pkg.getEClassifiers()) {
+    if (!isEClass(classifier)) continue;
+    classifier.getEAllStructuralFeatures().forEach((feature, index) => feature.setFeatureID(index));
+    classifier.getEAllOperations().forEach((op, index) => op.setOperationID(index));
+  }
+}
+function isEClass(classifier) {
+  return "getEStructuralFeatures" in classifier;
+}
+
+// src/ecore-meta-schema.ts
+function buildEcoreMetaSchema() {
+  const primitiveNames = [
+    "EBigDecimal",
+    "EBigInteger",
+    "EBoolean",
+    "EBooleanObject",
+    "EByte",
+    "EByteArray",
+    "EByteObject",
+    "EChar",
+    "ECharacterObject",
+    "EDate",
+    "EDiagnosticChain",
+    "EDouble",
+    "EDoubleObject",
+    "EEList",
+    "EEnumerator",
+    "EFeatureMap",
+    "EFeatureMapEntry",
+    "EFloat",
+    "EFloatObject",
+    "EInt",
+    "EIntegerObject",
+    "EJavaClass",
+    "EJavaObject",
+    "ELong",
+    "ELongObject",
+    "EMap",
+    "EResource",
+    "EResourceSet",
+    "EShort",
+    "EShortObject",
+    "EString",
+    "ETreeIterator",
+    "EInvocationTargetException"
+  ];
+  const primitives = new Map(
+    primitiveNames.map((n) => [
+      n,
+      (() => {
+        const d = new EDataTypeImpl2();
+        d.setName(n);
+        return d;
+      })()
+    ])
+  );
+  const p = (name) => primitives.get(name);
+  const eObject = new EClassImpl2();
+  eObject.setName("EObject");
+  const eModelElement = new EClassImpl2();
+  eModelElement.setName("EModelElement");
+  eModelElement.setAbstract(true);
+  const eAnnotation = new EClassImpl2();
+  eAnnotation.setName("EAnnotation");
+  const eNamedElement = new EClassImpl2();
+  eNamedElement.setName("ENamedElement");
+  eNamedElement.setAbstract(true);
+  const eTypedElement = new EClassImpl2();
+  eTypedElement.setName("ETypedElement");
+  eTypedElement.setAbstract(true);
+  const eClassifier = new EClassImpl2();
+  eClassifier.setName("EClassifier");
+  eClassifier.setAbstract(true);
+  const eStructuralFeature = new EClassImpl2();
+  eStructuralFeature.setName("EStructuralFeature");
+  eStructuralFeature.setAbstract(true);
+  const eAttribute = new EClassImpl2();
+  eAttribute.setName("EAttribute");
+  const eReference = new EClassImpl2();
+  eReference.setName("EReference");
+  const eClass = new EClassImpl2();
+  eClass.setName("EClass");
+  const ePackage = new EClassImpl2();
+  ePackage.setName("EPackage");
+  const eDataType = new EClassImpl2();
+  eDataType.setName("EDataType");
+  const eEnum = new EClassImpl2();
+  eEnum.setName("EEnum");
+  const eEnumLiteral = new EClassImpl2();
+  eEnumLiteral.setName("EEnumLiteral");
+  const eFactory = new EClassImpl2();
+  eFactory.setName("EFactory");
+  const eOperation = new EClassImpl2();
+  eOperation.setName("EOperation");
+  const eParameter = new EClassImpl2();
+  eParameter.setName("EParameter");
+  const eStringToStringMapEntry = new EClassImpl2();
+  eStringToStringMapEntry.setName("EStringToStringMapEntry");
+  const eGenericType = new EClassImpl2();
+  eGenericType.setName("EGenericType");
+  const eTypeParameter = new EClassImpl2();
+  eTypeParameter.setName("ETypeParameter");
+  eAnnotation.getESuperTypes().add(eModelElement);
+  eNamedElement.getESuperTypes().add(eModelElement);
+  eTypedElement.getESuperTypes().add(eNamedElement);
+  eClassifier.getESuperTypes().add(eNamedElement);
+  eStructuralFeature.getESuperTypes().add(eTypedElement);
+  eAttribute.getESuperTypes().add(eStructuralFeature);
+  eReference.getESuperTypes().add(eStructuralFeature);
+  eClass.getESuperTypes().add(eClassifier);
+  ePackage.getESuperTypes().add(eNamedElement);
+  eDataType.getESuperTypes().add(eClassifier);
+  eEnum.getESuperTypes().add(eDataType);
+  eEnumLiteral.getESuperTypes().add(eNamedElement);
+  eFactory.getESuperTypes().add(eModelElement);
+  eOperation.getESuperTypes().add(eTypedElement);
+  eParameter.getESuperTypes().add(eTypedElement);
+  eTypeParameter.getESuperTypes().add(eNamedElement);
+  const allClasses = [
+    eObject,
+    eModelElement,
+    eAnnotation,
+    eNamedElement,
+    eTypedElement,
+    eClassifier,
+    eStructuralFeature,
+    eAttribute,
+    eReference,
+    eClass,
+    ePackage,
+    eDataType,
+    eEnum,
+    eEnumLiteral,
+    eFactory,
+    eOperation,
+    eParameter,
+    eStringToStringMapEntry,
+    eGenericType,
+    eTypeParameter
+  ];
+  function attr(owner, name, type, opts = {}) {
+    const a = new EAttributeImpl2();
+    a.setName(name);
+    a.setEType(type);
+    if (opts.many) a.setUpperBound(-1);
+    if (opts.changeable === false) a.setChangeable(false);
+    if (opts.volatile) a.setVolatile(true);
+    if (opts.transient) a.setTransient(true);
+    if (opts.derived) a.setDerived(true);
+    a.setEContainingClass(owner);
+    owner.getEStructuralFeatures().add(a);
+    return a;
+  }
+  function ref(owner, name, type, opts = {}) {
+    const r = new EReferenceImpl2();
+    r.setName(name);
+    r.setEType(type);
+    if (opts.many) r.setUpperBound(-1);
+    if (opts.containment) r.setContainment(true);
+    if (opts.changeable === false) r.setChangeable(false);
+    if (opts.volatile) r.setVolatile(true);
+    if (opts.transient) r.setTransient(true);
+    if (opts.derived) r.setDerived(true);
+    r.setEContainingClass(owner);
+    owner.getEStructuralFeatures().add(r);
+    return r;
+  }
+  const eAnnotations = ref(eModelElement, "eAnnotations", eAnnotation, { many: true, containment: true });
+  attr(eAnnotation, "source", p("EString"));
+  ref(eAnnotation, "details", eStringToStringMapEntry, { many: true, containment: true });
+  const annotation_eModelElement = ref(eAnnotation, "eModelElement", eModelElement, { transient: true });
+  ref(eAnnotation, "contents", eObject, { many: true, containment: true });
+  ref(eAnnotation, "references", eObject, { many: true });
+  attr(eNamedElement, "name", p("EString"));
+  attr(eTypedElement, "ordered", p("EBoolean"));
+  attr(eTypedElement, "unique", p("EBoolean"));
+  attr(eTypedElement, "lowerBound", p("EInt"));
+  attr(eTypedElement, "upperBound", p("EInt"));
+  attr(eTypedElement, "many", p("EBoolean"), { changeable: false, volatile: true, transient: true, derived: true });
+  attr(eTypedElement, "required", p("EBoolean"), { changeable: false, volatile: true, transient: true, derived: true });
+  const eType = ref(eTypedElement, "eType", eClassifier, { volatile: true });
+  ref(eTypedElement, "eGenericType", eGenericType, { containment: true, volatile: true });
+  const classifier_ePackage = ref(eClassifier, "ePackage", ePackage, { changeable: false, transient: true });
+  ref(eClassifier, "eTypeParameters", eTypeParameter, { many: true, containment: true });
+  attr(eClassifier, "instanceClassName", p("EString"), { volatile: true });
+  attr(eClassifier, "instanceClass", p("EJavaClass"), {
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  attr(eClassifier, "defaultValue", p("EJavaObject"), {
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  attr(eClassifier, "instanceTypeName", p("EString"), { volatile: true });
+  attr(eStructuralFeature, "changeable", p("EBoolean"));
+  attr(eStructuralFeature, "volatile", p("EBoolean"));
+  attr(eStructuralFeature, "transient", p("EBoolean"));
+  attr(eStructuralFeature, "defaultValueLiteral", p("EString"));
+  attr(eStructuralFeature, "defaultValue", p("EJavaObject"), {
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  attr(eStructuralFeature, "unsettable", p("EBoolean"));
+  attr(eStructuralFeature, "derived", p("EBoolean"));
+  const feature_eContainingClass = ref(eStructuralFeature, "eContainingClass", eClass, {
+    changeable: false,
+    transient: true
+  });
+  attr(eAttribute, "iD", p("EBoolean"));
+  ref(eAttribute, "eAttributeType", eDataType, { changeable: false, volatile: true, transient: true, derived: true });
+  attr(eReference, "containment", p("EBoolean"));
+  attr(eReference, "container", p("EBoolean"), { changeable: false, volatile: true, transient: true, derived: true });
+  attr(eReference, "resolveProxies", p("EBoolean"));
+  const eOpposite = ref(eReference, "eOpposite", eReference, {});
+  ref(eReference, "eReferenceType", eClass, { changeable: false, volatile: true, transient: true, derived: true });
+  ref(eReference, "eKeys", eAttribute, { many: true });
+  attr(eClass, "abstract", p("EBoolean"));
+  attr(eClass, "interface", p("EBoolean"));
+  ref(eClass, "eSuperTypes", eClass, { many: true });
+  const eOperations = ref(eClass, "eOperations", eOperation, { many: true, containment: true });
+  ref(eClass, "eAllAttributes", eAttribute, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  ref(eClass, "eAllReferences", eReference, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  ref(eClass, "eReferences", eReference, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  ref(eClass, "eAttributes", eAttribute, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  ref(eClass, "eAllContainments", eReference, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  ref(eClass, "eAllOperations", eOperation, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  ref(eClass, "eAllStructuralFeatures", eStructuralFeature, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  ref(eClass, "eAllSuperTypes", eClass, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  ref(eClass, "eIDAttribute", eAttribute, { changeable: false, volatile: true, transient: true, derived: true });
+  const eStructuralFeatures = ref(eClass, "eStructuralFeatures", eStructuralFeature, { many: true, containment: true });
+  ref(eClass, "eGenericSuperTypes", eGenericType, { many: true, containment: true });
+  ref(eClass, "eAllGenericSuperTypes", eGenericType, {
+    many: true,
+    changeable: false,
+    volatile: true,
+    transient: true,
+    derived: true
+  });
+  attr(eDataType, "serializable", p("EBoolean"));
+  const eLiterals = ref(eEnum, "eLiterals", eEnumLiteral, { many: true, containment: true });
+  attr(eEnumLiteral, "value", p("EInt"));
+  attr(eEnumLiteral, "instance", p("EEnumerator"), { transient: true });
+  attr(eEnumLiteral, "literal", p("EString"));
+  const eEnumLiteral_eEnum = ref(eEnumLiteral, "eEnum", eEnum, { changeable: false, transient: true });
+  const factory_ePackage = ref(eFactory, "ePackage", ePackage, { transient: true });
+  const operation_eContainingClass = ref(eOperation, "eContainingClass", eClass, {
+    changeable: false,
+    transient: true
+  });
+  ref(eOperation, "eTypeParameters", eTypeParameter, { many: true, containment: true });
+  const eParameters = ref(eOperation, "eParameters", eParameter, { many: true, containment: true });
+  ref(eOperation, "eExceptions", eClassifier, { many: true });
+  ref(eOperation, "eGenericExceptions", eGenericType, { many: true, containment: true });
+  attr(ePackage, "nsURI", p("EString"));
+  attr(ePackage, "nsPrefix", p("EString"));
+  const eFactoryInstance = ref(ePackage, "eFactoryInstance", eFactory, { transient: true });
+  const eClassifiers = ref(ePackage, "eClassifiers", eClassifier, { many: true, containment: true });
+  const eSubpackages = ref(ePackage, "eSubpackages", ePackage, { many: true, containment: true });
+  const eSuperPackage = ref(ePackage, "eSuperPackage", ePackage, { changeable: false, transient: true });
+  const parameter_eOperation = ref(eParameter, "eOperation", eOperation, { changeable: false, transient: true });
+  attr(eStringToStringMapEntry, "key", p("EString"));
+  attr(eStringToStringMapEntry, "value", p("EString"));
+  ref(eGenericType, "eUpperBound", eGenericType, { containment: true });
+  ref(eGenericType, "eTypeArguments", eGenericType, { many: true, containment: true });
+  ref(eGenericType, "eRawType", eClassifier, { changeable: false, transient: true, derived: true });
+  ref(eGenericType, "eLowerBound", eGenericType, { containment: true });
+  ref(eGenericType, "eTypeParameter", eTypeParameter, {});
+  ref(eGenericType, "eClassifier", eClassifier, {});
+  ref(eTypeParameter, "eBounds", eGenericType, { many: true, containment: true });
+  eAnnotations.setEOpposite(annotation_eModelElement);
+  annotation_eModelElement.setEOpposite(eAnnotations);
+  classifier_ePackage.setEOpposite(eClassifiers);
+  eClassifiers.setEOpposite(classifier_ePackage);
+  feature_eContainingClass.setEOpposite(eStructuralFeatures);
+  eStructuralFeatures.setEOpposite(feature_eContainingClass);
+  operation_eContainingClass.setEOpposite(eOperations);
+  eOperations.setEOpposite(operation_eContainingClass);
+  parameter_eOperation.setEOpposite(eParameters);
+  eParameters.setEOpposite(parameter_eOperation);
+  factory_ePackage.setEOpposite(eFactoryInstance);
+  eFactoryInstance.setEOpposite(factory_ePackage);
+  eSubpackages.setEOpposite(eSuperPackage);
+  eSuperPackage.setEOpposite(eSubpackages);
+  eEnumLiteral_eEnum.setEOpposite(eLiterals);
+  eLiterals.setEOpposite(eEnumLiteral_eEnum);
+  void eOpposite;
+  void eType;
+  const pkg = new EPackageImpl2();
+  pkg.setName("ecore");
+  pkg.setNsURI("http://www.eclipse.org/emf/2002/Ecore");
+  pkg.setNsPrefix("ecore");
+  for (const d of primitives.values()) pkg.getEClassifiers().add(d);
+  for (const c of allClasses) pkg.getEClassifiers().add(c);
+  pkg.setEFactoryInstance(new DynamicEFactoryImpl());
+  assignFreshIds(pkg);
+  return {
+    pkg,
+    eObject,
+    eModelElement,
+    eAnnotation,
+    eNamedElement,
+    eTypedElement,
+    eClassifier,
+    eStructuralFeature,
+    eAttribute,
+    eReference,
+    eClass,
+    ePackage,
+    eDataType,
+    eEnum,
+    eEnumLiteral,
+    eFactory,
+    eOperation,
+    eParameter,
+    eStringToStringMapEntry,
+    eGenericType,
+    eTypeParameter
+  };
+}
+
+// src/ecore-loader.ts
+async function loadEcorePackage(ecoreFilePath) {
+  void EcorePackageImpl2.eINSTANCE;
+  const resourceSet = new ResourceSetImpl();
+  resourceSet.getUriConverterRegistry().register(new NodeFileUriConverter());
+  registerXmiFormat(resourceSet.getResourceFactoryRegistry());
+  const metaSchema = buildEcoreMetaSchema();
+  resourceSet.getPackageRegistry().register(metaSchema.pkg);
+  const uri = URI.createFileURI(ecoreFilePath);
+  const resource = await resourceSet.getResource(uri, true);
+  if (!resource) {
+    throw new Error(`Could not load '${ecoreFilePath}'.`);
+  }
+  const roots = resource.getContents().toArray();
+  const dynamicPkg = roots[0];
+  if (!dynamicPkg) {
+    throw new Error(`'${ecoreFilePath}' has no root element - expected a single EPackage.`);
+  }
+  return convertDynamicEcoreToTyped(dynamicPkg);
+}
+
+// src/generate.ts
+import nunjucks from "nunjucks";
+
+// src/file-extension.ts
+var FileExtension = class {
+  constructor(postProcess) {
+    this.postProcess = postProcess;
+  }
+  postProcess;
+  tags = ["file"];
+  collected = [];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parse(parser, nodes) {
+    const tok = parser.nextToken();
+    const pathExpr = parser.parseExpression();
+    parser.advanceAfterBlockEnd(tok.value);
+    const body = parser.parseUntilBlocks("endfile");
+    parser.advanceAfterBlockEnd();
+    return new nodes.CallExtensionAsync(this, "run", new nodes.NodeList(tok.lineno, tok.colno, [pathExpr]), [body]);
+  }
+  run(_context, path, body, callback) {
+    body((err, content) => {
+      if (err) {
+        callback(err, "");
+        return;
+      }
+      this.collected.push({ path, content: this.postProcess ? this.postProcess(path, content) : content });
+      callback(null, "");
+    });
+  }
+  /** Everything collected so far in this Environment's lifetime. */
+  getCollected() {
+    return this.collected;
+  }
+};
+
+// src/generate.ts
+function generate(pkg, templateSet, options = {}) {
+  assignFreshIds(pkg);
+  const problems = templateSet.validate?.(pkg) ?? [];
+  if (problems.length > 0) {
+    throw new Error(
+      `Cannot generate from this package - ${templateSet.name} found ${problems.length} unresolved problem(s):
+` + problems.map((p) => `  - ${p}`).join("\n")
+    );
+  }
+  const loader = new nunjucks.FileSystemLoader(templateSet.baseFolder, { noCache: true });
+  const env = new nunjucks.Environment(loader, { autoescape: false, trimBlocks: true, lstripBlocks: true });
+  const fileExtension = new FileExtension(
+    templateSet.postProcessFile ? (path, content) => templateSet.postProcessFile(path, content, options) : void 0
+  );
+  env.addExtension("file", fileExtension);
+  env.addGlobal("package", pkg);
+  env.addGlobal("options", options);
+  templateSet.configureEnvironment?.(env, { pkg, options });
+  env.render("main.njk");
+  return fileExtension.getCollected();
+}
+
+// src/run-generation.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join2, resolve } from "path";
+
+// src/typescript-template-set.ts
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+// src/type-import-mapping.ts
+import { detailValue } from "@typemf/core";
+var IMPORT_ANNOTATION_SOURCE = "https://typemf.dev/generator/import";
+var nonEmpty = (value) => value !== void 0 && value !== "" ? value : void 0;
+function info(type, from, internalFrom) {
+  const result = { type };
+  if (from !== void 0) result.from = from;
+  if (internalFrom !== void 0) result.internalFrom = internalFrom;
+  return result;
+}
+function importInfoOf(details) {
+  const type = nonEmpty(details && detailValue(details, "type"));
+  if (type === void 0) return void 0;
+  return info(
+    type,
+    nonEmpty(details && detailValue(details, "from")),
+    nonEmpty(details && detailValue(details, "internal-from"))
+  );
+}
+function readImportAnnotation(element) {
+  return importInfoOf(element.getEAnnotation(IMPORT_ANNOTATION_SOURCE)?.getDetails());
+}
+function readImportAnnotations(element) {
+  const result = [];
+  for (const annotation of element.getEAnnotations()) {
+    if (annotation.getSource() !== IMPORT_ANNOTATION_SOURCE) continue;
+    const entry = importInfoOf(annotation.getDetails());
+    if (entry !== void 0) result.push(entry);
+  }
+  return result;
+}
+var TypeImportMapping = class _TypeImportMapping {
+  explicit = /* @__PURE__ */ new Map();
+  constructor(entries = {}) {
+    for (const [key, entry] of Object.entries(entries)) {
+      const type = nonEmpty(entry.type);
+      if (type !== void 0) this.set(key, info(type, nonEmpty(entry.from), nonEmpty(entry["internal-from"])));
+    }
+  }
+  static keyOf(classifier) {
+    return `${classifier.getEPackage()?.getNsURI() ?? ""}#${classifier.getName()}`;
+  }
+  set(key, value) {
+    this.explicit.set(key, value);
+  }
+  lookup(classifier) {
+    return this.explicit.get(_TypeImportMapping.keyOf(classifier)) ?? readImportAnnotation(classifier);
+  }
+};
+
+// src/generation-context.ts
+var generationContext = { pkg: void 0, typeImports: new TypeImportMapping() };
+var TYPE_IMPORTS_OPTION = "type-imports";
+function beginGeneration(pkg, options) {
+  generationContext.pkg = pkg;
+  const entries = options[TYPE_IMPORTS_OPTION];
+  const valid = typeof entries === "object" && entries !== null && !Array.isArray(entries);
+  generationContext.typeImports = new TypeImportMapping(valid ? entries : {});
+}
+function isExternal(classifier) {
+  const owner = classifier.getEPackage();
+  return generationContext.pkg !== void 0 && owner !== void 0 && owner !== generationContext.pkg;
+}
+
+// src/import-collector.ts
+import { posix } from "path";
+function relativeImportPath(from, to, file) {
+  if (from === to) return `./${file}.js`;
+  if (from === "root") return `./${to}/${file}.js`;
+  if (to === "root") return `../${file}.js`;
+  return `../${to}/${file}.js`;
+}
+var ImportCollector = class {
+  /**
+   * Every distinct way each name has been requested. Usually one; more
+   * than one is only a problem if, once the mode and importing folder are
+   * known (render time), they resolve to genuinely different modules.
+   */
+  entries = /* @__PURE__ */ new Map();
+  add(entry) {
+    const variants = this.entries.get(entry.name) ?? [];
+    const sameSource = variants.findIndex(
+      (v) => v.location === entry.location && (v.file ?? v.name) === (entry.file ?? entry.name) && v.from === entry.from
+    );
+    if (sameSource >= 0) {
+      if (entry.foundational && !variants[sameSource].foundational) variants[sameSource] = entry;
+    } else {
+      variants.push(entry);
+    }
+    this.entries.set(entry.name, variants);
+  }
+  clear() {
+    this.entries.clear();
+  }
+  isEmpty() {
+    return this.entries.size === 0;
+  }
+  render(currentLocation, options) {
+    const generateEcore = Boolean(options["generate-ecore"]);
+    const corePackageNames = [];
+    const groups = /* @__PURE__ */ new Map();
+    const addToGroup = (key, specifier, name) => {
+      if (!groups.has(key)) groups.set(key, { specifier, names: [] });
+      groups.get(key).names.push(name);
+    };
+    for (const name of [...this.entries.keys()].sort((a, b) => a.localeCompare(b))) {
+      const resolved = this.entries.get(name).map((entry) => ({ entry, ...resolveEntry(entry, currentLocation, generateEcore) }));
+      const distinct = new Set(resolved.map((r) => r.specifier.replace(/\.(js|ts)$/, "")));
+      if (distinct.size > 1) {
+        throw new Error(
+          `Import collision while generating: "${name}" was requested from ${resolved.map((r) => `"${r.specifier}"`).join(" and ")}. A single name must resolve to exactly one real source.`
+        );
+      }
+      const chosen = resolved.find((r) => r.entry.from !== void 0) ?? resolved[0];
+      if (chosen.core) corePackageNames.push(name);
+      else addToGroup(chosen.key, chosen.specifier, name);
+    }
+    const lines = [];
+    if (corePackageNames.length > 0) {
+      lines.push(`import { ${corePackageNames.join(", ")} } from '@typemf/core';`);
+    }
+    for (const key of [...groups.keys()].sort()) {
+      const { specifier, names } = groups.get(key);
+      lines.push(`import { ${names.join(", ")} } from '${specifier}';`);
+    }
+    return lines.join("\n");
+  }
+};
+function resolveEntry(entry, currentLocation, generateEcore) {
+  if (entry.from !== void 0) {
+    const specifier = explicitImportSpecifier(entry.from, currentLocation);
+    return { specifier, key: `~${specifier}`, core: specifier === "@typemf/core" };
+  }
+  if (entry.foundational && !generateEcore) return { specifier: "@typemf/core", key: "@typemf/core", core: true };
+  const file = entry.file ?? entry.name;
+  return {
+    specifier: relativeImportPath(currentLocation, entry.location, file),
+    key: `${entry.location}/${file}`,
+    core: false
+  };
+}
+function explicitImportSpecifier(from, currentLocation) {
+  if (!from.startsWith("./") && !from.startsWith("../")) return from;
+  const fromDir = posix.join("/pkg", currentLocation === "root" ? "" : currentLocation);
+  const relative = posix.relative(fromDir, posix.join("/pkg", from));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+var importCollector = new ImportCollector();
+function locationOfPath(path) {
+  if (path.startsWith("types/")) return "types";
+  if (path.startsWith("impl/")) return "impl";
+  if (path.startsWith("util/")) return "util";
+  return "root";
+}
+
+// src/typescript-filters.ts
+import {
+  detailValue as detailValue2
+} from "@typemf/core";
+var TYPEMF_GENERATOR_ANNOTATION_SOURCE = "https://typemf.dev/generator";
+var ECLIPSE_GENMODEL_ANNOTATION_SOURCE = "http://www.eclipse.org/emf/2002/GenModel";
+var ECLIPSE_ECORE_ANNOTATION_SOURCE = "http://www.eclipse.org/emf/2002/Ecore";
+function layeredAnnotationDetail(element, key, fallbackSource) {
+  for (const source of [TYPEMF_GENERATOR_ANNOTATION_SOURCE, fallbackSource]) {
+    const details = element.getEAnnotation(source)?.getDetails();
+    const value = details && detailValue2(details, key);
+    if (value !== void 0 && value !== "") return value;
+  }
+  return void 0;
+}
+function documentationOf(element) {
+  return layeredAnnotationDetail(element, "documentation", ECLIPSE_ECORE_ANNOTATION_SOURCE);
+}
+function docComment(element, indent = "") {
+  const doc = documentationOf(element);
+  if (!doc) return "";
+  const lines = doc.trim().split("\n");
+  if (lines.length === 1) {
+    return `${indent}/** ${lines[0]} */`;
+  }
+  const body = lines.map((line) => `${indent} * ${line}`).join("\n");
+  return `${indent}/**
+${body}
+${indent} */`;
+}
+function operationBody(operation) {
+  return layeredAnnotationDetail(operation, "body", ECLIPSE_GENMODEL_ANNOTATION_SOURCE);
+}
+var FEATURE_ANNOTATION_SOURCE = "https://typemf.dev/generator/feature";
+function featureDetail(feature, key) {
+  const details = feature.getEAnnotation(FEATURE_ANNOTATION_SOURCE)?.getDetails();
+  const value = details && detailValue2(details, key);
+  return value !== void 0 && value !== "" ? value : void 0;
+}
+function featureGetter(feature) {
+  return featureDetail(feature, "get");
+}
+function featureSetter(feature) {
+  return featureDetail(feature, "set");
+}
+function customBodyNeedsOwnField(feature) {
+  const getter = featureGetter(feature);
+  const setter = featureSetter(feature);
+  if (!getter && !setter) return false;
+  const ownFieldRef = new RegExp(`\\bthis\\._${feature.getName()}\\b`);
+  return getter !== void 0 && ownFieldRef.test(getter) || setter !== void 0 && ownFieldRef.test(setter);
+}
+function isReadOnlyFeature(feature) {
+  return trivialDerivedFormula(feature) !== void 0 || featureGetter(feature) !== void 0 && featureSetter(feature) === void 0;
+}
+function needsImplOnlySetter(feature) {
+  return !isReadOnlyFeature(feature) && !feature.isChangeable();
+}
+function findFeatureAnnotationProblems(pkg) {
+  const problems = [];
+  for (const classifier of pkg.getEClassifiers()) {
+    if (!isEClass2(classifier)) continue;
+    for (const feature of classifier.getEStructuralFeatures()) {
+      if (feature.isMany() && featureSetter(feature) !== void 0) {
+        problems.push(
+          `${classifier.getName()}.${feature.getName()}: has a \`set\` annotation, but is many-valued - many-valued features never have a setter, so it is ignored`
+        );
+      }
+    }
+  }
+  return problems;
+}
+var TRIVIAL_DERIVED_FORMULAS = {
+  many: "this.getUpperBound() === -1 || this.getUpperBound() > 1",
+  // Verified directly against real EMF's own ETypedElementImpl.isRequired()
+  // source (org.eclipse.emf.ecore.impl) while implementing the equivalent
+  // reflective dispatch in @typemf/core: it is exactly `lowerBound >= 1`,
+  // with NO `!many` check. An earlier version of this formula incorrectly
+  // added one; caught only because the hand-written @typemf/core port
+  // (built independently, then checked against the same source) disagreed
+  // with this file.
+  required: "this.getLowerBound() >= 1",
+  container: "(this.getEOpposite()?.isContainment() ?? false)",
+  eReferenceType: "(this.getEType() as EClass | undefined)",
+  eAttributeType: "(this.getEType() as EDataType | undefined)"
+};
+function trivialDerivedFormula(feature) {
+  if (!feature.isDerived()) return void 0;
+  return TRIVIAL_DERIVED_FORMULAS[feature.getName()];
+}
+function tsScalarType(type) {
+  if (type !== void 0 && isTypedElement(type)) return tsTypeReference(type.getEType(), type.getEGenericType());
+  return tsTypeReference(type, void 0);
+}
+function isTypedElement(x) {
+  return "getEType" in x;
+}
+function tsTypeReference(classifier, genericType) {
+  const base = tsBaseType(classifier);
+  const parameterCount = classifier?.getETypeParameters().size() ?? 0;
+  if (parameterCount === 0) return base;
+  const given = genericType?.getETypeArguments();
+  const args = [];
+  for (let i = 0; i < parameterCount; i++) {
+    const argument = given !== void 0 && i < given.size() ? given.get(i) : void 0;
+    args.push(argument === void 0 ? "unknown" : tsGenericArgument(argument));
+  }
+  return `${base}<${args.join(", ")}>`;
+}
+function tsGenericArgument(argument) {
+  const classifier = argument.getEClassifier();
+  if (classifier) return tsTypeReference(classifier, argument);
+  const parameter = argument.getETypeParameter();
+  if (parameter) return parameter.getName();
+  return "unknown";
+}
+function genericArgumentClassifiers(genericType) {
+  const result = [];
+  const visit = (gt) => {
+    for (const argument of gt.getETypeArguments()) {
+      const classifier = argument.getEClassifier();
+      if (classifier) result.push(classifier);
+      visit(argument);
+    }
+  };
+  if (genericType) visit(genericType);
+  return result;
+}
+function tsBaseType(classifier) {
+  if (!classifier) {
+    importCollector.add({ name: "EObject", location: "types", foundational: true });
+    return "EObject";
+  }
+  if (isEDataType(classifier)) return tsPrimitiveType(classifier);
+  return classifier.getName();
+}
+function resolveDataTypeTs(dataType) {
+  const resolved = resolveDataTypeText(dataType);
+  const importInfo = generationContext.typeImports.lookup(dataType);
+  if (importInfo !== void 0) {
+    const source = isExternal(dataType) ? importInfo.from : importInfo.internalFrom ?? importInfo.from;
+    if (source !== void 0) return { ...resolved, importName: importInfo.type, importFrom: source };
+  }
+  return resolved;
+}
+function resolveDataTypeText(dataType) {
+  const ownDetails = dataType.getEAnnotation(TYPEMF_GENERATOR_ANNOTATION_SOURCE)?.getDetails();
+  const annotated = ownDetails && detailValue2(ownDetails, "type");
+  if (annotated !== void 0 && annotated !== "") return { text: annotated };
+  const instanceClassName = dataType.getInstanceClassName();
+  if (instanceClassName !== void 0 && instanceClassName !== "") return { text: instanceClassName };
+  return { text: dataType.getName() };
+}
+function registerBodyImports(element) {
+  for (const entry of readImportAnnotations(element)) {
+    const source = entry.internalFrom ?? entry.from;
+    if (source !== void 0)
+      importCollector.add({ name: entry.type, location: "root", foundational: false, from: source });
+  }
+  return "";
+}
+function tsPrimitiveType(dataType) {
+  const resolved = resolveDataTypeTs(dataType);
+  if (resolved.importName !== void 0 && resolved.importFrom !== void 0) {
+    importCollector.add({
+      name: resolved.importName,
+      location: "root",
+      foundational: false,
+      from: resolved.importFrom
+    });
+  }
+  return resolved.text;
+}
+var PRIMITIVE_VALUE_DATATYPE_NAMES = /* @__PURE__ */ new Set(["EBoolean", "EInt", "ELong", "EFloat", "EDouble", "EShort", "EByte"]);
+function isPrimitiveValueType(classifier) {
+  return classifier !== void 0 && isEDataType(classifier) && PRIMITIVE_VALUE_DATATYPE_NAMES.has(classifier.getName());
+}
+function primitiveDefaultValue(feature) {
+  const literal = "getDefaultValueLiteral" in feature ? feature.getDefaultValueLiteral() : void 0;
+  if (literal !== void 0 && literal !== "") return literal;
+  const classifier = feature.getEType();
+  return classifier?.getName() === "EBoolean" ? "false" : "0";
+}
+function tsOptionalScalarType(type) {
+  const scalar = tsScalarType(type);
+  const classifier = type !== void 0 && isTypedElement(type) ? type.getEType() : type;
+  if (classifier && isPrimitiveValueType(classifier)) return scalar;
+  if (scalar === "unknown") return scalar;
+  return `${scalar} | undefined`;
+}
+function beanGetterName(feature) {
+  const type = feature.getEType();
+  if (!feature.isMany() && type && type.getName() === "EBoolean") {
+    return `is${ucfirst(feature.getName())}`;
+  }
+  return `get${ucfirst(feature.getName())}`;
+}
+function tsFeatureType(feature) {
+  const scalar = tsScalarType(feature);
+  if ("isMany" in feature && feature.isMany()) {
+    return `EList<${scalar}>`;
+  }
+  return scalar;
+}
+function isOptional(feature) {
+  return !feature.isRequired();
+}
+function isEClass2(classifier) {
+  return "getEStructuralFeatures" in classifier;
+}
+function isEEnum(classifier) {
+  return "getELiterals" in classifier;
+}
+function isEDataType(classifier) {
+  return !isEClass2(classifier) && !isEEnum(classifier);
+}
+function isEReference(feature) {
+  return "isContainment" in feature;
+}
+function paramList(operation) {
+  return operation.getEParameters().toArray().map((p) => `${p.getName()}: ${tsFeatureType(p)}`).join(", ");
+}
+function optionalParamList(operation) {
+  return operation.getEParameters().toArray().map((p) => `${p.getName()}?: ${tsFeatureType(p)}`).join(", ");
+}
+function argList(operation) {
+  return operation.getEParameters().toArray().map((p) => p.getName()).join(", ");
+}
+function groupOperationsByName(operations) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    const list = groups.get(op.getName());
+    if (list) list.push(op);
+    else groups.set(op.getName(), [op]);
+  }
+  return [...groups.values()];
+}
+function mergeNames(names) {
+  const unique = [...new Set(names)];
+  return unique[0] + unique.slice(1).map((n) => `Or${ucfirst(n)}`).join("");
+}
+function mergedParams(group) {
+  const arity = Math.max(...group.map((op) => op.getEParameters().size()));
+  const params = [];
+  for (let i = 0; i < arity; i++) {
+    const having = group.filter((op) => op.getEParameters().size() > i);
+    params.push({
+      name: mergeNames(having.map((op) => op.getEParameters().get(i).getName())),
+      type: [...new Set(having.map((op) => tsFeatureType(op.getEParameters().get(i))))].join(" | "),
+      optional: having.length < group.length
+    });
+  }
+  return params;
+}
+function mergedParamList(group) {
+  const first = group[0];
+  if (group.length === 1) return paramList(first);
+  return mergedParams(group).map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ");
+}
+function primitiveTest(name, tsText) {
+  return ["string", "number", "boolean", "bigint"].includes(tsText) ? `typeof ${name} === '${tsText}'` : void 0;
+}
+function codeOnly(source) {
+  let out = "";
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const c = source[i];
+    const next = source[i + 1];
+    if (c === "/" && next === "/") {
+      while (i < n && source[i] !== "\n") i++;
+    } else if (c === "/" && next === "*") {
+      const end = source.indexOf("*/", i + 2);
+      i = end === -1 ? n : end + 2;
+    } else if (c === "'" || c === '"') {
+      i++;
+      while (i < n && source[i] !== c) i += source[i] === "\\" ? 2 : 1;
+      i++;
+      out += " ";
+    } else if (c === "`") {
+      i++;
+      while (i < n && source[i] !== "`") {
+        if (source[i] === "\\") i += 2;
+        else if (source[i] === "$" && source[i + 1] === "{") {
+          let depth = 1;
+          i += 2;
+          while (i < n && depth > 0) {
+            if (source[i] === "{") depth++;
+            else if (source[i] === "}") depth--;
+            if (depth > 0) out += source[i];
+            i++;
+          }
+          out += " ";
+        } else i++;
+      }
+      i++;
+      out += " ";
+    } else {
+      out += c;
+      i++;
+    }
+  }
+  return out;
+}
+var escapeForSingleQuotes = (text) => text.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+function overloadDispatch(group, className) {
+  const name = group[0].getName();
+  const stub = (why) => ({
+    branches: [],
+    stubMessage: escapeForSingleQuotes(`${className}.${name}() is overloaded and ${why} - nothing to generate.`)
+  });
+  if (!group.some((op) => operationBody(op) !== void 0))
+    return stub("none of its overloads has a `body` annotation");
+  const merged = mergedParams(group);
+  const branches = [];
+  for (const op of group) {
+    const params = [...op.getEParameters()];
+    const label = `${className}.${name}(${params.map((p) => p.getName()).join(", ")})`;
+    const dispatchDetails = op.getEAnnotation(TYPEMF_GENERATOR_ANNOTATION_SOURCE)?.getDetails();
+    let condition = dispatchDetails && detailValue2(dispatchDetails, "dispatch");
+    if (condition === void 0 || condition === "") {
+      const parts = [];
+      for (let i = 0; i < merged.length; i++) {
+        const m = merged[i];
+        const own = params[i];
+        if (own === void 0) {
+          parts.push(`${m.name} === undefined`);
+          continue;
+        }
+        const havingTypes = new Set(
+          group.filter((o) => o.getEParameters().size() > i).map((o) => tsFeatureType(o.getEParameters().get(i)))
+        );
+        if (havingTypes.size > 1) {
+          const test = "isMany" in own && own.isMany() ? void 0 : primitiveTest(m.name, tsScalarType(own));
+          if (test === void 0) {
+            return stub(
+              `cannot be dispatched: the parameter \`${own.getName()}\` of ${label} has type ${tsFeatureType(own)}, which has no runtime test - add a \`dispatch\` detail to the overload`
+            );
+          }
+          parts.push(test);
+        } else if (m.optional) {
+          parts.push(`${m.name} !== undefined`);
+        }
+      }
+      condition = parts.join(" && ");
+    }
+    const body = operationBody(op);
+    const code = body === void 0 ? "" : codeOnly(body);
+    const aliases = body === void 0 ? [] : params.flatMap((p, i) => {
+      const merged_i = merged[i];
+      const own = p.getName();
+      return own !== merged_i.name && new RegExp(`(?<![\\w$])${own.replace(/[$]/g, "\\$")}(?![\\w$])`).test(code) ? [`const ${own} = ${merged_i.name} as ${tsFeatureType(p)};`] : [];
+    });
+    branches.push({ operation: op, condition, body, aliases, label });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const b of branches) {
+    const earlier = seen.get(b.condition);
+    if (earlier !== void 0 || b.condition === "") {
+      return stub(
+        `cannot be dispatched: ${earlier ?? b.label} and ${b.label} have the same dispatch condition (${b.condition === "" ? "none" : b.condition}), so they cannot be told apart at runtime - add a \`dispatch\` detail`
+      );
+    }
+    seen.set(b.condition, b.label);
+  }
+  return { branches };
+}
+function tsOperationReturnType(op) {
+  const scalar = tsScalarType(op);
+  if (isPrimitiveValueType(op.getEType())) return scalar;
+  if (op.isRequired()) return scalar;
+  if (scalar === "unknown") return scalar;
+  return `${scalar} | undefined`;
+}
+function mergedReturnType(group) {
+  return [...new Set(group.map((op) => tsOperationReturnType(op)))].join(" | ");
+}
+function ucfirst(s) {
+  return s.length === 0 ? s : s.charAt(0).toUpperCase() + s.slice(1);
+}
+function packageClassName(pkg) {
+  return `${ucfirst(pkg.getName())}Package`;
+}
+function factoryClassName(pkg) {
+  return `${ucfirst(pkg.getName())}Factory`;
+}
+function switchClassName(pkg) {
+  return `${ucfirst(pkg.getName())}Switch`;
+}
+function typeGuardsClassName(pkg) {
+  return `${ucfirst(pkg.getName())}TypeGuards`;
+}
+function superType(eClass) {
+  const supers = eClass.getESuperTypes();
+  return supers.size() > 0 ? supers.get(0) : void 0;
+}
+function superTypeChain(eClass) {
+  const chain = [eClass];
+  let current = superType(eClass);
+  while (current) {
+    chain.push(current);
+    current = superType(current);
+  }
+  return chain;
+}
+function isClassifierDerived(eClass) {
+  return superTypeChain(eClass).some((c) => c.getName() === "EClassifier");
+}
+function isStructuralFeatureDerived(eClass) {
+  return superTypeChain(eClass).some((c) => c.getName() === "EStructuralFeature");
+}
+function isOperationDerived(eClass) {
+  return superTypeChain(eClass).some((c) => c.getName() === "EOperation");
+}
+function isBookkeepingOperation(op, eClass) {
+  if (op.getName() === "getClassifierID" && op.getEParameters().isEmpty() && isClassifierDerived(eClass)) return true;
+  if (op.getName() === "getFeatureID" && op.getEParameters().isEmpty() && isStructuralFeatureDerived(eClass))
+    return true;
+  if (op.getName() === "getOperationID" && op.getEParameters().isEmpty() && isOperationDerived(eClass)) return true;
+  if (op.getName() === "getContainerClass" && op.getEParameters().isEmpty() && isStructuralFeatureDerived(eClass))
+    return true;
+  return false;
+}
+function metaclassAccessorCollision(classifierName, pkg) {
+  const ePackageClassifier = [...pkg.getEClassifiers()].find((c) => c.getName() === "EPackage" && isEClass2(c));
+  if (!ePackageClassifier) return void 0;
+  const accessorName = "get" + classifierName;
+  for (const ancestor of superTypeChain(ePackageClassifier)) {
+    for (const op of ancestor.getEOperations()) {
+      if (op.getName() === accessorName) return op;
+    }
+  }
+  return void 0;
+}
+function metaclassAccessorCollisionTypeNames(pkg) {
+  const names = /* @__PURE__ */ new Set();
+  const maybeAdd = (type) => {
+    if (type && (isEClass2(type) || isEEnum(type))) names.add(type.getName());
+  };
+  for (const classifier of pkg.getEClassifiers()) {
+    const collision = metaclassAccessorCollision(classifier.getName(), pkg);
+    if (!collision) continue;
+    maybeAdd(collision.getEType());
+    for (const param of collision.getEParameters()) maybeAdd(param.getEType());
+  }
+  return [...names];
+}
+function findUnnamedElements(pkg) {
+  const problems = [];
+  const check = (element, kind, where) => {
+    if (element.getName() === void 0) problems.push(`${where}: a ${kind} with no name`);
+  };
+  for (const classifier of pkg.getEClassifiers()) {
+    check(classifier, "classifier", pkg.getName() ?? "(this package)");
+    if (isEClass2(classifier)) {
+      for (const feature of classifier.getEStructuralFeatures())
+        check(feature, "feature", classifier.getName() ?? "(unnamed classifier)");
+      for (const op of classifier.getEOperations()) {
+        check(op, "operation", classifier.getName() ?? "(unnamed classifier)");
+        for (const param of op.getEParameters())
+          check(
+            param,
+            "parameter",
+            `${classifier.getName() ?? "(unnamed classifier)"}.${op.getName() ?? "(unnamed operation)"}`
+          );
+      }
+    } else if (isEEnum(classifier)) {
+      for (const literal of classifier.getELiterals())
+        check(literal, "enum literal", classifier.getName() ?? "(unnamed classifier)");
+    }
+  }
+  return problems;
+}
+function findUnresolvedCollisions(pkg) {
+  const packageClassifierName = "EPackage";
+  const isSelfHosting = [...pkg.getEClassifiers()].some((c) => c.getName() === packageClassifierName && isEClass2(c));
+  const classifiers = [...pkg.getEClassifiers()].filter(isEClass2);
+  const results = [];
+  function scan(chainRoot, label, extra) {
+    const chain = superTypeChain(chainRoot);
+    const byName2 = /* @__PURE__ */ new Map();
+    const add = (name, source) => {
+      if (!byName2.has(name)) byName2.set(name, []);
+      byName2.get(name).push(source);
+    };
+    for (const [name, source] of extra) add(name, source);
+    for (const anc of chain) {
+      const ancName = anc.getName();
+      for (const f of anc.getEStructuralFeatures()) {
+        add(beanGetterName(f), `${ancName}.${f.getName()} getter`);
+        if (!f.isMany()) {
+          add("set" + f.getName()[0].toUpperCase() + f.getName().slice(1), `${ancName}.${f.getName()} setter`);
+        }
+      }
+      for (const group of groupOperationsByName(anc.getEOperations())) {
+        const op = group[0];
+        if (isBookkeepingOperation(op, anc)) continue;
+        add(op.getName(), `${ancName}.${op.getName()} operation`);
+      }
+      if (isClassifierDerived(anc) && ancName === "EClassifier") {
+        add("getClassifierID", `${ancName} bookkeeping`);
+        add("setClassifierID", `${ancName} bookkeeping`);
+      }
+      if (isStructuralFeatureDerived(anc) && ancName === "EStructuralFeature") {
+        add("getFeatureID", `${ancName} bookkeeping`);
+        add("setFeatureID", `${ancName} bookkeeping`);
+      }
+    }
+    for (const [name, sources] of byName2) {
+      if (sources.length > 1) {
+        results.push({ classifierName: label, memberName: name, sources });
+      }
+    }
+  }
+  for (const c of classifiers) {
+    scan(c, c.getName(), []);
+  }
+  if (isSelfHosting) {
+    const ePackageClassifier = classifiers.find((c) => c.getName() === packageClassifierName);
+    const ownAccessors = [];
+    for (const classifier of pkg.getEClassifiers()) {
+      if (metaclassAccessorCollision(classifier.getName(), pkg)) continue;
+      ownAccessors.push(["get" + classifier.getName(), `EcorePackage.get${classifier.getName()} metaclass accessor`]);
+    }
+    scan(ePackageClassifier, "EcorePackage", ownAccessors);
+  }
+  return results;
+}
+function referencedApiTypes(features, ...excludeTypeNames) {
+  const exclude = new Set(excludeTypeNames);
+  const names = /* @__PURE__ */ new Set();
+  for (const feature of features) {
+    const type = feature.getEType();
+    if (type && (isEReference(feature) || isEEnum(type)) && !exclude.has(type.getName())) names.add(type.getName());
+    for (const argument of genericArgumentClassifiers(feature.getEGenericType())) {
+      if ((isEClass2(argument) || isEEnum(argument)) && !exclude.has(argument.getName()))
+        names.add(argument.getName());
+    }
+  }
+  return [...names];
+}
+function referencedOperationTypes(operations, ...excludeTypeNames) {
+  const exclude = new Set(excludeTypeNames);
+  const names = /* @__PURE__ */ new Set();
+  const maybeAdd = (type) => {
+    if (type && (isEClass2(type) || isEEnum(type)) && !exclude.has(type.getName())) {
+      names.add(type.getName());
+    }
+  };
+  for (const op of operations) {
+    maybeAdd(op.getEType());
+    for (const argument of genericArgumentClassifiers(op.getEGenericType())) maybeAdd(argument);
+    for (const param of op.getEParameters()) {
+      maybeAdd(param.getEType());
+      for (const argument of genericArgumentClassifiers(param.getEGenericType())) maybeAdd(argument);
+    }
+  }
+  return [...names];
+}
+function jsString(value) {
+  if (value === void 0) {
+    throw new Error(
+      "jsString() received undefined - this means required metamodel data (a name, nsURI, nsPrefix, or annotation value) is missing on the source EPackage. JSON.stringify(undefined) is not a string, so this would otherwise silently emit an empty/malformed argument into generated code rather than failing clearly at generation time."
+    );
+  }
+  return JSON.stringify(value);
+}
+function detailsEntries(annotation) {
+  return [...annotation.getDetails()].map((entry) => ({ key: entry.getKey() ?? "", value: entry.getValue() ?? "" }));
+}
+function eClassesOf(pkg) {
+  return pkg.getEClassifiers().toArray().filter((c) => isEClass2(c) && c.getName() !== "EObject");
+}
+function concreteEClassesOf(pkg) {
+  return eClassesOf(pkg).filter((c) => !c.isAbstract());
+}
+function findEClassByName(pkg, name) {
+  return eClassesOf(pkg).find((c) => c.getName() === name);
+}
+function singleValuedFeatures(features) {
+  return [...features].filter((f) => !f.isMany());
+}
+
+// src/typescript-template-set.ts
+var packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+function useImport(name, location, opts) {
+  importCollector.add({ name, location, file: opts.file, foundational: opts.foundational });
+  return name;
+}
+var typescriptTemplateSet = {
+  name: "typescript",
+  baseFolder: join(packageRoot, "templates", "typescript"),
+  validate(pkg) {
+    return [
+      ...findUnnamedElements(pkg),
+      ...findUnresolvedCollisions(pkg).map(
+        (c) => `${c.classifierName}.${c.memberName}: name collision between ${c.sources.join(" and ")}`
+      )
+    ];
+  },
+  configureEnvironment(env, { pkg, options }) {
+    importCollector.clear();
+    beginGeneration(pkg, options);
+    env.addGlobal("docComment", docComment);
+    env.addGlobal("operationBody", operationBody);
+    env.addGlobal("featureGetter", featureGetter);
+    env.addGlobal("featureSetter", featureSetter);
+    env.addGlobal("isReadOnlyFeature", isReadOnlyFeature);
+    env.addGlobal("needsImplOnlySetter", needsImplOnlySetter);
+    env.addGlobal("customBodyNeedsOwnField", customBodyNeedsOwnField);
+    env.addGlobal("registerBodyImports", registerBodyImports);
+    env.addGlobal("overloadDispatch", overloadDispatch);
+    env.addGlobal("tsScalarType", tsScalarType);
+    env.addGlobal("tsFeatureType", tsFeatureType);
+    env.addGlobal("tsOperationReturnType", tsOperationReturnType);
+    env.addGlobal("isOptional", isOptional);
+    env.addGlobal("isEClass", isEClass2);
+    env.addGlobal("isEEnum", isEEnum);
+    env.addGlobal("isEDataType", isEDataType);
+    env.addGlobal("isEReference", isEReference);
+    env.addGlobal("paramList", paramList);
+    env.addGlobal("argList", argList);
+    env.addGlobal("ucfirst", ucfirst);
+    env.addGlobal("packageClassName", packageClassName);
+    env.addGlobal("factoryClassName", factoryClassName);
+    env.addGlobal("switchClassName", switchClassName);
+    env.addGlobal("superType", superType);
+    env.addGlobal("superTypeChain", superTypeChain);
+    env.addGlobal("referencedApiTypes", referencedApiTypes);
+    env.addGlobal("referencedOperationTypes", referencedOperationTypes);
+    env.addGlobal("eClassesOf", eClassesOf);
+    env.addGlobal("concreteEClassesOf", concreteEClassesOf);
+    env.addGlobal("singleValuedFeatures", singleValuedFeatures);
+    env.addGlobal("trivialDerivedFormula", trivialDerivedFormula);
+    env.addGlobal("findEClassByName", findEClassByName);
+    env.addGlobal("jsString", jsString);
+    env.addGlobal("detailsEntries", detailsEntries);
+    env.addGlobal("beanGetterName", beanGetterName);
+    env.addGlobal("isPrimitiveValueType", isPrimitiveValueType);
+    env.addGlobal("primitiveDefaultValue", primitiveDefaultValue);
+    env.addGlobal("tsOptionalScalarType", tsOptionalScalarType);
+    env.addGlobal("groupOperationsByName", groupOperationsByName);
+    env.addGlobal("mergedParamList", mergedParamList);
+    env.addGlobal("mergedReturnType", mergedReturnType);
+    env.addGlobal("isClassifierDerived", isClassifierDerived);
+    env.addGlobal("isBookkeepingOperation", isBookkeepingOperation);
+    env.addGlobal("metaclassAccessorCollision", metaclassAccessorCollision);
+    env.addGlobal("metaclassAccessorCollisionTypeNames", metaclassAccessorCollisionTypeNames);
+    env.addGlobal("optionalParamList", optionalParamList);
+    env.addGlobal("typeGuardsClassName", typeGuardsClassName);
+    env.addGlobal("useImport", useImport);
+  },
+  postProcessFile(path, content, options) {
+    const header = importCollector.render(locationOfPath(path), options);
+    importCollector.clear();
+    return header ? `${header}
+
+${content}` : content;
+  }
+};
+
+// src/template-set-registry.ts
+var builtinTemplateSets = {
+  typescript: typescriptTemplateSet
+};
+function resolveTemplateSet(name) {
+  const set = builtinTemplateSets[name];
+  if (!set) {
+    const known = Object.keys(builtinTemplateSets).join(", ");
+    throw new Error(`Unknown template set '${name}'. Known built-in sets: ${known}.`);
+  }
+  return set;
+}
+
+// src/run-generation.ts
+async function runGeneration(config, configDir, pkg) {
+  const templateSet = resolveTemplateSet(config.templateSet);
+  const files = generate(pkg, templateSet, config.options);
+  const outputRoot = resolve(configDir, config.outputDir);
+  const writtenPaths = [];
+  for (const file of files) {
+    const fullPath = join2(outputRoot, file.path);
+    await mkdir(dirname2(fullPath), { recursive: true });
+    await writeFile(fullPath, file.content, "utf-8");
+    writtenPaths.push(fullPath);
+  }
+  return { writtenPaths, outputRoot };
+}
+export {
+  ECLIPSE_ECORE_ANNOTATION_SOURCE,
+  ECLIPSE_GENMODEL_ANNOTATION_SOURCE,
+  FEATURE_ANNOTATION_SOURCE,
+  TYPEMF_GENERATOR_ANNOTATION_SOURCE,
+  argList,
+  assignFreshIds,
+  beanGetterName,
+  buildEcoreMetaSchema,
+  concreteEClassesOf,
+  convertDynamicEcoreToTyped,
+  customBodyNeedsOwnField,
+  detailsEntries,
+  docComment,
+  documentationOf,
+  eClassesOf,
+  factoryClassName,
+  featureGetter,
+  featureSetter,
+  findEClassByName,
+  findFeatureAnnotationProblems,
+  findUnnamedElements,
+  findUnresolvedCollisions,
+  generate,
+  genericArgumentClassifiers,
+  groupOperationsByName,
+  isBookkeepingOperation,
+  isClassifierDerived,
+  isEClass2 as isEClass,
+  isEDataType,
+  isEEnum,
+  isEReference,
+  isOperationDerived,
+  isOptional,
+  isPrimitiveValueType,
+  isReadOnlyFeature,
+  isStructuralFeatureDerived,
+  jsString,
+  layeredAnnotationDetail,
+  loadConfig,
+  loadEcorePackage,
+  mergedParamList,
+  mergedReturnType,
+  metaclassAccessorCollision,
+  metaclassAccessorCollisionTypeNames,
+  needsImplOnlySetter,
+  operationBody,
+  optionalParamList,
+  overloadDispatch,
+  packageClassName,
+  paramList,
+  primitiveDefaultValue,
+  referencedApiTypes,
+  referencedOperationTypes,
+  registerBodyImports,
+  resolveDataTypeTs,
+  resolveTemplateSet,
+  runGeneration,
+  singleValuedFeatures,
+  superType,
+  superTypeChain,
+  switchClassName,
+  trivialDerivedFormula,
+  tsFeatureType,
+  tsOperationReturnType,
+  tsOptionalScalarType,
+  tsScalarType,
+  typeGuardsClassName,
+  typescriptTemplateSet,
+  ucfirst
+};
+//# sourceMappingURL=index.js.map