From 4519bc7bf3f08d18c584a8a8d97961b46275b7c8 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 17:41:43 +0800
Subject: [PATCH 1/9] feat(stepper): add Stepper and supporting API stubs

---
 ...llowsWindowActivationEventsResponder.swift |   16 +-
 .../View/Control/Stepper/Stepper.swift        | 1334 +++++++++++++++++
 .../View/TextField/TextField.swift            |   35 +
 3 files changed, 1383 insertions(+), 2 deletions(-)
 create mode 100644 Sources/OpenSwiftUI/View/Control/Stepper/Stepper.swift
 create mode 100644 Sources/OpenSwiftUI/View/TextField/TextField.swift

diff --git a/Sources/OpenSwiftUI/Event/Responder/AllowsWindowActivationEventsResponder.swift b/Sources/OpenSwiftUI/Event/Responder/AllowsWindowActivationEventsResponder.swift
index 0eef282da..f74c56208 100644
--- a/Sources/OpenSwiftUI/Event/Responder/AllowsWindowActivationEventsResponder.swift
+++ b/Sources/OpenSwiftUI/Event/Responder/AllowsWindowActivationEventsResponder.swift
@@ -6,10 +6,22 @@
 //  Status: WIP
 //  ID: 302179F1EB9AE99B83C6A183C0B4143E (?)
 
-#if os(macOS)
 @_spi(ForOpenSwiftUIOnly)
-import OpenSwiftUICore
+public import OpenSwiftUICore
+
+// MARK: - View + allowsWindowActivationEvents [TBA]
+
+@available(OpenSwiftUI_v6_0, *)
+@available(tvOS, unavailable)
+@available(watchOS, unavailable)
+extension View {
+    nonisolated public func allowsWindowActivationEvents(_ value: Bool? = true) -> some View {
+        _openSwiftUIUnimplementedWarning()
+        return self
+    }
+}
 
+#if os(macOS)
 // TODO: AllowsWindowActivationEventsResponder
 class AllowsWindowActivationEventsResponder: DefaultLayoutViewResponder {
     var value: Bool?
diff --git a/Sources/OpenSwiftUI/View/Control/Stepper/Stepper.swift b/Sources/OpenSwiftUI/View/Control/Stepper/Stepper.swift
new file mode 100644
index 000000000..de475d7e1
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/Stepper/Stepper.swift
@@ -0,0 +1,1334 @@
+//
+//  Stepper.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: FF6E896BA929580F70ACD453368504D0 (SwiftUI)
+
+public import Foundation
+@_spi(ForOpenSwiftUIOnly)
+public import OpenSwiftUICore
+
+// MARK: - Stepper
+
+/// A control that performs increment and decrement actions.
+///
+/// Use a stepper control when you want the user to have granular control while
+/// incrementing or decrementing a value. For example, you can use a stepper
+/// to:
+///
+///  * Change a value up or down by `1`.
+///  * Operate strictly over a prescribed range.
+///  * Step by specific amounts over a stepper's range of possible values.
+///
+/// The example below uses an array that holds a number of ``Color`` values,
+/// a local state variable, `value`, to set the control's background
+/// color, and title label. When the user clicks or taps the stepper's
+/// increment or decrement buttons, OpenSwiftUI executes the relevant
+/// closure that updates `value`, wrapping the `value` to prevent overflow.
+/// OpenSwiftUI then re-renders the view, updating the text and background
+/// color to match the current index:
+///
+///     struct StepperView: View {
+///         @State private var value = 0
+///         let colors: [Color] = [.orange, .red, .gray, .blue,
+///                                .green, .purple, .pink]
+///
+///         func incrementStep() {
+///             value += 1
+///             if value >= colors.count { value = 0 }
+///         }
+///
+///         func decrementStep() {
+///             value -= 1
+///             if value < 0 { value = colors.count - 1 }
+///         }
+///
+///         var body: some View {
+///             Stepper {
+///                 Text("Value: \(value) Color: \(colors[value].description)")
+///             } onIncrement: {
+///                 incrementStep()
+///             } onDecrement: {
+///                 decrementStep()
+///             }
+///             .padding(5)
+///             .background(colors[value])
+///         }
+///     }
+///
+/// ![A view displaying a stepper that uses a text view for stepper's title and that changes the background color of its view when incremented or decremented. The view selects the new background color from a predefined array of colors using the stepper's value as the index.](OpenSwiftUI-Stepper-increment-decrement-closures)
+///
+/// The following example shows a stepper that displays the effect of
+/// incrementing or decrementing a value with the step size of `step` with
+/// the bounds defined by `range`:
+///
+///     struct StepperView: View {
+///         @State private var value = 0
+///         let step = 5
+///         let range = 1...50
+///
+///         var body: some View {
+///             Stepper(
+///                 value: $value,
+///                 in: range,
+///                 step: step
+///             ) {
+///                 Text("Current: \(value) in \(range.description) " +
+///                      "stepping by \(step)")
+///             }
+///             .padding(10)
+///         }
+///     }
+///
+/// ![A view displaying a stepper with a step size of five, and a prescribed range of 1 though 50.](OpenSwiftUI-Stepper-value-step-range)
+@available(OpenSwiftUI_v1_0, *)
+@available(OpenSwiftUI_watchOS_v4_0, *)
+@available(tvOS, unavailable)
+public struct Stepper<Label>: View where Label: View {
+    var configuration: StepperStyleConfiguration
+
+    var label: Label
+
+    var accessibilityValue: AccessibilityBoundedNumber?
+
+    /// Creates a stepper instance that performs the closures you provide when
+    /// the user increments or decrements the stepper.
+    ///
+    /// Use this initializer to create a control with a custom title that
+    /// executes closures you provide when the user clicks or taps the
+    /// stepper's increment or decrement buttons.
+    ///
+    /// The example below uses an array that holds a number of ``Color`` values,
+    /// a local state variable, `value`, to set the control's background
+    /// color, and title label. When the user clicks or taps on the stepper's
+    /// increment or decrement buttons OpenSwiftUI executes the relevant
+    /// closure that updates `value`, wrapping the `value` to prevent overflow.
+    /// OpenSwiftUI then re-renders the view, updating the text and background
+    /// color to match the current index:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let colors: [Color] = [.orange, .red, .gray, .blue, .green,
+    ///                                .purple, .pink]
+    ///
+    ///         func incrementStep() {
+    ///             value += 1
+    ///             if value >= colors.count { value = 0 }
+    ///         }
+    ///
+    ///         func decrementStep() {
+    ///             value -= 1
+    ///             if value < 0 { value = colors.count - 1 }
+    ///         }
+    ///
+    ///         var body: some View {
+    ///             Stepper {
+    ///                 Text("Value: \(value) Color: \(colors[value].description)")
+    ///             } onIncrement: {
+    ///                 incrementStep()
+    ///             } onDecrement: {
+    ///                 decrementStep()
+    ///             }
+    ///             .padding(5)
+    ///             .background(colors[value])
+    ///         }
+    ///    }
+    ///
+    /// ![A view displaying a stepper that uses a text view for stepper's title
+    ///   and that changes the background color of its view when incremented or
+    ///   decremented. The view selects the new background color from a
+    ///    predefined array of colors using the stepper's value as the
+    ///   index.](OpenSwiftUI-Stepper-increment-decrement-closures)
+    ///
+    /// - Parameters:
+    ///     - label: A view describing the purpose of this stepper.
+    ///     - onIncrement: The closure to execute when the user clicks or taps
+    ///       the control's plus button.
+    ///     - onDecrement: The closure to execute when the user clicks or taps
+    ///       the control's minus button.
+    ///     - onEditingChanged: A closure called when editing begins and ends.
+    ///       For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    @_alwaysEmitIntoClient
+    public init(
+        @ViewBuilder label: () -> Label,
+        onIncrement: (() -> Void)?,
+        onDecrement: (() -> Void)?,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) {
+        self.init(
+            onIncrement: onIncrement,
+            onDecrement: onDecrement,
+            onEditingChanged: onEditingChanged,
+            label: label
+        )
+    }
+
+    @_spi(Private)
+    @available(iOS, unavailable)
+    @available(macOS, unavailable)
+    nonisolated public init<CurrentValueLabel>(
+        @ViewBuilder label: () -> Label,
+        @ViewBuilder currentValueLabel: () -> CurrentValueLabel,
+        onIncrement: (() -> Void)?,
+        onDecrement: (() -> Void)?,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where CurrentValueLabel: View {
+        self.init(
+            label: label(),
+            currentValueField: AnyView(currentValueLabel()),
+            onIncrement: onIncrement,
+            onDecrement: onDecrement,
+            onEditingChanged: onEditingChanged,
+            accessibilityValue: nil
+        )
+    }
+
+    nonisolated init(_ configuration: StepperStyleConfiguration) where Label == StepperStyleConfiguration.Label {
+        self.configuration = configuration
+        label = configuration.label
+        accessibilityValue = nil
+    }
+
+    nonisolated init(
+        label: Label,
+        currentValueField: AnyView?,
+        onIncrement: (() -> Void)?,
+        onDecrement: (() -> Void)?,
+        onEditingChanged: @escaping (Bool) -> Void,
+        accessibilityValue: AccessibilityBoundedNumber?
+    ) {
+        configuration = StepperStyleConfiguration(
+            currentValueField: currentValueField.map { .init(base: $0) },
+            onIncrement: onIncrement,
+            onDecrement: onDecrement,
+            onEditingChanged: onEditingChanged
+        )
+        self.label = label
+        self.accessibilityValue = accessibilityValue
+    }
+
+    nonisolated init<V>(
+        value: Binding<V>,
+        in bounds: ClosedRange<V>?,
+        step: V.Stride,
+        label: Label,
+        currentValueField: AnyView?,
+        onEditingChanged: @escaping (Bool) -> Void
+    ) where V: Strideable {
+        let onIncrement: (() -> Void)?
+        let onDecrement: (() -> Void)?
+        if let bounds {
+            let currentValue = value.wrappedValue
+            let distance = bounds.lowerBound.distance(to: bounds.upperBound)
+            if currentValue == bounds.upperBound {
+                onIncrement = nil
+            } else if distance > step, currentValue <= bounds.upperBound.advanced(by: -step) {
+                onIncrement = {
+                    value.wrappedValue = value.wrappedValue.clamped(to: bounds).advanced(by: step)
+                }
+            } else {
+                onIncrement = { value.wrappedValue = bounds.upperBound }
+            }
+            if currentValue == bounds.lowerBound {
+                onDecrement = nil
+            } else if distance > step, currentValue >= bounds.lowerBound.advanced(by: step) {
+                onDecrement = {
+                    value.wrappedValue = value.wrappedValue.clamped(to: bounds).advanced(by: -step)
+                }
+            } else {
+                onDecrement = { value.wrappedValue = bounds.lowerBound }
+            }
+        } else {
+            onIncrement = { value.wrappedValue = value.wrappedValue.advanced(by: step) }
+            onDecrement = { value.wrappedValue = value.wrappedValue.advanced(by: -step) }
+        }
+        self.init(
+            label: label,
+            currentValueField: currentValueField,
+            onIncrement: onIncrement,
+            onDecrement: onDecrement,
+            onEditingChanged: onEditingChanged,
+            accessibilityValue: AccessibilityBoundedNumber(for: value.wrappedValue, in: bounds, by: step)
+        )
+    }
+
+    public var body: some View {
+        StepperBody(configuration: configuration)
+            .viewAlias(StepperStyleConfiguration.Label.self) { label }
+            .accessibilityConfiguration(
+                AccessibilityStepperModifier(configuration, value: accessibilityValue)
+            )
+            #if os(macOS)
+            .allowsWindowActivationEvents(true)
+            #endif
+    }
+}
+
+@available(*, unavailable)
+extension Stepper: Sendable {}
+
+// MARK: - Binding initializers
+
+@available(OpenSwiftUI_v1_0, *)
+@available(OpenSwiftUI_watchOS_v4_0, *)
+@available(tvOS, unavailable)
+extension Stepper {
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value you provide.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a bound value by a specific amount each time the user
+    /// clicks or taps the stepper's increment or decrement buttons.
+    ///
+    /// In the example below, a stepper increments or decrements `value` by the
+    /// `step` value of 5 at each click or tap of the control's increment or
+    /// decrement button:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///         let step = 5
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     step: step) {
+    ///                 Text("Current value: \(value), step: \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements a value by
+    ///   a specified amount each time the user clicks or taps the stepper's
+    ///   increment or decrement buttons.](OpenSwiftUI-Stepper-value-step)
+    ///
+    /// - Parameters:
+    ///   - value: The ``Binding`` to a value that you provide.
+    ///   - step: The amount to increment or decrement `value` each time the
+    ///     user clicks or taps the stepper's increment or decrement buttons.
+    ///     Defaults to `1`.
+    ///   - label: A view describing the purpose of this stepper.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(tvOS, unavailable)
+    @_alwaysEmitIntoClient
+    nonisolated public init<V>(
+        value: Binding<V>,
+        step: V.Stride = 1,
+        @ViewBuilder label: () -> Label,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V: Strideable {
+        self.init(value: value, step: step, onEditingChanged: onEditingChanged, label: label)
+    }
+
+    @_spi(Private)
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(iOS, unavailable)
+    @available(macOS, unavailable)
+    @available(tvOS, unavailable)
+    nonisolated public init<V, C>(
+        value: Binding<V>,
+        step: V.Stride = 1,
+        @ViewBuilder label: () -> Label,
+        @ViewBuilder currentValueLabel: () -> C,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V: Strideable, C: View {
+        self.init(
+            value: value,
+            in: nil,
+            step: step,
+            label: label(),
+            currentValueField: AnyView(currentValueLabel()),
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value and within a range of values you provide.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a binding to value by the step size you provide within the given bounds.
+    /// By setting the bounds, you ensure that the value never goes below or
+    /// above the lowest or highest value, respectively.
+    ///
+    /// The example below shows a stepper that displays the effect of
+    /// incrementing or decrementing a value with the step size of `step`
+    /// with the bounds defined by `range`:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     in: range,
+    ///                     step: step) {
+    ///                 Text("Current: \(value) in \(range.description) " +
+    ///                      "stepping by \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper with a step size of five, and a
+    /// prescribed range of 1 though 50.](OpenSwiftUI-Stepper-value-step-range)
+    ///
+    /// - Parameters:
+    ///   - value: A ``Binding`` to a value that you provide.
+    ///   - bounds: A closed range that describes the upper and lower bounds
+    ///     permitted by the stepper.
+    ///   - step: The amount to increment or decrement the stepper when the
+    ///     user clicks or taps the stepper's increment or decrement buttons,
+    ///     respectively.
+    ///   - label: A view describing the purpose of this stepper.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(tvOS, unavailable)
+    @_alwaysEmitIntoClient
+    nonisolated public init<V>(
+        value: Binding<V>,
+        in bounds: ClosedRange<V>,
+        step: V.Stride = 1,
+        @ViewBuilder label: () -> Label,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V: Strideable {
+        self.init(value: value, in: bounds, step: step, onEditingChanged: onEditingChanged, label: label)
+    }
+
+    @_spi(Private)
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(iOS, unavailable)
+    @available(macOS, unavailable)
+    @available(tvOS, unavailable)
+    nonisolated public init<V, C>(
+        value: Binding<V>,
+        in bounds: ClosedRange<V>,
+        step: V.Stride = 1,
+        @ViewBuilder label: () -> Label,
+        @ViewBuilder currentValueLabel: () -> C,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V: Strideable, C: View {
+        self.init(
+            value: value,
+            in: bounds,
+            step: step,
+            label: label(),
+            currentValueField: AnyView(currentValueLabel()),
+            onEditingChanged: onEditingChanged
+        )
+    }
+}
+
+// MARK: - Text initializers
+
+@available(OpenSwiftUI_v1_0, *)
+@available(OpenSwiftUI_watchOS_v4_0, *)
+@available(tvOS, unavailable)
+extension Stepper where Label == Text {
+    /// Creates a stepper that uses a title key and executes the closures
+    /// you provide when the user clicks or taps the stepper's increment and
+    /// decrement buttons.
+    ///
+    /// Use this initializer to create a stepper with a custom title that
+    /// executes closures you provide when either of the stepper's increment
+    /// or decrement buttons are pressed. This version of ``Stepper`` doesn't
+    /// take a binding to a value, nor does it allow you to specify a range of
+    /// acceptable values, or a step value -- it simply calls the closures you
+    /// provide when the control's buttons are pressed.
+    ///
+    /// The example below uses an array that holds a number of ``Color`` values,
+    /// a local state variable, `value`, to set the control's background
+    /// color, and title label. When the user clicks or taps on the stepper's
+    /// increment or decrement buttons OpenSwiftUI executes the relevant
+    /// closure that updates `value`, wrapping the `value` to prevent overflow.
+    /// OpenSwiftUI then re-renders the view, updating the text and background
+    /// color to match the current index:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let colors: [Color] = [.orange, .red, .gray, .blue, .green,
+    ///                                .purple, .pink]
+    ///
+    ///         func incrementStep() {
+    ///             value += 1
+    ///             if value >= colors.count { value = 0 }
+    ///         }
+    ///
+    ///         func decrementStep() {
+    ///             value -= 1
+    ///             if value < 0 { value = colors.count - 1 }
+    ///         }
+    ///
+    ///         var body: some View {
+    ///             Stepper("Value: \(value) Color: \(colors[value].description)",
+    ///                      onIncrement: incrementStep,
+    ///                      onDecrement: decrementStep)
+    ///             .padding(5)
+    ///             .background(colors[value])
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that uses a title key for the stepper's
+    /// localized title and that changes the background color of its view
+    /// when incremented or decremented selecting a color from a predefined
+    /// array using the stepper value as the
+    /// index.](OpenSwiftUI-Stepper-increment-decrement-closures)
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - onIncrement: The closure to execute when the user clicks or taps the
+    ///       control's plus button.
+    ///     - onDecrement: The closure to execute when the user clicks or taps the
+    ///       control's minus button.
+    ///    - onEditingChanged: A closure that's called when editing begins and
+    ///      ends. For example, on iOS, the user may touch and hold the increment
+    ///      or decrement buttons on a `Stepper` which causes the execution
+    ///      of the `onEditingChanged` closure at the start and end of
+    ///      the gesture.
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(tvOS, unavailable)
+    nonisolated public init(
+        _ titleKey: LocalizedStringKey,
+        onIncrement: (() -> Void)?,
+        onDecrement: (() -> Void)?,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) {
+        self.init(onIncrement: onIncrement, onDecrement: onDecrement, onEditingChanged: onEditingChanged) {
+            Text(titleKey)
+        }
+    }
+
+    /// Creates a stepper using a title string and that executes closures
+    /// you provide when the user clicks or taps the stepper's increment or
+    /// decrement buttons.
+    ///
+    /// Use `Stepper(_:onIncrement:onDecrement:onEditingChanged:)` to create a
+    /// control with a custom title that executes closures you provide when
+    /// the user clicks or taps on the stepper's increment or decrement buttons.
+    ///
+    /// The example below uses an array that holds a number of ``Color`` values,
+    /// a local state variable, `value`, to set the control's background
+    /// color, and title label. When the user clicks or taps on the stepper's
+    /// increment or decrement buttons OpenSwiftUI executes the relevant
+    /// closure that updates `value`, wrapping the `value` to prevent overflow.
+    /// OpenSwiftUI then re-renders the view, updating the text and background
+    /// color to match the current index:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let title: String
+    ///         let colors: [Color] = [.orange, .red, .gray, .blue, .green,
+    ///                                .purple, .pink]
+    ///
+    ///         func incrementStep() {
+    ///             value += 1
+    ///             if value >= colors.count { value = 0 }
+    ///         }
+    ///
+    ///         func decrementStep() {
+    ///             value -= 1
+    ///             if value < 0 { value = colors.count - 1 }
+    ///         }
+    ///
+    ///         var body: some View {
+    ///             Stepper(title, onIncrement: incrementStep, onDecrement: decrementStep)
+    ///                 .padding(5)
+    ///                 .background(colors[value])
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that uses a string for the stepper's title
+    ///   and that changes the background color of its view when incremented or
+    ///   decremented selecting a color from a predefined array using the
+    ///   stepper's value as the
+    ///   index.](OpenSwiftUI-Stepper-increment-decrement-closures)
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - onIncrement: The closure to execute when the user clicks or taps the
+    ///       control's plus button.
+    ///     - onDecrement: The closure to execute when the user clicks or taps the
+    ///       control's minus button.
+    ///    - onEditingChanged: A closure that's called when editing begins and
+    ///      ends. For example, on iOS, the user may touch and hold the increment
+    ///      or decrement buttons on a `Stepper` which causes the execution
+    ///      of the `onEditingChanged` closure at the start and end of
+    ///      the gesture.
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(tvOS, unavailable)
+    @_disfavoredOverload
+    nonisolated public init<S>(
+        _ title: S,
+        onIncrement: (() -> Void)?,
+        onDecrement: (() -> Void)?,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S: StringProtocol {
+        self.init(onIncrement: onIncrement, onDecrement: onDecrement, onEditingChanged: onEditingChanged) {
+            Text(title)
+        }
+    }
+
+    /// Creates a stepper with a title key and configured to increment and
+    /// decrement a binding to a value and step amount you provide.
+    ///
+    /// Use `Stepper(_:value:step:onEditingChanged:)` to create a stepper with a
+    /// custom title that increments or decrements a binding to value by the
+    /// step size you specify.
+    ///
+    /// In the example below, the stepper increments or decrements the binding
+    /// value by `5` each time the user clicks or taps on the control's
+    /// increment or decrement buttons, respectively:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///         let step = 5
+    ///
+    ///         var body: some View {
+    ///             Stepper("Current value: \(value), step: \(step)",
+    ///                     value: $value,
+    ///                     step: step)
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements by 5 each
+    ///   time the user clicks or taps on the control's increment or decrement
+    ///   buttons, respectively.](OpenSwiftUI-Stepper-value-step)
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that you provide.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's plus or minus button,
+    ///       respectively.  Defaults to `1`.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the
+    ///       increment or decrement buttons on a `Stepper` which causes the
+    ///       execution of the `onEditingChanged` closure at the start and end
+    ///       of the gesture.
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(tvOS, unavailable)
+    nonisolated public init<V>(
+        _ titleKey: LocalizedStringKey,
+        value: Binding<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V: Strideable {
+        self.init(value: value, step: step, onEditingChanged: onEditingChanged) { Text(titleKey) }
+    }
+
+    /// Creates a stepper with a title and configured to increment and
+    /// decrement a binding to a value and step amount you provide.
+    ///
+    /// Use `Stepper(_:value:step:onEditingChanged:)` to create a stepper with a
+    /// custom title that increments or decrements a binding to value by the
+    /// step size you specify.
+    ///
+    /// In the example below, the stepper increments or decrements the binding
+    /// value by `5` each time one of the user clicks or taps the control's
+    /// increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///         let step = 5
+    ///         let title: String
+    ///
+    ///         var body: some View {
+    ///             Stepper(title, value: $value, step: step)
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements by 1 each
+    ///   time the control's buttons
+    ///   are pressed.](OpenSwiftUI-Stepper-value-step)
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - value: The ``Binding`` to a value that you provide.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the
+    ///       increment or decrement buttons on a `Stepper` which causes the
+    ///       execution of the `onEditingChanged` closure at the start and end
+    ///       of the gesture.
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(tvOS, unavailable)
+    @_disfavoredOverload
+    nonisolated public init<S, V>(
+        _ title: S,
+        value: Binding<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S: StringProtocol, V: Strideable {
+        self.init(value: value, step: step, onEditingChanged: onEditingChanged) { Text(title) }
+    }
+
+    /// Creates a stepper instance that increments and decrements a binding to
+    /// a value, by a step size and within a closed range that you provide.
+    ///
+    /// Use `Stepper(_:value:in:step:onEditingChanged:)` to create a stepper
+    /// that increments or decrements a value within a specific range of values
+    /// by a specific step size. In the example below, a stepper increments or
+    /// decrements a binding to value over a range of `1...50` by `5` at each
+    /// press of the stepper's increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         @State private var titleKey = "Stepper"
+    ///
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             VStack(spacing: 20) {
+    ///                 Text("Current Stepper Value: \(value)")
+    ///                 Stepper(titleKey, value: $value, in: range, step: step)
+    ///             }
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements within a
+    ///   specified range and step size.](OpenSwiftUI-Stepper-value-step-range)
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that your provide.
+    ///     - bounds: A closed range that describes the upper and lower bounds
+    ///       permitted by the stepper.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(tvOS, unavailable)
+    nonisolated public init<V>(
+        _ titleKey: LocalizedStringKey,
+        value: Binding<V>,
+        in bounds: ClosedRange<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V: Strideable {
+        self.init(value: value, in: bounds, step: step, onEditingChanged: onEditingChanged) { Text(titleKey) }
+    }
+
+    /// Creates a stepper instance that increments and decrements a binding to
+    /// a value, by a step size and within a closed range that you provide.
+    ///
+    /// Use `Stepper(_:value:in:step:onEditingChanged:)` to create a stepper
+    /// that increments or decrements a value within a specific range of values
+    /// by a specific step size. In the example below, a stepper increments or
+    /// decrements a binding to value over a range of `1...50` by `5` each time
+    /// the user clicks or taps the stepper's increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             Stepper("Current: \(value) in \(range.description) stepping by \(step)",
+    ///                     value: $value,
+    ///                     in: range,
+    ///                     step: step)
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements within a
+    ///   specified range and step size.](OpenSwiftUI-Stepper-value-step-range)
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that your provide.
+    ///     - bounds: A closed range that describes the upper and lower bounds
+    ///       permitted by the stepper.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    @available(OpenSwiftUI_watchOS_v4_0, *)
+    @available(tvOS, unavailable)
+    @_disfavoredOverload
+    nonisolated public init<S, V>(
+        _ title: S,
+        value: Binding<V>,
+        in bounds: ClosedRange<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S: StringProtocol, V: Strideable {
+        self.init(value: value, in: bounds, step: step, onEditingChanged: onEditingChanged) { Text(title) }
+    }
+}
+
+// MARK: - Format initializers
+
+@available(OpenSwiftUI_v4_0, *)
+@available(tvOS, unavailable)
+extension Stepper {
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value you provide, displaying its value with an
+    /// applied format style.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a bound value by a specific amount each time the user clicks or taps
+    /// the stepper's increment or decrement buttons, while displaying the
+    /// current value.
+    ///
+    /// In the example below, a stepper increments or decrements `value` by the
+    /// `step` value of 5 at each click or tap of the control's increment or
+    /// decrement button:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1.0
+    ///         let step = 5.0
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     step: step,
+    ///                     format: .number) {
+    ///                 Text("Current value: \(value), step: \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements a value by
+    ///   a specified amount each time the user clicks or taps the stepper's
+    ///   increment or decrement buttons.](OpenSwiftUI-Stepper-value-step)
+    ///
+    /// - Parameters:
+    ///   - value: The ``Binding`` to a value that you provide.
+    ///   - step: The amount to increment or decrement `value` each time the
+    ///     user clicks or taps the stepper's increment or decrement buttons.
+    ///     Defaults to `1`.
+    ///   - format: A format style of type `F` to use when converting between
+    ///     the string the user edits and the underlying value of type
+    ///     `F.FormatInput`. If `format` can't perform the conversion, the
+    ///     stepper leaves `value` unchanged. If the user stops editing the
+    ///     text in an invalid state, the stepper updates the text to the last
+    ///     known valid value.
+    ///   - label: A view describing the purpose of this stepper.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    nonisolated public init<F>(
+        value: Binding<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        @ViewBuilder label: () -> Label,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where F: ParseableFormatStyle, F.FormatInput: BinaryFloatingPoint, F.FormatOutput == String {
+        let currentValueField = TextField(value: value, format: format, label: label)
+            .labelsHidden()
+        self.init(
+            value: value, in: nil, step: step, label: label(),
+            currentValueField: AnyView(currentValueField), onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value and within a range of values you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a binding to value by the step size you provide within the given bounds.
+    /// By setting the bounds, you ensure that the value never goes below or
+    /// above the lowest or highest value, respectively.
+    ///
+    /// The example below shows a stepper that displays the effect of
+    /// incrementing or decrementing a value with the step size of `step`
+    /// with the bounds defined by `range`:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0.0
+    ///         let step = 5.0
+    ///         let range = 1.0...50.0
+    ///
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     in: range,
+    ///                     step: step,
+    ///                     format: .number) {
+    ///                 Text("Current: \(value) in \(range.description) " +
+    ///                      "stepping by \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper with a step size of five, and a
+    /// prescribed range of 1 though 50.](OpenSwiftUI-Stepper-value-step-range)
+    ///
+    /// - Parameters:
+    ///   - value: A ``Binding`` to a value that you provide.
+    ///   - bounds: A closed range that describes the upper and lower bounds
+    ///     permitted by the stepper.
+    ///   - step: The amount to increment or decrement the stepper when the
+    ///     user clicks or taps the stepper's increment or decrement buttons,
+    ///     respectively.
+    ///   - format: A format style of type `F` to use when converting between
+    ///     the string the user edits and the underlying value of type
+    ///     `F.FormatInput`. If `format` can't perform the conversion, the
+    ///     stepper leaves `value` unchanged. If the user stops editing the
+    ///     text in an invalid state, the stepper updates the text to the last
+    ///     known valid value.
+    ///   - label: A view describing the purpose of this stepper.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    nonisolated public init<F>(
+        value: Binding<F.FormatInput>,
+        in bounds: ClosedRange<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        @ViewBuilder label: () -> Label,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where F: ParseableFormatStyle, F.FormatInput: BinaryFloatingPoint, F.FormatOutput == String {
+        let currentValueField = TextField(value: value, format: format, label: label)
+            .labelsHidden()
+        self.init(
+            value: value, in: bounds, step: step, label: label(),
+            currentValueField: AnyView(currentValueField), onEditingChanged: onEditingChanged
+        )
+    }
+}
+
+@available(OpenSwiftUI_v4_0, *)
+@available(tvOS, unavailable)
+extension Stepper where Label == Text {
+    /// Creates a stepper with a title key and configured to increment and
+    /// decrement a binding to a value and step amount you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use `Stepper(_:value:step:onEditingChanged:)` to create a stepper with a
+    /// custom title that increments or decrements a binding to value by the
+    /// step size you specify, while displaying the current value.
+    ///
+    /// In the example below, the stepper increments or decrements the binding
+    /// value by `5` each time the user clicks or taps on the control's
+    /// increment or decrement buttons, respectively:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1.0
+    ///
+    ///         var body: some View {
+    ///             Stepper("Stepping by \(step)",
+    ///                 value: $value,
+    ///                 step: 5,
+    ///                 format: .number
+    ///             )
+    ///             .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements by 5 each
+    ///   time the user clicks or taps on the control's increment or decrement
+    ///   buttons, respectively.](OpenSwiftUI-Stepper-value-step)
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that you provide.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's plus or minus button,
+    ///       respectively.  Defaults to `1`.
+    ///     - format: A format style of type `F` to use when converting between
+    ///       the string the user edits and the underlying value of type
+    ///       `F.FormatInput`. If `format` can't perform the conversion, the
+    ///       stepper leaves `value` unchanged. If the user stops editing the
+    ///       text in an invalid state, the stepper updates the text to the last
+    ///       known valid value.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the
+    ///       increment or decrement buttons on a `Stepper` which causes the
+    ///       execution of the `onEditingChanged` closure at the start and end
+    ///       of the gesture.
+    nonisolated public init<F>(
+        _ titleKey: LocalizedStringKey,
+        value: Binding<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where F: ParseableFormatStyle, F.FormatInput: BinaryFloatingPoint, F.FormatOutput == String {
+        self.init(value: value, step: step, format: format, label: { Text(titleKey) }, onEditingChanged: onEditingChanged)
+    }
+
+    /// Creates a stepper with a title and configured to increment and
+    /// decrement a binding to a value and step amount you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use `Stepper(_:value:step:format:onEditingChanged:)` to create a stepper
+    /// with a custom title that increments or decrements a binding to value by
+    /// the step size you specify, while displaying the current value.
+    ///
+    /// In the example below, the stepper increments or decrements the binding
+    /// value by `5` each time one of the user clicks or taps the control's
+    /// increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         let title: String
+    ///         @State private var value = 1.0
+    ///
+    ///         var body: some View {
+    ///             Stepper(title, value: $value, step: 5, format: .number)
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - value: The ``Binding`` to a value that you provide.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - format: A format style of type `F` to use when converting between
+    ///       the string the user edits and the underlying value of type
+    ///       `F.FormatInput`. If `format` can't perform the conversion, the
+    ///       stepper leaves `value` unchanged. If the user stops editing the
+    ///       text in an invalid state, the stepper updates the text to the last
+    ///       known valid value.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the
+    ///       increment or decrement buttons on a `Stepper` which causes the
+    ///       execution of the `onEditingChanged` closure at the start and end
+    ///       of the gesture.
+    @_disfavoredOverload
+    nonisolated public init<S, F>(
+        _ title: S,
+        value: Binding<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S: StringProtocol, F: ParseableFormatStyle, F.FormatInput: BinaryFloatingPoint, F.FormatOutput == String {
+        self.init(value: value, step: step, format: format, label: { Text(title) }, onEditingChanged: onEditingChanged)
+    }
+
+    /// Creates a stepper instance that increments and decrements a binding to
+    /// a value, by a step size and within a closed range that you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use `Stepper(_:value:in:step:format:onEditingChanged:)` to create a
+    /// stepper that increments or decrements a value within a specific range
+    /// of values by a specific step size, while displaying the current value.
+    /// In the example below, a stepper increments or decrements a binding to
+    /// value over a range of `1...50` by `5` each time the user clicks or taps
+    /// the stepper's increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0.0
+    ///
+    ///         var body: some View {
+    ///             Stepper("Stepping by \(step) in \(range.description)",
+    ///                 value: $value,
+    ///                 in: 1...50,
+    ///                 step: 5,
+    ///                 format: .number
+    ///             )
+    ///             .padding()
+    ///         }
+    ///     }
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that your provide.
+    ///     - bounds: A closed range that describes the upper and lower bounds
+    ///       permitted by the stepper.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - format: A format style of type `F` to use when converting between
+    ///       the string the user edits and the underlying value of type
+    ///       `F.FormatInput`. If `format` can't perform the conversion, the
+    ///       stepper leaves `value` unchanged. If the user stops editing the
+    ///       text in an invalid state, the stepper updates the text to the last
+    ///       known valid value.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    nonisolated public init<F>(
+        _ titleKey: LocalizedStringKey,
+        value: Binding<F.FormatInput>,
+        in bounds: ClosedRange<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where F: ParseableFormatStyle, F.FormatInput: BinaryFloatingPoint, F.FormatOutput == String {
+        self.init(value: value, in: bounds, step: step, format: format, label: { Text(titleKey) }, onEditingChanged: onEditingChanged)
+    }
+
+    /// Creates a stepper instance that increments and decrements a binding to
+    /// a value, by a step size and within a closed range that you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use `Stepper(_:value:in:step:format:onEditingChanged:)` to create a
+    /// stepper that increments or decrements a value within a specific range
+    /// of values by a specific step size, while displaying the current value.
+    /// In the example below, a stepper increments or decrements a binding to
+    /// value over a range of `1...50` by `5` each time the user clicks or taps
+    /// the stepper's increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         let title: String
+    ///         @State private var value = 0.0
+    ///
+    ///         let step = 5.0
+    ///         let range = 1.0...50.0
+    ///
+    ///         var body: some View {
+    ///             Stepper(title,
+    ///                 value: $value,
+    ///                 in: 1...50,
+    ///                 step: 5,
+    ///                 format: .number
+    ///             )
+    ///             .padding()
+    ///         }
+    ///     }
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that your provide.
+    ///     - bounds: A closed range that describes the upper and lower bounds
+    ///       permitted by the stepper.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - format: A format style of type `F` to use when converting between
+    ///       the string the user edits and the underlying value of type
+    ///       `F.FormatInput`. If `format` can't perform the conversion, the
+    ///       stepper leaves `value` unchanged. If the user stops editing the
+    ///       text in an invalid state, the stepper updates the text to the last
+    ///       known valid value.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    @_disfavoredOverload
+    nonisolated public init<S, F>(
+        _ title: S,
+        value: Binding<F.FormatInput>,
+        in bounds: ClosedRange<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S: StringProtocol, F: ParseableFormatStyle, F.FormatInput: BinaryFloatingPoint, F.FormatOutput == String {
+        self.init(value: value, in: bounds, step: step, format: format, label: { Text(title) }, onEditingChanged: onEditingChanged)
+    }
+}
+
+// MARK: - Deprecated initializers
+
+@available(OpenSwiftUI_v1_0, *)
+@available(OpenSwiftUI_watchOS_v4_0, *)
+@available(tvOS, unavailable)
+extension Stepper {
+    /// Creates a stepper instance that performs the closures you provide when
+    /// the user increments or decrements the stepper.
+    ///
+    /// Use this initializer to create a control with a custom title that
+    /// executes closures you provide when the user clicks or taps the
+    /// stepper's increment or decrement buttons.
+    ///
+    /// The example below uses an array that holds a number of ``Color`` values,
+    /// a local state variable, `value`, to set the control's background
+    /// color, and title label. When the user clicks or taps on the stepper's
+    /// increment or decrement buttons OpenSwiftUI executes the relevant
+    /// closure that updates `value`, wrapping the `value` to prevent overflow.
+    /// OpenSwiftUI then re-renders the view, updating the text and background
+    /// color to match the current index:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let colors: [Color] = [.orange, .red, .gray, .blue, .green,
+    ///                                .purple, .pink]
+    ///
+    ///         func incrementStep() {
+    ///             value += 1
+    ///             if value >= colors.count { value = 0 }
+    ///         }
+    ///
+    ///         func decrementStep() {
+    ///             value -= 1
+    ///             if value < 0 { value = colors.count - 1 }
+    ///         }
+    ///
+    ///         var body: some View {
+    ///             Stepper(onIncrement: incrementStep,
+    ///                 onDecrement: decrementStep) {
+    ///                 Text("Value: \(value) Color: \(colors[value].description)")
+    ///             }
+    ///             .padding(5)
+    ///             .background(colors[value])
+    ///         }
+    ///    }
+    ///
+    /// ![A view displaying a stepper that uses a text view for stepper's title
+    ///   and that changes the background color of its view when incremented or
+    ///   decremented. The view selects the new background color from a
+    ///    predefined array of colors using the stepper's value as the
+    ///   index.](OpenSwiftUI-Stepper-increment-decrement-closures)
+    ///
+    /// - Parameters:
+    ///     - onIncrement: The closure to execute when the user clicks or taps
+    ///       the control's plus button.
+    ///     - onDecrement: The closure to execute when the user clicks or taps
+    ///       the control's minus button.
+    ///     - onEditingChanged: A closure called when editing begins and ends.
+    ///       For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    ///     - label: A view describing the purpose of this stepper.
+    @available(*, deprecated, renamed: "Stepper(label:onIncrement:onDecrement:onEditingChanged:)")
+    @_disfavoredOverload
+    nonisolated public init(
+        onIncrement: (() -> Void)?,
+        onDecrement: (() -> Void)?,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in },
+        @ViewBuilder label: () -> Label
+    ) {
+        self.init(
+            label: label(), currentValueField: nil,
+            onIncrement: onIncrement, onDecrement: onDecrement,
+            onEditingChanged: onEditingChanged, accessibilityValue: nil
+        )
+    }
+
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value you provide.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a bound value by a specific amount each time the user
+    /// clicks or taps the stepper's increment or decrement buttons.
+    ///
+    /// In the example below, a stepper increments or decrements `value` by the
+    /// `step` value of 5 at each click or tap of the control's increment or
+    /// decrement button:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///         let step = 5
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     step: step) {
+    ///                 Text("Current value: \(value), step: \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements a value by
+    ///   a specified amount each time the user clicks or taps the stepper's
+    ///   increment or decrement buttons.](OpenSwiftUI-Stepper-value-step)
+    ///
+    /// - Parameters:
+    ///   - value: The ``Binding`` to a value that you provide.
+    ///   - step: The amount to increment or decrement `value` each time the
+    ///     user clicks or taps the stepper's increment or decrement buttons.
+    ///     Defaults to `1`.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    ///   - label: A view describing the purpose of this stepper.
+    @available(*, deprecated, renamed: "Stepper(value:step:label:onEditingChanged:)")
+    @_disfavoredOverload
+    nonisolated public init<V>(
+        value: Binding<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in },
+        @ViewBuilder label: () -> Label
+    ) where V: Strideable {
+        self.init(value: value, in: nil, step: step, label: label(), currentValueField: nil, onEditingChanged: onEditingChanged)
+    }
+
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value and within a range of values you provide.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a binding to value by the step size you provide within the given bounds.
+    /// By setting the bounds, you ensure that the value never goes below or
+    /// above the lowest or highest value, respectively.
+    ///
+    /// The example below shows a stepper that displays the effect of
+    /// incrementing or decrementing a value with the step size of `step`
+    /// with the bounds defined by `range`:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     in: range,
+    ///                     step: step) {
+    ///                 Text("Current: \(value) in \(range.description) " +
+    ///                      "stepping by \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper with a step size of five, and a
+    /// prescribed range of 1 though 50.](OpenSwiftUI-Stepper-value-step-range)
+    ///
+    /// - Parameters:
+    ///   - value: A ``Binding`` to a value that you provide.
+    ///   - bounds: A closed range that describes the upper and lower bounds
+    ///     permitted by the stepper.
+    ///   - step: The amount to increment or decrement the stepper when the
+    ///     user clicks or taps the stepper's increment or decrement buttons,
+    ///     respectively.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    ///   - label: A view describing the purpose of this stepper.
+    @available(*, deprecated, renamed: "Stepper(value:in:step:label:onEditingChanged:)")
+    @_disfavoredOverload
+    nonisolated public init<V>(
+        value: Binding<V>,
+        in bounds: ClosedRange<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in },
+        @ViewBuilder label: () -> Label
+    ) where V: Strideable {
+        self.init(value: value, in: bounds, step: step, label: label(), currentValueField: nil, onEditingChanged: onEditingChanged)
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/TextField/TextField.swift b/Sources/OpenSwiftUI/View/TextField/TextField.swift
new file mode 100644
index 000000000..a785db7b7
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/TextField/TextField.swift
@@ -0,0 +1,35 @@
+//
+//  TextField.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Stub
+
+public import Foundation
+public import OpenSwiftUICore
+
+// MARK: - TextField [TBA]
+
+@available(OpenSwiftUI_v1_0, *)
+public struct TextField<Label>: View where Label: View {
+    public var body: some View {
+        _openSwiftUIUnimplementedFailure()
+    }
+}
+
+@available(*, unavailable)
+extension TextField: Sendable {}
+
+// MARK: - TextField + Format [TBA]
+
+extension TextField {
+    @available(OpenSwiftUI_v3_0, *)
+    nonisolated public init<F>(
+        value: Binding<F.FormatInput>,
+        format: F,
+        prompt: Text? = nil,
+        @ViewBuilder label: () -> Label
+    ) where F: ParseableFormatStyle, F.FormatOutput == String {
+        _openSwiftUIUnimplementedFailure()
+    }
+}

From 2106b5bb59c9114ef6a2b059313445c9d4214ac4 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 18:57:06 +0800
Subject: [PATCH 2/9] feat: add AccessibilityStepperModifier

---
 .../AccessibilityConfiguration.swift          | 34 ++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/Sources/OpenSwiftUI/Accessibility/AccessibilityConfiguration.swift b/Sources/OpenSwiftUI/Accessibility/AccessibilityConfiguration.swift
index 6730d2025..c1b633507 100644
--- a/Sources/OpenSwiftUI/Accessibility/AccessibilityConfiguration.swift
+++ b/Sources/OpenSwiftUI/Accessibility/AccessibilityConfiguration.swift
@@ -149,7 +149,39 @@ struct AccessibilityLabelModifier<Content: View>: AccessibilityConfigurationModi
     }
 }
 
-// TODO: AccessibilityStepperModifier
+// MARK: - AccessibilityStepperModifier
+
+struct AccessibilityStepperModifier<Content>: AccessibilityConfigurationModifier where Content: View {
+    var base: AccessibilityAdjustableModifier<Content, AccessibilityStepperValue>
+
+    init(_ configuration: StepperStyleConfiguration, value: AccessibilityBoundedNumber?) {
+        base = AccessibilityAdjustableModifier(configuration: .init(
+            value: value.map { AccessibilityStepperValue($0) },
+            continuous: false,
+            onIncrement: configuration.onIncrement,
+            onDecrement: configuration.onDecrement,
+            onSet: { number in
+                guard let value else {
+                    return
+                }
+                let delta = number.value.doubleValue - value.value.doubleValue
+                let count = Int(abs((delta / (value.step?.doubleValue ?? 1)).rounded()))
+                for _ in 0 ..< count {
+                    if delta > 0 {
+                        configuration.onIncrement?()
+                    } else {
+                        configuration.onDecrement?()
+                    }
+                }
+            },
+            onEditingChanged: configuration.onEditingChanged
+        ))
+    }
+
+    func body(content: Content) -> some View {
+        base.body(content: content)
+    }
+}
 
 // MARK: - AccessibilityAdjustableModifier
 

From 6d4c12342bf91d130d752551a30f795cf466b83e Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 18:58:37 +0800
Subject: [PATCH 3/9] feat: add StepperStyle

---
 .../View/Control/Stepper/StepperStyle.swift   | 86 +++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/Stepper/StepperStyle.swift

diff --git a/Sources/OpenSwiftUI/View/Control/Stepper/StepperStyle.swift b/Sources/OpenSwiftUI/View/Control/Stepper/StepperStyle.swift
new file mode 100644
index 000000000..b9e0eab73
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/Stepper/StepperStyle.swift
@@ -0,0 +1,86 @@
+//
+//  StepperStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+@_spi(ForOpenSwiftUIOnly)
+public import OpenSwiftUICore
+
+// MARK: - StepperStyle
+
+@_spi(UIFrameworks)
+@available(OpenSwiftUI_v4_0, *)
+@available(tvOS, unavailable)
+@preconcurrency
+@MainActor
+public protocol StepperStyle {
+    associatedtype Body: View
+
+    @ViewBuilder
+    func makeBody(configuration: Configuration) -> Body
+
+    typealias Configuration = StepperStyleConfiguration
+}
+
+// MARK: - StepperStyleConfiguration
+
+@_spi(UIFrameworks)
+@available(OpenSwiftUI_v4_0, *)
+@available(tvOS, unavailable)
+public struct StepperStyleConfiguration {
+    public struct Label: ViewAlias {
+        init() {
+            _openSwiftUIEmptyStub()
+        }
+    }
+
+    public var label: Label { Label() }
+
+    var currentValueField: CurrentValueField?
+
+    public let onIncrement: (() -> Void)?
+
+    public let onDecrement: (() -> Void)?
+
+    public let onEditingChanged: (Bool) -> Void
+
+    struct CurrentValueField: View {
+        var base: AnyView
+
+        var body: some View { base }
+    }
+}
+
+@_spi(UIFrameworks)
+@available(*, unavailable)
+extension StepperStyleConfiguration.Label: Sendable {}
+
+@_spi(UIFrameworks)
+@available(*, unavailable)
+extension StepperStyleConfiguration: Sendable {}
+
+// MARK: - StepperBody
+
+struct StepperBody: StyleableView {
+    var configuration: StepperStyleConfiguration
+
+    static var defaultStyleModifier: StepperStyleModifier<DefaultStepperStyle> {
+        StepperStyleModifier(style: DefaultStepperStyle())
+    }
+}
+
+// MARK: - StepperStyleModifier
+
+struct StepperStyleModifier<Style>: StyleModifier where Style: StepperStyle {
+    var style: Style
+
+    init(style: Style) {
+        self.style = style
+    }
+
+    func styleBody(configuration: StepperStyleConfiguration) -> Style.Body {
+        style.makeBody(configuration: configuration)
+    }
+}

From 719019e7b02510bd2ef3ee35d812212890a44a03 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 19:01:44 +0800
Subject: [PATCH 4/9] feat: add DefaultStepperStyle and MenuStepperStyle stub

---
 .../Control/Stepper/DefaultStepperStyle.swift | 30 +++++++++++++++++++
 .../Control/Stepper/MenuStepperStyle.swift    | 18 +++++++++++
 2 files changed, 48 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/Stepper/DefaultStepperStyle.swift
 create mode 100644 Sources/OpenSwiftUI/View/Control/Stepper/MenuStepperStyle.swift

diff --git a/Sources/OpenSwiftUI/View/Control/Stepper/DefaultStepperStyle.swift b/Sources/OpenSwiftUI/View/Control/Stepper/DefaultStepperStyle.swift
new file mode 100644
index 000000000..9d8ea753b
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/Stepper/DefaultStepperStyle.swift
@@ -0,0 +1,30 @@
+//
+//  DefaultStepperStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+import OpenSwiftUICore
+
+// MARK: - DefaultStepperStyle
+
+struct DefaultStepperStyle: StepperStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        #if canImport(Darwin)
+        Stepper(configuration)
+            .modifier(
+                StepperStyleModifier(style: MenuStepperStyle())
+                    .requiring(MenuStyleContext.self)
+            )
+            #if os(macOS)
+            .modifier(StepperStyleModifier(style: ArrowStepperStyle()))
+            #else
+            .modifier(StepperStyleModifier(style: SegmentedButtonStepperStyle()))
+            #endif
+        #else
+        _openSwiftUIPlatformUnimplementedWarning()
+        return EmptyView()
+        #endif
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Control/Stepper/MenuStepperStyle.swift b/Sources/OpenSwiftUI/View/Control/Stepper/MenuStepperStyle.swift
new file mode 100644
index 000000000..c53a282a7
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/Stepper/MenuStepperStyle.swift
@@ -0,0 +1,18 @@
+//
+//  MenuStepperStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Stub
+
+import OpenSwiftUICore
+
+// MARK: - MenuStepperStyle [FIXME]
+
+struct MenuStepperStyle: StepperStyle {
+    // TODO: ControlGroup, CompactMenuControlGroupStyle, and menuActionDismissBehavior.
+    func makeBody(configuration: Configuration) -> some View {
+        _openSwiftUIUnimplementedWarning()
+        return EmptyView()
+    }
+}

From c56e8678b47e20e6b88e10a3a890cd89ec1aebaa Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 20:02:01 +0800
Subject: [PATCH 5/9] feat: add SegmentedButtonStepperStyle

---
 .../Stepper/SegmentedButtonStepperStyle.swift | 84 +++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/Stepper/SegmentedButtonStepperStyle.swift

diff --git a/Sources/OpenSwiftUI/View/Control/Stepper/SegmentedButtonStepperStyle.swift b/Sources/OpenSwiftUI/View/Control/Stepper/SegmentedButtonStepperStyle.swift
new file mode 100644
index 000000000..5b98b0601
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/Stepper/SegmentedButtonStepperStyle.swift
@@ -0,0 +1,84 @@
+//
+//  SegmentedButtonStepperStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: F1E9485F33A623EEFA647AA5EC4AE094 (SwiftUI)
+
+#if os(iOS) || os(visionOS)
+import OpenSwiftUICore
+import UIKit
+
+// MARK: - SegmentedButtonStepperStyle
+
+struct SegmentedButtonStepperStyle: StepperStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        LabeledContent {
+            UIKitStepper(configuration: configuration)
+                .fixedSize()
+        } label: {
+            configuration.label
+        }
+        .listLabeledContentPrefersHorizontalLayout()
+        .accessibilityLabeledContent()
+    }
+}
+
+// MARK: - UIKitStepper
+
+private struct UIKitStepper: UIViewRepresentable {
+    var configuration: StepperStyleConfiguration
+
+    func makeUIView(context: Context) -> UIStepper {
+        let stepper = UIStepper()
+        stepper.addTarget(context.coordinator, action: #selector(Coordinator.valueChanged(_:)), for: .valueChanged)
+        stepper.addTarget(context.coordinator, action: #selector(Coordinator.editingBegan(_:)), for: .touchDown)
+        stepper.addTarget(context.coordinator, action: #selector(Coordinator.editingEnded(_:)), for: [.touchUpInside, .touchUpOutside, .touchCancel])
+        return stepper
+    }
+
+    func updateUIView(_ uiView: UIStepper, context: Context) {
+        uiView.value = 0
+        uiView.minimumValue = configuration.onDecrement == nil ? 0 : -2
+        uiView.maximumValue = configuration.onIncrement == nil ? 0 : 2
+        uiView.stepValue = 1
+        context.coordinator.configuration = configuration
+    }
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator(configuration: configuration)
+    }
+}
+
+// MARK: - Coordinator
+
+private class Coordinator: PlatformViewCoordinator {
+    var configuration: StepperStyleConfiguration
+
+    init(configuration: StepperStyleConfiguration) {
+        self.configuration = configuration
+        super.init()
+    }
+
+    @objc
+    func valueChanged(_ stepper: UIStepper) {
+        if stepper.value > 0, let onIncrement = configuration.onIncrement {
+            Update.dispatchImmediately(reason: nil) { onIncrement() }
+        } else if stepper.value < 0, let onDecrement = configuration.onDecrement {
+            Update.dispatchImmediately(reason: nil) { onDecrement() }
+        }
+        stepper.value = 0
+    }
+
+    @objc
+    func editingBegan(_ stepper: UIStepper) {
+        Update.dispatchImmediately(reason: nil) { configuration.onEditingChanged(true) }
+    }
+
+    @objc
+    func editingEnded(_ stepper: UIStepper) {
+        Update.dispatchImmediately(reason: nil) { configuration.onEditingChanged(false) }
+    }
+}
+#endif

From 91b0d4a241570cc669bb0371d08e0c8cf9714b9f Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 20:02:13 +0800
Subject: [PATCH 6/9] feat: add ArrowStepperStyle

---
 .../Control/Stepper/ArrowStepperStyle.swift   | 168 ++++++++++++++++++
 .../Stepper/SegmentedButtonStepperStyle.swift |  62 +++----
 2 files changed, 199 insertions(+), 31 deletions(-)
 create mode 100644 Sources/OpenSwiftUI/View/Control/Stepper/ArrowStepperStyle.swift

diff --git a/Sources/OpenSwiftUI/View/Control/Stepper/ArrowStepperStyle.swift b/Sources/OpenSwiftUI/View/Control/Stepper/ArrowStepperStyle.swift
new file mode 100644
index 000000000..c94fe5e5e
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/Stepper/ArrowStepperStyle.swift
@@ -0,0 +1,168 @@
+//
+//  ArrowStepperStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+//  ID: 7EDEE3BC9F04CB7860AD83774DB90346 (SwiftUI)
+
+#if os(macOS)
+import AppKit
+import OpenSwiftUICore
+
+// MARK: - StepperFieldWidthKey [TBA]
+
+struct StepperFieldWidthKey: EnvironmentKey {
+    static let defaultValue: CGFloat? = nil
+}
+
+extension EnvironmentValues {
+    var stepperFieldWidth: CGFloat? {
+        get { self[StepperFieldWidthKey.self] }
+        set { self[StepperFieldWidthKey.self] = newValue }
+    }
+}
+
+// MARK: - ArrowStepperStyle [TBA]
+
+struct ArrowStepperStyle: StepperStyle {
+    @Environment(\.controlSize) private var controlSize
+
+    @Environment(\.stepperFieldWidth) private var stepperFieldWidth
+
+    func makeBody(configuration: Configuration) -> some View {
+        let size: ControlSize
+        switch controlSize {
+        case .mini, .small: size = controlSize
+        default: size = .regular
+        }
+        // TODO: Resolve FormStepperWidgetDefinition insets from the appearance.
+        let insets = EdgeInsets()
+        let field = AccessibilityLabelModifier()
+            .body(content: configuration.currentValueField)
+            .frame(width: stepperFieldWidth ?? 50)
+        let stepper = AppKitStepper(configuration: configuration)
+            .controlSize(size)
+            .fixedSize()
+        return LabeledContent {
+            StaticIf(StyleContextAcceptsPredicate<GroupedFormStyleContext>.self) {
+                ZStack(alignment: .trailing) {
+                    field
+                    stepper.offset(x: -insets.trailing)
+                }
+            } else: {
+                HStack(alignment: .center, spacing: 3) {
+                    field
+                    stepper
+                }
+            }
+        } label: {
+            configuration.label
+        }
+    }
+}
+
+// MARK: - AppKitStepper [TBA]
+
+private struct AppKitStepper: NSViewRepresentable {
+    var configuration: StepperStyleConfiguration
+
+    @Environment(\.allowsWindowActivationEvents) private var acceptsFirstMouse
+
+    func makeNSView(context: Context) -> EditTrackingStepper {
+        let stepper = EditTrackingStepper()
+        stepper.target = context.coordinator
+        stepper.action = #selector(Coordinator.valueChanged(_:))
+        return stepper
+    }
+
+    func updateNSView(_ nsView: EditTrackingStepper, context: Context) {
+        nsView.intValue = 0
+        nsView.maxValue = configuration.onIncrement == nil ? 0 : 2
+        nsView.minValue = configuration.onDecrement == nil ? 0 : -2
+        nsView.increment = 1
+        nsView.valueWraps = false
+        nsView.onEditingChanged = configuration.onEditingChanged
+        context.coordinator.configuration = configuration
+        nsView.customAcceptsFirstMouse = acceptsFirstMouse
+    }
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator(configuration: configuration)
+    }
+}
+
+// MARK: - Coordinator [TBA]
+
+private final class Coordinator: PlatformViewCoordinator {
+    var configuration: StepperStyleConfiguration
+
+    init(configuration: StepperStyleConfiguration) {
+        self.configuration = configuration
+        super.init()
+    }
+
+    @objc
+    func valueChanged(_ stepper: NSStepper) {
+        if stepper.intValue > 0 {
+            Update.dispatchImmediately(reason: nil) { configuration.onIncrement?() }
+        } else if stepper.intValue < 0 {
+            Update.dispatchImmediately(reason: nil) { configuration.onDecrement?() }
+        }
+        stepper.intValue = 0
+    }
+}
+
+// MARK: - EditTrackingStepper [TBA]
+
+private final class EditTrackingStepper: NSStepper, AcceptsFirstMouseCustomizing {
+    var onEditingChanged: ((Bool) -> Void)?
+
+    var customAcceptsFirstMouse: Bool?
+
+    override class var cellClass: AnyClass? {
+        get { EditTrackingStepperCell.self }
+        set { _openSwiftUIEmptyStub() }
+    }
+
+    override func performClick(_ sender: Any?) {
+        let onEditingChanged = onEditingChanged
+        onEditingChanged?(true)
+        super.performClick(sender)
+        onEditingChanged?(false)
+    }
+
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
+        if ResponderBasedHitTesting.isEnabled {
+            customAcceptsFirstMouse ?? super.acceptsFirstMouse(for: event)
+        } else {
+            effectiveAcceptsFirstMouse ?? super.acceptsFirstMouse(for: event)
+        }
+    }
+}
+
+// MARK: - EditTrackingStepperCell [TBA]
+
+private final class EditTrackingStepperCell: NSStepperCell {
+    override func startTracking(at startPoint: NSPoint, in controlView: NSView) -> Bool {
+        let tracking = super.startTracking(at: startPoint, in: controlView)
+        if tracking {
+            (self.controlView as? EditTrackingStepper)?.onEditingChanged?(true)
+        }
+        return tracking
+    }
+
+    override func continueTracking(last lastPoint: NSPoint, current currentPoint: NSPoint, in controlView: NSView) -> Bool {
+        let tracking = super.continueTracking(last: lastPoint, current: currentPoint, in: controlView)
+        if !tracking {
+            (self.controlView as? EditTrackingStepper)?.onEditingChanged?(false)
+        }
+        return tracking
+    }
+
+    override func stopTracking(last lastPoint: NSPoint, current stopPoint: NSPoint, in controlView: NSView, mouseIsUp flag: Bool) {
+        super.stopTracking(last: lastPoint, current: stopPoint, in: controlView, mouseIsUp: flag)
+        (self.controlView as? EditTrackingStepper)?.onEditingChanged?(false)
+    }
+}
+#endif
diff --git a/Sources/OpenSwiftUI/View/Control/Stepper/SegmentedButtonStepperStyle.swift b/Sources/OpenSwiftUI/View/Control/Stepper/SegmentedButtonStepperStyle.swift
index 5b98b0601..5d2e8093f 100644
--- a/Sources/OpenSwiftUI/View/Control/Stepper/SegmentedButtonStepperStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/Stepper/SegmentedButtonStepperStyle.swift
@@ -10,6 +10,37 @@
 import OpenSwiftUICore
 import UIKit
 
+// MARK: - Coordinator
+
+private class Coordinator: PlatformViewCoordinator {
+    var configuration: StepperStyleConfiguration
+
+    init(configuration: StepperStyleConfiguration) {
+        self.configuration = configuration
+        super.init()
+    }
+
+    @objc
+    func valueChanged(_ stepper: UIStepper) {
+        if stepper.value > 0, let onIncrement = configuration.onIncrement {
+            Update.dispatchImmediately(reason: nil) { onIncrement() }
+        } else if stepper.value < 0, let onDecrement = configuration.onDecrement {
+            Update.dispatchImmediately(reason: nil) { onDecrement() }
+        }
+        stepper.value = 0
+    }
+
+    @objc
+    func editingBegan(_ stepper: UIStepper) {
+        Update.dispatchImmediately(reason: nil) { configuration.onEditingChanged(true) }
+    }
+
+    @objc
+    func editingEnded(_ stepper: UIStepper) {
+        Update.dispatchImmediately(reason: nil) { configuration.onEditingChanged(false) }
+    }
+}
+
 // MARK: - SegmentedButtonStepperStyle
 
 struct SegmentedButtonStepperStyle: StepperStyle {
@@ -50,35 +81,4 @@ private struct UIKitStepper: UIViewRepresentable {
         Coordinator(configuration: configuration)
     }
 }
-
-// MARK: - Coordinator
-
-private class Coordinator: PlatformViewCoordinator {
-    var configuration: StepperStyleConfiguration
-
-    init(configuration: StepperStyleConfiguration) {
-        self.configuration = configuration
-        super.init()
-    }
-
-    @objc
-    func valueChanged(_ stepper: UIStepper) {
-        if stepper.value > 0, let onIncrement = configuration.onIncrement {
-            Update.dispatchImmediately(reason: nil) { onIncrement() }
-        } else if stepper.value < 0, let onDecrement = configuration.onDecrement {
-            Update.dispatchImmediately(reason: nil) { onDecrement() }
-        }
-        stepper.value = 0
-    }
-
-    @objc
-    func editingBegan(_ stepper: UIStepper) {
-        Update.dispatchImmediately(reason: nil) { configuration.onEditingChanged(true) }
-    }
-
-    @objc
-    func editingEnded(_ stepper: UIStepper) {
-        Update.dispatchImmediately(reason: nil) { configuration.onEditingChanged(false) }
-    }
-}
 #endif

From 770d6b0d2f601d8858aa386860cb9ec886d97a90 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 20:44:46 +0800
Subject: [PATCH 7/9] fix: align ArrowStepperStyle behavior

---
 .../Control/Stepper/ArrowStepperStyle.swift   | 195 +++++++++++-------
 1 file changed, 117 insertions(+), 78 deletions(-)

diff --git a/Sources/OpenSwiftUI/View/Control/Stepper/ArrowStepperStyle.swift b/Sources/OpenSwiftUI/View/Control/Stepper/ArrowStepperStyle.swift
index c94fe5e5e..0202e2e17 100644
--- a/Sources/OpenSwiftUI/View/Control/Stepper/ArrowStepperStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/Stepper/ArrowStepperStyle.swift
@@ -3,14 +3,102 @@
 //  OpenSwiftUI
 //
 //  Audited for 6.5.4
-//  Status: WIP
+//  Status: Complete (Blocked by CoreUIAppearanceWidget)
 //  ID: 7EDEE3BC9F04CB7860AD83774DB90346 (SwiftUI)
 
 #if os(macOS)
 import AppKit
 import OpenSwiftUICore
 
-// MARK: - StepperFieldWidthKey [TBA]
+// MARK: - Coordinator
+
+private class Coordinator: PlatformViewCoordinator {
+    var configuration: StepperStyleConfiguration
+
+    init(configuration: StepperStyleConfiguration) {
+        self.configuration = configuration
+        super.init()
+    }
+
+    @objc
+    func valueChanged(_ stepper: NSStepper) {
+        if stepper.intValue > 0 {
+            Update.dispatchImmediately(reason: nil) { configuration.onIncrement?() }
+        } else if stepper.intValue < 0 {
+            Update.dispatchImmediately(reason: nil) { configuration.onDecrement?() }
+        }
+        stepper.intValue = 0
+    }
+}
+
+// MARK: - EditTrackingStepper
+
+private class EditTrackingStepper: NSStepper, AcceptsFirstMouseCustomizing {
+    var onEditingChanged: ((Bool) -> Void)?
+
+    var customAcceptsFirstMouse: Bool?
+
+    override class var cellClass: AnyClass? {
+        get { EditTrackingStepperCell.self }
+        set { _openSwiftUIEmptyStub() }
+    }
+
+    override func performClick(_ sender: Any?) {
+        let onEditingChanged = onEditingChanged
+        onEditingChanged?(true)
+        super.performClick(sender)
+        onEditingChanged?(false)
+    }
+
+    override func moveUp(_ sender: Any?) {
+        let onEditingChanged = onEditingChanged
+        onEditingChanged?(true)
+        super.moveUp(sender)
+        onEditingChanged?(false)
+    }
+
+    override func moveDown(_ sender: Any?) {
+        let onEditingChanged = onEditingChanged
+        onEditingChanged?(true)
+        super.moveDown(sender)
+        onEditingChanged?(false)
+    }
+
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
+        if ResponderBasedHitTesting.isEnabled {
+            customAcceptsFirstMouse ?? super.acceptsFirstMouse(for: event)
+        } else {
+            effectiveAcceptsFirstMouse ?? super.acceptsFirstMouse(for: event)
+        }
+    }
+}
+
+// MARK: - EditTrackingStepperCell
+
+private class EditTrackingStepperCell: NSStepperCell {
+    override func startTracking(at startPoint: NSPoint, in controlView: NSView) -> Bool {
+        let tracking = super.startTracking(at: startPoint, in: controlView)
+        if tracking {
+            (self.controlView as? EditTrackingStepper)?.onEditingChanged?(true)
+        }
+        return tracking
+    }
+
+    override func continueTracking(last lastPoint: NSPoint, current currentPoint: NSPoint, in controlView: NSView) -> Bool {
+        let tracking = super.continueTracking(last: lastPoint, current: currentPoint, in: controlView)
+        if !tracking {
+            (self.controlView as? EditTrackingStepper)?.onEditingChanged?(false)
+        }
+        return tracking
+    }
+
+    override func stopTracking(last lastPoint: NSPoint, current stopPoint: NSPoint, in controlView: NSView, mouseIsUp flag: Bool) {
+        super.stopTracking(last: lastPoint, current: stopPoint, in: controlView, mouseIsUp: flag)
+        (self.controlView as? EditTrackingStepper)?.onEditingChanged?(false)
+    }
+}
+
+// MARK: - StepperFieldWidthKey
 
 struct StepperFieldWidthKey: EnvironmentKey {
     static let defaultValue: CGFloat? = nil
@@ -23,7 +111,7 @@ extension EnvironmentValues {
     }
 }
 
-// MARK: - ArrowStepperStyle [TBA]
+// MARK: - ArrowStepperStyle [FIXME]
 
 struct ArrowStepperStyle: StepperStyle {
     @Environment(\.controlSize) private var controlSize
@@ -59,10 +147,35 @@ struct ArrowStepperStyle: StepperStyle {
         } label: {
             configuration.label
         }
+        .accessibilityLabeledContent()
+    }
+}
+
+// MARK: - FormStepperWidgetDefinition [FIXME]
+
+// TODO: Add AppearanceWidgetDefinition and CoreUIAppearanceWidget with a layer renderer.
+private struct FormStepperWidgetDefinition: Hashable {
+    var controlSize: ControlSize
+
+    var coreUIOptions: [String: Any] {
+        let size: String
+        switch controlSize {
+        case .mini: size = "mini"
+        case .small: size = "small"
+        case .regular: size = "regular"
+        case .large, .extraLarge: size = "large"
+        }
+        // Use the CoreUI constant values until the headers expose their symbols.
+        return [
+            "widget": "littlearrows",
+            "size": size,
+            "state": "normal",
+            "kCUIVariantKey": "kCUIVariantForm",
+        ]
     }
 }
 
-// MARK: - AppKitStepper [TBA]
+// MARK: - AppKitStepper
 
 private struct AppKitStepper: NSViewRepresentable {
     var configuration: StepperStyleConfiguration
@@ -91,78 +204,4 @@ private struct AppKitStepper: NSViewRepresentable {
         Coordinator(configuration: configuration)
     }
 }
-
-// MARK: - Coordinator [TBA]
-
-private final class Coordinator: PlatformViewCoordinator {
-    var configuration: StepperStyleConfiguration
-
-    init(configuration: StepperStyleConfiguration) {
-        self.configuration = configuration
-        super.init()
-    }
-
-    @objc
-    func valueChanged(_ stepper: NSStepper) {
-        if stepper.intValue > 0 {
-            Update.dispatchImmediately(reason: nil) { configuration.onIncrement?() }
-        } else if stepper.intValue < 0 {
-            Update.dispatchImmediately(reason: nil) { configuration.onDecrement?() }
-        }
-        stepper.intValue = 0
-    }
-}
-
-// MARK: - EditTrackingStepper [TBA]
-
-private final class EditTrackingStepper: NSStepper, AcceptsFirstMouseCustomizing {
-    var onEditingChanged: ((Bool) -> Void)?
-
-    var customAcceptsFirstMouse: Bool?
-
-    override class var cellClass: AnyClass? {
-        get { EditTrackingStepperCell.self }
-        set { _openSwiftUIEmptyStub() }
-    }
-
-    override func performClick(_ sender: Any?) {
-        let onEditingChanged = onEditingChanged
-        onEditingChanged?(true)
-        super.performClick(sender)
-        onEditingChanged?(false)
-    }
-
-    override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
-        if ResponderBasedHitTesting.isEnabled {
-            customAcceptsFirstMouse ?? super.acceptsFirstMouse(for: event)
-        } else {
-            effectiveAcceptsFirstMouse ?? super.acceptsFirstMouse(for: event)
-        }
-    }
-}
-
-// MARK: - EditTrackingStepperCell [TBA]
-
-private final class EditTrackingStepperCell: NSStepperCell {
-    override func startTracking(at startPoint: NSPoint, in controlView: NSView) -> Bool {
-        let tracking = super.startTracking(at: startPoint, in: controlView)
-        if tracking {
-            (self.controlView as? EditTrackingStepper)?.onEditingChanged?(true)
-        }
-        return tracking
-    }
-
-    override func continueTracking(last lastPoint: NSPoint, current currentPoint: NSPoint, in controlView: NSView) -> Bool {
-        let tracking = super.continueTracking(last: lastPoint, current: currentPoint, in: controlView)
-        if !tracking {
-            (self.controlView as? EditTrackingStepper)?.onEditingChanged?(false)
-        }
-        return tracking
-    }
-
-    override func stopTracking(last lastPoint: NSPoint, current stopPoint: NSPoint, in controlView: NSView, mouseIsUp flag: Bool) {
-        super.stopTracking(last: lastPoint, current: stopPoint, in: controlView, mouseIsUp: flag)
-        (self.controlView as? EditTrackingStepper)?.onEditingChanged?(false)
-    }
-}
 #endif

From d4d5ccea169040b30535f05ad0534d6022974c60 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 20:53:18 +0800
Subject: [PATCH 8/9] test: add StepperTests

---
 .../View/Control/Stepper/StepperTests.swift   | 173 ++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 Tests/OpenSwiftUITests/View/Control/Stepper/StepperTests.swift

diff --git a/Tests/OpenSwiftUITests/View/Control/Stepper/StepperTests.swift b/Tests/OpenSwiftUITests/View/Control/Stepper/StepperTests.swift
new file mode 100644
index 000000000..001e9cc67
--- /dev/null
+++ b/Tests/OpenSwiftUITests/View/Control/Stepper/StepperTests.swift
@@ -0,0 +1,173 @@
+//
+//  StepperTests.swift
+//  OpenSwiftUITests
+
+import Foundation
+@_spi(UIFrameworks) @testable import OpenSwiftUI
+import OpenSwiftUITestsSupport
+import Testing
+
+@MainActor
+@Suite(.tags(.aigc))
+struct StepperTests {
+    @Test(arguments: [
+        (0, 3, true, false, 3, 0),
+        (4, 3, true, true, 7, 1),
+        (9, 3, true, true, 10, 6),
+        (1, 3, true, true, 4, 0),
+        (10, 3, false, true, 10, 7),
+        (5, 10, true, true, 10, 0),
+        (5, 20, true, true, 10, 0),
+        (5, 0, true, true, 5, 5),
+        (5, -2, true, true, 3, 7),
+        (-2, 3, true, true, 3, 0),
+        (12, 3, true, true, 10, 7),
+    ] as [(Int, Int, Bool, Bool, Int, Int)])
+    func boundedActions(
+        initial: Int,
+        step: Int,
+        canIncrement: Bool,
+        canDecrement: Bool,
+        incremented: Int,
+        decremented: Int
+    ) {
+        var value = initial
+        let binding = Binding(get: { value }, set: { value = $0 })
+        let stepper = Stepper(value: binding, in: 0 ... 10, step: step) {
+            EmptyView()
+        }
+        #expect((stepper.configuration.onIncrement != nil) == canIncrement)
+        #expect((stepper.configuration.onDecrement != nil) == canDecrement)
+        #expect(value == initial)
+        stepper.configuration.onIncrement?()
+        #expect(value == incremented)
+        value = initial
+        stepper.configuration.onDecrement?()
+        #expect(value == decremented)
+    }
+
+    @Test
+    func singleValueRangeDisablesBothActions() {
+        let stepper = Stepper(value: .constant(4), in: 4 ... 4) { EmptyView() }
+        #expect(stepper.configuration.onIncrement == nil)
+        #expect(stepper.configuration.onDecrement == nil)
+    }
+
+    @Test
+    func actionsReadTheCurrentBinding() {
+        var value = 2
+        let binding = Binding(get: { value }, set: { value = $0 })
+        let stepper = Stepper(value: binding, step: 3) { EmptyView() }
+        value = 10
+        stepper.configuration.onIncrement?()
+        #expect(value == 13)
+        stepper.configuration.onDecrement?()
+        #expect(value == 10)
+    }
+
+    @Test
+    func boundedActionsClampTheCurrentBindingBeforeAdvancing() {
+        var value = 4
+        let binding = Binding(get: { value }, set: { value = $0 })
+        let stepper = Stepper(value: binding, in: 0 ... 10, step: 3) { EmptyView() }
+        value = -2
+        stepper.configuration.onIncrement?()
+        #expect(value == 3)
+        value = 12
+        stepper.configuration.onDecrement?()
+        #expect(value == 7)
+    }
+
+    @Test
+    func supportsNonNumericStrideableValues() {
+        var value = Date(timeIntervalSinceReferenceDate: 10)
+        let binding = Binding(get: { value }, set: { value = $0 })
+        let stepper = Stepper(value: binding, step: 2.5) { EmptyView() }
+        stepper.configuration.onIncrement?()
+        #expect(value.timeIntervalSinceReferenceDate == 12.5)
+        stepper.configuration.onDecrement?()
+        #expect(value.timeIntervalSinceReferenceDate == 10)
+    }
+
+    @Test
+    func customActionsPreserveEditingCallbacks() {
+        var events: [String] = []
+        let stepper = Stepper {
+            EmptyView()
+        } onIncrement: {
+            events.append("increment")
+        } onDecrement: {
+            events.append("decrement")
+        } onEditingChanged: {
+            events.append($0 ? "begin" : "end")
+        }
+        stepper.configuration.onEditingChanged(true)
+        stepper.configuration.onIncrement?()
+        stepper.configuration.onDecrement?()
+        stepper.configuration.onEditingChanged(false)
+        #expect(events == ["begin", "increment", "decrement", "end"])
+        #expect(stepper.accessibilityValue == nil)
+    }
+
+    @Test
+    func accessibilityValueUsesTheClampedValueAndStep() throws {
+        let stepper = Stepper(value: .constant(12), in: 0 ... 10, step: 3) {
+            EmptyView()
+        }
+        let value = try #require(stepper.accessibilityValue)
+        #expect(value.value.intValue == 10)
+        #expect(value.minValue?.intValue == 0)
+        #expect(value.maxValue?.intValue == 10)
+        #expect(value.step?.intValue == 3)
+    }
+
+    @Test(arguments: [(5.0, 6), (3.0, 4), (2.0, 2), (1.0, 0), (-1.0, -2)])
+    func accessibilitySetValueRoundsToWholeSteps(target: Double, expected: Int) {
+        var value = 2
+        let binding = Binding(get: { value }, set: { value = $0 })
+        let stepper = Stepper(value: binding, step: 2) { EmptyView() }
+        let modifier = AccessibilityStepperModifier<EmptyView>(
+            stepper.configuration,
+            value: stepper.accessibilityValue
+        )
+        #expect(!modifier.base.configuration.continuous)
+        modifier.base.configuration.onSet(AccessibilityNumber(NSNumber(value: target)))
+        #expect(value == expected)
+    }
+
+    @Test
+    func accessibilitySetValueUsesTheEndpointAction() {
+        var value = 9
+        let binding = Binding(get: { value }, set: { value = $0 })
+        let stepper = Stepper(value: binding, in: 0 ... 10, step: 3) { EmptyView() }
+        let modifier = AccessibilityStepperModifier<EmptyView>(
+            stepper.configuration,
+            value: stepper.accessibilityValue
+        )
+        modifier.base.configuration.onSet(20)
+        #expect(value == 10)
+    }
+
+    @Test
+    func accessibilityWithoutANumericValueDoesNotSet() {
+        var increments = 0
+        let stepper = Stepper(label: { EmptyView() }, onIncrement: { increments += 1 }, onDecrement: nil)
+        let modifier = AccessibilityStepperModifier<EmptyView>(stepper.configuration, value: nil)
+        modifier.base.configuration.onSet(5)
+        #expect(increments == 0)
+        #expect(modifier.base.configuration.value == nil)
+    }
+
+    @Test
+    func titleOverloadsUseTheBinding() {
+        var value = 1
+        let binding = Binding(get: { value }, set: { value = $0 })
+        let localized = Stepper("Count", value: binding)
+        localized.configuration.onIncrement?()
+        #expect(value == 2)
+        let title = String("Count")
+        let verbatim = Stepper(title, value: binding, in: 0 ... 5, step: 2)
+        verbatim.configuration.onDecrement?()
+        #expect(value == 0)
+    }
+}

From 5abfbd11b8f9965e11d04dc4b00ae04f35de7489 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sun, 25 Oct 2026 21:16:36 +0800
Subject: [PATCH 9/9] test: add Stepper examples and UI snapshots

---
 Example/Shared/View/StepperExample.swift      | 79 +++++++++++++++++++
 .../View/StepperUITests.swift                 | 70 ++++++++++++++++
 2 files changed, 149 insertions(+)
 create mode 100644 Example/Shared/View/StepperExample.swift
 create mode 100644 Example/Tests/OpenSwiftUIUITests/View/StepperUITests.swift

diff --git a/Example/Shared/View/StepperExample.swift b/Example/Shared/View/StepperExample.swift
new file mode 100644
index 000000000..effbac9f0
--- /dev/null
+++ b/Example/Shared/View/StepperExample.swift
@@ -0,0 +1,79 @@
+//
+//  StepperExample.swift
+//  Shared
+
+#if OPENSWIFTUI
+import OpenSwiftUI
+#else
+import SwiftUI
+#endif
+
+struct StepperExample: View {
+    @State private var value: Int
+    @State private var isEditing = false
+
+    init(value: Int = 4) {
+        _value = State(initialValue: value)
+    }
+
+    var body: some View {
+        VStack(spacing: 16) {
+            Stepper(
+                "Count: \(value)",
+                value: $value,
+                in: 0...10,
+                step: 2,
+                onEditingChanged: { isEditing = $0 }
+            )
+            Text(isEditing ? "Editing" : "Ready")
+                .foregroundColor(isEditing ? .red : .blue)
+        }
+        .padding()
+    }
+}
+
+struct ActionStepperExample: View {
+    @State private var value = 0
+
+    var canIncrement = true
+    var canDecrement = true
+
+    var body: some View {
+        Stepper(
+            label: { Text("Count: \(value)") },
+            onIncrement: canIncrement ? { value += 1 } : nil,
+            onDecrement: canDecrement ? { value -= 1 } : nil
+        )
+        .padding()
+    }
+}
+
+struct FractionalStepperExample: View {
+    @State private var value = 1.25
+
+    var body: some View {
+        Stepper(value: $value, step: 0.25) {
+            Text("Value: \(value, specifier: "%.2f")")
+        }
+        .padding()
+    }
+}
+
+#Preview("Bounded") {
+    StepperExample()
+}
+
+#Preview("Custom actions") {
+    ActionStepperExample()
+}
+
+#Preview("Fractional steps") {
+    FractionalStepperExample()
+}
+
+#Preview("Hidden labels and disabled") {
+    VStack {
+        StepperExample().labelsHidden()
+        StepperExample().disabled(true)
+    }
+}
diff --git a/Example/Tests/OpenSwiftUIUITests/View/StepperUITests.swift b/Example/Tests/OpenSwiftUIUITests/View/StepperUITests.swift
new file mode 100644
index 000000000..f933448a6
--- /dev/null
+++ b/Example/Tests/OpenSwiftUIUITests/View/StepperUITests.swift
@@ -0,0 +1,70 @@
+//
+//  StepperUITests.swift
+//  OpenSwiftUIUITests
+
+import SnapshotTesting
+import Testing
+@testable import TestingHost
+
+@MainActor
+@Suite(.snapshots(record: .never, diffTool: diffTool))
+struct StepperUITests {
+    @Test(arguments: [0, 4, 10])
+    func boundedValues(value: Int) {
+        openSwiftUIAssertSnapshot(
+            of: StepperExample(value: value),
+            size: .init(width: 320, height: 120),
+            named: "\(value)"
+        )
+    }
+
+    @Test(arguments: [
+        (true, true),
+        (true, false),
+        (false, true),
+        (false, false),
+    ] as [(Bool, Bool)])
+    func optionalActions(canIncrement: Bool, canDecrement: Bool) {
+        openSwiftUIAssertSnapshot(
+            of: ActionStepperExample(
+                canIncrement: canIncrement,
+                canDecrement: canDecrement
+            ),
+            size: .init(width: 320, height: 100),
+            named: "increment-\(canIncrement)-decrement-\(canDecrement)"
+        )
+    }
+
+    @Test
+    func fractionalSteps() {
+        openSwiftUIAssertSnapshot(
+            of: FractionalStepperExample(),
+            size: .init(width: 320, height: 100)
+        )
+    }
+
+    @Test
+    func labelsHidden() {
+        openSwiftUIAssertSnapshot(
+            of: StepperExample().labelsHidden(),
+            size: .init(width: 320, height: 120)
+        )
+    }
+
+    @Test
+    func disabled() {
+        openSwiftUIAssertSnapshot(
+            of: StepperExample().disabled(true),
+            size: .init(width: 320, height: 120)
+        )
+    }
+
+    @Test(arguments: [.mini, .small, .regular, .large, .extraLarge] as [ControlSize])
+    func controlSizes(size: ControlSize) {
+        openSwiftUIAssertSnapshot(
+            of: StepperExample().controlSize(size),
+            size: .init(width: 320, height: 120),
+            named: "\(size)"
+        )
+    }
+}