@effect-app/vue-components 4.0.0-beta.235 → 4.0.0-beta.236

package/dist/types/components/OmegaForm/meta/defaults.d.ts

@@ -1,2 +1,21 @@
 import * as S from "effect-app/Schema";
 export declare const defaultsValueFromSchema: (schema: S.Schema<any>, record?: Record<string, any>) => any;
+/**
+ * Deep-fills a partial form value with schema defaults for any nullable
+ * struct that has **materialised**.
+ *
+ * A nullable struct (`S.NullOr(S.Struct(...))`) left `null` stays `null`, but
+ * once it materialises — e.g. the user filled a single child — its untouched
+ * children are filled with their schema default (or `null` when nullable).
+ * Without this, strict `S.NullOr(...)` children reject the leftover
+ * `undefined` with a spurious "field must not be empty" error.
+ *
+ * Only children of a struct reached *through a nullable union* are filled;
+ * the always-present root struct keeps whatever fields it already has, so the
+ * form's own default-value priority is left untouched.
+ *
+ * Reference-preserving: returns `value` unchanged (same reference) when there
+ * is nothing to fill, so callers can detect a no-op with `===` and the result
+ * is idempotent (`fill(fill(v)) === fill(v)`).
+ */
+export declare const fillNestedDefaults: (ast: S.AST.AST, value: unknown, fillMissing?: boolean) => unknown;

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

@@ -134,6 +134,12 @@ export interface OF<From, To> extends OmegaFormApi<From, To> {
     meta: MetaRecord<From>;
     unionMeta: Record<string, MetaRecord<From>>;
     clear: () => void;
+    /**
+     * Backfills the untouched children of any materialised nullable struct with
+     * their schema default (or `null`), so the live `values` matches what
+     * validation and decoding see. Called after a field change.
+     */
+    normalizeNullableStructs: () => void;
     i18nNamespace?: string;
     ignorePreventCloseEvents?: boolean;
     registerField: (field: ComputedRef<{

package/dist/vue-components15.es.js

@@ -19,44 +19,96 @@ var a = (e) => {
 function s(e) {
 	return e && "members" in e && Array.isArray(e.members);
 }
-var c = (r, i = {}) => {
-	let a = r.ast, l = o(a);
-	if (l !== void 0) return l;
+var c = (e) => typeof e == "object" && !!e && !Array.isArray(e), l = (e) => n.AST.isNull(e) || n.AST.isUndefined(e), u = (e) => {
+	let r = t(e);
+	return n.AST.isUnion(r) ? r.types.flatMap(u) : [r];
+}, d = (e) => {
+	let r = t(e);
+	if (n.AST.isLiteral(r)) return r.literal;
+	if (n.AST.isUnion(r) && r.types.length === 1) return d(r.types[0]);
+}, f = (e, t) => {
+	if (!(!c(t) || t._tag === void 0)) return e.find((e) => {
+		let n = e.propertySignatures.find((e) => e.name.toString() === "_tag");
+		return n ? d(n.type) === t._tag : !1;
+	});
+}, p = (r, i = {}) => {
+	let a = r.ast, c = o(a);
+	if (c !== void 0) return c;
 	if (e(r.ast) === "null") return null;
 	if (e(r.ast) === "undefined") return;
-	let u = n.AST.isObjects(a) ? a : n.AST.isDeclaration(a) ? t(a) : void 0;
-	if (u && n.AST.isObjects(u)) {
+	let l = n.AST.isObjects(a) ? a : n.AST.isDeclaration(a) ? t(a) : void 0;
+	if (l && n.AST.isObjects(l)) {
 		let t = {};
-		for (let r of u.propertySignatures) {
-			let a = r.name.toString(), s = r.type, l = o(s);
-			if (l !== void 0) {
-				t[a] = l;
+		for (let r of l.propertySignatures) {
+			let a = r.name.toString(), s = r.type, c = o(s);
+			if (c !== void 0) {
+				t[a] = c;
 				continue;
 			}
-			let u = c(n.make(s), i[a] || {});
-			u === void 0 ? e(s) === "undefined" && (t[a] = void 0) : t[a] = u;
+			let l = p(n.make(s), i[a] || {});
+			l === void 0 ? e(s) === "undefined" && (t[a] = void 0) : t[a] = l;
 		}
 		return {
 			...t,
 			...i
 		};
 	}
-	let d = n.AST.isUnion(a) ? a.types : s(r) ? r.members.map((e) => e.ast) : void 0;
-	if (d) {
+	let u = n.AST.isUnion(a) ? a.types : s(r) ? r.members.map((e) => e.ast) : void 0;
+	if (u) {
 		let e = {};
-		for (let r of d) {
+		for (let r of u) {
 			let i = t(r);
 			if (n.AST.isObjects(i)) for (let t of i.propertySignatures) {
 				let n = t.name.toString(), r = o(t.type), i = e[n] ? o(e[n].ast) : void 0;
 				(!e[n] || r !== void 0 && i === void 0) && (e[n] = { ast: t.type });
 			}
 		}
-		return Object.keys(e).length === 0 ? Object.keys(i).length > 0 ? i : void 0 : Object.entries(e).reduce((e, [t, { ast: r }]) => (e[t] = c(n.make(r), i[t] || {}), e), i);
+		return Object.keys(e).length === 0 ? Object.keys(i).length > 0 ? i : void 0 : Object.entries(e).reduce((e, [t, { ast: r }]) => (e[t] = p(n.make(r), i[t] || {}), e), i);
 	}
 	if (Object.keys(i).length === 0) {
 		if (n.AST.isString(a)) return "";
 		if (n.AST.isBoolean(a)) return !1;
 	}
+}, m = (r, i, a = !1) => {
+	let s = t(r);
+	switch (s._tag) {
+		case "Union": {
+			if (i == null) return i;
+			let e = u(s), t = e.filter(n.AST.isObjects);
+			if (t.length === 0) return i;
+			let r = e.some(l), o = f(t, i);
+			return o ? m(o, i, a || r) : r && t.length === 1 ? m(t[0], i, !0) : i;
+		}
+		case "Arrays": {
+			if (!Array.isArray(i)) return i;
+			let e = s.rest[0];
+			if (!e) return i;
+			let t = !1, n = i.map((n) => {
+				let r = m(e, n, a);
+				return r !== n && (t = !0), r;
+			});
+			return t ? n : i;
+		}
+		case "Objects": {
+			if (!c(i)) return i;
+			let t = i, n = !1, r = (e, r) => {
+				n ||= (t = { ...i }, !0), t[e] = r;
+			};
+			for (let t of s.propertySignatures) {
+				let n = t.name.toString(), s = i[n];
+				if (s !== void 0) {
+					let e = m(t.type, s, a);
+					e !== s && r(n, e);
+					continue;
+				}
+				if (!a || t.type.context?.isOptional === !0) continue;
+				let c = o(t.type);
+				c === void 0 ? e(t.type) === "null" && r(n, null) : r(n, c);
+			}
+			return t;
+		}
+		default: return i;
+	}
 };
 //#endregion
-export { c as defaultsValueFromSchema };
+export { p as defaultsValueFromSchema, m as fillNestedDefaults };

package/dist/vue-components33.es.js

@@ -33,7 +33,7 @@ var b = /* @__PURE__ */ o({
 			id: D
 		})));
 		let j = t(() => k.value[b.field.name]?.errors ?? []), M = t(() => j.value.map((e) => e?.message).filter(Boolean)), N = (e) => e == null || e === !1 || e === "" || Number.isNaN(e), P = (e) => {
-			N(e) && b.meta?.type !== "boolean" ? b.meta?.nullableOrUndefined ? b.field.handleChange(b.meta.nullableOrUndefined === "undefined" ? void 0 : null) : b.meta?.isOptionalKey ? b.field.form.deleteField(b.field.name) : b.field.handleChange(e) : b.field.handleChange(e);
+			N(e) && b.meta?.type !== "boolean" ? b.meta?.nullableOrUndefined ? b.field.handleChange(b.meta.nullableOrUndefined === "undefined" ? void 0 : null) : b.meta?.isOptionalKey ? b.field.form.deleteField(b.field.name) : b.field.handleChange(e) : b.field.handleChange(e), b.field.form.normalizeNullableStructs?.();
 		}, F = (e) => new Proxy(e, { get(e, t, n) {
 			return t === "handleChange" ? P : Reflect.get(...arguments);
 		} }), I = t(() => ({

package/dist/vue-components68.es.js

@@ -1,82 +1,100 @@
 import { useIntl as e } from "./vue-components6.es.js";
-import { generateMetaFromSchema as t } from "./vue-components14.es.js";
-import { defaultsValueFromSchema as n } from "./vue-components15.es.js";
-import { toFormSchema as r } from "./vue-components16.es.js";
-import { usePersistency as i } from "./vue-components18.es.js";
-import { annotateLiteralUnionMessages as a, toLocalizedStandardSchemaV1 as o } from "./vue-components19.es.js";
-import { eHoc as s, makeFieldMap as c } from "./vue-components20.es.js";
-import { fHoc as l } from "./vue-components21.es.js";
-import u from "./vue-components23.es.js";
-import d from "./vue-components25.es.js";
-import f from "./vue-components29.es.js";
-import p from "./vue-components36.es.js";
-import m from "./vue-components40.es.js";
-import h from "./vue-components44.es.js";
-import { makeSubmitHandlers as g, wrapOnSubmit as _ } from "./vue-components67.es.js";
-import { watch as v } from "vue";
-import * as y from "effect-app/Schema";
-import { revalidateLogic as b, useForm as x } from "@tanstack/vue-form";
-import * as S from "effect-app/Context";
-import { makeRunPromise as C } from "@effect-app/vue/runtime";
+import { generateMetaFromSchema as t, unwrapDeclaration as n } from "./vue-components14.es.js";
+import { defaultsValueFromSchema as r, fillNestedDefaults as i } from "./vue-components15.es.js";
+import { toFormSchema as a } from "./vue-components16.es.js";
+import { usePersistency as o } from "./vue-components18.es.js";
+import { annotateLiteralUnionMessages as s, toLocalizedStandardSchemaV1 as c } from "./vue-components19.es.js";
+import { eHoc as l, makeFieldMap as u } from "./vue-components20.es.js";
+import { fHoc as d } from "./vue-components21.es.js";
+import f from "./vue-components23.es.js";
+import p from "./vue-components25.es.js";
+import m from "./vue-components29.es.js";
+import h from "./vue-components36.es.js";
+import g from "./vue-components40.es.js";
+import _ from "./vue-components44.es.js";
+import { makeSubmitHandlers as v, wrapOnSubmit as y } from "./vue-components67.es.js";
+import { watch as b } from "vue";
+import * as x from "effect-app/Schema";
+import { revalidateLogic as S, useForm as C } from "@tanstack/vue-form";
+import * as w from "effect-app/Context";
+import { makeRunPromise as T } from "@effect-app/vue/runtime";
 //#region src/components/OmegaForm/useOmegaForm.ts
-var w = Symbol("OmegaForm"), T = C(S.empty()), E = (S, C, w) => {
-	if (!S) throw Error("Schema is required");
-	let { trans: E } = e(), D = r(S), O = o(a(D, E), E), k = y.decodeUnknownEffectConcurrently(D), { meta: A, unionMeta: j } = t(D), M = { form: void 0 }, N = i({
-		meta: A,
-		persistency: w?.persistency,
-		preventWindowExit: w?.preventWindowExit,
-		defaultValuesPriority: w?.defaultValuesPriority,
-		tanstackDefaultValues: C?.defaultValues,
-		schemaDefaultValues: () => n(S),
-		getForm: () => M.form
-	}), P = x({
-		...C,
-		validationLogic: b(),
+var E = Symbol("OmegaForm"), D = T(w.empty()), O = (w, T, E) => {
+	if (!w) throw Error("Schema is required");
+	let { trans: O } = e(), k = a(w), A = s(k, O), j = n(k.ast), M = (e) => i(j, e), N = c(A, O), P = {
+		...N,
+		"~standard": {
+			...N["~standard"],
+			validate: (e) => N["~standard"].validate(M(e))
+		}
+	}, F = x.decodeUnknownEffectConcurrently(k), I = (e) => F(M(e)), { meta: L, unionMeta: R } = t(k), z = { form: void 0 }, B = o({
+		meta: L,
+		persistency: E?.persistency,
+		preventWindowExit: E?.preventWindowExit,
+		defaultValuesPriority: E?.defaultValuesPriority,
+		tanstackDefaultValues: T?.defaultValues,
+		schemaDefaultValues: () => r(w),
+		getForm: () => z.form
+	}), V = C({
+		...T,
+		validationLogic: S(),
 		validators: {
-			onDynamic: O,
-			...C?.validators
+			onDynamic: P,
+			...T?.validators
 		},
-		onSubmit: _(C?.onSubmit, k, T),
-		defaultValues: N.defaultValues.value
+		onSubmit: y(T?.onSubmit, I, D),
+		defaultValues: B.defaultValues.value
 	});
-	M.form = P;
-	let F = () => {
-		Object.keys(A).forEach((e) => {
-			P.setFieldValue(e, void 0);
+	z.form = V;
+	let H = () => {
+		let e = V.state.values, t = i(j, e);
+		if (t === e || !t || typeof t != "object") return;
+		let n = e, r = t;
+		for (let e of Object.keys(r)) if (r[e] !== n[e]) {
+			let t = e;
+			V.setFieldValue(t, r[e], {
+				dontUpdateMeta: !0,
+				dontValidate: !0
+			});
+		}
+	}, U = () => {
+		Object.keys(L).forEach((e) => {
+			V.setFieldValue(e, void 0);
 		});
 	};
-	if (w?.preventWindowExit === "prevent-and-reset") {
-		let e = P.useStore((e) => e.isSubmitting), t = P.useStore((e) => e.submissionAttempts), n = P.useStore((e) => e.canSubmit), r = P.useStore((e) => e.values);
-		v([e, t], ([e, t], [i]) => {
-			i && !e && t > 0 && n.value && P.reset(r.value);
+	if (E?.preventWindowExit === "prevent-and-reset") {
+		let e = V.useStore((e) => e.isSubmitting), t = V.useStore((e) => e.submissionAttempts), n = V.useStore((e) => e.canSubmit), r = V.useStore((e) => e.values);
+		b([e, t], ([e, t], [i]) => {
+			i && !e && t > 0 && n.value && V.reset(r.value);
 		});
 	}
-	let { handleSubmit: I, handleSubmitEffect: L } = g(P), { fieldMap: R, registerField: z } = c(), B = Object.assign(P, {
-		i18nNamespace: w?.i18nNamespace,
-		ignorePreventCloseEvents: w?.ignorePreventCloseEvents,
-		meta: A,
-		unionMeta: j,
-		clear: F,
-		handleSubmit: I,
-		handleSubmitEffect: L,
-		registerField: z
-	}), V = {
-		form: B,
-		fieldMap: R
+	let { handleSubmit: W, handleSubmitEffect: G } = v(V), { fieldMap: K, registerField: q } = u(), J = Object.assign(V, {
+		i18nNamespace: E?.i18nNamespace,
+		ignorePreventCloseEvents: E?.ignorePreventCloseEvents,
+		meta: L,
+		unionMeta: R,
+		clear: U,
+		normalizeNullableStructs: H,
+		handleSubmit: W,
+		handleSubmitEffect: G,
+		registerField: q
+	}), Y = {
+		form: J,
+		fieldMap: K
 	};
-	return Object.assign(B, {
+	return Object.assign(J, {
 		_paths: void 0,
 		_keys: void 0,
-		_schema: S,
-		errorContext: V,
-		Form: l(B)(h),
-		Input: l(B)(w?.input ?? p),
-		TaggedUnion: l(B)(m),
-		Field: P.Field,
-		Errors: s(V)(f),
-		Array: l(B)(u),
-		AutoGen: l(B)(d)
+		_schema: w,
+		errorContext: Y,
+		Form: d(J)(_),
+		Input: d(J)(E?.input ?? h),
+		TaggedUnion: d(J)(g),
+		Field: V.Field,
+		Errors: l(Y)(m),
+		Array: d(J)(f),
+		AutoGen: d(J)(p)
 	});
 };
 //#endregion
-export { w as OmegaFormKey, E as useOmegaForm };
+export { E as OmegaFormKey, O as useOmegaForm };

package/package.json

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

package/src/components/OmegaForm/OmegaInternalInput.vue

@@ -145,6 +145,12 @@ const handleChange: OmegaFieldInternalApi<From, Name>["handleChange"] = (value)
   } else {
     props.field.handleChange(value)
   }
+
+  // A change here may have materialised a nullable struct (this field is one
+  // of its children); backfill the untouched siblings so the live `values`
+  // matches what validation and decoding see.
+  const form = props.field.form as { normalizeNullableStructs?: () => void }
+  form.normalizeNullableStructs?.()
 }
 
 // Note: Default value normalization (converting empty strings to null/undefined for nullable fields)

package/src/components/OmegaForm/meta/defaults.ts

@@ -33,10 +33,44 @@ type SchemaWithMembers = {
   members: readonly S.Schema<any>[]
 }
 
+type UnknownRecord = Record<string, unknown>
+
 function hasMembers(schema: any): schema is SchemaWithMembers {
   return schema && "members" in schema && Array.isArray(schema.members)
 }
 
+const isRecord = (value: unknown): value is UnknownRecord =>
+  value !== null && typeof value === "object" && !Array.isArray(value)
+
+const isNullishAst = (ast: S.AST.AST) => S.AST.isNull(ast) || S.AST.isUndefined(ast)
+
+const unionMembers = (ast: S.AST.AST): readonly S.AST.AST[] => {
+  const resolved = unwrapDeclaration(ast)
+  return S.AST.isUnion(resolved)
+    ? resolved.types.flatMap(unionMembers)
+    : [resolved]
+}
+
+const literalValue = (ast: S.AST.AST): unknown => {
+  const resolved = unwrapDeclaration(ast)
+  if (S.AST.isLiteral(resolved)) return resolved.literal
+  if (S.AST.isUnion(resolved) && resolved.types.length === 1) {
+    return literalValue(resolved.types[0])
+  }
+}
+
+const findTaggedObjectMember = (
+  members: readonly S.AST.Objects[],
+  value: unknown
+): S.AST.Objects | undefined => {
+  if (!isRecord(value) || value._tag === undefined) return undefined
+
+  return members.find((member) => {
+    const tagProp = member.propertySignatures.find((prop) => prop.name.toString() === "_tag")
+    return tagProp ? literalValue(tagProp.type) === value._tag : false
+  })
+}
+
 // Internal implementation with WeakSet tracking
 export const defaultsValueFromSchema = (
   schema: S.Schema<any>,
@@ -132,3 +166,96 @@ export const defaultsValueFromSchema = (
     }
   }
 }
+
+/**
+ * Deep-fills a partial form value with schema defaults for any nullable
+ * struct that has **materialised**.
+ *
+ * A nullable struct (`S.NullOr(S.Struct(...))`) left `null` stays `null`, but
+ * once it materialises — e.g. the user filled a single child — its untouched
+ * children are filled with their schema default (or `null` when nullable).
+ * Without this, strict `S.NullOr(...)` children reject the leftover
+ * `undefined` with a spurious "field must not be empty" error.
+ *
+ * Only children of a struct reached *through a nullable union* are filled;
+ * the always-present root struct keeps whatever fields it already has, so the
+ * form's own default-value priority is left untouched.
+ *
+ * Reference-preserving: returns `value` unchanged (same reference) when there
+ * is nothing to fill, so callers can detect a no-op with `===` and the result
+ * is idempotent (`fill(fill(v)) === fill(v)`).
+ */
+export const fillNestedDefaults = (
+  ast: S.AST.AST,
+  value: unknown,
+  fillMissing = false
+): unknown => {
+  const resolved = unwrapDeclaration(ast)
+
+  switch (resolved._tag) {
+    case "Union": {
+      if (value === null || value === undefined) return value
+      const members = unionMembers(resolved)
+      const objectMembers = members.filter(S.AST.isObjects)
+      if (objectMembers.length === 0) return value
+
+      const hasNullishMember = members.some(isNullishAst)
+      const taggedMember = findTaggedObjectMember(objectMembers, value)
+      if (taggedMember) {
+        return fillNestedDefaults(taggedMember, value, fillMissing || hasNullishMember)
+      }
+
+      if (hasNullishMember && objectMembers.length === 1) {
+        return fillNestedDefaults(objectMembers[0], value, true)
+      }
+
+      return value
+    }
+
+    case "Arrays": {
+      if (!Array.isArray(value)) return value
+      const element = resolved.rest[0]
+      if (!element) return value
+      let changed = false
+      const next = value.map((item) => {
+        const filled = fillNestedDefaults(element, item, fillMissing)
+        if (filled !== item) changed = true
+        return filled
+      })
+      return changed ? next : value
+    }
+
+    case "Objects": {
+      if (!isRecord(value)) return value
+      let result: UnknownRecord = value
+      let changed = false
+      const set = (key: string, next: unknown) => {
+        if (!changed) {
+          result = { ...value }
+          changed = true
+        }
+        result[key] = next
+      }
+      for (const prop of resolved.propertySignatures) {
+        const key = prop.name.toString()
+        const current = value[key]
+        if (current !== undefined) {
+          const filled = fillNestedDefaults(prop.type, current, fillMissing)
+          if (filled !== current) set(key, filled)
+          continue
+        }
+        if (!fillMissing || prop.type.context?.isOptional === true) continue
+        const propDefault = getDefaultFromAst(prop.type)
+        if (propDefault !== undefined) {
+          set(key, propDefault)
+        } else if (isNullableOrUndefined(prop.type) === "null") {
+          set(key, null)
+        }
+      }
+      return result
+    }
+
+    default:
+      return value
+  }
+}

package/src/components/OmegaForm/types.ts

@@ -295,6 +295,12 @@ export interface OF<From, To> extends OmegaFormApi<From, To> {
   meta: MetaRecord<From>
   unionMeta: Record<string, MetaRecord<From>>
   clear: () => void
+  /**
+   * Backfills the untouched children of any materialised nullable struct with
+   * their schema default (or `null`), so the live `values` matches what
+   * validation and decoding see. Called after a field change.
+   */
+  normalizeNullableStructs: () => void
   i18nNamespace?: string
   ignorePreventCloseEvents?: boolean
   registerField: (

package/src/components/OmegaForm/useOmegaForm.ts

@@ -1,14 +1,14 @@
 /* eslint-disable @typescript-eslint/consistent-type-imports */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { type FormAsyncValidateOrFn, type FormValidateOrFn, revalidateLogic, type StandardSchemaV1, useForm } from "@tanstack/vue-form"
+import { type DeepKeys, type DeepValue, type FormAsyncValidateOrFn, type FormValidateOrFn, revalidateLogic, type StandardSchemaV1, useForm } from "@tanstack/vue-form"
 import * as Context from "effect-app/Context"
 import * as S from "effect-app/Schema"
 import { type InjectionKey, watch } from "vue"
 import { eHoc, makeFieldMap } from "./errors"
 import { fHoc } from "./hocs"
-import { generateMetaFromSchema } from "./meta/createMeta"
-import { defaultsValueFromSchema } from "./meta/defaults"
+import { generateMetaFromSchema, unwrapDeclaration } from "./meta/createMeta"
+import { defaultsValueFromSchema, fillNestedDefaults } from "./meta/defaults"
 import { toFormSchema } from "./meta/redacted"
 import OmegaArray from "./OmegaArray.vue"
 import OmegaAutoGen from "./OmegaAutoGen.vue"
@@ -51,11 +51,29 @@ export const useOmegaForm = <
   // (select) and literal-array (multiple) AST nodes with a localized
   // `message` so the formatter picks them up via `findMessage`.
   const localizedSchema = annotateLiteralUnionMessages(formCompatibleSchema, trans)
-  const standardSchema = toLocalizedStandardSchemaV1(
+
+  // A nullable struct (`S.NullOr(S.Struct(...))`) has no slot in the form
+  // value until a child is filled. Once it materialises, its untouched
+  // children are still `undefined` — which strict `S.NullOr(...)` children
+  // reject. Deep-fill those children with their defaults before both
+  // validation and decoding so they validate as `null` (or their default).
+  const formAst = unwrapDeclaration(formCompatibleSchema.ast)
+  const normalizeFormValue = (value: unknown) => fillNestedDefaults(formAst, value)
+
+  const baseStandardSchema = toLocalizedStandardSchemaV1(
     localizedSchema as any,
     trans
   )
-  const decode = S.decodeUnknownEffectConcurrently(formCompatibleSchema)
+  const standardSchema: typeof baseStandardSchema = {
+    ...baseStandardSchema,
+    "~standard": {
+      ...baseStandardSchema["~standard"],
+      validate: (value) => baseStandardSchema["~standard"].validate(normalizeFormValue(value))
+    }
+  }
+
+  const baseDecode = S.decodeUnknownEffectConcurrently(formCompatibleSchema)
+  const decode = (value: From) => baseDecode(normalizeFormValue(value))
 
   const { meta, unionMeta } = generateMetaFromSchema(formCompatibleSchema)
 
@@ -100,6 +118,27 @@ export const useOmegaForm = <
   }) satisfies OmegaFormApi<To, From>
   formHolder.form = form
 
+  // Keep the live form state consistent with the schema: when a nullable
+  // struct materialises (a child got a value), backfill its untouched
+  // children so `values` reflects what is validated and submitted. Called
+  // from the field change handler — the only point a struct can materialise.
+  const normalizeNullableStructs = () => {
+    const current = form.state.values
+    const filled = fillNestedDefaults(formAst, current)
+    if (filled === current || !filled || typeof filled !== "object") return
+    const currentRecord = current as Partial<Record<Extract<keyof From, string>, unknown>>
+    const filledRecord = filled as Partial<Record<Extract<keyof From, string>, unknown>>
+    for (const key of Object.keys(filledRecord) as Array<Extract<keyof From, string>>) {
+      if (filledRecord[key] !== currentRecord[key]) {
+        const field = key as DeepKeys<From>
+        form.setFieldValue(field, filledRecord[key] as DeepValue<From, typeof field>, {
+          dontUpdateMeta: true,
+          dontValidate: true
+        })
+      }
+    }
+  }
+
   const clear = () => {
     Object.keys(meta).forEach((key: any) => {
       form.setFieldValue(key, undefined as any)
@@ -134,6 +173,7 @@ export const useOmegaForm = <
     meta,
     unionMeta,
     clear,
+    normalizeNullableStructs,
     handleSubmit,
     // /** @experimental */
     handleSubmitEffect,