@lucas-barake/effect-form 0.25.0-beta.0 → 0.25.0

package/src/FormAtoms.ts

@@ -1,9 +1,10 @@
+import * as Atom from "@effect-atom/atom/Atom"
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as Option from "effect/Option"
+import * as ParseResult from "effect/ParseResult"
 import * as Schema from "effect/Schema"
-import * as Atom from "effect/unstable/reactivity/Atom"
 import * as Field from "./Field.ts"
 import * as FormBuilder from "./FormBuilder.ts"
 import { recalculateDirtyFieldsForArray, recalculateDirtySubtree } from "./internal/dirty.ts"
@@ -18,7 +19,7 @@ export interface FieldAtoms {
   readonly touchedAtom: Atom.Writable<boolean, boolean>
   readonly errorAtom: Atom.Atom<Option.Option<Validation.ErrorEntry>>
   readonly isDirtyAtom: Atom.Atom<boolean>
-  readonly validationAtom: Atom.AtomResultFn<unknown, void, Schema.SchemaError>
+  readonly validationAtom: Atom.AtomResultFn<unknown, void, ParseResult.ParseError>
   readonly displayErrorAtom: Atom.Atom<Option.Option<string>>
   readonly fieldValidationCountAtom: Atom.Writable<number, number>
   readonly shouldValidateAtom: Atom.Atom<boolean>
@@ -53,9 +54,9 @@ export interface FormAtomsConfig<TFields extends Field.FieldsRecord, R, A, E, Su
 
 export type FieldRefs<TFields extends Field.FieldsRecord,> = {
   readonly [K in keyof TFields]: TFields[K] extends Field.FieldDef<any, infer S>
-    ? FormBuilder.FieldRef<Schema.Codec.Encoded<S>>
+    ? FormBuilder.FieldRef<Schema.Schema.Encoded<S>>
     : TFields[K] extends Field.ArrayFieldDef<any, infer S>
-      ? FormBuilder.FieldRef<ReadonlyArray<Schema.Codec.Encoded<S>>>
+      ? FormBuilder.FieldRef<ReadonlyArray<Schema.Schema.Encoded<S>>>
     : never
 }
 
@@ -75,22 +76,22 @@ export interface FormAtoms<TFields extends Field.FieldsRecord, R, A = void, E =
   readonly changedSinceSubmitFieldsAtom: Atom.Atom<ReadonlySet<string>>
   readonly hasChangedSinceSubmitAtom: Atom.Atom<boolean>
 
-  readonly submitAtom: Atom.AtomResultFn<SubmitArgs, A, E | Schema.SchemaError>
+  readonly submitAtom: Atom.AtomResultFn<SubmitArgs, A, E | ParseResult.ParseError>
   readonly validateAtom: Atom.AtomResultFn<void, void, never>
 
-  readonly combinedSchema: Schema.Codec<Field.DecodedFromFields<TFields>, Field.EncodedFromFields<TFields>, R>
+  readonly combinedSchema: Schema.Schema<Field.DecodedFromFields<TFields>, Field.EncodedFromFields<TFields>, R>
 
   readonly fieldRefs: FieldRefs<TFields>
 
-  readonly validationAtomsRegistry: WeakRegistry<Atom.AtomResultFn<unknown, void, Schema.SchemaError>>
+  readonly validationAtomsRegistry: WeakRegistry<Atom.AtomResultFn<unknown, void, ParseResult.ParseError>>
   readonly fieldAtomsRegistry: WeakRegistry<FieldAtoms>
 
   readonly getOrCreateValidationAtom: (
     fieldPath: string,
-    schema: Schema.Top
-  ) => Atom.AtomResultFn<unknown, void, Schema.SchemaError>
+    schema: Schema.Schema.Any
+  ) => Atom.AtomResultFn<unknown, void, ParseResult.ParseError>
 
-  readonly getOrCreateFieldAtoms: (fieldPath: string, schema: Schema.Top) => FieldAtoms
+  readonly getOrCreateFieldAtoms: (fieldPath: string, schema: Schema.Schema.Any) => FieldAtoms
 
   readonly resetValidationAtoms: (ctx: { set: <R, W,>(atom: Atom.Writable<R, W>, value: W) => void }) => void
 
@@ -155,7 +156,7 @@ export interface FormOperations<TFields extends Field.FieldsRecord,> {
   readonly appendArrayItem: (
     state: FormBuilder.FormState<TFields>,
     arrayPath: string,
-    itemSchema: Schema.Top,
+    itemSchema: Schema.Schema.Any,
     value?: unknown
   ) => FormBuilder.FormState<TFields>
 
@@ -258,14 +259,14 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
     })
   ).pipe(Atom.setIdleTTL(0))
 
-  const validationAtomsRegistry = createWeakRegistry<Atom.AtomResultFn<unknown, void, Schema.SchemaError>>()
+  const validationAtomsRegistry = createWeakRegistry<Atom.AtomResultFn<unknown, void, ParseResult.ParseError>>()
   const fieldAtomsRegistry = createWeakRegistry<FieldAtoms>()
   const publicFieldAtomsRegistry = createWeakRegistry<PublicFieldAtoms<unknown>>()
-  const validationSchemaRegistry = new Map<string, Schema.Top>()
-  const fieldSchemaRegistry = new Map<string, Schema.Top>()
+  const validationSchemaRegistry = new Map<string, Schema.Schema.Any>()
+  const fieldSchemaRegistry = new Map<string, Schema.Schema.Any>()
   const isDirtyAtomsRegistry = createWeakRegistry<Atom.Atom<boolean>>()
 
-  const fieldSchemasByKey = new Map<string, Schema.Top>()
+  const fieldSchemasByKey = new Map<string, Schema.Schema.Any>()
   for (const [key, def] of Object.entries(fields)) {
     if (Field.isArrayFieldDef(def)) {
       fieldSchemasByKey.set(key, Schema.Array(def.itemSchema))
@@ -276,24 +277,24 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
 
   const getOrCreateValidationAtom = (
     fieldPath: string,
-    schema: Schema.Top
-  ): Atom.AtomResultFn<unknown, void, Schema.SchemaError> => {
+    schema: Schema.Schema.Any
+  ): Atom.AtomResultFn<unknown, void, ParseResult.ParseError> => {
     const existing = validationAtomsRegistry.get(fieldPath)
     const existingSchema = validationSchemaRegistry.get(fieldPath)
     if (existing && existingSchema === schema) return existing
 
     const validationAtom = runtime
       .fn<unknown>()((value: unknown) =>
-        pipe(Schema.decodeUnknownEffect(schema)(value) as Effect.Effect<unknown, Schema.SchemaError, R>, Effect.asVoid)
+        pipe(Schema.decodeUnknown(schema)(value) as Effect.Effect<unknown, ParseResult.ParseError, R>, Effect.asVoid)
       )
-      .pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<unknown, void, Schema.SchemaError>
+      .pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<unknown, void, ParseResult.ParseError>
 
     validationAtomsRegistry.set(fieldPath, validationAtom)
     validationSchemaRegistry.set(fieldPath, schema)
     return validationAtom
   }
 
-  const getOrCreateFieldAtoms = (fieldPath: string, schema: Schema.Top): FieldAtoms => {
+  const getOrCreateFieldAtoms = (fieldPath: string, schema: Schema.Schema.Any): FieldAtoms => {
     const existing = fieldAtomsRegistry.get(fieldPath)
     const existingSchema = fieldSchemaRegistry.get(fieldPath)
     if (existing && existingSchema === schema) return existing
@@ -363,8 +364,8 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
 
       let livePerFieldError: Option.Option<string> = Option.none()
       if (validationResult._tag === "Failure") {
-        const parseError = Cause.findErrorOption(validationResult.cause)
-        if (Option.isSome(parseError) && Schema.isSchemaError(parseError.value)) {
+        const parseError = Cause.failureOption(validationResult.cause)
+        if (Option.isSome(parseError) && ParseResult.isParseError(parseError.value)) {
           livePerFieldError = Validation.extractFirstError(parseError.value)
         }
       }
@@ -469,9 +470,9 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
           const values = state.value.values
           get.set(errorsAtom, new Map())
           const decoded = yield* pipe(
-            Schema.decodeUnknownEffect(combinedSchema)(values, { errors: "all" }) as Effect.Effect<
+            Schema.decodeUnknown(combinedSchema, { errors: "all" })(values) as Effect.Effect<
               Field.DecodedFromFields<TFields>,
-              Schema.SchemaError,
+              ParseResult.ParseError,
               R
             >,
             Effect.tapError((parseError) =>
@@ -498,7 +499,7 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
         }),
       config.reactivityKeys ? { reactivityKeys: config.reactivityKeys } : undefined
     )
-    .pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<SubmitArgs, A, E | Schema.SchemaError>
+    .pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<SubmitArgs, A, E | ParseResult.ParseError>
 
   const validateAtom = runtime
     .fn<void>()(
@@ -509,12 +510,12 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
           const values = state.value.values
           get.set(errorsAtom, new Map())
           yield* pipe(
-            Schema.decodeUnknownEffect(combinedSchema)(values, { errors: "all" }) as Effect.Effect<
+            Schema.decodeUnknown(combinedSchema, { errors: "all" })(values) as Effect.Effect<
               Field.DecodedFromFields<TFields>,
-              Schema.SchemaError,
+              ParseResult.ParseError,
               R
             >,
-            Effect.catchTag("SchemaError", (parseError) =>
+            Effect.catchTag("ParseError", (parseError) =>
               Effect.sync(() => {
                 const routedErrors = Validation.routeErrorsWithSource(parseError)
                 get.set(errorsAtom, routedErrors)

package/src/FormBuilder.ts

@@ -1,9 +1,8 @@
+import type * as Registry from "@effect-atom/atom/Registry"
 import type * as Effect from "effect/Effect"
 import type * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
-import * as SchemaGetter from "effect/SchemaGetter"
-import type * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry"
 
 import type {
   AnyFieldDef,
@@ -15,11 +14,6 @@ import type {
 } from "./Field.ts"
 import { isArrayFieldDef, isFieldDef, makeField } from "./Field.ts"
 
-type FilterResult = undefined | boolean | string | {
-  readonly path: ReadonlyArray<PropertyKey>
-  readonly message: string
-}
-
 export interface SubmittedValues<TFields extends FieldsRecord,> {
   readonly encoded: EncodedFromFields<TFields>
   readonly decoded: DecodedFromFields<TFields>
@@ -57,12 +51,12 @@ export interface FormState<TFields extends FieldsRecord,> {
 
 interface SyncRefinement {
   readonly _tag: "sync"
-  readonly fn: (values: unknown) => FilterResult
+  readonly fn: (values: unknown) => Schema.FilterOutput
 }
 
 interface AsyncRefinement {
   readonly _tag: "async"
-  readonly fn: (values: unknown) => Effect.Effect<FilterResult, never, unknown>
+  readonly fn: (values: unknown) => Effect.Effect<Schema.FilterOutput, never, unknown>
 }
 
 type Refinement = SyncRefinement | AsyncRefinement
@@ -73,21 +67,21 @@ export interface FormBuilder<TFields extends FieldsRecord, R,> {
   readonly refinements: ReadonlyArray<Refinement>
   readonly _R?: R
 
-  addField<K extends string, S extends Schema.Top,>(
+  addField<K extends string, S extends Schema.Schema.Any,>(
     this: FormBuilder<TFields, R>,
     field: FieldDef<K, S>
-  ): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S> }, R | Schema.Codec.DecodingServices<S>>
+  ): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S> }, R | Schema.Schema.Context<S>>
 
-  addField<K extends string, S extends Schema.Top,>(
+  addField<K extends string, S extends Schema.Schema.Any,>(
     this: FormBuilder<TFields, R>,
     field: ArrayFieldDef<K, S>
-  ): FormBuilder<TFields & { readonly [key in K]: ArrayFieldDef<K, S> }, R | Schema.Codec.DecodingServices<S>>
+  ): FormBuilder<TFields & { readonly [key in K]: ArrayFieldDef<K, S> }, R | Schema.Schema.Context<S>>
 
-  addField<K extends string, S extends Schema.Top,>(
+  addField<K extends string, S extends Schema.Schema.Any,>(
     this: FormBuilder<TFields, R>,
     key: K,
     schema: S
-  ): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S> }, R | Schema.Codec.DecodingServices<S>>
+  ): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S> }, R | Schema.Schema.Context<S>>
 
   merge<TFields2 extends FieldsRecord, R2,>(
     this: FormBuilder<TFields, R>,
@@ -96,13 +90,13 @@ export interface FormBuilder<TFields extends FieldsRecord, R,> {
 
   refine(
     this: FormBuilder<TFields, R>,
-    predicate: (values: DecodedFromFields<TFields>) => FilterResult
+    predicate: (values: DecodedFromFields<TFields>) => Schema.FilterOutput
   ): FormBuilder<TFields, R>
 
   refineEffect<RD,>(
     this: FormBuilder<TFields, R>,
-    predicate: (values: DecodedFromFields<TFields>) => Effect.Effect<FilterResult, never, RD>
-  ): FormBuilder<TFields, R | Exclude<RD, AtomRegistry.AtomRegistry>>
+    predicate: (values: DecodedFromFields<TFields>) => Effect.Effect<Schema.FilterOutput, never, RD>
+  ): FormBuilder<TFields, R | Exclude<RD, Registry.AtomRegistry>>
 }
 
 const FormBuilderProto = {
@@ -110,7 +104,7 @@ const FormBuilderProto = {
   addField<TFields extends FieldsRecord, R,>(
     this: FormBuilder<TFields, R>,
     keyOrField: string | AnyFieldDef,
-    schema?: Schema.Top
+    schema?: Schema.Schema.Any
   ): FormBuilder<any, any> {
     const field = typeof keyOrField === "string"
       ? makeField(keyOrField, schema!)
@@ -131,7 +125,7 @@ const FormBuilderProto = {
   },
   refine<TFields extends FieldsRecord, R,>(
     this: FormBuilder<TFields, R>,
-    predicate: (values: DecodedFromFields<TFields>) => FilterResult
+    predicate: (values: DecodedFromFields<TFields>) => Schema.FilterOutput
   ): FormBuilder<TFields, R> {
     const newSelf = Object.create(FormBuilderProto)
     newSelf.fields = this.fields
@@ -143,8 +137,8 @@ const FormBuilderProto = {
   },
   refineEffect<TFields extends FieldsRecord, R, RD,>(
     this: FormBuilder<TFields, R>,
-    predicate: (values: DecodedFromFields<TFields>) => Effect.Effect<FilterResult, never, RD>
-  ): FormBuilder<TFields, R | Exclude<RD, AtomRegistry.AtomRegistry>> {
+    predicate: (values: DecodedFromFields<TFields>) => Effect.Effect<Schema.FilterOutput, never, RD>
+  ): FormBuilder<TFields, R | Exclude<RD, Registry.AtomRegistry>> {
     const newSelf = Object.create(FormBuilderProto)
     newSelf.fields = this.fields
     newSelf.refinements = [
@@ -167,8 +161,8 @@ export const empty: FormBuilder<{}, never> = (() => {
 
 export const buildSchema = <TFields extends FieldsRecord, R,>(
   self: FormBuilder<TFields, R>
-): Schema.Codec<DecodedFromFields<TFields>, EncodedFromFields<TFields>, R> => {
-  const schemaFields: Record<string, Schema.Top> = {}
+): Schema.Schema<DecodedFromFields<TFields>, EncodedFromFields<TFields>, R> => {
+  const schemaFields: Record<string, Schema.Schema.Any> = {}
   for (const [key, def] of Object.entries(self.fields)) {
     if (isArrayFieldDef(def)) {
       schemaFields[key] = Schema.Array(def.itemSchema)
@@ -177,22 +171,17 @@ export const buildSchema = <TFields extends FieldsRecord, R,>(
     }
   }
 
-  let schema: Schema.Codec<any, any, any, any> = Schema.Struct(schemaFields)
+  let schema: Schema.Schema<any, any, any> = Schema.Struct(schemaFields)
 
   for (const refinement of self.refinements) {
     if (refinement._tag === "sync") {
-      schema = schema.pipe(Schema.check(Schema.makeFilter((input) => refinement.fn(input))))
+      schema = schema.pipe(Schema.filter(refinement.fn))
     } else {
-      schema = schema.pipe(
-        Schema.decode({
-          decode: SchemaGetter.checkEffect((input) => refinement.fn(input)),
-          encode: SchemaGetter.passthrough()
-        })
-      )
+      schema = schema.pipe(Schema.filterEffect(refinement.fn))
     }
   }
 
-  return schema as Schema.Codec<
+  return schema as Schema.Schema<
     DecodedFromFields<TFields>,
     EncodedFromFields<TFields>,
     R

package/src/Mode.ts

@@ -24,9 +24,7 @@ export const parse = (mode?: FormMode): ParsedMode => {
   }
 
   if (validation === "onChange") {
-    const debounceMs = mode?.debounce === undefined
-      ? null
-      : Duration.toMillis(Duration.fromDurationInputUnsafe(mode.debounce))
+    const debounceMs = mode?.debounce === undefined ? null : Duration.toMillis(mode.debounce)
     const autoSubmit = mode?.autoSubmit === true
     return { validation: "onChange", debounce: debounceMs, autoSubmit }
   }

package/src/Validation.ts

@@ -1,6 +1,6 @@
 import * as Option from "effect/Option"
-import type * as Schema from "effect/Schema"
-import * as SchemaIssue from "effect/SchemaIssue"
+import * as ParseResult from "effect/ParseResult"
+import type * as AST from "effect/SchemaAST"
 import { schemaPathToFieldPath } from "./Path.ts"
 
 export type ErrorSource = "field" | "refinement"
@@ -13,51 +13,75 @@ export interface ErrorEntry {
 interface IssueSourceEntry {
   readonly path: ReadonlyArray<PropertyKey>
   readonly source: ErrorSource
-  readonly issue: SchemaIssue.Issue
+  readonly issue: ParseResult.ParseIssue
 }
 
-const standardFormatter = SchemaIssue.makeFormatterStandardSchemaV1()
+const getBaseAST = (ast: AST.AST): AST.AST => {
+  switch (ast._tag) {
+    case "Refinement":
+    case "Transformation":
+      return getBaseAST(ast.from)
+    default:
+      return ast
+  }
+}
+
+const isCompositeType = (ast: AST.AST): boolean => {
+  const base = getBaseAST(ast)
+  switch (base._tag) {
+    case "TypeLiteral": // Schema.Struct
+    case "TupleType": // Schema.Tuple
+    case "Declaration": // Schema.Class, Schema.TaggedClass
+    case "Union": // Schema.Union
+    case "Suspend": // Recursive schemas
+      return true
+    default:
+      return false
+  }
+}
 
-const collectIssueSources = (error: Schema.SchemaError): ReadonlyArray<IssueSourceEntry> => {
+const collectIssueSources = (error: ParseResult.ParseError): ReadonlyArray<IssueSourceEntry> => {
   const entries: Array<IssueSourceEntry> = []
 
-  const walk = (issue: SchemaIssue.Issue, path: ReadonlyArray<PropertyKey>, source: ErrorSource): void => {
+  const walk = (issue: ParseResult.ParseIssue, path: ReadonlyArray<PropertyKey>, source: ErrorSource): void => {
     switch (issue._tag) {
-      case "Filter":
-        if (path.length === 0) {
+      case "Refinement":
+        if (issue.kind === "Predicate" && isCompositeType(issue.ast.from) && path.length === 0) {
           walk(issue.issue, path, "refinement")
         } else {
           walk(issue.issue, path, source)
         }
         break
-      case "Encoding":
-        if (path.length === 0) {
-          walk(issue.issue, path, "refinement")
-        } else {
-          walk(issue.issue, path, source)
-        }
-        break
-      case "Pointer":
-        walk(issue.issue, [...path, ...issue.path], source)
-        break
-      case "Composite":
-        for (const sub of issue.issues) {
-          walk(sub, path, source)
-        }
+      case "Pointer": {
+        const pointerPath = Array.isArray(issue.path) ? issue.path : [issue.path]
+        walk(issue.issue, [...path, ...pointerPath], source)
         break
-      case "AnyOf":
-        for (const sub of issue.issues) {
+      }
+      case "Composite": {
+        const issues = Array.isArray(issue.issues) ? issue.issues : [issue.issues]
+        for (const sub of issues) {
           walk(sub, path, source)
         }
         break
-      case "InvalidType":
-      case "InvalidValue":
-      case "MissingKey":
-      case "UnexpectedKey":
+      }
+      case "Type":
+      case "Missing":
+      case "Unexpected":
       case "Forbidden":
-      case "OneOf":
         entries.push({ path, source, issue })
         break
+      case "Transformation":
+        if (
+          issue.kind === "Transformation" &&
+          issue.ast.transformation._tag === "FinalTransformation" &&
+          isCompositeType(issue.ast.from) &&
+          path.length === 0
+        ) {
+          walk(issue.issue, path, "refinement")
+        } else {
+          walk(issue.issue, path, source)
+        }
+        break
     }
   }
 
@@ -65,34 +89,25 @@ const collectIssueSources = (error: Schema.SchemaError): ReadonlyArray<IssueSour
   return entries
 }
 
-const getIssueMessage = (issue: SchemaIssue.Issue): string | undefined => {
-  const formatted = standardFormatter(issue)
-  return formatted.issues[0]?.message
+const getIssueMessage = (issue: ParseResult.ParseIssue): string | undefined => {
+  const formatted = ParseResult.ArrayFormatter.formatIssueSync(issue)
+  return formatted[0]?.message
 }
 
-export const extractFirstError = (error: Schema.SchemaError): Option.Option<string> => {
-  const formatted = standardFormatter(error.issue)
-  if (formatted.issues.length === 0) {
+export const extractFirstError = (error: ParseResult.ParseError): Option.Option<string> => {
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(error)
+  if (issues.length === 0) {
     return Option.none()
   }
-  return Option.some(formatted.issues[0].message)
-}
-
-const normalizePath = (
-  path: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined
-): ReadonlyArray<PropertyKey> => {
-  if (!path) return []
-  return path.map((segment) =>
-    typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment as PropertyKey
-  )
+  return Option.some(issues[0].message)
 }
 
-export const routeErrors = (error: Schema.SchemaError): Map<string, string> => {
+export const routeErrors = (error: ParseResult.ParseError): Map<string, string> => {
   const result = new Map<string, string>()
-  const formatted = standardFormatter(error.issue)
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(error)
 
-  for (const issue of formatted.issues) {
-    const fieldPath = schemaPathToFieldPath(normalizePath(issue.path))
+  for (const issue of issues) {
+    const fieldPath = schemaPathToFieldPath(issue.path)
     if (fieldPath && !result.has(fieldPath)) {
       result.set(fieldPath, issue.message)
     }
@@ -101,9 +116,9 @@ export const routeErrors = (error: Schema.SchemaError): Map<string, string> => {
   return result
 }
 
-export const routeErrorsWithSource = (error: Schema.SchemaError): Map<string, ErrorEntry> => {
+export const routeErrorsWithSource = (error: ParseResult.ParseError): Map<string, ErrorEntry> => {
   const result = new Map<string, ErrorEntry>()
-  const formattedIssues = standardFormatter(error.issue).issues
+  const formattedIssues = ParseResult.ArrayFormatter.formatErrorSync(error)
   const issueSources = collectIssueSources(error)
   const messageSources = new Map<string, ErrorSource>()
   const refinementPaths = new Set<string>()
@@ -124,7 +139,7 @@ export const routeErrorsWithSource = (error: Schema.SchemaError): Map<string, Er
   }
 
   for (const issue of formattedIssues) {
-    const fieldPath = schemaPathToFieldPath(normalizePath(issue.path)) ?? ""
+    const fieldPath = schemaPathToFieldPath(issue.path) ?? ""
     if (result.has(fieldPath)) continue
     const preferredSource: ErrorSource = refinementPaths.has(fieldPath) ? "refinement" : "field"
     const messageKey = `${fieldPath}::${issue.message}`
@@ -137,7 +152,7 @@ export const routeErrorsWithSource = (error: Schema.SchemaError): Map<string, Er
 
   if (result.size < formattedIssues.length) {
     for (const issue of formattedIssues) {
-      const fieldPath = schemaPathToFieldPath(normalizePath(issue.path)) ?? ""
+      const fieldPath = schemaPathToFieldPath(issue.path) ?? ""
       if (result.has(fieldPath)) continue
       const messageKey = `${fieldPath}::${issue.message}`
       const issueSource = messageSources.get(messageKey) ?? "field"

package/src/internal/dirty.ts

@@ -1,4 +1,5 @@
 import * as Equal from "effect/Equal"
+import * as Utils from "effect/Utils"
 import { getNestedValue, isPathUnderRoot } from "../Path.ts"
 
 export const recalculateDirtyFieldsForArray = (
@@ -25,7 +26,8 @@ export const recalculateDirtyFieldsForArray = (
 
     if (newItem === initialItem) continue
 
-    if (!Equal.equals(newItem, initialItem)) {
+    const isEqual = Utils.structuralRegion(() => Equal.equals(newItem, initialItem))
+    if (!isEqual) {
       nextDirty.add(itemPath)
     }
   }
@@ -95,7 +97,8 @@ export const recalculateDirtySubtree = (
         }
       }
     } else {
-      if (!Equal.equals(current, initial) && path) nextDirty.add(path)
+      const isEqual = Utils.structuralRegion(() => Equal.equals(current, initial))
+      if (!isEqual && path) nextDirty.add(path)
     }
   }