diff --git a/Sources/Blueprint/Blueprint.xcodeproj/project.pbxproj b/Sources/Blueprint/Blueprint.xcodeproj/project.pbxproj
index 45887ab8..a3db724f 100644
--- a/Sources/Blueprint/Blueprint.xcodeproj/project.pbxproj
+++ b/Sources/Blueprint/Blueprint.xcodeproj/project.pbxproj
@@ -549,7 +549,7 @@
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 20260618005;
+				CURRENT_PROJECT_VERSION = 20260629001;
 				DEVELOPMENT_TEAM = YEX9K6G97T;
 				ENABLE_PREVIEWS = YES;
 				ENABLE_USER_SCRIPT_SANDBOXING = YES;
@@ -579,7 +579,7 @@
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 20260618005;
+				CURRENT_PROJECT_VERSION = 20260629001;
 				DEVELOPMENT_TEAM = YEX9K6G97T;
 				ENABLE_PREVIEWS = YES;
 				ENABLE_USER_SCRIPT_SANDBOXING = YES;
diff --git a/Sources/Blueprint/Sources/Scene/Previews/TextAreaPreview.swift b/Sources/Blueprint/Sources/Scene/Previews/TextAreaPreview.swift
index 4a317f28..7a1645e5 100644
--- a/Sources/Blueprint/Sources/Scene/Previews/TextAreaPreview.swift
+++ b/Sources/Blueprint/Sources/Scene/Previews/TextAreaPreview.swift
@@ -11,28 +11,43 @@ import SwiftUI
 import Montage
 
 struct TextAreaPreview: View {
+    enum Size: String, CaseIterable {
+        case large
+        case medium
+
+        var description: String {
+            self.rawValue.capitalized
+        }
+
+        var s: TextArea.Size {
+            switch self {
+            case .large: .large
+            case .medium: .medium
+            }
+        }
+    }
+
     enum Resize: String, CaseIterable {
         case normal
         case limit
         case fixed
-        
+
         var description: String {
             self.rawValue.capitalized
         }
-        
+
         var r: TextArea.Resize {
             switch self {
             case .normal: .normal
             case .limit: .limit
-            case .fixed: .fixed(min: 100, max: 200)
+            case .fixed: .fixed(min: 116, max: 200)
             }
         }
     }
-    
+
     var resources: [TextArea.Resource?] {
         [
-            .characterCount(limit: Int(limit), overflow: overflow),
-            .textButton(
+            .button(
                 title: "Text",
                 handler: {}
             ),
@@ -40,39 +55,46 @@ struct TextAreaPreview: View {
                 icon: .send,
                 handler: {}
             ),
+            .primaryIconButton(
+                icon: .send,
+                handler: {}
+            ),
             .icon(
                 .chevronDown
             ),
-            .chip(
-                title: "Action",
-                handler: {}
+            .contentBadge(
+                title: "Badge"
             ),
-            .filterButton(
-                title: "Filter",
-                handler: {}
-            )
+            .segmentedControl(
+                selectedIndex: $segmentIndex,
+                icons: [.send, .chevronDown],
+                accessibilityLabels: ["전송", "더 보기"]
+            ),
+            .slot {
+                Image(systemName: "star.fill")
+                    .foregroundColor(.semantic(.primaryNormal))
+            }
         ]
     }
-    
+
     @State private var showTransparentChecker: Bool = false
     @State private var text: String = ""
+    @State private var size: Size = .large
     @State private var resize: Resize = .normal
     @State private var negative: Bool = false
     @State private var focus: Bool = false
     @FocusState private var focusState: Bool
     @State private var disable: Bool = false
-    @State private var heading: Bool = false
-    @State private var requiredBadge: Bool = false
-    @State private var description: Bool = false
     @State private var placeholder: Bool = true
     @State private var leadingResources = [TextArea.Resource]()
     @State private var trailingResources = [TextArea.Resource]()
-    @State private var limit: CGFloat = 10
-    @State private var overflow: Bool = false
-    
+    @State private var maxLength: CGFloat = 0
+    @State private var characterCount: Int = 0
+    @State private var segmentIndex: Int = 0
+
     var body: some View {
         SwiftUI.ScrollView {
-            VStack(spacing: 12) {
+            VStack(alignment: .leading) {
                 HStack {
                     Text("Preview").bold()
                     Spacer()
@@ -83,166 +105,109 @@ struct TextAreaPreview: View {
                             .foregroundColor(.semantic(.primaryNormal))
                     }
                 }
-                TextArea(text: $text, focus: $focusState)
-                    .resize(resize.r)
-                    .negative(negative)
-                    .disable(disable)
-                    .heading(heading ? "제목" : nil)
-                    .requiredBadge(requiredBadge)
-                    .bottomResources(
-                        leading: leadingResources,
-                        trailing: trailingResources
+                Group {
+                    TextArea(text: $text, focus: $focusState)
+                        .size(size.s)
+                        .resize(resize.r)
+                        .negative(negative)
+                        .disable(disable)
+                        .bottomResources(
+                            leading: leadingResources,
+                            trailing: trailingResources
+                        )
+                        .maxLength(maxLength > 0 ? Int(maxLength) : nil)
+                        .onTextChange { characterCount = $0.count }
+                        .placeholder(placeholder ? "텍스트를 입력해주세요" : nil)
+                        // resize 변경 시 뷰 아이덴티티를 리셋해 높이를 재계산한다.
+                        // text를 건드리면 placeholder 조건(text.isEmpty)이 깨지므로 .id로 처리한다.
+                        .id(resize)
+                }
+                Text("Options").bold()
+                HStack {
+                    Text("size")
+                    SegmentedControl(
+                        selectedIndex: Binding(
+                            get: { Size.allCases.firstIndex(of: size) ?? 0 },
+                            set: { size = Size.allCases[$0] }
+                        ),
+                        labels: Size.allCases.map(\.description)
                     )
-                    .description(description ? "메세지에 마침표를 찍어요." : nil)
-                    .placeholder(placeholder ? "텍스트를 입력해주세요" : nil)
-                
-                VStack(alignment: .leading, spacing: 12) {
-                    Text("Options").bold()
-                    HStack {
-                        HStack {
-                            Text("Resize :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Menu(resize.description) {
-                                ForEach(Resize.allCases, id: \.self) { r in
-                                    Button {
-                                        resize = r
-                                    } label: {
-                                        Text(r.description)
+                    .size(.small)
+                }
+                HStack {
+                    Text("resize")
+                    SegmentedControl(
+                        selectedIndex: Binding(
+                            get: { Resize.allCases.firstIndex(of: resize) ?? 0 },
+                            set: { resize = Resize.allCases[$0] }
+                        ),
+                        labels: Resize.allCases.map(\.description)
+                    )
+                    .size(.small)
+                }
+                HStack {
+                    Text("placeholder")
+                    Switch(checked: placeholder) { placeholder = $0 }
+                    Text("focus")
+                    Switch(checked: focus) { focusState = $0 }
+                }
+                HStack {
+                    Text("disable")
+                    Switch(checked: disable) { disable = $0 }
+                    Text("negative")
+                    Switch(checked: negative) { negative = $0 }
+                }
+                HStack {
+                    Text("leading")
+                    Menu("add") {
+                        ForEach(resources.indices, id: \.self) { index in
+                            if resources[index]?.isLeadingAllowed ?? false {
+                                Button {
+                                    if let resource = resources[index] {
+                                        leadingResources.append(resource)
+                                        leadingResources = leadingResources.suffix(3)
                                     }
+                                } label: {
+                                    Text(resources[index]?.description ?? "none")
                                 }
                             }
                         }
-                        HStack {
-                            Text("Placeholder :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Switch(checked: placeholder) { placeholder = $0 }
-                        }
-                    }
-                    HStack {
-                        HStack {
-                            Text("Focus :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Switch(checked: focus) {
-                                focusState = $0
-                            }
-                        }
-                        HStack {
-                            Text("Disable :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Switch(checked: disable) { disable = $0 }
-                        }
                     }
-                    HStack {
-                        HStack {
-                            Text("Heading :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Switch(checked: heading) { heading = $0 }
-                        }
-                        HStack {
-                            Text("RequiredBadge :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Switch(checked: requiredBadge) { requiredBadge = $0 }
-                        }
-                    }
-                    HStack {
-                        HStack {
-                            Text("Description :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Switch(checked: description) { description = $0 }
-                        }
-                        Text("Negative :")
-                            .typography(variant: .headline2, weight: .medium)
-                        Spacer()
-                        Switch(checked: negative) { negative = $0 }
-                    }
-                    HStack {
-                        HStack {
-                            Text("Leading :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Menu("add") {
-                                ForEach(resources.indices, id: \.self) { index in
-                                    Button {
-                                        if let resource = resources[index] {
-                                            leadingResources.append(resource)
-                                        }
-                                    } label: {
-                                        Text(resources[index]?.description ?? "none")
-                                    }
-                                }
-                            }
-                            Button("reset") {
-                                leadingResources.removeAll()
-                            }
-                        }
-                        HStack {
-                            Text("Trailing :")
-                                .typography(variant: .headline2, weight: .medium)
-                            Spacer()
-                            Menu("add") {
-                                ForEach(resources.indices, id: \.self) { index in
-                                    Button {
-                                        if let resource = resources[index] {
-                                            trailingResources.append(resource)
-                                        }
-                                    } label: {
-                                        Text(resources[index]?.description ?? "none")
-                                    }
+                    Button("reset") { leadingResources.removeAll() }
+                    Spacer()
+                    Text("trailing")
+                    Menu("add") {
+                        ForEach(resources.indices, id: \.self) { index in
+                            Button {
+                                if let resource = resources[index] {
+                                    trailingResources.append(resource)
+                                    trailingResources = trailingResources.suffix(3)
                                 }
+                            } label: {
+                                Text(resources[index]?.description ?? "none")
                             }
-                            Button("reset") {
-                                trailingResources.removeAll()
-                            }
-                        }
-                    }
-                    .font(.font(variant: .label1))
-                    if leadingResources.contains(where: { $0.isCharacterCount }) ||
-                        trailingResources.contains(where: { $0.isCharacterCount })
-                    {
-                        HStack {
-                            Text("characterCount")
-                                .layoutPriority(1)
-                            Text("limit")
-                            SwiftUI.Slider(value: $limit, in: 10...1000, step: 10)
-                            Text("overflow")
-                            Switch(checked: overflow) { overflow = $0 }
                         }
                     }
+                    Button("reset") { trailingResources.removeAll() }
                 }
+                HStack {
+                    Text("maxLength")
+                        .layoutPriority(1)
+                    SwiftUI.Slider(value: $maxLength, in: 0...1000, step: 10)
+                    Text(maxLength > 0 ? "\(characterCount)/\(Int(maxLength))" : "off")
+                }
+                Spacer(minLength: 0)
             }
+            .font(.caption)
             .padding()
         }
         .onChange(of: focusState) {
             focus = $0
         }
-        .onChange(of: resize) { _ in
-            // resize 값이 바뀔 때 프리뷰에서 높이가 제대로 갱신되지 않아서 꼼수로 처리
-            text = " "
-            Task {
-                text = ""
-            }
-        }
         .transparentChecking(isPresented: showTransparentChecker, checkerSize: 51, checkerColor: .red)
     }
 }
 
-extension TextArea.Resource {
-    var isCharacterCount: Bool {
-        if case .characterCount = self {
-            return true
-        } else {
-            return false
-        }
-    }
-}
-
 extension TextArea.Resource: CaseDescribable {}
 
 #Preview {
diff --git a/Sources/Blueprint/Sources/Scene/Previews/TextFieldPreview.swift b/Sources/Blueprint/Sources/Scene/Previews/TextFieldPreview.swift
index d570e0ec..860417b5 100644
--- a/Sources/Blueprint/Sources/Scene/Previews/TextFieldPreview.swift
+++ b/Sources/Blueprint/Sources/Scene/Previews/TextFieldPreview.swift
@@ -26,11 +26,11 @@ struct TextFieldPreview: View {
             self.rawValue.capitalized
         }
         
-        func v(description: Bool) -> Montage.TextField.Status {
+        var v: Montage.TextField.Status {
             switch self {
-            case .normal: .normal(description: description ? "설명 메세지를 나타내요." : "")
-            case .positive: .positive(description: description ? "성공 메세지를 나타내요." : "")
-            case .negative: .negative(description: description ? "에러 메세지를 나타내요." : "")
+            case .normal: .normal
+            case .positive: .positive
+            case .negative: .negative
             }
         }
     }
@@ -109,10 +109,7 @@ struct TextFieldPreview: View {
     @State private var fieldSize: FieldSize = .large
     @State private var variant: Variant = .normal
     @State private var disable: Bool = false
-    @State private var heading: Bool = false
-    @State private var requiredBadge: Bool = false
     @State private var icon: Bool = false
-    @State private var description: Bool = false
     @State private var placeholder: Bool = true
     @State private var trailingButton: Bool = false
     @State private var trailingContent: Content = .none
@@ -124,11 +121,11 @@ struct TextFieldPreview: View {
         "aaa2", "bbb2", "ccc2", "ddd2", "eee2", "fff2", "ggg2", "iii", "jjj"
     ]
 
-    /// 제목과 SegmentedControl을 묶은 옵션 행을 구성한다.
+    /// 제목과 SegmentedControl을 인라인으로 묶은 옵션 행을 구성한다.
     @ViewBuilder
     private func optionRow<Option: PreviewSegment>(_ title: String, _ selection: Binding<Option>) -> some View {
         let all = Array(Option.allCases)
-        VStack(alignment: .leading, spacing: 6) {
+        HStack {
             Text(title)
             SegmentedControl(
                 selectedIndex: Binding(
@@ -141,18 +138,77 @@ struct TextFieldPreview: View {
         }
     }
 
-    /// 제목과 Switch를 묶은 토글 행을 구성한다.
+    /// 제목과 Switch를 묶은 토글 쌍을 구성한다. (HStack에 여러 개를 인라인 배치)
+    @ViewBuilder
     private func toggleRow(_ title: String, _ isOn: Binding<Bool>) -> some View {
-        HStack {
-            Text(title)
-            Switch(checked: isOn.wrappedValue) { isOn.wrappedValue = $0 }
-            Spacer()
+        Text(title)
+        Switch(checked: isOn.wrappedValue) { isOn.wrappedValue = $0 }
+            .accessibilityLabel(title)
+    }
+
+    /// 현재 `text`와 `usingSuggestions` 상태를 기준으로 자동완성 데이터를 갱신한다.
+    /// 텍스트 변경과 autoComplete 토글 양쪽에서 동일한 규칙으로 호출된다.
+    private func refreshAutoCompletion() {
+        guard usingSuggestions else {
+            autoCompletionDataSource = nil
+            return
+        }
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            autoCompletionDataSource = nil
+            return
         }
+        let suggestions = candidates
+            .filter { $0.lowercased().contains(trimmed.lowercased()) }
+        autoCompletionDataSource = .init(
+            numberOfSections: 2,
+            sectionTitleAt: { section in
+                "\(section+1)번째 섹션"
+            },
+            numberOfItemsInSection: { _ in
+                suggestions.count
+            },
+            cellForItemAt: { indexPath in
+                ListCell(title: suggestions[indexPath.row]) {
+                    self.text = suggestions[indexPath.row]
+                    Task {
+                        autoCompletionDataSource = nil
+                    }
+                }
+                .highlight(trimmed)
+                .leadingContent {
+                    Group {
+                        if indexPath.section == 0 {
+                            Image.icon(.search)
+                                .foregroundStyle(SwiftUI.Color.semantic(.labelAlternative))
+                        } else {
+                            Avatar("", variant: .company, size: .medium)
+                        }
+                    }
+                }
+                .if(indexPath.section == 1) {
+                    $0.caption("캡션")
+                }
+            },
+            headerView: {
+                ListCell(title: "'\(trimmed)' 사용하기") {
+                    autoCompletionDataSource = nil
+                }
+                .highlight(trimmed)
+            },
+            footerView: {
+                ListCell(title: "'\(trimmed)' 사용하기") {
+                    autoCompletionDataSource = nil
+                }
+                .highlight(trimmed)
+            },
+            maxHeight: 200
+        )
     }
 
     var body: some View {
         SwiftUI.ScrollView {
-            VStack {
+            VStack(alignment: .leading) {
                 HStack {
                     Text("Preview").bold()
                     Spacer()
@@ -163,126 +219,60 @@ struct TextFieldPreview: View {
                             .foregroundColor(.semantic(.primaryNormal))
                     }
                 }
-                TextField(
-                    text: $text,
-                    autoCompletionDataSource: $autoCompletionDataSource
-                )
-                .size(fieldSize.s)
-                .status(variant.v(description: description))
-                .disable(disable)
-                .heading(heading ? "제목" : nil)
-                .requiredBadge(requiredBadge)
-                .placeholder(placeholder ? "텍스트를 입력해 주세요." : nil)
-                .icon(icon ? .verifiedCheckFill : nil)
-                .trailingButton(
-                    trailingButton ? TextField.TrailingButtonInfo(
-                        title: "텍스트",
-                        handler: { print("trailing button tapped") }
-                    ) : nil
-                )
-                .trailingContent {
-                    if let content = trailingContent.c {
-                        AnyView(content())
-                    } else {
-                        EmptyView()
+                Group {
+                    TextField(
+                        text: $text,
+                        autoCompletionDataSource: $autoCompletionDataSource
+                    )
+                    .size(fieldSize.s)
+                    .status(variant.v)
+                    .disable(disable)
+                    .placeholder(placeholder ? "텍스트를 입력해 주세요." : nil)
+                    .icon(icon ? .verifiedCheckFill : nil)
+                    .trailingButton(
+                        trailingButton ? TextField.TrailingButtonInfo(
+                            title: "텍스트",
+                            handler: { print("trailing button tapped") }
+                        ) : nil
+                    )
+                    .trailingContent {
+                        if let content = trailingContent.c {
+                            AnyView(content())
+                        } else {
+                            EmptyView()
+                        }
                     }
-                }
-                .onChange(of: text) { text in
-                    guard usingSuggestions else {
-                        autoCompletionDataSource = nil
-                        return
+                    .onChange(of: text) { _ in
+                        refreshAutoCompletion()
                     }
-                    let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
-                    guard !trimmed.isEmpty else {
-                        autoCompletionDataSource = nil
-                        return
+                    // 텍스트 변경뿐 아니라 autoComplete 토글 시점에도 현재 텍스트 기준으로 즉시 동기화한다.
+                    // (켜질 때 제안이 바로 뜨고, 꺼질 때 기존 제안이 남지 않도록)
+                    .onChange(of: usingSuggestions) { _ in
+                        refreshAutoCompletion()
                     }
-                    let suggestions = candidates
-                        .filter { $0.lowercased().contains(trimmed.lowercased()) }
-                    autoCompletionDataSource = .init(
-                        numberOfSections: 2,
-                        sectionTitleAt: { section in
-                            "\(section+1)번째 섹션"
-                        },
-                        numberOfItemsInSection: { _ in
-                            suggestions.count
-                        },
-                        cellForItemAt: { indexPath in
-                            ListCell(title: suggestions[indexPath.row]) {
-                                self.text = suggestions[indexPath.row]
-                                Task {
-                                    autoCompletionDataSource = nil
-                                }
-                            }
-                            .highlight(trimmed)
-                            .leadingContent {
-                                Group {
-                                    if indexPath.section == 0 {
-                                        Image.icon(.search)
-                                            .foregroundStyle(SwiftUI.Color.semantic(.labelAlternative))
-                                    } else {
-                                        Avatar("", variant: .company, size: .medium)
-                                    }
-                                }
-                            }
-                            .if(indexPath.section == 1) {
-                                $0.caption("캡션")
-                            }
-                        },
-                        headerView: {
-                            ListCell(title: "'\(trimmed)' 사용하기") {
-                                autoCompletionDataSource = nil
-                            }
-                            .highlight(trimmed)
-                        },
-                        footerView: {
-                            ListCell(title: "'\(trimmed)' 사용하기") {
-                                autoCompletionDataSource = nil
-                            }
-                            .highlight(trimmed)
-                        },
-                        maxHeight: 200
-                    )
                 }
-                
-                VStack(alignment: .leading, spacing: 16) {
-                    Text("Options").bold()
-
-                    // 필드 외형
-                    optionRow("Size", $fieldSize)
-                    optionRow("Status", $variant)
-
-                    Divider()
-
-                    // 필드 콘텐츠/상태 토글
-                    toggleRow("Placeholder", $placeholder)
-                    toggleRow("Icon", $icon)
-                    toggleRow("Disable", $disable)
-                    toggleRow("Heading", $heading)
-                    if heading {
-                        // RequiredBadge는 Heading이 있을 때만 표시된다.
-                        toggleRow("RequiredBadge", $requiredBadge)
-                            .padding(.leading, 16)
-                    }
-                    toggleRow("Description", $description)
-
-                    Divider()
-
-                    // 트레일링 영역
-                    toggleRow("TrailingButton", $trailingButton)
-                    optionRow("Trailing Content", $trailingContent)
-
-                    Divider()
-
-                    // 자동완성
-                    toggleRow("AutoComplete", $usingSuggestions)
-                    if usingSuggestions {
-                        Text("* 다음 목록 중 매칭되는 값들이 제안됩니다:\n  \(candidates.joined(separator: ", "))")
-                            .font(.caption)
-                            .foregroundStyle(SwiftUI.Color.secondary)
-                    }
+                Text("Options").bold()
+                optionRow("size", $fieldSize)
+                optionRow("status", $variant)
+                HStack {
+                    toggleRow("placeholder", $placeholder)
+                    toggleRow("icon", $icon)
+                }
+                HStack {
+                    toggleRow("disable", $disable)
+                    toggleRow("trailingButton", $trailingButton)
+                }
+                optionRow("trailingContent", $trailingContent)
+                HStack {
+                    toggleRow("autoComplete", $usingSuggestions)
+                }
+                if usingSuggestions {
+                    Text("* 다음 목록 중 매칭되는 값들이 제안됩니다:\n  \(candidates.joined(separator: ", "))")
+                        .foregroundStyle(SwiftUI.Color.secondary)
                 }
+                Spacer(minLength: 0)
             }
+            .font(.caption)
             .padding()
         }
         .transparentChecking(isPresented: showTransparentChecker, checkerSize: 201, checkerColor: .red)
diff --git a/Sources/Montage/1 Components/3 Selection And Input/TextArea.swift b/Sources/Montage/1 Components/3 Selection And Input/TextArea.swift
index 371a9fd0..96a6c1d8 100644
--- a/Sources/Montage/1 Components/3 Selection And Input/TextArea.swift	
+++ b/Sources/Montage/1 Components/3 Selection And Input/TextArea.swift	
@@ -10,7 +10,7 @@ import SwiftUI
 /// 여러 줄의 텍스트 입력을 위한 컴포넌트입니다.
 ///
 /// 이 컴포넌트는 사용자가 여러 줄의 텍스트를 입력할 수 있는 영역을 제공합니다.
-/// 제목, 배지, 리사이즈 옵션, 캐릭터 카운터 등 다양한 기능을 지원합니다.
+/// 사이즈, 리사이즈 옵션, 하단 리소스 등 다양한 기능을 지원합니다.
 ///
 /// ```swift
 /// @State private var longText = ""
@@ -18,37 +18,44 @@ import SwiftUI
 ///
 /// // 기본 텍스트 영역
 /// TextArea(text: $longText, focus: $isFocused)
-///     .heading("의견")
 ///     .placeholder("의견을 입력해주세요")
 ///
-/// // 문자 수 제한과 고정 크기를 가진 텍스트 영역
+/// // 중간 사이즈와 고정 크기를 가진 텍스트 영역
 /// TextArea(text: $longText)
-///     .resize(.fixed(min: 100, max: 200))
-///     .bottomResources(
-///         trailing: [.characterCount(limit: 100)]
-///     )
+///     .size(.medium)
+///     .resize(.fixed(min: 108, max: 200))
 ///
-/// // 필수 항목 표시와 설명이 있는 텍스트 영역
+/// // 입력 글자 수를 추적하는 텍스트 영역
+/// @State private var characterCount = 0
 /// TextArea(text: $longText)
-///     .heading("상세 설명")
-///     .requiredBadge(true)
-///     .description("최대한 자세히 작성해주세요")
+///     .maxLength(100)
+///     .onTextChange { characterCount = $0.count }
 /// ```
 public struct TextArea: View {
     // MARK: - Types
-    
+
+    /// 텍스트 영역의 사이즈를 정의합니다.
+    ///
+    /// 사이즈에 따라 모서리 반경, 최소 콘텐츠 높이, 입력 타이포그래피, 하단 리소스 크기가 함께 결정됩니다.
+    public enum Size {
+        /// 큰 사이즈 (입력 `body2`, 최소 콘텐츠 높이 48)
+        case large
+        /// 중간 사이즈 (입력 `label1`, 최소 콘텐츠 높이 44)
+        case medium
+    }
+
     /// 텍스트 영역의 크기 조절 방식을 정의합니다.
     public enum Resize {
-        /// 줄 수 제한이 없으며, 입력된 텍스트에 따라 영역이 자동으로 확장됩니다.
+        /// 줄 수 제한이 없으며, 입력된 텍스트에 따라 영역이 자동으로 확장됩니다. 최소 높이는 2줄 기준입니다.
         case normal
-        /// 최대 8줄까지 표시되며, 초과 부분은 스크롤할 수 있습니다.
+        /// 최대 6줄까지 표시되며, 초과 부분은 스크롤할 수 있습니다. 최소 높이는 2줄 기준입니다.
         case limit
         /// 텍스트 영역의 최소 및 최대 높이를 지정합니다. 초과 부분은 스크롤할 수 있습니다.
         /// - Parameters:
         ///   - min: 최소 높이
         ///   - max: 최대 높이
         case fixed(min: CGFloat, max: CGFloat)
-        
+
         var alignment: Alignment {
             switch self {
             case .normal, .limit: .center
@@ -56,56 +63,46 @@ public struct TextArea: View {
             }
         }
     }
-    
-    /// 텍스트 영역 하단에 표시할 수 있는 UI 요소를 정의합니다.
+
+    /// 텍스트 영역 하단(Bottom Content)에 표시할 수 있는 UI 요소를 정의합니다.
     ///
-    /// 다양한 종류의 컴포넌트를 텍스트 영역 하단에 배치할 수 있습니다.
-    /// 문자 수 카운터, 버튼, 아이콘, 칩, 뱃지 등을 지원합니다.
+    /// 프리셋(``button``·``iconButton``·``icon``·``contentBadge``·``segmentedControl``·
+    /// ``primaryIconButton``)과 임의 뷰(``slot(_:)``)를 지원합니다. 각 요소의 크기는 TextArea의
+    /// ``Size``에 따라 자동으로 조정됩니다.
     ///
-    /// - Note: 문자 수 카운터는 좌/우측 중 하나에만 사용 가능합니다. 중복 사용 시 좌측이 우선 표시됩니다.
+    /// - Note: 디자인 가이드 기준 `button`·`primaryIconButton`은 trailing 전용으로 권장됩니다.
     public enum Resource {
-        /// 요소의 배치 위치를 정의합니다.
-        public enum Placement {
-            /// 왼쪽에 배치
-            case leading
-            /// 오른쪽에 배치
-            case trailing
-        }
-        
-        /// 문자 수 카운터
-        /// - Parameters:
-        ///   - limit: 최대 문자 수 제한, 생략하면 기본값으로 `nil` 적용 (제한 없음)
-        ///   - overflow: 최대 문자 수 초과 허용 여부, 생략하면 기본값으로 `false` 적용
-        case characterCount(limit: Int? = nil, overflow: Bool = false)
-        
-        /// 텍스트 버튼
+        /// 텍스트 버튼(Outlined)
         /// - Parameters:
-        ///   - placement: 버튼 위치, 생략하면 기본값으로 `.leading` 적용
-        ///   - variant: 버튼 변형 스타일, 생략하면 기본값으로 `.assistive` 적용
+        ///   - color: 버튼 색상, 생략하면 기본값으로 `.assistive` 적용
         ///   - title: 버튼 텍스트
         ///   - handler: 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용
-        case textButton(
-            placement: Placement = .leading,
-            variant: TextButton.Color? = .assistive,
+        case button(
+            color: Button.Color = .assistive,
             title: String,
             handler: (() -> Void)? = nil
         )
-        
-        /// 아이콘 버튼
+
+        /// 아이콘 버튼(배경 없음)
         /// - Parameters:
-        ///   - placement: 버튼 위치, 생략하면 기본값으로 `.leading` 적용
-        ///   - variant: 버튼 변형 스타일, 생략하면 기본값으로 `.solid(size: .small)` 적용
         ///   - icon: 버튼 아이콘
         ///   - tintColor: 아이콘 색상, 생략하면 기본값으로 `.semantic(.labelAlternative)` 적용
         ///   - handler: 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용
         case iconButton(
-            placement: Placement = .leading,
-            variant: IconButton.Variant? = .solid(size: .small),
             icon: Icon,
             tintColor: SwiftUI.Color = .semantic(.labelAlternative),
             handler: (() -> Void)? = nil
         )
-        
+
+        /// Primary 아이콘 버튼(Solid)
+        /// - Parameters:
+        ///   - icon: 버튼 아이콘
+        ///   - handler: 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용
+        case primaryIconButton(
+            icon: Icon,
+            handler: (() -> Void)? = nil
+        )
+
         /// 단순 아이콘
         /// - Parameters:
         ///   - icon: 표시할 아이콘
@@ -114,52 +111,57 @@ public struct TextArea: View {
             _ icon: Icon,
             tintColor: SwiftUI.Color = .semantic(.labelAssistive)
         )
-        
-        /// 칩
-        /// - Parameters:
-        ///   - variant: 칩 변형 스타일, 생략하면 기본값으로 `.solid` 적용
-        ///   - title: 칩 텍스트
-        ///   - handler: 칩 클릭 핸들러, 생략하면 기본값으로 `nil` 적용
-        case chip(
-            _ variant: Chip.Variant = .solid,
-            title: String,
-            handler: (() -> Void)? = nil
-        )
-        
-        /// 필터 버튼
-        /// - Parameters:
-        ///   - variant: 버튼 변형 스타일, 생략하면 기본값으로 `.solid` 적용
-        ///   - title: 버튼 텍스트
-        ///   - handler: 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용
-        case filterButton(
-            _ variant: FilterButton.Variant = .solid,
-            title: String,
-            handler: (() -> Void)? = nil
-        )
-        
-        /// 뱃지
+
+        /// 콘텐츠 뱃지
         /// - Parameters:
         ///   - variant: 뱃지 변형 스타일, 생략하면 기본값으로 `.solid` 적용
         ///   - title: 뱃지 텍스트
-        case badge(
+        case contentBadge(
             _ variant: ContentBadge.Variant = .solid,
             title: String
         )
-        
-        var isCharacterCount: Bool {
-            if case .characterCount = self {
-                return true
-            } else {
-                return false
+
+        /// 세그먼트 컨트롤(아이콘 전용). Bottom Content 전용 크기로 렌더링되며 정방형 아이콘만 받습니다.
+        ///
+        /// 아이콘만 노출되므로 VoiceOver 사용자를 위해 세그먼트별 `accessibilityLabels`를 함께 전달하는 것을 권장합니다.
+        /// 라벨을 생략하거나 개수가 부족하면 해당 세그먼트는 아이콘 이름으로 대체됩니다.
+        /// - Parameters:
+        ///   - selectedIndex: 선택된 세그먼트 인덱스 바인딩
+        ///   - icons: 세그먼트 아이콘 배열
+        ///   - accessibilityLabels: 세그먼트별 VoiceOver 라벨 배열, 생략하면 기본값으로 `[]` 적용
+        ///   - onSelect: 선택 변경 핸들러, 생략하면 기본값으로 `nil` 적용
+        case segmentedControl(
+            selectedIndex: Binding<Int>,
+            icons: [Icon],
+            accessibilityLabels: [String] = [],
+            onSelect: ((Int) -> Void)? = nil
+        )
+
+        /// 임의 뷰. `.slot { ... }` 팩토리로 생성합니다.
+        case slotView(() -> AnyView)
+
+        /// 임의 뷰를 Bottom Content에 배치합니다.
+        ///
+        /// - Parameter content: 표시할 뷰를 생성하는 클로저
+        /// - Returns: 구성된 리소스
+        public static func slot<V: View>(@ViewBuilder _ content: @escaping () -> V) -> Resource {
+            .slotView { AnyView(content()) }
+        }
+
+        /// leading(왼쪽)에 배치할 수 있는 리소스인지 여부. `button`·`primaryIconButton`은 trailing 전용입니다.
+        public var isLeadingAllowed: Bool {
+            switch self {
+            case .button, .primaryIconButton: false
+            default: true
             }
         }
     }
-    
+
     // MARK: - Initializer
-    
+
     @Binding private var text: String
     private var exposedFocusState: FocusState<Bool>.Binding?
-    
+
     /// 텍스트 영역을 초기화합니다.
     ///
     /// - Parameters:
@@ -173,24 +175,32 @@ public struct TextArea: View {
         _text = text
         exposedFocusState = focus
     }
-    
+
     // MARK: - Modifiers
-    
+
+    private var size: Size = .large
     private var resize: Resize = .normal
     private var negative = false
     private var disable = false
-    private var heading: String? = nil
-    private var requiredBadge = false
-    private var description: String? = nil
     private var placeholder: String? = nil
     private var leadingResources: [Resource] = []
     private var trailingResources: [Resource] = []
     private var leadingResourceSpacing: CGFloat = 4
     private var trailingResourceSpacing: CGFloat = 4
-    private var characterCounterLimit: Int?
-    private var characterCounterOverflow: Bool = false
-    private var inputCharacterLimit: Int?
+    private var maxLength: Int?
     private var inputTransform: ((String) -> String)?
+    private var onTextChange: ((String) -> Void)?
+
+    /// 텍스트 영역의 사이즈를 설정합니다.
+    ///
+    /// - Parameter size: 텍스트 영역의 사이즈
+    /// - Returns: 수정된 텍스트 영역 인스턴스
+    public func size(_ size: Size) -> Self {
+        var zelf = self
+        zelf.size = size
+        return zelf
+    }
+
     /// 텍스트 영역의 크기 조절 방식을 설정합니다.
     ///
     /// - Parameter resize: 크기 조절 방식
@@ -201,17 +211,18 @@ public struct TextArea: View {
         return zelf
     }
 
-    /// 입력 시점에 적용할 최대 글자 수를 설정합니다.
+    /// 최대 글자 수를 설정합니다.
     ///
-    /// 하단 문자 수 카운터와 달리 카운터 UI를 표시하지 않고 입력 길이만 제한합니다.
-    /// 사후 변형이 아닌 입력 단계에서 제한하므로 UITextView의 텍스트와 UndoManager가
-    /// 일관되게 유지되며, 초과 입력/붙여넣기는 허용분만 잘라서 삽입됩니다.
+    /// 카운터 UI를 표시하지 않고 입력 길이만 제한합니다. 사후 변형이 아닌 입력 단계에서
+    /// 제한하므로 UITextView의 텍스트와 UndoManager가 일관되게 유지되며, 초과 입력/붙여넣기는
+    /// 허용분만 잘라서 삽입됩니다.
     ///
     /// - Parameter limit: 최대 글자 수, nil이면 제한 없음
     /// - Returns: 수정된 텍스트 영역 인스턴스
-    public func inputCharacterLimit(_ limit: Int?) -> Self {
+    public func maxLength(_ limit: Int?) -> Self {
         var zelf = self
-        zelf.inputCharacterLimit = limit
+        // 음수가 들어오면 String.prefix(_:)가 런타임 트랩을 일으키므로 진입점에서 0 이상으로 정규화한다.
+        zelf.maxLength = limit.map { max(0, $0) }
         return zelf
     }
 
@@ -228,7 +239,20 @@ public struct TextArea: View {
         zelf.inputTransform = transform
         return zelf
     }
-    
+
+    /// 텍스트가 변경될 때마다 호출할 클로저를 설정합니다.
+    ///
+    /// 변경된 전체 텍스트를 전달하므로 글자 수 계산(`text.count`), 유효성 검사 등 다양한 후처리에
+    /// 사용할 수 있습니다.
+    ///
+    /// - Parameter handler: 변경된 텍스트를 전달받는 클로저
+    /// - Returns: 수정된 텍스트 영역 인스턴스
+    public func onTextChange(_ handler: @escaping (String) -> Void) -> Self {
+        var zelf = self
+        zelf.onTextChange = handler
+        return zelf
+    }
+
     /// 텍스트 영역의 오류 상태를 설정합니다.
     ///
     /// 오류 상태일 때는 텍스트 영역이 적색 테두리로 강조됩니다.
@@ -240,7 +264,7 @@ public struct TextArea: View {
         zelf.negative = negative
         return zelf
     }
-    
+
     /// 텍스트 영역의 활성화 상태를 설정합니다.
     ///
     /// - Parameter disable: 비활성화 여부, 생략하면 기본값으로 `true` 적용
@@ -250,28 +274,7 @@ public struct TextArea: View {
         zelf.disable = disable
         return zelf
     }
-    
-    /// 텍스트 영역 위에 표시할 제목을 설정합니다.
-    ///
-    /// - Parameter heading: 표시할 제목, nil이면 제목 표시 안함
-    /// - Returns: 수정된 텍스트 영역 인스턴스
-    public func heading(_ heading: String?) -> Self {
-        var zelf = self
-        zelf.heading = heading
-        return zelf
-    }
-    
-    /// 제목 옆에 필수 입력을 나타내는 뱃지를 표시할지 설정합니다.
-    ///
-    /// - Parameter requiredBadge: 필수 입력 뱃지 표시 여부, 생략하면 기본값으로 `true` 적용
-    /// - Returns: 수정된 텍스트 영역 인스턴스
-    /// - Note: 제목이 설정되지 않은 경우 뱃지가 표시되지 않습니다.
-    public func requiredBadge(_ requiredBadge: Bool = true) -> Self {
-        var zelf = self
-        zelf.requiredBadge = requiredBadge
-        return zelf
-    }
-    
+
     /// 텍스트 영역 하단에 표시할 UI 요소를 설정합니다.
     ///
     /// - Parameters:
@@ -280,6 +283,7 @@ public struct TextArea: View {
     ///   - leadingResourceSpacing: 왼쪽 요소 간의 간격
     ///   - trailingResourceSpacing: 오른쪽 요소 간의 간격
     /// - Returns: 수정된 텍스트 영역 인스턴스
+    /// - Note: `button`·`primaryIconButton`은 디자인 가이드상 trailing 전용이므로 leading에 전달되면 무시됩니다.
     public func bottomResources(
         leading leadingResources: [Resource] = [],
         trailing trailingResources: [Resource] = [],
@@ -287,34 +291,15 @@ public struct TextArea: View {
         trailingResourceSpacing: CGFloat = 4
     ) -> Self {
         var zelf = self
-        zelf.leadingResources = Array(leadingResources.prefix(3))
+        // leading 전용 제약: trailing 전용 프리셋은 걸러낸다.
+        zelf.leadingResources = Array(leadingResources.filter(\.isLeadingAllowed).prefix(3))
         zelf.leadingResourceSpacing = leadingResourceSpacing
-        
+
         zelf.trailingResources = Array(trailingResources.prefix(3))
         zelf.trailingResourceSpacing = trailingResourceSpacing
-        
-        let bottomResources = zelf.leadingResources + zelf.filteredTrailingResources
-        if let characterCounter = bottomResources.first(where: \.isCharacterCount),
-           case let .characterCount(limit, overflow) = characterCounter {
-            zelf.characterCounterLimit = limit
-            zelf.characterCounterOverflow = overflow
-        } else {
-            zelf.characterCounterLimit = nil
-            zelf.characterCounterOverflow = false
-        }
         return zelf
     }
-    
-    /// 텍스트 영역 하단에 표시할 설명 텍스트를 설정합니다.
-    ///
-    /// - Parameter description: 표시할 설명 텍스트, nil이면 표시 안함
-    /// - Returns: 수정된 텍스트 영역 인스턴스
-    public func description(_ description: String?) -> Self {
-        var zelf = self
-        zelf.description = description
-        return zelf
-    }
-    
+
     /// 텍스트 영역에 입력된 텍스트가 없을 때 표시할 플레이스홀더를 설정합니다.
     ///
     /// - Parameter placeholder: 표시할 플레이스홀더 텍스트
@@ -324,79 +309,68 @@ public struct TextArea: View {
         zelf.placeholder = placeholder
         return zelf
     }
-    
+
     // MARK: - Body
-    
+
     @Environment(\.colorScheme) private var colorScheme
     @Environment(\.dynamicTypeSize) private var dynamicTypeSize
-    @State private var typedCharacters = 0
     @FocusState private var internalFocusState
 
-    /// 스케일된 본문 폰트(`.body1Reading`)의 한 줄 높이. `UIFont.font`이 Dynamic Type 스케일 폰트를
-    /// 반환하므로 글자 크기 설정에 따라 값이 달라진다.
+    /// 최소로 보장하는 줄 수.
+    private let minRows = 2
+    /// `.limit`에서 허용하는 최대 줄 수.
+    private let maxRows = 6
+
+    /// 입력 폰트(사이즈별 `body2`/`label1`)의 한 줄 높이. `UIFont.font`이 Dynamic Type 스케일 폰트를
+    /// 반환하므로 글자 크기 설정에 따라 값이 달라진다. UITextView는 디자인 lineSpacing이 아닌 폰트의
+    /// 자연 줄높이로 렌더링하므로, 정확한 줄 수를 맞추려면 이 값을 기준으로 높이를 계산해야 한다.
     private var lineHeightUnit: CGFloat {
-        UIFont.font(variant: .body1Reading).lineHeight
+        UIFont.font(variant: size.inputVariant).lineHeight
     }
 
     /// UITextView 기본 `textContainerInset`(상·하 각 8pt)의 합.
     private var verticalContainerInset: CGFloat { 16 }
 
-    /// resize 방식에 따른 최소 높이. `.normal`/`.limit`은 **한 줄 높이 기준**이며 폰트 크기에 따라
-    /// 동적으로 스케일된다. `.fixed`는 호출자가 지정한 픽셀값을 그대로 쓴다.
+    /// 지정한 줄 수가 온전히 보이도록 하는 프레임 높이.
+    private func height(forRows rows: Int) -> CGFloat {
+        ceil(lineHeightUnit * CGFloat(rows) + verticalContainerInset)
+    }
+
+    /// resize 방식에 따른 최소 높이. `.normal`/`.limit`은 **2줄 기준**이며 폰트 줄높이로 계산되어
+    /// Dynamic Type 변경에도 항상 정확히 2줄을 보장한다. `.fixed`는 호출자가 지정한 픽셀값을 그대로 쓴다.
     private var resolvedMinHeight: CGFloat? {
         _ = dynamicTypeSize // Dynamic Type 변경 시 높이 재계산을 위한 의존성 등록
         switch resize {
-        case .normal, .limit: return ceil(lineHeightUnit + verticalContainerInset)
-        case .fixed(let min, _): return min
+        case .normal, .limit:
+            return height(forRows: minRows)
+        case .fixed(let min, _):
+            return min
         }
     }
 
-    /// resize 방식에 따른 최대 높이. `.limit`은 기존 기준값(102pt)을 `.body` 곡선으로 스케일해
-    /// 큰 글자에서도 최소 높이를 밑돌지 않도록 한다.
+    /// resize 방식에 따른 최대 높이. `.limit`은 폰트 줄높이 기준 6줄로 계산되어 Dynamic Type 변경에도
+    /// 항상 정확히 6줄을 유지한다.
     private var resolvedMaxHeight: CGFloat? {
         _ = dynamicTypeSize
         switch resize {
         case .normal: return .infinity
-        case .limit: return UIFontMetrics(forTextStyle: .body).scaledValue(for: 102)
+        case .limit: return height(forRows: maxRows)
         case .fixed(_, let max): return max
         }
     }
-    
+
     /// 뷰의 내용과 동작을 정의합니다.
     public var body: some View {
-        VStack(alignment: .leading, spacing: 8) {
-            if let heading {
-                HStack(spacing: 4) {
-                    Text(heading)
-                        .typography(variant: .label1, weight: .bold, semantic: .labelNeutral)
-                    if requiredBadge {
-                        Text("*")
-                            .typography(variant: .label1, weight: .medium, semantic: .statusNegative)
-                    }
-                }
-            }
-            
-            editor
-            
-            if let description {
-                Text(description)
-                    .typography(
-                        variant: .caption1,
-                        semantic: negative ? .statusNegative : .labelAlternative
-                    )
-            }
-        }
+        editor
     }
-    
+
     // MARK: - Private
-    
+
     var editor: some View {
-        VStack(spacing: 12) {
+        VStack(spacing: size.contentBottomGap) {
             ZStack(alignment: .topLeading) {
-                UITextViewWrapper(text: $text)
-                    .characterCountLimit(characterCounterLimit)
-                    .characterCountOverflow(characterCounterOverflow)
-                    .inputLimit(inputCharacterLimit)
+                UITextViewWrapper(text: $text, inputVariant: size.inputVariant)
+                    .inputLimit(maxLength)
                     .inputTransform(inputTransform)
                     .frameHeight(
                         minHeight: resolvedMinHeight,
@@ -408,56 +382,65 @@ public struct TextArea: View {
                         alignment: resize.alignment
                     )
                     .foregroundStyle(editorTextColor)
-                    .font(.font(variant: .body1Reading))
-                    .lineSpacing(Typography.Variant.body1Reading.lineSpacing)
+                    .font(.font(variant: size.inputVariant))
+                    .lineSpacing(size.inputVariant.lineSpacing)
                     .if(!disable) {
                         $0.focused(focus)
                     }
-                    .onChange(of: text) { _ in
-                        typedCharacters = text.count
+                    .onChange(of: text) { newValue in
+                        onTextChange?(newValue)
                     }
                     .scrollContentBackground(.hidden)
                     .padding(.horizontal, -4.5)
                     .padding(.top, -4)
                     .padding(.bottom, -6)
                     .onAppear {
-                        typedCharacters = text.count
+                        onTextChange?(text)
                     }
-                    .onChange(of: characterCounterLimit) { limit in
-                        updateText(limit: limit, overflow: characterCounterOverflow)
-                    }
-                    .onChange(of: characterCounterOverflow) { overflow in
-                        updateText(limit: characterCounterLimit, overflow: overflow)
-                    }
-                
+
                 if $text.wrappedValue.isEmpty, let placeholder {
                     Text(placeholder)
                         .paragraph(
-                            variant: .body1Reading,
+                            variant: size.inputVariant,
                             color: placeholderTextColor
                         )
                         .allowsHitTesting(false)
                 }
             }
-            .padding(.horizontal, 4)
-            
+            .padding(.horizontal, size.contentPaddingX)
+
             if leadingResources.isEmpty == false || trailingResources.isEmpty == false {
                 Bottom(
-                    typedCharacters: $typedCharacters,
+                    size,
                     disable,
                     leadingResources,
                     leadingResourceSpacing,
-                    filteredTrailingResources,
+                    trailingResources,
                     trailingResourceSpacing
                 )
             }
         }
-        .padding(.all, 12)
+        .padding(.all, size.containerPadding)
+        // fill 배경은 자체적으로 cornerRadius로 clip한다. 최상위에 clipShape을 걸면 테두리 바깥으로
+        // 그려지는 focusRing(-4 padding)이 함께 잘리므로 여기서만 clip한다.
+        .background { editorBackground }
         .overlay {
-            RoundedRectangle(cornerRadius: 12)
-                .strokeBorder(editorStrokeColor, lineWidth: focus.wrappedValue ? 2 : 1)
+            RoundedRectangle(cornerRadius: size.cornerRadius)
+                .strokeBorder(editorStrokeColor, lineWidth: 1)
         }
-        .background {
+        // focusRing은 어떤 clip보다 뒤(=바깥)에 그려져야 테두리 밖으로 번질 수 있다.
+        .background { focusRing }
+        .allowsHitTesting(disable == false)
+        .contentShape(RoundedRectangle(cornerRadius: size.cornerRadius))
+        .onTapGesture {
+            focus.wrappedValue = true
+        }
+        .accessibilityValue(negative ? String(localized: "오류", bundle: .module) : "")
+    }
+
+    @ViewBuilder
+    private var editorBackground: some View {
+        Group {
             if disable {
                 SwiftUI.Color.semantic(.fillAlternative)
             } else {
@@ -470,82 +453,79 @@ public struct TextArea: View {
                 }
             }
         }
-        .clipShape(RoundedRectangle(cornerRadius: 12))
-        .allowsHitTesting(disable == false)
-        .contentShape(RoundedRectangle(cornerRadius: 12))
-        .onTapGesture {
-            focus.wrappedValue = true
+        .clipShape(RoundedRectangle(cornerRadius: size.cornerRadius))
+    }
+
+    /// 포커스 시 테두리 바깥에 표시되는 4px Focus Ring. TextField와 동일한 메커니즘이며,
+    /// negative 상태에서는 빨간 ring을 사용한다.
+    @ViewBuilder
+    private var focusRing: some View {
+        if focus.wrappedValue, disable == false {
+            RoundedRectangle(cornerRadius: size.cornerRadius + 4)
+                .strokeBorder(focusRingColor, lineWidth: 4)
+                .padding(-4)
         }
-        .accessibilityLabel(heading ?? "")
-        .accessibilityValue(negative ? (description ?? String(localized: "오류", bundle: .module)) : "")
     }
-    
+
+    private var focusRingColor: SwiftUI.Color {
+        negative
+            ? SwiftUI.Color.semantic(.interactionNegative)
+            : SwiftUI.Color.semantic(.interactionFocus)
+    }
+
     private var editorStrokeColor: SwiftUI.Color {
-        if negative {
-            SwiftUI.Color.semantic(.statusNegative).opacity(0.43)
+        if disable {
+            SwiftUI.Color.semantic(.lineAlternative)
+        } else if negative {
+            SwiftUI.Color.semantic(.lineNegativeStrong)
+        } else if focus.wrappedValue {
+            SwiftUI.Color.semantic(.linePrimaryStrong)
         } else {
-            focus.wrappedValue ? SwiftUI.Color.semantic(.primaryNormal).opacity(0.43) : SwiftUI.Color
-                .semantic(.lineNormal)
+            SwiftUI.Color.semantic(.lineNeutral)
         }
     }
-    
+
     private var focus: FocusState<Bool>.Binding {
         exposedFocusState ?? $internalFocusState
     }
-    
+
     private var placeholderTextColor: SwiftUI.Color {
         disable ? .semantic(.labelDisable) : .semantic(.labelAssistive)
     }
-    
+
     private var editorTextColor: SwiftUI.Color {
         disable ? .semantic(.labelAlternative) : .semantic(.labelNormal)
     }
-    
-    private var filteredTrailingResources: [Resource] {
-        if leadingResources.contains(where: \.isCharacterCount) &&
-            trailingResources.contains(where: \.isCharacterCount)
-        {
-            trailingResources.filter { $0.isCharacterCount == false }
-        } else {
-            trailingResources
-        }
-    }
-    
-    private func updateText(limit: Int?, overflow: Bool) {
-        if !overflow && text.count > (limit ?? .max) {
-            text = String(text.prefix(limit ?? .max))
-        }
-    }
-    
+
     // MARK: - Inner View
-    
+
     private struct Bottom: View {
-        @Binding private var typedCharacters: Int
-        
+        private let size: Size
         private let disable: Bool
         private let leadingResources: [Resource]
         private let leadingResourceSpacing: CGFloat
         private let trailingResources: [Resource]
         private let trailingResourceSpacing: CGFloat
-        
+
         init(
-            typedCharacters: Binding<Int>,
+            _ size: Size,
             _ disable: Bool,
             _ leadingResources: [Resource],
             _ leadingResourceSpacing: CGFloat,
             _ trailingResources: [Resource],
             _ trailingResourceSpacing: CGFloat
         ) {
-            _typedCharacters = typedCharacters
+            self.size = size
             self.disable = disable
             self.leadingResources = leadingResources
             self.leadingResourceSpacing = leadingResourceSpacing
             self.trailingResources = trailingResources
             self.trailingResourceSpacing = trailingResourceSpacing
         }
-        
+
+        // Bottom Content는 내부 요소 높이에 맞춰 가변되며(고정 minHeight 없음), 요소는 하단 정렬한다.
         var body: some View {
-            HStack {
+            HStack(alignment: .bottom) {
                 if leadingResources.isEmpty == false {
                     HStack(spacing: leadingResourceSpacing) {
                         ForEach(leadingResources.indices, id: \.self) { index in
@@ -553,7 +533,7 @@ public struct TextArea: View {
                         }
                     }
                 }
-                Spacer()
+                Spacer(minLength: 0)
                 if trailingResources.isEmpty == false {
                     HStack(spacing: trailingResourceSpacing) {
                         ForEach(trailingResources.indices, id: \.self) { index in
@@ -563,150 +543,211 @@ public struct TextArea: View {
                 }
             }
         }
-        
+
         @ViewBuilder
         func component(_ resource: Resource) -> some View {
             switch resource {
-            case .characterCount(let limit, let overflow):
-                HStack(spacing: 0) {
-                    Text(String(typedCharacters))
-                        .paragraph(
-                            variant: .label2,
-                            weight: .medium,
-                            semantic: disable ? .labelDisable : (
-                                overflow && typedCharacters > (limit ?? .max)
-                                ? .statusNegative
-                                : .labelAlternative
-                            )
-                        )
-                    if let limit {
-                        Text("/\(String(limit))")
-                            .paragraph(
-                                variant: .label2,
-                                weight: .medium,
-                                semantic: disable ? .labelDisable : .labelAlternative
-                            )
-                    }
-                }
-                .padding(.horizontal, 4)
-            case let .textButton(placement, variant, title, handler):
-                TextButton(
-                    color: {
-                        if let variant {
-                            variant
-                        } else {
-                            switch placement {
-                            case .leading: .assistive
-                            case .trailing: .primary
-                            }
-                        }
-                    }(),
-                    size: .medium,
+            case let .button(color, title, handler):
+                Button(
+                    variant: .outlined,
+                    color: color,
+                    size: size.buttonSize,
                     text: title,
                     handler: handler
                 )
-                .frame(maxHeight: 24)
-                .padding(.horizontal, 4)
-            case let .iconButton(placement, variant, icon, tintColor, handler):
+            case let .iconButton(icon, tintColor, handler):
                 IconButton(
-                    variant: {
-                        if let variant {
-                            variant
-                        } else {
-                            switch placement {
-                            case .leading: .outlined(size: .medium)
-                            case .trailing: .solid(size: .small)
-                            }
-                        }
-                    }(),
+                    variant: .normal(size: size.normalIconButtonSize),
                     icon: icon,
                     handler: handler
                 )
                 .iconColor(tintColor)
+            case let .primaryIconButton(icon, handler):
+                Button(
+                    variant: .solid,
+                    color: .primary,
+                    size: size.buttonSize,
+                    icon: icon,
+                    handler: handler
+                )
             case let .icon(icon, tintColor):
                 Image.icon(icon)
                     .resizable()
                     .foregroundColor(tintColor)
-                    .frame(width: 22, height: 22)
-            case let .chip(variant, title, handler):
-                Chip(
-                    variant: variant,
-                    size: .small,
-                    text: title,
-                    handler: handler
-                )
-            case let .filterButton(variant, title, handler):
-                FilterButton(
-                    variant: variant,
-                    size: .small,
-                    text: title,
-                    handler: handler
-                )
-            case let .badge(variant, title):
+                    .frame(width: size.resourceIconSize, height: size.resourceIconSize)
+            case let .contentBadge(variant, title):
                 ContentBadge(variant: variant, text: title)
-                    .size(.medium)
+                    .size(size.contentBadgeSize)
                     .colorStyle(.neutral())
+            case let .segmentedControl(selectedIndex, icons, accessibilityLabels, onSelect):
+                BottomSegmentedControl(
+                    selectedIndex: selectedIndex,
+                    icons: icons,
+                    accessibilityLabels: accessibilityLabels,
+                    size: size,
+                    onSelect: onSelect
+                )
+            case let .slotView(content):
+                content()
             }
         }
     }
-    
+
+    /// Bottom Content 전용 아이콘 세그먼트 컨트롤.
+    ///
+    /// 표준 ``SegmentedControl``과 달리 정방형 아이콘만 받으며, TextArea의 ``Size``에 맞춰
+    /// 더 작은 크기로 렌더링된다. 선택 스타일(elevated 배경 + shadow)은 표준 컨트롤과 동일하다.
+    private struct BottomSegmentedControl: View {
+        @Binding private var selectedIndex: Int
+        private let icons: [Icon]
+        private let accessibilityLabels: [String]
+        private let size: Size
+        private let onSelect: ((Int) -> Void)?
+
+        init(
+            selectedIndex: Binding<Int>,
+            icons: [Icon],
+            accessibilityLabels: [String],
+            size: Size,
+            onSelect: ((Int) -> Void)?
+        ) {
+            _selectedIndex = selectedIndex
+            self.icons = icons
+            self.accessibilityLabels = accessibilityLabels
+            self.size = size
+            self.onSelect = onSelect
+        }
+
+        private let containerRadius: CGFloat = 8
+        private let segmentRadius: CGFloat = 6
+        private let inset: CGFloat = 2
+
+        private var segmentSide: CGFloat { size.segmentControlHeight - inset * 2 }
+
+        var body: some View {
+            HStack(spacing: 0) {
+                ForEach(icons.indices, id: \.self) { index in
+                    segment(index)
+                }
+            }
+            // 선택 인디케이터는 표준 SegmentedControl과 동일하게 단일 뷰가 offset으로 슬라이드한다.
+            .background(alignment: .leading) { indicator }
+            .padding(inset)
+            .background {
+                RoundedRectangle(cornerRadius: containerRadius)
+                    .foregroundStyle(SwiftUI.Color.semantic(.fillNormal))
+            }
+        }
+
+        private var indicator: some View {
+            ZStack {
+                RoundedRectangle(cornerRadius: segmentRadius)
+                    .foregroundStyle(SwiftUI.Color.semantic(.backgroundElevated))
+                RoundedRectangle(cornerRadius: segmentRadius)
+                    .foregroundStyle(SwiftUI.Color.semantic(.staticWhite).opacity(0.28))
+            }
+            .shadow(color: .semantic(.staticBlack).opacity(0.08), radius: segmentRadius)
+            .frame(width: segmentSide, height: segmentSide)
+            .offset(x: segmentSide * CGFloat(selectedIndex))
+        }
+
+        @ViewBuilder
+        private func segment(_ index: Int) -> some View {
+            Image.icon(icons[index])
+                .resizable()
+                .frame(width: size.resourceIconSize, height: size.resourceIconSize)
+                .foregroundColor(.semantic(index == selectedIndex ? .labelNormal : .labelAlternative))
+                .frame(width: segmentSide, height: segmentSide)
+                .contentShape(RoundedRectangle(cornerRadius: segmentRadius))
+                .onTapGesture {
+                    withAnimation(.easeInOut(duration: 0.2)) {
+                        selectedIndex = index
+                    }
+                    onSelect?(index)
+                }
+                // 아이콘만 노출되므로 VoiceOver에서 의미·조작 가능 여부를 알 수 있도록 라벨과 버튼/선택 trait를 부여한다.
+                .accessibilityElement()
+                .accessibilityLabel(accessibilityLabel(index))
+                .accessibilityAddTraits(.isButton)
+                .accessibilityAddTraits(index == selectedIndex ? .isSelected : [])
+        }
+
+        /// 세그먼트의 VoiceOver 라벨. 명시적 라벨이 없으면 아이콘 이름으로 대체한다.
+        private func accessibilityLabel(_ index: Int) -> String {
+            if index < accessibilityLabels.count, !accessibilityLabels[index].isEmpty {
+                return accessibilityLabels[index]
+            }
+            return icons[index].rawValue
+        }
+    }
+
     struct UITextViewWrapper: UIViewRepresentable {
         @Binding var text: String
-        
-        init(text: Binding<String>) {
+        let inputVariant: Typography.Variant
+
+        init(text: Binding<String>, inputVariant: Typography.Variant) {
             _text = text
+            self.inputVariant = inputVariant
         }
-        
+
         func makeUIView(context: Context) -> UITextView {
             let textView = UITextView()
             // 디자인 폰트(Pretendard)를 Dynamic Type 스케일과 함께 적용한다. UIFont.font은 이미
             // UIFontMetrics 스케일 폰트를 반환하므로, adjustsFontForContentSizeCategory를 켜면 실행 중
             // 글자 크기 변경에도 자동으로 갱신된다.
-            textView.font = UIFont.font(variant: .body1Reading)
+            textView.font = UIFont.font(variant: inputVariant)
             textView.adjustsFontForContentSizeCategory = true
             textView.isScrollEnabled = false
             textView.backgroundColor = .clear
             textView.delegate = context.coordinator
             return textView
         }
-        
+
         func updateUIView(_ uiView: UITextView, context: Context) {
-            if uiView.text != text {
+            // 사이즈(=입력 타이포그래피) 변경에 반응하도록 폰트를 갱신한다.
+            uiView.font = UIFont.font(variant: inputVariant)
+
+            // inputLimit 인터페이스의 구현 책임: 현재 텍스트가 제한을 초과하면(예: 외부에서 inputLimit을
+            // 축소한 경우) 잘라낸다. 입력 시점 제한(shouldChangeTextIn)이 막지 못하는 경로를 보완한다.
+            let effectiveText = inputLimit.map { String(text.prefix($0)) } ?? text
+            if effectiveText != text {
+                DispatchQueue.main.async { text = effectiveText }
+            }
+
+            if uiView.text != effectiveText {
                 // 외부(코드)에서 텍스트가 교체되는 경우. 직접 대입은 UITextView의 UndoManager와
                 // 동기화되지 않아 stale operation이 남고, 이후 Undo 시 저장된 range가 현재 길이를
                 // 벗어나 out-of-bounds 크래시(LIVE-1014)를 유발하므로 undo 기록을 비운다.
                 // 사용자 입력으로 인한 길이 제한은 shouldChangeTextIn에서 처리되어 이 경로를
                 // 타지 않으므로 일반 타이핑의 undo/redo에는 영향을 주지 않는다.
-                uiView.text = text
+                uiView.text = effectiveText
                 uiView.undoManager?.removeAllActions()
             }
-            if context.coordinator.parent.text != text {
+            if context.coordinator.parent.text != effectiveText {
                 DispatchQueue.main.async {
-                    context.coordinator.parent.text = text
+                    context.coordinator.parent.text = effectiveText
                 }
             }
-            context.coordinator.parent.limit = limit
-            context.coordinator.parent.overflow = overflow
             context.coordinator.parent.inputLimit = inputLimit
             context.coordinator.parent.inputTransform = inputTransform
             context.coordinator.minHeight = minHeight
             context.coordinator.maxHeight = maxHeight
         }
-        
+
         func makeCoordinator() -> Coordinator {
             Coordinator(self)
         }
-        
+
         class Coordinator: NSObject, UITextViewDelegate {
             var parent: UITextViewWrapper
             var minHeight: CGFloat?
             var maxHeight: CGFloat?
             private var heightConstraint: NSLayoutConstraint?
-            
+
             init(_ parent: UITextViewWrapper) {
                 self.parent = parent
             }
-            
+
             func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {
                 let currentText = textView.text ?? ""
                 // Undo 등으로 전달된 range가 현재 텍스트 범위를 벗어나면 차단한다.
@@ -717,8 +758,7 @@ public struct TextArea: View {
                 // 정규화된 텍스트만 보유하도록 한다. 사후 변형을 하지 않으므로 textStorage와
                 // UndoManager가 일관되게 유지되어 LIVE-1014(Undo 시 out-of-bounds) 크래시를 방지한다.
                 var sanitized = parent.inputTransform?(text) ?? text
-                let maxLength = parent.inputLimit ?? (parent.overflow ? nil : parent.limit)
-                if let maxLength {
+                if let maxLength = parent.inputLimit {
                     let lengthWithoutRange = currentText.count
                         - currentText.distance(from: swiftRange.lowerBound, to: swiftRange.upperBound)
                     let remaining = max(0, maxLength - lengthWithoutRange)
@@ -742,6 +782,15 @@ public struct TextArea: View {
                 // 변형이 있으면 해당 범위에 직접 삽입(undo에 일관 기록)하고 시스템 입력은 차단한다.
                 if let textRange = textView.textRange(for: range) {
                     textView.replace(textRange, withText: sanitized)
+                    // replace + return false 경로에서는 캐럿이 삽입 시작 위치에 머무른다. UIKit이
+                    // 델리게이트 반환 이후 selection을 복원하므로, 다음 런루프에서 삽입된 텍스트의
+                    // 끝(시작 offset + 삽입 길이)으로 캐럿을 이동시킨다.
+                    let caretOffset = range.location + (sanitized as NSString).length
+                    DispatchQueue.main.async {
+                        if let caret = textView.position(from: textView.beginningOfDocument, offset: caretOffset) {
+                            textView.selectedTextRange = textView.textRange(from: caret, to: caret)
+                        }
+                    }
                 }
                 return false
             }
@@ -762,7 +811,7 @@ public struct TextArea: View {
                 textView.isScrollEnabled = fit > (maxHeight ?? .greatestFiniteMagnitude)
             }
         }
-        
+
         public func sizeThatFits(
             _ proposal: ProposedViewSize,
             uiView: UIViewType,
@@ -782,20 +831,12 @@ public struct TextArea: View {
                 height: newSize.height
             )
         }
-        
-        private var limit: Int?
-        private var overflow: Bool = false
+
         private var minHeight: CGFloat?
         private var maxHeight: CGFloat?
         private var inputLimit: Int?
         private var inputTransform: ((String) -> String)?
 
-        func characterCountLimit(_ limit: Int?) -> Self {
-            var zelf = self
-            zelf.limit = limit
-            return zelf
-        }
-
         func inputLimit(_ limit: Int?) -> Self {
             var zelf = self
             zelf.inputLimit = limit
@@ -807,13 +848,7 @@ public struct TextArea: View {
             zelf.inputTransform = transform
             return zelf
         }
-        
-        func characterCountOverflow(_ overflow: Bool) -> Self {
-            var zelf = self
-            zelf.overflow = overflow
-            return zelf
-        }
-        
+
         func frameHeight(minHeight: CGFloat?, maxHeight: CGFloat?) -> Self {
             var zelf = self
             zelf.minHeight = minHeight
@@ -821,7 +856,7 @@ public struct TextArea: View {
             return zelf
         }
     }
-    
+
     class CustomTextView: UITextView {
         override var intrinsicContentSize: CGSize {
             sizeThatFits(CGSize(width: frame.width, height: CGFloat.greatestFiniteMagnitude))
@@ -829,6 +864,75 @@ public struct TextArea: View {
     }
 }
 
+// MARK: - Size Tokens
+
+private extension TextArea.Size {
+    /// 모서리 반경
+    var cornerRadius: CGFloat {
+        switch self {
+        case .large: .radius14
+        case .medium: .radius12
+        }
+    }
+
+    /// Container 내부 패딩 (사이즈 공통 12)
+    var containerPadding: CGFloat { .spacing12 }
+
+    /// 콘텐츠 영역 ↔ Bottom Content 간격 (사이즈 공통 12)
+    var contentBottomGap: CGFloat { .spacing12 }
+
+    /// 콘텐츠 영역 좌우 패딩 (사이즈 공통 4)
+    var contentPaddingX: CGFloat { .spacing4 }
+
+    /// 입력 타이포그래피 변형
+    var inputVariant: Typography.Variant {
+        switch self {
+        case .large: .body2
+        case .medium: .label1
+        }
+    }
+
+    /// Bottom Content 단순 아이콘 / iconButton 아이콘 크기.
+    var resourceIconSize: CGFloat {
+        switch self {
+        case .large: 20
+        case .medium: 18
+        }
+    }
+
+    /// Bottom Content 텍스트 버튼 크기. Large=32, Medium=28 높이에 대응.
+    var buttonSize: Button.Size {
+        switch self {
+        case .large: .small
+        case .medium: .xsmall
+        }
+    }
+
+    /// 배경 없는 아이콘 버튼 크기. Large=32(아이콘20), Medium=28(아이콘18).
+    var normalIconButtonSize: IconButton.NormalSize {
+        switch self {
+        case .large: .large
+        case .medium: .medium
+        }
+    }
+
+    /// Bottom 전용 아이콘 세그먼트 컨트롤의 컨테이너 높이. Large=32, Medium=28.
+    var segmentControlHeight: CGFloat {
+        switch self {
+        case .large: 32
+        case .medium: 28
+        }
+    }
+
+    /// Bottom Content 콘텐츠 뱃지 크기.
+    var contentBadgeSize: ContentBadge.Size {
+        switch self {
+        case .large: .medium
+        case .medium: .small
+        }
+    }
+}
+
 private extension UITextView {
     /// NSRange를 UITextRange로 변환한다. 범위가 유효하지 않으면 nil을 반환한다.
     func textRange(for nsRange: NSRange) -> UITextRange? {
diff --git a/Sources/Montage/1 Components/3 Selection And Input/TextField.swift b/Sources/Montage/1 Components/3 Selection And Input/TextField.swift
index a3687b17..13cad852 100644
--- a/Sources/Montage/1 Components/3 Selection And Input/TextField.swift	
+++ b/Sources/Montage/1 Components/3 Selection And Input/TextField.swift	
@@ -17,15 +17,12 @@ import SwiftUI
 ///
 /// // 기본 텍스트 필드
 /// TextField(text: $inputText)
-///    .heading("이메일")
 ///    .placeholder("이메일을 입력하세요")
 ///
-/// // 아이콘이 있는 필수 입력 필드
+/// // 아이콘과 오류 상태를 가진 필드
 /// TextField(text: $inputText)
-///    .heading("아이디")
-///    .requiredBadge(true)
 ///    .icon(.person)
-///    .status(.negative(description: "올바른 아이디를 입력해주세요"))
+///    .status(.negative)
 ///
 /// // 오른쪽 버튼이 있는 텍스트 필드
 /// TextField(text: $inputText)
@@ -55,15 +52,12 @@ public struct TextField: View {
 
     /// 텍스트 필드의 상태를 정의합니다.
     public enum Status {
-        /// 기본 상태, 선택적으로 설명 텍스트 포함 가능
-        /// - Parameter description: 설명 텍스트, 생략하면 기본값으로 `""` 적용
-        case normal(description: String = "")
-        /// 유효한 입력 상태, 선택적으로 설명 텍스트 포함 가능
-        /// - Parameter description: 설명 텍스트, 생략하면 기본값으로 `""` 적용
-        case positive(description: String = "")
-        /// 오류 상태, 선택적으로 오류 설명 텍스트 포함 가능
-        /// - Parameter description: 오류 설명 텍스트, 생략하면 기본값으로 `""` 적용
-        case negative(description: String = "")
+        /// 기본 상태
+        case normal
+        /// 유효한 입력 상태
+        case positive
+        /// 오류 상태
+        case negative
     }
 
     /// 텍스트 필드의 오른쪽에 표시할 버튼의 속성을 정의합니다.
@@ -166,10 +160,8 @@ public struct TextField: View {
     // MARK: - Modifiers
 
     private var size: Size = .large
-    private var status: Status = .normal()
+    private var status: Status = .normal
     private var disable = false
-    private var heading: String? = nil
-    private var requiredBadge = false
     private var placeholder: String? = nil
     private var icon: Icon? = nil
     private var trailingButton: TrailingButtonInfo? = nil
@@ -207,27 +199,6 @@ public struct TextField: View {
         return zelf
     }
     
-    /// 텍스트 필드 위에 표시할 제목을 설정합니다.
-    ///
-    /// - Parameter heading: 표시할 제목, nil이면 제목 표시 안함
-    /// - Returns: 수정된 텍스트 필드 인스턴스
-    public func heading(_ heading: String?) -> Self {
-        var zelf = self
-        zelf.heading = heading
-        return zelf
-    }
-    
-    /// 제목 옆에 필수 입력을 나타내는 뱃지를 표시할지 설정합니다.
-    ///
-    /// - Parameter requiredBadge: 필수 입력 뱃지 표시 여부
-    /// - Returns: 수정된 텍스트 필드 인스턴스
-    /// - Note: 제목이 설정되지 않은 경우 뱃지가 표시되지 않습니다.
-    public func requiredBadge(_ requiredBadge: Bool) -> Self {
-        var zelf = self
-        zelf.requiredBadge = requiredBadge
-        return zelf
-    }
-    
     /// 텍스트 필드에 입력된 텍스트가 없을 때 표시할 플레이스홀더를 설정합니다.
     ///
     /// - Parameter placeholder: 표시할 플레이스홀더 텍스트
@@ -289,33 +260,7 @@ public struct TextField: View {
 
     /// 뷰의 내용과 동작을 정의합니다.
     public var body: some View {
-        VStack(alignment: .leading, spacing: 8) {
-            if let heading {
-                HStack(spacing: 4) {
-                    Text(heading)
-                        .paragraph(variant: .label1, weight: .bold, semantic: .labelNeutral)
-                    if requiredBadge {
-                        Text("*")
-                            .typography(variant: .label1, weight: .medium, semantic: .statusNegative)
-                    }
-                }
-            }
-            
-            inputField
-            
-            Group {
-                switch status {
-                case .positive(let caption), .negative(let caption), .normal(let caption):
-                    if caption.isEmpty == false {
-                        Text(caption)
-                            .paragraph(
-                                variant: .caption1,
-                                color: captionTextColor
-                            )
-                    }
-                }
-            }
-        }
+        inputField
     }
 }
         
@@ -434,8 +379,10 @@ private extension TextField {
             .foregroundStyle(fieldTextColor)
             .focused($textFieldFocusState)
             .padding(.horizontal, .spacing4)
-            .accessibilityLabel(heading ?? "")
-            .accessibilityValue(accessibilityStatusDescription)
+            // 실제 입력 텍스트가 보조 기술에 그대로 노출되도록 value는 덮어쓰지 않는다.
+            // 필드의 용도는 placeholder로 라벨링하고, 상태 메시지(오류 등)는 hint로 전달한다.
+            .accessibilityLabel(placeholder.map(Text.init) ?? Text(""))
+            .accessibilityHint(accessibilityStatusDescription)
 
             trailingArea
         }
@@ -505,25 +452,14 @@ private extension TextField {
     }
 
     var accessibilityStatusDescription: String {
-        switch status {
-        case .negative(let description):
-            description.isEmpty ? String(localized: "오류", bundle: .module) : description
-        case .positive(let description):
-            description.isEmpty ? "" : description
-        case .normal(let description):
-            description
-        }
-    }
-
-    var captionTextColor: SwiftUI.Color {
         switch status {
         case .negative:
-            .semantic(.statusNegative)
-        default:
-            .semantic(.labelAlternative)
+            String(localized: "오류", bundle: .module)
+        case .positive, .normal:
+            ""
         }
     }
-    
+
     var autoCompletionContent: some View {
         Group {
             if let autoCompletionDataSource {
diff --git a/documentation/components/selection and input/textarea/ios.md b/documentation/components/selection and input/textarea/ios.md
index b4ca15e1..ffd02231 100644
--- a/documentation/components/selection and input/textarea/ios.md	
+++ b/documentation/components/selection and input/textarea/ios.md	
@@ -9,7 +9,7 @@ description: 여러 줄의 텍스트 입력을 위한 컴포넌트입니다.
 
 ## Overview
 
-이 컴포넌트는 사용자가 여러 줄의 텍스트를 입력할 수 있는 영역을 제공합니다. 제목, 배지, 리사이즈 옵션, 캐릭터 카운터 등 다양한 기능을 지원합니다.
+이 컴포넌트는 사용자가 여러 줄의 텍스트를 입력할 수 있는 영역을 제공합니다. 사이즈, 리사이즈 옵션, 하단 리소스 등 다양한 기능을 지원합니다.
 
 ```swift
 @State private var longText = ""
@@ -17,21 +17,18 @@ description: 여러 줄의 텍스트 입력을 위한 컴포넌트입니다.
 
 // 기본 텍스트 영역
 TextArea(text: $longText, focus: $isFocused)
-    .heading("의견")
     .placeholder("의견을 입력해주세요")
 
-// 문자 수 제한과 고정 크기를 가진 텍스트 영역
+// 중간 사이즈와 고정 크기를 가진 텍스트 영역
 TextArea(text: $longText)
-    .resize(.fixed(min: 100, max: 200))
-    .bottomResources(
-        trailing: [.characterCount(limit: 100)]
-    )
+    .size(.medium)
+    .resize(.fixed(min: 108, max: 200))
 
-// 필수 항목 표시와 설명이 있는 텍스트 영역
+// 입력 글자 수를 추적하는 텍스트 영역
+@State private var characterCount = 0
 TextArea(text: $longText)
-    .heading("상세 설명")
-    .requiredBadge(true)
-    .description("최대한 자세히 작성해주세요")
+    .maxLength(100)
+    .onTextChange { characterCount = $0.count }
 ```
 
 ## Topics
@@ -81,21 +78,11 @@ TextArea(text: $longText)
 - **Return Value**
 
   수정된 텍스트 영역 인스턴스
-</details>
-<details>
-
-<summary>``func description(String?) -> TextArea``</summary>
-
-
-텍스트 영역 하단에 표시할 설명 텍스트를 설정합니다.
-
-- **Parameters**
-  | Parameter | Description |
-  | --- | --- |
-  | `description` | 표시할 설명 텍스트, nil이면 표시 안함 |
-- **Return Value**
+- **Discussion**
+  >  **Note**
+  >
+  > `button`·`primaryIconButton`은 디자인 가이드상 trailing 전용이므로 leading에 전달되면 무시됩니다.
 
-  수정된 텍스트 영역 인스턴스
 </details>
 <details>
 
@@ -114,25 +101,28 @@ TextArea(text: $longText)
 </details>
 <details>
 
-<summary>``func heading(String?) -> TextArea``</summary>
+<summary>``func inputTransform(((String) -> String)?) -> TextArea``</summary>
 
 
-텍스트 영역 위에 표시할 제목을 설정합니다.
+입력되는 텍스트를 입력 시점에 변환할 클로저를 설정합니다.
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `heading` | 표시할 제목, nil이면 제목 표시 안함 |
+  | `transform` | 입력 조각을 변환하는 클로저, nil이면 변환하지 않음 |
 - **Return Value**
 
   수정된 텍스트 영역 인스턴스
+- **Discussion**
+
+  사용자가 입력하거나 붙여넣는 텍스트(replacement) 조각에 적용됩니다. emoji 제거 등 도메인별 정규화에 사용합니다. 사후 변형이 아닌 입력 단계에서 적용되므로 UITextView의 텍스트와 UndoManager가 일관되게 유지됩니다.
 </details>
 <details>
 
-<summary>``func inputCharacterLimit(Int?) -> TextArea``</summary>
+<summary>``func maxLength(Int?) -> TextArea``</summary>
 
 
-입력 시점에 적용할 최대 글자 수를 설정합니다.
+최대 글자 수를 설정합니다.
 
 - **Parameters**
   | Parameter | Description |
@@ -143,43 +133,43 @@ TextArea(text: $longText)
   수정된 텍스트 영역 인스턴스
 - **Discussion**
 
-  하단 문자 수 카운터와 달리 카운터 UI를 표시하지 않고 입력 길이만 제한합니다. 사후 변형이 아닌 입력 단계에서 제한하므로 UITextView의 텍스트와 UndoManager가 일관되게 유지되며, 초과 입력/붙여넣기는 허용분만 잘라서 삽입됩니다.
+  카운터 UI를 표시하지 않고 입력 길이만 제한합니다. 사후 변형이 아닌 입력 단계에서 제한하므로 UITextView의 텍스트와 UndoManager가 일관되게 유지되며, 초과 입력/붙여넣기는 허용분만 잘라서 삽입됩니다.
 </details>
 <details>
 
-<summary>``func inputTransform(((String) -> String)?) -> TextArea``</summary>
+<summary>``func negative(Bool) -> TextArea``</summary>
 
 
-입력되는 텍스트를 입력 시점에 변환할 클로저를 설정합니다.
+텍스트 영역의 오류 상태를 설정합니다.
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `transform` | 입력 조각을 변환하는 클로저, nil이면 변환하지 않음 |
+  | `negative` | 오류 상태 여부, 생략하면 기본값으로 `true` 적용 |
 - **Return Value**
 
   수정된 텍스트 영역 인스턴스
 - **Discussion**
 
-  사용자가 입력하거나 붙여넣는 텍스트(replacement) 조각에 적용됩니다. emoji 제거 등 도메인별 정규화에 사용합니다. 사후 변형이 아닌 입력 단계에서 적용되므로 UITextView의 텍스트와 UndoManager가 일관되게 유지됩니다.
+  오류 상태일 때는 텍스트 영역이 적색 테두리로 강조됩니다.
 </details>
 <details>
 
-<summary>``func negative(Bool) -> TextArea``</summary>
+<summary>``func onTextChange((String) -> Void) -> TextArea``</summary>
 
 
-텍스트 영역의 오류 상태를 설정합니다.
+텍스트가 변경될 때마다 호출할 클로저를 설정합니다.
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `negative` | 오류 상태 여부, 생략하면 기본값으로 `true` 적용 |
+  | `handler` | 변경된 텍스트를 전달받는 클로저 |
 - **Return Value**
 
   수정된 텍스트 영역 인스턴스
 - **Discussion**
 
-  오류 상태일 때는 텍스트 영역이 적색 테두리로 강조됩니다.
+  변경된 전체 텍스트를 전달하므로 글자 수 계산(`text.count`), 유효성 검사 등 다양한 후처리에 사용할 수 있습니다.
 </details>
 <details>
 
@@ -198,35 +188,30 @@ TextArea(text: $longText)
 </details>
 <details>
 
-<summary>``func requiredBadge(Bool) -> TextArea``</summary>
+<summary>``func resize(Resize) -> TextArea``</summary>
 
 
-제목 옆에 필수 입력을 나타내는 뱃지를 표시할지 설정합니다.
+텍스트 영역의 크기 조절 방식을 설정합니다.
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `requiredBadge` | 필수 입력 뱃지 표시 여부, 생략하면 기본값으로 `true` 적용 |
+  | `resize` | 크기 조절 방식 |
 - **Return Value**
 
   수정된 텍스트 영역 인스턴스
-- **Discussion**
-  >  **Note**
-  >
-  > 제목이 설정되지 않은 경우 뱃지가 표시되지 않습니다.
-
 </details>
 <details>
 
-<summary>``func resize(Resize) -> TextArea``</summary>
+<summary>``func size(Size) -> TextArea``</summary>
 
 
-텍스트 영역의 크기 조절 방식을 설정합니다.
+텍스트 영역의 사이즈를 설정합니다.
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `resize` | 크기 조절 방식 |
+  | `size` | 텍스트 영역의 사이즈 |
 - **Return Value**
 
   수정된 텍스트 영역 인스턴스
@@ -260,14 +245,14 @@ TextArea(text: $longText)
 <summary>``case limit``</summary>
 
 
-최대 8줄까지 표시되며, 초과 부분은 스크롤할 수 있습니다.
+최대 6줄까지 표시되며, 초과 부분은 스크롤할 수 있습니다. 최소 높이는 2줄 기준입니다.
 </details>
 <details>
 
 <summary>``case normal``</summary>
 
 
-줄 수 제한이 없으며, 입력된 텍스트에 따라 영역이 자동으로 확장됩니다.
+줄 수 제한이 없으며, 입력된 텍스트에 따라 영역이 자동으로 확장됩니다. 최소 높이는 2줄 기준입니다.
 </details>
 
 </details>
@@ -276,133 +261,152 @@ TextArea(text: $longText)
 <summary>``enum Resource``</summary>
 
 
-텍스트 영역 하단에 표시할 수 있는 UI 요소를 정의합니다.
+텍스트 영역 하단(Bottom Content)에 표시할 수 있는 UI 요소를 정의합니다.
 #### Enumeration Cases
 
 <details>
 
-<summary>``case badge(ContentBadge.Variant, title: String)``</summary>
+<summary>``case button(color: Button.Color, title: String, handler: (() -> Void)?)``</summary>
 
 
-뱃지
+텍스트 버튼(Outlined)
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `variant` | 뱃지 변형 스타일, 생략하면 기본값으로 `.solid` 적용 |
-  | `title` | 뱃지 텍스트 |
+  | `color` | 버튼 색상, 생략하면 기본값으로 `.assistive` 적용 |
+  | `title` | 버튼 텍스트 |
+  | `handler` | 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용 |
 </details>
 <details>
 
-<summary>``case characterCount(limit: Int?, overflow: Bool)``</summary>
+<summary>``case contentBadge(ContentBadge.Variant, title: String)``</summary>
 
 
-문자 수 카운터
+콘텐츠 뱃지
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `limit` | 최대 문자 수 제한, 생략하면 기본값으로 `nil` 적용 (제한 없음) |
-  | `overflow` | 최대 문자 수 초과 허용 여부, 생략하면 기본값으로 `false` 적용 |
+  | `variant` | 뱃지 변형 스타일, 생략하면 기본값으로 `.solid` 적용 |
+  | `title` | 뱃지 텍스트 |
 </details>
 <details>
 
-<summary>``case chip(Chip.Variant, title: String, handler: (() -> Void)?)``</summary>
+<summary>``case icon(Icon, tintColor: SwiftUI.Color)``</summary>
 
 
-칩
+단순 아이콘
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `variant` | 칩 변형 스타일, 생략하면 기본값으로 `.solid` 적용 |
-  | `title` | 칩 텍스트 |
-  | `handler` | 칩 클릭 핸들러, 생략하면 기본값으로 `nil` 적용 |
+  | `icon` | 표시할 아이콘 |
+  | `tintColor` | 아이콘 색상, 생략하면 기본값으로 `.semantic(.labelAssistive)` 적용 |
 </details>
 <details>
 
-<summary>``case filterButton(FilterButton.Variant, title: String, handler: (() -> Void)?)``</summary>
+<summary>``case iconButton(icon: Icon, tintColor: SwiftUI.Color, handler: (() -> Void)?)``</summary>
 
 
-필터 버튼
+아이콘 버튼(배경 없음)
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `variant` | 버튼 변형 스타일, 생략하면 기본값으로 `.solid` 적용 |
-  | `title` | 버튼 텍스트 |
+  | `icon` | 버튼 아이콘 |
+  | `tintColor` | 아이콘 색상, 생략하면 기본값으로 `.semantic(.labelAlternative)` 적용 |
   | `handler` | 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용 |
 </details>
 <details>
 
-<summary>``case icon(Icon, tintColor: SwiftUI.Color)``</summary>
+<summary>``case primaryIconButton(icon: Icon, handler: (() -> Void)?)``</summary>
 
 
-단순 아이콘
+Primary 아이콘 버튼(Solid)
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `icon` | 표시할 아이콘 |
-  | `tintColor` | 아이콘 색상, 생략하면 기본값으로 `.semantic(.labelAssistive)` 적용 |
+  | `icon` | 버튼 아이콘 |
+  | `handler` | 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용 |
 </details>
 <details>
 
-<summary>``case iconButton(placement: Placement, variant: IconButton.Variant?, icon: Icon, tintColor: SwiftUI.Color, handler: (() -> Void)?)``</summary>
+<summary>``case segmentedControl(selectedIndex: Binding<Int>, icons: [Icon], accessibilityLabels: [String], onSelect: ((Int) -> Void)?)``</summary>
 
 
-아이콘 버튼
+세그먼트 컨트롤(아이콘 전용). Bottom Content 전용 크기로 렌더링되며 정방형 아이콘만 받습니다.
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `placement` | 버튼 위치, 생략하면 기본값으로 `.leading` 적용 |
-  | `variant` | 버튼 변형 스타일, 생략하면 기본값으로 `.solid(size: .small)` 적용 |
-  | `icon` | 버튼 아이콘 |
-  | `tintColor` | 아이콘 색상, 생략하면 기본값으로 `.semantic(.labelAlternative)` 적용 |
-  | `handler` | 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용 |
+  | `selectedIndex` | 선택된 세그먼트 인덱스 바인딩 |
+  | `icons` | 세그먼트 아이콘 배열 |
+  | `accessibilityLabels` | 세그먼트별 VoiceOver 라벨 배열, 생략하면 기본값으로 `[]` 적용 |
+  | `onSelect` | 선택 변경 핸들러, 생략하면 기본값으로 `nil` 적용 |
+- **Discussion**
+
+  아이콘만 노출되므로 VoiceOver 사용자를 위해 세그먼트별 `accessibilityLabels`를 함께 전달하는 것을 권장합니다. 라벨을 생략하거나 개수가 부족하면 해당 세그먼트는 아이콘 이름으로 대체됩니다.
+</details>
+<details>
+
+<summary>``case slotView(() -> AnyView)``</summary>
+
+
+임의 뷰. `.slot { ... }` 팩토리로 생성합니다.
+</details>
+
+#### Instance Properties
+
+<details>
+
+<summary>``var isLeadingAllowed: Bool``</summary>
+
+
+leading(왼쪽)에 배치할 수 있는 리소스인지 여부. `button`·`primaryIconButton`은 trailing 전용입니다.
 </details>
+
+#### Type Methods
+
 <details>
 
-<summary>``case textButton(placement: Placement, variant: TextButton.Color?, title: String, handler: (() -> Void)?)``</summary>
+<summary>``static func slot<V>(() -> V) -> Resource``</summary>
 
 
-텍스트 버튼
+임의 뷰를 Bottom Content에 배치합니다.
 
 - **Parameters**
   | Parameter | Description |
   | --- | --- |
-  | `placement` | 버튼 위치, 생략하면 기본값으로 `.leading` 적용 |
-  | `variant` | 버튼 변형 스타일, 생략하면 기본값으로 `.assistive` 적용 |
-  | `title` | 버튼 텍스트 |
-  | `handler` | 버튼 클릭 핸들러, 생략하면 기본값으로 `nil` 적용 |
-</details>
+  | `content` | 표시할 뷰를 생성하는 클로저 |
+- **Return Value**
 
-#### Enumerations
+  구성된 리소스
+</details>
 
+</details>
 <details>
 
-<summary>``enum Placement``</summary>
+<summary>``enum Size``</summary>
 
 
-요소의 배치 위치를 정의합니다.
-##### Enumeration Cases
+텍스트 영역의 사이즈를 정의합니다.
+#### Enumeration Cases
 
 <details>
 
-<summary>``case leading``</summary>
+<summary>``case large``</summary>
 
 
-왼쪽에 배치
+큰 사이즈 (입력 `body2`, 최소 콘텐츠 높이 48)
 </details>
 <details>
 
-<summary>``case trailing``</summary>
+<summary>``case medium``</summary>
 
 
-오른쪽에 배치
-</details>
-
+중간 사이즈 (입력 `label1`, 최소 콘텐츠 높이 44)
 </details>
 
 </details>
diff --git a/documentation/components/selection and input/textfield/ios.md b/documentation/components/selection and input/textfield/ios.md
index 29da1c0d..da72133c 100644
--- a/documentation/components/selection and input/textfield/ios.md	
+++ b/documentation/components/selection and input/textfield/ios.md	
@@ -16,15 +16,12 @@ description: 단일 라인 텍스트 입력을 위한 컴포넌트입니다.
 
 // 기본 텍스트 필드
 TextField(text: $inputText)
-   .heading("이메일")
    .placeholder("이메일을 입력하세요")
 
-// 아이콘이 있는 필수 입력 필드
+// 아이콘과 오류 상태를 가진 필드
 TextField(text: $inputText)
-   .heading("아이디")
-   .requiredBadge(true)
    .icon(.person)
-   .status(.negative(description: "올바른 아이디를 입력해주세요"))
+   .status(.negative)
 
 // 오른쪽 버튼이 있는 텍스트 필드
 TextField(text: $inputText)
@@ -175,21 +172,6 @@ TextField(text: $inputText)
 </details>
 <details>
 
-<summary>``func heading(String?) -> TextField``</summary>
-
-
-텍스트 필드 위에 표시할 제목을 설정합니다.
-
-- **Parameters**
-  | Parameter | Description |
-  | --- | --- |
-  | `heading` | 표시할 제목, nil이면 제목 표시 안함 |
-- **Return Value**
-
-  수정된 텍스트 필드 인스턴스
-</details>
-<details>
-
 <summary>``func icon(Icon?) -> TextField``</summary>
 
 
@@ -220,26 +202,6 @@ TextField(text: $inputText)
 </details>
 <details>
 
-<summary>``func requiredBadge(Bool) -> TextField``</summary>
-
-
-제목 옆에 필수 입력을 나타내는 뱃지를 표시할지 설정합니다.
-
-- **Parameters**
-  | Parameter | Description |
-  | --- | --- |
-  | `requiredBadge` | 필수 입력 뱃지 표시 여부 |
-- **Return Value**
-
-  수정된 텍스트 필드 인스턴스
-- **Discussion**
-  >  **Note**
-  >
-  > 제목이 설정되지 않은 경우 뱃지가 표시되지 않습니다.
-
-</details>
-<details>
-
 <summary>``func size(Size) -> TextField``</summary>
 
 
@@ -335,39 +297,24 @@ TextField(text: $inputText)
 
 <details>
 
-<summary>``case negative(description: String)``</summary>
-
+<summary>``case negative``</summary>
 
-오류 상태, 선택적으로 오류 설명 텍스트 포함 가능
 
-- **Parameters**
-  | Parameter | Description |
-  | --- | --- |
-  | `description` | 오류 설명 텍스트, 생략하면 기본값으로 `""` 적용 |
+오류 상태
 </details>
 <details>
 
-<summary>``case normal(description: String)``</summary>
-
+<summary>``case normal``</summary>
 
-기본 상태, 선택적으로 설명 텍스트 포함 가능
 
-- **Parameters**
-  | Parameter | Description |
-  | --- | --- |
-  | `description` | 설명 텍스트, 생략하면 기본값으로 `""` 적용 |
+기본 상태
 </details>
 <details>
 
-<summary>``case positive(description: String)``</summary>
+<summary>``case positive``</summary>
 
 
-유효한 입력 상태, 선택적으로 설명 텍스트 포함 가능
-
-- **Parameters**
-  | Parameter | Description |
-  | --- | --- |
-  | `description` | 설명 텍스트, 생략하면 기본값으로 `""` 적용 |
+유효한 입력 상태
 </details>
 
 </details>
diff --git a/packages/montage-mcp/data/components.json b/packages/montage-mcp/data/components.json
index 2e94cc39..88d88566 100644
--- a/packages/montage-mcp/data/components.json
+++ b/packages/montage-mcp/data/components.json
@@ -2343,36 +2343,24 @@
           "summary": "텍스트 영역 하단에 표시할 UI 요소를 설정합니다.",
           "kind": "method"
         },
-        {
-          "name": "description(_:)",
-          "signature": "func description(String?) -> TextArea",
-          "summary": "텍스트 영역 하단에 표시할 설명 텍스트를 설정합니다.",
-          "kind": "method"
-        },
         {
           "name": "disable(_:)",
           "signature": "func disable(Bool) -> TextArea",
           "summary": "텍스트 영역의 활성화 상태를 설정합니다.",
           "kind": "method"
         },
-        {
-          "name": "heading(_:)",
-          "signature": "func heading(String?) -> TextArea",
-          "summary": "텍스트 영역 위에 표시할 제목을 설정합니다.",
-          "kind": "method"
-        },
-        {
-          "name": "inputCharacterLimit(_:)",
-          "signature": "func inputCharacterLimit(Int?) -> TextArea",
-          "summary": "입력 시점에 적용할 최대 글자 수를 설정합니다.",
-          "kind": "method"
-        },
         {
           "name": "inputTransform(_:)",
           "signature": "func inputTransform(((String) -> String)?) -> TextArea",
           "summary": "입력되는 텍스트를 입력 시점에 변환할 클로저를 설정합니다.",
           "kind": "method"
         },
+        {
+          "name": "maxLength(_:)",
+          "signature": "func maxLength(Int?) -> TextArea",
+          "summary": "최대 글자 수를 설정합니다.",
+          "kind": "method"
+        },
         {
           "name": "negative(_:)",
           "signature": "func negative(Bool) -> TextArea",
@@ -2380,15 +2368,15 @@
           "kind": "method"
         },
         {
-          "name": "placeholder(_:)",
-          "signature": "func placeholder(String?) -> TextArea",
-          "summary": "텍스트 영역에 입력된 텍스트가 없을 때 표시할 플레이스홀더를 설정합니다.",
+          "name": "onTextChange(_:)",
+          "signature": "func onTextChange((String) -> Void) -> TextArea",
+          "summary": "텍스트가 변경될 때마다 호출할 클로저를 설정합니다.",
           "kind": "method"
         },
         {
-          "name": "requiredBadge(_:)",
-          "signature": "func requiredBadge(Bool) -> TextArea",
-          "summary": "제목 옆에 필수 입력을 나타내는 뱃지를 표시할지 설정합니다.",
+          "name": "placeholder(_:)",
+          "signature": "func placeholder(String?) -> TextArea",
+          "summary": "텍스트 영역에 입력된 텍스트가 없을 때 표시할 플레이스홀더를 설정합니다.",
           "kind": "method"
         },
         {
@@ -2396,6 +2384,12 @@
           "signature": "func resize(Resize) -> TextArea",
           "summary": "텍스트 영역의 크기 조절 방식을 설정합니다.",
           "kind": "method"
+        },
+        {
+          "name": "size(_:)",
+          "signature": "func size(Size) -> TextArea",
+          "summary": "텍스트 영역의 사이즈를 설정합니다.",
+          "kind": "method"
         }
       ],
       "staticMembers": [],
@@ -2413,15 +2407,32 @@
         {
           "name": "TextArea.Resource",
           "kind": "enum",
-          "summary": "텍스트 영역 하단에 표시할 수 있는 UI 요소를 정의합니다.",
+          "summary": "텍스트 영역 하단(Bottom Content)에 표시할 수 있는 UI 요소를 정의합니다.",
           "cases": [
-            "badge",
-            "characterCount",
-            "chip",
-            "filterButton",
+            "button",
+            "contentBadge",
             "icon",
             "iconButton",
-            "textButton"
+            "primaryIconButton",
+            "segmentedControl",
+            "slotView"
+          ],
+          "staticMethods": [
+            {
+              "name": "slot(_:)",
+              "signature": "static func slot<V>(() -> V) -> Resource",
+              "summary": "임의 뷰를 Bottom Content에 배치합니다.",
+              "kind": "method"
+            }
+          ]
+        },
+        {
+          "name": "TextArea.Size",
+          "kind": "enum",
+          "summary": "텍스트 영역의 사이즈를 정의합니다.",
+          "cases": [
+            "large",
+            "medium"
           ]
         }
       ]
@@ -2523,12 +2534,6 @@
           "summary": "텍스트 필드의 활성화 상태를 설정합니다.",
           "kind": "method"
         },
-        {
-          "name": "heading(_:)",
-          "signature": "func heading(String?) -> TextField",
-          "summary": "텍스트 필드 위에 표시할 제목을 설정합니다.",
-          "kind": "method"
-        },
         {
           "name": "icon(_:)",
           "signature": "func icon(Icon?) -> TextField",
@@ -2541,12 +2546,6 @@
           "summary": "텍스트 필드에 입력된 텍스트가 없을 때 표시할 플레이스홀더를 설정합니다.",
           "kind": "method"
         },
-        {
-          "name": "requiredBadge(_:)",
-          "signature": "func requiredBadge(Bool) -> TextField",
-          "summary": "제목 옆에 필수 입력을 나타내는 뱃지를 표시할지 설정합니다.",
-          "kind": "method"
-        },
         {
           "name": "size(_:)",
           "signature": "func size(Size) -> TextField",