@hookform/resolvers 5.9.2 → 6.0.1

package/README.md

@@ -1,7 +1,7 @@
 <div align="center">
     <p align="center">
         <a href="https://react-hook-form.com" title="React Hook Form - Simple React forms validation">
-            <img src="https://raw.githubusercontent.com/bluebill1049/react-hook-form/master/docs/logo.png" alt="React Hook Form Logo - React hook custom hook for form validation" />
+            <img src="https://react-hook-form.com/images/react-hook-form-og.png" alt="React Hook Form Logo - React hook custom hook for form validation" />
         </a>
     </p>
 </div>
@@ -782,7 +782,7 @@ const App = () => {
 
 ### [effect-ts](https://github.com/Effect-TS/effect)
 
-A powerful TypeScript framework that provides a fully-fledged functional effect system with a rich standard library.
+A powerful TypeScript framework that provides a fully-fledged functional effect system with a rich standard library. Requires `effect` v4 (use `@hookform/resolvers` v5 for `effect` v3).
 
 [![npm](https://img.shields.io/bundlephobia/minzip/effect?style=for-the-badge)](https://bundlephobia.com/result?p=effect)
 
@@ -793,11 +793,11 @@ import { effectTsResolver } from '@hookform/resolvers/effect-ts';
 import { Schema } from 'effect';
 
 const schema = Schema.Struct({
-  username: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => 'username required' }),
+  username: Schema.String.check(
+    Schema.isNonEmpty({ message: 'username required' }),
   ),
-  password: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => 'password required' }),
+  password: Schema.String.check(
+    Schema.isNonEmpty({ message: 'password required' }),
   ),
 });
 

package/effect-ts/dist/effect-ts.d.ts

@@ -1,11 +1,11 @@
 import { Schema } from 'effect';
-import { ParseOptions } from 'effect/SchemaAST';
+import type { ParseOptions } from 'effect/SchemaAST';
 import { FieldValues, Resolver } from 'react-hook-form';
-export declare function effectTsResolver<Input extends FieldValues, Context, Output>(schema: Schema.Schema<Output, Input>, schemaOptions?: ParseOptions, resolverOptions?: {
+export declare function effectTsResolver<Input extends FieldValues, Context, Output>(schema: Schema.Codec<Output, Input, never, unknown>, schemaOptions?: ParseOptions, resolverOptions?: {
     mode?: 'async' | 'sync';
     raw?: false;
 }): Resolver<Input, Context, Output>;
-export declare function effectTsResolver<Input extends FieldValues, Context, Output>(schema: Schema.Schema<Output, Input>, schemaOptions: ParseOptions | undefined, resolverOptions: {
+export declare function effectTsResolver<Input extends FieldValues, Context, Output>(schema: Schema.Codec<Output, Input, never, unknown>, schemaOptions: ParseOptions | undefined, resolverOptions: {
     mode?: 'async' | 'sync';
     raw: true;
 }): Resolver<Input, Context, Input>;

package/effect-ts/dist/effect-ts.js

@@ -1,2 +1,2 @@
-var e=require("@hookform/resolvers"),r=require("effect"),t=require("effect/ParseResult"),n=require("react-hook-form");exports.effectTsResolver=function(o,a){return void 0===a&&(a={errors:"all",onExcessProperty:"ignore"}),function(s,c,f){return t.decodeUnknown(o,a)(s).pipe(r.Effect.catchAll(function(e){return r.Effect.flip(t.ArrayFormatter.formatIssue(e))}),r.Effect.mapError(function(r){var t=!f.shouldUseNativeValidation&&"all"===f.criteriaMode,o=r.reduce(function(e,r){var o=r.path.join(".");if(e[o]||(e[o]={message:r.message,type:r._tag}),t){var a=e[o].types,s=a&&a[String(r._tag)];e[o]=n.appendErrors(o,t,e,r._tag,s?[].concat(s,r.message):r.message)}return e},Object.create(null));return e.toNestErrors(o,f)}),r.Effect.tap(function(){return r.Effect.sync(function(){return f.shouldUseNativeValidation&&e.validateFieldsNatively({},f)})}),r.Effect.match({onFailure:function(e){return{errors:e,values:{}}},onSuccess:function(e){return{errors:{},values:e}}}),r.Effect.runPromise)}};
+var e=require("@hookform/resolvers"),r=require("effect"),t=require("react-hook-form"),s=r.SchemaIssue.makeFormatterStandardSchemaV1(),a=function(e,r){switch(e._tag){case"Pointer":return a(e.issue,[].concat(r,e.path));case"Encoding":return a(e.issue,r);case"Composite":case"AnyOf":if(e.issues.length)return e.issues.flatMap(function(e){return a(e,r)})}return s(e).issues.map(function(t){return{path:[].concat(r,t.path||[]),message:t.message,type:e._tag}})};exports.effectTsResolver=function(s,n){return void 0===n&&(n={errors:"all",onExcessProperty:"ignore"}),function(o,i,c){return r.Schema.decodeUnknownEffect(s)(o,n).pipe(r.Effect.match({onFailure:function(r){var s=!c.shouldUseNativeValidation&&"all"===c.criteriaMode,n=a(r.issue,[]).reduce(function(e,r){var a=r.path.join(".");if(e[a]||(e[a]={message:r.message,type:r.type}),s){var n=e[a].types,o=n&&n[r.type];e[a]=t.appendErrors(a,s,e,r.type,o?[].concat(o,r.message):r.message)}return e},Object.create(null));return{errors:e.toNestErrors(n,c),values:{}}},onSuccess:function(r){return c.shouldUseNativeValidation&&e.validateFieldsNatively({},c),{errors:{},values:r}}}),r.Effect.runPromise)}};
 //# sourceMappingURL=effect-ts.js.map

package/effect-ts/dist/effect-ts.js.map

@@ -1 +1 @@
-{"version":3,"file":"effect-ts.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        // A null-prototype accumulator avoids false-positive hits from\n        // inherited members (e.g. `toString`, `constructor`) when a field\n        // is named after one of them — a plain `{}` would make `!acc[key]`\n        // truthy-skip those paths and silently drop their errors.\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          Object.create(null) as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","Object","create","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"wJA6CEA,EACAC,GAEA,YAF8B,IAA9BA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,oBAEzDC,EAAQC,EAAGC,GACjB,OAAOC,EAAaA,cAClBP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAMA,OAACC,SAAS,SAACC,GACf,OAAAF,EAAAA,OAAOG,KAAKC,EAAcA,eAACC,YAAYH,GAAY,GAErDF,EAAMA,OAACM,SAAS,SAACC,GACf,IAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAM1CjB,EAASc,EAAOI,OACpB,SAACC,EAAKC,GACJ,IAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,IAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,eACTT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,CACT,EACAa,OAAOC,OAAO,OAGhB,OAAOC,eAAalC,EAAQI,EAC9B,GACAG,SAAO4B,IAAI,WACT,OAAA5B,EAAAA,OAAO6B,KACL,WACE,OAAAhC,EAAQY,2BACRqB,EAAsBA,uBAAC,GAAIjC,EAAQ,EACtC,GAEHG,EAAAA,OAAO+B,MAAM,CACXC,UAAW,SAACvC,GAAM,MAAM,CAAEA,OAAAA,EAAQE,OAAQ,GAAI,EAC9CsC,UAAW,SAACC,GAAM,MAAM,CAAEzC,OAAQ,CAAE,EAAEE,OAAQuC,EAAQ,IAExDlC,EAAMA,OAACmC,WAEX,CACF"}
+{"version":3,"file":"effect-ts.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema, SchemaIssue } from 'effect';\nimport type { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\ntype Issue = { path: PropertyKey[]; message: string; type: string };\n\nconst formatIssue = SchemaIssue.makeFormatterStandardSchemaV1();\n\n// Flattens the issue tree like `makeFormatterStandardSchemaV1` does, but keeps\n// the `_tag` of the failing node so it can be reported as the error `type`.\nconst flattenIssue = (\n  issue: SchemaIssue.Issue,\n  path: PropertyKey[],\n): Issue[] => {\n  switch (issue._tag) {\n    case 'Pointer':\n      return flattenIssue(issue.issue, [...path, ...issue.path]);\n    case 'Encoding':\n      return flattenIssue(issue.issue, path);\n    case 'Composite':\n    case 'AnyOf':\n      if (issue.issues.length) {\n        return issue.issues.flatMap((issue) => flattenIssue(issue, path));\n      }\n  }\n\n  return formatIssue(issue).issues.map((error) => ({\n    path: [...path, ...(error.path || [])] as PropertyKey[],\n    message: error.message,\n    type: issue._tag,\n  }));\n};\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect Schema validation\n * @param {Schema.Codec<Output, Input>} schema - The Effect schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect Schema parse options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) =>\n    Schema.decodeUnknownEffect(schema)(values, schemaOptions).pipe(\n      Effect.match({\n        onFailure: ({ issue }) => {\n          const validateAllFieldCriteria =\n            !options.shouldUseNativeValidation &&\n            options.criteriaMode === 'all';\n\n          // A null-prototype accumulator avoids false-positive hits from\n          // inherited members (e.g. `toString`, `constructor`) when a field\n          // is named after one of them — a plain `{}` would make `!acc[key]`\n          // truthy-skip those paths and silently drop their errors.\n          const errors = flattenIssue(issue, []).reduce(\n            (acc, error) => {\n              const key = error.path.join('.');\n\n              if (!acc[key]) {\n                acc[key] = { message: error.message, type: error.type };\n              }\n\n              if (validateAllFieldCriteria) {\n                const types = acc[key].types;\n                const messages = types && types[error.type];\n\n                acc[key] = appendErrors(\n                  key,\n                  validateAllFieldCriteria,\n                  acc,\n                  error.type,\n                  messages\n                    ? ([] as string[]).concat(\n                        messages as string[],\n                        error.message,\n                      )\n                    : error.message,\n                ) as FieldError;\n              }\n\n              return acc;\n            },\n            Object.create(null) as Record<string, FieldError>,\n          );\n\n          return { errors: toNestErrors(errors, options), values: {} };\n        },\n        onSuccess: (result) => {\n          options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options);\n\n          return { errors: {}, values: result };\n        },\n      }),\n      Effect.runPromise,\n    );\n}\n"],"names":["formatIssue","SchemaIssue","makeFormatterStandardSchemaV1","flattenIssue","issue","path","_tag","concat","issues","length","flatMap","map","error","message","type","schema","schemaOptions","errors","onExcessProperty","values","_","options","Schema","decodeUnknownEffect","pipe","Effect","match","onFailure","_ref","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","key","join","types","messages","appendErrors","Object","create","toNestErrors","onSuccess","result","validateFieldsNatively","runPromise"],"mappings":"sFAYMA,EAAcC,EAAWA,YAACC,gCAI1BC,EAAe,SACnBC,EACAC,GAEA,OAAQD,EAAME,MACZ,IAAK,UACH,OAAOH,EAAaC,EAAMA,MAAK,GAAAG,OAAMF,EAASD,EAAMC,OACtD,IAAK,WACH,OAAOF,EAAaC,EAAMA,MAAOC,GACnC,IAAK,YACL,IAAK,QACH,GAAID,EAAMI,OAAOC,OACf,OAAOL,EAAMI,OAAOE,QAAQ,SAACN,GAAK,OAAKD,EAAaC,EAAOC,EAAK,GAItE,OAAOL,EAAYI,GAAOI,OAAOG,IAAI,SAACC,GAAW,MAAA,CAC/CP,KAAI,GAAAE,OAAMF,EAAUO,EAAMP,MAAQ,IAClCQ,QAASD,EAAMC,QACfC,KAAMV,EAAME,KACb,EACH,2BAmCgB,SACdS,EACAC,GAEA,YAF8B,IAA9BA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAE1D,SAACC,EAAQC,EAAGC,GACjB,OAAAC,EAAMA,OAACC,oBAAoBR,EAA3BO,CAAmCH,EAAQH,GAAeQ,KACxDC,EAAAA,OAAOC,MAAM,CACXC,UAAW,SAAFC,GAAgB,IACjBC,GACHR,EAAQS,2BACgB,QAAzBT,EAAQU,aAMJd,EAASd,EATEyB,EAALxB,MASuB,IAAI4B,OACrC,SAACC,EAAKrB,GACJ,IAAMsB,EAAMtB,EAAMP,KAAK8B,KAAK,KAM5B,GAJKF,EAAIC,KACPD,EAAIC,GAAO,CAAErB,QAASD,EAAMC,QAASC,KAAMF,EAAME,OAG/Ce,EAA0B,CAC5B,IAAMO,EAAQH,EAAIC,GAAKE,MACjBC,EAAWD,GAASA,EAAMxB,EAAME,MAEtCmB,EAAIC,GAAOI,eACTJ,EACAL,EACAI,EACArB,EAAME,KACNuB,EACK,GAAgB9B,OACf8B,EACAzB,EAAMC,SAERD,EAAMC,QAEd,CAEA,OAAOoB,CACT,EACAM,OAAOC,OAAO,OAGhB,MAAO,CAAEvB,OAAQwB,EAAYA,aAACxB,EAAQI,GAAUF,OAAQ,GAC1D,EACAuB,UAAW,SAACC,GAIV,OAHAtB,EAAQS,2BACNc,EAAsBA,uBAAC,GAAIvB,GAEtB,CAAEJ,OAAQ,CAAE,EAAEE,OAAQwB,EAC/B,IAEFlB,SAAOoB,WACR,CACL"}

package/effect-ts/dist/effect-ts.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{Effect as t}from"effect";import{decodeUnknown as o,ArrayFormatter as n}from"effect/ParseResult";import{appendErrors as a}from"react-hook-form";function i(i,s){return void 0===s&&(s={errors:"all",onExcessProperty:"ignore"}),function(u,c,f){return o(i,s)(u).pipe(t.catchAll(function(r){return t.flip(n.formatIssue(r))}),t.mapError(function(e){var t=!f.shouldUseNativeValidation&&"all"===f.criteriaMode,o=e.reduce(function(r,e){var o=e.path.join(".");if(r[o]||(r[o]={message:e.message,type:e._tag}),t){var n=r[o].types,i=n&&n[String(e._tag)];r[o]=a(o,t,r,e._tag,i?[].concat(i,e.message):e.message)}return r},Object.create(null));return r(o,f)}),t.tap(function(){return t.sync(function(){return f.shouldUseNativeValidation&&e({},f)})}),t.match({onFailure:function(r){return{errors:r,values:{}}},onSuccess:function(r){return{errors:{},values:r}}}),t.runPromise)}}export{i as effectTsResolver};
+import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";import{SchemaIssue as t,Schema as s,Effect as n}from"effect";import{appendErrors as o}from"react-hook-form";var a=t.makeFormatterStandardSchemaV1(),i=function(e,r){switch(e._tag){case"Pointer":return i(e.issue,[].concat(r,e.path));case"Encoding":return i(e.issue,r);case"Composite":case"AnyOf":if(e.issues.length)return e.issues.flatMap(function(e){return i(e,r)})}return a(e).issues.map(function(t){return{path:[].concat(r,t.path||[]),message:t.message,type:e._tag}})};function u(t,a){return void 0===a&&(a={errors:"all",onExcessProperty:"ignore"}),function(u,c,f){return s.decodeUnknownEffect(t)(u,a).pipe(n.match({onFailure:function(r){var t=!f.shouldUseNativeValidation&&"all"===f.criteriaMode,s=i(r.issue,[]).reduce(function(e,r){var s=r.path.join(".");if(e[s]||(e[s]={message:r.message,type:r.type}),t){var n=e[s].types,a=n&&n[r.type];e[s]=o(s,t,e,r.type,a?[].concat(a,r.message):r.message)}return e},Object.create(null));return{errors:e(s,f),values:{}}},onSuccess:function(e){return f.shouldUseNativeValidation&&r({},f),{errors:{},values:e}}}),n.runPromise)}}export{u as effectTsResolver};
 //# sourceMappingURL=effect-ts.module.js.map

package/effect-ts/dist/effect-ts.modern.mjs

@@ -1,2 +1,2 @@
-import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";import{Effect as o}from"effect";import{decodeUnknown as t,ArrayFormatter as s}from"effect/ParseResult";import{appendErrors as a}from"react-hook-form";function i(i,c={errors:"all",onExcessProperty:"ignore"}){return(n,l,m)=>t(i,c)(n).pipe(o.catchAll(e=>o.flip(s.formatIssue(e))),o.mapError(r=>{const o=!m.shouldUseNativeValidation&&"all"===m.criteriaMode,t=r.reduce((e,r)=>{const t=r.path.join(".");if(e[t]||(e[t]={message:r.message,type:r._tag}),o){const s=e[t].types,i=s&&s[String(r._tag)];e[t]=a(t,o,e,r._tag,i?[].concat(i,r.message):r.message)}return e},Object.create(null));return e(t,m)}),o.tap(()=>o.sync(()=>m.shouldUseNativeValidation&&r({},m))),o.match({onFailure:e=>({errors:e,values:{}}),onSuccess:e=>({errors:{},values:e})}),o.runPromise)}export{i as effectTsResolver};
+import{toNestErrors as e,validateFieldsNatively as s}from"@hookform/resolvers";import{SchemaIssue as r,Schema as t,Effect as o}from"effect";import{appendErrors as a}from"react-hook-form";const n=r.makeFormatterStandardSchemaV1(),i=(e,s)=>{switch(e._tag){case"Pointer":return i(e.issue,[...s,...e.path]);case"Encoding":return i(e.issue,s);case"Composite":case"AnyOf":if(e.issues.length)return e.issues.flatMap(e=>i(e,s))}return n(e).issues.map(r=>({path:[...s,...r.path||[]],message:r.message,type:e._tag}))};function c(r,n={errors:"all",onExcessProperty:"ignore"}){return(c,u,m)=>t.decodeUnknownEffect(r)(c,n).pipe(o.match({onFailure:({issue:s})=>{const r=!m.shouldUseNativeValidation&&"all"===m.criteriaMode,t=i(s,[]).reduce((e,s)=>{const t=s.path.join(".");if(e[t]||(e[t]={message:s.message,type:s.type}),r){const o=e[t].types,n=o&&o[s.type];e[t]=a(t,r,e,s.type,n?[].concat(n,s.message):s.message)}return e},Object.create(null));return{errors:e(t,m),values:{}}},onSuccess:e=>(m.shouldUseNativeValidation&&s({},m),{errors:{},values:e})}),o.runPromise)}export{c as effectTsResolver};
 //# sourceMappingURL=effect-ts.modern.mjs.map

package/effect-ts/dist/effect-ts.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"effect-ts.modern.mjs","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        // A null-prototype accumulator avoids false-positive hits from\n        // inherited members (e.g. `toString`, `constructor`) when a field\n        // is named after one of them — a plain `{}` would make `!acc[key]`\n        // truthy-skip those paths and silently drop their errors.\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          Object.create(null) as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["effectTsResolver","schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","Object","create","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"qOA4CgB,SAAAA,EACdC,EACAC,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAEjE,MAAO,CAACC,EAAQC,EAAGC,IACVC,EACLP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAOC,SAAUC,GACfF,EAAOG,KAAKC,EAAeC,YAAYH,KAEzCF,EAAOM,SAAUC,IACf,MAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAM1CjB,EAASc,EAAOI,OACpB,CAACC,EAAKC,KACJ,MAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,MAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,EACTT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,CAAG,EAEZa,OAAOC,OAAO,OAGhB,OAAOC,EAAalC,EAAQI,EAAQ,GAEtCG,EAAO4B,IAAI,IACT5B,EAAO6B,KACL,IACEhC,EAAQY,2BACRqB,EAAuB,CAAA,EAAIjC,KAGjCG,EAAO+B,MAAM,CACXC,UAAYvC,IAAY,CAAEA,SAAQE,OAAQ,CAAA,IAC1CsC,UAAYC,KAAczC,OAAQ,CAAA,EAAIE,OAAQuC,MAEhDlC,EAAOmC,WAGb"}
+{"version":3,"file":"effect-ts.modern.mjs","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema, SchemaIssue } from 'effect';\nimport type { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\ntype Issue = { path: PropertyKey[]; message: string; type: string };\n\nconst formatIssue = SchemaIssue.makeFormatterStandardSchemaV1();\n\n// Flattens the issue tree like `makeFormatterStandardSchemaV1` does, but keeps\n// the `_tag` of the failing node so it can be reported as the error `type`.\nconst flattenIssue = (\n  issue: SchemaIssue.Issue,\n  path: PropertyKey[],\n): Issue[] => {\n  switch (issue._tag) {\n    case 'Pointer':\n      return flattenIssue(issue.issue, [...path, ...issue.path]);\n    case 'Encoding':\n      return flattenIssue(issue.issue, path);\n    case 'Composite':\n    case 'AnyOf':\n      if (issue.issues.length) {\n        return issue.issues.flatMap((issue) => flattenIssue(issue, path));\n      }\n  }\n\n  return formatIssue(issue).issues.map((error) => ({\n    path: [...path, ...(error.path || [])] as PropertyKey[],\n    message: error.message,\n    type: issue._tag,\n  }));\n};\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect Schema validation\n * @param {Schema.Codec<Output, Input>} schema - The Effect schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect Schema parse options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) =>\n    Schema.decodeUnknownEffect(schema)(values, schemaOptions).pipe(\n      Effect.match({\n        onFailure: ({ issue }) => {\n          const validateAllFieldCriteria =\n            !options.shouldUseNativeValidation &&\n            options.criteriaMode === 'all';\n\n          // A null-prototype accumulator avoids false-positive hits from\n          // inherited members (e.g. `toString`, `constructor`) when a field\n          // is named after one of them — a plain `{}` would make `!acc[key]`\n          // truthy-skip those paths and silently drop their errors.\n          const errors = flattenIssue(issue, []).reduce(\n            (acc, error) => {\n              const key = error.path.join('.');\n\n              if (!acc[key]) {\n                acc[key] = { message: error.message, type: error.type };\n              }\n\n              if (validateAllFieldCriteria) {\n                const types = acc[key].types;\n                const messages = types && types[error.type];\n\n                acc[key] = appendErrors(\n                  key,\n                  validateAllFieldCriteria,\n                  acc,\n                  error.type,\n                  messages\n                    ? ([] as string[]).concat(\n                        messages as string[],\n                        error.message,\n                      )\n                    : error.message,\n                ) as FieldError;\n              }\n\n              return acc;\n            },\n            Object.create(null) as Record<string, FieldError>,\n          );\n\n          return { errors: toNestErrors(errors, options), values: {} };\n        },\n        onSuccess: (result) => {\n          options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options);\n\n          return { errors: {}, values: result };\n        },\n      }),\n      Effect.runPromise,\n    );\n}\n"],"names":["formatIssue","SchemaIssue","makeFormatterStandardSchemaV1","flattenIssue","issue","path","_tag","issues","length","flatMap","map","error","message","type","effectTsResolver","schema","schemaOptions","errors","onExcessProperty","values","_","options","Schema","decodeUnknownEffect","pipe","Effect","match","onFailure","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","key","join","types","messages","appendErrors","concat","Object","create","toNestErrors","onSuccess","result","validateFieldsNatively","runPromise"],"mappings":"2LAYA,MAAMA,EAAcC,EAAYC,gCAI1BC,EAAeA,CACnBC,EACAC,KAEA,OAAQD,EAAME,MACZ,IAAK,UACH,OAAOH,EAAaC,EAAMA,MAAO,IAAIC,KAASD,EAAMC,OACtD,IAAK,WACH,OAAOF,EAAaC,EAAMA,MAAOC,GACnC,IAAK,YACL,IAAK,QACH,GAAID,EAAMG,OAAOC,OACf,OAAOJ,EAAMG,OAAOE,QAASL,GAAUD,EAAaC,EAAOC,IAIjE,OAAOL,EAAYI,GAAOG,OAAOG,IAAKC,IAAW,CAC/CN,KAAM,IAAIA,KAAUM,EAAMN,MAAQ,IAClCO,QAASD,EAAMC,QACfC,KAAMT,EAAME,OACX,EAoCW,SAAAQ,EACdC,EACAC,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAEjE,MAAO,CAACC,EAAQC,EAAGC,IACjBC,EAAOC,oBAAoBR,EAA3BO,CAAmCH,EAAQH,GAAeQ,KACxDC,EAAOC,MAAM,CACXC,UAAWA,EAAGvB,YACZ,MAAMwB,GACHP,EAAQQ,2BACgB,QAAzBR,EAAQS,aAMJb,EAASd,EAAaC,EAAO,IAAI2B,OACrC,CAACC,EAAKrB,KACJ,MAAMsB,EAAMtB,EAAMN,KAAK6B,KAAK,KAM5B,GAJKF,EAAIC,KACPD,EAAIC,GAAO,CAAErB,QAASD,EAAMC,QAASC,KAAMF,EAAME,OAG/Ce,EAA0B,CAC5B,MAAMO,EAAQH,EAAIC,GAAKE,MACjBC,EAAWD,GAASA,EAAMxB,EAAME,MAEtCmB,EAAIC,GAAOI,EACTJ,EACAL,EACAI,EACArB,EAAME,KACNuB,EACK,GAAgBE,OACfF,EACAzB,EAAMC,SAERD,EAAMC,QAEd,CAEA,OAAOoB,CAAG,EAEZO,OAAOC,OAAO,OAGhB,MAAO,CAAEvB,OAAQwB,EAAaxB,EAAQI,GAAUF,OAAQ,GAAI,EAE9DuB,UAAYC,IACVtB,EAAQQ,2BACNe,EAAuB,CAAA,EAAIvB,GAEtB,CAAEJ,OAAQ,CAAA,EAAIE,OAAQwB,MAGjClB,EAAOoB,WAEb"}

package/effect-ts/dist/effect-ts.module.js

@@ -1,2 +1,2 @@
-import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{Effect as t}from"effect";import{decodeUnknown as o,ArrayFormatter as n}from"effect/ParseResult";import{appendErrors as a}from"react-hook-form";function i(i,s){return void 0===s&&(s={errors:"all",onExcessProperty:"ignore"}),function(u,c,f){return o(i,s)(u).pipe(t.catchAll(function(r){return t.flip(n.formatIssue(r))}),t.mapError(function(e){var t=!f.shouldUseNativeValidation&&"all"===f.criteriaMode,o=e.reduce(function(r,e){var o=e.path.join(".");if(r[o]||(r[o]={message:e.message,type:e._tag}),t){var n=r[o].types,i=n&&n[String(e._tag)];r[o]=a(o,t,r,e._tag,i?[].concat(i,e.message):e.message)}return r},Object.create(null));return r(o,f)}),t.tap(function(){return t.sync(function(){return f.shouldUseNativeValidation&&e({},f)})}),t.match({onFailure:function(r){return{errors:r,values:{}}},onSuccess:function(r){return{errors:{},values:r}}}),t.runPromise)}}export{i as effectTsResolver};
+import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";import{SchemaIssue as t,Schema as s,Effect as n}from"effect";import{appendErrors as o}from"react-hook-form";var a=t.makeFormatterStandardSchemaV1(),i=function(e,r){switch(e._tag){case"Pointer":return i(e.issue,[].concat(r,e.path));case"Encoding":return i(e.issue,r);case"Composite":case"AnyOf":if(e.issues.length)return e.issues.flatMap(function(e){return i(e,r)})}return a(e).issues.map(function(t){return{path:[].concat(r,t.path||[]),message:t.message,type:e._tag}})};function u(t,a){return void 0===a&&(a={errors:"all",onExcessProperty:"ignore"}),function(u,c,f){return s.decodeUnknownEffect(t)(u,a).pipe(n.match({onFailure:function(r){var t=!f.shouldUseNativeValidation&&"all"===f.criteriaMode,s=i(r.issue,[]).reduce(function(e,r){var s=r.path.join(".");if(e[s]||(e[s]={message:r.message,type:r.type}),t){var n=e[s].types,a=n&&n[r.type];e[s]=o(s,t,e,r.type,a?[].concat(a,r.message):r.message)}return e},Object.create(null));return{errors:e(s,f),values:{}}},onSuccess:function(e){return f.shouldUseNativeValidation&&r({},f),{errors:{},values:e}}}),n.runPromise)}}export{u as effectTsResolver};
 //# sourceMappingURL=effect-ts.module.js.map

package/effect-ts/dist/effect-ts.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"effect-ts.module.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        // A null-prototype accumulator avoids false-positive hits from\n        // inherited members (e.g. `toString`, `constructor`) when a field\n        // is named after one of them — a plain `{}` would make `!acc[key]`\n        // truthy-skip those paths and silently drop their errors.\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          Object.create(null) as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["effectTsResolver","schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","Object","create","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"8OA4CgBA,EACdC,EACAC,GAEA,YAF8B,IAA9BA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,oBAEzDC,EAAQC,EAAGC,GACjB,OAAOC,EACLP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAOC,SAAS,SAACC,GACf,OAAAF,EAAOG,KAAKC,EAAeC,YAAYH,GAAY,GAErDF,EAAOM,SAAS,SAACC,GACf,IAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAM1CjB,EAASc,EAAOI,OACpB,SAACC,EAAKC,GACJ,IAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,IAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,EACTT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,CACT,EACAa,OAAOC,OAAO,OAGhB,OAAOC,EAAalC,EAAQI,EAC9B,GACAG,EAAO4B,IAAI,WACT,OAAA5B,EAAO6B,KACL,WACE,OAAAhC,EAAQY,2BACRqB,EAAuB,GAAIjC,EAAQ,EACtC,GAEHG,EAAO+B,MAAM,CACXC,UAAW,SAACvC,GAAM,MAAM,CAAEA,OAAAA,EAAQE,OAAQ,GAAI,EAC9CsC,UAAW,SAACC,GAAM,MAAM,CAAEzC,OAAQ,CAAE,EAAEE,OAAQuC,EAAQ,IAExDlC,EAAOmC,WAEX,CACF"}
+{"version":3,"file":"effect-ts.module.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema, SchemaIssue } from 'effect';\nimport type { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\ntype Issue = { path: PropertyKey[]; message: string; type: string };\n\nconst formatIssue = SchemaIssue.makeFormatterStandardSchemaV1();\n\n// Flattens the issue tree like `makeFormatterStandardSchemaV1` does, but keeps\n// the `_tag` of the failing node so it can be reported as the error `type`.\nconst flattenIssue = (\n  issue: SchemaIssue.Issue,\n  path: PropertyKey[],\n): Issue[] => {\n  switch (issue._tag) {\n    case 'Pointer':\n      return flattenIssue(issue.issue, [...path, ...issue.path]);\n    case 'Encoding':\n      return flattenIssue(issue.issue, path);\n    case 'Composite':\n    case 'AnyOf':\n      if (issue.issues.length) {\n        return issue.issues.flatMap((issue) => flattenIssue(issue, path));\n      }\n  }\n\n  return formatIssue(issue).issues.map((error) => ({\n    path: [...path, ...(error.path || [])] as PropertyKey[],\n    message: error.message,\n    type: issue._tag,\n  }));\n};\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect Schema validation\n * @param {Schema.Codec<Output, Input>} schema - The Effect schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect Schema parse options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) =>\n    Schema.decodeUnknownEffect(schema)(values, schemaOptions).pipe(\n      Effect.match({\n        onFailure: ({ issue }) => {\n          const validateAllFieldCriteria =\n            !options.shouldUseNativeValidation &&\n            options.criteriaMode === 'all';\n\n          // A null-prototype accumulator avoids false-positive hits from\n          // inherited members (e.g. `toString`, `constructor`) when a field\n          // is named after one of them — a plain `{}` would make `!acc[key]`\n          // truthy-skip those paths and silently drop their errors.\n          const errors = flattenIssue(issue, []).reduce(\n            (acc, error) => {\n              const key = error.path.join('.');\n\n              if (!acc[key]) {\n                acc[key] = { message: error.message, type: error.type };\n              }\n\n              if (validateAllFieldCriteria) {\n                const types = acc[key].types;\n                const messages = types && types[error.type];\n\n                acc[key] = appendErrors(\n                  key,\n                  validateAllFieldCriteria,\n                  acc,\n                  error.type,\n                  messages\n                    ? ([] as string[]).concat(\n                        messages as string[],\n                        error.message,\n                      )\n                    : error.message,\n                ) as FieldError;\n              }\n\n              return acc;\n            },\n            Object.create(null) as Record<string, FieldError>,\n          );\n\n          return { errors: toNestErrors(errors, options), values: {} };\n        },\n        onSuccess: (result) => {\n          options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options);\n\n          return { errors: {}, values: result };\n        },\n      }),\n      Effect.runPromise,\n    );\n}\n"],"names":["formatIssue","SchemaIssue","makeFormatterStandardSchemaV1","flattenIssue","issue","path","_tag","concat","issues","length","flatMap","map","error","message","type","effectTsResolver","schema","schemaOptions","errors","onExcessProperty","values","_","options","Schema","decodeUnknownEffect","pipe","Effect","match","onFailure","_ref","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","key","join","types","messages","appendErrors","Object","create","toNestErrors","onSuccess","result","validateFieldsNatively","runPromise"],"mappings":"2LAYA,IAAMA,EAAcC,EAAYC,gCAI1BC,EAAe,SACnBC,EACAC,GAEA,OAAQD,EAAME,MACZ,IAAK,UACH,OAAOH,EAAaC,EAAMA,MAAK,GAAAG,OAAMF,EAASD,EAAMC,OACtD,IAAK,WACH,OAAOF,EAAaC,EAAMA,MAAOC,GACnC,IAAK,YACL,IAAK,QACH,GAAID,EAAMI,OAAOC,OACf,OAAOL,EAAMI,OAAOE,QAAQ,SAACN,GAAK,OAAKD,EAAaC,EAAOC,EAAK,GAItE,OAAOL,EAAYI,GAAOI,OAAOG,IAAI,SAACC,GAAW,MAAA,CAC/CP,KAAI,GAAAE,OAAMF,EAAUO,EAAMP,MAAQ,IAClCQ,QAASD,EAAMC,QACfC,KAAMV,EAAME,KACb,EACH,EAmCgB,SAAAS,EACdC,EACAC,GAEA,YAF8B,IAA9BA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAE1D,SAACC,EAAQC,EAAGC,GACjB,OAAAC,EAAOC,oBAAoBR,EAA3BO,CAAmCH,EAAQH,GAAeQ,KACxDC,EAAOC,MAAM,CACXC,UAAW,SAAFC,GAAgB,IACjBC,GACHR,EAAQS,2BACgB,QAAzBT,EAAQU,aAMJd,EAASf,EATE0B,EAALzB,MASuB,IAAI6B,OACrC,SAACC,EAAKtB,GACJ,IAAMuB,EAAMvB,EAAMP,KAAK+B,KAAK,KAM5B,GAJKF,EAAIC,KACPD,EAAIC,GAAO,CAAEtB,QAASD,EAAMC,QAASC,KAAMF,EAAME,OAG/CgB,EAA0B,CAC5B,IAAMO,EAAQH,EAAIC,GAAKE,MACjBC,EAAWD,GAASA,EAAMzB,EAAME,MAEtCoB,EAAIC,GAAOI,EACTJ,EACAL,EACAI,EACAtB,EAAME,KACNwB,EACK,GAAgB/B,OACf+B,EACA1B,EAAMC,SAERD,EAAMC,QAEd,CAEA,OAAOqB,CACT,EACAM,OAAOC,OAAO,OAGhB,MAAO,CAAEvB,OAAQwB,EAAaxB,EAAQI,GAAUF,OAAQ,GAC1D,EACAuB,UAAW,SAACC,GAIV,OAHAtB,EAAQS,2BACNc,EAAuB,GAAIvB,GAEtB,CAAEJ,OAAQ,CAAE,EAAEE,OAAQwB,EAC/B,IAEFlB,EAAOoB,WACR,CACL"}

package/effect-ts/dist/effect-ts.umd.js

@@ -1,2 +1,2 @@
-!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers"),require("effect"),require("effect/ParseResult"),require("react-hook-form")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","effect","effect/ParseResult","react-hook-form"],r):r((e||self).hookformResolversEffectTs={},e.hookformResolvers,e.Effect,e.EffectParseResult,e.ReactHookForm)}(this,function(e,r,t,o,f){e.effectTsResolver=function(e,n){return void 0===n&&(n={errors:"all",onExcessProperty:"ignore"}),function(s,a,c){return o.decodeUnknown(e,n)(s).pipe(t.Effect.catchAll(function(e){return t.Effect.flip(o.ArrayFormatter.formatIssue(e))}),t.Effect.mapError(function(e){var t=!c.shouldUseNativeValidation&&"all"===c.criteriaMode,o=e.reduce(function(e,r){var o=r.path.join(".");if(e[o]||(e[o]={message:r.message,type:r._tag}),t){var n=e[o].types,s=n&&n[String(r._tag)];e[o]=f.appendErrors(o,t,e,r._tag,s?[].concat(s,r.message):r.message)}return e},Object.create(null));return r.toNestErrors(o,c)}),t.Effect.tap(function(){return t.Effect.sync(function(){return c.shouldUseNativeValidation&&r.validateFieldsNatively({},c)})}),t.Effect.match({onFailure:function(e){return{errors:e,values:{}}},onSuccess:function(e){return{errors:{},values:e}}}),t.Effect.runPromise)}}});
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers"),require("effect"),require("react-hook-form")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","effect","react-hook-form"],r):r((e||self).hookformResolversEffectTs={},e.hookformResolvers,e.Effect,e.ReactHookForm)}(this,function(e,r,t,o){var s=t.SchemaIssue.makeFormatterStandardSchemaV1(),n=function(e,r){switch(e._tag){case"Pointer":return n(e.issue,[].concat(r,e.path));case"Encoding":return n(e.issue,r);case"Composite":case"AnyOf":if(e.issues.length)return e.issues.flatMap(function(e){return n(e,r)})}return s(e).issues.map(function(t){return{path:[].concat(r,t.path||[]),message:t.message,type:e._tag}})};e.effectTsResolver=function(e,s){return void 0===s&&(s={errors:"all",onExcessProperty:"ignore"}),function(a,i,c){return t.Schema.decodeUnknownEffect(e)(a,s).pipe(t.Effect.match({onFailure:function(e){var t=!c.shouldUseNativeValidation&&"all"===c.criteriaMode,s=n(e.issue,[]).reduce(function(e,r){var s=r.path.join(".");if(e[s]||(e[s]={message:r.message,type:r.type}),t){var n=e[s].types,a=n&&n[r.type];e[s]=o.appendErrors(s,t,e,r.type,a?[].concat(a,r.message):r.message)}return e},Object.create(null));return{errors:r.toNestErrors(s,c),values:{}}},onSuccess:function(e){return c.shouldUseNativeValidation&&r.validateFieldsNatively({},c),{errors:{},values:e}}}),t.Effect.runPromise)}}});
 //# sourceMappingURL=effect-ts.umd.js.map

package/effect-ts/dist/effect-ts.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"effect-ts.umd.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        // A null-prototype accumulator avoids false-positive hits from\n        // inherited members (e.g. `toString`, `constructor`) when a field\n        // is named after one of them — a plain `{}` would make `!acc[key]`\n        // truthy-skip those paths and silently drop their errors.\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          Object.create(null) as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","Object","create","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"wgBA6CEA,EACAC,GAEA,YAF8B,IAA9BA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,oBAEzDC,EAAQC,EAAGC,GACjB,OAAOC,EAAaA,cAClBP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAMA,OAACC,SAAS,SAACC,GACf,OAAAF,EAAAA,OAAOG,KAAKC,EAAcA,eAACC,YAAYH,GAAY,GAErDF,EAAMA,OAACM,SAAS,SAACC,GACf,IAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAM1CjB,EAASc,EAAOI,OACpB,SAACC,EAAKC,GACJ,IAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,IAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,eACTT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,CACT,EACAa,OAAOC,OAAO,OAGhB,OAAOC,eAAalC,EAAQI,EAC9B,GACAG,SAAO4B,IAAI,WACT,OAAA5B,EAAAA,OAAO6B,KACL,WACE,OAAAhC,EAAQY,2BACRqB,EAAsBA,uBAAC,GAAIjC,EAAQ,EACtC,GAEHG,EAAAA,OAAO+B,MAAM,CACXC,UAAW,SAACvC,GAAM,MAAM,CAAEA,OAAAA,EAAQE,OAAQ,GAAI,EAC9CsC,UAAW,SAACC,GAAM,MAAM,CAAEzC,OAAQ,CAAE,EAAEE,OAAQuC,EAAQ,IAExDlC,EAAMA,OAACmC,WAEX,CACF"}
+{"version":3,"file":"effect-ts.umd.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema, SchemaIssue } from 'effect';\nimport type { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\ntype Issue = { path: PropertyKey[]; message: string; type: string };\n\nconst formatIssue = SchemaIssue.makeFormatterStandardSchemaV1();\n\n// Flattens the issue tree like `makeFormatterStandardSchemaV1` does, but keeps\n// the `_tag` of the failing node so it can be reported as the error `type`.\nconst flattenIssue = (\n  issue: SchemaIssue.Issue,\n  path: PropertyKey[],\n): Issue[] => {\n  switch (issue._tag) {\n    case 'Pointer':\n      return flattenIssue(issue.issue, [...path, ...issue.path]);\n    case 'Encoding':\n      return flattenIssue(issue.issue, path);\n    case 'Composite':\n    case 'AnyOf':\n      if (issue.issues.length) {\n        return issue.issues.flatMap((issue) => flattenIssue(issue, path));\n      }\n  }\n\n  return formatIssue(issue).issues.map((error) => ({\n    path: [...path, ...(error.path || [])] as PropertyKey[],\n    message: error.message,\n    type: issue._tag,\n  }));\n};\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect Schema validation\n * @param {Schema.Codec<Output, Input>} schema - The Effect schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect Schema parse options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) =>\n    Schema.decodeUnknownEffect(schema)(values, schemaOptions).pipe(\n      Effect.match({\n        onFailure: ({ issue }) => {\n          const validateAllFieldCriteria =\n            !options.shouldUseNativeValidation &&\n            options.criteriaMode === 'all';\n\n          // A null-prototype accumulator avoids false-positive hits from\n          // inherited members (e.g. `toString`, `constructor`) when a field\n          // is named after one of them — a plain `{}` would make `!acc[key]`\n          // truthy-skip those paths and silently drop their errors.\n          const errors = flattenIssue(issue, []).reduce(\n            (acc, error) => {\n              const key = error.path.join('.');\n\n              if (!acc[key]) {\n                acc[key] = { message: error.message, type: error.type };\n              }\n\n              if (validateAllFieldCriteria) {\n                const types = acc[key].types;\n                const messages = types && types[error.type];\n\n                acc[key] = appendErrors(\n                  key,\n                  validateAllFieldCriteria,\n                  acc,\n                  error.type,\n                  messages\n                    ? ([] as string[]).concat(\n                        messages as string[],\n                        error.message,\n                      )\n                    : error.message,\n                ) as FieldError;\n              }\n\n              return acc;\n            },\n            Object.create(null) as Record<string, FieldError>,\n          );\n\n          return { errors: toNestErrors(errors, options), values: {} };\n        },\n        onSuccess: (result) => {\n          options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options);\n\n          return { errors: {}, values: result };\n        },\n      }),\n      Effect.runPromise,\n    );\n}\n"],"names":["formatIssue","SchemaIssue","makeFormatterStandardSchemaV1","flattenIssue","issue","path","_tag","concat","issues","length","flatMap","map","error","message","type","schema","schemaOptions","errors","onExcessProperty","values","_","options","Schema","decodeUnknownEffect","pipe","Effect","match","onFailure","_ref","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","key","join","types","messages","appendErrors","Object","create","toNestErrors","onSuccess","result","validateFieldsNatively","runPromise"],"mappings":"maAYA,IAAMA,EAAcC,EAAWA,YAACC,gCAI1BC,EAAe,SACnBC,EACAC,GAEA,OAAQD,EAAME,MACZ,IAAK,UACH,OAAOH,EAAaC,EAAMA,MAAK,GAAAG,OAAMF,EAASD,EAAMC,OACtD,IAAK,WACH,OAAOF,EAAaC,EAAMA,MAAOC,GACnC,IAAK,YACL,IAAK,QACH,GAAID,EAAMI,OAAOC,OACf,OAAOL,EAAMI,OAAOE,QAAQ,SAACN,GAAK,OAAKD,EAAaC,EAAOC,EAAK,GAItE,OAAOL,EAAYI,GAAOI,OAAOG,IAAI,SAACC,GAAW,MAAA,CAC/CP,KAAI,GAAAE,OAAMF,EAAUO,EAAMP,MAAQ,IAClCQ,QAASD,EAAMC,QACfC,KAAMV,EAAME,KACb,EACH,qBAmCgB,SACdS,EACAC,GAEA,YAF8B,IAA9BA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAE1D,SAACC,EAAQC,EAAGC,GACjB,OAAAC,EAAMA,OAACC,oBAAoBR,EAA3BO,CAAmCH,EAAQH,GAAeQ,KACxDC,EAAAA,OAAOC,MAAM,CACXC,UAAW,SAAFC,GAAgB,IACjBC,GACHR,EAAQS,2BACgB,QAAzBT,EAAQU,aAMJd,EAASd,EATEyB,EAALxB,MASuB,IAAI4B,OACrC,SAACC,EAAKrB,GACJ,IAAMsB,EAAMtB,EAAMP,KAAK8B,KAAK,KAM5B,GAJKF,EAAIC,KACPD,EAAIC,GAAO,CAAErB,QAASD,EAAMC,QAASC,KAAMF,EAAME,OAG/Ce,EAA0B,CAC5B,IAAMO,EAAQH,EAAIC,GAAKE,MACjBC,EAAWD,GAASA,EAAMxB,EAAME,MAEtCmB,EAAIC,GAAOI,eACTJ,EACAL,EACAI,EACArB,EAAME,KACNuB,EACK,GAAgB9B,OACf8B,EACAzB,EAAMC,SAERD,EAAMC,QAEd,CAEA,OAAOoB,CACT,EACAM,OAAOC,OAAO,OAGhB,MAAO,CAAEvB,OAAQwB,EAAYA,aAACxB,EAAQI,GAAUF,OAAQ,GAC1D,EACAuB,UAAW,SAACC,GAIV,OAHAtB,EAAQS,2BACNc,EAAsBA,uBAAC,GAAIvB,GAEtB,CAAEJ,OAAQ,CAAE,EAAEE,OAAQwB,EAC/B,IAEFlB,SAAOoB,WACR,CACL"}

package/effect-ts/package.json

@@ -12,7 +12,7 @@
   "license": "MIT",
   "peerDependencies": {
     "@hookform/resolvers": "^2.0.0",
-    "effect": "^3.10.3",
+    "effect": "^4.0.0",
     "react-hook-form": "^7.55.0"
   }
 }

package/effect-ts/src/__tests__/Form-native-validation.tsx

@@ -9,11 +9,11 @@ const USERNAME_REQUIRED_MESSAGE = 'username field is required';
 const PASSWORD_REQUIRED_MESSAGE = 'password field is required';
 
 const schema = Schema.Struct({
-  username: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => USERNAME_REQUIRED_MESSAGE }),
+  username: Schema.String.check(
+    Schema.isNonEmpty({ message: USERNAME_REQUIRED_MESSAGE }),
   ),
-  password: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => PASSWORD_REQUIRED_MESSAGE }),
+  password: Schema.String.check(
+    Schema.isNonEmpty({ message: PASSWORD_REQUIRED_MESSAGE }),
   ),
 });
 

package/effect-ts/src/__tests__/Form.tsx

@@ -9,11 +9,11 @@ const USERNAME_REQUIRED_MESSAGE = 'username field is required';
 const PASSWORD_REQUIRED_MESSAGE = 'password field is required';
 
 const schema = Schema.Struct({
-  username: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => USERNAME_REQUIRED_MESSAGE }),
+  username: Schema.String.check(
+    Schema.isNonEmpty({ message: USERNAME_REQUIRED_MESSAGE }),
   ),
-  password: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => PASSWORD_REQUIRED_MESSAGE }),
+  password: Schema.String.check(
+    Schema.isNonEmpty({ message: PASSWORD_REQUIRED_MESSAGE }),
   ),
 });
 

package/effect-ts/src/__tests__/__fixtures__/data.ts

@@ -2,43 +2,43 @@ import { Schema } from 'effect';
 import { Field, InternalFieldName } from 'react-hook-form';
 
 export const schema = Schema.Struct({
-  username: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => 'A username is required' }),
+  username: Schema.String.check(
+    Schema.isNonEmpty({ message: 'A username is required' }),
   ),
-  password: Schema.String.pipe(
-    Schema.pattern(new RegExp('.*[A-Z].*'), {
-      message: () => 'At least 1 uppercase letter.',
+  password: Schema.String.check(
+    Schema.isPattern(new RegExp('.*[A-Z].*'), {
+      message: 'At least 1 uppercase letter.',
     }),
-    Schema.pattern(new RegExp('.*[a-z].*'), {
-      message: () => 'At least 1 lowercase letter.',
+    Schema.isPattern(new RegExp('.*[a-z].*'), {
+      message: 'At least 1 lowercase letter.',
     }),
-    Schema.pattern(new RegExp('.*\\d.*'), {
-      message: () => 'At least 1 number.',
+    Schema.isPattern(new RegExp('.*\\d.*'), {
+      message: 'At least 1 number.',
     }),
-    Schema.pattern(
+    Schema.isPattern(
       new RegExp('.*[`~<>?,./!@#$%^&*()\\-_+="\'|{}\\[\\];:\\\\].*'),
       {
-        message: () => 'At least 1 special character.',
+        message: 'At least 1 special character.',
       },
     ),
-    Schema.minLength(8, { message: () => 'Must be at least 8 characters.' }),
+    Schema.isMinLength(8, { message: 'Must be at least 8 characters.' }),
   ),
-  accessToken: Schema.Union(Schema.String, Schema.Number),
-  birthYear: Schema.Number.pipe(
-    Schema.greaterThan(1900, {
-      message: () => 'Must be greater than the year 1900',
+  accessToken: Schema.Union([Schema.String, Schema.Number]),
+  birthYear: Schema.Number.check(
+    Schema.isGreaterThan(1900, {
+      message: 'Must be greater than the year 1900',
     }),
-    Schema.filter((value) => value < new Date().getFullYear(), {
-      message: () => 'Must be before the current year.',
+    Schema.makeFilter((value: number) => value < new Date().getFullYear(), {
+      message: 'Must be before the current year.',
     }),
   ),
-  email: Schema.String.pipe(
-    Schema.pattern(
+  email: Schema.String.check(
+    Schema.isPattern(
       new RegExp(
         /^(?!\.)(?!.*\.\.)([A-Z0-9_+-.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9-]*\.)+[A-Z]{2,}$/i,
       ),
       {
-        message: () => 'A valid email address is required.',
+        message: 'A valid email address is required.',
       },
     ),
   ),
@@ -49,9 +49,9 @@ export const schema = Schema.Struct({
   ),
   luckyNumbers: Schema.Array(Schema.Number),
   enabled: Schema.Boolean,
-  animal: Schema.Union(Schema.String, Schema.Literal('bird', 'snake')),
+  animal: Schema.Union([Schema.String, Schema.Literals(['bird', 'snake'])]),
   vehicles: Schema.Array(
-    Schema.Union(
+    Schema.Union([
       Schema.Struct({
         type: Schema.Literal('car'),
         brand: Schema.String,
@@ -61,7 +61,7 @@ export const schema = Schema.Struct({
         type: Schema.Literal('bike'),
         speed: Schema.Number,
       }),
-    ),
+    ]),
   ),
 });
 

package/effect-ts/src/__tests__/__snapshots__/effect-ts.ts.snap

@@ -4,17 +4,17 @@ exports[`effectTsResolver > should return a single error from effectTsResolver w
 {
   "errors": {
     "animal": {
-      "message": "Expected string, actual ["dog"]",
+      "message": "Expected string | "bird" | "snake"",
       "ref": undefined,
-      "type": "Type",
+      "type": "AnyOf",
     },
     "luckyNumbers": [
       ,
       ,
       {
-        "message": "Expected number, actual "3"",
+        "message": "Expected number",
         "ref": undefined,
-        "type": "Type",
+        "type": "InvalidType",
       },
     ],
     "password": {
@@ -22,15 +22,15 @@ exports[`effectTsResolver > should return a single error from effectTsResolver w
       "ref": {
         "name": "password",
       },
-      "type": "Refinement",
+      "type": "Filter",
     },
     "vehicles": [
       ,
       {
         "horsepower": {
-          "message": "is missing",
+          "message": "Missing key",
           "ref": undefined,
-          "type": "Missing",
+          "type": "MissingKey",
         },
       },
     ],
@@ -47,10 +47,9 @@ exports[`effectTsResolver > should return all the errors from effectTsResolver w
       "ref": {
         "name": "phoneNumber",
       },
-      "type": "Refinement",
+      "type": "Filter",
       "types": {
-        "Refinement": "Please enter a valid phone number in international format.",
-        "Type": "Expected undefined, actual "123"",
+        "Filter": "Please enter a valid phone number in international format.",
       },
     },
   },
@@ -66,7 +65,7 @@ exports[`effectTsResolver > should return the first error from effectTsResolver
       "ref": {
         "name": "phoneNumber",
       },
-      "type": "Refinement",
+      "type": "Filter",
     },
   },
   "values": {},

package/effect-ts/src/__tests__/effect-ts.ts

@@ -1,5 +1,11 @@
 import { renderHook } from '@testing-library/react';
-import { Schema } from 'effect';
+import {
+  Effect,
+  Schema,
+  SchemaGetter,
+  SchemaIssue,
+  SchemaTransformation,
+} from 'effect';
 import { Resolver, useForm } from 'react-hook-form';
 import { SubmitHandler } from 'react-hook-form';
 import { effectTsResolver } from '..';
@@ -29,9 +35,9 @@ describe('effectTsResolver', () => {
   it('should return the first error from effectTsResolver when validation fails with `validateAllFieldCriteria` set to firstError', async () => {
     const SignupSchema = Schema.Struct({
       phoneNumber: Schema.optional(
-        Schema.String.pipe(
-          Schema.pattern(/^\+\d{7,15}$/, {
-            message: () =>
+        Schema.String.check(
+          Schema.isPattern(/^\+\d{7,15}$/, {
+            message:
               'Please enter a valid phone number in international format.',
           }),
         ),
@@ -59,9 +65,9 @@ describe('effectTsResolver', () => {
   it('should return all the errors from effectTsResolver when validation fails with `validateAllFieldCriteria` set to true', async () => {
     const SignupSchema = Schema.Struct({
       phoneNumber: Schema.optional(
-        Schema.String.pipe(
-          Schema.pattern(/^\+\d{7,15}$/, {
-            message: () =>
+        Schema.String.check(
+          Schema.isPattern(/^\+\d{7,15}$/, {
+            message:
               'Please enter a valid phone number in international format.',
           }),
         ),
@@ -86,6 +92,171 @@ describe('effectTsResolver', () => {
     expect(result).toMatchSnapshot();
   });
 
+  it('should group all messages of the same issue type when `criteriaMode` is "all"', async () => {
+    const schema = Schema.Struct({
+      password: Schema.String.check(
+        Schema.isMinLength(8, { message: 'Too short' }),
+        Schema.isPattern(/\d/, { message: 'Needs a number' }),
+      ),
+    });
+
+    const result = await effectTsResolver(schema)(
+      { password: 'abc' },
+      undefined,
+      { fields, criteriaMode: 'all', shouldUseNativeValidation },
+    );
+
+    expect(result.errors.password).toMatchObject({
+      message: 'Too short',
+      type: 'Filter',
+      types: { Filter: ['Too short', 'Needs a number'] },
+    });
+  });
+
+  it('should return nested and indexed errors with their issue type', async () => {
+    const schema = Schema.Struct({
+      user: Schema.Struct({ name: Schema.String }),
+      tags: Schema.Array(Schema.String),
+    });
+
+    const result = await effectTsResolver(schema)(
+      { user: {}, tags: ['a', 1] } as any,
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+
+    expect(result).toEqual({
+      values: {},
+      errors: {
+        user: { name: { message: 'Missing key', type: 'MissingKey' } },
+        tags: [undefined, { message: 'Expected string', type: 'InvalidType' }],
+      },
+    });
+  });
+
+  it('should only report the first error when `schemaOptions.errors` is "first"', async () => {
+    const schema = Schema.Struct({ a: Schema.String, b: Schema.String });
+
+    const result = await effectTsResolver(schema, { errors: 'first' })(
+      {} as any,
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+
+    expect(Object.keys(result.errors)).toEqual(['a']);
+  });
+
+  it('should ignore excess properties by default and report them when `onExcessProperty` is "error"', async () => {
+    const schema = Schema.Struct({ a: Schema.String });
+    const values = { a: 'a', b: 'b' } as any;
+
+    const ignored = await effectTsResolver(schema)(values, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+    expect(ignored).toEqual({ errors: {}, values: { a: 'a' } });
+
+    const rejected = await effectTsResolver(schema, {
+      errors: 'all',
+      onExcessProperty: 'error',
+    })(values, undefined, { fields, shouldUseNativeValidation });
+    expect(rejected.errors).toMatchObject({
+      b: { type: 'UnexpectedKey' },
+    });
+  });
+
+  it('should return the decoded output when a transformation is used', async () => {
+    const schema = Schema.Struct({ age: Schema.NumberFromString });
+
+    const result = await effectTsResolver(schema)({ age: '42' }, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toEqual({ errors: {}, values: { age: 42 } });
+  });
+
+  it('should report errors raised by a failing transformation', async () => {
+    const schema = Schema.Struct({
+      age: Schema.String.pipe(
+        Schema.decodeTo(Schema.Number, {
+          decode: SchemaGetter.transformEffect((s: string) =>
+            Number.isNaN(Number(s))
+              ? Effect.fail(
+                  new SchemaIssue.InvalidValue({ message: 'Not a number' }),
+                )
+              : Effect.succeed(Number(s)),
+          ),
+          encode: SchemaGetter.String(),
+        }),
+      ),
+    });
+
+    const result = await effectTsResolver(schema)({ age: 'abc' }, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toEqual({
+      values: {},
+      errors: { age: { message: 'Not a number', type: 'InvalidValue' } },
+    });
+  });
+
+  it('should support asynchronous validation', async () => {
+    const schema = Schema.Struct({
+      username: Schema.String.pipe(
+        Schema.decodeTo(Schema.String, {
+          decode: SchemaGetter.checkEffect((s: string) =>
+            Effect.sleep('1 millis').pipe(
+              Effect.as(s === 'taken' ? 'Username is taken' : undefined),
+            ),
+          ),
+          encode: SchemaGetter.passthrough(),
+        }),
+      ),
+    });
+
+    const valid = await effectTsResolver(schema)(
+      { username: 'free' },
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+    expect(valid).toEqual({ errors: {}, values: { username: 'free' } });
+
+    const invalid = await effectTsResolver(schema)(
+      { username: 'taken' },
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+    expect(invalid.errors).toMatchObject({
+      username: { message: 'Username is taken' },
+    });
+  });
+
+  it('should validate fields natively when `shouldUseNativeValidation` is true', async () => {
+    const setCustomValidity = vi.fn();
+    const reportValidity = vi.fn();
+    const nativeFields = {
+      username: {
+        name: 'username',
+        ref: { name: 'username', setCustomValidity, reportValidity },
+      },
+    } as any;
+
+    const result = await effectTsResolver(
+      Schema.Struct({ username: Schema.String }),
+    )({ username: 'john' }, undefined, {
+      fields: nativeFields,
+      names: ['username'],
+      shouldUseNativeValidation: true,
+    });
+
+    expect(result).toEqual({ errors: {}, values: { username: 'john' } });
+    expect(setCustomValidity).toHaveBeenCalledWith('');
+    expect(reportValidity).toHaveBeenCalled();
+  });
+
   /**
    * Type inference tests
    */
@@ -100,10 +271,15 @@ describe('effectTsResolver', () => {
   it('should correctly infer the output type from a effectTs schema using a transform', () => {
     const resolver = effectTsResolver(
       Schema.Struct({
-        id: Schema.transform(Schema.Number, Schema.String, {
-          decode: (val) => String(val),
-          encode: (val) => Number(val),
-        }),
+        id: Schema.Number.pipe(
+          Schema.decodeTo(
+            Schema.String,
+            SchemaTransformation.transform({
+              decode: (val) => String(val),
+              encode: (val) => Number(val),
+            }),
+          ),
+        ),
       }),
     );
 
@@ -132,10 +308,15 @@ describe('effectTsResolver', () => {
 
   it('should correctly infer the output type from a effectTs schema with a transform for the handleSubmit function in useForm', () => {
     const schema = Schema.Struct({
-      id: Schema.transform(Schema.Number, Schema.String, {
-        decode: (val) => String(val),
-        encode: (val) => Number(val),
-      }),
+      id: Schema.Number.pipe(
+        Schema.decodeTo(
+          Schema.String,
+          SchemaTransformation.transform({
+            decode: (val) => String(val),
+            encode: (val) => Number(val),
+          }),
+        ),
+      ),
     });
 
     const {

package/effect-ts/src/__tests__/special-path-names.ts

@@ -8,7 +8,7 @@ describe('effectTsResolver special path names', () => {
     'reports a validation error for a field named "%s"',
     async (name) => {
       const schema = Schema.Struct({
-        [name]: Schema.String.pipe(Schema.minLength(1)),
+        [name]: Schema.String.check(Schema.isMinLength(1)),
       });
 
       const result = await effectTsResolver(schema as any)(

package/effect-ts/src/effect-ts.ts

@@ -1,7 +1,6 @@
 import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
-import { Effect, Schema } from 'effect';
-import { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';
-import { ParseOptions } from 'effect/SchemaAST';
+import { Effect, Schema, SchemaIssue } from 'effect';
+import type { ParseOptions } from 'effect/SchemaAST';
 import {
   type FieldError,
   FieldValues,
@@ -9,8 +8,37 @@ import {
   appendErrors,
 } from 'react-hook-form';
 
+type Issue = { path: PropertyKey[]; message: string; type: string };
+
+const formatIssue = SchemaIssue.makeFormatterStandardSchemaV1();
+
+// Flattens the issue tree like `makeFormatterStandardSchemaV1` does, but keeps
+// the `_tag` of the failing node so it can be reported as the error `type`.
+const flattenIssue = (
+  issue: SchemaIssue.Issue,
+  path: PropertyKey[],
+): Issue[] => {
+  switch (issue._tag) {
+    case 'Pointer':
+      return flattenIssue(issue.issue, [...path, ...issue.path]);
+    case 'Encoding':
+      return flattenIssue(issue.issue, path);
+    case 'Composite':
+    case 'AnyOf':
+      if (issue.issues.length) {
+        return issue.issues.flatMap((issue) => flattenIssue(issue, path));
+      }
+  }
+
+  return formatIssue(issue).issues.map((error) => ({
+    path: [...path, ...(error.path || [])] as PropertyKey[],
+    message: error.message,
+    type: issue._tag,
+  }));
+};
+
 export function effectTsResolver<Input extends FieldValues, Context, Output>(
-  schema: Schema.Schema<Output, Input>,
+  schema: Schema.Codec<Output, Input, never, unknown>,
   schemaOptions?: ParseOptions,
   resolverOptions?: {
     mode?: 'async' | 'sync';
@@ -19,7 +47,7 @@ export function effectTsResolver<Input extends FieldValues, Context, Output>(
 ): Resolver<Input, Context, Output>;
 
 export function effectTsResolver<Input extends FieldValues, Context, Output>(
-  schema: Schema.Schema<Output, Input>,
+  schema: Schema.Codec<Output, Input, never, unknown>,
   schemaOptions: ParseOptions | undefined,
   resolverOptions: {
     mode?: 'async' | 'sync';
@@ -28,9 +56,9 @@ export function effectTsResolver<Input extends FieldValues, Context, Output>(
 ): Resolver<Input, Context, Input>;
 
 /**
- * Creates a resolver for react-hook-form using Effect.ts schema validation
- * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against
- * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options
+ * Creates a resolver for react-hook-form using Effect Schema validation
+ * @param {Schema.Codec<Output, Input>} schema - The Effect schema to validate against
+ * @param {ParseOptions} [schemaOptions] - Optional Effect Schema parse options
  * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form
  * @example
  * const schema = Schema.Struct({
@@ -43,67 +71,61 @@ export function effectTsResolver<Input extends FieldValues, Context, Output>(
  * });
  */
 export function effectTsResolver<Input extends FieldValues, Context, Output>(
-  schema: Schema.Schema<Output, Input>,
+  schema: Schema.Codec<Output, Input, never, unknown>,
   schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },
 ): Resolver<Input, Context, Output | Input> {
-  return (values, _, options) => {
-    return decodeUnknown(
-      schema,
-      schemaOptions,
-    )(values).pipe(
-      Effect.catchAll((parseIssue) =>
-        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),
-      ),
-      Effect.mapError((issues) => {
-        const validateAllFieldCriteria =
-          !options.shouldUseNativeValidation && options.criteriaMode === 'all';
+  return (values, _, options) =>
+    Schema.decodeUnknownEffect(schema)(values, schemaOptions).pipe(
+      Effect.match({
+        onFailure: ({ issue }) => {
+          const validateAllFieldCriteria =
+            !options.shouldUseNativeValidation &&
+            options.criteriaMode === 'all';
 
-        // A null-prototype accumulator avoids false-positive hits from
-        // inherited members (e.g. `toString`, `constructor`) when a field
-        // is named after one of them — a plain `{}` would make `!acc[key]`
-        // truthy-skip those paths and silently drop their errors.
-        const errors = issues.reduce(
-          (acc, error) => {
-            const key = error.path.join('.');
+          // A null-prototype accumulator avoids false-positive hits from
+          // inherited members (e.g. `toString`, `constructor`) when a field
+          // is named after one of them — a plain `{}` would make `!acc[key]`
+          // truthy-skip those paths and silently drop their errors.
+          const errors = flattenIssue(issue, []).reduce(
+            (acc, error) => {
+              const key = error.path.join('.');
 
-            if (!acc[key]) {
-              acc[key] = { message: error.message, type: error._tag };
-            }
+              if (!acc[key]) {
+                acc[key] = { message: error.message, type: error.type };
+              }
 
-            if (validateAllFieldCriteria) {
-              const types = acc[key].types;
-              const messages = types && types[String(error._tag)];
+              if (validateAllFieldCriteria) {
+                const types = acc[key].types;
+                const messages = types && types[error.type];
 
-              acc[key] = appendErrors(
-                key,
-                validateAllFieldCriteria,
-                acc,
-                error._tag,
-                messages
-                  ? ([] as string[]).concat(messages as string[], error.message)
-                  : error.message,
-              ) as FieldError;
-            }
+                acc[key] = appendErrors(
+                  key,
+                  validateAllFieldCriteria,
+                  acc,
+                  error.type,
+                  messages
+                    ? ([] as string[]).concat(
+                        messages as string[],
+                        error.message,
+                      )
+                    : error.message,
+                ) as FieldError;
+              }
 
-            return acc;
-          },
-          Object.create(null) as Record<string, FieldError>,
-        );
+              return acc;
+            },
+            Object.create(null) as Record<string, FieldError>,
+          );
 
-        return toNestErrors(errors, options);
-      }),
-      Effect.tap(() =>
-        Effect.sync(
-          () =>
-            options.shouldUseNativeValidation &&
-            validateFieldsNatively({}, options),
-        ),
-      ),
-      Effect.match({
-        onFailure: (errors) => ({ errors, values: {} }),
-        onSuccess: (result) => ({ errors: {}, values: result }),
+          return { errors: toNestErrors(errors, options), values: {} };
+        },
+        onSuccess: (result) => {
+          options.shouldUseNativeValidation &&
+            validateFieldsNatively({}, options);
+
+          return { errors: {}, values: result };
+        },
       }),
       Effect.runPromise,
     );
-  };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hookform/resolvers",
   "amdName": "hookformResolvers",
-  "version": "5.9.2",
+  "version": "6.0.1",
   "description": "React Hook Form validation resolvers: Yup, Joi, Superstruct, Zod, Vest, Class Validator, io-ts, Nope, computed-types, TypeBox, arktype, Typanion, Effect-TS and VineJS",
   "main": "dist/resolvers.js",
   "module": "dist/resolvers.module.js",
@@ -226,7 +226,7 @@
     "build:arktype": "microbundle --cwd arktype --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm",
     "build:valibot": "microbundle --cwd valibot --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm",
     "build:typeschema": "microbundle --cwd typeschema --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm,@typeschema/main=main",
-    "build:effect-ts": "microbundle --cwd effect-ts --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm,effect=Effect,effect/SchemaAST=EffectSchemaAST,effect/ParseResult=EffectParseResult",
+    "build:effect-ts": "microbundle --cwd effect-ts --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm,effect=Effect,effect/SchemaAST=EffectSchemaAST",
     "build:vine": "microbundle --cwd vine --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm,@vinejs/vine=vine",
     "build:fluentvalidation-ts": "microbundle --cwd fluentvalidation-ts --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm",
     "build:standard-schema": "microbundle --cwd standard-schema --globals @hookform/resolvers=hookformResolvers,react-hook-form=ReactHookForm,@standard-schema/spec=standardSchema",
@@ -291,16 +291,16 @@
     "@vinejs/vine": "^4.4.0",
     "@vitejs/plugin-react": "^4.7.0",
     "ajv": "^8.20.0",
-    "ata-validator": "^1.23.0",
     "ajv-errors": "^3.0.0",
     "ajv-formats": "^2.1.1",
     "arktype": "2.0.4",
+    "ata-validator": "^1.23.0",
     "check-export-map": "^1.3.1",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.4",
     "computed-types": "^1.11.2",
     "cross-env": "^7.0.3",
-    "effect": "^3.22.0",
+    "effect": "^4.0.5",
     "fluentvalidation-ts": "^3.3.0",
     "fp-ts": "^2.16.11",
     "io-ts": "^2.2.22",
@@ -331,7 +331,6 @@
   "peerDependencies": {
     "@sinclair/typebox": ">=0.25.24",
     "@standard-schema/spec": "^1.0.0",
-    "@typeschema/main": ">=0.13.7",
     "@vinejs/vine": "^2.0.0 || ^3.0.0 || ^4.0.0",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
@@ -341,7 +340,7 @@
     "class-transformer": ">=0.4.0",
     "class-validator": ">=0.12.0",
     "computed-types": "^1.0.0",
-    "effect": "^3.10.3",
+    "effect": "^4.0.0",
     "fluentvalidation-ts": "^3.0.0",
     "fp-ts": "^2.7.0",
     "io-ts": "^2.0.0",
@@ -362,9 +361,6 @@
     "@standard-schema/spec": {
       "optional": true
     },
-    "@typeschema/main": {
-      "optional": true
-    },
     "@vinejs/vine": {
       "optional": true
     },

package/typeschema/package.json

@@ -13,6 +13,6 @@
   "peerDependencies": {
     "react-hook-form": "^7.55.0",
     "@hookform/resolvers": "^2.0.0",
-    "@typeschema/main": "^0.13.7"
+    "@standard-schema/spec": "^1.0.0"
   }
 }