@hot-updater/console 0.12.6 → 0.12.7

package/dist/index.js

@@ -4,6 +4,838 @@ import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
 import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
 import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
 import * as __WEBPACK_EXTERNAL_MODULE__hot_updater_plugin_core_40c1c502__ from "@hot-updater/plugin-core";
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/@hono+typia-validator@0.1.0_hono@4.6.3_typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.6.3_/node_modules/@hono/typia-validator/dist/cjs/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        exports.typiaValidator = void 0;
+        const validator_1 = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/validator/index.js");
+        const typiaValidator = (target, validate, hook)=>(0, validator_1.validator)(target, async (value, c)=>{
+                const result = validate(value);
+                if (hook) {
+                    const hookResult = await hook({
+                        ...result,
+                        data: value
+                    }, c);
+                    if (hookResult) {
+                        if (hookResult instanceof Response || hookResult instanceof Promise) return hookResult;
+                        if ('response' in hookResult) return hookResult.response;
+                    }
+                }
+                if (!result.success) return c.json({
+                    success: false,
+                    error: result.errors
+                }, 400);
+                return result.data;
+            });
+        exports.typiaValidator = typiaValidator;
+    },
+    "../../node_modules/.pnpm/typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.6.3/node_modules/typia/lib/internal/_validateReport.js": function(__unused_webpack_module, exports) {
+        exports._validateReport = void 0;
+        const _validateReport = (array)=>{
+            const reportable = (path)=>{
+                if (0 === array.length) return true;
+                const last = array[array.length - 1].path;
+                return path.length > last.length || last.substring(0, path.length) !== path;
+            };
+            return (exceptable, error)=>{
+                if (exceptable && reportable(error.path)) array.push(error);
+                return false;
+            };
+        };
+        exports._validateReport = _validateReport;
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/helper/cookie/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var cookie_exports = {};
+        __export(cookie_exports, {
+            deleteCookie: ()=>deleteCookie,
+            getCookie: ()=>getCookie,
+            getSignedCookie: ()=>getSignedCookie,
+            setCookie: ()=>setCookie,
+            setSignedCookie: ()=>setSignedCookie
+        });
+        module.exports = __toCommonJS(cookie_exports);
+        var import_cookie = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/cookie.js");
+        const getCookie = (c, key, prefix)=>{
+            const cookie = c.req.raw.headers.get("Cookie");
+            if ("string" == typeof key) {
+                if (!cookie) return;
+                let finalKey = key;
+                if ("secure" === prefix) finalKey = "__Secure-" + key;
+                else if ("host" === prefix) finalKey = "__Host-" + key;
+                const obj2 = (0, import_cookie.parse)(cookie, finalKey);
+                return obj2[finalKey];
+            }
+            if (!cookie) return {};
+            const obj = (0, import_cookie.parse)(cookie);
+            return obj;
+        };
+        const getSignedCookie = async (c, secret, key, prefix)=>{
+            const cookie = c.req.raw.headers.get("Cookie");
+            if ("string" == typeof key) {
+                if (!cookie) return;
+                let finalKey = key;
+                if ("secure" === prefix) finalKey = "__Secure-" + key;
+                else if ("host" === prefix) finalKey = "__Host-" + key;
+                const obj2 = await (0, import_cookie.parseSigned)(cookie, secret, finalKey);
+                return obj2[finalKey];
+            }
+            if (!cookie) return {};
+            const obj = await (0, import_cookie.parseSigned)(cookie, secret);
+            return obj;
+        };
+        const setCookie = (c, name, value, opt)=>{
+            let cookie;
+            cookie = opt?.prefix === "secure" ? (0, import_cookie.serialize)("__Secure-" + name, value, {
+                path: "/",
+                ...opt,
+                secure: true
+            }) : opt?.prefix === "host" ? (0, import_cookie.serialize)("__Host-" + name, value, {
+                ...opt,
+                path: "/",
+                secure: true,
+                domain: void 0
+            }) : (0, import_cookie.serialize)(name, value, {
+                path: "/",
+                ...opt
+            });
+            c.header("set-cookie", cookie, {
+                append: true
+            });
+        };
+        const setSignedCookie = async (c, name, value, secret, opt)=>{
+            let cookie;
+            cookie = opt?.prefix === "secure" ? await (0, import_cookie.serializeSigned)("__Secure-" + name, value, secret, {
+                path: "/",
+                ...opt,
+                secure: true
+            }) : opt?.prefix === "host" ? await (0, import_cookie.serializeSigned)("__Host-" + name, value, secret, {
+                ...opt,
+                path: "/",
+                secure: true,
+                domain: void 0
+            }) : await (0, import_cookie.serializeSigned)(name, value, secret, {
+                path: "/",
+                ...opt
+            });
+            c.header("set-cookie", cookie, {
+                append: true
+            });
+        };
+        const deleteCookie = (c, name, opt)=>{
+            const deletedCookie = getCookie(c, name);
+            setCookie(c, name, "", {
+                ...opt,
+                maxAge: 0
+            });
+            return deletedCookie;
+        };
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/http-exception.js": function(module) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var http_exception_exports = {};
+        __export(http_exception_exports, {
+            HTTPException: ()=>HTTPException
+        });
+        module.exports = __toCommonJS(http_exception_exports);
+        class HTTPException extends Error {
+            res;
+            status;
+            constructor(status = 500, options){
+                super(options?.message, {
+                    cause: options?.cause
+                });
+                this.res = options?.res;
+                this.status = status;
+            }
+            getResponse() {
+                if (this.res) {
+                    const newResponse = new Response(this.res.body, {
+                        status: this.status,
+                        headers: this.res.headers
+                    });
+                    return newResponse;
+                }
+                return new Response(this.message, {
+                    status: this.status
+                });
+            }
+        }
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/buffer.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var buffer_exports = {};
+        __export(buffer_exports, {
+            bufferToFormData: ()=>bufferToFormData,
+            bufferToString: ()=>bufferToString,
+            equal: ()=>equal,
+            timingSafeEqual: ()=>timingSafeEqual
+        });
+        module.exports = __toCommonJS(buffer_exports);
+        var import_crypto = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/crypto.js");
+        const equal = (a, b)=>{
+            if (a === b) return true;
+            if (a.byteLength !== b.byteLength) return false;
+            const va = new DataView(a);
+            const vb = new DataView(b);
+            let i = va.byteLength;
+            while(i--)if (va.getUint8(i) !== vb.getUint8(i)) return false;
+            return true;
+        };
+        const timingSafeEqual = async (a, b, hashFunction)=>{
+            if (!hashFunction) hashFunction = import_crypto.sha256;
+            const [sa, sb] = await Promise.all([
+                hashFunction(a),
+                hashFunction(b)
+            ]);
+            if (!sa || !sb) return false;
+            return sa === sb && a === b;
+        };
+        const bufferToString = (buffer)=>{
+            if (buffer instanceof ArrayBuffer) {
+                const enc = new TextDecoder("utf-8");
+                return enc.decode(buffer);
+            }
+            return buffer;
+        };
+        const bufferToFormData = (arrayBuffer, contentType)=>{
+            const response = new Response(arrayBuffer, {
+                headers: {
+                    "Content-Type": contentType
+                }
+            });
+            return response.formData();
+        };
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/cookie.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var cookie_exports = {};
+        __export(cookie_exports, {
+            parse: ()=>parse,
+            parseSigned: ()=>parseSigned,
+            serialize: ()=>serialize,
+            serializeSigned: ()=>serializeSigned
+        });
+        module.exports = __toCommonJS(cookie_exports);
+        var import_url = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/url.js");
+        const algorithm = {
+            name: "HMAC",
+            hash: "SHA-256"
+        };
+        const getCryptoKey = async (secret)=>{
+            const secretBuf = "string" == typeof secret ? new TextEncoder().encode(secret) : secret;
+            return await crypto.subtle.importKey("raw", secretBuf, algorithm, false, [
+                "sign",
+                "verify"
+            ]);
+        };
+        const makeSignature = async (value, secret)=>{
+            const key = await getCryptoKey(secret);
+            const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
+            return btoa(String.fromCharCode(...new Uint8Array(signature)));
+        };
+        const verifySignature = async (base64Signature, value, secret)=>{
+            try {
+                const signatureBinStr = atob(base64Signature);
+                const signature = new Uint8Array(signatureBinStr.length);
+                for(let i = 0, len = signatureBinStr.length; i < len; i++)signature[i] = signatureBinStr.charCodeAt(i);
+                return await crypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value));
+            } catch  {
+                return false;
+            }
+        };
+        const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+        const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+        const parse = (cookie, name)=>{
+            const pairs = cookie.trim().split(";");
+            return pairs.reduce((parsedCookie, pairStr)=>{
+                pairStr = pairStr.trim();
+                const valueStartPos = pairStr.indexOf("=");
+                if (-1 === valueStartPos) return parsedCookie;
+                const cookieName = pairStr.substring(0, valueStartPos).trim();
+                if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) return parsedCookie;
+                let cookieValue = pairStr.substring(valueStartPos + 1).trim();
+                if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) cookieValue = cookieValue.slice(1, -1);
+                if (validCookieValueRegEx.test(cookieValue)) parsedCookie[cookieName] = (0, import_url.decodeURIComponent_)(cookieValue);
+                return parsedCookie;
+            }, {});
+        };
+        const parseSigned = async (cookie, secret, name)=>{
+            const parsedCookie = {};
+            const secretKey = await getCryptoKey(secret);
+            for (const [key, value] of Object.entries(parse(cookie, name))){
+                const signatureStartPos = value.lastIndexOf(".");
+                if (signatureStartPos < 1) continue;
+                const signedValue = value.substring(0, signatureStartPos);
+                const signature = value.substring(signatureStartPos + 1);
+                if (44 !== signature.length || !signature.endsWith("=")) continue;
+                const isVerified = await verifySignature(signature, signedValue, secretKey);
+                parsedCookie[key] = isVerified ? signedValue : false;
+            }
+            return parsedCookie;
+        };
+        const _serialize = (name, value, opt = {})=>{
+            let cookie = `${name}=${value}`;
+            if (name.startsWith("__Secure-") && !opt.secure) throw new Error("__Secure- Cookie must have Secure attributes");
+            if (name.startsWith("__Host-")) {
+                if (!opt.secure) throw new Error("__Host- Cookie must have Secure attributes");
+                if ("/" !== opt.path) throw new Error('__Host- Cookie must have Path attributes with "/"');
+                if (opt.domain) throw new Error("__Host- Cookie must not have Domain attributes");
+            }
+            if (opt && "number" == typeof opt.maxAge && opt.maxAge >= 0) {
+                if (opt.maxAge > 3456e4) throw new Error("Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.");
+                cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
+            }
+            if (opt.domain && "host" !== opt.prefix) cookie += `; Domain=${opt.domain}`;
+            if (opt.path) cookie += `; Path=${opt.path}`;
+            if (opt.expires) {
+                if (opt.expires.getTime() - Date.now() > 3456e7) throw new Error("Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.");
+                cookie += `; Expires=${opt.expires.toUTCString()}`;
+            }
+            if (opt.httpOnly) cookie += "; HttpOnly";
+            if (opt.secure) cookie += "; Secure";
+            if (opt.sameSite) cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+            if (opt.partitioned) {
+                if (!opt.secure) throw new Error("Partitioned Cookie must have Secure attributes");
+                cookie += "; Partitioned";
+            }
+            return cookie;
+        };
+        const serialize = (name, value, opt)=>{
+            value = encodeURIComponent(value);
+            return _serialize(name, value, opt);
+        };
+        const serializeSigned = async (name, value, secret, opt = {})=>{
+            const signature = await makeSignature(value, secret);
+            value = `${value}.${signature}`;
+            value = encodeURIComponent(value);
+            return _serialize(name, value, opt);
+        };
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/crypto.js": function(module) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var crypto_exports = {};
+        __export(crypto_exports, {
+            createHash: ()=>createHash,
+            md5: ()=>md5,
+            sha1: ()=>sha1,
+            sha256: ()=>sha256
+        });
+        module.exports = __toCommonJS(crypto_exports);
+        const sha256 = async (data)=>{
+            const algorithm = {
+                name: "SHA-256",
+                alias: "sha256"
+            };
+            const hash = await createHash(data, algorithm);
+            return hash;
+        };
+        const sha1 = async (data)=>{
+            const algorithm = {
+                name: "SHA-1",
+                alias: "sha1"
+            };
+            const hash = await createHash(data, algorithm);
+            return hash;
+        };
+        const md5 = async (data)=>{
+            const algorithm = {
+                name: "MD5",
+                alias: "md5"
+            };
+            const hash = await createHash(data, algorithm);
+            return hash;
+        };
+        const createHash = async (data, algorithm)=>{
+            let sourceBuffer;
+            if (data instanceof ReadableStream) {
+                let body = "";
+                const reader = data.getReader();
+                await reader?.read().then(async (chuck)=>{
+                    const value = await createHash(chuck.value || "", algorithm);
+                    body += value;
+                });
+                return body;
+            }
+            if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) sourceBuffer = data;
+            else {
+                if ("object" == typeof data) data = JSON.stringify(data);
+                sourceBuffer = new TextEncoder().encode(String(data));
+            }
+            if (crypto && crypto.subtle) {
+                const buffer = await crypto.subtle.digest({
+                    name: algorithm.name
+                }, sourceBuffer);
+                const hash = Array.prototype.map.call(new Uint8Array(buffer), (x)=>("00" + x.toString(16)).slice(-2)).join("");
+                return hash;
+            }
+            return null;
+        };
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/url.js": function(module) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var url_exports = {};
+        __export(url_exports, {
+            checkOptionalParameter: ()=>checkOptionalParameter,
+            decodeURIComponent_: ()=>decodeURIComponent_,
+            getPath: ()=>getPath,
+            getPathNoStrict: ()=>getPathNoStrict,
+            getPattern: ()=>getPattern,
+            getQueryParam: ()=>getQueryParam,
+            getQueryParams: ()=>getQueryParams,
+            getQueryStrings: ()=>getQueryStrings,
+            mergePath: ()=>mergePath,
+            splitPath: ()=>splitPath,
+            splitRoutingPath: ()=>splitRoutingPath
+        });
+        module.exports = __toCommonJS(url_exports);
+        const splitPath = (path)=>{
+            const paths = path.split("/");
+            if ("" === paths[0]) paths.shift();
+            return paths;
+        };
+        const splitRoutingPath = (routePath)=>{
+            const { groups, path } = extractGroupsFromPath(routePath);
+            const paths = splitPath(path);
+            return replaceGroupMarks(paths, groups);
+        };
+        const extractGroupsFromPath = (path)=>{
+            const groups = [];
+            path = path.replace(/\{[^}]+\}/g, (match, index)=>{
+                const mark = `@${index}`;
+                groups.push([
+                    mark,
+                    match
+                ]);
+                return mark;
+            });
+            return {
+                groups,
+                path
+            };
+        };
+        const replaceGroupMarks = (paths, groups)=>{
+            for(let i = groups.length - 1; i >= 0; i--){
+                const [mark] = groups[i];
+                for(let j = paths.length - 1; j >= 0; j--)if (paths[j].includes(mark)) {
+                    paths[j] = paths[j].replace(mark, groups[i][1]);
+                    break;
+                }
+            }
+            return paths;
+        };
+        const patternCache = {};
+        const getPattern = (label)=>{
+            if ("*" === label) return "*";
+            const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+            if (match) {
+                if (!patternCache[label]) {
+                    if (match[2]) patternCache[label] = [
+                        label,
+                        match[1],
+                        new RegExp("^" + match[2] + "$")
+                    ];
+                    else patternCache[label] = [
+                        label,
+                        match[1],
+                        true
+                    ];
+                }
+                return patternCache[label];
+            }
+            return null;
+        };
+        const tryDecodeURI = (str)=>{
+            try {
+                return decodeURI(str);
+            } catch  {
+                return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match)=>{
+                    try {
+                        return decodeURI(match);
+                    } catch  {
+                        return match;
+                    }
+                });
+            }
+        };
+        const getPath = (request)=>{
+            const url = request.url;
+            const start = url.indexOf("/", 8);
+            let i = start;
+            for(; i < url.length; i++){
+                const charCode = url.charCodeAt(i);
+                if (37 === charCode) {
+                    const queryIndex = url.indexOf("?", i);
+                    const path = url.slice(start, -1 === queryIndex ? void 0 : queryIndex);
+                    return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
+                }
+                if (63 === charCode) break;
+            }
+            return url.slice(start, i);
+        };
+        const getQueryStrings = (url)=>{
+            const queryIndex = url.indexOf("?", 8);
+            return -1 === queryIndex ? "" : "?" + url.slice(queryIndex + 1);
+        };
+        const getPathNoStrict = (request)=>{
+            const result = getPath(request);
+            return result.length > 1 && "/" === result[result.length - 1] ? result.slice(0, -1) : result;
+        };
+        const mergePath = (...paths)=>{
+            let p = "";
+            let endsWithSlash = false;
+            for (let path of paths){
+                if ("/" === p[p.length - 1]) {
+                    p = p.slice(0, -1);
+                    endsWithSlash = true;
+                }
+                if ("/" !== path[0]) path = `/${path}`;
+                if ("/" === path && endsWithSlash) p = `${p}/`;
+                else if ("/" !== path) p = `${p}${path}`;
+                if ("/" === path && "" === p) p = "/";
+            }
+            return p;
+        };
+        const checkOptionalParameter = (path)=>{
+            if (!path.match(/\:.+\?$/)) return null;
+            const segments = path.split("/");
+            const results = [];
+            let basePath = "";
+            segments.forEach((segment)=>{
+                if ("" === segment || /\:/.test(segment)) {
+                    if (/\:/.test(segment)) {
+                        if (/\?/.test(segment)) {
+                            if (0 === results.length && "" === basePath) results.push("/");
+                            else results.push(basePath);
+                            const optionalSegment = segment.replace("?", "");
+                            basePath += "/" + optionalSegment;
+                            results.push(basePath);
+                        } else basePath += "/" + segment;
+                    }
+                } else basePath += "/" + segment;
+            });
+            return results.filter((v, i, a)=>a.indexOf(v) === i);
+        };
+        const _decodeURI = (value)=>{
+            if (!/[%+]/.test(value)) return value;
+            if (-1 !== value.indexOf("+")) value = value.replace(/\+/g, " ");
+            return /%/.test(value) ? decodeURIComponent_(value) : value;
+        };
+        const _getQueryParam = (url, key, multiple)=>{
+            let encoded;
+            if (!multiple && key && !/[%+]/.test(key)) {
+                let keyIndex2 = url.indexOf(`?${key}`, 8);
+                if (-1 === keyIndex2) keyIndex2 = url.indexOf(`&${key}`, 8);
+                while(-1 !== keyIndex2){
+                    const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+                    if (61 === trailingKeyCode) {
+                        const valueIndex = keyIndex2 + key.length + 2;
+                        const endIndex = url.indexOf("&", valueIndex);
+                        return _decodeURI(url.slice(valueIndex, -1 === endIndex ? void 0 : endIndex));
+                    }
+                    if (38 == trailingKeyCode || isNaN(trailingKeyCode)) return "";
+                    keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+                }
+                encoded = /[%+]/.test(url);
+                if (!encoded) return;
+            }
+            const results = {};
+            encoded ??= /[%+]/.test(url);
+            let keyIndex = url.indexOf("?", 8);
+            while(-1 !== keyIndex){
+                const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+                let valueIndex = url.indexOf("=", keyIndex);
+                if (valueIndex > nextKeyIndex && -1 !== nextKeyIndex) valueIndex = -1;
+                let name = url.slice(keyIndex + 1, -1 === valueIndex ? -1 === nextKeyIndex ? void 0 : nextKeyIndex : valueIndex);
+                if (encoded) name = _decodeURI(name);
+                keyIndex = nextKeyIndex;
+                if ("" === name) continue;
+                let value;
+                if (-1 === valueIndex) value = "";
+                else {
+                    value = url.slice(valueIndex + 1, -1 === nextKeyIndex ? void 0 : nextKeyIndex);
+                    if (encoded) value = _decodeURI(value);
+                }
+                if (multiple) {
+                    if (!(results[name] && Array.isArray(results[name]))) results[name] = [];
+                    results[name].push(value);
+                } else results[name] ??= value;
+            }
+            return key ? results[key] : results;
+        };
+        const getQueryParam = _getQueryParam;
+        const getQueryParams = (url, key)=>_getQueryParam(url, key, true);
+        const decodeURIComponent_ = decodeURIComponent;
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/validator/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var validator_exports = {};
+        __export(validator_exports, {
+            validator: ()=>import_validator.validator
+        });
+        module.exports = __toCommonJS(validator_exports);
+        var import_validator = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/validator/validator.js");
+    },
+    "../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/validator/validator.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all)=>{
+            for(var name in all)__defProp(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps = (to, from, except, desc)=>{
+            if (from && "object" == typeof from || "function" == typeof from) {
+                for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: ()=>from[key],
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            }
+            return to;
+        };
+        var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                value: true
+            }), mod);
+        var validator_exports = {};
+        __export(validator_exports, {
+            validator: ()=>validator
+        });
+        module.exports = __toCommonJS(validator_exports);
+        var import_cookie = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/helper/cookie/index.js");
+        var import_http_exception = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/http-exception.js");
+        var import_buffer = __webpack_require__("../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/cjs/utils/buffer.js");
+        const jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+        const multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
+        const urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+        const validator = (target, validationFunc)=>async (c, next)=>{
+                let value = {};
+                const contentType = c.req.header("Content-Type");
+                switch(target){
+                    case "json":
+                        if (!contentType || !jsonRegex.test(contentType)) break;
+                        try {
+                            value = await c.req.json();
+                        } catch  {
+                            const message = "Malformed JSON in request body";
+                            throw new import_http_exception.HTTPException(400, {
+                                message
+                            });
+                        }
+                        break;
+                    case "form":
+                        {
+                            if (!contentType || !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))) break;
+                            let formData;
+                            if (c.req.bodyCache.formData) formData = await c.req.bodyCache.formData;
+                            else try {
+                                const arrayBuffer = await c.req.arrayBuffer();
+                                formData = await (0, import_buffer.bufferToFormData)(arrayBuffer, contentType);
+                                c.req.bodyCache.formData = formData;
+                            } catch (e) {
+                                let message = "Malformed FormData request.";
+                                message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
+                                throw new import_http_exception.HTTPException(400, {
+                                    message
+                                });
+                            }
+                            const form = {};
+                            formData.forEach((value2, key)=>{
+                                if (key.endsWith("[]")) (form[key] ??= []).push(value2);
+                                else if (Array.isArray(form[key])) form[key].push(value2);
+                                else if (key in form) form[key] = [
+                                    form[key],
+                                    value2
+                                ];
+                                else form[key] = value2;
+                            });
+                            value = form;
+                            break;
+                        }
+                    case "query":
+                        value = Object.fromEntries(Object.entries(c.req.queries()).map(([k, v])=>1 === v.length ? [
+                                k,
+                                v[0]
+                            ] : [
+                                k,
+                                v
+                            ]));
+                        break;
+                    case "param":
+                        value = c.req.param();
+                        break;
+                    case "header":
+                        value = c.req.header();
+                        break;
+                    case "cookie":
+                        value = (0, import_cookie.getCookie)(c);
+                        break;
+                }
+                const res = await validationFunc(value, c);
+                if (res instanceof Response) return res;
+                c.req.addValidatedData(target, res);
+                await next();
+            };
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
 var getFilePath = (options)=>{
     let filename = options.filename;
     const defaultDocument = options.defaultDocument || "index.html";
@@ -1552,452 +2384,147 @@ var hono_Hono = class extends Hono {
         });
     }
 };
-var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
-var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
-var parse = (cookie, name)=>{
-    const pairs = cookie.trim().split(";");
-    return pairs.reduce((parsedCookie, pairStr)=>{
-        pairStr = pairStr.trim();
-        const valueStartPos = pairStr.indexOf("=");
-        if (-1 === valueStartPos) return parsedCookie;
-        const cookieName = pairStr.substring(0, valueStartPos).trim();
-        if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) return parsedCookie;
-        let cookieValue = pairStr.substring(valueStartPos + 1).trim();
-        if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) cookieValue = cookieValue.slice(1, -1);
-        if (validCookieValueRegEx.test(cookieValue)) parsedCookie[cookieName] = decodeURIComponent_(cookieValue);
-        return parsedCookie;
-    }, {});
-};
-var getCookie = (c, key, prefix)=>{
-    const cookie = c.req.raw.headers.get("Cookie");
-    if ("string" == typeof key) {
-        if (!cookie) return;
-        let finalKey = key;
-        if ("secure" === prefix) finalKey = "__Secure-" + key;
-        else if ("host" === prefix) finalKey = "__Host-" + key;
-        const obj2 = parse(cookie, finalKey);
-        return obj2[finalKey];
-    }
-    if (!cookie) return {};
-    const obj = parse(cookie);
-    return obj;
-};
-var HTTPException = class extends Error {
-    res;
-    status;
-    constructor(status = 500, options){
-        super(options?.message, {
-            cause: options?.cause
-        });
-        this.res = options?.res;
-        this.status = status;
-    }
-    getResponse() {
-        if (this.res) {
-            const newResponse = new Response(this.res.body, {
-                status: this.status,
-                headers: this.res.headers
-            });
-            return newResponse;
-        }
-        return new Response(this.message, {
-            status: this.status
-        });
-    }
-};
-var bufferToFormData = (arrayBuffer, contentType)=>{
-    const response = new Response(arrayBuffer, {
-        headers: {
-            "Content-Type": contentType
-        }
-    });
-    return response.formData();
-};
-var jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
-var multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
-var urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
-var validator = (target, validationFunc)=>async (c, next)=>{
-        let value = {};
-        const contentType = c.req.header("Content-Type");
-        switch(target){
-            case "json":
-                if (!contentType || !jsonRegex.test(contentType)) break;
-                try {
-                    value = await c.req.json();
-                } catch  {
-                    const message = "Malformed JSON in request body";
-                    throw new HTTPException(400, {
-                        message
-                    });
-                }
-                break;
-            case "form":
-                {
-                    if (!contentType || !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))) break;
-                    let formData;
-                    if (c.req.bodyCache.formData) formData = await c.req.bodyCache.formData;
-                    else try {
-                        const arrayBuffer = await c.req.arrayBuffer();
-                        formData = await bufferToFormData(arrayBuffer, contentType);
-                        c.req.bodyCache.formData = formData;
-                    } catch (e) {
-                        let message = "Malformed FormData request.";
-                        message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
-                        throw new HTTPException(400, {
-                            message
-                        });
-                    }
-                    const form = {};
-                    formData.forEach((value2, key)=>{
-                        if (key.endsWith("[]")) (form[key] ??= []).push(value2);
-                        else if (Array.isArray(form[key])) form[key].push(value2);
-                        else if (key in form) form[key] = [
-                            form[key],
-                            value2
-                        ];
-                        else form[key] = value2;
-                    });
-                    value = form;
-                    break;
-                }
-            case "query":
-                value = Object.fromEntries(Object.entries(c.req.queries()).map(([k, v])=>1 === v.length ? [
-                        k,
-                        v[0]
-                    ] : [
-                        k,
-                        v
-                    ]));
-                break;
-            case "param":
-                value = c.req.param();
-                break;
-            case "header":
-                value = c.req.header();
-                break;
-            case "cookie":
-                value = getCookie(c);
-                break;
-        }
-        const res = await validationFunc(value, c);
-        if (res instanceof Response) return res;
-        c.req.addValidatedData(target, res);
-        await next();
-    };
-var store;
-function getGlobalConfig(config2) {
-    return {
-        lang: config2?.lang ?? store?.lang,
-        message: config2?.message,
-        abortEarly: config2?.abortEarly ?? store?.abortEarly,
-        abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
-    };
-}
-var store2;
-function getGlobalMessage(lang) {
-    return store2?.get(lang);
-}
-var store3;
-function getSchemaMessage(lang) {
-    return store3?.get(lang);
-}
-var store4;
-function getSpecificMessage(reference, lang) {
-    return store4?.get(reference)?.get(lang);
-}
-function _stringify(input) {
-    const type = typeof input;
-    if ("string" === type) return `"${input}"`;
-    if ("number" === type || "bigint" === type || "boolean" === type) return `${input}`;
-    if ("object" === type || "function" === type) return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-    return type;
-}
-function _addIssue(context, label, dataset, config2, other) {
-    const input = other && "input" in other ? other.input : dataset.value;
-    const expected = other?.expected ?? context.expects ?? null;
-    const received = other?.received ?? _stringify(input);
-    const issue = {
-        kind: context.kind,
-        type: context.type,
-        input,
-        expected,
-        received,
-        message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
-        requirement: context.requirement,
-        path: other?.path,
-        issues: other?.issues,
-        lang: config2.lang,
-        abortEarly: config2.abortEarly,
-        abortPipeEarly: config2.abortPipeEarly
-    };
-    const isSchema = "schema" === context.kind;
-    const message = other?.message ?? context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
-    if (message) issue.message = "function" == typeof message ? message(issue) : message;
-    if (isSchema) dataset.typed = false;
-    if (dataset.issues) dataset.issues.push(issue);
-    else dataset.issues = [
-        issue
-    ];
-}
-function _joinExpects(values, separator) {
-    const list = [
-        ...new Set(values)
-    ];
-    if (list.length > 1) return `(${list.join(` ${separator} `)})`;
-    return list[0] ?? "never";
-}
-function getDefault(schema, dataset, config2) {
-    return "function" == typeof schema.default ? schema.default(dataset, config2) : schema.default;
-}
-function dist_boolean(message) {
-    return {
-        kind: "schema",
-        type: "boolean",
-        reference: dist_boolean,
-        expects: "boolean",
-        async: false,
-        message,
-        _run (dataset, config2) {
-            if ("boolean" == typeof dataset.value) dataset.typed = true;
-            else _addIssue(this, "type", dataset, config2);
-            return dataset;
-        }
-    };
-}
-function literal(literal_, message) {
-    return {
-        kind: "schema",
-        type: "literal",
-        reference: literal,
-        expects: _stringify(literal_),
-        async: false,
-        literal: literal_,
-        message,
-        _run (dataset, config2) {
-            if (dataset.value === this.literal) dataset.typed = true;
-            else _addIssue(this, "type", dataset, config2);
-            return dataset;
-        }
-    };
-}
-function nullable(wrapped, ...args) {
-    const schema = {
-        kind: "schema",
-        type: "nullable",
-        reference: nullable,
-        expects: `(${wrapped.expects} | null)`,
-        async: false,
-        wrapped,
-        _run (dataset, config2) {
-            if (null === dataset.value) {
-                if ("default" in this) dataset.value = getDefault(this, dataset, config2);
-                if (null === dataset.value) {
-                    dataset.typed = true;
-                    return dataset;
-                }
-            }
-            return this.wrapped._run(dataset, config2);
-        }
-    };
-    if (0 in args) schema.default = args[0];
-    return schema;
-}
-function dist_object(entries, message) {
-    return {
-        kind: "schema",
-        type: "object",
-        reference: dist_object,
-        expects: "Object",
-        async: false,
-        entries,
-        message,
-        _run (dataset, config2) {
-            const input = dataset.value;
-            if (input && "object" == typeof input) {
-                dataset.typed = true;
-                dataset.value = {};
-                for(const key in this.entries){
-                    const value2 = input[key];
-                    const valueDataset = this.entries[key]._run({
-                        typed: false,
-                        value: value2
-                    }, config2);
-                    if (valueDataset.issues) {
-                        const pathItem = {
-                            type: "object",
-                            origin: "value",
-                            input,
-                            key,
-                            value: value2
-                        };
-                        for (const issue of valueDataset.issues){
-                            if (issue.path) issue.path.unshift(pathItem);
-                            else issue.path = [
-                                pathItem
-                            ];
-                            dataset.issues?.push(issue);
-                        }
-                        if (!dataset.issues) dataset.issues = valueDataset.issues;
-                        if (config2.abortEarly) {
-                            dataset.typed = false;
-                            break;
-                        }
-                    }
-                    if (!valueDataset.typed) dataset.typed = false;
-                    if (void 0 !== valueDataset.value || key in input) dataset.value[key] = valueDataset.value;
-                }
-            } else _addIssue(this, "type", dataset, config2);
-            return dataset;
-        }
-    };
-}
-function optional(wrapped, ...args) {
-    const schema = {
-        kind: "schema",
-        type: "optional",
-        reference: optional,
-        expects: `(${wrapped.expects} | undefined)`,
-        async: false,
-        wrapped,
-        _run (dataset, config2) {
-            if (void 0 === dataset.value) {
-                if ("default" in this) dataset.value = getDefault(this, dataset, config2);
-                if (void 0 === dataset.value) {
-                    dataset.typed = true;
-                    return dataset;
-                }
-            }
-            return this.wrapped._run(dataset, config2);
-        }
-    };
-    if (0 in args) schema.default = args[0];
-    return schema;
-}
-function string(message) {
-    return {
-        kind: "schema",
-        type: "string",
-        reference: string,
-        expects: "string",
-        async: false,
-        message,
-        _run (dataset, config2) {
-            if ("string" == typeof dataset.value) dataset.typed = true;
-            else _addIssue(this, "type", dataset, config2);
-            return dataset;
+var _validateReport = __webpack_require__("../../node_modules/.pnpm/typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.6.3/node_modules/typia/lib/internal/_validateReport.js");
+var cjs = __webpack_require__("../../node_modules/.pnpm/@hono+typia-validator@0.1.0_hono@4.6.3_typia@8.0.3_@samchon+openapi@3.1.0_typescript@5.6.3_/node_modules/@hono/typia-validator/dist/cjs/index.js");
+const bundleIdValidator = (()=>{
+    const _io0 = (input)=>"string" == typeof input.bundleId;
+    const _vo0 = (input, _path, _exceptionable = true)=>[
+            "string" == typeof input.bundleId || _report(_exceptionable, {
+                path: _path + ".bundleId",
+                expected: "string",
+                value: input.bundleId
+            })
+        ].every((flag)=>flag);
+    const __is = (input)=>"object" == typeof input && null !== input && _io0(input);
+    let errors;
+    let _report;
+    return (input)=>{
+        if (false === __is(input)) {
+            errors = [];
+            _report = _validateReport._validateReport(errors);
+            ((input, _path, _exceptionable = true)=>("object" == typeof input && null !== input || _report(true, {
+                    path: _path + "",
+                    expected: "__type",
+                    value: input
+                })) && _vo0(input, _path + "", true) || _report(true, {
+                    path: _path + "",
+                    expected: "__type",
+                    value: input
+                }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
         }
+        return {
+            success: true,
+            data: input
+        };
     };
-}
-function _subIssues(datasets) {
-    let issues;
-    if (datasets) for (const dataset of datasets)if (issues) issues.push(...dataset.issues);
-    else issues = dataset.issues;
-    return issues;
-}
-function union(options, message) {
-    return {
-        kind: "schema",
-        type: "union",
-        reference: union,
-        expects: _joinExpects(options.map((option)=>option.expects), "|"),
-        async: false,
-        options,
-        message,
-        _run (dataset, config2) {
-            let validDataset;
-            let typedDatasets;
-            let untypedDatasets;
-            for (const schema of this.options){
-                const optionDataset = schema._run({
-                    typed: false,
-                    value: dataset.value
-                }, config2);
-                if (optionDataset.typed) {
-                    if (optionDataset.issues) {
-                        if (typedDatasets) typedDatasets.push(optionDataset);
-                        else typedDatasets = [
-                            optionDataset
-                        ];
-                    } else {
-                        validDataset = optionDataset;
-                        break;
-                    }
-                } else if (untypedDatasets) untypedDatasets.push(optionDataset);
-                else untypedDatasets = [
-                    optionDataset
-                ];
-            }
-            if (validDataset) return validDataset;
-            if (typedDatasets) {
-                if (1 === typedDatasets.length) return typedDatasets[0];
-                _addIssue(this, "type", dataset, config2, {
-                    issues: _subIssues(typedDatasets)
-                });
-                dataset.typed = true;
-            } else {
-                if (untypedDatasets?.length === 1) return untypedDatasets[0];
-                _addIssue(this, "type", dataset, config2, {
-                    issues: _subIssues(untypedDatasets)
-                });
-            }
-            return dataset;
+})();
+const updateBundleValidator = (()=>{
+    const _io0 = (input)=>"string" == typeof input.targetBundleId && "object" == typeof input.bundle && null !== input.bundle && false === Array.isArray(input.bundle) && _io1(input.bundle);
+    const _io1 = (input)=>(void 0 === input.id || "string" == typeof input.id) && (void 0 === input.platform || "ios" === input.platform || "android" === input.platform) && (void 0 === input.targetAppVersion || "string" == typeof input.targetAppVersion) && (void 0 === input.shouldForceUpdate || "boolean" == typeof input.shouldForceUpdate) && (void 0 === input.enabled || "boolean" == typeof input.enabled) && (void 0 === input.fileUrl || "string" == typeof input.fileUrl) && (void 0 === input.fileHash || "string" == typeof input.fileHash) && (null === input.gitCommitHash || void 0 === input.gitCommitHash || "string" == typeof input.gitCommitHash) && (null === input.message || void 0 === input.message || "string" == typeof input.message);
+    const _vo0 = (input, _path, _exceptionable = true)=>[
+            "string" == typeof input.targetBundleId || _report(_exceptionable, {
+                path: _path + ".targetBundleId",
+                expected: "string",
+                value: input.targetBundleId
+            }),
+            ("object" == typeof input.bundle && null !== input.bundle && false === Array.isArray(input.bundle) || _report(_exceptionable, {
+                path: _path + ".bundle",
+                expected: "Partial<Bundle>",
+                value: input.bundle
+            })) && _vo1(input.bundle, _path + ".bundle", _exceptionable) || _report(_exceptionable, {
+                path: _path + ".bundle",
+                expected: "Partial<Bundle>",
+                value: input.bundle
+            })
+        ].every((flag)=>flag);
+    const _vo1 = (input, _path, _exceptionable = true)=>[
+            void 0 === input.id || "string" == typeof input.id || _report(_exceptionable, {
+                path: _path + ".id",
+                expected: "(string | undefined)",
+                value: input.id
+            }),
+            void 0 === input.platform || "ios" === input.platform || "android" === input.platform || _report(_exceptionable, {
+                path: _path + ".platform",
+                expected: "(\"android\" | \"ios\" | undefined)",
+                value: input.platform
+            }),
+            void 0 === input.targetAppVersion || "string" == typeof input.targetAppVersion || _report(_exceptionable, {
+                path: _path + ".targetAppVersion",
+                expected: "(string | undefined)",
+                value: input.targetAppVersion
+            }),
+            void 0 === input.shouldForceUpdate || "boolean" == typeof input.shouldForceUpdate || _report(_exceptionable, {
+                path: _path + ".shouldForceUpdate",
+                expected: "(boolean | undefined)",
+                value: input.shouldForceUpdate
+            }),
+            void 0 === input.enabled || "boolean" == typeof input.enabled || _report(_exceptionable, {
+                path: _path + ".enabled",
+                expected: "(boolean | undefined)",
+                value: input.enabled
+            }),
+            void 0 === input.fileUrl || "string" == typeof input.fileUrl || _report(_exceptionable, {
+                path: _path + ".fileUrl",
+                expected: "(string | undefined)",
+                value: input.fileUrl
+            }),
+            void 0 === input.fileHash || "string" == typeof input.fileHash || _report(_exceptionable, {
+                path: _path + ".fileHash",
+                expected: "(string | undefined)",
+                value: input.fileHash
+            }),
+            null === input.gitCommitHash || void 0 === input.gitCommitHash || "string" == typeof input.gitCommitHash || _report(_exceptionable, {
+                path: _path + ".gitCommitHash",
+                expected: "(null | string | undefined)",
+                value: input.gitCommitHash
+            }),
+            null === input.message || void 0 === input.message || "string" == typeof input.message || _report(_exceptionable, {
+                path: _path + ".message",
+                expected: "(null | string | undefined)",
+                value: input.message
+            })
+        ].every((flag)=>flag);
+    const __is = (input)=>"object" == typeof input && null !== input && _io0(input);
+    let errors;
+    let _report;
+    return (input)=>{
+        if (false === __is(input)) {
+            errors = [];
+            _report = _validateReport._validateReport(errors);
+            ((input, _path, _exceptionable = true)=>("object" == typeof input && null !== input || _report(true, {
+                    path: _path + "",
+                    expected: "__type",
+                    value: input
+                })) && _vo0(input, _path + "", true) || _report(true, {
+                    path: _path + "",
+                    expected: "__type",
+                    value: input
+                }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
         }
+        return {
+            success: true,
+            data: input
+        };
     };
-}
-function omit(schema, keys) {
-    const entries = {
-        ...schema.entries
-    };
-    for (const key of keys)delete entries[key];
-    return {
-        ...schema,
-        entries
-    };
-}
-function partial(schema, keys) {
-    const entries = {};
-    for(const key in schema.entries)entries[key] = !keys || keys.includes(key) ? optional(schema.entries[key]) : schema.entries[key];
-    return {
-        ...schema,
-        entries
-    };
-}
-async function safeParseAsync(schema, input, config2) {
-    const dataset = await schema._run({
-        typed: false,
-        value: input
-    }, getGlobalConfig(config2));
-    return {
-        typed: dataset.typed,
-        success: !dataset.issues,
-        output: dataset.value,
-        issues: dataset.issues
-    };
-}
-var vValidator = (target, schema, hook)=>validator(target, async (value, c)=>{
-        const result = await safeParseAsync(schema, value);
-        if (hook) {
-            const hookResult = hook(result, c);
-            if (hookResult instanceof Response || hookResult instanceof Promise) return hookResult;
-        }
-        if (!result.success) return c.json(result, 400);
-        const data = result.output;
-        return data;
-    });
-const bundleSchema = dist_object({
-    platform: union([
-        literal("ios"),
-        literal("android")
-    ]),
-    targetAppVersion: string(),
-    id: string(),
-    shouldForceUpdate: dist_boolean(),
-    enabled: dist_boolean(),
-    fileUrl: string(),
-    fileHash: string(),
-    gitCommitHash: nullable(string()),
-    message: nullable(string())
-});
+})();
 let rpc_config = null;
 let rpc_databasePlugin = null;
 const prepareConfig = async ()=>{
@@ -2023,19 +2550,12 @@ const rpc = new hono_Hono().get("/getConfig", async (c)=>{
     const { databasePlugin } = await prepareConfig();
     const bundles = await databasePlugin?.getBundles(true);
     return c.json(bundles ?? []);
-}).get("/getBundleById", vValidator("query", dist_object({
-    bundleId: string()
-})), async (c)=>{
+}).get("/getBundleById", (0, cjs.typiaValidator)("query", bundleIdValidator), async (c)=>{
     const { bundleId } = c.req.valid("query");
     const { databasePlugin } = await prepareConfig();
     const bundle = await databasePlugin?.getBundleById(bundleId);
     return c.json(bundle ?? null);
-}).post("/updateBundle", vValidator("json", dist_object({
-    targetBundleId: string(),
-    bundle: partial(omit(bundleSchema, [
-        "id"
-    ]))
-})), async (c)=>{
+}).post("/updateBundle", (0, cjs.typiaValidator)("json", updateBundleValidator), async (c)=>{
     const { targetBundleId, bundle } = c.req.valid("json");
     const { databasePlugin } = await prepareConfig();
     await databasePlugin?.updateBundle(targetBundleId, bundle);