@valkyrjaio/sindri 26.2.0 → 26.4.0

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;
@@ -193,7 +193,7 @@ var require_typescript = __commonJS({
         SymbolDisplayPartKind: () => SymbolDisplayPartKind,
         SymbolFlags: () => SymbolFlags,
         SymbolFormatFlags: () => SymbolFormatFlags,
-        SyntaxKind: () => SyntaxKind2,
+        SyntaxKind: () => SyntaxKind,
         Ternary: () => Ternary,
         ThrottledCancellationToken: () => ThrottledCancellationToken,
         TokenClass: () => TokenClass,
@@ -4084,7 +4084,7 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
         function formatSyntaxKind(kind) {
           return formatEnum(
             kind,
-            SyntaxKind2,
+            SyntaxKind,
             /*isFlags*/
             false
           );
@@ -5532,7 +5532,7 @@ ${lanes.join("\n")}
       })(tracingEnabled || (tracingEnabled = {}));
       var startTracing = tracingEnabled.startTracing;
       var dumpTracingLegend = tracingEnabled.dumpLegend;
-      var SyntaxKind2 = /* @__PURE__ */ ((SyntaxKind5) => {
+      var SyntaxKind = /* @__PURE__ */ ((SyntaxKind5) => {
         SyntaxKind5[SyntaxKind5["Unknown"] = 0] = "Unknown";
         SyntaxKind5[SyntaxKind5["EndOfFileToken"] = 1] = "EndOfFileToken";
         SyntaxKind5[SyntaxKind5["SingleLineCommentTrivia"] = 2] = "SingleLineCommentTrivia";
@@ -6038,7 +6038,7 @@ ${lanes.join("\n")}
           /* LastKeyword */
         ] = "LastContextualKeyword";
         return SyntaxKind5;
-      })(SyntaxKind2 || {});
+      })(SyntaxKind || {});
       var NodeFlags = /* @__PURE__ */ ((NodeFlags3) => {
         NodeFlags3[NodeFlags3["None"] = 0] = "None";
         NodeFlags3[NodeFlags3["Let"] = 1] = "Let";
@@ -9433,11 +9433,11 @@ ${lanes.join("\n")}
           return toComponents;
         }
         const components = toComponents.slice(start);
-        const relative = [];
+        const relative2 = [];
         for (; start < fromComponents.length; start++) {
-          relative.push("..");
+          relative2.push("..");
         }
-        return ["", ...relative, ...components];
+        return ["", ...relative2, ...components];
       }
       function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
         Debug.assert(getRootLength(fromDirectory) > 0 === getRootLength(to) > 0, "Paths must either both be absolute or both be relative");
@@ -48133,11 +48133,11 @@ ${lanes.join("\n")}
             if (i < rootLength) {
               return void 0;
             }
-            const sep = directory.lastIndexOf(directorySeparator, i - 1);
-            if (sep === -1) {
+            const sep2 = directory.lastIndexOf(directorySeparator, i - 1);
+            if (sep2 === -1) {
               return void 0;
             }
-            return directory.substr(0, Math.max(sep, rootLength));
+            return directory.substr(0, Math.max(sep2, rootLength));
           }
         }
       }
@@ -53980,9 +53980,9 @@ ${lanes.join("\n")}
               if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
                 return;
               }
-              const relative = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
+              const relative2 = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
               for (const symlinkDirectory of symlinkDirectories) {
-                const option = resolvePath(symlinkDirectory, relative);
+                const option = resolvePath(symlinkDirectory, relative2);
                 const result2 = cb(option, target === referenceRedirect);
                 shouldFilterIgnoredPaths = true;
                 if (result2) return result2;
@@ -137157,9 +137157,9 @@ ${lanes.join("\n")}
             /*ignoreCase*/
             false
           )) {
-            const basename = getBaseFileName(a.fileName);
-            if (basename === "lib.d.ts" || basename === "lib.es6.d.ts") return 0;
-            const name = removeSuffix(removePrefix(basename, "lib."), ".d.ts");
+            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 index = libs.indexOf(name);
             if (index !== -1) return index + 1;
           }
@@ -196444,7 +196444,7 @@ ${options.prefix}` : "\n" : options.prefix
         SymbolDisplayPartKind: () => SymbolDisplayPartKind,
         SymbolFlags: () => SymbolFlags,
         SymbolFormatFlags: () => SymbolFormatFlags,
-        SyntaxKind: () => SyntaxKind2,
+        SyntaxKind: () => SyntaxKind,
         Ternary: () => Ternary,
         ThrottledCancellationToken: () => ThrottledCancellationToken,
         TokenClass: () => TokenClass,
@@ -201085,8 +201085,8 @@ ${options.prefix}` : "\n" : options.prefix
             }
           };
           for (const file of files) {
-            const basename = getBaseFileName(file);
-            if (basename === "package.json" || basename === "bower.json") {
+            const basename2 = getBaseFileName(file);
+            if (basename2 === "package.json" || basename2 === "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 basename = getBaseFileName(fileOrDirectoryPath);
-              if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename === "package.json" || basename === "node_modules")) {
+              const basename2 = getBaseFileName(fileOrDirectoryPath);
+              if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename2 === "package.json" || basename2 === "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;
       }
@@ -213537,7 +213537,7 @@ var require_path_browserify = __commonJS({
       }
       return res;
     }
-    function _format(sep, pathObject) {
+    function _format(sep2, pathObject) {
       var dir = pathObject.dir || pathObject.root;
       var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
       if (!dir) {
@@ -213546,7 +213546,7 @@ var require_path_browserify = __commonJS({
       if (dir === pathObject.root) {
         return dir + base;
       }
-      return dir + sep + base;
+      return dir + sep2 + base;
     }
     var posix = {
       // path.resolve([from ...], to)
@@ -213615,7 +213615,7 @@ var require_path_browserify = __commonJS({
           return ".";
         return posix.normalize(joined);
       },
-      relative: function relative(from, to) {
+      relative: function relative2(from, to) {
         assertPath(from);
         assertPath(to);
         if (from === to) return "";
@@ -213706,7 +213706,7 @@ var require_path_browserify = __commonJS({
         if (hasRoot && end === 1) return "//";
         return path4.slice(0, end);
       },
-      basename: function basename(path4, ext) {
+      basename: function basename2(path4, ext) {
         if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
         assertPath(path4);
         var start = 0;
@@ -216463,12 +216463,12 @@ var require_dist2 = __commonJS({
       return patterns.length > 0 ? buildCrawler(options, patterns) : [];
     }
     async function glob(globInput, options) {
-      const [crawler, relative] = getCrawler(globInput, options);
-      return crawler ? formatPaths(await crawler.withPromise(), relative) : [];
+      const [crawler, relative2] = getCrawler(globInput, options);
+      return crawler ? formatPaths(await crawler.withPromise(), relative2) : [];
     }
     function globSync(globInput, options) {
-      const [crawler, relative] = getCrawler(globInput, options);
-      return crawler ? formatPaths(crawler.sync(), relative) : [];
+      const [crawler, relative2] = getCrawler(globInput, options);
+      return crawler ? formatPaths(crawler.sync(), relative2) : [];
     }
     exports2.convertPathToPattern = convertPathToPattern;
     exports2.escapePath = escapePath;
@@ -216482,7 +216482,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");
@@ -216512,7 +216512,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);
@@ -219622,85 +219622,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;
@@ -231501,12 +231501,12 @@ Node text: ${this.#forgottenText}`;
         }
       };
     }
-    var Expression = class extends Node2 {
+    var Expression2 = class extends Node2 {
       getContextualType() {
         return this._context.typeChecker.getContextualType(this);
       }
     };
-    var BinaryExpressionBase = Expression;
+    var BinaryExpressionBase = Expression2;
     var BinaryExpression = class extends BinaryExpressionBase {
       getLeft() {
         return this._getNodeFromCompilerNode(this.compilerNode.left);
@@ -231530,7 +231530,7 @@ Node text: ${this.#forgottenText}`;
         return this._getNodeFromCompilerNode(this.compilerNode.left);
       }
     };
-    var UnaryExpression = class extends Expression {
+    var UnaryExpression = class extends Expression2 {
     };
     var UpdateExpression = class extends UnaryExpression {
     };
@@ -231660,7 +231660,7 @@ Node text: ${this.#forgottenText}`;
       return BaseExpressionedNode(Base);
     }
     var createBase$E = (ctor) => TypedNode(ExpressionedNode(ctor));
-    var AsExpressionBase = createBase$E(Expression);
+    var AsExpressionBase = createBase$E(Expression2);
     var AsExpression = class extends AsExpressionBase {
     };
     var AwaitExpressionBase = UnaryExpressionedNode(UnaryExpression);
@@ -231673,13 +231673,13 @@ Node text: ${this.#forgottenText}`;
         return this._context.typeChecker.getTypeAtLocation(this);
       }
     };
-    var CommaListExpressionBase = Expression;
+    var CommaListExpressionBase = Expression2;
     var CommaListExpression = class extends CommaListExpressionBase {
       getElements() {
         return this.compilerNode.elements.map((e) => this._getNodeFromCompilerNode(e));
       }
     };
-    var ConditionalExpressionBase = Expression;
+    var ConditionalExpressionBase = Expression2;
     var ConditionalExpression = class extends ConditionalExpressionBase {
       getCondition() {
         return this._getNodeFromCompilerNode(this.compilerNode.condition);
@@ -232010,13 +232010,13 @@ Node text: ${this.#forgottenText}`;
         });
       }
     };
-    var OmittedExpressionBase = Expression;
+    var OmittedExpressionBase = Expression2;
     var OmittedExpression = class extends OmittedExpressionBase {
     };
-    var ParenthesizedExpressionBase = ExpressionedNode(Expression);
+    var ParenthesizedExpressionBase = ExpressionedNode(Expression2);
     var ParenthesizedExpression = class extends ParenthesizedExpressionBase {
     };
-    var PartiallyEmittedExpressionBase = ExpressionedNode(Expression);
+    var PartiallyEmittedExpressionBase = ExpressionedNode(Expression2);
     var PartiallyEmittedExpression = class extends PartiallyEmittedExpressionBase {
     };
     var PostfixUnaryExpressionBase = UnaryExpression;
@@ -232042,10 +232042,10 @@ Node text: ${this.#forgottenText}`;
     var PropertyAccessExpression = class extends PropertyAccessExpressionBase {
     };
     var createBase$x = (ctor) => TypedNode(ExpressionedNode(ctor));
-    var SatisfiesExpressionBase = createBase$x(Expression);
+    var SatisfiesExpressionBase = createBase$x(Expression2);
     var SatisfiesExpression = class extends SatisfiesExpressionBase {
     };
-    var SpreadElementBase = ExpressionedNode(Expression);
+    var SpreadElementBase = ExpressionedNode(Expression2);
     var SpreadElement = class extends SpreadElementBase {
     };
     var SuperElementAccessExpressionBase = SuperExpressionedNode(ElementAccessExpression);
@@ -232070,7 +232070,7 @@ Node text: ${this.#forgottenText}`;
     var VoidExpressionBase = UnaryExpressionedNode(UnaryExpression);
     var VoidExpression = class extends VoidExpressionBase {
     };
-    var YieldExpressionBase = ExpressionableNode(GeneratorableNode(Expression));
+    var YieldExpressionBase = ExpressionableNode(GeneratorableNode(Expression2));
     var YieldExpression = class extends YieldExpressionBase {
     };
     var StatementBase = ChildOrderableNode(Node2);
@@ -234569,7 +234569,7 @@ Node text: ${this.#forgottenText}`;
       return JSDocableNode(TypeParameteredNode(SignaturedDeclaration(StatementedNode(ModifierableNode(Base)))));
     }
     var createBase$p = (ctor) => TextInsertableNode(BodiedNode(AsyncableNode(FunctionLikeDeclaration(ctor))));
-    var ArrowFunctionBase = createBase$p(Expression);
+    var ArrowFunctionBase = createBase$p(Expression2);
     var ArrowFunction = class extends ArrowFunctionBase {
       getEqualsGreaterThan() {
         return this._getNodeFromCompilerNode(this.compilerNode.equalsGreaterThanToken);
@@ -237145,7 +237145,7 @@ Node text: ${this.#forgottenText}`;
     var JsxClosingElementBase = createBase$3(Node2);
     var JsxClosingElement = class extends JsxClosingElementBase {
     };
-    var JsxClosingFragment = class extends Expression {
+    var JsxClosingFragment = class extends Expression2 {
     };
     var JsxElementBase = PrimaryExpression;
     var JsxElement = class extends JsxElementBase {
@@ -237217,7 +237217,7 @@ Node text: ${this.#forgottenText}`;
         }
       });
     }
-    var JsxExpressionBase = ExpressionableNode(DotDotDotTokenableNode(Expression));
+    var JsxExpressionBase = ExpressionableNode(DotDotDotTokenableNode(Expression2));
     var JsxExpression = class extends JsxExpressionBase {
     };
     var JsxFragment = class extends PrimaryExpression {
@@ -237252,10 +237252,10 @@ Node text: ${this.#forgottenText}`;
       }
     };
     var createBase$2 = (ctor) => JsxAttributedNode(JsxTagNamedNode(ctor));
-    var JsxOpeningElementBase = createBase$2(Expression);
+    var JsxOpeningElementBase = createBase$2(Expression2);
     var JsxOpeningElement = class extends JsxOpeningElementBase {
     };
-    var JsxOpeningFragment = class extends Expression {
+    var JsxOpeningFragment = class extends Expression2 {
     };
     var createBase$1 = (ctor) => JsxAttributedNode(JsxTagNamedNode(ctor));
     var JsxSelfClosingElementBase = createBase$1(PrimaryExpression);
@@ -240078,21 +240078,21 @@ Node text: ${this.#forgottenText}`;
       [common.SyntaxKind.WithStatement]: WithStatement,
       [common.SyntaxKind.YieldExpression]: YieldExpression,
       [common.SyntaxKind.SemicolonToken]: Node2,
-      [common.SyntaxKind.AnyKeyword]: Expression,
-      [common.SyntaxKind.BooleanKeyword]: Expression,
+      [common.SyntaxKind.AnyKeyword]: Expression2,
+      [common.SyntaxKind.BooleanKeyword]: Expression2,
       [common.SyntaxKind.FalseKeyword]: FalseLiteral,
       [common.SyntaxKind.ImportKeyword]: ImportExpression,
       [common.SyntaxKind.InferKeyword]: Node2,
       [common.SyntaxKind.NeverKeyword]: Node2,
       [common.SyntaxKind.NullKeyword]: NullLiteral,
-      [common.SyntaxKind.NumberKeyword]: Expression,
-      [common.SyntaxKind.ObjectKeyword]: Expression,
-      [common.SyntaxKind.StringKeyword]: Expression,
-      [common.SyntaxKind.SymbolKeyword]: Expression,
+      [common.SyntaxKind.NumberKeyword]: Expression2,
+      [common.SyntaxKind.ObjectKeyword]: Expression2,
+      [common.SyntaxKind.StringKeyword]: Expression2,
+      [common.SyntaxKind.SymbolKeyword]: Expression2,
       [common.SyntaxKind.SuperKeyword]: SuperExpression,
       [common.SyntaxKind.ThisKeyword]: ThisExpression,
       [common.SyntaxKind.TrueKeyword]: TrueLiteral,
-      [common.SyntaxKind.UndefinedKeyword]: Expression,
+      [common.SyntaxKind.UndefinedKeyword]: Expression2,
       [common.SyntaxKind.VoidExpression]: VoidExpression
     };
     var CompilerFactory = class {
@@ -241356,7 +241356,7 @@ Node text: ${this.#forgottenText}`;
     exports2.ExportSpecifier = ExportSpecifier;
     exports2.ExportSpecifierBase = ExportSpecifierBase;
     exports2.ExportableNode = ExportableNode;
-    exports2.Expression = Expression;
+    exports2.Expression = Expression2;
     exports2.ExpressionStatement = ExpressionStatement;
     exports2.ExpressionStatementBase = ExpressionStatementBase;
     exports2.ExpressionWithTypeArguments = ExpressionWithTypeArguments;
@@ -242575,7 +242575,20 @@ var HandlerData = class {
 };
 
 // src/Sindri/Ast/Abstract/AstReader.ts
-var AstReader = class {
+var AstReader = class _AstReader {
+  /**
+   * Module resolution settings for {@link resolveModuleSpecifierToFilePath}.
+   *
+   * NodeNext mirrors how the application itself resolves its imports, and
+   * `allowImportingTsExtensions` matches the framework convention of writing
+   * the `.ts` extension in every import specifier.
+   */
+  static MODULE_RESOLUTION_OPTIONS = {
+    module: import_ts_morph.ts.ModuleKind.NodeNext,
+    moduleResolution: import_ts_morph.ts.ModuleResolutionKind.NodeNext,
+    allowImportingTsExtensions: true,
+    noEmit: true
+  };
   parseFileToSourceFile(filePath) {
     if (!fs.existsSync(filePath)) {
       throw new AstFileReadException(`Cannot read file '${filePath}'.`);
@@ -242623,12 +242636,39 @@ var AstReader = class {
     if (moduleSpecifier === void 0) {
       return "";
     }
-    if (!moduleSpecifier.startsWith(".")) {
+    return this.resolveModuleSpecifierToFilePath(moduleSpecifier, currentFilePath);
+  }
+  /**
+   * Resolve a module specifier to the absolute path of the TypeScript file it points at.
+   *
+   * Relative specifiers resolve against the importing file's directory. Bare
+   * package specifiers (`@valkyrjaio/valkyrja/Cli/Routing/Data/Route.ts`) go
+   * through the TypeScript compiler's NodeNext resolver, which honors the
+   * package's `exports` map — so a provider tree that reaches into an
+   * installed package (the framework's own component providers, reached from
+   * the app config) is walked exactly like application source.
+   *
+   * Returns '' when the specifier cannot be resolved to an existing `.ts`
+   * source file. A package shipping only compiled `.js` — or only `.d.ts`
+   * declarations, which carry no `getRoutes()` body to read — has nothing for
+   * the AST readers to walk.
+   */
+  resolveModuleSpecifierToFilePath(moduleSpecifier, currentFilePath) {
+    if (moduleSpecifier.startsWith(".")) {
+      const dir = path.dirname(currentFilePath);
+      const resolved2 = path.resolve(dir, moduleSpecifier.replace(/\.js$/, ".ts"));
+      return fs.existsSync(resolved2) ? resolved2 : "";
+    }
+    const resolved = import_ts_morph.ts.resolveModuleName(
+      moduleSpecifier,
+      currentFilePath,
+      _AstReader.MODULE_RESOLUTION_OPTIONS,
+      import_ts_morph.ts.sys
+    ).resolvedModule?.resolvedFileName;
+    if (resolved === void 0 || !resolved.endsWith(".ts") || resolved.endsWith(".d.ts")) {
       return "";
     }
-    const dir = path.dirname(currentFilePath);
-    const resolved = path.resolve(dir, moduleSpecifier.replace(/\.js$/, ".ts"));
-    return fs.existsSync(resolved) ? resolved : "";
+    return resolved;
   }
   /**
    * Extract class names from a method returning [new A(), new B(), ...].
@@ -242650,6 +242690,90 @@ var AstReader = class {
     }
     return classes;
   }
+  /**
+   * Resolve a `new X()` or bare `X` identifier element to the absolute file
+   * path of the class it references, using the current file's import map.
+   *
+   * Returns undefined when the element is neither form, or when the name is
+   * not imported via a relative specifier (e.g. framework classes imported
+   * from a package — those are intentionally skipped by the provider walk).
+   */
+  resolveElementToFilePath(element, useMap, currentFilePath) {
+    let name;
+    if (import_ts_morph.ts.isNewExpression(element)) {
+      name = import_ts_morph.ts.isIdentifier(element.expression) ? element.expression.text : void 0;
+    } else if (import_ts_morph.ts.isIdentifier(element)) {
+      name = element.text;
+    }
+    if (name === void 0) {
+      return void 0;
+    }
+    const resolved = this.resolveImportToFilePath(name, useMap, currentFilePath);
+    return resolved !== "" ? resolved : void 0;
+  }
+  /**
+   * Extract the absolute file paths of the classes referenced by a method
+   * returning [new A(), new B(), ...] (or [A, B, ...]).
+   *
+   * Unlike {@link extractClassListFromValues} (which returns bare class
+   * names), this resolves each reference through the import map so provider
+   * classes are located unambiguously — critical when the same short class
+   * name exists in more than one component tree (e.g. an Http and a Cli
+   * `ComponentProvider`).
+   */
+  extractClassPathListFromValues(method, useMap, currentFilePath) {
+    if (method === void 0) {
+      return [];
+    }
+    const array = this.findReturnedArray(method);
+    if (array === void 0) {
+      return [];
+    }
+    return this.extractClassPathListFromArrayExpr(array, useMap, currentFilePath);
+  }
+  /**
+   * Extract the absolute file paths of the classes referenced by the elements
+   * of an array literal, using the current file's import map.
+   */
+  extractClassPathListFromArrayExpr(array, useMap, currentFilePath) {
+    const paths = [];
+    for (const element of array.elements) {
+      const resolved = this.resolveElementToFilePath(element, useMap, currentFilePath);
+      if (resolved !== void 0) {
+        paths.push(resolved);
+      }
+    }
+    return paths;
+  }
+  /**
+   * Collect every identifier an expression references as a value.
+   *
+   * Expressions taken from a provider's `getRoutes()` body are emitted into
+   * the generated data cache verbatim, so the cache must import everything
+   * they name — not just the provider class, but the parameter/enum/constant
+   * classes the route arguments reach for. Property *names* are skipped (the
+   * `HELP` of `CommandName.HELP` is not an import) as are type positions,
+   * which erase at runtime and must never become a value import.
+   */
+  collectReferencedIdentifiers(node, names = /* @__PURE__ */ new Set()) {
+    if (import_ts_morph.ts.isTypeNode(node)) {
+      return names;
+    }
+    if (import_ts_morph.ts.isIdentifier(node)) {
+      names.add(node.text);
+      return names;
+    }
+    if (import_ts_morph.ts.isPropertyAccessExpression(node)) {
+      return this.collectReferencedIdentifiers(node.expression, names);
+    }
+    if (import_ts_morph.ts.isPropertyAssignment(node)) {
+      return this.collectReferencedIdentifiers(node.initializer, names);
+    }
+    import_ts_morph.ts.forEachChild(node, (child) => {
+      this.collectReferencedIdentifiers(child, names);
+    });
+    return names;
+  }
   /**
    * Extract service ID strings from keys of an object-returning method.
    *
@@ -242751,7 +242875,7 @@ var AstReader = class {
       return node.text;
     }
     if (import_ts_morph.ts.isIdentifier(node)) {
-      return this.resolveStaticProperty(node.text, void 0, useMap, currentFilePath);
+      return this.resolveConstant(node.text, useMap, currentFilePath);
     }
     if (import_ts_morph.ts.isPropertyAccessExpression(node)) {
       const objName = import_ts_morph.ts.isIdentifier(node.expression) ? node.expression.text : void 0;
@@ -242762,33 +242886,75 @@ var AstReader = class {
     return void 0;
   }
   /**
-   * Resolve a static property value by reading the imported source file.
+   * Resolve a static property value by reading the file that declares its class.
    */
   resolveStaticProperty(className, propName, useMap, currentFilePath) {
-    const importedFilePath = this.resolveImportToFilePath(className, useMap, currentFilePath);
-    if (importedFilePath === "") {
+    const declaringClass = this.parseDeclaringSourceFile(className, useMap, currentFilePath)?.getClass(className);
+    if (declaringClass === void 0) {
       return void 0;
     }
+    const prop = declaringClass.getStaticProperty(propName);
+    if (prop === void 0 || !import_ts_morph.Node.isPropertyDeclaration(prop)) {
+      return void 0;
+    }
+    return this.stringValueOf(prop.getInitializer());
+  }
+  /**
+   * Resolve a module-level `const` to its string value.
+   *
+   * Not every binding key is a class static — some are plain exported
+   * constants, e.g. `export const LoggerContractId = 'Valkyrja.Log.Logger.LoggerContract' as const;`
+   */
+  resolveConstant(name, useMap, currentFilePath) {
+    const declaration = this.parseDeclaringSourceFile(name, useMap, currentFilePath)?.getVariableDeclaration(name);
+    return this.stringValueOf(declaration?.getInitializer());
+  }
+  /**
+   * Parse the file that declares a name: the module it is imported from, or
+   * the current file when the name is not imported.
+   *
+   * A provider commonly declares the binding keys for its own services
+   * alongside the publishers that use them, so `[Provider.SomeId]` names a
+   * constant that no import map can resolve — it lives in the file being read.
+   *
+   * Returns undefined when the file cannot be read.
+   */
+  parseDeclaringSourceFile(name, useMap, currentFilePath) {
+    const importedFilePath = this.resolveImportToFilePath(name, useMap, currentFilePath);
+    const filePath = importedFilePath !== "" ? importedFilePath : currentFilePath;
     try {
       const project = new import_ts_morph.Project({ skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: true });
-      const importedSource = project.addSourceFileAtPath(importedFilePath);
-      const importedClass = importedSource.getClass(className);
-      if (importedClass === void 0 || propName === void 0) {
-        return void 0;
-      }
-      const prop = importedClass.getStaticProperty(propName);
-      if (prop === void 0) {
-        return void 0;
-      }
-      if (import_ts_morph.Node.isPropertyDeclaration(prop)) {
-        const initializer = prop.getInitializer();
-        if (initializer?.isKind(import_ts_morph.SyntaxKind.StringLiteral) === true) {
-          return initializer.compilerNode.text;
-        }
-      }
+      return project.addSourceFileAtPath(filePath);
     } catch {
+      return void 0;
     }
-    return void 0;
+  }
+  /**
+   * The string a declaration's initializer holds, once its type-only wrappers are stripped.
+   */
+  stringValueOf(initializer) {
+    if (initializer === void 0) {
+      return void 0;
+    }
+    const value = this.unwrapTypeAssertions(initializer.compilerNode);
+    return import_ts_morph.ts.isStringLiteral(value) ? value.text : void 0;
+  }
+  /**
+   * Strip the type-only wrappers an expression may be dressed in — `as`,
+   * `satisfies` and parentheses — to reach the value node underneath.
+   *
+   * Binding-key constants are declared `static readonly Data = 'Some.Id' as
+   * const;`, so the initializer node is an `AsExpression`, not the
+   * `StringLiteral` holding the value. Without unwrapping, every such key
+   * resolves to nothing and the publishers it names are dropped from the
+   * generated cache.
+   */
+  unwrapTypeAssertions(node) {
+    let current = node;
+    while (import_ts_morph.ts.isAsExpression(current) || import_ts_morph.ts.isSatisfiesExpression(current) || import_ts_morph.ts.isParenthesizedExpression(current)) {
+      current = current.expression;
+    }
+    return current;
   }
   /**
    * Resolve a short class name — returns the name as-is (class names in TS are local).
@@ -243427,11 +243593,11 @@ var ComponentProviderReader = class _ComponentProviderReader extends AstReader {
     const useMap = this.buildUseMap(sourceFile);
     const methods = this.indexMethods(classDecl);
     return new ComponentProviderResult(
-      this.extractClassListFromValues(methods[_ComponentProviderReader.METHOD_COMPONENT], useMap, filePath),
-      this.extractClassListFromValues(methods[_ComponentProviderReader.METHOD_CONTAINER], useMap, filePath),
-      this.extractClassListFromValues(methods[_ComponentProviderReader.METHOD_EVENT], useMap, filePath),
-      this.extractClassListFromValues(methods[_ComponentProviderReader.METHOD_CLI], useMap, filePath),
-      this.extractClassListFromValues(methods[_ComponentProviderReader.METHOD_HTTP], useMap, filePath)
+      this.extractClassPathListFromValues(methods[_ComponentProviderReader.METHOD_COMPONENT], useMap, filePath),
+      this.extractClassPathListFromValues(methods[_ComponentProviderReader.METHOD_CONTAINER], useMap, filePath),
+      this.extractClassPathListFromValues(methods[_ComponentProviderReader.METHOD_EVENT], useMap, filePath),
+      this.extractClassPathListFromValues(methods[_ComponentProviderReader.METHOD_CLI], useMap, filePath),
+      this.extractClassPathListFromValues(methods[_ComponentProviderReader.METHOD_HTTP], useMap, filePath)
     );
   }
 };
@@ -243576,14 +243742,24 @@ var ConfigReader = class extends AstReader {
     return dataPath;
   }
   /**
-   * Extract provider class names from the providers argument.
-   * In CliConfig, providers is typically the 12th positional arg (index 11).
+   * Extract the absolute file paths of the configured provider classes.
+   *
+   * The providers array is the first array-literal argument after the
+   * `dataNamespace` (index 8) — every preceding argument is a scalar. Its
+   * exact position varies by config type (index 9 in `HttpConfig`, index 11
+   * in `CliConfig` after `applicationName`/`defaultCommandName`), so the
+   * array is located by scanning rather than by a fixed index.
+   *
+   * Each element (`new ComponentProvider()` or a bare `ComponentProvider`
+   * identifier) is resolved through the config file's import map to an
+   * absolute path, so the walk locates the right provider even when the same
+   * short name exists in multiple trees.
    */
   extractProvidersFromArgs(args, useMap, filePath) {
-    for (let i = 10; i < args.length; i++) {
+    for (let i = 9; i < args.length; i++) {
       const arg = args[i];
       if (arg !== void 0 && import_ts_morph3.ts.isArrayLiteralExpression(arg)) {
-        return this.extractClassListFromArrayExpr(arg, useMap, filePath);
+        return this.extractClassPathListFromArrayExpr(arg, useMap, filePath);
       }
     }
     return [];
@@ -244201,18 +244377,29 @@ var ListenerProviderReader = class _ListenerProviderReader extends AstReader {
   }
 };
 
+// src/Sindri/Ast/RouteProviderReader.ts
+var import_ts_morph6 = __toESM(require_ts_morph(), 1);
+
 // src/Sindri/Ast/Data/Result/RouteProviderResult.ts
 var RouteProviderResult = class _RouteProviderResult {
-  constructor(controllerClasses = [], routes = []) {
+  /**
+   * @param routeImports Local name → absolute file path for every class the
+   *                     imperative `routes` expressions reference, so the
+   *                     generated data cache can import them.
+   */
+  constructor(controllerClasses = [], routes = [], routeImports = {}) {
     this.controllerClasses = controllerClasses;
     this.routes = routes;
+    this.routeImports = routeImports;
   }
   controllerClasses;
   routes;
+  routeImports;
   merge(other) {
     return new _RouteProviderResult(
       [.../* @__PURE__ */ new Set([...this.controllerClasses, ...other.controllerClasses])],
-      [...this.routes, ...other.routes]
+      [...this.routes, ...other.routes],
+      { ...this.routeImports, ...other.routeImports }
     );
   }
 };
@@ -244229,18 +244416,58 @@ 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);
     return new RouteProviderResult(
       this.extractClassListFromValues(methods[_RouteProviderReader.METHOD_CONTROLLER_CLASSES], useMap, filePath),
-      this.extractRoutes(methods[_RouteProviderReader.METHOD_ROUTES], useMap, filePath)
+      routes,
+      this.extractRouteImports(routes, useMap, filePath)
     );
   }
-  extractRoutes(_method, _useMap, _filePath) {
-    return [];
+  /**
+   * 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.
+   */
+  extractRouteImports(routes, useMap, filePath) {
+    const imports = {};
+    for (const route2 of routes) {
+      for (const name of this.collectReferencedIdentifiers(route2)) {
+        const resolved = this.resolveImportToFilePath(name, useMap, filePath);
+        if (resolved !== "") {
+          imports[name] = resolved;
+        }
+      }
+    }
+    return imports;
+  }
+  /**
+   * Extract the route objects returned by a provider's `getRoutes()` method.
+   *
+   * TS route providers register routes imperatively — `getRoutes()` returns
+   * the concrete `new Route(...)` / `new DynamicRoute(...)` (or CLI
+   * `new Route(...)`) instances. Those expressions are returned verbatim for
+   * the data-cache generator to emit as route closures and to derive the
+   * path/regex lookup maps from. (Attribute/decorator scanning — the other,
+   * optional source of routes — is handled separately via
+   * {@link readFile}'s controller-class list.)
+   */
+  extractRoutes(method, _useMap, _filePath) {
+    if (method === void 0) {
+      return [];
+    }
+    const array = this.findReturnedArray(method);
+    if (array === void 0) {
+      return [];
+    }
+    return array.elements.filter((element) => import_ts_morph6.ts.isNewExpression(element));
   }
 };
 
 // src/Sindri/Ast/ServiceProviderReader.ts
-var import_ts_morph6 = __toESM(require_ts_morph(), 1);
+var import_ts_morph7 = __toESM(require_ts_morph(), 1);
 
 // src/Sindri/Ast/Data/Result/ServiceProviderResult.ts
 var ServiceProviderResult = class _ServiceProviderResult {
@@ -244293,7 +244520,7 @@ var ServiceProviderReader = class _ServiceProviderReader extends AstReader {
     }
     const map = {};
     for (const prop of obj.properties) {
-      if (!import_ts_morph6.ts.isPropertyAssignment(prop)) {
+      if (!import_ts_morph7.ts.isPropertyAssignment(prop)) {
         continue;
       }
       const serviceId = this.resolvePropertyKeyToString(prop.name, useMap, filePath);
@@ -244314,8 +244541,8 @@ var ServiceProviderReader = class _ServiceProviderReader extends AstReader {
    * Handles: `ProviderClass.publishMethod` and `[ProviderClass, 'method']`.
    */
   extractHandlerFromValue(node, useMap, filePath, currentClass) {
-    if (import_ts_morph6.ts.isPropertyAccessExpression(node)) {
-      const className = import_ts_morph6.ts.isIdentifier(node.expression) ? node.expression.text : void 0;
+    if (import_ts_morph7.ts.isPropertyAccessExpression(node)) {
+      const className = import_ts_morph7.ts.isIdentifier(node.expression) ? node.expression.text : void 0;
       if (className === void 0) {
         return void 0;
       }
@@ -244323,7 +244550,7 @@ var ServiceProviderReader = class _ServiceProviderReader extends AstReader {
       const resolvedClass = className === "self" || className === "this" ? currentClass : className;
       return [resolvedClass, methodName];
     }
-    if (import_ts_morph6.ts.isArrayLiteralExpression(node) && node.elements.length === 2) {
+    if (import_ts_morph7.ts.isArrayLiteralExpression(node) && node.elements.length === 2) {
       const raw = this.extractHandlerFromTsArray(node, useMap, filePath, currentClass);
       if (raw !== void 0) {
         return [raw.class, raw.method];
@@ -244334,11 +244561,11 @@ var ServiceProviderReader = class _ServiceProviderReader extends AstReader {
 };
 
 // src/Sindri/Generator/Ast/Cli/AstCliDataFileGenerator.ts
-var import_ts_morph8 = __toESM(require_ts_morph(), 1);
+var import_ts_morph9 = __toESM(require_ts_morph(), 1);
 
 // src/Sindri/Generator/Abstract/AstFileGenerator.ts
 var fs2 = __toESM(require("fs"), 1);
-var import_ts_morph7 = __toESM(require_ts_morph(), 1);
+var import_ts_morph8 = __toESM(require_ts_morph(), 1);
 var AstFileGenerator = class {
   /**
    * Build a property access or string literal expression from a "ClassName::CASE" string.
@@ -244346,12 +244573,33 @@ var AstFileGenerator = class {
   buildEnumCaseExpr(fqnColonCase) {
     const pos = fqnColonCase.indexOf("::");
     if (pos === -1) {
-      return import_ts_morph7.ts.factory.createStringLiteral(fqnColonCase);
+      return import_ts_morph8.ts.factory.createStringLiteral(fqnColonCase);
     }
     const fqn = fqnColonCase.substring(0, pos);
     const caseName = fqnColonCase.substring(pos + 2);
     const className = fqn.slice(fqn.lastIndexOf("\\") + 1);
-    return import_ts_morph7.ts.factory.createPropertyAccessExpression(import_ts_morph7.ts.factory.createIdentifier(className), caseName);
+    return import_ts_morph8.ts.factory.createPropertyAccessExpression(import_ts_morph8.ts.factory.createIdentifier(className), caseName);
+  }
+  /**
+   * Build the `import { X } from '...';` block for the provider/handler classes
+   * a generated data cache references, followed by a trailing newline (or an
+   * empty string when there are no such imports).
+   *
+   * Names the generated file's fixed framework header already binds are
+   * dropped: those are the same framework classes under the same names, and
+   * emitting them twice is a duplicate-identifier error.
+   */
+  buildUserImportsBlock(classImportMap, reservedNames) {
+    const userImports = Object.entries(classImportMap).filter(([name]) => !reservedNames.includes(name)).map(([name, specifier]) => `import { ${name} } from '${specifier}';`).join("\n");
+    return userImports ? `${userImports}
+` : "";
+  }
+  /**
+   * Render the fixed framework imports a generated data file always carries.
+   */
+  buildFrameworkImportLines(imports, isType = false) {
+    const keyword = isType ? "import type" : "import";
+    return Object.entries(imports).map(([name, specifier]) => `${keyword} { ${name} } from '${specifier}';`);
   }
   writeFile(directory, className, data) {
     const filePath = directory.replace(/\/$/, "") + `/${className}.ts`;
@@ -244370,33 +244618,42 @@ var AstFileGenerator = class {
 };
 
 // src/Sindri/Generator/Ast/Cli/AstCliDataFileGenerator.ts
-var AstCliDataFileGenerator = class extends AstFileGenerator {
+var AstCliDataFileGenerator = class _AstCliDataFileGenerator extends AstFileGenerator {
+  /** The framework classes every generated CLI data file imports as values. */
+  static FRAMEWORK_IMPORTS = {
+    CliRoutingData: "@valkyrjaio/valkyrja/Cli/Routing/Data/CliRoutingData.ts",
+    Route: "@valkyrjaio/valkyrja/Cli/Routing/Data/Route.ts",
+    ArgumentParameter: "@valkyrjaio/valkyrja/Cli/Routing/Data/ArgumentParameter.ts",
+    OptionParameter: "@valkyrjaio/valkyrja/Cli/Routing/Data/OptionParameter.ts",
+    ArgumentMode: "@valkyrjaio/valkyrja/Cli/Routing/Enum/ArgumentMode.ts",
+    ArgumentValueMode: "@valkyrjaio/valkyrja/Cli/Routing/Enum/ArgumentValueMode.ts",
+    OptionMode: "@valkyrjaio/valkyrja/Cli/Routing/Enum/OptionMode.ts",
+    OptionValueMode: "@valkyrjaio/valkyrja/Cli/Routing/Enum/OptionValueMode.ts"
+  };
+  /** The framework types every generated CLI data file imports. */
+  static FRAMEWORK_TYPE_IMPORTS = {
+    RouteContract: "@valkyrjaio/valkyrja/Cli/Routing/Data/Contract/RouteContract.ts"
+  };
   classImportMap = {};
-  printer = import_ts_morph8.ts.createPrinter({ newLine: import_ts_morph8.ts.NewLineKind.LineFeed });
-  dummySourceFile = import_ts_morph8.ts.createSourceFile(
+  printer = import_ts_morph9.ts.createPrinter({ newLine: import_ts_morph9.ts.NewLineKind.LineFeed });
+  dummySourceFile = import_ts_morph9.ts.createSourceFile(
     "_dummy.ts",
     "",
-    import_ts_morph8.ts.ScriptTarget.ESNext,
+    import_ts_morph9.ts.ScriptTarget.ESNext,
     false,
-    import_ts_morph8.ts.ScriptKind.TS
+    import_ts_morph9.ts.ScriptKind.TS
   );
   generateFile(directory, className, namespace, routes) {
-    const userImports = Object.entries(this.classImportMap).map(([name, specifier]) => `import { ${name} } from '${specifier}';`).join("\n");
-    const userImportsBlock = userImports ? `${userImports}
-` : "";
+    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
+      ...Object.keys(_AstCliDataFileGenerator.FRAMEWORK_IMPORTS),
+      ...Object.keys(_AstCliDataFileGenerator.FRAMEWORK_TYPE_IMPORTS)
+    ]);
     const contents = this.generateClassContents(routes);
     const data = [
       "// This file was automatically generated by Sindri.",
       "",
-      `import { CliRoutingData } from '@valkyrjaio/valkyrja/Cli/Routing/Data/CliRoutingData.ts';`,
-      `import { Route } from '@valkyrjaio/valkyrja/Cli/Routing/Data/Route.ts';`,
-      `import { ArgumentParameter } from '@valkyrjaio/valkyrja/Cli/Routing/Data/ArgumentParameter.ts';`,
-      `import { OptionParameter } from '@valkyrjaio/valkyrja/Cli/Routing/Data/OptionParameter.ts';`,
-      `import { ArgumentMode } from '@valkyrjaio/valkyrja/Cli/Routing/Enum/ArgumentMode.ts';`,
-      `import { ArgumentValueMode } from '@valkyrjaio/valkyrja/Cli/Routing/Enum/ArgumentValueMode.ts';`,
-      `import { OptionMode } from '@valkyrjaio/valkyrja/Cli/Routing/Enum/OptionMode.ts';`,
-      `import { OptionValueMode } from '@valkyrjaio/valkyrja/Cli/Routing/Enum/OptionValueMode.ts';`,
-      `import type { RouteContract } from '@valkyrjaio/valkyrja/Cli/Routing/Data/Contract/RouteContract.ts';`,
+      ...this.buildFrameworkImportLines(_AstCliDataFileGenerator.FRAMEWORK_IMPORTS),
+      ...this.buildFrameworkImportLines(_AstCliDataFileGenerator.FRAMEWORK_TYPE_IMPORTS, true),
       userImportsBlock,
       `export class ${className} extends CliRoutingData {`,
       `    constructor() {`,
@@ -244407,6 +244664,46 @@ var AstCliDataFileGenerator = class extends AstFileGenerator {
     ].join("\n");
     return this.writeFile(directory, className, data);
   }
+  /**
+   * Generate the CLI routing data file from imperative `getRoutes()` route
+   * objects — each `new Route(name, description, handler, ...)` is keyed by
+   * its command name (the first constructor argument) and emitted verbatim.
+   */
+  generateFileFromRoutes(directory, className, namespace, routeExprs) {
+    const routes = {};
+    for (const expr of routeExprs) {
+      if (!import_ts_morph9.ts.isNewExpression(expr)) {
+        continue;
+      }
+      const key = this.routeKey((expr.arguments ?? [])[0]);
+      if (key === void 0) {
+        continue;
+      }
+      routes[key] = expr;
+    }
+    return this.generateFile(directory, className, namespace, routes);
+  }
+  /**
+   * Derive the map key for a route from its name argument.
+   *
+   * A literal name keys the map by its own text. A constant reference
+   * (`CliCommandName.LIST` — how the framework's own commands name
+   * themselves) is kept as a `Class::CASE` marker, so the generated file
+   * emits the constant reference as a computed key rather than baking in the
+   * value it happens to hold today.
+   */
+  routeKey(nameArg) {
+    if (nameArg === void 0) {
+      return void 0;
+    }
+    if (import_ts_morph9.ts.isStringLiteral(nameArg)) {
+      return nameArg.text;
+    }
+    if (import_ts_morph9.ts.isPropertyAccessExpression(nameArg) && import_ts_morph9.ts.isIdentifier(nameArg.expression)) {
+      return `${nameArg.expression.text}::${nameArg.name.text}`;
+    }
+    return void 0;
+  }
   generateClassContents(routes) {
     const entries = Object.entries(routes);
     if (entries.length === 0) {
@@ -244414,38 +244711,53 @@ var AstCliDataFileGenerator = class extends AstFileGenerator {
     }
     const lines = [];
     for (const [key, valueExpr] of entries) {
-      const keyExpr = this.buildEnumCaseExpr(key);
-      const printedKey = this.printer.printNode(import_ts_morph8.ts.EmitHint.Unspecified, keyExpr, this.dummySourceFile);
-      const printedValue = this.printer.printNode(import_ts_morph8.ts.EmitHint.Unspecified, valueExpr, this.dummySourceFile);
-      const formattedKey = key.includes("::") ? `[${printedKey}]` : `['${printedKey}']`;
+      const printedValue = this.printExpr(valueExpr);
+      const formattedKey = key.includes("::") ? `[${this.printer.printNode(import_ts_morph9.ts.EmitHint.Unspecified, this.buildEnumCaseExpr(key), this.dummySourceFile)}]` : `['${key}']`;
       lines.push(`            ${formattedKey}: (): RouteContract => ${printedValue},`);
     }
-    return ["super({", "            routes: {", ...lines, "            },", "        });"].join("\n        ");
+    return ["super({", ...lines, "        });"].join("\n        ");
+  }
+  /**
+   * Print an expression to source. Parsed nodes (from a `getRoutes()` body)
+   * are emitted via their original source text; synthesized nodes (which
+   * 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);
   }
 };
 
 // src/Sindri/Generator/Ast/Container/AstContainerDataFileGenerator.ts
-var import_ts_morph9 = __toESM(require_ts_morph(), 1);
-var AstContainerDataFileGenerator = class extends AstFileGenerator {
+var import_ts_morph10 = __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 = {
+    ContainerData: "@valkyrjaio/valkyrja/Container/Data/ContainerData.ts"
+  };
+  /** The framework type every generated container data file imports. */
+  static FRAMEWORK_TYPE_IMPORTS = {
+    ContainerContract: "@valkyrjaio/valkyrja/Container/Manager/Contract/ContainerContract.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, publishers) {
-    const userImports = Object.entries(this.classImportMap).map(([name, specifier]) => `import { ${name} } from '${specifier}';`).join("\n");
-    const userImportsBlock = userImports ? `${userImports}
-` : "";
+    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
+      ...Object.keys(_AstContainerDataFileGenerator.FRAMEWORK_IMPORTS),
+      ...Object.keys(_AstContainerDataFileGenerator.FRAMEWORK_TYPE_IMPORTS)
+    ]);
     const contents = this.generateClassContents(publishers);
     const data = [
       "// This file was automatically generated by Sindri.",
       "",
-      `import { ContainerData } from '@valkyrjaio/valkyrja/Container/Data/ContainerData.ts';`,
-      `import type { ContainerContract } from '@valkyrjaio/valkyrja/Container/Manager/Contract/ContainerContract.ts';`,
+      ...this.buildFrameworkImportLines(_AstContainerDataFileGenerator.FRAMEWORK_IMPORTS),
+      ...this.buildFrameworkImportLines(_AstContainerDataFileGenerator.FRAMEWORK_TYPE_IMPORTS, true),
       userImportsBlock,
       `export class ${className} extends ContainerData {`,
       `    constructor() {`,
@@ -244463,10 +244775,8 @@ var AstContainerDataFileGenerator = class extends AstFileGenerator {
     }
     const lines = [];
     for (const [serviceId, [providerClass, methodName]] of entries) {
-      const keyExpr = this.buildEnumCaseExpr(serviceId);
-      const printedKey = this.printer.printNode(import_ts_morph9.ts.EmitHint.Unspecified, keyExpr, this.dummySourceFile);
       const shortProviderClass = providerClass.slice(providerClass.lastIndexOf("\\") + 1);
-      const formattedKey = serviceId.includes("::") ? `[${printedKey}]` : `['${printedKey}']`;
+      const formattedKey = serviceId.includes("::") ? `[${this.printer.printNode(import_ts_morph10.ts.EmitHint.Unspecified, this.buildEnumCaseExpr(serviceId), this.dummySourceFile)}]` : `['${serviceId}']`;
       lines.push(
         `            ${formattedKey}: (container: ContainerContract) => ${shortProviderClass}.${methodName}(container),`
       );
@@ -244478,28 +244788,45 @@ var AstContainerDataFileGenerator = class extends AstFileGenerator {
 };
 
 // src/Sindri/Generator/Ast/Event/AstEventDataFileGenerator.ts
-var import_ts_morph10 = __toESM(require_ts_morph(), 1);
-var AstEventDataFileGenerator = class extends AstFileGenerator {
+var import_ts_morph11 = __toESM(require_ts_morph(), 1);
+var AstEventDataFileGenerator = class _AstEventDataFileGenerator extends AstFileGenerator {
+  /** The framework class every generated event data file imports as a value. */
+  static FRAMEWORK_IMPORTS = {
+    EventData: "@valkyrjaio/valkyrja/Event/Data/EventData.ts"
+  };
+  /** The framework classes a generated event data file imports only when it holds listeners. */
+  static LISTENER_IMPORTS = {
+    Listener: "@valkyrjaio/valkyrja/Event/Data/Listener.ts"
+  };
+  /** The framework types a generated event data file imports only when it holds listeners. */
+  static LISTENER_TYPE_IMPORTS = {
+    ListenerContract: "@valkyrjaio/valkyrja/Event/Data/Contract/ListenerContract.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, listeners) {
-    const userImports = Object.entries(this.classImportMap).map(([name, specifier]) => `import { ${name} } from '${specifier}';`).join("\n");
-    const userImportsBlock = userImports ? `${userImports}
-` : "";
+    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 ? [
+      ...this.buildFrameworkImportLines(_AstEventDataFileGenerator.LISTENER_IMPORTS),
+      ...this.buildFrameworkImportLines(_AstEventDataFileGenerator.LISTENER_TYPE_IMPORTS, true)
+    ] : [];
     const data = [
       "// This file was automatically generated by Sindri.",
       "",
-      `import { EventData } from '@valkyrjaio/valkyrja/Event/Data/EventData.ts';`,
-      `import { Listener } from '@valkyrjaio/valkyrja/Event/Data/Listener.ts';`,
-      `import type { ListenerContract } from '@valkyrjaio/valkyrja/Event/Data/Contract/ListenerContract.ts';`,
+      ...this.buildFrameworkImportLines(_AstEventDataFileGenerator.FRAMEWORK_IMPORTS),
+      ...listenerImports,
       userImportsBlock,
       `export class ${className} extends EventData {`,
       `    constructor() {`,
@@ -244517,7 +244844,7 @@ var AstEventDataFileGenerator = class extends AstFileGenerator {
     }
     const lines = [];
     for (const [key, valueExpr] of entries) {
-      const printed = this.printer.printNode(import_ts_morph10.ts.EmitHint.Unspecified, valueExpr, this.dummySourceFile);
+      const printed = this.printer.printNode(import_ts_morph11.ts.EmitHint.Unspecified, valueExpr, this.dummySourceFile);
       lines.push(`            ['${key}']: (): ListenerContract => ${printed},`);
     }
     return ["super(", "            {},", "            {", ...lines, "            },", "        );"].join(
@@ -244527,7 +244854,22 @@ var AstEventDataFileGenerator = class extends AstFileGenerator {
 };
 
 // src/Sindri/Generator/Ast/Http/AstHttpDataFileGenerator.ts
-var import_ts_morph11 = __toESM(require_ts_morph(), 1);
+var import_ts_morph12 = __toESM(require_ts_morph(), 1);
+
+// node_modules/@valkyrjaio/valkyrja/src/Valkyrja/Http/Message/Enum/RequestMethod.ts
+function allRequestMethods() {
+  return [
+    "GET" /* GET */,
+    "HEAD" /* HEAD */,
+    "POST" /* POST */,
+    "PUT" /* PUT */,
+    "DELETE" /* DELETE */,
+    "CONNECT" /* CONNECT */,
+    "OPTIONS" /* OPTIONS */,
+    "TRACE" /* TRACE */,
+    "PATCH" /* PATCH */
+  ];
+}
 
 // node_modules/@valkyrjaio/valkyrja/src/Valkyrja/Http/Throwable/Exception/Abstract/HttpRuntimeException.ts
 var HttpRuntimeException = class extends ValkyrjaRuntimeException {
@@ -244884,8 +245226,8 @@ var Regex = class _Regex {
   static ALPHA_UPPERCASE = "[A-Z]+";
   static ALPHA_NUM = "[a-zA-Z0-9]+";
   static ALPHA_NUM_UNDERSCORE = "\\w+";
-  static START = "/^";
-  static END = "$/";
+  static START = "^";
+  static END = "$";
   static START_CAPTURE_GROUP = "(";
   static START_NON_CAPTURE_GROUP = "(?:";
   static END_CAPTURE_GROUP = ")";
@@ -244977,39 +245319,74 @@ var GeneratorUnreachableException = class extends GeneratorRuntimeException {
 };
 
 // src/Sindri/Generator/Ast/Http/AstHttpDataFileGenerator.ts
-var AstHttpDataFileGenerator = class extends AstFileGenerator {
+var AstHttpDataFileGenerator = class _AstHttpDataFileGenerator extends AstFileGenerator {
+  /** The framework classes every generated HTTP data file imports as values. */
+  static FRAMEWORK_IMPORTS = {
+    HttpRoutingData: "@valkyrjaio/valkyrja/Http/Routing/Data/HttpRoutingData.ts",
+    DynamicRoute: "@valkyrjaio/valkyrja/Http/Routing/Data/DynamicRoute.ts",
+    Route: "@valkyrjaio/valkyrja/Http/Routing/Data/Route.ts",
+    Parameter: "@valkyrjaio/valkyrja/Http/Routing/Data/Parameter.ts",
+    RequestMethod: "@valkyrjaio/valkyrja/Http/Message/Enum/RequestMethod.ts",
+    Regex: "@valkyrjaio/valkyrja/Http/Routing/Constant/Regex.ts"
+  };
+  /** The framework types every generated HTTP data file imports. */
+  static FRAMEWORK_TYPE_IMPORTS = {
+    RouteContract: "@valkyrjaio/valkyrja/Http/Routing/Data/Contract/RouteContract.ts"
+  };
   classImportMap = {};
   processor;
-  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
   );
   constructor(processor = new Processor()) {
     super();
     this.processor = processor;
   }
   generateFile(directory, className, namespace, routes, routeData) {
-    const userImports = Object.entries(this.classImportMap).map(([name, specifier]) => `import { ${name} } from '${specifier}';`).join("\n");
-    const userImportsBlock = userImports ? `${userImports}
-` : "";
+    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
+      ...Object.keys(_AstHttpDataFileGenerator.FRAMEWORK_IMPORTS),
+      ...Object.keys(_AstHttpDataFileGenerator.FRAMEWORK_TYPE_IMPORTS)
+    ]);
     const routesContent = this.getRoutesAsContent(routes, routeData);
     const paths = this.printNestedObject(this.buildPaths(routeData));
     const dynamicPaths = this.printNestedObject(this.buildDynamicPaths(routeData));
     const regexes = this.printNestedObject(this.buildRegexes(routeData));
-    const data = [
+    const data = this.assembleFile(className, userImportsBlock, routesContent, paths, dynamicPaths, regexes);
+    return this.writeFile(directory, className, data);
+  }
+  /**
+   * Generate the routing data file from imperative `getRoutes()` route
+   * objects (as opposed to attribute-scanned routes).
+   *
+   * Each route expression is emitted verbatim as a route closure and the
+   * path/dynamic-path/regex lookup maps are derived from the route objects'
+   * own arguments, mirroring the framework's runtime `RouteCollection`
+   * (literal path and regex, request methods defaulting to `[HEAD, GET]`).
+   */
+  generateFileFromRoutes(directory, className, _namespace, routeExprs) {
+    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap, [
+      ...Object.keys(_AstHttpDataFileGenerator.FRAMEWORK_IMPORTS),
+      ...Object.keys(_AstHttpDataFileGenerator.FRAMEWORK_TYPE_IMPORTS)
+    ]);
+    const metas = routeExprs.map((expr) => this.extractRouteMeta(expr)).filter((meta) => meta !== void 0);
+    const routesContent = this.getImperativeRoutesContent(metas);
+    const paths = this.printNestedObject(this.buildImperativePaths(metas, false));
+    const dynamicPaths = this.printNestedObject(this.buildImperativePaths(metas, true));
+    const regexes = this.printNestedObject(this.buildImperativeRegexes(metas));
+    const data = this.assembleFile(className, userImportsBlock, routesContent, paths, dynamicPaths, regexes);
+    return this.writeFile(directory, className, data);
+  }
+  assembleFile(className, userImportsBlock, routesContent, paths, dynamicPaths, regexes) {
+    return [
       "// This file was automatically generated by Sindri.",
       "",
-      `import { HttpRoutingData } from '@valkyrjaio/valkyrja/Http/Routing/Data/HttpRoutingData.ts';`,
-      `import { DynamicRoute } from '@valkyrjaio/valkyrja/Http/Routing/Data/DynamicRoute.ts';`,
-      `import { Route } from '@valkyrjaio/valkyrja/Http/Routing/Data/Route.ts';`,
-      `import { Parameter } from '@valkyrjaio/valkyrja/Http/Routing/Data/Parameter.ts';`,
-      `import { RequestMethod } from '@valkyrjaio/valkyrja/Http/Message/Enum/RequestMethod.ts';`,
-      `import { Regex } from '@valkyrjaio/valkyrja/Http/Routing/Constant/Regex.ts';`,
-      `import type { RouteContract } from '@valkyrjaio/valkyrja/Http/Routing/Data/Contract/RouteContract.ts';`,
+      ...this.buildFrameworkImportLines(_AstHttpDataFileGenerator.FRAMEWORK_IMPORTS),
+      ...this.buildFrameworkImportLines(_AstHttpDataFileGenerator.FRAMEWORK_TYPE_IMPORTS, true),
       userImportsBlock,
       `export class ${className} extends HttpRoutingData {`,
       `    constructor() {`,
@@ -245023,7 +245400,6 @@ var AstHttpDataFileGenerator = class extends AstFileGenerator {
       `}`,
       ""
     ].join("\n");
-    return this.writeFile(directory, className, data);
   }
   generateClassContents(routes, routeData) {
     const routesContent = this.getRoutesAsContent(routes, routeData);
@@ -245096,24 +245472,24 @@ var AstHttpDataFileGenerator = class extends AstFileGenerator {
       const innerProps = [];
       for (const [innerKey, value] of Object.entries(innerMap)) {
         innerProps.push(
-          import_ts_morph11.ts.factory.createPropertyAssignment(
-            import_ts_morph11.ts.factory.createStringLiteral(innerKey),
-            import_ts_morph11.ts.factory.createStringLiteral(value)
+          import_ts_morph12.ts.factory.createPropertyAssignment(
+            import_ts_morph12.ts.factory.createStringLiteral(innerKey),
+            import_ts_morph12.ts.factory.createStringLiteral(value)
           )
         );
       }
       outerProps.push(
-        import_ts_morph11.ts.factory.createPropertyAssignment(
-          import_ts_morph11.ts.factory.createStringLiteral(outerKey),
-          import_ts_morph11.ts.factory.createObjectLiteralExpression(innerProps, true)
+        import_ts_morph12.ts.factory.createPropertyAssignment(
+          import_ts_morph12.ts.factory.createStringLiteral(outerKey),
+          import_ts_morph12.ts.factory.createObjectLiteralExpression(innerProps, true)
         )
       );
     }
-    return import_ts_morph11.ts.factory.createObjectLiteralExpression(outerProps, true);
+    return import_ts_morph12.ts.factory.createObjectLiteralExpression(outerProps, true);
   }
   printNestedObject(data) {
     return this.printer.printNode(
-      import_ts_morph11.ts.EmitHint.Unspecified,
+      import_ts_morph12.ts.EmitHint.Unspecified,
       this.buildNestedStringArrayExpr(data),
       this.dummySourceFile
     );
@@ -245172,19 +245548,101 @@ var AstHttpDataFileGenerator = class extends AstFileGenerator {
     for (const [key, routeExpr] of entries) {
       const data = routeData[key] ?? null;
       let expr = routeExpr;
-      if (data !== null && data.isDynamic && import_ts_morph11.ts.isNewExpression(expr)) {
+      if (data !== null && data.isDynamic && import_ts_morph12.ts.isNewExpression(expr)) {
         const computedRegex = data.parameters.length > 0 ? this.computeRegex(data) : "";
-        const args = [...expr.arguments ?? [], import_ts_morph11.ts.factory.createStringLiteral(computedRegex)];
-        expr = import_ts_morph11.ts.factory.createNewExpression(expr.expression, expr.typeArguments, args);
+        const args = [...expr.arguments ?? [], import_ts_morph12.ts.factory.createStringLiteral(computedRegex)];
+        expr = import_ts_morph12.ts.factory.createNewExpression(expr.expression, expr.typeArguments, args);
       }
-      const keyExpr = this.buildEnumCaseExpr(key);
-      const printedKey = this.printer.printNode(import_ts_morph11.ts.EmitHint.Unspecified, keyExpr, this.dummySourceFile);
-      const printedRoute = this.printer.printNode(import_ts_morph11.ts.EmitHint.Unspecified, expr, this.dummySourceFile);
-      const formattedKey = key.includes("::") ? `[${printedKey}]` : `['${printedKey}']`;
+      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}']`;
       lines.push(`            ${formattedKey}: (): RouteContract => ${printedRoute},`);
     }
     return ["{", ...lines, "        }"].join("\n        ");
   }
+  // -------------------------------------------------------------------------
+  // Imperative `getRoutes()` support
+  // -------------------------------------------------------------------------
+  /**
+   * Extract routing metadata from a `new Route(...)` / `new DynamicRoute(...)`
+   * expression, matching the framework constructor argument order:
+   *   Route(path, name, handler, requestMethods?)
+   *   DynamicRoute(path, name, regex, parameters, handler, requestMethods?)
+   */
+  extractRouteMeta(expr) {
+    if (!import_ts_morph12.ts.isNewExpression(expr) || !import_ts_morph12.ts.isIdentifier(expr.expression)) {
+      return void 0;
+    }
+    const isDynamic = expr.expression.text === "DynamicRoute";
+    const args = expr.arguments ?? import_ts_morph12.ts.factory.createNodeArray();
+    const path4 = this.stringArg(args[0]);
+    const name = this.stringArg(args[1]);
+    if (name === void 0 || path4 === void 0) {
+      return void 0;
+    }
+    const regex = isDynamic ? this.stringArg(args[2]) ?? "" : "";
+    const methodsArg = isDynamic ? args[5] : args[3];
+    const methods = this.extractMethodNamesFromArg(methodsArg);
+    return { expr, name, path: path4, isDynamic, regex, methods };
+  }
+  stringArg(node) {
+    return node !== void 0 && import_ts_morph12.ts.isStringLiteral(node) ? node.text : void 0;
+  }
+  /**
+   * Resolve a `[RequestMethod.GET, ...]` argument to method-name strings,
+   * defaulting to `[HEAD, GET]` (the framework `Route` default) when omitted
+   * and expanding `RequestMethod.ANY` to every request method.
+   */
+  extractMethodNamesFromArg(node) {
+    if (node === void 0 || !import_ts_morph12.ts.isArrayLiteralExpression(node)) {
+      return ["HEAD" /* HEAD */, "GET" /* GET */];
+    }
+    const methods = [];
+    for (const element of node.elements) {
+      if (!import_ts_morph12.ts.isPropertyAccessExpression(element)) {
+        continue;
+      }
+      const method = element.name.text;
+      if (method === "ANY") {
+        return allRequestMethods();
+      }
+      methods.push(method);
+    }
+    return methods;
+  }
+  getImperativeRoutesContent(metas) {
+    if (metas.length === 0) {
+      return "{}";
+    }
+    const lines = [];
+    for (const meta of metas) {
+      lines.push(`            ['${meta.name}']: (): RouteContract => ${meta.expr.getText()},`);
+    }
+    return ["{", ...lines, "        }"].join("\n        ");
+  }
+  buildImperativePaths(metas, dynamic) {
+    const paths = {};
+    for (const meta of metas) {
+      if (meta.isDynamic !== dynamic) {
+        continue;
+      }
+      for (const method of meta.methods) {
+        (paths[method] ??= {})[meta.path] = meta.name;
+      }
+    }
+    return paths;
+  }
+  buildImperativeRegexes(metas) {
+    const regexes = {};
+    for (const meta of metas) {
+      if (!meta.isDynamic || meta.regex === "") {
+        continue;
+      }
+      for (const method of meta.methods) {
+        (regexes[method] ??= {})[meta.regex] = meta.name;
+      }
+    }
+    return regexes;
+  }
 };
 
 // src/Sindri/Generate/Abstract/GenerateDataFromAst.ts
@@ -245226,8 +245684,8 @@ var WarningFormatter = class extends Formatter {
 
 // node_modules/@valkyrjaio/valkyrja/src/Valkyrja/Application/Constant/ApplicationInfo.ts
 var ApplicationInfo = class {
-  static VERSION = "26.2.0";
-  static VERSION_BUILD_DATE_TIME = "July 24 2026 23:49:19 MST";
+  static VERSION = "26.4.0";
+  static VERSION_BUILD_DATE_TIME = "July 27 2026 22:05:07 MST";
   static ASCII = `
                  _ _               _
      /\\   /\\__ _| | | ___   _ _ __(_) __ _
@@ -245336,8 +245794,8 @@ var Header = class extends Message {
 
 // src/Sindri/Constant/SindriInfo.ts
 var SindriInfo = class {
-  static VERSION = "26.2.0";
-  static VERSION_BUILD_DATE_TIME = "July 25 2026 00:19:15 MST";
+  static VERSION = "26.4.0";
+  static VERSION_BUILD_DATE_TIME = "July 27 2026 22:16:03 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
@@ -245483,17 +245941,142 @@ var GenerateDataFromAst = class {
     }
     return "";
   }
+  /**
+   * Build the `import { X } from '...'` specifier for a class file, relative
+   * to the generated data file's output directory. Used to import the
+   * provider/handler classes referenced by the generated data caches.
+   */
+  relativeSpecifier(fromDir, toFile) {
+    const relative2 = path3.relative(fromDir, toFile).split(path3.sep).join("/");
+    return relative2.startsWith(".") ? relative2 : `./${relative2}`;
+  }
+  /**
+   * Build the specifier a generated data file should import a class file by.
+   *
+   * Application source is imported by a path relative to the data directory;
+   * a file belonging to an installed package is imported by that package's
+   * own public specifier — so the framework classes the cache references are
+   * written exactly as hand-written application code writes them
+   * (`@valkyrjaio/valkyrja/Cli/Routing/Data/Route.ts`), never as a brittle
+   * reach into `node_modules`.
+   */
+  importSpecifier(fromDir, toFile) {
+    return this.packageSpecifier(toFile) ?? this.relativeSpecifier(fromDir, toFile);
+  }
+  /**
+   * Map an absolute path inside an installed package back to the specifier
+   * that package publicly exposes it as, or undefined when the file is not
+   * part of one.
+   *
+   * The package's `exports` map is inverted: for `"./*.ts": "./src/*.ts"` a
+   * file at `<package>/src/Foo.ts` maps back to `<name>/Foo.ts`. Packages
+   * with no matching pattern fall back to the path as written under the
+   * package root, which is what a package without an `exports` map exposes.
+   */
+  packageSpecifier(filePath) {
+    const normalized = filePath.split(path3.sep).join("/");
+    const marker = normalized.lastIndexOf("/node_modules/");
+    if (marker === -1) {
+      return void 0;
+    }
+    const subject = normalized.substring(marker + "/node_modules/".length);
+    const segments = subject.split("/");
+    const nameLength = subject.startsWith("@") ? 2 : 1;
+    if (segments.length <= nameLength) {
+      return void 0;
+    }
+    const packageName = segments.slice(0, nameLength).join("/");
+    const packageDir = normalized.substring(0, marker + "/node_modules/".length) + packageName;
+    const relative2 = segments.slice(nameLength).join("/");
+    return `${packageName}/${this.exportedSubpath(packageDir, relative2) ?? relative2}`;
+  }
+  /**
+   * Invert a package's `exports` patterns to find the subpath a file inside
+   * it is exposed as, or undefined when no pattern matches it.
+   */
+  exportedSubpath(packageDir, relative2) {
+    for (const [key, target] of Object.entries(this.readPackageExports(packageDir))) {
+      const star = key.indexOf("*");
+      const targetStar = target.indexOf("*");
+      if (star === -1 || targetStar === -1) {
+        continue;
+      }
+      const prefix = target.substring(0, targetStar).replace(/^\.\//, "");
+      const suffix = target.substring(targetStar + 1);
+      if (!relative2.startsWith(prefix) || !relative2.endsWith(suffix)) {
+        continue;
+      }
+      const value = relative2.substring(prefix.length, relative2.length - suffix.length);
+      return (key.substring(0, star) + value + key.substring(star + 1)).replace(/^\.\//, "");
+    }
+    return void 0;
+  }
+  /**
+   * Read a package's `exports` map, flattened to subpath → file target.
+   *
+   * Conditional targets are collapsed to their first string value; every
+   * condition a package declares for a subpath points at the same source
+   * file in the layouts sindri generates for.
+   */
+  readPackageExports(packageDir) {
+    const manifestPath = path3.join(packageDir, "package.json");
+    if (!fs3.existsSync(manifestPath)) {
+      return {};
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
+    } catch {
+      return {};
+    }
+    const exports2 = manifest.exports;
+    if (typeof exports2 !== "object" || exports2 === null) {
+      return {};
+    }
+    const flattened = {};
+    for (const [subpath, target] of Object.entries(exports2)) {
+      const resolved = this.firstStringTarget(target);
+      if (resolved !== void 0) {
+        flattened[subpath] = resolved;
+      }
+    }
+    return flattened;
+  }
+  /**
+   * Reduce an `exports` target — a string, or a nested map of conditions — to
+   * the first file path it names.
+   */
+  firstStringTarget(target) {
+    if (typeof target === "string") {
+      return target;
+    }
+    if (typeof target !== "object" || target === null) {
+      return void 0;
+    }
+    for (const value of Object.values(target)) {
+      const resolved = this.firstStringTarget(value);
+      if (resolved !== void 0) {
+        return resolved;
+      }
+    }
+    return void 0;
+  }
   generateContainerData(serviceProviders, config, output) {
     output = output.withAddedMessages(new Message("Generating Container Data......................")).writeMessages();
     const publishers = {};
+    const importMap = {};
     for (const providerClass of serviceProviders) {
       const filePath = this.fqnToFilePath(providerClass, config.namespace, config.dir);
       if (filePath === "" || !fs3.existsSync(filePath)) {
         continue;
       }
       const result = this.serviceProviderReader.readFile(filePath);
+      if (Object.keys(result.publishers).length > 0) {
+        importMap[path3.basename(filePath, ".ts")] = this.importSpecifier(config.dataPath, filePath);
+      }
       Object.assign(publishers, result.publishers);
     }
+    this.containerGenerator.classImportMap = importMap;
     const status = this.containerGenerator.generateFile(
       config.dataPath,
       "AppContainerData",
@@ -245531,12 +246114,21 @@ var GenerateDataFromAst = class {
   generateCliData(cliRouteProviders, config, output) {
     output = output.withAddedMessages(new Message("Generating Cli Routes Data.....................")).writeMessages();
     const allRoutes = {};
+    const imperativeRoutes = [];
+    const importMap = {};
     for (const providerClass of cliRouteProviders) {
       const filePath = this.fqnToFilePath(providerClass, config.namespace, config.dir);
       if (filePath === "" || !fs3.existsSync(filePath)) {
         continue;
       }
       const providerResult = this.routeProviderReader.readFile(filePath);
+      if (providerResult.routes.length > 0) {
+        imperativeRoutes.push(...providerResult.routes);
+        importMap[path3.basename(filePath, ".ts")] = this.importSpecifier(config.dataPath, filePath);
+        for (const [name, importPath] of Object.entries(providerResult.routeImports)) {
+          importMap[name] = this.importSpecifier(config.dataPath, importPath);
+        }
+      }
       for (const controllerClass of providerResult.controllerClasses) {
         const controllerPath = this.fqnToFilePath(controllerClass, config.namespace, config.dir);
         if (controllerPath === "" || !fs3.existsSync(controllerPath)) {
@@ -245546,24 +246138,34 @@ var GenerateDataFromAst = class {
         Object.assign(allRoutes, attrResult.routes);
       }
     }
-    const status = this.cliGenerator.generateFile(
+    this.cliGenerator.classImportMap = importMap;
+    const status = imperativeRoutes.length > 0 ? this.cliGenerator.generateFileFromRoutes(
       config.dataPath,
       "AppCliRoutingData",
       config.dataNamespace,
-      allRoutes
-    );
+      imperativeRoutes
+    ) : this.cliGenerator.generateFile(config.dataPath, "AppCliRoutingData", config.dataNamespace, allRoutes);
     return this.addMessagesForGenerateStatus(output, status).withAddedMessages(new NewLine()).writeMessages();
   }
   generateHttpData(httpRouteProviders, config, output) {
     output = output.withAddedMessages(new Message("Generating Http Routes Data....................")).writeMessages();
     const allRoutes = {};
     const allRouteData = {};
+    const imperativeRoutes = [];
+    const importMap = {};
     for (const providerClass of httpRouteProviders) {
       const filePath = this.fqnToFilePath(providerClass, config.namespace, config.dir);
       if (filePath === "" || !fs3.existsSync(filePath)) {
         continue;
       }
       const providerResult = this.routeProviderReader.readFile(filePath);
+      if (providerResult.routes.length > 0) {
+        imperativeRoutes.push(...providerResult.routes);
+        importMap[path3.basename(filePath, ".ts")] = this.importSpecifier(config.dataPath, filePath);
+        for (const [name, importPath] of Object.entries(providerResult.routeImports)) {
+          importMap[name] = this.importSpecifier(config.dataPath, importPath);
+        }
+      }
       for (const controllerClass of providerResult.controllerClasses) {
         const controllerPath = this.fqnToFilePath(controllerClass, config.namespace, config.dir);
         if (controllerPath === "" || !fs3.existsSync(controllerPath)) {
@@ -245574,7 +246176,13 @@ var GenerateDataFromAst = class {
         Object.assign(allRouteData, attrResult.routeData);
       }
     }
-    const status = this.httpGenerator.generateFile(
+    this.httpGenerator.classImportMap = importMap;
+    const status = imperativeRoutes.length > 0 ? this.httpGenerator.generateFileFromRoutes(
+      config.dataPath,
+      "AppHttpRoutingData",
+      config.dataNamespace,
+      imperativeRoutes
+    ) : this.httpGenerator.generateFile(
       config.dataPath,
       "AppHttpRoutingData",
       config.dataNamespace,