@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/Controls.swift

@@ -0,0 +1,268 @@
+// MARK: - TextField
+
+public protocol TextFieldStyle {
+    var _name: String { get }
+}
+public struct DefaultTextFieldStyle: TextFieldStyle {
+    public init() {}
+    public var _name: String { "plain" }
+}
+public struct PlainTextFieldStyle: TextFieldStyle {
+    public init() {}
+    public var _name: String { "plain" }
+}
+public struct RoundedBorderTextFieldStyle: TextFieldStyle {
+    public init() {}
+    public var _name: String { "roundedBorder" }
+}
+extension TextFieldStyle where Self == DefaultTextFieldStyle {
+    public static var automatic: DefaultTextFieldStyle { DefaultTextFieldStyle() }
+}
+extension TextFieldStyle where Self == PlainTextFieldStyle {
+    public static var plain: PlainTextFieldStyle { PlainTextFieldStyle() }
+}
+extension TextFieldStyle where Self == RoundedBorderTextFieldStyle {
+    public static var roundedBorder: RoundedBorderTextFieldStyle { RoundedBorderTextFieldStyle() }
+}
+
+extension View {
+    public func textFieldStyle<S: TextFieldStyle>(_ style: S) -> some View {
+        environment(\._textFieldStyle, style._name)
+    }
+}
+
+/// Formats a value as text and parses text back (`Text(_:format:)`,
+/// `TextField(_:value:format:)`). `FoundationLite` conforms its format styles
+/// (`.number`, `.currency(code:)`); the shim itself has none.
+public protocol _TextFormat {
+    associatedtype Input
+    func _formatText(_ value: Input) -> String
+    func _parseText(_ text: String) -> Input?
+}
+
+/// What the user typed into a formatted field, and the formatted form of the
+/// value it parsed to. The field shows the typed text while the bound value
+/// still formats to that form; an outside change to the value replaces it.
+struct _TextDraft {
+    var typed: String
+    var formatted: String
+}
+
+public struct TextField<Label: View> {
+    let placeholder: String
+    let text: Binding<String>
+    let secure: Bool
+    /// Persistent storage for `TextField(_:value:format:)` (unused otherwise);
+    /// a `State` so the runtime keeps it across re-renders.
+    let draft: State<_TextDraft?>
+
+    init(placeholder: String, text: Binding<String>, secure: Bool) {
+        self.placeholder = placeholder
+        self.text = text
+        self.secure = secure
+        draft = State(wrappedValue: nil)
+    }
+}
+
+extension TextField where Label == Text {
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>) {
+        self.init(placeholder: String(title), text: text, secure: false)
+    }
+
+    /// The prompt, when given, is the placeholder; the title names the field.
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>, prompt: Text?) {
+        self.init(placeholder: prompt?.content ?? String(title), text: text, secure: false)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>, prompt: Text? = nil) {
+        self.init(placeholder: prompt?.content ?? titleKey.key, text: text, secure: false)
+    }
+
+    /// A field bound to a value through a format: it shows the formatted value
+    /// and, as the user types, parses the text and sets the value when parsing
+    /// succeeds. The typed text stays visible while the value matches it.
+    public init<S: StringProtocol, F: _TextFormat>(_ title: S, value: Binding<F.Input>, format: F,
+                                                   prompt: Text? = nil) {
+        self.init(_placeholder: prompt?.content ?? String(title), value: value, format: format)
+    }
+
+    public init<F: _TextFormat>(_ titleKey: LocalizedStringKey, value: Binding<F.Input>, format: F,
+                                prompt: Text? = nil) {
+        self.init(_placeholder: prompt?.content ?? titleKey.key, value: value, format: format)
+    }
+
+    /// The formatted field with its placeholder resolved; public so a bridge
+    /// module can wrap other format protocols (FoundationBridge wraps
+    /// Foundation's `ParseableFormatStyle`) without re-entering the public
+    /// initializers above.
+    public init<F: _TextFormat>(_placeholder placeholder: String, value: Binding<F.Input>, format: F) {
+        let draft = State<_TextDraft?>(wrappedValue: nil)
+        let text = Binding<String>(
+            get: {
+                let formatted = format._formatText(value.wrappedValue)
+                if let current = draft.wrappedValue, current.formatted == formatted { return current.typed }
+                return formatted
+            },
+            set: { typed in
+                if let parsed = format._parseText(typed) {
+                    draft.wrappedValue = _TextDraft(typed: typed, formatted: format._formatText(parsed))
+                    value.wrappedValue = parsed
+                } else {
+                    let formatted = draft.wrappedValue?.formatted ?? format._formatText(value.wrappedValue)
+                    draft.wrappedValue = _TextDraft(typed: typed, formatted: formatted)
+                }
+            }
+        )
+        self.placeholder = placeholder
+        self.text = text
+        secure = false
+        self.draft = draft
+    }
+}
+extension TextField: _PrimitiveView {}
+extension TextField: _HostView {
+    var _kind: String { "textfield" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON] = [
+            "text": .string(text.wrappedValue),
+            "placeholder": .string(placeholder),
+            "style": .string(environment._textFieldStyle),
+            "secure": .bool(secure),
+        ]
+        // Phase 12: `.focused(...)` binds the field's focus; `.onSubmit` wants
+        // the Enter key; `.submitLabel` names the return key.
+        if let focus = environment._focus { props["focused"] = .bool(focus.isFocused()) }
+        if environment._onSubmit != nil { props["submit"] = .bool(true) }
+        if let label = environment._submitLabel { props["submitLabel"] = .string(label) }
+        return .object(props)
+    }
+    var _handler: ((_JSON) -> Void)? { _handler(in: EnvironmentValues()) }
+}
+extension TextField: _EnvironmentHandling {
+    /// Text (`"value"` as a string), `focus` (`{type, value: Bool}`) and `submit` (`{type}`) events.
+    func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)? {
+        let text = self.text
+        let focus = environment._focus
+        let onSubmit = environment._onSubmit
+        return { payload in
+            switch payload {
+            case .string(let value):
+                text.wrappedValue = value
+            case .object(let fields):
+                switch fields["type"] {
+                case .string("focus")?:
+                    if case .bool(let focused)? = fields["value"] { focus?.setFocused(focused) }
+                case .string("submit")?:
+                    onSubmit?()
+                default:
+                    break
+                }
+            default:
+                break
+            }
+        }
+    }
+}
+
+public struct SecureField<Label: View> {
+    let field: TextField<Label>
+}
+extension SecureField where Label == Text {
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>) {
+        field = TextField(placeholder: String(title), text: text, secure: true)
+    }
+}
+extension SecureField: _PrimitiveView {}
+extension SecureField: _HostView {
+    var _kind: String { "textfield" }
+    func _props(in environment: EnvironmentValues) -> _JSON { field._props(in: environment) }
+    var _handler: ((_JSON) -> Void)? { field._handler }
+}
+extension SecureField: _EnvironmentHandling {
+    func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)? { field._handler(in: environment) }
+}
+
+// MARK: - Toggle
+
+public struct Toggle<Label: View> {
+    let isOn: Binding<Bool>
+    let label: Label
+
+    public init(isOn: Binding<Bool>, @ViewBuilder label: () -> Label) {
+        self.isOn = isOn
+        self.label = label()
+    }
+}
+extension Toggle where Label == Text {
+    public init<S: StringProtocol>(_ title: S, isOn: Binding<Bool>) {
+        self.init(isOn: isOn) { Text(title) }
+    }
+}
+extension Toggle: _PrimitiveView {}
+extension Toggle: _HostView {
+    var _kind: String { "toggle" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["isOn": .bool(isOn.wrappedValue)]) }
+    var _content: [any View] { [label] }
+    var _handler: ((_JSON) -> Void)? {
+        let isOn = self.isOn
+        return { payload in
+            if case .bool(let value) = payload { isOn.wrappedValue = value }
+        }
+    }
+}
+
+// MARK: - Label
+
+/// A title and an icon, laid out like SwiftUI's default label style.
+public struct Label<Title: View, Icon: View>: View {
+    let title: Title
+    let icon: Icon
+
+    public init(@ViewBuilder title: () -> Title, @ViewBuilder icon: () -> Icon) {
+        self.title = title()
+        self.icon = icon()
+    }
+
+    public var body: some View {
+        _StyledLabel(title: title, icon: icon)
+    }
+}
+
+extension Label where Title == Text, Icon == Image {
+    public init<S: StringProtocol>(_ title: S, systemImage: String) {
+        self.title = Text(title)
+        self.icon = Image(systemName: systemImage)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, systemImage: String) {
+        self.title = Text(titleKey)
+        self.icon = Image(systemName: systemImage)
+    }
+
+    public init<S: StringProtocol>(_ title: S, image name: String) {
+        self.title = Text(title)
+        self.icon = Image(name)
+    }
+}
+
+// MARK: - Enabling
+
+extension View {
+    public func disabled(_ disabled: Bool) -> some View {
+        _styled { $0.disabled = disabled ? true : nil }
+    }
+
+    /// Runs `action` once, right after the view is first rendered.
+    public func onAppear(perform action: (@MainActor () -> Void)? = nil) -> some View {
+        _OnAppearView(content: self, action: action)
+    }
+}
+
+struct _OnAppearView<Content: View> {
+    let content: Content
+    let action: (@MainActor () -> Void)?
+}
+extension _OnAppearView: _PrimitiveView {}
+extension _OnAppearView: _GroupView {
+    var _children: [any View] { [content] }
+}

package/Sources/SwiftUI/API/CustomLayout.swift

@@ -0,0 +1,403 @@
+// The `Layout` protocol, measured by the host. The Swift side has no text
+// metrics, so a custom layout cannot measure its children itself: the
+// renderer measures them (minimum, ideal and maximum size for the proposal
+// it places the `layout` element with) and reports the results in a `layout`
+// event. The runtime then runs `sizeThatFits` / `placeSubviews` and sends the
+// resulting size and frames back as props. See docs/ops-protocol.md (Phase 6).
+
+// MARK: - Public API
+
+/// A size proposed to a view; a `nil` dimension means "whatever you want".
+public struct ProposedViewSize: Equatable, Sendable {
+    public var width: CGFloat?
+    public var height: CGFloat?
+
+    public init(width: CGFloat?, height: CGFloat?) {
+        self.width = width
+        self.height = height
+    }
+
+    public init(_ size: CGSize) {
+        self.init(width: size.width, height: size.height)
+    }
+
+    public static let zero = ProposedViewSize(width: 0, height: 0)
+    public static let unspecified = ProposedViewSize(width: nil, height: nil)
+    public static let infinity = ProposedViewSize(width: .infinity, height: .infinity)
+
+    public func replacingUnspecifiedDimensions(by size: CGSize = CGSize(width: 10, height: 10)) -> CGSize {
+        CGSize(width: width ?? size.width, height: height ?? size.height)
+    }
+
+    var _json: _JSON {
+        .object(["width": _dimensionJSON(width), "height": _dimensionJSON(height)])
+    }
+}
+
+/// The size of a view, as `LayoutSubview.dimensions(in:)` reports it.
+public struct ViewDimensions: Equatable, Sendable {
+    public var width: CGFloat
+    public var height: CGFloat
+
+    init(width: CGFloat, height: CGFloat) {
+        self.width = width
+        self.height = height
+    }
+
+    public subscript(guide: HorizontalAlignment) -> CGFloat {
+        switch guide.name {
+        case "leading": 0
+        case "trailing": width
+        default: width / 2
+        }
+    }
+
+    public subscript(guide: VerticalAlignment) -> CGFloat {
+        switch guide.name {
+        case "top": 0
+        case "bottom": height
+        default: height / 2
+        }
+    }
+}
+
+/// Preferred spacing around a view. The shim has no per-view spacing
+/// preferences: every distance is the system default (8 points).
+public struct ViewSpacing: Equatable, Sendable {
+    public init() {}
+    public static let zero = ViewSpacing()
+
+    public func distance(to next: ViewSpacing, along axis: Axis) -> CGFloat { 8 }
+    public mutating func formUnion(_ other: ViewSpacing, edges: Edge.Set = .all) {}
+    public func union(_ other: ViewSpacing, edges: Edge.Set = .all) -> ViewSpacing { self }
+}
+
+/// Characteristics of a layout the system may take into account.
+public struct LayoutProperties: Sendable {
+    public var stackOrientation: Axis?
+    public init() {}
+}
+
+/// A key for values a subview exposes to its layout via `layoutValue(key:value:)`.
+/// The shim does not propagate such values; the layout always sees the default.
+public protocol LayoutValueKey {
+    associatedtype Value
+    static var defaultValue: Value { get }
+}
+
+extension View {
+    /// Accepted for source compatibility: custom layouts read `K.defaultValue`.
+    public func layoutValue<K: LayoutValueKey>(key: K.Type, value: K.Value) -> some View { self }
+}
+
+/// A proxy for one child of a custom layout.
+///
+/// The sizes come from the renderer's measurement of the child: its minimum
+/// (proposal 0), ideal (proposal `nil`) and maximum (proposal infinity).
+/// `sizeThatFits` answers from those: the ideal for an unspecified axis,
+/// otherwise the proposal clamped to the minimum and maximum.
+public struct LayoutSubview {
+    let index: Int
+    let min: CGSize
+    let ideal: CGSize
+    let max: CGSize
+    let placements: _LayoutPlacements
+
+    public func sizeThatFits(_ proposal: ProposedViewSize) -> CGSize {
+        CGSize(
+            width: Self.fit(proposal.width, min: min.width, ideal: ideal.width, max: max.width),
+            height: Self.fit(proposal.height, min: min.height, ideal: ideal.height, max: max.height)
+        )
+    }
+
+    static func fit(_ proposed: CGFloat?, min: CGFloat, ideal: CGFloat, max: CGFloat) -> CGFloat {
+        guard let proposed else { return ideal }
+        let lower = Swift.min(min, max)
+        return Swift.max(lower, Swift.min(proposed, max))
+    }
+
+    public func dimensions(in proposal: ProposedViewSize) -> ViewDimensions {
+        let size = sizeThatFits(proposal)
+        return ViewDimensions(width: size.width, height: size.height)
+    }
+
+    public var spacing: ViewSpacing { ViewSpacing() }
+
+    public var priority: Double { 0 }
+
+    public subscript<K: LayoutValueKey>(key: K.Type) -> K.Value { K.defaultValue }
+
+    /// Records where the child goes. Its size is `sizeThatFits(proposal)` and
+    /// `anchor` says which point of that size sits at `position`.
+    public func place(at position: CGPoint, anchor: UnitPoint = .topLeading, proposal: ProposedViewSize) {
+        let size = sizeThatFits(proposal)
+        let origin = CGPoint(x: position.x - anchor.x * size.width, y: position.y - anchor.y * size.height)
+        placements.frames[index] = CGRect(origin: origin, size: size)
+    }
+}
+
+/// Frames recorded by `LayoutSubview.place`, shared by every proxy of one pass.
+public final class _LayoutPlacements {
+    var frames: [Int: CGRect] = [:]
+    init() {}
+}
+
+/// The children of a custom layout.
+public struct LayoutSubviews: RandomAccessCollection, Equatable {
+    public typealias Element = LayoutSubview
+    public typealias Index = Int
+    public typealias SubSequence = LayoutSubviews
+
+    let subviews: [LayoutSubview]
+    public let startIndex: Int
+    public let endIndex: Int
+
+    init(_ subviews: [LayoutSubview]) {
+        self.subviews = subviews
+        startIndex = 0
+        endIndex = subviews.count
+    }
+
+    private init(_ subviews: [LayoutSubview], range: Range<Int>) {
+        self.subviews = subviews
+        startIndex = range.lowerBound
+        endIndex = range.upperBound
+    }
+
+    public subscript(position: Int) -> LayoutSubview { subviews[position] }
+
+    public subscript(bounds: Range<Int>) -> LayoutSubviews {
+        precondition(bounds.lowerBound >= startIndex && bounds.upperBound <= endIndex, "LayoutSubviews index out of range")
+        return LayoutSubviews(subviews, range: bounds)
+    }
+
+    public static func == (lhs: LayoutSubviews, rhs: LayoutSubviews) -> Bool {
+        lhs.startIndex == rhs.startIndex && lhs.endIndex == rhs.endIndex
+            && lhs.subviews.count == rhs.subviews.count
+            && lhs.subviews.indices.allSatisfy {
+                lhs.subviews[$0].min == rhs.subviews[$0].min
+                    && lhs.subviews[$0].ideal == rhs.subviews[$0].ideal
+                    && lhs.subviews[$0].max == rhs.subviews[$0].max
+            }
+    }
+}
+
+/// A custom container layout. Conforming types compile unchanged against
+/// Apple's SwiftUI; see the file comment for how measurement works here.
+public protocol Layout {
+    associatedtype Cache = Void
+    typealias Subviews = LayoutSubviews
+
+    static var layoutProperties: LayoutProperties { get }
+
+    func makeCache(subviews: Subviews) -> Cache
+    func updateCache(_ cache: inout Cache, subviews: Subviews)
+    func spacing(subviews: Subviews, cache: inout Cache) -> ViewSpacing
+    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout Cache) -> CGSize
+    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout Cache)
+    func explicitAlignment(of guide: HorizontalAlignment, in bounds: CGRect, proposal: ProposedViewSize,
+                           subviews: Subviews, cache: inout Cache) -> CGFloat?
+    func explicitAlignment(of guide: VerticalAlignment, in bounds: CGRect, proposal: ProposedViewSize,
+                           subviews: Subviews, cache: inout Cache) -> CGFloat?
+}
+
+extension Layout {
+    public static var layoutProperties: LayoutProperties { LayoutProperties() }
+
+    public func updateCache(_ cache: inout Cache, subviews: Subviews) {
+        cache = makeCache(subviews: subviews)
+    }
+
+    public func spacing(subviews: Subviews, cache: inout Cache) -> ViewSpacing { ViewSpacing() }
+
+    public func explicitAlignment(of guide: HorizontalAlignment, in bounds: CGRect, proposal: ProposedViewSize,
+                                  subviews: Subviews, cache: inout Cache) -> CGFloat? { nil }
+
+    public func explicitAlignment(of guide: VerticalAlignment, in bounds: CGRect, proposal: ProposedViewSize,
+                                  subviews: Subviews, cache: inout Cache) -> CGFloat? { nil }
+}
+
+extension Layout where Cache == Void {
+    public func makeCache(subviews: Subviews) -> Cache { () }
+    public func updateCache(_ cache: inout Cache, subviews: Subviews) {}
+}
+
+extension Layout {
+    /// Uses the layout as a container: `MyLayout { child; child }`.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        _LayoutView(layout: self, content: content())
+    }
+}
+
+// MARK: - Runtime
+
+/// The result of running a layout for one host measurement; what the `layout`
+/// element's props carry. Values are rounded to 2 decimals when stored so an
+/// unchanged measurement compares equal and emits no `update`.
+struct _LayoutResult: Equatable {
+    var proposal: ProposedViewSize
+    var size: CGSize
+    var frames: [CGRect]
+    /// The layout's own flexibility: `sizeThatFits` for a zero, unspecified and
+    /// infinite proposal. The host reads these when a parent measures the
+    /// layout with a proposal other than the one it answered, instead of
+    /// guessing from the answered size.
+    var sizes: _LayoutSizes
+
+    var _json: [String: _JSON] {
+        [
+            "proposal": proposal._json,
+            "size": .object(["width": .number(size.width), "height": .number(size.height)]),
+            "frames": .array(frames.map {
+                .object(["x": .number($0.minX), "y": .number($0.minY),
+                         "width": .number($0.width), "height": .number($0.height)])
+            }),
+            "sizes": sizes._json,
+        ]
+    }
+}
+
+/// A layout's min / ideal / max sizes. Infinite dimensions serialize as
+/// `"infinity"`, like proposals do.
+struct _LayoutSizes: Equatable {
+    var min: CGSize
+    var ideal: CGSize
+    var max: CGSize
+
+    var _json: _JSON {
+        func size(_ s: CGSize) -> _JSON {
+            .object(["width": _dimensionJSON(s.width), "height": _dimensionJSON(s.height)])
+        }
+        return .object(["min": size(min), "ideal": size(ideal), "max": size(max)])
+    }
+}
+
+/// Holds a layout's cache across measurements without triggering renders.
+final class _LayoutCacheBox {
+    var cache: Any?
+}
+
+/// The element a custom layout renders as: kind `layout`, the children
+/// flattened inside it like a `zstack`'s. The host measures the children and
+/// sends a `layout` event; the handler runs the layout and stores the result
+/// in `State`, so it persists across re-renders and invalidates on change.
+struct _LayoutView<L: Layout, Content: View> {
+    let layout: L
+    let content: Content
+    @State var result: _LayoutResult? = nil
+    @State var cacheBox = _LayoutCacheBox()
+
+    init(layout: L, content: Content) {
+        self.layout = layout
+        self.content = content
+    }
+}
+extension _LayoutView: _PrimitiveView {}
+extension _LayoutView: _HostView {
+    var _kind: String { "layout" }
+
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(result?._json ?? ["proposal": .null, "size": .null, "frames": .null])
+    }
+
+    var _content: [any View] { [content] }
+
+    var _handler: ((_JSON) -> Void)? {
+        let layout = self.layout
+        let resultBox = _result.box
+        let cacheBox = self.cacheBox
+        return { event in
+            guard let (proposal, subviews) = _parseLayoutEvent(event) else { return }
+            let computed = _runLayout(layout, proposal: proposal, subviews: subviews, cacheBox: cacheBox)
+            if computed != resultBox.value { resultBox.value = computed }
+        }
+    }
+}
+
+/// Parses `{"proposal": {...}, "children": [{"min", "ideal", "max"}]}`.
+func _parseLayoutEvent(_ event: _JSON) -> (ProposedViewSize, LayoutSubviews)? {
+    guard case .object(let fields) = event else { return nil }
+    let proposal: ProposedViewSize
+    if case .object(let p)? = fields["proposal"] {
+        proposal = ProposedViewSize(width: _dimension(p["width"]), height: _dimension(p["height"]))
+    } else {
+        proposal = .unspecified
+    }
+    guard case .array(let children)? = fields["children"] else { return nil }
+    let placements = _LayoutPlacements()
+    let subviews = children.enumerated().map { index, child in
+        func size(_ key: String) -> CGSize {
+            guard case .object(let c) = child, case .object(let s)? = c[key] else { return .zero }
+            return CGSize(width: _dimension(s["width"]) ?? 0, height: _dimension(s["height"]) ?? 0)
+        }
+        return LayoutSubview(index: index, min: size("min"), ideal: size("ideal"), max: size("max"),
+                             placements: placements)
+    }
+    return (proposal, LayoutSubviews(subviews))
+}
+
+/// Runs `sizeThatFits` and `placeSubviews`; unplaced subviews are centered at
+/// their ideal size, like SwiftUI does.
+func _runLayout<L: Layout>(_ layout: L, proposal: ProposedViewSize, subviews: LayoutSubviews,
+                           cacheBox: _LayoutCacheBox) -> _LayoutResult {
+    var cache: L.Cache
+    if let existing = cacheBox.cache as? L.Cache {
+        cache = existing
+        layout.updateCache(&cache, subviews: subviews)
+    } else {
+        cache = layout.makeCache(subviews: subviews)
+    }
+    // The flexibility probes run before the answer so `placeSubviews` sees the
+    // cache state `sizeThatFits` left for the real proposal.
+    let sizes = _LayoutSizes(
+        min: _rounded(layout.sizeThatFits(proposal: .zero, subviews: subviews, cache: &cache)),
+        ideal: _rounded(layout.sizeThatFits(proposal: .unspecified, subviews: subviews, cache: &cache)),
+        max: _rounded(layout.sizeThatFits(proposal: .infinity, subviews: subviews, cache: &cache))
+    )
+    let size = layout.sizeThatFits(proposal: proposal, subviews: subviews, cache: &cache)
+    let bounds = CGRect(origin: .zero, size: size)
+    layout.placeSubviews(in: bounds, proposal: proposal, subviews: subviews, cache: &cache)
+    cacheBox.cache = cache
+
+    let placements = subviews.first?.placements
+    let frames = subviews.map { subview -> CGRect in
+        if let frame = placements?.frames[subview.index] { return _rounded(frame) }
+        let ideal = subview.ideal
+        return _rounded(CGRect(x: bounds.midX - ideal.width / 2, y: bounds.midY - ideal.height / 2,
+                               width: ideal.width, height: ideal.height))
+    }
+    return _LayoutResult(
+        proposal: proposal,
+        size: CGSize(width: _round2(size.width), height: _round2(size.height)),
+        frames: frames,
+        sizes: sizes
+    )
+}
+
+/// A dimension from an event: a number, the string `"infinity"`, or nothing.
+func _dimension(_ json: _JSON?) -> CGFloat? {
+    switch json {
+    case .number(let n)?: n
+    case .string("infinity")?: .infinity
+    default: nil
+    }
+}
+
+func _dimensionJSON(_ value: CGFloat?) -> _JSON {
+    guard let value else { return .null }
+    return value == .infinity ? .string("infinity") : .number(_round2(value))
+}
+
+/// Rounds to 2 decimals so float noise never flips a snapshot.
+func _round2(_ value: CGFloat) -> CGFloat {
+    guard value.isFinite else { return value }
+    return (value * 100).rounded() / 100
+}
+
+private func _rounded(_ rect: CGRect) -> CGRect {
+    CGRect(x: _round2(rect.minX), y: _round2(rect.minY), width: _round2(rect.width), height: _round2(rect.height))
+}
+
+private func _rounded(_ size: CGSize) -> CGSize {
+    CGSize(width: _round2(size.width), height: _round2(size.height))
+}