From d45cedc05dacef7ad770067c568764fb3372bc27 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sat, 15 Aug 2026 19:20:11 +0800
Subject: [PATCH 01/25] Add ProgressViewStyle

---
 .../ProgressView/ProgressViewStyle.swift      | 178 ++++++++++++++++++
 1 file changed, 178 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/ProgressViewStyle.swift

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressViewStyle.swift
new file mode 100644
index 000000000..6b3fe75b0
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressViewStyle.swift
@@ -0,0 +1,178 @@
+//
+//  ProgressViewStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+
+@_spi(ForOpenSwiftUIOnly)
+public import OpenSwiftUICore
+
+// MARK: - ProgressViewStyle
+
+/// A type that applies standard interaction behavior to all progress views
+/// within a view hierarchy.
+///
+/// To configure the current progress view style for a view hierarchy, use the
+/// ``View/progressViewStyle(_:)`` modifier.
+@available(OpenSwiftUI_v2_0, *)
+@preconcurrency
+@MainActor
+public protocol ProgressViewStyle {
+
+    /// A view representing the body of a progress view.
+    associatedtype Body: View
+
+    /// Creates a view representing the body of a progress view.
+    ///
+    /// - Parameter configuration: The properties of the progress view being
+    ///   created.
+    ///
+    /// The view hierarchy calls this method for each progress view where this
+    /// style is the current progress view style.
+    ///
+    /// - Parameter configuration: The properties of the progress view, such as
+    ///  its preferred progress type.
+    @ViewBuilder
+    func makeBody(configuration: Configuration) -> Body
+
+    /// A type alias for the properties of a progress view instance.
+    typealias Configuration = ProgressViewStyleConfiguration
+}
+
+// MARK: - ProgressViewStyleConfiguration
+
+/// The properties of a progress view instance.
+@available(OpenSwiftUI_v2_0, *)
+public struct ProgressViewStyleConfiguration {
+
+    /// A type-erased label describing the task represented by the progress
+    /// view.
+    public struct Label: ViewAlias {
+        init() {
+            _openSwiftUIEmptyStub()
+        }
+    }
+
+    /// A type-erased label that describes the current value of a progress view.
+    public struct CurrentValueLabel: ViewAlias {
+        init() {
+            _openSwiftUIEmptyStub()
+        }
+    }
+
+    let value: ProgressViewValue
+
+    /// The completed fraction of the task represented by the progress view,
+    /// from `0.0` (not yet started) to `1.0` (fully complete), or `nil` if the
+    /// progress is indeterminate or relative to a date interval.
+    public let fractionCompleted: Double?
+
+    var alwaysIndeterminate: Bool
+
+    /// A view that describes the task represented by the progress view.
+    ///
+    /// If `nil`, then the task is self-evident from the surrounding context,
+    /// and the style does not need to provide any additional description.
+    ///
+    /// If the progress view is defined using a `Progress` instance, then this
+    /// label is equivalent to its `localizedDescription`.
+    public var label: Label?
+
+    /// A view that describes the current value of a progress view.
+    ///
+    /// If `nil`, then the value of the progress view is either self-evident
+    /// from the surrounding context or unknown, and the style does not need to
+    /// provide any additional description.
+    ///
+    /// If the progress view is defined using a `Progress` instance, then this
+    /// label is equivalent to its `localizedAdditionalDescription`.
+    public var currentValueLabel: CurrentValueLabel?
+
+    // TBA
+    init(
+        value: ProgressViewValue,
+        label: Label?,
+        currentValueLabel: CurrentValueLabel?
+    ) {
+        self.value = value
+        switch value {
+        case let .absolute(fractionCompleted, alwaysIndeterminate):
+            self.fractionCompleted = fractionCompleted
+            self.alwaysIndeterminate = alwaysIndeterminate
+        case .dateRelative:
+            fractionCompleted = nil
+            alwaysIndeterminate = false
+        }
+        self.label = label
+        self.currentValueLabel = currentValueLabel
+    }
+}
+
+@available(*, unavailable)
+extension ProgressViewStyleConfiguration: Sendable {}
+
+@available(*, unavailable)
+extension ProgressViewStyleConfiguration.CurrentValueLabel: Sendable {}
+
+@available(*, unavailable)
+extension ProgressViewStyleConfiguration.Label: Sendable {}
+
+// MARK: - ProgressViewStyleModifier
+
+struct ProgressViewStyleModifier<Style>: StyleModifier where Style: ProgressViewStyle {
+    var style: Style
+
+    init(style: Style) {
+        self.style = style
+    }
+
+    func styleBody(configuration: ProgressViewStyleConfiguration) -> Style.Body {
+        style.makeBody(configuration: configuration)
+    }
+}
+
+// MARK: - ResolvedProgressViewStyle
+
+struct ResolvedProgressViewStyle: StyleableView {
+    var configuration: ProgressViewStyleConfiguration
+
+    static var defaultStyleModifier: ProgressViewStyleModifier<DefaultProgressViewStyle> {
+        ProgressViewStyleModifier(style: DefaultProgressViewStyle())
+    }
+
+//    typealias Body = ModifiedContent<
+//        ModifiedContent<
+//            ProgressView<
+//                ProgressViewStyleConfiguration.Label,
+//                ProgressViewStyleConfiguration.CurrentValueLabel
+//            >,
+//            (IgnoreViewRespondersModifier in _EE68159C4F54001FA5A3813EBA5DD945)
+//        >,
+//        AccessibilityAttachmentModifier
+//    >
+
+    var body: some View {
+        // TODO: Apply the responder and accessibility modifiers when their
+        // corresponding OpenSwiftUI implementations are available.
+        ProgressView(configuration)
+    }
+}
+
+// MARK: - View + ProgressViewStyle
+
+@available(OpenSwiftUI_v2_0, *)
+extension View {
+    /// Sets the style for progress views in this view.
+    ///
+    /// For example, the following code creates a progress view that uses the
+    /// "circular" style:
+    ///
+    ///     ProgressView()
+    ///         .progressViewStyle(.circular)
+    ///
+    /// - Parameter style: The progress view style to use for this view.
+    nonisolated public func progressViewStyle<S>(_ style: S) -> some View where S: ProgressViewStyle {
+        modifier(ProgressViewStyleModifier(style: style))
+    }
+}

From f7f15d5fb46aabd3ab08831ce2059d4c070bff50 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sat, 15 Aug 2026 19:21:02 +0800
Subject: [PATCH 02/25] Add DefaultProgressViewStyle

---
 .../DefaultProgressViewStyle.swift            | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/DefaultProgressViewStyle.swift

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/DefaultProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/DefaultProgressViewStyle.swift
new file mode 100644
index 000000000..b8c05d9d8
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/DefaultProgressViewStyle.swift
@@ -0,0 +1,69 @@
+//
+//  DefaultProgressViewStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+public import OpenSwiftUICore
+
+// MARK: - ProgressViewStyle + Automatic
+
+@available(OpenSwiftUI_v2_0, *)
+extension ProgressViewStyle where Self == DefaultProgressViewStyle {
+
+    /// The default progress view style in the current context of the view being
+    /// styled.
+    ///
+    /// The default style represents the recommended style based on the original
+    /// initialization parameters of the progress view, and the progress view's
+    /// context within the view hierarchy.
+    @_alwaysEmitIntoClient
+    @MainActor
+    @preconcurrency
+    public static var automatic: DefaultProgressViewStyle {
+        .init()
+    }
+}
+
+// MARK: - DefaultProgressViewStyle
+
+/// The default progress view style in the current context of the view being
+/// styled.
+///
+/// Use ``ProgressViewStyle/automatic`` to construct this style.
+@available(OpenSwiftUI_v2_0, *)
+public struct DefaultProgressViewStyle: ProgressViewStyle {
+    /// Creates a default progress view style.
+    public init() {
+        _openSwiftUIEmptyStub()
+    }
+
+    // TBA
+    public func makeBody(configuration: Configuration) -> some View {
+//        Group {
+//            if configuration.alwaysIndeterminate {
+//                ProgressView(configuration)
+//                    .progressViewStyle(CircularProgressViewStyle())
+//            } else {
+//                switch configuration.value {
+//                case .dateRelative:
+//                    ProgressView(configuration)
+//                        .progressViewStyle(LinearProgressViewStyle())
+//                case .absolute:
+//                    if configuration.fractionCompleted != nil {
+//                        ProgressView(configuration)
+//                            .progressViewStyle(LinearProgressViewStyle())
+//                    } else {
+//                        ProgressView(configuration)
+//                            .progressViewStyle(CircularProgressViewStyle())
+//                    }
+//                }
+//            }
+//        }
+        _openSwiftUIUnimplementedFailure()
+    }
+}
+
+@available(*, unavailable)
+extension DefaultProgressViewStyle: Sendable {}

From 7a472132679c8f93572199ad7e1ac26f389742c0 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sat, 15 Aug 2026 19:21:49 +0800
Subject: [PATCH 03/25] Add ProgressView

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

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
new file mode 100644
index 000000000..9cf3940ae
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
@@ -0,0 +1,158 @@
+//
+//  ProgressView.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+//  ID: 936A47782A7E2FBE97D58CDBAEB02770 (SwiftUI)
+
+#if OPENSWIFTUI_OPENCOMBINE
+import OpenCombine
+import OpenCombineFoundation
+#else
+import Combine
+#endif
+import OpenAttributeGraphShims
+public import Foundation
+@_spi(ForOpenSwiftUIOnly)
+public import OpenSwiftUICore
+
+// MARK: - ProgressView
+
+/// A view that shows the progress toward completion of a task.
+///
+/// Use a progress view to show that a task is incomplete but advancing toward
+/// completion. A progress view can show both determinate (percentage complete)
+/// and indeterminate (progressing or not) types of progress.
+///
+/// Create a determinate progress view by initializing a `ProgressView` with
+/// a binding to a numeric value that indicates the progress, and a `total`
+/// value that represents completion of the task. By default, the progress is
+/// `0.0` and the total is `1.0`.
+///
+/// The example below uses the state property `progress` to show progress in
+/// a determinate `ProgressView`. The progress view uses its default total of
+/// `1.0`, and because `progress` starts with an initial value of `0.5`,
+/// the progress view begins half-complete. A "More" button below the progress
+/// view allows people to increment the progress in increments of five percent:
+///
+///     struct LinearProgressDemoView: View {
+///         @State private var progress = 0.5
+///
+///         var body: some View {
+///             VStack {
+///                 ProgressView(value: progress)
+///                 Button("More") { progress += 0.05 }
+///             }
+///         }
+///     }
+///
+/// ![A horizontal bar that represents progress, with a More button
+/// placed underneath. The progress bar is at 50 percent from the leading
+/// edge.](ProgressView-1-macOS)
+///
+/// To create an indeterminate progress view, use an initializer that doesn't
+/// take a progress value:
+///
+///     var body: some View {
+///         ProgressView()
+///     }
+///
+/// ![An indeterminate progress view, presented as a spinning set of gray lines
+/// emanating from the center of a circle, with opacity varying from fully
+/// opaque to transparent. An animation rotates which line is most opaque,
+/// creating the spinning effect.](ProgressView-2-macOS)
+///
+/// You can also create a progress view that covers a closed range of
+/// [Date](https://developer.apple.com/documentation/foundation/date) values. As
+/// long as the current date is within the range, the progress view
+/// automatically updates, filling or depleting the progress view as it nears
+/// the end of the range. The following example shows a five-minute timer whose
+/// start time is that of the progress view's initialization:
+///
+///     struct DateRelativeProgressDemoView: View {
+///         let workoutDateRange = Date()...Date().addingTimeInterval(5*60)
+///
+///         var body: some View {
+///              ProgressView(timerInterval: workoutDateRange) {
+///                  Text("Workout")
+///              }
+///         }
+///     }
+///
+/// ![A horizontal progress view that shows a bar partially filled with as it
+/// counts a five-minute duration.](ProgressView-3-macOS)
+///
+/// ### Styling progress views
+///
+/// You can customize the appearance and interaction of progress views by
+/// creating styles that conform to the ``ProgressViewStyle`` protocol. To set a
+/// specific style for all progress view instances within a view, use the
+/// ``View/progressViewStyle(_:)`` modifier. In the following example, a custom
+/// style adds a rounded pink border to all progress views within the enclosing
+/// ``VStack``:
+///
+///     struct BorderedProgressViews: View {
+///         var body: some View {
+///             VStack {
+///                 ProgressView(value: 0.25) { Text("25% progress") }
+///                 ProgressView(value: 0.75) { Text("75% progress") }
+///             }
+///             .progressViewStyle(PinkBorderedProgressViewStyle())
+///         }
+///     }
+///
+///     struct PinkBorderedProgressViewStyle: ProgressViewStyle {
+///         func makeBody(configuration: Configuration) -> some View {
+///             ProgressView(configuration)
+///                 .padding(4)
+///                 .border(.pink, width: 3)
+///                 .cornerRadius(4)
+///         }
+///     }
+///
+/// ![Two horizontal progress views, one at 25 percent complete and the other at 75 percent,
+/// each rendered with a rounded pink border.](ProgressView-4-macOS)
+///
+/// OpenSwiftUI provides two built-in progress view styles,
+/// ``ProgressViewStyle/linear`` and ``ProgressViewStyle/circular``, as well as
+/// an automatic style that defaults to the most appropriate style in the
+/// current context. The following example shows a circular progress view that
+/// starts at 60 percent completed.
+///
+///     struct CircularProgressDemoView: View {
+///         @State private var progress = 0.6
+///
+///         var body: some View {
+///             VStack {
+///                 ProgressView(value: progress)
+///                     .progressViewStyle(.circular)
+///             }
+///         }
+///     }
+///
+/// ![A ring shape, filled to 60 percent completion with a blue
+/// tint.](ProgressView-5-macOS)
+///
+/// On platforms other than macOS, the circular style may appear as an
+/// indeterminate indicator instead.
+@available(OpenSwiftUI_v2_0, *)
+public struct ProgressView<Label, CurrentValueLabel>: View where Label: View, CurrentValueLabel: View {
+    var base: Base
+
+    public var body: some View {
+        switch base {
+        case let .custom(custom): custom
+        case let .observing(observing): observing
+        }
+    }
+
+    enum Base {
+        case custom(CustomProgressView<Label, CurrentValueLabel>)
+        case observing(FoundationProgressView)
+    }
+}
+
+@available(*, unavailable)
+extension ProgressView: Sendable {}
+

From 40891ba904e533f4a8d9a794182a6bdbcd66b2ea Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sat, 15 Aug 2026 19:22:24 +0800
Subject: [PATCH 04/25] Add ProgressViewValue

---
 .../Control/ProgressView/ProgressView.swift   | 94 +++++++++++++++++++
 1 file changed, 94 insertions(+)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
index 9cf3940ae..123963391 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
@@ -156,3 +156,97 @@ public struct ProgressView<Label, CurrentValueLabel>: View where Label: View, Cu
 @available(*, unavailable)
 extension ProgressView: Sendable {}
 
+
+// MARK: - ProgressViewValue
+
+enum ProgressViewValue: Codable {
+    case absolute(fractionCompleted: Double?, alwaysIndeterminate: Bool)
+    case dateRelative(interval: ClosedRange<Date>, countdown: Bool)
+
+    private enum CodingKeys: CodingKey {
+        case absolute
+        case dateRelative
+    }
+
+    private enum AbsoluteCodingKeys: CodingKey {
+        case fractionCompleted
+        case alwaysIndeterminate
+    }
+
+    private enum DateRelativeCodingKeys: CodingKey {
+        case interval
+        case countdown
+    }
+
+    func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case let .absolute(fractionCompleted, alwaysIndeterminate):
+            var nestedContainer = container.nestedContainer(
+                keyedBy: AbsoluteCodingKeys.self,
+                forKey: .absolute
+            )
+            try nestedContainer.encodeIfPresent(
+                fractionCompleted,
+                forKey: .fractionCompleted
+            )
+            try nestedContainer.encode(
+                alwaysIndeterminate,
+                forKey: .alwaysIndeterminate
+            )
+        case let .dateRelative(interval, countdown):
+            var nestedContainer = container.nestedContainer(
+                keyedBy: DateRelativeCodingKeys.self,
+                forKey: .dateRelative
+            )
+            try nestedContainer.encode(interval, forKey: .interval)
+            try nestedContainer.encode(countdown, forKey: .countdown)
+        }
+    }
+
+    init(from decoder: any Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let keys = container.allKeys
+        guard keys.count == 1 else {
+            throw DecodingError.typeMismatch(
+                Self.self,
+                DecodingError.Context(
+                    codingPath: container.codingPath,
+                    debugDescription: "Invalid number of keys found, expected one."
+                )
+            )
+        }
+        switch keys[0] {
+        case .absolute:
+            let nestedContainer = try container.nestedContainer(
+                keyedBy: AbsoluteCodingKeys.self,
+                forKey: .absolute
+            )
+            self = try .absolute(
+                fractionCompleted: nestedContainer.decodeIfPresent(
+                    Double.self,
+                    forKey: .fractionCompleted
+                ),
+                alwaysIndeterminate: nestedContainer.decode(
+                    Bool.self,
+                    forKey: .alwaysIndeterminate
+                )
+            )
+        case .dateRelative:
+            let nestedContainer = try container.nestedContainer(
+                keyedBy: DateRelativeCodingKeys.self,
+                forKey: .dateRelative
+            )
+            self = try .dateRelative(
+                interval: nestedContainer.decode(
+                    ClosedRange<Date>.self,
+                    forKey: .interval
+                ),
+                countdown: nestedContainer.decode(
+                    Bool.self,
+                    forKey: .countdown
+                )
+            )
+        }
+    }
+}

From e10115afa878aafc7bf147ab3d93ff679752224d Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Sat, 15 Aug 2026 19:35:16 +0800
Subject: [PATCH 05/25] Add CustomProgressView

---
 .../Control/ProgressView/ProgressView.swift   | 142 ++++++++++++++++++
 1 file changed, 142 insertions(+)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
index 123963391..2acf98618 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
@@ -250,3 +250,145 @@ enum ProgressViewValue: Codable {
         }
     }
 }
+
+// MARK: - CustomProgressView
+
+@MainActor
+@preconcurrency
+struct CustomProgressView<Label, CurrentValueLabel>: PrimitiveView, UnaryView, View where Label: View, CurrentValueLabel: View {
+    var value: ProgressViewValue
+    var label: Label?
+    var currentValueLabel: CurrentValueLabel?
+
+    init(
+        interval: ClosedRange<Date>,
+        countdown: Bool,
+        label: Label?,
+        currentValueLabel: CurrentValueLabel?
+    ) {
+        self.value = .dateRelative(interval: interval, countdown: countdown)
+        self.label = label
+        self.currentValueLabel = currentValueLabel
+    }
+
+    init(
+        fractionCompleted: Double?,
+        alwaysIndeterminate: Bool,
+        label: Label?,
+        currentValueLabel: CurrentValueLabel?
+    ) {
+        self.value = .absolute(
+            fractionCompleted: fractionCompleted,
+            alwaysIndeterminate: alwaysIndeterminate
+        )
+        self.label = label
+        self.currentValueLabel = currentValueLabel
+    }
+
+    nonisolated static func _makeView(
+        view: _GraphValue<Self>,
+        inputs: _ViewInputs
+    ) -> _ViewOutputs {
+        let baseValue = view.value[offset: { .of(&$0.value) }]
+        let label = view.value[offset: { .of(&$0.label) }]
+        let currentValueLabel = view.value[offset: { .of(&$0.currentValueLabel) }]
+        let child = Child(
+            baseValue: baseValue,
+            label: label,
+            currentValueLabel: currentValueLabel
+        )
+        var outputs = Child.Value._makeView(
+            view: _GraphValue(child),
+            inputs: inputs
+        )
+        if inputs.preferences.contains(WidgetAuxiliaryViewMetadata.Key.self) {
+            outputs.preferences.platformItemList = nil
+            outputs.preferences.makePreferenceWriter(
+                inputs: inputs.preferences,
+                key: WidgetAuxiliaryViewMetadata.Key.self,
+                value: Attribute(
+                    WidgetMetadataWriter(
+                        baseValue: baseValue,
+                        labelPref: Attribute(
+                            LazyWidgetAuxiliaryMetadataTextImage(
+                                flags: _AttributeType.Flags.self,
+                                content: label,
+                                inputs: inputs
+                            )
+                        ),
+                        currentValueLabelPref: Attribute(
+                            LazyWidgetAuxiliaryMetadataTextImage(
+                                flags: _AttributeType.Flags.self,
+                                content: currentValueLabel,
+                                inputs: inputs
+                            )
+                        ),
+                        environment: inputs.environment
+                    )
+                )
+            )
+        }
+        return outputs
+    }
+
+    private struct WidgetMetadataWriter: Rule {
+        @Attribute var baseValue: ProgressViewValue
+        @Attribute var labelPref: WidgetAuxiliaryTextImagePreference?
+        @Attribute var currentValueLabelPref: WidgetAuxiliaryTextImagePreference?
+        @Attribute var environment: EnvironmentValues
+
+        var value: WidgetAuxiliaryViewMetadata? {
+            let kind: WidgetAuxiliaryViewMetadata.Progress.Kind = switch baseValue {
+            case let .absolute(fractionCompleted, alwaysIndeterminate): .absolute(fractionCompleted, alwaysIndeterminate)
+            case let .dateRelative(interval, countdown): .date(interval, countdown)
+            }
+            let label = WidgetAuxiliaryViewMetadata(
+                item: labelPref?.list?.mergedContentItem,
+                url: nil,
+                accessibility: nil,
+                child: nil
+            )
+            let currentValueLabel = WidgetAuxiliaryViewMetadata(
+                item: currentValueLabelPref?.list?.mergedContentItem,
+                url: nil,
+                accessibility: nil,
+                child: nil
+            )
+            return WidgetAuxiliaryViewMetadata(
+                progress: .init(
+                    kind: kind,
+                    label: label,
+                    currentValueLabel: currentValueLabel,
+                    tint: WidgetAuxiliaryViewMetadata.tint(from: environment)
+                )
+            )
+        }
+    }
+
+    private struct Child: Rule {
+        @Attribute var baseValue: ProgressViewValue
+        @Attribute var label: Label?
+        @Attribute var currentValueLabel: CurrentValueLabel?
+
+        var value: some View {
+            ResolvedProgressView(value: baseValue)
+                .optionalViewAlias(ProgressViewStyleConfiguration.CurrentValueLabel.self) {
+                    currentValueLabel
+                }
+                .optionalViewAlias(ProgressViewStyleConfiguration.Label.self) {
+                    label
+                }
+        }
+    }
+}
+
+// FIXME
+struct FoundationProgressView: View {
+    var body: some View { EmptyView() }
+}
+
+// FIXME
+struct ResolvedProgressView: View {
+    var value: ProgressViewValue
+    var body: some View { EmptyView() }
+}

From ddca2d4f4be21b32c2a75cdd5389f74039a92e0a Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Mon, 24 Aug 2026 00:38:44 +0800
Subject: [PATCH 06/25] Update ProgressView.init

---
 .../Control/ProgressView/ProgressView.swift   | 257 ++++++++++++++++++
 1 file changed, 257 insertions(+)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
index 2acf98618..560c77c82 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
@@ -156,7 +156,264 @@ public struct ProgressView<Label, CurrentValueLabel>: View where Label: View, Cu
 @available(*, unavailable)
 extension ProgressView: Sendable {}
 
+// MARK: - Indeterminate Initializers
 
+@available(OpenSwiftUI_v2_0, *)
+extension ProgressView where CurrentValueLabel == EmptyView {
+    /// Creates a progress view for showing indeterminate progress, without a
+    /// label.
+    nonisolated public init() where Label == EmptyView {
+        self.init(label: nil)
+    }
+
+    /// Creates a progress view for showing indeterminate progress that displays
+    /// a custom label.
+    ///
+    /// - Parameters:
+    ///     - label: A view builder that creates a view that describes the task
+    ///       in progress.
+    nonisolated public init(@ViewBuilder label: () -> Label) {
+        self.init(label: label())
+    }
+
+    /// Creates a progress view for showing indeterminate progress that
+    /// generates its label from a localized string.
+    ///
+    /// This initializer creates a ``Text`` view on your behalf, and treats the
+    /// localized key similar to ``Text/init(_:tableName:bundle:comment:)``. See
+    /// ``Text`` for more information about localizing strings. To initialize an
+    /// indeterminate progress view with a string variable, use the
+    /// corresponding initializer that takes a `StringProtocol` instance.
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the progress view's localized title that
+    ///       describes the task in progress.
+    nonisolated public init(_ titleKey: LocalizedStringKey) where Label == Text {
+        self.init(label: Text(titleKey))
+    }
+
+    /// Creates a progress view for showing indeterminate progress that
+    /// generates its label from a string.
+    ///
+    /// - Parameters:
+    ///     - title: A string that describes the task in progress.
+    ///
+    /// This initializer creates a ``Text`` view on your behalf, and treats the
+    /// title similar to ``Text/init(verbatim:)``. See ``Text`` for more
+    /// information about localizing strings. To initialize a progress view with
+    /// a localized string key, use the corresponding initializer that takes a
+    /// `LocalizedStringKey` instance.
+    @_disfavoredOverload
+    nonisolated public init<S>(_ title: S) where Label == Text, S: StringProtocol {
+        self.init(label: Text(title))
+    }
+
+    nonisolated init(label: Label?) {
+        base = .custom(
+            CustomProgressView(
+                fractionCompleted: nil,
+                alwaysIndeterminate: true,
+                label: label,
+                currentValueLabel: nil
+            )
+        )
+    }
+}
+
+// MARK: - Value-Based Initializers
+
+@available(OpenSwiftUI_v2_0, *)
+extension ProgressView {
+    /// Creates a progress view for showing determinate progress.
+    ///
+    /// If the value is non-`nil`, but outside the range of `0.0` through
+    /// `total`, the progress view pins the value to those limits, rounding to
+    /// the nearest possible bound. A value of `nil` represents indeterminate
+    /// progress, in which case the progress view ignores `total`.
+    ///
+    /// - Parameters:
+    ///     - value: The completed amount of the task to this point, in a range
+    ///       of `0.0` to `total`, or `nil` if the progress is indeterminate.
+    ///     - total: The full amount representing the complete scope of the
+    ///       task, meaning the task is complete if `value` equals `total`. The
+    ///       default value is `1.0`.
+    nonisolated public init<V>(
+        value: V?,
+        total: V = 1.0
+    ) where Label == EmptyView, CurrentValueLabel == EmptyView, V: BinaryFloatingPoint {
+        self.init(
+            value: value,
+            total: total,
+            label: nil,
+            currentValueLabel: nil
+        )
+    }
+
+    /// Creates a progress view for showing determinate progress, with a
+    /// custom label.
+    ///
+    /// If the value is non-`nil`, but outside the range of `0.0` through
+    /// `total`, the progress view pins the value to those limits, rounding to
+    /// the nearest possible bound. A value of `nil` represents indeterminate
+    /// progress, in which case the progress view ignores `total`.
+    ///
+    /// - Parameters:
+    ///     - value: The completed amount of the task to this point, in a range
+    ///       of `0.0` to `total`, or `nil` if the progress is indeterminate.
+    ///     - total: The full amount representing the complete scope of the
+    ///       task, meaning the task is complete if `value` equals `total`. The
+    ///       default value is `1.0`.
+    ///     - label: A view builder that creates a view that describes the task
+    ///       in progress.
+    nonisolated public init<V>(
+        value: V?,
+        total: V = 1.0,
+        @ViewBuilder label: () -> Label
+    ) where CurrentValueLabel == EmptyView, V: BinaryFloatingPoint {
+        self.init(
+            value: value,
+            total: total,
+            label: label(),
+            currentValueLabel: nil
+        )
+    }
+
+    /// Creates a progress view for showing determinate progress, with a
+    /// custom label.
+    ///
+    /// If the value is non-`nil`, but outside the range of `0.0` through
+    /// `total`, the progress view pins the value to those limits, rounding to
+    /// the nearest possible bound. A value of `nil` represents indeterminate
+    /// progress, in which case the progress view ignores `total`.
+    ///
+    /// - Parameters:
+    ///     - value: The completed amount of the task to this point, in a range
+    ///       of `0.0` to `total`, or `nil` if the progress is indeterminate.
+    ///     - total: The full amount representing the complete scope of the
+    ///       task, meaning the task is complete if `value` equals `total`. The
+    ///       default value is `1.0`.
+    ///     - label: A view builder that creates a view that describes the task
+    ///       in progress.
+    ///     - currentValueLabel: A view builder that creates a view that
+    ///       describes the level of completed progress of the task.
+    nonisolated public init<V>(
+        value: V?,
+        total: V = 1.0,
+        @ViewBuilder label: () -> Label,
+        @ViewBuilder currentValueLabel: () -> CurrentValueLabel
+    ) where V: BinaryFloatingPoint {
+        self.init(
+            value: value,
+            total: total,
+            label: label(),
+            currentValueLabel: currentValueLabel()
+        )
+    }
+
+    /// Creates a progress view for showing determinate progress that generates
+    /// its label from a localized string.
+    ///
+    /// If the value is non-`nil`, but outside the range of `0.0` through
+    /// `total`, the progress view pins the value to those limits, rounding to
+    /// the nearest possible bound. A value of `nil` represents indeterminate
+    /// progress, in which case the progress view ignores `total`.
+    ///
+    /// This initializer creates a ``Text`` view on your behalf, and treats the
+    /// localized key similar to ``Text/init(_:tableName:bundle:comment:)``. See
+    /// ``Text`` for more information about localizing strings. To initialize a
+    /// determinate progress view with a string variable, use the corresponding
+    /// initializer that takes a `StringProtocol` instance.
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the progress view's localized title that
+    ///       describes the task in progress.
+    ///     - value: The completed amount of the task to this point, in a range
+    ///       of `0.0` to `total`, or `nil` if the progress is
+    ///       indeterminate.
+    ///     - total: The full amount representing the complete scope of the
+    ///       task, meaning the task is complete if `value` equals `total`. The
+    ///       default value is `1.0`.
+    nonisolated public init<V>(
+        _ titleKey: LocalizedStringKey,
+        value: V?,
+        total: V = 1.0
+    ) where Label == Text, CurrentValueLabel == EmptyView, V: BinaryFloatingPoint {
+        self.init(
+            value: value,
+            total: total,
+            label: Text(titleKey),
+            currentValueLabel: nil
+        )
+    }
+
+    /// Creates a progress view for showing determinate progress that generates
+    /// its label from a string.
+    ///
+    /// If the value is non-`nil`, but outside the range of `0.0` through
+    /// `total`, the progress view pins the value to those limits, rounding to
+    /// the nearest possible bound. A value of `nil` represents indeterminate
+    /// progress, in which case the progress view ignores `total`.
+    ///
+    /// This initializer creates a ``Text`` view on your behalf, and treats the
+    /// title similar to ``Text/init(verbatim:)``. See ``Text`` for more
+    /// information about localizing strings. To initialize a determinate
+    /// progress view with a localized string key, use the corresponding
+    /// initializer that takes a `LocalizedStringKey` instance.
+    ///
+    /// - Parameters:
+    ///     - title: The string that describes the task in progress.
+    ///     - value: The completed amount of the task to this point, in a range
+    ///       of `0.0` to `total`, or `nil` if the progress is
+    ///       indeterminate.
+    ///     - total: The full amount representing the complete scope of the
+    ///       task, meaning the task is complete if `value` equals `total`. The
+    ///       default value is `1.0`.
+    @_disfavoredOverload
+    nonisolated public init<S, V>(
+        _ title: S,
+        value: V?,
+        total: V = 1.0
+    ) where Label == Text, CurrentValueLabel == EmptyView, S: StringProtocol, V: BinaryFloatingPoint {
+        self.init(
+            value: value,
+            total: total,
+            label: Text(title),
+            currentValueLabel: nil
+        )
+    }
+
+    nonisolated init<V>(
+        value: V?,
+        total: V,
+        label: Label?,
+        currentValueLabel: CurrentValueLabel?
+    ) where V: BinaryFloatingPoint {
+        var fractionCompleted: Double? {
+            guard let value else {
+                return nil
+            }
+            if value < 0 || value > total {
+                Log.runtimeIssues(
+                    "ProgressView initialized with an out-of-bounds progress value. The value will be clamped to the range of `0...total`."
+                )
+            }
+            guard value >= 0,
+                  total >= 0,
+                  value != 0 || total != 0 else {
+                return nil
+            }
+            return Double(value / total).clamp(min: 0, max: 1)
+        }
+        base = .custom(
+            CustomProgressView(
+                fractionCompleted: fractionCompleted,
+                alwaysIndeterminate: false,
+                label: label,
+                currentValueLabel: currentValueLabel
+            )
+        )
+    }
+}
 // MARK: - ProgressViewValue
 
 enum ProgressViewValue: Codable {

From f2d0817da42eaba2106c7ddcff1e4698a315bbb9 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Mon, 24 Aug 2026 01:24:10 +0800
Subject: [PATCH 07/25] Update missing ProgressView init

---
 .../Control/ProgressView/ProgressView.swift   | 169 +++++++++++++++++-
 1 file changed, 162 insertions(+), 7 deletions(-)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
index 560c77c82..164530d28 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
@@ -3,7 +3,7 @@
 //  OpenSwiftUI
 //
 //  Audited for 6.5.4
-//  Status: WIP
+//  Status: Complete
 //  ID: 936A47782A7E2FBE97D58CDBAEB02770 (SwiftUI)
 
 #if OPENSWIFTUI_OPENCOMBINE
@@ -414,6 +414,68 @@ extension ProgressView {
         )
     }
 }
+
+// MARK: - Foundation Progress
+
+@available(OpenSwiftUI_v2_0, *)
+extension ProgressView {
+    /// Creates a progress view for visualizing the given progress instance.
+    ///
+    /// The progress view synthesizes a default label using the
+    /// `localizedDescription` of the given progress instance.
+    nonisolated public init(
+        _ progress: Foundation.Progress
+    ) where Label == EmptyView, CurrentValueLabel == EmptyView {
+        base = .observing(FoundationProgressView(progress: progress))
+    }
+}
+
+// MARK: - ProgressView Style Configuration
+
+@available(OpenSwiftUI_v2_0, *)
+extension ProgressView {
+    /// Creates a progress view based on a style configuration.
+    ///
+    /// You can use this initializer within the
+    /// ``ProgressViewStyle/makeBody(configuration:)`` method of a
+    /// ``ProgressViewStyle`` to create an instance of the styled progress view.
+    /// This is useful for custom progress view styles that only modify the
+    /// current progress view style, as opposed to implementing a brand new
+    /// style. Because this modifier style can't know how the current style
+    /// represents progress, avoid making assumptions about the view's contents,
+    /// such as whether it uses bars or other shapes.
+    ///
+    /// The following example shows a style that adds a rounded pink border to a
+    /// progress view, but otherwise preserves the progress view's current
+    /// style:
+    ///
+    ///     struct PinkBorderedProgressViewStyle: ProgressViewStyle {
+    ///         func makeBody(configuration: Configuration) -> some View {
+    ///             ProgressView(configuration)
+    ///                 .padding(4)
+    ///                 .border(.pink, width: 3)
+    ///                 .cornerRadius(4)
+    ///         }
+    ///     }
+    ///
+    /// ![Two horizontal progress views, one at 25 percent complete and the
+    /// other at 75 percent, each rendered with a rounded pink
+    /// border.](ProgressView-4-macOS)
+    ///
+    /// - Note: Progress views in widgets don't apply custom styles.
+    nonisolated public init(
+        _ configuration: ProgressViewStyleConfiguration
+    ) where Label == ProgressViewStyleConfiguration.Label, CurrentValueLabel == ProgressViewStyleConfiguration.CurrentValueLabel {
+        base = .custom(
+            CustomProgressView(
+                value: configuration.value,
+                label: configuration.label,
+                currentValueLabel: configuration.currentValueLabel
+            )
+        )
+    }
+}
+
 // MARK: - ProgressViewValue
 
 enum ProgressViewValue: Codable {
@@ -517,6 +579,16 @@ struct CustomProgressView<Label, CurrentValueLabel>: PrimitiveView, UnaryView, V
     var label: Label?
     var currentValueLabel: CurrentValueLabel?
 
+    init(
+        value: ProgressViewValue,
+        label: Label?,
+        currentValueLabel: CurrentValueLabel?
+    ) {
+        self.value = value
+        self.label = label
+        self.currentValueLabel = currentValueLabel
+    }
+
     init(
         interval: ClosedRange<Date>,
         countdown: Bool,
@@ -639,13 +711,96 @@ struct CustomProgressView<Label, CurrentValueLabel>: PrimitiveView, UnaryView, V
     }
 }
 
-// FIXME
-struct FoundationProgressView: View {
-    var body: some View { EmptyView() }
-}
+// MARK: - ResolvedProgressView
 
-// FIXME
 struct ResolvedProgressView: View {
     var value: ProgressViewValue
-    var body: some View { EmptyView() }
+
+    @OptionalViewAlias
+    var label: ProgressViewStyleConfiguration.Label?
+
+    @OptionalViewAlias
+    var currentValueLabel: ProgressViewStyleConfiguration.CurrentValueLabel?
+
+    var body: ResolvedProgressViewStyle {
+        ResolvedProgressViewStyle(
+            configuration: ProgressViewStyleConfiguration(
+                value: value,
+                label: label,
+                currentValueLabel: currentValueLabel
+            )
+        )
+    }
+}
+
+// TBA
+
+// MARK: - FoundationProgressView
+
+@MainActor
+struct FoundationProgressView: View {
+    var progress: Foundation.Progress
+
+    @State
+    private var state: FoundationProgressUIState?
+
+    nonisolated init(progress: Foundation.Progress) {
+        self.progress = progress
+        _state = State(initialValue: nil)
+    }
+
+    var body: some View {
+        let state = state ?? FoundationProgressUIState(progress: progress)
+        let content = CustomProgressView(
+            fractionCompleted: state.isIndeterminate ? nil : state.fractionCompleted,
+            alwaysIndeterminate: false,
+            label: state.localizedDescription.isEmpty ? nil : Text(state.localizedDescription),
+            currentValueLabel: state.localizedAdditionalDescription.isEmpty ? nil : Text(state.localizedAdditionalDescription)
+        )
+        return content.onReceive(progress.uiStatePublisher) { state in
+            self.state = state
+        }
+    }
+}
+
+private struct FoundationProgressUIState: Equatable {
+    var fractionCompleted: Double
+    var isIndeterminate: Bool
+    var localizedDescription: String
+    var localizedAdditionalDescription: String
+
+    init(progress: Foundation.Progress) {
+        fractionCompleted = progress.fractionCompleted
+        isIndeterminate = progress.isIndeterminate
+        localizedDescription = progress.localizedDescription ?? ""
+        localizedAdditionalDescription = progress.localizedAdditionalDescription ?? ""
+    }
+}
+
+private extension Foundation.Progress {
+    var uiStatePublisher: some Publisher<FoundationProgressUIState, Never> {
+        #if OPENSWIFTUI_OPENCOMBINE
+        // [AI] OpenCombineFoundation has no KVO publisher, so sample Progress
+        // while the view is active to preserve live updates on non-Darwin hosts.
+        Foundation.Timer.publish(
+            every: 1.0 / 30.0,
+            on: .main,
+            in: .common
+        )
+            .autoconnect()
+            .map { [progress = self] _ in
+                FoundationProgressUIState(progress: progress)
+            }
+            .removeDuplicates()
+        #else
+        Publishers.CombineLatest4(
+            publisher(for: \.completedUnitCount),
+            publisher(for: \.totalUnitCount),
+            publisher(for: \.localizedDescription),
+            publisher(for: \.localizedAdditionalDescription)
+        ).map { [unowned self] _ in
+            FoundationProgressUIState(progress: self)
+        }
+        #endif
+    }
 }

From 8453c2618f9839d617889a2a3cb64009cc82eadc Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Mon, 24 Aug 2026 02:19:58 +0800
Subject: [PATCH 08/25] Add ProgressView+Foundation

---
 .../ProgressView+Foundation.swift             | 192 ++++++++++++++++++
 .../Control/ProgressView/ProgressView.swift   |  82 +-------
 2 files changed, 194 insertions(+), 80 deletions(-)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Foundation.swift

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Foundation.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Foundation.swift
new file mode 100644
index 000000000..ccc66f3d2
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Foundation.swift
@@ -0,0 +1,192 @@
+//
+//  ProgressView+Foundation.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 3E94A30D8C602D81EB55934DA2DC2E22 (SwiftUI)
+
+#if OPENSWIFTUI_OPENCOMBINE
+import OpenCombine
+import OpenCombineFoundation
+#else
+import Combine
+#endif
+import Foundation
+import OpenAttributeGraphShims
+@_spi(ForOpenSwiftUIOnly)
+import OpenSwiftUICore
+
+// MARK: - Progress + UI State
+
+extension Foundation.Progress {
+    fileprivate struct UIState {
+        var fractionCompleted: Double
+        var isIndeterminate: Bool
+        var localizedDescription: String
+        var localizedAdditionalDescription: String
+    }
+
+    fileprivate var uiState: UIState {
+        UIState(
+            fractionCompleted: fractionCompleted,
+            isIndeterminate: isIndeterminate,
+            localizedDescription: localizedDescription,
+            localizedAdditionalDescription: localizedAdditionalDescription
+        )
+    }
+
+    #if !OPENSWIFTUI_OPENCOMBINE
+    fileprivate typealias UIStatePublisher = Publishers.Map<
+        Publishers.CombineLatest4<
+            NSObject.KeyValueObservingPublisher<Foundation.Progress, Int64>,
+            NSObject.KeyValueObservingPublisher<Foundation.Progress, Int64>,
+            NSObject.KeyValueObservingPublisher<Foundation.Progress, String>,
+            NSObject.KeyValueObservingPublisher<Foundation.Progress, String>
+        >,
+        UIState
+    >
+
+    fileprivate var uiStatePublisher: UIStatePublisher {
+        Publishers.CombineLatest4(
+            publisher(
+                for: \.completedUnitCount,
+                options: [.initial, .new]
+            ),
+            publisher(
+                for: \.totalUnitCount,
+                options: [.initial, .new]
+            ),
+            publisher(
+                for: \.localizedDescription,
+                options: [.initial, .new]
+            ),
+            publisher(
+                for: \.localizedAdditionalDescription,
+                options: [.initial, .new]
+            )
+        ).map { [unowned self] _ in
+            uiState
+        }
+    }
+    #else
+    // TODO: Implement NSObject.KeyValueObservingPublisher in OpenCombine
+    fileprivate typealias UIStatePublisher = AnyPublisher<UIState, Never>
+
+    fileprivate var uiStatePublisher: UIStatePublisher {
+        // [AI] OpenCombineFoundation does not provide KVO publishers. Sample
+        // Progress while the graph-owned subscription is active instead.
+        Foundation.Timer.publish(
+            every: 1.0 / 30.0,
+            on: .main,
+            in: .common
+        )
+        .autoconnect()
+        .map { [unowned self] _ in
+            uiState
+        }
+        .eraseToAnyPublisher()
+    }
+    #endif
+
+    fileprivate struct UIStateSubscriber: Subscriber, Cancellable {
+        @Binding var viewState: UIState?
+        var combineIdentifier = CombineIdentifier()
+
+        func respond(to state: UIState) {
+            func update() {
+                viewState = state
+            }
+
+            if Thread.isMainThread {
+                Update.enqueueAction(reason: nil, update)
+            } else {
+                update()
+            }
+        }
+
+        func receive(subscription: any Subscription) {
+            subscription.request(.unlimited)
+        }
+
+        func receive(_ input: UIState) -> Subscribers.Demand {
+            respond(to: input)
+            return .none
+        }
+
+        func receive(completion _: Subscribers.Completion<Never>) {
+            _openSwiftUIEmptyStub()
+        }
+
+        func cancel() {
+            _openSwiftUIEmptyStub()
+        }
+    }
+}
+
+// MARK: - FoundationProgressView
+
+struct FoundationProgressView: View {
+    var progress: Foundation.Progress
+    @State private var state: Foundation.Progress.UIState?
+
+    var body: Body {
+        Body(progress: progress, state: $state)
+    }
+
+    struct Body: MultiView, PrimitiveView, View {
+        var progress: Foundation.Progress
+
+        @Binding
+        fileprivate var state: Foundation.Progress.UIState?
+
+        nonisolated static func _makeViewList(
+            view: _GraphValue<Self>,
+            inputs: _ViewListInputs
+        ) -> _ViewListOutputs {
+            let value = Attribute(
+                BodyAttribute(
+                    view: view.value,
+                    subscription: .init()
+                )
+            )
+            return BodyAttribute.Value._makeViewList(
+                view: _GraphValue(value),
+                inputs: inputs
+            )
+        }
+
+        private struct BodyAttribute: StatefulRule {
+            @Attribute var view: Body
+            var subscription: SubscriptionLifetime<Foundation.Progress.UIStatePublisher>
+
+            mutating func updateValue() {
+                let subscriber = Foundation.Progress.UIStateSubscriber(viewState: view.$state)
+                subscription.subscribe(
+                    subscriber: subscriber,
+                    to: view.progress.uiStatePublisher
+                )
+                value = Value(state: view.state ?? view.progress.uiState)
+            }
+
+            struct Value: View {
+                var state: Foundation.Progress.UIState
+
+                var body: some View {
+                    ResolvedProgressView(
+                        value: .absolute(
+                            fractionCompleted: state.isIndeterminate ? nil : state.fractionCompleted,
+                            alwaysIndeterminate: false
+                        )
+                    )
+                    .optionalViewAlias(ProgressViewStyleConfiguration.CurrentValueLabel.self) {
+                        state.localizedAdditionalDescription.isEmpty ? nil : Text(state.localizedAdditionalDescription)
+                    }
+                    .optionalViewAlias(ProgressViewStyleConfiguration.Label.self) {
+                        state.localizedDescription.isEmpty ? nil : Text(state.localizedDescription)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
index 164530d28..944f428d6 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView.swift
@@ -6,12 +6,6 @@
 //  Status: Complete
 //  ID: 936A47782A7E2FBE97D58CDBAEB02770 (SwiftUI)
 
-#if OPENSWIFTUI_OPENCOMBINE
-import OpenCombine
-import OpenCombineFoundation
-#else
-import Combine
-#endif
 import OpenAttributeGraphShims
 public import Foundation
 @_spi(ForOpenSwiftUIOnly)
@@ -415,7 +409,7 @@ extension ProgressView {
     }
 }
 
-// MARK: - Foundation Progress
+// MARK: - ProgressView + Foundation Progress
 
 @available(OpenSwiftUI_v2_0, *)
 extension ProgressView {
@@ -430,7 +424,7 @@ extension ProgressView {
     }
 }
 
-// MARK: - ProgressView Style Configuration
+// MARK: - ProgressView + Style Configuration
 
 @available(OpenSwiftUI_v2_0, *)
 extension ProgressView {
@@ -732,75 +726,3 @@ struct ResolvedProgressView: View {
         )
     }
 }
-
-// TBA
-
-// MARK: - FoundationProgressView
-
-@MainActor
-struct FoundationProgressView: View {
-    var progress: Foundation.Progress
-
-    @State
-    private var state: FoundationProgressUIState?
-
-    nonisolated init(progress: Foundation.Progress) {
-        self.progress = progress
-        _state = State(initialValue: nil)
-    }
-
-    var body: some View {
-        let state = state ?? FoundationProgressUIState(progress: progress)
-        let content = CustomProgressView(
-            fractionCompleted: state.isIndeterminate ? nil : state.fractionCompleted,
-            alwaysIndeterminate: false,
-            label: state.localizedDescription.isEmpty ? nil : Text(state.localizedDescription),
-            currentValueLabel: state.localizedAdditionalDescription.isEmpty ? nil : Text(state.localizedAdditionalDescription)
-        )
-        return content.onReceive(progress.uiStatePublisher) { state in
-            self.state = state
-        }
-    }
-}
-
-private struct FoundationProgressUIState: Equatable {
-    var fractionCompleted: Double
-    var isIndeterminate: Bool
-    var localizedDescription: String
-    var localizedAdditionalDescription: String
-
-    init(progress: Foundation.Progress) {
-        fractionCompleted = progress.fractionCompleted
-        isIndeterminate = progress.isIndeterminate
-        localizedDescription = progress.localizedDescription ?? ""
-        localizedAdditionalDescription = progress.localizedAdditionalDescription ?? ""
-    }
-}
-
-private extension Foundation.Progress {
-    var uiStatePublisher: some Publisher<FoundationProgressUIState, Never> {
-        #if OPENSWIFTUI_OPENCOMBINE
-        // [AI] OpenCombineFoundation has no KVO publisher, so sample Progress
-        // while the view is active to preserve live updates on non-Darwin hosts.
-        Foundation.Timer.publish(
-            every: 1.0 / 30.0,
-            on: .main,
-            in: .common
-        )
-            .autoconnect()
-            .map { [progress = self] _ in
-                FoundationProgressUIState(progress: progress)
-            }
-            .removeDuplicates()
-        #else
-        Publishers.CombineLatest4(
-            publisher(for: \.completedUnitCount),
-            publisher(for: \.totalUnitCount),
-            publisher(for: \.localizedDescription),
-            publisher(for: \.localizedAdditionalDescription)
-        ).map { [unowned self] _ in
-            FoundationProgressUIState(progress: self)
-        }
-        #endif
-    }
-}

From ca520fb2dcaaabfcfb558df93f9e81a5694126a1 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Mon, 24 Aug 2026 02:50:39 +0800
Subject: [PATCH 09/25] Add LinearProgressViewStyle

---
 .../LinearProgressViewStyle.swift             | 82 +++++++++++++++++++
 .../View/Configuration/StaticIf.swift         |  2 +-
 2 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift
new file mode 100644
index 000000000..09aacd968
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift
@@ -0,0 +1,82 @@
+//
+//  LinearProgressViewStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 6399EAC5515CA9566698FD9D51220283 (SwiftUI)
+
+public import OpenSwiftUICore
+
+// MARK: - ProgressViewStyle + Linear
+
+@available(OpenSwiftUI_v2_0, *)
+extension ProgressViewStyle where Self == LinearProgressViewStyle {
+    /// A progress view that visually indicates its progress using a horizontal
+    /// bar.
+    @_alwaysEmitIntoClient
+    @MainActor
+    @preconcurrency
+    public static var linear: LinearProgressViewStyle {
+        .init()
+    }
+}
+
+// MARK: - LinearProgressViewStyle
+
+/// A progress view that visually indicates its progress using a horizontal
+/// bar.
+@available(OpenSwiftUI_v2_0, *)
+public struct LinearProgressViewStyle: ProgressViewStyle {
+    @Environment(\.tintColor)
+    private var controlTint: Color?
+
+    @Environment(\.labelsVisibility)
+    private var labelsVisibility: Visibility
+
+    private let tint: Color?
+
+    /// Creates a linear progress view style.
+    public init() {
+        tint = nil
+    }
+
+    /// Creates a linear progress view style with a custom tint color.
+    @available(*, deprecated, message: "Use ``View/tint(_)`` instead.")
+    public init(tint: Color) {
+        self.tint = tint
+    }
+
+    public func makeBody(configuration: Configuration) -> some View {
+        VStack(alignment: .leading, spacing: 4) {
+            if !isLinkedOnOrAfter(.v5) || labelsVisibility != .hidden {
+                configuration.label
+            }
+            progressBar(configuration: configuration)
+            if !isLinkedOnOrAfter(.v5) || labelsVisibility != .hidden {
+                configuration.currentValueLabel
+                    .defaultForegroundColor(.secondary)
+                    .font(.caption)
+                    .monospacedDigit()
+            }
+        }
+    }
+
+    private func progressBar(configuration: Configuration) -> some View {
+        _openSwiftUIUnimplementedFailure()
+//        StaticIf(idiom: .widget) {
+//            ArchivableLinearProgressView(
+//                configuration: configuration,
+//                tint: tint ?? controlTint
+//            )
+//        } else: {
+//            LinearUIKitProgressView(
+//                configuration: configuration,
+//                tint: tint ?? controlTint
+//            )
+//        }
+    }
+}
+
+@available(*, unavailable)
+extension LinearProgressViewStyle: Sendable {}
diff --git a/Sources/OpenSwiftUICore/View/Configuration/StaticIf.swift b/Sources/OpenSwiftUICore/View/Configuration/StaticIf.swift
index 57d04e763..3025a9ad8 100644
--- a/Sources/OpenSwiftUICore/View/Configuration/StaticIf.swift
+++ b/Sources/OpenSwiftUICore/View/Configuration/StaticIf.swift
@@ -52,7 +52,7 @@ extension StaticIf: PrimitiveView, View where TrueBody: View, FalseBody: View {
     ///   - idiom: The interface idiom to evaluate against the current environment.
     ///   - then: A closure that returns the view to display when the current device matches the specified idiom.
     ///   - else: A closure that returns the view to display when the current device doesn't match the specified idiom.
-    init<I>(idiom: I, then: () -> TrueBody, else: () -> FalseBody) where Predicate == InterfaceIdiomPredicate<I>, I: InterfaceIdiom {
+    package init<I>(idiom: I, then: () -> TrueBody, else: () -> FalseBody) where Predicate == InterfaceIdiomPredicate<I>, I: InterfaceIdiom {
         trueBody = then()
         falseBody = `else`()
     }

From 336ef8c590cdd795e2e9983135f4db3052e5e246 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Mon, 24 Aug 2026 03:03:22 +0800
Subject: [PATCH 10/25] Add CircularProgressViewStyle

---
 .../CircularProgressViewStyle.swift           | 127 ++++++++++++++++++
 1 file changed, 127 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift
new file mode 100644
index 000000000..614f1c6c5
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift
@@ -0,0 +1,127 @@
+//
+//  CircularProgressViewStyle.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+@_spi(ForOpenSwiftUIOnly)
+public import OpenSwiftUICore
+
+// MARK: - ProgressViewStyle + Circular
+
+@available(OpenSwiftUI_v2_0, *)
+extension ProgressViewStyle where Self == CircularProgressViewStyle {
+    /// A progress view that uses a circular gauge to indicate the partial
+    /// completion of an activity.
+    @_alwaysEmitIntoClient
+    @MainActor
+    @preconcurrency
+    public static var circular: CircularProgressViewStyle {
+        .init()
+    }
+}
+
+// MARK: - CircularProgressViewStyle
+
+/// A progress view that uses a circular gauge to indicate the partial
+/// completion of an activity.
+@available(OpenSwiftUI_v2_0, *)
+public struct CircularProgressViewStyle: ProgressViewStyle {
+    @Environment(\.tintColor)
+    private var controlTint: Color?
+
+    @Environment(\.labelsVisibility)
+    private var labelsVisibility: Visibility
+
+    private let tint: Color?
+
+    @_spi(Private)
+    @available(iOS, unavailable)
+    @available(macOS, unavailable)
+    @available(tvOS, unavailable)
+    @available(watchOS, deprecated: 8.0, message: "Use View.controlSize(_:) instead.")
+    public enum Size: Hashable {
+        case small
+        case medium
+        case large
+    }
+
+    /// Creates a circular progress view style.
+    public init() {
+        tint = nil
+    }
+
+    @_spi(Private)
+    @available(iOS, unavailable)
+    @available(macOS, unavailable)
+    @available(tvOS, unavailable)
+    @available(watchOS, deprecated: 8.0, message: "Use View.controlSize(_:) instead.")
+    public init(size _: Size) {
+        tint = nil
+    }
+
+    /// Creates a circular progress view style with a custom tint color.
+    @available(*, deprecated, message: "Use ``View/tint(_)`` instead.")
+    public init(tint: Color) {
+        self.tint = tint
+    }
+
+    public func makeBody(configuration: Configuration) -> some View {
+        VStack {
+            fractionCompletedView(configuration: configuration)
+            StaticIf(idiom: .widget) {
+                configuration.alwaysIndeterminate
+                    ? labels(configuration: configuration)
+                    : nil
+            } else: {
+                labels(configuration: configuration)
+            }
+        }
+        .spacing(Spacing())
+    }
+
+    @ViewBuilder
+    func fractionCompletedView(configuration: Configuration) -> some View {
+        _openSwiftUIUnreachableCode()
+//        StaticIf(idiom: .widget) {
+//            ArchivableCircularProgressView(
+//                size: 58,
+//                centerFont: 30,
+//                configuration: configuration,
+//                tint: tint ?? controlTint
+//            )
+//        } else: {
+//            StaticIf(idiom: MacInterfaceIdiom.mac) {
+//                CircularUIKitProgressView(
+//                    tint: tint ?? controlTint,
+//                    useCustomWidth: false
+//                )
+//            } else: {
+//                CircularUIKitProgressView(
+//                    tint: tint ?? controlTint,
+//                    useCustomWidth: true
+//                )
+//            }
+//        }
+    }
+
+    @ViewBuilder
+    func labels(configuration: Configuration) -> some View {
+        if !isLinkedOnOrAfter(.v5) || labelsVisibility != .hidden {
+            VStack {
+                HStack {
+                    configuration.label
+                }
+                HStack {
+                    configuration.currentValueLabel
+                }
+                .font(.caption)
+            }
+            .defaultForegroundColor(.secondary)
+        }
+    }
+}
+
+@available(*, unavailable)
+extension CircularProgressViewStyle: Sendable {}

From cc52a287ebf25420ca184d869d929b124c18f15b Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Mon, 24 Aug 2026 03:39:36 +0800
Subject: [PATCH 11/25] Update DefaultProgressViewStyle

---
 .../DefaultProgressViewStyle.swift            | 42 +++++++++----------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/DefaultProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/DefaultProgressViewStyle.swift
index b8c05d9d8..9457fb9c5 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/DefaultProgressViewStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/DefaultProgressViewStyle.swift
@@ -39,29 +39,27 @@ public struct DefaultProgressViewStyle: ProgressViewStyle {
         _openSwiftUIEmptyStub()
     }
 
-    // TBA
     public func makeBody(configuration: Configuration) -> some View {
-//        Group {
-//            if configuration.alwaysIndeterminate {
-//                ProgressView(configuration)
-//                    .progressViewStyle(CircularProgressViewStyle())
-//            } else {
-//                switch configuration.value {
-//                case .dateRelative:
-//                    ProgressView(configuration)
-//                        .progressViewStyle(LinearProgressViewStyle())
-//                case .absolute:
-//                    if configuration.fractionCompleted != nil {
-//                        ProgressView(configuration)
-//                            .progressViewStyle(LinearProgressViewStyle())
-//                    } else {
-//                        ProgressView(configuration)
-//                            .progressViewStyle(CircularProgressViewStyle())
-//                    }
-//                }
-//            }
-//        }
-        _openSwiftUIUnimplementedFailure()
+        Group {
+            if configuration.alwaysIndeterminate {
+                ProgressView(configuration)
+                    .progressViewStyle(CircularProgressViewStyle())
+            } else {
+                switch configuration.value {
+                case .dateRelative:
+                    ProgressView(configuration)
+                        .progressViewStyle(LinearProgressViewStyle())
+                case .absolute:
+                    if configuration.fractionCompleted != nil {
+                        ProgressView(configuration)
+                            .progressViewStyle(LinearProgressViewStyle())
+                    } else {
+                        ProgressView(configuration)
+                            .progressViewStyle(CircularProgressViewStyle())
+                    }
+                }
+            }
+        }
     }
 }
 

From 5cc98147fba4ca86594e22698e936d2f5219d19c Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Mon, 24 Aug 2026 03:55:52 +0800
Subject: [PATCH 12/25] Add CircularUIKitProgressView

---
 .../COpenSwiftUI/Shims/UIKit/UIKit_Private.h  |  4 +
 .../ProgressView/UIKitProgressView.swift      | 76 +++++++++++++++++++
 2 files changed, 80 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift

diff --git a/Sources/COpenSwiftUI/Shims/UIKit/UIKit_Private.h b/Sources/COpenSwiftUI/Shims/UIKit/UIKit_Private.h
index f242c9051..51c517e83 100644
--- a/Sources/COpenSwiftUI/Shims/UIKit/UIKit_Private.h
+++ b/Sources/COpenSwiftUI/Shims/UIKit/UIKit_Private.h
@@ -48,6 +48,10 @@ OPENSWIFTUI_ASSUME_NONNULL_BEGIN
 @property(class, nonatomic, readonly) NSInteger _currentAnimationCurve_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(_currentAnimationCurve);
 @end
 
+@interface UIActivityIndicatorView (OpenSwiftUI_SPI)
+- (void)_setCustomWidth:(CGFloat)width;
+@end
+
 @interface UIResponder (OpenSwiftUI_SPI)
 - (void)_performMainMenuShortcutKeyCommand:(UIKeyCommand *)keyCommand; // FIXME
 @end
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift
new file mode 100644
index 000000000..78f91f27a
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift
@@ -0,0 +1,76 @@
+//
+//  UIKitProgressView.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 593A28E6B13910E9C78D52974AE7D9AF (SwiftUI)
+
+#if os(iOS) || os(visionOS)
+import COpenSwiftUI
+import OpenSwiftUICore
+import UIKit
+
+// MARK: - LinearUIKitProgressView [TODO]
+
+// MARK: - CircularUIKitProgressView
+
+struct CircularUIKitProgressView: UIViewRepresentable {
+    @Environment(\.controlSize) private var controlSize
+    @ScaledMetric private var regular: CGFloat = 20
+    @ScaledMetric private var small: CGFloat = 14
+    @ScaledMetric private var large: CGFloat = 37
+    var tint: Color?
+    var useCustomWidth: Bool
+
+    init(tint: Color?, useCustomWidth: Bool) {
+        self.tint = tint
+        self.useCustomWidth = useCustomWidth
+    }
+
+    func makeUIView(context _: Context) -> UIActivityIndicatorView {
+        let uiView = SwiftUIActivityIndicatorView()
+        uiView.style = if useCustomWidth {
+            .init(rawValue: 16)!
+        } else {
+            switch controlSize {
+            case .mini, .small:
+                .init(rawValue: 3)!
+            case .regular:
+                .medium
+            case .large, .extraLarge:
+                .large
+            }
+        }
+        uiView.startAnimating()
+        return uiView
+    }
+
+    func updateUIView(_ uiView: UIActivityIndicatorView, context: Context) {
+        if useCustomWidth {
+            uiView._setCustomWidth(resolvedWidth)
+        }
+        let tintColor = tint ?? (useCustomWidth ? .secondary : nil)
+        let newColor = tintColor.map {
+            $0.resolve(in: context.environment).kitColor as! UIColor
+        }
+        if newColor != uiView.color {
+            uiView.color = newColor
+        }
+    }
+
+    private var resolvedWidth: CGFloat {
+        switch controlSize {
+        case .mini, .small:
+            small
+        case .regular:
+            regular
+        case .large, .extraLarge:
+            large
+        }
+    }
+
+    private class SwiftUIActivityIndicatorView: UIActivityIndicatorView {}
+}
+
+#endif

From 9d9f83d80f4f99181f9aca5c49db81cf73b626d7 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Mon, 24 Aug 2026 04:30:24 +0800
Subject: [PATCH 13/25] Add ProgressView+Date

---
 .../ProgressView/ProgressView+Date.swift      | 188 ++++++++++++++++++
 1 file changed, 188 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
new file mode 100644
index 000000000..051a51687
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
@@ -0,0 +1,188 @@
+//
+//  ProgressView+Date.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: E25B5CE50FE780022155187DDAA79ACA (SwiftUI)
+
+import Foundation
+import OpenSwiftUICore
+
+// MARK: - TimelineProgressViewExtendedBase
+
+protocol TimelineProgressViewExtendedBase: View {
+    associatedtype ExtendedState: Codable
+
+    init(fractionCompleted: Double, tint: Color?, extendedState: ExtendedState)
+}
+
+// MARK: - TimelineProgressViewBase
+
+protocol TimelineProgressViewBase: TimelineProgressViewExtendedBase where ExtendedState == _TimelineProgressViewBaseEmptyState {
+    init(fractionCompleted: Double, tint: Color?)
+}
+
+// MARK: - _TimelineProgressViewBaseEmptyState
+
+struct _TimelineProgressViewBaseEmptyState: Codable {}
+
+// MARK: - TimelineProgressView
+
+struct TimelineProgressView<Base>: View where Base: TimelineProgressViewExtendedBase {
+    var interval: ClosedRange<Date>
+    var updateStyle: TimelineProgressViewUpdateStyle
+    var countdown: Bool
+    var tint: Color?
+    var isCircular: Bool
+    var extendedState: Base.ExtendedState
+
+    var body: some View {
+        ConditionallyArchivableTimelineProgressView(
+            interval: interval,
+            updateStyle: updateStyle,
+            countdown: countdown,
+            tint: tint,
+            isCircular: isCircular,
+            extendedState: extendedState
+        )
+    }
+
+    struct ArchivableTimelineProgressView: /*_ArchivableView*/ View {
+        var interval: ClosedRange<Date>
+        var updateStyle: TimelineProgressViewUpdateStyle
+        var countdown: Bool
+        var resolvedTint: Color.Resolved?
+        var extendedState: Base.ExtendedState
+
+        var body: some View {
+            FinalTimelineProgressView(
+                interval: interval,
+                updateStyle: updateStyle,
+                countdown: countdown,
+                tint: resolvedTint.map(Color.init),
+                extendedState: extendedState
+            )
+        }
+    }
+
+    private struct ConditionallyArchivableTimelineProgressView: /*ConditionallyArchivableView*/ View {
+        var interval: ClosedRange<Date>
+        var updateStyle: TimelineProgressViewUpdateStyle
+        var countdown: Bool
+        var tint: Color?
+        var isCircular: Bool
+        var extendedState: Base.ExtendedState
+
+        var body: some View {
+            FinalTimelineProgressView(
+                interval: interval,
+                updateStyle: updateStyle,
+                countdown: countdown,
+                tint: tint,
+                extendedState: extendedState
+            )
+        }
+
+        var archivedBody: some View {
+            EnvironmentReader { environment in
+                ArchivableTimelineProgressView(
+                    interval: interval,
+                    updateStyle: updateStyle,
+                    countdown: countdown,
+                    resolvedTint: tint?.resolve(in: environment),
+                    extendedState: extendedState
+                )
+            }
+            .fixedSize(horizontal: false, vertical: !isCircular)
+        }
+    }
+
+    private struct FinalTimelineProgressView: View {
+        var interval: ClosedRange<Date>
+        var updateStyle: TimelineProgressViewUpdateStyle
+        var countdown: Bool
+        var tint: Color?
+        var extendedState: Base.ExtendedState
+
+        @ViewBuilder
+        var body: some View {
+            TimelineView(
+                ProgressViewSchedule(
+                    interval: interval,
+                    updateStyle: updateStyle
+                )
+            ) { context in
+                Base(
+                    fractionCompleted: interval.progress(
+                        at: context.date,
+                        countdown: countdown
+                    ),
+                    tint: tint,
+                    extendedState: extendedState
+                )
+            }
+        }
+    }
+}
+
+// MARK: - TimelineProgressViewUpdateStyle
+
+enum TimelineProgressViewUpdateStyle: Codable, Hashable {
+    case `default`
+    case onTheSecond
+}
+
+// MARK: - ProgressViewSchedule
+
+@available(OpenSwiftUI_v3_0, *)
+struct ProgressViewSchedule: TimelineSchedule {
+    var interval: ClosedRange<Date>
+    var updateStyle: TimelineProgressViewUpdateStyle
+
+    func entries(
+        from _: Date,
+        mode: TimelineScheduleMode
+    ) -> AnyIterator<Date> {
+        let entries: AnySequence<Date>
+        switch mode {
+        case .normal:
+            switch updateStyle {
+            case .default:
+                entries = AnySequence(
+                    AnimationTimelineSchedule()
+                        .entries(from: interval.lowerBound, mode: mode)
+                )
+            case .onTheSecond:
+                entries = AnySequence(
+                    PeriodicTimelineSchedule(from: interval.lowerBound, by: 1)
+                        .entries(from: interval.lowerBound, mode: mode)
+                )
+            }
+        case .lowFrequency:
+            let calendar = Calendar.current
+            let second = calendar.component(.second, from: interval.upperBound)
+            let alignedStart = calendar.nextDate(
+                after: interval.lowerBound,
+                matching: DateComponents(second: second, nanosecond: 0),
+                matchingPolicy: .nextTime,
+                repeatedTimePolicy: .first,
+                direction: .backward
+            ) ?? interval.lowerBound
+            entries = AnySequence(
+                PeriodicTimelineSchedule(from: alignedStart, by: 60)
+                    .entries(from: alignedStart, mode: mode)
+            )
+        }
+        var iterator = entries.makeIterator()
+        return AnyIterator {
+            guard let date = iterator.next() else {
+                return nil
+            }
+            if date > interval.upperBound, Date.now >= interval.upperBound {
+                return .distantFuture
+            }
+            return date
+        }
+    }
+}

From 2795b7e0549a5c8454fab1c780d132d688e4daf8 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 02:04:51 +0800
Subject: [PATCH 14/25] Add ConditionallyArchivableView

---
 .../ProgressView/ProgressView+Date.swift      |   3 +-
 .../View/Archive/ArchivedViewInput.swift      |   8 ++
 .../Archive/ConditionallyArchivableView.swift | 117 ++++++++++++++++++
 3 files changed, 127 insertions(+), 1 deletion(-)
 create mode 100644 Sources/OpenSwiftUICore/View/Archive/ConditionallyArchivableView.swift

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
index 051a51687..ba10b9062 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
@@ -7,6 +7,7 @@
 //  ID: E25B5CE50FE780022155187DDAA79ACA (SwiftUI)
 
 import Foundation
+@_spi(Private)
 import OpenSwiftUICore
 
 // MARK: - TimelineProgressViewExtendedBase
@@ -66,7 +67,7 @@ struct TimelineProgressView<Base>: View where Base: TimelineProgressViewExtended
         }
     }
 
-    private struct ConditionallyArchivableTimelineProgressView: /*ConditionallyArchivableView*/ View {
+    private struct ConditionallyArchivableTimelineProgressView: ConditionallyArchivableView {
         var interval: ClosedRange<Date>
         var updateStyle: TimelineProgressViewUpdateStyle
         var countdown: Bool
diff --git a/Sources/OpenSwiftUICore/View/Archive/ArchivedViewInput.swift b/Sources/OpenSwiftUICore/View/Archive/ArchivedViewInput.swift
index 501c635e1..9c6d8ddbf 100644
--- a/Sources/OpenSwiftUICore/View/Archive/ArchivedViewInput.swift
+++ b/Sources/OpenSwiftUICore/View/Archive/ArchivedViewInput.swift
@@ -170,3 +170,11 @@ extension _ViewListInputs {
         set { self[ArchivedViewInput.self] = newValue }
     }
 }
+
+extension _ViewListCountInputs {
+    @inline(__always)
+    package var archivedView: ArchivedViewInput.Value {
+        get { self[ArchivedViewInput.self] }
+        set { self[ArchivedViewInput.self] = newValue }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/View/Archive/ConditionallyArchivableView.swift b/Sources/OpenSwiftUICore/View/Archive/ConditionallyArchivableView.swift
new file mode 100644
index 000000000..417c136ad
--- /dev/null
+++ b/Sources/OpenSwiftUICore/View/Archive/ConditionallyArchivableView.swift
@@ -0,0 +1,117 @@
+//
+//  ConditionallyArchivableView.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: F8DD13CD1E8AE0A4CA4BADC71F5C64DE (SwiftUICore)
+
+import OpenAttributeGraphShims
+
+// MARK: - ConditionallyArchivableView
+
+@_spi(Private)
+@available(OpenSwiftUI_v2_0, *)
+public protocol ConditionallyArchivableView: View {
+    associatedtype ArchivedBody: View
+
+    @ViewBuilder
+    var archivedBody: ArchivedBody { get }
+}
+
+@_spi(Private)
+@available(OpenSwiftUI_v2_0, *)
+extension ConditionallyArchivableView {
+    nonisolated public static func _makeView(
+        view: _GraphValue<Self>,
+        inputs: _ViewInputs
+    ) -> _ViewOutputs {
+        let fields = DynamicPropertyCache.fields(of: Self.self)
+        var newInputs = inputs
+        let (body, buffer) = makeBody(
+            view: view,
+            inputs: &newInputs.base,
+            fields: fields
+        )
+        let outputs = body.makeView(inputs: newInputs)
+        if let buffer {
+            buffer.traceMountedProperties(to: view, fields: fields)
+        }
+        return outputs
+    }
+
+    nonisolated public static func _makeViewList(
+        view: _GraphValue<Self>,
+        inputs: _ViewListInputs
+    ) -> _ViewListOutputs {
+        let fields = DynamicPropertyCache.fields(of: Self.self)
+        var newInputs = inputs
+        let (body, buffer) = makeBody(
+            view: view,
+            inputs: &newInputs.base,
+            fields: fields
+        )
+        let outputs = body.makeViewList(inputs: newInputs)
+        if let buffer {
+            buffer.traceMountedProperties(to: view, fields: fields)
+        }
+        return outputs
+    }
+
+    nonisolated public static func _viewListCount(
+        inputs: _ViewListCountInputs
+    ) -> Int? {
+        if inputs.archivedView.isArchived {
+            ArchivedBody._viewListCount(inputs: inputs)
+        } else {
+            Body._viewListCount(inputs: inputs)
+        }
+    }
+
+    nonisolated private static func makeBody(
+        view: _GraphValue<Self>,
+        inputs: inout _GraphInputs,
+        fields: DynamicPropertyCache.Fields
+    ) -> (
+        ConditionalGraphValue<Body, ArchivedBody>,
+        _DynamicPropertyBuffer?
+    ) {
+        precondition(
+            Metadata(Self.self).isValueType,
+            "views must be value types (either a struct or an enum); \(Self.self) is a class."
+        )
+        if inputs.archivedView.isArchived {
+            let accessor = ArchivedViewBodyAccessor<Self>()
+            let (body, buffer) = accessor.makeBody(
+                container: view,
+                inputs: &inputs,
+                fields: fields
+            )
+            return (.second(body), buffer)
+        } else {
+            let accessor = ViewBodyAccessor<Self>()
+            let (body, buffer) = accessor.makeBody(
+                container: view,
+                inputs: &inputs,
+                fields: fields
+            )
+            return (.first(body), buffer)
+        }
+    }
+}
+
+// MARK: - ArchivedViewBodyAccessor
+
+private struct ArchivedViewBodyAccessor<V>: BodyAccessor where V: ConditionallyArchivableView {
+    typealias Container = V
+    typealias Body = V.ArchivedBody
+
+    func updateBody(of container: V, changed: Bool) {
+        guard changed else {
+            return
+        }
+        setBody {
+            container.archivedBody
+        }
+    }
+}

From d98b991cebc226bc2b95022f9dfbb58b331f0721 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 02:08:45 +0800
Subject: [PATCH 15/25] Add _ArchivableView stub

---
 .../View/ArchivedView/ArchivableView.swift    | 20 +++++++++++++++++++
 .../ProgressView/ProgressView+Date.swift      |  2 +-
 2 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift

diff --git a/Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift b/Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift
new file mode 100644
index 000000000..0b6f3ce7a
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift
@@ -0,0 +1,20 @@
+//
+//  ArchivableView.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Blocked by ArchivableFactory
+
+public import OpenSwiftUICore
+
+// MARK: - _ArchivableView [WIP]
+
+protocol _ArchivableView: Codable, View {
+    func sizeThatFits(in proposedSize: _ProposedSize) -> CGSize
+}
+
+extension _ArchivableView {
+    func sizeThatFits(in proposedSize: _ProposedSize) -> CGSize {
+        proposedSize.fixingUnspecifiedDimensions()
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
index ba10b9062..74ba579da 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
@@ -49,7 +49,7 @@ struct TimelineProgressView<Base>: View where Base: TimelineProgressViewExtended
         )
     }
 
-    struct ArchivableTimelineProgressView: /*_ArchivableView*/ View {
+    struct ArchivableTimelineProgressView: _ArchivableView {
         var interval: ClosedRange<Date>
         var updateStyle: TimelineProgressViewUpdateStyle
         var countdown: Bool

From a04dd03ba8981126cfa307f73672fa4b8578cf25 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 02:20:04 +0800
Subject: [PATCH 16/25] Add LinearUIKitProgressView

---
 .../ProgressView/ProgressView+Date.swift      |  6 +++
 .../ProgressView/UIKitProgressView.swift      | 54 +++++++++++++++++--
 2 files changed, 57 insertions(+), 3 deletions(-)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
index 74ba579da..2721741be 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
@@ -24,6 +24,12 @@ protocol TimelineProgressViewBase: TimelineProgressViewExtendedBase where Extend
     init(fractionCompleted: Double, tint: Color?)
 }
 
+extension TimelineProgressViewBase {
+    init(fractionCompleted: Double, tint: Color?, extendedState: ExtendedState) {
+        self.init(fractionCompleted: fractionCompleted, tint: tint)
+    }
+}
+
 // MARK: - _TimelineProgressViewBaseEmptyState
 
 struct _TimelineProgressViewBaseEmptyState: Codable {}
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift
index 78f91f27a..5721b875d 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift
@@ -11,7 +11,55 @@ import COpenSwiftUI
 import OpenSwiftUICore
 import UIKit
 
-// MARK: - LinearUIKitProgressView [TODO]
+// MARK: - LinearUIKitProgressView
+
+struct LinearUIKitProgressView: View {
+    var configuration: ProgressViewStyleConfiguration
+    var tint: Color?
+
+    var body: some View {
+        switch configuration.value {
+        case let .absolute(fractionCompleted, _):
+            Base(
+                fractionCompleted: fractionCompleted ?? 0,
+                tint: tint
+            )
+        case let .dateRelative(interval, countdown):
+            TimelineProgressView<Base>(
+                interval: interval,
+                updateStyle: .default,
+                countdown: countdown,
+                tint: tint,
+                isCircular: false,
+                extendedState: .init()
+            )
+        }
+    }
+
+    struct Base: UIViewRepresentable, TimelineProgressViewBase {
+        var fractionCompleted: Double
+        var tint: Color?
+
+        func makeUIView(context _: Context) -> UIProgressView {
+            OpenSwiftUIProgressView(progressViewStyle: .default)
+        }
+
+        func updateUIView(_ uiView: UIProgressView, context: Context) {
+            uiView.setProgress(
+                Float(fractionCompleted),
+                animated: context.transaction.animation != nil
+            )
+            let newTintColor = tint.map {
+                $0.resolve(in: context.environment).kitColor as! UIColor
+            }
+            if newTintColor != uiView.progressTintColor {
+                uiView.progressTintColor = newTintColor
+            }
+        }
+
+        private class OpenSwiftUIProgressView: UIProgressView {}
+    }
+}
 
 // MARK: - CircularUIKitProgressView
 
@@ -29,7 +77,7 @@ struct CircularUIKitProgressView: UIViewRepresentable {
     }
 
     func makeUIView(context _: Context) -> UIActivityIndicatorView {
-        let uiView = SwiftUIActivityIndicatorView()
+        let uiView = OpenSwiftUIActivityIndicatorView()
         uiView.style = if useCustomWidth {
             .init(rawValue: 16)!
         } else {
@@ -70,7 +118,7 @@ struct CircularUIKitProgressView: UIViewRepresentable {
         }
     }
 
-    private class SwiftUIActivityIndicatorView: UIActivityIndicatorView {}
+    private class OpenSwiftUIActivityIndicatorView: UIActivityIndicatorView {}
 }
 
 #endif

From 759ba3402c8d4bda2dbfd2416d4356a9b9c1f2a9 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 02:40:06 +0800
Subject: [PATCH 17/25] Add ArchivableProgressView

---
 .../ProgressView/ArchivableProgressView.swift | 225 ++++++++++++++++++
 1 file changed, 225 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/ArchivableProgressView.swift

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ArchivableProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ArchivableProgressView.swift
new file mode 100644
index 000000000..024f68bb5
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ArchivableProgressView.swift
@@ -0,0 +1,225 @@
+//
+//  ArchivableProgressView.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+import Foundation
+import OpenSwiftUICore
+
+// MARK: - ArchivableCircularPlaybackProgressView
+
+struct ArchivableCircularPlaybackProgressView: View {
+    var configuration: ProgressViewStyleConfiguration
+    var tint: Color
+
+    var body: some View {
+        ResolvedCircularPlaybackProgressView(
+            configuration: configuration,
+            tint: tint
+        )
+    }
+}
+
+// MARK: - ArchivableCircularProgressView
+
+struct ArchivableCircularProgressView: View {
+    var size: CGFloat
+    var centerFont: CGFloat
+    var configuration: ProgressViewStyleConfiguration
+    var tint: Color?
+    struct Metrics {}
+    let metrics: Metrics
+
+    @ViewBuilder
+    var gaugeRing: some View {
+        switch configuration.value {
+        case let .absolute(fractionCompleted, _):
+            CircularPercentageGaugeRing(
+                fractionCompleted: fractionCompleted ?? 0,
+                tint: tint
+            )
+        case let .dateRelative(interval, countdown):
+            TimelineProgressView<CircularPercentageGaugeRing>(
+                interval: interval,
+                updateStyle: .default,
+                countdown: countdown,
+                tint: tint,
+                isCircular: true,
+                extendedState: .init()
+            )
+        }
+    }
+
+    var body: some View {
+        GeometryReader { proxy in
+            ZStack {
+                gaugeRing
+                VStack {
+                    if configuration.currentValueLabel != nil {
+                        HStack {
+                            configuration.currentValueLabel
+                        }
+                    } else {
+                        HStack {
+                            configuration.label
+                        }
+                    }
+                }
+                .font(
+                    .system(
+                        size: centerFont * proxy.size.height / size,
+                        weight: .semibold,
+                        design: .rounded
+                    )
+                )
+                .frame(height: min(proxy.size.width, proxy.size.height) * 0.5)
+                .labelStyle(.iconOnly)
+                .modifier(_ForegroundLayerViewModifier())
+                .multilineTextAlignment(.center)
+            }
+        }
+        .aspectRatio(1, contentMode: .fit)
+        .minimumScaleFactor(0.01)
+    }
+}
+
+// MARK: - ArchivableLinearProgressView
+
+struct ArchivableLinearProgressView: View {
+    var configuration: ProgressViewStyleConfiguration
+    var tint: Color?
+
+    @ViewBuilder
+    var body: some View {
+        switch configuration.value {
+        case let .absolute(fractionCompleted, _):
+            Base(
+                fractionCompleted: fractionCompleted ?? 0,
+                tint: tint
+            )
+        case let .dateRelative(interval, countdown):
+            TimelineProgressView<Base>(
+                interval: interval,
+                updateStyle: .default,
+                countdown: countdown,
+                tint: tint,
+                isCircular: false,
+                extendedState: .init()
+            )
+        }
+    }
+
+    struct Base: TimelineProgressViewBase {
+        var fractionCompleted: Double
+        var tint: Color?
+
+        var body: some View {
+            LinearCapsuleGauge(value: fractionCompleted)
+            // TODO
+        }
+    }
+}
+
+// MARK: - ResolvedCircularPlaybackProgressView
+
+struct ResolvedCircularPlaybackProgressView: View {
+    var configuration: ProgressViewStyleConfiguration
+    var tint: Color
+
+    var body: some View {
+        switch configuration.value {
+        case let .absolute(fractionCompleted, _):
+            Base(
+                fractionCompleted: fractionCompleted ?? 0,
+                tint: tint
+            )
+        case let .dateRelative(interval, _):
+            TimelineProgressView<Base>(
+                interval: interval,
+                updateStyle: .default,
+                countdown: false,
+                tint: tint,
+                isCircular: true,
+                extendedState: .init()
+            )
+        }
+    }
+
+    struct Base: TimelineProgressViewBase {
+        var fractionCompleted: Double
+        var tint: Color
+
+        init(fractionCompleted: Double, tint: Color?) {
+            self.fractionCompleted = fractionCompleted
+            self.tint = tint ?? .accentColor
+        }
+
+        var body: some View {
+            Circle()
+                .inset(by: 2.0)
+                .trim(from: 0, to: fractionCompleted)
+                .stroke(tint, lineWidth: 4.0)
+                .rotationEffect(.degrees(-90.0))
+        }
+    }
+}
+
+// MARK: - CircularPercentageGaugeRing [TODO]
+
+struct CircularPercentageGaugeRing: TimelineProgressViewBase {
+    var fractionCompleted: Double
+    var tint: AnyShapeStyle
+
+    init(fractionCompleted: Double, tint: Color?) {
+        self.fractionCompleted = fractionCompleted
+        self.tint = AnyShapeStyle(tint ?? .primary)
+    }
+
+    var body: some View {
+        EmptyView()
+    }
+}
+
+// MARK: - LinearCapsuleGauge [TODO]
+
+struct LinearCapsuleGauge: View {
+    var value: Double
+    // @ScaledMetric var height: CGFloat
+    // @Environment(\.) var gaugeTintOverride: (Color, Color)?
+    // @Environment(\.) var controlTint: AnyShapeStyle?
+    // @Environment(\.) var direction: LayoutDirection?
+
+    var body: some View {
+        EmptyView()
+    }
+}
+
+extension Shape {
+    @inlinable
+    nonisolated public func trim(
+        from startFraction: CGFloat = 0,
+        to endFraction: CGFloat = 1
+    ) -> some Shape {
+        // FIXME: _TrimmedShape
+        self
+    }
+}
+
+// FIXME
+typealias _ForegroundLayerViewModifier = EmptyModifier
+
+extension View {
+    func labelStyle(_ style: LabelStyle) -> some View {
+        self
+    }
+}
+
+protocol LabelStyle {}
+
+struct IconOnlyLabelStyle: LabelStyle {}
+
+extension LabelStyle where Self == IconOnlyLabelStyle {
+    static var iconOnly: IconOnlyLabelStyle { .init() }
+}

From e801312af8a3f81fc6bb6b1b64d003a88465e71f Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 03:28:45 +0800
Subject: [PATCH 18/25] Update ProgressViewStyle

---
 .../CircularProgressViewStyle.swift           | 42 +++++++++----------
 .../LinearProgressViewStyle.swift             | 23 +++++-----
 .../ProgressView/UIKitProgressView.swift      |  6 +--
 3 files changed, 35 insertions(+), 36 deletions(-)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift
index 614f1c6c5..0f5e8d6b6 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift
@@ -83,27 +83,27 @@ public struct CircularProgressViewStyle: ProgressViewStyle {
 
     @ViewBuilder
     func fractionCompletedView(configuration: Configuration) -> some View {
-        _openSwiftUIUnreachableCode()
-//        StaticIf(idiom: .widget) {
-//            ArchivableCircularProgressView(
-//                size: 58,
-//                centerFont: 30,
-//                configuration: configuration,
-//                tint: tint ?? controlTint
-//            )
-//        } else: {
-//            StaticIf(idiom: MacInterfaceIdiom.mac) {
-//                CircularUIKitProgressView(
-//                    tint: tint ?? controlTint,
-//                    useCustomWidth: false
-//                )
-//            } else: {
-//                CircularUIKitProgressView(
-//                    tint: tint ?? controlTint,
-//                    useCustomWidth: true
-//                )
-//            }
-//        }
+        StaticIf(idiom: .widget) {
+            ArchivableCircularProgressView(
+                size: 58,
+                centerFont: 30,
+                configuration: configuration,
+                tint: tint ?? controlTint,
+                metrics: .init()
+            )
+        } else: {
+            StaticIf(idiom: MacInterfaceIdiom.mac) {
+                CircularUIKitProgressView(
+                    tint: tint ?? controlTint,
+                    useCustomWidth: false
+                )
+            } else: {
+                CircularUIKitProgressView(
+                    tint: tint ?? controlTint,
+                    useCustomWidth: true
+                )
+            }
+        }
     }
 
     @ViewBuilder
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift
index 09aacd968..e5348af1d 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift
@@ -63,18 +63,17 @@ public struct LinearProgressViewStyle: ProgressViewStyle {
     }
 
     private func progressBar(configuration: Configuration) -> some View {
-        _openSwiftUIUnimplementedFailure()
-//        StaticIf(idiom: .widget) {
-//            ArchivableLinearProgressView(
-//                configuration: configuration,
-//                tint: tint ?? controlTint
-//            )
-//        } else: {
-//            LinearUIKitProgressView(
-//                configuration: configuration,
-//                tint: tint ?? controlTint
-//            )
-//        }
+        StaticIf(idiom: .widget) {
+            ArchivableLinearProgressView(
+                configuration: configuration,
+                tint: tint ?? controlTint
+            )
+        } else: {
+            LinearUIKitProgressView(
+                configuration: configuration,
+                tint: tint ?? controlTint
+            )
+        }
     }
 }
 
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift
index 5721b875d..417d81ae4 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/UIKitProgressView.swift
@@ -65,9 +65,9 @@ struct LinearUIKitProgressView: View {
 
 struct CircularUIKitProgressView: UIViewRepresentable {
     @Environment(\.controlSize) private var controlSize
-    @ScaledMetric private var regular: CGFloat = 20
-    @ScaledMetric private var small: CGFloat = 14
-    @ScaledMetric private var large: CGFloat = 37
+    @ScaledMetric private var regular: CGFloat = 20.0
+    @ScaledMetric private var small: CGFloat = 14.0
+    @ScaledMetric private var large: CGFloat = 37.0
     var tint: Color?
     var useCustomWidth: Bool
 

From cf04617a11cb7f8ba113bdd5cab387095749f2f8 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 03:44:00 +0800
Subject: [PATCH 19/25] Update ProgressViewStyle

---
 .../Accessibility/AccessibilityGeometry.swift | 33 +++++++++++++++++++
 .../ProgressView/ProgressViewStyle.swift      | 26 +++++----------
 .../AccessibilityLabeledContent.swift         | 32 ++++++++++++++++--
 3 files changed, 71 insertions(+), 20 deletions(-)
 create mode 100644 Sources/OpenSwiftUI/Accessibility/AccessibilityGeometry.swift

diff --git a/Sources/OpenSwiftUI/Accessibility/AccessibilityGeometry.swift b/Sources/OpenSwiftUI/Accessibility/AccessibilityGeometry.swift
new file mode 100644
index 000000000..287d9f661
--- /dev/null
+++ b/Sources/OpenSwiftUI/Accessibility/AccessibilityGeometry.swift
@@ -0,0 +1,33 @@
+//
+//  AccessibilityGeometry.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+//  ID: EE68159C4F54001FA5A3813EBA5DD945 (SwiftUI)
+
+@_spi(Private)
+import OpenSwiftUICore
+
+// MARK: - IgnoreViewRespondersModifier
+
+private struct IgnoreViewRespondersModifier: PrimitiveViewModifier, ViewInputsModifier {
+    nonisolated static func _makeViewInputs(
+        modifier _: _GraphValue<Self>,
+        inputs: inout _ViewInputs
+    ) {
+        inputs.needsAccessibilityViewResponders = false
+    }
+}
+
+// MARK: - AccessibilityProgressViewModifier [WIP]
+
+struct AccessibilityProgressViewModifier {
+    var fractionCompleted: Double?
+
+    func body<Content>(content: Content) -> some View where Content: View {
+        content
+            .modifier(IgnoreViewRespondersModifier())
+            // .modifier(AccessibilityAttachmentModifier())
+    }
+}
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressViewStyle.swift
index 6b3fe75b0..e6678ee42 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressViewStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressViewStyle.swift
@@ -3,7 +3,7 @@
 //  OpenSwiftUI
 //
 //  Audited for 6.5.4
-//  Status: WIP
+//  Status: Complete
 
 @_spi(ForOpenSwiftUIOnly)
 public import OpenSwiftUICore
@@ -89,7 +89,6 @@ public struct ProgressViewStyleConfiguration {
     /// label is equivalent to its `localizedAdditionalDescription`.
     public var currentValueLabel: CurrentValueLabel?
 
-    // TBA
     init(
         value: ProgressViewValue,
         label: Label?,
@@ -101,8 +100,8 @@ public struct ProgressViewStyleConfiguration {
             self.fractionCompleted = fractionCompleted
             self.alwaysIndeterminate = alwaysIndeterminate
         case .dateRelative:
-            fractionCompleted = nil
-            alwaysIndeterminate = false
+            self.fractionCompleted = nil
+            self.alwaysIndeterminate = false
         }
         self.label = label
         self.currentValueLabel = currentValueLabel
@@ -141,21 +140,12 @@ struct ResolvedProgressViewStyle: StyleableView {
         ProgressViewStyleModifier(style: DefaultProgressViewStyle())
     }
 
-//    typealias Body = ModifiedContent<
-//        ModifiedContent<
-//            ProgressView<
-//                ProgressViewStyleConfiguration.Label,
-//                ProgressViewStyleConfiguration.CurrentValueLabel
-//            >,
-//            (IgnoreViewRespondersModifier in _EE68159C4F54001FA5A3813EBA5DD945)
-//        >,
-//        AccessibilityAttachmentModifier
-//    >
-
     var body: some View {
-        // TODO: Apply the responder and accessibility modifiers when their
-        // corresponding OpenSwiftUI implementations are available.
-        ProgressView(configuration)
+        AccessibilityProgressViewModifier(
+            fractionCompleted: configuration.fractionCompleted
+        ).body(
+            content: ProgressView(configuration)
+        )
     }
 }
 
diff --git a/Sources/OpenSwiftUI/View/LabelContent/AccessibilityLabeledContent.swift b/Sources/OpenSwiftUI/View/LabelContent/AccessibilityLabeledContent.swift
index c0ed23732..f5e42049e 100644
--- a/Sources/OpenSwiftUI/View/LabelContent/AccessibilityLabeledContent.swift
+++ b/Sources/OpenSwiftUI/View/LabelContent/AccessibilityLabeledContent.swift
@@ -127,10 +127,38 @@ struct ResolvedPresentation: Rule {
 }
 
 // FIXME
-struct AccessibilityAttachmentModifier {}
+class AnyAccessibilityViewModifier {}
 
 // FIXME
-enum AccessibilityAttachment {}
+struct AccessibilityChildBehavior {
+    var modifier: AnyAccessibilityViewModifier
+}
+
+// FIXME
+struct AccessibilityAttachmentModifier: PrimitiveViewModifier {
+    var storage: MutableBox<AccessibilityAttachment>
+
+    let behavior: AccessibilityChildBehavior?
+
+    nonisolated static func _makeView(
+        modifier _: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        body(_Graph(), inputs)
+    }
+
+    nonisolated static func _makeViewList(
+        modifier _: _GraphValue<Self>,
+        inputs: _ViewListInputs,
+        body: @escaping (_Graph, _ViewListInputs) -> _ViewListOutputs
+    ) -> _ViewListOutputs {
+        body(_Graph(), inputs)
+    }
+}
+
+// FIXME
+struct AccessibilityAttachment {}
 
 extension AccessibilityAttachment {
     enum Tree {

From e31bc13d763451372765c5c0e5849098dea87b59 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 04:23:38 +0800
Subject: [PATCH 20/25] Update ControlSize API

---
 .../Environment/PlatformEnvironment.swift     | 14 +-------
 .../Graphic/AppKit/AppKitConversions.swift    | 34 +++++++++++++++++++
 2 files changed, 35 insertions(+), 13 deletions(-)
 create mode 100644 Sources/OpenSwiftUI/Integration/Graphic/AppKit/AppKitConversions.swift

diff --git a/Sources/OpenSwiftUI/Data/Environment/PlatformEnvironment.swift b/Sources/OpenSwiftUI/Data/Environment/PlatformEnvironment.swift
index 691c26b24..f90898f8e 100644
--- a/Sources/OpenSwiftUI/Data/Environment/PlatformEnvironment.swift
+++ b/Sources/OpenSwiftUI/Data/Environment/PlatformEnvironment.swift
@@ -125,19 +125,7 @@ struct OpenSwiftUIFallbackFontProvider: FallbackFontProvider {
 
 extension Font {
     static func _system(controlSize: ControlSize) -> Font {
-        let nsControlSize: NSControl.ControlSize = switch controlSize {
-        case .mini: .mini
-        case .small: .small
-        case .regular: .regular
-        case .large: .large
-        case .extraLarge:
-            if #available(macOS 26, *) {
-                .extraLarge
-            } else {
-                .large
-            }
-        }
-        let size = NSFont.systemFontSize(for: nsControlSize)
+        let size = NSFont.systemFontSize(for: NSControl.ControlSize(controlSize))
         return Font.system(size: size)
     }
 }
diff --git a/Sources/OpenSwiftUI/Integration/Graphic/AppKit/AppKitConversions.swift b/Sources/OpenSwiftUI/Integration/Graphic/AppKit/AppKitConversions.swift
new file mode 100644
index 000000000..b6310ecc2
--- /dev/null
+++ b/Sources/OpenSwiftUI/Integration/Graphic/AppKit/AppKitConversions.swift
@@ -0,0 +1,34 @@
+//
+//  AppKitConversions.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+
+#if canImport(AppKit)
+import AppKit
+import OpenSwiftUICore
+
+// MARK: - ControlSize Conversions
+
+extension NSControl.ControlSize {
+    init(_ controlSize: ControlSize) {
+        switch controlSize {
+        case .mini:
+            self = .mini
+        case .small:
+            self = .small
+        case .regular:
+            self = .regular
+        case .large:
+            self = .large
+        case .extraLarge:
+            if #available(macOS 26.0, *) {
+                self = .extraLarge
+            } else {
+                self = .large
+            }
+        }
+    }
+}
+#endif

From 424d348bdc94a4d6da6e4ffc5ddd9b6f640ce9dd Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 04:24:11 +0800
Subject: [PATCH 21/25] Add AppKitProgressView

---
 .../Shims/AppKit/AppKit_Private.h             |   4 +
 .../ProgressView/AppKitProgressView.swift     | 108 ++++++++++++++++++
 2 files changed, 112 insertions(+)
 create mode 100644 Sources/OpenSwiftUI/View/Control/ProgressView/AppKitProgressView.swift

diff --git a/Sources/COpenSwiftUI/Shims/AppKit/AppKit_Private.h b/Sources/COpenSwiftUI/Shims/AppKit/AppKit_Private.h
index 9c9ae9e69..37ef98f54 100644
--- a/Sources/COpenSwiftUI/Shims/AppKit/AppKit_Private.h
+++ b/Sources/COpenSwiftUI/Shims/AppKit/AppKit_Private.h
@@ -36,6 +36,10 @@ typedef OPENSWIFTUI_ENUM(NSInteger, NSViewVibrantBlendingStyle) {
 - (nullable NSAppearance *)appearanceByApplyingTintColor:(NSColor *)tintColor;
 @end
 
+@interface NSProgressIndicator (OpenSwiftUI_SPI)
+@property (nullable, strong) NSFont *font;
+@end
+
 @interface NSMenu (OpenSwiftUI_SPI)
 + (void)_setAlwaysCallDelegateBeforeSidebandUpdaters_openswiftui_safe_wrapper:(BOOL)value OPENSWIFTUI_SWIFT_NAME(_setAlwaysCallDelegateBeforeSidebandUpdaters(_:));
 + (void)_setAlwaysInstallWindowTabItems_openswiftui_safe_wrapper:(BOOL)value OPENSWIFTUI_SWIFT_NAME(_setAlwaysInstallWindowTabItems(_:));
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/AppKitProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/AppKitProgressView.swift
new file mode 100644
index 000000000..e497e8949
--- /dev/null
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/AppKitProgressView.swift
@@ -0,0 +1,108 @@
+//
+//  AppKitProgressView.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+
+#if os(macOS)
+import AppKit
+import COpenSwiftUI
+import OpenSwiftUICore
+
+// MARK: - AppKitProgressView
+
+struct AppKitProgressView: NSViewRepresentable {
+    var fractionCompleted: Double?
+    var style: NSProgressIndicator.Style
+    var tint: Color?
+
+    @Environment(\.controlSize)
+    private var controlSize
+
+    @Environment(\.effectiveFont)
+    private var font
+
+    func makeNSView(context _: Context) -> NSProgressIndicator {
+        let nsView = NSProgressIndicator()
+        nsView.minValue = 0
+        nsView.maxValue = 1
+        return nsView
+    }
+
+    func updateNSView(_ nsView: NSProgressIndicator, context: Context) {
+        nsView.style = style
+        if fractionCompleted == nil {
+            nsView.startAnimation(nil)
+        } else {
+            nsView.stopAnimation(nil)
+        }
+        nsView.isIndeterminate = fractionCompleted == nil
+        nsView.doubleValue = fractionCompleted ?? 0
+
+        let controlSize = NSControl.ControlSize(controlSize)
+        if nsView.controlSize != controlSize {
+            nsView.controlSize = controlSize
+        }
+
+        nsView.font = font.platformFont(in: context.environment)
+        if let superview = nsView.superview {
+            let appearance = superview.effectiveAppearance
+            nsView.appearance = if let tint, tint != Color.accentColor {
+                appearance.applyingTintColor(.init(tint))
+            } else {
+                nil
+            }
+        }
+    }
+}
+
+// MARK: - LinearAppKitProgressView
+
+struct LinearAppKitProgressView: View {
+    var configuration: ProgressViewStyleConfiguration
+    var tint: Color?
+
+    var body: some View {
+        switch configuration.value {
+        case let .absolute(fractionCompleted, _):
+            Base(
+                fractionCompleted: fractionCompleted,
+                tint: tint
+            )
+        case let .dateRelative(interval, countdown):
+            TimelineProgressView<Base>(
+                interval: interval,
+                updateStyle: .default,
+                countdown: countdown,
+                tint: tint,
+                isCircular: false,
+                extendedState: .init()
+            )
+        }
+    }
+
+    struct Base: TimelineProgressViewBase {
+        var fractionCompleted: Double?
+        var tint: Color?
+
+        init(fractionCompleted: Double?, tint: Color?) {
+            self.fractionCompleted = fractionCompleted
+            self.tint = tint
+        }
+
+        init(fractionCompleted: Double, tint: Color?) {
+            self.fractionCompleted = fractionCompleted
+            self.tint = tint
+        }
+
+        var body: some View {
+            AppKitProgressView(
+                fractionCompleted: fractionCompleted,
+                style: .bar,
+                tint: tint
+            )
+        }
+    }
+}
+#endif

From ade294983ce2bf3b8be3ffcaa7f3af13edbfbaa2 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 04:24:36 +0800
Subject: [PATCH 22/25] Update ProgressViewStyle for AppKit

---
 .../ProgressView/CircularProgressViewStyle.swift       | 10 ++++++++++
 .../Control/ProgressView/LinearProgressViewStyle.swift |  9 +++++++++
 2 files changed, 19 insertions(+)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift
index 0f5e8d6b6..2d9748602 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/CircularProgressViewStyle.swift
@@ -92,6 +92,13 @@ public struct CircularProgressViewStyle: ProgressViewStyle {
                 metrics: .init()
             )
         } else: {
+            #if os(macOS)
+            AppKitProgressView(
+                fractionCompleted: configuration.fractionCompleted,
+                style: .spinning,
+                tint: tint ?? controlTint
+            )
+            #elseif os(iOS) || os(visionOS)
             StaticIf(idiom: MacInterfaceIdiom.mac) {
                 CircularUIKitProgressView(
                     tint: tint ?? controlTint,
@@ -103,6 +110,9 @@ public struct CircularProgressViewStyle: ProgressViewStyle {
                     useCustomWidth: true
                 )
             }
+            #else
+            _openSwiftUIPlatformUnimplementedFailure()
+            #endif
         }
     }
 
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift
index e5348af1d..9f54204fd 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/LinearProgressViewStyle.swift
@@ -69,10 +69,19 @@ public struct LinearProgressViewStyle: ProgressViewStyle {
                 tint: tint ?? controlTint
             )
         } else: {
+            #if os(macOS)
+            LinearAppKitProgressView(
+                configuration: configuration,
+                tint: tint ?? controlTint
+            )
+            #elseif os(iOS) || os(visionOS)
             LinearUIKitProgressView(
                 configuration: configuration,
                 tint: tint ?? controlTint
             )
+            #else
+            _openSwiftUIPlatformUnimplementedFailure()
+            #endif
         }
     }
 }

From fea5becd8aa20cd368ca7c1705f3835704224092 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Tue, 25 Aug 2026 23:23:06 +0800
Subject: [PATCH 23/25] Add DefaultDateProgressLabel

---
 .../ProgressView/ProgressView+Date.swift      | 141 +++++++++++++++++-
 .../View/Text/Text/Text+Date.swift            |  38 +++++
 2 files changed, 178 insertions(+), 1 deletion(-)

diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
index 2721741be..e2985a16c 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ProgressView+Date.swift
@@ -6,10 +6,149 @@
 //  Status: Complete
 //  ID: E25B5CE50FE780022155187DDAA79ACA (SwiftUI)
 
-import Foundation
+public import Foundation
 @_spi(Private)
 import OpenSwiftUICore
 
+// MARK: - DefaultDateProgressLabel
+
+/// The default current value label used by a date-relative progress view.
+@available(OpenSwiftUI_v4_0, *)
+public struct DefaultDateProgressLabel: View {
+    var interval: ClosedRange<Date>
+    var countdown: Bool
+
+    public var body: some View {
+        Text(
+            timerInterval: interval,
+            countsDown: countdown
+        )
+    }
+}
+
+@available(*, unavailable)
+extension DefaultDateProgressLabel: Sendable {}
+
+// MARK: - Date-Relative Initializers
+
+@available(OpenSwiftUI_v4_0, *)
+extension ProgressView {
+    /// Creates a progress view that displays progress over a date interval.
+    nonisolated public init(
+        timerInterval: ClosedRange<Date>,
+        countsDown: Bool = true,
+        @ViewBuilder label: () -> Label,
+        @ViewBuilder currentValueLabel: () -> CurrentValueLabel
+    ) {
+        base = .custom(
+            CustomProgressView(
+                interval: timerInterval,
+                countdown: countsDown,
+                label: label(),
+                currentValueLabel: currentValueLabel()
+            )
+        )
+    }
+}
+
+@_spi(_)
+@available(OpenSwiftUI_v4_0, *)
+extension ProgressView {
+    @available(*, deprecated, renamed: "init(timerInterval:countsDown:label:currentValueLabel:)")
+    nonisolated public init(
+        interval: ClosedRange<Date>,
+        countdown: Bool = true,
+        @ViewBuilder label: () -> Label,
+        @ViewBuilder currentValueLabel: () -> CurrentValueLabel
+    ) {
+        self.init(
+            timerInterval: interval,
+            countsDown: countdown,
+            label: label,
+            currentValueLabel: currentValueLabel
+        )
+    }
+}
+
+@available(OpenSwiftUI_v4_0, *)
+extension ProgressView where CurrentValueLabel == DefaultDateProgressLabel {
+    /// Creates a progress view that displays progress over a date interval and
+    /// uses the default current value label.
+    nonisolated public init(
+        timerInterval: ClosedRange<Date>,
+        countsDown: Bool = true,
+        @ViewBuilder label: () -> Label
+    ) {
+        base = .custom(
+            CustomProgressView(
+                interval: timerInterval,
+                countdown: countsDown,
+                label: label(),
+                currentValueLabel: DefaultDateProgressLabel(
+                    interval: timerInterval,
+                    countdown: countsDown
+                )
+            )
+        )
+    }
+}
+
+@_spi(_)
+@available(OpenSwiftUI_v4_0, *)
+extension ProgressView where CurrentValueLabel == DefaultDateProgressLabel {
+    @_spi(_)
+    @available(*, deprecated, renamed: "init(timerInterval:countsDown:label:)")
+    nonisolated public init(
+        interval: ClosedRange<Date>,
+        countdown: Bool = true,
+        @ViewBuilder label: () -> Label
+    ) {
+        self.init(
+            timerInterval: interval,
+            countsDown: countdown,
+            label: label
+        )
+    }
+}
+
+@available(OpenSwiftUI_v4_0, *)
+extension ProgressView where Label == EmptyView, CurrentValueLabel == DefaultDateProgressLabel {
+    /// Creates an unlabeled progress view that displays progress over a date
+    /// interval and uses the default current value label.
+    nonisolated public init(
+        timerInterval: ClosedRange<Date>,
+        countsDown: Bool = true
+    ) {
+        base = .custom(
+            CustomProgressView(
+                interval: timerInterval,
+                countdown: countsDown,
+                label: nil,
+                currentValueLabel: DefaultDateProgressLabel(
+                    interval: timerInterval,
+                    countdown: countsDown
+                )
+            )
+        )
+    }
+}
+
+@_spi(_)
+@available(OpenSwiftUI_v4_0, *)
+extension ProgressView where Label == EmptyView, CurrentValueLabel == DefaultDateProgressLabel {
+    @_spi(_)
+    @available(*, deprecated, renamed: "init(timerInterval:countsDown:)")
+    nonisolated public init(
+        interval: ClosedRange<Date>,
+        countdown: Bool = true
+    ) {
+        self.init(
+            timerInterval: interval,
+            countsDown: countdown
+        )
+    }
+}
+
 // MARK: - TimelineProgressViewExtendedBase
 
 protocol TimelineProgressViewExtendedBase: View {
diff --git a/Sources/OpenSwiftUICore/View/Text/Text/Text+Date.swift b/Sources/OpenSwiftUICore/View/Text/Text/Text+Date.swift
index 614131075..f9928fccc 100644
--- a/Sources/OpenSwiftUICore/View/Text/Text/Text+Date.swift
+++ b/Sources/OpenSwiftUICore/View/Text/Text/Text+Date.swift
@@ -157,6 +157,44 @@ extension Text {
     }
 }
 
+// MARK: - Text + Timer Interval
+
+@available(OpenSwiftUI_v4_0, *)
+extension Text {
+    /// Creates a text view that displays a timer over a date interval.
+    public init(
+        timerInterval: ClosedRange<Date>,
+        pauseTime: Date? = nil,
+        countsDown: Bool = true,
+        showsHours: Bool = true
+    ) {
+        let pause = pauseTime.map {
+            $0.timeIntervalSince(timerInterval.lowerBound)
+        }
+        let interval = DateInterval(
+            start: timerInterval.lowerBound,
+            end: timerInterval.upperBound
+        )
+        let units: NSCalendar.Unit = if showsHours {
+            ResolvableTimer.defaultUnits
+        } else {
+            [.minute, .second]
+        }
+        let timer = ResolvableTimer(
+            interval: interval,
+            pause: pause,
+            countdown: countsDown,
+            units: units,
+            in: EnvironmentValues()
+        )
+        self.init(
+            source: timer.source,
+            format: timer.format,
+            reducedLuminanceBudget: 60.0
+        )
+    }
+}
+
 // TDOO
 
 // MARK: - Text + ReferenceDate

From dbc68d043f5abeed140d96df39295516cd08da39 Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Wed, 26 Aug 2026 00:17:33 +0800
Subject: [PATCH 24/25] Add ProgressView UI tests

---
 .../View/ProgressViewUITests.swift            | 33 ++++++++
 Example/Shared/View/ProgressViewExample.swift | 79 +++++++++++++++++++
 2 files changed, 112 insertions(+)
 create mode 100644 Example/OpenSwiftUIUITests/View/ProgressViewUITests.swift
 create mode 100644 Example/Shared/View/ProgressViewExample.swift

diff --git a/Example/OpenSwiftUIUITests/View/ProgressViewUITests.swift b/Example/OpenSwiftUIUITests/View/ProgressViewUITests.swift
new file mode 100644
index 000000000..ebd731ba4
--- /dev/null
+++ b/Example/OpenSwiftUIUITests/View/ProgressViewUITests.swift
@@ -0,0 +1,33 @@
+//
+//  ProgressViewUITests.swift
+//  OpenSwiftUIUITests
+
+import SnapshotTesting
+import Testing
+@testable import TestingHost
+
+@MainActor
+@Suite(.snapshots(record: .never, diffTool: diffTool))
+struct ProgressViewUITests {
+    @Test
+    func valueBasedProgress() {
+        openSwiftUIAssertSnapshot(of: ProgressViewExample())
+    }
+
+    @Test
+    func indeterminateInitializers() {
+        openSwiftUIAssertSnapshot(of: IndeterminateProgressViewExample())
+    }
+
+    @Test(.disabled("ResolvableTextSegmentAttribute is not implemented yet"))
+    func defaultDateProgressLabelInitializers() {
+        openSwiftUIAssertSnapshot(of: DefaultDateProgressLabelExample())
+    }
+
+    @Test(
+        .disabled(if: attributeGraphVendor == .compute, "Temporarily disabled for IAG snapshot crash")
+    )
+    func foundationProgress() {
+        openSwiftUIAssertSnapshot(of: FoundationProgressViewExample())
+    }
+}
diff --git a/Example/Shared/View/ProgressViewExample.swift b/Example/Shared/View/ProgressViewExample.swift
new file mode 100644
index 000000000..a35ed7264
--- /dev/null
+++ b/Example/Shared/View/ProgressViewExample.swift
@@ -0,0 +1,79 @@
+//
+//  ProgressViewExample.swift
+//  Shared
+
+import Foundation
+#if OPENSWIFTUI
+import OpenSwiftUI
+#else
+import SwiftUI
+#endif
+
+struct ProgressViewExample: View {
+    var body: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            ProgressView(value: 0.25)
+            ProgressView("Downloading", value: 0.5)
+            ProgressView(value: 0.75) {
+                Text("Installing")
+            } currentValueLabel: {
+                Text("75%")
+            }
+            .tint(.blue)
+        }
+        .padding()
+    }
+}
+
+struct IndeterminateProgressViewExample: View {
+    private let localizedTitle: LocalizedStringKey = "Localized label"
+    private let title = "String label"
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            ProgressView()
+            ProgressView {
+                Text("Custom label")
+            }
+            ProgressView(localizedTitle)
+            ProgressView(title)
+        }
+        .padding()
+    }
+}
+
+struct DefaultDateProgressLabelExample: View {
+    private let timerInterval = Date(timeIntervalSinceReferenceDate: 0)...Date(
+        timeIntervalSinceReferenceDate: 90
+    )
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            ProgressView(timerInterval: timerInterval) {
+                Text("Countdown")
+            }
+            ProgressView(
+                timerInterval: timerInterval,
+                countsDown: false
+            )
+        }
+        .padding()
+    }
+}
+
+struct FoundationProgressViewExample: View {
+    private let progress: Progress
+
+    init() {
+        let progress = Progress(totalUnitCount: 100)
+        progress.completedUnitCount = 40
+        progress.localizedDescription = "Downloading"
+        progress.localizedAdditionalDescription = "40%"
+        self.progress = progress
+    }
+
+    var body: some View {
+        ProgressView(progress)
+            .padding()
+    }
+}

From bad1fd1cdfe8ad60fc5fe35e8af874ff3a8eaa3e Mon Sep 17 00:00:00 2001
From: Kyle <kyle201817146@gmail.com>
Date: Wed, 26 Aug 2026 01:29:26 +0800
Subject: [PATCH 25/25] Fix ProgressView Linux build

---
 Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift      | 1 +
 .../View/Control/ProgressView/ArchivableProgressView.swift      | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift b/Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift
index 0b6f3ce7a..6dfbb7399 100644
--- a/Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift
+++ b/Sources/OpenSwiftUI/View/ArchivedView/ArchivableView.swift
@@ -5,6 +5,7 @@
 //  Audited for 6.5.4
 //  Status: Blocked by ArchivableFactory
 
+public import Foundation
 public import OpenSwiftUICore
 
 // MARK: - _ArchivableView [WIP]
diff --git a/Sources/OpenSwiftUI/View/Control/ProgressView/ArchivableProgressView.swift b/Sources/OpenSwiftUI/View/Control/ProgressView/ArchivableProgressView.swift
index 024f68bb5..f51f065ee 100644
--- a/Sources/OpenSwiftUI/View/Control/ProgressView/ArchivableProgressView.swift
+++ b/Sources/OpenSwiftUI/View/Control/ProgressView/ArchivableProgressView.swift
@@ -5,7 +5,7 @@
 //  Audited for 6.5.4
 //  Status: Complete
 
-import Foundation
+public import Foundation
 import OpenSwiftUICore
 
 // MARK: - ArchivableCircularPlaybackProgressView