@optique/valibot 0.7.0-dev.144

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2025 Hong Minhee
+
+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,180 @@
+@optique/valibot
+================
+
+> [!WARNING]
+> The API is stabilizing, but may change before the 1.0 release.
+
+Valibot value parsers for Optique. This package provides seamless integration
+between [Valibot] schemas and *@optique/core*, enabling powerful validation and
+type-safe parsing of command-line arguments with minimal bundle size.
+
+[Valibot]: https://valibot.dev/
+
+
+Installation
+------------
+
+~~~~ bash
+deno add jsr:@optique/valibot jsr:@optique/run jsr:@optique/core valibot
+npm  add     @optique/valibot     @optique/run     @optique/core valibot
+pnpm add     @optique/valibot     @optique/run     @optique/core valibot
+yarn add     @optique/valibot     @optique/run     @optique/core valibot
+bun  add     @optique/valibot     @optique/run     @optique/core valibot
+~~~~
+
+This package supports Valibot versions 0.42.0 and above.
+
+
+Quick example
+-------------
+
+The following example uses the `valibot()` value parser to validate an email
+address.
+
+~~~~ typescript
+import { run } from "@optique/run";
+import { option } from "@optique/core/parser";
+import { valibot } from "@optique/valibot";
+import * as v from "valibot";
+
+const cli = run({
+  email: option("--email", valibot(v.pipe(v.string(), v.email()))),
+});
+
+console.log(`Welcome, ${cli.email}!`);
+~~~~
+
+Run it:
+
+~~~~ bash
+$ node cli.js --email user@example.com
+Welcome, user@example.com!
+
+$ node cli.js --email invalid-email
+Error: Invalid email
+~~~~
+
+
+Common use cases
+----------------
+
+### Email validation
+
+~~~~ typescript
+import { valibot } from "@optique/valibot";
+import * as v from "valibot";
+
+const email = option("--email", valibot(v.pipe(v.string(), v.email())));
+~~~~
+
+### URL validation
+
+~~~~ typescript
+import { valibot } from "@optique/valibot";
+import * as v from "valibot";
+
+const url = option("--url", valibot(v.pipe(v.string(), v.url())));
+~~~~
+
+### Port numbers with range validation
+
+> [!IMPORTANT]
+> Always use explicit transformations with `v.pipe()` and `v.transform()` for
+> non-string types, since CLI arguments are always strings.
+
+~~~~ typescript
+import { valibot } from "@optique/valibot";
+import * as v from "valibot";
+
+const port = option("-p", "--port",
+  valibot(v.pipe(
+    v.string(),
+    v.transform(Number),
+    v.number(),
+    v.integer(),
+    v.minValue(1024),
+    v.maxValue(65535)
+  ))
+);
+~~~~
+
+### Enum choices
+
+~~~~ typescript
+import { valibot } from "@optique/valibot";
+import * as v from "valibot";
+
+const logLevel = option("--log-level",
+  valibot(v.picklist(["debug", "info", "warn", "error"]))
+);
+~~~~
+
+### Date transformations
+
+~~~~ typescript
+import { valibot } from "@optique/valibot";
+import * as v from "valibot";
+
+const startDate = argument(
+  valibot(v.pipe(v.string(), v.transform((s) => new Date(s))))
+);
+~~~~
+
+
+Custom error messages
+---------------------
+
+You can customize error messages using the `errors` option:
+
+~~~~ typescript
+import { valibot } from "@optique/valibot";
+import { message } from "@optique/core/message";
+import * as v from "valibot";
+
+const email = option("--email", valibot(v.pipe(v.string(), v.email()), {
+  metavar: "EMAIL",
+  errors: {
+    valibotError: (issues, input) =>
+      message`Please provide a valid email address, got ${input}.`
+  }
+}));
+~~~~
+
+
+Important notes
+---------------
+
+### Always use explicit transformations for non-string types
+
+CLI arguments are always strings. If you want to parse numbers, booleans,
+or other types, you must use explicit `v.transform()`:
+
+~~~~ typescript
+// ✅ Correct
+const port = option("-p", valibot(v.pipe(v.string(), v.transform(Number))));
+
+// ❌ Won't work (CLI arguments are always strings)
+const port = option("-p", valibot(v.number()));
+~~~~
+
+### Async validations are not supported
+
+Optique's `ValueParser.parse()` is synchronous, so async Valibot features like
+async validations cannot be supported:
+
+~~~~ typescript
+// ❌ Not supported
+const email = option("--email",
+  valibot(v.pipeAsync(v.string(), v.checkAsync(async (val) => await checkDB(val))))
+);
+~~~~
+
+If you need async validation, perform it after parsing the CLI arguments.
+
+
+For more resources
+------------------
+
+ -  [Optique documentation](https://optique.dev/)
+ -  [Valibot documentation](https://valibot.dev/)
+ -  [Examples directory](/examples/)

package/dist/index.cjs

@@ -0,0 +1,198 @@
+//#region rolldown:runtime
+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));
+
+//#endregion
+const __optique_core_message = __toESM(require("@optique/core/message"));
+const valibot = __toESM(require("valibot"));
+
+//#region src/index.ts
+/**
+* Infers an appropriate metavar string from a Valibot schema.
+*
+* This function analyzes the Valibot schema's internal structure to determine
+* the most appropriate metavar string for help text generation.
+*
+* @param schema A Valibot schema to analyze.
+* @returns The inferred metavar string.
+*
+* @example
+* ```typescript
+* inferMetavar(v.string())           // "STRING"
+* inferMetavar(v.email())            // "EMAIL"
+* inferMetavar(v.number())           // "NUMBER"
+* inferMetavar(v.integer())          // "INTEGER"
+* inferMetavar(v.picklist(["a"]))    // "CHOICE"
+* ```
+*
+* @since 0.7.0
+*/
+function inferMetavar(schema) {
+	const schemaType = schema.type;
+	if (!schemaType) return "VALUE";
+	if (schemaType === "string") {
+		const pipeline = schema.pipe;
+		if (Array.isArray(pipeline)) for (const action of pipeline) {
+			const actionType = action.type;
+			if (actionType === "transform") return "VALUE";
+			if (actionType === "email") return "EMAIL";
+			if (actionType === "url") return "URL";
+			if (actionType === "uuid") return "UUID";
+			if (actionType === "ulid") return "ULID";
+			if (actionType === "cuid2") return "CUID2";
+			if (actionType === "iso_date") return "DATE";
+			if (actionType === "iso_date_time") return "DATETIME";
+			if (actionType === "iso_time") return "TIME";
+			if (actionType === "iso_timestamp") return "TIMESTAMP";
+			if (actionType === "ipv4") return "IPV4";
+			if (actionType === "ipv6") return "IPV6";
+			if (actionType === "ip") return "IP";
+			if (actionType === "emoji") return "EMOJI";
+			if (actionType === "base64") return "BASE64";
+		}
+		return "STRING";
+	}
+	if (schemaType === "number") {
+		const pipeline = schema.pipe;
+		if (Array.isArray(pipeline)) for (const action of pipeline) {
+			const actionType = action.type;
+			if (actionType === "transform") return "VALUE";
+			if (actionType === "integer") return "INTEGER";
+		}
+		return "NUMBER";
+	}
+	if (schemaType === "boolean") return "BOOLEAN";
+	if (schemaType === "date") return "DATE";
+	if (schemaType === "picklist") return "CHOICE";
+	if (schemaType === "literal") return "VALUE";
+	if (schemaType === "union" || schemaType === "variant") return "VALUE";
+	if (schemaType === "optional" || schemaType === "nullable" || schemaType === "nullish") {
+		const wrapped = schema.wrapped;
+		if (wrapped) return inferMetavar(wrapped);
+	}
+	return "VALUE";
+}
+/**
+* Creates a value parser from a Valibot schema.
+*
+* This parser validates CLI argument strings using Valibot schemas, enabling
+* powerful validation and transformation capabilities with minimal bundle size
+* for command-line interfaces.
+*
+* The metavar is automatically inferred from the schema type unless explicitly
+* provided in options. For example:
+* - `v.string()` → `"STRING"`
+* - `v.pipe(v.string(), v.email())` → `"EMAIL"`
+* - `v.number()` → `"NUMBER"`
+* - `v.pipe(v.number(), v.integer())` → `"INTEGER"`
+* - `v.picklist([...])` → `"CHOICE"`
+*
+* @template T The output type of the Valibot schema.
+* @param schema A Valibot schema to validate input against.
+* @param options Optional configuration for the parser.
+* @returns A value parser that validates inputs using the provided schema.
+*
+* @example Basic string validation
+* ```typescript
+* import * as v from "valibot";
+* import { valibot } from "@optique/valibot";
+* import { option } from "@optique/core/primitives";
+*
+* const email = option("--email", valibot(v.pipe(v.string(), v.email())));
+* ```
+*
+* @example Number validation with pipeline
+* ```typescript
+* import * as v from "valibot";
+* import { valibot } from "@optique/valibot";
+* import { option } from "@optique/core/primitives";
+*
+* // Use v.pipe with v.transform for non-string types since CLI args are always strings
+* const port = option("-p", "--port",
+*   valibot(v.pipe(
+*     v.string(),
+*     v.transform(Number),
+*     v.number(),
+*     v.integer(),
+*     v.minValue(1024),
+*     v.maxValue(65535)
+*   ))
+* );
+* ```
+*
+* @example Picklist validation
+* ```typescript
+* import * as v from "valibot";
+* import { valibot } from "@optique/valibot";
+* import { option } from "@optique/core/primitives";
+*
+* const logLevel = option("--log-level",
+*   valibot(v.picklist(["debug", "info", "warn", "error"]))
+* );
+* ```
+*
+* @example Custom error messages
+* ```typescript
+* import * as v from "valibot";
+* import { valibot } from "@optique/valibot";
+* import { message } from "@optique/core/message";
+* import { option } from "@optique/core/primitives";
+*
+* const email = option("--email",
+*   valibot(v.pipe(v.string(), v.email()), {
+*     metavar: "EMAIL",
+*     errors: {
+*       valibotError: (issues, input) =>
+*         message`Please provide a valid email address, got ${input}.`
+*     }
+*   })
+* );
+* ```
+*
+* @since 0.7.0
+*/
+function valibot$1(schema, options = {}) {
+	return {
+		metavar: options.metavar ?? inferMetavar(schema),
+		parse(input) {
+			const result = (0, valibot.safeParse)(schema, input);
+			if (result.success) return {
+				success: true,
+				value: result.output
+			};
+			if (options.errors?.valibotError) return {
+				success: false,
+				error: typeof options.errors.valibotError === "function" ? options.errors.valibotError(result.issues, input) : options.errors.valibotError
+			};
+			const firstIssue = result.issues[0];
+			return {
+				success: false,
+				error: __optique_core_message.message`${firstIssue?.message ?? "Validation failed"}`
+			};
+		},
+		format(value) {
+			return String(value);
+		}
+	};
+}
+
+//#endregion
+exports.valibot = valibot$1;

package/dist/index.d.cts

@@ -0,0 +1,113 @@
+import { ValueParser } from "@optique/core/valueparser";
+import { Message } from "@optique/core/message";
+import * as v from "valibot";
+
+//#region src/index.d.ts
+
+/**
+ * Options for creating a Valibot value parser.
+ * @since 0.7.0
+ */
+interface ValibotParserOptions {
+  /**
+   * The metavariable name for this parser. This is used in help messages to
+   * indicate what kind of value this parser expects. Usually a single
+   * word in uppercase, like `VALUE` or `SCHEMA`.
+   * @default `"VALUE"`
+   */
+  readonly metavar?: string;
+  /**
+   * Custom error messages for Valibot validation failures.
+   */
+  readonly errors?: {
+    /**
+     * Custom error message when input fails Valibot validation.
+     * Can be a static message or a function that receives the Valibot issues
+     * and input string.
+     * @since 0.7.0
+     */
+    valibotError?: Message | ((issues: v.InferIssue<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>[], input: string) => Message);
+  };
+}
+/**
+ * Creates a value parser from a Valibot schema.
+ *
+ * This parser validates CLI argument strings using Valibot schemas, enabling
+ * powerful validation and transformation capabilities with minimal bundle size
+ * for command-line interfaces.
+ *
+ * The metavar is automatically inferred from the schema type unless explicitly
+ * provided in options. For example:
+ * - `v.string()` → `"STRING"`
+ * - `v.pipe(v.string(), v.email())` → `"EMAIL"`
+ * - `v.number()` → `"NUMBER"`
+ * - `v.pipe(v.number(), v.integer())` → `"INTEGER"`
+ * - `v.picklist([...])` → `"CHOICE"`
+ *
+ * @template T The output type of the Valibot schema.
+ * @param schema A Valibot schema to validate input against.
+ * @param options Optional configuration for the parser.
+ * @returns A value parser that validates inputs using the provided schema.
+ *
+ * @example Basic string validation
+ * ```typescript
+ * import * as v from "valibot";
+ * import { valibot } from "@optique/valibot";
+ * import { option } from "@optique/core/primitives";
+ *
+ * const email = option("--email", valibot(v.pipe(v.string(), v.email())));
+ * ```
+ *
+ * @example Number validation with pipeline
+ * ```typescript
+ * import * as v from "valibot";
+ * import { valibot } from "@optique/valibot";
+ * import { option } from "@optique/core/primitives";
+ *
+ * // Use v.pipe with v.transform for non-string types since CLI args are always strings
+ * const port = option("-p", "--port",
+ *   valibot(v.pipe(
+ *     v.string(),
+ *     v.transform(Number),
+ *     v.number(),
+ *     v.integer(),
+ *     v.minValue(1024),
+ *     v.maxValue(65535)
+ *   ))
+ * );
+ * ```
+ *
+ * @example Picklist validation
+ * ```typescript
+ * import * as v from "valibot";
+ * import { valibot } from "@optique/valibot";
+ * import { option } from "@optique/core/primitives";
+ *
+ * const logLevel = option("--log-level",
+ *   valibot(v.picklist(["debug", "info", "warn", "error"]))
+ * );
+ * ```
+ *
+ * @example Custom error messages
+ * ```typescript
+ * import * as v from "valibot";
+ * import { valibot } from "@optique/valibot";
+ * import { message } from "@optique/core/message";
+ * import { option } from "@optique/core/primitives";
+ *
+ * const email = option("--email",
+ *   valibot(v.pipe(v.string(), v.email()), {
+ *     metavar: "EMAIL",
+ *     errors: {
+ *       valibotError: (issues, input) =>
+ *         message`Please provide a valid email address, got ${input}.`
+ *     }
+ *   })
+ * );
+ * ```
+ *
+ * @since 0.7.0
+ */
+declare function valibot<T>(schema: v.BaseSchema<unknown, T, v.BaseIssue<unknown>>, options?: ValibotParserOptions): ValueParser<T>;
+//#endregion
+export { ValibotParserOptions, valibot };

package/dist/index.d.ts

@@ -0,0 +1,113 @@
+import { Message } from "@optique/core/message";
+import * as v from "valibot";
+import { ValueParser } from "@optique/core/valueparser";
+
+//#region src/index.d.ts
+
+/**
+ * Options for creating a Valibot value parser.
+ * @since 0.7.0
+ */
+interface ValibotParserOptions {
+  /**
+   * The metavariable name for this parser. This is used in help messages to
+   * indicate what kind of value this parser expects. Usually a single
+   * word in uppercase, like `VALUE` or `SCHEMA`.
+   * @default `"VALUE"`
+   */
+  readonly metavar?: string;
+  /**
+   * Custom error messages for Valibot validation failures.
+   */
+  readonly errors?: {
+    /**
+     * Custom error message when input fails Valibot validation.
+     * Can be a static message or a function that receives the Valibot issues
+     * and input string.
+     * @since 0.7.0
+     */
+    valibotError?: Message | ((issues: v.InferIssue<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>[], input: string) => Message);
+  };
+}
+/**
+ * Creates a value parser from a Valibot schema.
+ *
+ * This parser validates CLI argument strings using Valibot schemas, enabling
+ * powerful validation and transformation capabilities with minimal bundle size
+ * for command-line interfaces.
+ *
+ * The metavar is automatically inferred from the schema type unless explicitly
+ * provided in options. For example:
+ * - `v.string()` → `"STRING"`
+ * - `v.pipe(v.string(), v.email())` → `"EMAIL"`
+ * - `v.number()` → `"NUMBER"`
+ * - `v.pipe(v.number(), v.integer())` → `"INTEGER"`
+ * - `v.picklist([...])` → `"CHOICE"`
+ *
+ * @template T The output type of the Valibot schema.
+ * @param schema A Valibot schema to validate input against.
+ * @param options Optional configuration for the parser.
+ * @returns A value parser that validates inputs using the provided schema.
+ *
+ * @example Basic string validation
+ * ```typescript
+ * import * as v from "valibot";
+ * import { valibot } from "@optique/valibot";
+ * import { option } from "@optique/core/primitives";
+ *
+ * const email = option("--email", valibot(v.pipe(v.string(), v.email())));
+ * ```
+ *
+ * @example Number validation with pipeline
+ * ```typescript
+ * import * as v from "valibot";
+ * import { valibot } from "@optique/valibot";
+ * import { option } from "@optique/core/primitives";
+ *
+ * // Use v.pipe with v.transform for non-string types since CLI args are always strings
+ * const port = option("-p", "--port",
+ *   valibot(v.pipe(
+ *     v.string(),
+ *     v.transform(Number),
+ *     v.number(),
+ *     v.integer(),
+ *     v.minValue(1024),
+ *     v.maxValue(65535)
+ *   ))
+ * );
+ * ```
+ *
+ * @example Picklist validation
+ * ```typescript
+ * import * as v from "valibot";
+ * import { valibot } from "@optique/valibot";
+ * import { option } from "@optique/core/primitives";
+ *
+ * const logLevel = option("--log-level",
+ *   valibot(v.picklist(["debug", "info", "warn", "error"]))
+ * );
+ * ```
+ *
+ * @example Custom error messages
+ * ```typescript
+ * import * as v from "valibot";
+ * import { valibot } from "@optique/valibot";
+ * import { message } from "@optique/core/message";
+ * import { option } from "@optique/core/primitives";
+ *
+ * const email = option("--email",
+ *   valibot(v.pipe(v.string(), v.email()), {
+ *     metavar: "EMAIL",
+ *     errors: {
+ *       valibotError: (issues, input) =>
+ *         message`Please provide a valid email address, got ${input}.`
+ *     }
+ *   })
+ * );
+ * ```
+ *
+ * @since 0.7.0
+ */
+declare function valibot<T>(schema: v.BaseSchema<unknown, T, v.BaseIssue<unknown>>, options?: ValibotParserOptions): ValueParser<T>;
+//#endregion
+export { ValibotParserOptions, valibot };

package/dist/index.js

@@ -0,0 +1,175 @@
+import { message } from "@optique/core/message";
+import { safeParse } from "valibot";
+
+//#region src/index.ts
+/**
+* Infers an appropriate metavar string from a Valibot schema.
+*
+* This function analyzes the Valibot schema's internal structure to determine
+* the most appropriate metavar string for help text generation.
+*
+* @param schema A Valibot schema to analyze.
+* @returns The inferred metavar string.
+*
+* @example
+* ```typescript
+* inferMetavar(v.string())           // "STRING"
+* inferMetavar(v.email())            // "EMAIL"
+* inferMetavar(v.number())           // "NUMBER"
+* inferMetavar(v.integer())          // "INTEGER"
+* inferMetavar(v.picklist(["a"]))    // "CHOICE"
+* ```
+*
+* @since 0.7.0
+*/
+function inferMetavar(schema) {
+	const schemaType = schema.type;
+	if (!schemaType) return "VALUE";
+	if (schemaType === "string") {
+		const pipeline = schema.pipe;
+		if (Array.isArray(pipeline)) for (const action of pipeline) {
+			const actionType = action.type;
+			if (actionType === "transform") return "VALUE";
+			if (actionType === "email") return "EMAIL";
+			if (actionType === "url") return "URL";
+			if (actionType === "uuid") return "UUID";
+			if (actionType === "ulid") return "ULID";
+			if (actionType === "cuid2") return "CUID2";
+			if (actionType === "iso_date") return "DATE";
+			if (actionType === "iso_date_time") return "DATETIME";
+			if (actionType === "iso_time") return "TIME";
+			if (actionType === "iso_timestamp") return "TIMESTAMP";
+			if (actionType === "ipv4") return "IPV4";
+			if (actionType === "ipv6") return "IPV6";
+			if (actionType === "ip") return "IP";
+			if (actionType === "emoji") return "EMOJI";
+			if (actionType === "base64") return "BASE64";
+		}
+		return "STRING";
+	}
+	if (schemaType === "number") {
+		const pipeline = schema.pipe;
+		if (Array.isArray(pipeline)) for (const action of pipeline) {
+			const actionType = action.type;
+			if (actionType === "transform") return "VALUE";
+			if (actionType === "integer") return "INTEGER";
+		}
+		return "NUMBER";
+	}
+	if (schemaType === "boolean") return "BOOLEAN";
+	if (schemaType === "date") return "DATE";
+	if (schemaType === "picklist") return "CHOICE";
+	if (schemaType === "literal") return "VALUE";
+	if (schemaType === "union" || schemaType === "variant") return "VALUE";
+	if (schemaType === "optional" || schemaType === "nullable" || schemaType === "nullish") {
+		const wrapped = schema.wrapped;
+		if (wrapped) return inferMetavar(wrapped);
+	}
+	return "VALUE";
+}
+/**
+* Creates a value parser from a Valibot schema.
+*
+* This parser validates CLI argument strings using Valibot schemas, enabling
+* powerful validation and transformation capabilities with minimal bundle size
+* for command-line interfaces.
+*
+* The metavar is automatically inferred from the schema type unless explicitly
+* provided in options. For example:
+* - `v.string()` → `"STRING"`
+* - `v.pipe(v.string(), v.email())` → `"EMAIL"`
+* - `v.number()` → `"NUMBER"`
+* - `v.pipe(v.number(), v.integer())` → `"INTEGER"`
+* - `v.picklist([...])` → `"CHOICE"`
+*
+* @template T The output type of the Valibot schema.
+* @param schema A Valibot schema to validate input against.
+* @param options Optional configuration for the parser.
+* @returns A value parser that validates inputs using the provided schema.
+*
+* @example Basic string validation
+* ```typescript
+* import * as v from "valibot";
+* import { valibot } from "@optique/valibot";
+* import { option } from "@optique/core/primitives";
+*
+* const email = option("--email", valibot(v.pipe(v.string(), v.email())));
+* ```
+*
+* @example Number validation with pipeline
+* ```typescript
+* import * as v from "valibot";
+* import { valibot } from "@optique/valibot";
+* import { option } from "@optique/core/primitives";
+*
+* // Use v.pipe with v.transform for non-string types since CLI args are always strings
+* const port = option("-p", "--port",
+*   valibot(v.pipe(
+*     v.string(),
+*     v.transform(Number),
+*     v.number(),
+*     v.integer(),
+*     v.minValue(1024),
+*     v.maxValue(65535)
+*   ))
+* );
+* ```
+*
+* @example Picklist validation
+* ```typescript
+* import * as v from "valibot";
+* import { valibot } from "@optique/valibot";
+* import { option } from "@optique/core/primitives";
+*
+* const logLevel = option("--log-level",
+*   valibot(v.picklist(["debug", "info", "warn", "error"]))
+* );
+* ```
+*
+* @example Custom error messages
+* ```typescript
+* import * as v from "valibot";
+* import { valibot } from "@optique/valibot";
+* import { message } from "@optique/core/message";
+* import { option } from "@optique/core/primitives";
+*
+* const email = option("--email",
+*   valibot(v.pipe(v.string(), v.email()), {
+*     metavar: "EMAIL",
+*     errors: {
+*       valibotError: (issues, input) =>
+*         message`Please provide a valid email address, got ${input}.`
+*     }
+*   })
+* );
+* ```
+*
+* @since 0.7.0
+*/
+function valibot(schema, options = {}) {
+	return {
+		metavar: options.metavar ?? inferMetavar(schema),
+		parse(input) {
+			const result = safeParse(schema, input);
+			if (result.success) return {
+				success: true,
+				value: result.output
+			};
+			if (options.errors?.valibotError) return {
+				success: false,
+				error: typeof options.errors.valibotError === "function" ? options.errors.valibotError(result.issues, input) : options.errors.valibotError
+			};
+			const firstIssue = result.issues[0];
+			return {
+				success: false,
+				error: message`${firstIssue?.message ?? "Validation failed"}`
+			};
+		},
+		format(value) {
+			return String(value);
+		}
+	};
+}
+
+//#endregion
+export { valibot };

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@optique/valibot",
+  "version": "0.7.0-dev.144+da70df70",
+  "description": "Valibot value parsers for Optique",
+  "keywords": [
+    "CLI",
+    "command-line",
+    "commandline",
+    "parser",
+    "valibot",
+    "validation"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Hong Minhee",
+    "email": "hong@minhee.org",
+    "url": "https://hongminhee.org/"
+  },
+  "homepage": "https://optique.dev/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dahlia/optique.git",
+    "directory": "packages/valibot/"
+  },
+  "bugs": {
+    "url": "https://github.com/dahlia/optique/issues"
+  },
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "engines": {
+    "node": ">=20.0.0",
+    "bun": ">=1.2.0",
+    "deno": ">=2.3.0"
+  },
+  "files": [
+    "dist/",
+    "package.json",
+    "README.md"
+  ],
+  "type": "module",
+  "module": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "valibot": "^0.42.0"
+  },
+  "dependencies": {
+    "@optique/core": ""
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.9",
+    "tsdown": "^0.13.0",
+    "typescript": "^5.8.3",
+    "valibot": "^0.42.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test"
+  }
+}