@valkyrjaio/sindri 26.2.0 → 26.3.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;
@@ -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;
           }
@@ -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;
@@ -242650,6 +242650,61 @@ 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;
+  }
   /**
    * Extract service ID strings from keys of an object-returning method.
    *
@@ -243427,11 +243482,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 +243631,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,6 +244266,9 @@ 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 = []) {
@@ -244234,13 +244302,31 @@ var RouteProviderReader = class _RouteProviderReader extends AstReader {
       this.extractRoutes(methods[_RouteProviderReader.METHOD_ROUTES], useMap, filePath)
     );
   }
-  extractRoutes(_method, _useMap, _filePath) {
-    return [];
+  /**
+   * 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 +244379,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 +244400,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 +244409,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 +244420,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 +244432,22 @@ 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).
+   */
+  buildUserImportsBlock(classImportMap) {
+    const userImports = Object.entries(classImportMap).map(([name, specifier]) => `import { ${name} } from '${specifier}';`).join("\n");
+    return userImports ? `${userImports}
+` : "";
   }
   writeFile(directory, className, data) {
     const filePath = directory.replace(/\/$/, "") + `/${className}.ts`;
@@ -244372,18 +244468,16 @@ var AstFileGenerator = class {
 // src/Sindri/Generator/Ast/Cli/AstCliDataFileGenerator.ts
 var AstCliDataFileGenerator = class extends AstFileGenerator {
   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);
     const contents = this.generateClassContents(routes);
     const data = [
       "// This file was automatically generated by Sindri.",
@@ -244407,6 +244501,25 @@ 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 nameArg = (expr.arguments ?? [])[0];
+      if (nameArg === void 0 || !import_ts_morph9.ts.isStringLiteral(nameArg)) {
+        continue;
+      }
+      routes[nameArg.text] = expr;
+    }
+    return this.generateFile(directory, className, namespace, routes);
+  }
   generateClassContents(routes) {
     const entries = Object.entries(routes);
     if (entries.length === 0) {
@@ -244414,32 +244527,36 @@ 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 import_ts_morph10 = __toESM(require_ts_morph(), 1);
 var AstContainerDataFileGenerator = class extends AstFileGenerator {
   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);
     const contents = this.generateClassContents(publishers);
     const data = [
       "// This file was automatically generated by Sindri.",
@@ -244463,10 +244580,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 +244593,29 @@ var AstContainerDataFileGenerator = class extends AstFileGenerator {
 };
 
 // src/Sindri/Generator/Ast/Event/AstEventDataFileGenerator.ts
-var import_ts_morph10 = __toESM(require_ts_morph(), 1);
+var import_ts_morph11 = __toESM(require_ts_morph(), 1);
 var AstEventDataFileGenerator = class extends AstFileGenerator {
   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);
     const contents = this.generateClassContents(listeners);
+    const listenerImports = Object.keys(listeners).length > 0 ? [
+      `import { Listener } from '@valkyrjaio/valkyrja/Event/Data/Listener.ts';`,
+      `import type { ListenerContract } from '@valkyrjaio/valkyrja/Event/Data/Contract/ListenerContract.ts';`
+    ] : [];
     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';`,
+      ...listenerImports,
       userImportsBlock,
       `export class ${className} extends EventData {`,
       `    constructor() {`,
@@ -244517,7 +244633,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 +244643,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 {
@@ -244980,27 +245111,48 @@ var GeneratorUnreachableException = class extends GeneratorRuntimeException {
 var AstHttpDataFileGenerator = class extends AstFileGenerator {
   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);
     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);
+    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';`,
@@ -245023,7 +245175,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 +245247,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 +245323,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 +245459,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.3.0";
+  static VERSION_BUILD_DATE_TIME = "July 25 2026 20:40:59 MST";
   static ASCII = `
                  _ _               _
      /\\   /\\__ _| | | ___   _ _ __(_) __ _
@@ -245336,8 +245569,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.3.0";
+  static VERSION_BUILD_DATE_TIME = "July 25 2026 21:11: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 +245716,31 @@ 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}`;
+  }
   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.relativeSpecifier(config.dataPath, filePath);
+      }
       Object.assign(publishers, result.publishers);
     }
+    this.containerGenerator.classImportMap = importMap;
     const status = this.containerGenerator.generateFile(
       config.dataPath,
       "AppContainerData",
@@ -245531,12 +245778,18 @@ 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.relativeSpecifier(config.dataPath, filePath);
+      }
       for (const controllerClass of providerResult.controllerClasses) {
         const controllerPath = this.fqnToFilePath(controllerClass, config.namespace, config.dir);
         if (controllerPath === "" || !fs3.existsSync(controllerPath)) {
@@ -245546,24 +245799,31 @@ 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.relativeSpecifier(config.dataPath, filePath);
+      }
       for (const controllerClass of providerResult.controllerClasses) {
         const controllerPath = this.fqnToFilePath(controllerClass, config.namespace, config.dir);
         if (controllerPath === "" || !fs3.existsSync(controllerPath)) {
@@ -245574,7 +245834,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,