@asenajs/hono-adapter 1.4.0 → 1.5.1

package/README.md

@@ -44,8 +44,8 @@ await new AsenaServer(adapter)
 ### Controller Example
 
 ```typescript
-import { Controller } from '@asenajs/asena/server';
-import { Get } from '@asenajs/asena/web';
+import { Controller } from '@asenajs/asena/decorators';
+import { Get } from '@asenajs/asena/decorators/http';
 import type { Context } from '@asenajs/hono-adapter';
 
 @Controller()

package/dist/lib/HonoAdapter.d.ts

@@ -1,18 +1,28 @@
 import { Hono } from 'hono';
 import type { Server } from 'bun';
-import type { AsenaWebsocketAdapter, WebsocketRouteParams } from '@asenajs/asena/adapter';
+import type { WebsocketRouteParams } from '@asenajs/asena/adapter';
 import { AsenaAdapter, type AsenaServeOptions, type BaseMiddleware, type RouteParams } from '@asenajs/asena/adapter';
 import type { GlobalMiddlewareRouteConfig } from '@asenajs/asena/server/config';
-import type { HonoErrorHandler, StaticServeExtras } from './types';
+import type { HonoAdapterOptions, HonoErrorHandler, StaticServeExtras } from './types';
 import { type ServerLogger } from '@asenajs/asena/logger';
 import type { ValidationSchema } from './defaults';
 import type { Context as HonoAdapterContext } from './defaults/Context';
+import { HonoWebsocketAdapter } from './HonoWebsocketAdapter';
 import type { WebSocketData } from '@asenajs/asena/web-socket';
 export declare class HonoAdapter extends AsenaAdapter<HonoAdapterContext, ValidationSchema> {
     name: string;
-    app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+    app: Hono;
+    private readonly _strict;
     private server;
     private options;
+    /**
+     * Normalizes a route path for Hono compatibility.
+     * Strips trailing slash (except root '/') because Hono's strict:false
+     * normalizes incoming request paths by removing trailing slashes.
+     * Registered routes must match this normalized form.
+     */
+    private normalizePath;
+    stop(closeActiveConnections?: boolean): Promise<void>;
     private routeQueue;
     /**
      * WebSocket route queue for deferred registration
@@ -24,9 +34,19 @@ export declare class HonoAdapter extends AsenaAdapter<HonoAdapterContext, Valida
      * Middlewares are stored with their pattern config and applied during route registration
      */
     private globalMiddlewares;
+    /**
+     * HTML routes for FrontendController pages
+     * Stored separately and merged into Bun.serve() routes at start time
+     */
+    private htmlRoutes;
+    /**
+     * Queue of FrontendController route metadata for deferred logging at start time
+     */
+    private frontEndRouteQueue;
     private routesRegistered;
     private readonly methodMap;
-    constructor(logger: ServerLogger, websocketAdapter?: AsenaWebsocketAdapter);
+    constructor(options: HonoAdapterOptions);
+    constructor(logger: ServerLogger, websocketAdapter?: HonoWebsocketAdapter, app?: Hono<any, any, any>);
     /**
      * Registers a global middleware with optional path filtering
      *
@@ -53,6 +73,14 @@ export declare class HonoAdapter extends AsenaAdapter<HonoAdapterContext, Valida
      * });
      * ```
      */
+    /**
+     * Registers an HTML route for FrontendController pages.
+     * HTML routes bypass the middleware chain and are served directly by Bun.serve().
+     *
+     * @param path - Full URL path (e.g., '/ui/home')
+     * @param htmlBundle - The HTML bundle returned by importing an .html file
+     */
+    registerHTMLRoute(path: string, htmlBundle: unknown, controllerName: string, controllerBasePath: string): void;
     use(middleware: BaseMiddleware<HonoAdapterContext>, config?: GlobalMiddlewareRouteConfig): void;
     registerRoute(params: RouteParams<HonoAdapterContext, ValidationSchema, StaticServeExtras>): Promise<void>;
     /**
@@ -107,6 +135,19 @@ export declare class HonoAdapter extends AsenaAdapter<HonoAdapterContext, Valida
      * @returns Array of Hono middleware handlers for validation
      */
     private prepareValidator;
+    /**
+     * Registers global middlewares at the top level of the Hono app
+     *
+     * Must be called BEFORE route registration so middlewares run before route matching.
+     * This ensures global middlewares (like CORS) handle all requests including
+     * OPTIONS preflight requests that don't have explicit route handlers.
+     *
+     * Uses Hono's native path-based middleware registration:
+     * - No config → app.use('*', mw)
+     * - Only include patterns → app.use('/api/*', mw) per pattern
+     * - Exclude patterns → runtime shouldApplyMiddleware check (Hono has no native exclude)
+     */
+    private registerGlobalMiddlewaresTopLevel;
     /**
      * Gets global middlewares that should be applied to a specific path
      *
@@ -231,4 +272,8 @@ export declare class HonoAdapter extends AsenaAdapter<HonoAdapterContext, Valida
      * ```
      */
     private buildControllerBasedLog;
+    /**
+     * Groups FrontendController routes by controller name for logging
+     */
+    private groupFrontEndRoutesByController;
 }

package/dist/lib/HonoAdapter.js

@@ -3,18 +3,37 @@ import { HTTPException } from 'hono/http-exception';
 import * as bun from 'bun';
 import { HonoContextWrapper } from './HonoContextWrapper';
 import { AsenaAdapter, VALIDATOR_METHODS, } from '@asenajs/asena/adapter';
-import { shouldApplyMiddleware } from '@asenajs/asena/utlis';
+import { shouldApplyMiddleware } from '@asenajs/asena/utils';
 import { blue, green, red, yellow } from '@asenajs/asena/logger';
 import { zValidator } from '@hono/zod-validator';
 import { middlewareParser } from './utils/middlewareParser';
+import { compareRoutePriority } from './utils/routePriority';
 import { HttpMethod } from '@asenajs/asena/web-types';
 import { HonoWebsocketAdapter } from './HonoWebsocketAdapter';
 import { serveStatic } from 'hono/bun';
 export class HonoAdapter extends AsenaAdapter {
     name = 'HonoAdapter';
-    app = new Hono();
+    app;
+    _strict = true;
     server;
     options = {};
+    /**
+     * Normalizes a route path for Hono compatibility.
+     * Strips trailing slash (except root '/') because Hono's strict:false
+     * normalizes incoming request paths by removing trailing slashes.
+     * Registered routes must match this normalized form.
+     */
+    normalizePath(path) {
+        if (path.length > 1 && path.endsWith('/')) {
+            return path.slice(0, -1);
+        }
+        return path;
+    }
+    async stop(closeActiveConnections = true) {
+        if (this.server) {
+            await this.server.stop(closeActiveConnections);
+        }
+    }
     // Deferred route registration
     routeQueue = [];
     /**
@@ -27,6 +46,15 @@ export class HonoAdapter extends AsenaAdapter {
      * Middlewares are stored with their pattern config and applied during route registration
      */
     globalMiddlewares = [];
+    /**
+     * HTML routes for FrontendController pages
+     * Stored separately and merged into Bun.serve() routes at start time
+     */
+    htmlRoutes = new Map();
+    /**
+     * Queue of FrontendController route metadata for deferred logging at start time
+     */
+    frontEndRouteQueue = [];
     routesRegistered = false;
     methodMap = {
         [HttpMethod.GET]: (path, ...handlers) => this.app.get(path, ...handlers),
@@ -35,19 +63,40 @@ export class HonoAdapter extends AsenaAdapter {
         [HttpMethod.DELETE]: (path, ...handlers) => this.app.delete(path, ...handlers),
         [HttpMethod.PATCH]: (path, ...handlers) => this.app.patch(path, ...handlers),
         [HttpMethod.OPTIONS]: (path, ...handlers) => this.app.options(path, ...handlers),
-        [HttpMethod.CONNECT]: (path, ...handlers) => this.app.on(HttpMethod.CONNECT.toUpperCase(), path, ...handlers),
-        [HttpMethod.HEAD]: (path, ...handlers) => this.app.on(HttpMethod.HEAD.toUpperCase(), path, ...handlers),
-        [HttpMethod.TRACE]: (path, ...handlers) => this.app.on(HttpMethod.TRACE.toUpperCase(), path, ...handlers),
+        [HttpMethod.CONNECT]: (path, ...handlers) => this.app.on([HttpMethod.CONNECT.toUpperCase()], path, ...handlers),
+        // HEAD is handled automatically by Hono via GET routes (HTTP spec: HEAD = GET without body).
+        // Registering via app.on(['HEAD'], ...) does not work in Hono — it silently 404s.
+        [HttpMethod.HEAD]: (path, ...handlers) => this.app.get(path, ...handlers),
+        [HttpMethod.TRACE]: (path, ...handlers) => this.app.on([HttpMethod.TRACE.toUpperCase()], path, ...handlers),
+        [HttpMethod.ALL]: (path, ...handlers) => this.app.all(path, ...handlers),
     };
-    constructor(logger, websocketAdapter) {
-        super(logger, websocketAdapter);
-        if (!this.websocketAdapter) {
-            this.websocketAdapter = new HonoWebsocketAdapter(logger);
+    constructor(loggerOrOptions, websocketAdapter, app) {
+        let logger;
+        let wsAdapter;
+        let honoApp;
+        if (typeof loggerOrOptions === 'object' && 'logger' in loggerOrOptions) {
+            logger = loggerOrOptions.logger;
+            wsAdapter = loggerOrOptions.websocketAdapter ?? new HonoWebsocketAdapter(logger);
+            honoApp = loggerOrOptions.app;
+        }
+        else {
+            logger = loggerOrOptions;
+            wsAdapter = websocketAdapter ?? new HonoWebsocketAdapter(logger);
+            honoApp = app;
         }
-        // to ensure that the logger is set
+        super(logger, wsAdapter);
         if (!this.websocketAdapter.logger && logger) {
             this.websocketAdapter.logger = this.logger;
         }
+        this._strict = typeof loggerOrOptions === 'object' && 'logger' in loggerOrOptions
+            ? loggerOrOptions.strict ?? true
+            : true;
+        if (honoApp) {
+            this.app = honoApp;
+        }
+        else {
+            this.app = new Hono({ strict: this._strict });
+        }
     }
     /**
      * Registers a global middleware with optional path filtering
@@ -75,6 +124,27 @@ export class HonoAdapter extends AsenaAdapter {
      * });
      * ```
      */
+    /**
+     * Registers an HTML route for FrontendController pages.
+     * HTML routes bypass the middleware chain and are served directly by Bun.serve().
+     *
+     * @param path - Full URL path (e.g., '/ui/home')
+     * @param htmlBundle - The HTML bundle returned by importing an .html file
+     */
+    registerHTMLRoute(path, htmlBundle, controllerName, controllerBasePath) {
+        if (this.htmlRoutes.has(path)) {
+            throw new Error(`Duplicate HTML route: "${path}" is already registered.`);
+        }
+        this.htmlRoutes.set(path, htmlBundle);
+        this.frontEndRouteQueue.push({ path, controllerName, controllerBasePath });
+        // Register trailing slash variant for consistent routing
+        if (path !== '/' && !path.endsWith('/')) {
+            this.htmlRoutes.set(`${path}/`, htmlBundle);
+        }
+        else if (path !== '/' && path.endsWith('/')) {
+            this.htmlRoutes.set(path.slice(0, -1), htmlBundle);
+        }
+    }
     use(middleware, config) {
         // Store middleware with config for deferred application during route registration
         this.globalMiddlewares.push({ middleware, config });
@@ -102,19 +172,28 @@ export class HonoAdapter extends AsenaAdapter {
     async start() {
         // Register all queued routes with optimization
         if (!this.routesRegistered) {
+            // Register global middlewares at top level BEFORE routes
+            // This ensures they run for ALL requests including OPTIONS preflight
+            this.registerGlobalMiddlewaresTopLevel();
             await this.optimizeAndRegisterRoutes();
             this.routesRegistered = true;
         }
         this.websocketAdapter.prepareWebSocket(this.options?.wsOptions);
-        this.server = bun.serve({
+        const serveConfig = {
             ...this.options.serveOptions,
             port: this.port,
             fetch: this.app.fetch,
             websocket: this.websocketAdapter.websocket,
-        });
+        };
+        // Add HTML routes if any are registered (FrontendController pages)
+        // Bun checks routes first, then falls through to fetch (Hono) for API routes
+        if (this.htmlRoutes.size > 0) {
+            serveConfig.routes = Object.fromEntries(this.htmlRoutes);
+        }
+        this.server = bun.serve(serveConfig);
         this.websocketAdapter.startWebsocket(this.server);
         // Log controller-based route information
-        if (this.routeQueue.length > 0 || this.wsRouteQueue.length > 0) {
+        if (this.routeQueue.length > 0 || this.wsRouteQueue.length > 0 || this.frontEndRouteQueue.length > 0) {
             this.logger.info('\n' + this.buildControllerBasedLog());
         }
         this.logger.info(`Server running at http://localhost:${this.server.port}`);
@@ -156,7 +235,7 @@ export class HonoAdapter extends AsenaAdapter {
                 timestamp: new Date().toISOString(),
             });
             // Wrap context for user handler
-            const wrapper = new HonoContextWrapper(context);
+            const wrapper = new HonoContextWrapper(context, this.server);
             // Handle HTTPException with Hono's standard pattern
             if (error instanceof HTTPException) {
                 try {
@@ -196,10 +275,10 @@ export class HonoAdapter extends AsenaAdapter {
         this.port = port;
     }
     prepareMiddlewares(middlewares) {
-        return middlewareParser(middlewares);
+        return middlewareParser(middlewares, () => this.server);
     }
     prepareHandler(handler) {
-        return (c) => handler(new HonoContextWrapper(c));
+        return (c) => handler(new HonoContextWrapper(c, this.server));
     }
     /**
      * Prepares static serve options with enhanced features
@@ -234,7 +313,7 @@ export class HonoAdapter extends AsenaAdapter {
                         });
                     }
                     // Call user callback
-                    await staticServe.onFound.handler(path, new HonoContextWrapper(c));
+                    await staticServe.onFound.handler(path, new HonoContextWrapper(c, this.server));
                 };
             }
         }
@@ -260,7 +339,7 @@ export class HonoAdapter extends AsenaAdapter {
             }
             else {
                 staticServeOptions.onNotFound = (path, c) => {
-                    staticServe.onNotFound.handler(path, new HonoContextWrapper(c));
+                    staticServe.onNotFound.handler(path, new HonoContextWrapper(c, this.server));
                 };
             }
         }
@@ -330,6 +409,49 @@ export class HonoAdapter extends AsenaAdapter {
         }
         return validators;
     }
+    /**
+     * Registers global middlewares at the top level of the Hono app
+     *
+     * Must be called BEFORE route registration so middlewares run before route matching.
+     * This ensures global middlewares (like CORS) handle all requests including
+     * OPTIONS preflight requests that don't have explicit route handlers.
+     *
+     * Uses Hono's native path-based middleware registration:
+     * - No config → app.use('*', mw)
+     * - Only include patterns → app.use('/api/*', mw) per pattern
+     * - Exclude patterns → runtime shouldApplyMiddleware check (Hono has no native exclude)
+     */
+    registerGlobalMiddlewaresTopLevel() {
+        for (const { middleware, config } of this.globalMiddlewares) {
+            const parsed = middlewareParser([middleware], () => this.server);
+            if (!config) {
+                // No pattern filter → apply to all routes
+                this.app.use('*', ...parsed);
+            }
+            else if (config.include && !config.exclude) {
+                // Only include patterns → use Hono's native path matching
+                for (const pattern of config.include) {
+                    this.app.use(pattern, ...parsed);
+                }
+            }
+            else {
+                // Exclude patterns exist → runtime filtering required
+                this.app.use('*', async (c, next) => {
+                    if (shouldApplyMiddleware(new URL(c.req.url).pathname, config)) {
+                        for (const mw of parsed) {
+                            let called = false;
+                            await mw(c, async () => {
+                                called = true;
+                            });
+                            if (!called)
+                                return;
+                        }
+                    }
+                    await next();
+                });
+            }
+        }
+    }
     /**
      * Gets global middlewares that should be applied to a specific path
      *
@@ -420,9 +542,16 @@ export class HonoAdapter extends AsenaAdapter {
     async optimizeAndRegisterRoutes() {
         // Register HTTP routes
         if (this.routeQueue.length > 0) {
+            // Sort routes by priority: static > param > wildcard, more specific first.
+            // Hono matches in registration order — correct ordering prevents /:id
+            // from catching static routes like /count or /search.
+            // @see routePriority.ts for the segment-based comparison algorithm.
+            this.routeQueue.sort((a, b) => compareRoutePriority(a.path, b.path));
             // Group routes by base path
             const routeGroups = this.groupRoutesByBasePath(this.routeQueue);
-            for (const [basePath, routes] of routeGroups) {
+            // Sort groups by the same priority algorithm to ensure correct inter-group order
+            const sortedGroups = [...routeGroups.entries()].sort(([a], [b]) => compareRoutePriority(a, b));
+            for (const [basePath, routes] of sortedGroups) {
                 // Find common middlewares for this group
                 const commonMiddlewares = this.extractCommonMiddlewares(routes);
                 if (routes.length > 1 && commonMiddlewares.length > 0) {
@@ -466,6 +595,13 @@ export class HonoAdapter extends AsenaAdapter {
                 this.logger.info(`${green('✓')} Successfully registered ${yellow('WEBSOCKET')} ${blue(controllerName)} ${yellow(`(${routeCount} ${routeText})`)}`);
             }
         }
+        // Log FrontendControllers
+        const frontEndGroups = this.groupFrontEndRoutesByController();
+        for (const [controllerName, group] of frontEndGroups) {
+            const routeCount = group.routes.length;
+            const routeText = routeCount === 1 ? 'route' : 'routes';
+            this.logger.info(`${green('✓')} Successfully registered ${yellow('FRONTEND')} ${blue(controllerName)} ${yellow(`(${routeCount} ${routeText})`)}`);
+        }
     }
     /**
      * Registers a WebSocket route directly
@@ -478,10 +614,12 @@ export class HonoAdapter extends AsenaAdapter {
         const preparedMiddlewares = this.prepareMiddlewares(wsRoute.middlewares || []);
         // Combine: global middlewares -> route middlewares
         const allMiddlewares = [...preparedGlobalMiddlewares, ...preparedMiddlewares];
-        this.app.get(`/${wsRoute.path}`, ...allMiddlewares, async (c, next) => {
+        const normalizedWsPath = this.normalizePath(`/${wsRoute.path}`);
+        this.app.get(normalizedWsPath, ...allMiddlewares, async (c, next) => {
             const websocketData = c.get('_websocketData') || {};
             const id = bun.randomUUIDv7();
-            const data = { values: websocketData, id, path: wsRoute.path };
+            const dataPath = normalizedWsPath.startsWith('/') ? normalizedWsPath.slice(1) : normalizedWsPath;
+            const data = { values: websocketData, id, path: dataPath };
             const upgradeResult = this.server.upgrade(c.req.raw, { data });
             if (upgradeResult) {
                 return new Response(null);
@@ -494,14 +632,8 @@ export class HonoAdapter extends AsenaAdapter {
      */
     async registerRouteGroup(basePath, commonMiddlewares, routes) {
         // Create grouped Hono instance
-        const group = new Hono();
-        // Get filtered global middlewares for this base path
-        const applicableGlobalMiddlewares = this.getGlobalMiddlewaresForPath(basePath);
-        const preparedGlobalMiddlewares = this.prepareMiddlewares(applicableGlobalMiddlewares);
-        // Apply global middlewares first (before common middlewares)
-        if (preparedGlobalMiddlewares.length > 0) {
-            group.use('*', ...preparedGlobalMiddlewares);
-        }
+        const group = new Hono({ strict: this._strict });
+        // Global middlewares are registered at top level via registerGlobalMiddlewaresTopLevel()
         // Apply common middlewares to the entire group
         const preparedCommonMiddlewares = this.prepareMiddlewares(commonMiddlewares);
         if (preparedCommonMiddlewares.length > 0) {
@@ -515,9 +647,10 @@ export class HonoAdapter extends AsenaAdapter {
             [HttpMethod.DELETE]: (path, ...handlers) => group.delete(path, ...handlers),
             [HttpMethod.PATCH]: (path, ...handlers) => group.patch(path, ...handlers),
             [HttpMethod.OPTIONS]: (path, ...handlers) => group.options(path, ...handlers),
-            [HttpMethod.CONNECT]: (path, ...handlers) => group.on(HttpMethod.CONNECT.toUpperCase(), path, ...handlers),
-            [HttpMethod.HEAD]: (path, ...handlers) => group.on(HttpMethod.HEAD.toUpperCase(), path, ...handlers),
-            [HttpMethod.TRACE]: (path, ...handlers) => group.on(HttpMethod.TRACE.toUpperCase(), path, ...handlers),
+            [HttpMethod.CONNECT]: (path, ...handlers) => group.on([HttpMethod.CONNECT.toUpperCase()], path, ...handlers),
+            // HEAD is handled automatically by Hono via GET routes (HTTP spec: HEAD = GET without body).
+            [HttpMethod.HEAD]: (path, ...handlers) => group.get(path, ...handlers),
+            [HttpMethod.TRACE]: (path, ...handlers) => group.on([HttpMethod.TRACE.toUpperCase()], path, ...handlers),
         };
         // Register each route in the group
         for (const route of routes) {
@@ -526,10 +659,8 @@ export class HonoAdapter extends AsenaAdapter {
             const preparedMiddlewares = this.prepareMiddlewares(uniqueMiddlewares);
             const validators = route.validator ? await this.prepareValidator(route.validator) : [];
             const allMiddlewares = [...validators, ...preparedMiddlewares];
-            const methodHandler = groupMethodMap[route.method];
-            if (!methodHandler) {
-                throw new Error(`Invalid HTTP method: ${route.method}`);
-            }
+            const methodHandler = groupMethodMap[route.method] ??
+                ((path, ...handlers) => group.on([route.method.toUpperCase()], path, ...handlers));
             // Calculate relative path
             let relativePath = route.path;
             if (route.path.startsWith(basePath) && basePath !== '/') {
@@ -538,39 +669,40 @@ export class HonoAdapter extends AsenaAdapter {
             if (!relativePath.startsWith('/')) {
                 relativePath = '/' + relativePath;
             }
+            // Normalize path for Hono trailing slash compatibility
+            const normalizedRelativePath = this.normalizePath(relativePath);
             // Register to group
             if (route.staticServe) {
-                methodHandler(relativePath, ...allMiddlewares, serveStatic(this.prepareStaticServeOptions(route.staticServe)));
+                methodHandler(normalizedRelativePath, ...allMiddlewares, serveStatic(this.prepareStaticServeOptions(route.staticServe)));
             }
             else {
                 const handler = this.prepareHandler(route.handler);
-                methodHandler(relativePath, ...allMiddlewares, handler);
+                methodHandler(normalizedRelativePath, ...allMiddlewares, handler);
             }
         }
-        // Mount group to main app
-        this.app.route(basePath, group);
+        // Mount group to main app (normalize basePath too)
+        this.app.route(this.normalizePath(basePath), group);
     }
     /**
      * Registers a single route directly without grouping
      */
     async registerRouteDirect(route) {
-        // Get filtered global middlewares for this route
-        const applicableGlobalMiddlewares = this.getGlobalMiddlewaresForPath(route.path);
-        const preparedGlobalMiddlewares = this.prepareMiddlewares(applicableGlobalMiddlewares);
         const preparedMiddlewares = this.prepareMiddlewares(route.middlewares || []);
         const validators = route.validator ? await this.prepareValidator(route.validator) : [];
-        // Combine: validators -> global middlewares -> route middlewares
-        const allMiddlewares = [...validators, ...preparedGlobalMiddlewares, ...preparedMiddlewares];
-        const methodHandler = this.methodMap[route.method];
-        if (!methodHandler) {
-            throw new Error(`Invalid HTTP method: ${route.method}`);
-        }
+        // Global middlewares are registered at top level via registerGlobalMiddlewaresTopLevel()
+        const allMiddlewares = [...validators, ...preparedMiddlewares];
+        const methodHandler = this.methodMap[route.method] ??
+            ((path, ...handlers) => this.app.on([route.method.toUpperCase()], path, ...handlers));
+        // Normalize path for Hono: strip trailing slash (except root '/')
+        // Hono strict:false strips trailing slash from incoming requests,
+        // so registered paths must also not have trailing slash to match.
+        const normalizedPath = this.normalizePath(route.path);
         if (route.staticServe) {
-            methodHandler(route.path, ...allMiddlewares, serveStatic(this.prepareStaticServeOptions(route.staticServe)));
+            methodHandler(normalizedPath, ...allMiddlewares, serveStatic(this.prepareStaticServeOptions(route.staticServe)));
         }
         else {
             const handler = this.prepareHandler(route.handler);
-            methodHandler(route.path, ...allMiddlewares, handler);
+            methodHandler(normalizedPath, ...allMiddlewares, handler);
         }
     }
     /**
@@ -728,7 +860,33 @@ export class HonoAdapter extends AsenaAdapter {
             }
             lines.push(''); // Empty line between controllers
         }
+        // Add FrontendController groups
+        const frontEndGroups = this.groupFrontEndRoutesByController();
+        const sortedFrontEnd = Array.from(frontEndGroups.entries()).sort(([a], [b]) => a.localeCompare(b));
+        for (const [controllerName, group] of sortedFrontEnd) {
+            lines.push(`  ${blue(controllerName)} ${yellow(`(${group.basePath})`)}`);
+            for (const route of group.routes) {
+                lines.push(`    ${green('HTML')} ${route.path}`);
+            }
+            lines.push('');
+        }
         return lines.join('\n');
     }
+    /**
+     * Groups FrontendController routes by controller name for logging
+     */
+    groupFrontEndRoutesByController() {
+        const groups = new Map();
+        for (const route of this.frontEndRouteQueue) {
+            if (!groups.has(route.controllerName)) {
+                groups.set(route.controllerName, {
+                    basePath: route.controllerBasePath,
+                    routes: [],
+                });
+            }
+            groups.get(route.controllerName).routes.push({ path: route.path });
+        }
+        return groups;
+    }
 }
 //# sourceMappingURL=HonoAdapter.js.map