@nestia/core 14.0.1 → 14.0.3

package/src/adaptors/McpAdaptor.ts

@@ -11,6 +11,7 @@ import { InstanceWrapper } from "@nestjs/core/injector/instance-wrapper";
 import { Module } from "@nestjs/core/injector/module";
 
 import { IMcpRouteReflect } from "../decorators/internal/IMcpRouteReflect";
+import { resolve_request_body } from "../decorators/internal/validate_request_body";
 import {
   create_external_context_creator,
   get_request_context_id,
@@ -47,14 +48,12 @@ import {
  *
  * @author wildduck - https://github.com/wildduck2
  * @example
- *   ```typescript
  *   import core from "@nestia/core";
  *   import { NestFactory } from "@nestjs/core";
  *
  *   const app = await NestFactory.create(AppModule);
  *   await core.McpAdaptor.upgrade(app, { path: "/mcp" });
  *   await app.listen(3000);
- *   ```;
  */
 export class McpAdaptor {
   /**
@@ -71,6 +70,11 @@ export class McpAdaptor {
    *
    * @param app Running Nest application instance.
    * @param options Transport and identity overrides.
+   * @evidence contracts/common.md#principled-implementation Tools are collected once from the prototype chain of every controller instance by the `nestia/McpRoute` metadata, with the first definition of a property name winning and accessors skipped without execution, duplicates by tool name refused before serving, and each call runs through NestJS's `ExternalContextCreator` so guards, interceptors, pipes, and exception filters apply as for an HTTP route; every request gets a fresh MCP server and Streamable HTTP transport, which stateless mode requires, and both are closed in a `finally`.
+   * @evidence contracts/common.md#clear-and-simple-design One entry point does discovery and registration; the per-tool call (`createHandler`), the duplicate check, the SDK loader, and the per-request response facade are separate module-private functions.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Reading the module graph goes through the internal `app.container`, because `INestApplication` exposes no public accessor for it, `create_external_context_creator` constructs an owned subclass through the Nest constructor and overrides module selection on that type, because the default looks for provider classes while controllers belong to the controller collection, and `get_request_context_id` registers the request provider on the request object as NestJS's router does for an HTTP route, and a per-request response facade forwards native state, events and method receivers without replacing raw methods. After a tool or its exception filter has sent headers, only the facade suppresses subsequent transport writes and preserves callbacks and chaining. Native transport writes do not themselves activate takeover. The remaining foreign-internal reads are the application container and Nest request context registration; the MCP SDK uses its public Node response injection boundary.
+   * @evidence contracts/common.md#meaningful-documentation The comment states the stateless mode, what is discovered, and that the SDK is an optional dependency; the options documentation states the path and server information.
+   * @evidenceExclude contracts/portability.md#os-neutral-implementation MCP tool discovery and HTTP transport callbacks carry protocol values; optional SDK imports use Node module resolution and no native file identity or child process is defined here.
    */
   public static async upgrade(
     app: INestApplication,
@@ -101,7 +105,8 @@ export class McpAdaptor {
           for (const key of Object.getOwnPropertyNames(proto)) {
             if (key === "constructor" || visited.has(key)) continue;
             visited.add(key);
-            const method = proto[key];
+            // Route discovery inspects data descriptors without invoking accessors.
+            const method = Object.getOwnPropertyDescriptor(proto, key)?.value;
             if (typeof method !== "function") continue;
 
             const meta: IMcpRouteReflect | undefined = Reflect.getMetadata(
@@ -154,6 +159,7 @@ export class McpAdaptor {
         capabilities: { tools: {} },
       });
       const server = mcp.server;
+      const relay = transportResponse(res.raw ?? res);
 
       server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: tools.map((t) => ({
@@ -181,7 +187,7 @@ export class McpAdaptor {
             response: res,
             args,
           });
-          if (tookOver(res)) return { content: [] };
+          if (relay.takeOver()) return { content: [] };
           if (result instanceof Error) throw result;
           if (result === undefined) return { content: [] };
           return {
@@ -194,7 +200,7 @@ export class McpAdaptor {
             ],
           };
         } catch (e) {
-          if (tookOver(res)) return { content: [] };
+          if (relay.takeOver()) return { content: [] };
           if (INVALID_ARGUMENTS.has(e as object)) {
             const body = (e as BadRequestException).getResponse() as any;
             throw new McpError(ErrorCode.InvalidParams, (e as Error).message, {
@@ -224,7 +230,7 @@ export class McpAdaptor {
       });
       try {
         await mcp.connect(transport);
-        await transport.handleRequest(req.raw ?? req, res.raw ?? res, req.body);
+        await transport.handleRequest(req.raw ?? req, relay.response, req.body);
       } finally {
         await transport.close().catch(() => {});
         await mcp.close().catch(() => {});
@@ -242,7 +248,9 @@ export class McpAdaptor {
  * The arguments reach the method through the pipes as its body would, validated
  * by typia at that stage: after the guards, as `@TypedBody()` is. An invalid
  * argument is thrown as the validator's `BadRequestException`, which an
- * exception filter may map; unmapped, it becomes JSON-RPC `-32602`.
+ * exception filter may map; unmapped, it becomes JSON-RPC `-32602`. Successful
+ * resolver data becomes the argument before pipes execute. Legacy error-only
+ * metadata callbacks retain raw input on null success.
  *
  * A controller that is request-scoped, itself or through an enhancer or a
  * dependency, is built per request with its enhancers, as NestJS builds it for
@@ -275,10 +283,11 @@ const createHandler = (props: {
       {
         // [request, response, next] as an HTTP route has, then the arguments
         exchangeKeyForValue: (_type, _data, [, , , args]) => {
-          const error: Error | null = validate ? validate(args) : null;
-          if (error === null) return args;
-          INVALID_ARGUMENTS.add(error);
-          throw error;
+          if (!validate) return args;
+          const result = resolve_request_body(validate, args);
+          if (result.success) return result.data;
+          INVALID_ARGUMENTS.add(result.error);
+          throw result.error;
         },
       },
       contextId,
@@ -307,22 +316,55 @@ const createHandler = (props: {
 };
 
 /**
- * Whether an exception filter already wrote the HTTP response itself. The
- * response it wrote stands, so the transport's own is dropped: writing again
- * would throw, and the transport would destroy the connection mid-response.
+ * The transport's response view. Native state, events and method receivers stay
+ * on the real response; only this view's writes stop after a tool's exception
+ * filter has already answered. Normal transport writes never activate
+ * takeover.
  */
-const tookOver = (response: any): boolean => {
-  const raw: any = response.raw ?? response;
-  if (raw.headersSent !== true) return false;
-  raw.writeHead = () => raw;
-  raw.flushHeaders = () => {};
-  raw.write = () => true;
-  raw.end = (...args: unknown[]) => {
-    const callback: unknown = args.find((a) => typeof a === "function");
-    if (typeof callback === "function") queueMicrotask(() => callback());
-    return raw;
+const transportResponse = (
+  raw: any,
+): { response: any; takeOver: () => boolean } => {
+  let takenOver = false;
+  const respond = (key: string, args: unknown[]): unknown => {
+    if (takenOver) {
+      const callback = args.find((arg) => typeof arg === "function");
+      if ((key === "write" || key === "end") && typeof callback === "function")
+        queueMicrotask(() => callback());
+      return key === "write"
+        ? true
+        : key === "flushHeaders"
+          ? undefined
+          : response;
+    }
+    const result = Reflect.apply(raw[key], raw, args);
+    return result === raw ? response : result;
+  };
+  const writes = new Map<PropertyKey, (...args: unknown[]) => unknown>(
+    ["writeHead", "flushHeaders", "write", "end"].map((key) => [
+      key,
+      (...args: unknown[]) => respond(key, args),
+    ]),
+  );
+  const response: any = new Proxy(raw, {
+    get: (target, key) => {
+      const write = writes.get(key);
+      if (write !== undefined) return write;
+      const value = Reflect.get(target, key, target);
+      if (typeof value !== "function") return value;
+      return (...args: unknown[]) => {
+        const result = Reflect.apply(value, target, args);
+        return result === target ? response : result;
+      };
+    },
+    set: (target, key, value) => Reflect.set(target, key, value, target),
+  });
+  return {
+    response,
+    takeOver: () => {
+      takenOver ||= raw.headersSent === true;
+      return takenOver;
+    },
   };
-  return true;
 };
 
 const PARAMS_METADATA = "nestia/McpRoute/ExternalParameters";
@@ -374,8 +416,26 @@ const loadMcpSdk = async () => {
   }
 };
 
+/**
+ * Types of {@link McpAdaptor}: the options of `upgrade` and the record of a
+ * registered tool.
+ *
+ * @evidence contracts/common.md#principled-implementation The class exposes one static entry point, so the adapter has no instance state: the tool list is closed over by the registered route handler.
+ * @evidence contracts/common.md#clear-and-simple-design One static method and two nested types.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts It has no fixture or tool name, and the MCP SDK is loaded lazily so an application that never enables MCP does not need it.
+ * @evidence contracts/common.md#meaningful-documentation The class comment explains what an MCP route is and how to enable it.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation MCP tool discovery and HTTP transport callbacks carry protocol values; optional SDK imports use Node module resolution and no native file identity or child process is defined here.
+ */
 export namespace McpAdaptor {
-  /** Configuration options for {@link McpAdaptor.upgrade}. */
+  /**
+   * Configuration options for {@link McpAdaptor.upgrade}.
+   *
+   * @evidence contracts/common.md#principled-implementation The two options are the route path, with `/mcp` as the default, and the server information reported to clients, with a default name and version.
+   * @evidence contracts/common.md#clear-and-simple-design A flat record of two optional values.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts It is a type; the defaults are stated in the code that reads them.
+   * @evidence contracts/common.md#meaningful-documentation Each option documents its meaning.
+   * @evidenceExclude contracts/portability.md#os-neutral-implementation MCP tool discovery and HTTP transport callbacks carry protocol values; optional SDK imports use Node module resolution and no native file identity or child process is defined here.
+   */
   export interface IOptions {
     /**
      * HTTP path where the MCP endpoint will be mounted.

package/src/adaptors/WebSocketAdaptor.ts

@@ -11,7 +11,10 @@ import {
   SCOPE_OPTIONS_METADATA,
   VERSION_METADATA,
 } from "@nestjs/common/constants";
-import { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
+import {
+  VERSION_NEUTRAL,
+  VersionValue,
+} from "@nestjs/common/interfaces/index.js";
 import { NestContainer } from "@nestjs/core";
 import { InstanceWrapper } from "@nestjs/core/injector/instance-wrapper";
 import { Module } from "@nestjs/core/injector/module";
@@ -21,20 +24,59 @@ import path from "path";
 import { Duplex } from "stream";
 import { WebSocketAcceptor } from "tgrid";
 import typia from "typia";
+import { fileURLToPath } from "url";
 import WebSocket from "ws";
 
 import { IWebSocketRouteReflect } from "../decorators/internal/IWebSocketRouteReflect";
+import { resolve_request_body } from "../decorators/internal/validate_request_body";
 import { ArrayUtil } from "../utils/ArrayUtil";
 import { VersioningStrategy } from "../utils/VersioningStrategy";
 import { RoutePathMatcher } from "./internal/RoutePathMatcher";
 
+/**
+ * Serves the `@WebSocketRoute()` methods of a NestJS application over
+ * WebSocket.
+ *
+ * Call {@link upgrade} after the application has been created. It finds the
+ * routes, checks them, and takes over the HTTP server's `upgrade` events. A
+ * handshake whose path matches no route is rejected with close code 1002.
+ *
+ * @evidence contracts/common.md#principled-implementation Routes are matched by paths built from the global prefix, the version, the module prefix, the controller path, and the method path, joined and normalized the same way for every combination; the adapter answers upgrade events itself through a `ws` server in no-server mode and removes its listeners when the HTTP server closes.
+ * @evidence contracts/common.md#clear-and-simple-design A class with one static factory, one `close` property, and the private handler; discovery, method checks, termination, and close reasons are module-private functions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The global prefix, versioning options, and module graph are read from `app.config` and `app.container`, which NestJS keeps internal because `INestApplication` has no public accessor for them; this is the limitation of the adapter, not a fixture-specific branch.
+ * @evidence contracts/common.md#meaningful-documentation The comment states when to call it and what happens to an unmatched handshake.
+ * @evidence contracts/portability.md#os-neutral-implementation Diagnostic source URLs are converted by fileURLToPath before path.relative uses native paths; route matching uses HTTP path segments separately from filesystem paths. No filesystem case policy is inferred from the OS.
+ */
 export class WebSocketAdaptor {
+  /**
+   * Creates the adapter for the application: it visits every controller,
+   * validates the WebSocket routes, and starts listening for upgrade events.
+   *
+   * All route errors of the application are collected and thrown together, with
+   * the controller, method, source location, and reasons of each.
+   *
+   * @evidence contracts/common.md#principled-implementation Controller data-method descriptors are checked before any handshake is served, with child properties shadowing inherited methods and accessors never executed, and all defects are reported in one error, so a misconfigured route fails at start and not at the first client; source locations come from `get-function-location`, converted with `fileURLToPath` so a `file:` URL becomes the path on every platform.
+   * @evidence contracts/common.md#clear-and-simple-design One asynchronous factory that awaits the visitor and hands the operator list to the private constructor.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The visitor reports through the same error path for every controller; no controller or route name is special-cased.
+   * @evidence contracts/common.md#meaningful-documentation The comment states the collected error report and the effect on the server.
+   * @evidence contracts/portability.md#os-neutral-implementation Diagnostic source URLs are converted by fileURLToPath before path.relative uses native paths; route matching uses HTTP path segments separately from filesystem paths. No filesystem case policy is inferred from the OS.
+   */
   public static async upgrade(
     app: INestApplication,
   ): Promise<WebSocketAdaptor> {
     return new this(app, await visitApplication(app));
   }
 
+  /**
+   * Stops the adapter: removes its listeners from the HTTP server and closes
+   * the WebSocket server.
+   *
+   * @evidence contracts/common.md#principled-implementation The listeners are removed before the `ws` server closes, so no upgrade event reaches a closing server, and the returned promise resolves when the server has closed.
+   * @evidence contracts/common.md#clear-and-simple-design An arrow property so the same function value can be registered and unregistered as the HTTP server's close listener.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts It releases exactly what the adapter registered.
+   * @evidence contracts/common.md#meaningful-documentation The comment states what is released.
+   * @evidence contracts/portability.md#os-neutral-implementation Diagnostic source URLs are converted by fileURLToPath before path.relative uses native paths; route matching uses HTTP path segments separately from filesystem paths. No filesystem case policy is inferred from the OS.
+   */
   public readonly close = async (): Promise<void> =>
     new Promise((resolve) => {
       this.http.off("close", this.close);
@@ -207,8 +249,7 @@ const visitController = async (props: {
     modulePrefix: props.modulePrefix,
   };
   for (const mk of getOwnPropertyNames(controller.prototype).filter(
-    (key) =>
-      key !== "constructor" && typeof controller.prototype[key] === "function",
+    (key) => key !== "constructor",
   )) {
     const errorMessages: string[] = [];
     visitMethod({
@@ -229,7 +270,9 @@ const visitController = async (props: {
         ...file,
         source: path.relative(
           process.cwd(),
-          file.source.replace("file:///", ""),
+          file.source.startsWith("file:")
+            ? fileURLToPath(file.source)
+            : file.source,
         ),
       });
     }
@@ -342,9 +385,12 @@ const visitMethod = (props: {
                 else if (p.category === "driver")
                   args.push(input.acceptor.getDriver());
                 else if (p.category === "header") {
-                  const error: Error | null = p.validate(input.acceptor.header);
-                  if (error !== null) throw error;
-                  args.push(input.acceptor.header);
+                  const result = resolve_request_body(
+                    p.validate,
+                    input.acceptor.header,
+                  );
+                  if (!result.success) throw result.error;
+                  args.push(result.data);
                 } else if (p.category === "param")
                   args.push(p.assert(input.params[p.field]!));
                 else if (p.category === "query") {
@@ -475,14 +521,23 @@ const MAX_CLOSE_REASON_BYTES: number = 123;
 
 const wrapPaths = (value: string[]) => (value.length === 0 ? [""] : value);
 const getOwnPropertyNames = (prototype: any): string[] => {
-  const result: Set<string> = new Set();
-  const iterate = (m: any) => {
-    if (m === null) return;
-    for (const k of Object.getOwnPropertyNames(m)) result.add(k);
-    iterate(Object.getPrototypeOf(m));
-  };
-  iterate(prototype);
-  return Array.from(result);
+  const visited: Set<string> = new Set();
+  const result: string[] = [];
+  for (
+    let current = prototype;
+    current !== null;
+    current = Object.getPrototypeOf(current)
+  )
+    for (const key of Object.getOwnPropertyNames(current)) {
+      if (visited.has(key)) continue;
+      visited.add(key);
+      if (
+        typeof Object.getOwnPropertyDescriptor(current, key)?.value ===
+        "function"
+      )
+        result.push(key);
+    }
+  return result;
 };
 
 interface Entry<T> {

package/src/adaptors/internal/external_context.ts

@@ -1,5 +1,18 @@
 import { ContextId, ContextIdFactory, NestContainer } from "@nestjs/core";
+import { ExternalExceptionFilterContext } from "@nestjs/core/exceptions/external-exception-filter-context";
+import {
+  GuardsConsumer,
+  GuardsContextCreator,
+} from "@nestjs/core/guards/index.js";
 import { ExternalContextCreator } from "@nestjs/core/helpers/external-context-creator";
+import {
+  InterceptorsConsumer,
+  InterceptorsContextCreator,
+} from "@nestjs/core/interceptors/index.js";
+import {
+  PipesConsumer,
+  PipesContextCreator,
+} from "@nestjs/core/pipes/index.js";
 import { REQUEST_CONTEXT_ID } from "@nestjs/core/router/request/request-constants";
 
 /**
@@ -15,12 +28,36 @@ import { REQUEST_CONTEXT_ID } from "@nestjs/core/router/request/request-constant
 export const create_external_context_creator = (
   container: NestContainer,
   moduleKey: string,
-): ExternalContextCreator => {
-  const creator: ExternalContextCreator =
-    ExternalContextCreator.fromContainer(container);
-  creator.getContextModuleKey = () => moduleKey;
-  return creator;
-};
+): ExternalContextCreator => new ControllerContextCreator(container, moduleKey);
+
+class ControllerContextCreator extends ExternalContextCreator {
+  public constructor(
+    private readonly owner: NestContainer,
+    private readonly moduleKey: string,
+  ) {
+    super(
+      new GuardsContextCreator(owner, owner.applicationConfig),
+      new GuardsConsumer(),
+      new InterceptorsContextCreator(owner, owner.applicationConfig),
+      new InterceptorsConsumer(),
+      owner.getModules(),
+      new PipesContextCreator(owner, owner.applicationConfig),
+      new PipesConsumer(),
+      new ExternalExceptionFilterContext(owner, owner.applicationConfig),
+    );
+  }
+
+  public override getContextModuleKey(): string {
+    return this.moduleKey;
+  }
+
+  public override registerRequestProvider<T = any>(
+    request: T,
+    contextId: ContextId,
+  ): void {
+    this.owner.registerRequestProvider(request, contextId);
+  }
+}
 
 /**
  * The context a request-scoped provider is built in for this request, the one

package/src/decorators/DynamicModule.ts

@@ -1,5 +1,5 @@
 import { Module } from "@nestjs/common";
-import { ModuleMetadata } from "@nestjs/common/interfaces";
+import { ModuleMetadata } from "@nestjs/common/interfaces/index.js";
 
 import { Creator } from "../typings/Creator";
 import { load_controllers } from "./internal/load_controller";
@@ -11,6 +11,11 @@ import { load_controllers } from "./internal/load_controller";
  * controller classes dynamically just by specifying their directory path.
  *
  * @author Jeongho Nam - https://github.com/samchon
+ * @evidence contracts/common.md#principled-implementation The namespace builds a Nest module whose controllers are found on disk at startup instead of listed in code, using the shared loader.
+ * @evidence contracts/common.md#clear-and-simple-design One function that delegates discovery to `load_controllers` and decorates a class with the result.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Paths are caller input, and no controller name is assumed.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes the purpose and the path forms.
+ * @evidence contracts/portability.md#os-neutral-implementation Controller discovery delegates native path handling to SourceFinder and conversion of import paths to file URLs to load_controllers; module metadata contains controller constructors rather than filesystem identities.
  */
 export namespace DynamicModule {
   /**
@@ -23,7 +28,14 @@ export namespace DynamicModule {
    *
    * @param path Path of controllers
    * @param metadata Additional metadata except controllers
+   * @param isTsNode Select TypeScript source files explicitly; otherwise
+   *   compiled JavaScript is tried first, with a source fallback under `ttsx`.
    * @returns Module instance
+   * @evidence contracts/common.md#principled-implementation Controllers are loaded from the paths, given as a path, a list, or include and exclude lists, and then a class decorated with `@Module` and those controllers is returned, so Nest treats the result as an ordinary module.
+   * @evidence contracts/common.md#clear-and-simple-design A short function whose discovery details live in `load_controllers`.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts It calls Nest's public `Module` decorator with the metadata; nothing is patched.
+   * @evidence contracts/common.md#meaningful-documentation The comment documents the path forms and the `isTsNode` option.
+   * @evidence contracts/portability.md#os-neutral-implementation Controller discovery delegates native path handling to SourceFinder and conversion of import paths to file URLs to load_controllers; module metadata contains controller constructors rather than filesystem identities.
    */
   export async function mount(
     path: string | string[] | { include: string[]; exclude?: string[] },

package/src/decorators/EncryptedBody.ts

@@ -20,22 +20,30 @@ import { validate_request_body } from "./internal/validate_request_body";
  * Encrypted body decorator.
  *
  * `EncryptedBody` is a decorator function getting `application/json` typed data
- * from request body which has been encrypted by AES-128/256 algorithm. Also,
- * `EncryptedBody` validates the request body data type through
- * [typia](https://github.com/samchon/typia) ad the validation speed is maximum
- * 15,000x times faster than `class-validator`.
+ * from request body which has been encrypted by AES-128/192/256 algorithm.
+ * Also, `EncryptedBody` validates the request body data type through
+ * [typia](https://github.com/samchon/typia) using the declared TypeScript
+ * type.
  *
  * For reference, when the request body data is not following the promised type
  * `T`, `BadRequestException` error (status code: 400) would be thrown. Also,
- * `EncryptedRoute` decrypts request body using those options.
+ * This decorator decrypts the request body using these options.
  *
- * - AES-128/256
+ * - AES-128/192/256
  * - CBC mode
  * - PKCS #5 Padding
  * - Base64 Encoding
  *
+ * Successful validator data becomes the decorated argument, including copies
+ * returned by clone validators after decryption and JSON parsing.
+ *
  * @author Jeongho Nam - https://github.com/samchon
  * @returns Parameter decorator
+ * @evidence contracts/common.md#principled-implementation The body must be `text/plain` ciphertext; it is decrypted with the password of the controller or module, the plain text is parsed as JSON and validated by the transformed validator, and a decryption or parse failure becomes a 400 with one fixed message that does not echo the ciphertext and does not tell the two failures apart; a key or initialization vector the cipher itself refuses is the server's configuration, independent of the request, and is thrown as it is.
+ * @evidence contracts/common.md#clear-and-simple-design One parameter decorator composes shared text reading, password lookup and validator resolution; the successfully resolved data becomes the argument without repeating validation or changing decryption error handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The algorithm comes from `AesPkcs5` of the fetcher, the same one the client uses, and no key is embedded; a missing password is an error rather than a plain pass-through.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes the protocol and the requirement of a password on the controller or module, and the private decode helper documents why every decryption failure collapses into one response.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Ciphertext parsing, AES decryption and request validation operate on HTTP values, with no native filesystem or subprocess boundary.
  */
 export function EncryptedBody<T>(
   validator?: IRequestBodyValidator<T>,
@@ -70,9 +78,9 @@ export function EncryptedBody<T>(
 
     // PARSE AND VALIDATE DATA
     const data: any = decode(body, password.key, password.iv);
-    const error: Error | null = checker(data);
-    if (error !== null) throw error;
-    return data;
+    const result = checker.resolve(data);
+    if (!result.success) throw result.error;
+    return result.data;
   })();
 }
 
@@ -89,9 +97,13 @@ export function EncryptedBody<T>(
  *
  * Both failure modes must therefore collapse into one indistinguishable
  * `BadRequestException` (identical status, message, and body). Only the
- * downstream type validation of an already-parsed body may report its own
- * distinct error, because reaching it requires plaintext the attacker cannot
- * forge without already knowing it.
+ * downstream type validation of an already-parsed body reports its own distinct
+ * error. AES-CBC provides no authentication; collapsing parse and padding
+ * errors does not establish ciphertext authenticity.
+ *
+ * A key or initialization vector the cipher refuses is thrown as it is. It says
+ * nothing about the body, so it opens no oracle, and it is a defect of the
+ * server's configuration that a 400 would blame on the client.
  *
  * @internal
  */
@@ -99,10 +111,22 @@ const decode = (body: string, key: string, iv: string): unknown => {
   try {
     return JSON.parse(AesPkcs5.decrypt(body, key, iv));
   } catch (exp) {
-    if (exp instanceof Error)
+    // A password the cipher itself refuses is the server's configuration, which
+    // no request body can influence, so it is no oracle and no client's fault.
+    if (exp instanceof Error && PASSWORD_ERRORS.has((exp as any).code))
+      throw exp;
+    else if (exp instanceof Error)
       throw new BadRequestException(
         "Failed to decrypt the request body. Check your body content or encryption password.",
       );
     else throw exp;
   }
 };
+
+/** The error codes of a key or an initialization vector the cipher refuses. */
+const PASSWORD_ERRORS: Set<unknown> = new Set([
+  "ERR_INVALID_ARG_TYPE",
+  "ERR_CRYPTO_INVALID_IV",
+  "ERR_CRYPTO_INVALID_KEYLEN",
+  "ERR_CRYPTO_UNKNOWN_CIPHER",
+]);

package/src/decorators/EncryptedController.ts

@@ -7,7 +7,7 @@ import { ENCRYPTION_CONTROLLER_METADATA_KEY } from "./internal/EncryptedConstant
  * Encrypted controller.
  *
  * `EncryptedController` is an extension of the {@link nest.Controller} class
- * decorator function who configures encryption password of the AES-128/256
+ * decorator function who configures encryption password of the AES-128/192/256
  * algorithm. The encryption algorithm and password would be used by
  * {@link EncryptedRoute} and {@link EncryptedBody} to encrypt the request and
  * response body of the HTTP protocol.
@@ -28,6 +28,11 @@ import { ENCRYPTION_CONTROLLER_METADATA_KEY } from "./internal/EncryptedConstant
  * @param path Path of the HTTP request
  * @param password Encryption password or its getter function
  * @returns Class decorator
+ * @evidence contracts/common.md#principled-implementation The decorator stores the password as metadata on the class and then applies Nest's `Controller(path)`, so the encrypted decorators can find the password by reading the class.
+ * @evidence contracts/common.md#clear-and-simple-design One decorator that composes a metadata write with the standard decorator.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts It uses Nest's public `Controller` decorator and the reflect metadata API.
+ * @evidence contracts/common.md#meaningful-documentation The comment states the password forms and the encrypted decorators it enables.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Controller paths are HTTP routing metadata and passwords are in-memory values; neither is a native filesystem path.
  */
 export function EncryptedController(
   path: string,

package/src/decorators/EncryptedModule.ts

@@ -9,9 +9,9 @@ import { load_controllers } from "./internal/load_controller";
  * Encrypted module.
  *
  * `EncryptedModule` is an extension of the {@link Module} class decorator
- * function who configures encryption password of the AES-128/256 algorithm. The
- * encryption algorithm and password would be used by {@link EncryptedRoute} and
- * {@link EncryptedBody} to encrypt the request and response bod of the HTTP
+ * function who configures encryption password of the AES-128/192/256 algorithm.
+ * The encryption algorithm and password would be used by {@link EncryptedRoute}
+ * and {@link EncryptedBody} to encrypt the request and response bod of the HTTP
  * protocol.
  *
  * By using this `EncryptedModule` decorator function, all of the
@@ -38,6 +38,11 @@ import { load_controllers } from "./internal/load_controller";
  * @param metadata Module configuration metadata
  * @param password Encryption password or its getter function
  * @returns Class decorator
+ * @evidence contracts/common.md#principled-implementation A visited set breaks import cycles, the controllers of each visited module get the password as metadata, asynchronous modules are awaited through the same promise Nest awaits, and a forward reference is resolved once its class exists.
+ * @evidence contracts/common.md#clear-and-simple-design One decorator whose traversal is a private function; the dynamic-module helper is in the merged namespace.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The traversal uses the public metadata keys of Nest modules; no module name is special-cased.
+ * @evidence contracts/common.md#meaningful-documentation The comment states which module shapes are followed.
+ * @evidence contracts/portability.md#os-neutral-implementation The decorator traverses Nest module metadata in memory; its dynamic helper delegates native paths and file-URL imports to load_controllers instead of composing platform-specific import strings.
  */
 export function EncryptedModule(
   metadata: Parameters<typeof Module>[0],
@@ -49,6 +54,16 @@ export function EncryptedModule(
   };
 }
 
+/**
+ * Helpers of {@link EncryptedModule}, namely `dynamic`, which builds an
+ * encrypted module from controller paths.
+ *
+ * @evidence contracts/common.md#principled-implementation `dynamic` loads the controllers with the shared loader, wraps an object password into a closure, and returns a class decorated by `EncryptedModule`.
+ * @evidence contracts/common.md#clear-and-simple-design One function that reuses the loader and the decorator.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Paths and password are caller input.
+ * @evidence contracts/common.md#meaningful-documentation The comment documents the path forms and the password argument.
+ * @evidence contracts/portability.md#os-neutral-implementation The decorator traverses Nest module metadata in memory; its dynamic helper delegates native paths and file-URL imports to load_controllers instead of composing platform-specific import strings.
+ */
 export namespace EncryptedModule {
   /**
    * Dynamic encrypted module.