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

package/dist/types/components/OmegaForm/OmegaFormStuff.d.ts

@@ -91,6 +91,7 @@ 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
@@ -154,7 +155,7 @@ export type CreateMeta = {
     property: S.AST.AST;
 });
 export declare const isNullableOrUndefined: (property: false | S.AST.AST | undefined) => false | "undefined" | "null";
-export declare const createMeta: <T = any>({ meta, parent, property, propertySignatures }: CreateMeta, acc?: Partial<MetaRecord<T>>) => MetaRecord<T> | FieldMeta;
+export declare const createMeta: <T = any>({ meta, parent, property, propertySignatures }: CreateMeta, acc?: Partial<MetaRecord<T>>, fieldAstByPath?: Record<string, S.AST.AST>) => MetaRecord<T> | FieldMeta;
 export declare const toFormSchema: <From, To>(schema: S.Codec<To, From, never>) => S.Codec<To, From, never>;
 export declare const duplicateSchema: <From, To>(schema: S.Codec<To, From, never>) => S.Codec<To, From, never, never>;
 export declare const generateMetaFromSchema: <From, To>(schema: S.Codec<To, From, never>) => {

package/dist/vue-components12.es.js

@@ -72,29 +72,29 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 		}
 	} else a.AST.isBoolean(e) ? t.type = "boolean" : a.AST.isDeclaration(e) && e.annotations?.typeConstructor?._tag === "Date" ? t.type = "date" : t.type = "unknown";
 	return t;
-}, b = ({ meta: e = {}, parent: t = "", property: n, propertySignatures: r }, i = {}) => {
+}, b = ({ meta: e = {}, parent: t = "", property: n, propertySignatures: r }, i = {}, o) => {
 	if (n &&= c(n), n && a.AST.isObjects(n)) return b({
 		meta: e,
 		propertySignatures: n.propertySignatures
 	});
 	if (r) {
 		for (let n of r) {
-			let r = t ? `${t}.${n.name.toString()}` : n.name.toString(), o = f(n.type), s = n.type.context?.isOptional === !0, l;
-			l = e._isNullableDiscriminatedUnion && n.name.toString() === "_tag" || e.required === !1 || s ? !1 : !o;
-			let u = c(n.type);
+			let r = t ? `${t}.${n.name.toString()}` : n.name.toString(), s = f(n.type), l = n.type.context?.isOptional === !0, u;
+			u = e._isNullableDiscriminatedUnion && n.name.toString() === "_tag" || e.required === !1 || l ? !1 : !s;
+			let d = c(n.type);
 			if (a.AST.isUnion(n.type)) {
 				let e = m(n.type.types);
 				if (e.some(a.AST.isObjects)) {
-					o || (i[r] = b({
+					s || (i[r] = b({
 						parent: r,
 						property: n.type,
 						meta: {
-							required: l,
-							nullableOrUndefined: o
+							required: u,
+							nullableOrUndefined: s
 						}
 					}));
 					for (let t of e) if (a.AST.isObjects(t)) {
-						let n = o && e.length > 1, a = b({
+						let n = s && e.length > 1, a = b({
 							parent: r,
 							propertySignatures: t.propertySignatures,
 							meta: n ? { _isNullableDiscriminatedUnion: !0 } : {}
@@ -112,9 +112,9 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 							type: "multiple",
 							members: e.elements,
 							rest: e.rest,
-							required: l,
-							nullableOrUndefined: o
-						}, e.rest && e.rest.length > 0) {
+							required: u,
+							nullableOrUndefined: s
+						}, o && (o[r] = n.type), e.rest && e.rest.length > 0) {
 							let t = c(e.rest[0]);
 							if (a.AST.isObjects(t)) for (let e of t.propertySignatures) {
 								let t = `${r}.${e.name.toString()}`, n = b({
@@ -125,7 +125,7 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 										nullableOrUndefined: f(e.type)
 									}
 								});
-								if (n && typeof n == "object" && "type" in n && (i[t] = n, n.type === "multiple" && a.AST.isArrays(e.type) && e.type.rest && e.type.rest.length > 0)) {
+								if (n && typeof n == "object" && "type" in n && (i[t] = n, o && (o[t] = e.type), n.type === "multiple" && a.AST.isArrays(e.type) && e.type.rest && e.type.rest.length > 0)) {
 									let n = c(e.type.rest[0]);
 									if (a.AST.isObjects(n)) for (let e of n.propertySignatures) {
 										let n = `${t}.${e.name.toString()}`, r = b({
@@ -136,7 +136,7 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 												nullableOrUndefined: f(e.type)
 											}
 										});
-										r && typeof r == "object" && "type" in r && (i[n] = r);
+										r && typeof r == "object" && "type" in r && (i[n] = r, o && (o[n] = e.type));
 									}
 								}
 							}
@@ -145,19 +145,19 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 						parent: r,
 						property: n.type,
 						meta: {
-							required: l,
-							nullableOrUndefined: o
+							required: u,
+							nullableOrUndefined: s
 						}
-					});
+					}), o && (o[r] = n.type);
 				}
-			} else if (a.AST.isObjects(u)) Object.assign(i, b({
+			} else if (a.AST.isObjects(d)) Object.assign(i, b({
 				parent: r,
-				propertySignatures: u.propertySignatures,
+				propertySignatures: d.propertySignatures,
 				meta: {
-					required: l,
-					nullableOrUndefined: o
+					required: u,
+					nullableOrUndefined: s
 				}
-			}));
+			}, {}, o));
 			else if (a.AST.isArrays(n.type)) if (n.type.rest.length > 0 && a.AST.isObjects(c(n.type.rest[0]))) {
 				let e = c(n.type.rest[0]);
 				if (a.AST.isObjects(e)) for (let t of e.propertySignatures) {
@@ -173,7 +173,7 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 									required: !f(t.type),
 									nullableOrUndefined: f(t.type)
 								}
-							});
+							}), o && (o[n] = t.type);
 						}
 						else i[e] = {
 							type: "multiple",
@@ -181,7 +181,7 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 							rest: t.type.rest,
 							required: !f(t.type),
 							nullableOrUndefined: f(t.type)
-						};
+						}, o && (o[e] = t.type);
 					} else i[e] = b({
 						parent: e,
 						property: t.type,
@@ -189,24 +189,24 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 							required: !f(t.type),
 							nullableOrUndefined: f(t.type)
 						}
-					});
+					}), o && (o[e] = t.type);
 				}
 			} else i[r] = {
 				type: "multiple",
 				members: n.type.elements,
 				rest: n.type.rest,
-				required: l,
-				nullableOrUndefined: o
-			};
+				required: u,
+				nullableOrUndefined: s
+			}, o && (o[r] = n.type);
 			else i[r] = b({
 				parent: r,
 				property: n.type,
 				meta: {
-					required: l && (!a.AST.isString(u) || !!y(u).minLength),
-					nullableOrUndefined: o,
-					...s ? { isOptionalKey: !0 } : {}
+					required: u && (!a.AST.isString(d) || !!y(d).minLength),
+					nullableOrUndefined: s,
+					...l ? { isOptionalKey: !0 } : {}
 				}
-			});
+			}), o && (o[r] = n.type);
 		}
 		return i;
 	}
@@ -263,22 +263,45 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 	}
 	return n;
 }, S = (e) => {
-	let t = c(e.ast), n = {}, r = {}, i = {};
+	let t = c(e.ast), n = {}, r = {}, i = {}, l = {}, d = (e, t) => {
+		let n = a.make(e), r = t ? n : a.NullishOr(n);
+		return a.toStandardSchemaV1(r);
+	}, f = (e) => {
+		for (let [t, n] of Object.entries(l)) {
+			let r = e[t];
+			if (r) try {
+				let e = r.required ?? !0;
+				Object.defineProperty(r, "originalSchema", {
+					value: d(n, e),
+					enumerable: !1,
+					configurable: !0,
+					writable: !0
+				});
+			} catch {
+				Object.defineProperty(r, "originalSchema", {
+					value: a.toStandardSchemaV1(a.Unknown),
+					enumerable: !1,
+					configurable: !0,
+					writable: !0
+				});
+			}
+		}
+	};
 	if (a.AST.isUnion(t)) {
 		let e = m(t.types);
 		if (e.every(a.AST.isObjects) && e.length > 0) {
 			let t = [];
 			for (let r of e) if (a.AST.isObjects(r)) {
-				let e = r.propertySignatures.find((e) => e.name.toString() === "_tag"), c = null, l = e ? u(e.type) : null;
-				l && a.AST.isLiteral(l) && (c = l.literal, t.push(c), e && a.AST.isUnion(e.type) && s() && c != null && !o.has(c) && (o.add(c), console.warn(`[OmegaForm] Union member with _tag "${c}" uses S.Struct({ _tag: S.Literal("${c}"), ... }). Please migrate to S.TaggedStruct("${c}", { ... }) for cleaner AST handling.`)));
-				let d = b({ propertySignatures: r.propertySignatures });
-				c && (i[c] = x(d)), Object.assign(n, d);
+				let e = r.propertySignatures.find((e) => e.name.toString() === "_tag"), c = null, d = e ? u(e.type) : null;
+				d && a.AST.isLiteral(d) && (c = d.literal, t.push(c), e && a.AST.isUnion(e.type) && s() && c != null && !o.has(c) && (o.add(c), console.warn(`[OmegaForm] Union member with _tag "${c}" uses S.Struct({ _tag: S.Literal("${c}"), ... }). Please migrate to S.TaggedStruct("${c}", { ... }) for cleaner AST handling.`)));
+				let f = b({ propertySignatures: r.propertySignatures }, {}, l);
+				c && (i[c] = x(f)), Object.assign(n, f);
 			}
 			return t.length > 0 && (n._tag = {
 				type: "select",
 				members: t,
 				required: !0
-			}), {
+			}), f(n), {
 				meta: n,
 				defaultValues: r,
 				unionMeta: i
@@ -286,12 +309,15 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 		}
 	}
 	if (a.AST.isObjects(t)) {
-		let e = b({ propertySignatures: t.propertySignatures });
-		if (Object.values(e).every((e) => e && "type" in e)) return {
-			meta: e,
-			defaultValues: r,
-			unionMeta: i
-		};
+		let e = b({ propertySignatures: t.propertySignatures }, {}, l);
+		if (Object.values(e).every((e) => e && "type" in e)) {
+			let t = e;
+			return f(t), {
+				meta: t,
+				defaultValues: r,
+				unionMeta: i
+			};
+		}
 		let a = (e, t = "") => {
 			for (let r in e) {
 				let i = t ? `${t}.${r}` : r;
@@ -300,7 +326,7 @@ var o = /* @__PURE__ */ new Set(), s = () => globalThis.process?.env?.NODE_ENV !
 		};
 		a(e);
 	}
-	return {
+	return f(n), {
 		meta: n,
 		defaultValues: r,
 		unionMeta: i

package/dist/vue-components51.es.js

@@ -22,15 +22,22 @@ var y = /* @__PURE__ */ c({
 			if (!e) return b.value;
 			let t = e;
 			return `${b.value}-${t.type}-${t.minLength ?? ""}-${t.maxLength ?? ""}-${t.minimum ?? ""}-${t.maximum ?? ""}`;
-		}), { trans: E } = e(), D = i(() => {
+		}), { trans: E } = e(), D = (e) => Array.isArray(e?.issues) && e.issues.length > 0, O = (e, t) => ({ "~standard": {
+			...e["~standard"],
+			validate: (n) => {
+				let r = e["~standard"].validate(n);
+				return r && typeof r.then == "function" ? r.then((e) => D(e) ? e : t["~standard"].validate(n)) : D(r) ? r : t["~standard"].validate(n);
+			}
+		} }), k = i(() => {
 			if (!w.value) throw console.log(y.name, Object.keys(y.form.meta), y.form.meta), Error("Meta is undefined");
-			return t(w.value, E);
-		}), O = r(y.form);
+			let e = t(w.value, E), n = w.value.originalSchema;
+			return n ? O(e, n) : e;
+		}), A = r(y.form);
 		return (e, t) => (p(), a(h(c.form.Field), {
 			key: T.value,
 			name: c.name,
 			validators: {
-				onBlur: D.value,
+				onBlur: k.value,
 				...c.validators
 			}
 		}, {
@@ -42,7 +49,7 @@ var y = /* @__PURE__ */ c({
 				field: t,
 				state: r,
 				register: c.form.registerField,
-				label: c.label ?? g(O)(b.value),
+				label: c.label ?? g(A)(b.value),
 				meta: w.value
 			}), s({
 				default: v((t) => [m(e.$slots, "default", f(l(t)))]),

package/dist/vue-components61.es.js

@@ -77,7 +77,7 @@ var te = class extends S.TaggedError("FormErrors") {}, k = (e) => function(t) {
 	};
 }, M = (e, t) => e.includes(t), N = O(x.empty()), P = (e, h, x) => {
 	if (!e) throw Error("Schema is required");
-	let S = i(e), O = E.toStandardSchemaV1(S), A = E.decodeUnknownEffect(S), { meta: P, unionMeta: ne } = r(e), F = m(() => x?.persistency?.id ? x.persistency.id : `${window.location.pathname}-${Object.keys(P).join("-")}`), I = () => {
+	let S = i(e), O = E.toStandardSchemaV1(S), A = E.decodeUnknownEffect(S), { meta: P, unionMeta: ne } = r(S), F = m(() => x?.persistency?.id ? x.persistency.id : `${window.location.pathname}-${Object.keys(P).join("-")}`), I = () => {
 		let e = new URLSearchParams(window.location.search);
 		e.delete(F.value);
 		let t = new URL(window.location.href);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "4.0.0-beta.150",
+  "version": "4.0.0-beta.151",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "effect": "^4.0.0-beta.56",
@@ -58,8 +58,8 @@
     "highlight.js": "^11.11.1",
     "mitt": "^3.0.1",
     "vue3-highlightjs": "^1.0.5",
-    "effect-app": "4.0.0-beta.150",
-    "@effect-app/vue": "4.0.0-beta.150"
+    "@effect-app/vue": "4.0.0-beta.151",
+    "effect-app": "4.0.0-beta.151"
   },
   "scripts": {
     "check": "vue-tsc",

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -256,6 +256,7 @@ 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
@@ -509,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)
@@ -608,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) {
@@ -628,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
@@ -651,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
+                            }
                           }
                         }
                       }
@@ -667,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
@@ -708,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
@@ -718,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>({
@@ -729,6 +753,9 @@ export const createMeta = <T = any>(
                     }
                   })
                   acc[propKey as NestedKeyOf<T>] = fieldMeta as FieldMeta
+                  if (fieldAstByPath) {
+                    fieldAstByPath[propKey] = prop.type
+                  }
                 }
               }
             }
@@ -741,6 +768,9 @@ export const createMeta = <T = any>(
               required: isRequired,
               nullableOrUndefined
             } as FieldMeta
+            if (fieldAstByPath) {
+              fieldAstByPath[key] = p.type
+            }
           }
         } else {
           const newMeta = createMeta<T>({
@@ -757,6 +787,9 @@ export const createMeta = <T = any>(
           })
 
           acc[key as NestedKeyOf<T>] = newMeta as FieldMeta
+          if (fieldAstByPath) {
+            fieldAstByPath[key] = p.type
+          }
         }
       }
     }
@@ -861,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)) {
@@ -910,9 +982,13 @@ const metadataFromAst = <From, To>(
           }
 
           // 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) {
@@ -933,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 = (
@@ -963,6 +1050,7 @@ const metadataFromAst = <From, To>(
     flattenObject(meta)
   }
 
+  attachOriginalSchemas(newMeta)
   return { meta: newMeta, defaultValues, unionMeta }
 }
 

package/src/components/OmegaForm/OmegaInput.vue

@@ -4,6 +4,7 @@
     :key="fieldKey"
     :name="name"
     :validators="{
+      //     onChange: schema,
       onBlur: schema,
       ...validators
     }"
@@ -97,12 +98,45 @@ const fieldKey = computed(() => {
 // Call useIntl during setup to avoid issues when computed re-evaluates
 const { trans } = useIntl()
 
+const hasIssues = (result: any): boolean => Array.isArray(result?.issues) && result.issues.length > 0
+
+const composeStandardSchemas = (
+  omegaSchema: any,
+  originalSchema: any
+) => ({
+  "~standard": {
+    ...omegaSchema["~standard"],
+    validate: (value: unknown) => {
+      const omegaResult = omegaSchema["~standard"].validate(value)
+      if (omegaResult && typeof omegaResult.then === "function") {
+        return omegaResult.then((resolved: any) => {
+          if (hasIssues(resolved)) {
+            return resolved
+          }
+          return originalSchema["~standard"].validate(value)
+        })
+      }
+
+      if (hasIssues(omegaResult)) {
+        return omegaResult
+      }
+
+      return originalSchema["~standard"].validate(value)
+    }
+  }
+})
+
 const schema = computed(() => {
   if (!meta.value) {
     console.log(props.name, Object.keys(props.form.meta), props.form.meta)
     throw new Error("Meta is undefined")
   }
-  return generateInputStandardSchemaFromFieldMeta(meta.value, trans)
+  const omegaSchema = generateInputStandardSchemaFromFieldMeta(meta.value, trans)
+  const fieldSchema = meta.value.originalSchema
+  if (fieldSchema) {
+    return composeStandardSchemas(omegaSchema, fieldSchema)
+  }
+  return omegaSchema
 })
 
 const errori18n = useErrorLabel(props.form)

package/src/components/OmegaForm/useOmegaForm.ts

@@ -688,7 +688,7 @@ export const useOmegaForm = <
   const standardSchema = S.toStandardSchemaV1(formCompatibleSchema)
   const decode = S.decodeUnknownEffect(formCompatibleSchema)
 
-  const { meta, unionMeta } = generateMetaFromSchema(schema)
+  const { meta, unionMeta } = generateMetaFromSchema(formCompatibleSchema)
 
   const persistencyKey = computed(() => {
     if (omegaConfig?.persistency?.id) {