@effect-app/vue-components 4.0.0-beta.6 → 4.0.0-beta.61

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -1,16 +1,30 @@
-import type * as Effect from "effect/Effect"
-import * as AST from "effect/SchemaAST"
+import { Effect, Option, type Record, S } from "effect-app"
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { type DeepKeys, type DeepValue, type FieldAsyncValidateOrFn, type FieldValidateOrFn, type FormApi, type FormAsyncValidateOrFn, type FormOptions, type FormState, type FormValidateOrFn, type StandardSchemaV1, type VueFormApi } from "@tanstack/vue-form"
 import { isObject } from "@vueuse/core"
-import * as S from "effect/Schema"
+import type { Fiber as EffectFiber } from "effect/Fiber"
+import type { Redacted } from "effect/Redacted"
 import { getTransformationFrom, useIntl } from "../../utils"
 import { type OmegaFieldInternalApi } from "./InputProps"
 import { type OF, type OmegaFormReturn } from "./useOmegaForm"
 
+const legacyTagWarningEmittedFor = new Set<string>()
+type GlobalThisWithOptionalProcess = typeof globalThis & {
+  process?: {
+    env?: {
+      NODE_ENV?: string
+    }
+  }
+}
+
+const isDevelopmentEnvironment = () => {
+  const process = (globalThis as GlobalThisWithOptionalProcess).process
+  return process?.env?.NODE_ENV !== "production"
+}
+
 export type FieldPath<T> = unknown extends T ? string
   // technically we cannot have primitive at the root
-  : T extends string | boolean | number | null | undefined | symbol | bigint ? ""
+  : T extends string | boolean | number | null | undefined | symbol | bigint | Redacted<any> ? ""
   // technically we cannot have array at the root
   : T extends ReadonlyArray<infer U> ? FieldPath_<U, `[${number}]`>
   : {
@@ -18,7 +32,7 @@ export type FieldPath<T> = unknown extends T ? string
   }[keyof T]
 
 export type FieldPath_<T, Path extends string> = unknown extends T ? string
-  : T extends string | boolean | number | null | undefined | symbol | bigint ? Path
+  : T extends string | boolean | number | null | undefined | symbol | bigint | Redacted<any> ? Path
   : T extends ReadonlyArray<infer U> ? FieldPath_<U, `${Path}[${number}]`> | Path
   : {
     [K in keyof T]: FieldPath_<T[K], `${Path}.${K & string}`>
@@ -145,7 +159,7 @@ export type FormProps<From, To> =
       formApi: OmegaFormParams<From, To>
       meta: any
       value: To
-    }) => Promise<any> | Effect.Effect<unknown, any, never>
+    }) => Promise<any> | EffectFiber<any, any> | Effect.Effect<unknown, any, never>
   }
 
 export type OmegaFormParams<From, To> = FormApi<
@@ -223,7 +237,13 @@ export type PrefixFromDepth<
   _TDepth extends any[]
 > = K
 
-export type NestedKeyOf<T> = DeepKeys<T>
+// Recursively replace Redacted<A> with its inner type so DeepKeys treats it as a leaf
+type StripRedacted<T> = T extends Redacted<any> ? string
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<StripRedacted<U>>
+  : T extends Record<string, any> ? { [K in keyof T]: StripRedacted<T[K]> }
+  : T
+
+export type NestedKeyOf<T> = DeepKeys<StripRedacted<T>>
 
 export type FieldValidators<T> = {
   onChangeAsync?: FieldAsyncValidateOrFn<T, any, any>
@@ -262,13 +282,17 @@ export type SelectFieldMeta = BaseFieldMeta & {
 export type MultipleFieldMeta = BaseFieldMeta & {
   type: "multiple"
   members: any[] // TODO: should be non empty array?
-  rest: readonly AST.AST[]
+  rest: readonly S.AST.AST[]
 }
 
 export type BooleanFieldMeta = BaseFieldMeta & {
   type: "boolean"
 }
 
+export type DateFieldMeta = BaseFieldMeta & {
+  type: "date"
+}
+
 export type UnknownFieldMeta = BaseFieldMeta & {
   type: "unknown"
 }
@@ -279,6 +303,7 @@ export type FieldMeta =
   | SelectFieldMeta
   | MultipleFieldMeta
   | BooleanFieldMeta
+  | DateFieldMeta
   | UnknownFieldMeta
 
 export type MetaRecord<T = string> = {
@@ -301,34 +326,57 @@ export type CreateMeta =
   }
   & (
     | {
-      propertySignatures: readonly AST.PropertySignature[]
+      propertySignatures: readonly S.AST.PropertySignature[]
       property?: never
     }
     | {
       propertySignatures?: never
-      property: AST.AST
+      property: S.AST.AST
     }
   )
 
-const getNullableOrUndefined = (property: AST.AST) => {
-  if (!AST.isUnion(property)) return false
-  return property.types.find((_) => AST.isUndefined(_) || _ === S.Null.ast)
+const unwrapDeclaration = (property: S.AST.AST): S.AST.AST => {
+  let current = getTransformationFrom(property)
+
+  while (S.AST.isDeclaration(current) && current.typeParameters.length > 0) {
+    current = getTransformationFrom(current.typeParameters[0]!)
+  }
+
+  return current
 }
 
-export const isNullableOrUndefined = (property: false | AST.AST | undefined) => {
-  if (!property || !AST.isUnion(property)) return false
-  if (property.types.find((_) => AST.isUndefined(_))) {
+const isNullishType = (property: S.AST.AST) => S.AST.isUndefined(property) || S.AST.isNull(property)
+
+/**
+ * Unwrap a single-element Union to its inner type if it's a Literal.
+ * After AST.toType, S.Struct({ _tag: S.Literal("X") }) produces Union([Literal("X")])
+ * instead of bare Literal("X") like S.TaggedStruct does.
+ * TODO: remove after manual _tag deprecation
+ */
+const unwrapSingleLiteralUnion = (ast: S.AST.AST): S.AST.AST =>
+  S.AST.isUnion(ast) && ast.types.length === 1 && S.AST.isLiteral(ast.types[0]!)
+    ? ast.types[0]!
+    : ast
+
+const getNullableOrUndefined = (property: S.AST.AST) =>
+  S.AST.isUnion(property)
+    ? property.types.find((_) => isNullishType(_))
+    : false
+
+export const isNullableOrUndefined = (property: false | S.AST.AST | undefined) => {
+  if (!property || !S.AST.isUnion(property)) return false
+  if (property.types.find((_) => S.AST.isUndefined(_))) {
     return "undefined"
   }
-  if (property.types.find((_) => _ === S.Null.ast)) return "null"
+  if (property.types.find((_) => S.AST.isNull(_))) return "null"
   return false
 }
 
 // Helper function to recursively unwrap nested unions (e.g., S.NullOr(S.NullOr(X)) -> X)
-const unwrapNestedUnions = (types: readonly AST.AST[]): readonly AST.AST[] => {
-  const result: AST.AST[] = []
+const unwrapNestedUnions = (types: readonly S.AST.AST[]): readonly S.AST.AST[] => {
+  const result: S.AST.AST[] = []
   for (const type of types) {
-    if (AST.isUnion(type)) {
+    if (S.AST.isUnion(type)) {
       // Recursively unwrap nested unions
       const unwrapped = unwrapNestedUnions(type.types)
       result.push(...unwrapped)
@@ -339,31 +387,127 @@ const unwrapNestedUnions = (types: readonly AST.AST[]): readonly AST.AST[] => {
   return result
 }
 
+const getNonNullTypes = (types: readonly S.AST.AST[]) =>
+  unwrapNestedUnions(types)
+    .map(unwrapDeclaration)
+    .filter((_) => !isNullishType(_))
+
+const getJsonSchemaAnnotation = (property: S.AST.AST): Record<string, unknown> => {
+  const jsonSchema = S.AST.resolve(property)?.jsonSchema
+  return jsonSchema && typeof jsonSchema === "object" ? jsonSchema as Record<string, unknown> : {}
+}
+
+const extractDefaultFromLink = (link: any): unknown | undefined => {
+  if (!link?.transformation?.decode?.run) return undefined
+  try {
+    const result = Effect.runSync(link.transformation.decode.run(Option.none())) as Option.Option<unknown>
+    return Option.isSome(result) ? result.value : undefined
+  } catch {
+    return undefined
+  }
+}
+
+const getDefaultFromAst = (property: S.AST.AST) => {
+  // 1. Check withDefaultConstructor (stored in context.defaultValue)
+  const constructorLink = property.context?.defaultValue?.[0]
+  const constructorDefault = extractDefaultFromLink(constructorLink)
+  if (constructorDefault !== undefined) return constructorDefault
+
+  // 2. Check withDecodingDefault (stored in encoding)
+  const encodingLink = property.encoding?.[0]
+  if (encodingLink && property.context?.isOptional) {
+    return extractDefaultFromLink(encodingLink)
+  }
+
+  return undefined
+}
+
+const getCheckMetas = (property: S.AST.AST): Array<Record<string, any>> => {
+  const checks = property.checks ?? []
+
+  return checks.flatMap((check) => {
+    if (check._tag === "FilterGroup") {
+      return check.checks.flatMap((inner) => {
+        const meta = inner.annotations?.meta
+        return meta && typeof meta === "object" ? [meta as Record<string, any>] : []
+      })
+    }
+
+    const meta = check.annotations?.meta
+    return meta && typeof meta === "object" ? [meta as Record<string, any>] : []
+  })
+}
+
+const getFieldMetadataFromAst = (property: S.AST.AST) => {
+  const base: Partial<FieldMeta> & Record<string, unknown> = {
+    description: S.AST.resolveDescription(property)
+  }
+  const checks = getCheckMetas(property)
+
+  if (S.AST.isString(property)) {
+    base.type = "string"
+    for (const check of checks) {
+      switch (check._tag) {
+        case "isMinLength":
+          base.minLength = check.minLength
+          break
+        case "isMaxLength":
+          base.maxLength = check.maxLength
+          break
+      }
+    }
+
+    if (S.AST.resolveTitle(property) === "Email") {
+      base.format = "email"
+    }
+  } else if (S.AST.isNumber(property)) {
+    base.type = "number"
+    for (const check of checks) {
+      switch (check._tag) {
+        case "isInt":
+          base.refinement = "int"
+          break
+        case "isGreaterThanOrEqualTo":
+          base.minimum = check.minimum
+          break
+        case "isLessThanOrEqualTo":
+          base.maximum = check.maximum
+          break
+        case "isBetween":
+          base.minimum = check.minimum
+          base.maximum = check.maximum
+          break
+        case "isGreaterThan":
+          base.exclusiveMinimum = check.exclusiveMinimum
+          break
+        case "isLessThan":
+          base.exclusiveMaximum = check.exclusiveMaximum
+          break
+      }
+    }
+  } else if (S.AST.isBoolean(property)) {
+    base.type = "boolean"
+  } else if (
+    S.AST.isDeclaration(property)
+    && (property.annotations as any)?.typeConstructor?._tag === "Date"
+  ) {
+    base.type = "date"
+  } else {
+    base.type = "unknown"
+  }
+
+  return base
+}
+
 export const createMeta = <T = any>(
   { meta = {}, parent = "", property, propertySignatures }: CreateMeta,
   acc: Partial<MetaRecord<T>> = {}
 ): MetaRecord<T> | FieldMeta => {
-  // unwraps class (Class are transformations)
-  // this calls createMeta recursively, so wrapped transformations are also unwrapped
-  // BUT: check for Int title annotation first - S.Int and branded Int have title "Int" or "int"
-  // and we don't want to lose that information by unwrapping
-  if (property && AST.isDeclaration(property)) {
-    const titleOnTransform = property.annotations?.title ?? ""
-
-    // only unwrap if this is NOT an Int type
-    if (titleOnTransform !== "Int" && titleOnTransform !== "int") {
-      // In v4, Declaration doesn't have a 'from' property
-      // Just return the property as-is
-      return createMeta<T>({
-        parent,
-        meta,
-        property
-      })
-    }
-    // if it's Int, fall through to process it with the Int type
+  if (property) {
+    property = unwrapDeclaration(property)
   }
 
-  if (property && AST.isObjects(property)) {
+  if (property && S.AST.isObjects(property)) {
     return createMeta<T>({
       meta,
       propertySignatures: property.propertySignatures
@@ -375,12 +519,9 @@ export const createMeta = <T = any>(
       const key = parent ? `${parent}.${p.name.toString()}` : p.name.toString()
       const nullableOrUndefined = isNullableOrUndefined(p.type)
 
-      // Check if this property has title "Int" or "int" annotation (from Int brand wrapper)
-      const propertyTitle = p.type.annotations?.title ?? ""
-      const isIntField = propertyTitle === "Int" || propertyTitle === "int"
-
       // Determine if this field should be required:
       // - For nullable discriminated unions, only _tag should be non-required
+      // - optionalKey fields are not required
       // - All other fields should calculate their required status normally
       let isRequired: boolean
       if (meta._isNullableDiscriminatedUnion && p.name.toString() === "_tag") {
@@ -389,25 +530,18 @@ export const createMeta = <T = any>(
       } else if (meta.required === false) {
         // Explicitly set to non-required (legacy behavior for backwards compatibility)
         isRequired = false
+      } else if ((p.type as any).context?.isOptional) {
+        isRequired = false
       } else {
         // Calculate from the property itself
         isRequired = !nullableOrUndefined
       }
 
-      const typeToProcess = p.type
-      if (AST.isUnion(p.type)) {
-        // First unwrap any nested unions, then filter out null/undefined
-        const unwrappedTypes = unwrapNestedUnions(p.type.types)
-        const nonNullTypes = unwrappedTypes
-          .filter(
-            (t) => !AST.isUndefined(t) && !AST.isNull(t)
-          )
-          // unwraps class (Class are transformations)
-          .map(getTransformationFrom)
+      const typeToProcess = unwrapDeclaration(p.type)
+      if (S.AST.isUnion(p.type)) {
+        const nonNullTypes = getNonNullTypes(p.type.types)
 
-        const hasStructMembers = nonNullTypes.some(
-          (t) => AST.isObjects(t)
-        )
+        const hasStructMembers = nonNullTypes.some(S.AST.isObjects)
 
         if (hasStructMembers) {
           // Only create parent meta for non-NullOr unions to avoid duplicates
@@ -422,25 +556,38 @@ export const createMeta = <T = any>(
 
           // Process each non-null type and merge their metadata
           for (const nonNullType of nonNullTypes) {
-            if (AST.isObjects(nonNullType)) {
+            if (S.AST.isObjects(nonNullType)) {
               // For discriminated unions (multiple branches):
               // - If the parent union is nullable, only _tag should be non-required
               // - All other fields maintain their normal required status based on their own types
               const isNullableDiscriminatedUnion = nullableOrUndefined && nonNullTypes.length > 1
 
-              Object.assign(
-                acc,
-                createMeta<T>({
-                  parent: key,
-                  propertySignatures: nonNullType.propertySignatures,
-                  meta: isNullableDiscriminatedUnion ? { _isNullableDiscriminatedUnion: true } : {}
-                })
-              )
+              const branchMeta = createMeta<T>({
+                parent: key,
+                propertySignatures: nonNullType.propertySignatures,
+                meta: isNullableDiscriminatedUnion ? { _isNullableDiscriminatedUnion: true } : {}
+              })
+
+              // Merge branch metadata, combining select members for shared discriminator fields
+              for (const [metaKey, metaValue] of Object.entries(branchMeta)) {
+                const existing = acc[metaKey as NestedKeyOf<T>] as FieldMeta | undefined
+                if (
+                  existing && existing.type === "select" && (metaValue as any)?.type === "select"
+                ) {
+                  existing.members = [
+                    ...existing.members,
+                    ...(metaValue as SelectFieldMeta).members.filter(
+                      (m: any) => !existing.members.includes(m)
+                    )
+                  ]
+                } else {
+                  acc[metaKey as NestedKeyOf<T>] = metaValue as FieldMeta
+                }
+              }
             }
           }
         } else {
-          // Check if any of the union types are arrays
-          const arrayTypes = nonNullTypes.filter(AST.isArrays)
+          const arrayTypes = nonNullTypes.filter(S.AST.isArrays)
           if (arrayTypes.length > 0) {
             const arrayType = arrayTypes[0] // Take the first array type
 
@@ -454,8 +601,8 @@ export const createMeta = <T = any>(
 
             // If the array has struct elements, also create metadata for their properties
             if (arrayType.rest && arrayType.rest.length > 0) {
-              const restElement = arrayType.rest[0]
-              if (AST.isObjects(restElement)) {
+              const restElement = unwrapDeclaration(arrayType.rest[0]!)
+              if (S.AST.isObjects(restElement)) {
                 for (const prop of restElement.propertySignatures) {
                   const propKey = `${key}.${prop.name.toString()}`
 
@@ -473,12 +620,12 @@ export const createMeta = <T = any>(
                     acc[propKey as NestedKeyOf<T>] = propMeta as FieldMeta
 
                     if (
-                      propMeta.type === "multiple" && AST.isArrays(prop.type) && prop
+                      propMeta.type === "multiple" && S.AST.isArrays(prop.type) && prop
                         .type
                         .rest && prop.type.rest.length > 0
                     ) {
-                      const nestedRestElement = prop.type.rest[0]
-                      if (AST.isObjects(nestedRestElement)) {
+                      const nestedRestElement = unwrapDeclaration(prop.type.rest[0]!)
+                      if (S.AST.isObjects(nestedRestElement)) {
                         for (const nestedProp of nestedRestElement.propertySignatures) {
                           const nestedPropKey = `${propKey}.${nestedProp.name.toString()}`
 
@@ -513,34 +660,32 @@ export const createMeta = <T = any>(
           }
         }
       } else {
-        // Unwrap transformations (like ExtendedClass) to check for propertySignatures
-        const unwrappedTypeToProcess = getTransformationFrom(typeToProcess)
-        if (AST.isObjects(unwrappedTypeToProcess)) {
+        if (S.AST.isObjects(typeToProcess)) {
           Object.assign(
             acc,
             createMeta<T>({
               parent: key,
-              propertySignatures: unwrappedTypeToProcess.propertySignatures,
+              propertySignatures: typeToProcess.propertySignatures,
               meta: { required: isRequired, nullableOrUndefined }
             })
           )
-        } else if (AST.isArrays(p.type)) {
+        } else if (S.AST.isArrays(p.type)) {
           // Check if it has struct elements
           const hasStructElements = p.type.rest.length > 0
-            && AST.isObjects(p.type.rest[0])
+            && S.AST.isObjects(unwrapDeclaration(p.type.rest[0]!))
 
           if (hasStructElements) {
             // For arrays with struct elements, only create meta for nested fields, not the array itself
-            const elementType = p.type.rest[0]
-            if (AST.isObjects(elementType)) {
+            const elementType = unwrapDeclaration(p.type.rest[0]!)
+            if (S.AST.isObjects(elementType)) {
               // Process each property in the array element
               for (const prop of elementType.propertySignatures) {
                 const propKey = `${key}.${prop.name.toString()}`
 
                 // Check if the property is another array
-                if (AST.isArrays(prop.type) && prop.type.rest.length > 0) {
-                  const nestedElementType = prop.type.rest[0]
-                  if (AST.isObjects(nestedElementType)) {
+                if (S.AST.isArrays(prop.type) && prop.type.rest.length > 0) {
+                  const nestedElementType = unwrapDeclaration(prop.type.rest[0]!)
+                  if (S.AST.isObjects(nestedElementType)) {
                     // Array with struct elements - process nested fields
                     for (const nestedProp of nestedElementType.propertySignatures) {
                       const nestedKey = `${propKey}.${nestedProp.name.toString()}`
@@ -592,9 +737,11 @@ export const createMeta = <T = any>(
             parent: key,
             property: p.type,
             meta: {
-              required: isRequired,
-              nullableOrUndefined,
-              ...(isIntField && { refinement: "int" })
+              // an empty string is valid for a S.String field, so we should not mark it as required
+              // TODO: handle this better via the createMeta minLength parsing
+              required: isRequired
+                && (!S.AST.isString(typeToProcess) || !!getFieldMetadataFromAst(typeToProcess).minLength),
+              nullableOrUndefined
             }
           })
 
@@ -607,19 +754,30 @@ export const createMeta = <T = any>(
 
   if (property) {
     const nullableOrUndefined = getNullableOrUndefined(property)
+    property = unwrapDeclaration(property)
 
     if (!Object.hasOwnProperty.call(meta, "required")) {
       meta["required"] = !nullableOrUndefined
     }
 
-    if (AST.isUnion(property)) {
-      // First unwrap any nested unions, then filter out null/undefined
-      const unwrappedTypes = unwrapNestedUnions(property.types)
-      const nonNullType = unwrappedTypes.find(
-        (t) => !AST.isUndefined(t) && !AST.isNull(t)
-      )!
+    if (S.AST.isUnion(property)) {
+      const unwrappedTypes = unwrapNestedUnions(property.types).map(unwrapDeclaration)
+      const nonNullTypes = unwrappedTypes.filter((t) => !isNullishType(t))
+
+      // Unwrap single-element unions when the literal is a boolean
+      // (effect-app's S.Literal wraps as S.Literals([x]) → Union([Literal(x)]))
+      // Don't unwrap string/number literals — they may be discriminator values in a union
+      if (
+        nonNullTypes.length === 1
+        && S.AST.isLiteral(nonNullTypes[0]!)
+        && typeof nonNullTypes[0]!.literal === "boolean"
+      ) {
+        return createMeta<T>({ parent, meta, property: nonNullTypes[0]! })
+      }
+
+      const nonNullType = nonNullTypes[0]!
 
-      if (AST.isObjects(nonNullType)) {
+      if (S.AST.isObjects(nonNullType)) {
         return createMeta<T>({
           propertySignatures: nonNullType.propertySignatures,
           parent,
@@ -627,11 +785,13 @@ export const createMeta = <T = any>(
         })
       }
 
-      if (unwrappedTypes.every(AST.isLiteral)) {
+      // TODO: remove after manual _tag deprecation — unwrap legacy S.Struct({ _tag: S.Literal("X") }) pattern
+      const resolvedTypes = unwrappedTypes.map(unwrapSingleLiteralUnion)
+      if (resolvedTypes.every((_) => isNullishType(_) || S.AST.isLiteral(_))) {
         return {
           ...meta,
           type: "select",
-          members: unwrappedTypes.map((t) => t.literal)
+          members: resolvedTypes.filter(S.AST.isLiteral).map((t) => t.literal)
         } as FieldMeta
       }
 
@@ -645,7 +805,7 @@ export const createMeta = <T = any>(
       } as FieldMeta
     }
 
-    if (AST.isArrays(property)) {
+    if (S.AST.isArrays(property)) {
       return {
         ...meta,
         type: "multiple",
@@ -654,38 +814,7 @@ export const createMeta = <T = any>(
       } as FieldMeta
     }
 
-    const JSONAnnotation = (property.annotations?.jsonSchema ?? {}) as Record<string, unknown>
-
-    meta = { ...JSONAnnotation, ...meta }
-
-    // check the title annotation BEFORE following "from" to detect refinements like S.Int
-    let titleType = property.annotations?.title ?? "unknown"
-
-    // Detect basic types from AST if no title annotation
-    if (titleType === "unknown") {
-      if (AST.isString(property)) {
-        titleType = "string"
-      } else if (AST.isNumber(property)) {
-        titleType = "number"
-      } else if (AST.isBoolean(property)) {
-        titleType = "boolean"
-      }
-    }
-
-    // if this is S.Int (a refinement), set the type and skip following "from"
-    // otherwise we'd lose the "Int" information and get "number" instead
-    if (titleType === "Int" || titleType === "int") {
-      meta["type"] = "number"
-      meta["refinement"] = "int"
-      // don't follow "from" for Int refinements
-    } else {
-      meta["type"] = titleType
-    }
-
-    // Always ensure required is set before returning
-    if (!Object.hasOwnProperty.call(meta, "required")) {
-      meta["required"] = !nullableOrUndefined
-    }
+    meta = { ...getJsonSchemaAnnotation(property), ...getFieldMetadataFromAst(property), ...meta }
 
     return meta as FieldMeta
   }
@@ -711,27 +840,21 @@ const flattenMeta = <T>(meta: MetaRecord<T> | FieldMeta, parentKey: string = "")
   return result
 }
 
-const _schemaFromAst = (ast: AST.AST): S.Codec<any> => S.make(ast)
-
-const metadataFromAst = <_From, To>(
-  schema: any // v4 Schema type is complex, use any for now
+const metadataFromAst = <From, To>(
+  schema: S.Codec<To, From, never>
 ): { meta: MetaRecord<To>; defaultValues: Record<string, any>; unionMeta: Record<string, MetaRecord<To>> } => {
-  const ast = schema.ast
+  const ast = unwrapDeclaration(schema.ast)
   const newMeta: MetaRecord<To> = {}
   const defaultValues: Record<string, any> = {}
   const unionMeta: Record<string, MetaRecord<To>> = {}
 
   // Handle root-level Union types (discriminated unions)
-  if (AST.isUnion(ast)) {
-    const types = ast.types
-
+  if (S.AST.isUnion(ast)) {
     // Filter out null/undefined types and unwrap transformations
-    const nonNullTypes = types
-      .filter((t: any) => !AST.isUndefined(t) && !AST.isNull(t))
-      .map(getTransformationFrom)
+    const nonNullTypes = getNonNullTypes(ast.types)
 
     // Check if this is a discriminated union (all members are structs)
-    const allStructs = nonNullTypes.every((t: any) => AST.isObjects(t))
+    const allStructs = nonNullTypes.every(S.AST.isObjects)
 
     if (allStructs && nonNullTypes.length > 0) {
       // Extract discriminator values from each union member
@@ -739,16 +862,32 @@ const metadataFromAst = <_From, To>(
 
       // Store metadata for each union member by its tag value
       for (const memberType of nonNullTypes) {
-        if (AST.isObjects(memberType)) {
+        if (S.AST.isObjects(memberType)) {
           // Find the discriminator field (usually _tag)
           const tagProp = memberType.propertySignatures.find(
-            (p: any) => p.name.toString() === "_tag"
+            (p) => p.name.toString() === "_tag"
           )
 
           let tagValue: string | null = null
-          if (tagProp && AST.isLiteral(tagProp.type)) {
-            tagValue = tagProp.type.literal as string
+          // TODO: remove after manual _tag deprecation — unwrap legacy S.Struct({ _tag: S.Literal("X") }) pattern
+          const resolvedTagType = tagProp ? unwrapSingleLiteralUnion(tagProp.type) : null
+          if (resolvedTagType && S.AST.isLiteral(resolvedTagType)) {
+            tagValue = resolvedTagType.literal as string
             discriminatorValues.push(tagValue)
+            // Warn if the tag was wrapped in a single-element Union (legacy pattern)
+            if (
+              tagProp
+              && S.AST.isUnion(tagProp.type)
+              && isDevelopmentEnvironment()
+              && tagValue != null
+              && !legacyTagWarningEmittedFor.has(tagValue)
+            ) {
+              legacyTagWarningEmittedFor.add(tagValue)
+              console.warn(
+                `[OmegaForm] Union member with _tag "${tagValue}" uses S.Struct({ _tag: S.Literal("${tagValue}"), ... }). `
+                  + `Please migrate to S.TaggedStruct("${tagValue}", { ... }) for cleaner AST handling.`
+              )
+            }
           }
 
           // Create metadata for this member's properties
@@ -779,7 +918,7 @@ const metadataFromAst = <_From, To>(
     }
   }
 
-  if (AST.isObjects(ast)) {
+  if (S.AST.isObjects(ast)) {
     const meta = createMeta<To>({
       propertySignatures: ast.propertySignatures
     })
@@ -808,16 +947,80 @@ const metadataFromAst = <_From, To>(
   return { meta: newMeta, defaultValues, unionMeta }
 }
 
+/*
+ * Checks if an AST node is a S.Redacted Declaration without encoding.
+ * These need to be swapped to S.RedactedFromValue for form usage
+ * because S.Redacted expects Redacted objects, not plain strings.
+ */
+const isRedactedWithoutEncoding = (ast: S.AST.AST): boolean =>
+  S.AST.isDeclaration(ast)
+  && (ast.annotations as any)?.typeConstructor?._tag === "effect/Redacted"
+  && !ast.encoding
+
+/*
+ * Creates a form-compatible schema by replacing S.Redacted(X) with
+ * S.RedactedFromValue(X). S.Redacted is a Declaration that expects
+ * Redacted<A> on both encoded and type sides, so form inputs (which
+ * produce plain strings) fail validation. S.RedactedFromValue accepts
+ * plain values on the encoded side and wraps them in Redacted on decode.
+ */
+export const toFormSchema = <From, To>(
+  schema: S.Codec<To, From, never>
+): S.Codec<To, From, never> => {
+  const ast = schema.ast
+  const objAst = S.AST.isObjects(ast)
+    ? ast
+    : S.AST.isDeclaration(ast)
+    ? S.AST.toEncoded(ast)
+    : null
+
+  if (!objAst || !("propertySignatures" in objAst)) return schema
+
+  let hasRedacted = false
+  const props: Record<string, S.Struct.Fields[string]> = {}
+
+  for (const p of objAst.propertySignatures) {
+    if (isRedactedWithoutEncoding(p.type)) {
+      hasRedacted = true
+      const innerSchema = S.make((p.type as S.AST.Declaration).typeParameters[0]!)
+      props[p.name as string] = S.RedactedFromValue(innerSchema)
+    } else if (S.AST.isUnion(p.type)) {
+      const types = p.type.types
+      const redactedType = types.find(isRedactedWithoutEncoding)
+      if (redactedType) {
+        hasRedacted = true
+        const innerSchema = S.make((redactedType as S.AST.Declaration).typeParameters[0]!)
+        const hasNull = types.some(S.AST.isNull)
+        const hasUndefined = types.some(S.AST.isUndefined)
+        const base = S.RedactedFromValue(innerSchema)
+        props[p.name as string] = hasNull && hasUndefined
+          ? S.NullishOr(base)
+          : hasNull
+          ? S.NullOr(base)
+          : hasUndefined
+          ? S.UndefinedOr(base)
+          : base
+      } else {
+        props[p.name as string] = S.make(p.type)
+      }
+    } else {
+      props[p.name as string] = S.make(p.type)
+    }
+  }
+
+  return hasRedacted ? S.Struct(props) as unknown as S.Codec<To, From, never> : schema
+}
+
 export const duplicateSchema = <From, To>(
   schema: S.Codec<To, From, never>
 ) => {
   return schema
 }
 
-export const generateMetaFromSchema = <_From, To>(
-  schema: any // v4 Schema type is complex, use any for now
+export const generateMetaFromSchema = <From, To>(
+  schema: S.Codec<To, From, never>
 ): {
-  schema: any
+  schema: S.Codec<To, From, never>
   meta: MetaRecord<To>
   unionMeta: Record<string, MetaRecord<To>>
 } => {
@@ -833,168 +1036,138 @@ export const generateInputStandardSchemaFromFieldMeta = (
   if (!trans) {
     trans = useIntl().trans
   }
-  let schema: S.Codec<any>
-
+  let schema: any
   switch (meta.type) {
-    case "string": {
-      schema = S.String
-
-      // Apply format-specific schemas
-      if (meta.format === "email") {
-        // v4 doesn't have S.Email, use pattern validation
-        schema = S.String.check(
-          S.makeFilter(
-            (s) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s) || trans("validation.email.invalid"),
-            { title: "email format" }
-          )
-        )
-      }
+    case "string":
+      schema = meta.format === "email"
+        ? S.Email.annotate({
+          message: trans("validation.email.invalid")
+        })
+        : S.String.annotate({
+          message: trans("validation.empty")
+        })
 
-      // Apply length validations
-      if (meta.required || typeof meta.minLength === "number") {
-        const minLen = meta.required ? Math.max(1, meta.minLength || 0) : (meta.minLength || 0)
-        if (minLen > 0) {
-          schema = schema.check(
-            S.makeFilter(
-              (s) => s.length >= minLen || trans("validation.string.minLength", { minLength: minLen }),
-              { title: `minLength(${minLen})` }
-            )
-          )
-        }
+      if (meta.required) {
+        schema = schema.check(S.isMinLength(1, {
+          message: trans("validation.empty")
+        }))
       }
 
       if (typeof meta.maxLength === "number") {
-        schema = schema.check(
-          S.makeFilter(
-            (s) => s.length <= meta.maxLength! || trans("validation.string.maxLength", { maxLength: meta.maxLength }),
-            { title: `maxLength(${meta.maxLength})` }
-          )
-        )
+        schema = schema.check(S.isMaxLength(meta.maxLength, {
+          message: trans("validation.string.maxLength", {
+            maxLength: meta.maxLength
+          })
+        }))
+      }
+      if (typeof meta.minLength === "number") {
+        schema = schema.check(S.isMinLength(meta.minLength, {
+          message: trans("validation.string.minLength", {
+            minLength: meta.minLength
+          })
+        }))
       }
       break
-    }
 
-    case "number": {
+    case "number":
       if (meta.refinement === "int") {
-        schema = S.Int
+        schema = S
+          .Number
+          .annotate({
+            message: trans("validation.empty")
+          })
+          .check(S.isInt({
+            message: trans("validation.integer.expected", { actualValue: "NaN" })
+          }))
       } else {
-        schema = S.Number
+        schema = S.Finite.annotate({
+          message: trans("validation.number.expected", { actualValue: "NaN" })
+        })
+
+        if (meta.required) {
+          schema = schema.annotate({
+            message: trans("validation.empty")
+          })
+        }
       }
 
-      // Apply numeric validations
       if (typeof meta.minimum === "number") {
-        schema = schema.check(
-          S.makeFilter(
-            (n) =>
-              n >= meta.minimum! || trans(
-                meta.minimum === 0 ? "validation.number.positive" : "validation.number.min",
-                { minimum: meta.minimum, isExclusive: false }
-              ),
-            { title: `>=${meta.minimum}` }
-          )
-        )
+        schema = schema.check(S.isGreaterThanOrEqualTo(meta.minimum, {
+          message: trans(meta.minimum === 0 ? "validation.number.positive" : "validation.number.min", {
+            minimum: meta.minimum,
+            isExclusive: true
+          })
+        }))
       }
-
       if (typeof meta.maximum === "number") {
-        schema = schema.check(
-          S.makeFilter(
-            (n) =>
-              n <= meta.maximum! || trans("validation.number.max", {
-                maximum: meta.maximum,
-                isExclusive: false
-              }),
-            { title: `<=${meta.maximum}` }
-          )
-        )
+        schema = schema.check(S.isLessThanOrEqualTo(meta.maximum, {
+          message: trans("validation.number.max", {
+            maximum: meta.maximum,
+            isExclusive: true
+          })
+        }))
       }
-
       if (typeof meta.exclusiveMinimum === "number") {
-        schema = schema.check(
-          S.makeFilter(
-            (n) =>
-              n > meta.exclusiveMinimum! || trans(
-                meta.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min",
-                { minimum: meta.exclusiveMinimum, isExclusive: true }
-              ),
-            { title: `>${meta.exclusiveMinimum}` }
-          )
-        )
+        schema = schema.check(S.isGreaterThan(meta.exclusiveMinimum, {
+          message: trans(meta.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min", {
+            minimum: meta.exclusiveMinimum,
+            isExclusive: false
+          })
+        }))
       }
-
       if (typeof meta.exclusiveMaximum === "number") {
-        schema = schema.check(
-          S.makeFilter(
-            (n) =>
-              n < meta.exclusiveMaximum! || trans("validation.number.max", {
-                maximum: meta.exclusiveMaximum,
-                isExclusive: true
-              }),
-            { title: `<${meta.exclusiveMaximum}` }
-          )
-        )
+        schema = schema.check(S.isLessThan(meta.exclusiveMaximum, {
+          message: trans("validation.number.max", {
+            maximum: meta.exclusiveMaximum,
+            isExclusive: false
+          })
+        }))
       }
       break
-    }
+    case "select":
+      schema = S.Literals(meta.members as [any, ...any[]]).annotate({
+        message: trans("validation.not_a_valid", {
+          type: "select",
+          message: meta.members.join(", ")
+        })
+      })
 
-    case "select": {
-      // Use Literal for select options
-      if (meta.members.length === 0) {
-        schema = S.Unknown
-      } else if (meta.members.length === 1) {
-        schema = S.Literal(meta.members[0])
-      } else {
-        // v4 Union accepts an array of schemas
-        schema = S.Union(meta.members.map((m) => S.Literal(m)))
-      }
       break
-    }
 
-    case "multiple": {
-      schema = S.Array(S.String)
+    case "multiple":
+      schema = S.Array(S.String).annotate({
+        message: trans("validation.not_a_valid", {
+          type: "multiple",
+          message: meta.members.join(", ")
+        })
+      })
       break
-    }
 
-    case "boolean": {
+    case "boolean":
       schema = S.Boolean
       break
-    }
 
-    case "unknown": {
+    case "date":
+      schema = S.Date
+      break
+
+    case "unknown":
       schema = S.Unknown
       break
-    }
 
-    default: {
-      console.warn(`Unhandled field type: ${(meta as any).type}`)
+    default:
+      // For any unhandled types, use Unknown schema to prevent undefined errors
+      console.warn(`Unhandled field type: ${meta}`)
       schema = S.Unknown
       break
-    }
   }
-
-  // Wrap in union with null/undefined if not required
   if (!meta.required) {
-    // v4 Union takes an array of schemas
-    schema = S.Union([schema, S.Null, S.Undefined])
+    schema = S.NullishOr(schema)
   }
-
-  return S.toStandardSchemaV1(schema as any)
+  const result = S.toStandardSchemaV1(schema as any)
+  return result
 }
 
-// TODO: Fix v4 migration - nullableInput transformation needs proper type handling
-// export const nullableInput = <A>(
-//   schema: S.Codec<A>,
-//   defaultValue: () => A
-// ): S.Codec<A> =>
-//   S.NullOr(schema).pipe(
-//     S.decodeTo(
-//       schema,
-//       SchemaTransformation.transform({
-//         decode: (input: A | null) => input ?? defaultValue(),
-//         encode: (output: A) => output
-//       })
-//     )
-//   )
-
 export type OmegaAutoGenMeta<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>,
@@ -1037,18 +1210,8 @@ export function deepMerge(target: any, source: any) {
   return result
 }
 
-// Type definitions for schemas with fields and members
-type SchemaWithFields = {
-  fields: Record<string, S.Top>
-}
-
 type SchemaWithMembers = {
-  members: readonly S.Top[]
-}
-
-// Type guards to check schema types
-function hasFields(schema: any): schema is SchemaWithFields {
-  return schema && "fields" in schema && typeof schema.fields === "object"
+  members: readonly S.Schema<any>[]
 }
 
 function hasMembers(schema: any): schema is SchemaWithMembers {
@@ -1057,10 +1220,15 @@ function hasMembers(schema: any): schema is SchemaWithMembers {
 
 // Internal implementation with WeakSet tracking
 export const defaultsValueFromSchema = (
-  schema: S.Codec<any>,
+  schema: S.Schema<any>,
   record: Record<string, any> = {}
 ): any => {
   const ast = schema.ast
+  const defaultValue = getDefaultFromAst(ast)
+
+  if (defaultValue !== undefined) {
+    return defaultValue
+  }
 
   if (isNullableOrUndefined(schema.ast) === "null") {
     return null
@@ -1069,106 +1237,79 @@ export const defaultsValueFromSchema = (
     return undefined
   }
 
-  // Handle v4 Objects AST structure
-  if (AST.isObjects(ast)) {
-    const result: Record<string, any> = { ...record }
+  // Handle structs via AST (covers plain structs, transformed schemas like decodeTo, ExtendedClass, etc.)
+  const objectsAst = S.AST.isObjects(ast)
+    ? ast
+    : S.AST.isDeclaration(ast)
+    ? unwrapDeclaration(ast)
+    : undefined
+  if (objectsAst && S.AST.isObjects(objectsAst)) {
+    const result: Record<string, any> = {}
 
-    for (const prop of ast.propertySignatures) {
+    for (const prop of objectsAst.propertySignatures) {
       const key = prop.name.toString()
       const propType = prop.type
 
-      // Get the property schema from the original schema's fields if available
-      // This preserves schema wrappers like withDefaultConstructor
-      let propSchema: S.Codec<any>
-      if ((schema as any).fields && (schema as any).fields[key]) {
-        propSchema = (schema as any).fields[key]
-      } else {
-        propSchema = S.make(propType)
+      const propDefault = getDefaultFromAst(propType)
+      if (propDefault !== undefined) {
+        result[key] = propDefault
+        continue
       }
 
-      // Recursively process the property to get its defaults
+      const propSchema = S.make(propType)
       const propValue = defaultsValueFromSchema(propSchema, record[key] || {})
 
       if (propValue !== undefined) {
         result[key] = propValue
+      } else if (isNullableOrUndefined(propType) === "undefined") {
+        result[key] = undefined
       }
     }
 
-    return result
+    return { ...result, ...record }
   }
 
-  // v3 compatible fields extraction
-  if (hasFields(schema)) {
-    // Process fields and extract default values
-    const result: Record<string, any> = {}
-
-    for (const [key, fieldSchema] of Object.entries(schema.fields)) {
-      // Check if this field has a defaultValue in its AST
-      const fieldAst = (fieldSchema as any)?.ast
-      if (fieldAst?.defaultValue) {
-        try {
-          result[key] = fieldAst.defaultValue()
-          continue
-        } catch {
-          // If defaultValue() throws, fall through to recursive processing
+  // Handle unions via AST or schema-level .members
+  const unionTypes = S.AST.isUnion(ast)
+    ? ast.types
+    : hasMembers(schema)
+    ? schema.members.map((m) => m.ast)
+    : undefined
+  if (unionTypes) {
+    const mergedFields: Record<string, { ast: S.AST.AST }> = {}
+
+    for (const memberAstRaw of unionTypes) {
+      const memberAst = unwrapDeclaration(memberAstRaw)
+      if (!S.AST.isObjects(memberAst)) continue
+
+      for (const prop of memberAst.propertySignatures) {
+        const key = prop.name.toString()
+        const fieldDefault = getDefaultFromAst(prop.type)
+        const existingDefault = mergedFields[key] ? getDefaultFromAst(mergedFields[key]!.ast) : undefined
+
+        if (!mergedFields[key] || (fieldDefault !== undefined && existingDefault === undefined)) {
+          mergedFields[key] = { ast: prop.type }
         }
       }
-
-      // Recursively process the field
-      const fieldValue = defaultsValueFromSchema(fieldSchema as any, record[key] || {})
-      if (fieldValue !== undefined) {
-        result[key] = fieldValue
-      }
     }
 
-    return { ...result, ...record }
-  }
-
-  // Check if schema has fields in from (for ExtendedClass and similar transformations)
-  if ((schema as any)?.from && hasFields((schema as any).from)) {
-    return defaultsValueFromSchema((schema as any).from, record)
-  }
-
-  if (hasMembers(schema)) {
-    // Merge all member fields, giving precedence to fields with default values
-    const mergedMembers = schema.members.reduce((acc, member) => {
-      if (hasFields(member)) {
-        // Check each field and give precedence to ones with default values
-        Object.entries(member.fields).forEach(([key, fieldSchema]) => {
-          const fieldAst: any = fieldSchema.ast
-          const existingFieldAst: any = acc[key]?.ast
-
-          // If field doesn't exist yet, or new field has default and existing doesn't, use new field
-          if (!acc[key] || (fieldAst?.defaultValue && !existingFieldAst?.defaultValue)) {
-            acc[key] = fieldSchema
-          }
-          // If both have defaults or neither have defaults, keep the first one (existing)
-        })
-        return acc
-      }
-      return acc
-    }, {} as Record<string, any>)
+    if (Object.keys(mergedFields).length === 0) {
+      return Object.keys(record).length > 0 ? record : undefined
+    }
 
-    // Use reduce to properly accumulate the merged fields
-    return Object.entries(mergedMembers).reduce((acc, [key, value]) => {
-      acc[key] = defaultsValueFromSchema(value, record[key] || {})
+    return Object.entries(mergedFields).reduce((acc, [key, { ast: propAst }]) => {
+      acc[key] = defaultsValueFromSchema(S.make(propAst), record[key] || {})
       return acc
     }, record)
   }
 
   if (Object.keys(record).length === 0) {
-    // Check for constructor defaults in v4's context
-    if (ast.context?.defaultValue) {
-      // In v4, defaultValue is an Encoding type, not directly callable
-      // For now, skip complex default extraction
-      // TODO: properly extract default from encoding chain
+    if (S.AST.isString(ast)) {
+      return ""
     }
-  }
 
-  if (AST.isString(ast)) {
-    return ""
-  }
-  if (AST.isBoolean(ast)) {
-    return false
+    if (S.AST.isBoolean(ast)) {
+      return false
+    }
   }
 }