@effect-app/vue-components 4.0.0-beta.14 → 4.0.0-beta.141

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,14 @@ export type FieldValidators<T> = {
 export type BaseFieldMeta = {
   required: boolean
   nullableOrUndefined?: false | "undefined" | "null"
+  /**
+   * 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 +297,10 @@ export type BooleanFieldMeta = BaseFieldMeta & {
   type: "boolean"
 }
 
+export type DateFieldMeta = BaseFieldMeta & {
+  type: "date"
+}
+
 export type UnknownFieldMeta = BaseFieldMeta & {
   type: "unknown"
 }
@@ -278,6 +311,7 @@ export type FieldMeta =
   | SelectFieldMeta
   | MultipleFieldMeta
   | BooleanFieldMeta
+  | DateFieldMeta
   | UnknownFieldMeta
 
 export type MetaRecord<T = string> = {
@@ -321,6 +355,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 +405,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 +415,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 +481,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 +495,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"
   }
@@ -463,8 +527,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 +540,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 +572,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 {
@@ -667,8 +750,9 @@ 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 } : {})
             }
           })
 
@@ -689,7 +773,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 +796,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 +825,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
@@ -781,9 +888,25 @@ 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
@@ -843,6 +966,70 @@ 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>
 ) => {
@@ -912,7 +1099,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 +1166,10 @@ export const generateInputStandardSchemaFromFieldMeta = (
       schema = S.Boolean
       break
 
+    case "date":
+      schema = S.Date
+      break
+
     case "unknown":
       schema = S.Unknown
       break
@@ -996,11 +1187,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 +1229,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 +1256,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, 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 [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 ""
     }

package/src/components/OmegaForm/OmegaInput.vue

@@ -4,7 +4,7 @@
     :key="fieldKey"
     :name="name"
     :validators="{
-      onChange: schema,
+      onBlur: schema,
       ...validators
     }"
   >

package/src/components/OmegaForm/OmegaInputVuetify.vue

@@ -1,7 +1,10 @@
 <template>
   <div
     class="omega-input"
-    @focusout="$emit('blur', $event)"
+    @focusout="(e) => {
+      $emit('blur', e)
+      field.handleBlur()
+    }"
     @focusin="$emit('focus', $event)"
   >
     <component

package/src/components/OmegaForm/OmegaInternalInput.vue

@@ -119,6 +119,7 @@ const isFalsyButNotZero = (value: unknown): boolean => {
 // we remove value and errors when the field is empty and not required
 // convert nullish value to null or undefined based on schema
 const handleChange: OmegaFieldInternalApi<From, Name>["handleChange"] = (value) => {
+  let fieldDeleted = false
   if (isFalsyButNotZero(value) && props.meta?.type !== "boolean") {
     // Only convert to null/undefined if the field is actually nullable or optional
     if (props.meta?.nullableOrUndefined) {
@@ -128,6 +129,14 @@ const handleChange: OmegaFieldInternalApi<From, Name>["handleChange"] = (value)
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           : null as any
       )
+    } else if (props.meta?.isOptionalKey) {
+      // `S.optionalKey` expects the key to be ABSENT from the submitted
+      // object, not present-with-undefined. Remove it from form state
+      // rather than setting it to `undefined`. Note: this is distinct
+      // from `required: false`, which may also just mean "empty string
+      // is valid" for unconstrained `S.String` fields.
+      props.field.form.deleteField(props.field.name)
+      fieldDeleted = true
     } else {
       // Keep the actual value (e.g., empty string for S.String fields)
       props.field.handleChange(value)
@@ -138,7 +147,10 @@ const handleChange: OmegaFieldInternalApi<From, Name>["handleChange"] = (value)
 
   // whenever we change the field, regardless if we set it to null, we should reset onSubmit.
   // not sure why this is not the case in tanstack form.
-  props.field.setMeta((m) => ({ ...m, errorMap: { ...m.errorMap, onSubmit: undefined } }))
+  // Skip when the field was deleted — its meta no longer exists in the form store.
+  if (!fieldDeleted) {
+    props.field.setMeta((m) => ({ ...m, errorMap: { ...m.errorMap, onSubmit: undefined } }))
+  }
 }
 
 // Note: Default value normalization (converting empty strings to null/undefined for nullable fields)
@@ -165,11 +177,13 @@ const inputProps: ComputedRef<InputProps<From, Name>> = computed(() => ({
     minLength: props.meta?.type === "string" && props.meta?.minLength,
     maxLength: props.meta?.type === "string" && props.meta?.maxLength,
     max: (props.meta?.type === "number")
-      && (props.meta?.maximum
-        ?? (typeof props.meta?.exclusiveMaximum === "number" && props.meta.exclusiveMaximum - 1)),
+      ? (props.meta?.maximum
+        ?? (typeof props.meta?.exclusiveMaximum === "number" ? props.meta.exclusiveMaximum - 1 : undefined))
+      : undefined,
     min: (props.meta?.type === "number")
-      && (props.meta?.minimum
-        ?? (typeof props.meta?.exclusiveMinimum === "number" && props.meta.exclusiveMinimum + 1)),
+      ? (props.meta?.minimum
+        ?? (typeof props.meta?.exclusiveMinimum === "number" ? props.meta.exclusiveMinimum + 1 : undefined))
+      : undefined,
     errorMessages: errors.value,
     error: !!errors.value.length,
     type: fieldType.value,