@maiyunnet/kebab 9.16.2 → 9.17.1

package/index.d.ts

@@ -5,7 +5,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export declare const VER = "9.16.2";
+export declare const VER = "9.17.1";
 /** --- 框架根目录，以 / 结尾  --- */
 export declare const ROOT_PATH: string;
 /** --- 框架的 LIB，以 / 结尾 --- */

package/index.js

@@ -6,7 +6,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export const VER = '9.16.2';
+export const VER = '9.17.1';
 // --- 服务端用的路径 ---
 const imu = decodeURIComponent(import.meta.url).replace('file://', '').replace(/^\/(\w:)/, '$1');
 /** --- /xxx/xxx --- */

package/lib/core.d.ts

@@ -2,10 +2,13 @@ import * as http from 'http';
 import * as http2 from 'http2';
 import * as stream from 'stream';
 import * as net from 'net';
+import * as valibot from 'valibot';
 import * as kebab from '#kebab/index.js';
 import * as lNetResponse from '#kebab/lib/net/response.js';
 import * as lUndiciResponse from '#kebab/lib/undici/response.js';
 import * as sCtr from '#kebab/sys/ctr.js';
+/** --- Valibot 数据校验工具，业务侧可通过 lCore.v 使用 --- */
+export { valibot as v };
 /** --- 全局参数 --- */
 export declare const globalConfig: kebab.IConfig & {
     'httpPort': number;

package/lib/core.js

@@ -11,6 +11,7 @@ import * as net from 'net';
 import * as crypto from 'crypto';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
+import * as valibot from 'valibot';
 import * as kebab from '#kebab/index.js';
 import * as lTime from '#kebab/lib/time.js';
 import * as lFs from '#kebab/lib/fs.js';
@@ -20,6 +21,8 @@ import * as lCrypto from '#kebab/lib/crypto.js';
 import * as lNetResponse from '#kebab/lib/net/response.js';
 import * as lUndiciResponse from '#kebab/lib/undici/response.js';
 import * as sCtr from '#kebab/sys/ctr.js';
+/** --- Valibot 数据校验工具，业务侧可通过 lCore.v 使用 --- */
+export { valibot as v };
 /** --- 全局参数 --- */
 export const globalConfig = {};
 /** --- JSON Schema 校验器 --- */

package/lib/db/conn.d.ts

@@ -53,9 +53,12 @@ export declare class Connection {
      */
     isUsing(): boolean;
     /**
-     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功并自动刷新最后时间 ---
+     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功 ---
+     * @param opt 获取选项，连接巡检独占时不刷新最后使用时间
      */
-    using(): boolean;
+    using(opt?: {
+        'refreshLast'?: boolean;
+    }): boolean;
     /**
      * --- 取消占用 ---
      */
@@ -85,7 +88,12 @@ export declare class Connection {
      * --- 关闭连接，一般情况下不使用 ---
      */
     end(): Promise<boolean>;
-    beginTransaction(): Promise<boolean>;
+    /**
+     * --- 开启事务，只能在独占连接中使用 ---
+     * @param logError 失败时是否记录错误，连接池在非最后一次重试时传 false
+     * @returns 是否开启成功
+     */
+    beginTransaction(logError?: boolean): Promise<boolean>;
     commit(): Promise<boolean>;
     rollback(): Promise<boolean>;
 }

package/lib/db/conn.js

@@ -99,14 +99,17 @@ export class Connection {
         return this._using;
     }
     /**
-     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功并自动刷新最后时间 ---
+     * --- 判断是否可用（丢失的也算不可用），返回 true 代表获取成功 ---
+     * @param opt 获取选项，连接巡检独占时不刷新最后使用时间
      */
-    using() {
+    using(opt = {}) {
         if (this._lost || this._using) {
             return false;
         }
         else {
-            this.refreshLast();
+            if (opt.refreshLast !== false) {
+                this.refreshLast();
+            }
             this._using = true;
             return true;
         }
@@ -281,6 +284,8 @@ export class Connection {
      * --- 关闭连接，一般情况下不使用 ---
      */
     async end() {
+        // --- 驱动的 end 事件可能在异步关闭完成后才触发，提前标记避免连接池在关闭期间重新取到本连接 ---
+        this._lost = true;
         try {
             await this._link.end();
             return true;
@@ -289,8 +294,12 @@ export class Connection {
             return false;
         }
     }
-    // --- 事务，只能在独占连接中使用，pool 创建事务返回独占连接，commit 或 rollback 释放连接回连接池 ---
-    async beginTransaction() {
+    /**
+     * --- 开启事务，只能在独占连接中使用 ---
+     * @param logError 失败时是否记录错误，连接池在非最后一次重试时传 false
+     * @returns 是否开启成功
+     */
+    async beginTransaction(logError = true) {
         if (this._using) {
             try {
                 this._transaction = true;
@@ -306,12 +315,16 @@ export class Connection {
                 this._transaction = false;
                 this._using = false;
                 this._lost = true;
-                lCore.log({}, '[DB][Connection][beginTransaction] ' + lText.stringifyError(e), '-error');
+                if (logError) {
+                    lCore.log({}, '[DB][Connection][beginTransaction] ' + lText.stringifyError(e), '-error');
+                }
                 return false;
             }
         }
         else {
-            lCore.log({}, '[DB][Connection][beginTransaction] connection is not in use', '-error');
+            if (logError) {
+                lCore.log({}, '[DB][Connection][beginTransaction] connection is not in use', '-error');
+            }
             return false;
         }
     }

package/lib/db/pool.js

@@ -67,6 +67,10 @@ async function checkConnection() {
             }
             continue;
         }
+        // --- 巡检探活或关闭前先独占连接，避免业务在异步操作期间取到同一连接 ---
+        if (!connection.using({ 'refreshLast': false })) {
+            continue;
+        }
         if (connection.getLast() <= now - 30) {
             // --- 超 30 秒未被使用，则关闭 ---
             await connection.end();
@@ -75,8 +79,9 @@ async function checkConnection() {
             continue;
         }
         // --- 30 秒内使用过，看看连接是否正常 ---
-        if (await connection.isAvailable(false)) {
+        if (await connection.isAvailable(false) && !connection.isLost()) {
             // --- 正常 ---
+            connection.used();
             continue;
         }
         // --- 连接有问题，直接关闭 ---
@@ -120,7 +125,7 @@ export class Pool {
      */
     async query(sql, values) {
         ++this._queries;
-        // --- 获取并自动 using  ---
+        // --- 获取并自动 using ---
         const conn = await this._getConnection();
         if (!conn) {
             return {
@@ -167,7 +172,9 @@ export class Pool {
                 lCore.log(ctr ?? {}, `[DB][Pool][beginTransaction] failed to get connection, service: ${lDb.ESERVICE[this._service]}, database: ${this._etc.name ?? ''}`, '-error');
                 return null;
             }
-            if (!await conn.beginTransaction()) {
+            /** --- 只有最后一次尝试仍失败时才记录原始错误，避免已恢复的重试被误判为业务失败 --- */
+            const logError = i === BEGIN_TRANSACTION_MAX_ATTEMPTS - 1;
+            if (!await conn.beginTransaction(logError)) {
                 continue;
             }
             return new Transaction(ctr, conn);

package/lib/fs.js

@@ -440,10 +440,13 @@ export async function readToResponse(path, req, res, stat) {
     }
     // --- 这些文件可能需要缓存 ---
     if (['htm', 'html', 'css', 'js', 'mjs', 'xml', 'jpg', 'jpeg', 'svg', 'gif', 'png', 'json'].includes(mimeData.extension)) {
+        /** --- 静态文件默认缓存秒数 --- */
+        const cacheTTL = 600;
         const hash = `W/"${stat.size.toString(16)}-${stat.mtime.getTime().toString(16)}"`;
         const lastModified = stat.mtime.toUTCString();
         res.setHeader('etag', hash);
-        res.setHeader('cache-control', 'public, max-age=600');
+        res.setHeader('expires', new Date(Date.now() + cacheTTL * 1_000).toUTCString());
+        res.setHeader('cache-control', 'public, max-age=' + cacheTTL.toString());
         // --- 判断返回 304 吗 ---
         const noneMatch = req.headers['if-none-match'];
         const modifiedSince = req.headers['if-modified-since'];

package/lib/undici/response.d.ts

@@ -31,7 +31,7 @@ export declare class Response {
     /**
      * --- 获取响应读取流对象 ---
      */
-    getStream(): (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | zlib.Gunzip | zlib.Inflate | zlib.BrotliDecompress | null;
+    getStream(): zlib.BrotliDecompress | zlib.Gunzip | zlib.Inflate | (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | null;
     /**
      * --- 获取原生响应读取流对象 ---
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "9.16.2",
+  "version": "9.17.1",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "type": "module",
   "keywords": [
@@ -22,10 +22,10 @@
     "#kebab/*": "./*"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.1096.0",
-    "@aws-sdk/lib-storage": "^3.1096.0",
+    "@aws-sdk/client-s3": "^3.1120.0",
+    "@aws-sdk/lib-storage": "^3.1120.0",
     "@litert/http-client": "^1.1.2",
-    "@litert/mime": "^0.1.3",
+    "@litert/mime": "^2.0.0",
     "@litert/redis": "^3.2.1",
     "@litert/websocket": "^0.2.8",
     "@radix-ui/react-checkbox": "^1.3.11",
@@ -39,30 +39,31 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "ejs": "^6.0.1",
-    "esbuild": "^0.28.1",
+    "esbuild": "^0.28.2",
     "jszip": "^3.10.1",
-    "mysql2": "^3.23.2",
+    "mysql2": "^3.24.2",
     "node-cron": "^4.6.0",
-    "openai": "^7.0.0",
-    "pg": "^8.22.0",
+    "openai": "^7.8.0",
+    "pg": "^8.23.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "react-router-dom": "^7.18.1",
+    "react-router-dom": "^7.18.2",
     "ssh2": "^1.17.0",
     "svg-captcha": "^1.4.0",
     "tailwind-merge": "^3.6.0",
-    "tencentcloud-sdk-nodejs": "^4.1.277",
-    "undici": "^8.9.0"
+    "tencentcloud-sdk-nodejs": "^4.1.303",
+    "undici": "^8.10.0",
+    "valibot": "^1.4.2"
   },
   "devDependencies": {
     "@litert/eslint-plugin-rules": "^0.3.1",
     "@types/ejs": "^3.1.5",
-    "@types/node": "^26.1.2",
-    "@types/pg": "^8.20.0",
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3",
+    "@types/node": "^26.4.0",
+    "@types/pg": "^8.23.1",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.5",
     "typedoc": "^0.28.20",
-    "typedoc-plugin-markdown": "^4.12.0",
+    "typedoc-plugin-markdown": "^4.13.0",
     "typescript": "^6.0.3"
   }
 }

package/sys/ctr.d.ts

@@ -1,5 +1,11 @@
+/**
+ * Project: Kebab, User: JianSuoQiYue
+ * Date: 2020-3-14 17:24:38
+ * Last: 2020-3-30 15:31:40, 2022-07-22 16:59:00, 2022-09-12 23:51:56, 2022-09-23 15:53:58, 2022-12-29 01:18:08, 2023-2-28 20:07:57, 2023-12-27 18:39:35, 2024-3-1 19:38:53, 2024-4-9 16:03:58, 2025-2-12 18:55:44, 2025-6-12 16:56:08, 2026-8-22
+ */
 import * as http from 'http';
 import * as http2 from 'http2';
+import type * as v from 'valibot';
 import * as kebab from '#kebab/index.js';
 import * as lSession from '#kebab/lib/session.js';
 import * as lDb from '#kebab/lib/db.js';
@@ -9,6 +15,49 @@ import * as lWs from '#kebab/lib/ws.js';
  * --- 清除已经加载的 data 与语言包文件缓存 ---
  */
 export declare function clearLocaleData(): void;
+/** --- Valibot 校验失败时可直接返回给客户端的内容或生成函数 --- */
+export type TValibotResponse<TIssue extends v.BaseIssue<unknown>> = kebab.Json[] | ((issues: [TIssue, ...TIssue[]]) => kebab.Json[]);
+/** --- 在 issue 路径完整后，根据 Kebab 生成的语言键翻译消息 --- */
+export type TValibotTranslate = (key: string, issue: v.BaseIssue<unknown>) => string;
+/** --- Valibot 同步校验选项 --- */
+export interface IValibotOptions<TIssue extends v.BaseIssue<unknown>> {
+    /** --- 传给 Valibot 的校验配置 --- */
+    'config'?: v.Config<TIssue>;
+    /** --- 校验失败时返回给客户端的内容，默认使用首个 issue 的消息 --- */
+    'response'?: TValibotResponse<TIssue>;
+    /** --- 使用完整 issue 路径翻译消息 --- */
+    'translate'?: TValibotTranslate;
+}
+/** --- XSRF 校验失败的问题描述 --- */
+export interface IValibotXsrfIssue extends v.BaseIssue<unknown> {
+    readonly kind: 'validation';
+    readonly type: 'xsrf';
+}
+/** --- 带 XSRF 检测的 Valibot 同步校验选项 --- */
+export interface IValibotXOptions<TIssue extends v.BaseIssue<unknown>> {
+    /** --- 传给 Valibot 的校验配置 --- */
+    'config'?: v.Config<TIssue>;
+    /** --- 校验失败时返回给客户端的内容，回调同时可能收到 XSRF issue --- */
+    'response'?: TValibotResponse<TIssue | IValibotXsrfIssue>;
+    /** --- 使用完整 issue 路径翻译消息，包括 XSRF issue --- */
+    'translate'?: TValibotTranslate;
+    /** --- 是否忽略 XSRF 检测 --- */
+    'ignoreXsrf'?: boolean;
+}
+/** --- Valibot 校验结果：仅成功分支提供 schema 推导后的 output --- */
+export type TValibotResult<TSchema extends v.GenericSchema, TIssue extends v.BaseIssue<unknown> = v.InferIssue<TSchema>> = {
+    readonly typed: true;
+    readonly success: true;
+    readonly output: v.InferOutput<TSchema>;
+    readonly issues: undefined;
+    readonly response: undefined;
+} | {
+    readonly typed: boolean;
+    readonly success: false;
+    readonly output: undefined;
+    readonly issues: [TIssue, ...TIssue[]];
+    readonly response: kebab.Json[];
+};
 export declare class Ctr {
     /** --- 路由参数序列数组 --- */
     protected _param: string[];
@@ -200,6 +249,42 @@ export declare class Ctr {
      * @param msgSuffix 可选的消息后缀
      */
     private _setCheckError;
+    /**
+     * --- 生成 Valibot 校验失败结果 ---
+     * @param issues Valibot 问题列表
+     * @param response 自定义客户端返回值或生成函数
+     * @returns 校验失败结果
+     */
+    private _getValibotFailure;
+    /**
+     * --- 根据完整 issue 路径生成 Kebab 语言包键 ---
+     * @param issue Valibot 校验问题
+     * @returns 语言包键
+     */
+    private _getValibotLocaleKey;
+    /**
+     * --- 在 Valibot 完成父级路径组装后翻译问题消息 ---
+     * @param issues Valibot 问题列表
+     * @param translate 消息翻译函数
+     * @returns 翻译后的问题列表
+     */
+    private _translateValibotIssues;
+    /**
+     * --- 使用 Valibot schema 校验并解析输入，成功后 output 会自动推导类型 ---
+     * @param schema Valibot 同步 schema
+     * @param input 待校验的输入
+     * @param options Valibot 配置和自定义客户端返回值
+     * @returns 可判别的校验结果
+     */
+    protected _valibot<const TSchema extends v.GenericSchema>(schema: TSchema, input: unknown, options?: IValibotOptions<v.InferIssue<TSchema>>): TValibotResult<TSchema>;
+    /**
+     * --- 使用 Valibot schema 校验并解析输入，同时检测 XSRF ---
+     * @param schema Valibot 同步 schema
+     * @param input 待校验的输入
+     * @param options Valibot 配置、自定义客户端返回值和 XSRF 选项
+     * @returns 可判别的校验结果
+     */
+    protected _valibotx<const TSchema extends v.GenericSchema>(schema: TSchema, input: unknown, options?: IValibotXOptions<v.InferIssue<TSchema>>): TValibotResult<TSchema, v.InferIssue<TSchema> | IValibotXsrfIssue>;
     /**
      * --- 检测提交的数据类型 ---
      * @param input 要校验的输入项

package/sys/ctr.js

@@ -1,8 +1,3 @@
-/**
- * Project: Kebab, User: JianSuoQiYue
- * Date: 2020-3-14 17:24:38
- * Last: 2020-3-30 15:31:40, 2022-07-22 16:59:00, 2022-09-12 23:51:56, 2022-09-23 15:53:58, 2022-12-29 01:18:08, 2023-2-28 20:07:57, 2023-12-27 18:39:35, 2024-3-1 19:38:53, 2024-4-9 16:03:58, 2025-2-12 18:55:44, 2025-6-12 16:56:08, 2026-8-22
- */
 import ejs from 'ejs';
 import * as lCore from '#kebab/lib/core.js';
 import * as lFs from '#kebab/lib/fs.js';
@@ -416,6 +411,123 @@ export class Ctr {
             rtn[2] = lastVal[2];
         }
     }
+    /**
+     * --- 生成 Valibot 校验失败结果 ---
+     * @param issues Valibot 问题列表
+     * @param response 自定义客户端返回值或生成函数
+     * @returns 校验失败结果
+     */
+    _getValibotFailure(issues, response, translate) {
+        /** --- 路径已完整且消息已翻译的问题列表 --- */
+        const translatedIssues = this._translateValibotIssues(issues, translate);
+        const clientResponse = typeof response === 'function' ? response(translatedIssues) : response;
+        return {
+            'typed': false,
+            'success': false,
+            'output': undefined,
+            'issues': translatedIssues,
+            'response': clientResponse ?? [0, translatedIssues[0].message],
+        };
+    }
+    /**
+     * --- 根据完整 issue 路径生成 Kebab 语言包键 ---
+     * @param issue Valibot 校验问题
+     * @returns 语言包键
+     */
+    _getValibotLocaleKey(issue) {
+        if ((issue.type === 'strict_object') && (issue.expected === 'never')) {
+            return 'validation.strict_object';
+        }
+        const path = lCore.v.getDotPath(issue);
+        return path ? `validation.${path}.${issue.type}` : `validation.${issue.type}`;
+    }
+    /**
+     * --- 在 Valibot 完成父级路径组装后翻译问题消息 ---
+     * @param issues Valibot 问题列表
+     * @param translate 消息翻译函数
+     * @returns 翻译后的问题列表
+     */
+    _translateValibotIssues(issues, translate) {
+        if (!translate) {
+            return issues;
+        }
+        const translateIssue = (issue) => {
+            const key = this._getValibotLocaleKey(issue);
+            const message = translate(key, issue);
+            return {
+                ...issue,
+                /** --- 语言包缺失时保留键名，并回退到 Valibot 原始英文原因 --- */
+                'message': message === `[LocaleError]${key}` ? `[${key}] ${issue.message}` : message,
+            };
+        };
+        return [translateIssue(issues[0]), ...issues.slice(1).map(translateIssue)];
+    }
+    /**
+     * --- 使用 Valibot schema 校验并解析输入，成功后 output 会自动推导类型 ---
+     * @param schema Valibot 同步 schema
+     * @param input 待校验的输入
+     * @param options Valibot 配置和自定义客户端返回值
+     * @returns 可判别的校验结果
+     */
+    _valibot(schema, input, options) {
+        const result = lCore.v.safeParse(schema, input, options?.config);
+        if (!result.success) {
+            return this._getValibotFailure(result.issues, options?.response, options?.translate);
+        }
+        return {
+            ...result,
+            'response': undefined,
+        };
+    }
+    /**
+     * --- 使用 Valibot schema 校验并解析输入，同时检测 XSRF ---
+     * @param schema Valibot 同步 schema
+     * @param input 待校验的输入
+     * @param options Valibot 配置、自定义客户端返回值和 XSRF 选项
+     * @returns 可判别的校验结果
+     */
+    _valibotx(schema, input, options) {
+        /** --- 用户提交的 XSRF token --- */
+        let submittedXsrf;
+        /** --- 移除 XSRF 传输字段后交给业务 schema 的输入 --- */
+        let schemaInput = input;
+        if ((typeof input === 'object') && (input !== null) && !Array.isArray(input)) {
+            const inputRecord = input;
+            submittedXsrf = inputRecord['_xsrf'];
+            schemaInput = { ...inputRecord };
+            delete schemaInput['_xsrf'];
+        }
+        if (!options?.ignoreXsrf) {
+            /** --- Cookie 中应匹配的 XSRF token --- */
+            const expectedXsrf = this._cookie['XSRF-TOKEN'];
+            if (!expectedXsrf || (submittedXsrf !== expectedXsrf)) {
+                const issue = {
+                    'kind': 'validation',
+                    'type': 'xsrf',
+                    'input': undefined,
+                    'expected': 'valid XSRF token',
+                    'received': submittedXsrf === undefined ? 'undefined' : typeof submittedXsrf,
+                    'message': 'Bad request, no permission.',
+                    'path': [{
+                            'type': 'unknown',
+                            'origin': 'value',
+                            'input': undefined,
+                            'key': '_xsrf',
+                            'value': undefined,
+                        }],
+                };
+                return this._getValibotFailure([issue], options?.response, options?.translate);
+            }
+        }
+        const result = lCore.v.safeParse(schema, schemaInput, options?.config);
+        if (!result.success) {
+            return this._getValibotFailure(result.issues, options?.response, options?.translate);
+        }
+        return {
+            ...result,
+            'response': undefined,
+        };
+    }
     /**
      * --- 检测提交的数据类型 ---
      * @param input 要校验的输入项

package/www/example/ctr/test.d.ts

@@ -18,6 +18,8 @@ export default class extends sCtr.Ctr {
     ctrCheckinput1(): Promise<kebab.Json[]>;
     ctrCheckinputSchema(): string;
     ctrCheckinputSchema1(): Promise<kebab.Json[]>;
+    ctrValibot(): Promise<kebab.Json[] | string>;
+    ctrValibot1(): Promise<kebab.Json[]>;
     ctrLocale(): Promise<kebab.Json[] | string>;
     ctrCachettl(): string;
     ctrHttpcode(): string;

package/www/example/ctr/test.js

@@ -28,6 +28,15 @@ import * as sCtr from '#kebab/sys/ctr.js';
 // --- mod ---
 import mTest from '../mod/test.js';
 import mTestData from '../mod/testdata.js';
+/** --- Kebab 核心库提供的 Valibot 对象 --- */
+const v = lCore.v;
+/** --- Valibot 示例支持的语言 --- */
+const valibotLocaleSchema = v.picklist(['en', 'sc', 'tc', 'ja']);
+/** --- 模块级复用的 Valibot 输入规则，不绑定任何请求或语言 --- */
+const valibotInputSchema = v.strictObject({
+    'title': v.pipe(v.string(), v.nonEmpty()),
+    'count': v.pipe(v.string(), v.toNumber(), v.integer()),
+});
 export default class extends sCtr.Ctr {
     _internalUrl = '';
     onLoad() {
@@ -114,6 +123,7 @@ export default class extends sCtr.Ctr {
             '<br><br><b>Ctr:</b>',
             `<br><br><a href="${this._config.const.urlBase}test/ctr-xsrf">View "test/ctr-xsrf"</a>`,
             `<br><a href="${this._config.const.urlBase}test/ctr-checkinput">View "test/ctr-checkinput"</a> <a href="${this._config.const.urlBase}test/ctr-checkinput-schema">schema</a>`,
+            `<br><a href="${this._config.const.urlBase}test/ctr-valibot">View "test/ctr-valibot"</a>`,
             `<br><a href="${this._config.const.urlBase}test/ctr-locale">View "test/ctr-locale"</a>`,
             `<br><a href="${this._config.const.urlBase}test/ctr-cachettl">View "test/ctr-cachettl"</a>`,
             `<br><a href="${this._config.const.urlBase}test/ctr-httpcode">View "test/ctr-httpcode"</a>`,
@@ -546,6 +556,88 @@ function post(p) {
         }
         return [1, { 'post': this._post }];
     }
+    async ctrValibot() {
+        const locale = this._valibot(valibotLocaleSchema, this._get['lang'] ?? 'en', {
+            'response': [0, 'Wrong language.'],
+        });
+        if (!locale.success) {
+            return locale.response;
+        }
+        if (!await this._loadLocale(locale.output, 'test')) {
+            return [0, 'Could not load locale.'];
+        }
+        this._enabledXsrf();
+        const echo = [
+            '<b>Test _valibotx with inferred output and request locale</b><br><br>',
+            `<a href="${this._config.const.urlBase}test/ctr-valibot?lang=en">English</a> | ` +
+                `<a href="${this._config.const.urlBase}test/ctr-valibot?lang=sc">简体中文</a> | ` +
+                `<a href="${this._config.const.urlBase}test/ctr-valibot?lang=tc">繁體中文</a> | ` +
+                `<a href="${this._config.const.urlBase}test/ctr-valibot?lang=ja">日本語</a><br><br>`,
+            `<b>Current locale:</b> ${locale.output}<br><br>`,
+            `<pre>const v = lCore.v;
+const valibotInputSchema = v.strictObject({
+    'title': v.pipe(v.string(), v.nonEmpty()),
+    'count': v.pipe(v.string(), v.toNumber(), v.integer()),
+});</pre>`,
+        ];
+        const posts = [
+            { 'title': 'Kebab', 'count': '2' },
+            { 'title': '', 'count': '2' },
+            { 'title': 'Kebab', 'count': 'abc' },
+            { 'title': 'Kebab', 'count': '1.5' },
+            { 'title': 'Kebab', 'count': '2', 'extra': true },
+        ];
+        for (const item of posts) {
+            const str = lText.stringifyJson(item).replace(/"/g, '&quot;');
+            echo.push(`<input type="button" value="Post '${str}'" onclick="post('${str}')"><br>`);
+        }
+        echo.push(`<script>
+function post(p) {
+    const data = JSON.parse(p);
+    data._xsrf = '${this._xsrf}';
+    document.getElementById('result').innerText = 'Waiting...';
+    fetch('${this._config.const.urlBase}test/ctr-valibot1?lang=${locale.output}', {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json'
+        },
+        body: JSON.stringify(data)
+    }).then(function(r) {
+        return r.text();
+    }).then(function(t) {
+        document.getElementById('result').innerText = t;
+    });
+}
+</script>
+<br>Result:<pre id="result">Nothing.</pre>`);
+        return echo.join('') + this._getEnd();
+    }
+    async ctrValibot1() {
+        if (!await this._handleFormData()) {
+            return [0];
+        }
+        const locale = this._valibot(valibotLocaleSchema, this._get['lang'] ?? 'en', {
+            'response': [0, 'Wrong language.'],
+        });
+        if (!locale.success) {
+            return locale.response;
+        }
+        if (!await this._loadLocale(locale.output, 'test')) {
+            return [0, 'Could not load locale.'];
+        }
+        const parsed = this._valibotx(valibotInputSchema, this._post, {
+            'translate': key => this._l(key),
+            'response': issues => [0, issues[0].message, {
+                    'issues': v.flatten(issues),
+                }],
+        });
+        if (!parsed.success) {
+            return parsed.response;
+        }
+        return [1, {
+                'post': parsed.output,
+            }];
+    }
     async ctrLocale() {
         const rtn = [];
         if (!this._checkInput(this._get, {

package/www/example/data/locale/en.test.json

@@ -4,5 +4,22 @@
     "test": "The ? test ?.",
     "test2": {
         "test3": "test4"
+    },
+    "validation": {
+        "strict_object": "The submitted data must be an object and contain only supported fields.",
+        "_xsrf": {
+            "xsrf": "Bad request, no permission."
+        },
+        "title": {
+            "strict_object": "The title is required.",
+            "string": "The title must be a string.",
+            "non_empty": "Please enter a title."
+        },
+        "count": {
+            "strict_object": "The count is required.",
+            "string": "The count must be a string.",
+            "to_number": "The count must be a number.",
+            "integer": "The count must be an integer."
+        }
     }
-}
+}