@pyreon/validation 0.3.0 → 0.7.0

package/lib/types/index.d.ts

@@ -1,71 +1,79 @@
 import { SchemaValidateFn, SchemaValidateFn as SchemaValidateFn$1, ValidateFn, ValidateFn as ValidateFn$1, ValidationError, ValidationError as ValidationError$1 } from "@pyreon/form";
 
-//#region src/zod.d.ts
-/**
- * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.
- * These match Zod v3's public API surface.
- */
-interface ZodIssue {
-  path: PropertyKey[];
-  message: string;
-}
+//#region src/arktype.d.ts
 /**
- * Duck-typed Zod schema interface — works with both Zod v3 and v4.
- * Inlines the result shape to avoid version-specific type mismatches.
+ * Internal callable interface matching ArkType's Type.
+ * Not exposed publicly — consumers pass their ArkType schema directly.
  */
-interface ZodSchema<T = unknown> {
-  safeParse(data: unknown): {
-    success: boolean;
-    data?: T;
-    error?: {
-      issues: ZodIssue[];
-    };
-  };
-  safeParseAsync(data: unknown): Promise<{
-    success: boolean;
-    data?: T;
-    error?: {
-      issues: ZodIssue[];
-    };
-  }>;
-}
+type ArkTypeCallable = (data: unknown) => unknown;
 /**
- * Create a form-level schema validator from a Zod schema.
- * Supports both sync and async Zod schemas (uses `safeParseAsync`).
+ * Create a form-level schema validator from an ArkType schema.
+ *
+ * Accepts any callable ArkType `Type` instance. The schema is duck-typed —
+ * no ArkType import required.
  *
  * @example
- * import { z } from 'zod'
- * import { zodSchema } from '@pyreon/validation/zod'
+ * import { type } from 'arktype'
+ * import { arktypeSchema } from '@pyreon/validation/arktype'
  *
- * const schema = z.object({
- *   email: z.string().email(),
- *   password: z.string().min(8),
+ * const schema = type({
+ *   email: 'string.email',
+ *   password: 'string >= 8',
  * })
  *
  * const form = useForm({
  *   initialValues: { email: '', password: '' },
- *   schema: zodSchema(schema),
+ *   schema: arktypeSchema(schema),
  *   onSubmit: (values) => { ... },
  * })
  */
-declare function zodSchema<TValues extends Record<string, unknown>>(schema: ZodSchema<TValues>): SchemaValidateFn$1<TValues>;
+declare function arktypeSchema<TValues extends Record<string, unknown>>(schema: ArkTypeCallable): SchemaValidateFn$1<TValues>;
 /**
- * Create a single-field validator from a Zod schema.
- * Supports both sync and async Zod refinements.
+ * Create a single-field validator from an ArkType schema.
  *
  * @example
- * import { z } from 'zod'
- * import { zodField } from '@pyreon/validation/zod'
+ * import { type } from 'arktype'
+ * import { arktypeField } from '@pyreon/validation/arktype'
  *
  * const form = useForm({
  *   initialValues: { email: '' },
  *   validators: {
- *     email: zodField(z.string().email('Invalid email')),
+ *     email: arktypeField(type('string.email')),
  *   },
  *   onSubmit: (values) => { ... },
  * })
  */
-declare function zodField<T>(schema: ZodSchema<T>): ValidateFn$1<T>;
+declare function arktypeField<T>(schema: ArkTypeCallable): ValidateFn$1<T>;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Generic issue produced by any schema library.
+ * Adapters normalize library-specific errors into this shape.
+ */
+interface ValidationIssue {
+  /** Dot-separated field path (e.g. "address.city"). */
+  path: string;
+  /** Human-readable error message. */
+  message: string;
+}
+/**
+ * A generic schema adapter transforms library-specific parse results
+ * into a flat record of field → error message.
+ */
+type SchemaAdapter<TSchema> = <TValues extends Record<string, unknown>>(schema: TSchema) => SchemaValidateFn<TValues>;
+/**
+ * A generic field adapter transforms a library-specific schema
+ * into a single-field validator function.
+ */
+type FieldAdapter<TSchema> = <T>(schema: TSchema) => ValidateFn<T>;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Convert an array of validation issues into a flat field → error record.
+ * For nested paths like ["address", "city"], produces "address.city".
+ * When multiple issues exist for the same path, the first message wins.
+ */
+declare function issuesToRecord<TValues extends Record<string, unknown>>(issues: ValidationIssue[]): Partial<Record<keyof TValues, ValidationError$1>>;
 //#endregion
 //#region src/valibot.d.ts
 /**
@@ -114,82 +122,72 @@ declare function valibotSchema<TValues extends Record<string, unknown>>(schema:
  */
 declare function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn$1<T>;
 //#endregion
-//#region src/arktype.d.ts
+//#region src/zod.d.ts
 /**
- * Internal callable interface matching ArkType's Type.
- * Not exposed publicly — consumers pass their ArkType schema directly.
+ * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.
+ * These match Zod v3's public API surface.
  */
-interface ArkTypeCallable {
-  (data: unknown): unknown;
+interface ZodIssue {
+  path: PropertyKey[];
+  message: string;
 }
 /**
- * Create a form-level schema validator from an ArkType schema.
- *
- * Accepts any callable ArkType `Type` instance. The schema is duck-typed —
- * no ArkType import required.
+ * Duck-typed Zod schema interface — works with both Zod v3 and v4.
+ * Inlines the result shape to avoid version-specific type mismatches.
+ */
+interface ZodSchema<T = unknown> {
+  safeParse(data: unknown): {
+    success: boolean;
+    data?: T;
+    error?: {
+      issues: ZodIssue[];
+    };
+  };
+  safeParseAsync(data: unknown): Promise<{
+    success: boolean;
+    data?: T;
+    error?: {
+      issues: ZodIssue[];
+    };
+  }>;
+}
+/**
+ * Create a form-level schema validator from a Zod schema.
+ * Supports both sync and async Zod schemas (uses `safeParseAsync`).
  *
  * @example
- * import { type } from 'arktype'
- * import { arktypeSchema } from '@pyreon/validation/arktype'
+ * import { z } from 'zod'
+ * import { zodSchema } from '@pyreon/validation/zod'
  *
- * const schema = type({
- *   email: 'string.email',
- *   password: 'string >= 8',
+ * const schema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(8),
  * })
  *
  * const form = useForm({
  *   initialValues: { email: '', password: '' },
- *   schema: arktypeSchema(schema),
+ *   schema: zodSchema(schema),
  *   onSubmit: (values) => { ... },
  * })
  */
-declare function arktypeSchema<TValues extends Record<string, unknown>>(schema: ArkTypeCallable): SchemaValidateFn$1<TValues>;
+declare function zodSchema<TValues extends Record<string, unknown>>(schema: ZodSchema<TValues>): SchemaValidateFn$1<TValues>;
 /**
- * Create a single-field validator from an ArkType schema.
+ * Create a single-field validator from a Zod schema.
+ * Supports both sync and async Zod refinements.
  *
  * @example
- * import { type } from 'arktype'
- * import { arktypeField } from '@pyreon/validation/arktype'
+ * import { z } from 'zod'
+ * import { zodField } from '@pyreon/validation/zod'
  *
  * const form = useForm({
  *   initialValues: { email: '' },
  *   validators: {
- *     email: arktypeField(type('string.email')),
+ *     email: zodField(z.string().email('Invalid email')),
  *   },
  *   onSubmit: (values) => { ... },
  * })
  */
-declare function arktypeField<T>(schema: ArkTypeCallable): ValidateFn$1<T>;
-//#endregion
-//#region src/types.d.ts
-/**
- * Generic issue produced by any schema library.
- * Adapters normalize library-specific errors into this shape.
- */
-interface ValidationIssue {
-  /** Dot-separated field path (e.g. "address.city"). */
-  path: string;
-  /** Human-readable error message. */
-  message: string;
-}
-/**
- * A generic schema adapter transforms library-specific parse results
- * into a flat record of field → error message.
- */
-type SchemaAdapter<TSchema> = <TValues extends Record<string, unknown>>(schema: TSchema) => SchemaValidateFn<TValues>;
-/**
- * A generic field adapter transforms a library-specific schema
- * into a single-field validator function.
- */
-type FieldAdapter<TSchema> = <T>(schema: TSchema) => ValidateFn<T>;
-//#endregion
-//#region src/utils.d.ts
-/**
- * Convert an array of validation issues into a flat field → error record.
- * For nested paths like ["address", "city"], produces "address.city".
- * When multiple issues exist for the same path, the first message wins.
- */
-declare function issuesToRecord<TValues extends Record<string, unknown>>(issues: ValidationIssue[]): Partial<Record<keyof TValues, ValidationError$1>>;
+declare function zodField<T>(schema: ZodSchema<T>): ValidateFn$1<T>;
 //#endregion
 export { type FieldAdapter, type SchemaAdapter, type SchemaValidateFn, type ValidateFn, type ValidationError, type ValidationIssue, arktypeField, arktypeSchema, issuesToRecord, valibotField, valibotSchema, zodField, zodSchema };
 //# sourceMappingURL=index2.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index2.d.ts","names":[],"sources":["../../src/zod.ts","../../src/valibot.ts","../../src/arktype.ts","../../src/types.ts","../../src/utils.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,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;AA+BpB;;;;iBAAgB,QAAA,GAAA,CAAY,MAAA,EAAQ,SAAA,CAAU,CAAA,IAAK,YAAA,CAAW,CAAA;;;;;AAvFzC;;;;KC6BhB,kBAAA,GAAqB,QAAA;;;;;ADnBjB;;;;;;;;;;;;;;;;;iBCsDO,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;ADbpB;;;iBC8CgB,YAAA,GAAA,CACd,MAAA,WACA,WAAA,EAAa,kBAAA,GACZ,YAAA,CAAW,CAAA;;;;;ADvGO;;UEoBX,eAAA;EAAA,CACP,IAAA;AAAA;;;;;AFXM;;;;;;;;;;;;;;;;;iBE8CO,aAAA,iBAA8B,MAAA,kBAAA,CAC5C,MAAA,EAAQ,eAAA,GACP,kBAAA,CAAiB,OAAA;;;;;;;;;;;;;AFJpB;;;iBEkCgB,YAAA,GAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,YAAA,CAAW,CAAA;;;AFxFhD;;;;AAAA,UGSJ,eAAA;EHAT;EGEN,IAAA;EHDO;EGGP,OAAA;AAAA;;;;;KAOU,aAAA,6BAA0C,MAAA,mBACpD,MAAA,EAAQ,OAAA,KACL,gBAAA,CAAiB,OAAA;;;;;KAMV,YAAA,gBAA4B,MAAA,EAAQ,OAAA,KAAY,UAAA,CAAW,CAAA;;;;AH5BlD;;;;iBIIL,cAAA,iBAA+B,MAAA,kBAAA,CAC7C,MAAA,EAAQ,eAAA,KACP,OAAA,CAAQ,MAAA,OAAa,OAAA,EAAS,iBAAA"}
+{"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"}

package/lib/types/valibot.d.ts

@@ -1,89 +1,51 @@
-//#region src/utils.ts
-/**
-* Convert an array of validation issues into a flat field → error record.
-* For nested paths like ["address", "city"], produces "address.city".
-* When multiple issues exist for the same path, the first message wins.
-*/
-function issuesToRecord(issues) {
-  const errors = {};
-  for (const issue of issues) {
-    const key = issue.path;
-    if (errors[key] === void 0) errors[key] = issue.message;
-  }
-  return errors;
-}
+import { SchemaValidateFn, ValidateFn } from "@pyreon/form";
 
-//#endregion
-//#region src/valibot.ts
-function valibotIssuesToGeneric(issues) {
-  return issues.map(issue => ({
-    path: issue.path?.map(p => String(p.key)).join(".") ?? "",
-    message: issue.message
-  }));
-}
+//#region src/valibot.d.ts
 /**
-* Create a form-level schema validator from a Valibot schema.
-*
-* Valibot uses standalone functions rather than methods, so you must pass
-* the `safeParseAsync` (or `safeParse`) function from valibot.
-*
-* @example
-* import * as v from 'valibot'
-* import { valibotSchema } from '@pyreon/validation/valibot'
-*
-* const schema = v.object({
-*   email: v.pipe(v.string(), v.email()),
-*   password: v.pipe(v.string(), v.minLength(8)),
-* })
-*
-* const form = useForm({
-*   initialValues: { email: '', password: '' },
-*   schema: valibotSchema(schema, v.safeParseAsync),
-*   onSubmit: (values) => { ... },
-* })
-*/
-function valibotSchema(schema, safeParseFn) {
-  const parse = safeParseFn;
-  return async values => {
-    try {
-      const result = await parse(schema, values);
-      if (result.success) return {};
-      return issuesToRecord(valibotIssuesToGeneric(result.issues ?? []));
-    } catch (err) {
-      return {
-        "": err instanceof Error ? err.message : String(err)
-      };
-    }
-  };
-}
+ * Any function that takes (schema, input, ...rest) and returns a parse result.
+ * Valibot's safeParse/safeParseAsync have generic constraints on the schema
+ * parameter that can't be expressed without importing Valibot types. We accept
+ * any callable and cast internally.
+ */
+type GenericSafeParseFn = Function;
 /**
-* Create a single-field validator from a Valibot schema.
-*
-* @example
-* import * as v from 'valibot'
-* import { valibotField } from '@pyreon/validation/valibot'
-*
-* const form = useForm({
-*   initialValues: { email: '' },
-*   validators: {
-*     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),
-*   },
-*   onSubmit: (values) => { ... },
-* })
-*/
-function valibotField(schema, safeParseFn) {
-  const parse = safeParseFn;
-  return async value => {
-    try {
-      const result = await parse(schema, value);
-      if (result.success) return void 0;
-      return result.issues?.[0]?.message;
-    } catch (err) {
-      return err instanceof Error ? err.message : String(err);
-    }
-  };
-}
-
+ * Create a form-level schema validator from a Valibot schema.
+ *
+ * Valibot uses standalone functions rather than methods, so you must pass
+ * the `safeParseAsync` (or `safeParse`) function from valibot.
+ *
+ * @example
+ * import * as v from 'valibot'
+ * import { valibotSchema } from '@pyreon/validation/valibot'
+ *
+ * const schema = v.object({
+ *   email: v.pipe(v.string(), v.email()),
+ *   password: v.pipe(v.string(), v.minLength(8)),
+ * })
+ *
+ * const form = useForm({
+ *   initialValues: { email: '', password: '' },
+ *   schema: valibotSchema(schema, v.safeParseAsync),
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function valibotSchema<TValues extends Record<string, unknown>>(schema: unknown, safeParseFn: GenericSafeParseFn): SchemaValidateFn<TValues>;
+/**
+ * Create a single-field validator from a Valibot schema.
+ *
+ * @example
+ * import * as v from 'valibot'
+ * import { valibotField } from '@pyreon/validation/valibot'
+ *
+ * const form = useForm({
+ *   initialValues: { email: '' },
+ *   validators: {
+ *     email: valibotField(v.pipe(v.string(), v.email('Invalid email')), v.safeParseAsync),
+ *   },
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function valibotField<T>(schema: unknown, safeParseFn: GenericSafeParseFn): ValidateFn<T>;
 //#endregion
 export { valibotField, valibotSchema };
-//# sourceMappingURL=valibot.d.ts.map
+//# sourceMappingURL=valibot2.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"valibot.d.ts","names":[],"sources":["../../src/utils.ts","../../src/valibot.ts"],"mappings":";;;;;;AAQA,SAAgB,cAAA,CACd,MAAA,EACiD;EACjD,MAAM,MAAA,GAAS,CAAA,CAAE;EACjB,KAAK,MAAM,KAAA,IAAS,MAAA,EAAQ;IAC1B,MAAM,GAAA,GAAM,KAAA,CAAM,IAAA;IAElB,IAAI,MAAA,CAAO,GAAA,CAAA,KAAS,KAAA,CAAA,EAClB,MAAA,CAAO,GAAA,CAAA,GAAO,KAAA,CAAM,OAAA;;EAGxB,OAAO,MAAA;;;;;ACgBT,SAAS,sBAAA,CAAuB,MAAA,EAA2C;EACzE,OAAO,MAAA,CAAO,GAAA,CAAK,KAAA,KAAW;IAC5B,IAAA,EAAM,KAAA,CAAM,IAAA,EAAM,GAAA,CAAK,CAAA,IAAM,MAAA,CAAO,CAAA,CAAE,GAAA,CAAI,CAAC,CAAC,IAAA,CAAK,GAAA,CAAI,IAAI,EAAA;IACzD,OAAA,EAAS,KAAA,CAAM;GAChB,CAAA,CAAE;;;;;;;;;;;;;;;;;;;;;;;AA6BL,SAAgB,aAAA,CACd,MAAA,EACA,WAAA,EAC2B;EAC3B,MAAM,KAAA,GAAQ,WAAA;EACd,OAAO,MAAO,MAAA,IAAoB;IAChC,IAAI;MACF,MAAM,MAAA,GAAS,MAAM,KAAA,CAAM,MAAA,EAAQ,MAAA,CAAO;MAC1C,IAAI,MAAA,CAAO,OAAA,EACT,OAAO,CAAA,CAAE;MACX,OAAO,cAAA,CACL,sBAAA,CAAuB,MAAA,CAAO,MAAA,IAAU,EAAE,CAAC,CAC5C;aACM,GAAA,EAAK;MACZ,OAAO;QACL,EAAA,EAAI,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA;MAAI,CACrD;;;;;;;;;;;;;;;;;;;AAoBP,SAAgB,YAAA,CACd,MAAA,EACA,WAAA,EACe;EACf,MAAM,KAAA,GAAQ,WAAA;EACd,OAAO,MAAO,KAAA,IAAa;IACzB,IAAI;MACF,MAAM,MAAA,GAAS,MAAM,KAAA,CAAM,MAAA,EAAQ,KAAA,CAAM;MACzC,IAAI,MAAA,CAAO,OAAA,EAAS,OAAO,KAAA,CAAA;MAC3B,OAAO,MAAA,CAAO,MAAA,GAAS,CAAA,CAAA,EAAI,OAAA;aACpB,GAAA,EAAK;MACZ,OAAO,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA,CAAI"}
+{"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"}

package/lib/types/zod.d.ts

@@ -1,86 +1,71 @@
-//#region src/utils.ts
-/**
-* Convert an array of validation issues into a flat field → error record.
-* For nested paths like ["address", "city"], produces "address.city".
-* When multiple issues exist for the same path, the first message wins.
-*/
-function issuesToRecord(issues) {
-  const errors = {};
-  for (const issue of issues) {
-    const key = issue.path;
-    if (errors[key] === void 0) errors[key] = issue.message;
-  }
-  return errors;
-}
+import { SchemaValidateFn, ValidateFn } from "@pyreon/form";
 
-//#endregion
-//#region src/zod.ts
-function zodIssuesToGeneric(issues) {
-  return issues.map(issue => ({
-    path: issue.path.map(String).join("."),
-    message: issue.message
-  }));
-}
+//#region src/zod.d.ts
 /**
-* Create a form-level schema validator from a Zod schema.
-* Supports both sync and async Zod schemas (uses `safeParseAsync`).
-*
-* @example
-* import { z } from 'zod'
-* import { zodSchema } from '@pyreon/validation/zod'
-*
-* const schema = z.object({
-*   email: z.string().email(),
-*   password: z.string().min(8),
-* })
-*
-* const form = useForm({
-*   initialValues: { email: '', password: '' },
-*   schema: zodSchema(schema),
-*   onSubmit: (values) => { ... },
-* })
-*/
-function zodSchema(schema) {
-  return async values => {
-    try {
-      const result = await schema.safeParseAsync(values);
-      if (result.success) return {};
-      return issuesToRecord(zodIssuesToGeneric(result.error.issues));
-    } catch (err) {
-      return {
-        "": err instanceof Error ? err.message : String(err)
-      };
-    }
-  };
+ * Minimal Zod-compatible interfaces so we don't require zod as a hard dep.
+ * These match Zod v3's public API surface.
+ */
+interface ZodIssue {
+  path: PropertyKey[];
+  message: string;
 }
 /**
-* Create a single-field validator from a Zod schema.
-* Supports both sync and async Zod refinements.
-*
-* @example
-* import { z } from 'zod'
-* import { zodField } from '@pyreon/validation/zod'
-*
-* const form = useForm({
-*   initialValues: { email: '' },
-*   validators: {
-*     email: zodField(z.string().email('Invalid email')),
-*   },
-*   onSubmit: (values) => { ... },
-* })
-*/
-function zodField(schema) {
-  return async value => {
-    try {
-      const result = await schema.safeParseAsync(value);
-      if (result.success) return void 0;
-      return result.error.issues[0]?.message;
-    } catch (err) {
-      return err instanceof Error ? err.message : String(err);
-    }
+ * Duck-typed Zod schema interface — works with both Zod v3 and v4.
+ * Inlines the result shape to avoid version-specific type mismatches.
+ */
+interface ZodSchema<T = unknown> {
+  safeParse(data: unknown): {
+    success: boolean;
+    data?: T;
+    error?: {
+      issues: ZodIssue[];
+    };
   };
+  safeParseAsync(data: unknown): Promise<{
+    success: boolean;
+    data?: T;
+    error?: {
+      issues: ZodIssue[];
+    };
+  }>;
 }
-
+/**
+ * Create a form-level schema validator from a Zod schema.
+ * Supports both sync and async Zod schemas (uses `safeParseAsync`).
+ *
+ * @example
+ * import { z } from 'zod'
+ * import { zodSchema } from '@pyreon/validation/zod'
+ *
+ * const schema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(8),
+ * })
+ *
+ * const form = useForm({
+ *   initialValues: { email: '', password: '' },
+ *   schema: zodSchema(schema),
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function zodSchema<TValues extends Record<string, unknown>>(schema: ZodSchema<TValues>): SchemaValidateFn<TValues>;
+/**
+ * Create a single-field validator from a Zod schema.
+ * Supports both sync and async Zod refinements.
+ *
+ * @example
+ * import { z } from 'zod'
+ * import { zodField } from '@pyreon/validation/zod'
+ *
+ * const form = useForm({
+ *   initialValues: { email: '' },
+ *   validators: {
+ *     email: zodField(z.string().email('Invalid email')),
+ *   },
+ *   onSubmit: (values) => { ... },
+ * })
+ */
+declare function zodField<T>(schema: ZodSchema<T>): ValidateFn<T>;
 //#endregion
 export { zodField, zodSchema };
-//# sourceMappingURL=zod.d.ts.map
+//# sourceMappingURL=zod2.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"zod.d.ts","names":[],"sources":["../../src/utils.ts","../../src/zod.ts"],"mappings":";;;;;;AAQA,SAAgB,cAAA,CACd,MAAA,EACiD;EACjD,MAAM,MAAA,GAAS,CAAA,CAAE;EACjB,KAAK,MAAM,KAAA,IAAS,MAAA,EAAQ;IAC1B,MAAM,GAAA,GAAM,KAAA,CAAM,IAAA;IAElB,IAAI,MAAA,CAAO,GAAA,CAAA,KAAS,KAAA,CAAA,EAClB,MAAA,CAAO,GAAA,CAAA,GAAO,KAAA,CAAM,OAAA;;EAGxB,OAAO,MAAA;;;;;ACaT,SAAS,kBAAA,CAAmB,MAAA,EAAuC;EACjE,OAAO,MAAA,CAAO,GAAA,CAAK,KAAA,KAAW;IAC5B,IAAA,EAAM,KAAA,CAAM,IAAA,CAAK,GAAA,CAAI,MAAA,CAAO,CAAC,IAAA,CAAK,GAAA,CAAI;IACtC,OAAA,EAAS,KAAA,CAAM;GAChB,CAAA,CAAE;;;;;;;;;;;;;;;;;;;;;AAsBL,SAAgB,SAAA,CACd,MAAA,EAC2B;EAC3B,OAAO,MAAO,MAAA,IAAoB;IAChC,IAAI;MACF,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,cAAA,CAAe,MAAA,CAAO;MAClD,IAAI,MAAA,CAAO,OAAA,EACT,OAAO,CAAA,CAAE;MACX,OAAO,cAAA,CAAwB,kBAAA,CAAmB,MAAA,CAAO,KAAA,CAAO,MAAA,CAAO,CAAC;aACjE,GAAA,EAAK;MACZ,OAAO;QACL,EAAA,EAAI,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA;MAAI,CACrD;;;;;;;;;;;;;;;;;;;;AAqBP,SAAgB,QAAA,CAAY,MAAA,EAAqC;EAC/D,OAAO,MAAO,KAAA,IAAa;IACzB,IAAI;MACF,MAAM,MAAA,GAAS,MAAM,MAAA,CAAO,cAAA,CAAe,KAAA,CAAM;MACjD,IAAI,MAAA,CAAO,OAAA,EAAS,OAAO,KAAA,CAAA;MAC3B,OAAO,MAAA,CAAO,KAAA,CAAO,MAAA,CAAO,CAAA,CAAA,EAAI,OAAA;aACzB,GAAA,EAAK;MACZ,OAAO,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,MAAA,CAAO,GAAA,CAAI"}
+{"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/validation",
-  "version": "0.3.0",
+  "version": "0.7.0",
   "description": "Schema validation adapters for Pyreon forms (Zod, Valibot, ArkType)",
   "license": "MIT",
   "repository": {
@@ -55,7 +55,7 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@pyreon/form": "^0.3.0"
+    "@pyreon/form": "^0.7.0"
   },
   "peerDependenciesMeta": {
     "zod": {

package/src/arktype.ts

@@ -22,9 +22,7 @@ interface ArkErrors extends Array<ArkError> {
  * Internal callable interface matching ArkType's Type.
  * Not exposed publicly — consumers pass their ArkType schema directly.
  */
-interface ArkTypeCallable {
-  (data: unknown): unknown
-}
+type ArkTypeCallable = (data: unknown) => unknown
 
 function isArkErrors(result: unknown): result is ArkErrors {
   return Array.isArray(result) && 'summary' in (result as object)

package/src/index.ts

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

package/src/tests/{validation.test.ts → validation.test.tsx}

@@ -1,25 +1,30 @@
-import { z } from 'zod'
-import * as v from 'valibot'
-import { type } from 'arktype'
-import { h } from '@pyreon/core'
-import { mount } from '@pyreon/runtime-dom'
 import { useForm } from '@pyreon/form'
-import { zodSchema, zodField } from '../zod'
-import { valibotSchema, valibotField } from '../valibot'
-import { arktypeSchema, arktypeField } from '../arktype'
+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 ──────────────────────────────────────────────────────────────────
 
+function Capture<T>({ fn }: { fn: () => T }) {
+  fn()
+  return null
+}
+
 function mountWith<T>(fn: () => T): { result: T; unmount: () => void } {
   let result: T | undefined
   const el = document.createElement('div')
   document.body.appendChild(el)
   const unmount = mount(
-    h(() => {
-      result = fn()
-      return null
-    }, null),
+    <Capture
+      fn={() => {
+        result = fn()
+      }}
+    />,
     el,
   )
   return {