@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/Runtime/JSONParser.swift

@@ -0,0 +1,443 @@
+/// RFC 8259 parser for `_JSON`. Like the serializer in JSON.swift it uses no
+/// Foundation (see Geometry.swift): it walks the UTF-8 bytes of the input with
+/// an index and builds numbers by hand.
+///
+/// Rejected on purpose: trailing garbage, trailing commas, leading zeros
+/// (`01`), control characters inside strings, unknown escapes, lone UTF-16
+/// surrogates, unterminated input, and nesting deeper than 512 levels (a
+/// recursive parser would otherwise overflow the stack on hostile input).
+
+/// Error thrown by `_JSON.parse`. `offset` is the UTF-8 byte offset into the
+/// input at which the problem was detected.
+public struct _JSONParseError: Error, CustomStringConvertible, Sendable {
+    public let message: String
+    public let offset: Int
+
+    public init(message: String, offset: Int) {
+        self.message = message
+        self.offset = offset
+    }
+
+    public var description: String { "\(message) at byte offset \(offset)" }
+}
+
+extension _JSON {
+    /// Parses one JSON text. Any number of whitespace characters may surround
+    /// the value; anything else before or after it is an error.
+    public static func parse(_ text: String) throws(_JSONParseError) -> _JSON {
+        var parser = _JSONParser(bytes: Array(text.utf8))
+        parser.skipWhitespace()
+        let value = try parser.parseValue()
+        parser.skipWhitespace()
+        if parser.index < parser.bytes.count {
+            throw parser.error("unexpected characters after the JSON value")
+        }
+        return value
+    }
+}
+
+private struct _JSONParser {
+    /// Nesting limit for arrays and objects.
+    static let maxDepth = 512
+
+    let bytes: [UInt8]
+    var index = 0
+    private var depth = 0
+
+    init(bytes: [UInt8]) {
+        self.bytes = bytes
+    }
+
+    // MARK: Helpers
+
+    private var peek: UInt8? { index < bytes.count ? bytes[index] : nil }
+
+    func error(_ message: String) -> _JSONParseError {
+        error(message, at: index)
+    }
+
+    func error(_ message: String, at offset: Int) -> _JSONParseError {
+        _JSONParseError(message: message, offset: offset)
+    }
+
+    private func endOfInput() -> _JSONParseError {
+        error("unexpected end of input", at: bytes.count)
+    }
+
+    mutating func skipWhitespace() {
+        while index < bytes.count {
+            switch bytes[index] {
+            case 0x20, 0x09, 0x0A, 0x0D: index += 1  // space, tab, LF, CR
+            default: return
+            }
+        }
+    }
+
+    private static func isDigit(_ byte: UInt8) -> Bool {
+        byte >= 0x30 && byte <= 0x39  // '0'...'9'
+    }
+
+    // MARK: Values
+
+    mutating func parseValue() throws(_JSONParseError) -> _JSON {
+        guard let byte = peek else { throw endOfInput() }
+        switch byte {
+        case 0x7B:  // {
+            return try parseObject()
+        case 0x5B:  // [
+            return try parseArray()
+        case 0x22:  // "
+            return .string(try parseString())
+        case 0x74:  // t
+            try expectLiteral("true")
+            return .bool(true)
+        case 0x66:  // f
+            try expectLiteral("false")
+            return .bool(false)
+        case 0x6E:  // n
+            try expectLiteral("null")
+            return .null
+        case 0x2D, 0x30...0x39:  // - or digit
+            return .number(try parseNumber())
+        default:
+            throw error("unexpected character")
+        }
+    }
+
+    private mutating func expectLiteral(_ literal: StaticString) throws(_JSONParseError) {
+        let start = index
+        var matched = true
+        literal.withUTF8Buffer { expected in
+            if index + expected.count > bytes.count {
+                matched = false
+                return
+            }
+            for (offset, byte) in expected.enumerated() where bytes[index + offset] != byte {
+                matched = false
+                return
+            }
+            index += expected.count
+        }
+        if !matched {
+            throw error("invalid literal; expected '\(literal)'", at: start)
+        }
+    }
+
+    // MARK: Containers
+
+    private mutating func enterContainer() throws(_JSONParseError) {
+        depth += 1
+        if depth > Self.maxDepth {
+            throw error("nesting deeper than \(Self.maxDepth) levels")
+        }
+    }
+
+    private mutating func parseArray() throws(_JSONParseError) -> _JSON {
+        try enterContainer()
+        defer { depth -= 1 }
+        index += 1  // [
+        var items: [_JSON] = []
+        skipWhitespace()
+        if peek == 0x5D {  // ]
+            index += 1
+            return .array(items)
+        }
+        while true {
+            skipWhitespace()
+            items.append(try parseValue())
+            skipWhitespace()
+            guard let byte = peek else { throw endOfInput() }
+            switch byte {
+            case 0x2C:  // ,
+                index += 1
+                skipWhitespace()
+                if peek == 0x5D { throw error("trailing comma in array") }
+            case 0x5D:  // ]
+                index += 1
+                return .array(items)
+            default:
+                throw error("expected ',' or ']' in array")
+            }
+        }
+    }
+
+    private mutating func parseObject() throws(_JSONParseError) -> _JSON {
+        try enterContainer()
+        defer { depth -= 1 }
+        index += 1  // {
+        var members: [String: _JSON] = [:]
+        skipWhitespace()
+        if peek == 0x7D {  // }
+            index += 1
+            return .object(members)
+        }
+        while true {
+            skipWhitespace()
+            guard let byte = peek else { throw endOfInput() }
+            guard byte == 0x22 else {
+                throw error(peek == 0x7D ? "trailing comma in object" : "expected string key in object")
+            }
+            let key = try parseString()
+            skipWhitespace()
+            guard let separator = peek else { throw endOfInput() }
+            guard separator == 0x3A else { throw error("expected ':' after object key") }  // :
+            index += 1
+            skipWhitespace()
+            members[key] = try parseValue()
+            skipWhitespace()
+            guard let next = peek else { throw endOfInput() }
+            switch next {
+            case 0x2C:  // ,
+                index += 1
+            case 0x7D:  // }
+                index += 1
+                return .object(members)
+            default:
+                throw error("expected ',' or '}' in object")
+            }
+        }
+    }
+
+    // MARK: Strings
+
+    /// Parses a string starting at the opening quote and returns its contents.
+    private mutating func parseString() throws(_JSONParseError) -> String {
+        let start = index
+        index += 1  // opening quote
+        var buffer: [UInt8] = []
+        while true {
+            // Copy a run of ordinary bytes in one go.
+            let runStart = index
+            while index < bytes.count {
+                let byte = bytes[index]
+                if byte == 0x22 || byte == 0x5C || byte < 0x20 { break }
+                index += 1
+            }
+            guard index < bytes.count else {
+                throw error("unterminated string", at: start)
+            }
+            let byte = bytes[index]
+            if byte == 0x22 {  // closing quote
+                index += 1
+                if buffer.isEmpty {
+                    return String(decoding: bytes[runStart..<(index - 1)], as: UTF8.self)
+                }
+                buffer.append(contentsOf: bytes[runStart..<(index - 1)])
+                return String(decoding: buffer, as: UTF8.self)
+            }
+            buffer.append(contentsOf: bytes[runStart..<index])
+            if byte == 0x5C {  // backslash
+                try parseEscape(into: &buffer)
+            } else {
+                throw error("control character in string must be escaped")
+            }
+        }
+    }
+
+    /// Parses one escape sequence starting at the backslash.
+    private mutating func parseEscape(into buffer: inout [UInt8]) throws(_JSONParseError) {
+        let start = index
+        index += 1  // backslash
+        guard let byte = peek else { throw endOfInput() }
+        index += 1
+        switch byte {
+        case 0x22: buffer.append(0x22)  // \"
+        case 0x5C: buffer.append(0x5C)  // \\
+        case 0x2F: buffer.append(0x2F)  // \/
+        case 0x62: buffer.append(0x08)  // \b
+        case 0x66: buffer.append(0x0C)  // \f
+        case 0x6E: buffer.append(0x0A)  // \n
+        case 0x72: buffer.append(0x0D)  // \r
+        case 0x74: buffer.append(0x09)  // \t
+        case 0x75:  // \u
+            var scalar = try parseHex4()
+            if scalar >= 0xD800 && scalar <= 0xDBFF {
+                // High surrogate: a low surrogate escape must follow.
+                guard index + 1 < bytes.count, bytes[index] == 0x5C, bytes[index + 1] == 0x75 else {
+                    throw error("high surrogate without a following low surrogate", at: start)
+                }
+                index += 2
+                let low = try parseHex4()
+                guard low >= 0xDC00 && low <= 0xDFFF else {
+                    throw error("invalid low surrogate in escape", at: start)
+                }
+                scalar = 0x10000 + ((scalar - 0xD800) << 10) + (low - 0xDC00)
+            } else if scalar >= 0xDC00 && scalar <= 0xDFFF {
+                throw error("lone low surrogate in escape", at: start)
+            }
+            Self.appendUTF8(scalar, to: &buffer)
+        default:
+            throw error("invalid escape sequence", at: start)
+        }
+    }
+
+    /// Reads exactly four hex digits.
+    private mutating func parseHex4() throws(_JSONParseError) -> UInt32 {
+        guard index + 4 <= bytes.count else { throw endOfInput() }
+        var value: UInt32 = 0
+        for _ in 0..<4 {
+            let byte = bytes[index]
+            let digit: UInt32
+            switch byte {
+            case 0x30...0x39: digit = UInt32(byte - 0x30)
+            case 0x41...0x46: digit = UInt32(byte - 0x41 + 10)
+            case 0x61...0x66: digit = UInt32(byte - 0x61 + 10)
+            default: throw error("invalid hex digit in \\u escape")
+            }
+            value = value << 4 | digit
+            index += 1
+        }
+        return value
+    }
+
+    private static func appendUTF8(_ scalar: UInt32, to buffer: inout [UInt8]) {
+        if scalar < 0x80 {
+            buffer.append(UInt8(scalar))
+        } else if scalar < 0x800 {
+            buffer.append(0xC0 | UInt8(scalar >> 6))
+            buffer.append(0x80 | UInt8(scalar & 0x3F))
+        } else if scalar < 0x10000 {
+            buffer.append(0xE0 | UInt8(scalar >> 12))
+            buffer.append(0x80 | UInt8((scalar >> 6) & 0x3F))
+            buffer.append(0x80 | UInt8(scalar & 0x3F))
+        } else {
+            buffer.append(0xF0 | UInt8(scalar >> 18))
+            buffer.append(0x80 | UInt8((scalar >> 12) & 0x3F))
+            buffer.append(0x80 | UInt8((scalar >> 6) & 0x3F))
+            buffer.append(0x80 | UInt8(scalar & 0x3F))
+        }
+    }
+
+    // MARK: Numbers
+
+    /// Powers of ten as correctly rounded literals. Entries 1e0...1e22 are
+    /// exactly representable, so for every realistic number (at most 15-16
+    /// significant digits, a modest exponent) the single multiplication or
+    /// division below yields the correctly rounded Double. Beyond that the
+    /// result is within an ulp, which is accurate enough for this use.
+    private static let powersOfTen: [Double] = [
+        1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10,
+        1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21,
+        1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30, 1e31, 1e32,
+        1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39, 1e40, 1e41, 1e42, 1e43,
+        1e44, 1e45, 1e46, 1e47, 1e48, 1e49, 1e50, 1e51, 1e52, 1e53, 1e54,
+        1e55, 1e56, 1e57, 1e58, 1e59, 1e60, 1e61, 1e62, 1e63, 1e64, 1e65,
+        1e66, 1e67, 1e68, 1e69, 1e70, 1e71, 1e72, 1e73, 1e74, 1e75, 1e76,
+        1e77, 1e78, 1e79, 1e80, 1e81, 1e82, 1e83, 1e84, 1e85, 1e86, 1e87,
+        1e88, 1e89, 1e90, 1e91, 1e92, 1e93, 1e94, 1e95, 1e96, 1e97, 1e98,
+        1e99, 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
+        1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, 1e120,
+        1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, 1e130, 1e131,
+        1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, 1e140, 1e141, 1e142,
+        1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, 1e150, 1e151, 1e152, 1e153,
+        1e154, 1e155, 1e156, 1e157, 1e158, 1e159, 1e160, 1e161, 1e162, 1e163, 1e164,
+        1e165, 1e166, 1e167, 1e168, 1e169, 1e170, 1e171, 1e172, 1e173, 1e174, 1e175,
+        1e176, 1e177, 1e178, 1e179, 1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186,
+        1e187, 1e188, 1e189, 1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197,
+        1e198, 1e199, 1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208,
+        1e209, 1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219,
+        1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229, 1e230,
+        1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239, 1e240, 1e241,
+        1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249, 1e250, 1e251, 1e252,
+        1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259, 1e260, 1e261, 1e262, 1e263,
+        1e264, 1e265, 1e266, 1e267, 1e268, 1e269, 1e270, 1e271, 1e272, 1e273, 1e274,
+        1e275, 1e276, 1e277, 1e278, 1e279, 1e280, 1e281, 1e282, 1e283, 1e284, 1e285,
+        1e286, 1e287, 1e288, 1e289, 1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296,
+        1e297, 1e298, 1e299, 1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307,
+        1e308,
+    ]
+
+    /// Parses `-?int frac? exp?` into a Double. Up to 19 significant digits
+    /// are accumulated exactly in a UInt64; further digits only shift the
+    /// decimal exponent. The exponent is then applied with a single
+    /// multiplication or division by a power of ten from the table above.
+    private mutating func parseNumber() throws(_JSONParseError) -> Double {
+        let start = index
+        var negative = false
+        if peek == 0x2D {  // -
+            negative = true
+            index += 1
+        }
+        guard let first = peek else { throw endOfInput() }
+        guard Self.isDigit(first) else { throw error("expected a digit") }
+
+        var mantissa: UInt64 = 0
+        var exponent = 0  // decimal exponent to apply to the mantissa
+        let mantissaLimit: UInt64 = 1_000_000_000_000_000_000  // 1e18; below it, *10+9 fits
+
+        // Integer part.
+        if first == 0x30 {
+            index += 1
+            if let next = peek, Self.isDigit(next) {
+                throw error("leading zeros are not allowed", at: start)
+            }
+        } else {
+            while let byte = peek, Self.isDigit(byte) {
+                if mantissa < mantissaLimit {
+                    mantissa = mantissa * 10 + UInt64(byte - 0x30)
+                } else {
+                    exponent += 1
+                }
+                index += 1
+            }
+        }
+
+        // Fraction.
+        if peek == 0x2E {  // .
+            index += 1
+            guard let byte = peek, Self.isDigit(byte) else {
+                throw error("expected a digit after the decimal point")
+            }
+            while let byte = peek, Self.isDigit(byte) {
+                if mantissa < mantissaLimit {
+                    mantissa = mantissa * 10 + UInt64(byte - 0x30)
+                    exponent -= 1
+                }
+                index += 1
+            }
+        }
+
+        // Exponent.
+        if let byte = peek, byte == 0x65 || byte == 0x45 {  // e or E
+            index += 1
+            var exponentNegative = false
+            if peek == 0x2B {  // +
+                index += 1
+            } else if peek == 0x2D {  // -
+                exponentNegative = true
+                index += 1
+            }
+            guard let digit = peek, Self.isDigit(digit) else {
+                throw error("expected a digit in the exponent")
+            }
+            var explicitExponent = 0
+            while let byte = peek, Self.isDigit(byte) {
+                // Clamp so absurd exponents cannot overflow Int; the value
+                // saturates to infinity or zero below anyway.
+                if explicitExponent < 100_000 {
+                    explicitExponent = explicitExponent * 10 + Int(byte - 0x30)
+                }
+                index += 1
+            }
+            exponent += exponentNegative ? -explicitExponent : explicitExponent
+        }
+
+        var value = Double(mantissa)
+        if mantissa != 0 {
+            if exponent > 308 {
+                // Even a mantissa of 1 exceeds Double.greatestFiniteMagnitude.
+                value = .infinity
+            } else if exponent > 0 {
+                value *= Self.powersOfTen[exponent]  // may overflow to +infinity
+            } else if exponent < -308 {
+                // Step down in two divisions; the mantissa has at most 19
+                // digits, so anything below 1e-330 underflows to zero.
+                let remaining = -exponent - 308
+                value = remaining > 22 ? 0 : value / Self.powersOfTen[308] / Self.powersOfTen[remaining]
+            } else if exponent < 0 {
+                value /= Self.powersOfTen[-exponent]
+            }
+        }
+        return negative ? -value : value
+    }
+}

package/Sources/SwiftUI/Runtime/LazyRows.swift

@@ -0,0 +1,99 @@
+// Lazy rows. SwiftUI builds the rows of a `List` (or `Form`), and of a `LazyVStack` or
+// `LazyHStack`, as they scroll into view: a timeline of a thousand posts
+// mounts the few on screen. Building every row up front made long lists
+// expensive in the browser, in time (each row's body, its elements, the
+// page's layout of them) and in memory, which a phone's browser runs out of.
+//
+// Here a keyed group (`ForEach`, or a modifier spread over one) whose rows
+// are a lazy container's rows mounts its first rows only, followed by a
+// `lazyspacer` element standing for the rest. When the page sees the spacer
+// come near its scroll view's visible area it sends a `lazy` event, and the
+// group mounts the next rows (docs/ops-protocol.md, "Lazy rows"). Rows that
+// were built stay built, as on iOS a row's state survives scrolling away.
+//
+// The rows of a lazy container are its content seen through groups,
+// sections and views with a body of their own: `List { Section {
+// ForEach(...) } }` and `List { TimelineRows() }` are lazy, while a
+// `ForEach` inside a row's own `VStack` is part of that row and is built
+// with it.
+
+/// `List`, `Form`, `LazyVStack` and `LazyHStack`: their rows are built lazily.
+protocol _LazyRowsContainer: _TraitBearing {
+    var _lazyAxis: Axis { get }
+}
+
+enum _LazyRows {
+    /// Rows a group mounts before its spacer, and the rows each `lazy` event adds.
+    static let batch = 12
+}
+
+/// The key of a group's spacer among its rows' keys. Each batch's spacer is a
+/// new element (keyed by the rows before it), so the page watches it afresh:
+/// one still in view after a batch was built asks for the next.
+struct _LazySpacerKey: Hashable {
+    let built: Int
+}
+
+/// The rows of a lazy group that are not built yet (`lazyspacer` element).
+struct _LazyRowsSpacer {
+    let axis: Axis
+    let remaining: Int
+    let extend: @MainActor () -> Void
+}
+extension _LazyRowsSpacer: _PrimitiveView {}
+
+extension _LazyRowsSpacer: _HostView {
+    var _kind: String { "lazyspacer" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object([
+            "axis": .string(axis == .horizontal ? "horizontal" : "vertical"),
+            "remaining": .number(Double(remaining)),
+        ])
+    }
+    var _handler: ((_JSON) -> Void)? {
+        let extend = extend
+        return { _ in MainActor.assumeIsolated { extend() } }
+    }
+}
+
+extension List: _LazyRowsContainer {
+    var _lazyAxis: Axis { .vertical }
+}
+/// A `Form` is a grouped list, on iOS as here.
+extension Form: _LazyRowsContainer {
+    var _lazyAxis: Axis { .vertical }
+}
+extension LazyVStack: _LazyRowsContainer {
+    var _lazyAxis: Axis { .vertical }
+}
+extension LazyHStack: _LazyRowsContainer {
+    var _lazyAxis: Axis { .horizontal }
+}
+
+// MARK: - Lazy menus
+
+// A `Menu`'s items and a `.contextMenu`'s are built when the menu opens, as
+// on iOS, and dropped when it closes. Until then the `menu` / `contextmenu`
+// element has its label (or content) only and `"deferred": true`; the page
+// sends `{"type": "menu", "id": n, "open": true}` when the viewer opens it,
+// shows the popover once the items arrive, and sends `"open": false` when it
+// closes (docs/ops-protocol.md, "Lazy menus"). A timeline's rows each carry
+// a menu or two: built eagerly they were half of Ice Cubes' page. Headless
+// runs, whose event scripts tap menu items directly, build them eagerly.
+
+/// `Menu` and `.contextMenu`: hosts whose items are built only while open.
+protocol _LazyMenuHost: _TraitBearing {
+    /// The label (a `Menu`'s, in its `ZStack`) or the content (a context menu's).
+    var _menuBase: any View { get }
+    var _menuItems: any View { get }
+}
+
+extension Menu: _LazyMenuHost {
+    var _menuBase: any View { ZStack { label } }
+    var _menuItems: any View { content }
+}
+
+extension _ContextMenuView: _LazyMenuHost {
+    var _menuBase: any View { content }
+    var _menuItems: any View { items }
+}

package/Sources/SwiftUI/Runtime/Measurements.swift

@@ -0,0 +1,140 @@
+// Views measured by the page for code that asks for a view's size
+// synchronously: `UIHostingController.sizeThatFits(in:)` (UIKit), which
+// packages call to size SwiftUI views before laying them out themselves
+// (WrappingHStack measures each item this way to break its lines). Swift has
+// no text metrics, so the answer comes from the page, one render late:
+//
+// 1. The first ask for a view finds no measurement: the answer is nil (the
+//    hosting controller reports a zero size) and the view joins the pending
+//    list.
+// 2. The render that asked also renders the pending views, off screen: as
+//    the children of a `layout` element of their own at the root, transparent
+//    and not hit-testable. The page measures a `layout` element's children
+//    (minimum, ideal and maximum size) and sends them in a `layout` event,
+//    as it does for a custom `Layout` (CustomLayout.swift).
+// 3. The event fills the cache and asks for a render in which no body is
+//    skipped as unchanged, so the code that measured runs again and finds
+//    the sizes (the library keeps them in objects of its own, which only a
+//    body that re-runs makes again).
+//
+// A view is known by its reflected description (`String(reflecting:)`): its
+// type and stored values, as SwiftUI's own diffing sees them. Content a body
+// reads from elsewhere (an observable object) is not part of it, so such a
+// view keeps its first measurement. Views are measured in the root's
+// environment, as Apple's hosting controller measures them in its own,
+// without the environment of the view that asks. A view whose description
+// changes on every render (one that stores a new UUID each time) would be
+// measured forever: after a few rounds in a row that only found new views,
+// measurements are still taken but no longer re-render.
+
+/// A view's sizes as the page measured them: for a zero, unspecified and infinite proposal.
+struct _MeasuredSizes: Equatable {
+    var min: CGSize
+    var ideal: CGSize
+    var max: CGSize
+
+    /// The size for `proposal`, as `LayoutSubview.sizeThatFits` answers it.
+    func fitting(_ proposal: ProposedViewSize) -> CGSize {
+        CGSize(
+            width: LayoutSubview.fit(proposal.width, min: min.width, ideal: ideal.width, max: max.width),
+            height: LayoutSubview.fit(proposal.height, min: min.height, ideal: ideal.height, max: max.height)
+        )
+    }
+}
+
+/// The page's measurements of views, by description, and the views waiting for one.
+@MainActor
+public final class _ViewMeasurements {
+    public static let shared = _ViewMeasurements()
+
+    private var sizes: [String: _MeasuredSizes] = [:]
+    /// Waiting views, in the order the measuring element renders them.
+    private(set) var pending: [(key: String, view: AnyView)] = []
+    private var pendingKeys: Set<String> = []
+    /// Rounds in a row in which measurements arrived and the render that
+    /// followed asked for new views again.
+    private var rounds = 0
+    static let maxRounds = 4
+    /// The runtime that rendered last: the one to render again.
+    weak var runtime: _Runtime?
+
+    init() {}
+
+    /// The size `view` takes for `proposal`, from the page's measurement;
+    /// nil until the page has measured it, and the view is then queued.
+    public func size<V: View>(of view: V, fitting proposal: ProposedViewSize) -> CGSize? {
+        let key = String(reflecting: view)
+        if let measured = sizes[key] { return measured.fitting(proposal) }
+        if pendingKeys.insert(key).inserted {
+            pending.append((key, AnyView(view)))
+            runtime?._scheduleRender()
+        }
+        return nil
+    }
+
+    /// Records the sizes of the pending views the page measured (`keys`, in order).
+    func record(_ measured: [(key: String, sizes: _MeasuredSizes)]) {
+        var added = false
+        for (key, value) in measured where pendingKeys.contains(key) {
+            sizes[key] = value
+            pendingKeys.remove(key)
+            added = true
+        }
+        guard added else { return }
+        pending.removeAll { sizes[$0.key] != nil }
+        rounds += 1
+        if rounds <= Self.maxRounds { runtime?._renderEverything() }
+    }
+
+    /// Called after a render: a render that asked for nothing new ends the rounds.
+    func renderFinished() {
+        if pending.isEmpty { rounds = 0 }
+    }
+
+    /// Forgets everything (tests).
+    func reset() {
+        sizes = [:]
+        pending = []
+        pendingKeys = []
+        rounds = 0
+    }
+}
+
+/// The off-screen element that has the pending views measured: a `layout`
+/// element whose children are the views, transparent and not hit-testable.
+struct _MeasuringView: View {
+    let entries: [(key: String, view: AnyView)]
+
+    var body: some View {
+        _MeasuringLayout(entries: entries)
+            .opacity(0)
+            .allowsHitTesting(false)
+    }
+}
+
+struct _MeasuringLayout {
+    let entries: [(key: String, view: AnyView)]
+}
+extension _MeasuringLayout: _PrimitiveView {}
+extension _MeasuringLayout: _HostView {
+    var _kind: String { "layout" }
+
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["proposal": .null, "size": .null, "frames": .null])
+    }
+
+    var _content: [any View] { entries.map(\.view) }
+
+    var _handler: ((_JSON) -> Void)? {
+        let keys = entries.map(\.key)
+        return { event in
+            // An event for another set of children (a render added views
+            // since) is left for the event about the current ones.
+            guard let (_, subviews) = _parseLayoutEvent(event), subviews.count == keys.count else { return }
+            let measured = zip(keys, subviews).map { key, subview in
+                (key: key, sizes: _MeasuredSizes(min: subview.min, ideal: subview.ideal, max: subview.max))
+            }
+            MainActor.assumeIsolated { _ViewMeasurements.shared.record(measured) }
+        }
+    }
+}