@effect-app/vue-components 2.7.8 → 2.7.9

package/dist/vue-components.es10.js

@@ -1,128 +1,137 @@
-import { useForm as z } from "@tanstack/vue-form";
-import { Data as Q, S, Effect as b, Array as g, Fiber as O, Option as D } from "effect-app";
-import { runtimeFiberAsPromise as X } from "./vue-components.es16.js";
-import { isObject as Y } from "./vue-components.es17.js";
-import { computed as V, onUnmounted as W, onMounted as Z, onBeforeUnmount as C, watch as H, ref as ee, h as B } from "vue";
-import te from "./vue-components.es18.js";
-import re from "./vue-components.es19.js";
-import ne from "./vue-components.es20.js";
-import { generateMetaFromSchema as se, isNullableOrUndefined as J } from "./vue-components.es12.js";
-import oe from "./vue-components.es6.js";
-import ie from "./vue-components.es8.js";
-import ae from "./vue-components.es21.js";
-import { trace as q } from "./vue-components.es22.js";
-import { context as T } from "./vue-components.es23.js";
-const A = (c) => {
+import { useForm as K } from "@tanstack/vue-form";
+import { Data as G, S as p, Effect as b, Array as A, Fiber as x, Option as O } from "effect-app";
+import { runtimeFiberAsPromise as z } from "./vue-components.es16.js";
+import { isObject as Q } from "./vue-components.es17.js";
+import { computed as V, onUnmounted as N, onMounted as X, onBeforeUnmount as Y, watch as W, ref as Z, h as J } from "vue";
+import C from "./vue-components.es18.js";
+import ee from "./vue-components.es19.js";
+import te from "./vue-components.es20.js";
+import { generateMetaFromSchema as re, isNullableOrUndefined as ne } from "./vue-components.es12.js";
+import se from "./vue-components.es6.js";
+import oe from "./vue-components.es8.js";
+import ie from "./vue-components.es21.js";
+import { trace as H } from "./vue-components.es22.js";
+import { context as L } from "./vue-components.es23.js";
+const g = (c) => {
   const i = c.ast;
+  if (i._tag === "Refinement") {
+    const n = i, u = p.make(n.from);
+    return g(u);
+  }
   if (i._tag === "Union") {
-    const o = i.types.map((f) => {
-      const l = S.make(f);
-      return A(l).ast;
-    }), p = {
+    const n = i.types.map((f) => {
+      const l = p.make(f);
+      return g(l).ast;
+    }), u = {
       ...i,
-      types: o
+      types: n
     };
-    return S.make(p);
+    return p.make(u);
   }
   if (i._tag === "Transformation") {
-    const o = S.make(i.from), p = S.make(i.to), f = A(o), l = A(p), d = {
+    const n = i;
+    if (n.to._tag === "Declaration") {
+      const h = p.make(n.from);
+      return g(h);
+    }
+    const u = p.make(n.from), f = p.make(n.to), l = g(u), d = g(f), w = {
       ...i,
-      from: f.ast,
-      to: l.ast
+      from: l.ast,
+      to: d.ast
     };
-    return S.make(d);
+    return p.make(w);
   }
   if (i._tag === "TypeLiteral") {
-    const o = i.propertySignatures.map((f) => {
+    const n = i.propertySignatures.map((f) => {
       const l = f.type;
       let d = l;
-      if (l._tag === "TypeLiteral" || l._tag === "Union" || l._tag === "Transformation") {
-        const k = S.make(l);
-        d = A(k).ast;
+      if (l._tag === "TypeLiteral" || l._tag === "Union" || l._tag === "Transformation" || l._tag === "Refinement") {
+        const w = p.make(l);
+        d = g(w).ast;
       }
       return {
         ...f,
         type: d,
         isOptional: !0
       };
-    }), p = {
+    }), u = {
       ...i,
-      propertySignatures: o
+      propertySignatures: n
     };
-    return S.make(p);
+    return p.make(u);
   }
   return c;
 };
-class le extends Q.TaggedError("FormErrors") {
+class ae extends G.TaggedError("FormErrors") {
 }
-const M = (c) => function(o) {
+const k = (c) => function(n) {
   return {
     render() {
-      return B(o, {
+      return J(n, {
         form: c,
         ...this.$attrs
       }, this.$slots);
     }
   };
-}, ce = (c) => function(o) {
+}, le = (c) => function(n) {
   return {
     setup() {
-      const { fieldMap: p, form: f } = c, l = f.useStore((v) => v.errors), d = f.useStore((v) => v.fieldMeta), k = f.useStore((v) => v.errorMap), h = V(() => {
-        const v = g.filterMap(
+      const { fieldMap: u, form: f } = c, l = f.useStore((S) => S.errors), d = f.useStore((S) => S.fieldMeta), w = f.useStore((S) => S.errorMap), h = V(() => {
+        const S = A.filterMap(
           Object.entries(d.value),
-          ([x, w]) => {
-            const a = w.errors ?? [];
-            if (!a.length) return D.none();
-            const y = p.value.get(x);
-            return y ? D.some({
-              label: y.label,
-              inputId: y.id,
+          ([M, y]) => {
+            const a = y.errors ?? [];
+            if (!a.length) return O.none();
+            const v = u.value.get(M);
+            return v ? O.some({
+              label: v.label,
+              inputId: v.id,
               // Only show the first error
               errors: [a[0]?.message].filter(Boolean)
-            }) : D.none();
+            }) : O.none();
           }
         ), F = [];
-        if (k.value.onSubmit) {
-          for (const [x, w] of Object.entries(k.value.onSubmit))
-            if (g.isArray(w) && w.length)
-              for (const a of w) {
-                const y = a;
-                if (y?.path && g.isArray(y.path) && y.path.length) {
-                  const _ = y.path.join(".");
-                  if (!p.value.has(_)) {
+        if (w.value.onSubmit) {
+          for (const [M, y] of Object.entries(w.value.onSubmit))
+            if (A.isArray(y) && y.length)
+              for (const a of y) {
+                const v = a;
+                if (v?.path && A.isArray(v.path) && v.path.length) {
+                  const _ = v.path.join(".");
+                  if (!u.value.has(_)) {
                     F.push({
                       label: _,
                       inputId: _,
-                      errors: [y.message].filter(Boolean)
+                      errors: [v.message].filter(Boolean)
                     });
                     break;
                   }
                 }
               }
         }
-        return [...v, ...F];
+        return [...S, ...F];
       });
       return {
         generalErrors: l,
         errors: h
       };
     },
-    render({ errors: p, generalErrors: f }) {
-      return B(o, {
-        errors: p,
+    render({ errors: u, generalErrors: f }) {
+      return J(n, {
+        errors: u,
         generalErrors: f,
         ...this.$attrs
       }, this.$slots);
     }
   };
-}, _e = (c, i, o) => {
+}, _e = (c, i, n) => {
   if (!c) throw new Error("Schema is required");
-  const p = S.standardSchemaV1(c), f = S.decode(c), { meta: l } = se(c), d = V(() => {
-    if (o?.persistency?.id)
-      return o.persistency.id;
+  const u = p.standardSchemaV1(c), f = p.decode(c), { meta: l } = re(c), d = V(() => {
+    if (n?.persistency?.id)
+      return n.persistency.id;
     const e = window.location.pathname, t = Object.keys(l);
     return `${e}-${t.join("-")}`;
-  }), k = () => {
+  }), w = () => {
     const e = new URLSearchParams(window.location.search);
     e.delete(d.value);
     const t = new URL(window.location.href);
@@ -130,78 +139,48 @@ const M = (c) => function(o) {
   };
   function h(e, t) {
     for (const r in t)
-      g.isArray(t[r]) ? e[r] = t[r] : t[r] && Y(t[r]) ? (e[r] || (e[r] = {}), h(e[r], t[r])) : e[r] = t[r];
+      A.isArray(t[r]) ? e[r] = t[r] : t[r] && Q(t[r]) ? (e[r] || (e[r] = {}), h(e[r], t[r])) : e[r] = t[r];
     return e;
   }
-  const v = (e) => {
+  const S = (e) => {
     const t = {};
-    if (typeof e?.make == "function")
-      try {
-        const n = e.make({});
-        if (e?.fields && typeof e.fields == "object") {
-          for (const [s, u] of Object.entries(e.fields))
-            if (n[s] === void 0) {
-              const m = u?.ast, U = J(m);
-              U === "null" ? n[s] = null : U === "undefined" && (n[s] = void 0);
-            }
-        }
-        return n;
-      } catch {
-      }
-    const r = e?.members || (e?.ast?._tag === "Union" && e.ast.types ? e.ast.types.map((n) => S.make(n)) : null);
-    if (r && g.isArray(r)) {
-      for (const n of r) {
-        const s = v(n);
-        if (Object.keys(s).length > 0 && n?.fields && Object.entries(n.fields).some(
-          ([m, U]) => m === "_tag" || m === "type" || m === "kind" ? U?.ast?.defaultValue !== void 0 : !1
-        ))
-          return s;
-      }
-      return {};
-    }
     if (e?.fields && typeof e.fields == "object")
-      for (const [n, s] of Object.entries(e.fields)) {
-        if (s?.ast?.defaultValue)
+      for (const [r, o] of Object.entries(e.fields)) {
+        if (o?.ast?.defaultValue)
           try {
-            const m = s.ast.defaultValue();
-            t[n] = m;
+            const m = o.ast.defaultValue();
+            t[r] = m;
           } catch {
           }
         else {
-          const m = s?.ast;
-          switch (J(m)) {
+          const m = o?.ast;
+          switch (ne(m)) {
             case "null":
-              t[n] = null;
+              t[r] = null;
               break;
             case "undefined":
-              t[n] = void 0;
+              t[r] = void 0;
               break;
           }
         }
-        const u = v(s);
-        Object.keys(u).length > 0 && (t[n] && typeof t[n] == "object" ? Object.assign(t[n], u) : t[n] || (t[n] = u));
+        const s = S(o);
+        Object.keys(s).length > 0 && (t[r] && typeof t[r] == "object" ? Object.assign(t[r], s) : t[r] || (t[r] = s));
       }
+    else if (e?.from?.fields && typeof e?.from?.fields == "object")
+      return S(e.from);
     return t;
   }, F = (e = {}) => {
     let t = {};
     try {
-      let r = c;
-      r?.ast?._tag === "Refinement" && r?.from && (r = r.from);
-      const n = r.make(e);
-      t = S.encodeSync(A(r))(n);
+      const r = S(c);
+      t = p.encodeSync(g(c))(r);
     } catch (r) {
-      window.location.hostname === "localhost" && console.warn("schema.make() failed, extracting defaults from AST:", r);
-      try {
-        const n = v(c);
-        t = S.encodeSync(A(c))(n);
-      } catch (n) {
-        window.location.hostname === "localhost" && console.warn("Could not extract defaults from AST:", n);
-      }
+      window.location.hostname === "localhost" && console.warn("Could not extract defaults from AST:", r);
     }
     return h(t, e);
-  }, x = V(() => {
+  }, M = V(() => {
     let e;
-    const t = o?.persistency;
+    const t = n?.persistency;
     if (
       // query string has higher priority than local/session storage
       t?.policies && !e && (t.policies.includes("local") || t.policies.includes("session"))
@@ -209,131 +188,131 @@ const M = (c) => function(o) {
       const r = t.policies.includes("local") ? localStorage : sessionStorage;
       if (r)
         try {
-          const n = JSON.parse(
+          const o = JSON.parse(
             r.getItem(d.value) || "{}"
           );
-          r.removeItem(d.value), e = n;
-        } catch (n) {
-          console.error(n);
+          r.removeItem(d.value), e = o;
+        } catch (o) {
+          console.error(o);
         }
     }
     if (t?.policies && t.policies.includes("querystring"))
       try {
-        const n = new URLSearchParams(window.location.search).get(d.value);
-        k(), n && (e = h(e || {}, JSON.parse(n)));
+        const o = new URLSearchParams(window.location.search).get(d.value);
+        w(), o && (e = h(e || {}, JSON.parse(o)));
       } catch (r) {
         console.error(r);
       }
     return e ??= {}, F(
-      o?.persistency?.overrideDefaultValues ? h(i?.defaultValues || {}, e) : h(e, i?.defaultValues || {})
+      n?.persistency?.overrideDefaultValues ? h(i?.defaultValues || {}, e) : h(e, i?.defaultValues || {})
     );
-  }), w = (e, t) => e ? T.with(q.setSpan(T.active(), e), t) : t(), a = z({
+  }), y = (e, t) => e ? L.with(H.setSpan(L.active(), e), t) : t(), a = K({
     ...i,
     validators: {
-      onSubmit: p,
+      onSubmit: u,
       ...i?.validators || {}
     },
-    onSubmit: i?.onSubmit ? ({ formApi: e, meta: t, value: r }) => w(t?.currentSpan, async () => {
-      const n = await b.runPromise(f(r)), s = i.onSubmit({
+    onSubmit: i?.onSubmit ? ({ formApi: e, meta: t, value: r }) => y(t?.currentSpan, async () => {
+      const o = await b.runPromise(f(r)), s = i.onSubmit({
         formApi: e,
         meta: t,
-        value: n
+        value: o
       });
-      return O.isFiber(s) && O.isRuntimeFiber(s) ? await X(s) : b.isEffect(s) ? await b.runPromise(
+      return x.isFiber(s) && x.isRuntimeFiber(s) ? await z(s) : b.isEffect(s) ? await b.runPromise(
         s.pipe(
           // meta?.currentSpan
           //   ? Effect.withParentSpan(meta.currentSpan)
           //   : (_) => _,
-          b.flatMap((u) => O.join(u))
+          b.flatMap((m) => x.join(m))
         )
       ) : s;
     }) : void 0,
-    defaultValues: x.value
-  }), y = () => {
+    defaultValues: M.value
+  }), v = () => {
     Object.keys(l).forEach((e) => {
       a.setFieldValue(e, void 0);
     });
   }, _ = (e) => e.reduce((t, r) => {
-    const n = r.split(".");
-    return n.reduce((s, u, m) => (m === n.length - 1 ? s[u] = a.getFieldValue(r) : s[u] = s[u] ?? {}, s[u]), t), t;
-  }, {}), j = (e) => {
+    const o = r.split(".");
+    return o.reduce((s, m, U) => (U === o.length - 1 ? s[m] = a.getFieldValue(r) : s[m] = s[m] ?? {}, s[m]), t), t;
+  }, {}), D = (e) => {
     if (e) {
-      if (g.isArray(e.keys))
+      if (A.isArray(e.keys))
         return _(e.keys);
-      if (g.isArray(e.banKeys)) {
+      if (A.isArray(e.banKeys)) {
         const t = Object.keys(l).filter((r) => e.banKeys?.includes(r));
         return _(t);
       }
       return a.store.state.values;
     }
   }, P = () => {
-    const e = o?.persistency;
+    const e = n?.persistency;
     if (!(!e?.policies || e.policies.length === 0) && (e.policies.includes("local") || e.policies.includes("session"))) {
       const t = e.policies.includes("local") ? localStorage : sessionStorage;
       if (!t) return;
-      const r = j(e);
+      const r = D(e);
       return t.setItem(d.value, JSON.stringify(r));
     }
-  }, I = () => {
-    const e = o?.persistency;
+  }, T = () => {
+    const e = n?.persistency;
     if (!(!e?.policies || e.policies.length === 0) && e.policies.includes("querystring")) {
-      const t = j(e), r = new URLSearchParams(window.location.search);
+      const t = D(e), r = new URLSearchParams(window.location.search);
       r.set(d.value, JSON.stringify(t));
-      const n = new URL(window.location.href);
-      n.search = r.toString(), window.history.replaceState({}, "", n.toString());
+      const o = new URL(window.location.href);
+      o.search = r.toString(), window.history.replaceState({}, "", o.toString());
     }
-  }, $ = (e) => {
+  }, I = (e) => {
     a.store.state.isDirty && e.preventDefault();
   };
-  if (W(P), Z(() => {
-    window.addEventListener("beforeunload", P), window.addEventListener("blur", I), o?.preventWindowExit && o.preventWindowExit !== "nope" && window.addEventListener("beforeunload", $);
-  }), C(() => {
-    window.removeEventListener("beforeunload", P), window.removeEventListener("blur", I), o?.preventWindowExit && o.preventWindowExit !== "nope" && window.removeEventListener("beforeunload", $);
-  }), o?.preventWindowExit === "prevent-and-reset") {
-    const e = a.useStore((s) => s.isSubmitting), t = a.useStore((s) => s.submissionAttempts), r = a.useStore((s) => s.canSubmit), n = a.useStore((s) => s.values);
-    H([e, t], ([s, u], [m]) => {
-      m && !s && u > 0 && r.value && a.reset(n.value);
+  if (N(P), X(() => {
+    window.addEventListener("beforeunload", P), window.addEventListener("blur", T), n?.preventWindowExit && n.preventWindowExit !== "nope" && window.addEventListener("beforeunload", I);
+  }), Y(() => {
+    window.removeEventListener("beforeunload", P), window.removeEventListener("blur", T), n?.preventWindowExit && n.preventWindowExit !== "nope" && window.removeEventListener("beforeunload", I);
+  }), n?.preventWindowExit === "prevent-and-reset") {
+    const e = a.useStore((s) => s.isSubmitting), t = a.useStore((s) => s.submissionAttempts), r = a.useStore((s) => s.canSubmit), o = a.useStore((s) => s.values);
+    W([e, t], ([s, m], [U]) => {
+      U && !s && m > 0 && r.value && a.reset(o.value);
     });
   }
-  const N = (e) => b.currentSpan.pipe(
+  const R = (e) => b.currentSpan.pipe(
     b.option,
     b.flatMap(
-      (t) => b.promise(() => a.handleSubmit(D.isSome(t) ? { currentSpan: t.value, ...e } : e))
+      (t) => b.promise(() => a.handleSubmit(O.isSome(t) ? { currentSpan: t.value, ...e } : e))
     )
-  ), K = (e) => e?.checkErrors ? N(e?.meta).pipe(b.flatMap(b.fnUntraced(function* () {
+  ), q = (e) => e?.checkErrors ? R(e?.meta).pipe(b.flatMap(b.fnUntraced(function* () {
     const t = a.getAllErrors();
     if (Object.keys(t.fields).length || t.form.errors.length)
-      return yield* new le({ form: t.form, fields: t.fields });
-  }))) : N(e?.meta), G = a.handleSubmit, L = ee(/* @__PURE__ */ new Map()), E = Object.assign(a, {
-    i18nNamespace: o?.i18nNamespace,
-    ignorePreventCloseEvents: o?.ignorePreventCloseEvents,
+      return yield* new ae({ form: t.form, fields: t.fields });
+  }))) : R(e?.meta), B = a.handleSubmit, j = Z(/* @__PURE__ */ new Map()), E = Object.assign(a, {
+    i18nNamespace: n?.i18nNamespace,
+    ignorePreventCloseEvents: n?.ignorePreventCloseEvents,
     meta: l,
-    clear: y,
+    clear: v,
     handleSubmit: (e) => {
-      const t = q.getSpan(T.active());
-      return G({ currentSpan: t, ...e });
+      const t = H.getSpan(L.active());
+      return B({ currentSpan: t, ...e });
     },
     // /** @experimental */
-    handleSubmitEffect: K,
+    handleSubmitEffect: q,
     registerField: (e) => {
-      H(e, (t) => L.value.set(t.name, { label: t.label, id: t.id }), { immediate: !0 }), W(() => L.value.delete(e.value.name));
+      W(e, (t) => j.value.set(t.name, { label: t.label, id: t.id }), { immediate: !0 }), N(() => j.value.delete(e.value.name));
     }
-  }), R = { form: E, fieldMap: L };
+  }), $ = { form: E, fieldMap: j };
   return Object.assign(E, {
     // Type-level properties for performance optimization (not used at runtime)
     _paths: void 0,
     _keys: void 0,
-    errorContext: R,
-    Form: M(E)(ae),
-    Input: M(E)(o?.input ?? oe),
-    TaggedUnion: M(E)(ie),
+    errorContext: $,
+    Form: k(E)(ie),
+    Input: k(E)(n?.input ?? se),
+    TaggedUnion: k(E)(oe),
     Field: a.Field,
-    Errors: ce(R)(ne),
-    Array: M(E)(te),
-    AutoGen: M(E)(re)
+    Errors: le($)(te),
+    Array: k(E)(C),
+    AutoGen: k(E)(ee)
   });
 };
 export {
-  le as FormErrors,
+  ae as FormErrors,
   _e as useOmegaForm
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "2.7.8",
+  "version": "2.7.9",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "effect": "^3.18.0",
@@ -53,8 +53,8 @@
     "highlight.js": "^11.11.1",
     "mitt": "^3.0.1",
     "vue3-highlightjs": "^1.0.5",
-    "@effect-app/vue": "2.92.2",
-    "effect-app": "3.12.0"
+    "effect-app": "3.12.0",
+    "@effect-app/vue": "2.92.2"
   },
   "scripts": {
     "build": "pnpm build:run",

package/src/components/OmegaForm/useOmegaForm.ts

@@ -29,6 +29,14 @@ import OmegaForm from "./OmegaWrapper.vue"
 const partialRecursive = <A, I, R>(schema: S.Schema<A, I, R>): S.Schema<Partial<A>, Partial<I>, R> => {
   const ast = schema.ast
 
+  // Handle Refinement types (e.g., NonEmptyArray, filters on ExtendedClass)
+  if (ast._tag === "Refinement") {
+    const refinementAst = ast as any
+    // For refinements, bypass the filter and recursively apply partial to the underlying type
+    const fromSchema = S.make(refinementAst.from)
+    return partialRecursive(fromSchema as any)
+  }
+
   // Handle Union types - recursively apply partial to each member
   if (ast._tag === "Union") {
     const partialMembers = (ast as any).types.map((memberAst: any) => {
@@ -45,11 +53,21 @@ const partialRecursive = <A, I, R>(schema: S.Schema<A, I, R>): S.Schema<Partial<
     return S.make(newAst as any)
   }
 
-  // Handle Transformation types (e.g., withDefaultConstructor)
+  // Handle Transformation types (e.g., withDefaultConstructor, ExtendedClass)
   if (ast._tag === "Transformation") {
-    // For transformations, apply partial to both the 'from' and 'to' sides
-    const fromSchema = S.make((ast as any).from)
-    const toSchema = S.make((ast as any).to)
+    const transformAst = ast as any
+
+    // Special handling for ExtendedClass (Declaration in 'to' side)
+    if (transformAst.to._tag === "Declaration") {
+      // For ExtendedClass, extract the TypeLiteral from the 'from' side
+      // and make that partial, bypassing the Declaration entirely
+      const fromSchema = S.make(transformAst.from)
+      return partialRecursive(fromSchema as any)
+    }
+
+    // For other transformations, apply partial to both sides
+    const fromSchema = S.make(transformAst.from)
+    const toSchema = S.make(transformAst.to)
     const partialFrom = partialRecursive(fromSchema as any)
     const partialTo = partialRecursive(toSchema as any)
 
@@ -68,8 +86,12 @@ const partialRecursive = <A, I, R>(schema: S.Schema<A, I, R>): S.Schema<Partial<
       const propType = prop.type
       let newType = propType
 
-      // Recursively handle nested complex types (structs, unions, transformations)
-      if (propType._tag === "TypeLiteral" || propType._tag === "Union" || propType._tag === "Transformation") {
+      // Recursively handle nested complex types (structs, unions, transformations, refinements)
+      if (
+        propType._tag === "TypeLiteral" || propType._tag === "Union" || propType
+            ._tag === "Transformation" || propType
+            ._tag === "Refinement"
+      ) {
         const nestedSchema = S.make(propType)
         const recursivePartial = partialRecursive(nestedSchema as any)
         newType = recursivePartial.ast
@@ -762,66 +784,6 @@ export const useOmegaForm = <
   const extractDefaultsFromAST = (schemaObj: any): any => {
     const result: Record<string, any> = {}
 
-    // If this schema has a .make() method (like ExtendedClass), use it to get complete defaults
-    // This is more reliable than manually extracting fields, especially for classes
-    if (typeof schemaObj?.make === "function") {
-      try {
-        const instance = schemaObj.make({})
-        // For ExtendedClass, the instance is already in the correct encoded format
-        // But we need to check for nullable fields that may have been set to undefined
-        // instead of null, and fix them
-        if (schemaObj?.fields && typeof schemaObj.fields === "object") {
-          for (const [key, fieldSchema] of Object.entries(schemaObj.fields)) {
-            // Only fix fields that are undefined in the instance
-            if (instance[key] === undefined) {
-              const ast = (fieldSchema as any)?.ast
-              const nullableOrUndefined = isNullableOrUndefined(ast)
-              if (nullableOrUndefined === "null") {
-                instance[key] = null
-              } else if (nullableOrUndefined === "undefined") {
-                instance[key] = undefined
-              }
-            }
-          }
-        }
-        return instance
-      } catch {
-        // If make() fails, fall through to manual extraction
-      }
-    }
-
-    // Check if this schema is a union - check both direct property and AST
-    const unionMembers = schemaObj?.members
-      || (schemaObj?.ast?._tag === "Union" && schemaObj.ast.types
-        ? schemaObj.ast.types.map((t: any) => S.make(t))
-        : null)
-    if (unionMembers && Array.isArray(unionMembers)) {
-      // For unions, we try to find the first member that has a complete set of defaults
-      // Priority is given to members with default values for discriminator fields
-      for (const member of unionMembers as any[]) {
-        const memberDefaults = extractDefaultsFromAST(member)
-        if (Object.keys(memberDefaults).length > 0) {
-          // Check if this member has a default value for a discriminator field (like _tag)
-          // If it does, use this member's defaults
-          const hasDiscriminatorDefault = member?.fields && Object.entries(member.fields).some(
-            ([key, fieldSchema]: [string, any]) => {
-              // Common discriminator field names
-              if (key === "_tag" || key === "type" || key === "kind") {
-                return fieldSchema?.ast?.defaultValue !== undefined
-              }
-              return false
-            }
-          )
-
-          if (hasDiscriminatorDefault) {
-            return memberDefaults
-          }
-        }
-      }
-      // If no member has a discriminator default, return empty
-      return {}
-    }
-
     // Check if this schema has fields (struct)
     if (schemaObj?.fields && typeof schemaObj.fields === "object") {
       for (const [key, fieldSchema] of Object.entries(schemaObj.fields)) {
@@ -859,6 +821,10 @@ export const useOmegaForm = <
           }
         }
       }
+    } else {
+      if (schemaObj?.from?.fields && typeof schemaObj?.from?.fields === "object") {
+        return extractDefaultsFromAST(schemaObj.from)
+      }
     }
 
     return result
@@ -869,30 +835,14 @@ export const useOmegaForm = <
     let result: Partial<From> = {}
 
     try {
-      // For filtered schemas (created with S.filter), use the original unfiltered schema's make method
-      let schemaToUse = schema as any
-      if (schemaToUse?.ast?._tag === "Refinement" && schemaToUse?.from) {
-        schemaToUse = schemaToUse.from
-      }
-
-      // First try to use schema.make() if available
-      // Note: Partial schemas don't have .make() method yet (https://github.com/Effect-TS/effect/issues/4222)
-      const decoded = schemaToUse.make(defaultValues)
-      result = S.encodeSync(partialRecursive(schemaToUse))(decoded)
-    } catch (error) {
-      // If make() fails, try to extract defaults from AST
+      const astDefaults = extractDefaultsFromAST(schema)
+      result = S.encodeSync(partialRecursive(schema))(astDefaults)
+    } catch (astError) {
       if (window.location.hostname === "localhost") {
-        console.warn("schema.make() failed, extracting defaults from AST:", error)
-      }
-      try {
-        const astDefaults = extractDefaultsFromAST(schema)
-        result = S.encodeSync(partialRecursive(schema))(astDefaults)
-      } catch (astError) {
-        if (window.location.hostname === "localhost") {
-          console.warn("Could not extract defaults from AST:", astError)
-        }
+        console.warn("Could not extract defaults from AST:", astError)
       }
     }
+
     return deepMerge(result, defaultValues)
   }