@jderstd/hono-standard-validator 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present, Alpheus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# JDER Hono Standard Validator
+
+A standard validator for Hono.
+
+This package includes a standard validator based on the JSON response structure specified in [JSON Data Errors Response (JDER)](https://github.com/jderstd/spec). With the validator, various kinds of requests can be validated easily and send JSON responses instead of plain text responses.
+
+## License
+
+This project is licensed under the terms of the MIT license.

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,23 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+
+exports.__toESM = __toESM;

package/dist/hook.d.ts

@@ -0,0 +1,15 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { Context } from "hono";
+import { Env, TypedResponse, ValidationTargets as ValidationTargets$1 } from "hono/types";
+declare const sValidatorHook: <T, E extends Env, P extends string, Target extends keyof ValidationTargets$1 = keyof ValidationTargets$1, O = {}>(result: ({
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: readonly StandardSchemaV1.Issue[];
+  data: T;
+}) & {
+  target: Target;
+}, c: Context<E, P>) => Response | void | TypedResponse<O> | Promise<Response | void | TypedResponse<O>>;
+export { sValidatorHook };
+//# sourceMappingURL=hook.d.ts.map

package/dist/hook.js

@@ -0,0 +1,30 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let __jderstd_hono_response = require("@jderstd/hono/response");
+__jderstd_hono_response = require_rolldown_runtime.__toESM(__jderstd_hono_response);
+let __jderstd_hono_response_error = require("@jderstd/hono/response/error");
+__jderstd_hono_response_error = require_rolldown_runtime.__toESM(__jderstd_hono_response_error);
+let hono_http_exception = require("hono/http-exception");
+hono_http_exception = require_rolldown_runtime.__toESM(hono_http_exception);
+
+const sValidatorHook = (result, c) => {
+	if (result.success) return void 0;
+	const errors = [];
+	const errs = result.error;
+	for (let i = 0; i < errs.length; i++) {
+		const err = errs[i];
+		if (!err) continue;
+		const path = err.path?.map((p) => {
+			if (typeof p === "object") return p.key.toString();
+			return p.toString();
+		}) ?? [];
+		errors.push({
+			code: __jderstd_hono_response_error.ResponseErrorCode.Parse,
+			path,
+			message: err.message
+		});
+	}
+	throw new hono_http_exception.HTTPException(400, { res: (0, __jderstd_hono_response.createJsonResponse)(c, { errors }) });
+};
+
+exports.sValidatorHook = sValidatorHook;
+//# sourceMappingURL=hook.js.map

package/dist/hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.js","names":["errors: JsonResponseError[]","errs: readonly StandardSchemaV1.Issue[]","i: number","err: StandardSchemaV1.Issue | undefined","path: string[]","ResponseErrorCode","HTTPException"],"sources":["../src/hook.ts"],"sourcesContent":["import type { JsonResponseError } from \"@jderstd/hono/response\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { Context } from \"hono\";\nimport type { Env, TypedResponse, ValidationTargets } from \"hono/types\";\n\nimport { createJsonResponse } from \"@jderstd/hono/response\";\nimport { ResponseErrorCode } from \"@jderstd/hono/response/error\";\nimport { HTTPException } from \"hono/http-exception\";\n\nconst sValidatorHook = <\n    T,\n    E extends Env,\n    P extends string,\n    Target extends keyof ValidationTargets = keyof ValidationTargets,\n    // biome-ignore lint/complexity/noBannedTypes: any non-nullable value\n    O = {},\n>(\n    result: (\n        | {\n              success: true;\n              data: T;\n          }\n        | {\n              success: false;\n              error: readonly StandardSchemaV1.Issue[];\n              data: T;\n          }\n    ) & {\n        target: Target;\n    },\n    c: Context<E, P>,\n):\n    | Response\n    | void\n    | TypedResponse<O>\n    // biome-ignore lint/suspicious/noConfusingVoidType: return type\n    | Promise<Response | void | TypedResponse<O>> => {\n    if (result.success) return void 0;\n\n    const errors: JsonResponseError[] = [];\n\n    const errs: readonly StandardSchemaV1.Issue[] = result.error;\n\n    for (let i: number = 0; i < errs.length; i++) {\n        const err: StandardSchemaV1.Issue | undefined = errs[i];\n\n        if (!err) continue;\n\n        const path: string[] =\n            err.path?.map((p) => {\n                if (typeof p === \"object\") return p.key.toString();\n                return p.toString();\n            }) ?? [];\n\n        errors.push({\n            code: ResponseErrorCode.Parse,\n            path,\n            message: err.message,\n        });\n    }\n\n    throw new HTTPException(400, {\n        res: createJsonResponse(c, {\n            errors,\n        }),\n    });\n};\n\nexport { sValidatorHook };\n"],"mappings":";;;;;;;;AASA,MAAM,kBAQF,QAaA,MAMiD;AACjD,KAAI,OAAO,QAAS,QAAO,KAAK;CAEhC,MAAMA,SAA8B,EAAE;CAEtC,MAAMC,OAA0C,OAAO;AAEvD,MAAK,IAAIC,IAAY,GAAG,IAAI,KAAK,QAAQ,KAAK;EAC1C,MAAMC,MAA0C,KAAK;AAErD,MAAI,CAAC,IAAK;EAEV,MAAMC,OACF,IAAI,MAAM,KAAK,MAAM;AACjB,OAAI,OAAO,MAAM,SAAU,QAAO,EAAE,IAAI,UAAU;AAClD,UAAO,EAAE,UAAU;IACrB,IAAI,EAAE;AAEZ,SAAO,KAAK;GACR,MAAMC,gDAAkB;GACxB;GACA,SAAS,IAAI;GAChB,CAAC;;AAGN,OAAM,IAAIC,kCAAc,KAAK,EACzB,qDAAwB,GAAG,EACvB,QACH,CAAC,EACL,CAAC"}

package/dist/hook.mjs

@@ -0,0 +1,26 @@
+import { createJsonResponse } from "@jderstd/hono/response";
+import { ResponseErrorCode } from "@jderstd/hono/response/error";
+import { HTTPException } from "hono/http-exception";
+
+const sValidatorHook = (result, c) => {
+	if (result.success) return void 0;
+	const errors = [];
+	const errs = result.error;
+	for (let i = 0; i < errs.length; i++) {
+		const err = errs[i];
+		if (!err) continue;
+		const path = err.path?.map((p) => {
+			if (typeof p === "object") return p.key.toString();
+			return p.toString();
+		}) ?? [];
+		errors.push({
+			code: ResponseErrorCode.Parse,
+			path,
+			message: err.message
+		});
+	}
+	throw new HTTPException(400, { res: createJsonResponse(c, { errors }) });
+};
+
+export { sValidatorHook };
+//# sourceMappingURL=hook.mjs.map

package/dist/hook.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.mjs","names":["errors: JsonResponseError[]","errs: readonly StandardSchemaV1.Issue[]","i: number","err: StandardSchemaV1.Issue | undefined","path: string[]"],"sources":["../src/hook.ts"],"sourcesContent":["import type { JsonResponseError } from \"@jderstd/hono/response\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { Context } from \"hono\";\nimport type { Env, TypedResponse, ValidationTargets } from \"hono/types\";\n\nimport { createJsonResponse } from \"@jderstd/hono/response\";\nimport { ResponseErrorCode } from \"@jderstd/hono/response/error\";\nimport { HTTPException } from \"hono/http-exception\";\n\nconst sValidatorHook = <\n    T,\n    E extends Env,\n    P extends string,\n    Target extends keyof ValidationTargets = keyof ValidationTargets,\n    // biome-ignore lint/complexity/noBannedTypes: any non-nullable value\n    O = {},\n>(\n    result: (\n        | {\n              success: true;\n              data: T;\n          }\n        | {\n              success: false;\n              error: readonly StandardSchemaV1.Issue[];\n              data: T;\n          }\n    ) & {\n        target: Target;\n    },\n    c: Context<E, P>,\n):\n    | Response\n    | void\n    | TypedResponse<O>\n    // biome-ignore lint/suspicious/noConfusingVoidType: return type\n    | Promise<Response | void | TypedResponse<O>> => {\n    if (result.success) return void 0;\n\n    const errors: JsonResponseError[] = [];\n\n    const errs: readonly StandardSchemaV1.Issue[] = result.error;\n\n    for (let i: number = 0; i < errs.length; i++) {\n        const err: StandardSchemaV1.Issue | undefined = errs[i];\n\n        if (!err) continue;\n\n        const path: string[] =\n            err.path?.map((p) => {\n                if (typeof p === \"object\") return p.key.toString();\n                return p.toString();\n            }) ?? [];\n\n        errors.push({\n            code: ResponseErrorCode.Parse,\n            path,\n            message: err.message,\n        });\n    }\n\n    throw new HTTPException(400, {\n        res: createJsonResponse(c, {\n            errors,\n        }),\n    });\n};\n\nexport { sValidatorHook };\n"],"mappings":";;;;AASA,MAAM,kBAQF,QAaA,MAMiD;AACjD,KAAI,OAAO,QAAS,QAAO,KAAK;CAEhC,MAAMA,SAA8B,EAAE;CAEtC,MAAMC,OAA0C,OAAO;AAEvD,MAAK,IAAIC,IAAY,GAAG,IAAI,KAAK,QAAQ,KAAK;EAC1C,MAAMC,MAA0C,KAAK;AAErD,MAAI,CAAC,IAAK;EAEV,MAAMC,OACF,IAAI,MAAM,KAAK,MAAM;AACjB,OAAI,OAAO,MAAM,SAAU,QAAO,EAAE,IAAI,UAAU;AAClD,UAAO,EAAE,UAAU;IACrB,IAAI,EAAE;AAEZ,SAAO,KAAK;GACR,MAAM,kBAAkB;GACxB;GACA,SAAS,IAAI;GAChB,CAAC;;AAGN,OAAM,IAAI,cAAc,KAAK,EACzB,KAAK,mBAAmB,GAAG,EACvB,QACH,CAAC,EACL,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import * as hono0 from "hono";
+import { ValidationTargets } from "hono";
+/**
+ * Validate the request with validator based on Standard Schema.
+ *
+ * Following error may returned if the request is invalid:
+ *
+ * ```jsonc
+ * // Status: 400
+ * {
+ *     "success": false,
+ *     "errors": [
+ *         {
+ *             "code": "parse",
+ *             "path": ["xxx"],
+ *             "message": "xxx"
+ *         }
+ *     ]
+ * }
+ * ```
+ *
+ * ### Example
+ *
+ * ```ts
+ * import type { Context, Env } from "hono";
+ *
+ * import { Hono } from "hono";
+ * import { z } from "zod";
+ * import { sValidator } from "@jderstd/hono-standard-validator";
+ *
+ * const app: Hono = new Hono();
+ *
+ * const json = z.object({
+ *     name: z.string(),
+ *     age: z.number()
+ * });
+ *
+ * type Json = z.infer<typeof json>;
+ *
+ * type RouteContext = Context<
+ *     Env,
+ *     "/",
+ *     {
+ *         in: {
+ *             json: Json;
+ *         },
+ *         out: {
+ *             json: Json;
+ *         },
+ *     },
+ * >;
+ *
+ * app.post(
+ *     "/",
+ *     sValidator("json", json),
+ *     (c: RouteContext): Response => {
+ *         const data: Json = c.req.valid("json");
+ *         return c.json(data);
+ *     }
+ * );
+ * ```
+ */
+declare const sValidator: <Target extends keyof ValidationTargets, Schema extends StandardSchemaV1>(target: Target, schema: Schema) => hono0.MiddlewareHandler<hono0.Env, string, {
+  in: (undefined extends StandardSchemaV1.InferInput<Schema> ? true : false) extends true ? { [K in Target]?: (StandardSchemaV1.InferInput<Schema> extends infer T ? T extends StandardSchemaV1.InferInput<Schema> ? T extends ValidationTargets[K] ? T : { [K2 in keyof T]?: ValidationTargets[K][K2] | undefined } : never : never) | undefined } : { [K_1 in Target]: StandardSchemaV1.InferInput<Schema> extends infer T ? T extends StandardSchemaV1.InferInput<Schema> ? T extends ValidationTargets[K_1] ? T : { [K2 in keyof T]: ValidationTargets[K_1][K2] } : never : never };
+  out: { [K_2 in Target]: StandardSchemaV1.InferOutput<Schema> };
+}>;
+export { sValidator };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,71 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_hook = require('./hook.js');
+let __hono_standard_validator = require("@hono/standard-validator");
+__hono_standard_validator = require_rolldown_runtime.__toESM(__hono_standard_validator);
+
+/**
+* Validate the request with validator based on Standard Schema.
+*
+* Following error may returned if the request is invalid:
+*
+* ```jsonc
+* // Status: 400
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "parse",
+*             "path": ["xxx"],
+*             "message": "xxx"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Example
+*
+* ```ts
+* import type { Context, Env } from "hono";
+*
+* import { Hono } from "hono";
+* import { z } from "zod";
+* import { sValidator } from "@jderstd/hono-standard-validator";
+*
+* const app: Hono = new Hono();
+*
+* const json = z.object({
+*     name: z.string(),
+*     age: z.number()
+* });
+*
+* type Json = z.infer<typeof json>;
+*
+* type RouteContext = Context<
+*     Env,
+*     "/",
+*     {
+*         in: {
+*             json: Json;
+*         },
+*         out: {
+*             json: Json;
+*         },
+*     },
+* >;
+*
+* app.post(
+*     "/",
+*     sValidator("json", json),
+*     (c: RouteContext): Response => {
+*         const data: Json = c.req.valid("json");
+*         return c.json(data);
+*     }
+* );
+* ```
+*/
+const sValidator = (target, schema) => {
+	return (0, __hono_standard_validator.sValidator)(target, schema, require_hook.sValidatorHook);
+};
+
+exports.sValidator = sValidator;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["sValidatorHook"],"sources":["../src/index.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { ValidationTargets } from \"hono\";\n\nimport { sValidator as sv } from \"@hono/standard-validator\";\n\nimport { sValidatorHook } from \"#/hook\";\n\n/**\n * Validate the request with validator based on Standard Schema.\n *\n * Following error may returned if the request is invalid:\n *\n * ```jsonc\n * // Status: 400\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"parse\",\n *             \"path\": [\"xxx\"],\n *             \"message\": \"xxx\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import type { Context, Env } from \"hono\";\n *\n * import { Hono } from \"hono\";\n * import { z } from \"zod\";\n * import { sValidator } from \"@jderstd/hono-standard-validator\";\n *\n * const app: Hono = new Hono();\n *\n * const json = z.object({\n *     name: z.string(),\n *     age: z.number()\n * });\n *\n * type Json = z.infer<typeof json>;\n *\n * type RouteContext = Context<\n *     Env,\n *     \"/\",\n *     {\n *         in: {\n *             json: Json;\n *         },\n *         out: {\n *             json: Json;\n *         },\n *     },\n * >;\n *\n * app.post(\n *     \"/\",\n *     sValidator(\"json\", json),\n *     (c: RouteContext): Response => {\n *         const data: Json = c.req.valid(\"json\");\n *         return c.json(data);\n *     }\n * );\n * ```\n */\nconst sValidator = <\n    Target extends keyof ValidationTargets,\n    Schema extends StandardSchemaV1,\n>(\n    target: Target,\n    schema: Schema,\n) => {\n    return sv(target, schema, sValidatorHook);\n};\n\nexport { sValidator };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,MAAM,cAIF,QACA,WACC;AACD,kDAAU,QAAQ,QAAQA,4BAAe"}

package/dist/index.mjs

@@ -0,0 +1,69 @@
+import { sValidatorHook } from "./hook.mjs";
+import { sValidator as sValidator$1 } from "@hono/standard-validator";
+
+/**
+* Validate the request with validator based on Standard Schema.
+*
+* Following error may returned if the request is invalid:
+*
+* ```jsonc
+* // Status: 400
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "parse",
+*             "path": ["xxx"],
+*             "message": "xxx"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Example
+*
+* ```ts
+* import type { Context, Env } from "hono";
+*
+* import { Hono } from "hono";
+* import { z } from "zod";
+* import { sValidator } from "@jderstd/hono-standard-validator";
+*
+* const app: Hono = new Hono();
+*
+* const json = z.object({
+*     name: z.string(),
+*     age: z.number()
+* });
+*
+* type Json = z.infer<typeof json>;
+*
+* type RouteContext = Context<
+*     Env,
+*     "/",
+*     {
+*         in: {
+*             json: Json;
+*         },
+*         out: {
+*             json: Json;
+*         },
+*     },
+* >;
+*
+* app.post(
+*     "/",
+*     sValidator("json", json),
+*     (c: RouteContext): Response => {
+*         const data: Json = c.req.valid("json");
+*         return c.json(data);
+*     }
+* );
+* ```
+*/
+const sValidator = (target, schema) => {
+	return sValidator$1(target, schema, sValidatorHook);
+};
+
+export { sValidator };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["sv"],"sources":["../src/index.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { ValidationTargets } from \"hono\";\n\nimport { sValidator as sv } from \"@hono/standard-validator\";\n\nimport { sValidatorHook } from \"#/hook\";\n\n/**\n * Validate the request with validator based on Standard Schema.\n *\n * Following error may returned if the request is invalid:\n *\n * ```jsonc\n * // Status: 400\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"parse\",\n *             \"path\": [\"xxx\"],\n *             \"message\": \"xxx\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import type { Context, Env } from \"hono\";\n *\n * import { Hono } from \"hono\";\n * import { z } from \"zod\";\n * import { sValidator } from \"@jderstd/hono-standard-validator\";\n *\n * const app: Hono = new Hono();\n *\n * const json = z.object({\n *     name: z.string(),\n *     age: z.number()\n * });\n *\n * type Json = z.infer<typeof json>;\n *\n * type RouteContext = Context<\n *     Env,\n *     \"/\",\n *     {\n *         in: {\n *             json: Json;\n *         },\n *         out: {\n *             json: Json;\n *         },\n *     },\n * >;\n *\n * app.post(\n *     \"/\",\n *     sValidator(\"json\", json),\n *     (c: RouteContext): Response => {\n *         const data: Json = c.req.valid(\"json\");\n *         return c.json(data);\n *     }\n * );\n * ```\n */\nconst sValidator = <\n    Target extends keyof ValidationTargets,\n    Schema extends StandardSchemaV1,\n>(\n    target: Target,\n    schema: Schema,\n) => {\n    return sv(target, schema, sValidatorHook);\n};\n\nexport { sValidator };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,MAAM,cAIF,QACA,WACC;AACD,QAAOA,aAAG,QAAQ,QAAQ,eAAe"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@jderstd/hono-standard-validator",
+  "version": "0.1.0",
+  "description": "A standard validator for Hono",
+  "keywords": [
+    "jder",
+    "hono",
+    "validator",
+    "ts",
+    "typescript",
+    "js",
+    "javascript"
+  ],
+  "homepage": "https://github.com/jderstd/hono",
+  "bugs": "https://github.com/jderstd/hono/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jderstd/hono.git",
+    "directory": "packages/hono-standard-validator"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Alpheus",
+    "email": "contact@alphe.us"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./hook": {
+      "types": "./dist/hook.d.ts",
+      "import": "./dist/hook.mjs",
+      "require": "./dist/hook.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hono/standard-validator": "~0.1.5",
+    "@standard-schema/spec": "^1.0.0"
+  },
+  "devDependencies": {
+    "hono": "4.5.0",
+    "@jderstd/hono": "0.6.0"
+  },
+  "peerDependencies": {
+    "@jderstd/hono": "~0.6.0",
+    "hono": "^4.5.0"
+  }
+}