@typemf/generator 0.5.0

package/templates/typescript/epackage.njk

@@ -0,0 +1,438 @@
+{% set pkgClass = packageClassName(package) %}
+{% file pkgClass + ".ts" %}
+{% for name in metaclassAccessorCollisionTypeNames(package) %}
+{% set _ = useImport(name, "types", {foundational: true}) %}
+{% endfor %}
+
+/**
+ * Classifier/feature IDs, as pure numeric literals - safe to import from
+ * anywhere (Factory, Switch) with zero risk of the circular-import hazard
+ * that made a lazy, explicit init() necessary for the singleton itself
+ * (see {{ pkgClass }}Impl.ts) - these are just numbers, never require
+ * constructing anything.
+ */
+export const Ids = {
+{% for classifier in package.getEClassifiers() %}
+  {{ classifier.getName() }}: { self: {{ classifier.getClassifierID() }}{% if isEClass(classifier) %}{% for feature in classifier.getEStructuralFeatures() %}, {{ feature.getName() }}: {{ feature.getFeatureID() }}{% endfor %}{% for op in classifier.getEOperations() %}, op{{ loop.index0 }}: {{ op.getOperationID() }}{% endfor %}{% endif %} },
+{% endfor %}
+} as const;
+
+{{ docComment(package) }}
+export interface {{ pkgClass }} extends {{ useImport("EPackage", "types", {foundational: true}) }} {
+{% for classifier in package.getEClassifiers() %}
+{% set collision = metaclassAccessorCollision(classifier.getName(), package) %}
+{% if isEClass(classifier) %}
+  get{{ classifier.getName() }}(): {{ useImport("EClass", "types", {foundational: true}) }};
+{% if collision %}
+  get{{ classifier.getName() }}({{ paramList(collision) }}): {{ tsOperationReturnType(collision) }};
+{% endif %}
+{% for feature in classifier.getEStructuralFeatures() %}
+  get{{ classifier.getName() }}_{{ ucfirst(feature.getName()) }}(): {{ useImport("EReference", "types", {foundational: true}) if isEReference(feature) else useImport("EAttribute", "types", {foundational: true}) }};
+{% endfor %}
+{% elif isEEnum(classifier) %}
+  get{{ classifier.getName() }}(): {{ useImport("EEnum", "types", {foundational: true}) }};
+{% if collision %}
+  get{{ classifier.getName() }}({{ paramList(collision) }}): {{ tsOperationReturnType(collision) }};
+{% endif %}
+{% else %}
+  get{{ classifier.getName() }}(): {{ useImport("EDataType", "types", {foundational: true}) }};
+{% if collision %}
+  get{{ classifier.getName() }}({{ paramList(collision) }}): {{ tsOperationReturnType(collision) }};
+{% endif %}
+{% endif %}
+{% endfor %}
+}
+{% endfile %}
+{% file "impl/" + pkgClass + "Impl.ts" %}
+{% for name in metaclassAccessorCollisionTypeNames(package) %}
+{% set _ = useImport(name, "types", {foundational: true}) %}
+{% endfor %}
+{% set _ = useImport("EPackageImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EClassImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EAttributeImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EReferenceImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EOperationImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EParameterImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EDataTypeImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EEnumImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EEnumLiteralImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EAnnotationImpl", "impl", {foundational: true}) %}
+{% set _ = useImport("EFactoryImpl", "impl", {foundational: true}) %}
+{% set _ = useImport(pkgClass, "root", {foundational: false}) %}
+{% set _ = useImport("Ids", "root", {file: pkgClass, foundational: false}) %}
+{% set _ = useImport(factoryClassName(package), "root", {foundational: false}) %}
+{% set _ = useImport(factoryClassName(package) + "Impl", "impl", {foundational: false}) %}
+{% set _ = useImport("set" + pkgClass + "Ref", "impl", {file: pkgClass + "Ref", foundational: false}) %}
+
+{#-
+  Emits code reconstructing `element`'s real EAnnotations (source +
+  details) onto the runtime object built at `targetExpr`. Scoped to
+  package/classifier/feature/enum-literal only - EOperations have no
+  runtime representation in the converted metamodel yet, so there's
+  nowhere for an operation-level annotation to attach (see NOTES.md).
+#}
+{#-
+ Both macros exist for one reason: this template is shared between
+ ordinary metamodel generation and self-hosting Ecore.ecore, and only
+ self-hosting has the bootstrap-ordering hazard (a real, confirmed one,
+ not hypothetical - see NOTES.md) that eBasicSetValue/eBootstrapList exist to
+ route around. For an ordinary metamodel, the runtime metaclasses are
+ @typemf/core's own hand-written classes (which don't have
+ eBasicSetValue/eBootstrapList, and don't need to - they're not self-
+ describing), and Ids has no entry for foundational names like
+ "EClassifier"/"EClass" at all unless the metamodel genuinely declares
+ classifiers with those names. So the ordinary, reflective bean setter
+ call is correct and necessary there, and the bypass is correct and
+ necessary here - never both from the same call site.
+#}
+{#- The expression for classifier `c`: its field for a classifier of this package, Ecore's own accessor otherwise. #}
+{% macro classifierExpr(c) -%}
+{%- if c.getEPackage() == package -%}this._{{ c.getName() }}{%- else -%}{{ useImport("EcorePackageImpl", "impl", {foundational: true}) }}.eINSTANCE.get{{ c.getName() }}(){%- endif -%}
+{%- endmacro %}
+{% macro bootstrapSet(targetExpr, beanSetterName, idsExpr, valueExpr) %}
+{% if options['generate-ecore'] %}
+{{ targetExpr }}.eBasicSetValue({{ idsExpr }}, {{ valueExpr }});
+{% else %}
+{{ targetExpr }}.{{ beanSetterName }}({{ valueExpr }});
+{% endif %}
+{% endmacro %}
+
+{% macro bootstrapAdd(targetExpr, beanGetterName, idsExpr, itemExpr) %}
+{% if options['generate-ecore'] %}
+{{ targetExpr }}.eBootstrapList({{ idsExpr }}).add({{ itemExpr }});
+{% else %}
+{{ targetExpr }}.{{ beanGetterName }}().add({{ itemExpr }});
+{% endif %}
+{% endmacro %}
+
+{% macro emitAnnotations(targetExpr, element) %}
+{#- Mode-conditional for a real, structural reason, not just a different method name: self-hosting's
+    generated EAnnotationImpl.ts (and, since the getDetails() migration, @typemf/core's own hand-written
+    one too - both now genuinely EList<EStringToStringMapEntry>, matching real EMF) still differ in HOW
+    a detail gets constructed during BOOTSTRAP specifically - the self-hosting branch bypasses the
+    reflective path entirely (eBasicSetValue/eBootstrapList), for the same bootstrap-ordering reason as
+    everywhere else in this file (the metaclass for EStringToStringMapEntry doesn't exist yet at the
+    point this code runs during self-construction); the ordinary branch has no such ordering problem and
+    uses the real, public API (setDetailValue) directly. #}
+{% for annotation in element.getEAnnotations() %}
+    {
+      const annotation = new EAnnotationImpl();
+{% if annotation.getSource() %}
+{{ bootstrapSet("annotation", "setSource", "Ids.EAnnotation.source", jsString(annotation.getSource())) }}
+{% endif %}
+{% if options['generate-ecore'] %}
+{% for entry in detailsEntries(annotation) %}
+      {
+        const entry = new {{ useImport("EStringToStringMapEntryImpl", "impl", {foundational: true}) }}();
+        entry.eBasicSetValue(Ids.EStringToStringMapEntry.key, {{ jsString(entry.key) }});
+        entry.eBasicSetValue(Ids.EStringToStringMapEntry.value, {{ jsString(entry.value) }});
+        annotation.eBootstrapList(Ids.EAnnotation.details).add(entry);
+      }
+{% endfor %}
+{% else %}
+{% for entry in detailsEntries(annotation) %}
+      {{ useImport("setDetailValue", "root", {foundational: true}) }}(annotation.getDetails(), {{ jsString(entry.key) }}, {{ jsString(entry.value) }});
+{% endfor %}
+{% endif %}
+{{ bootstrapAdd(targetExpr, "getEAnnotations", "Ids.EModelElement.eAnnotations", "annotation") }}
+    }
+{% endfor %}
+{% endmacro %}
+
+{{ docComment(package) }}
+export class {{ pkgClass }}Impl extends EPackageImpl implements {{ pkgClass }} {
+{% for classifier in package.getEClassifiers() %}
+{% if isEClass(classifier) %}
+  private readonly _{{ classifier.getName() }}: EClassImpl;
+{% for feature in classifier.getEStructuralFeatures() %}
+  private readonly _{{ classifier.getName() }}_{{ feature.getName() }}: {{ "EReferenceImpl" if isEReference(feature) else "EAttributeImpl" }};
+{% endfor %}
+{% for op in classifier.getEOperations() %}
+{% set opIndex = loop.index0 %}
+  {#- Indexed by position, not name - operations can be overloaded (the same name, several signatures),
+      so a name alone would collide; position is always unique. #}
+  private readonly _{{ classifier.getName() }}_op{{ opIndex }}: EOperationImpl;
+{% for param in op.getEParameters() %}
+  private readonly _{{ classifier.getName() }}_op{{ opIndex }}_p{{ loop.index0 }}: EParameterImpl;
+{% endfor %}
+{% endfor %}
+{% elif isEEnum(classifier) %}
+  private readonly _{{ classifier.getName() }}: EEnumImpl;
+{% else %}
+  private readonly _{{ classifier.getName() }}: EDataTypeImpl;
+{% endif %}
+{% endfor %}
+
+  private static _instance: {{ pkgClass }}Impl | undefined;
+
+  /**
+   * The one explicit entry point that constructs the singleton - call it
+   * yourself, with your own factory, before anything else in your program
+   * touches {{ pkgClass }}Impl.eINSTANCE, to use a custom factory (e.g. one
+   * overriding createX() to return your own derived classes). Whichever
+   * caller gets here FIRST wins; a later call with a *different* factory
+   * is logged and otherwise ignored, rather than silently replacing an
+   * already-in-use singleton or throwing on a caller who didn't cause the
+   * conflict.
+   */
+  static init(factory?: {{ factoryClassName(package) }}): {{ pkgClass }}Impl {
+    if (!{{ pkgClass }}Impl._instance) {
+      {{ pkgClass }}Impl._instance = new {{ pkgClass }}Impl();
+      {{ pkgClass }}Impl._instance.setEFactoryInstance(factory ?? new {{ factoryClassName(package) }}Impl());
+    } else if (factory) {
+      console.warn(
+        '{{ pkgClass }}Impl.init() called again with a different factory after the singleton already ' +
+          'existed - ignoring the new factory and keeping the existing one.'
+      );
+    }
+    return {{ pkgClass }}Impl._instance;
+  }
+
+  static get eINSTANCE(): {{ pkgClass }}Impl {
+    return {{ pkgClass }}Impl.init();
+  }
+
+  private constructor() {
+    super();
+    // Set immediately, before Pass 1 constructs any classifier (each of
+    // which may need this reference - see {{ pkgClass }}Ref.ts's own doc
+    // comment for why this is a late-bound reference rather than a
+    // direct import of {{ pkgClass }}Impl.
+    set{{ pkgClass }}Ref(this);
+
+    // Pass 1: create every classifier (empty shell - no features/supertypes
+    // yet), so later passes can reference any of them regardless of
+    // declaration order.
+{% for classifier in package.getEClassifiers() %}
+{% if isEClass(classifier) %}
+    this._{{ classifier.getName() }} = new EClassImpl();
+{{ bootstrapSet("this._" + classifier.getName(), "setName", "Ids.ENamedElement.name", jsString(classifier.getName())) }}
+    this._{{ classifier.getName() }}.setClassifierID(Ids.{{ classifier.getName() }}.self);
+{% if classifier.isAbstract() %}
+{{ bootstrapSet("this._" + classifier.getName(), "setAbstract", "Ids.EClass.abstract", "true") }}
+{% endif %}
+{{ emitAnnotations("this._" + classifier.getName(), classifier) }}
+{{ bootstrapAdd("this", "getEClassifiers", "Ids.EPackage.eClassifiers", "this._" + classifier.getName()) }}
+{% elif isEEnum(classifier) %}
+    this._{{ classifier.getName() }} = new EEnumImpl();
+{{ bootstrapSet("this._" + classifier.getName(), "setName", "Ids.ENamedElement.name", jsString(classifier.getName())) }}
+    this._{{ classifier.getName() }}.setClassifierID(Ids.{{ classifier.getName() }}.self);
+{% for literal in classifier.getELiterals() %}
+    {
+      const literal = new EEnumLiteralImpl();
+{{ bootstrapSet("literal", "setName", "Ids.ENamedElement.name", jsString(literal.getName())) }}
+{{ bootstrapSet("literal", "setValue", "Ids.EEnumLiteral.value", literal.getValue()) }}
+{{ bootstrapSet("literal", "setLiteral", "Ids.EEnumLiteral.literal", jsString(literal.getLiteral())) }}
+{{ emitAnnotations("literal", literal) }}
+{% if options['generate-ecore'] %}
+      // No addLiteral() here - this generated EEnumImpl doesn't have that
+      // hand-written convenience method (it's not a reflective feature),
+      // so the list-add and the eEnum backpointer (a real, modeled,
+      // non-changeable opposite - see NOTES.md) are wired manually.
+      this._{{ classifier.getName() }}.eBootstrapList(Ids.EEnum.eLiterals).add(literal);
+      literal.eBasicSetValue(Ids.EEnumLiteral.eEnum, this._{{ classifier.getName() }});
+{% else %}
+      {#- addLiteral() no longer exists - @typemf/core's own EEnumImpl/EEnumLiteralImpl are
+          themselves now generated (self-hosted) classes, properly extending EObjectImpl, so the
+          ordinary getELiterals().add() path correctly wires the eEnum opposite automatically now
+          (the same standard mechanism every other generated opposite-maintained containment
+          reference already relies on) - the old convenience existed specifically to work around
+          hand-written EEnumLiteralImpl NOT extending EObjectImpl, which is no longer true. #}
+      this._{{ classifier.getName() }}.getELiterals().add(literal);
+{% endif %}
+    }
+{% endfor %}
+{{ emitAnnotations("this._" + classifier.getName(), classifier) }}
+{{ bootstrapAdd("this", "getEClassifiers", "Ids.EPackage.eClassifiers", "this._" + classifier.getName()) }}
+{% else %}
+    this._{{ classifier.getName() }} = new EDataTypeImpl();
+{{ bootstrapSet("this._" + classifier.getName(), "setName", "Ids.ENamedElement.name", jsString(classifier.getName())) }}
+    this._{{ classifier.getName() }}.setClassifierID(Ids.{{ classifier.getName() }}.self);
+{{ emitAnnotations("this._" + classifier.getName(), classifier) }}
+{{ bootstrapAdd("this", "getEClassifiers", "Ids.EPackage.eClassifiers", "this._" + classifier.getName()) }}
+{% endif %}
+{% endfor %}
+
+    // Pass 2: attributes/references, now that every classifier (including
+    // ones referenced as a feature's eType) already exists.
+{% for classifier in eClassesOf(package) %}
+{% for feature in classifier.getEStructuralFeatures() %}
+    this._{{ classifier.getName() }}_{{ feature.getName() }} = new {{ "EReferenceImpl" if isEReference(feature) else "EAttributeImpl" }}();
+{% set fieldExpr = "this._" + classifier.getName() + "_" + feature.getName() %}
+{{ bootstrapSet(fieldExpr, "setName", "Ids.ENamedElement.name", jsString(feature.getName())) }}
+{% if feature.getEType() %}
+{{ bootstrapSet(fieldExpr, "setEType", "Ids.ETypedElement.eType", classifierExpr(feature.getEType())) }}
+{% endif %}
+{{ bootstrapSet(fieldExpr, "setLowerBound", "Ids.ETypedElement.lowerBound", feature.getLowerBound()) }}
+{{ bootstrapSet(fieldExpr, "setUpperBound", "Ids.ETypedElement.upperBound", feature.getUpperBound()) }}
+{#- The rest of a feature's own boolean flags - derived/transient/volatile/unsettable/changeable
+    (EStructuralFeature) and ordered/unique (ETypedElement) - were a real, confirmed gap: nothing
+    here ever emitted bootstrap code for them at all, so every self-hosted feature silently fell
+    back to the runtime's own hardcoded field defaults regardless of what the model itself
+    declared. Confirmed directly against EClass.eAllGenericSuperTypes, which the real model marks
+    changeable="false" volatile="true" transient="true" derived="true" but which the generated
+    bootstrap (before this fix) never set any of - a real save/serialize failure downstream in
+    @typemf/xmi (a derived, never-persisted feature being written out as if it were real, stored
+    data) traced all the way back to this single missing set of bootstrapSet calls. Unconditional,
+    matching lowerBound/upperBound's own established pattern just above, rather than conditional
+    on differing from some assumed runtime default - simplest and least likely to silently drift
+    out of sync with whatever the runtime's own defaults happen to be. #}
+{{ bootstrapSet(fieldExpr, "setDerived", "Ids.EStructuralFeature.derived", feature.isDerived()) }}
+{{ bootstrapSet(fieldExpr, "setTransient", "Ids.EStructuralFeature.transient", feature.isTransient()) }}
+{{ bootstrapSet(fieldExpr, "setVolatile", "Ids.EStructuralFeature.volatile", feature.isVolatile()) }}
+{{ bootstrapSet(fieldExpr, "setUnsettable", "Ids.EStructuralFeature.unsettable", feature.isUnsettable()) }}
+{{ bootstrapSet(fieldExpr, "setChangeable", "Ids.EStructuralFeature.changeable", feature.isChangeable()) }}
+{{ bootstrapSet(fieldExpr, "setOrdered", "Ids.ETypedElement.ordered", feature.isOrdered()) }}
+{{ bootstrapSet(fieldExpr, "setUnique", "Ids.ETypedElement.unique", feature.isUnique()) }}
+    {{ fieldExpr }}.setFeatureID(Ids.{{ classifier.getName() }}.{{ feature.getName() }});
+    {#- containerClass: the concrete implementation class the feature is declared on - the closest
+        TypeScript has to Java's own containerClass semantics (Class<?>, e.g. EClassifier.class in the
+        real EMF bootstrap this mirrors). Real EMF uses the DECLARED INTERFACE's class object; TypeScript
+        interfaces don't exist as runtime values at all, so the concrete Impl class - the only thing
+        actually inspectable at runtime here - is the deliberate, disclosed adaptation. #}
+    {{ fieldExpr }}.setContainerClass({{ useImport(classifier.getName() + "Impl", "impl", {foundational: false}) }});
+{{ bootstrapSet(fieldExpr, "setEContainingClass", "Ids.EStructuralFeature.eContainingClass", "this._" + classifier.getName()) }}
+{% if isEReference(feature) %}
+{{ bootstrapSet(fieldExpr, "setContainment", "Ids.EReference.containment", 'true' if feature.isContainment() else 'false') }}
+{% else %}
+{% if feature.isID() %}
+{{ bootstrapSet(fieldExpr, "setID", "Ids.EAttribute.iD", "true") }}
+{% endif %}
+{% endif %}
+{{ emitAnnotations(fieldExpr, feature) }}
+{{ bootstrapAdd("this._" + classifier.getName(), "getEStructuralFeatures", "Ids.EClass.eStructuralFeatures", fieldExpr) }}
+{% endfor %}
+{% endfor %}
+
+    // Pass 2.5: operations and their parameters - real EOperation/EParameter objects, not just the
+    // generated METHODS (which already existed) - eOperations used to be permanently empty at runtime;
+    // this is what actually populates it, the same way pass 2 populates eStructuralFeatures. Kept as
+    // its own pass, after every classifier and feature exists (an operation's return type or a
+    // parameter's type can reference either), rather than folded into the loop above.
+{% for classifier in eClassesOf(package) %}
+{% for op in classifier.getEOperations() %}
+{% set opIndex = loop.index0 %}
+{% set opFieldExpr = "this._" + classifier.getName() + "_op" + opIndex %}
+    {{ opFieldExpr }} = new EOperationImpl();
+{{ bootstrapSet(opFieldExpr, "setName", "Ids.ENamedElement.name", jsString(op.getName())) }}
+{% if op.getEType() %}
+{{ bootstrapSet(opFieldExpr, "setEType", "Ids.ETypedElement.eType", classifierExpr(op.getEType())) }}
+{% endif %}
+{{ bootstrapSet(opFieldExpr, "setEContainingClass", "Ids.EOperation.eContainingClass", "this._" + classifier.getName()) }}
+    {{ opFieldExpr }}.setOperationID(Ids.{{ classifier.getName() }}.op{{ opIndex }});
+{% for param in op.getEParameters() %}
+{% set paramFieldExpr = opFieldExpr + "_p" + loop.index0 %}
+    {{ paramFieldExpr }} = new EParameterImpl();
+{{ bootstrapSet(paramFieldExpr, "setName", "Ids.ENamedElement.name", jsString(param.getName())) }}
+{% if param.getEType() %}
+{{ bootstrapSet(paramFieldExpr, "setEType", "Ids.ETypedElement.eType", classifierExpr(param.getEType())) }}
+{% endif %}
+{{ bootstrapSet(paramFieldExpr, "setLowerBound", "Ids.ETypedElement.lowerBound", param.getLowerBound()) }}
+{{ bootstrapSet(paramFieldExpr, "setUpperBound", "Ids.ETypedElement.upperBound", param.getUpperBound()) }}
+{{ bootstrapSet(paramFieldExpr, "setEOperation", "Ids.EParameter.eOperation", opFieldExpr) }}
+{{ bootstrapAdd(opFieldExpr, "getEParameters", "Ids.EOperation.eParameters", paramFieldExpr) }}
+{% endfor %}
+{% for exception in op.getEExceptions() %}
+{{ bootstrapAdd(opFieldExpr, "getEExceptions", "Ids.EOperation.eExceptions", classifierExpr(exception)) }}
+{% endfor %}
+{{ emitAnnotations(opFieldExpr, op) }}
+{{ bootstrapAdd("this._" + classifier.getName(), "getEOperations", "Ids.EClass.eOperations", opFieldExpr) }}
+{% endfor %}
+{% endfor %}
+
+    // Pass 3: every classifier's owning package (self-referential, so must
+    // come after pass 1 creates them all).
+{% for classifier in package.getEClassifiers() %}
+{{ bootstrapSet("this._" + classifier.getName(), "setEPackage", "Ids.EClassifier.ePackage", "this") }}
+{% endfor %}
+
+    // Pass 4: supertypes.
+{% for classifier in eClassesOf(package) %}
+{% set parent = superType(classifier) %}
+{% if parent %}
+{{ bootstrapAdd("this._" + classifier.getName(), "getESuperTypes", "Ids.EClass.eSuperTypes", classifierExpr(parent)) }}
+{% endif %}
+{% endfor %}
+
+    // Pass 4b: opposites. Set after all bootstrap adds, so those adds don't trigger inverse updates.
+    // Opposites in another package are not emitted.
+{% for classifier in eClassesOf(package) %}
+{% for feature in classifier.getEStructuralFeatures() %}
+{% set opposite = feature.getEOpposite() if isEReference(feature) else undefined %}
+{% if opposite and opposite.getEContainingClass().getEPackage() == package %}
+{{ bootstrapSet("this._" + classifier.getName() + "_" + feature.getName(), "setEOpposite", "Ids.EReference.eOpposite", "this._" + opposite.getEContainingClass().getName() + "_" + opposite.getName()) }}
+{% endif %}
+{% endfor %}
+{% endfor %}
+
+    // Pass 5 (recompute EAll* caches, ordinary mode only) removed - stale post-swap.
+    // @typemf/core's own EClassImpl is now itself generated code (see NOTES.md's point 6/7
+    // write-ups), using the same automatic, get-bodied caching (EObjectImpl.getModelGeneration(),
+    // point 1) as self-hosted output always did - there is no recomputeAllLists() method to call
+    // anymore, in either mode, and none is needed.
+
+    // Pass 6: set the package's own name/nsURI/nsPrefix/annotations last,
+    // deliberately - these go through the ordinary reflective setters
+    // (this.setName(), etc.), which need the "name"/etc. feature's own
+    // metaclass object to already exist (it's built above, in the passes
+    // this follows). Calling them earlier - before those metaclasses
+    // exist - is a genuine bootstrap-ordering bug, confirmed directly by
+    // reproducing it: this line order isn't a style choice, the metaclass
+    // shells and feature wiring above are a real, load-bearing
+    // precondition for the reflective setter calls below to work at all.
+    this.setName({{ jsString(package.getName()) }});
+    this.setNsURI({{ jsString(package.getNsURI()) }});
+    this.setNsPrefix({{ jsString(package.getNsPrefix()) }});
+{{ emitAnnotations("this", package) }}
+  }
+
+{% for classifier in package.getEClassifiers() %}
+{% set collision = metaclassAccessorCollision(classifier.getName(), package) %}
+{% if isEClass(classifier) %}
+{% if collision %}
+  get{{ classifier.getName() }}(): {{ useImport("EClass", "types", {foundational: true}) }};
+  get{{ classifier.getName() }}({{ paramList(collision) }}): {{ tsOperationReturnType(collision) }};
+  get{{ classifier.getName() }}({{ optionalParamList(collision) }}): EClass | {{ tsOperationReturnType(collision) }} {
+    if ({{ collision.getEParameters().get(0).getName() }} === undefined) return this._{{ classifier.getName() }};
+    return super.get{{ classifier.getName() }}({{ argList(collision) }});
+  }
+{% else %}
+  get{{ classifier.getName() }}(): {{ useImport("EClass", "types", {foundational: true}) }} {
+    return this._{{ classifier.getName() }};
+  }
+{% endif %}
+{% for feature in classifier.getEStructuralFeatures() %}
+  get{{ classifier.getName() }}_{{ ucfirst(feature.getName()) }}(): {{ useImport("EReference", "types", {foundational: true}) if isEReference(feature) else useImport("EAttribute", "types", {foundational: true}) }} {
+    return this._{{ classifier.getName() }}_{{ feature.getName() }};
+  }
+{% endfor %}
+{% elif isEEnum(classifier) %}
+{% if collision %}
+  get{{ classifier.getName() }}(): {{ useImport("EEnum", "types", {foundational: true}) }};
+  get{{ classifier.getName() }}({{ paramList(collision) }}): {{ tsOperationReturnType(collision) }};
+  get{{ classifier.getName() }}({{ optionalParamList(collision) }}): EEnum | {{ tsOperationReturnType(collision) }} {
+    if ({{ collision.getEParameters().get(0).getName() }} === undefined) return this._{{ classifier.getName() }};
+    return super.get{{ classifier.getName() }}({{ argList(collision) }});
+  }
+{% else %}
+  get{{ classifier.getName() }}(): {{ useImport("EEnum", "types", {foundational: true}) }} {
+    return this._{{ classifier.getName() }};
+  }
+{% endif %}
+{% else %}
+{% if collision %}
+  get{{ classifier.getName() }}(): {{ useImport("EDataType", "types", {foundational: true}) }};
+  get{{ classifier.getName() }}({{ paramList(collision) }}): {{ tsOperationReturnType(collision) }};
+  get{{ classifier.getName() }}({{ optionalParamList(collision) }}): EDataType | {{ tsOperationReturnType(collision) }} {
+    if ({{ collision.getEParameters().get(0).getName() }} === undefined) return this._{{ classifier.getName() }};
+    return super.get{{ classifier.getName() }}({{ argList(collision) }});
+  }
+{% else %}
+  get{{ classifier.getName() }}(): {{ useImport("EDataType", "types", {foundational: true}) }} {
+    return this._{{ classifier.getName() }};
+  }
+{% endif %}
+{% endif %}
+{% endfor %}
+}
+{% endfile %}

package/templates/typescript/epackageref.njk

@@ -0,0 +1,46 @@
+{% file "impl/" + packageClassName(package) + "Ref.ts" %}
+import type { {{ packageClassName(package) }} } from '../{{ packageClassName(package) }}.js';
+
+/**
+ * A late-bound reference to the {{ packageClassName(package) }} singleton,
+ * set once by {{ packageClassName(package) }}Impl's own constructor after
+ * it finishes constructing itself.
+ *
+ * Every generated class needs a reference to the package singleton (for
+ * eClass(), for feature-ID lookups in field initializers/lazy getters,
+ * etc.) - and {{ packageClassName(package) }}Impl itself constructs
+ * (nearly) every one of those classes to build the runtime metamodel. For
+ * an ordinary generated package that mutual reference is harmless: the
+ * package singleton already exists in full by the time anything else is
+ * ever constructed. But self-hosting a metamodel that describes itself
+ * (as with real Ecore.ecore) makes this a genuine, confirmed hazard: a
+ * real class along the package's own superclass chain, or a class that is
+ * ALSO the superclass of something the package constructs directly (the
+ * "EFactory unification" / "EPackage unification" cases), can end up
+ * needing this reference while {{ packageClassName(package) }}Impl is
+ * still in the middle of constructing itself - a genuine circular
+ * dependency, not merely an ordering preference, confirmed directly
+ * against a real failing bundle ("Class extends value undefined is not a
+ * constructor or null") while building this generator, not assumed.
+ *
+ * This module has only a type-only import (erased at compile time, zero
+ * runtime footprint) - so importing FROM this module can never itself
+ * participate in a circular dependency, unlike importing
+ * {{ packageClassName(package) }}Impl (or anything re-exporting it)
+ * directly.
+ */
+let ref: {{ packageClassName(package) }} | undefined;
+
+export function set{{ packageClassName(package) }}Ref(pkg: {{ packageClassName(package) }}): void {
+  ref = pkg;
+}
+
+export function get{{ packageClassName(package) }}Ref(): {{ packageClassName(package) }} {
+  if (!ref) {
+    throw new Error(
+      'get{{ packageClassName(package) }}Ref() called before the {{ packageClassName(package) }} singleton finished constructing itself.'
+    );
+  }
+  return ref;
+}
+{% endfile %}

package/templates/typescript/eswitch.njk

@@ -0,0 +1,32 @@
+{% file "util/" + switchClassName(package) + ".ts" %}
+export abstract class {{ switchClassName(package) }}<T> {
+  doSwitch(eObject: {{ useImport("EObject", "types", {foundational: true}) }}): T | undefined {
+    switch (eObject.eClass().getClassifierID()) {
+{% for classifier in concreteEClassesOf(package) %}
+      case {{ useImport("Ids", "root", {file: packageClassName(package), foundational: false}) }}.{{ classifier.getName() }}.self: {
+        // {{ classifier.getName() }}
+{% for c in superTypeChain(classifier) %}
+        const result{{ loop.index }} = this.case{{ c.getName() }}(eObject as {{ useImport(c.getName(), "types", {foundational: false}) }});
+        if (result{{ loop.index }} !== undefined) return result{{ loop.index }};
+{% endfor %}
+        return this.defaultCase(eObject);
+      }
+{% endfor %}
+      default:
+        return this.defaultCase(eObject);
+    }
+  }
+
+{% for classifier in eClassesOf(package) %}
+  case{{ classifier.getName() }}(object: {{ useImport(classifier.getName(), "types", {foundational: false}) }}): T | undefined {
+    void object;
+    return undefined;
+  }
+{% endfor %}
+
+  defaultCase(object: {{ useImport("EObject", "types", {foundational: true}) }}): T | undefined {
+    void object;
+    return undefined;
+  }
+}
+{% endfile %}

package/templates/typescript/etypeguards.njk

@@ -0,0 +1,30 @@
+{% file "util/" + typeGuardsClassName(package) + ".ts" %}
+/**
+ * Runtime type guards, one per classifier declared in types/ - the
+ * reflective counterpart to a hand-written structural guard like
+ *
+ *   function isReference(feature: EStructuralFeature): feature is EReference {
+ *     return "isContainment" in feature;
+ *   }
+ *
+ * Structural (duck-typing) checks like that one work when a single
+ * classifier has some genuinely distinguishing own member - but nothing
+ * guarantees an arbitrary generated classifier has one (a subclass might
+ * add no own features at all, inheriting everything). These guards check
+ * the object's REAL runtime EClass against the metamodel's own
+ * eAllSuperTypes reflectively instead (via isSuperTypeOf()), which is
+ * correct for every classifier unconditionally, including abstract ones
+ * (correctly true for any instance of a concrete subclass) and dynamic
+ * instances (no dependency on the object's actual JS class/prototype at
+ * all, unlike `instanceof`).
+ */
+function hasEClass(obj: unknown): obj is {{ useImport("EObject", "types", {foundational: true}) }} {
+  return obj !== null && typeof obj === 'object' && typeof (obj as { eClass?: unknown }).eClass === 'function';
+}
+
+{% for classifier in eClassesOf(package) %}
+export function is{{ classifier.getName() }}(obj: unknown): obj is {{ useImport(classifier.getName(), "types", {foundational: false}) }} {
+  return hasEClass(obj) && {{ useImport("get" + packageClassName(package) + "Ref", "impl", {file: packageClassName(package) + "Ref", foundational: false}) }}().get{{ classifier.getName() }}().isSuperTypeOf(obj.eClass());
+}
+{% endfor %}
+{% endfile %}

package/templates/typescript/main.njk

@@ -0,0 +1,19 @@
+{% for classifier in package.getEClassifiers() %}
+{% if classifier.getName() == "EObject" %}
+{# Deliberately no files generated - see typescript-filters.ts's tsScalarType()
+   doc comment and eclass.njk's existing no-declared-supertype fallback,
+   which already resolve any reference to "EObject" to the real
+   @typemf/core EObject rather than a generated, shadowing one. #}
+{% elif isEClass(classifier) %}
+{% set eClass = classifier %}
+{% include "eclass.njk" %}
+{% elif isEEnum(classifier) %}
+{% set eEnum = classifier %}
+{% include "eenum.njk" %}
+{% endif %}
+{% endfor %}
+{% include "epackage.njk" %}
+{% include "epackageref.njk" %}
+{% include "efactory.njk" %}
+{% include "eswitch.njk" %}
+{% include "etypeguards.njk" %}