@optique/standard-schema 1.2.0-dev.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2025–2026 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,100 @@
+@optique/standard-schema
+========================
+
+Standard Schema value parsers for Optique. This package lets you use any
+[Standard Schema]-compatible validator as an *@optique/core* value parser.
+
+[Standard Schema]: https://standardschema.dev/
+
+
+Installation
+------------
+
+~~~~ bash
+deno add jsr:@optique/standard-schema jsr:@optique/run jsr:@optique/core npm:@standard-schema/spec npm:arktype
+npm  add     @optique/standard-schema     @optique/run     @optique/core     @standard-schema/spec arktype
+pnpm add     @optique/standard-schema     @optique/run     @optique/core     @standard-schema/spec arktype
+yarn add     @optique/standard-schema     @optique/run     @optique/core     @standard-schema/spec arktype
+bun  add     @optique/standard-schema     @optique/run     @optique/core     @standard-schema/spec arktype
+~~~~
+
+Replace `arktype` with any Standard Schema-compatible library you want to use.
+
+
+Quick example
+-------------
+
+The following example validates an email address with an ArkType schema through
+the generic `standardSchema()` adapter.
+
+~~~~ typescript
+import { object } from "@optique/core/constructs";
+import { option } from "@optique/core/primitives";
+import { run } from "@optique/run";
+import { standardSchema } from "@optique/standard-schema";
+import { type } from "arktype";
+
+const cli = run(
+  object({
+    email: option("--email",
+      standardSchema(type("string.email"), {
+        placeholder: "",
+        metavar: "EMAIL",
+      }),
+    ),
+  }),
+);
+
+console.log(`Welcome, ${cli.email}!`);
+~~~~
+
+
+Async schemas
+-------------
+
+Use `standardSchemaAsync()` when the validator may perform async work:
+
+~~~~ typescript
+import { option } from "@optique/core/primitives";
+import { runAsync } from "@optique/run";
+import { standardSchemaAsync } from "@optique/standard-schema";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+const apiKeySchema: StandardSchemaV1<unknown, string> = {
+  "~standard": {
+    version: 1,
+    vendor: "example",
+    async validate(value) {
+      if (typeof value === "string" && value.startsWith("live_")) {
+        return { value };
+      }
+      return { issues: [{ message: "Unknown API key." }] };
+    },
+  },
+};
+
+const apiKey = option("--api-key",
+  standardSchemaAsync(apiKeySchema, {
+    placeholder: "",
+    metavar: "API_KEY",
+  }),
+);
+
+const key = await runAsync(apiKey);
+~~~~
+
+The synchronous `standardSchema()` helper rejects async validation results and
+asks you to use `standardSchemaAsync()` instead.
+
+
+Dedicated adapters
+------------------
+
+Standard Schema intentionally exposes validation results, not library-specific
+metadata. This package therefore stays conservative: it does not infer choices,
+completion suggestions, Boolean CLI literals, or specialized metavars from the
+underlying schema.
+
+Use *@optique/zod* or *@optique/valibot* when you want richer behavior for
+those libraries. Use *@optique/standard-schema* when portability matters, or
+when your schema library does not have a dedicated Optique adapter.

package/dist/index.cjs

@@ -0,0 +1,146 @@
+//#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 __optique_core_nonempty = __toESM(require("@optique/core/nonempty"));
+
+//#region src/index.ts
+function validateOptions(functionName, options) {
+	if (options == null || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${functionName}() requires an options object with a placeholder property.`);
+	if (!("placeholder" in options)) throw new TypeError(`${functionName}() options must include a placeholder property.`);
+}
+function isPromiseLike(value) {
+	return value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+function formatValue(value, format) {
+	if (format) return format(value);
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? String(value) : value.toISOString();
+	if (typeof value !== "object" || value === null) return String(value);
+	if (Array.isArray(value)) return String(value);
+	const str = String(value);
+	if (str !== "[object Object]") return str;
+	const proto = Object.getPrototypeOf(value);
+	if (proto === Object.prototype || proto === null) try {
+		return JSON.stringify(value) ?? str;
+	} catch {}
+	return str;
+}
+function validationFailure(issues, input, error) {
+	if (error) return {
+		success: false,
+		error: typeof error === "function" ? error(issues, input) : error
+	};
+	return {
+		success: false,
+		error: __optique_core_message.message`${(0, __optique_core_message.text)(issues[0]?.message ?? "Validation failed")}`
+	};
+}
+function processValidationResult(result, input, options) {
+	if (result.issues) return validationFailure(result.issues, input, options.errors?.schemaError);
+	return {
+		success: true,
+		value: result.value
+	};
+}
+/**
+* Creates a value parser from a Standard Schema-compatible validator.
+*
+* The returned parser validates CLI argument strings with
+* `schema["~standard"].validate(input)`. Standard Schema does not expose
+* library-specific metadata such as enum choices, Boolean parser shape, or
+* preferred metavars, so this generic adapter stays conservative. Use
+* dedicated adapters such as *@optique/zod* or *@optique/valibot* when their
+* richer CLI behavior is useful.
+*
+* @template T The output type of the Standard Schema validator.
+* @param schema A Standard Schema-compatible validator.
+* @param options Configuration for the parser, including a required
+*   `placeholder` value used during deferred prompt resolution.
+* @returns A value parser that validates inputs using the provided schema.
+*
+* @throws {TypeError} If `options` is missing, not an object, or does not
+*   include `placeholder`.
+* @throws {TypeError} If the resolved `metavar` is an empty string.
+* @throws {TypeError} If the validator returns a promise during parsing.
+* @since 1.2.0
+*/
+function standardSchema(schema, options) {
+	validateOptions("standardSchema", options);
+	const metavar = options.metavar ?? "VALUE";
+	(0, __optique_core_nonempty.ensureNonEmptyString)(metavar);
+	const parser = {
+		mode: "sync",
+		metavar,
+		placeholder: options.placeholder,
+		parse(input) {
+			const result = schema["~standard"].validate(input);
+			if (isPromiseLike(result)) throw new TypeError("Async Standard Schema validators are not supported by standardSchema(). Use standardSchemaAsync() instead.");
+			return processValidationResult(result, input, options);
+		},
+		format(value) {
+			return formatValue(value, options.format);
+		}
+	};
+	return parser;
+}
+/**
+* Creates an async value parser from a Standard Schema-compatible validator.
+*
+* Use this helper when the validator may return a promise from
+* `schema["~standard"].validate(input)`, such as schemas with asynchronous
+* refinements or checks. Synchronous validators are also accepted.
+*
+* @template T The output type of the Standard Schema validator.
+* @param schema A Standard Schema-compatible validator.
+* @param options Configuration for the parser, including a required
+*   `placeholder` value used during deferred prompt resolution.
+* @returns An async value parser that validates inputs using the provided
+*   schema.
+*
+* @throws {TypeError} If `options` is missing, not an object, or does not
+*   include `placeholder`.
+* @throws {TypeError} If the resolved `metavar` is an empty string.
+* @since 1.2.0
+*/
+function standardSchemaAsync(schema, options) {
+	validateOptions("standardSchemaAsync", options);
+	const metavar = options.metavar ?? "VALUE";
+	(0, __optique_core_nonempty.ensureNonEmptyString)(metavar);
+	const parser = {
+		mode: "async",
+		metavar,
+		placeholder: options.placeholder,
+		async parse(input) {
+			const result = await schema["~standard"].validate(input);
+			return processValidationResult(result, input, options);
+		},
+		format(value) {
+			return formatValue(value, options.format);
+		}
+	};
+	return parser;
+}
+
+//#endregion
+exports.standardSchema = standardSchema;
+exports.standardSchemaAsync = standardSchemaAsync;

package/dist/index.d.cts

@@ -0,0 +1,94 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { NonEmptyString, ValueParser } from "@optique/core/valueparser";
+import { Message } from "@optique/core/message";
+
+//#region src/index.d.ts
+
+/**
+ * Options for creating a Standard Schema value parser.
+ *
+ * @template T The output type of the Standard Schema validator.
+ * @since 1.2.0
+ */
+interface StandardSchemaParserOptions<T = unknown> {
+  /**
+   * 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?: NonEmptyString;
+  /**
+   * A phase-one stand-in value of type `T` used during deferred prompt
+   * resolution. Because the output type of a Standard Schema validator cannot
+   * be inferred to a concrete default, callers must provide this explicitly.
+   */
+  readonly placeholder: T;
+  /**
+   * Custom formatter for displaying parsed values in help messages.
+   * When not provided, the default formatter is used: primitives use
+   * `String()`, valid `Date` values use `.toISOString()`, and plain
+   * objects use `JSON.stringify()` when possible. All other objects use
+   * `String()`.
+   *
+   * @param value The parsed value to format.
+   * @returns A string representation of the value.
+   */
+  readonly format?: (value: T) => string;
+  /**
+   * Custom error messages for Standard Schema validation failures.
+   */
+  readonly errors?: {
+    /**
+     * Custom error message when input fails Standard Schema validation. Can be
+     * a static message or a function that receives the Standard Schema issues
+     * and input string.
+     */
+    readonly schemaError?: Message | ((issues: readonly StandardSchemaV1.Issue[], input: string) => Message);
+  };
+}
+/**
+ * Creates a value parser from a Standard Schema-compatible validator.
+ *
+ * The returned parser validates CLI argument strings with
+ * `schema["~standard"].validate(input)`. Standard Schema does not expose
+ * library-specific metadata such as enum choices, Boolean parser shape, or
+ * preferred metavars, so this generic adapter stays conservative. Use
+ * dedicated adapters such as *@optique/zod* or *@optique/valibot* when their
+ * richer CLI behavior is useful.
+ *
+ * @template T The output type of the Standard Schema validator.
+ * @param schema A Standard Schema-compatible validator.
+ * @param options Configuration for the parser, including a required
+ *   `placeholder` value used during deferred prompt resolution.
+ * @returns A value parser that validates inputs using the provided schema.
+ *
+ * @throws {TypeError} If `options` is missing, not an object, or does not
+ *   include `placeholder`.
+ * @throws {TypeError} If the resolved `metavar` is an empty string.
+ * @throws {TypeError} If the validator returns a promise during parsing.
+ * @since 1.2.0
+ */
+declare function standardSchema<T>(schema: StandardSchemaV1<unknown, T>, options: StandardSchemaParserOptions<T>): ValueParser<"sync", T>;
+/**
+ * Creates an async value parser from a Standard Schema-compatible validator.
+ *
+ * Use this helper when the validator may return a promise from
+ * `schema["~standard"].validate(input)`, such as schemas with asynchronous
+ * refinements or checks. Synchronous validators are also accepted.
+ *
+ * @template T The output type of the Standard Schema validator.
+ * @param schema A Standard Schema-compatible validator.
+ * @param options Configuration for the parser, including a required
+ *   `placeholder` value used during deferred prompt resolution.
+ * @returns An async value parser that validates inputs using the provided
+ *   schema.
+ *
+ * @throws {TypeError} If `options` is missing, not an object, or does not
+ *   include `placeholder`.
+ * @throws {TypeError} If the resolved `metavar` is an empty string.
+ * @since 1.2.0
+ */
+declare function standardSchemaAsync<T>(schema: StandardSchemaV1<unknown, T>, options: StandardSchemaParserOptions<T>): ValueParser<"async", T>;
+//#endregion
+export { StandardSchemaParserOptions, standardSchema, standardSchemaAsync };

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { Message } from "@optique/core/message";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { NonEmptyString, ValueParser } from "@optique/core/valueparser";
+
+//#region src/index.d.ts
+
+/**
+ * Options for creating a Standard Schema value parser.
+ *
+ * @template T The output type of the Standard Schema validator.
+ * @since 1.2.0
+ */
+interface StandardSchemaParserOptions<T = unknown> {
+  /**
+   * 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?: NonEmptyString;
+  /**
+   * A phase-one stand-in value of type `T` used during deferred prompt
+   * resolution. Because the output type of a Standard Schema validator cannot
+   * be inferred to a concrete default, callers must provide this explicitly.
+   */
+  readonly placeholder: T;
+  /**
+   * Custom formatter for displaying parsed values in help messages.
+   * When not provided, the default formatter is used: primitives use
+   * `String()`, valid `Date` values use `.toISOString()`, and plain
+   * objects use `JSON.stringify()` when possible. All other objects use
+   * `String()`.
+   *
+   * @param value The parsed value to format.
+   * @returns A string representation of the value.
+   */
+  readonly format?: (value: T) => string;
+  /**
+   * Custom error messages for Standard Schema validation failures.
+   */
+  readonly errors?: {
+    /**
+     * Custom error message when input fails Standard Schema validation. Can be
+     * a static message or a function that receives the Standard Schema issues
+     * and input string.
+     */
+    readonly schemaError?: Message | ((issues: readonly StandardSchemaV1.Issue[], input: string) => Message);
+  };
+}
+/**
+ * Creates a value parser from a Standard Schema-compatible validator.
+ *
+ * The returned parser validates CLI argument strings with
+ * `schema["~standard"].validate(input)`. Standard Schema does not expose
+ * library-specific metadata such as enum choices, Boolean parser shape, or
+ * preferred metavars, so this generic adapter stays conservative. Use
+ * dedicated adapters such as *@optique/zod* or *@optique/valibot* when their
+ * richer CLI behavior is useful.
+ *
+ * @template T The output type of the Standard Schema validator.
+ * @param schema A Standard Schema-compatible validator.
+ * @param options Configuration for the parser, including a required
+ *   `placeholder` value used during deferred prompt resolution.
+ * @returns A value parser that validates inputs using the provided schema.
+ *
+ * @throws {TypeError} If `options` is missing, not an object, or does not
+ *   include `placeholder`.
+ * @throws {TypeError} If the resolved `metavar` is an empty string.
+ * @throws {TypeError} If the validator returns a promise during parsing.
+ * @since 1.2.0
+ */
+declare function standardSchema<T>(schema: StandardSchemaV1<unknown, T>, options: StandardSchemaParserOptions<T>): ValueParser<"sync", T>;
+/**
+ * Creates an async value parser from a Standard Schema-compatible validator.
+ *
+ * Use this helper when the validator may return a promise from
+ * `schema["~standard"].validate(input)`, such as schemas with asynchronous
+ * refinements or checks. Synchronous validators are also accepted.
+ *
+ * @template T The output type of the Standard Schema validator.
+ * @param schema A Standard Schema-compatible validator.
+ * @param options Configuration for the parser, including a required
+ *   `placeholder` value used during deferred prompt resolution.
+ * @returns An async value parser that validates inputs using the provided
+ *   schema.
+ *
+ * @throws {TypeError} If `options` is missing, not an object, or does not
+ *   include `placeholder`.
+ * @throws {TypeError} If the resolved `metavar` is an empty string.
+ * @since 1.2.0
+ */
+declare function standardSchemaAsync<T>(schema: StandardSchemaV1<unknown, T>, options: StandardSchemaParserOptions<T>): ValueParser<"async", T>;
+//#endregion
+export { StandardSchemaParserOptions, standardSchema, standardSchemaAsync };

package/dist/index.js

@@ -0,0 +1,122 @@
+import { message, text } from "@optique/core/message";
+import { ensureNonEmptyString } from "@optique/core/nonempty";
+
+//#region src/index.ts
+function validateOptions(functionName, options) {
+	if (options == null || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${functionName}() requires an options object with a placeholder property.`);
+	if (!("placeholder" in options)) throw new TypeError(`${functionName}() options must include a placeholder property.`);
+}
+function isPromiseLike(value) {
+	return value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+function formatValue(value, format) {
+	if (format) return format(value);
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? String(value) : value.toISOString();
+	if (typeof value !== "object" || value === null) return String(value);
+	if (Array.isArray(value)) return String(value);
+	const str = String(value);
+	if (str !== "[object Object]") return str;
+	const proto = Object.getPrototypeOf(value);
+	if (proto === Object.prototype || proto === null) try {
+		return JSON.stringify(value) ?? str;
+	} catch {}
+	return str;
+}
+function validationFailure(issues, input, error) {
+	if (error) return {
+		success: false,
+		error: typeof error === "function" ? error(issues, input) : error
+	};
+	return {
+		success: false,
+		error: message`${text(issues[0]?.message ?? "Validation failed")}`
+	};
+}
+function processValidationResult(result, input, options) {
+	if (result.issues) return validationFailure(result.issues, input, options.errors?.schemaError);
+	return {
+		success: true,
+		value: result.value
+	};
+}
+/**
+* Creates a value parser from a Standard Schema-compatible validator.
+*
+* The returned parser validates CLI argument strings with
+* `schema["~standard"].validate(input)`. Standard Schema does not expose
+* library-specific metadata such as enum choices, Boolean parser shape, or
+* preferred metavars, so this generic adapter stays conservative. Use
+* dedicated adapters such as *@optique/zod* or *@optique/valibot* when their
+* richer CLI behavior is useful.
+*
+* @template T The output type of the Standard Schema validator.
+* @param schema A Standard Schema-compatible validator.
+* @param options Configuration for the parser, including a required
+*   `placeholder` value used during deferred prompt resolution.
+* @returns A value parser that validates inputs using the provided schema.
+*
+* @throws {TypeError} If `options` is missing, not an object, or does not
+*   include `placeholder`.
+* @throws {TypeError} If the resolved `metavar` is an empty string.
+* @throws {TypeError} If the validator returns a promise during parsing.
+* @since 1.2.0
+*/
+function standardSchema(schema, options) {
+	validateOptions("standardSchema", options);
+	const metavar = options.metavar ?? "VALUE";
+	ensureNonEmptyString(metavar);
+	const parser = {
+		mode: "sync",
+		metavar,
+		placeholder: options.placeholder,
+		parse(input) {
+			const result = schema["~standard"].validate(input);
+			if (isPromiseLike(result)) throw new TypeError("Async Standard Schema validators are not supported by standardSchema(). Use standardSchemaAsync() instead.");
+			return processValidationResult(result, input, options);
+		},
+		format(value) {
+			return formatValue(value, options.format);
+		}
+	};
+	return parser;
+}
+/**
+* Creates an async value parser from a Standard Schema-compatible validator.
+*
+* Use this helper when the validator may return a promise from
+* `schema["~standard"].validate(input)`, such as schemas with asynchronous
+* refinements or checks. Synchronous validators are also accepted.
+*
+* @template T The output type of the Standard Schema validator.
+* @param schema A Standard Schema-compatible validator.
+* @param options Configuration for the parser, including a required
+*   `placeholder` value used during deferred prompt resolution.
+* @returns An async value parser that validates inputs using the provided
+*   schema.
+*
+* @throws {TypeError} If `options` is missing, not an object, or does not
+*   include `placeholder`.
+* @throws {TypeError} If the resolved `metavar` is an empty string.
+* @since 1.2.0
+*/
+function standardSchemaAsync(schema, options) {
+	validateOptions("standardSchemaAsync", options);
+	const metavar = options.metavar ?? "VALUE";
+	ensureNonEmptyString(metavar);
+	const parser = {
+		mode: "async",
+		metavar,
+		placeholder: options.placeholder,
+		async parse(input) {
+			const result = await schema["~standard"].validate(input);
+			return processValidationResult(result, input, options);
+		},
+		format(value) {
+			return formatValue(value, options.format);
+		}
+	};
+	return parser;
+}
+
+//#endregion
+export { standardSchema, standardSchemaAsync };

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@optique/standard-schema",
+  "version": "1.2.0-dev.0",
+  "description": "Standard Schema value parsers for Optique",
+  "keywords": [
+    "CLI",
+    "command-line",
+    "commandline",
+    "parser",
+    "standard-schema",
+    "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/standard-schema/"
+  },
+  "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": {
+    "@standard-schema/spec": "^1.1.0"
+  },
+  "dependencies": {
+    "@optique/core": "1.2.0"
+  },
+  "devDependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "@types/node": "^24.0.0",
+    "tsdown": "^0.13.0",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "node --test",
+    "test:bun": "bun test",
+    "test:deno": "deno test",
+    "test-all": "tsdown && node --test && bun test && deno test"
+  }
+}