@valkyrjaio/sindri 26.5.0 → 26.6.0

package/src/Sindri/Ast/HttpRouteAttributeReader.ts

@@ -15,18 +15,22 @@ import { HttpRouteAttributeResult } from './Data/Result/HttpRouteAttributeResult
 import { HttpRouteMiddlewareReader } from './HttpRouteMiddlewareReader.ts';
 import { HttpRouteParameterReader } from './HttpRouteParameterReader.ts';
 
-import type { ClassDeclaration, Decorator, MethodDeclaration, Node } from 'ts-morph';
+import type { ClassDeclaration, Decorator, MethodDeclaration } from 'ts-morph';
 
 import type { HttpRouteAttributeReaderContract } from './Contract/HttpRouteAttributeReaderContract.ts';
 import type { HttpRouteMiddlewareReaderContract } from './Contract/HttpRouteMiddlewareReaderContract.ts';
 import type { HttpRouteParameterReaderContract } from './Contract/HttpRouteParameterReaderContract.ts';
+import type { HandlerData } from './Data/HandlerData.ts';
 
 /**
  * Scans an HTTP controller class file for @Route / @DynamicRoute and related
  * sub-decorators and returns TypeScript compiler API Expr nodes ready for the data cache generator.
  *
- * Mirrors the logic of the framework's runtime AttributeRouteCollector but operates
- * entirely on AST without executing any TypeScript code.
+ * The shipped decorators accept a single options object
+ * (`@Route({ path, name, ... })`), so this reader parses object-literal
+ * properties rather than positional arguments. It mirrors the logic of the
+ * framework's runtime AttributeRouteCollector but operates entirely on AST
+ * without executing any TypeScript code.
  */
 export class HttpRouteAttributeReader extends RouteAttributeReader implements HttpRouteAttributeReaderContract {
     constructor(
@@ -112,7 +116,7 @@ export class HttpRouteAttributeReader extends RouteAttributeReader implements Ht
 
         for (const method of classDecl.getMethods()) {
             for (const decorator of this.findDecoratorsOnNode(method, 'Route', useMap, currentFilePath)) {
-                const data = this.buildRouteData(
+                this.collectRoute(
                     decorator,
                     method,
                     useMap,
@@ -121,16 +125,13 @@ export class HttpRouteAttributeReader extends RouteAttributeReader implements Ht
                     classPathPrefix,
                     classNamePrefix,
                     false,
+                    routes,
+                    routeData,
                 );
-
-                if (data !== null) {
-                    routes[data.name] = this.buildRouteExpr(data);
-                    routeData[data.name] = data;
-                }
             }
 
             for (const decorator of this.findDecoratorsOnNode(method, 'DynamicRoute', useMap, currentFilePath)) {
-                const data = this.buildRouteData(
+                this.collectRoute(
                     decorator,
                     method,
                     useMap,
@@ -139,16 +140,44 @@ export class HttpRouteAttributeReader extends RouteAttributeReader implements Ht
                     classPathPrefix,
                     classNamePrefix,
                     true,
+                    routes,
+                    routeData,
                 );
-
-                if (data !== null) {
-                    routes[data.name] = this.buildRouteExpr(data);
-                    routeData[data.name] = data;
-                }
             }
         }
 
-        return new HttpRouteAttributeResult(routes, routeData);
+        const importMap = this.buildImportMap(routeData, useMap, currentFilePath, currentClass);
+
+        return new HttpRouteAttributeResult(routes, routeData, importMap);
+    }
+
+    protected collectRoute(
+        decorator: Decorator,
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+        classPathPrefix: string,
+        classNamePrefix: string,
+        isDynamic: boolean,
+        routes: Record<string, ts.Expression>,
+        routeData: Record<string, HttpRouteData>,
+    ): void {
+        const data = this.buildRouteData(
+            decorator,
+            method,
+            useMap,
+            currentFilePath,
+            currentClass,
+            classPathPrefix,
+            classNamePrefix,
+            isDynamic,
+        );
+
+        if (data !== null) {
+            routes[data.name] = this.buildRouteExpr(data);
+            routeData[data.name] = data;
+        }
     }
 
     protected buildRouteData(
@@ -161,8 +190,14 @@ export class HttpRouteAttributeReader extends RouteAttributeReader implements Ht
         classNamePrefix: string,
         isDynamic: boolean,
     ): HttpRouteData | null {
-        const path = this.extractStringArg(decorator, 0, useMap, currentFilePath, currentClass);
-        const name = this.extractStringArg(decorator, 1, useMap, currentFilePath, currentClass);
+        const obj = this.getDecoratorObjectArg(decorator);
+
+        if (obj === undefined) {
+            return null;
+        }
+
+        const path = this.getObjectStringProp(obj, 'path', useMap, currentFilePath, currentClass);
+        const name = this.getObjectStringProp(obj, 'name', useMap, currentFilePath, currentClass);
 
         if (path === '' || name === '') {
             return null;
@@ -173,10 +208,8 @@ export class HttpRouteAttributeReader extends RouteAttributeReader implements Ht
 
         const resolvedIsDynamic = isDynamic || updatedPath.includes('{');
 
-        const decoratorArgs = decorator.getArguments().map((a: Node) => a.compilerNode as ts.Expression);
-
         const requestMethods = this.middlewareReader.updateRequestMethods(
-            this.middlewareReader.extractInlineRequestMethods(decoratorArgs, useMap, currentFilePath, currentClass),
+            this.middlewareReader.extractObjectRequestMethods(obj, useMap, currentFilePath, currentClass),
             method,
             useMap,
             currentFilePath,
@@ -194,32 +227,84 @@ export class HttpRouteAttributeReader extends RouteAttributeReader implements Ht
             useMap,
             currentFilePath,
             currentClass,
-            this.extractClassListArgFromDecorator(decorator, 5, useMap, currentFilePath, currentClass),
-            this.extractClassListArgFromDecorator(decorator, 6, useMap, currentFilePath, currentClass),
-            this.extractClassListArgFromDecorator(decorator, 7, useMap, currentFilePath, currentClass),
-            this.extractClassListArgFromDecorator(decorator, 8, useMap, currentFilePath, currentClass),
-            this.extractClassListArgFromDecorator(decorator, 9, useMap, currentFilePath, currentClass),
+            this.getObjectClassListProp(obj, 'middleware', useMap, currentFilePath, currentClass),
         );
 
         return new HttpRouteData(
             updatedPath,
             updatedName,
-            this.updateHandler(method, useMap, currentFilePath, currentClass),
+            this.resolveHandler(obj, method, useMap, currentFilePath, currentClass),
             requestMethods,
             routeMatchedMiddleware,
             routeDispatchedMiddleware,
             throwableCaughtMiddleware,
             sendingResponseMiddleware,
             responseSentMiddleware,
-            this.middlewareReader.updateRequestStruct(method, useMap, currentFilePath, currentClass),
-            this.middlewareReader.updateResponseStruct(method, useMap, currentFilePath, currentClass),
+            this.resolveRequestStruct(obj, method, useMap, currentFilePath, currentClass),
+            this.resolveResponseStruct(obj, method, useMap, currentFilePath, currentClass),
             resolvedIsDynamic,
-            resolvedIsDynamic
-                ? this.updateParameters(decoratorArgs, method, useMap, currentFilePath, currentClass)
-                : [],
+            resolvedIsDynamic ? this.parameterReader.updateParameters(obj, useMap, currentFilePath, currentClass) : [],
         );
     }
 
+    protected resolveHandler(
+        obj: ts.ObjectLiteralExpression,
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): HandlerData {
+        const fromObj = this.getObjectHandlerProp(obj, 'handler', useMap, currentFilePath, currentClass);
+
+        if (fromObj !== undefined) {
+            return fromObj;
+        }
+
+        return this.updateHandler(method, useMap, currentFilePath, currentClass);
+    }
+
+    protected resolveRequestStruct(
+        obj: ts.ObjectLiteralExpression,
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): string | null {
+        const value = this.extractExprValue(
+            this.getObjectProp(obj, 'requestStruct'),
+            useMap,
+            currentFilePath,
+            currentClass,
+        );
+
+        if (typeof value === 'string' && value !== '') {
+            return value;
+        }
+
+        return this.middlewareReader.updateRequestStruct(method, useMap, currentFilePath, currentClass);
+    }
+
+    protected resolveResponseStruct(
+        obj: ts.ObjectLiteralExpression,
+        method: MethodDeclaration,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): string | null {
+        const value = this.extractExprValue(
+            this.getObjectProp(obj, 'responseStruct'),
+            useMap,
+            currentFilePath,
+            currentClass,
+        );
+
+        if (typeof value === 'string' && value !== '') {
+            return value;
+        }
+
+        return this.middlewareReader.updateResponseStruct(method, useMap, currentFilePath, currentClass);
+    }
+
     protected updatePath(
         path: string,
         classPathPrefix: string,
@@ -276,23 +361,27 @@ export class HttpRouteAttributeReader extends RouteAttributeReader implements Ht
         return name;
     }
 
+    /**
+     * Emit `new DynamicRoute(path, name, regex, parameters, handler,
+     * requestMethods, ...5 middleware, requestStruct, responseStruct)` or
+     * `new Route(path, name, handler, requestMethods, ...5 middleware,
+     * requestStruct, responseStruct)`, matching the framework constructor order.
+     *
+     * For dynamic routes the regex slot is emitted as an empty-string
+     * placeholder; the generator computes and injects the real regex (it owns
+     * the routing `Processor`), and the parameters array is always emitted (`[]`
+     * when empty).
+     */
     protected buildRouteExpr(data: HttpRouteData): ts.Expression {
         const args: ts.Expression[] = [this.buildEnumCaseExpr(data.path), this.buildEnumCaseExpr(data.name)];
 
-        if (data.isDynamic && data.parameters.length > 0) {
+        if (data.isDynamic) {
+            args.push(this.buildStringExpr(''));
             args.push(this.parameterReader.buildParameterListExpr([...data.parameters]));
         }
 
-        if (data.handler !== null) {
-            args.push(this.buildHandlerExpr(data.handler));
-        } else {
-            args.push(this.buildNullExpr());
-        }
-
-        if (data.requestMethods.length > 0) {
-            args.push(this.buildEnumCaseArrayExpr(data.requestMethods));
-        }
-
+        args.push(data.handler !== null ? this.buildHandlerExpr(data.handler) : this.buildNullExpr());
+        args.push(this.buildEnumCaseArrayExpr(data.requestMethods));
         args.push(...this.middlewareReader.buildRouteMiddlewareArgs(data));
         args.push(...this.middlewareReader.buildRouteStructArgs(data));
 
@@ -303,13 +392,54 @@ export class HttpRouteAttributeReader extends RouteAttributeReader implements Ht
         return this.buildNewExpr(targetClass, args);
     }
 
-    protected updateParameters(
-        decoratorArgs: ts.Expression[],
-        method: MethodDeclaration,
+    /**
+     * Build the class-name → absolute-file-path map for every handler and
+     * middleware class the generated data cache references, so the generator can
+     * emit the matching import statements.
+     */
+    protected buildImportMap(
+        routeData: Record<string, HttpRouteData>,
         useMap: Record<string, string>,
         currentFilePath: string,
         currentClass: string,
-    ): import('./Data/HttpParameterData.ts').HttpParameterData[] {
-        return this.parameterReader.updateParameters(decoratorArgs, method, useMap, currentFilePath, currentClass);
+    ): Record<string, string> {
+        const importMap: Record<string, string> = {};
+
+        for (const data of Object.values(routeData)) {
+            if (data.handler !== null) {
+                this.addClassImport(importMap, data.handler.class, useMap, currentFilePath, currentClass);
+            }
+
+            for (const middleware of [
+                ...data.routeMatchedMiddleware,
+                ...data.routeDispatchedMiddleware,
+                ...data.throwableCaughtMiddleware,
+                ...data.sendingResponseMiddleware,
+                ...data.responseSentMiddleware,
+            ]) {
+                this.addClassImport(importMap, middleware, useMap, currentFilePath, currentClass);
+            }
+        }
+
+        return importMap;
+    }
+
+    protected addClassImport(
+        importMap: Record<string, string>,
+        className: string,
+        useMap: Record<string, string>,
+        currentFilePath: string,
+        currentClass: string,
+    ): void {
+        const shortName = className.slice(className.lastIndexOf('\\') + 1);
+
+        const filePath =
+            shortName === currentClass
+                ? currentFilePath
+                : this.resolveImportToFilePath(shortName, useMap, currentFilePath);
+
+        if (filePath !== '') {
+            importMap[shortName] = filePath;
+        }
     }
 }

package/src/Sindri/Ast/HttpRouteMiddlewareReader.ts

@@ -24,19 +24,13 @@ import type { HttpRouteMiddlewareReaderContract } from './Contract/HttpRouteMidd
  * complexity threshold; injected as a constructor argument.
  */
 export class HttpRouteMiddlewareReader extends AstReader implements HttpRouteMiddlewareReaderContract {
-    extractInlineRequestMethods(
-        decoratorArgs: ts.NodeArray<ts.Expression> | ts.Expression[],
+    extractObjectRequestMethods(
+        obj: ts.ObjectLiteralExpression,
         useMap: Record<string, string>,
         namespace: string,
         currentClass: string,
     ): string[] {
-        const requestMethodsArg = decoratorArgs[3];
-
-        if (requestMethodsArg === undefined || !ts.isArrayLiteralExpression(requestMethodsArg)) {
-            return [];
-        }
-
-        return this.extractClassListFromArrayExpr(requestMethodsArg, useMap, namespace, currentClass);
+        return this.getObjectClassListProp(obj, 'requestMethods', useMap, namespace, currentClass);
     }
 
     updateRequestMethods(
@@ -71,14 +65,41 @@ export class HttpRouteMiddlewareReader extends AstReader implements HttpRouteMid
         useMap: Record<string, string>,
         namespace: string,
         currentClass: string,
-        routeMatchedMiddleware: string[],
-        routeDispatchedMiddleware: string[],
-        throwableCaughtMiddleware: string[],
-        sendingResponseMiddleware: string[],
-        responseSentMiddleware: string[],
+        middleware: string[],
     ): [string[], string[], string[], string[], string[]] {
+        let routeMatchedMiddleware: string[] = [];
+        let routeDispatchedMiddleware: string[] = [];
+        let throwableCaughtMiddleware: string[] = [];
+        let sendingResponseMiddleware: string[] = [];
+        let responseSentMiddleware: string[] = [];
+
+        for (const mwName of middleware) {
+            [
+                routeMatchedMiddleware,
+                routeDispatchedMiddleware,
+                throwableCaughtMiddleware,
+                sendingResponseMiddleware,
+                responseSentMiddleware,
+            ] = this.classifyMiddleware(
+                mwName,
+                useMap,
+                namespace,
+                routeMatchedMiddleware,
+                routeDispatchedMiddleware,
+                throwableCaughtMiddleware,
+                sendingResponseMiddleware,
+                responseSentMiddleware,
+            );
+        }
+
         for (const decorator of this.findDecoratorsOnNode(method, 'Middleware', useMap, namespace)) {
-            const mwName = this.extractExprValue(this.getDecoratorArg(decorator, 0), useMap, namespace, currentClass);
+            // `@Middleware` takes a thunked class reference (`() => AuthMiddleware`).
+            const mwName = this.extractExprValue(
+                this.unwrapClassThunk(this.getDecoratorArg(decorator, 0)),
+                useMap,
+                namespace,
+                currentClass,
+            );
 
             if (typeof mwName !== 'string' || mwName === '') {
                 continue;

package/src/Sindri/Ast/HttpRouteParameterReader.ts

@@ -12,75 +12,41 @@ import { ts } from 'ts-morph';
 import { AstReader } from './Abstract/AstReader.ts';
 import { HttpParameterData } from './Data/HttpParameterData.ts';
 
-import type { Decorator, MethodDeclaration } from 'ts-morph';
-
 import type { HttpRouteParameterReaderContract } from './Contract/HttpRouteParameterReaderContract.ts';
 
 /**
  * Reads and builds AST expressions for HTTP dynamic route parameters.
  *
+ * The shipped `@DynamicRoute` decorator folds parameter definitions into its
+ * options object as `parameters: [{ name, regex, cast?, isOptional?,
+ * shouldCapture?, default? }]` (TC39 Stage-3 has no parameter decorators), so
+ * this reader parses that array of object literals rather than a separate
+ * `@Parameter` decorator.
+ *
  * Extracted from HttpRouteAttributeReader to keep each class under the
  * complexity threshold; injected as a constructor argument.
  */
 export class HttpRouteParameterReader extends AstReader implements HttpRouteParameterReaderContract {
     updateParameters(
-        decoratorArgs: ts.NodeArray<ts.Expression> | ts.Expression[],
-        method: MethodDeclaration,
+        obj: ts.ObjectLiteralExpression,
         useMap: Record<string, string>,
         namespace: string,
         currentClass: string,
     ): HttpParameterData[] {
-        return [
-            ...this.collectInlineParameters(decoratorArgs, useMap, namespace, currentClass),
-            ...this.collectAttributeParameters(method, useMap, namespace, currentClass),
-            ...this.collectMethodParamParameters(method, useMap, namespace, currentClass),
-        ];
-    }
+        const node = this.getObjectProp(obj, 'parameters');
 
-    buildParameterListExpr(parameters: HttpParameterData[]): ts.ArrayLiteralExpression {
-        const elements = parameters.map((p) => this.buildParameterExpr(p));
-        return ts.factory.createArrayLiteralExpression(elements);
-    }
-
-    protected collectInlineParameters(
-        decoratorArgs: ts.NodeArray<ts.Expression> | ts.Expression[],
-        useMap: Record<string, string>,
-        currentFilePath: string,
-        currentClass: string,
-    ): HttpParameterData[] {
-        const inlineArg = decoratorArgs[2];
-
-        if (inlineArg === undefined || !ts.isArrayLiteralExpression(inlineArg)) {
+        if (node === undefined || !ts.isArrayLiteralExpression(node)) {
             return [];
         }
 
         const parameters: HttpParameterData[] = [];
 
-        for (const element of inlineArg.elements) {
-            if (!ts.isNewExpression(element) || element.arguments === undefined) {
+        for (const element of node.elements) {
+            if (!ts.isObjectLiteralExpression(element)) {
                 continue;
             }
 
-            const param = this.buildParameterDataFromTsArgs(element.arguments, useMap, currentFilePath, currentClass);
-
-            if (param !== null) {
-                parameters.push(param);
-            }
-        }
-
-        return parameters;
-    }
-
-    protected collectAttributeParameters(
-        method: MethodDeclaration,
-        useMap: Record<string, string>,
-        currentFilePath: string,
-        currentClass: string,
-    ): HttpParameterData[] {
-        const parameters: HttpParameterData[] = [];
-
-        for (const decorator of this.findDecoratorsOnNode(method, 'Parameter', useMap, currentFilePath)) {
-            const param = this.buildParameterDataFromDecorator(decorator, useMap, currentFilePath, currentClass);
+            const param = this.buildParameterData(element, useMap, namespace, currentClass);
 
             if (param !== null) {
                 parameters.push(param);
@@ -90,89 +56,49 @@ export class HttpRouteParameterReader extends AstReader implements HttpRoutePara
         return parameters;
     }
 
-    protected collectMethodParamParameters(
-        method: MethodDeclaration,
-        useMap: Record<string, string>,
-        currentFilePath: string,
-        currentClass: string,
-    ): HttpParameterData[] {
-        const parameters: HttpParameterData[] = [];
-
-        for (const methodParam of method.getParameters()) {
-            for (const decorator of this.findDecoratorsOnNode(methodParam, 'Parameter', useMap, currentFilePath)) {
-                const param = this.buildParameterDataFromDecorator(decorator, useMap, currentFilePath, currentClass);
-
-                if (param !== null) {
-                    parameters.push(param);
-                }
-            }
-        }
-
-        return parameters;
+    buildParameterListExpr(parameters: HttpParameterData[]): ts.ArrayLiteralExpression {
+        const elements = parameters.map((p) => this.buildParameterExpr(p));
+        return ts.factory.createArrayLiteralExpression(elements);
     }
 
-    protected buildParameterDataFromDecorator(
-        decorator: Decorator,
+    protected buildParameterData(
+        obj: ts.ObjectLiteralExpression,
         useMap: Record<string, string>,
         currentFilePath: string,
         currentClass: string,
     ): HttpParameterData | null {
-        const name = this.extractStringArg(decorator, 0, useMap, currentFilePath, currentClass);
-        const regex = this.extractStringArg(decorator, 1, useMap, currentFilePath, currentClass);
+        const name = this.getObjectStringProp(obj, 'name', useMap, currentFilePath, currentClass);
+        const regex = this.getObjectStringProp(obj, 'regex', useMap, currentFilePath, currentClass);
 
         if (name === '' || regex === '') {
             return null;
         }
 
+        const cast = this.getObjectStringProp(obj, 'cast', useMap, currentFilePath, currentClass) || null;
+
         return new HttpParameterData(
             name,
             regex,
-            this.extractStringArg(decorator, 2, useMap, currentFilePath, currentClass) || null,
-            this.extractBoolArg(decorator, 3, useMap, currentFilePath, currentClass, false),
-            this.extractBoolArg(decorator, 4, useMap, currentFilePath, currentClass, true),
+            cast,
+            this.getObjectBoolProp(obj, 'isOptional', useMap, currentFilePath, currentClass, false),
+            this.getObjectBoolProp(obj, 'shouldCapture', useMap, currentFilePath, currentClass, true),
+            this.extractDefault(obj, useMap, currentFilePath, currentClass),
         );
     }
 
-    protected buildParameterDataFromTsArgs(
-        args: ts.NodeArray<ts.Expression>,
+    protected extractDefault(
+        obj: ts.ObjectLiteralExpression,
         useMap: Record<string, string>,
         currentFilePath: string,
         currentClass: string,
-    ): HttpParameterData | null {
-        const nameNode = args[0];
-        const regexNode = args[1];
+    ): string | number | boolean | null {
+        const value = this.extractExprValue(this.getObjectProp(obj, 'default'), useMap, currentFilePath, currentClass);
 
-        if (nameNode === undefined || regexNode === undefined) {
-            return null;
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return value;
         }
 
-        const name = this.extractExprValue(nameNode, useMap, currentFilePath, currentClass);
-        const regex = this.extractExprValue(regexNode, useMap, currentFilePath, currentClass);
-
-        if (typeof name !== 'string' || name === '' || typeof regex !== 'string' || regex === '') {
-            return null;
-        }
-
-        const castNode = args[2];
-        const castRaw =
-            castNode !== undefined ? this.extractExprValue(castNode, useMap, currentFilePath, currentClass) : null;
-        const cast = typeof castRaw === 'string' && castRaw !== '' ? castRaw : null;
-
-        const isOptionalNode = args[3];
-        const isOptionalRaw =
-            isOptionalNode !== undefined
-                ? this.extractExprValue(isOptionalNode, useMap, currentFilePath, currentClass)
-                : false;
-        const isOptional = typeof isOptionalRaw === 'boolean' ? isOptionalRaw : false;
-
-        const shouldCaptureNode = args[4];
-        const shouldCaptureRaw =
-            shouldCaptureNode !== undefined
-                ? this.extractExprValue(shouldCaptureNode, useMap, currentFilePath, currentClass)
-                : true;
-        const shouldCapture = typeof shouldCaptureRaw === 'boolean' ? shouldCaptureRaw : true;
-
-        return new HttpParameterData(name, regex, cast, isOptional, shouldCapture);
+        return null;
     }
 
     protected buildParameterExpr(data: HttpParameterData): ts.Expression {
@@ -188,6 +114,22 @@ export class HttpRouteParameterReader extends AstReader implements HttpRoutePara
             this.buildBoolExpr(data.shouldCapture),
         ];
 
+        if (data.defaultValue !== null) {
+            args.push(this.buildScalarExpr(data.defaultValue));
+        }
+
         return this.buildNewExpr('Valkyrja\\Http\\Routing\\Data\\Parameter', args);
     }
+
+    protected buildScalarExpr(value: string | number | boolean): ts.Expression {
+        if (typeof value === 'string') {
+            return this.buildStringExpr(value);
+        }
+
+        if (typeof value === 'boolean') {
+            return this.buildBoolExpr(value);
+        }
+
+        return ts.factory.createNumericLiteral(value);
+    }
 }

package/src/Sindri/Constant/SindriInfo.ts

@@ -8,8 +8,8 @@
  */
 
 export class SindriInfo {
-    static readonly VERSION = '26.5.0' as const;
-    static readonly VERSION_BUILD_DATE_TIME = 'July 31 2026 08:59:24 MST' as const;
+    static readonly VERSION = '26.6.0' as const;
+    static readonly VERSION_BUILD_DATE_TIME = 'August 1 2026 18:38:34 MST' as const;
     static readonly ICON = `\
     ██████████
     ████  ████