@valkyrjaio/sindri 26.3.0 → 26.4.0

package/dist/bin/sindri.cjs

@@ -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";
@@ -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,
@@ -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(), ...].
@@ -242705,6 +242745,35 @@ var AstReader = class {
     }
     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.
    *
@@ -242806,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;
@@ -242817,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).
@@ -244271,16 +244382,24 @@ 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 }
     );
   }
 };
@@ -244297,11 +244416,33 @@ 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)
     );
   }
+  /**
+   * 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.
    *
@@ -244443,12 +244584,23 @@ var AstFileGenerator = class {
    * 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) {
-    const userImports = Object.entries(classImportMap).map(([name, specifier]) => `import { ${name} } from '${specifier}';`).join("\n");
+  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`;
     try {
@@ -244466,7 +244618,22 @@ 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_morph9.ts.createPrinter({ newLine: import_ts_morph9.ts.NewLineKind.LineFeed });
   dummySourceFile = import_ts_morph9.ts.createSourceFile(
@@ -244477,20 +244644,16 @@ var AstCliDataFileGenerator = class extends AstFileGenerator {
     import_ts_morph9.ts.ScriptKind.TS
   );
   generateFile(directory, className, namespace, routes) {
-    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap);
+    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() {`,
@@ -244512,14 +244675,35 @@ var AstCliDataFileGenerator = class extends AstFileGenerator {
       if (!import_ts_morph9.ts.isNewExpression(expr)) {
         continue;
       }
-      const nameArg = (expr.arguments ?? [])[0];
-      if (nameArg === void 0 || !import_ts_morph9.ts.isStringLiteral(nameArg)) {
+      const key = this.routeKey((expr.arguments ?? [])[0]);
+      if (key === void 0) {
         continue;
       }
-      routes[nameArg.text] = expr;
+      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) {
@@ -244545,7 +244729,15 @@ var AstCliDataFileGenerator = class extends AstFileGenerator {
 
 // src/Sindri/Generator/Ast/Container/AstContainerDataFileGenerator.ts
 var import_ts_morph10 = __toESM(require_ts_morph(), 1);
-var AstContainerDataFileGenerator = class extends AstFileGenerator {
+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_morph10.ts.createPrinter({ newLine: import_ts_morph10.ts.NewLineKind.LineFeed });
   dummySourceFile = import_ts_morph10.ts.createSourceFile(
@@ -244556,13 +244748,16 @@ var AstContainerDataFileGenerator = class extends AstFileGenerator {
     import_ts_morph10.ts.ScriptKind.TS
   );
   generateFile(directory, className, namespace, publishers) {
-    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap);
+    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() {`,
@@ -244594,7 +244789,19 @@ var AstContainerDataFileGenerator = class extends AstFileGenerator {
 
 // src/Sindri/Generator/Ast/Event/AstEventDataFileGenerator.ts
 var import_ts_morph11 = __toESM(require_ts_morph(), 1);
-var AstEventDataFileGenerator = class extends AstFileGenerator {
+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_morph11.ts.createPrinter({ newLine: import_ts_morph11.ts.NewLineKind.LineFeed });
   dummySourceFile = import_ts_morph11.ts.createSourceFile(
@@ -244605,16 +244812,20 @@ var AstEventDataFileGenerator = class extends AstFileGenerator {
     import_ts_morph11.ts.ScriptKind.TS
   );
   generateFile(directory, className, namespace, listeners) {
-    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap);
+    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 ? [
-      `import { Listener } from '@valkyrjaio/valkyrja/Event/Data/Listener.ts';`,
-      `import type { ListenerContract } from '@valkyrjaio/valkyrja/Event/Data/Contract/ListenerContract.ts';`
+      ...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';`,
+      ...this.buildFrameworkImportLines(_AstEventDataFileGenerator.FRAMEWORK_IMPORTS),
       ...listenerImports,
       userImportsBlock,
       `export class ${className} extends EventData {`,
@@ -245015,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 = ")";
@@ -245108,7 +245319,20 @@ 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_morph12.ts.createPrinter({ newLine: import_ts_morph12.ts.NewLineKind.LineFeed });
@@ -245124,7 +245348,10 @@ var AstHttpDataFileGenerator = class extends AstFileGenerator {
     this.processor = processor;
   }
   generateFile(directory, className, namespace, routes, routeData) {
-    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap);
+    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));
@@ -245142,7 +245369,10 @@ var AstHttpDataFileGenerator = class extends AstFileGenerator {
    * (literal path and regex, request methods defaulting to `[HEAD, GET]`).
    */
   generateFileFromRoutes(directory, className, _namespace, routeExprs) {
-    const userImportsBlock = this.buildUserImportsBlock(this.classImportMap);
+    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));
@@ -245155,13 +245385,8 @@ var AstHttpDataFileGenerator = class extends AstFileGenerator {
     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() {`,
@@ -245459,8 +245684,8 @@ var WarningFormatter = class extends Formatter {
 
 // node_modules/@valkyrjaio/valkyrja/src/Valkyrja/Application/Constant/ApplicationInfo.ts
 var ApplicationInfo = class {
-  static VERSION = "26.3.0";
-  static VERSION_BUILD_DATE_TIME = "July 25 2026 20:40:59 MST";
+  static VERSION = "26.4.0";
+  static VERSION_BUILD_DATE_TIME = "July 27 2026 22:05:07 MST";
   static ASCII = `
                  _ _               _
      /\\   /\\__ _| | | ___   _ _ __(_) __ _
@@ -245569,8 +245794,8 @@ var Header = class extends Message {
 
 // src/Sindri/Constant/SindriInfo.ts
 var SindriInfo = class {
-  static VERSION = "26.3.0";
-  static VERSION_BUILD_DATE_TIME = "July 25 2026 21:11:03 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
@@ -245725,6 +245950,117 @@ var GenerateDataFromAst = class {
     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 = {};
@@ -245736,7 +246072,7 @@ var GenerateDataFromAst = class {
       }
       const result = this.serviceProviderReader.readFile(filePath);
       if (Object.keys(result.publishers).length > 0) {
-        importMap[path3.basename(filePath, ".ts")] = this.relativeSpecifier(config.dataPath, filePath);
+        importMap[path3.basename(filePath, ".ts")] = this.importSpecifier(config.dataPath, filePath);
       }
       Object.assign(publishers, result.publishers);
     }
@@ -245788,7 +246124,10 @@ var GenerateDataFromAst = class {
       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);
+        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);
@@ -245822,7 +246161,10 @@ var GenerateDataFromAst = class {
       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);
+        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);