@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/Runtime/Runtime.swift

@@ -0,0 +1,2146 @@
+import Observation
+
+#if canImport(WASILibc)
+import WASILibc
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(Darwin)
+import Darwin
+#endif
+
+/// A view that has been mounted. Composite views keep their `State` boxes here
+/// so values survive the parent recreating the view struct.
+@MainActor
+final class _MountedNode {
+    var view: any View
+    var children: [_MountedNode] = []
+    var boxes: [any _AnyStateBox] = []
+    /// Identity within a keyed parent (`ForEach`).
+    var key: AnyHashable?
+    /// Position-and-type path used to restore state across hot reloads (ViewPath.swift).
+    var path: _ViewPath?
+    var environment = EnvironmentValues()
+    /// Handler supplied by the runtime (navigation links and screens).
+    var handler: ((_JSON) -> Void)?
+    var navTitle: String?
+    var navDisplayMode: String?
+    var depth = 0
+    var appeared = false
+    /// `.onDisappear`: run when the node leaves the tree.
+    var disappearAction: (@MainActor () -> Void)?
+    /// `.animation(_:value:)`: the last tracked value and a counter bumped on change.
+    var animationValue: Any?
+    var animationToken = 0
+    /// The render pass in which `animationToken` was last bumped.
+    var animationTokenPass = -1
+    /// Sheets: the mounted sheet content (second child) and its detents.
+    var sheetDetents: [String]?
+    /// `.task`: the running task and the id it was started for.
+    var task: Task<Void, Never>?
+    var taskID: AnyHashable?
+    var taskStarted = false
+    /// `GeometryReader`: the size the renderer last reported.
+    var geometrySize = CGSize.zero
+    /// A custom shape: the path it drew last (Shape.swift).
+    var pathState: _PathState?
+    /// The rows a lazily built keyed group has mounted so far (LazyRows.swift).
+    var lazyLimit = _LazyRows.batch
+    /// A `Menu` or context menu whose items are built (the page opened it).
+    var menuOpen = false
+    /// Phase 12: this stack is a `.scrollTargetLayout()`; its props carry `scrollTarget`.
+    var scrollTargetLayout = false
+    /// `TabView` / `Picker`: option tags in order, and the selected index.
+    var optionTags: [AnyHashable?] = []
+    var selectedIndex = 0
+    /// `NavigationStack`: destinations registered by descendants, kept across renders.
+    var destinations: [ObjectIdentifier: (Any) -> (any View)?] = [:]
+    var pickerOptions: [String] = []
+    var pickerLabel = ""
+    /// `NavigationSplitView`: the sidebar's `List(selection:)` binding, registered
+    /// each pass while the sidebar is reconciled.
+    var splitSelection: _ListSelection?
+    /// `NavigationStack` nested in another stack's screen: rendered in place.
+    /// Also a sidebar `TabView`, which renders its split view in place.
+    var navFlattened = false
+    /// `navscreen` / `List`: the edit mode this node owns (`EditButton` toggles it).
+    var editMode = EditMode.inactive
+    /// `NavigationStack` / compact `NavigationSplitView`: the stack context its
+    /// screens and links share. Kept across passes: a clean pass skips the
+    /// phase that recomputes `detailShown`, and screen handlers capture it.
+    var navContext: _NavContext?
+
+    // Incremental rendering (Phase 9). A render re-runs a view's body only
+    // when the node is `dirty` (its own `@State`, observed object or
+    // `@Observable` read changed) or an ancestor re-ran (its view value is
+    // new); a clean node whose descendants are all clean is skipped whole,
+    // and the elements it produced last time are reused.
+    weak var parent: _MountedNode?
+    /// This node's body must run again.
+    var dirty = true
+    /// A descendant is dirty (the chain from the root to every dirty node).
+    var subtreeDirty = false
+    /// The elements this node produced last time, with the sheets and alerts
+    /// its subtree presented (they are collected as side effects).
+    var cachedElements: [_Element]?
+    var cachedSheets: [_Element] = []
+    var cachedAlerts: [_Element] = []
+
+    // Skipping unchanged views (Phase 16). When an ancestor re-runs, this
+    // node gets a new view value; if it is the same as `view` and so is
+    // everything the node received from its parent, the node is treated as
+    // clean, like SwiftUI does for a view whose stored properties are equal.
+    /// What the parent passed down the last time this node was reconciled.
+    var received: _ReceivedContext?
+    /// This node or a descendant writes to its ancestors while reconciled
+    /// (a navigation title, a destination, detents, a list selection, a stack
+    /// or tab structure): a parent that re-runs resets what they set and
+    /// expects them to set it again, so they are never skipped that way.
+    var writesContext = false
+
+    /// The preference values this subtree produced (see Preferences.swift),
+    /// kept for passes that skip it.
+    var preferences = _PreferenceValues()
+    /// What an `onPreferenceChange` saw last.
+    var preferenceSeen: Any?
+
+    init(view: any View) {
+        self.view = view
+    }
+}
+
+/// The enclosing `NavigationStack`, shared by everything inside it.
+@MainActor
+final class _NavContext {
+    var box: _StateBox<[_PushedScreen]>
+    var path: _PathBinding?
+    /// The stack's mounted node, which owns the destination registry.
+    unowned let node: _MountedNode
+
+    init(box: _StateBox<[_PushedScreen]>, path: _PathBinding?, node: _MountedNode) {
+        self.box = box
+        self.path = path
+        self.node = node
+    }
+
+    func push(_ view: any View) { box.value.append(_PushedScreen(view: view)) }
+
+    /// Pushes a value: onto the path binding when there is one, otherwise as
+    /// a resolved destination view.
+    func push(value: AnyHashable) {
+        if let path {
+            path.set(path.get() + [value])
+        } else {
+            push(destination(for: value))
+        }
+    }
+
+    func register(_ registration: any _DestinationRegistering) {
+        node.destinations[registration._destinationType] = { registration._destination(for: $0) }
+    }
+
+    func destination(for value: AnyHashable) -> any View {
+        let type = ObjectIdentifier(Swift.type(of: value.base))
+        if let builder = node.destinations[type], let view = builder(value.base) { return view }
+        return Text("No navigationDestination(for: \(Swift.type(of: value.base)).self)")
+    }
+
+    /// Compact `NavigationSplitView`: set to the split view's node. While
+    /// `detailShown`, depth 1 is the detail screen, whose pop clears the
+    /// sidebar's selection; pushed screens follow it.
+    var splitNode: _MountedNode?
+    var detailShown = false
+
+    /// Pops so that `depth` screens below the popped one remain (`depth` 1 pops to the root).
+    func pop(to depth: Int) {
+        if let splitNode {
+            if detailShown, depth <= 1 {
+                box.value.removeAll()
+                splitNode.splitSelection?.set(nil)
+                return
+            }
+            let pushedDepth = depth - (detailShown ? 1 : 0)
+            guard pushedDepth >= 1, box.value.count >= pushedDepth else { return }
+            box.value.removeSubrange((pushedDepth - 1)...)
+            return
+        }
+        let pathCount = path?.get().count ?? 0
+        if depth <= pathCount, let path {
+            path.set(Array(path.get().prefix(depth - 1)))
+            box.value.removeAll()
+            return
+        }
+        let pushedDepth = depth - pathCount
+        guard pushedDepth >= 1, box.value.count >= pushedDepth else { return }
+        box.value.removeSubrange((pushedDepth - 1)...)
+    }
+}
+
+struct _ReconcileContext {
+    var environment: EnvironmentValues
+    /// `Type/index:Type/...` from the root (ViewPath.swift); keys state snapshots.
+    var path: _ViewPath
+    var navStack: _NavContext?
+    var screen: _MountedNode?
+    /// The nearest enclosing presented sheet's node (for `presentationDetents`).
+    var sheet: _MountedNode?
+    /// The `NavigationSplitView` whose sidebar is being reconciled: its
+    /// `List(selection:)` registers with it.
+    var split: _MountedNode?
+    /// Inside a `TabView` tab that is not selected: titles stay put.
+    var inactiveTab = false
+    /// Reconciling the rows of a `List` or lazy stack (LazyRows.swift): a
+    /// keyed group here builds its rows as they come into view.
+    var lazyRows: Axis?
+}
+
+/// What a node received from its parent, to tell whether a new pass passes
+/// the same thing (`_MountedNode.received`). Objects are kept by identity.
+struct _ReceivedContext {
+    var environment: EnvironmentValues
+    var path: _ViewPath
+    var navStack: ObjectIdentifier?
+    var screen: ObjectIdentifier?
+    var sheet: ObjectIdentifier?
+    var split: ObjectIdentifier?
+    var inactiveTab: Bool
+    var lazyRows: Axis?
+
+    @MainActor init(_ context: _ReconcileContext) {
+        environment = context.environment
+        path = context.path
+        navStack = context.navStack.map(ObjectIdentifier.init)
+        screen = context.screen.map(ObjectIdentifier.init)
+        sheet = context.sheet.map(ObjectIdentifier.init)
+        split = context.split.map(ObjectIdentifier.init)
+        inactiveTab = context.inactiveTab
+        lazyRows = context.lazyRows
+    }
+
+    /// Same objects, path and tab state, and the same environment.
+    @MainActor func matches(_ context: _ReconcileContext) -> Bool {
+        path.matches(context.path)
+            && navStack == context.navStack.map(ObjectIdentifier.init)
+            && screen == context.screen.map(ObjectIdentifier.init)
+            && sheet == context.sheet.map(ObjectIdentifier.init)
+            && split == context.split.map(ObjectIdentifier.init)
+            && inactiveTab == context.inactiveTab
+            && lazyRows == context.lazyRows
+            && environment._isSame(as: context.environment)
+    }
+}
+
+/// The identity of a value the runtime re-creates on every pass for a node
+/// (`_RuntimeIdentified`): the node and what the value is for.
+struct _RuntimeKey: Hashable, Sendable {
+    let node: ObjectIdentifier
+    let role: String
+}
+
+/// Owns the mounted tree, schedules renders and routes events.
+@MainActor
+public final class _Runtime {
+    public static let shared = _Runtime()
+
+    private(set) var host: any _RenderHost = _BufferedHost.shared
+    private var rootView: (any View)?
+    private var root: _MountedNode?
+    /// The off-screen element measuring views for `_ViewMeasurements` (Measurements.swift).
+    private var measuringRoot: _MountedNode?
+    /// Set when measurements arrive: the next render re-runs every body, none skipped as unchanged.
+    private var renderEverythingPass = false
+    private let reconciler = _Reconciler()
+    private var needsRender = false
+    /// The next render re-runs every body (environment changes, `invalidate()`).
+    private var fullRender = true
+    private var rendering = false
+    private var pendingAppear: [@MainActor () -> Void] = []
+    /// `.onDisappear` actions of the nodes the last pass removed, run after it like the appear actions.
+    private var pendingDisappear: [@MainActor () -> Void] = []
+    /// Values the renderer controls, such as the color scheme.
+    private var baseEnvironment = EnvironmentValues() {
+        didSet { EnvironmentValues._page = baseEnvironment }
+    }
+    /// `.preferredColorScheme` seen in the last pass (sticky), and what the host was told.
+    private var preferredColorScheme: ColorScheme?
+    private var sentColorScheme: ColorScheme?
+    /// State values from a previous build, applied as views first mount.
+    private var restoredState: [String: _JSON] = [:]
+    /// The transaction `withAnimation` (or an animated binding's write) has
+    /// open while its body runs: `.some(nil)` when it disables animations. Shared
+    /// by every runtime instance because `withAnimation` is a free function.
+    private static var openTransaction: Animation?? = nil
+    /// Animation for this runtime's next render pass: the open transaction's,
+    /// recorded when a change made inside it invalidates this runtime. A
+    /// transaction whose body changes nothing animates nothing later.
+    private var passAnimation: Animation?
+    /// Counts render passes (`_MountedNode.animationTokenPass`).
+    private var renderPass = 0
+    /// Sheet elements collected during the current element pass, emitted after the tree.
+    private var presentedSheets: [_Element] = []
+    /// Alert elements collected during the current element pass, emitted after
+    /// the sheets so that an alert presented from a sheet covers it.
+    private var presentedAlerts: [_Element] = []
+
+    init() {}
+
+    // MARK: Entry points
+
+    /// Called from `App.main()`.
+    public func launch<A: App>(_ app: A) {
+        watchApp(app)
+        guard let scene = app.body as? any _RootScene else {
+            fatalError("\(A.Body.self) is not a scene the runtime can present. Use WindowGroup.")
+        }
+        let headless = _environment("SB_HEADLESS") == "1"
+        isHeadless = headless
+        if headless, let text = _environment("SB_RESPONSES"), let json = try? _JSON.parse(text), case .array(let items) = json {
+            headlessResponses = items
+        }
+        if let state = _environment("SB_STATE"), let json = try? _JSON.parse(state), case .object(let values) = json {
+            restoredState = values
+        }
+        mount(scene._rootView, host: headless ? _HeadlessHost() : _BufferedHost.shared)
+        _flushAfterUpdate()
+
+        if headless {
+            // A script that names an element not on screen stops the run.
+            if !replay(events: _environment("SB_EVENTS") ?? "") { exit(1) }
+            if let limit = _environment("SB_RUN_MS").flatMap(Double.init), limit > 0 {
+                runHeadlessClock(upTo: limit)
+            }
+        }
+    }
+
+    /// Re-evaluates the app's `body` when the app's own `@State` changes or,
+    /// for an app with `@Environment` properties, when the environment the
+    /// host reports changes (`scenePhase`, the color scheme…), as SwiftUI
+    /// does: `.onChange(of: scenePhase)` on a scene and bindings to the app's
+    /// state (`TabView(selection: $selectedTab)`) work. The new root view
+    /// replaces the old and its node renders again. An app with neither is
+    /// evaluated once, as before.
+    private var refreshApp: (() -> Void)?
+
+    private func watchApp<A: App>(_ app: A) {
+        let properties = Mirror(reflecting: app).children.map(\.value)
+        let environment = properties.filter { $0 is any _EnvironmentProperty || $0 is any _EnvironmentReading }
+        // `@StateObject`s are observed by the views they are handed to.
+        let boxes = properties.filter { !($0 is any _ObservingProperty) }.compactMap { ($0 as? any _StateProperty)?._box }
+        guard !environment.isEmpty || !boxes.isEmpty else { return }
+        let refresh = { [unowned self] in
+            for property in environment {
+                (property as? any _EnvironmentProperty)?._resolve(in: baseEnvironment)
+                (property as? any _EnvironmentReading)?._resolve(in: baseEnvironment)
+            }
+            guard let scene = app.body as? any _RootScene else { return }
+            rootView = scene._rootView
+            if let root { invalidate(root) }
+        }
+        refreshApp = refresh
+        for box in boxes {
+            box._onChange = { [weak self] in self?.refreshApp?() }
+        }
+        for property in environment {
+            (property as? any _EnvironmentProperty)?._resolve(in: baseEnvironment)
+            (property as? any _EnvironmentReading)?._resolve(in: baseEnvironment)
+        }
+    }
+
+    /// Puts `object` in every view's environment, under its type: SwiftUI does
+    /// so with an app's scene delegate that is `Observable` or an
+    /// `ObservableObject` (UIKit's AppDelegate.swift connects the scene).
+    public func _addRootEnvironmentObject(_ object: AnyObject) {
+        baseEnvironment._setAnyObject(object)
+        refreshApp?()
+        if let root { invalidate(root) }
+    }
+
+    /// `launch` without the headless setup, for tests.
+    func _launchForTesting<A: App>(_ app: A, host: any _RenderHost) {
+        watchApp(app)
+        guard let scene = app.body as? any _RootScene else { fatalError("\(A.Body.self) is not a presentable scene") }
+        mount(scene._rootView, host: host)
+    }
+
+    /// Sends the app's defaults to the host (a `defaults` op), which keeps them
+    /// for the next launch. Called by `UserDefaults` (Sources/FoundationBridge).
+    public func storeDefaults(_ values: _JSON) {
+        host.apply([.defaults(values)])
+    }
+
+    /// Sends one saved batch of a SwiftData store to the host (a `swiftdata`
+    /// op), which writes it to IndexedDB and hands the store back at the next
+    /// launch (`SB_SWIFTDATA`). Called by `ModelContext.save()` (Sources/SwiftData).
+    public func storeSwiftData(_ change: _JSON) {
+        host.apply([.swiftData(change)])
+    }
+
+    /// Keys of the image sources the host has been sent (`imagedata` ops).
+    private var sentImageSources: Set<String> = []
+
+    /// Sends a bitmap's source to the host unless it has it already. Called
+    /// before an element that draws it is emitted, and by `ShareLink` before
+    /// it shares one, so the host always has the bytes a recipe names.
+    public func _sendImageSource(_ source: _ImageSource) {
+        guard sentImageSources.insert(source.key).inserted else { return }
+        host.apply([.imageData(source.json)])
+    }
+
+    // MARK: After-update actions
+
+    /// One-shot actions to run once the current event, executor run or launch
+    /// has rendered: SwiftData's autosave saves there, after the changes an
+    /// event made and before the host gets control back.
+    private var afterUpdate: [@MainActor () -> Void] = []
+
+    /// Runs `action` at the end of the current event (or executor run), after
+    /// its render pass.
+    public func _afterUpdate(_ action: @escaping @MainActor () -> Void) {
+        afterUpdate.append(action)
+    }
+
+    /// Runs the actions `_afterUpdate` queued, and renders what they changed.
+    public func _flushAfterUpdate() {
+        var rounds = 0
+        while !afterUpdate.isEmpty, rounds < 16 {
+            rounds += 1
+            let actions = afterUpdate
+            afterUpdate.removeAll()
+            for action in actions { action() }
+            renderIfNeeded()
+        }
+    }
+
+    // MARK: Host requests (Phase 13)
+
+    private var isHeadless = false
+    /// Headless mode: canned answers from `SB_RESPONSES` (a JSON array; each
+    /// item names a `url`, or a `prefix`, and carries `status` / `headers` /
+    /// `body` or `bodyBase64` for a fetch, `width` / `height` for an image;
+    /// or carries a `pick` for a `pickFiles` request).
+    private var headlessResponses: [_JSON] = []
+    private var pendingRequests: [Int: CheckedContinuation<_JSON, any Error>] = [:]
+    private var nextRequestID = 1
+
+    /// Asks the host for something only it can do (a `fetch`, an `image`
+    /// probe; see docs/ops-protocol.md, "Phase 13") and waits for its
+    /// `response` event. Called by `URLSession` and `AsyncImage`
+    /// (Sources/FoundationBridge). Headless runs answer from `SB_RESPONSES`
+    /// at once, or fail, so an app's network paths replay deterministically;
+    /// a caller that knows its own headless answer passes it as `headless`
+    /// (the stand-in frameworks: UserNotifications).
+    public func _hostRequest(kind: String, params: _JSON, headless: _JSON? = nil) async throws -> _JSON {
+        let id = nextRequestID
+        nextRequestID += 1
+        return try await withCheckedThrowingContinuation { continuation in
+            pendingRequests[id] = continuation
+            host.apply([.request(id: id, kind: kind, params: params)])
+            if isHeadless {
+                if let headless { complete(request: id, with: ["value": headless]) }
+                else { answerHeadless(id: id, kind: kind, params: params) }
+            }
+        }
+    }
+
+    /// Completes the request `id` from a `response` event: `value` on
+    /// success, `error` (a message) on failure.
+    private func complete(request id: Int, with fields: [String: _JSON]) {
+        guard let continuation = pendingRequests.removeValue(forKey: id) else { return }
+        if case .string(let message)? = fields["error"] {
+            continuation.resume(throwing: _HostRequestError(message: message))
+        } else {
+            continuation.resume(returning: fields["value"] ?? .null)
+        }
+    }
+
+    private func answerHeadless(id: Int, kind: String, params: _JSON) {
+        if kind == "share" {
+            // Nothing to share with headless; the op in the log is the record.
+            complete(request: id, with: ["value": .object(["outcome": .string("headless")])])
+            return
+        }
+        if kind == "pickFiles" {
+            complete(request: id, with: ["value": headlessPick()])
+            return
+        }
+        if kind == "scanner" {
+            complete(request: id, with: ["value": headlessScan(params: params)])
+            return
+        }
+        if kind == "openURL" {
+            // No tabs headless: the op in the log is the record.
+            complete(request: id, with: ["value": .null])
+            return
+        }
+        if kind == "media" {
+            // AVFoundation (docs/ops-protocol.md, "Video and audio"): a file
+            // becomes a stand-in URL; a probe reads `duration` / `width` /
+            // `height` from the `SB_RESPONSES` entry for its URL.
+            complete(request: id, with: Self._headlessMedia(params: params, fixtures: headlessResponses, serial: id))
+            return
+        }
+        if kind == "websocket" {
+            // No sockets headless: the open fails, as it does offline.
+            complete(request: id, with: ["error": .string("headless: WebSockets are not available")])
+            return
+        }
+        if kind == "webAuth" {
+            // A sign-in window: a fixture plays the provider (WebAuthHeadless.swift).
+            complete(request: id, with: Self._headlessWebAuth(params: params, fixtures: headlessResponses))
+            return
+        }
+        guard case .object(let request) = params, case .string(let url)? = request["url"] else {
+            complete(request: id, with: ["error": .string("malformed request")])
+            return
+        }
+        let fixture = headlessResponses.first { item in
+            guard case .object(let fields) = item else { return false }
+            if case .string(let exact)? = fields["url"], exact == url { return true }
+            if case .string(let prefix)? = fields["prefix"], url.hasPrefix(prefix) { return true }
+            return false
+        }
+        guard case .object(let fields)? = fixture else {
+            complete(request: id, with: ["error": .string("headless: no SB_RESPONSES entry for \(url)")])
+            return
+        }
+        switch kind {
+        case "fetch":
+            var body = ""
+            if case .string(let text)? = fields["body"] { body = _base64(Array(text.utf8)) }
+            if case .string(let encoded)? = fields["bodyBase64"] { body = encoded }
+            let status: _JSON = fields["status"] ?? .number(200)
+            let headers: _JSON = fields["headers"] ?? .object([:])
+            complete(request: id, with: ["value": .object(["status": status, "headers": headers, "body": .string(body), "url": .string(url)])])
+        case "image":
+            guard let width = fields["width"], let height = fields["height"] else {
+                complete(request: id, with: ["error": .string("headless: SB_RESPONSES entry for \(url) has no width/height")])
+                return
+            }
+            complete(request: id, with: ["value": .object(["width": width, "height": height])])
+        default:
+            complete(request: id, with: ["error": .string("headless: unknown request kind \(kind)")])
+        }
+    }
+
+    /// `SB_RESPONSES` entries with a `pick` (a list of files), used in order.
+    private var headlessPicksUsed = 0
+
+    /// A `pickFiles` answer (`PhotosPicker`; docs/ops-protocol.md, "Photos
+    /// picker") from the next `SB_RESPONSES` entry with a `pick`: each file's
+    /// `name`, `type`, `body` (text) or `bodyBase64`, and for a picture
+    /// `width` / `height` (its `url` defaults to a data URL). With no entry
+    /// left, the viewer dismissed the chooser: no items.
+    private func headlessPick() -> _JSON {
+        let picks = headlessResponses.compactMap { item -> [_JSON]? in
+            guard case .object(let fields) = item, case .array(let files)? = fields["pick"] else { return nil }
+            return files
+        }
+        guard headlessPicksUsed < picks.count else { return .object(["items": .array([])]) }
+        let files = picks[headlessPicksUsed]
+        headlessPicksUsed += 1
+        let items = files.map { file -> _JSON in
+            guard case .object(let fields) = file else { return .null }
+            var item = fields
+            item.removeValue(forKey: "body")
+            item.removeValue(forKey: "bodyBase64")
+            var data = ""
+            if case .string(let text)? = fields["body"] { data = _base64(Array(text.utf8)) }
+            if case .string(let encoded)? = fields["bodyBase64"] { data = encoded }
+            item["data"] = .string(data)
+            if item["url"] == nil, case .string(let type)? = fields["type"], fields["width"] != nil {
+                item["url"] = .string("data:\(type);base64,\(data)")
+            }
+            return .object(item)
+        }
+        return .object(["items": .array(items)])
+    }
+
+    /// `SB_RESPONSES` entries with a `scan` (a code), used in order.
+    private var headlessScansUsed = 0
+
+    /// A `scanner` answer (AVFoundation's capture sessions; docs/ops-protocol.md,
+    /// "Code scanning"): no camera for a `probe`; for a `scan`, the next
+    /// `SB_RESPONSES` entry's `scan` (`string`, and optionally `format`,
+    /// `corners`, `image`), or the viewer closing the camera when none is left.
+    private func headlessScan(params: _JSON) -> _JSON {
+        if case .object(let fields) = params, case .string("probe")? = fields["action"] { return .object(["camera": .bool(false)]) }
+        let scans = headlessResponses.compactMap { item -> _JSON? in
+            guard case .object(let fields) = item, let scan = fields["scan"] else { return nil }
+            return scan
+        }
+        guard headlessScansUsed < scans.count else { return .object(["cancelled": .bool(true)]) }
+        headlessScansUsed += 1
+        return scans[headlessScansUsed - 1]
+    }
+
+    /// Drives the executor with a virtual clock: runs jobs, jumps to the next
+    /// timer, and stops when none remain or the clock would pass `limit` ms.
+    private func runHeadlessClock(upTo limit: Double) {
+        let executor = _HostExecutor.shared
+        var guardCount = 0
+        while guardCount < 10_000 {
+            guardCount += 1
+            let next = runJobsAndRender()
+            if next < 0 { break }
+            let nextMs = Double(executor.nowNs + UInt64(next)) / 1_000_000
+            if nextMs > limit { break }
+            executor.nowNs += UInt64(next)
+            host.apply([.event(.object(["type": .string("clock"), "ms": .number(nextMs.rounded())]))])
+        }
+    }
+
+    /// Mounts `view` as the root and performs the first render.
+    func mount(_ view: any View, host: any _RenderHost) {
+        self.host = host
+        sentImageSources = []
+        rootView = view
+        root = nil
+        measuringRoot = nil
+        render()
+    }
+
+    /// A tap on the element with this id.
+    public func dispatch(tap id: Int) {
+        dispatch(event: .object(["type": .string("tap"), "id": .number(Double(id))]))
+    }
+
+    /// Handles one renderer event (see docs/ops-protocol.md) and renders if needed.
+    public func dispatch(event: _JSON) {
+        handle(event)
+        renderIfNeeded()
+        _flushAfterUpdate()
+    }
+
+    /// Applies an event's state changes without rendering. A `batch` event
+    /// (`{"type": "batch", "events": [...]}`) applies each of its events, so
+    /// one host layout pass that measured several `geometry` and `layout`
+    /// elements costs one render instead of one per element.
+    private func handle(_ event: _JSON) {
+        guard case .object(let fields) = event, case .string(let type)? = fields["type"] else { return }
+        let id: Int? = if case .number(let n)? = fields["id"] { Int(n) } else { nil }
+
+        switch type {
+        case "batch":
+            if case .array(let events)? = fields["events"] { events.forEach(handle) }
+        case "tap":
+            // A tap with a location (`onTapGesture { point in }`) carries the
+            // point in the element's coordinates; any other tap is `.null`.
+            if let id {
+                if let x = fields["x"], let y = fields["y"] {
+                    reconciler.handlers[id]?(.object(["x": x, "y": y]))
+                } else {
+                    reconciler.handlers[id]?(.null)
+                }
+            }
+        case "text", "toggle", "select", "step", "slide", "date", "link":
+            // `link`: a tap on a link in a text's runs; the value is its URL.
+            if let id, let value = fields["value"] { reconciler.handlers[id]?(value) }
+        case "geometry":
+            if let id, let width = fields["width"], let height = fields["height"] {
+                reconciler.handlers[id]?(.object(["width": width, "height": height]))
+            }
+        case "layout":
+            // Host measurement of a custom `Layout`'s children; the handler
+            // parses the whole event (see CustomLayout.swift).
+            if let id { reconciler.handlers[id]?(event) }
+        case "drag", "longpress", "delete", "refresh", "focus", "submit", "video", "lazy", "menu":
+            // Phase 8: the handler receives the whole event and reads `type`
+            // (a `listrow` handles both `tap` and `delete`; Phase 12: a
+            // `textfield` handles `text`, `focus` and `submit`; a `video`
+            // reads its `event`, docs/ops-protocol.md, "Video and audio").
+            if let id { reconciler.handlers[id]?(event) }
+        case "response":
+            // Phase 13: the host's answer to a `request` op.
+            if let id { complete(request: id, with: fields) }
+        case "environment":
+            if case .string(let scheme)? = fields["colorScheme"] {
+                baseEnvironment.colorScheme = scheme == "dark" ? .dark : .light
+                invalidate()
+            }
+            if case .string(let size)? = fields["dynamicTypeSize"], let value = DynamicTypeSize(name: size) {
+                baseEnvironment.dynamicTypeSize = value
+                invalidate()
+            }
+            if case .string(let name)? = fields["horizontalSizeClass"], let value = UserInterfaceSizeClass(name: name) {
+                baseEnvironment.horizontalSizeClass = value
+                invalidate()
+            }
+            if case .string(let name)? = fields["scenePhase"], let value = ScenePhase(name: name) {
+                baseEnvironment.scenePhase = value
+                invalidate()
+            }
+            // The app's `@Environment` properties read the new values.
+            refreshApp?()
+        default:
+            break
+        }
+    }
+
+    /// A render soon (a view to measure was queued outside of one).
+    func _scheduleRender() {
+        if !rendering { needsRender = true }
+    }
+
+    /// A render that re-evaluates the whole tree and re-runs every body, even
+    /// those whose view is unchanged (new measurements, Measurements.swift).
+    func _renderEverything() {
+        renderEverythingPass = true
+        invalidate()
+    }
+
+    /// Schedules a render that re-evaluates the whole tree.
+    func invalidate() {
+        needsRender = true
+        fullRender = true
+        recordTransaction()
+    }
+
+    /// Schedules a render that re-evaluates `node`'s subtree (and whatever
+    /// else is dirty); everything else is reused.
+    func invalidate(_ node: _MountedNode) {
+        markDirty(node)
+        needsRender = true
+        recordTransaction()
+    }
+
+    /// A change made inside a transaction takes its animation to the next pass.
+    private func recordTransaction() {
+        if let open = Self.openTransaction { passAnimation = open }
+    }
+
+    private func markDirty(_ node: _MountedNode) {
+        node.dirty = true
+        node.cachedElements = nil
+        var ancestor = node.parent
+        while let current = ancestor, !current.subtreeDirty {
+            current.subtreeDirty = true
+            current.cachedElements = nil
+            ancestor = current.parent
+        }
+    }
+
+    /// Opens a transaction for the changes `body` makes: they animate with
+    /// `animation` (none when it is nil), and changes after it do not.
+    func runInTransaction<Result>(_ animation: Animation?, _ body: () throws -> Result) rethrows -> Result {
+        let outer = beginTransaction(animation)
+        defer { endTransaction(outer) }
+        return try body()
+    }
+
+    /// Opens a transaction; returns the one it replaces, for `endTransaction`.
+    func beginTransaction(_ animation: Animation?) -> Animation?? {
+        let outer = Self.openTransaction
+        Self.openTransaction = .some(animation)
+        return outer
+    }
+
+    func endTransaction(_ outer: Animation??) {
+        Self.openTransaction = outer
+    }
+
+    /// Whether this pass may animate `node`'s changes: the transaction has an
+    /// animation, or an `.animation(_:value:)` above it saw its value change.
+    private func passAnimates(_ node: _MountedNode) -> Bool {
+        if passAnimation != nil { return true }
+        var ancestor: _MountedNode? = node
+        while let current = ancestor {
+            if current.animationTokenPass == renderPass { return true }
+            ancestor = current.parent
+        }
+        return false
+    }
+
+    /// Advances the executor's clock, runs queued jobs and due timers, renders
+    /// if anything changed, and returns milliseconds until the next timer (-1: none).
+    public func runJobs(nowMilliseconds: Double) -> Double {
+        let executor = _HostExecutor.shared
+        executor.nowNs = UInt64(max(0, nowMilliseconds) * 1_000_000)
+        let next = runJobsAndRender()
+        return next < 0 ? -1 : Double(next) / 1_000_000
+    }
+
+    /// Runs the queued jobs and renders what they changed. A render can start
+    /// tasks of its own (an `onChange` action's `Task`, such as one loading
+    /// the item a `PhotosPicker` answer just selected); they run in the same
+    /// call instead of waiting for the next event or timer. Returns the
+    /// executor's delay until its next timer (nanoseconds, -1: none).
+    private func runJobsAndRender() -> Int64 {
+        let executor = _HostExecutor.shared
+        var next: Int64 = -1
+        var rounds = 0
+        repeat {
+            rounds += 1
+            next = executor.runJobs()
+            renderIfNeeded()
+            _flushAfterUpdate()
+        } while executor.hasQueuedJobs && rounds < 16
+        return next
+    }
+
+    func renderIfNeeded() {
+        if needsRender, !rendering { render() }
+    }
+
+    // MARK: Rendering
+
+    private func render() {
+        guard let rootView else { return }
+        rendering = true
+        needsRender = false
+        renderPass += 1
+        _ViewMeasurements.shared.runtime = self
+        // An app's own `ShapeStyle` resolves in the page's environment, a
+        // global: the runtime rendering now is the page's (tests mount
+        // several runtimes, in parallel suites, each with its own scheme).
+        EnvironmentValues._page = baseEnvironment
+
+        let context = _ReconcileContext(environment: baseEnvironment, path: _ViewPath(root: type(of: rootView)))
+        let force = fullRender
+        fullRender = false
+        let node = reconcile(root, with: rootView, context: context, force: force)
+        root = node
+        // The views measured for synchronous size questions, asked while the
+        // bodies above ran (Measurements.swift).
+        let measuring = _ViewMeasurements.shared.pending
+        let measuringNode: _MountedNode? = measuring.isEmpty ? nil : reconcile(
+            measuringRoot, with: _MeasuringView(entries: measuring),
+            context: _ReconcileContext(environment: baseEnvironment, path: _ViewPath(root: _MeasuringView.self)), force: true)
+        measuringRoot = measuringNode
+        renderEverythingPass = false
+        presentedSheets = []
+        presentedAlerts = []
+        barFree.nextPass()
+        // Bodies are tracked per node (see `reconcileChildren`); an observable
+        // read while producing elements (rare) falls back to a full render.
+        let tree = withObservationTracking {
+            elements(of: node) + presentedSheets + presentedAlerts + (measuringNode.map { elements(of: $0) } ?? [])
+        } onChange: { [weak self] in
+            MainActor.assumeIsolated { self?.invalidate() }
+        }
+        let animation = passAnimation?._json
+        passAnimation = nil
+        var ops = reconciler.update(with: tree, animation: animation)
+        if preferredColorScheme != sentColorScheme {
+            // Phase 12: `.preferredColorScheme` reaches the host as a root update.
+            sentColorScheme = preferredColorScheme
+            ops.insert(.update(id: 0, props: .object(["colorScheme": preferredColorScheme.map { .string($0 == .dark ? "dark" : "light") } ?? .null])), at: 0)
+        }
+        host.apply(ops)
+        rendering = false
+        _ViewMeasurements.shared.renderFinished()
+
+        let disappearing = pendingDisappear
+        pendingDisappear.removeAll()
+        for action in disappearing { action() }
+        let appearing = pendingAppear
+        pendingAppear.removeAll()
+        for action in appearing { action() }
+        renderIfNeeded()
+    }
+
+    /// Re-evaluates the mounted tree against `view`, reusing nodes (and their
+    /// state) whose view type is unchanged at the same position or key.
+    /// `force`: the parent re-ran, so `view` is a new value and this node's
+    /// body must run (and its children are forced in turn), unless the value
+    /// and everything else the parent passed are the same as last time
+    /// (`canSkip`, Phase 16). Otherwise `view` is the node's own stored view
+    /// and the body runs only when the node is dirty; a clean node with no
+    /// dirty descendant is returned as is.
+    private func reconcile(_ existing: _MountedNode?, with view: any View, context: _ReconcileContext,
+                           force: Bool) -> _MountedNode {
+        var force = force
+        if force, let existing, canSkip(existing, for: view, in: context) {
+            // The parent re-ran but passed the same view and context: the node
+            // is clean, and only its dirty descendants (if any) re-run.
+            force = false
+            skippedViews += 1
+        }
+        if let existing, !force, !existing.dirty, !existing.subtreeDirty {
+            return existing
+        }
+        let received = _ReceivedContext(context)
+        var context = context
+        let node: _MountedNode
+        let clean: Bool
+        let properties: [Any]?
+        let boxes: [any _AnyStateBox]
+        let path = context.path
+
+        if let existing, type(of: existing.view) == type(of: view) {
+            node = existing
+            clean = !force && !existing.dirty
+            if clean {
+                // Same view value, same state: no reflection, no body.
+                properties = nil
+                boxes = existing.boxes
+            } else {
+                properties = _reflectedProperties(of: view)
+                boxes = stateBoxes(in: properties)
+                for (old, new) in zip(existing.boxes, boxes) where old !== new {
+                    new._adopt(old)
+                }
+            }
+        } else {
+            node = _MountedNode(view: view)
+            clean = false
+            properties = _reflectedProperties(of: view)
+            boxes = stateBoxes(in: properties)
+            restoreState(into: boxes, at: path)
+        }
+        node.dirty = false
+        node.subtreeDirty = false
+        // A clean node reached here has a dirty descendant, whose elements are
+        // part of its own. Its cache was cleared when the descendant was marked,
+        // unless that happened during the last pass (an `onChange` action
+        // setting state while its body ran), which cached its elements again
+        // after the mark.
+        node.cachedElements = nil
+        node.view = view
+        node.path = path
+        node.received = received
+        if !clean {
+            node.boxes = boxes
+            for box in boxes {
+                // Weak: a `StateObject`'s publisher keeps this closure for as long
+                // as the object lives, which may be longer than the runtime (tests).
+                box._onChange = { [weak self, weak node] in
+                    if let node { self?.invalidate(node) }
+                }
+            }
+        }
+
+        let traits = _ViewTraits.of(view)
+        // Lazy rows (LazyRows.swift): a lazy container's content is its rows
+        // through groups, sections and views with a body; any other view is
+        // part of one row, whose groups are built with it.
+        let lazyRowsHere = context.lazyRows
+        if traits.contains(.lazyRows), let container = view as? any _LazyRowsContainer {
+            context.lazyRows = container._lazyAxis
+        } else if context.lazyRows != nil, !traits.contains(.group), !traits.contains(.section),
+                  !traits.isDisjoint(with: .bodiless) {
+            context.lazyRows = nil
+        }
+        if traits.contains(.environmentModifying), let modifier = view as? any _EnvironmentModifying {
+            modifier._apply(to: &context.environment)
+        }
+        if traits.contains(.preferredColorScheme), let preferred = view as? any _PreferredColorSchemeModifying, !context.inactiveTab {
+            preferredColorScheme = preferred._preferredColorScheme
+        }
+        if context.environment._scrollTargetLayout, traits.contains(.scrollTargetContainer) {
+            // This stack's children are the snap targets; nested stacks are not.
+            node.scrollTargetLayout = true
+            context.environment._scrollTargetLayout = false
+        }
+        if traits.contains(.navigationTitle), let title = view as? any _NavigationTitleModifying, let screen = context.screen, !context.inactiveTab {
+            if let value = title._title { screen.navTitle = value }
+            if let mode = title._displayMode { screen.navDisplayMode = mode }
+        }
+        if traits.contains(.onDisappearing), let disappear = view as? any _OnDisappearing {
+            node.disappearAction = disappear._disappearAction
+        }
+        if traits.contains(.onAppearing), let appear = view as? any _OnAppearing, !node.appeared {
+            node.appeared = true
+            if let action = appear._action { pendingAppear.append(action) }
+        }
+        if traits.contains(.detents), let detents = view as? any _DetentsModifying, let sheet = context.sheet {
+            sheet.sheetDetents = detents._detents
+        }
+        if traits.contains(.animated), let animated = view as? any _AnimatedView {
+            if node === existing, animated._changed(since: node.animationValue) {
+                node.animationToken += 1
+                node.animationTokenPass = renderPass
+            }
+            node.animationValue = animated._value
+        }
+        if traits.contains(.destinationRegistering), let registration = view as? any _DestinationRegistering {
+            context.navStack?.register(registration)
+        }
+        if traits.contains(.splitSidebar), let sidebar = view as? _SplitSidebarView {
+            context.split = sidebar.split
+        }
+        if traits.contains(.listSelection), let list = view as? any _ListSelectionProviding {
+            if var selection = list._selection {
+                selection.identity = _RuntimeKey(node: ObjectIdentifier(node), role: "selection:\(selection.snapshot())")
+                context.environment._listSelection = selection
+                context.split?.splitSelection = selection
+            }
+            // A list outside a navigation screen owns its rows' edit mode.
+            if context.environment.editMode == nil {
+                context.environment.editMode = editModeBinding(for: node)
+            }
+        }
+        if traits.contains(.taskStarting), let starting = view as? any _TaskStarting {
+            if !node.taskStarted || node.taskID != starting._taskID {
+                node.task?.cancel()
+                node.taskStarted = true
+                node.taskID = starting._taskID
+                let action = starting._taskAction
+                node.task = Task { await action() }
+            }
+        }
+
+        // Decide how to produce the children first, because navigation views
+        // adjust the environment that must be resolved before any body runs.
+        var makeChildren: () -> [any View]
+        /// A second batch of children, produced after the first was reconciled
+        /// (a compact split view decides on its detail screen from the
+        /// selection its sidebar registered).
+        var makeMoreChildren: (() -> [any View])?
+        var keys: [AnyHashable]?
+        node.handler = nil
+        node.navFlattened = false
+
+        if traits.contains(.navigationSplit), let split = view as? any _NavigationSplitHost {
+            // Descendants fill these in as they are reconciled; a clean pass
+            // (only some descendants re-run) keeps what the skipped ones set.
+            if !clean { node.splitSelection = nil }
+            let sidebar = _SplitSidebarView(content: split._sidebar, split: node)
+            if context.environment.horizontalSizeClass == .regular {
+                // Two columns, each its own stack; they are not nested in a
+                // screen even when the split view is, so they are not flattened.
+                context.navStack = nil
+                context.screen = nil
+                let detail = split._detail
+                makeChildren = {
+                    let sidebarStack = NavigationStack {
+                        _NavigationTitleView(content: AnyView(sidebar), title: nil, displayMode: "large")
+                    }
+                    let detailStack: any View = detail is any _NavigationStackView
+                        ? detail : NavigationStack { AnyView(detail) }
+                    return [sidebarStack, detailStack]
+                }
+            } else {
+                // One stack rooted at the sidebar; the detail is pushed while
+                // the sidebar's selection is set, and deeper links push after it.
+                let nav = navContext(for: node, box: split._pushedBox, path: nil, clean: clean)
+                nav.splitNode = node
+                context.navStack = nav
+                makeChildren = { [_NavScreenView(content: sidebar, depth: 0)] }
+                let detail = split._detail
+                makeMoreChildren = {
+                    nav.detailShown = node.splitSelection?.get() != nil
+                    let base = nav.detailShown ? 1 : 0
+                    let detailScreens = nav.detailShown ? [_NavScreenView(content: detail, depth: 1)] : []
+                    let pushedScreens = nav.box.value.enumerated().map { index, pushed in
+                        _NavScreenView(content: pushed.view, depth: base + index + 1)
+                    }
+                    return detailScreens + pushedScreens
+                }
+            }
+        } else if traits.contains(.navigationStack), let stack = view as? any _NavigationStackView, context.screen != nil, context.navStack != nil {
+            // Nested in another stack's screen: the root renders in place, its
+            // destinations and links use the enclosing stack, its path is ignored.
+            node.navFlattened = true
+            makeChildren = { [stack._root] }
+        } else if traits.contains(.navigationStack), let stack = view as? any _NavigationStackView {
+            let nav = navContext(for: node, box: stack._pushedBox, path: stack._path, clean: clean)
+            context.navStack = nav
+            makeChildren = {
+                let pathScreens = (nav.path?.get() ?? []).enumerated().map { index, value in
+                    _NavScreenView(content: _PathScreenValue(value: value), depth: index + 1)
+                }
+                let pushedScreens = nav.box.value.enumerated().map { index, pushed in
+                    _NavScreenView(content: pushed.view, depth: pathScreens.count + index + 1)
+                }
+                return [_NavScreenView(content: stack._root, depth: 0)] + pathScreens + pushedScreens
+            }
+        } else if traits.contains(.navScreen), let screen = view as? _NavScreenView {
+            context.screen = node
+            // A screen inside an unselected tab still owns its own title.
+            context.inactiveTab = false
+            if !clean {
+                node.navTitle = nil
+                node.navDisplayMode = nil
+            }
+            node.depth = screen.depth
+            if screen.depth > 0, let nav = context.navStack {
+                let depth = screen.depth
+                node.handler = { _ in nav.pop(to: depth) }
+                context.environment.dismiss = DismissAction(identity: _RuntimeKey(node: ObjectIdentifier(node), role: "pop\(depth)")) {
+                    nav.pop(to: depth)
+                }
+            }
+            // Each screen owns the edit mode of its content (`EditButton`,
+            // `List.editing`), as on iOS.
+            context.environment.editMode = editModeBinding(for: node)
+            let nav = context.navStack
+            makeChildren = {
+                // Path screens resolve their value through the stack's
+                // registrations, which the root screen filled in just before.
+                if let pathValue = screen.content as? _PathScreenValue, let nav {
+                    return [nav.destination(for: pathValue.value)]
+                }
+                return [screen.content]
+            }
+        } else if traits.contains(.navigationLink), let link = view as? any _NavigationLinkView {
+            let destination = link._destination
+            let value = traits.contains(.navigationValueLink) ? (view as? any _NavigationValueLinkView)?._value : nil
+            let nav = context.navStack
+            // In a split view's sidebar a value link selects the row of a
+            // `List(selection:)` instead of pushing.
+            let selection = context.environment._splitSidebar ? context.environment._listSelection : nil
+            node.handler = { _ in
+                if let value, let selection {
+                    selection.set(value)
+                } else if let value {
+                    nav?.push(value: value)
+                } else {
+                    nav?.push(destination)
+                }
+            }
+            makeChildren = { (view as? any _HostView)?._content ?? [] }
+        } else if traits.contains(.tabView), let tabs = view as? any _TabViewHost {
+            let roots = _flattenChildren(tabs._tabContent)
+            node.optionTags = roots.map { _tag(of: $0) }
+            node.selectedIndex = tabs._selectedIndex(tags: node.optionTags)
+            let tags = node.optionTags
+            node.handler = { payload in
+                if case .number(let index) = payload { tabs._select(index: Int(index), tags: tags) }
+            }
+            let selected = node.selectedIndex
+            if _tabViewIsSidebar(context.environment) {
+                // Regular-width `.sidebarAdaptable`: a split view whose sidebar
+                // lists the tabs (Tabs.swift); the tab view adds no element.
+                node.navFlattened = true
+                makeChildren = { [_tabSidebar(roots: roots, selected: selected) { tabs._select(index: $0, tags: tags) }] }
+            } else {
+                makeChildren = {
+                    roots.enumerated().map { index, root in
+                        _TabScreenView(root: root, isSelected: index == selected)
+                    }
+                }
+            }
+        } else if traits.contains(.tabScreen), let tab = view as? _TabScreenView {
+            if !tab.isSelected { context.inactiveTab = true }
+            makeChildren = { [tab.content] }
+        } else if traits.contains(.picker), let picker = view as? any _PickerHost {
+            let options = _flattenPickerOptions(picker._options)
+            node.optionTags = options.map { $0.tag }
+            node.selectedIndex = picker._selectedIndex(tags: node.optionTags)
+            node.pickerOptions = options.map { _textContent(of: $0.view) }
+            node.pickerLabel = _textContent(of: picker._labelView)
+            let tags = node.optionTags
+            node.handler = { payload in
+                if case .number(let index) = payload { picker._select(index: Int(index), tags: tags) }
+            }
+            makeChildren = { [] }
+        } else if traits.contains(.geometryReading), let reader = view as? any _GeometryReading {
+            let size = node.geometrySize
+            node.handler = { [unowned self] payload in
+                guard case .object(let fields) = payload,
+                      case .number(let width)? = fields["width"],
+                      case .number(let height)? = fields["height"] else { return }
+                let reported = CGSize(width: width, height: height)
+                if reported != node.geometrySize {
+                    node.geometrySize = reported
+                    self.invalidate(node)
+                }
+            }
+            makeChildren = { [reader._content(for: size)] }
+        } else if traits.contains(.sheet), let sheet = view as? any _SheetPresenting {
+            // The base is always a child; the sheet content is a second child
+            // while presented, so its state survives re-renders.
+            let isPresented = sheet._isPresented
+            let onDismiss = sheet._onDismiss
+            if !clean { node.sheetDetents = nil }
+            node.handler = { _ in
+                isPresented.wrappedValue = false
+                onDismiss?()
+            }
+            // Read in the tracked closure: a binding into an `@Observable`
+            // model presents when the model changes.
+            makeChildren = { isPresented.wrappedValue ? [sheet._base, sheet._sheetContent] : [sheet._base] }
+        } else if traits.contains(.alert), let alert = view as? any _AlertPresenting {
+            // Like a sheet: the actions are a second child while presented. A
+            // tap on the alert itself dismisses without running an action.
+            let isPresented = alert._isPresented
+            node.handler = { _ in isPresented.wrappedValue = false }
+            makeChildren = { isPresented.wrappedValue ? [alert._base, alert._alertActions] : [alert._base] }
+        } else if traits.contains(.preferenceDecorating), let decorating = view as? any _PreferenceValueDecorating {
+            // The decoration is made from the base's values, so the base
+            // reconciles first (and the decoration is made again every pass).
+            makeChildren = { [decorating._base] }
+            makeMoreChildren = { [unowned node] in
+                [decorating._decoration(from: node.children.first?.preferences ?? _PreferenceValues())]
+            }
+        } else if traits.contains(.group), let group = view as? any _GroupView {
+            keys = group._keys
+            makeChildren = { group._children }
+            if let axis = lazyRowsHere, let allKeys = keys, allKeys.count > node.lazyLimit,
+               let requests = context.environment._scrollReader?.requests {
+                // `proxy.scrollTo(id)` where the rows carry their own ids
+                // (`.id(item.id)`): the rows up to the target are built first.
+                for request in requests {
+                    if let index = allKeys.firstIndex(of: request.target), index >= node.lazyLimit {
+                        node.lazyLimit = index + _LazyRows.batch
+                    }
+                }
+            }
+            if let axis = lazyRowsHere, let allKeys = keys, allKeys.count > node.lazyLimit {
+                // The first rows, and a spacer for the rest until the page
+                // sees it near the visible area.
+                let limit = node.lazyLimit
+                keys = Array(allKeys.prefix(limit)) + [AnyHashable(_LazySpacerKey(built: limit))]
+                let spacer = _LazyRowsSpacer(axis: axis, remaining: allKeys.count - limit) { [weak self, weak node] in
+                    guard let self, let node, node.lazyLimit == limit else { return }
+                    node.lazyLimit = limit + _LazyRows.batch
+                    self.invalidate(node)
+                }
+                makeChildren = { Array(group._children.prefix(limit)) + [spacer] }
+            }
+        } else if traits.contains(.lazyMenu), let menu = view as? any _LazyMenuHost {
+            // Lazy menus (LazyRows.swift): the items only while open.
+            node.handler = { [weak self, weak node] payload in
+                guard let self, let node, case .object(let fields) = payload,
+                      case .bool(let open)? = fields["open"], node.menuOpen != open else { return }
+                node.menuOpen = open
+                self.invalidate(node)
+            }
+            let open = isHeadless || node.menuOpen
+            makeChildren = { open ? [menu._menuBase, menu._menuItems] : [menu._menuBase] }
+        } else if traits.contains(.host), let hostView = view as? any _HostView {
+            if let dependent = view as? any _EnvironmentContent {
+                // A button under a custom style (ButtonStyles.swift).
+                let environment = context.environment
+                makeChildren = { dependent._content(in: environment) }
+            } else {
+                makeChildren = { hostView._content }
+            }
+        } else {
+            makeChildren = { [self.body(of: view)] }
+        }
+
+        if node.handler == nil, traits.contains(.refreshing), let refreshing = view as? any _Refreshing {
+            node.handler = refreshing._refresh(in: context.environment).handler
+        }
+        if node.handler == nil, traits.contains(.environmentHandling), let handling = view as? any _EnvironmentHandling {
+            node.handler = handling._handler(in: context.environment)
+        }
+        if traits.contains(.sizeReporting)
+            || (traits.contains(.pathDrawing) && (view as? any _PathDrawing)?._drawsPath == true) {
+            // The element reports its laid-out size, like a GeometryReader's;
+            // an anchor preference resolves against it, a custom shape draws
+            // its path for it.
+            node.handler = { [unowned self] payload in
+                guard case .object(let fields) = payload,
+                      case .number(let width)? = fields["width"],
+                      case .number(let height)? = fields["height"] else { return }
+                let reported = CGSize(width: width, height: height)
+                if reported != node.geometrySize {
+                    node.geometrySize = reported
+                    self.invalidate(node)
+                }
+            }
+        }
+
+        node.environment = context.environment
+        let decorating = traits.contains(.preferenceDecorating)
+        if clean && !decorating {
+            // The body's output is the children already mounted (the view
+            // value is unchanged); only the dirty ones among them re-run.
+            let kept = node.children
+            makeChildren = { kept.map(\.view) }
+            makeMoreChildren = nil
+            keys = kept.allSatisfy { $0.key != nil } && !kept.isEmpty ? kept.map { $0.key! } : nil
+        } else {
+            resolveEnvironment(in: properties, with: context.environment, owner: node)
+        }
+        var phases = [makeChildren]
+        if let makeMoreChildren { phases.append(makeMoreChildren) }
+        reconcileChildren(of: node, phases: phases, keys: keys, context: context, force: !clean, forceLaterPhases: decorating)
+
+        // Preferences flow up: the children's values in order, then this view's own.
+        var preferences = _PreferenceValues()
+        for child in node.children where !child.preferences.isEmpty { preferences.merge(child.preferences) }
+        if traits.contains(.preferenceWriting), let writer = view as? any _PreferenceWriting {
+            writer._write(&preferences, measured: node.geometrySize)
+        }
+        node.preferences = preferences
+        if traits.contains(.preferenceReading), let reader = view as? any _PreferenceReading {
+            let (seen, action) = reader._read(preferences, last: node.preferenceSeen)
+            node.preferenceSeen = seen
+            // After the pass, like onAppear: the action usually sets state.
+            if let action { pendingAppear.append(action) }
+        }
+        node.writesContext = !traits.isDisjoint(with: .contextWriting) || node.children.contains { $0.writesContext }
+        return node
+    }
+
+    /// Whether a node whose parent re-ran can be treated as clean: it is not
+    /// dirty itself, nothing in its subtree writes to its ancestors, and the
+    /// parent passed the same view value and the same context as last time.
+    private func canSkip(_ existing: _MountedNode, for view: any View, in context: _ReconcileContext) -> Bool {
+        guard !renderEverythingPass, !existing.dirty, !existing.writesContext, let received = existing.received,
+              type(of: existing.view) == type(of: view) else { return false }
+        let key = ObjectIdentifier(type(of: view))
+        if incomparableTypes.contains(key) { return false }
+        // Only views with a body of their own are compared. The shim's
+        // containers and primitives (stacks, modifiers, text) are cheap to
+        // re-run, and their values hold their whole content, so comparing
+        // them would walk the subtree once per level; the views with bodies
+        // inside them are compared on their own.
+        if !_ViewTraits.of(view).isDisjoint(with: .bodiless) { return false }
+        guard _Sameness.sameView(existing.view, view) else {
+            // A type whose values never compare equal (it stores a closure or
+            // a binding) is not compared again.
+            if !_Sameness.canEverBeSame(view) { incomparableTypes.insert(key) }
+            return false
+        }
+        return received.matches(context)
+    }
+
+    /// See `_hoistBarItems`.
+    private var barFree = _BarFreeTokens()
+    /// View types whose values hold a closure or binding: never the same.
+    private var incomparableTypes: Set<ObjectIdentifier> = []
+    /// Forced nodes treated as clean because their view was unchanged (for tests).
+    private(set) var skippedViews = 0
+
+    /// The stack context of a `NavigationStack` / split node, created once and
+    /// pointed at the current view's storage on every pass that re-ran the body.
+    private func navContext(for node: _MountedNode, box: _StateBox<[_PushedScreen]>, path: _PathBinding?,
+                            clean: Bool) -> _NavContext {
+        if let nav = node.navContext {
+            if !clean {
+                nav.box = box
+                nav.path = path
+            }
+            return nav
+        }
+        let nav = _NavContext(box: box, path: path, node: node)
+        node.navContext = nav
+        return nav
+    }
+
+    /// Reconciles the node's children phase by phase: each phase's views are
+    /// produced only after the previous phase's children were reconciled.
+    /// Keys apply to the first phase's views.
+    /// `forceLaterPhases`: the views of phases after the first are new values
+    /// even on a clean pass (a preference decoration made from the first).
+    private func reconcileChildren(of node: _MountedNode, phases: [() -> [any View]],
+                                   keys: [AnyHashable]?, context: _ReconcileContext, force: Bool,
+                                   forceLaterPhases: Bool = false) {
+        let old = node.children
+        var oldByKey: [AnyHashable: _MountedNode] = [:]
+        for child in old {
+            if let key = child.key { oldByKey[key] = child }
+        }
+        defer {
+            let kept = Set(node.children.map(ObjectIdentifier.init))
+            for dropped in old where !kept.contains(ObjectIdentifier(dropped)) {
+                unmount(dropped)
+            }
+        }
+
+        var children: [_MountedNode] = []
+        for (phase, makeViews) in phases.enumerated() {
+            let force = force || (forceLaterPhases && phase > 0)
+            // A later phase may read what the earlier ones mounted.
+            if phase > 0 { node.children = children }
+            // The body (and a `ForEach`'s row closures) run under observation
+            // tracking: an `@Observable` property read here marks this node
+            // dirty when it changes, and nothing else re-renders.
+            let views: [any View] = force
+                ? withObservationTracking(makeViews) { [weak self, weak node] in
+                    MainActor.assumeIsolated { if let node { self?.invalidate(node) } }
+                }
+                : makeViews()
+            for childView in views {
+                let index = children.count
+                let key = phase == 0 ? keys?[index] : nil
+                let existing: _MountedNode?
+                if let key {
+                    existing = oldByKey.removeValue(forKey: key)
+                } else if index < old.count, old[index].key == nil {
+                    existing = old[index]
+                } else {
+                    existing = nil
+                }
+                var childContext = context
+                childContext.path = context.path.child(key.map(_ViewPath.Step.key) ?? .index(index), type(of: childView))
+                if index == 1, let sheet = node.view as? any _SheetPresenting {
+                    let isPresented = sheet._isPresented
+                    let onDismiss = sheet._onDismiss
+                    childContext.sheet = node
+                    childContext.navStack = nil
+                    childContext.screen = nil
+                    childContext.environment.dismiss = DismissAction(identity: _RuntimeKey(node: ObjectIdentifier(node), role: "sheet")) {
+                        isPresented.wrappedValue = false
+                        onDismiss?()
+                    }
+                }
+                if index == 1, let alert = node.view as? any _AlertPresenting {
+                    let isPresented = alert._isPresented
+                    childContext.environment.dismiss = DismissAction(identity: _RuntimeKey(node: ObjectIdentifier(node), role: "alert")) {
+                        isPresented.wrappedValue = false
+                    }
+                }
+                let child = reconcile(existing, with: childView, context: childContext, force: force)
+                child.key = key
+                child.parent = node
+                children.append(child)
+            }
+        }
+        node.children = children
+    }
+
+    /// The `editMode` environment binding a `navscreen` or `List` node owns.
+    private func editModeBinding(for node: _MountedNode) -> Binding<EditMode> {
+        Binding(
+            // The mode is part of the identity: the binding reads the node's
+            // live mode, so the environment of a pass must record which mode
+            // it carried for a toggle to re-run the views below.
+            identity: _RuntimeKey(node: ObjectIdentifier(node), role: "editMode:\(node.editMode)"),
+            get: { [weak node] in MainActor.assumeIsolated { node?.editMode ?? .inactive } },
+            set: { [weak self, weak node] mode in
+                MainActor.assumeIsolated {
+                    guard let node, node.editMode != mode else { return }
+                    node.editMode = mode
+                    self?.invalidate(node)
+                }
+            }
+        )
+    }
+
+    /// Cancels tasks in a subtree that left the tree, and queues its
+    /// `.onDisappear` actions (innermost first, as SwiftUI calls them).
+    private func unmount(_ node: _MountedNode) {
+        node.task?.cancel()
+        node.task = nil
+        node.children.forEach(unmount)
+        if let action = node.disappearAction {
+            node.disappearAction = nil
+            pendingDisappear.append(action)
+        }
+    }
+
+    private func body(of view: any View) -> any View {
+        func open<V: View>(_ view: V) -> any View { view.body }
+        return open(view)
+    }
+
+    /// The property-wrapper values of a view that the runtime acts on
+    /// (`@State`, `@StateObject`, `@ObservedObject`, `@Environment`,
+    /// `@EnvironmentObject`), or `nil` when its type declares none.
+    ///
+    /// Reflection is the most expensive step of a render, and most views in a
+    /// tree are the shim's own modifiers and primitives, which declare no
+    /// such properties. The first instance of each type is reflected and
+    /// each stored property checked (`_RuntimeProperty`); the wrappers are
+    /// concrete struct types, so which properties are wrappers is a property
+    /// of the type, not of the instance. A struct type's answer is kept as a
+    /// plan: none (it is never reflected again), or the positions to read,
+    /// so later passes reflect it without checking each property again.
+    private func _reflectedProperties(of view: any View) -> [Any]? {
+        // `ModifiedContent` stores its `ViewModifier`, whose own `@State` and
+        // `@Environment` properties are managed like the view's.
+        // A custom `ButtonStyle` (ButtonStyles.swift) too.
+        let values = runtimeProperties(of: view, lookInsideModifiers: _ViewTraits.of(view).contains(.holdsModifier))
+        return values.isEmpty ? nil : values
+    }
+
+    /// Which stored properties of a struct type the runtime reads: the
+    /// wrappers', then (for `_HoldsModifier` views) the stored modifiers or
+    /// styles whose own wrappers it reads, in that order.
+    private struct PropertyPlan {
+        var wrappers: [Int]
+        var modifiers: [Int]
+        static let none = PropertyPlan(wrappers: [], modifiers: [])
+        var isNone: Bool { wrappers.isEmpty && modifiers.isEmpty }
+    }
+
+    /// Per struct type: its plan. Per other type: `.none` when it declares no wrappers.
+    private var propertyPlans: [ObjectIdentifier: PropertyPlan] = [:]
+
+    private func runtimeProperties(of value: Any, lookInsideModifiers: Bool) -> [Any] {
+        let type = type(of: value)
+        let key = ObjectIdentifier(type)
+        let plan = propertyPlans[key]
+        if let plan, plan.isNone { return [] }
+        let mirrored = Mirror(reflecting: value).children
+        if let plan {
+            // A struct's children are random access: only the planned ones are read (and boxed).
+            func child(_ offset: Int) -> Any { mirrored[mirrored.index(mirrored.startIndex, offsetBy: offset)].value }
+            var values = plan.wrappers.map(child)
+            for offset in plan.modifiers { values += runtimeProperties(of: child(offset), lookInsideModifiers: false) }
+            return values
+        }
+        let children = Array(mirrored)
+        var wrappers: [Int] = []
+        var modifiers: [Int] = []
+        var values: [Any] = []
+        var inner: [Any] = []
+        for (index, child) in children.enumerated() {
+            // One lookup per property type (`_RuntimeProperty`, ViewTraits.swift).
+            if child.value is any _RuntimeProperty {
+                wrappers.append(index)
+                values.append(child.value)
+            } else if lookInsideModifiers, child.value is any ViewModifier || child.value is any ButtonStyle {
+                let found = runtimeProperties(of: child.value, lookInsideModifiers: false)
+                if !found.isEmpty { modifiers.append(index) }
+                inner += found
+            }
+        }
+        values += inner
+        if values.isEmpty {
+            propertyPlans[key] = PropertyPlan.none
+        } else if _ViewTraits.isStruct(type) {
+            // Not an enum's: its children are its case's payload, which differ by case.
+            propertyPlans[key] = PropertyPlan(wrappers: wrappers, modifiers: modifiers)
+        }
+        return values
+    }
+
+    private func stateBoxes(in properties: [Any]?) -> [any _AnyStateBox] {
+        guard let properties else { return [] }
+        return properties.compactMap { ($0 as? any _StateProperty)?._box }
+    }
+
+    /// Resolves `@Environment`/`@EnvironmentObject` properties and subscribes
+    /// `@ObservedObject`/`@EnvironmentObject` properties so that their
+    /// object's `objectWillChange` invalidates this runtime. Resolution runs
+    /// first because an environment object is observed through its resolved value.
+    private func resolveEnvironment(in properties: [Any]?, with environment: EnvironmentValues, owner node: _MountedNode) {
+        guard let properties else { return }
+        for value in properties {
+            (value as? any _EnvironmentProperty)?._resolve(in: environment)
+            (value as? any _EnvironmentReading)?._resolve(in: environment)
+            (value as? any _ObservingProperty)?._observe(owner: node) { [weak self, weak node] in
+                if let node { self?.invalidate(node) }
+            }
+        }
+    }
+
+    // MARK: Elements
+
+    private func elements(of node: _MountedNode) -> [_Element] {
+        if let cached = node.cachedElements {
+            presentedSheets += node.cachedSheets
+            presentedAlerts += node.cachedAlerts
+            return cached
+        }
+        let sheetsBefore = presentedSheets.count
+        let alertsBefore = presentedAlerts.count
+        let produced = produceElements(of: node)
+        node.cachedElements = produced
+        node.cachedSheets = Array(presentedSheets[sheetsBefore...])
+        node.cachedAlerts = Array(presentedAlerts[alertsBefore...])
+        return produced
+    }
+
+    private func produceElements(of node: _MountedNode) -> [_Element] {
+        var produced: [_Element]
+        let traits = _ViewTraits.of(node.view)
+        if traits.contains(.navScreen) {
+            // `.toolbar` / `.searchable` emit `toolbar` and `searchfield`
+            // elements wherever they were applied; the renderer wants them as
+            // the screen's own children, after the content.
+            var bar: [_Element] = []
+            let content = node.children.flatMap(elements(of:)).map { _hoistBarItems(from: $0, into: &bar, barFree: &barFree) }
+            produced = [_Element(
+                kind: "navscreen",
+                props: .object([
+                    "title": .string(node.navTitle ?? ""),
+                    "displayMode": .string(node.navDisplayMode ?? "automatic"),
+                    "depth": .number(Double(node.depth)),
+                ]),
+                children: content + bar,
+                handler: node.handler
+            )]
+        } else if traits.contains(.sheet), let sheet = node.view as? any _SheetPresenting {
+            // Base inline; the presented content becomes a root-level `sheet` element.
+            produced = node.children.first.map(elements(of:)) ?? []
+            if node.children.count > 1 {
+                let detents = sheet._fullScreen ? ["full"] : (node.sheetDetents ?? ["large"])
+                presentedSheets.append(_Element(
+                    kind: "sheet",
+                    props: .object(["detents": .array(detents.map(_JSON.string))]),
+                    children: elements(of: node.children[1]),
+                    handler: node.handler,
+                    key: AnyHashable(_SheetKey(path: node.path?.text ?? ""))
+                ))
+            }
+        } else if traits.contains(.alert), let alert = node.view as? any _AlertPresenting {
+            // Base inline; the actions become a root-level `alert` element whose
+            // buttons also dismiss when tapped.
+            produced = node.children.first.map(elements(of:)) ?? []
+            if node.children.count > 1 {
+                let isPresented = alert._isPresented
+                let buttons = elements(of: node.children[1]).map { _dismissing($0, with: isPresented) }
+                presentedAlerts.append(_Element(
+                    kind: "alert",
+                    props: .object([
+                        "title": .string(alert._alertTitle),
+                        "message": alert._alertMessage.map(_JSON.string) ?? .null,
+                        "style": .string(alert._alertStyle),
+                    ]),
+                    children: buttons,
+                    handler: node.handler,
+                    key: AnyHashable(_AlertKey(path: node.path?.text ?? ""))
+                ))
+            }
+        } else if traits.contains(.navigationSplit) {
+            // Regular: `navsplit` over the two column stacks. Compact: one
+            // `navstack` whose screens are the sidebar, the detail and what
+            // the detail pushed.
+            let regular = node.environment.horizontalSizeClass == .regular
+            produced = [_Element(
+                kind: regular ? "navsplit" : "navstack",
+                props: .object([:]),
+                children: node.children.flatMap(elements(of:)),
+                handler: nil
+            )]
+        } else if traits.contains(.navigationStack), node.navFlattened {
+            produced = node.children.flatMap(elements(of:))
+        } else if traits.contains(.tabView), node.navFlattened {
+            produced = node.children.flatMap(elements(of:))
+        } else if traits.contains(.tabView) {
+            produced = [_Element(
+                kind: "tabview",
+                props: .object(["selected": .number(Double(node.selectedIndex))]),
+                children: node.children.flatMap(elements(of:)),
+                handler: node.handler
+            )]
+        } else if traits.contains(.picker) {
+            produced = [_Element(
+                kind: "picker",
+                props: .object([
+                    "style": .string(node.environment._pickerStyle),
+                    "label": .string(node.pickerLabel),
+                    "options": .array(node.pickerOptions.map(_JSON.string)),
+                    "selected": .number(Double(node.selectedIndex)),
+                ]),
+                children: [],
+                handler: node.handler
+            )]
+        } else if traits.contains(.animated), let animated = node.view as? any _AnimatedView {
+            var style: [String: _JSON] = ["animationToken": .number(Double(node.animationToken))]
+            if let animation = animated._animation { style["animation"] = animation._json }
+            produced = [_Element(
+                kind: "styled",
+                props: .object(["style": .object(style)]),
+                children: node.children.flatMap(elements(of:)),
+                handler: nil
+            )]
+        } else if traits.contains(.host), !traits.contains(.group), let hostView = node.view as? any _HostView {
+            let kind = hostView._kind
+            var children = childElements(of: node)
+            if kind == "list" { children = wrapListRows(children, in: node) }
+            var props = hostView._props(in: node.environment)
+            if traits.contains(.pathDrawing), let drawing = node.view as? any _PathDrawing, drawing._drawsPath {
+                let state = node.pathState ?? _PathState()
+                node.pathState = state
+                props = drawing._pathProps(props, size: node.geometrySize, state: state, animated: passAnimates(node))
+            }
+            if traits.contains(.lazyMenu), !isHeadless, case .object(var fields) = props {
+                fields["deferred"] = .bool(!node.menuOpen)
+                props = .object(fields)
+            }
+            if kind == "image", let image = hostView as? Image { image._sendBitmapSource(through: self) }
+            if kind == "text", let rich = hostView as? _RichText { rich._sendBitmapSources(through: self) }
+            if node.scrollTargetLayout, case .object(var fields) = props {
+                // Phase 12: this stack's children are the scroll view's snap targets.
+                fields["scrollTarget"] = .bool(true)
+                props = .object(fields)
+            }
+            // A custom layout reads its children's `.layoutValue`s (CustomLayout.swift).
+            if kind == "layout", let receiving = node.view as? any _LayoutValuesReceiving {
+                receiving._receive(childLayoutValues: children.map { $0.layoutValues ?? [:] })
+            }
+            var element = _Element(
+                kind: kind,
+                props: props,
+                children: children,
+                handler: node.handler ?? hostView._handler
+            )
+            if traits.contains(.navigationValueLink), let link = node.view as? any _NavigationValueLinkView, let value = link._value {
+                element.row = _RowMark(linkValue: value, linkHandler: element.handler)
+            }
+            // Wrappers that leave the row's content as their (first) child pass
+            // its row mark up, so `Text("x").tag(1).padding()` stays selectable.
+            let transparent = kind == "styled" || kind == "gesture" || kind == "tapgesture"
+                ? children.count == 1 : kind == "swipeactions" || kind == "contextmenu"
+            if transparent, let inner = children.first?.row {
+                element.row = (element.row ?? _RowMark()).merged(with: inner)
+            }
+            // Modifiers outside a `.layoutValue` (`.zIndex`, `.offset`, an
+            // overlay) leave the value on the view the layout sees.
+            if kind == "styled" || kind == "gesture" || kind == "tapgesture" || kind == "decorated"
+                || kind == "contextmenu" || kind == "swipeactions", let inner = children.first?.layoutValues {
+                element.layoutValues = inner
+            }
+            produced = [element]
+        } else {
+            produced = childElements(of: node)
+        }
+
+        if traits.contains(.tagProviding), let tagged = node.view as? any _TagProviding {
+            let tag = tagged._tag
+            for index in produced.indices where produced[index].row?.tag == nil {
+                produced[index].row = (produced[index].row ?? _RowMark()).merged(with: _RowMark(tag: tag))
+            }
+        }
+        if traits.contains(.rowEditingDisabling), let disabling = node.view as? any _RowEditingDisabling, disabling._deleteDisabled {
+            for index in produced.indices {
+                produced[index].row = (produced[index].row ?? _RowMark()).merged(with: _RowMark(deleteDisabled: true))
+            }
+        }
+        if traits.contains(.layoutValueProviding), let providing = node.view as? any _LayoutValueProviding {
+            // The value closest to the view wins: an inner one is already set.
+            let (key, value) = providing._layoutValue
+            for index in produced.indices where produced[index].layoutValues?[key] == nil {
+                produced[index].layoutValues = (produced[index].layoutValues ?? [:]).merging([key: value]) { inner, _ in inner }
+            }
+        }
+        if traits.contains(.accessibilityProviding), let providing = node.view as? any _AccessibilityProviding {
+            let mark = providing._accessibility
+            for index in produced.indices {
+                produced[index].accessibility = (produced[index].accessibility ?? _AccessibilityMark()).merged(with: mark)
+            }
+        }
+        if traits.contains(.tabScreen), let tab = node.view as? _TabScreenView, !tab.isSelected {
+            // An unselected tab's toolbars do not reach the enclosing screen.
+            var dropped: [_Element] = []
+            produced = produced.map { _hoistBarItems(from: $0, into: &dropped, barFree: &barFree) }
+        }
+
+        if let key = node.key {
+            for index in produced.indices where produced[index].key == nil {
+                produced[index].key = AnyHashable(_ElementKey(base: key, index: index))
+            }
+        }
+        return produced
+    }
+
+    // MARK: State snapshot (hot reload)
+
+    /// The elements of a node's children, in order. The elements a keyed
+    /// group (`ForEach`) produces carry its ids as keys; two keyed groups
+    /// under the same parent may use the same ids (`ForEach(0..<n)` twice in
+    /// a `ZStack`), so each group's keys are qualified by its position among
+    /// the siblings. Without that the element diff matched the two groups'
+    /// elements to each other on alternate passes, swapping their props.
+    private func childElements(of node: _MountedNode) -> [_Element] {
+        let delete = _ViewTraits.of(node.view).contains(.deletableGroup) ? (node.view as? any _DeletableGroup)?._delete : nil
+        return node.children.enumerated().flatMap { position, child -> [_Element] in
+            var items = elements(of: child)
+            // A `ForEach` id is the row's implicit tag; an `onDelete` group's
+            // child at `position` is the row at that offset of its data.
+            if let key = child.key {
+                for index in items.indices where items[index].row?.tag == nil {
+                    items[index].row = (items[index].row ?? _RowMark()).merged(with: _RowMark(tag: key))
+                }
+            }
+            if let delete {
+                for index in items.indices where items[index].row?.delete == nil {
+                    items[index].row = (items[index].row ?? _RowMark()).merged(with: _RowMark(delete: { delete(position) }))
+                }
+            }
+            if child.key == nil, _ViewTraits.of(child.view).contains(.group), let group = child.view as? any _GroupView, group._keys != nil {
+                for index in items.indices {
+                    if let key = items[index].key {
+                        items[index].key = AnyHashable(_GroupKey(position: position, key: key))
+                    }
+                }
+            }
+            return items
+        }
+    }
+
+    /// Wraps a `list`'s rows (also those of its `section`s) that can be selected
+    /// or deleted in `listrow` elements (docs/ops-protocol.md, Phase 8). A row
+    /// is selectable when the list has a selection and the row's `.tag`,
+    /// `ForEach` id or `NavigationLink(value:)` is of the selection's type;
+    /// deletable when its `ForEach` has `onDelete` and the row is not
+    /// `deleteDisabled`. The row's key moves to the wrapper.
+    private func wrapListRows(_ elements: [_Element], in node: _MountedNode) -> [_Element] {
+        let selection = node.environment._listSelection
+        let editMode = node.environment.editMode
+        return elements.map { element in
+            if element.kind == "section" {
+                var section = element
+                section.children = wrapListRows(section.children, in: node)
+                return section
+            }
+            guard let mark = element.row else { return element }
+            let value = mark.linkValue ?? mark.tag
+            let selectable: Bool = if let selection, let value { selection.accepts(value) } else { false }
+            let deletable = mark.delete != nil && !mark.deleteDisabled
+            guard selectable || deletable else { return element }
+            let selected = selectable && selection!.contains(value!)
+
+            var inner = element
+            inner.key = nil
+            inner.row = nil
+            let handler: (_JSON) -> Void = { payload in
+                if case .object(let fields) = payload, case .string("delete")? = fields["type"] {
+                    if deletable { mark.delete?() }
+                    return
+                }
+                guard selectable, let selection, let value else {
+                    mark.linkHandler?(.null)
+                    return
+                }
+                let editing = editMode?.wrappedValue.isEditing ?? false
+                if mark.linkValue != nil, !editing {
+                    // A value link pushes (or, in a split sidebar, selects) as before.
+                    mark.linkHandler?(.null)
+                } else if selection.isMultiple || editing {
+                    selection.toggle(value)
+                } else {
+                    selection.set(value)
+                }
+            }
+            return _Element(
+                kind: "listrow",
+                props: .object([
+                    "selectable": .bool(selectable),
+                    "selected": .bool(selected),
+                    "deletable": .bool(deletable),
+                ]),
+                children: [inner],
+                handler: handler,
+                key: element.key
+            )
+        }
+    }
+
+    /// Primitive `@State` values keyed by view path, for `SB_STATE`.
+    public func snapshot() -> _JSON {
+        var values: [String: _JSON] = [:]
+        func walk(_ node: _MountedNode) {
+            for (index, box) in node.boxes.enumerated() {
+                if let json = _primitiveJSON(box._anyValue) {
+                    values["\(node.path?.text ?? "")#\(index)"] = json
+                }
+            }
+            node.children.forEach(walk)
+        }
+        if let root { walk(root) }
+        return .object(values)
+    }
+
+    private func restoreState(into boxes: [any _AnyStateBox], at path: _ViewPath) {
+        guard !restoredState.isEmpty, !boxes.isEmpty else { return }
+        let text = path.text
+        for (index, box) in boxes.enumerated() {
+            guard let saved = restoredState["\(text)#\(index)"] else { continue }
+            switch (box._anyValue, saved) {
+            case (is Int, .number(let n)) where n == n.rounded(): box._anyValue = Int(n)
+            case (is Double, .number(let n)): box._anyValue = n
+            case (is String, .string(let s)): box._anyValue = s
+            case (is Bool, .bool(let b)): box._anyValue = b
+            default: break
+            }
+        }
+    }
+
+    // MARK: Headless replay
+
+    /// Replays an event script (Sources/SwiftUI/Runtime/Replay.swift): events
+    /// separated by commas or line breaks, such as `tap:"Add"`, `tap:12`,
+    /// `text:"Name":Milk`, `toggle:"Done":true`, `select:"Sort":"Title"`,
+    /// `env:dark`, `type:xxxLarge`, `size:regular`, `step:"8 hours":1`,
+    /// `slide:7:0.35`, `date:7:1700000000`, `drag:12:changed:40x-3`,
+    /// `longpress:12`, `delete:"Coffee"`, `refresh:40`, `back`, `dismiss`.
+    /// Each is echoed, with the id its target resolved to, before its ops.
+    /// Returns false, after printing an error op, at the first event that
+    /// cannot be parsed or whose selector does not name exactly one element.
+    @discardableResult
+    func replay(events script: String) -> Bool {
+        for raw in _EventScript.split(script) {
+            // `wait:500`: the virtual clock moves on 500 ms, running what comes due
+            // (work an event queued, a timer), before the next event.
+            if raw.hasPrefix("wait:"), let ms = Double(String(raw.dropFirst(5)).trimmingSpaces()), ms >= 0 {
+                runHeadlessClock(upTo: Double(_HostExecutor.shared.nowNs) / 1_000_000 + ms)
+                continue
+            }
+            let event: [String: _JSON]
+            do {
+                event = try scriptEvent(raw)
+            } catch {
+                print(_JSON.object(["op": .string("error"), "message": .string(error.message)]).serialized)
+                return false
+            }
+            host.apply([.event(.object(event))])
+            dispatch(event: .object(event))
+        }
+        return true
+    }
+
+    func scriptEvent(_ raw: String) throws(_ScriptError) -> [String: _JSON] {
+        let parsed = try _EventScript.parse(raw)
+        let unrecognized = _ScriptError(message: "unrecognized event \(raw)")
+        func number(_ text: String?) throws(_ScriptError) -> _JSON {
+            guard let text, let value = Double(text) else { throw unrecognized }
+            return .number(value)
+        }
+        func size(_ text: String?) throws(_ScriptError) -> _JSON {
+            let dims = (text ?? "").split(separator: "x").compactMap { Double(String($0)) }
+            guard dims.count == 2 else { throw unrecognized }
+            return .object(["width": .number(dims[0]), "height": .number(dims[1])])
+        }
+
+        switch parsed.type {
+        case "back", "dismiss":
+            guard parsed.target == nil, parsed.value == nil else { throw unrecognized }
+            let target = parsed.type == "back" ? try reconciler.backTarget() : try reconciler.dismissTarget()
+            return ["type": .string("tap"), "id": .number(Double(target.id))]
+        case "env", "type", "size":
+            guard let value = parsed.value, !value.isEmpty else { throw unrecognized }
+            let field = ["env": "colorScheme", "type": "dynamicTypeSize", "size": "horizontalSizeClass"][parsed.type]!
+            return ["type": .string("environment"), field: .string(value)]
+        default:
+            break
+        }
+
+        var element: _Reconciler.Rendered?
+        let id: Int
+        switch parsed.target {
+        case .id(let number)?:
+            id = number
+        case .selector(let selector)?:
+            let resolved = try reconciler.resolve(selector, for: parsed.type)
+            element = resolved
+            id = resolved.id
+        case nil:
+            throw unrecognized
+        }
+        var event: [String: _JSON] = ["type": .string(parsed.type), "id": .number(Double(id))]
+        let value = parsed.value
+
+        switch parsed.type {
+        case "tap", "longpress", "delete", "refresh":
+            guard value == nil else { throw unrecognized }
+        case "text":
+            guard let value else { throw unrecognized }
+            event["value"] = .string(value)
+        case "toggle":
+            guard value == "true" || value == "false" else { throw unrecognized }
+            event["value"] = .bool(value == "true")
+        case "select":
+            if parsed.valueQuoted, let option = value {
+                guard let target = element ?? reconciler.element(id: id) else { throw unrecognized }
+                event["value"] = .number(Double(try reconciler.optionIndex(option, of: target)))
+            } else {
+                event["value"] = try number(value)
+            }
+        case "step", "slide", "date":
+            event["value"] = try number(value)
+        case "geometry":
+            guard case .object(let dims) = try size(value) else { throw unrecognized }
+            event["width"] = dims["width"]
+            event["height"] = dims["height"]
+        case "drag":
+            // drag:12:changed:40x-3 (phase and translation)
+            let rest = (value ?? "").split(separator: ":", maxSplits: 1).map { String($0).trimmingSpaces() }
+            guard rest.count == 2 else { throw unrecognized }
+            event["phase"] = .string(rest[0])
+            event["translation"] = try size(rest[1])
+        default:
+            throw unrecognized
+        }
+        return event
+    }
+}
+
+/// A host request failed: the host could not perform it (a network error,
+/// a missing headless fixture). `URLSession` maps it onto `URLError`.
+public struct _HostRequestError: Error, CustomStringConvertible, Sendable {
+    public let message: String
+    public init(message: String) { self.message = message }
+    public var description: String { message }
+}
+
+/// Standard base64 (RFC 4648, padded). The runtime has no Foundation.
+public func _base64(_ bytes: [UInt8]) -> String {
+    let table = Array("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".utf8)
+    var out: [UInt8] = []
+    out.reserveCapacity((bytes.count + 2) / 3 * 4)
+    var index = 0
+    while index + 3 <= bytes.count {
+        let n = (UInt32(bytes[index]) << 16) | (UInt32(bytes[index + 1]) << 8) | UInt32(bytes[index + 2])
+        out += [table[Int(n >> 18 & 63)], table[Int(n >> 12 & 63)], table[Int(n >> 6 & 63)], table[Int(n & 63)]]
+        index += 3
+    }
+    let rest = bytes.count - index
+    if rest == 1 {
+        let n = UInt32(bytes[index]) << 16
+        out += [table[Int(n >> 18 & 63)], table[Int(n >> 12 & 63)], 61, 61]
+    } else if rest == 2 {
+        let n = (UInt32(bytes[index]) << 16) | (UInt32(bytes[index + 1]) << 8)
+        out += [table[Int(n >> 18 & 63)], table[Int(n >> 12 & 63)], table[Int(n >> 6 & 63)], 61]
+    }
+    return String(decoding: out, as: UTF8.self)
+}
+
+/// Views that run an action when first mounted.
+protocol _OnAppearing: _TraitBearing {
+    var _action: (@MainActor () -> Void)? { get }
+}
+
+extension _OnAppearView: _OnAppearing {
+    var _action: (@MainActor () -> Void)? { action }
+}
+
+/// Views that run an action when they leave the tree.
+protocol _OnDisappearing: _TraitBearing {
+    var _disappearAction: (@MainActor () -> Void)? { get }
+}
+
+extension _OnDisappearView: _OnDisappearing {
+    var _disappearAction: (@MainActor () -> Void)? { action }
+}
+
+func _primitiveJSON(_ value: Any) -> _JSON? {
+    switch value {
+    case let v as Int: .number(Double(v))
+    case let v as Double: .number(v)
+    case let v as String: .string(v)
+    case let v as Bool: .bool(v)
+    default: nil
+    }
+}
+
+/// The WASI environment (`SB_*` variables the host sets); nil when unset.
+public func _environment(_ name: String) -> String? {
+    guard let value = getenv(name) else { return nil }
+    return String(cString: value)
+}
+
+/// Identity for a sheet element at the root, so re-renders keep its id.
+struct _SheetKey: Hashable {
+    let path: String
+}
+
+/// Identity for an alert element at the root.
+struct _AlertKey: Hashable {
+    let path: String
+}
+
+/// The element with every `button` in its subtree made to also set
+/// `isPresented` to false when tapped (an alert's action buttons dismiss it).
+private func _dismissing(_ element: _Element, with isPresented: Binding<Bool>) -> _Element {
+    var copy = element
+    if element.kind == "button" {
+        let action = element.handler
+        copy.handler = { payload in
+            action?(payload)
+            isPresented.wrappedValue = false
+        }
+    }
+    copy.children = element.children.map { _dismissing($0, with: isPresented) }
+    return copy
+}
+
+// MARK: - Tab and picker helpers
+
+/// Flattens structural groups (tuples, optionals, conditionals, ForEach) into
+/// the views they contribute, keeping ForEach ids as tags when asked.
+@MainActor
+func _flattenChildren(_ view: any View, keys: Bool) -> [(view: any View, tag: AnyHashable?)] {
+    // A `Text` is a group (of its one rendering) but one view to its container.
+    if let group = view as? any _GroupView, !(view is Text),
+       !(view is any _TabItemProviding), !(view is any _TagProviding) {
+        let children = group._children
+        let ids = keys ? group._keys : nil
+        return children.enumerated().flatMap { index, child -> [(view: any View, tag: AnyHashable?)] in
+            let nested = _flattenChildren(child, keys: keys)
+            guard let ids else { return nested }
+            return nested.map { ($0.view, $0.tag ?? ids[index]) }
+        }
+    }
+    return [(view, _tag(of: view))]
+}
+
+@MainActor
+func _flattenChildren(_ view: any View) -> [any View] {
+    _flattenChildren(view, keys: false).map(\.view)
+}
+
+/// The `.tag` applied to a view, looking through other wrappers.
+@MainActor
+func _tag(of view: any View) -> AnyHashable? {
+    if let tagged = view as? any _TagProviding { return tagged._tag }
+    if let item = view as? any _TabItemProviding { return _tag(of: item._tabContent) }
+    if let group = view as? any _GroupView, group._children.count == 1, !(view is TupleView<Any>) {
+        return _tag(of: group._children[0])
+    }
+    return nil
+}
+
+/// The `.tabItem` label applied to a view, looking through other wrappers.
+@MainActor
+func _tabLabel(of view: any View) -> (any View)? {
+    if let item = view as? any _TabItemProviding { return item._tabLabel }
+    if let tagged = view as? any _TagProviding { return _tabLabel(of: tagged._tagged) }
+    if let group = view as? any _GroupView, group._children.count == 1 {
+        return _tabLabel(of: group._children[0])
+    }
+    return nil
+}
+
+/// Removes `toolbar` and `searchfield` elements from anywhere under `element`
+/// (appending them to `bar`) and returns the element without them.
+private func _hoistBarItems(from element: _Element, into bar: inout [_Element],
+                           barFree: inout _BarFreeTokens) -> _Element {
+    if barFree.contains(element.token) { return element }
+    var kept: [_Element] = []
+    var changed = false
+    for child in element.children {
+        if child.kind == "toolbar" || child.kind == "searchfield" {
+            bar.append(child)
+            changed = true
+        } else {
+            let hoisted = _hoistBarItems(from: child, into: &bar, barFree: &barFree)
+            if hoisted.token != child.token { changed = true }
+            kept.append(hoisted)
+        }
+    }
+    // Unchanged subtrees keep their element (and token), so the reconciler
+    // can skip them; a modified copy is a new element.
+    guard changed else {
+        barFree.insert(element.token)
+        return element
+    }
+    var copy = element
+    copy.children = kept
+    copy.token = _Element.nextToken()
+    return copy
+}
+
+/// Tokens of element subtrees known to hold no `toolbar` or `searchfield`,
+/// which `_hoistBarItems` does not walk again. A clean node's cached elements
+/// keep their tokens from pass to pass, so a screen whose content changed in
+/// one place walks only the elements produced anew. Holds the tokens met in
+/// this pass and the previous one.
+struct _BarFreeTokens {
+    private var current: Set<Int> = []
+    private var previous: Set<Int> = []
+
+    mutating func contains(_ token: Int) -> Bool {
+        if current.contains(token) { return true }
+        guard previous.contains(token) else { return false }
+        current.insert(token)
+        return true
+    }
+
+    mutating func insert(_ token: Int) { current.insert(token) }
+
+    mutating func nextPass() {
+        swap(&current, &previous)
+        current.removeAll(keepingCapacity: true)
+    }
+}
+
+/// A picker's options, looking through `Section`s (their headers are dropped).
+@MainActor
+func _flattenPickerOptions(_ options: any View) -> [(view: any View, tag: AnyHashable?)] {
+    _flattenChildren(options, keys: true).flatMap { entry -> [(view: any View, tag: AnyHashable?)] in
+        if let section = entry.view as? any _SectionView {
+            return _flattenPickerOptions(section._sectionContent)
+        }
+        return [entry]
+    }
+}