stratal 0.0.13 → 0.0.14

package/dist/gateway-context-D7TFPLi5.mjs

@@ -0,0 +1,226 @@
+import { S as ApplicationError, b as ERROR_CODES } from "./errors-BRJgVd5-.mjs";
+import { d as Transient } from "./logger-Bg-CuidS.mjs";
+import { o as ROUTE_METADATA_KEYS, t as RouterContext } from "./router-context-DlTxpJUG.mjs";
+//#region src/websocket/decorators/gateway.decorator.ts
+const CONTROLLER_ROUTE_KEY = ROUTE_METADATA_KEYS.CONTROLLER_ROUTE;
+const CONTROLLER_OPTIONS_KEY = ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS;
+const GATEWAY_MARKER_KEY = ROUTE_METADATA_KEYS.GATEWAY_MARKER;
+/**
+* Gateway decorator for WebSocket route registration
+*
+* Marks a class as a WebSocket gateway and stores route metadata.
+* Reuses the same metadata key as @Controller for middleware compatibility —
+* `getControllerRoute()`, `forRoutes()`, and the entire middleware system work
+* with zero changes.
+*
+* @param route - WebSocket route path (e.g., '/ws/chat')
+*
+* @example
+* ```typescript
+* import { type GatewayContext, Gateway, OnMessage, OnClose } from 'stratal/websocket'
+*
+* @Gateway('/ws/chat')
+* class ChatGateway {
+*   @OnMessage()
+*   handleMessage(evt: MessageEvent, ctx: GatewayContext) {
+*     ctx.send('ack')
+*   }
+*
+*   @OnClose()
+*   handleClose(evt: CloseEvent, ctx: GatewayContext) {
+*     console.log('closed')
+*   }
+* }
+* ```
+*/
+function Gateway(route, options) {
+	return function(target) {
+		Transient()(target);
+		Reflect.defineMetadata(CONTROLLER_ROUTE_KEY, route, target);
+		Reflect.defineMetadata(GATEWAY_MARKER_KEY, true, target);
+		if (options) Reflect.defineMetadata(CONTROLLER_OPTIONS_KEY, options, target);
+		return target;
+	};
+}
+/**
+* Check if a class is a WebSocket gateway
+*
+* @param target - Class constructor or instance
+* @returns true if the class is decorated with @Gateway
+*/
+function isGateway(target) {
+	const metadataTarget = typeof target === "function" ? target : target.constructor;
+	return Reflect.getMetadata(GATEWAY_MARKER_KEY, metadataTarget) === true;
+}
+//#endregion
+//#region src/websocket/errors/websocket-duplicate-event-handler.error.ts
+var WebSocketDuplicateEventHandlerError = class extends ApplicationError {
+	constructor(decorator, existingMethod) {
+		super("errors.websocketDuplicateEventHandler", ERROR_CODES.SYSTEM.WEBSOCKET_DUPLICATE_EVENT_HANDLER, {
+			decorator,
+			existingMethod
+		});
+	}
+};
+//#endregion
+//#region src/websocket/decorators/ws-event.decorator.ts
+const WS_ON_MESSAGE_KEY = ROUTE_METADATA_KEYS.WS_ON_MESSAGE;
+const WS_ON_CLOSE_KEY = ROUTE_METADATA_KEYS.WS_ON_CLOSE;
+const WS_ON_ERROR_KEY = ROUTE_METADATA_KEYS.WS_ON_ERROR;
+/**
+* Define a single-handler metadata key on the prototype.
+* Throws if a different method already owns this key (prevents silent override).
+*/
+function defineSingleHandlerMetadata(key, propertyKey, target, decoratorName) {
+	const existing = Reflect.getMetadata(key, target);
+	if (existing !== void 0 && existing !== propertyKey) throw new WebSocketDuplicateEventHandlerError(decoratorName, String(existing));
+	Reflect.defineMetadata(key, propertyKey, target);
+}
+/**
+* Marks a method as the WebSocket message handler
+*
+* @example
+* ```typescript
+* @Gateway('/ws/chat')
+* class ChatGateway {
+*   @OnMessage()
+*   handleMessage(evt: MessageEvent, ctx: GatewayContext) {
+*     ctx.send(evt.data)
+*   }
+* }
+* ```
+*/
+function OnMessage() {
+	return (_target, propertyKey) => {
+		defineSingleHandlerMetadata(WS_ON_MESSAGE_KEY, propertyKey, _target, "OnMessage");
+	};
+}
+/**
+* Marks a method as the WebSocket close handler
+*
+* @example
+* ```typescript
+* @Gateway('/ws/chat')
+* class ChatGateway {
+*   @OnClose()
+*   handleClose(evt: CloseEvent, ctx: GatewayContext) {
+*     console.log('closed')
+*   }
+* }
+* ```
+*/
+function OnClose() {
+	return (_target, propertyKey) => {
+		defineSingleHandlerMetadata(WS_ON_CLOSE_KEY, propertyKey, _target, "OnClose");
+	};
+}
+/**
+* Marks a method as the WebSocket error handler
+*
+* @example
+* ```typescript
+* @Gateway('/ws/chat')
+* class ChatGateway {
+*   @OnError()
+*   handleError(evt: Event, ctx: GatewayContext) {
+*     console.error('WebSocket error', evt)
+*   }
+* }
+* ```
+*/
+function OnError() {
+	return (_target, propertyKey) => {
+		defineSingleHandlerMetadata(WS_ON_ERROR_KEY, propertyKey, _target, "OnError");
+	};
+}
+/**
+* Get the method name decorated with @OnMessage
+*/
+function getWsOnMessageMethod(target) {
+	return Reflect.getMetadata(WS_ON_MESSAGE_KEY, target.prototype);
+}
+/**
+* Get the method name decorated with @OnClose
+*/
+function getWsOnCloseMethod(target) {
+	return Reflect.getMetadata(WS_ON_CLOSE_KEY, target.prototype);
+}
+/**
+* Get the method name decorated with @OnError
+*/
+function getWsOnErrorMethod(target) {
+	return Reflect.getMetadata(WS_ON_ERROR_KEY, target.prototype);
+}
+//#endregion
+//#region src/websocket/errors/websocket-body-not-available.error.ts
+var WebSocketBodyNotAvailableError = class extends ApplicationError {
+	constructor() {
+		super("errors.websocketBodyNotAvailable", ERROR_CODES.SYSTEM.WEBSOCKET_BODY_NOT_AVAILABLE);
+	}
+};
+//#endregion
+//#region src/websocket/gateway-context.ts
+/**
+* WebSocket gateway context
+*
+* Extends RouterContext with WebSocket-specific methods.
+* Inherits `getContainer()`, `param()`, `query()`, `header()`, `getLocale()`
+* from RouterContext. HTTP response methods (`json()`, `redirect()`, etc.) are
+* inherited but harmless post-upgrade.
+*
+* @example
+* ```typescript
+* @OnMessage()
+* handleMessage(evt: MessageEvent, ctx: GatewayContext) {
+*   ctx.send('ack')           // convenience method
+*   ctx.header('Authorization') // upgrade request headers
+* }
+* ```
+*/
+var GatewayContext = class extends RouterContext {
+	constructor(c, ws) {
+		super(c);
+		this.ws = ws;
+	}
+	/** Send data through the WebSocket connection */
+	send(data) {
+		this.ws.send(data);
+	}
+	/** Close the WebSocket connection */
+	close(code, reason) {
+		this.ws.close(code, reason);
+	}
+	/** Current WebSocket ready state */
+	get readyState() {
+		return this.ws.readyState;
+	}
+	/**
+	* Get route parameter value from the raw request (no OpenAPI validation)
+	*
+	* @param key - Parameter name (e.g., 'id' for /ws/chat/:id)
+	*/
+	param(key) {
+		return this.c.req.param(key);
+	}
+	/**
+	* Get query parameter value from the raw request (no OpenAPI validation)
+	*
+	* @param key - Query parameter name
+	*/
+	query(key) {
+		if (key) return this.c.req.query(key);
+		return this.c.req.query();
+	}
+	/**
+	* Request body is not available in WebSocket gateways
+	*
+	* @throws WebSocketBodyNotAvailableError always — WebSocket upgrade requests do not have a body
+	*/
+	body() {
+		throw new WebSocketBodyNotAvailableError();
+	}
+};
+//#endregion
+export { OnMessage as a, getWsOnMessageMethod as c, isGateway as d, OnError as i, WebSocketDuplicateEventHandlerError as l, WebSocketBodyNotAvailableError as n, getWsOnCloseMethod as o, OnClose as r, getWsOnErrorMethod as s, GatewayContext as t, Gateway as u };
+
+//# sourceMappingURL=gateway-context-D7TFPLi5.mjs.map

package/dist/gateway-context-D7TFPLi5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-context-D7TFPLi5.mjs","names":[],"sources":["../src/websocket/decorators/gateway.decorator.ts","../src/websocket/errors/websocket-duplicate-event-handler.error.ts","../src/websocket/decorators/ws-event.decorator.ts","../src/websocket/errors/websocket-body-not-available.error.ts","../src/websocket/gateway-context.ts"],"sourcesContent":["import { Transient } from '../../di/decorators'\nimport { ROUTE_METADATA_KEYS } from '../../router/constants'\nimport { type Constructor } from '../../types'\nimport type { GatewayOptions } from '../../websocket/types'\n\nconst CONTROLLER_ROUTE_KEY = ROUTE_METADATA_KEYS.CONTROLLER_ROUTE\nconst CONTROLLER_OPTIONS_KEY = ROUTE_METADATA_KEYS.CONTROLLER_OPTIONS\nconst GATEWAY_MARKER_KEY = ROUTE_METADATA_KEYS.GATEWAY_MARKER\n\n/**\n * Gateway decorator for WebSocket route registration\n *\n * Marks a class as a WebSocket gateway and stores route metadata.\n * Reuses the same metadata key as @Controller for middleware compatibility —\n * `getControllerRoute()`, `forRoutes()`, and the entire middleware system work\n * with zero changes.\n *\n * @param route - WebSocket route path (e.g., '/ws/chat')\n *\n * @example\n * ```typescript\n * import { type GatewayContext, Gateway, OnMessage, OnClose } from 'stratal/websocket'\n *\n * @Gateway('/ws/chat')\n * class ChatGateway {\n *   @OnMessage()\n *   handleMessage(evt: MessageEvent, ctx: GatewayContext) {\n *     ctx.send('ack')\n *   }\n *\n *   @OnClose()\n *   handleClose(evt: CloseEvent, ctx: GatewayContext) {\n *     console.log('closed')\n *   }\n * }\n * ```\n */\nexport function Gateway(route: string, options?: GatewayOptions) {\n  return function <T extends Constructor>(target: T) {\n    Transient()(target)\n    Reflect.defineMetadata(CONTROLLER_ROUTE_KEY, route, target)\n    Reflect.defineMetadata(GATEWAY_MARKER_KEY, true, target)\n    if (options) {\n      Reflect.defineMetadata(CONTROLLER_OPTIONS_KEY, options, target)\n    }\n    return target\n  }\n}\n\n/**\n * Check if a class is a WebSocket gateway\n *\n * @param target - Class constructor or instance\n * @returns true if the class is decorated with @Gateway\n */\nexport function isGateway(target: object): boolean {\n  const metadataTarget = typeof target === 'function' ? target : (target as { constructor: object }).constructor\n  return Reflect.getMetadata(GATEWAY_MARKER_KEY, metadataTarget) === true\n}\n","import { ApplicationError, ERROR_CODES } from '../../errors'\n\nexport class WebSocketDuplicateEventHandlerError extends ApplicationError {\n  constructor(decorator: string, existingMethod: string) {\n    super(\n      'errors.websocketDuplicateEventHandler',\n      ERROR_CODES.SYSTEM.WEBSOCKET_DUPLICATE_EVENT_HANDLER,\n      { decorator, existingMethod }\n    )\n  }\n}\n","import { ROUTE_METADATA_KEYS } from '../../router/constants'\nimport type { Constructor } from '../../types'\nimport { WebSocketDuplicateEventHandlerError } from '../errors/websocket-duplicate-event-handler.error'\n\nconst WS_ON_MESSAGE_KEY = ROUTE_METADATA_KEYS.WS_ON_MESSAGE\nconst WS_ON_CLOSE_KEY = ROUTE_METADATA_KEYS.WS_ON_CLOSE\nconst WS_ON_ERROR_KEY = ROUTE_METADATA_KEYS.WS_ON_ERROR\n\n/**\n * Define a single-handler metadata key on the prototype.\n * Throws if a different method already owns this key (prevents silent override).\n */\nfunction defineSingleHandlerMetadata(key: string | symbol, propertyKey: string | symbol, target: object, decoratorName: string): void {\n  const existing = Reflect.getMetadata(key, target) as string | symbol | undefined\n  if (existing !== undefined && existing !== propertyKey) {\n    throw new WebSocketDuplicateEventHandlerError(decoratorName, String(existing))\n  }\n  Reflect.defineMetadata(key, propertyKey, target)\n}\n\n/**\n * Marks a method as the WebSocket message handler\n *\n * @example\n * ```typescript\n * @Gateway('/ws/chat')\n * class ChatGateway {\n *   @OnMessage()\n *   handleMessage(evt: MessageEvent, ctx: GatewayContext) {\n *     ctx.send(evt.data)\n *   }\n * }\n * ```\n */\nexport function OnMessage(): MethodDecorator {\n  // `_target` is the class prototype (method decorator convention).\n  // The getter functions below read from `target.prototype` symmetrically.\n  return (_target: object, propertyKey: string | symbol) => {\n    defineSingleHandlerMetadata(WS_ON_MESSAGE_KEY, propertyKey, _target, 'OnMessage')\n  }\n}\n\n/**\n * Marks a method as the WebSocket close handler\n *\n * @example\n * ```typescript\n * @Gateway('/ws/chat')\n * class ChatGateway {\n *   @OnClose()\n *   handleClose(evt: CloseEvent, ctx: GatewayContext) {\n *     console.log('closed')\n *   }\n * }\n * ```\n */\nexport function OnClose(): MethodDecorator {\n  return (_target: object, propertyKey: string | symbol) => {\n    defineSingleHandlerMetadata(WS_ON_CLOSE_KEY, propertyKey, _target, 'OnClose')\n  }\n}\n\n/**\n * Marks a method as the WebSocket error handler\n *\n * @example\n * ```typescript\n * @Gateway('/ws/chat')\n * class ChatGateway {\n *   @OnError()\n *   handleError(evt: Event, ctx: GatewayContext) {\n *     console.error('WebSocket error', evt)\n *   }\n * }\n * ```\n */\nexport function OnError(): MethodDecorator {\n  return (_target: object, propertyKey: string | symbol) => {\n    defineSingleHandlerMetadata(WS_ON_ERROR_KEY, propertyKey, _target, 'OnError')\n  }\n}\n\n/**\n * Get the method name decorated with @OnMessage\n */\nexport function getWsOnMessageMethod(target: Constructor): string | undefined {\n  return Reflect.getMetadata(WS_ON_MESSAGE_KEY, target.prototype as object) as string | undefined\n}\n\n/**\n * Get the method name decorated with @OnClose\n */\nexport function getWsOnCloseMethod(target: Constructor): string | undefined {\n  return Reflect.getMetadata(WS_ON_CLOSE_KEY, target.prototype as object) as string | undefined\n}\n\n/**\n * Get the method name decorated with @OnError\n */\nexport function getWsOnErrorMethod(target: Constructor): string | undefined {\n  return Reflect.getMetadata(WS_ON_ERROR_KEY, target.prototype as object) as string | undefined\n}\n","import { ApplicationError, ERROR_CODES } from '../../errors'\n\nexport class WebSocketBodyNotAvailableError extends ApplicationError {\n  constructor() {\n    super(\n      'errors.websocketBodyNotAvailable',\n      ERROR_CODES.SYSTEM.WEBSOCKET_BODY_NOT_AVAILABLE\n    )\n  }\n}\n","import type { Context } from 'hono'\nimport type { WSContext, WSReadyState } from 'hono/ws'\nimport type { ContextQueryResult } from '../router/router-context'\nimport { RouterContext } from '../router/router-context'\nimport type { RouterEnv } from '../router/types'\nimport { WebSocketBodyNotAvailableError } from './errors/websocket-body-not-available.error'\n\n/**\n * WebSocket gateway context\n *\n * Extends RouterContext with WebSocket-specific methods.\n * Inherits `getContainer()`, `param()`, `query()`, `header()`, `getLocale()`\n * from RouterContext. HTTP response methods (`json()`, `redirect()`, etc.) are\n * inherited but harmless post-upgrade.\n *\n * @example\n * ```typescript\n * @OnMessage()\n * handleMessage(evt: MessageEvent, ctx: GatewayContext) {\n *   ctx.send('ack')           // convenience method\n *   ctx.header('Authorization') // upgrade request headers\n * }\n * ```\n */\nexport class GatewayContext extends RouterContext {\n  constructor(c: Context<RouterEnv>, public readonly ws: WSContext) {\n    super(c)\n  }\n\n  /** Send data through the WebSocket connection */\n  send(data: string | ArrayBuffer | Uint8Array<ArrayBuffer>): void {\n    this.ws.send(data)\n  }\n\n  /** Close the WebSocket connection */\n  close(code?: number, reason?: string): void {\n    this.ws.close(code, reason)\n  }\n\n  /** Current WebSocket ready state */\n  get readyState(): WSReadyState {\n    return this.ws.readyState\n  }\n\n  /**\n   * Get route parameter value from the raw request (no OpenAPI validation)\n   *\n   * @param key - Parameter name (e.g., 'id' for /ws/chat/:id)\n   */\n  override param(key: string): string {\n    return this.c.req.param(key)!\n  }\n\n  /**\n   * Get query parameter value from the raw request (no OpenAPI validation)\n   *\n   * @param key - Query parameter name\n   */\n  override query<R extends Record<string, unknown> | undefined = undefined, K extends string | undefined = undefined>(key?: K): ContextQueryResult<R, K> {\n    if (key) {\n      return this.c.req.query(key) as ContextQueryResult<R, K>\n    }\n    return this.c.req.query() as ContextQueryResult<R, K>\n  }\n\n  /**\n   * Request body is not available in WebSocket gateways\n   *\n   * @throws WebSocketBodyNotAvailableError always — WebSocket upgrade requests do not have a body\n   */\n  override body<T>(): Promise<T> {\n    throw new WebSocketBodyNotAvailableError()\n  }\n}\n"],"mappings":";;;;AAKA,MAAM,uBAAuB,oBAAoB;AACjD,MAAM,yBAAyB,oBAAoB;AACnD,MAAM,qBAAqB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B/C,SAAgB,QAAQ,OAAe,SAA0B;AAC/D,QAAO,SAAiC,QAAW;AACjD,aAAW,CAAC,OAAO;AACnB,UAAQ,eAAe,sBAAsB,OAAO,OAAO;AAC3D,UAAQ,eAAe,oBAAoB,MAAM,OAAO;AACxD,MAAI,QACF,SAAQ,eAAe,wBAAwB,SAAS,OAAO;AAEjE,SAAO;;;;;;;;;AAUX,SAAgB,UAAU,QAAyB;CACjD,MAAM,iBAAiB,OAAO,WAAW,aAAa,SAAU,OAAmC;AACnG,QAAO,QAAQ,YAAY,oBAAoB,eAAe,KAAK;;;;ACvDrE,IAAa,sCAAb,cAAyD,iBAAiB;CACxE,YAAY,WAAmB,gBAAwB;AACrD,QACE,yCACA,YAAY,OAAO,mCACnB;GAAE;GAAW;GAAgB,CAC9B;;;;;ACJL,MAAM,oBAAoB,oBAAoB;AAC9C,MAAM,kBAAkB,oBAAoB;AAC5C,MAAM,kBAAkB,oBAAoB;;;;;AAM5C,SAAS,4BAA4B,KAAsB,aAA8B,QAAgB,eAA6B;CACpI,MAAM,WAAW,QAAQ,YAAY,KAAK,OAAO;AACjD,KAAI,aAAa,KAAA,KAAa,aAAa,YACzC,OAAM,IAAI,oCAAoC,eAAe,OAAO,SAAS,CAAC;AAEhF,SAAQ,eAAe,KAAK,aAAa,OAAO;;;;;;;;;;;;;;;;AAiBlD,SAAgB,YAA6B;AAG3C,SAAQ,SAAiB,gBAAiC;AACxD,8BAA4B,mBAAmB,aAAa,SAAS,YAAY;;;;;;;;;;;;;;;;;AAkBrF,SAAgB,UAA2B;AACzC,SAAQ,SAAiB,gBAAiC;AACxD,8BAA4B,iBAAiB,aAAa,SAAS,UAAU;;;;;;;;;;;;;;;;;AAkBjF,SAAgB,UAA2B;AACzC,SAAQ,SAAiB,gBAAiC;AACxD,8BAA4B,iBAAiB,aAAa,SAAS,UAAU;;;;;;AAOjF,SAAgB,qBAAqB,QAAyC;AAC5E,QAAO,QAAQ,YAAY,mBAAmB,OAAO,UAAoB;;;;;AAM3E,SAAgB,mBAAmB,QAAyC;AAC1E,QAAO,QAAQ,YAAY,iBAAiB,OAAO,UAAoB;;;;;AAMzE,SAAgB,mBAAmB,QAAyC;AAC1E,QAAO,QAAQ,YAAY,iBAAiB,OAAO,UAAoB;;;;AClGzE,IAAa,iCAAb,cAAoD,iBAAiB;CACnE,cAAc;AACZ,QACE,oCACA,YAAY,OAAO,6BACpB;;;;;;;;;;;;;;;;;;;;;;ACiBL,IAAa,iBAAb,cAAoC,cAAc;CAChD,YAAY,GAAuB,IAA+B;AAChE,QAAM,EAAE;AADyC,OAAA,KAAA;;;CAKnD,KAAK,MAA4D;AAC/D,OAAK,GAAG,KAAK,KAAK;;;CAIpB,MAAM,MAAe,QAAuB;AAC1C,OAAK,GAAG,MAAM,MAAM,OAAO;;;CAI7B,IAAI,aAA2B;AAC7B,SAAO,KAAK,GAAG;;;;;;;CAQjB,MAAe,KAAqB;AAClC,SAAO,KAAK,EAAE,IAAI,MAAM,IAAI;;;;;;;CAQ9B,MAAoH,KAAmC;AACrJ,MAAI,IACF,QAAO,KAAK,EAAE,IAAI,MAAM,IAAI;AAE9B,SAAO,KAAK,EAAE,IAAI,OAAO;;;;;;;CAQ3B,OAA+B;AAC7B,QAAM,IAAI,gCAAgC"}

package/dist/guards/index.d.mts

@@ -0,0 +1,172 @@
+import { $t as Container, Tt as RouterContext } from "../index-C9bIk5tt.mjs";
+import { t as Constructor } from "../types-JUIHSW_a.mjs";
+import { i as LoggerService } from "../index-3TtGtYlJ.mjs";
+
+//#region src/guards/types.d.ts
+/**
+ * Interface for guards that control access to routes
+ *
+ * Guards are executed after middlewares but before route handlers.
+ * They determine if a request should be allowed to proceed.
+ *
+ * @example
+ * ```typescript
+ * class RoleGuard implements CanActivate {
+ *   constructor(private readonly role: string) {}
+ *
+ *   async canActivate(context: RouterContext): Promise<boolean> {
+ *     const user = context.getUser()
+ *     return user?.roles.includes(this.role) ?? false
+ *   }
+ * }
+ * ```
+ */
+interface CanActivate {
+  /**
+   * Determine if the request should be allowed
+   *
+   * @param context - Router context with request/response helpers
+   * @returns true to allow, false to deny (throws 403)
+   */
+  canActivate(context: RouterContext): boolean | Promise<boolean>;
+}
+/**
+ * Type for guard class constructors
+ */
+type GuardClass = Constructor<CanActivate>;
+/**
+ * Guard can be a class constructor or an instance
+ * Instances are used for factory-created guards with configuration
+ */
+type Guard = GuardClass | CanActivate;
+/**
+ * Options for AuthGuard factory
+ */
+interface AuthGuardOptions {
+  /**
+   * Required permissions (scopes) for authorization
+   * If provided, permission check is performed after authentication.
+   * If omitted, only authentication is required.
+   */
+  scopes?: string[];
+}
+/**
+ * Metadata stored by `@UseGuards` decorator
+ */
+interface GuardMetadata {
+  guards: Guard[];
+}
+/**
+ * Metadata key for guard storage
+ */
+declare const GUARD_METADATA_KEY: unique symbol;
+//#endregion
+//#region src/guards/use-guards.decorator.d.ts
+/**
+ * UseGuards Decorator
+ *
+ * Applies one or more guards to a controller or method.
+ * Guards are executed in order and all must pass for the request to proceed.
+ *
+ * **Execution Order:**
+ * 1. Request → Global Middlewares → Route Middlewares
+ * 2. **Guards (controller-level, then method-level)**
+ * 3. Route Handler
+ *
+ * **Guard Resolution:**
+ * - Guard classes are resolved from the request-scoped DI container
+ * - Guard instances (from factory functions) are used directly
+ *
+ * @param guards - Guard classes or instances to apply
+ *
+ * @example Authentication only
+ * ```typescript
+ * @Controller('/api/v1/profile')
+ * @UseGuards(AuthGuard())
+ * export class ProfileController {
+ *   show() { } // Requires authentication
+ * }
+ * ```
+ *
+ * @example Authentication with permissions
+ * ```typescript
+ * @Controller('/api/v1/students')
+ * @UseGuards(AuthGuard({ scopes: ['students:read'] }))
+ * export class StudentsController {
+ *   index() { } // Requires 'students:read' permission
+ * }
+ * ```
+ *
+ * @example Method-level guards
+ * ```typescript
+ * @Controller('/api/v1/students')
+ * @UseGuards(AuthGuard()) // Controller-level: auth only
+ * export class StudentsController {
+ *   index() { } // Auth only (inherited)
+ *
+ *   @UseGuards(AuthGuard({ scopes: ['students:create'] }))
+ *   create() { } // Auth + 'students:create' permission
+ * }
+ * ```
+ *
+ * @example Multiple guards
+ * ```typescript
+ * @UseGuards(AuthGuard(), RateLimitGuard(), CustomGuard())
+ * export class SecureController {
+ *   // All guards must pass
+ * }
+ * ```
+ */
+declare function UseGuards(...guards: Guard[]): ClassDecorator & MethodDecorator;
+/**
+ * Get controller-level guard metadata
+ *
+ * @param target - Controller class
+ * @returns Guard metadata or undefined if not decorated
+ */
+declare function getControllerGuards(target: object): GuardMetadata | undefined;
+/**
+ * Get method-level guard metadata
+ *
+ * @param target - Controller prototype
+ * @param propertyKey - Method name
+ * @returns Guard metadata or undefined if not decorated
+ */
+declare function getMethodGuards(target: object, propertyKey: string | symbol): GuardMetadata | undefined;
+//#endregion
+//#region src/guards/guard-execution.service.d.ts
+/**
+ * Guard Execution Service
+ *
+ * Executes guards for a route and determines if the request should proceed.
+ * Guards are executed in order; all must pass for the request to proceed.
+ */
+declare class GuardExecutionService {
+  private readonly logger;
+  constructor(logger: LoggerService);
+  /**
+   * Execute all guards for a route
+   *
+   * @param guards - Array of guards (classes or instances)
+   * @param context - Router context
+   * @param container - Request-scoped DI container
+   * @returns true if all guards pass
+   * @throws Error from first failing guard
+   */
+  executeGuards(guards: Guard[], context: RouterContext, container: Container): Promise<boolean>;
+  /**
+   * Resolve a guard to an instance
+   *
+   * @param guard - Guard class or instance
+   * @param container - Request-scoped DI container
+   * @returns Guard instance
+   */
+  private resolveGuard;
+  /**
+   * Type guard to check if value is a guard instance
+   */
+  private isGuardInstance;
+}
+//#endregion
+export { AuthGuardOptions, CanActivate, GUARD_METADATA_KEY, Guard, GuardClass, GuardExecutionService, GuardMetadata, UseGuards, getControllerGuards, getMethodGuards };
+//# sourceMappingURL=index.d.mts.map

package/dist/guards/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/guards/types.ts","../../src/guards/use-guards.decorator.ts","../../src/guards/guard-execution.service.ts"],"mappings":";;;;;;;;;AAqBA;;;;;;;;;;AAaA;;;;UAbiB,WAAA;EAmBL;;;;;AAKZ;EAjBE,WAAA,CAAY,OAAA,EAAS,aAAA,aAA0B,OAAA;AAAA;;;AA6BjD;KAvBY,UAAA,GAAa,WAAA,CAAY,WAAA;;;;AA8BrC;KAxBY,KAAA,GAAQ,UAAA,GAAa,WAAA;;;;UAKhB,gBAAA;;;ACYjB;;;EDNE,MAAA;AAAA;;;;UAMe,aAAA;EACf,MAAA,EAAQ,KAAA;AAAA;;;;cAMG,kBAAA;;;;;;;;AA3Cb;;;;;;;;;;AAaA;;;;;AAMA;;;;;AAKA;;;;;AAYA;;;;;AAOA;;;;;;;;ACPA;;;;;;;;;;;;iBAAgB,SAAA,CAAA,GAAa,MAAA,EAAQ,KAAA,KAAU,cAAA,GAAiB,eAAA;;AAoBhE;;;;;iBAAgB,mBAAA,CAAoB,MAAA,WAAiB,aAAA;;;;;;;;iBAWrC,eAAA,CAAgB,MAAA,UAAgB,WAAA,oBAA+B,aAAA;;;;;ADnE/E;;;;cEVa,qBAAA;EAAA,iBACkB,MAAA;cAAA,MAAA,EAAQ,aAAA;EFgBU;;;AAMjD;;;;;AAMA;EEjBQ,aAAA,CACJ,MAAA,EAAQ,KAAA,IACR,OAAA,EAAS,aAAA,EACT,SAAA,EAAW,SAAA,GACV,OAAA;;;;AFkBL;;;;UEsBU,YAAA;EFVO;;;EAAA,QEuBP,eAAA;AAAA"}

package/dist/guards/index.mjs

@@ -0,0 +1,2 @@
+import { a as GUARD_METADATA_KEY, i as getMethodGuards, n as UseGuards, r as getControllerGuards, t as GuardExecutionService } from "../guards-B5o618bL.mjs";
+export { GUARD_METADATA_KEY, GuardExecutionService, UseGuards, getControllerGuards, getMethodGuards };

package/dist/guards-B5o618bL.mjs

@@ -0,0 +1,151 @@
+//#region src/guards/types.ts
+/**
+* Metadata key for guard storage
+*/
+const GUARD_METADATA_KEY = Symbol.for("stratal:guards");
+//#endregion
+//#region src/guards/use-guards.decorator.ts
+/**
+* UseGuards Decorator
+*
+* Applies one or more guards to a controller or method.
+* Guards are executed in order and all must pass for the request to proceed.
+*
+* **Execution Order:**
+* 1. Request → Global Middlewares → Route Middlewares
+* 2. **Guards (controller-level, then method-level)**
+* 3. Route Handler
+*
+* **Guard Resolution:**
+* - Guard classes are resolved from the request-scoped DI container
+* - Guard instances (from factory functions) are used directly
+*
+* @param guards - Guard classes or instances to apply
+*
+* @example Authentication only
+* ```typescript
+* @Controller('/api/v1/profile')
+* @UseGuards(AuthGuard())
+* export class ProfileController {
+*   show() { } // Requires authentication
+* }
+* ```
+*
+* @example Authentication with permissions
+* ```typescript
+* @Controller('/api/v1/students')
+* @UseGuards(AuthGuard({ scopes: ['students:read'] }))
+* export class StudentsController {
+*   index() { } // Requires 'students:read' permission
+* }
+* ```
+*
+* @example Method-level guards
+* ```typescript
+* @Controller('/api/v1/students')
+* @UseGuards(AuthGuard()) // Controller-level: auth only
+* export class StudentsController {
+*   index() { } // Auth only (inherited)
+*
+*   @UseGuards(AuthGuard({ scopes: ['students:create'] }))
+*   create() { } // Auth + 'students:create' permission
+* }
+* ```
+*
+* @example Multiple guards
+* ```typescript
+* @UseGuards(AuthGuard(), RateLimitGuard(), CustomGuard())
+* export class SecureController {
+*   // All guards must pass
+* }
+* ```
+*/
+function UseGuards(...guards) {
+	return (target, propertyKey) => {
+		const metadata = { guards };
+		if (propertyKey !== void 0) Reflect.defineMetadata(GUARD_METADATA_KEY, metadata, target, propertyKey);
+		else Reflect.defineMetadata(GUARD_METADATA_KEY, metadata, target);
+	};
+}
+/**
+* Get controller-level guard metadata
+*
+* @param target - Controller class
+* @returns Guard metadata or undefined if not decorated
+*/
+function getControllerGuards(target) {
+	return Reflect.getMetadata(GUARD_METADATA_KEY, target);
+}
+/**
+* Get method-level guard metadata
+*
+* @param target - Controller prototype
+* @param propertyKey - Method name
+* @returns Guard metadata or undefined if not decorated
+*/
+function getMethodGuards(target, propertyKey) {
+	return Reflect.getMetadata(GUARD_METADATA_KEY, target, propertyKey);
+}
+//#endregion
+//#region src/guards/guard-execution.service.ts
+/**
+* Guard Execution Service
+*
+* Executes guards for a route and determines if the request should proceed.
+* Guards are executed in order; all must pass for the request to proceed.
+*/
+var GuardExecutionService = class {
+	constructor(logger) {
+		this.logger = logger;
+	}
+	/**
+	* Execute all guards for a route
+	*
+	* @param guards - Array of guards (classes or instances)
+	* @param context - Router context
+	* @param container - Request-scoped DI container
+	* @returns true if all guards pass
+	* @throws Error from first failing guard
+	*/
+	async executeGuards(guards, context, container) {
+		if (guards.length === 0) return true;
+		this.logger.debug("Executing guards", {
+			guardCount: guards.length,
+			path: context.c.req.path,
+			method: context.c.req.method
+		});
+		for (const guard of guards) if (!await this.resolveGuard(guard, container).canActivate(context)) {
+			this.logger.debug("Guard denied access", {
+				guard: guard.constructor?.name || "AnonymousGuard",
+				path: context.c.req.path
+			});
+			return false;
+		}
+		this.logger.debug("All guards passed", {
+			guardCount: guards.length,
+			path: context.c.req.path
+		});
+		return true;
+	}
+	/**
+	* Resolve a guard to an instance
+	*
+	* @param guard - Guard class or instance
+	* @param container - Request-scoped DI container
+	* @returns Guard instance
+	*/
+	resolveGuard(guard, container) {
+		if (this.isGuardInstance(guard)) return guard;
+		return container.resolve(guard);
+	}
+	/**
+	* Type guard to check if value is a guard instance
+	*/
+	isGuardInstance(guard) {
+		return typeof guard === "object" && guard !== null && "canActivate" in guard && typeof guard.canActivate === "function";
+	}
+};
+//#endregion
+export { GUARD_METADATA_KEY as a, getMethodGuards as i, UseGuards as n, getControllerGuards as r, GuardExecutionService as t };
+
+//# sourceMappingURL=guards-B5o618bL.mjs.map

package/dist/guards-B5o618bL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards-B5o618bL.mjs","names":[],"sources":["../src/guards/types.ts","../src/guards/use-guards.decorator.ts","../src/guards/guard-execution.service.ts"],"sourcesContent":["import type { RouterContext } from '../router'\nimport type { Constructor } from '../types'\n\n/**\n * Interface for guards that control access to routes\n *\n * Guards are executed after middlewares but before route handlers.\n * They determine if a request should be allowed to proceed.\n *\n * @example\n * ```typescript\n * class RoleGuard implements CanActivate {\n *   constructor(private readonly role: string) {}\n *\n *   async canActivate(context: RouterContext): Promise<boolean> {\n *     const user = context.getUser()\n *     return user?.roles.includes(this.role) ?? false\n *   }\n * }\n * ```\n */\nexport interface CanActivate {\n  /**\n   * Determine if the request should be allowed\n   *\n   * @param context - Router context with request/response helpers\n   * @returns true to allow, false to deny (throws 403)\n   */\n  canActivate(context: RouterContext): boolean | Promise<boolean>\n}\n\n/**\n * Type for guard class constructors\n */\nexport type GuardClass = Constructor<CanActivate>\n\n/**\n * Guard can be a class constructor or an instance\n * Instances are used for factory-created guards with configuration\n */\nexport type Guard = GuardClass | CanActivate\n\n/**\n * Options for AuthGuard factory\n */\nexport interface AuthGuardOptions {\n  /**\n   * Required permissions (scopes) for authorization\n   * If provided, permission check is performed after authentication.\n   * If omitted, only authentication is required.\n   */\n  scopes?: string[]\n}\n\n/**\n * Metadata stored by `@UseGuards` decorator\n */\nexport interface GuardMetadata {\n  guards: Guard[]\n}\n\n/**\n * Metadata key for guard storage\n */\nexport const GUARD_METADATA_KEY = Symbol.for('stratal:guards')\n","import { GUARD_METADATA_KEY, type Guard, type GuardMetadata } from './types'\n\n/**\n * UseGuards Decorator\n *\n * Applies one or more guards to a controller or method.\n * Guards are executed in order and all must pass for the request to proceed.\n *\n * **Execution Order:**\n * 1. Request → Global Middlewares → Route Middlewares\n * 2. **Guards (controller-level, then method-level)**\n * 3. Route Handler\n *\n * **Guard Resolution:**\n * - Guard classes are resolved from the request-scoped DI container\n * - Guard instances (from factory functions) are used directly\n *\n * @param guards - Guard classes or instances to apply\n *\n * @example Authentication only\n * ```typescript\n * @Controller('/api/v1/profile')\n * @UseGuards(AuthGuard())\n * export class ProfileController {\n *   show() { } // Requires authentication\n * }\n * ```\n *\n * @example Authentication with permissions\n * ```typescript\n * @Controller('/api/v1/students')\n * @UseGuards(AuthGuard({ scopes: ['students:read'] }))\n * export class StudentsController {\n *   index() { } // Requires 'students:read' permission\n * }\n * ```\n *\n * @example Method-level guards\n * ```typescript\n * @Controller('/api/v1/students')\n * @UseGuards(AuthGuard()) // Controller-level: auth only\n * export class StudentsController {\n *   index() { } // Auth only (inherited)\n *\n *   @UseGuards(AuthGuard({ scopes: ['students:create'] }))\n *   create() { } // Auth + 'students:create' permission\n * }\n * ```\n *\n * @example Multiple guards\n * ```typescript\n * @UseGuards(AuthGuard(), RateLimitGuard(), CustomGuard())\n * export class SecureController {\n *   // All guards must pass\n * }\n * ```\n */\nexport function UseGuards(...guards: Guard[]): ClassDecorator & MethodDecorator {\n  return (target: object, propertyKey?: string | symbol) => {\n    const metadata: GuardMetadata = { guards }\n\n    if (propertyKey !== undefined) {\n      // Method decorator - store on method\n      Reflect.defineMetadata(GUARD_METADATA_KEY, metadata, target, propertyKey)\n    } else {\n      // Class decorator - store on class\n      Reflect.defineMetadata(GUARD_METADATA_KEY, metadata, target)\n    }\n  }\n}\n\n/**\n * Get controller-level guard metadata\n *\n * @param target - Controller class\n * @returns Guard metadata or undefined if not decorated\n */\nexport function getControllerGuards(target: object): GuardMetadata | undefined {\n  return Reflect.getMetadata(GUARD_METADATA_KEY, target) as GuardMetadata | undefined\n}\n\n/**\n * Get method-level guard metadata\n *\n * @param target - Controller prototype\n * @param propertyKey - Method name\n * @returns Guard metadata or undefined if not decorated\n */\nexport function getMethodGuards(target: object, propertyKey: string | symbol): GuardMetadata | undefined {\n  return Reflect.getMetadata(GUARD_METADATA_KEY, target, propertyKey) as GuardMetadata | undefined\n}\n","import type { Container } from '../di'\nimport type { LoggerService } from '../logger'\nimport type { RouterContext } from '../router'\nimport type { CanActivate, Guard } from './types'\n\n/**\n * Guard Execution Service\n *\n * Executes guards for a route and determines if the request should proceed.\n * Guards are executed in order; all must pass for the request to proceed.\n */\nexport class GuardExecutionService {\n  constructor(private readonly logger: LoggerService) { }\n\n  /**\n   * Execute all guards for a route\n   *\n   * @param guards - Array of guards (classes or instances)\n   * @param context - Router context\n   * @param container - Request-scoped DI container\n   * @returns true if all guards pass\n   * @throws Error from first failing guard\n   */\n  async executeGuards(\n    guards: Guard[],\n    context: RouterContext,\n    container: Container\n  ): Promise<boolean> {\n    if (guards.length === 0) {\n      return true\n    }\n\n    this.logger.debug('Executing guards', {\n      guardCount: guards.length,\n      path: context.c.req.path,\n      method: context.c.req.method,\n    })\n\n    for (const guard of guards) {\n      const guardInstance = this.resolveGuard(guard, container)\n      const canActivate = await guardInstance.canActivate(context)\n\n      if (!canActivate) {\n        this.logger.debug('Guard denied access', {\n          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- guard.constructor may be null at runtime\n          guard: guard.constructor?.name || 'AnonymousGuard',\n          path: context.c.req.path,\n        })\n        return false\n      }\n    }\n\n    this.logger.debug('All guards passed', {\n      guardCount: guards.length,\n      path: context.c.req.path,\n    })\n\n    return true\n  }\n\n  /**\n   * Resolve a guard to an instance\n   *\n   * @param guard - Guard class or instance\n   * @param container - Request-scoped DI container\n   * @returns Guard instance\n   */\n  private resolveGuard(guard: Guard, container: Container): CanActivate {\n    // If already an instance (has canActivate method), use directly\n    if (this.isGuardInstance(guard)) {\n      return guard\n    }\n\n    // Otherwise, resolve from container\n    return container.resolve<CanActivate>(guard)\n  }\n\n  /**\n   * Type guard to check if value is a guard instance\n   */\n  private isGuardInstance(guard: Guard): guard is CanActivate {\n    return (\n      typeof guard === 'object' &&\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typeof null === 'object', null check is required\n      guard !== null &&\n      'canActivate' in guard &&\n      typeof guard.canActivate === 'function'\n    )\n  }\n}\n"],"mappings":";;;;AAgEA,MAAa,qBAAqB,OAAO,IAAI,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACP9D,SAAgB,UAAU,GAAG,QAAmD;AAC9E,SAAQ,QAAgB,gBAAkC;EACxD,MAAM,WAA0B,EAAE,QAAQ;AAE1C,MAAI,gBAAgB,KAAA,EAElB,SAAQ,eAAe,oBAAoB,UAAU,QAAQ,YAAY;MAGzE,SAAQ,eAAe,oBAAoB,UAAU,OAAO;;;;;;;;;AAWlE,SAAgB,oBAAoB,QAA2C;AAC7E,QAAO,QAAQ,YAAY,oBAAoB,OAAO;;;;;;;;;AAUxD,SAAgB,gBAAgB,QAAgB,aAAyD;AACvG,QAAO,QAAQ,YAAY,oBAAoB,QAAQ,YAAY;;;;;;;;;;AC9ErE,IAAa,wBAAb,MAAmC;CACjC,YAAY,QAAwC;AAAvB,OAAA,SAAA;;;;;;;;;;;CAW7B,MAAM,cACJ,QACA,SACA,WACkB;AAClB,MAAI,OAAO,WAAW,EACpB,QAAO;AAGT,OAAK,OAAO,MAAM,oBAAoB;GACpC,YAAY,OAAO;GACnB,MAAM,QAAQ,EAAE,IAAI;GACpB,QAAQ,QAAQ,EAAE,IAAI;GACvB,CAAC;AAEF,OAAK,MAAM,SAAS,OAIlB,KAAI,CAFgB,MADE,KAAK,aAAa,OAAO,UAAU,CACjB,YAAY,QAAQ,EAE1C;AAChB,QAAK,OAAO,MAAM,uBAAuB;IAEvC,OAAO,MAAM,aAAa,QAAQ;IAClC,MAAM,QAAQ,EAAE,IAAI;IACrB,CAAC;AACF,UAAO;;AAIX,OAAK,OAAO,MAAM,qBAAqB;GACrC,YAAY,OAAO;GACnB,MAAM,QAAQ,EAAE,IAAI;GACrB,CAAC;AAEF,SAAO;;;;;;;;;CAUT,aAAqB,OAAc,WAAmC;AAEpE,MAAI,KAAK,gBAAgB,MAAM,CAC7B,QAAO;AAIT,SAAO,UAAU,QAAqB,MAAM;;;;;CAM9C,gBAAwB,OAAoC;AAC1D,SACE,OAAO,UAAU,YAEjB,UAAU,QACV,iBAAiB,SACjB,OAAO,MAAM,gBAAgB"}

package/dist/i18n/index.d.mts

@@ -0,0 +1,3 @@
+import { $ as I18nModuleOptions, J as TranslationMissingError, Q as I18nModule, X as setupI18nCompiler, Y as LocaleNotSupportedError, Z as I18N_TOKENS, _n as Messages, bn as messages, et as ResolvedI18nOptions, q as LocaleExtractionMiddleware, tt as resolveI18nOptions, u as I18nContextMiddleware, vn as getLocales, yn as getMessages } from "../index-C9bIk5tt.mjs";
+import { _ as II18nService, b as SystemMessageKeys, g as DeepKeys, h as AppMessages, m as AppMessageKeys, v as MessageKeys, y as MessageParams } from "../index-Dl4RvzNp.mjs";
+export { AppMessageKeys, AppMessages, DeepKeys, I18N_TOKENS, I18nContextMiddleware, I18nModule, I18nModuleOptions, II18nService, LocaleExtractionMiddleware, LocaleNotSupportedError, MessageKeys, MessageParams, Messages, ResolvedI18nOptions, SystemMessageKeys, TranslationMissingError, getLocales, getMessages, messages, resolveI18nOptions, setupI18nCompiler };

package/dist/i18n/index.mjs

@@ -0,0 +1,11 @@
+import { o as I18N_TOKENS } from "../errors-BRJgVd5-.mjs";
+import "../logger-Bg-CuidS.mjs";
+import "../module-Dvzm4dhS.mjs";
+import "../events-CQyvSyrQ.mjs";
+import "../middleware-B3tx1u1K.mjs";
+import "../router-context-DlTxpJUG.mjs";
+import "../validation-DA5nptIp.mjs";
+import { A as LocaleNotSupportedError, F as messages, M as setupI18nCompiler, N as getLocales, P as getMessages, R as LocaleExtractionMiddleware, j as resolveI18nOptions, k as TranslationMissingError, t as I18nModule, z as I18nContextMiddleware } from "../i18n.module-C9wQr_2k.mjs";
+import "../guards-B5o618bL.mjs";
+import "../gateway-context-D7TFPLi5.mjs";
+export { I18N_TOKENS, I18nContextMiddleware, I18nModule, LocaleExtractionMiddleware, LocaleNotSupportedError, TranslationMissingError, getLocales, getMessages, messages, resolveI18nOptions, setupI18nCompiler };

package/dist/i18n/messages/en/index.d.mts

@@ -0,0 +1,2 @@
+import { a as errors, i as emails, n as zodI18n, o as common, r as validation } from "../../../index-BWEwA_XK.mjs";
+export { common, emails, errors, validation, zodI18n };

package/dist/i18n/messages/en/index.mjs

@@ -0,0 +1,2 @@
+import { a as errors, i as emails, n as zodI18n, o as common, r as validation } from "../../../en-C9U5-ETs.mjs";
+export { common, emails, errors, validation, zodI18n };

package/dist/i18n/validation/index.d.mts

@@ -0,0 +1,4 @@
+import { c as runWithErrorMapContext, d as LocaleProvider, f as ZodCustomIssue, i as ZodError, l as ErrorMapContext, n as OpenAPIObject, o as z, p as withI18n, r as PathItemObject, s as backendErrorMap, t as OpenAPIHono, u as I18nErrorMetadata } from "../../index-Dl4RvzNp.mjs";
+export * from "@hono/zod-openapi";
+export * from "zod";
+export { ErrorMapContext, I18nErrorMetadata, LocaleProvider, OpenAPIHono, OpenAPIObject, PathItemObject, ZodCustomIssue, ZodError, backendErrorMap, runWithErrorMapContext, withI18n, z };

package/dist/i18n/validation/index.mjs

@@ -0,0 +1,3 @@
+import { a as withI18n, i as z, n as ZodError, o as backendErrorMap, s as runWithErrorMapContext, t as OpenAPIHono } from "../../validation-DA5nptIp.mjs";
+export * from "@hono/zod-openapi";
+export { OpenAPIHono, ZodError, backendErrorMap, runWithErrorMapContext, withI18n, z };