@nestia/fetcher 14.0.1 → 14.0.2

package/lib/AesPkcs5.d.ts

@@ -1,12 +1,21 @@
 /**
- * Utility class for the AES-128/256 encryption.
+ * Utilities for AES-CBC encryption.
  *
- * - AES-128/256
+ * - AES-128/192/256
  * - CBC mode
  * - PKCS#5 Padding
  * - Base64 Encoding
  *
+ * The key and the initializer vector are strings that Node reads as UTF-8
+ * bytes. The variant is chosen by the key's byte length: 16, 24, and 32 bytes
+ * select AES-128, AES-192, and AES-256, and any other length is refused by the
+ * cipher.
+ *
  * @author Jeongho Nam - https://github.com/samchon
+ * @evidence contracts/common.md#principled-implementation The functions call Node's `createCipheriv` and `createDecipheriv` with AES in CBC mode, whose default padding is PKCS#5/PKCS#7, and exchange base64 text; the variant is derived from the key's UTF-8 byte length, which is the length Node actually reads, so a key of 16, 24, or 32 bytes selects AES-128, AES-192, or AES-256 and any other length is refused by the cipher. CBC carries no authentication tag, so the format offers confidentiality without integrity; the mode and encoding are fixed by the wire format `@nestia/core`'s encrypted decorators use, so this namespace cannot change them alone.
+ * @evidence contracts/common.md#clear-and-simple-design Two functions with the same three inputs and no state; the variant selection is one expression in each because the two directions share nothing else.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The primitives are the platform's crypto module with no custom cipher, padding, or key derivation; nothing is hardcoded to a key or an initializer vector.
+ * @evidence contracts/common.md#meaningful-documentation The comment names the algorithm, the mode, the padding, and the encoding, and states how the key length selects the variant.
  */
 export declare namespace AesPkcs5 {
     /**
@@ -16,6 +25,10 @@ export declare namespace AesPkcs5 {
      * @param key Key value of the encryption.
      * @param iv Initializer Vector for the encryption
      * @returns Encrypted data
+     * @evidence contracts/common.md#principled-implementation The plain text is read as UTF-8, encrypted in CBC mode with the key and the initializer vector, and emitted as base64 by concatenating the update and final outputs, so the result decrypts to the same text with the same key and vector.
+     * @evidence contracts/common.md#clear-and-simple-design A single expression over one cipher object, with the cipher name derived from the key in the line above.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The key and the vector come only from the caller, and a key of unsupported size makes Node throw instead of being padded or truncated.
+     * @evidence contracts/common.md#meaningful-documentation The parameters and the return value are documented, and the namespace comment states the byte-length rule for the key.
      */
     function encrypt(data: string, key: string, iv: string): string;
     /**
@@ -25,6 +38,10 @@ export declare namespace AesPkcs5 {
      * @param key Key value of the decryption.
      * @param iv Initializer Vector for the decryption
      * @returns Decrypted data.
+     * @evidence contracts/common.md#principled-implementation The base64 text is decrypted in CBC mode with the key and the initializer vector, and the update and final outputs are concatenated as UTF-8, so `decrypt(encrypt(x))` returns `x`; wrong keys or corrupted text make the final block check throw rather than return garbage silently in the usual case, although CBC without a tag cannot detect every alteration.
+     * @evidence contracts/common.md#clear-and-simple-design A single expression over one decipher object, mirroring `encrypt`.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts It uses the platform's decipher and does not catch its errors, so a padding or key failure reaches the caller.
+     * @evidence contracts/common.md#meaningful-documentation The parameters and the return value are documented, and the namespace comment states the byte-length rule for the key.
      */
     function decrypt(data: string, key: string, iv: string): string;
 }

package/lib/AesPkcs5.js

@@ -6,14 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AesPkcs5 = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 /**
- * Utility class for the AES-128/256 encryption.
+ * Utilities for AES-CBC encryption.
  *
- * - AES-128/256
+ * - AES-128/192/256
  * - CBC mode
  * - PKCS#5 Padding
  * - Base64 Encoding
  *
+ * The key and the initializer vector are strings that Node reads as UTF-8
+ * bytes. The variant is chosen by the key's byte length: 16, 24, and 32 bytes
+ * select AES-128, AES-192, and AES-256, and any other length is refused by the
+ * cipher.
+ *
  * @author Jeongho Nam - https://github.com/samchon
+ * @evidence contracts/common.md#principled-implementation The functions call Node's `createCipheriv` and `createDecipheriv` with AES in CBC mode, whose default padding is PKCS#5/PKCS#7, and exchange base64 text; the variant is derived from the key's UTF-8 byte length, which is the length Node actually reads, so a key of 16, 24, or 32 bytes selects AES-128, AES-192, or AES-256 and any other length is refused by the cipher. CBC carries no authentication tag, so the format offers confidentiality without integrity; the mode and encoding are fixed by the wire format `@nestia/core`'s encrypted decorators use, so this namespace cannot change them alone.
+ * @evidence contracts/common.md#clear-and-simple-design Two functions with the same three inputs and no state; the variant selection is one expression in each because the two directions share nothing else.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The primitives are the platform's crypto module with no custom cipher, padding, or key derivation; nothing is hardcoded to a key or an initializer vector.
+ * @evidence contracts/common.md#meaningful-documentation The comment names the algorithm, the mode, the padding, and the encoding, and states how the key length selects the variant.
  */
 var AesPkcs5;
 (function (AesPkcs5) {
@@ -24,9 +33,13 @@ var AesPkcs5;
      * @param key Key value of the encryption.
      * @param iv Initializer Vector for the encryption
      * @returns Encrypted data
+     * @evidence contracts/common.md#principled-implementation The plain text is read as UTF-8, encrypted in CBC mode with the key and the initializer vector, and emitted as base64 by concatenating the update and final outputs, so the result decrypts to the same text with the same key and vector.
+     * @evidence contracts/common.md#clear-and-simple-design A single expression over one cipher object, with the cipher name derived from the key in the line above.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The key and the vector come only from the caller, and a key of unsupported size makes Node throw instead of being padded or truncated.
+     * @evidence contracts/common.md#meaningful-documentation The parameters and the return value are documented, and the namespace comment states the byte-length rule for the key.
      */
     function encrypt(data, key, iv) {
-        const bytes = key.length * 8;
+        const bytes = Buffer.byteLength(key, "utf8") * 8;
         const cipher = crypto_1.default.createCipheriv(`AES-${bytes}-CBC`, key, iv);
         return cipher.update(data, "utf8", "base64") + cipher.final("base64");
     }
@@ -38,9 +51,13 @@ var AesPkcs5;
      * @param key Key value of the decryption.
      * @param iv Initializer Vector for the decryption
      * @returns Decrypted data.
+     * @evidence contracts/common.md#principled-implementation The base64 text is decrypted in CBC mode with the key and the initializer vector, and the update and final outputs are concatenated as UTF-8, so `decrypt(encrypt(x))` returns `x`; wrong keys or corrupted text make the final block check throw rather than return garbage silently in the usual case, although CBC without a tag cannot detect every alteration.
+     * @evidence contracts/common.md#clear-and-simple-design A single expression over one decipher object, mirroring `encrypt`.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts It uses the platform's decipher and does not catch its errors, so a padding or key failure reaches the caller.
+     * @evidence contracts/common.md#meaningful-documentation The parameters and the return value are documented, and the namespace comment states the byte-length rule for the key.
      */
     function decrypt(data, key, iv) {
-        const bytes = key.length * 8;
+        const bytes = Buffer.byteLength(key, "utf8") * 8;
         const decipher = crypto_1.default.createDecipheriv(`AES-${bytes}-CBC`, key, iv);
         return decipher.update(data, "base64", "utf8") + decipher.final("utf8");
     }

package/lib/AesPkcs5.js.map

@@ -1 +1 @@
-{"version":3,"file":"AesPkcs5.js","sourceRoot":"","sources":["../src/AesPkcs5.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAE5B;;;;;;;;;GASG;AACH,IAAiB,QAAQ,CA4BxB;AA5BD,WAAiB,QAAQ;IACvB;;;;;;;OAOG;IACH,SAAgB,OAAO,CAAC,IAAY,EAAE,GAAW,EAAE,EAAU;QAC3D,MAAM,KAAK,GAAW,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;QACrC,MAAM,MAAM,GAAG,gBAAM,CAAC,cAAc,CAAC,OAAO,KAAK,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QAClE,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxE,CAAC;IAJe,SAAA,OAAO,UAItB,CAAA;IAED;;;;;;;OAOG;IACH,SAAgB,OAAO,CAAC,IAAY,EAAE,GAAW,EAAE,EAAU;QAC3D,MAAM,KAAK,GAAW,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;QACrC,MAAM,QAAQ,GAAG,gBAAM,CAAC,gBAAgB,CAAC,OAAO,KAAK,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QACtE,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1E,CAAC;IAJe,SAAA,OAAO,UAItB,CAAA;AACH,CAAC,EA5BgB,QAAQ,aAAR,QAAQ,GAAR,QAAQ,QA4BxB"}
+{"version":3,"file":"AesPkcs5.js","sourceRoot":"","sources":["../src/AesPkcs5.ts"],"names":[],"mappings":";;;;;;AAAA,oDAA4B;AAE5B;;;;;;;;;;;;;;;;;;GAkBG;AACH,IAAiB,QAAQ,CAoCxB;AApCD,WAAiB,QAAQ;IACvB;;;;;;;;;;;OAWG;IACH,SAAgB,OAAO,CAAC,IAAY,EAAE,GAAW,EAAE,EAAU;QAC3D,MAAM,KAAK,GAAW,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,MAAM,GAAG,gBAAM,CAAC,cAAc,CAAC,OAAO,KAAK,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QAClE,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxE,CAAC;IAJe,SAAA,OAAO,UAItB,CAAA;IAED;;;;;;;;;;;OAWG;IACH,SAAgB,OAAO,CAAC,IAAY,EAAE,GAAW,EAAE,EAAU;QAC3D,MAAM,KAAK,GAAW,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,gBAAM,CAAC,gBAAgB,CAAC,OAAO,KAAK,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QACtE,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1E,CAAC;IAJe,SAAA,OAAO,UAItB,CAAA;AACH,CAAC,EApCgB,QAAQ,aAAR,QAAQ,GAAR,QAAQ,QAoCxB"}

package/lib/AesPkcs5.mjs

@@ -3,13 +3,13 @@ import crypto from "crypto";
 let AesPkcs5;
 (function(_AesPkcs) {
 	function encrypt(data, key, iv) {
-		const bytes = key.length * 8;
+		const bytes = Buffer.byteLength(key, "utf8") * 8;
 		const cipher = crypto.createCipheriv(`AES-${bytes}-CBC`, key, iv);
 		return cipher.update(data, "utf8", "base64") + cipher.final("base64");
 	}
 	_AesPkcs.encrypt = encrypt;
 	function decrypt(data, key, iv) {
-		const bytes = key.length * 8;
+		const bytes = Buffer.byteLength(key, "utf8") * 8;
 		const decipher = crypto.createDecipheriv(`AES-${bytes}-CBC`, key, iv);
 		return decipher.update(data, "base64", "utf8") + decipher.final("utf8");
 	}

package/lib/AesPkcs5.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"AesPkcs5.mjs","names":[],"sources":["../src/AesPkcs5.ts"],"sourcesContent":["import crypto from \"crypto\";\n\n/**\n * Utility class for the AES-128/256 encryption.\n *\n * - AES-128/256\n * - CBC mode\n * - PKCS#5 Padding\n * - Base64 Encoding\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport namespace AesPkcs5 {\n  /**\n   * Encrypt data\n   *\n   * @param data Target data\n   * @param key Key value of the encryption.\n   * @param iv Initializer Vector for the encryption\n   * @returns Encrypted data\n   */\n  export function encrypt(data: string, key: string, iv: string): string {\n    const bytes: number = key.length * 8;\n    const cipher = crypto.createCipheriv(`AES-${bytes}-CBC`, key, iv);\n    return cipher.update(data, \"utf8\", \"base64\") + cipher.final(\"base64\");\n  }\n\n  /**\n   * Decrypt data.\n   *\n   * @param data Target data\n   * @param key Key value of the decryption.\n   * @param iv Initializer Vector for the decryption\n   * @returns Decrypted data.\n   */\n  export function decrypt(data: string, key: string, iv: string): string {\n    const bytes: number = key.length * 8;\n    const decipher = crypto.createDecipheriv(`AES-${bytes}-CBC`, key, iv);\n    return decipher.update(data, \"base64\", \"utf8\") + decipher.final(\"utf8\");\n  }\n}\n"],"mappings":";;AAYO,IAAA;;CASE,SAAS,QAAQ,MAAc,KAAa,IAAoB;EACrE,MAAM,QAAgB,IAAI,SAAS;EACnC,MAAM,SAAS,OAAO,eAAe,OAAO,MAAM,OAAO,KAAK,EAAE;EAChE,OAAO,OAAO,OAAO,MAAM,QAAQ,QAAQ,IAAI,OAAO,MAAM,QAAQ;CACtE;;CAUO,SAAS,QAAQ,MAAc,KAAa,IAAoB;EACrE,MAAM,QAAgB,IAAI,SAAS;EACnC,MAAM,WAAW,OAAO,iBAAiB,OAAO,MAAM,OAAO,KAAK,EAAE;EACpE,OAAO,SAAS,OAAO,MAAM,UAAU,MAAM,IAAI,SAAS,MAAM,MAAM;CACxE;;GACD,aAAA,WAAA,CAAA,EAAD"}
+{"version":3,"file":"AesPkcs5.mjs","names":[],"sources":["../src/AesPkcs5.ts"],"sourcesContent":["import crypto from \"crypto\";\n\n/**\n * Utilities for AES-CBC encryption.\n *\n * - AES-128/192/256\n * - CBC mode\n * - PKCS#5 Padding\n * - Base64 Encoding\n *\n * The key and the initializer vector are strings that Node reads as UTF-8\n * bytes. The variant is chosen by the key's byte length: 16, 24, and 32 bytes\n * select AES-128, AES-192, and AES-256, and any other length is refused by the\n * cipher.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @evidence contracts/common.md#principled-implementation The functions call Node's `createCipheriv` and `createDecipheriv` with AES in CBC mode, whose default padding is PKCS#5/PKCS#7, and exchange base64 text; the variant is derived from the key's UTF-8 byte length, which is the length Node actually reads, so a key of 16, 24, or 32 bytes selects AES-128, AES-192, or AES-256 and any other length is refused by the cipher. CBC carries no authentication tag, so the format offers confidentiality without integrity; the mode and encoding are fixed by the wire format `@nestia/core`'s encrypted decorators use, so this namespace cannot change them alone.\n * @evidence contracts/common.md#clear-and-simple-design Two functions with the same three inputs and no state; the variant selection is one expression in each because the two directions share nothing else.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The primitives are the platform's crypto module with no custom cipher, padding, or key derivation; nothing is hardcoded to a key or an initializer vector.\n * @evidence contracts/common.md#meaningful-documentation The comment names the algorithm, the mode, the padding, and the encoding, and states how the key length selects the variant.\n */\nexport namespace AesPkcs5 {\n  /**\n   * Encrypt data\n   *\n   * @param data Target data\n   * @param key Key value of the encryption.\n   * @param iv Initializer Vector for the encryption\n   * @returns Encrypted data\n   * @evidence contracts/common.md#principled-implementation The plain text is read as UTF-8, encrypted in CBC mode with the key and the initializer vector, and emitted as base64 by concatenating the update and final outputs, so the result decrypts to the same text with the same key and vector.\n   * @evidence contracts/common.md#clear-and-simple-design A single expression over one cipher object, with the cipher name derived from the key in the line above.\n   * @evidence contracts/common.md#prohibited-implementation-shortcuts The key and the vector come only from the caller, and a key of unsupported size makes Node throw instead of being padded or truncated.\n   * @evidence contracts/common.md#meaningful-documentation The parameters and the return value are documented, and the namespace comment states the byte-length rule for the key.\n   */\n  export function encrypt(data: string, key: string, iv: string): string {\n    const bytes: number = Buffer.byteLength(key, \"utf8\") * 8;\n    const cipher = crypto.createCipheriv(`AES-${bytes}-CBC`, key, iv);\n    return cipher.update(data, \"utf8\", \"base64\") + cipher.final(\"base64\");\n  }\n\n  /**\n   * Decrypt data.\n   *\n   * @param data Target data\n   * @param key Key value of the decryption.\n   * @param iv Initializer Vector for the decryption\n   * @returns Decrypted data.\n   * @evidence contracts/common.md#principled-implementation The base64 text is decrypted in CBC mode with the key and the initializer vector, and the update and final outputs are concatenated as UTF-8, so `decrypt(encrypt(x))` returns `x`; wrong keys or corrupted text make the final block check throw rather than return garbage silently in the usual case, although CBC without a tag cannot detect every alteration.\n   * @evidence contracts/common.md#clear-and-simple-design A single expression over one decipher object, mirroring `encrypt`.\n   * @evidence contracts/common.md#prohibited-implementation-shortcuts It uses the platform's decipher and does not catch its errors, so a padding or key failure reaches the caller.\n   * @evidence contracts/common.md#meaningful-documentation The parameters and the return value are documented, and the namespace comment states the byte-length rule for the key.\n   */\n  export function decrypt(data: string, key: string, iv: string): string {\n    const bytes: number = Buffer.byteLength(key, \"utf8\") * 8;\n    const decipher = crypto.createDecipheriv(`AES-${bytes}-CBC`, key, iv);\n    return decipher.update(data, \"base64\", \"utf8\") + decipher.final(\"utf8\");\n  }\n}\n"],"mappings":";;AAqBO,IAAA;;CAaE,SAAS,QAAQ,MAAc,KAAa,IAAoB;EACrE,MAAM,QAAgB,OAAO,WAAW,KAAK,MAAM,IAAI;EACvD,MAAM,SAAS,OAAO,eAAe,OAAO,MAAM,OAAO,KAAK,EAAE;EAChE,OAAO,OAAO,OAAO,MAAM,QAAQ,QAAQ,IAAI,OAAO,MAAM,QAAQ;CACtE;;CAcO,SAAS,QAAQ,MAAc,KAAa,IAAoB;EACrE,MAAM,QAAgB,OAAO,WAAW,KAAK,MAAM,IAAI;EACvD,MAAM,WAAW,OAAO,iBAAiB,OAAO,MAAM,OAAO,KAAK,EAAE;EACpE,OAAO,SAAS,OAAO,MAAM,UAAU,MAAM,IAAI,SAAS,MAAM,MAAM;CACxE;;GACD,aAAA,WAAA,CAAA,EAAD"}

package/lib/EncryptedFetcher.d.ts

@@ -1,6 +1,5 @@
 import { IConnection } from "./IConnection";
 import { IFetchRoute } from "./IFetchRoute";
-import { IPropagation } from "./IPropagation";
 /**
  * Utility class for `fetch` functions used in `@nestia/sdk` with encryption.
  *
@@ -16,6 +15,10 @@ import { IPropagation } from "./IPropagation";
  * {@link PlainFetcher} class would be used instead.
  *
  * @author Jeongho Nam - https://github.com/samchon
+ * @evidence contracts/common.md#principled-implementation A per-call codec encrypts the request body only when the route declares its request encrypted and decrypts the response body only when the route declares its response encrypted; the password is read from the connection, directly or through a closure that receives the headers, the body text, and the direction, where the body is the serialized plain text when encoding and the received cipher text when decoding, as on the server, and the request pipeline itself is shared with `PlainFetcher`.
+ * @evidence contracts/common.md#clear-and-simple-design Two public operations, `fetch` and `propagate`, share one private `codec` builder, so the encryption policy exists once and the transport lives in `FetcherBase`.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No route, header, or key is special-cased: encryption follows the route metadata that `@nestia/sdk` generates, and a missing password is a thrown error rather than a silent plain request.
+ * @evidence contracts/common.md#meaningful-documentation The namespace prose says when the generated SDK uses this fetcher instead of `PlainFetcher`.
  */
 export declare namespace EncryptedFetcher {
     /**
@@ -24,6 +27,10 @@ export declare namespace EncryptedFetcher {
      * @param connection Connection information for the remote HTTP server
      * @param route Route information about the target API
      * @returns Nothing because of `HEAD` method
+     * @evidence contracts/common.md#principled-implementation The overloads narrow the route method to the argument list and return type that method allows; the implementation builds the codec, which throws before any request when an encrypted route has no password, and delegates to `FetcherBase.request`, which returns the body on success and throws `HttpError` otherwise.
+     * @evidence contracts/common.md#clear-and-simple-design The implementation is one delegation, and the overloads exist only for the type-level split between `HEAD`, `GET`, and the body methods.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The function gates on the route's declared encryption and adds no branch for a particular path or password.
+     * @evidence contracts/common.md#meaningful-documentation Each overload documents its parameters and return value.
      */
     function fetch(connection: IConnection, route: IFetchRoute<"HEAD">): Promise<void>;
     /**
@@ -42,6 +49,30 @@ export declare namespace EncryptedFetcher {
      * @returns Response body data from the remote API
      */
     function fetch<Input, Output>(connection: IConnection, route: IFetchRoute<"POST" | "PUT" | "PATCH" | "DELETE">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;
-    function propagate<Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<"GET" | "HEAD">): Promise<Output>;
-    function propagate<Input, Output extends IPropagation<any, any>>(connection: IConnection, route: IFetchRoute<"DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;
+    /**
+     * Fetch function that returns every response as an {@link IPropagation},
+     * encrypting and decrypting the bodies the route declares encrypted.
+     *
+     * An HTTP failure status is returned as a failed branch instead of being
+     * thrown. A missing encryption password and a transport failure still throw.
+     * The output must describe numeric status branches with boolean success and
+     * string or string-array headers; its data type remains caller-owned.
+     *
+     * @evidence contracts/common.md#principled-implementation It builds the same codec as `fetch` and delegates to `FetcherBase.propagate`. Its structural branch constraint accepts numeric literal successes, numeric range failures and unknown-status fallback without instantiating a status map with any, while requiring boolean success and actual numeric status/header shapes.
+     * @evidence contracts/common.md#clear-and-simple-design The implementation is one delegation to the shared pipeline, and the overloads only split the argument types by method.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The function adds no status-specific branch: the success flag comes from the status rules in `FetcherBase`.
+     * @evidence contracts/common.md#meaningful-documentation The comment states what the returned union carries and which failures still throw.
+     */
+    function propagate<Output extends {
+        success: boolean;
+        status: number;
+        headers: Record<string, string | string[]>;
+        data: unknown;
+    }>(connection: IConnection, route: IFetchRoute<"GET" | "HEAD">): Promise<Output>;
+    function propagate<Input, Output extends {
+        success: boolean;
+        status: number;
+        headers: Record<string, string | string[]>;
+        data: unknown;
+    }>(connection: IConnection, route: IFetchRoute<"DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT">, input?: Input, stringify?: (input: Input) => string): Promise<Output>;
 }

package/lib/EncryptedFetcher.js

@@ -27,72 +27,62 @@ const FetcherBase_1 = require("./internal/FetcherBase");
  * {@link PlainFetcher} class would be used instead.
  *
  * @author Jeongho Nam - https://github.com/samchon
+ * @evidence contracts/common.md#principled-implementation A per-call codec encrypts the request body only when the route declares its request encrypted and decrypts the response body only when the route declares its response encrypted; the password is read from the connection, directly or through a closure that receives the headers, the body text, and the direction, where the body is the serialized plain text when encoding and the received cipher text when decoding, as on the server, and the request pipeline itself is shared with `PlainFetcher`.
+ * @evidence contracts/common.md#clear-and-simple-design Two public operations, `fetch` and `propagate`, share one private `codec` builder, so the encryption policy exists once and the transport lives in `FetcherBase`.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No route, header, or key is special-cased: encryption follows the route metadata that `@nestia/sdk` generates, and a missing password is a thrown error rather than a silent plain request.
+ * @evidence contracts/common.md#meaningful-documentation The namespace prose says when the generated SDK uses this fetcher instead of `PlainFetcher`.
  */
 var EncryptedFetcher;
 (function (EncryptedFetcher) {
     function fetch(connection, route, input, stringify) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            if ((((_a = route.request) === null || _a === void 0 ? void 0 : _a.encrypted) === true || ((_b = route.response) === null || _b === void 0 ? void 0 : _b.encrypted)) &&
-                connection.encryption === undefined)
-                throw new Error("Error on EncryptedFetcher.fetch(): the encryption password has not been configured.");
-            const closure = typeof connection.encryption === "function"
-                ? (direction) => (headers, body) => connection.encryption({
-                    headers,
-                    body,
-                    direction,
-                })
-                : () => () => connection.encryption;
-            return FetcherBase_1.FetcherBase.request({
-                className: "EncryptedFetcher",
-                encode: ((_c = route.request) === null || _c === void 0 ? void 0 : _c.encrypted) === true
-                    ? (input, headers) => {
-                        const p = closure("encode")(headers, input);
-                        return AesPkcs5_1.AesPkcs5.encrypt((stringify !== null && stringify !== void 0 ? stringify : JSON.stringify)(input), p.key, p.iv);
-                    }
-                    : (input) => input,
-                decode: ((_d = route.response) === null || _d === void 0 ? void 0 : _d.encrypted) === true
-                    ? (input, headers) => {
-                        const p = closure("decode")(headers, input);
-                        const s = AesPkcs5_1.AesPkcs5.decrypt(input, p.key, p.iv);
-                        return s.length ? JSON.parse(s) : s;
-                    }
-                    : (input) => input,
-            })(connection, route, input, stringify);
+            return FetcherBase_1.FetcherBase.request(codec({ method: "fetch", connection, route, stringify }))(connection, route, input, stringify);
         });
     }
     EncryptedFetcher.fetch = fetch;
     function propagate(connection, route, input, stringify) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            if ((((_a = route.request) === null || _a === void 0 ? void 0 : _a.encrypted) === true || ((_b = route.response) === null || _b === void 0 ? void 0 : _b.encrypted)) &&
-                connection.encryption === undefined)
-                throw new Error("Error on EncryptedFetcher.propagate(): the encryption password has not been configured.");
-            const closure = typeof connection.encryption === "function"
-                ? (direction) => (headers, body) => connection.encryption({
-                    headers,
-                    body,
-                    direction,
-                })
-                : () => () => connection.encryption;
-            return FetcherBase_1.FetcherBase.propagate({
-                className: "EncryptedFetcher",
-                encode: ((_c = route.request) === null || _c === void 0 ? void 0 : _c.encrypted) === true
-                    ? (input, headers) => {
-                        const p = closure("encode")(headers, input);
-                        return AesPkcs5_1.AesPkcs5.encrypt((stringify !== null && stringify !== void 0 ? stringify : JSON.stringify)(input), p.key, p.iv);
-                    }
-                    : (input) => input,
-                decode: ((_d = route.response) === null || _d === void 0 ? void 0 : _d.encrypted) === true
-                    ? (input, headers) => {
-                        const p = closure("decode")(headers, input);
-                        const s = AesPkcs5_1.AesPkcs5.decrypt(input, p.key, p.iv);
-                        return s.length ? JSON.parse(s) : s;
-                    }
-                    : (input) => input,
-            })(connection, route, input, stringify);
+            return FetcherBase_1.FetcherBase.propagate(codec({ method: "propagate", connection, route, stringify }))(connection, route, input, stringify);
         });
     }
     EncryptedFetcher.propagate = propagate;
+    /**
+     * Builds the body codec of one call: encrypt the request body when the route
+     * declares it encrypted, and decrypt the response body likewise.
+     *
+     * Refuses the call before any request when the route needs a password and the
+     * connection has none.
+     */
+    const codec = (props) => {
+        var _a, _b, _c, _d;
+        const { connection, route, stringify } = props;
+        if ((((_a = route.request) === null || _a === void 0 ? void 0 : _a.encrypted) === true || ((_b = route.response) === null || _b === void 0 ? void 0 : _b.encrypted)) &&
+            connection.encryption === undefined)
+            throw new Error(`Error on EncryptedFetcher.${props.method}(): the encryption password has not been configured.`);
+        const closure = typeof connection.encryption === "function"
+            ? (direction) => (headers, body) => connection.encryption({
+                headers,
+                body,
+                direction,
+            })
+            : () => () => connection.encryption;
+        return {
+            className: "EncryptedFetcher",
+            encode: ((_c = route.request) === null || _c === void 0 ? void 0 : _c.encrypted) === true
+                ? (input, headers) => {
+                    const text = (stringify !== null && stringify !== void 0 ? stringify : JSON.stringify)(input);
+                    const p = closure("encode")(headers, text);
+                    return AesPkcs5_1.AesPkcs5.encrypt(text, p.key, p.iv);
+                }
+                : (input) => input,
+            decode: ((_d = route.response) === null || _d === void 0 ? void 0 : _d.encrypted) === true
+                ? (input, headers) => {
+                    const p = closure("decode")(headers, input);
+                    const s = AesPkcs5_1.AesPkcs5.decrypt(input, p.key, p.iv);
+                    return s.length ? JSON.parse(s) : s;
+                }
+                : (input) => input,
+        };
+    };
 })(EncryptedFetcher || (exports.EncryptedFetcher = EncryptedFetcher = {}));
 //# sourceMappingURL=EncryptedFetcher.js.map

package/lib/EncryptedFetcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"EncryptedFetcher.js","sourceRoot":"","sources":["../src/EncryptedFetcher.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"EncryptedFetcher.js","sourceRoot":"","sources":["../src/EncryptedFetcher.ts"],"names":[],"mappings":"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"}

package/lib/EncryptedFetcher.mjs

@@ -4,47 +4,52 @@ import { FetcherBase } from "./internal/FetcherBase.mjs";
 let EncryptedFetcher;
 (function(_EncryptedFetcher) {
 	async function fetch(connection, route, input, stringify) {
-		if ((route.request?.encrypted === true || route.response?.encrypted) && connection.encryption === void 0) throw new Error("Error on EncryptedFetcher.fetch(): the encryption password has not been configured.");
-		const closure = typeof connection.encryption === "function" ? (direction) => (headers, body) => connection.encryption({
-			headers,
-			body,
-			direction
-		}) : () => () => connection.encryption;
-		return FetcherBase.request({
-			className: "EncryptedFetcher",
-			encode: route.request?.encrypted === true ? (input, headers) => {
-				const p = closure("encode")(headers, input);
-				return AesPkcs5.encrypt((stringify ?? JSON.stringify)(input), p.key, p.iv);
-			} : (input) => input,
-			decode: route.response?.encrypted === true ? (input, headers) => {
-				const p = closure("decode")(headers, input);
-				const s = AesPkcs5.decrypt(input, p.key, p.iv);
-				return s.length ? JSON.parse(s) : s;
-			} : (input) => input
-		})(connection, route, input, stringify);
+		return FetcherBase.request(codec({
+			method: "fetch",
+			connection,
+			route,
+			stringify
+		}))(connection, route, input, stringify);
 	}
 	_EncryptedFetcher.fetch = fetch;
 	async function propagate(connection, route, input, stringify) {
-		if ((route.request?.encrypted === true || route.response?.encrypted) && connection.encryption === void 0) throw new Error("Error on EncryptedFetcher.propagate(): the encryption password has not been configured.");
+		return FetcherBase.propagate(codec({
+			method: "propagate",
+			connection,
+			route,
+			stringify
+		}))(connection, route, input, stringify);
+	}
+	_EncryptedFetcher.propagate = propagate;
+	/**
+	* Builds the body codec of one call: encrypt the request body when the route
+	* declares it encrypted, and decrypt the response body likewise.
+	*
+	* Refuses the call before any request when the route needs a password and the
+	* connection has none.
+	*/
+	const codec = (props) => {
+		const { connection, route, stringify } = props;
+		if ((route.request?.encrypted === true || route.response?.encrypted) && connection.encryption === void 0) throw new Error(`Error on EncryptedFetcher.${props.method}(): the encryption password has not been configured.`);
 		const closure = typeof connection.encryption === "function" ? (direction) => (headers, body) => connection.encryption({
 			headers,
 			body,
 			direction
 		}) : () => () => connection.encryption;
-		return FetcherBase.propagate({
+		return {
 			className: "EncryptedFetcher",
 			encode: route.request?.encrypted === true ? (input, headers) => {
-				const p = closure("encode")(headers, input);
-				return AesPkcs5.encrypt((stringify ?? JSON.stringify)(input), p.key, p.iv);
+				const text = (stringify ?? JSON.stringify)(input);
+				const p = closure("encode")(headers, text);
+				return AesPkcs5.encrypt(text, p.key, p.iv);
 			} : (input) => input,
 			decode: route.response?.encrypted === true ? (input, headers) => {
 				const p = closure("decode")(headers, input);
 				const s = AesPkcs5.decrypt(input, p.key, p.iv);
 				return s.length ? JSON.parse(s) : s;
 			} : (input) => input
-		})(connection, route, input, stringify);
-	}
-	_EncryptedFetcher.propagate = propagate;
+		};
+	};
 })(EncryptedFetcher || (EncryptedFetcher = {}));
 //#endregion
 export { EncryptedFetcher };

package/lib/EncryptedFetcher.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"EncryptedFetcher.mjs","names":[],"sources":["../src/EncryptedFetcher.ts"],"sourcesContent":["import { AesPkcs5 } from \"./AesPkcs5\";\nimport { IConnection } from \"./IConnection\";\nimport { IEncryptionPassword } from \"./IEncryptionPassword\";\nimport { IFetchRoute } from \"./IFetchRoute\";\nimport { IPropagation } from \"./IPropagation\";\nimport { FetcherBase } from \"./internal/FetcherBase\";\n\n/**\n * Utility class for `fetch` functions used in `@nestia/sdk` with encryption.\n *\n * `EncryptedFetcher` is a utility class designed for SDK functions generated by\n * [`@nestia/sdk`](https://nestia.io/docs/sdk/sdk), interacting with the remote\n * HTTP API encrypted by AES-PKCS algorithm. In other words, this is a\n * collection of dedicated `fetch()` functions for `@nestia/sdk` with\n * encryption.\n *\n * For reference, `EncryptedFetcher` class being used only when target\n * controller method is encrypting body data by `@EncryptedRoute` or\n * `@EncryptedBody` decorators. If those decorators are not used,\n * {@link PlainFetcher} class would be used instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n */\nexport namespace EncryptedFetcher {\n  /**\n   * Fetch function only for `HEAD` method.\n   *\n   * @param connection Connection information for the remote HTTP server\n   * @param route Route information about the target API\n   * @returns Nothing because of `HEAD` method\n   */\n  export function fetch(\n    connection: IConnection,\n    route: IFetchRoute<\"HEAD\">,\n  ): Promise<void>;\n\n  /**\n   * Fetch function only for `GET` method.\n   *\n   * @param connection Connection information for the remote HTTP server\n   * @param route Route information about the target API\n   * @returns Response body data from the remote API\n   */\n  export function fetch<Output>(\n    connection: IConnection,\n    route: IFetchRoute<\"GET\">,\n  ): Promise<Output>;\n\n  /**\n   * Fetch function for the `POST`, `PUT`, `PATCH` and `DELETE` methods.\n   *\n   * @param connection Connection information for the remote HTTP server\n   * @param route Route information about the target API\n   * @returns Response body data from the remote API\n   */\n  export function fetch<Input, Output>(\n    connection: IConnection,\n    route: IFetchRoute<\"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\">,\n    input?: Input,\n    stringify?: (input: Input) => string,\n  ): Promise<Output>;\n\n  export async function fetch<Input, Output>(\n    connection: IConnection,\n    route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">,\n    input?: Input,\n    stringify?: (input: Input) => string,\n  ): Promise<Output> {\n    if (\n      (route.request?.encrypted === true || route.response?.encrypted) &&\n      connection.encryption === undefined\n    )\n      throw new Error(\n        \"Error on EncryptedFetcher.fetch(): the encryption password has not been configured.\",\n      );\n    const closure =\n      typeof connection.encryption === \"function\"\n        ? (direction: \"encode\" | \"decode\") =>\n            (\n              headers: Record<string, IConnection.HeaderValue | undefined>,\n              body: string,\n            ) =>\n              (connection.encryption as IEncryptionPassword.Closure)({\n                headers,\n                body,\n                direction,\n              })\n        : () => () => connection.encryption as IEncryptionPassword;\n\n    return FetcherBase.request({\n      className: \"EncryptedFetcher\",\n      encode:\n        route.request?.encrypted === true\n          ? (input, headers) => {\n              const p: IEncryptionPassword = closure(\"encode\")(headers, input);\n              return AesPkcs5.encrypt(\n                (stringify ?? JSON.stringify)(input),\n                p.key,\n                p.iv,\n              );\n            }\n          : (input) => input,\n      decode:\n        route.response?.encrypted === true\n          ? (input, headers) => {\n              const p: IEncryptionPassword = closure(\"decode\")(headers, input);\n              const s: string = AesPkcs5.decrypt(input, p.key, p.iv);\n              return s.length ? JSON.parse(s) : s;\n            }\n          : (input) => input,\n    })(connection, route, input, stringify);\n  }\n\n  export function propagate<Output extends IPropagation<any, any>>(\n    connection: IConnection,\n    route: IFetchRoute<\"GET\" | \"HEAD\">,\n  ): Promise<Output>;\n\n  export function propagate<Input, Output extends IPropagation<any, any>>(\n    connection: IConnection,\n    route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">,\n    input?: Input,\n    stringify?: (input: Input) => string,\n  ): Promise<Output>;\n\n  export async function propagate<Input, Output extends IPropagation<any, any>>(\n    connection: IConnection,\n    route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">,\n    input?: Input,\n    stringify?: (input: Input) => string,\n  ): Promise<Output> {\n    if (\n      (route.request?.encrypted === true || route.response?.encrypted) &&\n      connection.encryption === undefined\n    )\n      throw new Error(\n        \"Error on EncryptedFetcher.propagate(): the encryption password has not been configured.\",\n      );\n    const closure =\n      typeof connection.encryption === \"function\"\n        ? (direction: \"encode\" | \"decode\") =>\n            (\n              headers: Record<string, IConnection.HeaderValue | undefined>,\n              body: string,\n            ) =>\n              (connection.encryption as IEncryptionPassword.Closure)({\n                headers,\n                body,\n                direction,\n              })\n        : () => () => connection.encryption as IEncryptionPassword;\n\n    return FetcherBase.propagate({\n      className: \"EncryptedFetcher\",\n      encode:\n        route.request?.encrypted === true\n          ? (input, headers) => {\n              const p: IEncryptionPassword = closure(\"encode\")(headers, input);\n              return AesPkcs5.encrypt(\n                (stringify ?? JSON.stringify)(input),\n                p.key,\n                p.iv,\n              );\n            }\n          : (input) => input,\n      decode:\n        route.response?.encrypted === true\n          ? (input, headers) => {\n              const p: IEncryptionPassword = closure(\"decode\")(headers, input);\n              const s: string = AesPkcs5.decrypt(input, p.key, p.iv);\n              return s.length ? JSON.parse(s) : s;\n            }\n          : (input) => input,\n    })(connection, route, input, stringify) as Promise<Output>;\n  }\n}\n"],"mappings":";;;AAuBO,IAAA;;CAuCE,eAAe,MACpB,YACA,OACA,OACA,WACiB;EACjB,KACG,MAAM,SAAS,cAAc,QAAQ,MAAM,UAAU,cACtD,WAAW,eAAe,KAAA,GAE1B,MAAM,IAAI,MACR,qFACF;EACF,MAAM,UACJ,OAAO,WAAW,eAAe,cAC5B,eAEG,SACA,SAEC,WAAW,WAA2C;GACrD;GACA;GACA;EACF,CAAC,gBACO,WAAW;EAE7B,OAAO,YAAY,QAAQ;GACzB,WAAW;GACX,QACE,MAAM,SAAS,cAAc,QACxB,OAAO,YAAY;IAClB,MAAM,IAAyB,QAAQ,QAAQ,CAAC,CAAC,SAAS,KAAK;IAC/D,OAAO,SAAS,SACb,aAAa,KAAK,UAAA,CAAW,KAAK,GACnC,EAAE,KACF,EAAE,EACJ;GACF,KACC,UAAU;GACjB,QACE,MAAM,UAAU,cAAc,QACzB,OAAO,YAAY;IAClB,MAAM,IAAyB,QAAQ,QAAQ,CAAC,CAAC,SAAS,KAAK;IAC/D,MAAM,IAAY,SAAS,QAAQ,OAAO,EAAE,KAAK,EAAE,EAAE;IACrD,OAAO,EAAE,SAAS,KAAK,MAAM,CAAC,IAAI;GACpC,KACC,UAAU;EACnB,CAAC,CAAC,CAAC,YAAY,OAAO,OAAO,SAAS;CACxC;;CAcO,eAAe,UACpB,YACA,OACA,OACA,WACiB;EACjB,KACG,MAAM,SAAS,cAAc,QAAQ,MAAM,UAAU,cACtD,WAAW,eAAe,KAAA,GAE1B,MAAM,IAAI,MACR,yFACF;EACF,MAAM,UACJ,OAAO,WAAW,eAAe,cAC5B,eAEG,SACA,SAEC,WAAW,WAA2C;GACrD;GACA;GACA;EACF,CAAC,gBACO,WAAW;EAE7B,OAAO,YAAY,UAAU;GAC3B,WAAW;GACX,QACE,MAAM,SAAS,cAAc,QACxB,OAAO,YAAY;IAClB,MAAM,IAAyB,QAAQ,QAAQ,CAAC,CAAC,SAAS,KAAK;IAC/D,OAAO,SAAS,SACb,aAAa,KAAK,UAAA,CAAW,KAAK,GACnC,EAAE,KACF,EAAE,EACJ;GACF,KACC,UAAU;GACjB,QACE,MAAM,UAAU,cAAc,QACzB,OAAO,YAAY;IAClB,MAAM,IAAyB,QAAQ,QAAQ,CAAC,CAAC,SAAS,KAAK;IAC/D,MAAM,IAAY,SAAS,QAAQ,OAAO,EAAE,KAAK,EAAE,EAAE;IACrD,OAAO,EAAE,SAAS,KAAK,MAAM,CAAC,IAAI;GACpC,KACC,UAAU;EACnB,CAAC,CAAC,CAAC,YAAY,OAAO,OAAO,SAAS;CACxC;;GACD,qBAAA,mBAAA,CAAA,EAAD"}
+{"version":3,"file":"EncryptedFetcher.mjs","names":[],"sources":["../src/EncryptedFetcher.ts"],"sourcesContent":["import { AesPkcs5 } from \"./AesPkcs5\";\nimport { IConnection } from \"./IConnection\";\nimport { IEncryptionPassword } from \"./IEncryptionPassword\";\nimport { IFetchRoute } from \"./IFetchRoute\";\nimport { IPropagation } from \"./IPropagation\";\nimport { FetcherBase } from \"./internal/FetcherBase\";\n\n/**\n * Utility class for `fetch` functions used in `@nestia/sdk` with encryption.\n *\n * `EncryptedFetcher` is a utility class designed for SDK functions generated by\n * [`@nestia/sdk`](https://nestia.io/docs/sdk/sdk), interacting with the remote\n * HTTP API encrypted by AES-PKCS algorithm. In other words, this is a\n * collection of dedicated `fetch()` functions for `@nestia/sdk` with\n * encryption.\n *\n * For reference, `EncryptedFetcher` class being used only when target\n * controller method is encrypting body data by `@EncryptedRoute` or\n * `@EncryptedBody` decorators. If those decorators are not used,\n * {@link PlainFetcher} class would be used instead.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @evidence contracts/common.md#principled-implementation A per-call codec encrypts the request body only when the route declares its request encrypted and decrypts the response body only when the route declares its response encrypted; the password is read from the connection, directly or through a closure that receives the headers, the body text, and the direction, where the body is the serialized plain text when encoding and the received cipher text when decoding, as on the server, and the request pipeline itself is shared with `PlainFetcher`.\n * @evidence contracts/common.md#clear-and-simple-design Two public operations, `fetch` and `propagate`, share one private `codec` builder, so the encryption policy exists once and the transport lives in `FetcherBase`.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts No route, header, or key is special-cased: encryption follows the route metadata that `@nestia/sdk` generates, and a missing password is a thrown error rather than a silent plain request.\n * @evidence contracts/common.md#meaningful-documentation The namespace prose says when the generated SDK uses this fetcher instead of `PlainFetcher`.\n */\nexport namespace EncryptedFetcher {\n  /**\n   * Fetch function only for `HEAD` method.\n   *\n   * @param connection Connection information for the remote HTTP server\n   * @param route Route information about the target API\n   * @returns Nothing because of `HEAD` method\n   * @evidence contracts/common.md#principled-implementation The overloads narrow the route method to the argument list and return type that method allows; the implementation builds the codec, which throws before any request when an encrypted route has no password, and delegates to `FetcherBase.request`, which returns the body on success and throws `HttpError` otherwise.\n   * @evidence contracts/common.md#clear-and-simple-design The implementation is one delegation, and the overloads exist only for the type-level split between `HEAD`, `GET`, and the body methods.\n   * @evidence contracts/common.md#prohibited-implementation-shortcuts The function gates on the route's declared encryption and adds no branch for a particular path or password.\n   * @evidence contracts/common.md#meaningful-documentation Each overload documents its parameters and return value.\n   */\n  export function fetch(\n    connection: IConnection,\n    route: IFetchRoute<\"HEAD\">,\n  ): Promise<void>;\n\n  /**\n   * Fetch function only for `GET` method.\n   *\n   * @param connection Connection information for the remote HTTP server\n   * @param route Route information about the target API\n   * @returns Response body data from the remote API\n   */\n  export function fetch<Output>(\n    connection: IConnection,\n    route: IFetchRoute<\"GET\">,\n  ): Promise<Output>;\n\n  /**\n   * Fetch function for the `POST`, `PUT`, `PATCH` and `DELETE` methods.\n   *\n   * @param connection Connection information for the remote HTTP server\n   * @param route Route information about the target API\n   * @returns Response body data from the remote API\n   */\n  export function fetch<Input, Output>(\n    connection: IConnection,\n    route: IFetchRoute<\"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\">,\n    input?: Input,\n    stringify?: (input: Input) => string,\n  ): Promise<Output>;\n\n  export async function fetch<Input, Output>(\n    connection: IConnection,\n    route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">,\n    input?: Input,\n    stringify?: (input: Input) => string,\n  ): Promise<Output> {\n    return FetcherBase.request(\n      codec({ method: \"fetch\", connection, route, stringify }),\n    )(connection, route, input, stringify);\n  }\n\n  /**\n   * Fetch function that returns every response as an {@link IPropagation},\n   * encrypting and decrypting the bodies the route declares encrypted.\n   *\n   * An HTTP failure status is returned as a failed branch instead of being\n   * thrown. A missing encryption password and a transport failure still throw.\n   * The output must describe numeric status branches with boolean success and\n   * string or string-array headers; its data type remains caller-owned.\n   *\n   * @evidence contracts/common.md#principled-implementation It builds the same codec as `fetch` and delegates to `FetcherBase.propagate`. Its structural branch constraint accepts numeric literal successes, numeric range failures and unknown-status fallback without instantiating a status map with any, while requiring boolean success and actual numeric status/header shapes.\n   * @evidence contracts/common.md#clear-and-simple-design The implementation is one delegation to the shared pipeline, and the overloads only split the argument types by method.\n   * @evidence contracts/common.md#prohibited-implementation-shortcuts The function adds no status-specific branch: the success flag comes from the status rules in `FetcherBase`.\n   * @evidence contracts/common.md#meaningful-documentation The comment states what the returned union carries and which failures still throw.\n   */\n  export function propagate<\n    Output extends {\n      success: boolean;\n      status: number;\n      headers: Record<string, string | string[]>;\n      data: unknown;\n    },\n  >(\n    connection: IConnection,\n    route: IFetchRoute<\"GET\" | \"HEAD\">,\n  ): Promise<Output>;\n\n  export function propagate<\n    Input,\n    Output extends {\n      success: boolean;\n      status: number;\n      headers: Record<string, string | string[]>;\n      data: unknown;\n    },\n  >(\n    connection: IConnection,\n    route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">,\n    input?: Input,\n    stringify?: (input: Input) => string,\n  ): Promise<Output>;\n\n  export async function propagate<\n    Input,\n    Output extends {\n      success: boolean;\n      status: number;\n      headers: Record<string, string | string[]>;\n      data: unknown;\n    },\n  >(\n    connection: IConnection,\n    route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">,\n    input?: Input,\n    stringify?: (input: Input) => string,\n  ): Promise<Output> {\n    return FetcherBase.propagate(\n      codec({ method: \"propagate\", connection, route, stringify }),\n    )(connection, route, input, stringify) as Promise<Output>;\n  }\n\n  /**\n   * Builds the body codec of one call: encrypt the request body when the route\n   * declares it encrypted, and decrypt the response body likewise.\n   *\n   * Refuses the call before any request when the route needs a password and the\n   * connection has none.\n   */\n  const codec = <Input>(props: {\n    method: \"fetch\" | \"propagate\";\n    connection: IConnection;\n    route: IFetchRoute<\"DELETE\" | \"GET\" | \"HEAD\" | \"PATCH\" | \"POST\" | \"PUT\">;\n    stringify: ((input: Input) => string) | undefined;\n  }): FetcherBase.IProps => {\n    const { connection, route, stringify } = props;\n    if (\n      (route.request?.encrypted === true || route.response?.encrypted) &&\n      connection.encryption === undefined\n    )\n      throw new Error(\n        `Error on EncryptedFetcher.${props.method}(): the encryption password has not been configured.`,\n      );\n    const closure =\n      typeof connection.encryption === \"function\"\n        ? (direction: \"encode\" | \"decode\") =>\n            (\n              headers: Record<string, IConnection.HeaderValue | undefined>,\n              body: string,\n            ) =>\n              (connection.encryption as IEncryptionPassword.Closure)({\n                headers,\n                body,\n                direction,\n              })\n        : () => () => connection.encryption as IEncryptionPassword;\n    return {\n      className: \"EncryptedFetcher\",\n      encode:\n        route.request?.encrypted === true\n          ? (input, headers) => {\n              const text: string = (stringify ?? JSON.stringify)(input);\n              const p: IEncryptionPassword = closure(\"encode\")(headers, text);\n              return AesPkcs5.encrypt(text, p.key, p.iv);\n            }\n          : (input) => input,\n      decode:\n        route.response?.encrypted === true\n          ? (input, headers) => {\n              const p: IEncryptionPassword = closure(\"decode\")(headers, input);\n              const s: string = AesPkcs5.decrypt(input, p.key, p.iv);\n              return s.length ? JSON.parse(s) : s;\n            }\n          : (input) => input,\n    };\n  };\n}\n"],"mappings":";;;AA2BO,IAAA;;CA2CE,eAAe,MACpB,YACA,OACA,OACA,WACiB;EACjB,OAAO,YAAY,QACjB,MAAM;GAAE,QAAQ;GAAS;GAAY;GAAO;EAAU,CAAC,CACzD,CAAC,CAAC,YAAY,OAAO,OAAO,SAAS;CACvC;;CA2CO,eAAe,UASpB,YACA,OACA,OACA,WACiB;EACjB,OAAO,YAAY,UACjB,MAAM;GAAE,QAAQ;GAAa;GAAY;GAAO;EAAU,CAAC,CAC7D,CAAC,CAAC,YAAY,OAAO,OAAO,SAAS;CACvC;;;;;;;;;CASA,MAAM,SAAgB,UAKI;EACxB,MAAM,EAAE,YAAY,OAAO,cAAc;EACzC,KACG,MAAM,SAAS,cAAc,QAAQ,MAAM,UAAU,cACtD,WAAW,eAAe,KAAA,GAE1B,MAAM,IAAI,MACR,6BAA6B,MAAM,OAAO,qDAC5C;EACF,MAAM,UACJ,OAAO,WAAW,eAAe,cAC5B,eAEG,SACA,SAEC,WAAW,WAA2C;GACrD;GACA;GACA;EACF,CAAC,gBACO,WAAW;EAC7B,OAAO;GACL,WAAW;GACX,QACE,MAAM,SAAS,cAAc,QACxB,OAAO,YAAY;IAClB,MAAM,QAAgB,aAAa,KAAK,UAAA,CAAW,KAAK;IACxD,MAAM,IAAyB,QAAQ,QAAQ,CAAC,CAAC,SAAS,IAAI;IAC9D,OAAO,SAAS,QAAQ,MAAM,EAAE,KAAK,EAAE,EAAE;GAC3C,KACC,UAAU;GACjB,QACE,MAAM,UAAU,cAAc,QACzB,OAAO,YAAY;IAClB,MAAM,IAAyB,QAAQ,QAAQ,CAAC,CAAC,SAAS,KAAK;IAC/D,MAAM,IAAY,SAAS,QAAQ,OAAO,EAAE,KAAK,EAAE,EAAE;IACrD,OAAO,EAAE,SAAS,KAAK,MAAM,CAAC,IAAI;GACpC,KACC,UAAU;EACnB;CACF;GACD,qBAAA,mBAAA,CAAA,EAAD"}

package/lib/FormDataInput.d.ts

@@ -17,15 +17,18 @@
  * array of `File` class, it converts it to an array of union type of `File` and
  * {@link FormDataInput.IFileProps} type too.
  *
- * Before | After ----------|------------------------ `boolean` | `boolean`
- * `bigint` | `bigint` `number` | `number` `string` | `string` `File` | `File \|
- * IFileProps`
+ * Atomic fields retain their original types; file fields accept either a File
+ * or the React Native file descriptor.
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @template T Target object type.
+ * @evidence contracts/common.md#principled-implementation The mapped type delegates each field to a distributive value conversion, so file alternatives and file-array alternatives accept React Native descriptors even when optional or mixed with another field type. Arrays and functions at the outer body level become never because a form body is an object of named fields.
+ * @evidence contracts/common.md#clear-and-simple-design One conditional over the object type, delegating the per-value rule to `FormDataInput.Value`.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts It is a type and adds no runtime behavior.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the React Native motive, which fields are converted, and the platform limit of descriptors.
  */
 export type FormDataInput<T extends object> = T extends Array<any> ? never : T extends Function ? never : {
-    [P in keyof T]: T[P] extends Array<infer U> ? FormDataInput.Value<U>[] : FormDataInput.Value<T[P]>;
+    [P in keyof T]: FormDataInput.Value<T[P]>;
 };
 export declare namespace FormDataInput {
     /**
@@ -36,8 +39,13 @@ export declare namespace FormDataInput {
      * If the original value type is a `File` class, `Value<T>` converts it to an
      * union type of `File` and {@link IFileProps} type which is a structured data
      * for the URI file location in the React Native environment.
+     *
+     * @evidence contracts/common.md#principled-implementation Distribution examines each optional or union alternative separately; mutable arrays convert their immediate File elements, File becomes File or its descriptor, and other scalar alternatives retain their types.
+     * @evidence contracts/common.md#clear-and-simple-design One value conversion owns scalar and array handling, so the outer mapped type applies one rule to every field.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts It is a type and adds no runtime behavior.
+     * @evidence contracts/common.md#meaningful-documentation The comment states the conversion for `File` values.
      */
-    type Value<T> = T extends File ? T | IFileProps : T;
+    type Value<T> = T extends Array<infer U> ? (U extends File ? U | IFileProps : U)[] : T extends File ? T | IFileProps : T;
     /**
      * Properties of a file.
      *
@@ -45,19 +53,24 @@ export declare namespace FormDataInput {
      * `File` class instance in the `FormData` request.
      *
      * Just put the {@link uri URI address} of the local file system with the
-     * file's {@link name} and {@link type}. It would be casted to the `File` class
-     * instance automatically in the `FormData` request.
+     * file's {@link name} and {@link type}. React Native's FormData implementation
+     * consumes this descriptor; the fetcher does not construct a File instance.
      *
      * Note that, this `IFileProps` type works only in the React Native
      * environment. If you are developing a Web or NodeJS application, you have to
      * utilize the `File` class instance directly.
+     *
+     * @evidence contracts/common.md#principled-implementation React Native has no `File` class, so a file is described by the local URI, the file name, and the content type, which is the shape its FormData implementation accepts.
+     * @evidence contracts/common.md#clear-and-simple-design A three-field record with no behavior.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts It is a type and adds no runtime behavior.
+     * @evidence contracts/common.md#meaningful-documentation The comment states the platform limit and each field is documented.
      */
     interface IFileProps {
         /**
          * URI address of the file.
          *
          * In the React Native, the URI address in the local file system can replace
-         * the `File` class instance. If
+         * the `File` class instance.
          *
          * @format uri
          */