@effect-app/vue-components 4.0.0-beta.15 → 4.0.0-beta.151

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -2,14 +2,29 @@ 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 type * as Fiber from "effect/Fiber"
+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}]`>
   : {
@@ -17,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}`>
@@ -144,7 +159,7 @@ export type FormProps<From, To> =
       formApi: OmegaFormParams<From, To>
       meta: any
       value: To
-    }) => Promise<any> | Fiber.Fiber<any, any> | Effect.Effect<unknown, any, never>
+    }) => Promise<any> | EffectFiber<any, any> | Effect.Effect<unknown, any, never>
   }
 
 export type OmegaFormParams<From, To> = FormApi<
@@ -222,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>
@@ -235,6 +256,15 @@ export type FieldValidators<T> = {
 export type BaseFieldMeta = {
   required: boolean
   nullableOrUndefined?: false | "undefined" | "null"
+  originalSchema?: StandardSchemaV1<any, any>
+  /**
+   * True when the schema property is `S.optionalKey` (AST
+   * `context.isOptional`) — i.e. the key should be ABSENT from the submitted
+   * object when empty, not present with `undefined`. Distinct from
+   * `required: false`, which may also mean "empty string is valid" for
+   * unconstrained `S.String` fields.
+   */
+  isOptionalKey?: boolean
 }
 
 export type StringFieldMeta = BaseFieldMeta & {
@@ -268,6 +298,10 @@ export type BooleanFieldMeta = BaseFieldMeta & {
   type: "boolean"
 }
 
+export type DateFieldMeta = BaseFieldMeta & {
+  type: "date"
+}
+
 export type UnknownFieldMeta = BaseFieldMeta & {
   type: "unknown"
 }
@@ -278,6 +312,7 @@ export type FieldMeta =
   | SelectFieldMeta
   | MultipleFieldMeta
   | BooleanFieldMeta
+  | DateFieldMeta
   | UnknownFieldMeta
 
 export type MetaRecord<T = string> = {
@@ -321,6 +356,17 @@ const unwrapDeclaration = (property: S.AST.AST): S.AST.AST => {
 
 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(_))
@@ -360,13 +406,8 @@ const getJsonSchemaAnnotation = (property: S.AST.AST): Record<string, unknown> =
   return jsonSchema && typeof jsonSchema === "object" ? jsonSchema as Record<string, unknown> : {}
 }
 
-const getDefaultFromAst = (property: S.AST.AST) => {
-  const link = property.context?.defaultValue?.[0] as any
-
-  if (!link?.transformation?.decode?.run) {
-    return undefined
-  }
-
+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
@@ -375,6 +416,21 @@ const getDefaultFromAst = (property: S.AST.AST) => {
   }
 }
 
+const getDefaultFromAst = (property: S.AST.AST) => {
+  // 1. Check withConstructorDefault (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 ?? []
 
@@ -426,6 +482,10 @@ const getFieldMetadataFromAst = (property: S.AST.AST) => {
         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
@@ -436,6 +496,11 @@ const getFieldMetadataFromAst = (property: S.AST.AST) => {
     }
   } 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"
   }
@@ -445,7 +510,8 @@ const getFieldMetadataFromAst = (property: S.AST.AST) => {
 
 export const createMeta = <T = any>(
   { meta = {}, parent = "", property, propertySignatures }: CreateMeta,
-  acc: Partial<MetaRecord<T>> = {}
+  acc: Partial<MetaRecord<T>> = {},
+  fieldAstByPath?: Record<string, S.AST.AST>
 ): MetaRecord<T> | FieldMeta => {
   if (property) {
     property = unwrapDeclaration(property)
@@ -463,8 +529,11 @@ export const createMeta = <T = any>(
       const key = parent ? `${parent}.${p.name.toString()}` : p.name.toString()
       const nullableOrUndefined = isNullableOrUndefined(p.type)
 
+      const isOptionalKey = (p.type as any).context?.isOptional === true
+
       // 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") {
@@ -473,6 +542,8 @@ export const createMeta = <T = any>(
       } else if (meta.required === false) {
         // Explicitly set to non-required (legacy behavior for backwards compatibility)
         isRequired = false
+      } else if (isOptionalKey) {
+        isRequired = false
       } else {
         // Calculate from the property itself
         isRequired = !nullableOrUndefined
@@ -503,14 +574,28 @@ export const createMeta = <T = any>(
               // - 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 {
@@ -525,6 +610,9 @@ export const createMeta = <T = any>(
               required: isRequired,
               nullableOrUndefined
             } as FieldMeta
+            if (fieldAstByPath) {
+              fieldAstByPath[key] = p.type
+            }
 
             // If the array has struct elements, also create metadata for their properties
             if (arrayType.rest && arrayType.rest.length > 0) {
@@ -545,6 +633,9 @@ export const createMeta = <T = any>(
                   // add to accumulator if valid
                   if (propMeta && typeof propMeta === "object" && "type" in propMeta) {
                     acc[propKey as NestedKeyOf<T>] = propMeta as FieldMeta
+                    if (fieldAstByPath) {
+                      fieldAstByPath[propKey] = prop.type
+                    }
 
                     if (
                       propMeta.type === "multiple" && S.AST.isArrays(prop.type) && prop
@@ -568,6 +659,9 @@ export const createMeta = <T = any>(
                           // add to accumulator if valid
                           if (nestedPropMeta && typeof nestedPropMeta === "object" && "type" in nestedPropMeta) {
                             acc[nestedPropKey as NestedKeyOf<T>] = nestedPropMeta as FieldMeta
+                            if (fieldAstByPath) {
+                              fieldAstByPath[nestedPropKey] = nestedProp.type
+                            }
                           }
                         }
                       }
@@ -584,17 +678,24 @@ export const createMeta = <T = any>(
               meta: { required: isRequired, nullableOrUndefined }
             })
             acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
+            if (fieldAstByPath) {
+              fieldAstByPath[key] = p.type
+            }
           }
         }
       } else {
         if (S.AST.isObjects(typeToProcess)) {
           Object.assign(
             acc,
-            createMeta<T>({
-              parent: key,
-              propertySignatures: typeToProcess.propertySignatures,
-              meta: { required: isRequired, nullableOrUndefined }
-            })
+            createMeta<T>(
+              {
+                parent: key,
+                propertySignatures: typeToProcess.propertySignatures,
+                meta: { required: isRequired, nullableOrUndefined }
+              },
+              {},
+              fieldAstByPath
+            )
           )
         } else if (S.AST.isArrays(p.type)) {
           // Check if it has struct elements
@@ -625,6 +726,9 @@ export const createMeta = <T = any>(
                         }
                       })
                       acc[nestedKey as NestedKeyOf<T>] = nestedMeta as FieldMeta
+                      if (fieldAstByPath) {
+                        fieldAstByPath[nestedKey] = nestedProp.type
+                      }
                     }
                   } else {
                     // Array with primitive elements - create meta for the array itself
@@ -635,6 +739,9 @@ export const createMeta = <T = any>(
                       required: !isNullableOrUndefined(prop.type),
                       nullableOrUndefined: isNullableOrUndefined(prop.type)
                     } as FieldMeta
+                    if (fieldAstByPath) {
+                      fieldAstByPath[propKey] = prop.type
+                    }
                   }
                 } else {
                   const fieldMeta = createMeta<T>({
@@ -646,6 +753,9 @@ export const createMeta = <T = any>(
                     }
                   })
                   acc[propKey as NestedKeyOf<T>] = fieldMeta as FieldMeta
+                  if (fieldAstByPath) {
+                    fieldAstByPath[propKey] = prop.type
+                  }
                 }
               }
             }
@@ -658,6 +768,9 @@ export const createMeta = <T = any>(
               required: isRequired,
               nullableOrUndefined
             } as FieldMeta
+            if (fieldAstByPath) {
+              fieldAstByPath[key] = p.type
+            }
           }
         } else {
           const newMeta = createMeta<T>({
@@ -667,12 +780,16 @@ export const createMeta = <T = any>(
               // 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(p.type).minLength),
-              nullableOrUndefined
+                && (!S.AST.isString(typeToProcess) || !!getFieldMetadataFromAst(typeToProcess).minLength),
+              nullableOrUndefined,
+              ...(isOptionalKey ? { isOptionalKey: true } : {})
             }
           })
 
           acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
+          if (fieldAstByPath) {
+            fieldAstByPath[key] = p.type
+          }
         }
       }
     }
@@ -689,7 +806,20 @@ export const createMeta = <T = any>(
 
     if (S.AST.isUnion(property)) {
       const unwrappedTypes = unwrapNestedUnions(property.types).map(unwrapDeclaration)
-      const nonNullType = unwrappedTypes.find((t) => !isNullishType(t))!
+      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 (S.AST.isObjects(nonNullType)) {
         return createMeta<T>({
@@ -699,11 +829,13 @@ export const createMeta = <T = any>(
         })
       }
 
-      if (unwrappedTypes.every((_) => isNullishType(_) || S.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.filter(S.AST.isLiteral).map((t) => t.literal)
+          members: resolvedTypes.filter(S.AST.isLiteral).map((t) => t.literal)
         } as FieldMeta
       }
 
@@ -726,6 +858,14 @@ export const createMeta = <T = any>(
       } as FieldMeta
     }
 
+    if (S.AST.isLiteral(property)) {
+      return {
+        ...meta,
+        type: "select",
+        members: [property.literal]
+      } as FieldMeta
+    }
+
     meta = { ...getJsonSchemaAnnotation(property), ...getFieldMetadataFromAst(property), ...meta }
 
     return meta as FieldMeta
@@ -754,11 +894,50 @@ const flattenMeta = <T>(meta: MetaRecord<T> | FieldMeta, parentKey: string = "")
 
 const metadataFromAst = <From, To>(
   schema: S.Codec<To, From, never>
-): { meta: MetaRecord<To>; defaultValues: Record<string, any>; unionMeta: Record<string, MetaRecord<To>> } => {
+): {
+  meta: MetaRecord<To>
+  defaultValues: Record<string, any>
+  unionMeta: Record<string, MetaRecord<To>>
+} => {
   const ast = unwrapDeclaration(schema.ast)
   const newMeta: MetaRecord<To> = {}
   const defaultValues: Record<string, any> = {}
   const unionMeta: Record<string, MetaRecord<To>> = {}
+  const fieldAstByPath: Record<string, S.AST.AST> = {}
+
+  const toFieldStandardSchema = (
+    propertyAst: S.AST.AST,
+    required: boolean
+  ): StandardSchemaV1<any, any> => {
+    const base = S.make(propertyAst)
+    const fieldSchema = required ? base : S.NullishOr(base)
+    return S.toStandardSchemaV1(fieldSchema as any)
+  }
+
+  const attachOriginalSchemas = (metaRecord: MetaRecord<To>) => {
+    for (const [key, fieldAst] of Object.entries(fieldAstByPath)) {
+      const fieldMeta = metaRecord[key as NestedKeyOf<To>]
+      if (!fieldMeta) {
+        continue
+      }
+      try {
+        const required = fieldMeta.required ?? true
+        Object.defineProperty(fieldMeta, "originalSchema", {
+          value: toFieldStandardSchema(fieldAst, required),
+          enumerable: false,
+          configurable: true,
+          writable: true
+        })
+      } catch {
+        Object.defineProperty(fieldMeta, "originalSchema", {
+          value: S.toStandardSchemaV1(S.Unknown),
+          enumerable: false,
+          configurable: true,
+          writable: true
+        })
+      }
+    }
+  }
 
   // Handle root-level Union types (discriminated unions)
   if (S.AST.isUnion(ast)) {
@@ -781,15 +960,35 @@ const metadataFromAst = <From, To>(
           )
 
           let tagValue: string | null = null
-          if (tagProp && S.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
-          const memberMeta = createMeta<To>({
-            propertySignatures: memberType.propertySignatures
-          })
+          const memberMeta = createMeta<To>(
+            {
+              propertySignatures: memberType.propertySignatures
+            },
+            {},
+            fieldAstByPath
+          )
 
           // Store per-tag metadata for reactive lookup
           if (tagValue) {
@@ -810,17 +1009,28 @@ const metadataFromAst = <From, To>(
         } as FieldMeta
       }
 
+      attachOriginalSchemas(newMeta)
       return { meta: newMeta, defaultValues, unionMeta }
     }
   }
 
   if (S.AST.isObjects(ast)) {
-    const meta = createMeta<To>({
-      propertySignatures: ast.propertySignatures
-    })
+    const meta = createMeta<To>(
+      {
+        propertySignatures: ast.propertySignatures
+      },
+      {},
+      fieldAstByPath
+    )
 
     if (Object.values(meta).every((value) => value && "type" in value)) {
-      return { meta: meta as MetaRecord<To>, defaultValues, unionMeta }
+      const typedMeta = meta as MetaRecord<To>
+      attachOriginalSchemas(typedMeta)
+      return {
+        meta: typedMeta,
+        defaultValues,
+        unionMeta
+      }
     }
 
     const flattenObject = (
@@ -840,9 +1050,74 @@ const metadataFromAst = <From, To>(
     flattenObject(meta)
   }
 
+  attachOriginalSchemas(newMeta)
   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>
 ) => {
@@ -912,7 +1187,7 @@ export const generateInputStandardSchemaFromFieldMeta = (
             message: trans("validation.integer.expected", { actualValue: "NaN" })
           }))
       } else {
-        schema = S.Number.annotate({
+        schema = S.Finite.annotate({
           message: trans("validation.number.expected", { actualValue: "NaN" })
         })
 
@@ -979,6 +1254,10 @@ export const generateInputStandardSchemaFromFieldMeta = (
       schema = S.Boolean
       break
 
+    case "date":
+      schema = S.Date
+      break
+
     case "unknown":
       schema = S.Unknown
       break
@@ -996,11 +1275,6 @@ export const generateInputStandardSchemaFromFieldMeta = (
   return result
 }
 
-export const nullableInput = <A, I, R>(
-  schema: S.Codec<A, I, R>,
-  _defaultValue: () => A
-) => S.NullOr(schema) as any
-
 export type OmegaAutoGenMeta<
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>,
@@ -1043,20 +1317,10 @@ export function deepMerge(target: any, source: any) {
   return result
 }
 
-// Type definitions for schemas with fields and members
-type SchemaWithFields = {
-  fields: Record<string, S.Schema<any>>
-}
-
 type SchemaWithMembers = {
   members: readonly S.Schema<any>[]
 }
 
-// Type guards to check schema types
-function hasFields(schema: any): schema is SchemaWithFields {
-  return schema && "fields" in schema && typeof schema.fields === "object"
-}
-
 function hasMembers(schema: any): schema is SchemaWithMembers {
   return schema && "members" in schema && Array.isArray(schema.members)
 }
@@ -1080,99 +1344,73 @@ export const defaultsValueFromSchema = (
     return undefined
   }
 
-  // Check if schema has fields directly
-  if (hasFields(schema)) {
-    // Process fields and extract default values
+  // Handle structs via AST (covers plain structs, transformed schemas like decodeTo, Class, 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 [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
-        }
+    for (const prop of objectsAst.propertySignatures) {
+      const key = prop.name.toString()
+      const propType = prop.type
+
+      const propDefault = getDefaultFromAst(propType)
+      if (propDefault !== undefined) {
+        result[key] = propDefault
+        continue
       }
 
-      // Recursively process the field
-      const fieldValue = defaultsValueFromSchema(fieldSchema as any, record[key] || {})
-      if (fieldValue !== undefined) {
-        result[key] = fieldValue
+      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, ...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)
-  }
+  // 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 }> = {}
 
-  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
+    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 }
+        }
       }
-      return acc
-    }, {} as Record<string, any>)
+    }
 
-    if (Object.keys(mergedMembers).length === 0) {
+    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) {
-    if (S.AST.isObjects(ast)) {
-      // Process TypeLiteral fields directly to build the result object
-      const result: Record<string, any> = { ...record }
-
-      for (const prop of ast.propertySignatures) {
-        const key = prop.name.toString()
-        const propType = prop.type
-
-        const propDefault = getDefaultFromAst(propType)
-        if (propDefault !== undefined) {
-          result[key] = propDefault
-          continue
-        }
-
-        // Create a schema from the property type and get its defaults
-        const propSchema = S.make(propType)
-
-        // Recursively process the property - don't pas for prop processing
-        // to allow proper unwrapping of nested structures
-        const propValue = defaultsValueFromSchema(propSchema, record[key] || {})
-
-        if (propValue !== undefined) {
-          result[key] = propValue
-        }
-      }
-
-      return result
-    }
-
     if (S.AST.isString(ast)) {
       return ""
     }