stratal 0.0.20 → 0.0.22

package/dist/exception-context-B4kM-M53.mjs

@@ -0,0 +1,429 @@
+import { a as ContainerError, o as ROUTER_TOKENS } from "./di-BO1QIb5H.mjs";
+import { t as Macroable } from "./macroable-DzlfzT50.mjs";
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { stream, streamSSE, streamText } from "hono/streaming";
+//#region src/router/constants.ts
+/**
+* Type-safe context keys for Hono router variables
+* Using symbols to avoid string collisions
+*/
+const ROUTER_CONTEXT_KEYS = {
+	REQUEST_CONTAINER: "requestContainer",
+	LOCALE: "locale"
+};
+/**
+* Metadata keys for storing route and controller configuration
+* Using symbols to avoid collisions with other decorators
+*/
+const ROUTE_METADATA_KEYS = {
+	CONTROLLER_ROUTE: Symbol.for("stratal:controller:route"),
+	CONTROLLER_OPTIONS: Symbol.for("stratal:controller:options"),
+	CONTROLLER_MIDDLEWARES: Symbol.for("stratal:controller:middlewares"),
+	ROUTE_CONFIG: Symbol.for("stratal:route:config"),
+	DECORATED_METHODS: Symbol.for("stratal:decorated:methods"),
+	AUTH_GUARD: Symbol.for("stratal:auth:guard"),
+	GATEWAY_MARKER: Symbol.for("stratal:gateway:marker"),
+	WS_ON_MESSAGE: Symbol.for("stratal:ws:on-message"),
+	WS_ON_CLOSE: Symbol.for("stratal:ws:on-close"),
+	WS_ON_ERROR: Symbol.for("stratal:ws:on-error"),
+	RATE_LIMIT: Symbol.for("stratal:route:rate-limit")
+};
+/**
+* Security scheme identifiers for OpenAPI
+* These reference the security scheme definitions in security.schemas.ts
+*/
+const SECURITY_SCHEMES = {
+	BEARER_AUTH: "bearerAuth",
+	API_KEY: "apiKey",
+	SESSION_COOKIE: "sessionCookie"
+};
+/**
+* HTTP method mapping for RESTful controller methods
+* Maps controller method names to HTTP verbs and path patterns
+*/
+const HTTP_METHODS = {
+	index: {
+		method: "get",
+		path: ""
+	},
+	show: {
+		method: "get",
+		path: "/:id"
+	},
+	create: {
+		method: "post",
+		path: ""
+	},
+	update: {
+		method: "put",
+		path: "/:id"
+	},
+	patch: {
+		method: "patch",
+		path: "/:id"
+	},
+	destroy: {
+		method: "delete",
+		path: "/:id"
+	}
+};
+/**
+* Default success status codes for RESTful controller methods
+* Used by @Route() decorator to auto-derive response status
+*/
+const METHOD_STATUS_CODES = {
+	index: 200,
+	show: 200,
+	create: 201,
+	update: 200,
+	patch: 200,
+	destroy: 200
+};
+/**
+* Sentinel symbol to opt a controller out of versioning.
+* When used as the version, no prefix is applied even when defaultVersion is set.
+*/
+const VERSION_NEUTRAL = Symbol.for("stratal:version:neutral");
+/**
+* Default content type for request bodies and responses
+*/
+const DEFAULT_CONTENT_TYPE = "application/json";
+//#endregion
+//#region src/router/router-context.ts
+/**
+* Router context wrapper with helper methods
+*
+* Provides convenient access to Hono's context and common request/response operations.
+* The native Hono context is available via the `c` property for advanced use cases.
+*
+* @example
+* ```typescript
+* async index(ctx: RouterContext): Promise<Response> {
+*   // Use helper methods
+*   const users = await this.service.findAll()
+*   return ctx.json(users)
+* }
+*
+* async show(ctx: RouterContext): Promise<Response> {
+*   // Access route params
+*   const id = ctx.param('id')
+*   const user = await this.service.findById(id)
+*   return ctx.json(user)
+* }
+*
+* async create(ctx: RouterContext): Promise<Response> {
+*   // Parse request body
+*   const body = await ctx.body<CreateUserInput>()
+*   const user = await this.service.create(body)
+*   return ctx.json(user, 201)
+* }
+* ```
+*/
+var RouterContext = class extends Macroable {
+	c;
+	/**
+	* Native Hono context
+	* Access for advanced use cases not covered by helper methods
+	*/
+	constructor(c) {
+		super();
+		this.c = c;
+	}
+	/**
+	* Cloudflare-provided request properties (geo, TLS, bot management, etc.).
+	* Always available on Cloudflare Workers requests via `c.req.raw.cf`.
+	*/
+	get cf() {
+		return this.c.req.raw.cf;
+	}
+	/**
+	* Get request-scoped DI container
+	* Contains request-specific services and context (AuthContext)
+	*
+	* @throws Error if container not initialized
+	*/
+	getContainer() {
+		const container = this.c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER);
+		if (!container) throw new ContainerError("Request container has not been initialized");
+		return container;
+	}
+	/**
+	* Set locale for the current request
+	*
+	* @param locale - Locale code (e.g., 'en', 'fr')
+	*/
+	setLocale(locale) {
+		this.c.set(ROUTER_CONTEXT_KEYS.LOCALE, locale);
+	}
+	/**
+	* Get locale for the current request
+	*
+	* @returns Current locale code
+	*/
+	getLocale() {
+		return this.c.get(ROUTER_CONTEXT_KEYS.LOCALE) || "en";
+	}
+	/**
+	* Return JSON response
+	*
+	* When data is null, automatically returns 204 No Content (configurable via status param).
+	*
+	* @param data - Data to serialize as JSON, or null for 204
+	* @param status - HTTP status code (default: 200, or 204 when data is null)
+	*/
+	json(data, status) {
+		if (data === null) return this.c.body(null, status ?? 204);
+		return this.c.json(data, status);
+	}
+	param(key) {
+		const all = this.c.req.valid("param") ?? {};
+		return key === void 0 ? all : all[key];
+	}
+	/**
+	* Get query parameter value
+	*
+	* @param key - Query parameter name
+	*/
+	query(key) {
+		const validated = this.c.req.valid("query");
+		return key ? validated[key] : validated;
+	}
+	/**
+	* Get request header value
+	*
+	* @param name - Header name (case-insensitive)
+	*/
+	header(name) {
+		return this.c.req.header(name);
+	}
+	/**
+	* Read a cookie value from the current request.
+	*
+	* @param name - Cookie name
+	* @returns The cookie value, or `undefined` if the cookie is not present
+	*
+	* @example
+	* ```typescript
+	* const redirectTo = ctx.getCookie('redirectTo')
+	* ```
+	*/
+	getCookie(name) {
+		return getCookie(this.c, name);
+	}
+	/**
+	* Set a cookie on the response.
+	*
+	* Cookie operations must run while the response is mutable — call this
+	* before returning the final `Response` from the handler.
+	*
+	* @param name - Cookie name
+	* @param value - Cookie value
+	* @param options - Cookie attributes (httpOnly, secure, sameSite, path, etc.)
+	*
+	* @example
+	* ```typescript
+	* ctx.setCookie('redirectTo', '/app/', {
+	*   httpOnly: true,
+	*   secure: true,
+	*   sameSite: 'lax',
+	*   path: '/',
+	* })
+	* ```
+	*/
+	setCookie(name, value, options) {
+		setCookie(this.c, name, value, options);
+	}
+	/**
+	* Delete a cookie from the response.
+	*
+	* Pass the same `path` and `domain` options that were used when the cookie
+	* was set, otherwise the browser will not clear the matching cookie.
+	*
+	* @param name - Cookie name
+	* @param options - Cookie attributes used at set time (path, domain, etc.)
+	* @returns The deleted cookie's previous value, or `undefined`
+	*
+	* @example
+	* ```typescript
+	* ctx.deleteCookie('redirectTo', { path: '/' })
+	* ```
+	*/
+	deleteCookie(name, options) {
+		return deleteCookie(this.c, name, options);
+	}
+	/**
+	* Get validated request body from OpenAPI route
+	* Returns pre-validated data that has passed schema validation
+	*
+	* @returns Validated JSON body
+	*/
+	body() {
+		return this.c.req.valid("json");
+	}
+	/**
+	* Return text response
+	*
+	* @param text - Text content
+	* @param status - HTTP status code (default: 200)
+	*/
+	text(text, status) {
+		return this.c.text(text, status);
+	}
+	/**
+	* Return HTML response
+	*
+	* @param html - HTML content
+	* @param status - HTTP status code (default: 200)
+	*/
+	html(html, status) {
+		return this.c.html(html, status);
+	}
+	/**
+	* Generate a URL from a named route.
+	*
+	* Keys matching `:param` placeholders fill the path.
+	* Domain params are consumed from the same object.
+	* Extra keys become query string parameters.
+	*
+	* @param name - Named route identifier
+	* @param params - Route params + domain params + extra query params
+	* @param options - URL generation options (e.g., `{ absolute: true }`)
+	*
+	* @example
+	* ```typescript
+	* ctx.route('users.show', { id: '1' })           // '/v1/users/1'
+	* ctx.route('users.show', { id: '1', q: 'test' }) // '/v1/users/1?q=test'
+	* ```
+	*/
+	route(name, params, options) {
+		return this.resolveUri().route(name, params, options);
+	}
+	/**
+	* Get a domain parameter value from the current request.
+	* Domain params are set by the domain matching middleware.
+	*
+	* @param key - Domain parameter name (e.g., 'tenant' from '{tenant}.myapp.com')
+	*
+	* @example
+	* ```typescript
+	* const tenant = ctx.domain('tenant')
+	* ```
+	*/
+	domain(key) {
+		return this.c.get(`domain:${key}`);
+	}
+	/**
+	* Generate a signed URL from a named route.
+	*
+	* @param name - Named route identifier
+	* @param params - Route params (same as route())
+	* @param options - Signing options (e.g., expiresIn) and URL options
+	* @returns Signed URL string with signature query param
+	*/
+	async signedUrl(name, params, options) {
+		return this.resolveUri().signedRoute(name, params, options);
+	}
+	/**
+	* Check if the current request has a valid signature.
+	*
+	* @returns true if the URL signature is valid and not expired
+	*/
+	async hasValidSignature() {
+		return this.resolveUri().hasValidSignature();
+	}
+	/**
+	* Redirect to another URL
+	*
+	* @param url - Target URL
+	* @param status - HTTP status code (default: 302)
+	*/
+	redirect(url, status) {
+		return this.c.redirect(url, status);
+	}
+	/**
+	* Return a streaming response (binary/generic)
+	*
+	* @param callback - Async function that writes to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	stream(callback, onError) {
+		return stream(this.c, callback, onError);
+	}
+	/**
+	* Return a streaming text response
+	*
+	* Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+	*
+	* @param callback - Async function that writes text to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	streamText(callback, onError) {
+		this.c.header("Content-Encoding", "Identity");
+		return streamText(this.c, callback, onError);
+	}
+	/**
+	* Return a Server-Sent Events (SSE) streaming response
+	*
+	* Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.
+	*
+	* @param callback - Async function that writes SSE events to the stream
+	* @param onError - Optional error handler called if an error occurs during streaming
+	*/
+	streamSSE(callback, onError) {
+		this.c.header("Content-Encoding", "Identity");
+		return streamSSE(this.c, callback, onError);
+	}
+	resolveUri() {
+		return this.getContainer().resolve(ROUTER_TOKENS.Uri);
+	}
+};
+//#endregion
+//#region src/errors/exception-context.ts
+/**
+* Create an HTTP exception context from a Hono context.
+*
+* @param c - The raw Hono context from the request
+* @returns An {@link HttpExceptionContext} wrapping a RouterContext
+*/
+function createHttpExceptionContext(c) {
+	return {
+		type: "http",
+		ctx: new RouterContext(c)
+	};
+}
+/**
+* Create a queue exception context.
+*
+* @param queueName - The name of the queue being processed
+* @returns A {@link QueueExceptionContext}
+*/
+function createQueueExceptionContext(queueName) {
+	return {
+		type: "queue",
+		queueName
+	};
+}
+/**
+* Create a cron exception context.
+*
+* @returns A {@link CronExceptionContext}
+*/
+function createCronExceptionContext() {
+	return { type: "cron" };
+}
+/**
+* Create a CLI command exception context.
+*
+* @param commandName - The name of the command that threw
+* @returns A {@link CliExceptionContext}
+*/
+function createCliExceptionContext(commandName) {
+	return {
+		type: "cli",
+		commandName
+	};
+}
+//#endregion
+export { RouterContext as a, METHOD_STATUS_CODES as c, SECURITY_SCHEMES as d, VERSION_NEUTRAL as f, createQueueExceptionContext as i, ROUTER_CONTEXT_KEYS as l, createCronExceptionContext as n, DEFAULT_CONTENT_TYPE as o, createHttpExceptionContext as r, HTTP_METHODS as s, createCliExceptionContext as t, ROUTE_METADATA_KEYS as u };
+
+//# sourceMappingURL=exception-context-B4kM-M53.mjs.map

package/dist/exception-context-B4kM-M53.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception-context-B4kM-M53.mjs","names":["honoGetCookie","honoDeleteCookie","honoStream","honoStreamText","honoStreamSSE"],"sources":["../src/router/constants.ts","../src/router/router-context.ts","../src/errors/exception-context.ts"],"sourcesContent":["/**\n * Type-safe context keys for Hono router variables\n * Using symbols to avoid string collisions\n */\nexport const ROUTER_CONTEXT_KEYS = {\n  REQUEST_CONTAINER: 'requestContainer',\n  LOCALE: 'locale'\n} as const satisfies Record<string, string>\n\n/**\n * Metadata keys for storing route and controller configuration\n * Using symbols to avoid collisions with other decorators\n */\nexport const ROUTE_METADATA_KEYS = {\n  CONTROLLER_ROUTE: Symbol.for('stratal:controller:route'),\n  CONTROLLER_OPTIONS: Symbol.for('stratal:controller:options'),\n  CONTROLLER_MIDDLEWARES: Symbol.for('stratal:controller:middlewares'),\n  ROUTE_CONFIG: Symbol.for('stratal:route:config'),\n  DECORATED_METHODS: Symbol.for('stratal:decorated:methods'),\n  AUTH_GUARD: Symbol.for('stratal:auth:guard'),\n  GATEWAY_MARKER: Symbol.for('stratal:gateway:marker'),\n  WS_ON_MESSAGE: Symbol.for('stratal:ws:on-message'),\n  WS_ON_CLOSE: Symbol.for('stratal:ws:on-close'),\n  WS_ON_ERROR: Symbol.for('stratal:ws:on-error'),\n  RATE_LIMIT: Symbol.for('stratal:route:rate-limit'),\n} as const\n\n/**\n * Security scheme identifiers for OpenAPI\n * These reference the security scheme definitions in security.schemas.ts\n */\nexport const SECURITY_SCHEMES = {\n  BEARER_AUTH: 'bearerAuth',\n  API_KEY: 'apiKey',\n  SESSION_COOKIE: 'sessionCookie'\n} as const\n\n/**\n * HTTP method mapping for RESTful controller methods\n * Maps controller method names to HTTP verbs and path patterns\n */\nexport const HTTP_METHODS = {\n  index: { method: 'get', path: '' } as const,\n  show: { method: 'get', path: '/:id' } as const,\n  create: { method: 'post', path: '' } as const,\n  update: { method: 'put', path: '/:id' } as const,\n  patch: { method: 'patch', path: '/:id' } as const,\n  destroy: { method: 'delete', path: '/:id' } as const\n} as const\n\n/**\n * Default success status codes for RESTful controller methods\n * Used by @Route() decorator to auto-derive response status\n */\nexport const METHOD_STATUS_CODES = {\n  index: 200,\n  show: 200,\n  create: 201,\n  update: 200,\n  patch: 200,\n  destroy: 200\n} as const\n\n/**\n * Sentinel symbol to opt a controller out of versioning.\n * When used as the version, no prefix is applied even when defaultVersion is set.\n */\nexport const VERSION_NEUTRAL = Symbol.for('stratal:version:neutral')\n\n/**\n * Default content type for request bodies and responses\n */\nexport const DEFAULT_CONTENT_TYPE = 'application/json'\n","import type { Context } from 'hono'\nimport {\n  deleteCookie as honoDeleteCookie,\n  getCookie as honoGetCookie,\n  setCookie as honoSetCookie,\n} from 'hono/cookie'\nimport type { SSEStreamingApi } from 'hono/streaming'\nimport { stream as honoStream, streamSSE as honoStreamSSE, streamText as honoStreamText } from 'hono/streaming'\nimport type { CookieOptions } from 'hono/utils/cookie'\nimport type { ContentfulStatusCode, RedirectStatusCode } from 'hono/utils/http-status'\nimport type { StreamingApi } from 'hono/utils/stream'\nimport type { Container } from '../di/container'\nimport { ContainerError } from '../di/container.error'\nimport { Macroable } from '../macroable'\nimport { ROUTER_CONTEXT_KEYS } from './constants'\nimport type { RouteName, RouteParams } from './route-map'\nimport { ROUTER_TOKENS } from './router.tokens'\nimport type { RouterEnv } from './types'\nimport type { SignedUriOptions, Uri, UriOptions } from './uri'\n\nexport type ContextQueryResult<R extends Record<string, unknown> | undefined, K extends string | undefined> = K extends string ? string : R extends undefined ? Record<string, unknown> : R\n\n/**\n * Router context wrapper with helper methods\n *\n * Provides convenient access to Hono's context and common request/response operations.\n * The native Hono context is available via the `c` property for advanced use cases.\n *\n * @example\n * ```typescript\n * async index(ctx: RouterContext): Promise<Response> {\n *   // Use helper methods\n *   const users = await this.service.findAll()\n *   return ctx.json(users)\n * }\n *\n * async show(ctx: RouterContext): Promise<Response> {\n *   // Access route params\n *   const id = ctx.param('id')\n *   const user = await this.service.findById(id)\n *   return ctx.json(user)\n * }\n *\n * async create(ctx: RouterContext): Promise<Response> {\n *   // Parse request body\n *   const body = await ctx.body<CreateUserInput>()\n *   const user = await this.service.create(body)\n *   return ctx.json(user, 201)\n * }\n * ```\n */\nexport class RouterContext<T extends RouterEnv = RouterEnv> extends Macroable {\n  /**\n   * Native Hono context\n   * Access for advanced use cases not covered by helper methods\n   */\n  constructor(\n    public readonly c: Context<T>\n  ) {\n    super()\n  }\n\n  /**\n   * Cloudflare-provided request properties (geo, TLS, bot management, etc.).\n   * Always available on Cloudflare Workers requests via `c.req.raw.cf`.\n   */\n  get cf(): CfProperties {\n    return this.c.req.raw.cf!\n  }\n\n  /**\n   * Get request-scoped DI container\n   * Contains request-specific services and context (AuthContext)\n   *\n   * @throws Error if container not initialized\n   */\n  getContainer(): Container {\n    const container = this.c.get(ROUTER_CONTEXT_KEYS.REQUEST_CONTAINER)\n    if (!container) {\n      throw new ContainerError('Request container has not been initialized')\n    }\n    return container as Container\n  }\n\n  /**\n   * Set locale for the current request\n   *\n   * @param locale - Locale code (e.g., 'en', 'fr')\n   */\n  setLocale(locale: string): void {\n    this.c.set(ROUTER_CONTEXT_KEYS.LOCALE, locale)\n  }\n\n  /**\n   * Get locale for the current request\n   *\n   * @returns Current locale code\n   */\n  getLocale(): string {\n    const locale = this.c.get(ROUTER_CONTEXT_KEYS.LOCALE)\n    return (locale as string) || 'en'\n  }\n\n  /**\n   * Return JSON response\n   *\n   * When data is null, automatically returns 204 No Content (configurable via status param).\n   *\n   * @param data - Data to serialize as JSON, or null for 204\n   * @param status - HTTP status code (default: 200, or 204 when data is null)\n   */\n  json(data: object | null, status?: ContentfulStatusCode): Response {\n    if (data === null) {\n      return this.c.body(null, status ?? 204)\n    }\n    return this.c.json(data, status)\n  }\n\n  /**\n   * Get route parameter value(s).\n   *\n   * Reads the validated, Zod-coerced param record from `c.req.valid('param')`,\n   * which is what `@hono/zod-openapi` populates for every route registered\n   * via `app.openapi(...)`. Bare `c.req.param()` returns `undefined` for those\n   * routes — always go through the validated record.\n   *\n   * - With a key → returns the single string value.\n   * - With no args → returns the full `Record<string, string>` (or `{}` when\n   *   the matched route has no path params).\n   *\n   * @param key - Parameter name (e.g., 'id' for /users/:id)\n   */\n  param(): Record<string, string>\n  param(key: string): string\n  param(key?: string): string | Record<string, string> {\n    const all = (this.c.req as unknown as { valid(target: 'param'): Record<string, string> | undefined }).valid('param') ?? {}\n    return key === undefined ? all : all[key]\n  }\n\n  /**\n   * Get query parameter value\n   *\n   * @param key - Query parameter name\n   */\n  query<R extends Record<string, unknown> | undefined = undefined, K extends string | undefined = undefined>(key?: K): ContextQueryResult<R, K> {\n    const validated = (this.c.req as unknown as { valid(target: 'query'): Record<string, unknown> }).valid('query')\n    return key ? validated[key] as ContextQueryResult<R, K> : validated as ContextQueryResult<R, K>\n  }\n\n  /**\n   * Get request header value\n   *\n   * @param name - Header name (case-insensitive)\n   */\n  header(name: string): string | undefined {\n    return this.c.req.header(name)\n  }\n\n  /**\n   * Read a cookie value from the current request.\n   *\n   * @param name - Cookie name\n   * @returns The cookie value, or `undefined` if the cookie is not present\n   *\n   * @example\n   * ```typescript\n   * const redirectTo = ctx.getCookie('redirectTo')\n   * ```\n   */\n  getCookie(name: string): string | undefined {\n    return honoGetCookie(this.c, name)\n  }\n\n  /**\n   * Set a cookie on the response.\n   *\n   * Cookie operations must run while the response is mutable — call this\n   * before returning the final `Response` from the handler.\n   *\n   * @param name - Cookie name\n   * @param value - Cookie value\n   * @param options - Cookie attributes (httpOnly, secure, sameSite, path, etc.)\n   *\n   * @example\n   * ```typescript\n   * ctx.setCookie('redirectTo', '/app/', {\n   *   httpOnly: true,\n   *   secure: true,\n   *   sameSite: 'lax',\n   *   path: '/',\n   * })\n   * ```\n   */\n  setCookie(name: string, value: string, options?: CookieOptions): void {\n    honoSetCookie(this.c, name, value, options)\n  }\n\n  /**\n   * Delete a cookie from the response.\n   *\n   * Pass the same `path` and `domain` options that were used when the cookie\n   * was set, otherwise the browser will not clear the matching cookie.\n   *\n   * @param name - Cookie name\n   * @param options - Cookie attributes used at set time (path, domain, etc.)\n   * @returns The deleted cookie's previous value, or `undefined`\n   *\n   * @example\n   * ```typescript\n   * ctx.deleteCookie('redirectTo', { path: '/' })\n   * ```\n   */\n  deleteCookie(name: string, options?: CookieOptions): string | undefined {\n    return honoDeleteCookie(this.c, name, options)\n  }\n\n  /**\n   * Get validated request body from OpenAPI route\n   * Returns pre-validated data that has passed schema validation\n   *\n   * @returns Validated JSON body\n   */\n  body<T>(): Promise<T> {\n    // Type assertion needed because req.valid() is type-safe per route\n    // but this is a generic helper method that works across all routes\n    return (this.c.req as unknown as { valid(target: 'json'): Promise<T> }).valid('json')\n  }\n\n  /**\n   * Return text response\n   *\n   * @param text - Text content\n   * @param status - HTTP status code (default: 200)\n   */\n  text(text: string, status?: ContentfulStatusCode): Response {\n    return this.c.text(text, status)\n  }\n\n  /**\n   * Return HTML response\n   *\n   * @param html - HTML content\n   * @param status - HTTP status code (default: 200)\n   */\n  html(html: string, status?: ContentfulStatusCode): Response {\n    return this.c.html(html, status)\n  }\n\n  /**\n   * Generate a URL from a named route.\n   *\n   * Keys matching `:param` placeholders fill the path.\n   * Domain params are consumed from the same object.\n   * Extra keys become query string parameters.\n   *\n   * @param name - Named route identifier\n   * @param params - Route params + domain params + extra query params\n   * @param options - URL generation options (e.g., `{ absolute: true }`)\n   *\n   * @example\n   * ```typescript\n   * ctx.route('users.show', { id: '1' })           // '/v1/users/1'\n   * ctx.route('users.show', { id: '1', q: 'test' }) // '/v1/users/1?q=test'\n   * ```\n   */\n  route<N extends RouteName>(name: N, params?: RouteParams<N>, options?: UriOptions): string {\n    return this.resolveUri().route(name, params, options)\n  }\n\n  /**\n   * Get a domain parameter value from the current request.\n   * Domain params are set by the domain matching middleware.\n   *\n   * @param key - Domain parameter name (e.g., 'tenant' from '{tenant}.myapp.com')\n   *\n   * @example\n   * ```typescript\n   * const tenant = ctx.domain('tenant')\n   * ```\n   */\n  domain(key: string): string {\n    return this.c.get(`domain:${key}`) as string\n  }\n\n  /**\n   * Generate a signed URL from a named route.\n   *\n   * @param name - Named route identifier\n   * @param params - Route params (same as route())\n   * @param options - Signing options (e.g., expiresIn) and URL options\n   * @returns Signed URL string with signature query param\n   */\n  async signedUrl<N extends RouteName>(name: N, params?: RouteParams<N>, options?: SignedUriOptions): Promise<string> {\n    return this.resolveUri().signedRoute(name, params, options)\n  }\n\n  /**\n   * Check if the current request has a valid signature.\n   *\n   * @returns true if the URL signature is valid and not expired\n   */\n  async hasValidSignature(): Promise<boolean> {\n    return this.resolveUri().hasValidSignature()\n  }\n\n  /**\n   * Redirect to another URL\n   *\n   * @param url - Target URL\n   * @param status - HTTP status code (default: 302)\n   */\n  redirect(url: string, status?: RedirectStatusCode): Response {\n    return this.c.redirect(url, status)\n  }\n\n  /**\n   * Return a streaming response (binary/generic)\n   *\n   * @param callback - Async function that writes to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  stream(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response {\n    return honoStream(this.c, callback, onError)\n  }\n\n  /**\n   * Return a streaming text response\n   *\n   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.\n   *\n   * @param callback - Async function that writes text to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  streamText(callback: (stream: StreamingApi) => Promise<void>, onError?: (err: Error, stream: StreamingApi) => Promise<void>): Response {\n    this.c.header('Content-Encoding', 'Identity')\n    return honoStreamText(this.c, callback, onError)\n  }\n\n  /**\n   * Return a Server-Sent Events (SSE) streaming response\n   *\n   * Automatically sets `Content-Encoding: Identity` for Cloudflare Workers compatibility.\n   *\n   * @param callback - Async function that writes SSE events to the stream\n   * @param onError - Optional error handler called if an error occurs during streaming\n   */\n  streamSSE(callback: (stream: SSEStreamingApi) => Promise<void>, onError?: (err: Error, stream: SSEStreamingApi) => Promise<void>): Response {\n    this.c.header('Content-Encoding', 'Identity')\n    return honoStreamSSE(this.c, callback, onError)\n  }\n\n  private resolveUri(): Uri {\n    return this.getContainer().resolve<Uri>(ROUTER_TOKENS.Uri)\n  }\n}\n","import type { Context } from 'hono'\nimport { RouterContext } from '../router/router-context'\nimport type { RouterEnv } from '../router/types'\n\n/**\n * Exception context for errors occurring during HTTP request handling.\n *\n * Provides access to the full {@link RouterContext} for building responses\n * with `ctx.json()`, `ctx.text()`, `ctx.html()`, etc.\n */\nexport interface HttpExceptionContext {\n  readonly type: 'http'\n  /** Stratal RouterContext — use for building HTTP responses */\n  readonly ctx: RouterContext\n}\n\n/**\n * Exception context for errors occurring during queue message processing.\n */\nexport interface QueueExceptionContext {\n  readonly type: 'queue'\n  /** Name of the queue being processed */\n  readonly queueName: string\n}\n\n/**\n * Exception context for errors occurring during scheduled cron execution.\n */\nexport interface CronExceptionContext {\n  readonly type: 'cron'\n}\n\n/**\n * Exception context for errors occurring during CLI command execution.\n */\nexport interface CliExceptionContext {\n  readonly type: 'cli'\n  /** Name of the command that threw */\n  readonly commandName: string\n}\n\n/**\n * Discriminated union of all exception context types.\n *\n * Narrow via `ctx.type` to access context-specific properties:\n *\n * @example\n * ```typescript\n * handler.renderable(MyError, (error, ctx) => {\n *   if (ctx.type === 'http') {\n *     return ctx.ctx.json({ message: 'Something went wrong' }, 500)\n *   }\n *   // Non-HTTP contexts: return undefined to use default rendering\n * })\n * ```\n */\nexport type ExceptionContext =\n  | HttpExceptionContext\n  | QueueExceptionContext\n  | CronExceptionContext\n  | CliExceptionContext\n\n/**\n * Create an HTTP exception context from a Hono context.\n *\n * @param c - The raw Hono context from the request\n * @returns An {@link HttpExceptionContext} wrapping a RouterContext\n */\nexport function createHttpExceptionContext(c: Context<RouterEnv>): HttpExceptionContext {\n  return { type: 'http', ctx: new RouterContext(c) }\n}\n\n/**\n * Create a queue exception context.\n *\n * @param queueName - The name of the queue being processed\n * @returns A {@link QueueExceptionContext}\n */\nexport function createQueueExceptionContext(queueName: string): QueueExceptionContext {\n  return { type: 'queue', queueName }\n}\n\n/**\n * Create a cron exception context.\n *\n * @returns A {@link CronExceptionContext}\n */\nexport function createCronExceptionContext(): CronExceptionContext {\n  return { type: 'cron' }\n}\n\n/**\n * Create a CLI command exception context.\n *\n * @param commandName - The name of the command that threw\n * @returns A {@link CliExceptionContext}\n */\nexport function createCliExceptionContext(commandName: string): CliExceptionContext {\n  return { type: 'cli', commandName }\n}\n"],"mappings":"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"}

package/dist/{gateway-context-CdJjpUCW.mjs → gateway-context-CFe6a9gz.mjs}

@@ -1,5 +1,8 @@
-import { H as ApplicationError, f as ROUTE_METADATA_KEYS, k as ERROR_CODES, s as RouterContext } from "./errors-BdyV5PnY.mjs";
-import { t as Controller } from "./controller.decorator-DQzenvSN.mjs";
+import { a as ApplicationError } from "./container-storage-GpNNz79X.mjs";
+import { n as getMetadata, t as defineMetadata } from "./metadata-BVkc4aUu.mjs";
+import "./errors-BBZTnjdq.mjs";
+import { a as RouterContext, u as ROUTE_METADATA_KEYS } from "./exception-context-B4kM-M53.mjs";
+import { t as Controller } from "./controller.decorator-DIUazNU7.mjs";
 //#region src/websocket/decorators/gateway.decorator.ts
 const GATEWAY_MARKER_KEY = ROUTE_METADATA_KEYS.GATEWAY_MARKER;
 /**
@@ -33,7 +36,7 @@ const GATEWAY_MARKER_KEY = ROUTE_METADATA_KEYS.GATEWAY_MARKER;
 function Gateway(route, options) {
 	return function(target) {
 		Controller(route, options)(target);
-		Reflect.defineMetadata(GATEWAY_MARKER_KEY, true, target);
+		defineMetadata(GATEWAY_MARKER_KEY, true, target);
 		return target;
 	};
 }
@@ -44,19 +47,11 @@ function Gateway(route, options) {
 * @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;
+	return getMetadata(GATEWAY_MARKER_KEY, typeof target === "function" ? target : target.constructor) === 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
-		});
-	}
-};
+//#region src/websocket/websocket.error.ts
+var WebSocketError = class extends ApplicationError {};
 //#endregion
 //#region src/websocket/decorators/ws-event.decorator.ts
 const WS_ON_MESSAGE_KEY = ROUTE_METADATA_KEYS.WS_ON_MESSAGE;
@@ -67,9 +62,9 @@ const WS_ON_ERROR_KEY = ROUTE_METADATA_KEYS.WS_ON_ERROR;
 * 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);
+	const existing = getMetadata(key, target);
+	if (existing !== void 0 && existing !== propertyKey) throw new WebSocketError(`Duplicate @${decoratorName} handler: method "${String(existing)}" is already registered`);
+	defineMetadata(key, propertyKey, target);
 }
 /**
 * Marks a method as the WebSocket message handler
@@ -132,28 +127,21 @@ function OnError() {
 * Get the method name decorated with @OnMessage
 */
 function getWsOnMessageMethod(target) {
-	return Reflect.getMetadata(WS_ON_MESSAGE_KEY, target.prototype);
+	return 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);
+	return 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);
+	return 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
@@ -173,6 +161,7 @@ var WebSocketBodyNotAvailableError = class extends ApplicationError {
 * ```
 */
 var GatewayContext = class extends RouterContext {
+	ws;
 	constructor(c, ws) {
 		super(c);
 		this.ws = ws;
@@ -205,13 +194,13 @@ var GatewayContext = class extends RouterContext {
 	/**
 	* Request body is not available in WebSocket gateways
 	*
-	* @throws WebSocketBodyNotAvailableError always — WebSocket upgrade requests do not have a body
+	* @throws WebSocketError always — WebSocket upgrade requests do not have a body
 	*/
 	body() {
-		throw new WebSocketBodyNotAvailableError();
+		throw new WebSocketError("Request body is not available in WebSocket gateways");
 	}
 };
 //#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 };
+export { getWsOnCloseMethod as a, WebSocketError as c, OnMessage as i, Gateway as l, OnClose as n, getWsOnErrorMethod as o, OnError as r, getWsOnMessageMethod as s, GatewayContext as t, isGateway as u };
 
-//# sourceMappingURL=gateway-context-CdJjpUCW.mjs.map
+//# sourceMappingURL=gateway-context-CFe6a9gz.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-context-CFe6a9gz.mjs","names":[],"sources":["../src/websocket/decorators/gateway.decorator.ts","../src/websocket/websocket.error.ts","../src/websocket/decorators/ws-event.decorator.ts","../src/websocket/gateway-context.ts"],"sourcesContent":["import { defineMetadata, getMetadata } from '../../di/metadata'\nimport { ROUTE_METADATA_KEYS } from '../../router/constants'\nimport { Controller } from '../../router/decorators/controller.decorator'\nimport { type Constructor } from '../../types'\nimport type { GatewayOptions } from '../../websocket/types'\n\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    Controller(route, options)(target)\n    defineMetadata(GATEWAY_MARKER_KEY, true, target)\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 getMetadata(GATEWAY_MARKER_KEY, metadataTarget) === true\n}\n","import { ApplicationError } from '../errors'\n\nexport class WebSocketError extends ApplicationError {}\n","import { defineMetadata, getMetadata } from '../../di/metadata'\nimport { ROUTE_METADATA_KEYS } from '../../router/constants'\nimport type { Constructor } from '../../types'\nimport { WebSocketError } from '../websocket.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: symbol, propertyKey: string | symbol, target: object, decoratorName: string): void {\n  const existing = getMetadata<string | symbol>(key, target)\n  if (existing !== undefined && existing !== propertyKey) {\n    throw new WebSocketError(`Duplicate @${decoratorName} handler: method \"${String(existing)}\" is already registered`)\n  }\n  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 getMetadata<string>(WS_ON_MESSAGE_KEY, target.prototype as object)\n}\n\n/**\n * Get the method name decorated with @OnClose\n */\nexport function getWsOnCloseMethod(target: Constructor): string | undefined {\n  return getMetadata<string>(WS_ON_CLOSE_KEY, target.prototype as object)\n}\n\n/**\n * Get the method name decorated with @OnError\n */\nexport function getWsOnErrorMethod(target: Constructor): string | undefined {\n  return getMetadata<string>(WS_ON_ERROR_KEY, target.prototype as object)\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 { WebSocketError } from './websocket.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(s) from the raw request — WebSocket gateways are\n   * not OpenAPI-registered, so reads come straight from Hono's matcher.\n   *\n   * - With a key → single string value.\n   * - With no args → full `Record<string, string>` (or `{}` when none).\n   *\n   * @param key - Parameter name (e.g., 'id' for /ws/chat/:id)\n   */\n  override param(): Record<string, string>\n  override param(key: string): string\n  override param(key?: string): string | Record<string, string> {\n    if (key === undefined) return this.c.req.param() ?? {}\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 WebSocketError always — WebSocket upgrade requests do not have a body\n   */\n  override body<T>(): Promise<T> {\n    throw new WebSocketError('Request body is not available in WebSocket gateways')\n  }\n}\n"],"mappings":";;;;;;AAMA,MAAM,qBAAqB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B/C,SAAgB,QAAQ,OAAe,SAA0B;CAC/D,OAAO,SAAiC,QAAW;EACjD,WAAW,OAAO,QAAQ,CAAC,OAAO;EAClC,eAAe,oBAAoB,MAAM,OAAO;EAChD,OAAO;;;;;;;;;AAUX,SAAgB,UAAU,QAAyB;CAEjD,OAAO,YAAY,oBADI,OAAO,WAAW,aAAa,SAAU,OAAmC,YAC7C,KAAK;;;;AClD7D,IAAa,iBAAb,cAAoC,iBAAiB;;;ACGrD,MAAM,oBAAoB,oBAAoB;AAC9C,MAAM,kBAAkB,oBAAoB;AAC5C,MAAM,kBAAkB,oBAAoB;;;;;AAM5C,SAAS,4BAA4B,KAAa,aAA8B,QAAgB,eAA6B;CAC3H,MAAM,WAAW,YAA6B,KAAK,OAAO;CAC1D,IAAI,aAAa,KAAA,KAAa,aAAa,aACzC,MAAM,IAAI,eAAe,cAAc,cAAc,oBAAoB,OAAO,SAAS,CAAC,yBAAyB;CAErH,eAAe,KAAK,aAAa,OAAO;;;;;;;;;;;;;;;;AAiB1C,SAAgB,YAA6B;CAG3C,QAAQ,SAAiB,gBAAiC;EACxD,4BAA4B,mBAAmB,aAAa,SAAS,YAAY;;;;;;;;;;;;;;;;;AAkBrF,SAAgB,UAA2B;CACzC,QAAQ,SAAiB,gBAAiC;EACxD,4BAA4B,iBAAiB,aAAa,SAAS,UAAU;;;;;;;;;;;;;;;;;AAkBjF,SAAgB,UAA2B;CACzC,QAAQ,SAAiB,gBAAiC;EACxD,4BAA4B,iBAAiB,aAAa,SAAS,UAAU;;;;;;AAOjF,SAAgB,qBAAqB,QAAyC;CAC5E,OAAO,YAAoB,mBAAmB,OAAO,UAAoB;;;;;AAM3E,SAAgB,mBAAmB,QAAyC;CAC1E,OAAO,YAAoB,iBAAiB,OAAO,UAAoB;;;;;AAMzE,SAAgB,mBAAmB,QAAyC;CAC1E,OAAO,YAAoB,iBAAiB,OAAO,UAAoB;;;;;;;;;;;;;;;;;;;;;AC7EzE,IAAa,iBAAb,cAAoC,cAAc;CACG;CAAnD,YAAY,GAAuB,IAA+B;EAChE,MAAM,EAAE;EADyC,KAAA,KAAA;;;CAKnD,KAAK,MAA4D;EAC/D,KAAK,GAAG,KAAK,KAAK;;;CAIpB,MAAM,MAAe,QAAuB;EAC1C,KAAK,GAAG,MAAM,MAAM,OAAO;;;CAI7B,IAAI,aAA2B;EAC7B,OAAO,KAAK,GAAG;;CAcjB,MAAe,KAA+C;EAC5D,IAAI,QAAQ,KAAA,GAAW,OAAO,KAAK,EAAE,IAAI,OAAO,IAAI,EAAE;EACtD,OAAO,KAAK,EAAE,IAAI,MAAM,IAAI;;;;;;;CAQ9B,MAAoH,KAAmC;EACrJ,IAAI,KACF,OAAO,KAAK,EAAE,IAAI,MAAM,IAAI;EAE9B,OAAO,KAAK,EAAE,IAAI,OAAO;;;;;;;CAQ3B,OAA+B;EAC7B,MAAM,IAAI,eAAe,sDAAsD"}

package/dist/guards/index.d.mts

@@ -1,6 +1,6 @@
-import { Dr as Container, V as RouterContext } from "../index-D0US0X14.mjs";
-import { t as Constructor } from "../types-cySNS_lp.mjs";
-import { i as LoggerService } from "../index-DBd_2wv8.mjs";
+import { Y as Container, rt as RouterContext } from "../index-DEncMcC6.mjs";
+import { r as LoggerService } from "../index-BtlE9RuO.mjs";
+import { t as Constructor } from "../types-BaeHi67f.mjs";
 
 //#region src/guards/types.d.ts
 /**

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

@@ -1 +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;EAmBA;;;;AAKjB;;EAjBE,WAAA,CAAY,OAAA,EAAS,aAAA,aAA0B,OAAA;AAAA;;AAsCjD;;KAhCY,UAAA,GAAa,WAAA,CAAY,WAAA;;;AAuCrC;;KAjCY,KAAA,GAAQ,UAAA,GAAa,WAAA;;;;UAKhB,gBAAA;;ACYjB;;;;;;;;;;;;;EDGE,WAAA;AAAA;;;;UAMe,aAAA;EACf,MAAA,EAAQ,KAAA;AAAA;;;;cAMG,kBAAA;;;;;;;AApDb;;;;;;;;;;AAaA;;;;;AAMA;;;;;AAKA;;;;;AAqBA;;;;;AAOA;;;;;;;;AChBA;;;;;;;;;;;;;iBAAgB,SAAA,CAAA,GAAa,MAAA,EAAQ,KAAA,KAAU,cAAA,GAAiB,eAAA;AAoBhE;;;;;AAWA;AAXA,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;EFgBiB;;AAMxD;;;;;AAMA;;EEjBQ,aAAA,CACJ,MAAA,EAAQ,KAAA,IACR,OAAA,EAAS,aAAA,EACT,SAAA,EAAW,SAAA,GACV,OAAA;EFae;;AAKpB;;;;;EALoB,QE2BV,YAAA;EFDoB;;;EAAA,QEcpB,eAAA;AAAA"}
+{"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;EAmBA;;;;AAKjB;;EAjBE,WAAA,CAAY,OAAA,EAAS,aAAA,aAA0B,OAAA;AAAA;;AAsCjD;;KAhCY,UAAA,GAAa,WAAA,CAAY,WAAA;;;AAuCrC;;KAjCY,KAAA,GAAQ,UAAA,GAAa,WAAA;;;;UAKhB,gBAAA;;ACajB;;;;;;;;;;;;;EDEE,WAAA;AAAA;;;;UAMe,aAAA;EACf,MAAA,EAAQ,KAAA;AAAA;;;;cAMG,kBAAA;;;;;;;AApDb;;;;;;;;;;AAaA;;;;;AAMA;;;;;AAKA;;;;;AAqBA;;;;;AAOA;;;;;;;;ACfA;;;;;;;;;;;;;iBAAgB,SAAA,CAAA,GAAa,MAAA,EAAQ,KAAA,KAAU,cAAA,GAAiB,eAAA;AAoBhE;;;;;AAWA;AAXA,iBAAgB,mBAAA,CAAoB,MAAA,WAAiB,aAAA;;;;;;;;iBAWrC,eAAA,CAAgB,MAAA,UAAgB,WAAA,oBAA+B,aAAA;;;;ADpE/E;;;;;cEVa,qBAAA;EAAA,iBACkB,MAAA;cAAA,MAAA,EAAQ,aAAA;EFgBiB;;AAMxD;;;;;AAMA;;EEjBQ,aAAA,CACJ,MAAA,EAAQ,KAAA,IACR,OAAA,EAAS,aAAA,EACT,SAAA,EAAW,SAAA,GACV,OAAA;EFae;;AAKpB;;;;;EALoB,QE2BV,YAAA;EFDoB;;;EAAA,QEcpB,eAAA;AAAA"}

package/dist/guards/index.mjs

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