@pyreon/validation 0.10.0 → 0.11.1

package/lib/arktype.js.map

@@ -1 +1 @@
-{"version":3,"file":"arktype.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result))\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACOT,SAAS,YAAY,QAAsC;AACzD,QAAO,MAAM,QAAQ,OAAO,IAAI,aAAc;;AAGhD,SAAS,mBAAmB,QAAsC;AAChE,QAAO,OAAO,KAAK,SAAS;EAC1B,MAAM,IAAI,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACpC,SAAS,IAAI;EACd,EAAE;;;;;;;;;;;;;;;;;;;;;;;AAwBL,SAAgB,cACd,QAC2B;AAC3B,SAAQ,WAAoB;AAC1B,MAAI;GACF,MAAM,SAAS,OAAO,OAAO;AAC7B,OAAI,CAAC,YAAY,OAAO,CACtB,QAAO,EAAE;AACX,UAAO,eAAwB,mBAAmB,OAAO,CAAC;WACnD,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAwC;AACtE,SAAQ,UAAa;AACnB,MAAI;GACF,MAAM,SAAS,OAAO,MAAM;AAC5B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO;AACjC,UAAO,OAAO,IAAI;WACX,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}
+{"version":3,"file":"arktype.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts"],"sourcesContent":["import type { ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && \"summary\" in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join(\".\"),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACGT,SAAS,YAAY,QAAsC;AACzD,QAAO,MAAM,QAAQ,OAAO,IAAI,aAAc;;AAGhD,SAAS,mBAAmB,QAAsC;AAChE,QAAO,OAAO,KAAK,SAAS;EAC1B,MAAM,IAAI,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACpC,SAAS,IAAI;EACd,EAAE;;;;;;;;;;;;;;;;;;;;;;;AAwBL,SAAgB,cACd,QAC2B;AAC3B,SAAQ,WAAoB;AAC1B,MAAI;GACF,MAAM,SAAS,OAAO,OAAO;AAC7B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO,EAAE;AACnC,UAAO,eAAwB,mBAAmB,OAAO,CAAC;WACnD,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAwC;AACtE,SAAQ,UAAa;AACnB,MAAI;GACF,MAAM,SAAS,OAAO,MAAM;AAC5B,OAAI,CAAC,YAAY,OAAO,CAAE,QAAO;AACjC,UAAO,OAAO,IAAI;WACX,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts","../src/valibot.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && 'summary' in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join('.'),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result))\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(\n        valibotIssuesToGeneric(result.issues ?? []),\n      )\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join('.'),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/arktype.ts","../src/valibot.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.\n */\ninterface ArkError {\n  path: PropertyKey[]\n  message: string\n}\n\ninterface ArkErrors extends Array<ArkError> {\n  summary: string\n}\n\n/**\n * Internal callable interface matching ArkType's Type.\n * Not exposed publicly — consumers pass their ArkType schema directly.\n */\ntype ArkTypeCallable = (data: unknown) => unknown\n\nfunction isArkErrors(result: unknown): result is ArkErrors {\n  return Array.isArray(result) && \"summary\" in (result as object)\n}\n\nfunction arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {\n  return errors.map((err) => ({\n    path: err.path.map(String).join(\".\"),\n    message: err.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from an ArkType schema.\n *\n * Accepts any callable ArkType `Type` instance. The schema is duck-typed —\n * no ArkType import required.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeSchema } from '@pyreon/validation/arktype'\n *\n * const schema = type({\n *   email: 'string.email',\n *   password: 'string >= 8',\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: arktypeSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeSchema<TValues extends Record<string, unknown>>(\n  schema: ArkTypeCallable,\n): SchemaValidateFn<TValues> {\n  return (values: TValues) => {\n    try {\n      const result = schema(values)\n      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(arkIssuesToGeneric(result))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from an ArkType schema.\n *\n * @example\n * import { type } from 'arktype'\n * import { arktypeField } from '@pyreon/validation/arktype'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: arktypeField(type('string.email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function arktypeField<T>(schema: ArkTypeCallable): ValidateFn<T> {\n  return (value: T) => {\n    try {\n      const result = schema(value)\n      if (!isArkErrors(result)) return undefined\n      return result[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join(\".\") ?? \"\",\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join(\".\"),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":"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"}

package/lib/types/arktype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arktype2.d.ts","names":[],"sources":["../../../src/arktype.ts"],"mappings":";;;;;AAIqB;;KAoBhB,eAAA,IAAmB,IAAA;;;AAkCxB;;;;;;;;;;;;;;;;;AAgCA;;iBAhCgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA8BJ,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,UAAA,CAAW,CAAA"}
+{"version":3,"file":"arktype2.d.ts","names":[],"sources":["../../../src/arktype.ts"],"mappings":";;;;;AAAiF;;KAoB5E,eAAA,IAAmB,IAAA;;;AAkCxB;;;;;;;;;;;;;;;;;AA+BA;;iBA/BgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA6BJ,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,UAAA,CAAW,CAAA"}

package/lib/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/arktype.ts","../../../src/types.ts","../../../src/utils.ts","../../../src/valibot.ts","../../../src/zod.ts"],"mappings":";;;;;AAIqB;;KAoBhB,eAAA,IAAmB,IAAA;;;AAkCxB;;;;;;;;;;;;;;;;;AAgCA;;iBAhCgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA8BJ,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,YAAA,CAAW,CAAA;;;AAtFhD;;;;AAAA,UCSJ,eAAA;ED6CD;EC3Cd,IAAA;ED2C2B;ECzC3B,OAAA;AAAA;;;;;KAOU,aAAA,6BAA0C,MAAA,mBACpD,MAAA,EAAQ,OAAA,KACL,gBAAA,CAAiB,OAAA;;;;;KAMV,YAAA,gBAA4B,MAAA,EAAQ,OAAA,KAAY,UAAA,CAAW,CAAA;;;;AD5BlD;;;;iBEIL,cAAA,iBAA+B,MAAA,kBAAA,CAC7C,MAAA,EAAQ,eAAA,KACP,OAAA,CAAQ,MAAA,OAAa,OAAA,EAAS,iBAAA;;;;;AFNZ;;;;KG6BhB,kBAAA,GAAqB,QAAA;AHyB1B;;;;;;;;;;;;;;;;;AAgCA;;;;AAhCA,iBGUgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;AF1DpB;;iBE2FgB,YAAA,GAAA,CACd,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,YAAA,CAAW,CAAA;;;;;AHvGO;;UIQX,QAAA;EACR,IAAA,EAAM,WAAA;EACN,OAAA;AAAA;;;;;UAOQ,SAAA;EACR,SAAA,CAAU,IAAA;IACR,OAAA;IACA,IAAA,GAAO,CAAA;IACP,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;EAEpB,cAAA,CACE,IAAA,YACC,OAAA;IAAU,OAAA;IAAkB,IAAA,GAAO,CAAA;IAAG,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;;;AHhB7D;;;;;iBG6CgB,SAAA,iBAA0B,MAAA,kBAAA,CACxC,MAAA,EAAQ,SAAA,CAAU,OAAA,IACjB,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;;iBA+BJ,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,YAAA,CAAW,CAAA"}
+{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/arktype.ts","../../../src/types.ts","../../../src/utils.ts","../../../src/valibot.ts","../../../src/zod.ts"],"mappings":";;;;;AAAiF;;KAoB5E,eAAA,IAAmB,IAAA;;;AAkCxB;;;;;;;;;;;;;;;;;AA+BA;;iBA/BgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA6BJ,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,YAAA,CAAW,CAAA;;;AArFY;;;;AAAA,UCShE,eAAA;ED6CD;EC3Cd,IAAA;ED2C2B;ECzC3B,OAAA;AAAA;;;;;KAOU,aAAA,6BAA0C,MAAA,mBACpD,MAAA,EAAQ,OAAA,KACL,gBAAA,CAAiB,OAAA;;;;;KAMV,YAAA,gBAA4B,MAAA,EAAQ,OAAA,KAAY,UAAA,CAAW,CAAA;;;;AD5BU;;;;iBEQjE,cAAA,iBAA+B,MAAA,kBAAA,CAC7C,MAAA,EAAQ,eAAA,KACP,OAAA,CAAQ,MAAA,OAAa,OAAA,EAAS,iBAAA;;;;;AFVgD;;;;KG6B5E,kBAAA,GAAqB,QAAA;AHyB1B;;;;;;;;;;;;;;;;;AA+BA;;;;AA/BA,iBGUgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;AF1DpB;;iBEwFgB,YAAA,GAAA,CAAgB,MAAA,WAAiB,WAAA,EAAa,kBAAA,GAAqB,YAAA,CAAW,CAAA;;;;;AHjGb;;UIQvE,QAAA;EACR,IAAA,EAAM,WAAA;EACN,OAAA;AAAA;;;;;UAOQ,SAAA;EACR,SAAA,CAAU,IAAA;IACR,OAAA;IACA,IAAA,GAAO,CAAA;IACP,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;EAEpB,cAAA,CACE,IAAA,YACC,OAAA;IAAU,OAAA;IAAkB,IAAA,GAAO,CAAA;IAAG,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;;;AHhB7D;;;;;iBG6CgB,SAAA,iBAA0B,MAAA,kBAAA,CACxC,MAAA,EAAQ,SAAA,CAAU,OAAA,IACjB,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;;iBA8BJ,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,YAAA,CAAW,CAAA"}

package/lib/types/valibot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valibot2.d.ts","names":[],"sources":["../../../src/valibot.ts"],"mappings":";;;;;AAIqB;;;;KA6BhB,kBAAA,GAAqB,QAAA;AAmC1B;;;;;;;;;;;;;;;;;;AAoCA;;;AApCA,iBAAgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBAiCJ,YAAA,GAAA,CACd,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,UAAA,CAAW,CAAA"}
+{"version":3,"file":"valibot2.d.ts","names":[],"sources":["../../../src/valibot.ts"],"mappings":";;;;;AAAiF;;;;KA6B5E,kBAAA,GAAqB,QAAA;AAmC1B;;;;;;;;;;;;;;;;;;AAiCA;;;AAjCA,iBAAgB,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;;;;iBA8BJ,YAAA,GAAA,CAAgB,MAAA,WAAiB,WAAA,EAAa,kBAAA,GAAqB,UAAA,CAAW,CAAA"}

package/lib/types/zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod2.d.ts","names":[],"sources":["../../../src/zod.ts"],"mappings":";;;;;AAIqB;;UAQX,QAAA;EACR,IAAA,EAAM,WAAA;EACN,OAAA;AAAA;;;;AAAO;UAOC,SAAA;EACR,SAAA,CAAU,IAAA;IACR,OAAA;IACA,IAAA,GAAO,CAAA;IACP,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;EAEpB,cAAA,CACE,IAAA,YACC,OAAA;IAAU,OAAA;IAAkB,IAAA,GAAO,CAAA;IAAG,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;;AA6B7D;;;;;;iBAAgB,SAAA,iBAA0B,MAAA,kBAAA,CACxC,MAAA,EAAQ,SAAA,CAAU,OAAA,IACjB,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;AA+BpB;;;;iBAAgB,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,UAAA,CAAW,CAAA"}
+{"version":3,"file":"zod2.d.ts","names":[],"sources":["../../../src/zod.ts"],"mappings":";;;;;AAAiF;;UAQvE,QAAA;EACR,IAAA,EAAM,WAAA;EACN,OAAA;AAAA;;;;AAAO;UAOC,SAAA;EACR,SAAA,CAAU,IAAA;IACR,OAAA;IACA,IAAA,GAAO,CAAA;IACP,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;EAEpB,cAAA,CACE,IAAA,YACC,OAAA;IAAU,OAAA;IAAkB,IAAA,GAAO,CAAA;IAAG,KAAA;MAAU,MAAA,EAAQ,QAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;;AA6B7D;;;;;;iBAAgB,SAAA,iBAA0B,MAAA,kBAAA,CACxC,MAAA,EAAQ,SAAA,CAAU,OAAA,IACjB,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;AA8BpB;;;;iBAAgB,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,UAAA,CAAW,CAAA"}

package/lib/valibot.js.map

@@ -1 +1 @@
-{"version":3,"file":"valibot.js","names":[],"sources":["../src/utils.ts","../src/valibot.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(\n        valibotIssuesToGeneric(result.issues ?? []),\n      )\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACgBT,SAAS,uBAAuB,QAA2C;AACzE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,IAAI;EACzD,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;;;AA6BL,SAAgB,cACd,QACA,aAC2B;CAC3B,MAAM,QAAQ;AACd,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,OAAO;AAC1C,OAAI,OAAO,QACT,QAAO,EAAE;AACX,UAAO,eACL,uBAAuB,OAAO,UAAU,EAAE,CAAC,CAC5C;WACM,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aACd,QACA,aACe;CACf,MAAM,QAAQ;AACd,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,MAAM;AACzC,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,SAAS,IAAI;WACpB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}
+{"version":3,"file":"valibot.js","names":[],"sources":["../src/utils.ts","../src/valibot.ts"],"sourcesContent":["import type { ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.\n */\ninterface ValibotPathItem {\n  key: string | number\n}\n\ninterface ValibotIssue {\n  path?: ValibotPathItem[]\n  message: string\n}\n\ninterface ValibotSafeParseResult {\n  success: boolean\n  output?: unknown\n  issues?: ValibotIssue[]\n}\n\n/**\n * Any function that takes (schema, input, ...rest) and returns a parse result.\n * Valibot's safeParse/safeParseAsync have generic constraints on the schema\n * parameter that can't be expressed without importing Valibot types. We accept\n * any callable and cast internally.\n */\n// biome-ignore lint/complexity/noBannedTypes: must accept any valibot parse function\ntype GenericSafeParseFn = Function\n\nfunction valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path?.map((p) => String(p.key)).join(\".\") ?? \"\",\n    message: issue.message,\n  }))\n}\n\ntype InternalParseFn = (\n  schema: unknown,\n  input: unknown,\n) => ValibotSafeParseResult | Promise<ValibotSafeParseResult>\n\n/**\n * Create a form-level schema validator from a Valibot schema.\n *\n * Valibot uses standalone functions rather than methods, so you must pass\n * the `safeParseAsync` (or `safeParse`) function from valibot.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotSchema } from '@pyreon/validation/valibot'\n *\n * const schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n *   password: v.pipe(v.string(), v.minLength(8)),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: valibotSchema(schema, v.safeParseAsync),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotSchema<TValues extends Record<string, unknown>>(\n  schema: unknown,\n  safeParseFn: GenericSafeParseFn,\n): SchemaValidateFn<TValues> {\n  const parse = safeParseFn as InternalParseFn\n  return async (values: TValues) => {\n    try {\n      const result = await parse(schema, values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Valibot schema.\n *\n * @example\n * import * as v from 'valibot'\n * import { valibotField } from '@pyreon/validation/valibot'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T> {\n  const parse = safeParseFn as InternalParseFn\n  return async (value: T) => {\n    try {\n      const result = await parse(schema, value)\n      if (result.success) return undefined\n      return result.issues?.[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACYT,SAAS,uBAAuB,QAA2C;AACzE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,IAAI;EACzD,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;;;AA6BL,SAAgB,cACd,QACA,aAC2B;CAC3B,MAAM,QAAQ;AACd,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,OAAO;AAC1C,OAAI,OAAO,QAAS,QAAO,EAAE;AAC7B,UAAO,eAAwB,uBAAuB,OAAO,UAAU,EAAE,CAAC,CAAC;WACpE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,aAAgB,QAAiB,aAAgD;CAC/F,MAAM,QAAQ;AACd,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,MAAM,QAAQ,MAAM;AACzC,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,SAAS,IAAI;WACpB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}

package/lib/zod.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.js","names":[],"sources":["../src/utils.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from '@pyreon/form'\nimport type { ValidationIssue } from './types'\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type {\n  SchemaValidateFn,\n  ValidateFn,\n  ValidationError,\n} from '@pyreon/form'\nimport type { ValidationIssue } from './types'\nimport { issuesToRecord } from './utils'\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join('.'),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success)\n        return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        '': err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACaT,SAAS,mBAAmB,QAAuC;AACjE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACtC,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;AAsBL,SAAgB,UACd,QAC2B;AAC3B,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,OAAO;AAClD,OAAI,OAAO,QACT,QAAO,EAAE;AACX,UAAO,eAAwB,mBAAmB,OAAO,MAAO,OAAO,CAAC;WACjE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;;AAqBP,SAAgB,SAAY,QAAqC;AAC/D,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,MAAM;AACjD,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,MAAO,OAAO,IAAI;WACzB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}
+{"version":3,"file":"zod.js","names":[],"sources":["../src/utils.ts","../src/zod.ts"],"sourcesContent":["import type { ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\n\n/**\n * Convert an array of validation issues into a flat field → error record.\n * For nested paths like [\"address\", \"city\"], produces \"address.city\".\n * When multiple issues exist for the same path, the first message wins.\n */\nexport function issuesToRecord<TValues extends Record<string, unknown>>(\n  issues: ValidationIssue[],\n): Partial<Record<keyof TValues, ValidationError>> {\n  const errors = {} as Partial<Record<keyof TValues, ValidationError>>\n  for (const issue of issues) {\n    const key = issue.path as keyof TValues\n    // First error per field wins\n    if (errors[key] === undefined) {\n      errors[key] = issue.message\n    }\n  }\n  return errors\n}\n","import type { SchemaValidateFn, ValidateFn, ValidationError } from \"@pyreon/form\"\nimport type { ValidationIssue } from \"./types\"\nimport { issuesToRecord } from \"./utils\"\n\n/**\n * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.\n * These match Zod v3's public API surface.\n */\ninterface ZodIssue {\n  path: PropertyKey[]\n  message: string\n}\n\n/**\n * Duck-typed Zod schema interface — works with both Zod v3 and v4.\n * Inlines the result shape to avoid version-specific type mismatches.\n */\ninterface ZodSchema<T = unknown> {\n  safeParse(data: unknown): {\n    success: boolean\n    data?: T\n    error?: { issues: ZodIssue[] }\n  }\n  safeParseAsync(\n    data: unknown,\n  ): Promise<{ success: boolean; data?: T; error?: { issues: ZodIssue[] } }>\n}\n\nfunction zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {\n  return issues.map((issue) => ({\n    path: issue.path.map(String).join(\".\"),\n    message: issue.message,\n  }))\n}\n\n/**\n * Create a form-level schema validator from a Zod schema.\n * Supports both sync and async Zod schemas (uses `safeParseAsync`).\n *\n * @example\n * import { z } from 'zod'\n * import { zodSchema } from '@pyreon/validation/zod'\n *\n * const schema = z.object({\n *   email: z.string().email(),\n *   password: z.string().min(8),\n * })\n *\n * const form = useForm({\n *   initialValues: { email: '', password: '' },\n *   schema: zodSchema(schema),\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodSchema<TValues extends Record<string, unknown>>(\n  schema: ZodSchema<TValues>,\n): SchemaValidateFn<TValues> {\n  return async (values: TValues) => {\n    try {\n      const result = await schema.safeParseAsync(values)\n      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>\n      return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))\n    } catch (err) {\n      return {\n        \"\": err instanceof Error ? err.message : String(err),\n      } as Partial<Record<keyof TValues, ValidationError>>\n    }\n  }\n}\n\n/**\n * Create a single-field validator from a Zod schema.\n * Supports both sync and async Zod refinements.\n *\n * @example\n * import { z } from 'zod'\n * import { zodField } from '@pyreon/validation/zod'\n *\n * const form = useForm({\n *   initialValues: { email: '' },\n *   validators: {\n *     email: zodField(z.string().email('Invalid email')),\n *   },\n *   onSubmit: (values) => { ... },\n * })\n */\nexport function zodField<T>(schema: ZodSchema<T>): ValidateFn<T> {\n  return async (value: T) => {\n    try {\n      const result = await schema.safeParseAsync(value)\n      if (result.success) return undefined\n      return result.error!.issues[0]?.message\n    } catch (err) {\n      return err instanceof Error ? err.message : String(err)\n    }\n  }\n}\n"],"mappings":";;;;;;AAQA,SAAgB,eACd,QACiD;CACjD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,MAAM,MAAM;AAElB,MAAI,OAAO,SAAS,OAClB,QAAO,OAAO,MAAM;;AAGxB,QAAO;;;;;ACST,SAAS,mBAAmB,QAAuC;AACjE,QAAO,OAAO,KAAK,WAAW;EAC5B,MAAM,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI;EACtC,SAAS,MAAM;EAChB,EAAE;;;;;;;;;;;;;;;;;;;;;AAsBL,SAAgB,UACd,QAC2B;AAC3B,QAAO,OAAO,WAAoB;AAChC,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,OAAO;AAClD,OAAI,OAAO,QAAS,QAAO,EAAE;AAC7B,UAAO,eAAwB,mBAAmB,OAAO,MAAO,OAAO,CAAC;WACjE,KAAK;AACZ,UAAO,EACL,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,EACrD;;;;;;;;;;;;;;;;;;;;AAqBP,SAAgB,SAAY,QAAqC;AAC/D,QAAO,OAAO,UAAa;AACzB,MAAI;GACF,MAAM,SAAS,MAAM,OAAO,eAAe,MAAM;AACjD,OAAI,OAAO,QAAS,QAAO;AAC3B,UAAO,OAAO,MAAO,OAAO,IAAI;WACzB,KAAK;AACZ,UAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI"}

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@pyreon/validation",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Schema validation adapters for Pyreon forms (Zod, Valibot, ArkType)",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pyreon/fundamentals.git",
-    "directory": "packages/validation"
+    "url": "https://github.com/pyreon/pyreon.git",
+    "directory": "packages/fundamentals/validation"
   },
   "homepage": "https://github.com/pyreon/fundamentals/tree/main/packages/validation#readme",
   "bugs": {
-    "url": "https://github.com/pyreon/fundamentals/issues"
+    "url": "https://github.com/pyreon/pyreon/issues"
   },
   "publishConfig": {
     "access": "public"
@@ -52,10 +52,11 @@
     "build": "vl_rolldown_build",
     "dev": "vl_rolldown_build-watch",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check ."
   },
   "peerDependencies": {
-    "@pyreon/form": "^0.10.0"
+    "@pyreon/form": "^0.11.1"
   },
   "peerDependenciesMeta": {
     "zod": {
@@ -67,5 +68,15 @@
     "arktype": {
       "optional": true
     }
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.8.3",
+    "@pyreon/core": "^0.11.1",
+    "@pyreon/form": "^0.11.1",
+    "@pyreon/reactivity": "^0.11.1",
+    "@pyreon/runtime-dom": "^0.11.1",
+    "zod": "^4.3.6",
+    "valibot": "^1.2.0",
+    "arktype": "^2.2.0"
   }
 }

package/src/arktype.ts

@@ -1,10 +1,6 @@
-import type {
-  SchemaValidateFn,
-  ValidateFn,
-  ValidationError,
-} from '@pyreon/form'
-import type { ValidationIssue } from './types'
-import { issuesToRecord } from './utils'
+import type { SchemaValidateFn, ValidateFn, ValidationError } from "@pyreon/form"
+import type { ValidationIssue } from "./types"
+import { issuesToRecord } from "./utils"
 
 /**
  * Minimal ArkType-compatible interfaces so we don't require arktype as a hard dep.
@@ -25,12 +21,12 @@ interface ArkErrors extends Array<ArkError> {
 type ArkTypeCallable = (data: unknown) => unknown
 
 function isArkErrors(result: unknown): result is ArkErrors {
-  return Array.isArray(result) && 'summary' in (result as object)
+  return Array.isArray(result) && "summary" in (result as object)
 }
 
 function arkIssuesToGeneric(errors: ArkErrors): ValidationIssue[] {
   return errors.map((err) => ({
-    path: err.path.map(String).join('.'),
+    path: err.path.map(String).join("."),
     message: err.message,
   }))
 }
@@ -62,12 +58,11 @@ export function arktypeSchema<TValues extends Record<string, unknown>>(
   return (values: TValues) => {
     try {
       const result = schema(values)
-      if (!isArkErrors(result))
-        return {} as Partial<Record<keyof TValues, ValidationError>>
+      if (!isArkErrors(result)) return {} as Partial<Record<keyof TValues, ValidationError>>
       return issuesToRecord<TValues>(arkIssuesToGeneric(result))
     } catch (err) {
       return {
-        '': err instanceof Error ? err.message : String(err),
+        "": err instanceof Error ? err.message : String(err),
       } as Partial<Record<keyof TValues, ValidationError>>
     }
   }

package/src/index.ts

@@ -1,4 +1,4 @@
-export { arktypeField, arktypeSchema } from './arktype'
+export { arktypeField, arktypeSchema } from "./arktype"
 export type {
   FieldAdapter,
   SchemaAdapter,
@@ -6,7 +6,7 @@ export type {
   ValidateFn,
   ValidationError,
   ValidationIssue,
-} from './types'
-export { issuesToRecord } from './utils'
-export { valibotField, valibotSchema } from './valibot'
-export { zodField, zodSchema } from './zod'
+} from "./types"
+export { issuesToRecord } from "./utils"
+export { valibotField, valibotSchema } from "./valibot"
+export { zodField, zodSchema } from "./zod"

package/src/tests/setup.ts

@@ -1 +1 @@
-import '@happy-dom/global-registrator'
+import "@happy-dom/global-registrator"

package/src/tests/validation.test.tsx

@@ -1,12 +1,12 @@
-import { useForm } from '@pyreon/form'
-import { mount } from '@pyreon/runtime-dom'
-import { type } from 'arktype'
-import * as v from 'valibot'
-import { z } from 'zod'
-import { arktypeField, arktypeSchema } from '../arktype'
-import { issuesToRecord } from '../utils'
-import { valibotField, valibotSchema } from '../valibot'
-import { zodField, zodSchema } from '../zod'
+import { useForm } from "@pyreon/form"
+import { mount } from "@pyreon/runtime-dom"
+import { type } from "arktype"
+import * as v from "valibot"
+import { z } from "zod"
+import { arktypeField, arktypeSchema } from "../arktype"
+import { issuesToRecord } from "../utils"
+import { valibotField, valibotSchema } from "../valibot"
+import { zodField, zodSchema } from "../zod"
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -17,7 +17,7 @@ function Capture<T>({ fn }: { fn: () => T }) {
 
 function mountWith<T>(fn: () => T): { result: T; unmount: () => void } {
   let result: T | undefined
-  const el = document.createElement('div')
+  const el = document.createElement("div")
   document.body.appendChild(el)
   const unmount = mount(
     <Capture
@@ -38,85 +38,85 @@ function mountWith<T>(fn: () => T): { result: T; unmount: () => void } {
 
 // ─── issuesToRecord ──────────────────────────────────────────────────────────
 
-describe('issuesToRecord', () => {
-  it('converts issues to a flat record', () => {
+describe("issuesToRecord", () => {
+  it("converts issues to a flat record", () => {
     const result = issuesToRecord([
-      { path: 'email', message: 'Required' },
-      { path: 'password', message: 'Too short' },
+      { path: "email", message: "Required" },
+      { path: "password", message: "Too short" },
     ])
-    expect(result).toEqual({ email: 'Required', password: 'Too short' })
+    expect(result).toEqual({ email: "Required", password: "Too short" })
   })
 
-  it('first error per field wins', () => {
+  it("first error per field wins", () => {
     const result = issuesToRecord([
-      { path: 'email', message: 'Required' },
-      { path: 'email', message: 'Invalid format' },
+      { path: "email", message: "Required" },
+      { path: "email", message: "Invalid format" },
     ])
-    expect(result).toEqual({ email: 'Required' })
+    expect(result).toEqual({ email: "Required" })
   })
 
-  it('returns empty object for no issues', () => {
+  it("returns empty object for no issues", () => {
     expect(issuesToRecord([])).toEqual({})
   })
 })
 
 // ─── Zod Adapter ─────────────────────────────────────────────────────────────
 
-describe('zodSchema', () => {
+describe("zodSchema", () => {
   const schema = z.object({
-    email: z.string().email('Invalid email'),
-    password: z.string().min(8, 'Min 8 chars'),
+    email: z.string().email("Invalid email"),
+    password: z.string().min(8, "Min 8 chars"),
   })
 
-  it('returns empty record for valid data', async () => {
+  it("returns empty record for valid data", async () => {
     const validate = zodSchema(schema)
-    const result = await validate({ email: 'a@b.com', password: '12345678' })
+    const result = await validate({ email: "a@b.com", password: "12345678" })
     expect(result).toEqual({})
   })
 
-  it('returns field errors for invalid data', async () => {
+  it("returns field errors for invalid data", async () => {
     const validate = zodSchema(schema)
-    const result = await validate({ email: 'bad', password: 'short' })
-    expect(result.email).toBe('Invalid email')
-    expect(result.password).toBe('Min 8 chars')
+    const result = await validate({ email: "bad", password: "short" })
+    expect(result.email).toBe("Invalid email")
+    expect(result.password).toBe("Min 8 chars")
   })
 
-  it('returns error for single invalid field', async () => {
+  it("returns error for single invalid field", async () => {
     const validate = zodSchema(schema)
-    const result = await validate({ email: 'a@b.com', password: 'short' })
+    const result = await validate({ email: "a@b.com", password: "short" })
     expect(result.email).toBeUndefined()
-    expect(result.password).toBe('Min 8 chars')
+    expect(result.password).toBe("Min 8 chars")
   })
 })
 
-describe('zodField', () => {
-  it('returns undefined for valid value', async () => {
-    const validate = zodField(z.string().email('Invalid email'))
-    expect(await validate('a@b.com', {})).toBeUndefined()
+describe("zodField", () => {
+  it("returns undefined for valid value", async () => {
+    const validate = zodField(z.string().email("Invalid email"))
+    expect(await validate("a@b.com", {})).toBeUndefined()
   })
 
-  it('returns error message for invalid value', async () => {
-    const validate = zodField(z.string().email('Invalid email'))
-    expect(await validate('bad', {})).toBe('Invalid email')
+  it("returns error message for invalid value", async () => {
+    const validate = zodField(z.string().email("Invalid email"))
+    expect(await validate("bad", {})).toBe("Invalid email")
   })
 
-  it('works with number schemas', async () => {
-    const validate = zodField(z.number().min(0, 'Must be positive'))
-    expect(await validate(-1, {})).toBe('Must be positive')
+  it("works with number schemas", async () => {
+    const validate = zodField(z.number().min(0, "Must be positive"))
+    expect(await validate(-1, {})).toBe("Must be positive")
     expect(await validate(5, {})).toBeUndefined()
   })
 })
 
-describe('zod + useForm integration', () => {
-  it('validates form with zod schema', async () => {
+describe("zod + useForm integration", () => {
+  it("validates form with zod schema", async () => {
     const schema = z.object({
-      email: z.string().email('Invalid email'),
-      password: z.string().min(8, 'Min 8 chars'),
+      email: z.string().email("Invalid email"),
+      password: z.string().min(8, "Min 8 chars"),
     })
 
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         schema: zodSchema(schema),
         onSubmit: () => {
           /* noop */
@@ -126,18 +126,18 @@ describe('zod + useForm integration', () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.email.error()).toBe('Invalid email')
-    expect(form.fields.password.error()).toBe('Min 8 chars')
+    expect(form.fields.email.error()).toBe("Invalid email")
+    expect(form.fields.password.error()).toBe("Min 8 chars")
     unmount()
   })
 
-  it('validates with field-level zod validators', async () => {
+  it("validates with field-level zod validators", async () => {
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: '', age: 0 },
+        initialValues: { email: "", age: 0 },
         validators: {
-          email: zodField(z.string().email('Invalid')),
-          age: zodField(z.number().min(18, 'Must be 18+')),
+          email: zodField(z.string().email("Invalid")),
+          age: zodField(z.number().min(18, "Must be 18+")),
         },
         onSubmit: () => {
           /* noop */
@@ -147,52 +147,52 @@ describe('zod + useForm integration', () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.email.error()).toBe('Invalid')
-    expect(form.fields.age.error()).toBe('Must be 18+')
+    expect(form.fields.email.error()).toBe("Invalid")
+    expect(form.fields.age.error()).toBe("Must be 18+")
     unmount()
   })
 })
 
 // ─── Valibot Adapter ─────────────────────────────────────────────────────────
 
-describe('valibotSchema', () => {
+describe("valibotSchema", () => {
   const schema = v.object({
-    email: v.pipe(v.string(), v.email('Invalid email')),
-    password: v.pipe(v.string(), v.minLength(8, 'Min 8 chars')),
+    email: v.pipe(v.string(), v.email("Invalid email")),
+    password: v.pipe(v.string(), v.minLength(8, "Min 8 chars")),
   })
 
-  it('returns empty record for valid data', async () => {
+  it("returns empty record for valid data", async () => {
     const validate = valibotSchema(schema, v.safeParseAsync)
-    const result = await validate({ email: 'a@b.com', password: '12345678' })
+    const result = await validate({ email: "a@b.com", password: "12345678" })
     expect(result).toEqual({})
   })
 
-  it('returns field errors for invalid data', async () => {
+  it("returns field errors for invalid data", async () => {
     const validate = valibotSchema(schema, v.safeParseAsync)
-    const result = await validate({ email: 'bad', password: 'short' })
-    expect(result.email).toBe('Invalid email')
-    expect(result.password).toBe('Min 8 chars')
+    const result = await validate({ email: "bad", password: "short" })
+    expect(result.email).toBe("Invalid email")
+    expect(result.password).toBe("Min 8 chars")
   })
 
-  it('works with sync safeParse', async () => {
+  it("works with sync safeParse", async () => {
     const validate = valibotSchema(schema, v.safeParse)
-    const result = await validate({ email: 'bad', password: 'short' })
-    expect(result.email).toBe('Invalid email')
+    const result = await validate({ email: "bad", password: "short" })
+    expect(result.email).toBe("Invalid email")
   })
 
-  it('handles issues without path', async () => {
+  it("handles issues without path", async () => {
     // Simulate a safeParse function that returns issues without path
     const mockSafeParse = async () => ({
       success: false as const,
-      issues: [{ message: 'Schema-level error' }],
+      issues: [{ message: "Schema-level error" }],
     })
     const validate = valibotSchema({}, mockSafeParse)
     const result = await validate({})
     // Issue without path maps to empty string key
-    expect(result['' as keyof typeof result]).toBe('Schema-level error')
+    expect(result["" as keyof typeof result]).toBe("Schema-level error")
   })
 
-  it('handles result with undefined issues array', async () => {
+  it("handles result with undefined issues array", async () => {
     const mockSafeParse = async () => ({
       success: false as const,
       // issues is undefined
@@ -203,42 +203,36 @@ describe('valibotSchema', () => {
   })
 })
 
-describe('valibotField', () => {
-  it('returns undefined for valid value', async () => {
-    const validate = valibotField(
-      v.pipe(v.string(), v.email('Invalid email')),
-      v.safeParseAsync,
-    )
-    expect(await validate('a@b.com', {})).toBeUndefined()
+describe("valibotField", () => {
+  it("returns undefined for valid value", async () => {
+    const validate = valibotField(v.pipe(v.string(), v.email("Invalid email")), v.safeParseAsync)
+    expect(await validate("a@b.com", {})).toBeUndefined()
   })
 
-  it('returns error message for invalid value', async () => {
-    const validate = valibotField(
-      v.pipe(v.string(), v.email('Invalid email')),
-      v.safeParseAsync,
-    )
-    expect(await validate('bad', {})).toBe('Invalid email')
+  it("returns error message for invalid value", async () => {
+    const validate = valibotField(v.pipe(v.string(), v.email("Invalid email")), v.safeParseAsync)
+    expect(await validate("bad", {})).toBe("Invalid email")
   })
 
-  it('handles result with undefined issues', async () => {
+  it("handles result with undefined issues", async () => {
     const mockSafeParse = async () => ({
       success: false as const,
     })
     const validate = valibotField({}, mockSafeParse)
-    expect(await validate('x', {})).toBeUndefined()
+    expect(await validate("x", {})).toBeUndefined()
   })
 })
 
-describe('valibot + useForm integration', () => {
-  it('validates form with valibot schema', async () => {
+describe("valibot + useForm integration", () => {
+  it("validates form with valibot schema", async () => {
     const schema = v.object({
-      email: v.pipe(v.string(), v.email('Invalid email')),
-      password: v.pipe(v.string(), v.minLength(8, 'Min 8 chars')),
+      email: v.pipe(v.string(), v.email("Invalid email")),
+      password: v.pipe(v.string(), v.minLength(8, "Min 8 chars")),
     })
 
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         schema: valibotSchema(schema, v.safeParseAsync),
         onSubmit: () => {
           /* noop */
@@ -248,198 +242,198 @@ describe('valibot + useForm integration', () => {
 
     const valid = await form.validate()
     expect(valid).toBe(false)
-    expect(form.fields.email.error()).toBe('Invalid email')
-    expect(form.fields.password.error()).toBe('Min 8 chars')
+    expect(form.fields.email.error()).toBe("Invalid email")
+    expect(form.fields.password.error()).toBe("Min 8 chars")
     unmount()
   })
 })
 
 // ─── ArkType Adapter ─────────────────────────────────────────────────────────
 
-describe('arktypeSchema', () => {
+describe("arktypeSchema", () => {
   const schema = type({
-    email: 'string.email',
-    password: 'string >= 8',
+    email: "string.email",
+    password: "string >= 8",
   })
 
-  it('returns empty record for valid data', async () => {
+  it("returns empty record for valid data", async () => {
     const validate = arktypeSchema(schema)
-    const result = await validate({ email: 'a@b.com', password: '12345678' })
+    const result = await validate({ email: "a@b.com", password: "12345678" })
     expect(result).toEqual({})
   })
 
-  it('returns field errors for invalid data', async () => {
+  it("returns field errors for invalid data", async () => {
     const validate = arktypeSchema(schema)
-    const result = await validate({ email: 'bad', password: 'short' })
+    const result = await validate({ email: "bad", password: "short" })
     expect(result.email).toBeDefined()
     expect(result.password).toBeDefined()
   })
 })
 
-describe('arktypeField', () => {
-  it('returns undefined for valid value', async () => {
-    const validate = arktypeField(type('string.email'))
-    expect(await validate('a@b.com', {})).toBeUndefined()
+describe("arktypeField", () => {
+  it("returns undefined for valid value", async () => {
+    const validate = arktypeField(type("string.email"))
+    expect(await validate("a@b.com", {})).toBeUndefined()
   })
 
-  it('returns error message for invalid value', async () => {
-    const validate = arktypeField(type('string.email'))
-    const result = await validate('bad', {})
+  it("returns error message for invalid value", async () => {
+    const validate = arktypeField(type("string.email"))
+    const result = await validate("bad", {})
     expect(result).toBeDefined()
-    expect(typeof result).toBe('string')
+    expect(typeof result).toBe("string")
   })
 })
 
-describe('zodSchema catch branch', () => {
-  it('captures Error when safeParseAsync throws an Error', async () => {
+describe("zodSchema catch branch", () => {
+  it("captures Error when safeParseAsync throws an Error", async () => {
     const throwingSchema = {
       safeParseAsync: () => {
-        throw new Error('Zod schema exploded')
+        throw new Error("Zod schema exploded")
       },
       safeParse: () => {
-        throw new Error('Zod schema exploded')
+        throw new Error("Zod schema exploded")
       },
     }
     const validate = zodSchema(throwingSchema as any)
-    const result = await validate({ email: '', password: '' })
-    expect(result['' as keyof typeof result]).toBe('Zod schema exploded')
+    const result = await validate({ email: "", password: "" })
+    expect(result["" as keyof typeof result]).toBe("Zod schema exploded")
   })
 
-  it('captures non-Error when safeParseAsync throws a string', async () => {
+  it("captures non-Error when safeParseAsync throws a string", async () => {
     const throwingSchema = {
       safeParseAsync: () => {
-        throw 'raw string error'
+        throw "raw string error"
       },
       safeParse: () => {
-        throw 'raw string error'
+        throw "raw string error"
       },
     }
     const validate = zodSchema(throwingSchema as any)
-    const result = await validate({ email: '', password: '' })
-    expect(result['' as keyof typeof result]).toBe('raw string error')
+    const result = await validate({ email: "", password: "" })
+    expect(result["" as keyof typeof result]).toBe("raw string error")
   })
 })
 
-describe('zodField catch branch', () => {
-  it('captures Error when safeParseAsync throws an Error', async () => {
+describe("zodField catch branch", () => {
+  it("captures Error when safeParseAsync throws an Error", async () => {
     const throwingSchema = {
       safeParseAsync: () => {
-        throw new Error('Zod field exploded')
+        throw new Error("Zod field exploded")
       },
       safeParse: () => {
-        throw new Error('Zod field exploded')
+        throw new Error("Zod field exploded")
       },
     }
     const validate = zodField(throwingSchema as any)
-    const result = await validate('test', {})
-    expect(result).toBe('Zod field exploded')
+    const result = await validate("test", {})
+    expect(result).toBe("Zod field exploded")
   })
 
-  it('captures non-Error when safeParseAsync throws a string', async () => {
+  it("captures non-Error when safeParseAsync throws a string", async () => {
     const throwingSchema = {
       safeParseAsync: () => {
-        throw 'raw zod field error'
+        throw "raw zod field error"
       },
       safeParse: () => {
-        throw 'raw zod field error'
+        throw "raw zod field error"
       },
     }
     const validate = zodField(throwingSchema as any)
-    const result = await validate('test', {})
-    expect(result).toBe('raw zod field error')
+    const result = await validate("test", {})
+    expect(result).toBe("raw zod field error")
   })
 })
 
-describe('valibotSchema catch branch', () => {
-  it('captures Error when safeParse function throws an Error', async () => {
+describe("valibotSchema catch branch", () => {
+  it("captures Error when safeParse function throws an Error", async () => {
     const throwingParse = () => {
-      throw new Error('Valibot schema exploded')
+      throw new Error("Valibot schema exploded")
     }
     const validate = valibotSchema({}, throwingParse)
-    const result = await validate({ email: '', password: '' })
-    expect(result['' as keyof typeof result]).toBe('Valibot schema exploded')
+    const result = await validate({ email: "", password: "" })
+    expect(result["" as keyof typeof result]).toBe("Valibot schema exploded")
   })
 
-  it('captures non-Error when safeParse function throws a string', async () => {
+  it("captures non-Error when safeParse function throws a string", async () => {
     const throwingParse = () => {
-      throw 'raw valibot schema error'
+      throw "raw valibot schema error"
     }
     const validate = valibotSchema({}, throwingParse)
-    const result = await validate({ email: '', password: '' })
-    expect(result['' as keyof typeof result]).toBe('raw valibot schema error')
+    const result = await validate({ email: "", password: "" })
+    expect(result["" as keyof typeof result]).toBe("raw valibot schema error")
   })
 })
 
-describe('valibotField catch branch', () => {
-  it('captures Error when safeParse function throws an Error', async () => {
+describe("valibotField catch branch", () => {
+  it("captures Error when safeParse function throws an Error", async () => {
     const throwingParse = () => {
-      throw new Error('Valibot field exploded')
+      throw new Error("Valibot field exploded")
     }
     const validate = valibotField({}, throwingParse)
-    const result = await validate('test', {})
-    expect(result).toBe('Valibot field exploded')
+    const result = await validate("test", {})
+    expect(result).toBe("Valibot field exploded")
   })
 
-  it('captures non-Error when safeParse function throws a string', async () => {
+  it("captures non-Error when safeParse function throws a string", async () => {
     const throwingParse = () => {
-      throw 'raw valibot field error'
+      throw "raw valibot field error"
     }
     const validate = valibotField({}, throwingParse)
-    const result = await validate('test', {})
-    expect(result).toBe('raw valibot field error')
+    const result = await validate("test", {})
+    expect(result).toBe("raw valibot field error")
   })
 })
 
-describe('arktypeSchema catch branch', () => {
-  it('captures Error when schema function throws an Error', async () => {
+describe("arktypeSchema catch branch", () => {
+  it("captures Error when schema function throws an Error", async () => {
     const throwingSchema = () => {
-      throw new Error('ArkType schema exploded')
+      throw new Error("ArkType schema exploded")
     }
     const validate = arktypeSchema(throwingSchema)
-    const result = await validate({ email: '', password: '' })
-    expect(result['' as keyof typeof result]).toBe('ArkType schema exploded')
+    const result = await validate({ email: "", password: "" })
+    expect(result["" as keyof typeof result]).toBe("ArkType schema exploded")
   })
 
-  it('captures non-Error when schema function throws a string', async () => {
+  it("captures non-Error when schema function throws a string", async () => {
     const throwingSchema = () => {
-      throw 'raw arktype schema error'
+      throw "raw arktype schema error"
     }
     const validate = arktypeSchema(throwingSchema)
-    const result = await validate({ email: '', password: '' })
-    expect(result['' as keyof typeof result]).toBe('raw arktype schema error')
+    const result = await validate({ email: "", password: "" })
+    expect(result["" as keyof typeof result]).toBe("raw arktype schema error")
   })
 })
 
-describe('arktypeField catch branch', () => {
-  it('captures Error when schema function throws an Error', async () => {
+describe("arktypeField catch branch", () => {
+  it("captures Error when schema function throws an Error", async () => {
     const throwingSchema = () => {
-      throw new Error('ArkType field exploded')
+      throw new Error("ArkType field exploded")
     }
     const validate = arktypeField(throwingSchema)
-    const result = await validate('test', {})
-    expect(result).toBe('ArkType field exploded')
+    const result = await validate("test", {})
+    expect(result).toBe("ArkType field exploded")
   })
 
-  it('captures non-Error when schema function throws a string', async () => {
+  it("captures non-Error when schema function throws a string", async () => {
     const throwingSchema = () => {
-      throw 'raw arktype field error'
+      throw "raw arktype field error"
     }
     const validate = arktypeField(throwingSchema)
-    const result = await validate('test', {})
-    expect(result).toBe('raw arktype field error')
+    const result = await validate("test", {})
+    expect(result).toBe("raw arktype field error")
   })
 })
 
-describe('arktype + useForm integration', () => {
-  it('validates form with arktype schema', async () => {
+describe("arktype + useForm integration", () => {
+  it("validates form with arktype schema", async () => {
     const schema = type({
-      email: 'string.email',
-      password: 'string >= 8',
+      email: "string.email",
+      password: "string >= 8",
     })
 
     const { result: form, unmount } = mountWith(() =>
       useForm({
-        initialValues: { email: '', password: '' },
+        initialValues: { email: "", password: "" },
         schema: arktypeSchema(schema),
         onSubmit: () => {
           /* noop */

package/src/types.ts

@@ -1,8 +1,4 @@
-import type {
-  SchemaValidateFn,
-  ValidateFn,
-  ValidationError,
-} from '@pyreon/form'
+import type { SchemaValidateFn, ValidateFn, ValidationError } from "@pyreon/form"
 
 /** Re-export form types for convenience. */
 export type { SchemaValidateFn, ValidateFn, ValidationError }

package/src/utils.ts

@@ -1,5 +1,5 @@
-import type { ValidationError } from '@pyreon/form'
-import type { ValidationIssue } from './types'
+import type { ValidationError } from "@pyreon/form"
+import type { ValidationIssue } from "./types"
 
 /**
  * Convert an array of validation issues into a flat field → error record.

package/src/valibot.ts

@@ -1,10 +1,6 @@
-import type {
-  SchemaValidateFn,
-  ValidateFn,
-  ValidationError,
-} from '@pyreon/form'
-import type { ValidationIssue } from './types'
-import { issuesToRecord } from './utils'
+import type { SchemaValidateFn, ValidateFn, ValidationError } from "@pyreon/form"
+import type { ValidationIssue } from "./types"
+import { issuesToRecord } from "./utils"
 
 /**
  * Minimal Valibot-compatible interfaces so we don't require valibot as a hard dep.
@@ -35,7 +31,7 @@ type GenericSafeParseFn = Function
 
 function valibotIssuesToGeneric(issues: ValibotIssue[]): ValidationIssue[] {
   return issues.map((issue) => ({
-    path: issue.path?.map((p) => String(p.key)).join('.') ?? '',
+    path: issue.path?.map((p) => String(p.key)).join(".") ?? "",
     message: issue.message,
   }))
 }
@@ -74,14 +70,11 @@ export function valibotSchema<TValues extends Record<string, unknown>>(
   return async (values: TValues) => {
     try {
       const result = await parse(schema, values)
-      if (result.success)
-        return {} as Partial<Record<keyof TValues, ValidationError>>
-      return issuesToRecord<TValues>(
-        valibotIssuesToGeneric(result.issues ?? []),
-      )
+      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>
+      return issuesToRecord<TValues>(valibotIssuesToGeneric(result.issues ?? []))
     } catch (err) {
       return {
-        '': err instanceof Error ? err.message : String(err),
+        "": err instanceof Error ? err.message : String(err),
       } as Partial<Record<keyof TValues, ValidationError>>
     }
   }
@@ -102,10 +95,7 @@ export function valibotSchema<TValues extends Record<string, unknown>>(
  *   onSubmit: (values) => { ... },
  * })
  */
-export function valibotField<T>(
-  schema: unknown,
-  safeParseFn: GenericSafeParseFn,
-): ValidateFn<T> {
+export function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T> {
   const parse = safeParseFn as InternalParseFn
   return async (value: T) => {
     try {

package/src/zod.ts

@@ -1,10 +1,6 @@
-import type {
-  SchemaValidateFn,
-  ValidateFn,
-  ValidationError,
-} from '@pyreon/form'
-import type { ValidationIssue } from './types'
-import { issuesToRecord } from './utils'
+import type { SchemaValidateFn, ValidateFn, ValidationError } from "@pyreon/form"
+import type { ValidationIssue } from "./types"
+import { issuesToRecord } from "./utils"
 
 /**
  * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.
@@ -32,7 +28,7 @@ interface ZodSchema<T = unknown> {
 
 function zodIssuesToGeneric(issues: ZodIssue[]): ValidationIssue[] {
   return issues.map((issue) => ({
-    path: issue.path.map(String).join('.'),
+    path: issue.path.map(String).join("."),
     message: issue.message,
   }))
 }
@@ -62,12 +58,11 @@ export function zodSchema<TValues extends Record<string, unknown>>(
   return async (values: TValues) => {
     try {
       const result = await schema.safeParseAsync(values)
-      if (result.success)
-        return {} as Partial<Record<keyof TValues, ValidationError>>
+      if (result.success) return {} as Partial<Record<keyof TValues, ValidationError>>
       return issuesToRecord<TValues>(zodIssuesToGeneric(result.error!.issues))
     } catch (err) {
       return {
-        '': err instanceof Error ? err.message : String(err),
+        "": err instanceof Error ? err.message : String(err),
       } as Partial<Record<keyof TValues, ValidationError>>
     }
   }