diff --git a/.changeset/dry-clocks-travel.md b/.changeset/dry-clocks-travel.md
new file mode 100644
index 0000000000..043cbd2080
--- /dev/null
+++ b/.changeset/dry-clocks-travel.md
@@ -0,0 +1,5 @@
+---
+"@effect-app/vue-components": minor
+---
+
+Accept root level unions as OmegaForm citizen
diff --git a/.changeset/tangy-lights-tickle.md b/.changeset/tangy-lights-tickle.md
new file mode 100644
index 0000000000..fe0bdad333
--- /dev/null
+++ b/.changeset/tangy-lights-tickle.md
@@ -0,0 +1,5 @@
+---
+"@effect-app/vue-components": patch
+---
+
+Adds support to nested constructors in OmegaForm defaultsValue with schema
diff --git a/packages/vue-components/src/components/OmegaForm/InputProps.ts b/packages/vue-components/src/components/OmegaForm/InputProps.ts
index fd8b214ee3..090c257ca0 100644
--- a/packages/vue-components/src/components/OmegaForm/InputProps.ts
+++ b/packages/vue-components/src/components/OmegaForm/InputProps.ts
@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { DeepKeys, DeepValue, FieldApi, FieldAsyncValidateOrFn, FieldValidateAsyncFn, FieldValidateFn, FieldValidateOrFn, FormAsyncValidateOrFn, FormValidateOrFn, StandardSchemaV1 } from "@tanstack/vue-form"
+import { type IsUnion } from "effect-app/utils"
 
 export type OmegaFieldInternalApi<From extends Record<PropertyKey, any>, TName extends DeepKeys<From>> = FieldApi<
   /* in out TParentData*/ From,
@@ -60,10 +61,13 @@ export type VuetifyInputProps<From extends Record<PropertyKey, any>, TName exten
 // Utility type to extract _tag literal values from a discriminated union
 // For a union like { _tag: "A", ... } | { _tag: "B", ... }, this returns "A" | "B"
 // For nullable unions like { _tag: "A" } | { _tag: "B" } | null, this still returns "A" | "B" (excluding null)
-export type ExtractTagValue<From extends Record<PropertyKey, any>, TName extends DeepKeys<From>> =
-  DeepValue<From, TName> extends infer U ? U extends { _tag: infer Tag } ? Tag
-    : never
+export type ExtractTagValue<
+  From extends Record<PropertyKey, any>,
+  TName extends DeepKeys<From> | undefined
+> = IsUnion<TName> extends true ? From extends { _tag: infer Tag } ? Tag : never
+  : DeepValue<From, TName> extends infer U ? U extends { _tag: infer Tag } ? Tag
     : never
+  : never
 
 // Utility type to extract a specific branch from a discriminated union based on _tag value
 // For union { _tag: "A", foo: string } | { _tag: "B", bar: number } and Tag="A", returns { _tag: "A", foo: string }
@@ -72,16 +76,21 @@ export type ExtractUnionBranch<T, Tag> = T extends { _tag: Tag } ? T
 
 // Option type for TaggedUnion component with strongly-typed value
 // The value can be either one of the _tag values OR null (for the placeholder)
-export type TaggedUnionOption<From extends Record<PropertyKey, any>, TName extends DeepKeys<From>> = {
+export type TaggedUnionOption<From extends Record<PropertyKey, any>, TName extends DeepKeys<From> | undefined> = {
   readonly title: string
   readonly value: ExtractTagValue<From, TName> | null
 }
 
 // Options array must ALWAYS start with a null option (placeholder), followed by the actual options
-export type TaggedUnionOptionsArray<From extends Record<PropertyKey, any>, TName extends DeepKeys<From>> = readonly [
-  { readonly title: string; readonly value: null },
-  ...ReadonlyArray<{ readonly title: string; readonly value: ExtractTagValue<From, TName> }>
-]
+export type TaggedUnionOptionsArray<
+  From extends Record<PropertyKey, any>,
+  TName extends DeepKeys<From> | undefined
+> =
+  | readonly [
+    { readonly title: string; readonly value: null },
+    ...ReadonlyArray<{ readonly title: string; readonly value: ExtractTagValue<From, TName> }>
+  ]
+  | ReadonlyArray<{ readonly title: string; readonly value: ExtractTagValue<From, TName> }>
 
 // Props for TaggedUnion component
 export type TaggedUnionProps<From extends Record<PropertyKey, any>, TName extends DeepKeys<From>> = {
diff --git a/packages/vue-components/src/components/OmegaForm/OmegaFormStuff.ts b/packages/vue-components/src/components/OmegaForm/OmegaFormStuff.ts
index c1d01465c7..b1c5dc98b8 100644
--- a/packages/vue-components/src/components/OmegaForm/OmegaFormStuff.ts
+++ b/packages/vue-components/src/components/OmegaForm/OmegaFormStuff.ts
@@ -695,6 +695,58 @@ const flattenMeta = <From, To>(
     return flattenMeta(S.make(ast.from))
   }
 
+  // Handle root-level Union types (discriminated unions)
+  if (ast._tag === "Union") {
+    const unionAst = ast as any
+    const types = unionAst.types || []
+
+    // Filter out null/undefined types and unwrap transformations
+    const nonNullTypes = types
+      .filter((t: any) => t._tag !== "UndefinedKeyword" && t !== S.Null.ast)
+      .map(getTransformationFrom)
+
+    // Check if this is a discriminated union (all members are structs)
+    const allStructs = nonNullTypes.every((t: any) => t._tag === "TypeLiteral" && "propertySignatures" in t)
+
+    if (allStructs && nonNullTypes.length > 0) {
+      // Extract discriminator values from each union member
+      const discriminatorValues: any[] = []
+
+      // Merge metadata from all union members
+      for (const memberType of nonNullTypes) {
+        if ("propertySignatures" in memberType) {
+          // Find the discriminator field (usually _tag)
+          const tagProp = memberType.propertySignatures.find(
+            (p: any) => p.name.toString() === "_tag"
+          )
+
+          if (tagProp && S.AST.isLiteral(tagProp.type)) {
+            discriminatorValues.push(tagProp.type.literal)
+          }
+
+          // Create metadata for this member's properties
+          const memberMeta = createMeta<To>({
+            propertySignatures: memberType.propertySignatures
+          })
+
+          // Merge into result
+          Object.assign(result, memberMeta)
+        }
+      }
+
+      // Create metadata for the discriminator field
+      if (discriminatorValues.length > 0) {
+        result["_tag" as DeepKeys<To>] = {
+          type: "select",
+          members: discriminatorValues,
+          required: true
+        } as FieldMeta
+      }
+
+      return result
+    }
+  }
+
   if ("propertySignatures" in ast) {
     const meta = createMeta<To>({
       propertySignatures: ast.propertySignatures
diff --git a/packages/vue-components/src/components/OmegaForm/OmegaTaggedUnion.vue b/packages/vue-components/src/components/OmegaForm/OmegaTaggedUnion.vue
index ad9aab7450..489f8e1e19 100644
--- a/packages/vue-components/src/components/OmegaForm/OmegaTaggedUnion.vue
+++ b/packages/vue-components/src/components/OmegaForm/OmegaTaggedUnion.vue
@@ -4,59 +4,40 @@
   generic="
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>,
-  Name extends DeepKeys<From>
+  Name extends DeepKeys<From> | undefined = DeepKeys<From>
 "
 >
-import { type DeepKeys, type DeepValue } from "@tanstack/vue-form"
-import { onMounted } from "vue"
-import { type TaggedUnionOption, type TaggedUnionOptionsArray } from "./InputProps"
+import { type DeepKeys } from "@tanstack/vue-form"
+import { type TaggedUnionOption } from "./InputProps"
 import { type FieldPath } from "./OmegaFormStuff"
 import OmegaTaggedUnionInternal from "./OmegaTaggedUnionInternal.vue"
 import { type useOmegaForm } from "./useOmegaForm"
 
-const props = defineProps<{
-  name: Name
+defineProps<{
+  name?: Name
   form: ReturnType<typeof useOmegaForm<From, To>>
   type?: "select" | "radio"
-  options: TaggedUnionOptionsArray<From, Name>
+  options: TaggedUnionOption<From, Name>[]
   label?: string
 }>()
-
-// Initialize the union field on mount
-onMounted(() => {
-  const currentValue = props.form.getFieldValue(props.name)
-  const meta = props.form.meta[props.name as keyof typeof props.form.meta]
-
-  if (currentValue === undefined) {
-    if (meta?.nullableOrUndefined === "null" || !meta?.required) {
-      // Initialize to null for nullable/optional unions
-      props.form.setFieldValue(props.name, null as DeepValue<From, Name>)
-    } else {
-      // For required unions, initialize with first non-null option
-      const firstOption = props.options.find((opt) => opt.value !== null)
-      if (firstOption && firstOption.value) {
-        props.form.setFieldValue(props.name, {
-          _tag: firstOption.value
-        } as DeepValue<From, Name>)
-      }
-    }
-  }
-})
 </script>
 
 <template>
-  <form.Input
-    :name="`${name}._tag` as FieldPath<From>"
-    :label="label"
-    :type="type ?? 'select'"
-    :options="options as unknown as TaggedUnionOption<From, Name>[]"
-  />
-  <form.Field :name="name">
+  <slot name="OmegaCustomInput">
+    <form.Input
+      :name="(name ? `${name}._tag` : '_tag') as FieldPath<From>"
+      :label="label"
+      :type="type ?? 'select'"
+      :options="options"
+    />
+  </slot>
+  <form.Field :name="(name ?? '') as any">
     <template #default="{ field, state }">
       <slot v-if="state.value" />
       <OmegaTaggedUnionInternal
         :field="field as any"
         :state="state.value"
+        :name="name"
       >
         <template
           v-for="(_, slotname) in $slots"
diff --git a/packages/vue-components/src/components/OmegaForm/OmegaTaggedUnionInternal.vue b/packages/vue-components/src/components/OmegaForm/OmegaTaggedUnionInternal.vue
index 823e615b51..73ba19ed9d 100644
--- a/packages/vue-components/src/components/OmegaForm/OmegaTaggedUnionInternal.vue
+++ b/packages/vue-components/src/components/OmegaForm/OmegaTaggedUnionInternal.vue
@@ -1,7 +1,7 @@
 <template>
   <slot
     v-if="state?._tag"
-    :name="state?._tag"
+    :name="`${name ? `${name}.` : ''}${state?._tag}`"
     v-bind="{ field, state }"
   />
 </template>
@@ -22,6 +22,7 @@ import { type OmegaFieldInternalApi } from "./InputProps"
 const props = defineProps<{
   state: DeepValue<From, Name>
   field: OmegaFieldInternalApi<From, Name>
+  name?: DeepKeys<From>
 }>()
 
 // Watch for _tag changes
diff --git a/packages/vue-components/src/components/OmegaForm/useOmegaForm.ts b/packages/vue-components/src/components/OmegaForm/useOmegaForm.ts
index 19a0e7f20f..b2b18bccf4 100644
--- a/packages/vue-components/src/components/OmegaForm/useOmegaForm.ts
+++ b/packages/vue-components/src/components/OmegaForm/useOmegaForm.ts
@@ -16,6 +16,86 @@ import OmegaInput from "./OmegaInput.vue"
 import OmegaTaggedUnion from "./OmegaTaggedUnion.vue"
 import OmegaForm from "./OmegaWrapper.vue"
 
+/**
+ * Recursively makes all properties in a schema optional, including nested objects.
+ * Unlike S.partial which only makes top-level properties optional, this utility
+ * traverses the schema tree and applies partial transformation at every level.
+ *
+ * Handles:
+ * - TypeLiteral (structs): Makes all properties optional and recursively processes nested types
+ * - Union types: Recursively applies partial to each union member
+ * - Transformation types: Applies partial to both 'from' and 'to' sides
+ */
+const partialRecursive = <A, I, R>(schema: S.Schema<A, I, R>): S.Schema<Partial<A>, Partial<I>, R> => {
+  const ast = schema.ast
+
+  // Handle Union types - recursively apply partial to each member
+  if (ast._tag === "Union") {
+    const partialMembers = (ast as any).types.map((memberAst: any) => {
+      const memberSchema = S.make(memberAst)
+      const partialMember = partialRecursive(memberSchema as any)
+      return partialMember.ast
+    })
+
+    const newAst = {
+      ...ast,
+      types: partialMembers
+    }
+
+    return S.make(newAst as any)
+  }
+
+  // Handle Transformation types (e.g., withDefaultConstructor)
+  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 partialFrom = partialRecursive(fromSchema as any)
+    const partialTo = partialRecursive(toSchema as any)
+
+    const newAst = {
+      ...ast,
+      from: partialFrom.ast,
+      to: partialTo.ast
+    }
+
+    return S.make(newAst as any)
+  }
+
+  // If this is a TypeLiteral (struct), recursively apply partial to nested fields
+  if (ast._tag === "TypeLiteral") {
+    const fields = ast.propertySignatures.map((prop: any) => {
+      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") {
+        const nestedSchema = S.make(propType)
+        const recursivePartial = partialRecursive(nestedSchema as any)
+        newType = recursivePartial.ast
+      }
+
+      // Create a new property signature with isOptional: true
+      return {
+        ...prop,
+        type: newType,
+        isOptional: true
+      }
+    })
+
+    const newAst = {
+      ...ast,
+      propertySignatures: fields
+    }
+
+    return S.make(newAst as any)
+  }
+
+  // For other schema types (primitives, refinements, etc.), return as-is
+  // These types don't need to be made partial, and S.partial doesn't support them anyway
+  return schema as any
+}
+
 type keysRule<T> =
   | {
     keys?: NestedKeyOf<T>[]
@@ -433,9 +513,10 @@ export interface OmegaFormReturn<
             never
           >
           & {
-            name: Name
+            name?: Name
             type?: "select" | "radio"
             options: import("./InputProps").TaggedUnionOptionsArray<From, Name>
+            _debugName?: [NoInfer<Name>]
             label?: string
           }
           & {}
@@ -710,6 +791,34 @@ export const useOmegaForm = <
   const extractDefaultsFromAST = (schemaObj: any): any => {
     const result: Record<string, any> = {}
 
+    // Check if this schema is a union
+    if (schemaObj?.members && Array.isArray(schemaObj.members)) {
+      // 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 schemaObj.members) {
+        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)) {
@@ -725,7 +834,7 @@ export const useOmegaForm = <
           }
         }
 
-        // Recursively check nested fields for structs
+        // Recursively check nested fields for structs and unions
         const nestedDefaults = extractDefaultsFromAST(fieldSchema as any)
         if (Object.keys(nestedDefaults).length > 0) {
           // If we already have a default value for this key, merge with nested
@@ -744,13 +853,14 @@ export const useOmegaForm = <
 
   // Extract default values from schema constructors (e.g., withDefaultConstructor)
   const extractSchemaDefaults = (defaultValues: Partial<From> = {}) => {
+    let result: Partial<From> = {}
+
     try {
+      // First try to use schema.make() if available
       // 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)
-      if ("make" in schema && typeof (schema as any).make === "function") {
-        const decoded = (schema as any).make(defaultValues)
-        return S.encodeSync(schema.pipe(S.partial))(decoded)
-      }
+      const decoded = (schema as any).make(defaultValues)
+      result = S.encodeSync(partialRecursive(schema))(decoded)
     } catch (error) {
       // If make() fails, try to extract defaults from AST
       if (window.location.hostname === "localhost") {
@@ -758,20 +868,23 @@ export const useOmegaForm = <
       }
       try {
         const astDefaults = extractDefaultsFromAST(schema)
-
-        return S.encodeSync(schema.pipe(S.partial))(astDefaults)
+        result = S.encodeSync(partialRecursive(schema))(astDefaults)
       } catch (astError) {
         if (window.location.hostname === "localhost") {
           console.warn("Could not extract defaults from AST:", astError)
         }
-        return {}
       }
     }
+    return deepMerge(result, defaultValues)
   }
 
   const defaultValues = computed(() => {
     // Normalize tanstack default values at the beginning
-    const normalizedTanstackDefaults = extractSchemaDefaults(normalizeDefaultValues(tanstackFormOptions?.defaultValues))
+    const normalizedTanstackDefaults = extractSchemaDefaults(
+      normalizeDefaultValues(
+        tanstackFormOptions?.defaultValues
+      )
+    )
 
     if (
       normalizedTanstackDefaults
diff --git a/packages/vue-components/stories/OmegaForm.stories.ts b/packages/vue-components/stories/OmegaForm.stories.ts
index a719068581..e6592e481a 100644
--- a/packages/vue-components/stories/OmegaForm.stories.ts
+++ b/packages/vue-components/stories/OmegaForm.stories.ts
@@ -21,6 +21,7 @@ import MetaFormComponent from "./OmegaForm/Meta.vue"
 import NullComponent from "./OmegaForm/Null.vue"
 import PersistencyFormComponent from "./OmegaForm/PersistencyForm.vue"
 import ProgrammaticallyHandleSubmitCheckErrorsComponent from "./OmegaForm/ProgrammaticallyHandleSubmitCheckErrors.vue"
+import RootLevelTaggedUnionComponent from "./OmegaForm/RootLevelTaggedUnion.vue"
 import SetErrorOnSubmitComponent from "./OmegaForm/SetErrorOnSubmit.vue"
 import SimpleFormComponent from "./OmegaForm/SimpleForm.vue"
 import SimpleFormVuetifyDefaultComponent from "./OmegaForm/SimpleFormVuetifyDefault.vue"
@@ -87,6 +88,13 @@ export const FormTaggedUnion: Story = {
   })
 }
 
+export const RootLevelTaggedUnion: Story = {
+  render: () => ({
+    components: { RootLevelTaggedUnionComponent },
+    template: "<RootLevelTaggedUnionComponent />"
+  })
+}
+
 export const IntersectionExample: Story = {
   render: () => ({
     components: { IntersectionExampleComponent },
diff --git a/packages/vue-components/stories/OmegaForm/FormTaggedUnion.vue b/packages/vue-components/stories/OmegaForm/FormTaggedUnion.vue
index 0d09299d77..b3b110aa95 100644
--- a/packages/vue-components/stories/OmegaForm/FormTaggedUnion.vue
+++ b/packages/vue-components/stories/OmegaForm/FormTaggedUnion.vue
@@ -39,7 +39,6 @@
           name="union"
           label="Union!"
           :options="[
-            { value: null, title: 'Select one' },
             { value: 'A', title: 'Option 1' },
             { value: 'B', title: 'Option 2' }
           ]"
@@ -50,14 +49,14 @@
             label="Common Field"
           />
           <!-- Named slot #A: rendered only when _tag === "A" -->
-          <template #A>
+          <template #union.A>
             <form.Input
               name="union.a"
               label="A Field"
             />
           </template>
           <!-- Named slot #B: rendered only when _tag === "B" -->
-          <template #B>
+          <template #union.B>
             <form.Input
               name="union.b"
               label="B Field"
diff --git a/packages/vue-components/stories/OmegaForm/RootLevelTaggedUnion.vue b/packages/vue-components/stories/OmegaForm/RootLevelTaggedUnion.vue
new file mode 100644
index 0000000000..f823248117
--- /dev/null
+++ b/packages/vue-components/stories/OmegaForm/RootLevelTaggedUnion.vue
@@ -0,0 +1,115 @@
+<template>
+  <div>
+    <div style="background: #f5f5f5; padding: 20px; margin-bottom: 20px; border-radius: 4px; border-left: 4px solid #1976d2">
+      <h1 style="margin-top: 0">
+        Root-Level TaggedUnion Component Usage
+      </h1>
+
+      <h2>Overview</h2>
+      <p>
+        This example demonstrates using a tagged union at the ROOT level of your form schema. The entire form is a
+        discriminated union, not nested within a struct.
+      </p>
+
+      <h2>Key Differences from Nested Usage</h2>
+      <ul>
+        <li>
+          <strong>No <code>name</code> prop:</strong> Since the union is at the root, omit the <code>name</code> prop
+        </li>
+        <li>
+          <strong>Field paths:</strong> Use direct paths like <code>"a"</code>, <code>"common"</code> instead of
+          <code>"union.a"</code>
+        </li>
+        <li>
+          <strong>Schema:</strong> Pass <code>S.Union(...)</code> directly to <code>useOmegaForm</code>, not wrapped in
+          <code>S.Struct</code>
+        </li>
+      </ul>
+    </div>
+
+    <form.Form :subscribe="['values', 'canSubmit']">
+      <template #default="{ subscribedValues: { values } }">
+        <form.TaggedUnion
+          label="Select Type"
+          :options="[
+            { value: 'A', title: 'Option A' },
+            { value: 'B', title: 'Option B' }
+          ] as const"
+        >
+          <!-- Default slot: rendered for ALL branches (common fields) -->
+          <form.Input
+            name="common"
+            label="Common Field (shared by both A and B)"
+          />
+          <!-- Named slot #A: rendered only when _tag === "A" -->
+          <template #A>
+            <form.Input
+              name="a"
+              label="Field A (string)"
+            />
+          </template>
+          <!-- Named slot #B: rendered only when _tag === "B" -->
+          <template #B>
+            <form.Input
+              name="b"
+              label="Field B (number)"
+              type="number"
+            />
+          </template>
+        </form.TaggedUnion>
+        <pre>{{ values }}</pre>
+        <form.Errors />
+        <v-btn type="submit">
+          Submit
+        </v-btn>
+      </template>
+    </form.Form>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { S } from "effect-app"
+import { useOmegaForm } from "../../src"
+
+// Root-level union schema - the entire form is a union
+const schema = S.Union(
+  S.Struct({
+    a: S.NonEmptyString255,
+    common: S.String,
+    _tag: S.Literal("A")
+  }),
+  S.Struct({
+    b: S.Number,
+    common: S.String,
+    _tag: S.Literal("B")
+  })
+)
+
+const form = useOmegaForm(
+  schema,
+  {
+    onSubmit: async ({ value }) => {
+      console.log("Form submitted:", value)
+    },
+    defaultValues: {
+      _tag: "A"
+    }
+  }
+)
+</script>
+
+<style scoped>
+h1 {
+  margin-bottom: 1rem;
+}
+ul, ol, p {
+  margin-left: 1rem;
+  margin-bottom: 1rem;
+}
+code {
+  background: #e0e0e0;
+  padding: 2px 6px;
+  border-radius: 3px;
+  font-family: monospace;
+}
+</style>