5. zod/mini・zod/v4/core・zod/compile リファレンス

Zod v4 は階層化されたライブラリエコシステムとして設計されています。zod/v4/core はメソッドを持たない最小のトレイト実行エンジン（$constructor、$ZodType、$ZodCheck、ParsePayload、JSONSchemaGenerator）を提供し、zod/mini は厳格なバンドルサイズ制約向けにツリーシェイク可能な関数型ラッパー（ZodMiniType とスタンドアロンチェック・コンビネータ関数群）を提供し、zod/compile は AOT（事前）および初回パース時の JIT コード生成コンパイラ（compile、compileFn、withParser）を提供します。

05_mini_and_core_engine_1
zod/v4/core・zod/mini・zod/compile の3層アーキテクチャ
Source Code 
from drawlib import canvas
from drawlib.diagrams.architecture import ArchitectureDiagram, Node, NodeGroup, PhosphorIcon
from drawlib.styles import Styles

canvas.clear()
canvas.setup(width=188, height=96, dpi=150)

d = ArchitectureDiagram(
    node_style=Styles.Primary,
    node_text_style=Styles.DarkBold.patch(text_size=10.0),
    edge_style=Styles.DarkBold,
    edge_text_style=Styles.Dark.patch(text_size=10.0),
    node_card_style=Styles.Neutral,
    title="階層型アーキテクチャ: zod/mini・zod/v4/core・zod/compile",
)

# Left Group: zod/mini (Tree-Shakable Functional API) (node width=46 -> center x = 5 + 23 = 28)
mini_grp = d.add(
    NodeGroup(title="1. zod/mini (ツリーシェイク対応)", padding=5.0),
    xy=(0.0, 0.0),
)
mini_type = mini_grp.add(
    Node("ZodMiniType<O, I>\n.parse / .safeParse\n.check / .register / .brand", width=46, height=20, icon=PhosphorIcon.FEATHER, icon_size=6.5, card_style=Styles.PrimaryNeutral),
    xy=(28.0, 52.0),
)
mini_fns = mini_grp.add(
    Node("スタンドアロン関数群\nz.minLength / z.gt / z.regex\nz.optional / z._default / z.pipe", width=46, height=20, icon=PhosphorIcon.FUNCTION, icon_size=6.5, card_style=Styles.Neutral),
    xy=(28.0, 15.0),
)

# Center Group: zod/v4/core (Shared Trait Engine) (node width=42 -> center x = 5 + 21 = 26)
core_grp = d.add(
    NodeGroup(title="2. zod/v4/core (共有エンジン)", padding=5.0),
    xy=(66.0, 0.0),
)
core_ctor = core_grp.add(
    Node("core.$constructor(name, init)\n$ZodType & _zod.run()\nParsePayload / traits Set", width=42, height=20, icon=PhosphorIcon.CPU, icon_size=6.5, style=Styles.WhiteBold, card_style=Styles.PrimaryFlat, text_style=Styles.WhiteBold.patch(text_size=10.0)),
    xy=(26.0, 52.0),
)
core_chk = core_grp.add(
    Node("$ZodCheck & JSONSchema\n_zod.check(payload)\nJSONSchemaGenerator", width=42, height=20, icon=PhosphorIcon.SHIELD_CHECK, icon_size=6.5, card_style=Styles.Neutral),
    xy=(26.0, 15.0),
)

# Right Group: zod/compile (AOT & Fast-Path Compiler) (node width=46 -> center x = 5 + 23 = 28)
comp_grp = d.add(
    NodeGroup(title="3. zod/compile (AOT 高速パス)", padding=5.0),
    xy=(128.0, 0.0),
)
comp_api = comp_grp.add(
    Node("コンパイラ API\nz.compile(schema, opts)\ncompileFn / withParser", width=46, height=20, icon=PhosphorIcon.LIGHTNING, icon_size=6.5, style=Styles.WhiteBold, card_style=Styles.AccentFlat, text_style=Styles.WhiteBold.patch(text_size=10.0)),
    xy=(28.0, 52.0),
)
comp_shim = comp_grp.add(
    Node("グローバル Post-Processor\nimport 'zod/compile'\nINVALID 時は _zod.run に委譲", width=46, height=20, icon=PhosphorIcon.GEAR_SIX, icon_size=6.5, card_style=Styles.PrimaryNeutral),
    xy=(28.0, 15.0),
)

# Connections
d.connect(mini_type, core_ctor, padding=1.5)
d.connect(mini_fns, core_chk, padding=1.5)
d.connect(core_chk, core_ctor, label="def.checks", padding=1.5)
core_ctor.fork([comp_api, comp_shim], at_x=122.0, padding=1.5)

d.draw(xy=(94.0, 46.0), align="center")
canvas.save()

classZodMiniType (zod/mini)#

zod/mini（または zod/v4-mini）からインポートされる ZodMiniType<Output, Input, Internals> は、ZodType が持つ多数のラッパー・チェックメソッド（.optional()、.nullable()、.default()、.min()、.max()、.email() など）をプロトタイプから排除し、バンドラ（Rollup、esbuild、Webpack、Vite）が未使用のスキーマやチェックをクライアントバンドルから完全にツリーシェイクできるように設計されています。

ZodMiniType インスタンスメンバ一覧#

メンバ 種別 シグネチャ / 型 説明
schema.type プロパティ Internals["def"]["type"] スキーマ種別のリテラル判別文字列（"string"、"number"、"object"、"pipe" など）。
schema.def プロパティ Internals["def"] 基底の $ZodTypeDef 定義オブジェクト。
schema._zod プロパティ Internals ($ZodTypeInternals<O, I>) コア内部ランタイムスロット（_zod.run、_zod.parse、_zod.traits、_zod.bag）。
schema["~standard"] Getter $ZodStandardSchema<this> Standard Schema v1（StandardSchemaV1.Props<I, O>）相互運用ディスクリプタ。
schema.parse(data, params?) メソッド (data: unknown, params?: ParseContext) => O data を同期的に検証し、失敗時は ZodError をスローします。
schema.safeParse(data, params?) メソッド (data: unknown, params?: ParseContext) => SafeParseResult<O> data を同期的に検証し、{ success, data | error } を返します。
schema.parseAsync(data, params?) メソッド (data: unknown, params?: ParseContext) => Promise<O> 非同期パースを実行します。
schema.safeParseAsync(data, params?) メソッド (data: unknown, params?: ParseContext) => Promise<SafeParseResult<O>> 非同期セーフパースを実行します。
schema.check(...checks) / schema.with(...checks) メソッド (...checks: (CheckFn<O> | $ZodCheck<O>)[]) => this スキーマを複製し、1つ以上のスタンドアロン $ZodCheck ディスクリプタを追加します。
schema.register(registry, meta?) メソッド <R extends $ZodRegistry>(registry: R, meta?: ...) => this registry にメタデータを登録し、this を返します。
schema.brand<B, Dir>() メソッド <T extends PropertyKey, Dir extends "in" | "out" | "inout" = "out">(val?: T) => $ZodBranded<this, T, Dir> 出力型・入力型・またはその両方に公称型ブランド（$brand<T>）を付与します。
schema.clone(def?, params?) メソッド (def?: Internals["def"], params?: { parent: boolean }) => this 定義を更新してスキーマインスタンスを複製します。
schema.apply(fn, ...args) メソッド <T, A extends unknown[]>(fn: (s: this, ...args: A) => T, ...args: A) => T 関数合成のために fn(this, ...args) に this を渡します。 
import * as z from "zod/mini";

const UserMiniSchema = z.object({
  id: z.uuid(),
  username: z.string().check(z.trim(), z.minLength(3), z.maxLength(24)),
  age: z.optional(z.int().check(z.gte(18))),
});

const parsed = UserMiniSchema.parse({
  id: "550e8400-e29b-41d4-a716-446655440000",
  username: "  alice  ",
});

functionzod/mini Standalone Checks (z.minLength, z.maxLength, z.gt, z.lt, ...)#

ZodMiniString、ZodMiniNumber、ZodMiniArray、ZodMiniSet はプロトタイプ上にチェックメソッド（.min() や .regex() など）を持たないため、zod/mini におけるすべての制約検証とインプレース変換はスタンドアロン関数を schema.check(...) に渡して合成します。

zod/mini チェック・リファインメント関数一覧#

カテゴリ zod/mini がエクスポートする関数 対象スキーマ
数値・日付の境界 z.lt(v)、z.lte(v) (z.maximum)、z.gt(v)、z.gte(v) (z.minimum)、z.positive()、z.negative()、z.nonpositive()、z.nonnegative()、z.multipleOf(v) z.number()、z.int()、z.bigint()、z.date()
長さ制約 (.length) z.minLength(n)、z.maxLength(n)、z.length(n) z.string()、z.array()、z.file()
要素数・ファイルサイズ (.size) z.minSize(n)、z.maxSize(n)、z.size(n) z.map()、z.set()、z.file()
文字列パターン・大文字小文字検証 z.regex(re)、z.lowercase()、z.uppercase()、z.includes(s)、z.startsWith(s)、z.endsWith(s) z.string() および各種文字列フォーマットスキーマ
文字列インプレース正規化 z.trim()、z.toLowerCase()、z.toUpperCase()、z.normalize(form?)、z.slugify() z.string()
プロパティ・MIME・カスタム検証 z.property(k, schema)、z.properties(shape)、z.mime(types)、z.overwrite(fn)、z.check(fn)、z.refine(fn, params?)、z.superRefine(fn, params?) 任意の互換 ZodMiniType

functionzod/mini Wrapper Functions (z.optional, z.nullable, z._default, z.prefault)#

zod/mini では、スキーマラッパーおよびコンビネータはメソッドチェーンではなく内部スキーマを受け取るトップレベル関数として呼び出します。

zod/mini ラッパー・コンビネータ関数一覧#

zod/mini 関数 Classic zod の対応メソッド 戻り値型 説明
z.optional(schema) schema.optional() ZodMiniOptional<T> undefined を許容し、そのまま通過させます（output<T> | undefined）。
z.exactOptional(schema) schema.exactOptional() ZodMiniExactOptional<T> オブジェクトプロパティの省略を許可しますが、明示的な undefined 値の代入は拒否します。
z.nullable(schema) schema.nullable() ZodMiniNullable<T> null を許容し、そのまま通過させます（output<T> | null）。
z.nullish(schema) schema.nullish() ZodMiniOptional<ZodMiniNullable<T>> null と undefined の両方を許容します（z.optional(z.nullable(schema))）。
z.nonoptional(schema, params?) schema.nonoptional(params?) ZodMiniNonOptional<T> undefined 入力を拒否し、推論される出力型から undefined を除外します。
z._default(schema, valueOrFn) schema.default(valueOrFn) ZodMiniDefault<T> 入力が undefined の場合に schema を実行せず短絡評価してデフォルトの output<T> 値を返します。
z.prefault(schema, valueOrFn) schema.prefault(valueOrFn) ZodMiniPrefault<T> 入力が undefined の場合にデフォルトの input<T> 値を補填し、schema に通してパースします。
z.catch(schema, valueOrFn) schema.catch(valueOrFn) ZodMiniCatch<T> schema のバリデーション失敗時にフォールバック値を返します。
z.readonly(schema) schema.readonly() ZodMiniReadonly<T> パース後の出力に対して Object.freeze() を呼び出し、静的型を Readonly<O> にします。
z.pipe(inSchema, outSchema) inSchema.pipe(outSchema) ZodMiniPipe<A, B> inSchema の出力を outSchema の入力に接続します。
z.codec(inSchema, outSchema, { decode, encode }) z.codec(...) ZodMiniCodec<A, B> zod/mini で双方向コーデックを構築します。 
import * as z from "zod/mini";

// zod/mini における関数型ラッパーの合成
const EnvPortSchema = z._default(
  z.pipe(z.string().check(z.trim()), z.coerce.number().check(z.gte(1024), z.lte(65535))),
  8080,
);

EnvPortSchema.parse(undefined); // => 8080
EnvPortSchema.parse(" 3000 ");  // => 3000

function$constructor (zod/v4/core)#

zod/v4/core の中核をなすのが $constructor(name, initializer, proto?, params?) です。これは zod/v4/core、zod（Classic）、zod/mini 間の多重トレイト合成を可能にしつつ、Symbol.hasInstance と inst._zod.traits によって O(1) の instanceof 判定を実現する軽量クラスファクトリです。

$constructor シグネチャとライフサイクル#

export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
  new (def: D): T;
  init(inst: T, def: D): asserts inst is T;
}

export function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(
  name: string,
  initializer: (inst: T, def: D) => void,
  proto?: ProtoOf<T>,
  params?: { Parent?: typeof Class }
): $constructor<T, D>;
メカニズム ランタイムの動作
new Ctor(def) インスタンス inst を割り当て、Ctor.init(inst, def) を実行した後、inst._zod.deferred の遅延初期化関数をすべて消化し、最後に globalConfig.postProcessor?.(inst)（zod/compile が利用）を呼び出します。
Ctor.init(inst, def) 初回呼び出し時に列挙不可の inst._zod（{ def, constr, traits: Set }）を定義し、inst._zod.traits.has(name) による二重初期化防止ガードを行った上で、traits に name を追加し、initializer(inst, def) の実行とプロトタイプへの proto メンバ登録（WeakSet でプロトタイプあたり1回のみ）を行います。
inst instanceof Ctor カスタム [Symbol.hasInstance] が inst?._zod?.traits?.has(name) を検査するため、ZodString と ZodMiniString の両方が inst instanceof core.$ZodString かつ inst instanceof core.$ZodType を満たします。

interface$ZodType & $ZodTypeInternals (zod/v4/core)#

Zod v4 のすべてのスキーマは $ZodType<O, I, Internals> を実装します。$ZodType 自体は _zod（$ZodTypeInternals<O, I>）と "~standard"（StandardSchemaV1.Props<I, O>）の 2 つのプロパティのみを持つ最小インターフェースです。

$ZodTypeInternals<O, I> & ParsePayload<T> リファレンス#

プロパティ / メソッド 型 説明
_zod.def $ZodTypeDef 宣言的スキーマ定義オブジェクト（{ type, error?, checks? }）。
_zod.version { major: 4, minor: 6, patch: ... } @zod/core のセマンティックバージョン情報。
_zod.traits Set<string> このインスタンスに合成された $constructor トレイト名の集合（例: {"$ZodType", "$ZodString", "ZodType", "ZodString"}）。
_zod.run(payload, ctx) (payload: ParsePayload, ctx: ParseContextInternal) => MaybeAsync<ParsePayload> 完全な実行エントリポイント: 基本型パース（_zod.parse）と登録された全 def.checks を実行します。
_zod.parse(payload, ctx) (payload: ParsePayload, ctx: ParseContextInternal) => MaybeAsync<ParsePayload> def.checks 実行前の基本型検証ルーチン。
_zod.bag Record<string, unknown> チェックの onattach や zod/compile（validator, fallbackRun）によって集約されるメタデータバッグ。
_zod.optin / _zod.optout "optional" | "defaulted" | undefined オブジェクトプロパティ内でこのスキーマが入力側・出力側で省略可能かどうかを示します。
_zod.values / _zod.pattern PrimitiveSet | undefined / RegExp | undefined 許容されるリテラル値の集合（z.record キーや判別共用体で使用）および正規表現パターン（z.templateLiteral で使用）。
payload.value T _zod.parse および def.checks を通過しながら更新される ParsePayload<T> 内の現在値。
payload.issues $ZodRawIssue[] バリデーション中に蓄積される未確定 Issue の可変配列。

class$ZodCheck (zod/v4/core)#

$ZodCheck<T> は、packages/zod/src/v4/core/checks.ts におけるすべての型検査後制約およびインプレース変換の基底 $constructor です。

$ZodCheckInternals<T> の構造#

メンバ 型 説明
_zod.def $ZodCheckDef { check: string, error?: $ZodErrorMap, abort?: boolean, when?: (payload: ParsePayload) => boolean }。
_zod.check(payload) (payload: ParsePayload<T>) => MaybeAsync<void> payload.value に対して制約を評価（失敗時は payload.issues に追加）するか、payload.value をインプレースで書き換えます。
_zod.onattach ((schema: $ZodType) => void)[] チェックがスキーマに追加された際に実行されるコールバック配列。schema._zod.bag に minimum、maximum、format、pattern などを記録します。 
import * as core from "zod/v4/core";

// zod/v4/core で再利用可能なカスタム $ZodCheck を定義する例
export const $ZodCheckEven = core.$constructor<{ _zod: core.$ZodCheckInternals<number> }>(
  "$ZodCheckEven",
  (inst, def) => {
    core.$ZodCheck.init(inst, def);
    inst._zod.onattach.push((schema) => {
      schema._zod.bag.even = true;
    });
    inst._zod.check = (payload) => {
      if (payload.value % 2 !== 0) {
        payload.issues.push({
          code: "custom",
          input: payload.value,
          inst,
          message: "偶数を指定してください",
        });
      }
    };
  },
);

classJSONSchemaGenerator (zod/v4/core)#

zod/v4/core からエクスポートされる JSONSchemaGenerator は、z.toJSONSchema() の内部基盤である 2 フェーズ（process -> emit）のステートフルなクラスインターフェースです。通常のアプリケーションコードでは関数型の z.toJSONSchema(schema, params) が推奨されますが、カスタムのマルチスキーマ変換パイプライン向けに zod/v4/core で公開されています。

JSONSchemaGenerator メソッド一覧#

メソッド シグネチャ 説明
new JSONSchemaGenerator(params?) constructor(params?: Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">) allProcessors とターゲット仕様（デフォルト "draft-2020-12"）を用いて ToJSONSchemaContext を初期化します。
gen.process(schema, params?) (schema: $ZodType, params?: ProcessParams) => JSONSchema.BaseSchema schema を走査して this.ctx.seen に登録し、循環参照および再利用カウントを記録します。emit() の前に呼び出す必要があります。
gen.emit(schema, params?) (schema: $ZodType, params?: EmitParams) => JSONSchema.BaseSchema extractDefs() で共有 $defs を抽出し、finalize() で $ref ポインタを解決して最終的な JSON Schema オブジェクトを返します。

functioncompile / compileFn / withParser (zod/compile)#

Zod v4 は、同期・順方向パース向けに特化した JavaScript 検証関数を生成するスキーマコンパイラ（packages/zod/src/v4/core/compile.ts および副作用エントリポイント zod/compile）を内蔵しています。正常な入力に対しては ParsePayload や ParseContext を割り当てずに直接出力値を構築し、不正な入力に対してはセンチネルシンボル z.INVALID（Symbol.for("zod.compile.invalid")）を返して通常の _zod.run インタプリタにフォールバックするため、エラーマップや Issue のパス・メッセージはインタプリタ実行時と 100% 一致します。

コンパイラ API リファレンス#

エクスポート / エントリポイント シグネチャ 説明
import "zod/compile" 副作用モジュールインポート globalConfig.postProcessor を登録し、インポート後に構築されたすべてのスキーマを初回同期パース時に遅延 AOT コンパイルします。z.config({ jitless: true }) が設定されている場合は自動的にバイパスします。
z.compile(schema, options?) <T extends SomeType>(schema: T, options?: { strict?: boolean }) => T schema を即座にコンパイルし、高速化された _zod.run と _zod.bag.validator を持つクローンを返します。未対応機能を含む場合はデフォルトで元の schema をそのまま返し、{ strict: true } 指定時のみ ZodCompileUnsupportedError / ZodCompileAsyncError をスローします。
compileFn(schema, options?) <T extends SomeType>(schema: T, options?: { debug?: boolean; assertOnly?: boolean }) => CompiledFn<output<T>> (zod/v4/core) ((input: unknown) => output<T> | INVALID) & { code?: string; definite?: boolean } を生成する低レベルコード生成器。assertOnly: true の場合は z.validate() 向けに出力オブジェクト構築を省略します。
z.withParser(schema, parser) <T extends SomeType>(schema: T, parser: (input: unknown) => output<T> | INVALID) => T ビルド時等に事前生成された AOT パーサ関数（厳格な CSP / jitless 環境向け）を schema のクローンに組み込みます。
z.INVALID unique symbol (Symbol.for("zod.compile.invalid")) コンパイル済みパーサが検証失敗時に返すセンチネルシンボル（ランタイムの _zod.run フォールバックを起動）。 
// モード A: アプリケーションのエントリポイントで全スキーマを自動コンパイル
import "zod/compile";
import * as z from "zod";

// モード B: 個別スキーマの明示的コンパイル（strict モード）
const OrderSchema = z.compile(
  z.object({
    orderId: z.uuid(),
    items: z.array(z.object({ sku: z.string(), qty: z.int().positive() })),
  }),
  { strict: true },
);

const order = OrderSchema.parse(rawOrder);

interfaceStandardSchemaV1 (~standard)#

すべての Zod v4 スキーマ（ZodType、ZodMiniType、$ZodType）は、schema["~standard"] プロパティ下にライブラリ横断の Standard Schema v1（StandardSchemaV1）および Standard JSON Schema v1（StandardJSONSchemaV1）仕様を実装しており、tRPC、TanStack Form/Router、Hono、Next.js Server Actions、OpenAPI ジェネレータ等とアダプタなしで直接連携できます。

05_mini_and_core_engine_2
schema['~standard'] が公開する StandardSchemaV1 および StandardJSONSchemaV1 コントラクト
Source Code 
from drawlib import canvas
from drawlib.diagrams.class_diagram import ClassDiagram, ClassNode
from drawlib.fonts import FontRoboto, FontSourceCode
from drawlib.styles import Styles

canvas.clear()
canvas.setup(width=188, height=96, dpi=150)

cd = ClassDiagram(
    node_style=Styles.Neutral.patch(text_font=FontSourceCode.ROBOTO_MONO, text_size=9.5),
    header_style=Styles.PrimaryNeutral.patch(text_font=FontRoboto.ROBOTO_BOLD, text_size=10.5),
    edge_style=Styles.DarkBold,
    edge_text_style=Styles.Dark.patch(text_size=9.5),
    title="StandardSchemaV1 & StandardJSONSchemaV1 (~standard コントラクト)",
)

# Left: Zod Schema
zod_schema = cd.add(
    ClassNode("ZodType<O, I> / ZodMiniType<O, I>", width=50, header_style=Styles.SecondaryNeutral.patch(text_font=FontRoboto.ROBOTO_BOLD, text_size=10.5))
    .add_attribute("~standard", "StandardSchemaProps<I, O>", visibility="+")
    .add_method("parse", "data: unknown", "O")
    .add_method("toJSONSchema", "params?", "BaseSchema"),
    xy=(28.0, 48.0),
)

# Center: ~standard Props
std_props = cd.add(
    ClassNode("StandardSchemaProps<I, O>", width=54, header_style=Styles.PrimaryNeutral)
    .add_attribute("version", "1", visibility="+")
    .add_attribute("vendor", "'zod'", visibility="+")
    .add_attribute("types", "{ input: I, output: O }", visibility="+")
    .add_attribute("jsonSchema", "StandardJSONSchemaV1.Converter", visibility="+")
    .add_method("validate", "val: unknown", "Result<O> | Promise"),
    xy=(94.0, 48.0),
)

# Right Top: Validation Result
std_res = cd.add(
    ClassNode("StandardSchemaV1.Result<O>", width=52, header_style=Styles.PrimaryNeutral)
    .add_attribute("SuccessResult<O>", "{ value: O }")
    .add_attribute("FailureResult", "{ issues: Issue[] }"),
    xy=(160.0, 68.0),
)

# Right Bottom: JSON Schema Converter
std_json = cd.add(
    ClassNode("StandardJSONSchemaV1.Converter", width=52, header_style=Styles.PrimaryNeutral)
    .add_method("input", "opts: Options", "JSONSchema")
    .add_method("output", "opts: Options", "JSONSchema"),
    xy=(160.0, 26.0),
)

cd.connect(zod_schema, std_props, "composition", directed=True, start_side="right", end_side="left")
cd.connect(std_props, std_res, "dependency", start_side="right", end_side="left")
cd.connect(std_props, std_json, "composition", directed=True, start_side="right", end_side="left")

cd.draw(xy=(94.0, 46.0), align="center")
canvas.save()

schema["~standard"] コントラクト一覧#

プロパティ / メソッド 型 説明
schema["~standard"].version 1 Standard Schema 仕様バージョン番号（固定値 1）。
schema["~standard"].vendor "zod" ベンダー識別文字列（"zod"）。
schema["~standard"].validate(value, opts?) (value: unknown, options?: StandardSchemaV1.Options) => Result<O> | Promise<Result<O>> バリデーションを実行し、成功時は { value: O }、失敗時は { issues: $ZodIssue[] } を返します（同期実行可能な場合は同期で返し、非同期チェックを含む場合は Promise を返します）。
schema["~standard"].jsonSchema.input(opts) (options: { target: Target; libraryOptions?: Record<string, unknown> }) => Record<string, unknown> スキーマの入力型（io: "input"）に対する JSON Schema（"draft-2020-12", "draft-07", "openapi-3.0"）を生成します（Classic ZodType に実装）。
schema["~standard"].jsonSchema.output(opts) (options: { target: Target; libraryOptions?: Record<string, unknown> }) => Record<string, unknown> スキーマの出力型（io: "output"）に対する JSON Schema を生成します（Classic ZodType に実装）。
StandardSchemaV1.InferInput<S> / InferOutput<S> 型ヘルパー NonNullable<S["~standard"]["types"]>["input" | "output"] から静的な入力型・出力型を抽出するライブラリ非依存の型ユーティリティ。 
import * as z from "zod";
import type { StandardSchemaV1 } from "@standard-schema/spec";

// StandardSchemaV1 準拠の任意のスキーマを受け取る汎用バリデータ
async function validateBody<S extends StandardSchemaV1>(
  schema: S,
  body: unknown,
): Promise<StandardSchemaV1.InferOutput<S>> {
  let result = schema["~standard"].validate(body);
  if (result instanceof Promise) result = await result;
  if (result.issues) {
    throw new Error(z.prettifyError(result));
  }
  return result.value;
}