@sap/cds-dk 10.1.2 → 10.2.1

package/node_modules/@sap/cds-compiler/lib/compiler/extend.js

@@ -1,11 +1,51 @@
-// Extend
+// Provide functions for extensions and includes
+
+// The main functions are the following, the first three are called on-demand in
+// the "origin chain loop", i.e. in dependency order:
+//
+// extendArtifactBefore(), called at the start of the loop body:
+//  - traverses collected extensions for the given artifact, and for each property,
+//    select one (or sort them, e.g. for `includes`) if multiple extensions exist
+//  - _also called_ by main function of this file for all user-defined main artifacts,
+//    because we need some annotations rather early → the "origin" is not necessarily
+//    processed → this fn can't inspect the "origin" or derived props of includes
+//
+// … in between: populateGeneratedEntity(), resolveInclude(), populateArtifact()
+//
+// extendArtifactAdd(), called in the middle of the loop body:
+//  - add elements, enums and actions to artifact via includes and/or extension
+//
+// … in between: set _effectiveType, mergeSpecifiedElementsOrEnum(), generateForEntity()
+//
+// extendArtifactAfter(), called at the end of the loop body:
+//  - pushes down member extensions to members
+//  - handles type property extensions (TODO: move to extendArtifactAdd)
+//
+// createRemainingAnnotateStatements(), called near end of compilation
+//  - creates `annotate` statements for non-applied extensions
+
+// Sections in this file: -------------------------------------------------------
+//  - Pushdown and transform extensions
+//  - Sort sources, select/sort extension
+//  - Array annotations with `...`, same anno values
+//  - Special properties: query clauses, type properties
+//  - Add new members
+//  - Create “super” ANNOTATE statements
+//  - TODO TMP: initMembers()
+//  - TODO TMP: includes
+//  - Foreign key extensions (currently postponed)
+//  - Utility functions
 
 'use strict';
 
 const { weakRefLocation } = require('../base/location');
-const { searchName } = require('../base/messages');
-const { dictAdd, pushToDict, dictForEach } = require('./dictionaries');
-const { kindProperties, dictKinds } = require('./base');
+const {
+  dictAdd,
+  pushToDict,
+  dictNonEmpty,
+  dictFirst,
+} = require('./dictionaries');
+const { kindProperties } = require('./base');
 const {
   setLink,
   setArtifactLink,
@@ -13,9 +53,8 @@ const {
   setExpandStatus,
   linkToOrigin,
   initItemsLinks,
-  setMemberParent,
+  outerArtifact,
   createAndLinkCalcDepElement,
-  initExprAnnoBlock,
   initBoundSelfParam,
   dependsOnSilent,
   hasSecurityAnno,
@@ -26,13 +65,12 @@ const {
   forEachDefinition,
   forEachMember,
   forEachGeneric,
-  isDirectComposition,
-  targetCantBeAspect,
 } = require('./utils');
 const layers = require('./moduleLayers');
 const { CompilerAssertion } = require('../base/error');
 const { Location } = require('../base/location');
 const { typeParameters } = require('./builtins');
+const { XsnArtifact, XsnName } = require('./xsn-model');
 
 const $location = Symbol.for( 'cds.$location' );
 const $inferred = Symbol.for( 'cds.$inferred' ); // TODO: no $inferred yet?
@@ -53,10 +91,6 @@ const draftBoundActions = [
   'draftEdit',
 ];
 
-function canBeDraftMember( name, parent, draftMembers ) {
-  return parent?.kind === 'entity' && parent._service && draftMembers.includes( name );
-}
-
 function extend( model ) {
   // Get simplified "resolve" functionality and the message function:
   const {
@@ -68,7 +102,6 @@ function extend( model ) {
     resolveTypeArgumentsUnchecked,
     resolveDefinitionName,
     attachAndEmitValidNames,
-    checkRedefinition,
   } = model.$functions;
 
   Object.assign( model.$functions, {
@@ -78,117 +111,15 @@ function extend( model ) {
     extendArtifactAdd,
     extendForeignKeys,
     withLocalizedData,
-    applyIncludes,              // TODO: re-check
   } );
 
-  const includeCollisions = [];
-
-  forEachGeneric( model, 'definitions', tagCompositionTargets );
-  dictForEach( model.$collectedExtensions, e => e._extensions.forEach( tagCompositionTargets ) );
-  // remark: tagging on extensions works _before_ running extendArtifactBefore() on each artifact
   sortModelSources();
-
   // Set annotations on user-provided artifacts, but they are not propagated yet!
-  // Use them in the main compiler phase (and before) with extra care:
   forEachDefinition( model, extendArtifactBefore );
   return;
 
-  // Tag composition targets: ---------------------------------------------------
-
-  function tagCompositionTargets( elem ) {
-    if (elem.$inferred)         // TODO: probably no $inferred yet
-      return;
-    if (elem.targetAspect?.elements)
-      elem = elem.targetAspect;
-    if (elem.elements) {
-      forEachGeneric( elem, 'elements', tagCompositionTargets );
-    }
-    else if (elem.columns) {    // `elem` is query or extension
-      elem.columns.forEach( tagCompositionTargets );
-    }
-    else if (elem.$queries) {
-      for (const query of elem.$queries) {
-        if (query.mixin)
-          forEachGeneric( query, 'mixin', tagCompositionTargets );
-        if (query.columns)
-          query.columns.forEach( tagCompositionTargets );
-        // Remark: no directly published expand/inline column yet
-      }
-    }
-    else if (elem.target && isDirectComposition( elem )) {
-      const name = resolveUncheckedPath( elem.target, 'target', elem );
-      if (!name)
-        return;
-      const target = model.definitions[name];
-      // move target aspect in `target` to `targetAspect` (in define.js, we only
-      // do it with anonymous aspect)
-      if (target?.kind in { aspect: 1, type: 1 } && // type is sloppy
-          target.elements && !target.elements[$inferred] &&
-          !targetCantBeAspect( elem, false, model.definitions )) { // tests `!elem.targetAspect`
-        elem.targetAspect = elem.target;
-        delete elem.target;
-      }
-      model.$compositionTargets[name] = true; // does not hurt if set on aspect
-    }
-  }
-
-
-  //-----------------------------------------------------------------------------
-  // Extensions: general algorithm
-  //-----------------------------------------------------------------------------
-  // extendArtifactBefore, extendArtifactAfter, createRemainingAnnotateStatements,
-  // extendForeignKeys
-
-  /**
-   * Goes through all (applied) annotations in the given artifact and chooses one
-   * if multiple exist according to the module layer.
-   * TODO: update comment if extension algorithm is finished
-   *
-   * Called at the beginning for each main artifact, and must not call
-   * resolvePath() then.  It is later called via effectiveType().
-   *
-   * @param {XSN.Artifact} art
-   */
-  function extendArtifactBefore( art ) {
-    // for main artifacts, move extensions from `$collectedExtensions` model dictionary:
-    if (!art._main && !art._outer && art._extensions === undefined &&
-        art.name && // TODO: probably just a workaround, check with TODO in getOriginRaw()
-        art.kind !== 'namespace') {
-      const { id } = art.name;
-      setLink( art, '_extensions', model.$collectedExtensions[id]?._extensions || null );
-      if (art._extensions && !art.builtin) { // keep extensions for builtin in $collectedExtensions
-        delete model.$collectedExtensions[id];
-        // TODO: if the extension mechanism has been completed, we could uncomment:
-        // art._extensions.forEach( ext => resolvePath( ext.name, ext.kind, ext )); // for LSP
-        // for now, we do that at the end of createRemainingAnnotateStatements()
-      }
-    }
-    if (art.kind === 'entity' && art.includes && !art._entityIncludes)
-      setEntityIncludes( art, art );
 
-    if (art._extensions) {
-      // TODO: the following function can now be simplified
-      // if (art.$inferred) console.log('CAI:', art.name, art.$inferred,art._extensions)
-      // With extensions, member appears in CSN, affects directly the rendering of
-      // elements etc.  TODO: do that more specifically on the dicts (via symbol)
-      // Probably better: we could use the _extensions dict prop directly in to-csn
-      if (art.$inferred)
-        setExpandStatus( art, 'annotate' );
-      if (Array.isArray( art._extensions )) {
-        checkExtensionsKind( art._extensions, art );
-        transformArtifactExtensions( art );
-      }
-      // console.log('EA:',require('../model/revealInternalProperties')
-      //             .ref(art),Object.keys(art._extensions))
-      for (const prop in art._extensions) {
-        if (Object.hasOwn( art._extensions, prop ) &&
-            // remark: if we change the array, consider whether to delete the artifact
-            // TODO: what is the `$gen`?  `$add` is handled...
-            ![ 'elements', 'actions', 'params', '$gen' ].includes( prop ))
-          applyPropertyExtensions( art, prop );
-      }
-    }
-  }
+  // Pushdown and transform extensions ------------------------------------------
 
   /**
    * Push down extensions on member properties like `elements` to the individual
@@ -240,14 +171,17 @@ function extend( model ) {
         annotateFor( art, 'params', '' );  // create anno for non-existing returns
       for (const ext of extensionsMap.elements) {
         if (!ext.returns) {
+          if (artProp === 'returns') {
+            reportMissingReturns( ext, art );
+            if (ext.kind === 'extend')
+              continue;
+          }
           pushToDict( returnsDict || art[artProp], '_extensions', ext );
-          if (artProp === 'returns')
-            extendHandleReturns( ext, art );
         }
         else {
           pushToDict( returnsDict || art[artProp], '_extensions', ext.returns );
           if (!art.returns)
-            checkReturnsExtension( ext, art );
+            reportUnexpectedReturns( ext, art );
         }
       }
       // TODO: what about `many many Type` (via CSN)?
@@ -255,7 +189,7 @@ function extend( model ) {
     else if (!art.target) { // TODO: foreign keys currently handled specially
       for (const ext of extensionsMap.elements) {
         if (ext.returns)
-          checkReturnsExtension( ext, art );
+          reportUnexpectedReturns( ext, art ); // TODO: ???
       }
       // if (art.elements || art.enum || art.kind === 'annotate')
       moveDictExtensions( art, extensionsMap,
@@ -263,114 +197,26 @@ function extend( model ) {
     }
   }
 
-  /**
-   * Apply foreign key extensions.  Because foreign keys are handled late in the compiler
-   * (in tweak-assocs.js), we can't apply them in effectiveType(), yet.
-   * Instead, we postpone applying them until all foreign keys were generated.
-   *
-   * @param art
-   */
-  function extendForeignKeys( art ) {
-    // See extendArtifactAfter() for targetAspect/items handling.
-    if (!art._extensions || art.items || art.targetAspect?.elements)
-      return;
-
-    // push down foreign keys
-    moveDictExtensions( art, art._extensions, 'foreignKeys', 'elements' );
-    if (!art.foreignKeys)
-      return;
-
-    forEachGeneric(art, 'foreignKeys', (key) => {
-      if (!key._effectiveType)
-        throw new CompilerAssertion('foreign key should have been processed');
-      extendArtifactBefore( key );
-      extendArtifactAfter( key );
-    });
-  }
-
-  /**
-   * Applying extensions is handled in extendArtifactAfter(). And only afterward,
-   * an effective sequence number is set.  Meaning that if a sub artifact already
-   * has a sequence number, then extensions would be lost.
-   *
-   * A special case are foreign keys, see extendForeignKeys().
-   */
-  function ensureArtifactNotProcessed( art ) {
-    if (!model.options.testMode)
-      return;
-
-    if (art.kind !== 'key' && art.$effectiveSeqNo !== 0 && art.$effectiveSeqNo !== undefined) {
-      // if the artifact already has a sequence number, then
-      // extendArtifactAfter() was already called -> annotations would be lost.
-      throw new CompilerAssertion('artifact already processed; extensions would be lost');
-    }
-  }
-
-  /**
-   * Create super annotate statements for remaining extensions
-   */
-  function createRemainingAnnotateStatements() {
-    model.extensions = Object.values( model.$collectedExtensions );
-    // TODO: testMode sort?
-    model.extensions.forEach( createSuperAnnotate );
-    // set _artifact links for “main extensions” late as it would disturb the
-    // still existing old extend mechanism, see extendArtifactBefore(),
-    // needed for LSP and friends:
-    Object.values( model.sources ).forEach( setArtifactLinkForExtensions );
-    Object.values( model.definitions ).forEach( setArtifactLinkForExtensions );
-  }
-
-  // TODO: delete again - if not, what about extensions in contexts/services?
-  //       Check test.lsp-api.js! Links in extensions are needed.
-  function setArtifactLinkForExtensions( source ) {
-    if (!source.extensions)
+  function moveDictExtensions( art, extensionsMap, artProp, extProp = artProp ) {
+    const extensions = extensionsMap[extProp || 'elements'];
+    if (!extensions)
       return;
-    for (const ext of source.extensions) {
-      if (!ext.name?.id)
-        continue;
-
-      const { name } = ext;
-      const { path } = name;
-      if (name._artifact === undefined) {
-        resolvePath( name, ext.kind, ext ); // induce error & for LSP
-      }
-      else if (model.options.lspMode && path?.[0]._artifact === undefined) {
-        // we don't use resolvePath(…,'extend'), as that would add a dependency
-        resolveDefinitionName( ext );
-        setArtifactLink( path[path.length - 1], name._artifact );
-      }
-    }
-  }
-
-  // For extendArtifactBefore(): ------------------------------------------------
-
-  /**
-   * Complain about invalid `extend service` and `extend context`.
-   */
-  function checkExtensionsKind( extensions, art ) {
     for (const ext of extensions) {
-      const kind = ext.expectedKind?.val;
-      if (kind && kind !== art.kind) {
-        const loc = ext.expectedKind.location;
-        if (kind === 'context' || kind === 'service') {
-          // We have no real artifact during the construction of a super-annotate statement:
-          const msgArgs = {
-            '#': (art.kind === 'service' || art.kind === 'annotate') ? art.kind : 'std',
-            art,
-            kind,
-            code: 'extend … with definitions',
-            keyword: 'extend service',
-          };
-          // TODO v7: Discuss: make this an error?
-          warning( 'ext-invalid-kind', [ loc, ext ], msgArgs, {
-            std: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) instead',
-            annotate: 'There is no artifact $(ART), use $(CODE) instead',
-            // do not mention 'extend context', that is not in CAPire
-            service: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) or $(KEYWORD) instead',
-          } );
-        }
-        // TODO: Use similar checks for EXTEND ENTITY etc - 'ext-ignoring-kind'
-      }
+      const members = art[artProp];
+      const realExtProp = extProp || (ext.enum ? 'enum' : 'elements');
+      if (!members && !checkExtensionDictionary( ext, art, artProp, realExtProp ))
+        continue;
+      forEachGeneric( ext, realExtProp, ( elemExt, name ) => {
+        if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend')
+          return;             // definitions inside extend, already handled
+        // Remark: don't test elemExt.$duplicates, `annotate A (@Foo P, @Bar P)` should work
+        reportUnexpectedMemberExtensions( art, elemExt, artProp, name );
+        const elem = members?.[name] || annotateFor( art, extProp || 'elements', name );
+        setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
+        // null, because the element is not really there, just in a "super annotate"
+        if (elem.$duplicates !== true) // TODO: re-check, or just !elem.$duplicates
+          pushToDict( elem, '_extensions', elemExt );
+      });
     }
   }
 
@@ -379,8 +225,12 @@ function extend( model ) {
    * `{ prop: relevantExtensions, … }` where `relevantExtensions` are the extensions
    * which are relevant for the value of `art[prop]` after the application of extensions.
    *
-   * Remark: it is not necessarily clear at this moment whether `art` has
-   * `elements`, `enums`, `items`, etc.
+   * A special property is `$add`: it collects extensions for both `elements` (+
+   * `enum`) extensions and `includes` (also without elements, because the order
+   * of includes might influences which inludes wins for inherited annotations).
+   *
+   * Called in extendArtifactBefore(), where it is not necessarily clear whether
+   * `art` has `elements`, `enums`, `items`, etc.
    */
   function transformArtifactExtensions( art ) {
     // TODO: if extensions has more than one of returns,items,elements,enum, delete all those props
@@ -403,7 +253,7 @@ function extend( model ) {
                  prop === 'groupBy' || prop === 'where' || prop === 'having' ||
                  prop === 'orderBy' || prop === 'limit' || prop === 'length' ||
                  prop === 'scale' || prop === 'precision' || prop === 'srid') {
-          if (!isAutoItemsOrReturns)
+          if (!isAutoItemsOrReturns) // these props are ignored inside items/returns
             pushToDict( dict, prop, ext );
         }
         else if (prop === 'elements' || prop === 'enum') {
@@ -417,14 +267,19 @@ function extend( model ) {
           }
           else {
             pushToDict( dict, 'elements', ext ); // yes, enum → elements here
-            if (ext.kind === 'extend' && !isAutoItemsOrReturns)
+            // if at least one elem/enum (TODO):
+            // && Object.keys( ext.elements ).some( elem => elem.kind !== 'extend' ))
+            // Add to $add if not already for includes:
+            if (ext.kind === 'extend' && !ext.includes)
               pushTo$add( dict, ext );
+            // TODO: issue error for ext on art having returns/items if ext has both
+            // include/actions/params and elements/enum (or handle that properly)
           }
         }
         else if (prop === 'returns') {
           pushToDict( dict, 'elements', ext );
           if (hasSecurityAnno( ext.returns ))
-            checkReturnsExtension( ext, ext );
+            reportUnexpectedReturns( ext, ext );
           // create 'returns' for the super annotate, store in elements anyway
           if (!art.returns && art.kind === 'annotate')
             annotateCreate( art, '', art, 'returns' );
@@ -433,14 +288,14 @@ function extend( model ) {
         }
         else if (prop === 'actions' || prop === 'params') {
           pushToDict( dict, prop, ext );
-          if (ext.kind === 'extend' && prop === 'actions' && !isAutoItemsOrReturns)
-            pushTo$add( dict, ext );
         }
       }
     }
     art._extensions = dict;
   }
 
+  // Sort sources, select/sort extensions ---------------------------------------
+
   /**
    * Sort sources according to the reversed layered extension order without
    * reporting any messages.
@@ -467,12 +322,84 @@ function extend( model ) {
     setLink( model, '_sortedSources', scheduled );
   }
 
+  /**
+   * Traverses collected extensions for the given artifact, and for each property,
+   * select one (or sort them, e.g. for `includes`) if multiple extensions exist.
+   *
+   * Consider the module layer for the selection/sorting, and issue messages.
+   *
+   * Called at the beginning for each main artifact, and must not call
+   * resolvePath() then.
+   *
+   * @param {XSN.Artifact} art
+   */
+  function extendArtifactBefore( art ) {
+    // for main artifacts, move extensions from `$collectedExtensions` model dictionary:
+    if (!art._main && !art._outer && art._extensions === undefined &&
+        art.name && // TODO: probably just a workaround, check with TODO in getOriginRaw()
+        art.kind !== 'namespace') {
+      const { id } = art.name;
+      setLink( art, '_extensions', model.$collectedExtensions[id]?._extensions || null );
+      if (art._extensions && !art.builtin) { // keep extensions for builtin in $collectedExtensions
+        delete model.$collectedExtensions[id];
+        // TODO: if the extension mechanism has been completed, we could uncomment:
+        // art._extensions.forEach( ext => resolvePath( ext.name, ext.kind, ext )); // for LSP
+        // for now, we do that at the end of createRemainingAnnotateStatements()
+      }
+    }
+    if (art.kind === 'entity' && art.includes && !art._entityIncludes)
+      setEntityIncludes( art, art );
+
+    if (Array.isArray( art._extensions )) {
+      // TODO: the following function can now be simplified
+      // if (art.$inferred) console.log('CAI:', art.name, art.$inferred,art._extensions)
+      // With extensions, member appears in CSN, affects directly the rendering of
+      // elements etc.  TODO: do that more specifically on the dicts (via symbol)
+      // Probably better: we could use the _extensions dict prop directly in to-csn
+      if (art.$inferred)
+        setExpandStatus( art, 'annotate' );
+      if (Array.isArray( art._extensions )) {
+        reportInvalidExtensionKind( art._extensions, art );
+        transformArtifactExtensions( art );
+      }
+      // console.log('EA:',require('../model/revealInternalProperties')
+      //             .ref(art),Object.keys(art._extensions))
+      for (const prop in art._extensions) {
+        if (Object.hasOwn( art._extensions, prop ))
+          applyPropertyExtensions( art, prop );
+      }
+    }
+  }
+
+  /**
+   * Collect all includes which are entities in property `_entityIncludes`.
+   * This information is needed to kick-start the auto-redirection mechanism,
+   * i.e. must be called in extendArtifactBefore().
+   *
+   * A consequence is that a compiler-generated entity must never include an
+   * entity; the generated entity could be an auto-redirection target otherwise
+   * → an on-demand generated could change the auto-redirection behavior.
+   */
+  function setEntityIncludes( ext, art ) {
+    // TODO: better to call this once at the end of extendArtifactBefore()
+    setLink( art, '_entityIncludes', [] );
+    for (const ref of ext.includes) {
+      const name = resolveUncheckedPath( ref, 'include', ext );
+      const template = name && model.definitions[name];
+      if (template?.kind === 'entity')
+        art._entityIncludes.push( template );
+    }
+  }
+
   /**
    * For all `prop → extensions` in `art._extensions`, apply the extensions.
    * Currently only for annotations, the `doc` property, `columns` and type properties,
    * not for `elements` and other members.
    */
   function applyPropertyExtensions( art, prop ) {
+    if (prop === 'params' || prop === 'returns' || prop === 'elements')
+      return;                   // only for push-down
+
     const extensions = art._extensions;
     // annotations, `doc`, `includes`, `columns`, `length`, ...
     const scheduled = [];
@@ -498,20 +425,19 @@ function extend( model ) {
     }
     // Now apply the relevant extensions
     scheduled.reverse();
-    art.$postponeInclude ??= 0; // add elems of includes before direct ones
     if (prop === 'includes' && !art.includes?.$original) {
       const $original = art.includes ?? [];
       art.includes = [ ...$original ];
       art.includes.$original = $original;
+      // extensions[prop] = scheduled;
       // console.log('APE:',art.name.id,art.includes.map( r => r._artifact?.name.id ))
     }
-    if (prop === '$add') {
+    if (prop === '$add' || prop === 'actions') {
       extensions[prop] = scheduled;
-      return;                   // the $add is applied in extendArtifactAdd()
+      return;                   // $add and actions are applied in extendArtifactAdd()
     }
     for (const ext of scheduled)
       applySingleExtension( art, ext, prop );
-    delete extensions[prop];
   }
 
   function extensionOverwrites( ext, prop ) {
@@ -520,80 +446,20 @@ function extend( model ) {
       : !annotationHasEllipsis( ext[prop] );
   }
 
-  // TODO: still a bit annotation assignment specific
-  function reportDuplicateExtensions( extensions, prop, issue, index, art ) {
-    // TODO: think about messages for these
-    if (prop === 'elements' || prop === 'actions' || prop === 'columns' ||
-        prop === 'params' || prop === '$add' )
-      return;                   // extensions currently handled extra
-    // TODO: columns?
-    const isTypeParam = typeParameters.list.includes( prop );
-    const isAnnoOrDoc = prop.charAt(0) === '@' || prop === 'doc';
-    if (!isAnnoOrDoc && !isTypeParam && prop !== 'orderBy')
-      return;
-    if (issue) {
-      if (prop === 'orderBy' && issue === 'unrelated') {
-        for (const ext of extensions) {
-          const clause = ext[prop];
-          if (clause) {
-            message( 'ext-unstable-order', [ clause[0]?.location || ext.location, ext ],
-                     { keyword: prop },
-                     // eslint-disable-next-line @stylistic/max-len
-                     'Unstable order of entries in the $(KEYWORD) clause due to another extension in unrelated layer' );
-          }
-        }
-        return;
-      }
-      // eslint-disable-next-line no-nested-ternary
-      let msg = (index < 0)
-        ? 'anno-unstable-array'
-        : (issue === true)
-          ? 'anno-duplicate'
-          : 'anno-duplicate-unrelated-layer';
-      if (!isAnnoOrDoc) {
-        msg = (issue === true)
-          ? 'ext-duplicate-extend-type'
-          : 'ext-duplicate-extend-type-unrelated-layer';
-        // not sure whether to repeat the extended artifact in the message (we
-        // have the semantic location, after all)
-        // extend-repeated-intralayer / extend-unrelated-layer
-      }
-      const variant = prop === 'doc' ? 'doc' : 'std';
-      for (const ext of extensions) {
-        const anno = ext[prop];
-        if (anno && !anno.$errorReported) {
-          message( msg, [ anno.name?.location || anno.location, ext ],
-                   { '#': variant, anno: prop, type: art } );
-        }
-      }
-    }
-    else if (index > 0) {     // more than one set (not just ...)
-      const variant = prop === 'doc' ? 'doc' : 'std';
-      const msgid = (isAnnoOrDoc)
-        ? 'anno-duplicate-same-file' // TODO: always ext-duplicate-…
-        : 'ext-duplicate-same-file';
-      while (index >= 0) {    // do not report for trailing [...]
-        const ext = extensions[index--];
-        const anno = ext[prop];
-        warning( msgid, [ anno.name?.location || anno.location, ext ],
-                 { '#': variant, prop, anno: prop } );
-      }
-    }
-  }
-
-  function applySingleExtension( art, ext, prop ) {
-    if (prop === 'includes') {
-      if (art.kind !== 'annotate' && !art._outer) { // TODO: why this check?
-        // not with elem extension in targetAspect
-        art.includes.push( ...ext.includes );
-        // head of ref in in ext.includes must be set in _block of ext; for
-        // remaining path items, effectiveType() has `art` as user
-        // (alternatively, we could set some _user on `includes` items):
-        for (const ref of ext.includes)
-          resolveUncheckedPath( ref, 'include', ext );
-        if (art.kind === 'entity')
-          setEntityIncludes( ext, art );
-        // console.log( 'ASI:',prop,art.name,ext,extensionsDict[id])
+  function applySingleExtension( art, ext, prop ) {
+    if (prop === 'includes') {
+      if (art.kind !== 'annotate' && !art._outer) { // TODO: why this check?
+        // not with elem extension in targetAspect
+        art.includes.push( ...ext.includes );
+        // head of ref in in ext.includes must be set in _block of ext; for
+        // remaining path items, effectiveType() has `art` as user
+        // (alternatively, we could set some _user on `includes` items):
+        for (const ref of ext.includes)
+          resolveUncheckedPath( ref, 'include', ext );
+        // TODO: some warning if duplicate ref
+        if (art.kind === 'entity')
+          setEntityIncludes( ext, art );
+        // console.log( 'ASI:',prop,art.name,ext,extensionsDict[id])
       }
       // art[prop] = (art[prop]) ? art[prop].concat( ext[prop] ) : ext[prop];
     }
@@ -610,10 +476,14 @@ function extend( model ) {
         error( 'extend-columns', [ ext.columns[$location], ext ], { '#': variant, art } );
         return;
       }
-      if (!query.columns)
-        query.columns = [ { location: query.from.location, val: '*' }, ...ext.columns ];
-      else
+      if (!query.columns) {
+        query.columns = [ {
+          __proto__: XsnArtifact.prototype, location: query.from.location, val: '*',
+        }, ...ext.columns ];
+      }
+      else {
         query.columns.push( ...ext.columns );
+      }
       ext.columns.forEach( col => changeParentLinks( col, query ) );
     }
     else if (prop === 'groupBy' || prop === 'where' || prop === 'having' ||
@@ -626,76 +496,12 @@ function extend( model ) {
     }
     else {
       const result = applyAssignment( art[prop], ext[prop], ext, prop );
+      // Remark: result is ext[prop] if without [...]
       art[prop] = (result.name) ? result : Object.assign( {}, art[prop], result );
     }
   }
 
-  function applyQueryClause( prop, ext, art ) {
-    const { query } = art;
-    const clause = ext[prop];
-    const isArray = Array.isArray( clause );
-
-    if (prop !== 'limit') {
-      const items = isArray ? clause : [ clause ];
-      for (const item of items) {
-        item.$extended = prop;
-        setLink( item, '_block', ext._block );
-        setLink( item, '_outer', query );
-      }
-    }
-    if (!query?.from?.path) {
-      const variant = (query?.from || query)?.op?.val || 'std';
-      const loc = isArray ? clause[$location] : clause.location;
-      error( `extend-${ prop.toLowerCase() }`, [ loc, ext ], { '#': variant, art } );
-      return;
-    }
-    if (isArray) {
-      if (!query[prop])
-        query[prop] = [];
-      query[prop].push( ...clause );
-    }
-    else if (prop === 'where' || prop === 'having') {
-      const existing = query[prop];
-      if (!existing) {
-        query[prop] = clause;
-      }
-      else if (existing.op?.val === 'and' &&
-               existing.args.some( a => a.$extended === prop )) {
-        existing.args.push( clause );
-      }
-      else {
-        query[prop] = {
-          op: { val: 'and', location: art.name.location },
-          args: [ existing, clause ],
-          location: clause.location,
-        };
-      }
-    }
-    else if (query[prop]) {
-      error( 'ext-unexpected-sql-clause', [ clause.location, ext ], { art, keyword: prop } );
-    }
-    else {
-      query[prop] = clause;
-    }
-  }
-
-  function changeParentLinks( art, queryOrMain ) {
-    // TODO: we might also change the implicit name (if name.id is a number,
-    // adding the previous column lenght - 1) for better error messages
-    const parent = art._parent;
-    if (!art._parent)
-      return;
-    if (parent.kind === 'extend')
-      art._parent = queryOrMain;
-    if (art._main.kind === 'extend') // TODO: probably always
-      art._main = queryOrMain._main;
-    if (art._columnParent?.kind === 'extend')
-      art._columnParent = queryOrMain;
-    const subColumns = art.expand || art.inline;
-    if (subColumns)
-      subColumns.forEach( a => changeParentLinks( a, queryOrMain ) );
-    forEachMember( art, a => changeParentLinks( a, queryOrMain ) );
-  }
+  // Array annotations with `...`: ----------------------------------------------
 
   function applyAssignment( previousAnno, anno, art, annoName ) {
     const firstEllipsis = annotationHasEllipsis( anno );
@@ -738,6 +544,7 @@ function extend( model ) {
       }
       else {
         let upToSpec = !item.$errorReported && item.upTo;
+        // $errorReported: no anno-unexpected-upto-value with anno-invalid-upto-value
         while (prevPos < previousValue.length) {
           const prevItem = previousValue[prevPos++];
           result.push( prevItem );
@@ -748,7 +555,8 @@ function extend( model ) {
         }
         if (upToSpec && hasBase) {
           // non-matched UP TO; if there is no base to apply to, there is already an error.
-          warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
+          warning( 'anno-unexpected-upto-value', [ item.upTo.location, art ],
+                   { anno: annoName, code: '... up to' },
                    'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
         }
       }
@@ -764,7 +572,6 @@ function extend( model ) {
   }
 
   // For the `up to` specification, see ../../test3/Annotations/EllipsisUpTo/
-
   function equalUpTo( previousItem, upToSpec ) {
     if (!previousItem)
       return false;
@@ -816,11 +623,60 @@ function extend( model ) {
 
   function normalizeRef( node ) { // see to-csn.js
     const ref = pathName( node.path );
-    // TODO XSN 7.1: get rid of name.variant (induces a wrong structure anyway)
+    // TODO XSN 7.2: get rid of name.variant (induces a wrong structure anyway)
     return node.variant ? `${ ref }#${ pathName( node.variant.path ) }` : ref;
   }
 
-  // For extendArtifactAfter(): -------------------------------------------------
+  // Special properties: query clauses, type properties -------------------------
+
+  function applyQueryClause( prop, ext, art ) {
+    const { query } = art;
+    const clause = ext[prop];
+    const isArray = Array.isArray( clause );
+
+    if (prop !== 'limit') {
+      const items = isArray ? clause : [ clause ];
+      for (const item of items) {
+        item.$extended = prop;
+        setLink( item, '_block', ext._block );
+        setLink( item, '_outer', query );
+      }
+    }
+    if (!query?.from?.path) {
+      const variant = (query?.from || query)?.op?.val || 'std';
+      const loc = isArray ? clause[$location] : clause.location;
+      error( `extend-${ prop.toLowerCase() }`, [ loc, ext ], { '#': variant, art } );
+      return;
+    }
+    if (isArray) {
+      if (!query[prop])
+        query[prop] = [];
+      query[prop].push( ...clause );
+    }
+    else if (prop === 'where' || prop === 'having') {
+      const existing = query[prop];
+      if (!existing) {
+        query[prop] = clause;
+      }
+      else if (existing.op?.val === 'and' &&
+               existing.args.some( a => a.$extended === prop )) {
+        existing.args.push( clause );
+      }
+      else {
+        query[prop] = {
+          op: { val: 'and', location: art.name.location },
+          args: [ existing, clause ],
+          location: clause.location,
+        };
+      }
+    }
+    else if (query[prop]) {
+      error( 'ext-unexpected-sql-clause', [ clause.location, ext ], { art, keyword: prop } );
+    }
+    else {
+      query[prop] = clause;
+    }
+  }
 
   // Remarks on messages: we allow the type extensions only if the artifact
   // originally had that property → any check of the kind “type prop can only be
@@ -833,7 +689,7 @@ function extend( model ) {
   // - 'ext-unexpected-type-argument' (TODO) if the artifact does not have the prop
   // - 'ext-invalid-type-argument' if the value is wrong for extend (no overwrite)
   //
-  // TODO v6: do not allow `extend … with (precision: …)` alone if original def also has `scale`
+  // TODO v8: do not allow `extend … with (precision: …)` alone if original def also has `scale`
   function applyTypeExtensions( art, ext, prop, scaleDiff ) {
     // console.log('ATE:',art?.[prop],ext?.[prop],scaleDiff)
     if (!ext?.[prop])
@@ -901,194 +757,332 @@ function extend( model ) {
     return parameters.includes( prop ) || parameters[0]?.name === prop;
   }
 
-  function moveDictExtensions( art, extensionsMap, artProp, extProp = artProp ) {
-    // TODO: setExpandStatus
-    const extensions = extensionsMap[extProp || 'elements'];
-    if (!extensions)
-      return;
+  // Add new members ------------------------------------------------------------
 
-    for (const ext of extensions) {
-      forEachGeneric( ext, extProp || (ext.enum ? 'enum' : 'elements'), ( elemExt, name ) => {
-        if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
-          return;             // definitions inside extend, already handled
-        checkRemainingMemberExtensions( art, elemExt, artProp, name );
-        const elem = art[artProp]?.[name] || annotateFor( art, extProp || 'elements', name );
-        setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
-        // TODO: why null for annotate?
-        ensureArtifactNotProcessed( elem );
-        if (elem.$duplicates !== true) // TODO: re-check
-          pushToDict( elem, '_extensions', elemExt );
-      });
+  /**
+   * Extend artifact with additional elements and actions: via includes and/or
+   * extensions.  This happens _after_ `populateArtifact`, i.e. after eventually
+   * having inferred the elements/... from an "origin".
+   *
+   * `art` can also be a pseudo artifact in `items`.
+   */
+  function extendArtifactAdd( art ) {
+    const { includes, _extensions: extensions } = art;
+    if (includes) {
+      // propagation of core-compiler relevant annotation assignments:
+      propagateEarly( art, '@cds.autoexpose' );
+      propagateEarly( art, '@fiori.draft.enabled' );
+      reportInvalidIncludes( art );
     }
-  }
+    else if (!extensions) {     // semantically unnecessary, just for speed-up
+      return;
+    }
+    if (art.items || art.targetAspect || art.returns)
+      return;                   // adding enums/elements is pushed down
 
-  function annotateFor( art, prop, name ) {
-    const base = annotateBase( art );
-    if (name === '' && prop === 'params')
-      return base.returns || annotateCreate( base, name, base, 'returns' );
-    const dict = base[prop] || (base[prop] = Object.create( null ));
-    if (name == null)
-      return dict;
-    return dict[name] || annotateCreate( dict, name, base );
-  }
+    const realArt = outerArtifact( art ); // e.g. if `art = realArt.items`
 
-  function annotateBase( art ) {
-    while (art._outer)          // TODO: think about anonymous target aspect
-      art = art._outer;
-    if (art.kind === 'annotate')
-      return art;
+    // params: no new params can be added via extend yet (annotation is ok)
+    if (!art.params && extensions?.params &&
+        (art.kind === 'action' || art.kind === 'function' ||
+         art.kind === 'entity' && art.query))
+      art.params = Object.create(null); // for moveDictExtensions()
 
-    // TODO: more to do if annotate can have `returns` property
-    if (art.kind === 'select')
-      art = art._parent;
-    if (art._main)
-      return annotateFor( art._parent, kindProperties[art.kind].dict, art.name.id );
+    // foreign keys: TODO - do something here?
 
-    const { id } = art.name;
-    return model.$collectedExtensions[id] ||
-           annotateCreate( model.$collectedExtensions, id );
-  }
+    const { elements } = art;
+    if (extensions?.$add) {
+      for (const ext of extensions.$add)
+        addExtensionEnum( ext, realArt, art );
+    }
 
-  function annotateCreate( dict, id, parent, prop ) {
-    const annotate = {
-      kind: 'annotate',
-      name: { id, location: genLocation },
-      $inferred: '',
-      location: genLocation,
-    };
-    if (parent) {
-      setLink( annotate, '_parent', parent );
-      setLink( annotate, '_main', parent._main || parent );
+    if (!elements)    // elements and actions can only added to defs with elements
+      return;
+    // elements: direct includes + elements → extended includes + elements
+    if (includes?.some( i => i._artifact?.elements ) ||
+        extensions?.$add?.some( e => e.elements || e.enum )) {
+      // TODO: calculate $add here, not in extendArtifactBefore(), consider
+      // unreleated layer messages (elements + includes with elements)
+      art.elements = Object.create( null );
+      art.elements[$location] = elements[$location];
+      if (elements[$inferred])
+        art.elements[$inferred] = elements[$inferred];
+      const def = { elements, includes: includes?.$original || includes };
+      const postponeFirst = postponeFirstInclude( def.includes, elements );
+      let addedLast = addExtensionMembers( def, realArt, art, 'elements', postponeFirst );
+      for (const ext of extensions?.$add || []) {
+        const extInclude = ext.includes?.[0];
+        if (extInclude) {
+          const postpone = extInclude.$postponeInclude ?? 0;
+          extInclude.$postponeInclude = postpone + addedLast;
+          addedLast = addExtensionMembers( ext, realArt, art, 'elements', postpone );
+        }
+        else {
+          addedLast += addExtensionMembers( ext, realArt, art, 'elements', -1 );
+        }
+      }
+      if (includes)
+        reportRedefinitionThroughIncludes( art, 'elements' );
+    }
+
+    // actions: via includes (also extended ones) → direct actions → extended actions
+    if (art.kind === 'type') {  // TODO: what about event ?
+      if (includes)
+        reportTypeIncludesWithActions( art );
+    }
+    else if ((art.kind === 'entity' || art.kind === 'aspect') &&
+             (extensions?.actions || includes?.some( ref => ref._artifact?.actions ))) {
+      const { actions } = art;
+      art.actions = Object.create( null );
+      if (actions)
+        art.actions[$location] = actions[$location];
+      for (const ref of includes || [])
+        applyInclude( ref, null, art, 'actions' );
+      if (actions)
+        addExtensionMembers( { actions }, art, art, 'actions' );
+      for (const ext of extensions?.actions || [])
+        addExtensionMembers( ext, art, art, 'actions' );
+      if (includes)
+        reportRedefinitionThroughIncludes( art, 'actions' );
     }
-    dict[prop || id] = annotate;
-    return annotate;
   }
 
-  function checkReturnsExtension( ext, art ) {
-    const msgId = hasSecurityAnno( ext.returns )
-      ? 'ext-unexpected-returns-sec'
-      : 'ext-unexpected-returns';
-    message( msgId, [ ext.returns.location, ext ],
-             { '#': art.kind, keyword: 'returns' } );
-    // Do not put completely wrong returns into a “super annotate” statement;
-    // this could induce consequential errors with [..., …]:
-    return art.kind === 'action' || art.kind === 'function';
-  }
+  function addExtensionMembers( ext, art, obj, prop, postpone = -1 ) {
+    if (ext.kind)
+      dependsOnSilent( art, ext ); // TODO: really do that here?
+    if (ext.kind === 'annotate') // is also used for extensions.actions
+      return 0;
+      // art depends silently on ext (inverse to normal dep!), still necessary?
+    const { includes } = ext;
+    const extDict = ext[prop];
+    if (!extDict && !includes?.some( i => i._artifact?.[prop] ))
+      return 0;
 
-  function extendHandleReturns( ext, art ) {
-    warning( 'ext-expecting-returns', [ ext.name.location, ext ], {
-      '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
-    }, {
-      std: 'Expected $(CODE)', // unused variant
-      action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
-      function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
-      // eslint-disable-next-line @stylistic/max-len
-      annotate: 'Expected $(KEYWORD) when annotating a return structure of an unknown action or function, i.e. $(CODE)',
-    } );
+    const artDict = obj[prop];
+    if (ext.kind &&
+        (obj.$inferred || artDict?.[$inferred] || art.query && prop === 'elements') &&
+        (extDict || ext.includes))
+      reportExtensionOnGenerated( ext, art, prop, extDict );
+    let index = 0;
+    for (const name in extDict || {}) { // remark: `|| {}` not really necessary
+      const adding = extDict[name];
+      if (adding.kind === 'annotate' || adding.kind === 'extend')
+        continue;
+      while (postpone === 0)
+        postpone = applyInclude( includes[index++], includes[index], art, prop );
+      const existing = artDict[name];
+      if (!existing || existing.$inferred === 'include')
+        artDict[name] = adding;
+      else
+        dictAdd( artDict, name, adding, reportDuplicate );
+      initMember( adding, art, prop );
+      if (!adding.$inferred)    // not for derived members (with aspect include)
+        --postpone;             // also when members shadows included one
+    }
+    if (prop !== 'elements' || !includes?.[index])
+      return -1 - postpone;       // number of elements added last (after includes)
+    while (index < includes.length)
+      applyInclude( includes[index++], null, art, prop );
+    return 0;
   }
 
-  function checkRemainingMemberExtensions( parent, ext, prop, name ) {
-    // console.log('CRME:',prop,name,parent,ext)
-
-    // TODO: just use `ext-undefined-element` etc also when no elements are there
-    // at all (but use an extra text variant and the `{…}` location).  Reason: we
-    // might allow to add new actions, and an `annotate` on an undefined action
-    // should not lead to another message id.  We would use and extra message id
-    // if we consider this an error or such sub annotates are then ignored
-    // (i.e. not put into the "super annotate").
-    const dict = parent[prop];
-    const securityRelevant = hasSecurityAnno( ext ) ? '-sec' : '';
-    const inSuperAnnotate = (parent.kind === 'annotate');
-    if (!dict && !securityRelevant) {
-      if (inSuperAnnotate)      // no check in super annotate statement
-        return;
-      // TODO: check - for each name? - better locations
-      const location = ext._parent?.[prop]?.[$location] || ext.name.location;
-      // Remark: no `elements` dict location with `annotate Main:elem`
-      switch (prop) {
-        // TODO: change texts, somehow similar to checkDefinitions() ?
-        case 'foreignKeys':
-        case 'elements':
-        case 'enum':            // TODO: extra?
-          warning( 'anno-unexpected-elements', [ location, ext._parent ],
-                   { '#': (parent._effectiveType?.kind === 'entity') ? 'entity' : 'std' }, {
-                     std: 'Elements only exist in entities, types or typed constructs',
-                     entity: 'Elements of entity types can\'t be annotated',
-                     // TODO: extra msg for 'entity'? → this is some other
-                     // situation, somehow similar when trying to annotate elements
-                     // of target entity
-                   } );
-          break;
-        case 'params':
-          warning( 'anno-unexpected-params', [ location, ext._parent ], {},
-                   'Parameters only exist for actions or functions' );
-          break;
-        case 'actions':
-          if (canBeDraftMember( name, parent, draftBoundActions ))
-            return;
-          // TODO: use extra text variant and location of dictionary - no
-          notFound( 'ext-undefined-action', ext.name.location, ext,
-                    { '#': 'action', art: parent, name } );
-          break;
-        default:
-          if (model.options.testMode)
-            throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
-      }
+  function addExtensionEnum( ext, art, obj ) {
+    // TODO: test `extend Enum with Include;
+    const artDict = obj.enum;
+    if (!artDict) {
+      if (ext.enum)
+        error( 'def-unexpected-enum', [ ext.enum[$location] || ext.name.location, ext ], {} );
+      return;
     }
-    else if (!dict?.[name]) {
-      if (inSuperAnnotate && !securityRelevant)
-        return;       // there was already a warning for the parent
-      // TODO: make variant `returns` an auto-variant for ($ART) ?
-      const inReturns = parent._parent?.returns;
-      switch (prop) {
-        case 'elements':
-          if (canBeDraftMember( name, parent, draftElements ))
-            break;
-          notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
-                    { '#': (inReturns ? 'returns' : 'element'), name },
-                    parent.elements );
-          break;
-        case 'enum':            // TODO: extra msg id?
-          notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
-                    { '#': (inReturns ? 'enum-returns' : 'enum'), name },
-                    parent.enum );
-          break;
-        case 'foreignKeys':
-          notFound( `ext-undefined-key${ securityRelevant }`, ext.name.location, ext,
-                    { name }, parent.foreignKeys );
-          break;
-        case 'params':
-          notFound( `ext-undefined-param${ securityRelevant }`, ext.name.location, ext,
-                    { '#': 'param', name },
-                    parent.params );
-          break;
-        case 'actions':
-          if (canBeDraftMember( name, parent, draftBoundActions ))
-            break;
-          notFound( `ext-undefined-action${ securityRelevant }`, ext.name.location, ext,
-                    { '#': 'action', name },
-                    parent.actions );
-          break;
-        default:
-          if (model.options.testMode)
-            throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
+    if (ext.kind)
+      dependsOnSilent( art, ext ); // TODO: really do that here?
+      // art depends silently on ext (inverse to normal dep!), still necessary?
+    const extDict = ext.enum || ext.elements;
+    if (!extDict)               // i.e. includes-only extension
+      return;
+    const notEnum = [];
+    if (ext.kind && (art.$inferred || art.query))
+      reportExtensionOnGenerated( ext, art, 'enum', extDict );
+    for (const name in extDict) {
+      const adding = extDict[name];
+      if (adding.kind === 'annotate' || adding.kind === 'extend')
+        continue;
+      if (adding.kind === 'enum' || adding.$syntax === 'or-enum') {
+        notEnum.addedAnyway = true;
+        adding.kind = 'enum';
+        initMember( adding, art, 'enum' );
+        dictAdd( artDict, name, adding, reportDuplicate );
+      }
+      else {
+        notEnum.push( name );   // not added to enum dict!
       }
     }
+    if (notEnum.length) {
+      error( 'ext-unexpected-element', [ extDict[$location], ext ],
+             { code: 'extend … with enum', names: notEnum } );
+    }
+    else if (notEnum.addedAnyway &&
+            (!obj.type || obj.type.$inferred || (art._main || art).query)) {
+      // TODO: really improve msg id and text
+      error( 'extend-type', [ extDict[$location], ext ], {},
+             'Only structures or enum types can be extended with elements/enums' );
+    }
+    else if (!ext.enum) {
+      warning( 'ext-expecting-enum', [ extDict[$location], ext ],
+               { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
+    }
   }
 
-  function notFound( msgId, location, address, args, validDict ) {
-    const msg = message( msgId, [ location, address ], args );
-    attachAndEmitValidNames( msg, validDict );
+  function postponeFirstInclude( includes, members ) {
+    if (!includes?.length)
+      return -1;
+    const postpone = includes[0].$postponeInclude;
+    if (postpone != null || !members) // TODO v8: `(postpone !== -1)`
+      return postpone ?? 0;
+    // compatibility: includes in definition - if elements cover all elements from
+    // includes, use provided order - TODO v8: only for CSN input
+    for (const ref of includes) {
+      const elements = ref._artifact?.elements;
+      if (elements && Object.keys( elements ).some( name => !members[name] ))
+        return 0;       // some element in some include not covered → normal order
+    }
+    return -1;                  // includes last = use provided element order
   }
 
-  // For createRemainingAnnotateStatements(): -----------------------------------
+  function applyInclude( ref, nextRef, art, prop ) {
+    const include = ref._artifact; // already resolved
+    const members = include?.[prop];
+    if (!members)
+      return nextRef ? nextRef.$postponeInclude ?? 0 : -1;
 
-  function createSuperAnnotate( annotate ) {
-    const extensions = annotate._extensions;
-    if (extensions && !annotate._main) {
+    // If elements `texts` and `localized` from an included entity are (likely)
+    // compiler-generated, users won't expect them to be included:
+    const checkForLocalized = prop === 'elements' && include.kind === 'entity' &&
+      !include.query && withLocalizedData( include );
+    const propagateKeys = art.kind !== 'type' || model.options.v6KeyPropagation;
+
+    for (const name in members) {
+      const existing = art[prop][name];
+      if (existing && existing.$inferred !== 'include' ||
+          checkForLocalized && (name === 'texts' || name === 'localized'))
+        continue;   // shadowed by directly defined/extended element, or localized
+      const origin = members[name];
+      if (origin.$duplicates)   // duplicates are not included
+        continue;
+      const location = weakRefLocation( ref );
+      const proxy = linkToOrigin( origin, name, null, null, location );
+      setLink( proxy, '_block', origin._block ); // TODO: why is this necessary?
+      proxy.$inferred = 'include';
+      if (origin.key && propagateKeys)
+        proxy.key = Object.assign( { $inferred: 'include' }, origin.key );
+      // TODO: origin.$syntax === 'calc' test?
+      if (origin.value && origin.$syntax === 'calc') {
+        // TODO: If paths become invalid in the new artifact, should we mark
+        //       all usages in the expressions? Possibly just the first one?
+        proxy.value = { $inferred: 'include', ...copyExpr( origin.value, location, true ) };
+        proxy.$syntax = 'calc';
+        createAndLinkCalcDepElement( proxy );
+        setLink( proxy, '_calcOrigin', origin._calcOrigin || origin );
+      }
+
+      setLink( proxy, '_parent', art );
+      setLink( proxy, '_main', art );
+      initMember( proxy, art );
+      dictAdd( art[prop], name, proxy );
+      // delayed reporting of duplicates via reportRedefinitionThroughIncludes()
+    }
+    return nextRef ? nextRef.$postponeInclude ?? 0 : -1;
+  }
+
+  /**
+   * Return true if include (with `name` and `elements`) in `ext` highly likely
+   * contain elements `texts` and `localized` which are compiler-generated for
+   * localized data.  Due to recompilation, we cannot just check the `$inferred`
+   * property in the XSN, but need to apply an heuristics.
+   * (We could still use $inferred as speed-up if run without `testMode`.)
+   *
+   * It is as follows: the elements `texts` and `localized` in entity `‹E›` and
+   * the entity `‹E›.texts` are considered compiler-generated for Localized Data if
+   *
+   *  - `‹E›.texts` has a key element `locale`
+   *    (TODO: currently weakend to “entity exists”)
+   *  - `texts` of `‹E›` is an unmanaged composition to `‹E›.texts`
+   *  - `localized` of `‹E›` is an unmanaged association to `‹E›.texts`
+   */
+  function withLocalizedData( { name, elements } ) { // TODO: use it again
+    const textsEntityName = `${ name.id }.texts`;
+    // if we test (again) for element `locale` - it might come from an extend or
+    // TextsAspect include, which might not have yet applied
+    if (!model.definitions[textsEntityName])
+      return false;
+    const { texts, localized } = elements ?? {};
+    return texts?.target && localized?.target && texts.on && localized.on &&
+      resolveUncheckedPath( texts.target, 'target', texts ) === textsEntityName &&
+      resolveUncheckedPath( localized.target, 'target', localized ) === textsEntityName &&
+      resolveUncheckedPath( texts.type, 'type', texts ) === 'cds.Composition' &&
+      resolveUncheckedPath( localized.type, 'type', localized ) === 'cds.Association';
+  }
+
+  function initMember( member, parent, prop = 'elements' ) {
+    if (member._parent === parent) // origin element → nothing to do
+      return;
+    changeParentLinks( member, parent );
+    if (member.targetAspect?.elements)
+      setLink( member.targetAspect, '_parent', member._parent );
+
+    if (member.kind === 'action' || member.kind === 'function')
+      initBoundSelfParam( member.params, member._main );
+
+    if (parent[prop]?.[$inferred])
+      setExpandStatus( parent, 'extend' );
+
+    if (member.$syntax === 'or-enum' && member.value && member.kind === 'element') {
+      member.$syntax = 'calc';
+      createAndLinkCalcDepElement( member );
+    }
+  }
+
+  function changeParentLinks( art, parentOrMain ) { // or just `parentOrMain`?
+    // TODO: we might also change the implicit name (if name.id is a number,
+    // adding the previous column lenght - 1) for better error messages
+    if (art._parent?.kind === 'extend')
+      setLink( art, '_parent', parentOrMain );
+    if (art._outer?.kind === 'extend')
+      setLink( art, '_outer', parentOrMain );
+    if (art._main?.kind === 'extend')
+      setLink( art, '_main', parentOrMain._main || parentOrMain );
+    if (art._columnParent?.kind === 'extend')
+      art._columnParent = parentOrMain;
+    const subColumns = art.expand || art.inline;
+    if (subColumns)
+      subColumns.forEach( a => changeParentLinks( a, parentOrMain ) );
+    forEachMember( initItemsLinks( art, art._block ),
+                   a => changeParentLinks( a, parentOrMain ) );
+  }
+
+  // Create “super” ANNOTATE statements -----------------------------------------
+
+  /**
+   * Create super annotate statements for remaining extensions.
+   * Called near the end of the compilation.
+   */
+  function createRemainingAnnotateStatements() {
+    model.extensions = Object.values( model.$collectedExtensions );
+    // TODO: testMode sort?
+    model.extensions.forEach( createSuperAnnotate );
+    // set _artifact links for “main extensions” late as it would disturb the
+    // still existing old extend mechanism, see extendArtifactBefore(),
+    // needed for LSP and friends:
+    Object.values( model.sources ).forEach( setArtifactLinkForExtensions );
+    Object.values( model.definitions ).forEach( setArtifactLinkForExtensions );
+  }
+
+  function createSuperAnnotate( annotate ) {
+    const extensions = annotate._extensions;
+    if (extensions && !annotate._main) {
       const art = model.definitions[annotate.name.id];
       for (const ext of extensions)
-        checkRemainingMainExtensions( art, ext ); // induce messages for extension path
+        reportExtensionOnBuiltin( art, ext ); // induce messages for extension path
       if (art?.builtin && art.kind !== 'namespace') { // TODO: do not set `builtin` on cds, cds.hana
         setLink( annotate, '_extensions', art._extensions ); // for messages and member extensions
         // direct annotations on builtins or on the builtins for propagation, and
@@ -1108,716 +1102,559 @@ function extend( model ) {
     forEachMember( annotate, createSuperAnnotate );
   }
 
-  function checkRemainingMainExtensions( art, ext ) {
-    const refCtx = extensionRefContext( ext );
-    if (resolvePath( ext.name, refCtx, ext ) && art?.builtin) {
-      if (ext.kind === 'extend') {
-        // extending built-ins with elements/enums already gives an error
-        warning( 'ext-unexpected-builtin', [ ext.name.location, ext ], {}, // error v8?
-                 'Built-in types should not be extended' ); // keep the text general
-        const typeProp = typeParameters.list.find( p => ext[p] );
-        if (typeProp) {
-          const location = ext.$typeArgs?.[$location] || ext[typeProp].location;
-          message( 'ext-unexpected-type-property', [ location, ext ], {}, // error v7
-                   'Built-in types can\'t be extended with type properties' );
-          // see also 'ext-invalid-type-property'
-        }
-      }
-      else {
-        info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
-      }
-      // TODO: remove built-ins as CC candidates via accept property of ./shared.js
-    }
-  }
-
-  // Issue messages for annotations on namespaces and builtins
-  // (TODO: really here?, probably split main artifacts vs returns)
-  // see also createRemainingAnnotateStatements() where similar messages are reported
-  function checkAnnotate( construct, art ) {
-    // TODO: Handle extend statements properly: Different message for empty extend?
+  // TODO: delete again - if not, what about extensions in contexts/services?
+  //       Check test.lsp-api.js! Links in extensions are needed.
+  function setArtifactLinkForExtensions( source ) {
+    if (!source.extensions)
+      return;
+    for (const ext of source.extensions) {
+      if (!ext.name?.id)
+        continue;
 
-    // --> without art._block, art not found
-    if (construct.kind === 'annotate' && art._block?.$frontend === 'cdl') {
-      if (construct.returns && art.kind !== 'action' && art.kind !== 'function' ) {
-        // See moveReturnsExtensions()
+      const { name } = ext;
+      const { path } = name;
+      if (name._artifact === undefined) {
+        resolvePath( name, ext.kind, ext ); // induce error & for LSP
       }
-      else if (!construct.returns &&
-          (art.kind === 'action' || art.kind === 'function') && construct.elements) {
-        warning( 'ext-expecting-returns', [ construct.name.location, construct ], {
-          '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
-        }, {
-          std: 'Expected $(CODE)', // unused variant
-          action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
-          function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
-        } );
+      else if (model.options.lspMode && path?.[0]._artifact === undefined) {
+        // we don't use resolvePath(…,'extend'), as that would add a dependency
+        resolveDefinitionName( ext );
+        setArtifactLink( path[path.length - 1], name._artifact );
       }
     }
   }
 
-  // extend, mainly old-style ---------------------------------------------------
-
-  function addedElements( art ) {
-    return Object.values( art.elements )
-      .reduce( ( acc, elem ) => (elem.kind === 'extend' ? acc : acc + 1), 0 );
+  function annotateFor( art, prop, name ) {
+    const base = annotateBase( art );
+    if (name === '' && prop === 'params')
+      return base.returns || annotateCreate( base, name, base, 'returns' );
+    const dict = base[prop] || (base[prop] = Object.create( null ));
+    if (name == null)
+      return dict;
+    return dict[name] || annotateCreate( dict, name, base );
   }
 
-  /**
-   * Extend artifact with additional elements and actions: via includes and/or
-   * extensions.  This happens _after_ `populateArtifact`, i.e. after eventually
-   * having inferred the elements/... from an "origin".
-   */
-  function extendArtifactAdd( art ) {
-    const { includes } = art;
-    if (includes) {
-      if (includes.$original)              // if extensions with includes:
-        art.includes = includes.$original; // original includes have been stored
-      if (art.includes?.length)
-        applyIncludes( art, art ); // apply includes provided with definition
-      else if (art.elements)       // next include only after elements so far
-        art.$postponeInclude += addedElements( art );
-
-      art.includes = includes;
-      // early propagation of specific annotation assignments
-      // TODO: propagate in effectiveType() ?
-      propagateEarly( art, '@cds.autoexpose' );
-      propagateEarly( art, '@fiori.draft.enabled' );
-    }
-    if (art._extensions?.$add)
-      extendArtifact( art._extensions.$add, art ); // apply extensions
-    checkRedefinitionThroughIncludes( art, 'elements' );
-    checkRedefinitionThroughIncludes( art, 'actions' );
-  }
+  function annotateBase( art ) {
+    while (art._outer)          // TODO: think about anonymous target aspect
+      art = art._outer;
+    if (art.kind === 'annotate')
+      return art;
 
-  /**
-   * Extend artifact `art` by `extensions`.  `cyclicIncludeNames` can have values:
-   * - falsy: try to apply include, then perform extend and annotate
-   * - an array of include names with cyclic dependencies: includes are not applied,
-   *   extend and annotate is performed
-   *   remark: we could have applied includes without cycle
-   *
-   * Returns true if extend and annotate are performed.
-   *
-   * @param {XSN.Extension[]} extensions
-   * @param {XSN.Definition} art
-   * @param {String[]|false} [cyclicIncludeNames=false]
-   */
-  function extendArtifact( extensions, art ) {
-    if (!art.query && !art._main && !art._outer) { // TODO: remove _entities
-      model._entities.push( art ); // add structure with includes in dep order
-    }
-    // TODO: complain if $inferred
-    // checkExtensionsKind( extensions, art );
-    extendMembers( extensions, art );
-    reportIncludeCollisions( art );
-    // TODO: complain about element extensions inside projection
-    return true;
+    // TODO: more to do if annotate can have `returns` property
+    if (art.kind === 'select')
+      art = art._parent;
+    if (art._main)
+      return annotateFor( art._parent, kindProperties[art.kind].dict, art.name.id );
+
+    const { id } = art.name;
+    return model.$collectedExtensions[id] ||
+           annotateCreate( model.$collectedExtensions, id );
   }
 
-  function reportIncludeCollisions( art ) {
-    const grouped = Object.create( null );
-    for (const {
-      prop, name, existing, elem,
-    } of includeCollisions) {
-      const key = `${ prop }:${ name }`;
-      if (!grouped[key])
-        grouped[key] = { prop, name, collisions: new Set( [ existing ] ) };
-      grouped[key].collisions.add( elem );
-    }
-    for (const key in grouped) {
-      const { prop, name, collisions } = grouped[key];
-      const member = art[prop]?.[name];
-      if (member?.$inferred === 'include') {
-        const arts = [ ...collisions ].map( m => m._origin._main );
-        message( 'ext-duplicate-include', [ art.name.location, member ],
-                 { '#': prop, name, sorted_arts: arts } );
-      }
+  function annotateCreate( dict, id, parent, prop ) {
+    const annotate = {
+      __proto__: XsnArtifact.prototype,
+      kind: 'annotate',
+      name: { __proto__: XsnName.prototype, id, location: genLocation },
+      $inferred: '',
+      location: genLocation,
+    };
+    if (parent) {
+      setLink( annotate, '_parent', parent );
+      setLink( annotate, '_main', parent._main || parent );
     }
-    includeCollisions.length = 0;
+    dict[prop || id] = annotate;
+    return annotate;
   }
 
-  function extendMembers( extensions, art ) {
-    // only called in extendArtifact()
-    // TODO: do the whole extension stuff lazily if the elements are requested
-    const elemExtensions = [];
-    // if (art._main)              // extensions already sorted for main artifacts
-    //   extensions.sort( layers.compareLayer );
-    // TODO: use same sequence as in chooseAssignment() - better: use common code with that fn
-    // console.log('EM:',art.name,extensions,art._extensions)
-    for (const ext of extensions) { // those in extMap.includes
-      if (art.$inferred === 'include') {
-        error( 'ref-expected-direct-structure', [ ext.name.location, ext ],
-               { '#': 'elements', art } );
-      }
-      else if (art.$inferred) {
-        error( 'extend-for-generated', [ ext.name.location, ext ], { art, keyword: 'extend' },
-               'You can\'t use $(KEYWORD) on the generated $(ART)' ); // or with inferred elements
-      }
+  // Issue messages about dubious extensions ------------------------------------
+  // checkXYZ() = return whether to extend, reportXYZ() = extend anyway
 
-
-      // console.log(message( 'id', [ext.location, ext], { art: ext.name._artifact },
-      //                      'Info', 'EXT').toString())
-      setArtifactLink( ext.name, art ); // TODO: probably already done
-      if (ext.includes)
-        applyIncludes( ext, art ); // moves included elem to extension(! TODO: recheck)
-      else if (ext.elements)
-        art.$postponeInclude += addedElements( ext );
-
-      // console.log(ext,art)
-      checkAnnotate( ext, art );
-      // TODO: do we allow to add elements with array of {...}?  If yes, adapt
-      initMembers( ext, art, ext._block ); // might set _extend, _annotate
-      dependsOnSilent( art, ext ); // art depends silently on ext (inverse to normal dep!)
-
-      for (const name in ext.elements) {
-        const elem = ext.elements[name];
-        if (elem.kind === 'element') { // i.e. not extend or annotate
-          elemExtensions.push( elem );
-          break;                // more than one elem in same EXTEND is fine
+  // called from extendArtifactAfter()
+  function checkExtensionDictionary( ext, art, artProp, extProp ) {
+    if (art.kind === 'annotate') // the super annotate
+      return true;
+    // assume dict not on art
+    const dict = ext[extProp];
+    const location = dict?.[$location] ||
+      dictFirst( dict )?.name?.location || // for `annotate E:elem`
+      ext.name.location;
+    switch (artProp) {
+      case 'params':
+        // currently just via `annotate`, TODO: test w/ CSN input
+        warning( 'anno-unexpected-params', [ location, ext ], {},
+                 'Parameters only exist for actions or functions' );
+        // TODO text: or query entities
+        break;
+      case 'actions':
+        // extendArtifactAdd() had created actions prop with correct actions extensions
+        if (ext.kind === 'extend' && Object.keys( dict ).length) {
+          error( 'def-unexpected-actions', [ location, ext ], {}, // TODO: ext-
+                 'Actions and functions only exist top-level and for entities' ); // or aspects
+        }
+        else {                  // annotate or empty dict
+          warning( 'ext-ignoring-actions', [ location, ext ], {},
+                   'Actions and functions only exist top-level and for entities' );
+          return true;
+        }
+        break;
+      case 'elements':
+        if (ext.kind === 'annotate') {
+          warning( 'anno-unexpected-elements', [ location, ext ],
+                   { '#': art.type?._artifact?.kind } );
+          // extra msg variant for entity as parameter type
+        }
+        else if (ext.kind === 'extend' && Object.keys( dict ).length) {
+          // TODO v8: also error with empty dict
+          const msgid = [ 'type', 'aspect' ].includes( art.kind )
+            ? 'extend-type'
+            : 'def-unexpected-elements';
+          error( msgid, [ location, ext ], {} );
+        }
+        else {                  // annotate or empty dict
+          warning( 'ext-ignoring-elements', [ location, ext ], {},
+                   'Only structures with directly specified elements can be extended by elements' );
+          return true;
+        }
+        break;
+      case 'enum':
+        if (ext.kind === 'extend') {
+          const msgid = art.kind === 'type' ? 'extend-type' : 'def-unexpected-enum';
+          error( msgid, [ location, ext ], {} );
         }
+        break;
+      case 'foreignKeys': {
+        // currently just via `annotate`
+        warning( 'ext-undefined-key', [ location, ext ], { '#': 'dict' } );
+        break;
       }
+      default:
+        if (model.options.testMode)
+          throw new CompilerAssertion(`Missing case for prop: ${ artProp }`);
     }
-    if (elemExtensions.length > 1)
-      reportUnstableExtensions( elemExtensions ); // TODO: still?
+    return ext.kind === 'annotate';
+    // Remark: to detect security-relevant annotation on (sub) members,
+    // super-annotates must be created (→ return true) when no error is reported.
+  }
 
-    // This whole function will be removed with a next change - no need to have nice code here:
-    const dict = Object.create( null );
-    // actions cannot be extended anyway. TODO: there should be a message
-    // (possible with CSN input), but that was missing before this change, too.
-    for (const e of extensions) {
-      if (!e.elements)
-        continue;
-      for (const n in e.elements) {
-        if (e.elements[n].kind === 'extend')
-          pushToDict( dict, n, e.elements[n] );
-      }
-    }
-    for (const name in dict) {
-      let obj = art;
-      if (obj.targetAspect)
-        obj = obj.targetAspect;
-      while (obj.items)
-        obj = obj.items;
-      const validDict = obj.elements || obj.enum;
-      const member = validDict && validDict[name];
-      if (!member)
-        extendNothing( dict[name], 'elements', name, art, validDict );
-    }
+  function reportDuplicate( name, location, art ) {
+    if (art.$duplicates)        // already reported in define.js
+      return;
+    error( 'duplicate-definition', [ art.name.location, art ], {
+      name: art.name.id,
+      '#': kindProperties[art.kind].normalized || art.kind,
+    } );
   }
 
-  /**
-   * Report 'Warning: Unstable element order due to repeated extensions'
-   * except if all extensions are in the same file.
-   *
-   * @param {XSN.Extension[]} extensions
-   */
-  function reportUnstableExtensions( extensions ) {
-    // No message if all extensions are in the same file:
-    const file = layers.realname( extensions[0] );
-    if (extensions.every( ( ext, i ) => !i || file === layers.realname( ext ) ))
+  function reportUnexpectedMemberExtensions( parent, ext, prop, name ) {
+    const securityRelevant = hasSecurityAnno( ext ) ? '-sec' : '';
+    const dict = (parent.kind === 'annotate') ? null : parent[prop];
+    // real dictionary, not just one in the super-annotate
+
+    // checkExtensionDictionary() had complained about extension with unexpected
+    // dict property → new message just for missing art member (or if security
+    // relevant)
+    if (dict ? dict[name] : !securityRelevant)
       return;
-    // Similar to chooseAssignment(), TODO there: also extra intralayer message
-    // as this is a modeling error
-    let lastExt = null;
-    let open = [];              // the "highest" layers
-    for (const ext of extensions) {
-      const extLayer = layers.layer( ext ) ||
-          { realname: '', _layerExtends: Object.create( null ) };
-      if (!open.length) {
-        lastExt = ext;
-        open = [ extLayer.realname ];
-      }
-      else if (extLayer.realname === open[open.length - 1]) { // in same layer
-        if (lastExt) {
-          message( 'extend-repeated-intralayer', [ lastExt.location, lastExt ] );
-          lastExt = null;
-        }
-        message( 'extend-repeated-intralayer', [ ext.location, ext ] );
+
+    // Remark: there can currently be just an extend in elements/enum, not actions etc
+    switch (prop) {
+      case 'elements':
+      case 'enum': {
+        if (ext.kind === 'annotate' && parent.kind === 'entity' &&
+            canBeDraftMember( name, parent, draftElements ))
+          break;
+        const msgId = (ext.kind === 'extend')
+          ? 'extend-undefined'
+          : `ext-undefined-element${ securityRelevant }`;
+        // eslint-disable-next-line no-nested-ternary
+        const msgVn = (!parent._parent?.returns)
+          ? prop
+          : (prop === 'enum' ? 'enum-returns' : 'returns');
+        notFound( msgId, ext.name.location, ext,
+                  { '#': msgVn, name, art: parent },
+                  dict );
+        break;
       }
-      else {
-        if (lastExt && (open.length > 1 || !extLayer._layerExtends[open[0]])) {
-          // report for lastExt if that is unrelated to other open exts or current ext
-          message( 'extend-unrelated-layer', [ lastExt.location, lastExt ], {},
-                   'Unstable element order due to other extension in unrelated layer' );
-        }
-        lastExt = ext;
-        open = open.filter( name => !extLayer._layerExtends[name] );
-        open.push( extLayer.realname );
+      case 'foreignKeys': {
+        notFound( `ext-undefined-key${ securityRelevant }`, ext.name.location, ext,
+                  { name }, parent.foreignKeys );
+        break;
       }
+      case 'params':
+        notFound( `ext-undefined-param${ securityRelevant }`, ext.name.location, ext,
+                  { '#': 'param', name },
+                  dict );
+        break;
+      case 'actions':
+        if (ext.kind === 'annotate' && parent.kind === 'entity' &&
+            canBeDraftMember( name, parent, draftBoundActions ))
+          break;
+        notFound( `ext-undefined-action${ securityRelevant }`, ext.name.location, ext,
+                  { '#': 'action', name },
+                  dict );
+        break;
+      default:
+        if (model.options.testMode)
+          throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
     }
   }
 
-
   /**
-   * @param {XSN.Extension[]} extensions
-   * @param {string} prop
-   * @param {string} name
-   * @param {XSN.Artifact} art
-   * @param {object} validDict
+   * Complain about invalid `extend service` and `extend context`.
+   * Called in extendArtifactBefore().
    */
-  function extendNothing( extensions, prop, name, art, validDict ) {
-    // TODO: probably too much magic in the creation of artName…
-    const extMain = { ...(art._main || art) };
-    const artName = searchName( art, name, dictKinds[prop] );
-    setLink( artName, '_main', extMain );
+  function reportInvalidExtensionKind( extensions, art ) {
     for (const ext of extensions) {
-      // TODO: use shared functionality with notFound in resolver.js
-      const { location } = ext.name;
-      extMain.kind = ext.kind;
-      const msg = error( 'extend-undefined', [ location, artName ], { art: artName }, {
-        std: 'Unknown $(ART) - nothing to extend',
-        element: 'Artifact $(ART) has no element or enum $(MEMBER) - nothing to extend',
-        action: 'Artifact $(ART) has no action $(MEMBER) - nothing to extend',
-      } );
-      attachAndEmitValidNames( msg, validDict );
-    }
-  }
-
-  // TODO TMP: copied from ./define.js: -----------------------------------------
-
-  /**
-   * Set property `_parent` for all elements in `parent` to `parent` and do so
-   * recursively for all sub elements.
-   *
-   * If `construct !== parent`, also copy elements to `parent`.
-   *
-   * (Only) if called recursively: `construct === parent`
-   *
-   * TODO: separate extension!
-   */
-  function initMembers( construct, parent, block ) {
-    // only called by extendMembers() and recursively
-    // TODO: split extend from init
-    const obj = initItemsLinks( construct, block );
-    initExprAnnoBlock( construct, block, error );
-    if (parent.targetAspect?.elements)
-      parent = parent.targetAspect;
-    const main = parent._main || parent;
-    const isQueryExtension = construct.kind === 'extend' && main.query;
-
-    if (obj !== parent && obj.elements && parent.enum) { // applying the extension
-      initElementsAsEnum();
-      if (parent.enum[$inferred])
-        setExpandStatus( parent, 'extend' );
-    }
-    else {
-      if (checkDefinitions( construct, parent, 'elements', obj.elements || false ))
-        forEachInOrder( obj, 'elements', init );
-      if (checkDefinitions( construct, parent, 'enum', obj.enum || false ))
-        forEachGeneric( obj, 'enum', init );
-    }
-
-    if (obj.foreignKeys)
-      forEachInOrder( obj, 'foreignKeys', init );
-    if (checkDefinitions( construct, parent, 'actions' ))
-      forEachGeneric( construct, 'actions', init );
-    if (checkDefinitions( construct, parent, 'params' ))
-      forEachInOrder( construct, 'params', init );
-    const { returns } = construct;
-    if (returns) {
-      const { kind } = construct;
-      returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
-      init( returns, '' );      // '' is special name for returns parameter
-    }
-    return;
-
-    // We allow `extend MyEnum with {…}` and not just `extend MyEnum with enum {…}`
-    // for compatibility, with a warning.
-    function initElementsAsEnum() {
-      // in extensions, extended enums are represented as elements
-      let hasElement = false;
-      for (const n in obj.elements) {
-        const e = obj.elements[n];
-        if (e.kind === 'extend')
-          continue;
-        if (e.$syntax !== 'or-enum') { // parser might set $syntax: 'or-enum'
-          // We do not want to complain separately about all element properties:
-          error( 'ext-unexpected-element', [ e.location, construct ],
-                 { name: e.name.id, code: 'extend … with enum' },
-                 // eslint-disable-next-line @stylistic/max-len
-                 'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
-          // Don't emit 'ext-expecting-enum' if this error is emitted.
-          return;
+      const kind = ext.expectedKind?.val;
+      if (kind && kind !== art.kind) {
+        const loc = ext.expectedKind.location;
+        if (kind === 'context' || kind === 'service') {
+          // We have no real artifact during the construction of a super-annotate statement:
+          const msgArgs = {
+            '#': (art.kind === 'service' || art.kind === 'annotate') ? art.kind : 'std',
+            art,
+            kind,
+            code: 'extend … with definitions',
+            keyword: 'extend service',
+          };
+          // TODO v7: Discuss: make this an error?
+          warning( 'ext-invalid-kind', [ loc, ext ], msgArgs, {
+            std: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) instead',
+            annotate: 'There is no artifact $(ART), use $(CODE) instead',
+            // do not mention 'extend context', that is not in CAPire
+            service: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) or $(KEYWORD) instead',
+          } );
         }
-        e.kind = 'enum';
-        hasElement = true;    // warning with CDL input or `name: {}` in CSN input
-      }
-      if (!parent.type || parent.type.$inferred || (parent._main || parent).query) {
-        error( 'extend-type', [ obj.elements[$location], construct ], {},
-               'Only structures or enum types can be extended with elements/enums' );
-      }
-      else if (hasElement) {
-        warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
-                 { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
+        // TODO: Use similar checks for EXTEND ENTITY etc - 'ext-ignoring-kind'
       }
-      forEachGeneric( { enum: obj.elements }, 'enum', init );
     }
+  }
 
-    function init( elem, name, prop ) {
-      if (!elem.name && !elem._outer) {
-        const ref = elem.targetElement || elem.kind === 'element' && elem.value;
-        if (ref && ref.path) {
-          elem.name = Object.assign( { $inferred: 'as' },
-                                     ref.path[ref.path.length - 1] );
-        }
-        else {                  // RETURNS, parser robustness
-          elem.name = { id: name, location: elem.location };
+  // called in createSuperAnnotate()
+  function reportExtensionOnBuiltin( art, ext ) {
+    const refCtx = extensionRefContext( ext );
+    if (resolvePath( ext.name, refCtx, ext ) && art?.builtin) {
+      if (ext.kind === 'extend') {
+        // extending built-ins with elements/enums already gives an error
+        message( 'ext-unexpected-builtin', [ ext.name.location, ext ], {},
+                 'Built-in types should not be extended' ); // keep the text general
+        // TODO v8: error - especially bad with includes extension
+        const typeProp = typeParameters.list.find( p => ext[p] );
+        if (typeProp) {
+          const location = ext.$typeArgs?.[$location] || ext[typeProp].location;
+          message( 'ext-unexpected-type-property', [ location, ext ], {}, // error v7
+                   'Built-in types can\'t be extended with type properties' );
+          // see also 'ext-invalid-type-property'
         }
       }
-
-      if (!elem._block)
-        setLink( elem, '_block', block );
-      // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
-      if ((elem.kind === 'extend' || elem.kind === 'annotate'))
-        return;
-
-      if (isQueryExtension && elem.kind === 'element') {
-        error( 'extend-query', [ elem.location, construct ], // TODO: searchName ?
-               { code: 'extend … with columns' },
-               'Use $(CODE) to add select items to the query entity' );
-        return;
-      }
-
-      const existing = parent[prop]?.[name];
-      const shadowsIncludeMember = construct !== parent &&
-        elem.$inferred !== 'include' &&
-        existing?.$inferred === 'include';
-      const add = construct !== parent && (!existing || elem.$inferred !== 'include');
-      if (!add && existing?.$inferred === 'include' && elem.$inferred === 'include') {
-        includeCollisions.push( {
-          prop, name, existing, elem,
-        } );
-      }
-      // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
-      const { $duplicates } = elem;
-      if ($duplicates === true && add)
-        elem.$duplicates = null;
-      if (add && elem.$inferred === 'include' && Array.isArray( $duplicates ))
-        elem.$duplicates = null;
-      if (shadowsIncludeMember) {
-        parent[prop][name] = elem;
-        setMemberParent( elem, name, parent );
-      }
       else {
-        setMemberParent( elem, name, parent, add && prop );
-        if (!$duplicates)       // not already reported
-          checkRedefinition( elem );
+        info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
       }
-      initMembers( elem, elem, elem._block );
-      if (elem.kind === 'action' || elem.kind === 'function')
-        initBoundSelfParam( elem.params, elem._main );
+      // TODO: remove built-ins as CC candidates via accept property of ./shared.js
+    }
+  }
 
-      // for a correct home path, setMemberParent needed to be called
+  // Called in extendArtifactAdd()
+  function reportExtensionOnGenerated( ext, art, prop, extMembers ) {
+    // Beware: if we allow element extensions later, we might still want to
+    // disallow includes with elements, see reportInvalidIncludes(); additionally,
+    // adding sub elements might still be wrong
+    const location = ext[prop]?.[$location] || ext.name.location;
+    if (ext.enum) {             // enum extension on structure
+      error( 'def-unexpected-enum', [ location, ext ], {} );
+    }
+    else if (art.$inferred === 'include') { // element of include
+      error( 'ref-expected-direct-structure', [ location, ext ],
+             { '#': 'elements', art } );
+    }
+    else if (extMembers && Object.keys( extMembers ).length ||
+             ext.includes?.some( ref => dictNonEmpty( ref._artifact.elements ))) {
+      // TODO: we could allow extMembers containing `extend`s only, but then make
+      // sure that we do not accidentially allow adding sub elements
+      error( 'extend-for-generated', [ location, ext ],
+             {                  // eslint-disable-next-line no-nested-ternary
+               '#': (art.query ? 'query' : ext.includes ? 'std' : prop),
+               art,
+               keyword: 'extend',
+             }, {
+               std: 'You can\'t use $(KEYWORD) on the generated $(ART)',
+               query: 'You can\'t use $(KEYWORD) on the query to add elements',
+               elements: 'You can\'t use $(KEYWORD) on the inferred elements of $(ART)',
+             } );
+      // TODO: for invalid includes, use specific ref-invalid-include messages
+    }
+  }
 
-      if (parent[prop]?.[$inferred])
-        setExpandStatus( parent, 'extend' );
+  // Remark: the acceptFn for resolvePath() does a first check whether includes
+  // are allowed
+  function reportInvalidIncludes( art ) {
+    const { elements } = art;
+    for (const ref of art.includes) {
+      const incl = ref._artifact;
+      if (!incl)
+        continue;
+      if (!elements && (incl.elements || incl.kind !== 'aspect'))
+        error( 'ref-invalid-include', [ ref.location, art ], { '#': 'bare' } );
+      else if ((incl.elements ? incl.elements[$inferred] : incl.kind !== 'aspect') ||
+               incl.query)     // TODO: allow query entity and inferred elems soon
+        error( 'ref-invalid-include', [ ref.location, art ] );
+    }
+  }
 
-      if (!elem.value || elem.kind !== 'element')
-        return;
-      // remark: potential enum elements have already been turned into enums
-      // -> it's a calculated element
-      if (!elem.type && elem.value?.type) {  // top-level CAST( expr AS type )
-        if (!elem.target)
-          elem.type = { ...elem.value.type, $inferred: 'cast' };
-      }
-      elem.$syntax = 'calc';
-      // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
-      createAndLinkCalcDepElement( elem );
-
-      // Special case (hack) for calculated elements that use composition+filter:
-      // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
-      if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
-        delete elem.type;
-        delete elem.on;
-        delete elem.target;
+  // Called in extendArtifactAdd()
+  function reportTypeIncludesWithActions( art ) {
+    for (const ref of art.includes || []) {
+      const incl = ref._artifact;
+      if (incl?.actions && Object.keys( incl.actions ).length) {
+        warning( 'ref-ignoring-actions', [ ref.location, art ], { art: incl },
+                 'The actions of $(ART) are not added to the type' ); // TODO: info?
       }
     }
   }
 
-  // TODO: is only necessary for extensions - make special for extend/annotate
-  function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
-    // TODO: do differently, see also annotateMembers() in resolver
-    // To have been checked by parsers:
-    // - artifacts (CDL-only anyway) only inside [extend] context|service
-    if (!dict)
-      return false;
-    const feature = kindProperties[parent.kind ?? 'element'][prop];
-    if (feature &&
-        (feature === true || construct.kind !== 'extend' || feature( prop, parent )))
-      return true;
-    const location = dict[$location];
+  // Called in extendArtifactBefore() and extendArtifactAfter()
+  function reportUnexpectedReturns( ext, art ) {
+    const msgId = hasSecurityAnno( ext.returns )
+      ? 'ext-unexpected-returns-sec'
+      : 'ext-unexpected-returns';
+    message( msgId, [ ext.returns.location, ext ],
+             { '#': art.kind, keyword: 'returns' } );
+  }
 
-    // TODO: a bit inconsistent = not a simple switch on `prop`…
-    if (prop === 'actions') {
-      if (Object.keys( dict ).length) {
-        error( 'def-unexpected-actions', [ location, construct ], {}, // TODO: ext-
-               'Actions and functions only exist top-level and for entities' ); // or aspects
-      }
-      else {
-        warning( 'ext-ignoring-actions', [ location, construct ], {},
-                 'Actions and functions only exist top-level and for entities' );
-        return false;
-      }
-    }
-    else if (parent.kind === 'action' || parent.kind === 'function') {
-      error( 'ext-unexpected-action', [ construct.location, construct ], { '#': parent.kind }, {
+  // Called in extendArtifactAfter()
+  function reportMissingReturns( ext, art ) {
+    if (ext.kind === 'extend') {
+      error( 'ext-unexpected-action', [ ext.name.location, ext ], { '#': art.kind }, {
         std: 'Actions and functions can\'t be extended, only annotated', // TODO: → ext-unsupported
         action: 'Actions can\'t be extended, only annotated',
         function: 'Functions can\'t be extended, only annotated',
       } );
     }
-    else if (prop === 'params') {
-      if (!feature) {
-        // Note: This error can't be triggered at the moment.  But as we likely want to
-        //       allow extensions with params in the future, we keep the code.
-        error( 'def-unexpected-params', [ location, construct ], {},
-               'Parameters only exist for entities, actions or functions' );
-      }
-      else {
-        // remark: we could allow this
-        error( 'extend-with-params', [ location, construct ], {},
-               'Extending artifacts with parameters is not supported' );
-      }
-    }
-    else if (feature) {         // allowed in principle, but not with extend
-      if (!Object.keys( dict ).length) {
-        warning( 'ext-ignoring-elements', [ location, construct ], {},
-                 'Only structures with directly specified elements can be extended by elements' );
-        return false;
-      }
-      else if (parent.$inferred === 'include') { // special case for better error message
-        const variant = (construct.enum || construct.elements) ? 'elements' : 'std';
-        error( 'ref-expected-direct-structure', [ location, construct ],
-               { '#': variant, art: parent } );
-      }
-      else if (prop !== 'enum' || !parent.enum ||
-               !parent.type || parent.type.$inferred || (parent._main || parent).query) {
-        error( 'extend-type', [ location, construct ], {},
-               'Only structures or enum types can be extended with elements/enums' );
-      }
-      else {
-        return true;
-      }
-    }
-    else if (prop === 'elements') {
-      error( 'def-unexpected-elements', [ location, construct ], {},
-             'Elements only exist in entities, types or typed constructs' );
-    }
-    else if (prop === 'columns') {
-      error( 'extend-columns', [ location, construct ], { art: construct } );
-    }
-    else { // if (prop === 'enum') {
-      error( 'def-unexpected-enum', [ location, construct ], {},
-             'Enum symbols can only be defined for types or typed constructs' );
+    else {
+      warning( 'ext-expecting-returns', [ ext.name.location, ext ], {
+        '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
+      }, {
+        std: 'Expected $(CODE)', // unused variant
+        action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
+        function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
+        // eslint-disable-next-line @stylistic/max-len
+        annotate: 'Expected $(KEYWORD) when annotating a return structure of an unknown action or function, i.e. $(CODE)',
+      } );
     }
-    return construct === parent;
   }
 
-
-  // includes ----------------------------------------------------------------
-
   /**
-   * Apply all includes of `ext` on `ext`.  Checks that `art` allows includes.
-   * If `ext === art`, then includes of the artifact itself are applied.
-   * If `ext !== art`, applies includes on the extensions, not artifact.
-
-   * Sets `_ancestors` links on `art` if it is an entity, collecting the entity
-   * includes with their ancestors.
-   *
-   * Examples:
-   *   ext === art:  `entity E : F {}`  => add elements of F to E
-   *   ext !== art:  `extend E with F`  => add elements of F to extension on E
-   *
-   * @param {XSN.Extension} ext
-   * @param {XSN.Artifact} art
+   * Report duplicates in parent[prop] that happen due to multiple includes having
+   * the same member.  Run after includes and extends in extendArtifactAdd() so
+   * shadowing members have already replaced any include-derived proxy.
    */
-  function setEntityIncludes( ext, art ) {
-    setLink( art, '_entityIncludes', [] );
-    for (const ref of ext.includes) {
-      const name = resolveUncheckedPath( ref, 'include', ext );
-      const template = name && model.definitions[name];
-      if (template?.kind === 'entity')
-        art._entityIncludes.push( template );
-    }
+  function reportRedefinitionThroughIncludes( parent, prop ) {
+    if (!parent[prop])
+      return;
+    forEachInOrder( parent, prop, ( member, name ) => {
+      if (member.$inferred === 'include' && Array.isArray( member.$duplicates )) {
+        const includes = [ member, ...member.$duplicates ].map( dup => dup._origin._main );
+        // TODO: 'ref-duplicate-include-member' with one message per affected include,
+        // mentioning the problematic element/action names
+        error( 'duplicate-definition', [ member.location, member ],
+               { '#': `include-${ prop }`, name, sorted_arts: includes } );
+      }
+    } );
   }
 
-  function applyIncludes( ext, art ) {
-    if (kindProperties[art.kind].include !== true) {
-      error( 'extend-unexpected-include', [ ext.includes[0]?.location, ext ],
-             { meta: art.kind } );
-      return;
+  // TODO: still a bit annotation assignment specific
+  // Called in extendArtifactBefore().
+  function reportDuplicateExtensions( extensions, prop, issue, index, art ) {
+    // TODO: think about messages for these
+    if (prop === 'elements' || prop === 'actions' || prop === 'columns' ||
+        prop === 'params' || prop === '$add' ) {
+      if (issue && (prop === '$add' || prop === 'columns'))
+        reportUnstableExtensions( extensions, issue );
+      return;                   // extensions currently handled extra
     }
-    // console.log( (ext===art?'D-INCL:':'E-INCL:'), art.kind, art.name.id,
-    //              ...ext.includes.map( r => r._artifact?.name.id ));
-    if (!art.query && art.elements) // do not set art.elements and art.enums with query entity!
-      includeMembers( ext, art, 'elements' );
 
-    if (art.kind !== 'type') {
-      includeMembers( ext, art, 'actions' );
-    }
-    else {
-      for (const ref of ext.includes) {
-        const template = ref._artifact; // already resolved
-        if (template?.actions && Object.keys( template.actions ).length) {
-          warning( 'ref-ignoring-actions', [ ref.location, ext ], { art: template },
-                   'The actions of $(ART) are not added to the type' );
+    const isTypeParam = typeParameters.list.includes( prop );
+    const isAnnoOrDoc = prop.charAt(0) === '@' || prop === 'doc';
+    if (!isAnnoOrDoc && !isTypeParam && prop !== 'orderBy')
+      return;
+    if (issue) {
+      if (prop === 'orderBy' && issue === 'unrelated') {
+        for (const ext of extensions) {
+          const clause = ext[prop];
+          if (clause) {
+            message( 'ext-unstable-order', [ clause[0]?.location || ext.location, ext ],
+                     { keyword: prop },
+                     // eslint-disable-next-line @stylistic/max-len
+                     'Unstable order of entries in the $(KEYWORD) clause due to another extension in unrelated layer' );
+          }
+        }
+        return;
+      }
+      if (isAnnoOrDoc && prop !== 'doc' &&
+          allAnnoValuesEqual( extensions, prop )) {
+        if (issue === 'unrelated')
+          return;
+        for (const ext of extensions) {
+          const anno = ext[prop];
+          if (anno) {
+            // annotations with equal value in the same layer -> warn
+            warning( 'anno-duplicate-equal', [ anno.name?.location || anno.location, ext ],
+                     { '#': 'std', anno: prop, type: art } );
+          }
+        }
+        return;
+      }
+      // eslint-disable-next-line no-nested-ternary
+      let msg = (index < 0)
+        ? 'anno-unstable-array'
+        : (issue === true)
+          ? 'anno-duplicate'
+          : 'anno-duplicate-unrelated-layer';
+      if (prop === 'includes') {
+        msg = (issue === true)
+          ? 'ext-duplicate-includes'
+          : 'ext-unstable-includes';
+        // TODO v7: location on include would be nicer
+      }
+      else if (!isAnnoOrDoc) {
+        msg = (issue === true)
+          ? 'ext-duplicate-extend-type'
+          : 'ext-duplicate-extend-type-unrelated-layer';
+        // not sure whether to repeat the extended artifact in the message (we
+        // have the semantic location, after all)
+        // extend-repeated-intralayer / extend-unrelated-layer
+      }
+      const variant = prop === 'doc' ? 'doc' : 'std';
+      for (const ext of extensions) {
+        const anno = ext[prop];
+        if (anno) {
+          message( msg, [ anno.name?.location || anno.location, ext ],
+                   { '#': variant, anno: prop, type: art } );
         }
       }
     }
+    else if (index > 0) {     // more than one set (not just ...)
+      const variant = prop === 'doc' ? 'doc' : 'std';
+      const msgid = (isAnnoOrDoc)
+        ? 'anno-duplicate-same-file' // TODO: always ext-duplicate-…
+        : 'ext-duplicate-same-file';
+      while (index >= 0) {    // do not report for trailing [...]
+        const ext = extensions[index--];
+        const anno = ext[prop];
+        warning( msgid, [ anno.name?.location || anno.location, ext ],
+                 { '#': variant, prop, anno: prop } );
+      }
+    }
   }
 
   /**
-   * Add all members (e.g. elements or actions) of `ext.includes` to `ext[prop]`.
-   * If `art` is `ext`, set the parent link accordingly.
+   * Report 'Warning: Unstable element order due to repeated extensions'
+   * except if all extensions are in the same file.
    *
-   * @param {XSN.Extension} ext
-   * @param {XSN.Artifact} art
-   * @param {string} prop 'elements' or 'actions'
+   * Called in extendArtifactBefore(), via reportDuplicateExtensions().
    */
-  function includeMembers( ext, art, prop ) {
-    // TODO two kind of messages:
-    // Error 'More than one include defines element "A"' (at include ref)
-    // Warning 'Overwrites definition from include "I" (at elem def)
-    const propagateKeys = art.kind !== 'type' || model.options.v6KeyPropagation;
-    const parent = ext === art && art;
-    const members = ext[prop];
-    // if (members)console.log( 'EXT:', prop, art.kind, art.name.id, ...Object.keys(members));
-    if (members) {
-      ext[prop] = Object.create( null );
-      ext[prop][$location] = members[$location];
-    }
-    let elementsAdded = 0;
-    let hasNewElement = false;
-    for (const ref of ext.includes) {
-      // Elements of include are added after previously provided elements:
-      if (prop === 'elements') {
-        if (ref.$postponeInclude == null) {
-          if (ref._artifact?.elements)
-            ref.$postponeInclude = art.$postponeInclude || 0;
-        }
-        else if (ref.$postponeInclude > 0 && members) {
-          let added = elementsAdded;
-          let postpone = ref.$postponeInclude;
-          elementsAdded += postpone;
-          forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
-            // The element could have been added in the previous loop (includes) to keep
-            // the element order.
-            if (--added < 0 && --postpone >= 0 && ext[prop][name] !== elem )
-              dictAdd( ext[prop], name, elem );
-          } );
-        }
-        if (ref.$postponeInclude != null) // not reset after bare aspect
-          art.$postponeInclude = 0; // elements of next include directly after this one
+  function reportUnstableExtensions( extensions, issue ) {
+    for (const ext of extensions) {
+      // TODO: location of complete includes / elements
+      // (currently just for having lower diff in tests)
+      const location = ext.includes?.[0]?.location ||
+        ext.elements && Object.values( ext.elements )[0]?.location ||
+        ext.columns?.[0]?.location ||
+        ext.location;
+      if (issue === 'unrelated') {
+        message( 'extend-unrelated-layer', [ location, ext ], {},
+                 'Unstable element order due to other extension in unrelated layer' );
       }
-      const template = ref._artifact; // already resolved
-      if (template) {           // be robust
-        if (template[prop] && !ext[prop])
-          ext[prop] = Object.create( null );
-        const location = weakRefLocation( ref );
-
-        // prevent recompilation issue when localized entity is included in aspect or
-        // entity without keys (via shadowing):
-        const checkForLocalized = prop === 'elements' &&
-          template.kind === 'entity' && !template.query &&
-          withLocalizedData( template, ext );
-
-        // eslint-disable-next-line no-loop-func
-        forEachInOrder( template, prop, ( origin, name ) => {
-          if (checkForLocalized && (name === 'texts' || name === 'localized'))
-            return;
-          if (members && members[name]) {
-            if (!ext[prop][name])
-              dictAdd( ext[prop], name, members[name] ); // to keep order
-            return;
-          }
-          hasNewElement = true;
-          const elem = linkToOrigin( origin, name, parent, prop, location );
-          setLink( elem, '_block', origin._block );
-          if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
-            dictAdd( ext[prop], name, elem );
-          elem.$inferred = 'include';
-          if (origin.key && propagateKeys)
-            elem.key = Object.assign( { $inferred: 'include' }, origin.key );
-          if (origin.value && origin.$syntax === 'calc') {
-            // TODO: If paths become invalid in the new artifact, should we mark
-            //       all usages in the expressions? Possibly just the first one?
-            // TODO: Unify with other code in extend.js
-            elem.value = Object.assign( { $inferred: 'include' },
-                                        copyExpr( origin.value, location, true ) );
-            elem.$syntax = 'calc';
-            createAndLinkCalcDepElement( elem );
-            setLink( elem, '_calcOrigin', origin._calcOrigin || origin );
-          }
-          // TODO: also complain if elem is just defined in art
-        } );
+      else {
+        message( 'extend-repeated-intralayer', [ location, ext ] );
       }
     }
-    if (!hasNewElement && members) {
-      ext[prop] = members;
-      if (prop === 'elements')
-        art.$postponeInclude += addedElements( ext );
-    }
-    else if (members) {
-      let added = elementsAdded;
-      // TODO: expand elements having direct elements (if needed)
-      forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
-        // The element could have been added in the previous loop (includes) to keep
-        // the element order.
-        if (--added < 0 && ext[prop][name] !== elem ) {
-          dictAdd( ext[prop], name, elem );
-          if (prop === 'elements' && elem.kind !== 'extend')
-            ++art.$postponeInclude;
-        }
-      } );
+  }
+
+  function allAnnoValuesEqual( extensions, prop ) {
+    let first;
+    let seen = false;
+    for (const ext of extensions) {
+      const anno = ext[prop];
+      if (anno == null)
+        continue;
+      if (annotationHasEllipsis( anno ))
+        return false;
+      if (!seen) {
+        first = anno;
+        seen = true;
+      }
+      else if (!annoValueEqual( first, anno )) {
+        return false;
+      }
     }
+    return seen;
   }
 
-  /**
-   * Return true if include (with `name` and `elements`) in `ext` highly likely
-   * contain elements `texts` and `localized` which are compiler-generated for
-   * localized data.  Due to recompilation, we cannot just check the `$inferred`
-   * property in the XSN, but need to apply an heuristics.
-   * (We could still use $inferred as speed-up if run without `testMode`.)
-   *
-   * It is as follows: the elements `texts` and `localized` in entity `‹E›` and
-   * the entity `‹E›.texts` are considered compiler-generated for Localized Data if
-   *
-   *  - `‹E›.texts` has a key element `locale`
-   *    (TODO: currently weakend to “entity exists”)
-   *  - `texts` of `‹E›` is an unmanaged composition to `‹E›.texts`
-   *  - `localized` of `‹E›` is an unmanaged association to `‹E›.texts`
-   */
-  function withLocalizedData( { name, elements }, ext ) {
-    const textsEntityName = `${ name.id }.texts`;
-    // if we test (again) for element `locale` - it might come from an extend or
-    // TextsAspect include, which might not have yet applied
-    if (!model.definitions[textsEntityName])
+  function annoValueEqual( a, b ) {
+    if (a == null || b == null)
+      return a == null && b == null;
+    if (a.literal === 'array' || b.literal === 'array' ||
+        a.path || b.path || a.struct || b.struct )
       return false;
-    const { texts, localized } = elements ?? {};
-    return texts?.target && localized?.target && texts.on && localized.on &&
-      resolveUncheckedPath( texts.target, 'target', ext ) === textsEntityName &&
-      resolveUncheckedPath( localized.target, 'target', ext ) === textsEntityName &&
-      resolveUncheckedPath( texts.type, 'type', ext ) === 'cds.Composition' &&
-      resolveUncheckedPath( localized.type, 'type', ext ) === 'cds.Association';
+    if (a.sym || b.sym) {
+      return a.literal === 'enum' && b.literal === 'enum' &&
+        a.sym.id === b.sym.id;
+    }
+    if (!!a.$tokenTexts !== !!b.$tokenTexts)
+      return false;
+    if (a.$tokenTexts && !('val' in a && 'val' in b))
+      return false;
+    // no val (undefined) as true for annotation values
+    const aVal = ('val' in a) ? a.val : true;
+    const bVal = ('val' in b) ? b.val : true;
+    const aLit = ('val' in a) ? a.literal : 'boolean';
+    const bLit = ('val' in b) ? b.literal : 'boolean';
+    return aVal === bVal && aLit === bLit;
+  }
+
+  // TODO: in shared?
+  function notFound( msgId, location, address, args, validDict ) {
+    const msg = message( msgId, [ location, address ], args );
+    attachAndEmitValidNames( msg, validDict );
   }
 
+  // Foreign key extensions (currently postponed) -------------------------------
+
   /**
-   * Report duplicates in parent[prop] that happen due to multiple includes having the
-   * same member.  Run after includes and extends so shadowing members have already
-   * replaced any include-derived survivors in-place.
+   * Apply foreign key extensions.  Because foreign keys are handled late in the compiler
+   * (in tweak-assocs.js), we can't apply them in effectiveType(), yet.
+   * Instead, we postpone applying them until all foreign keys were generated.
+   *
+   * @param art
    */
-  function checkRedefinitionThroughIncludes( parent, prop ) {
-    if (!parent[prop])
+  function extendForeignKeys( art ) {
+    // See extendArtifactAfter() for targetAspect/items handling.
+    if (!art._extensions || art.items || art.targetAspect?.elements)
       return;
-    forEachInOrder( parent, prop, ( member, name ) => {
-      if (member.$inferred === 'include' && Array.isArray( member.$duplicates )) {
-        const includes = [ member, ...member.$duplicates ].map( dup => dup._origin._main );
-        error( 'duplicate-definition', [ parent.name.location, member ],
-               { '#': `include-${ prop }`, name, sorted_arts: includes } );
-      }
-    } );
+
+    // push down foreign keys
+    moveDictExtensions( art, art._extensions, 'foreignKeys', 'elements' );
+    if (!art.foreignKeys)
+      return;
+
+    forEachGeneric(art, 'foreignKeys', (key) => {
+      if (!key._effectiveType)
+        throw new CompilerAssertion( 'foreign key should have been processed' );
+      extendArtifactBefore( key );
+      // Adding foreign key not possible yet
+      extendArtifactAfter( key );
+    });
   }
 }
 
+// Utility functions ------------------------------------------------------------
+
+function canBeDraftMember( name, parent, draftMembers ) {
+  return parent?.kind === 'entity' && parent._service && draftMembers.includes( name );
+}
+
 /**
  * Group extensions by their layers.  A definition (for specified elements)
  * is considered to be provided in a layer named '', the lowest layer.
@@ -1915,6 +1752,7 @@ function compareExtensions( a, b ) {
 /**
  * Propagate the given `prop` (e.g. annotation) early, i.e. copy it from all `.includes`
  * if they have the property.
+ * TODO: move to ./utils.js,
  *
  * @param {XSN.Definition} art
  * @param {string} prop