@valkyrjaio/sindri 26.6.64 → 26.6.66

package/dist/bin/sindri.cjs

@@ -33,7 +33,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // node_modules/@ts-morph/common/dist/typescript.js
 var require_typescript = __commonJS({
   "node_modules/@ts-morph/common/dist/typescript.js"(exports2, module2) {
-    var ts12 = {};
+    var ts13 = {};
     ((module3) => {
       "use strict";
       var __defProp2 = Object.defineProperty;
@@ -137157,9 +137157,9 @@ ${lanes.join("\n")}
             /*ignoreCase*/
             false
           )) {
-            const basename2 = getBaseFileName(a.fileName);
-            if (basename2 === "lib.d.ts" || basename2 === "lib.es6.d.ts") return 0;
-            const name = removeSuffix(removePrefix(basename2, "lib."), ".d.ts");
+            const basename3 = getBaseFileName(a.fileName);
+            if (basename3 === "lib.d.ts" || basename3 === "lib.es6.d.ts") return 0;
+            const name = removeSuffix(removePrefix(basename3, "lib."), ".d.ts");
             const index = libs.indexOf(name);
             if (index !== -1) return index + 1;
           }
@@ -201085,8 +201085,8 @@ ${options.prefix}` : "\n" : options.prefix
             }
           };
           for (const file of files) {
-            const basename2 = getBaseFileName(file);
-            if (basename2 === "package.json" || basename2 === "bower.json") {
+            const basename3 = getBaseFileName(file);
+            if (basename3 === "package.json" || basename3 === "bower.json") {
               createProjectWatcher(
                 file,
                 "FileWatcher"
@@ -204770,8 +204770,8 @@ All files are: ${JSON.stringify(names)}`,
               var _a;
               const fileOrDirectoryPath = removeIgnoredPath(this.toPath(fileOrDirectory));
               if (!fileOrDirectoryPath) return;
-              const basename2 = getBaseFileName(fileOrDirectoryPath);
-              if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename2 === "package.json" || basename2 === "node_modules")) {
+              const basename3 = getBaseFileName(fileOrDirectoryPath);
+              if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename3 === "package.json" || basename3 === "node_modules")) {
                 result.affectedModuleSpecifierCacheProjects.forEach((project) => {
                   var _a2;
                   (_a2 = project.getModuleSpecifierCache()) == null ? void 0 : _a2.clear();
@@ -211530,9 +211530,9 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
         };
       }
     })({ get exports() {
-      return ts12;
+      return ts13;
     }, set exports(v) {
-      ts12 = v;
+      ts13 = v;
       if (typeof module2 !== "undefined" && module2.exports) {
         module2.exports = v;
       }
@@ -213742,7 +213742,7 @@ var require_path_browserify = __commonJS({
         if (hasRoot && end === 1) return "//";
         return path6.slice(0, end);
       },
-      basename: function basename2(path6, ext) {
+      basename: function basename3(path6, ext) {
         if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
         assertPath(path6);
         var start = 0;
@@ -216527,7 +216527,7 @@ var require_dist2 = __commonJS({
 var require_ts_morph_common = __commonJS({
   "node_modules/@ts-morph/common/dist/ts-morph-common.js"(exports2) {
     "use strict";
-    var ts12 = require_typescript();
+    var ts13 = require_typescript();
     var minimatch = require_commonjs3();
     var path$1 = require_path_browserify();
     var fs$1 = require("node:fs");
@@ -216557,7 +216557,7 @@ var require_ts_morph_common = __commonJS({
       n.default = e;
       return Object.freeze(n);
     }
-    var ts__namespace = /* @__PURE__ */ _interopNamespaceCompat(ts12);
+    var ts__namespace = /* @__PURE__ */ _interopNamespaceCompat(ts13);
     var minimatch__namespace = /* @__PURE__ */ _interopNamespaceCompat(minimatch);
     var path__default = /* @__PURE__ */ _interopDefaultCompat(path$1);
     var fs__namespace = /* @__PURE__ */ _interopNamespaceCompat(fs$1);
@@ -219667,85 +219667,85 @@ ${nodeLocation}` : message;
     Object.defineProperty(exports2, "DiagnosticCategory", {
       enumerable: true,
       get: function() {
-        return ts12.DiagnosticCategory;
+        return ts13.DiagnosticCategory;
       }
     });
     Object.defineProperty(exports2, "EmitHint", {
       enumerable: true,
       get: function() {
-        return ts12.EmitHint;
+        return ts13.EmitHint;
       }
     });
     Object.defineProperty(exports2, "LanguageVariant", {
       enumerable: true,
       get: function() {
-        return ts12.LanguageVariant;
+        return ts13.LanguageVariant;
       }
     });
     Object.defineProperty(exports2, "ModuleKind", {
       enumerable: true,
       get: function() {
-        return ts12.ModuleKind;
+        return ts13.ModuleKind;
       }
     });
     Object.defineProperty(exports2, "ModuleResolutionKind", {
       enumerable: true,
       get: function() {
-        return ts12.ModuleResolutionKind;
+        return ts13.ModuleResolutionKind;
       }
     });
     Object.defineProperty(exports2, "NewLineKind", {
       enumerable: true,
       get: function() {
-        return ts12.NewLineKind;
+        return ts13.NewLineKind;
       }
     });
     Object.defineProperty(exports2, "NodeFlags", {
       enumerable: true,
       get: function() {
-        return ts12.NodeFlags;
+        return ts13.NodeFlags;
       }
     });
     Object.defineProperty(exports2, "ObjectFlags", {
       enumerable: true,
       get: function() {
-        return ts12.ObjectFlags;
+        return ts13.ObjectFlags;
       }
     });
     Object.defineProperty(exports2, "ScriptKind", {
       enumerable: true,
       get: function() {
-        return ts12.ScriptKind;
+        return ts13.ScriptKind;
       }
     });
     Object.defineProperty(exports2, "ScriptTarget", {
       enumerable: true,
       get: function() {
-        return ts12.ScriptTarget;
+        return ts13.ScriptTarget;
       }
     });
     Object.defineProperty(exports2, "SymbolFlags", {
       enumerable: true,
       get: function() {
-        return ts12.SymbolFlags;
+        return ts13.SymbolFlags;
       }
     });
     Object.defineProperty(exports2, "SyntaxKind", {
       enumerable: true,
       get: function() {
-        return ts12.SyntaxKind;
+        return ts13.SyntaxKind;
       }
     });
     Object.defineProperty(exports2, "TypeFlags", {
       enumerable: true,
       get: function() {
-        return ts12.TypeFlags;
+        return ts13.TypeFlags;
       }
     });
     Object.defineProperty(exports2, "TypeFormatFlags", {
       enumerable: true,
       get: function() {
-        return ts12.TypeFormatFlags;
+        return ts13.TypeFormatFlags;
       }
     });
     exports2.ts = ts__namespace;
@@ -242861,17 +242861,54 @@ var AstReader = class _AstReader {
       names.add(node.text);
       return names;
     }
-    if (import_ts_morph.ts.isPropertyAccessExpression(node)) {
-      return this.collectReferencedIdentifiers(node.expression, names);
+    if (import_ts_morph.ts.isBindingElement(node)) {
+      if (node.propertyName !== void 0 && import_ts_morph.ts.isComputedPropertyName(node.propertyName)) {
+        this.collectReferencedIdentifiers(node.propertyName.expression, names);
+      }
+      this.collectReferencedIdentifiers(node.name, names);
+      return node.initializer === void 0 ? names : this.collectReferencedIdentifiers(node.initializer, names);
     }
-    if (import_ts_morph.ts.isPropertyAssignment(node)) {
-      return this.collectReferencedIdentifiers(node.initializer, names);
+    const slotName = "name" in node && node.name !== void 0 && import_ts_morph.ts.isIdentifier(node.name) && !import_ts_morph.ts.isShorthandPropertyAssignment(node) ? node.name : void 0;
+    import_ts_morph.ts.forEachChild(node, (child) => {
+      if (child !== slotName) {
+        this.collectReferencedIdentifiers(child, names);
+      }
+    });
+    return names;
+  }
+  /**
+   * The names the provider file declares anywhere in itself, less the file's own base name, which
+   * is the name the generated data file imports the provider by.
+   */
+  collectFileNames(sourceFile, filePath) {
+    const names = this.collectDeclaredNames(sourceFile.compilerNode);
+    names.delete(path.basename(filePath, ".ts"));
+    return names;
+  }
+  /**
+   * The names a node declares, such as the parameters of an inline handler.
+   *
+   * A name any part of an expression declares counts as declared throughout it, which reads a
+   * shadowed name as declared rather than stopping on it.
+   */
+  collectDeclaredNames(node, names = /* @__PURE__ */ new Set()) {
+    if (_AstReader.declaresName(node) && node.name !== void 0 && import_ts_morph.ts.isIdentifier(node.name)) {
+      names.add(node.name.text);
     }
     import_ts_morph.ts.forEachChild(node, (child) => {
-      this.collectReferencedIdentifiers(child, names);
+      this.collectDeclaredNames(child, names);
     });
     return names;
   }
+  /**
+   * Whether a node's `name` declares a binding rather than naming one.
+   *
+   * A property access, a shorthand property and an object-literal key all carry a `name` that
+   * references or keys instead of declaring, so the kind decides rather than the slot.
+   */
+  static declaresName(node) {
+    return import_ts_morph.ts.isParameter(node) || import_ts_morph.ts.isVariableDeclaration(node) || import_ts_morph.ts.isBindingElement(node) || import_ts_morph.ts.isFunctionDeclaration(node) || import_ts_morph.ts.isFunctionExpression(node) || import_ts_morph.ts.isClassDeclaration(node) || import_ts_morph.ts.isClassExpression(node) || import_ts_morph.ts.isEnumDeclaration(node) || import_ts_morph.ts.isModuleDeclaration(node);
+  }
   /**
    * Extract service ID strings from keys of an object-returning method.
    *
@@ -244010,8 +244047,8 @@ var Header = class extends Message {
 
 // src/Sindri/Constant/SindriInfo.ts
 var SindriInfo = class {
-  static VERSION = "26.6.64";
-  static VERSION_BUILD_DATE_TIME = "October 10 2026 10:39:52 MST";
+  static VERSION = "26.6.66";
+  static VERSION_BUILD_DATE_TIME = "October 12 2026 14:34:58 MST";
   static ICON = `    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588
     \u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588
         \u2588\u2588\u2588\u2588
@@ -245487,10 +245524,16 @@ var ListenerData = class {
 
 // src/Sindri/Ast/Data/Result/ListenerAttributeResult.ts
 var ListenerAttributeResult = class {
-  constructor(listeners = {}) {
+  /**
+   * @param listeners A Map, because an object reorders a key that reads as an integer
+   * @param importMap Class short name → absolute file path for the handler imports
+   */
+  constructor(listeners = /* @__PURE__ */ new Map(), importMap = {}) {
     this.listeners = listeners;
+    this.importMap = importMap;
   }
   listeners;
+  importMap;
 };
 
 // src/Sindri/Ast/ListenerAttributeReader.ts
@@ -245502,22 +245545,46 @@ var ListenerAttributeReader = class _ListenerAttributeReader extends AstReader {
       return new ListenerAttributeResult();
     }
     const { classDecl, useMap, currentClass } = context;
-    const listeners = {};
+    const listeners = /* @__PURE__ */ new Map();
+    const listenerData = [];
     for (const decorator of this.findDecoratorsOnNode(classDecl, "Listener", useMap, filePath)) {
       const data = this.buildListenerData(decorator, useMap, filePath, currentClass, classDecl, void 0);
       if (data !== null) {
-        listeners[data.name] = this.buildListenerExpr(data);
+        listeners.set(data.name, this.buildListenerExpr(data));
+        listenerData.push(data);
       }
     }
     for (const method of classDecl.getMethods()) {
       for (const decorator of this.findDecoratorsOnNode(method, "Listener", useMap, filePath)) {
         const data = this.buildListenerData(decorator, useMap, filePath, currentClass, classDecl, method);
         if (data !== null) {
-          listeners[data.name] = this.buildListenerExpr(data);
+          listeners.set(data.name, this.buildListenerExpr(data));
+          listenerData.push(data);
         }
       }
     }
-    return new ListenerAttributeResult(listeners);
+    return new ListenerAttributeResult(
+      listeners,
+      this.buildImportMap(listenerData, useMap, filePath, currentClass)
+    );
+  }
+  /**
+   * Build the class-name → absolute-file-path map for every handler class the generated data
+   * cache references.
+   */
+  buildImportMap(listenerData, useMap, currentFilePath, currentClass) {
+    const importMap = {};
+    for (const data of listenerData) {
+      if (data.handler === null) {
+        continue;
+      }
+      const shortName = data.handler.class.slice(data.handler.class.lastIndexOf("\\") + 1);
+      const filePath = shortName === currentClass ? currentFilePath : this.resolveClassToFilePath(shortName, useMap, currentFilePath);
+      if (filePath !== "") {
+        importMap[shortName] = filePath;
+      }
+    }
+    return importMap;
   }
   buildListenerData(decorator, useMap, currentFilePath, currentClass, classDecl, method) {
     const eventId = this.extractStringArg(decorator, 0, useMap, currentFilePath, currentClass);
@@ -245563,22 +245630,44 @@ var ListenerAttributeReader = class _ListenerAttributeReader extends AstReader {
   }
 };
 
+// src/Sindri/Ast/ListenerProviderReader.ts
+var import_ts_morph7 = __toESM(require_ts_morph(), 1);
+
 // src/Sindri/Ast/Data/Result/ListenerProviderResult.ts
 var ListenerProviderResult = class _ListenerProviderResult {
-  constructor(listenerClasses = [], listeners = []) {
+  /**
+   * @param listenerImports Local name → absolute file path for every class the `listeners`
+   *                        expressions reference
+   */
+  constructor(listenerClasses = [], listeners = [], listenerImports = {}) {
     this.listenerClasses = listenerClasses;
     this.listeners = listeners;
+    this.listenerImports = listenerImports;
   }
   listenerClasses;
   listeners;
+  listenerImports;
   merge(other) {
     return new _ListenerProviderResult(
       [.../* @__PURE__ */ new Set([...this.listenerClasses, ...other.listenerClasses])],
-      [...this.listeners, ...other.listeners]
+      [...this.listeners, ...other.listeners],
+      { ...this.listenerImports, ...other.listenerImports }
     );
   }
 };
 
+// src/Sindri/Throwable/Exception/Abstract/SindriInvalidArgumentException.ts
+var SindriInvalidArgumentException = class extends ValkyrjaInvalidArgumentException {
+};
+
+// src/Sindri/Ast/Throwable/Exception/Abstract/AstInvalidArgumentException.ts
+var AstInvalidArgumentException = class extends SindriInvalidArgumentException {
+};
+
+// src/Sindri/Ast/Throwable/Exception/AstUnreadableListenerException.ts
+var AstUnreadableListenerException = class extends AstInvalidArgumentException {
+};
+
 // src/Sindri/Ast/ListenerProviderReader.ts
 var ListenerProviderReader = class _ListenerProviderReader extends AstReader {
   static METHOD_LISTENER_CLASSES = "getListenerClasses";
@@ -245591,18 +245680,62 @@ var ListenerProviderReader = class _ListenerProviderReader extends AstReader {
     }
     const useMap = this.buildUseMap(sourceFile);
     const methods = this.indexMethods(classDecl);
+    const listeners = this.extractListeners(methods[_ListenerProviderReader.METHOD_LISTENERS]);
     return new ListenerProviderResult(
       this.extractClassListFromValues(methods[_ListenerProviderReader.METHOD_LISTENER_CLASSES], useMap, filePath),
-      this.extractListeners(methods[_ListenerProviderReader.METHOD_LISTENERS], useMap, filePath)
+      listeners,
+      this.extractListenerImports(listeners, useMap, filePath, this.collectFileNames(sourceFile, filePath))
     );
   }
-  extractListeners(_method, _useMap, _filePath) {
-    return [];
+  /**
+   * Extract the listeners a provider's `getListeners()` method returns, which the generator
+   * emits verbatim.
+   */
+  extractListeners(method) {
+    if (method === void 0) {
+      return [];
+    }
+    const array = this.findReturnedArray(method);
+    if (array === void 0) {
+      return [];
+    }
+    return array.elements.filter((element) => this.isConstructedListener(element));
+  }
+  /** Whether an expression declares a listener through a construction, with or without a chain. */
+  isConstructedListener(expression) {
+    let current = this.unwrapTypeAssertions(expression);
+    while (import_ts_morph7.ts.isCallExpression(current) && import_ts_morph7.ts.isPropertyAccessExpression(current.expression)) {
+      current = this.unwrapTypeAssertions(current.expression.expression);
+    }
+    return import_ts_morph7.ts.isNewExpression(current);
+  }
+  /**
+   * Resolve every class the listener expressions reference to its absolute file path, so the
+   * generated data cache can import them.
+   */
+  extractListenerImports(listeners, useMap, filePath, fileNames) {
+    const imports = {};
+    for (const listener of listeners) {
+      const declaredNames = this.collectDeclaredNames(listener);
+      for (const name of this.collectReferencedIdentifiers(listener)) {
+        const resolved = this.resolveImportToFilePath(name, useMap, filePath);
+        if (resolved !== "") {
+          imports[name] = resolved;
+          continue;
+        }
+        if (fileNames.has(name) && !declaredNames.has(name)) {
+          throw new AstUnreadableListenerException(
+            `Cannot read the listener '${listener.getText()}': the generated data cannot import '${name}', which the provider declares for itself.`
+          );
+        }
+      }
+    }
+    return imports;
   }
 };
 
 // src/Sindri/Ast/RouteProviderReader.ts
-var import_ts_morph7 = __toESM(require_ts_morph(), 1);
+var import_ts_morph8 = __toESM(require_ts_morph(), 1);
 
 // src/Sindri/Ast/Data/Result/RouteProviderResult.ts
 var RouteProviderResult = class _RouteProviderResult {
@@ -245628,6 +245761,10 @@ var RouteProviderResult = class _RouteProviderResult {
   }
 };
 
+// src/Sindri/Ast/Throwable/Exception/AstUnreadableRouteException.ts
+var AstUnreadableRouteException = class extends AstInvalidArgumentException {
+};
+
 // src/Sindri/Ast/RouteProviderReader.ts
 var RouteProviderReader = class _RouteProviderReader extends AstReader {
   static METHOD_CONTROLLER_CLASSES = "getControllerClasses";
@@ -245641,19 +245778,17 @@ var RouteProviderReader = class _RouteProviderReader extends AstReader {
     const useMap = this.buildUseMap(sourceFile);
     const methods = this.indexMethods(classDecl);
     const routes = this.extractRoutes(methods[_RouteProviderReader.METHOD_ROUTES], useMap, filePath);
+    const routeImports = this.extractRouteImports(routes, useMap, filePath);
+    this.validateRouteImports(routes, routeImports, useMap, this.collectFileNames(sourceFile, filePath));
     return new RouteProviderResult(
       this.extractClassListFromValues(methods[_RouteProviderReader.METHOD_CONTROLLER_CLASSES], useMap, filePath),
       routes,
-      this.extractRouteImports(routes, useMap, filePath)
+      routeImports
     );
   }
   /**
-   * Resolve every class the imperative route expressions reference to its
-   * absolute file path, so the generated data cache can import them.
-   *
-   * Names that are not imported by the provider file — locals, globals, and
-   * the provider's own class (which the generator imports separately) — have
-   * no entry in the use map and are skipped.
+   * Resolve every class the imperative route expressions reference to its absolute file path, so
+   * the generated data cache can import them.
    */
   extractRouteImports(routes, useMap, filePath) {
     const imports = {};
@@ -245667,6 +245802,27 @@ var RouteProviderReader = class _RouteProviderReader extends AstReader {
     }
     return imports;
   }
+  /** Stop on a name a route references that the generated data file, in another module, cannot reach. */
+  validateRouteImports(routes, routeImports, useMap, fileNames) {
+    for (const route2 of routes) {
+      const declaredNames = this.collectDeclaredNames(route2);
+      for (const name of this.collectReferencedIdentifiers(route2)) {
+        if (routeImports[name] !== void 0 || declaredNames.has(name)) {
+          continue;
+        }
+        if (fileNames.has(name)) {
+          throw new AstUnreadableRouteException(
+            `Cannot read the route '${route2.getText()}': the generated data cannot import '${name}', which the provider declares for itself.`
+          );
+        }
+        if (useMap[name] !== void 0) {
+          throw new AstUnreadableRouteException(
+            `Cannot read the route '${route2.getText()}': the import of '${name}' resolves to no TypeScript file.`
+          );
+        }
+      }
+    }
+  }
   /**
    * Extract the route objects returned by a provider's `getRoutes()` method.
    *
@@ -245686,12 +245842,12 @@ var RouteProviderReader = class _RouteProviderReader extends AstReader {
     if (array === void 0) {
       return [];
     }
-    return array.elements.filter((element) => import_ts_morph7.ts.isNewExpression(element));
+    return array.elements.filter((element) => import_ts_morph8.ts.isNewExpression(element));
   }
 };
 
 // src/Sindri/Ast/ServiceProviderReader.ts
-var import_ts_morph8 = __toESM(require_ts_morph(), 1);
+var import_ts_morph9 = __toESM(require_ts_morph(), 1);
 
 // src/Sindri/Ast/Data/Result/ServiceProviderResult.ts
 var ServiceProviderResult = class _ServiceProviderResult {
@@ -245744,7 +245900,7 @@ var ServiceProviderReader = class _ServiceProviderReader extends AstReader {
     }
     const map = {};
     for (const prop of obj.properties) {
-      if (!import_ts_morph8.ts.isPropertyAssignment(prop)) {
+      if (!import_ts_morph9.ts.isPropertyAssignment(prop)) {
         continue;
       }
       const serviceId = this.resolvePropertyKeyToString(prop.name, useMap, filePath);
@@ -245765,8 +245921,8 @@ var ServiceProviderReader = class _ServiceProviderReader extends AstReader {
    * Handles: `ProviderClass.publishMethod` and `[ProviderClass, 'method']`.
    */
   extractHandlerFromValue(node, useMap, filePath, currentClass) {
-    if (import_ts_morph8.ts.isPropertyAccessExpression(node)) {
-      const className = import_ts_morph8.ts.isIdentifier(node.expression) ? node.expression.text : void 0;
+    if (import_ts_morph9.ts.isPropertyAccessExpression(node)) {
+      const className = import_ts_morph9.ts.isIdentifier(node.expression) ? node.expression.text : void 0;
       if (className === void 0) {
         return void 0;
       }
@@ -245774,7 +245930,7 @@ var ServiceProviderReader = class _ServiceProviderReader extends AstReader {
       const resolvedClass = className === "self" || className === "this" ? currentClass : className;
       return [resolvedClass, methodName];
     }
-    if (import_ts_morph8.ts.isArrayLiteralExpression(node) && node.elements.length === 2) {
+    if (import_ts_morph9.ts.isArrayLiteralExpression(node) && node.elements.length === 2) {
       const raw = this.extractHandlerFromTsArray(node, useMap, filePath, currentClass);
       if (raw !== void 0) {
         return [raw.class, raw.method];
@@ -245785,7 +245941,7 @@ var ServiceProviderReader = class _ServiceProviderReader extends AstReader {
 };
 
 // src/Sindri/Generator/Ast/Cli/AstCliDataFileGenerator.ts
-var import_ts_morph9 = __toESM(require_ts_morph(), 1);
+var import_ts_morph10 = __toESM(require_ts_morph(), 1);
 var AstCliDataFileGenerator = class _AstCliDataFileGenerator extends AstFileGenerator {
   /** The framework classes every generated CLI data file imports as values. */
   static FRAMEWORK_IMPORTS = {
@@ -245803,13 +245959,13 @@ var AstCliDataFileGenerator = class _AstCliDataFileGenerator extends AstFileGene
     RouteContract: "@valkyrjaio/valkyrja/Cli/Routing/Data/Contract/RouteContract.ts"
   };
   classImportMap = {};
-  printer = import_ts_morph9.ts.createPrinter({ newLine: import_ts_morph9.ts.NewLineKind.LineFeed });
-  dummySourceFile = import_ts_morph9.ts.createSourceFile(
+  printer = import_ts_morph10.ts.createPrinter({ newLine: import_ts_morph10.ts.NewLineKind.LineFeed });
+  dummySourceFile = import_ts_morph10.ts.createSourceFile(
     "_dummy.ts",
     "",
-    import_ts_morph9.ts.ScriptTarget.ESNext,
+    import_ts_morph10.ts.ScriptTarget.ESNext,
     false,
-    import_ts_morph9.ts.ScriptKind.TS
+    import_ts_morph10.ts.ScriptKind.TS
   );
   generateFile(directory, className, namespace, routes) {
     const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
@@ -245849,7 +246005,7 @@ var AstCliDataFileGenerator = class _AstCliDataFileGenerator extends AstFileGene
   generateMergedFile(directory, className, namespace, routes, routeExprs) {
     const merged = { ...routes };
     for (const expr of routeExprs) {
-      if (!import_ts_morph9.ts.isNewExpression(expr)) {
+      if (!import_ts_morph10.ts.isNewExpression(expr)) {
         continue;
       }
       const key = this.routeKey((expr.arguments ?? [])[0]);
@@ -245873,10 +246029,10 @@ var AstCliDataFileGenerator = class _AstCliDataFileGenerator extends AstFileGene
     if (nameArg === void 0) {
       return void 0;
     }
-    if (import_ts_morph9.ts.isStringLiteral(nameArg)) {
+    if (import_ts_morph10.ts.isStringLiteral(nameArg)) {
       return nameArg.text;
     }
-    if (import_ts_morph9.ts.isPropertyAccessExpression(nameArg) && import_ts_morph9.ts.isIdentifier(nameArg.expression)) {
+    if (import_ts_morph10.ts.isPropertyAccessExpression(nameArg) && import_ts_morph10.ts.isIdentifier(nameArg.expression)) {
       return `${nameArg.expression.text}::${nameArg.name.text}`;
     }
     return void 0;
@@ -245889,7 +246045,7 @@ var AstCliDataFileGenerator = class _AstCliDataFileGenerator extends AstFileGene
     const lines = [];
     for (const [key, valueExpr] of entries) {
       const printedValue = this.printExpr(valueExpr);
-      const formattedKey = key.includes("::") ? `[${this.printer.printNode(import_ts_morph9.ts.EmitHint.Unspecified, this.buildEnumCaseExpr(key), this.dummySourceFile)}]` : `['${key}']`;
+      const formattedKey = key.includes("::") ? `[${this.printer.printNode(import_ts_morph10.ts.EmitHint.Unspecified, this.buildEnumCaseExpr(key), this.dummySourceFile)}]` : `['${key}']`;
       lines.push(`            ${formattedKey}: (): RouteContract => ${printedValue},`);
     }
     return ["super({", ...lines, "        });"].join("\n        ");
@@ -245900,12 +246056,12 @@ var AstCliDataFileGenerator = class _AstCliDataFileGenerator extends AstFileGene
    * carry no source positions) are emitted through the printer.
    */
   printExpr(expr) {
-    return expr.pos >= 0 ? expr.getText() : this.printer.printNode(import_ts_morph9.ts.EmitHint.Unspecified, expr, this.dummySourceFile);
+    return expr.pos >= 0 ? expr.getText() : this.printer.printNode(import_ts_morph10.ts.EmitHint.Unspecified, expr, this.dummySourceFile);
   }
 };
 
 // src/Sindri/Generator/Ast/Container/AstContainerDataFileGenerator.ts
-var import_ts_morph10 = __toESM(require_ts_morph(), 1);
+var import_ts_morph11 = __toESM(require_ts_morph(), 1);
 var AstContainerDataFileGenerator = class _AstContainerDataFileGenerator extends AstFileGenerator {
   /** The framework class every generated container data file imports as a value. */
   static FRAMEWORK_IMPORTS = {
@@ -245916,13 +246072,13 @@ var AstContainerDataFileGenerator = class _AstContainerDataFileGenerator extends
     ContainerContract: "@valkyrjaio/valkyrja/Container/Manager/Contract/ContainerContract.ts"
   };
   classImportMap = {};
-  printer = import_ts_morph10.ts.createPrinter({ newLine: import_ts_morph10.ts.NewLineKind.LineFeed });
-  dummySourceFile = import_ts_morph10.ts.createSourceFile(
+  printer = import_ts_morph11.ts.createPrinter({ newLine: import_ts_morph11.ts.NewLineKind.LineFeed });
+  dummySourceFile = import_ts_morph11.ts.createSourceFile(
     "_dummy.ts",
     "",
-    import_ts_morph10.ts.ScriptTarget.ESNext,
+    import_ts_morph11.ts.ScriptTarget.ESNext,
     false,
-    import_ts_morph10.ts.ScriptKind.TS
+    import_ts_morph11.ts.ScriptKind.TS
   );
   generateFile(directory, className, namespace, publishers) {
     const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
@@ -245953,7 +246109,7 @@ var AstContainerDataFileGenerator = class _AstContainerDataFileGenerator extends
     const lines = [];
     for (const [serviceId, [providerClass, methodName]] of entries) {
       const shortProviderClass = providerClass.slice(providerClass.lastIndexOf("\\") + 1);
-      const formattedKey = serviceId.includes("::") ? `[${this.printer.printNode(import_ts_morph10.ts.EmitHint.Unspecified, this.buildEnumCaseExpr(serviceId), this.dummySourceFile)}]` : `['${serviceId}']`;
+      const formattedKey = serviceId.includes("::") ? `[${this.printer.printNode(import_ts_morph11.ts.EmitHint.Unspecified, this.buildEnumCaseExpr(serviceId), this.dummySourceFile)}]` : `['${serviceId}']`;
       lines.push(
         `            ${formattedKey}: (container: ContainerContract) => ${shortProviderClass}.${methodName}(container),`
       );
@@ -245965,7 +246121,17 @@ var AstContainerDataFileGenerator = class _AstContainerDataFileGenerator extends
 };
 
 // src/Sindri/Generator/Ast/Event/AstEventDataFileGenerator.ts
-var import_ts_morph11 = __toESM(require_ts_morph(), 1);
+var import_ts_morph12 = __toESM(require_ts_morph(), 1);
+
+// src/Sindri/Generator/Throwable/Exception/Abstract/GeneratorInvalidArgumentException.ts
+var GeneratorInvalidArgumentException = class extends SindriInvalidArgumentException {
+};
+
+// src/Sindri/Generator/Throwable/Exception/GeneratorUnreadableListenerException.ts
+var GeneratorUnreadableListenerException = class extends GeneratorInvalidArgumentException {
+};
+
+// src/Sindri/Generator/Ast/Event/AstEventDataFileGenerator.ts
 var AstEventDataFileGenerator = class _AstEventDataFileGenerator extends AstFileGenerator {
   /** The framework class every generated event data file imports as a value. */
   static FRAMEWORK_IMPORTS = {
@@ -245979,23 +246145,58 @@ var AstEventDataFileGenerator = class _AstEventDataFileGenerator extends AstFile
   static LISTENER_TYPE_IMPORTS = {
     ListenerContract: "@valkyrjaio/valkyrja/Event/Data/Contract/ListenerContract.ts"
   };
+  /** The builders `ListenerContract` declares. */
+  static LISTENER_BUILDERS = ["withEventId", "withName", "withHandler"];
+  /** The builder that replaces a listener's event id. */
+  static BUILDER_EVENT_ID = "withEventId";
+  /** The builder that replaces a listener's name. */
+  static BUILDER_NAME = "withName";
+  /** The position of the event id in a `Listener` construction. */
+  static ARGUMENT_EVENT_ID = 0;
+  /** The position of the listener name in a `Listener` construction. */
+  static ARGUMENT_NAME = 1;
   classImportMap = {};
-  printer = import_ts_morph11.ts.createPrinter({ newLine: import_ts_morph11.ts.NewLineKind.LineFeed });
-  dummySourceFile = import_ts_morph11.ts.createSourceFile(
+  printer = import_ts_morph12.ts.createPrinter({ newLine: import_ts_morph12.ts.NewLineKind.LineFeed });
+  dummySourceFile = import_ts_morph12.ts.createSourceFile(
     "_dummy.ts",
     "",
-    import_ts_morph11.ts.ScriptTarget.ESNext,
+    import_ts_morph12.ts.ScriptTarget.ESNext,
     false,
-    import_ts_morph11.ts.ScriptKind.TS
+    import_ts_morph12.ts.ScriptKind.TS
   );
   generateFile(directory, className, namespace, listeners) {
+    return this.generateMergedFile(directory, className, namespace, listeners, []);
+  }
+  /**
+   * Generate the event data file from the decorated listeners and the listeners a provider
+   * declares by hand.
+   */
+  generateMergedFile(directory, className, namespace, listeners, listenerExprs) {
+    const factories = /* @__PURE__ */ new Map();
+    const events = /* @__PURE__ */ new Map();
+    for (const [name, listener] of listeners) {
+      this.fileListener(
+        factories,
+        events,
+        this.stringSource(name),
+        this.readListenerKeys(listener).eventId,
+        listener
+      );
+    }
+    for (const listener of listenerExprs) {
+      const keys = this.readListenerKeys(listener);
+      if (keys.name === void 0 || keys.eventId === void 0) {
+        continue;
+      }
+      this.fileListener(factories, events, keys.name, keys.eventId, listener);
+    }
     const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
       ...Object.keys(_AstEventDataFileGenerator.FRAMEWORK_IMPORTS),
       ...Object.keys(_AstEventDataFileGenerator.LISTENER_IMPORTS),
       ...Object.keys(_AstEventDataFileGenerator.LISTENER_TYPE_IMPORTS)
     ]);
-    const contents = this.generateClassContents(listeners);
-    const listenerImports = Object.keys(listeners).length > 0 ? [
+    const contents = this.generateClassContents(factories, events);
+    const listenerImports = factories.size > 0 ? [
       ...this.buildFrameworkImportLines(_AstEventDataFileGenerator.LISTENER_IMPORTS),
       ...this.buildFrameworkImportLines(_AstEventDataFileGenerator.LISTENER_TYPE_IMPORTS, true)
     ] : [];
@@ -246014,24 +246215,187 @@ var AstEventDataFileGenerator = class _AstEventDataFileGenerator extends AstFile
     ].join("\n");
     return this.writeFile(directory, className, data);
   }
-  generateClassContents(listeners) {
-    const entries = Object.entries(listeners);
-    if (entries.length === 0) {
+  generateClassContents(factories, events) {
+    if (factories.size === 0) {
       return "super();";
     }
-    const lines = [];
-    for (const [key, valueExpr] of entries) {
-      const printed = this.printer.printNode(import_ts_morph11.ts.EmitHint.Unspecified, valueExpr, this.dummySourceFile);
-      lines.push(`            ['${key}']: (): ListenerContract => ${printed},`);
+    return [
+      "super(",
+      ...this.wrapMapLines(this.buildEventIndexLines(events)),
+      ...this.wrapMapLines(this.buildListenerLines(factories)),
+      "        );"
+    ].join("\n");
+  }
+  /**
+   * File one listener into the listener map and the event index, the way
+   * `ListenerCollection.addListener` files it.
+   *
+   * @param name    The source text of the key the listener map files the listener under
+   * @param eventId The source text of the key the event index files the name under, or nothing
+   *                when the listener names no event id a key can read
+   */
+  fileListener(factories, events, name, eventId, listener) {
+    factories.set(name, listener);
+    if (eventId === void 0) {
+      return;
     }
-    return ["super(", "            {},", "            {", ...lines, "            },", "        );"].join(
-      "\n        "
+    const names = events.get(eventId);
+    if (names === void 0) {
+      events.set(eventId, [name]);
+      return;
+    }
+    if (!names.includes(name)) {
+      names.push(name);
+    }
+  }
+  /**
+   * Read the event id and the name the listener an expression declares ends up with.
+   *
+   * The chain is walked from the outermost call inward, so the first `withEventId` and the first
+   * `withName` it reaches are the last ones the framework applies.
+   */
+  readListenerKeys(listener) {
+    let eventIdArgument = void 0;
+    let nameArgument = void 0;
+    let eventIdReplaced = false;
+    let nameReplaced = false;
+    this.requireNoTypeBinding(listener);
+    let current = this.readValueExpression(listener);
+    while (import_ts_morph12.ts.isCallExpression(current) && import_ts_morph12.ts.isPropertyAccessExpression(current.expression)) {
+      const builder = current.expression.name.text;
+      if (!_AstEventDataFileGenerator.LISTENER_BUILDERS.includes(builder)) {
+        throw new GeneratorUnreadableListenerException(
+          `Cannot read the listener '${this.printExpr(current)}': '${builder}' is not a listener builder.`
+        );
+      }
+      if (builder === _AstEventDataFileGenerator.BUILDER_EVENT_ID && !eventIdReplaced) {
+        eventIdReplaced = true;
+        eventIdArgument = current.arguments[0];
+      }
+      if (builder === _AstEventDataFileGenerator.BUILDER_NAME && !nameReplaced) {
+        nameReplaced = true;
+        nameArgument = current.arguments[0];
+      }
+      current = this.readValueExpression(current.expression.expression);
+    }
+    if (!import_ts_morph12.ts.isNewExpression(current)) {
+      return { eventId: void 0, name: void 0 };
+    }
+    const args = current.arguments ?? [];
+    if (!eventIdReplaced) {
+      eventIdArgument = args[_AstEventDataFileGenerator.ARGUMENT_EVENT_ID];
+    }
+    if (!nameReplaced) {
+      nameArgument = args[_AstEventDataFileGenerator.ARGUMENT_NAME];
+    }
+    return { eventId: this.keySource(eventIdArgument), name: this.keySource(nameArgument) };
+  }
+  /**
+   * Read the source text of one key an argument names, which is nothing when the generated file
+   * cannot name that key before the application runs.
+   */
+  keySource(argument) {
+    if (argument === void 0) {
+      return void 0;
+    }
+    const value = this.readValueExpression(argument);
+    if (import_ts_morph12.ts.isStringLiteral(value)) {
+      return this.stringSource(value.text);
+    }
+    if (!import_ts_morph12.ts.isPropertyAccessExpression(value) || !import_ts_morph12.ts.isIdentifier(value.expression)) {
+      return void 0;
+    }
+    if (!Object.hasOwn(this.classImportMap, value.expression.text)) {
+      throw new GeneratorUnreadableListenerException(
+        `Cannot read the listener key '${this.printExpr(value)}': the generated data imports no '${value.expression.text}'.`
+      );
+    }
+    return this.printExpr(value);
+  }
+  /** Build the lines of the event index, which files each listener name under its event id. */
+  buildEventIndexLines(events) {
+    return [...events].map(([eventId, names]) => `                [${eventId}]: [${names.join(", ")}],`);
+  }
+  /** Build the lines of the listener map, which holds a factory for each listener name. */
+  buildListenerLines(factories) {
+    return [...factories].map(
+      ([name, listener]) => `                [${name}]: (): ListenerContract => ${this.printExpr(listener)},`
+    );
+  }
+  /** Wrap the lines of one generated map in its braces, and collapse an empty map to `{}`. */
+  wrapMapLines(lines) {
+    if (lines.length === 0) {
+      return ["            {},"];
+    }
+    return ["            {", ...lines, "            },"];
+  }
+  /** Render a string as the source text of a string literal, with the escapes it needs. */
+  stringSource(value) {
+    return this.printer.printNode(
+      import_ts_morph12.ts.EmitHint.Unspecified,
+      import_ts_morph12.ts.factory.createStringLiteral(value, true),
+      this.dummySourceFile
     );
   }
+  /** Print an expression to source. */
+  printExpr(expr) {
+    return this.printNodeText(expr);
+  }
+  /** Print a node to source, through its own text when it carries a source position. */
+  printNodeText(node) {
+    return node.pos >= 0 ? node.getText() : this.printer.printNode(import_ts_morph12.ts.EmitHint.Unspecified, node, this.dummySourceFile);
+  }
+  /** Reach the value node a wrapped expression holds, through the parentheses and the casts. */
+  readValueExpression(expression) {
+    if (import_ts_morph12.ts.isParenthesizedExpression(expression) || import_ts_morph12.ts.isAsExpression(expression) || import_ts_morph12.ts.isSatisfiesExpression(expression)) {
+      return this.readValueExpression(expression.expression);
+    }
+    return expression;
+  }
+  /**
+   * Stop when any part of a listener names a binding in a type, which the generated file carries
+   * no import for.
+   */
+  requireNoTypeBinding(listener, node = listener) {
+    if (import_ts_morph12.ts.isTypeNode(node) && this.namesBinding(node)) {
+      throw new GeneratorUnreadableListenerException(
+        `Cannot read the listener '${this.printNodeText(listener)}': the generated data cannot import the type '${this.printNodeText(node)}'; declare the listener without it.`
+      );
+    }
+    import_ts_morph12.ts.forEachChild(node, (child) => {
+      this.requireNoTypeBinding(listener, child);
+    });
+  }
+  /**
+   * Whether a type names a binding that the file holding it has to resolve. `const` is a reserved
+   * word, so it names none.
+   */
+  namesBinding(node) {
+    if (import_ts_morph12.ts.isImportTypeNode(node) || import_ts_morph12.ts.isQualifiedName(node)) {
+      return true;
+    }
+    if (import_ts_morph12.ts.isIdentifier(node)) {
+      return node.text !== "const";
+    }
+    const declaredName = this.declaredName(node);
+    let names = false;
+    import_ts_morph12.ts.forEachChild(node, (child) => {
+      names = names || child !== declaredName && this.namesBinding(child);
+    });
+    return names;
+  }
+  /**
+   * The name a declaration spells out as one identifier, which declares a binding rather than
+   * naming one. Every other name form can hold an expression, so it is read.
+   */
+  declaredName(node) {
+    const name = "name" in node ? node.name : void 0;
+    return name !== void 0 && import_ts_morph12.ts.isIdentifier(name) ? name : void 0;
+  }
 };
 
 // src/Sindri/Generator/Ast/Http/AstHttpDataFileGenerator.ts
-var import_ts_morph12 = __toESM(require_ts_morph(), 1);
+var import_ts_morph13 = __toESM(require_ts_morph(), 1);
 
 // node_modules/@valkyrjaio/valkyrja/src/Valkyrja/Http/Message/Enum/RequestMethod.ts
 function allRequestMethods() {
@@ -246514,13 +246878,13 @@ var AstHttpDataFileGenerator = class _AstHttpDataFileGenerator extends AstFileGe
   };
   classImportMap = {};
   processor;
-  printer = import_ts_morph12.ts.createPrinter({ newLine: import_ts_morph12.ts.NewLineKind.LineFeed });
-  dummySourceFile = import_ts_morph12.ts.createSourceFile(
+  printer = import_ts_morph13.ts.createPrinter({ newLine: import_ts_morph13.ts.NewLineKind.LineFeed });
+  dummySourceFile = import_ts_morph13.ts.createSourceFile(
     "_dummy.ts",
     "",
-    import_ts_morph12.ts.ScriptTarget.ESNext,
+    import_ts_morph13.ts.ScriptTarget.ESNext,
     false,
-    import_ts_morph12.ts.ScriptKind.TS
+    import_ts_morph13.ts.ScriptKind.TS
   );
   constructor(processor = new Processor()) {
     super();
@@ -246668,24 +247032,24 @@ var AstHttpDataFileGenerator = class _AstHttpDataFileGenerator extends AstFileGe
       const innerProps = [];
       for (const [innerKey, value] of Object.entries(innerMap)) {
         innerProps.push(
-          import_ts_morph12.ts.factory.createPropertyAssignment(
-            import_ts_morph12.ts.factory.createStringLiteral(innerKey),
-            import_ts_morph12.ts.factory.createStringLiteral(value)
+          import_ts_morph13.ts.factory.createPropertyAssignment(
+            import_ts_morph13.ts.factory.createStringLiteral(innerKey),
+            import_ts_morph13.ts.factory.createStringLiteral(value)
           )
         );
       }
       outerProps.push(
-        import_ts_morph12.ts.factory.createPropertyAssignment(
-          import_ts_morph12.ts.factory.createStringLiteral(outerKey),
-          import_ts_morph12.ts.factory.createObjectLiteralExpression(innerProps, true)
+        import_ts_morph13.ts.factory.createPropertyAssignment(
+          import_ts_morph13.ts.factory.createStringLiteral(outerKey),
+          import_ts_morph13.ts.factory.createObjectLiteralExpression(innerProps, true)
         )
       );
     }
-    return import_ts_morph12.ts.factory.createObjectLiteralExpression(outerProps, true);
+    return import_ts_morph13.ts.factory.createObjectLiteralExpression(outerProps, true);
   }
   printNestedObject(data) {
     return this.printer.printNode(
-      import_ts_morph12.ts.EmitHint.Unspecified,
+      import_ts_morph13.ts.EmitHint.Unspecified,
       this.buildNestedStringArrayExpr(data),
       this.dummySourceFile
     );
@@ -246751,8 +247115,8 @@ var AstHttpDataFileGenerator = class _AstHttpDataFileGenerator extends AstFileGe
     for (const [key, routeExpr] of Object.entries(routes)) {
       const data = routeData[key] ?? null;
       const expr = data !== null ? this.injectRegex(routeExpr, data) : routeExpr;
-      const printedRoute = this.printer.printNode(import_ts_morph12.ts.EmitHint.Unspecified, expr, this.dummySourceFile);
-      const formattedKey = key.includes("::") ? `[${this.printer.printNode(import_ts_morph12.ts.EmitHint.Unspecified, this.buildEnumCaseExpr(key), this.dummySourceFile)}]` : `['${key}']`;
+      const printedRoute = this.printer.printNode(import_ts_morph13.ts.EmitHint.Unspecified, expr, this.dummySourceFile);
+      const formattedKey = key.includes("::") ? `[${this.printer.printNode(import_ts_morph13.ts.EmitHint.Unspecified, this.buildEnumCaseExpr(key), this.dummySourceFile)}]` : `['${key}']`;
       lines.push(`            ${formattedKey}: (): RouteContract => ${printedRoute},`);
     }
     return lines;
@@ -246764,13 +247128,13 @@ var AstHttpDataFileGenerator = class _AstHttpDataFileGenerator extends AstFileGe
    * `Processor` and computes the real value here.
    */
   injectRegex(expr, data) {
-    if (!(data.isDynamic && import_ts_morph12.ts.isNewExpression(expr))) {
+    if (!(data.isDynamic && import_ts_morph13.ts.isNewExpression(expr))) {
       return expr;
     }
     const computedRegex = data.parameters.length > 0 ? this.computeRegex(data) : "";
-    const original = expr.arguments ?? import_ts_morph12.ts.factory.createNodeArray();
-    const args = original.map((arg, index) => index === 2 ? import_ts_morph12.ts.factory.createStringLiteral(computedRegex) : arg);
-    return import_ts_morph12.ts.factory.createNewExpression(expr.expression, expr.typeArguments, args);
+    const original = expr.arguments ?? import_ts_morph13.ts.factory.createNodeArray();
+    const args = original.map((arg, index) => index === 2 ? import_ts_morph13.ts.factory.createStringLiteral(computedRegex) : arg);
+    return import_ts_morph13.ts.factory.createNewExpression(expr.expression, expr.typeArguments, args);
   }
   // -------------------------------------------------------------------------
   // Imperative `getRoutes()` support
@@ -246782,11 +247146,11 @@ var AstHttpDataFileGenerator = class _AstHttpDataFileGenerator extends AstFileGe
    *   DynamicRoute(path, name, regex, parameters, handler, requestMethods?)
    */
   extractRouteMeta(expr) {
-    if (!import_ts_morph12.ts.isNewExpression(expr) || !import_ts_morph12.ts.isIdentifier(expr.expression)) {
+    if (!import_ts_morph13.ts.isNewExpression(expr) || !import_ts_morph13.ts.isIdentifier(expr.expression)) {
       return void 0;
     }
     const isDynamic = expr.expression.text === "DynamicRoute";
-    const args = expr.arguments ?? import_ts_morph12.ts.factory.createNodeArray();
+    const args = expr.arguments ?? import_ts_morph13.ts.factory.createNodeArray();
     const path6 = this.stringArg(args[0]);
     const name = this.stringArg(args[1]);
     if (name === void 0 || path6 === void 0) {
@@ -246798,7 +247162,7 @@ var AstHttpDataFileGenerator = class _AstHttpDataFileGenerator extends AstFileGe
     return { expr, name, path: path6, isDynamic, regex, methods };
   }
   stringArg(node) {
-    return node !== void 0 && import_ts_morph12.ts.isStringLiteral(node) ? node.text : void 0;
+    return node !== void 0 && import_ts_morph13.ts.isStringLiteral(node) ? node.text : void 0;
   }
   /**
    * Resolve a `[RequestMethod.GET, ...]` argument to method-name strings,
@@ -246806,12 +247170,12 @@ var AstHttpDataFileGenerator = class _AstHttpDataFileGenerator extends AstFileGe
    * and expanding `RequestMethod.ANY` to every request method.
    */
   extractMethodNamesFromArg(node) {
-    if (node === void 0 || !import_ts_morph12.ts.isArrayLiteralExpression(node)) {
+    if (node === void 0 || !import_ts_morph13.ts.isArrayLiteralExpression(node)) {
       return ["HEAD" /* HEAD */, "GET" /* GET */];
     }
     const methods = [];
     for (const element of node.elements) {
-      if (!import_ts_morph12.ts.isPropertyAccessExpression(element)) {
+      if (!import_ts_morph13.ts.isPropertyAccessExpression(element)) {
         continue;
       }
       const method = element.name.text;
@@ -247018,27 +247382,39 @@ var GenerateDataFromAst = class extends GenerateFromAst {
   }
   generateEventData(listenerProviders, config, output) {
     output = output.withAddedMessages(new Message("Generating Event Data..........................")).writeMessages();
-    const allListeners = {};
+    const allListeners = /* @__PURE__ */ new Map();
+    const imperativeListeners = [];
+    const importMap = {};
     for (const providerClass of listenerProviders) {
       const filePath = this.fqnToFilePath(providerClass, config.namespace, config.dir);
       if (filePath === "" || !fs4.existsSync(filePath)) {
         continue;
       }
       const providerResult = this.listenerProviderReader.readFile(filePath);
+      if (providerResult.listeners.length > 0) {
+        imperativeListeners.push(...providerResult.listeners);
+        importMap[path5.basename(filePath, ".ts")] = this.importSpecifier(config.dataPath, filePath);
+        this.mergeReaderImports(importMap, providerResult.listenerImports, config);
+      }
       for (const listenerClass of providerResult.listenerClasses) {
         const listenerPath = this.fqnToFilePath(listenerClass, config.namespace, config.dir);
         if (listenerPath === "" || !fs4.existsSync(listenerPath)) {
           continue;
         }
         const attrResult = this.listenerAttributeReader.readFile(listenerPath);
-        Object.assign(allListeners, attrResult.listeners);
+        for (const [name, listener] of attrResult.listeners) {
+          allListeners.set(name, listener);
+        }
+        this.mergeReaderImports(importMap, attrResult.importMap, config);
       }
     }
-    const status = this.eventGenerator.generateFile(
+    this.eventGenerator.classImportMap = importMap;
+    const status = this.eventGenerator.generateMergedFile(
       config.dataPath,
       "AppEventData",
       config.dataNamespace,
-      allListeners
+      allListeners,
+      imperativeListeners
     );
     return this.addMessagesForGenerateStatus(output, status).withAddedMessages(new NewLine()).writeMessages();
   }
@@ -247122,12 +247498,8 @@ var GenerateDataFromAst = class extends GenerateFromAst {
     return this.addMessagesForGenerateStatus(output, status).withAddedMessages(new NewLine()).writeMessages();
   }
   /**
-   * Merge the class-name → absolute-file-path imports a route attribute reader
-   * resolved (handler/help-text/middleware classes) into the generated data
-   * file's import map, converting each absolute path to the specifier the
-   * generated file imports it by — relative to the output directory for
-   * application source, or the owning package's own specifier for a class an
-   * installed package exposes.
+   * Merge the class-name → absolute-file-path imports a reader resolved into the generated data
+   * file's import map, by the specifier that file imports each one by.
    */
   mergeReaderImports(importMap, readerImportMap, config) {
     for (const [name, absolutePath] of Object.entries(readerImportMap)) {