@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/PresentationExtras.swift

@@ -0,0 +1,60 @@
+// Sheet and transition modifiers accepted for source compatibility. The
+// page's sheet keeps its system background, corner radius and drag (to
+// dismiss, and between detents); a navigation push or sheet keeps its own
+// slide instead of iOS 18's zoom from a source view.
+//
+// `.presentationBackground`, `.presentationCornerRadius`,
+// `.presentationBackgroundInteraction`, `.presentationSizing`,
+// `.presentationDragIndicator`, `.interactiveDismissDisabled` (the sheet can
+// still be dragged down), `.navigationTransition` and
+// `.matchedTransitionSource` add nothing to the tree.
+
+public struct PresentationBackgroundInteraction: Sendable {
+    let name: String
+    public static let automatic = PresentationBackgroundInteraction(name: "automatic")
+    public static let enabled = PresentationBackgroundInteraction(name: "enabled")
+    public static func enabled(upThrough detent: PresentationDetent) -> PresentationBackgroundInteraction { .enabled }
+    public static let disabled = PresentationBackgroundInteraction(name: "disabled")
+}
+
+public struct PresentationSizing: Sendable {
+    let name: String
+    public static let automatic = PresentationSizing(name: "automatic")
+    public static let page = PresentationSizing(name: "page")
+    public static let form = PresentationSizing(name: "form")
+    public static let fitted = PresentationSizing(name: "fitted")
+}
+
+/// A navigation transition (iOS 18); the page keeps the standard one.
+public struct NavigationTransition: Sendable {
+    let name: String
+    public static let automatic = NavigationTransition(name: "automatic")
+    public static func zoom<ID: Hashable>(sourceID: ID, in namespace: Namespace.ID) -> NavigationTransition {
+        NavigationTransition(name: "zoom")
+    }
+}
+
+/// What `matchedTransitionSource(id:in:configuration:)` configures; unused.
+public struct EmptyMatchedTransitionSourceConfiguration: Sendable {
+    public func background(_ style: Color) -> EmptyMatchedTransitionSourceConfiguration { self }
+    public func clipShape(_ shape: RoundedRectangle) -> EmptyMatchedTransitionSourceConfiguration { self }
+    public func shadow(color: Color = .black, radius: CGFloat, x: CGFloat = 0, y: CGFloat = 0)
+        -> EmptyMatchedTransitionSourceConfiguration { self }
+}
+
+nonisolated extension View {
+    public func presentationBackground<S: ShapeStyle>(_ style: S) -> some View { self }
+    public func presentationBackground<V: View>(alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View { self }
+    public func presentationCornerRadius(_ cornerRadius: CGFloat?) -> some View { self }
+    public func presentationBackgroundInteraction(_ interaction: PresentationBackgroundInteraction) -> some View { self }
+    public func presentationSizing(_ sizing: PresentationSizing) -> some View { self }
+    public func presentationDragIndicator(_ visibility: Visibility) -> some View { self }
+    public func interactiveDismissDisabled(_ isDisabled: Bool = true) -> some View { self }
+
+    public func navigationTransition(_ style: NavigationTransition) -> some View { self }
+    public func matchedTransitionSource<ID: Hashable>(id: ID, in namespace: Namespace.ID) -> some View { self }
+    public func matchedTransitionSource<ID: Hashable>(
+        id: ID, in namespace: Namespace.ID,
+        configuration: (EmptyMatchedTransitionSourceConfiguration) -> EmptyMatchedTransitionSourceConfiguration
+    ) -> some View { self }
+}

package/Sources/SwiftUI/API/Primitives.swift

@@ -0,0 +1,517 @@
+import Foundation
+
+// MARK: - Text
+
+/// A localization key, as Xcode writes it in a string catalog: the literal
+/// text with a specifier for each interpolation (`"\(count) posts"` is the
+/// key `"%lld posts"` with the argument `count`), looked up in the app's string
+/// tables when shown (Localization/Localization.swift). A key the tables lack
+/// is its own text.
+public struct LocalizedStringKey: Equatable, Sendable, ExpressibleByStringInterpolation {
+    /// The key, with `%%` for a literal percent sign when it has arguments.
+    let formatKey: String
+    let arguments: [Argument]
+
+    /// An interpolated value: one a specifier formats, or a view in the text.
+    enum Argument: Equatable, Sendable {
+        case value(_LocalizationArgument)
+        case image(Image)
+        case text(Text)
+
+        var formatted: _LocalizationArgument? {
+            if case .value(let value) = self { return value }
+            return nil
+        }
+    }
+
+    public init(_ value: String) { formatKey = value; arguments = [] }
+    public init(stringLiteral value: String) { formatKey = value; arguments = [] }
+    public init(stringInterpolation: StringInterpolation) {
+        formatKey = stringInterpolation.key
+        arguments = stringInterpolation.arguments
+    }
+
+    /// The localized text, views left out: what titles, labels and placeholders show.
+    public var key: String { _resolved(table: nil, bundlePath: nil) }
+
+    /// The localized text from `table` in the bundle at `bundlePath` (the main bundle when nil).
+    public func _resolved(table: String?, bundlePath: String?) -> String {
+        _Localization.string(key: formatKey, arguments: arguments.map(\.formatted), table: table, bundlePath: bundlePath)
+    }
+
+    /// The localized pieces, with the views in their places.
+    func _pieces(table: String?, bundlePath: String?) -> [_LocalizedPiece] {
+        _Localization.resolve(key: formatKey, arguments: arguments.map(\.formatted), table: table, bundlePath: bundlePath)
+    }
+
+    /// Builds the key as SwiftUI does: each interpolation adds the specifier of
+    /// its type (`%@` for strings and views, `%lld` for `Int`, `%lf` for
+    /// `Double`…) and an argument; literal percent signs are doubled.
+    public struct StringInterpolation: StringInterpolationProtocol {
+        var key = ""
+        var arguments: [Argument] = []
+        public init(literalCapacity: Int, interpolationCount: Int) {}
+
+        public mutating func appendLiteral(_ literal: String) {
+            key += literal.replacingOccurrences(of: "%", with: "%%")
+        }
+
+        /// An argument with its specifier: for the shim's own interpolations (a date with a style).
+        public mutating func _append(_ argument: _LocalizationArgument, specifier: String) {
+            key += specifier
+            arguments.append(.value(argument))
+        }
+
+        /// A string the shim made (a formatted value): `%@`.
+        mutating func append(_ string: String) { _append(.string(string), specifier: "%@") }
+
+        public mutating func appendInterpolation(_ string: String) { append(string) }
+        public mutating func appendInterpolation<T>(_ value: T) { append(String(describing: value)) }
+        /// A number, with its type's specifier (`%lld` for `Int`, `%lf` for `Double`…).
+        public mutating func appendInterpolation<T: _FormatSpecifiable>(_ value: T) {
+            _append(value._localizationArgument, specifier: T._specifier)
+        }
+
+        /// `"\(value, specifier: "%.1f")"`: the key holds the given specifier.
+        public mutating func appendInterpolation<T>(_ value: T, specifier: String) {
+            _append((value as? any _FormatSpecifiable)?._localizationArgument ?? .string(String(describing: value)), specifier: specifier)
+        }
+
+        /// `"\(price, format: .currency(code: "USD"))"`: `%@`, the formatted value.
+        public mutating func appendInterpolation<F: FormatStyle>(_ value: F.FormatInput, format: F) where F.FormatOutput == String {
+            append(format.format(value))
+        }
+
+        /// An image inline in the text: `Text("\(Image(systemName: "star")) Favorites")`.
+        public mutating func appendInterpolation(_ image: Image) {
+            key += "%@"
+            arguments.append(.image(image))
+        }
+
+        /// A styled text inline: `Text("Hello \(Text("world").bold())")`.
+        public mutating func appendInterpolation(_ text: Text) {
+            key += "%@"
+            arguments.append(.text(text))
+        }
+    }
+}
+
+// MARK: - Image
+
+/// An SF Symbol (`systemName`) or an image from the app's asset catalog
+/// (`name`, possibly namespaced like `"dough/plain-full"`). The renderer owns
+/// the pixels: asset images come from the catalog manifest the web side
+/// builds from `Examples/<App>/*.xcassets` (see docs/ops-protocol.md).
+public struct Image: Equatable, Sendable {
+    enum Source: Equatable, Sendable {
+        case system(String)
+        case named(String)
+        /// Phase 13: a remote image the browser loads itself (`AsyncImage`);
+        /// `width` and `height` are its intrinsic size in points.
+        case url(String, width: Double, height: Double)
+        /// A `UIImage` or `CGImage` bitmap the page draws from its recipe
+        /// (Bitmaps.swift); `width` and `height` are its size in points.
+        case bitmap(_ImageRecipe, width: Double, height: Double)
+    }
+
+    let source: Source
+    /// `.resizable()`: fill the proposed size instead of the intrinsic one.
+    let isResizable: Bool
+    /// `.interpolation(.none)`: scaled without smoothing (a QR code's modules
+    /// stay square). The other levels draw as the browser smooths.
+    var interpolation: Interpolation = .high
+
+    public init(systemName: String) {
+        source = .system(systemName)
+        isResizable = false
+    }
+
+    /// An image from the asset catalog, which is the whole app's: packages'
+    /// catalogs included. `Image(_:bundle:)` (FoundationBridge, which has
+    /// `Bundle`) draws the same image.
+    public init(_ name: String) {
+        source = .named(name)
+        isResizable = false
+    }
+
+    /// A catalog image hidden from assistive technology (no bridge in the
+    /// browser, so it draws like `Image(_:)`). `bundle:` as for `Image(_:)`.
+    public init(decorative name: String) {
+        source = .named(name)
+        isResizable = false
+    }
+
+    init(source: Source, isResizable: Bool) {
+        self.source = source
+        self.isResizable = isResizable
+    }
+
+    /// An image at a URL the host has already loaded (`AsyncImage` asks it
+    /// to, and learns the pixel size); `scale` turns pixels into points.
+    public init(_url url: String, pixelWidth: Double, pixelHeight: Double, scale: Double) {
+        let factor = scale > 0 ? scale : 1
+        source = .url(url, width: pixelWidth / factor, height: pixelHeight / factor)
+        isResizable = false
+    }
+
+    /// The SF Symbol name, for labels that render the icon as a glyph (tab
+    /// items, menu pickers); nil for catalog images.
+    var systemName: String? {
+        if case .system(let name) = source { return name }
+        return nil
+    }
+
+    public func resizable() -> Image {
+        var copy = Image(source: source, isResizable: true)
+        copy.interpolation = interpolation
+        return copy
+    }
+
+    /// `.none` draws without smoothing; the other levels are the browser's.
+    public enum Interpolation: Hashable, Sendable {
+        case none, low, medium, high
+    }
+
+    public func interpolation(_ interpolation: Interpolation) -> Image {
+        var copy = self
+        copy.interpolation = interpolation
+        return copy
+    }
+    public func antialiased(_ isAntialiased: Bool) -> Image { self }
+
+    /// Whether an image draws its own colors or, as a template, the foreground
+    /// color through its shape. SF Symbols are templates already.
+    public enum TemplateRenderingMode: Hashable, Sendable {
+        case template, original
+    }
+
+    /// Approximation: a bitmap draws its own colors either way (tint one with
+    /// `UIImage.withTintColor(_:)`); symbols take the foreground color as before.
+    public func renderingMode(_ renderingMode: TemplateRenderingMode?) -> Image { self }
+
+    /// Symbols draw in one color here, whatever the mode (as the View modifier).
+    public func symbolRenderingMode(_ mode: SymbolRenderingMode?) -> Image { self }
+
+    /// The page draws images in the browser's range.
+    public func allowedDynamicRange(_ range: DynamicRange?) -> Image { self }
+
+    public struct DynamicRange: Hashable, Sendable {
+        let name: String
+        public static let standard = DynamicRange(name: "standard")
+        public static let constrainedHigh = DynamicRange(name: "constrainedHigh")
+        public static let high = DynamicRange(name: "high")
+    }
+}
+extension Image: _PrimitiveView {}
+extension Image: _HostView {
+    var _kind: String { "image" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON]
+        switch source {
+        case .system(let name):
+            return .object(["systemName": .string(name)])
+        case .named(let name):
+            props = ["name": .string(name), "resizable": .bool(isResizable)]
+        case .url(let url, let width, let height):
+            props = ["url": .string(url), "resizable": .bool(isResizable), "width": .number(width), "height": .number(height)]
+        case .bitmap(let recipe, let width, let height):
+            props = ["bitmap": recipe.json, "resizable": .bool(isResizable), "width": .number(width), "height": .number(height)]
+        }
+        if interpolation == .none { props["interpolation"] = .string("none") }
+        return .object(props)
+    }
+}
+
+// MARK: - Stacks
+
+public struct VStack<Content: View> {
+    let alignment: HorizontalAlignment
+    let spacing: CGFloat?
+    let content: Content
+
+    public init(alignment: HorizontalAlignment = .center, spacing: CGFloat? = nil,
+                @ViewBuilder content: () -> Content) {
+        self.alignment = alignment
+        self.spacing = spacing
+        self.content = content()
+    }
+}
+extension VStack: _PrimitiveView {}
+extension VStack: _HostView {
+    var _kind: String { "vstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["spacing": spacing.map(_JSON.number) ?? .null, "alignment": .string(alignment.name)])
+    }
+    var _content: [any View] { [content] }
+}
+
+public struct HStack<Content: View> {
+    let alignment: VerticalAlignment
+    let spacing: CGFloat?
+    let content: Content
+
+    public init(alignment: VerticalAlignment = .center, spacing: CGFloat? = nil,
+                @ViewBuilder content: () -> Content) {
+        self.alignment = alignment
+        self.spacing = spacing
+        self.content = content()
+    }
+}
+extension HStack: _PrimitiveView {}
+extension HStack: _HostView {
+    var _kind: String { "hstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["spacing": spacing.map(_JSON.number) ?? .null, "alignment": .string(alignment.name)])
+    }
+    var _content: [any View] { [content] }
+}
+
+public struct ZStack<Content: View> {
+    let alignment: Alignment
+    let content: Content
+
+    public init(alignment: Alignment = .center, @ViewBuilder content: () -> Content) {
+        self.alignment = alignment
+        self.content = content()
+    }
+}
+extension ZStack: _PrimitiveView {}
+extension ZStack: _HostView {
+    var _kind: String { "zstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["alignment": .string(alignment._name)]) }
+    var _content: [any View] { [content] }
+}
+
+/// Shows the first of its children whose ideal size fits the proposed space
+/// on `axes` (the last when none fits). The renderer measures and chooses
+/// (see docs/ops-protocol.md, Phase 7); the children are all its candidates.
+public struct ViewThatFits<Content: View> {
+    let axes: Axis.Set
+    let content: Content
+
+    public init(in axes: Axis.Set = [.horizontal, .vertical], @ViewBuilder content: () -> Content) {
+        self.axes = axes
+        self.content = content()
+    }
+}
+extension ViewThatFits: _PrimitiveView {}
+extension ViewThatFits: _HostView {
+    var _kind: String { "viewthatfits" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["axes": .string(axes._name)]) }
+    var _content: [any View] { [content] }
+}
+
+public struct Spacer: Sendable {
+    let minLength: CGFloat?
+    public init(minLength: CGFloat? = nil) { self.minLength = minLength }
+}
+extension Spacer: _PrimitiveView {}
+extension Spacer: _HostView {
+    var _kind: String { "spacer" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["minLength": minLength.map(_JSON.number) ?? .null])
+    }
+}
+
+public struct Divider: Sendable {
+    public init() {}
+}
+extension Divider: _PrimitiveView {}
+extension Divider: _HostView {
+    var _kind: String { "divider" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+}
+
+// MARK: - ScrollView
+
+public enum Axis: Int8, CaseIterable, Sendable {
+    case horizontal, vertical
+
+    public struct Set: OptionSet, Sendable {
+        public let rawValue: Int8
+        public init(rawValue: Int8) { self.rawValue = rawValue }
+        public static let horizontal = Set(rawValue: 1 << 0)
+        public static let vertical = Set(rawValue: 1 << 1)
+
+        /// `"horizontal"`, `"vertical"` or `"both"` (also for an empty set).
+        var _name: String {
+            if self == .horizontal { return "horizontal" }
+            if self == .vertical { return "vertical" }
+            return "both"
+        }
+    }
+}
+
+public struct ScrollView<Content: View> {
+    let axes: Axis.Set
+    let content: Content
+    /// `.refreshable`: true while the action runs.
+    @State var refreshing = false
+
+    public init(_ axes: Axis.Set = .vertical, showsIndicators: Bool = true,
+                @ViewBuilder content: () -> Content) {
+        self.axes = axes
+        self.content = content()
+    }
+}
+extension ScrollView: _PrimitiveView {}
+extension ScrollView: _HostView {
+    var _kind: String { "scrollview" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON] = ["axes": .string(axes._name)]
+        _refresh(in: environment).addProps(to: &props)
+        if let snap = environment._scrollTargetBehavior { props["snap"] = .string(snap) }
+        // `.scrollDismissesKeyboard` (ScrollModifiers.swift).
+        if environment._scrollDismissesKeyboard { props["dismissesKeyboard"] = .bool(true) }
+        return .object(props)
+    }
+    var _content: [any View] { [content] }
+}
+extension ScrollView: _EnvironmentContent {
+    /// `.contentMargins` above (ScrollModifiers.swift): padding inside the scroll view.
+    func _content(in environment: EnvironmentValues) -> [any View] {
+        guard let margins = environment._scrollContentMargins else { return [content] }
+        return [content.padding(margins)]
+    }
+}
+extension ScrollView: _Refreshing {
+    func _refresh(in environment: EnvironmentValues) -> _Refresh {
+        _Refresh(action: environment._refreshAction, refreshing: $refreshing)
+    }
+}
+
+// MARK: - Button
+
+public struct ButtonRole: Equatable, Sendable {
+    let name: String
+    public static let destructive = ButtonRole(name: "destructive")
+    public static let cancel = ButtonRole(name: "cancel")
+}
+
+public struct Button<Label: View> {
+    let action: @MainActor () -> Void
+    let role: ButtonRole?
+    let label: Label
+
+    public init(action: @escaping @MainActor () -> Void, @ViewBuilder label: () -> Label) {
+        self.action = action
+        self.role = nil
+        self.label = label()
+    }
+
+    public init(role: ButtonRole?, action: @escaping @MainActor () -> Void,
+                @ViewBuilder label: () -> Label) {
+        self.action = action
+        self.role = role
+        self.label = label()
+    }
+}
+
+extension Button where Label == Text {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, action: @escaping @MainActor () -> Void) {
+        self.init(action: action) { Text(title) }
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, role: ButtonRole?, action: @escaping @MainActor () -> Void) {
+        self.init(role: role, action: action) { Text(title) }
+    }
+
+    public init(_ titleKey: LocalizedStringKey, action: @escaping @MainActor () -> Void) {
+        self.init(action: action) { Text(titleKey) }
+    }
+
+    public init(_ titleKey: LocalizedStringKey, role: ButtonRole?, action: @escaping @MainActor () -> Void) {
+        self.init(role: role, action: action) { Text(titleKey) }
+    }
+}
+
+extension Button where Label == SwiftUI.Label<Text, Image> {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, systemImage: String, action: @escaping @MainActor () -> Void) {
+        let title = String(title)
+        self.init(action: action) { SwiftUI.Label(title, systemImage: systemImage) }
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, systemImage: String, role: ButtonRole?,
+                                   action: @escaping @MainActor () -> Void) {
+        let title = String(title)
+        self.init(role: role, action: action) { SwiftUI.Label(title, systemImage: systemImage) }
+    }
+
+    public init(_ titleKey: LocalizedStringKey, systemImage: String, action: @escaping @MainActor () -> Void) {
+        self.init(action: action) { SwiftUI.Label(titleKey, systemImage: systemImage) }
+    }
+
+    public init(_ titleKey: LocalizedStringKey, systemImage: String, role: ButtonRole?,
+                action: @escaping @MainActor () -> Void) {
+        self.init(role: role, action: action) { SwiftUI.Label(titleKey, systemImage: systemImage) }
+    }
+}
+extension Button: _PrimitiveView {}
+extension Button: _HostView {
+    var _kind: String { "button" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object([
+            // A custom `ButtonStyle` draws its own look: `plain` (ButtonStyles.swift).
+            "style": .string(environment._buttonStyle == _CustomButtonStyle.marker ? "plain" : environment._buttonStyle),
+            "role": role.map { .string($0.name) } ?? .null,
+        ])
+    }
+    var _content: [any View] { [label] }
+    var _handler: ((_JSON) -> Void)? {
+        let action = self.action
+        return { _ in MainActor.assumeIsolated { action() } }
+    }
+}
+
+// MARK: - Button styles
+
+public protocol PrimitiveButtonStyle {
+    var _name: String { get }
+}
+
+public struct DefaultButtonStyle: PrimitiveButtonStyle {
+    public init() {}
+    public var _name: String { "automatic" }
+}
+public struct PlainButtonStyle: PrimitiveButtonStyle {
+    public init() {}
+    public var _name: String { "plain" }
+}
+public struct BorderedButtonStyle: PrimitiveButtonStyle {
+    public init() {}
+    public var _name: String { "bordered" }
+}
+public struct BorderedProminentButtonStyle: PrimitiveButtonStyle {
+    public init() {}
+    public var _name: String { "borderedProminent" }
+}
+
+public struct BorderlessButtonStyle: PrimitiveButtonStyle {
+    public init() {}
+    public var _name: String { "plain" }
+}
+extension PrimitiveButtonStyle where Self == BorderlessButtonStyle {
+    public static var borderless: BorderlessButtonStyle { BorderlessButtonStyle() }
+}
+extension PrimitiveButtonStyle where Self == DefaultButtonStyle {
+    public static var automatic: DefaultButtonStyle { DefaultButtonStyle() }
+}
+extension PrimitiveButtonStyle where Self == PlainButtonStyle {
+    public static var plain: PlainButtonStyle { PlainButtonStyle() }
+}
+extension PrimitiveButtonStyle where Self == BorderedButtonStyle {
+    public static var bordered: BorderedButtonStyle { BorderedButtonStyle() }
+}
+extension PrimitiveButtonStyle where Self == BorderedProminentButtonStyle {
+    public static var borderedProminent: BorderedProminentButtonStyle { BorderedProminentButtonStyle() }
+}
+
+nonisolated extension View {
+    public func buttonStyle<S: PrimitiveButtonStyle>(_ style: S) -> some View {
+        environment(\._buttonStyle, style._name)
+    }
+}

package/Sources/SwiftUI/API/Publishers.swift

@@ -0,0 +1,107 @@
+/// The sliver of Combine that SwiftUI code reaches for without importing
+/// Combine (Apple's SwiftUI re-exports it): `onReceive(_:perform:)` on a
+/// publisher such as `Timer.publish(…).autoconnect()`. A `_Publisher` delivers
+/// values to one subscriber at a time, on the main actor, until cancelled.
+public protocol _Publisher {
+    associatedtype Output
+    /// Starts delivering values; the returned cancellable stops it.
+    @MainActor func _subscribe(_ receive: @escaping @MainActor (Output) -> Void) -> any _Cancellable
+}
+
+public protocol _Cancellable: Sendable {
+    func cancel()
+}
+
+/// A cancellable backed by a task (publishers that tick from the executor).
+public struct _TaskCancellable: _Cancellable {
+    let task: Task<Void, Never>
+    public init(_ task: Task<Void, Never>) { self.task = task }
+    public func cancel() { task.cancel() }
+}
+
+/// Emits `make()` every `interval` seconds, from the executor's clock (the same
+/// clock as `.task` sleeps, so headless runs stay deterministic).
+/// `Timer.publish` in FoundationBridge wraps this with `{ Date() }`.
+public struct _IntervalPublisher<Output: Sendable>: _Publisher, Sendable {
+    public let interval: Double
+    let make: @Sendable () -> Output
+
+    public init(every interval: Double, make: @escaping @Sendable () -> Output) {
+        self.interval = interval
+        self.make = make
+    }
+
+    /// Starts ticking as soon as `onReceive` subscribes; Combine's `autoconnect`
+    /// has the same effect, so this is the identity.
+    public func autoconnect() -> _IntervalPublisher<Output> { self }
+
+    @MainActor public func _subscribe(_ receive: @escaping @MainActor (Output) -> Void) -> any _Cancellable {
+        let interval = max(interval, 0.001)
+        let make = self.make
+        let task = Task { @MainActor in
+            while !Task.isCancelled {
+                try? await Task.sleep(for: .seconds(interval))
+                if Task.isCancelled { break }
+                receive(make())
+            }
+        }
+        return _TaskCancellable(task)
+    }
+}
+
+/// The executor-driven timer behind `Timer.scheduledTimer(withTimeInterval:repeats:block:)`:
+/// fires `block` after `interval` seconds, again every `interval` when
+/// repeating, until `invalidate()`. Like Foundation's, a scheduled timer stays
+/// alive until it has fired (or forever while repeating) whether or not the
+/// caller keeps a reference.
+public final class _ExecutorTimer: @unchecked Sendable {
+    public let timeInterval: Double
+    public private(set) var isValid = true
+    private var task: Task<Void, Never>?
+
+    public init(interval: Double, repeats: Bool, block: @escaping @Sendable (_ExecutorTimer) -> Void) {
+        timeInterval = interval
+        task = Task { @MainActor in
+            repeat {
+                try? await Task.sleep(for: .seconds(max(interval, 0.001)))
+                guard self.isValid, !Task.isCancelled else { return }
+                block(self)
+            } while repeats && !Task.isCancelled
+            self.isValid = false
+        }
+    }
+
+    public func invalidate() {
+        isValid = false
+        task?.cancel()
+        task = nil
+    }
+}
+
+/// `onReceive` is a task that subscribes while the view is on screen (the
+/// runtime starts it on appear and cancels it when the view leaves).
+struct _OnReceiveView<Content: View, P: _Publisher>: View {
+    let content: Content
+    let publisher: P
+    let action: @MainActor (P.Output) -> Void
+    var body: some View {
+        let publisher = self.publisher
+        let action = self.action
+        return content.task { @MainActor in
+            let cancellable = publisher._subscribe(action)
+            // Stay alive until cancelled; the publisher drives the callbacks.
+            while !Task.isCancelled {
+                try? await Task.sleep(for: .seconds(3600))
+            }
+            cancellable.cancel()
+        }
+    }
+}
+
+nonisolated extension View {
+    /// Calls `action` with every value `publisher` emits while the view is shown.
+    @MainActor
+    public func onReceive<P: _Publisher>(_ publisher: P, perform action: @escaping @MainActor (P.Output) -> Void) -> some View {
+        _OnReceiveView(content: self, publisher: publisher, action: action)
+    }
+}