@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/Runtime/Runtime.swift

@@ -19,8 +19,8 @@ final class _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.
-    var path = ""
+    /// 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)?
@@ -28,9 +28,13 @@ final class _MountedNode {
     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.
@@ -39,6 +43,12 @@ final class _MountedNode {
     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.
@@ -52,6 +62,7 @@ final class _MountedNode {
     /// 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
@@ -76,6 +87,24 @@ final class _MountedNode {
     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
     }
@@ -150,8 +179,8 @@ final class _NavContext {
 
 struct _ReconcileContext {
     var environment: EnvironmentValues
-    /// `index:Type/index:Type/...` from the root; keys state snapshots.
-    var path: String = ""
+    /// `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`).
@@ -161,6 +190,52 @@ struct _ReconcileContext {
     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.
@@ -171,22 +246,37 @@ public final class _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()
+    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] = [:]
-    /// Animation for the next render pass, set by `withAnimation`. Shared by
-    /// every runtime instance because `withAnimation` is a free function.
-    private static var transactionAnimation: Animation?
+    /// 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
@@ -199,29 +289,291 @@ public final class _Runtime {
 
     /// 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 {
-            replay(events: _environment("SB_EVENTS") ?? "")
+            // 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/_FoundationCommon).
+    /// 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) {
@@ -229,8 +581,7 @@ public final class _Runtime {
         var guardCount = 0
         while guardCount < 10_000 {
             guardCount += 1
-            let next = executor.runJobs()
-            renderIfNeeded()
+            let next = runJobsAndRender()
             if next < 0 { break }
             let nextMs = Double(executor.nowNs + UInt64(next)) / 1_000_000
             if nextMs > limit { break }
@@ -242,8 +593,10 @@ public final class _Runtime {
     /// 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()
     }
 
@@ -256,6 +609,7 @@ public final class _Runtime {
     public func dispatch(event: _JSON) {
         handle(event)
         renderIfNeeded()
+        _flushAfterUpdate()
     }
 
     /// Applies an event's state changes without rendering. A `batch` event
@@ -270,8 +624,17 @@ public final class _Runtime {
         case "batch":
             if case .array(let events)? = fields["events"] { events.forEach(handle) }
         case "tap":
-            if let id { reconciler.handlers[id]?(.null) }
-        case "text", "toggle", "select", "step", "slide", "date":
+            // 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"] {
@@ -281,11 +644,15 @@ public final class _Runtime {
             // 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":
+        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`).
+            // `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
@@ -303,15 +670,30 @@ public final class _Runtime {
                 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
@@ -319,6 +701,12 @@ public final class _Runtime {
     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) {
@@ -332,9 +720,35 @@ public final class _Runtime {
         }
     }
 
-    /// Records the animation `withAnimation` wants for the changes that follow.
-    func beginTransaction(_ animation: Animation?) {
-        Self.transactionAnimation = animation
+    /// 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
@@ -342,11 +756,28 @@ public final class _Runtime {
     public func runJobs(nowMilliseconds: Double) -> Double {
         let executor = _HostExecutor.shared
         executor.nowNs = UInt64(max(0, nowMilliseconds) * 1_000_000)
-        let next = executor.runJobs()
-        renderIfNeeded()
+        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() }
     }
@@ -357,23 +788,38 @@ public final class _Runtime {
         guard let rootView else { return }
         rendering = true
         needsRender = false
-
-        let context = _ReconcileContext(environment: baseEnvironment, path: _typeName(of: rootView))
+        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
+            elements(of: node) + presentedSheets + presentedAlerts + (measuringNode.map { elements(of: $0) } ?? [])
         } onChange: { [weak self] in
             MainActor.assumeIsolated { self?.invalidate() }
         }
-        let animation = Self.transactionAnimation?._json
-        Self.transactionAnimation = nil
+        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.
@@ -382,7 +828,11 @@ public final class _Runtime {
         }
         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() }
@@ -392,14 +842,24 @@ public final class _Runtime {
     /// 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). 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.
+    /// 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
@@ -430,9 +890,15 @@ public final class _Runtime {
         }
         node.dirty = false
         node.subtreeDirty = false
-        if !clean { node.cachedElements = nil }
+        // 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 {
@@ -444,42 +910,58 @@ public final class _Runtime {
             }
         }
 
-        if let modifier = view as? any _EnvironmentModifying {
+        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 let preferred = view as? any _PreferredColorSchemeModifying, !context.inactiveTab {
+        if traits.contains(.preferredColorScheme), let preferred = view as? any _PreferredColorSchemeModifying, !context.inactiveTab {
             preferredColorScheme = preferred._preferredColorScheme
         }
-        if context.environment._scrollTargetLayout, view is any _ScrollTargetContainer {
+        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 let title = view as? any _NavigationTitleModifying, let screen = context.screen, !context.inactiveTab {
+        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 let appear = view as? any _OnAppearing, !node.appeared {
+        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 let detents = view as? any _DetentsModifying, let sheet = context.sheet {
+        if traits.contains(.detents), let detents = view as? any _DetentsModifying, let sheet = context.sheet {
             sheet.sheetDetents = detents._detents
         }
-        if let animated = view as? any _AnimatedView {
+        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 let registration = view as? any _DestinationRegistering {
+        if traits.contains(.destinationRegistering), let registration = view as? any _DestinationRegistering {
             context.navStack?.register(registration)
         }
-        if let sidebar = view as? _SplitSidebarView {
+        if traits.contains(.splitSidebar), let sidebar = view as? _SplitSidebarView {
             context.split = sidebar.split
         }
-        if let list = view as? any _ListSelectionProviding {
-            if let selection = list._selection {
+        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
             }
@@ -488,7 +970,7 @@ public final class _Runtime {
                 context.environment.editMode = editModeBinding(for: node)
             }
         }
-        if let starting = view as? any _TaskStarting {
+        if traits.contains(.taskStarting), let starting = view as? any _TaskStarting {
             if !node.taskStarted || node.taskID != starting._taskID {
                 node.task?.cancel()
                 node.taskStarted = true
@@ -509,7 +991,7 @@ public final class _Runtime {
         node.handler = nil
         node.navFlattened = false
 
-        if let split = view as? any _NavigationSplitHost {
+        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 }
@@ -546,12 +1028,12 @@ public final class _Runtime {
                     return detailScreens + pushedScreens
                 }
             }
-        } else if let stack = view as? any _NavigationStackView, context.screen != nil, context.navStack != nil {
+        } 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 let stack = view as? any _NavigationStackView {
+        } 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 = {
@@ -563,7 +1045,7 @@ public final class _Runtime {
                 }
                 return [_NavScreenView(content: stack._root, depth: 0)] + pathScreens + pushedScreens
             }
-        } else if let screen = view as? _NavScreenView {
+        } 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
@@ -575,7 +1057,9 @@ public final class _Runtime {
             if screen.depth > 0, let nav = context.navStack {
                 let depth = screen.depth
                 node.handler = { _ in nav.pop(to: depth) }
-                context.environment.dismiss = DismissAction { 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.
@@ -589,9 +1073,9 @@ public final class _Runtime {
                 }
                 return [screen.content]
             }
-        } else if let link = view as? any _NavigationLinkView {
+        } else if traits.contains(.navigationLink), let link = view as? any _NavigationLinkView {
             let destination = link._destination
-            let value = (view as? any _NavigationValueLinkView)?._value
+            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.
@@ -606,7 +1090,7 @@ public final class _Runtime {
                 }
             }
             makeChildren = { (view as? any _HostView)?._content ?? [] }
-        } else if let tabs = view as? any _TabViewHost {
+        } 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)
@@ -615,19 +1099,22 @@ public final class _Runtime {
                 if case .number(let index) = payload { tabs._select(index: Int(index), tags: tags) }
             }
             let selected = node.selectedIndex
-            makeChildren = {
-                roots.enumerated().map { index, root in
-                    let label = _tabLabel(of: root)
-                    return _TabScreenView(content: root,
-                                          title: label.map { _textContent(of: $0) } ?? "",
-                                          systemImage: label.flatMap { _systemImage(of: $0) },
-                                          isSelected: index == selected)
+            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 let tab = view as? _TabScreenView {
+        } else if traits.contains(.tabScreen), let tab = view as? _TabScreenView {
             if !tab.isSelected { context.inactiveTab = true }
             makeChildren = { [tab.content] }
-        } else if let picker = view as? any _PickerHost {
+        } 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)
@@ -638,7 +1125,7 @@ public final class _Runtime {
                 if case .number(let index) = payload { picker._select(index: Int(index), tags: tags) }
             }
             makeChildren = { [] }
-        } else if let reader = view as? any _GeometryReading {
+        } 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,
@@ -651,7 +1138,7 @@ public final class _Runtime {
                 }
             }
             makeChildren = { [reader._content(for: size)] }
-        } else if let sheet = view as? any _SheetPresenting {
+        } 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
@@ -661,39 +1148,95 @@ public final class _Runtime {
                 isPresented.wrappedValue = false
                 onDismiss?()
             }
-            if isPresented.wrappedValue {
-                makeChildren = { [sheet._base, sheet._sheetContent] }
-            } else {
-                makeChildren = { [sheet._base] }
-            }
-        } else if let alert = view as? any _AlertPresenting {
+            // 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 }
-            if isPresented.wrappedValue {
-                makeChildren = { [alert._base, alert._alertActions] }
-            } else {
-                makeChildren = { [alert._base] }
+            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 let group = view as? any _GroupView {
+        } else if traits.contains(.group), let group = view as? any _GroupView {
             keys = group._keys
             makeChildren = { group._children }
-        } else if let hostView = view as? any _HostView {
-            makeChildren = { hostView._content }
+            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, let refreshing = view as? any _Refreshing {
+        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, let handling = view as? any _EnvironmentHandling {
+        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
-        if clean {
+        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
@@ -705,10 +1248,55 @@ public final class _Runtime {
         }
         var phases = [makeChildren]
         if let makeMoreChildren { phases.append(makeMoreChildren) }
-        reconcileChildren(of: node, phases: phases, keys: keys, context: context, force: !clean)
+        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?,
@@ -728,8 +1316,11 @@ public final class _Runtime {
     /// 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) {
+                                   keys: [AnyHashable]?, context: _ReconcileContext, force: Bool,
+                                   forceLaterPhases: Bool = false) {
         let old = node.children
         var oldByKey: [AnyHashable: _MountedNode] = [:]
         for child in old {
@@ -744,6 +1335,9 @@ public final class _Runtime {
 
         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.
@@ -764,22 +1358,23 @@ public final class _Runtime {
                     existing = nil
                 }
                 var childContext = context
-                let segment = key.map { "\($0.base)" } ?? String(index)
-                childContext.path += "/\(segment):\(_typeName(of: childView))"
+                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 {
+                    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 { isPresented.wrappedValue = false }
+                    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
@@ -793,6 +1388,10 @@ public final class _Runtime {
     /// 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 {
@@ -804,11 +1403,16 @@ public final class _Runtime {
         )
     }
 
-    /// Cancels tasks in a subtree that left the tree.
+    /// 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 {
@@ -822,35 +1426,72 @@ public final class _Runtime {
     ///
     /// 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; when
-    /// none of its stored properties is one of those wrappers the type is
-    /// remembered as plain and never reflected again. The wrappers are
-    /// concrete struct types, so whether a stored property is one is a
-    /// property of the type, not of the instance.
+    /// 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]? {
-        let key = ObjectIdentifier(type(of: view))
-        if let plain = plainTypes[key], plain { return nil }
-        var values = Mirror(reflecting: view).children.map(\.value)
         // `ModifiedContent` stores its `ViewModifier`, whose own `@State` and
         // `@Environment` properties are managed like the view's.
-        for value in values where value is any ViewModifier {
-            values += Mirror(reflecting: value).children.map(\.value)
+        // 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
         }
-        if plainTypes[key] == nil {
-            let relevant = values.contains { value in
-                value is any _StateProperty || value is any _EnvironmentProperty || value is any _ObservingProperty
+        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
             }
-            plainTypes[key] = !relevant
-            if !relevant { return nil }
+        }
+        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
     }
 
-    /// Per view type: `true` when it declares no runtime-managed properties.
-    private var plainTypes: [ObjectIdentifier: Bool] = [:]
-    /// Per view type: its name without generic arguments.
-    private var typeNames: [ObjectIdentifier: String] = [:]
-
     private func stateBoxes(in properties: [Any]?) -> [any _AnyStateBox] {
         guard let properties else { return [] }
         return properties.compactMap { ($0 as? any _StateProperty)?._box }
@@ -864,21 +1505,13 @@ public final class _Runtime {
         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) }
             }
         }
     }
 
-    private func _typeName(of view: any View) -> String {
-        let key = ObjectIdentifier(type(of: view))
-        if let cached = typeNames[key] { return cached }
-        let full = String(describing: type(of: view))
-        let name = if let angle = full.firstIndex(of: "<") { String(full[..<angle]) } else { full }
-        typeNames[key] = name
-        return name
-    }
-
     // MARK: Elements
 
     private func elements(of node: _MountedNode) -> [_Element] {
@@ -898,12 +1531,13 @@ public final class _Runtime {
 
     private func produceElements(of node: _MountedNode) -> [_Element] {
         var produced: [_Element]
-        if node.view is _NavScreenView {
+        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) }
+            let content = node.children.flatMap(elements(of:)).map { _hoistBarItems(from: $0, into: &bar, barFree: &barFree) }
             produced = [_Element(
                 kind: "navscreen",
                 props: .object([
@@ -914,7 +1548,7 @@ public final class _Runtime {
                 children: content + bar,
                 handler: node.handler
             )]
-        } else if let sheet = node.view as? any _SheetPresenting {
+        } 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 {
@@ -924,10 +1558,10 @@ public final class _Runtime {
                     props: .object(["detents": .array(detents.map(_JSON.string))]),
                     children: elements(of: node.children[1]),
                     handler: node.handler,
-                    key: AnyHashable(_SheetKey(path: node.path))
+                    key: AnyHashable(_SheetKey(path: node.path?.text ?? ""))
                 ))
             }
-        } else if let alert = node.view as? any _AlertPresenting {
+        } 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:)) ?? []
@@ -943,10 +1577,10 @@ public final class _Runtime {
                     ]),
                     children: buttons,
                     handler: node.handler,
-                    key: AnyHashable(_AlertKey(path: node.path))
+                    key: AnyHashable(_AlertKey(path: node.path?.text ?? ""))
                 ))
             }
-        } else if node.view is any _NavigationSplitHost {
+        } 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.
@@ -957,16 +1591,18 @@ public final class _Runtime {
                 children: node.children.flatMap(elements(of:)),
                 handler: nil
             )]
-        } else if node.view is any _NavigationStackView, node.navFlattened {
+        } 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 node.view is any _TabViewHost {
+        } 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 node.view is any _PickerHost {
+        } else if traits.contains(.picker) {
             produced = [_Element(
                 kind: "picker",
                 props: .object([
@@ -978,7 +1614,7 @@ public final class _Runtime {
                 children: [],
                 handler: node.handler
             )]
-        } else if let animated = node.view as? any _AnimatedView {
+        } 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(
@@ -987,25 +1623,38 @@ public final class _Runtime {
                 children: node.children.flatMap(elements(of:)),
                 handler: nil
             )]
-        } else if !(node.view is any _GroupView), let hostView = node.view as? any _HostView {
-            // Groups are checked first: casting an `Optional<SomeHostView>` to
-            // `_HostView` unwraps the optional, which would misclassify it.
+        } 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 let link = node.view as? any _NavigationValueLinkView, let value = link._value {
+            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
@@ -1015,26 +1664,45 @@ public final class _Runtime {
             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 let tagged = node.view as? any _TagProviding {
+        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 let disabling = node.view as? any _RowEditingDisabling, disabling._deleteDisabled {
+        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 let tab = node.view as? _TabScreenView, !tab.isSelected {
+        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) }
+            produced = produced.map { _hoistBarItems(from: $0, into: &dropped, barFree: &barFree) }
         }
 
         if let key = node.key {
@@ -1054,7 +1722,7 @@ public final class _Runtime {
     /// 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 = (node.view as? any _DeletableGroup)?._delete
+        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
@@ -1069,7 +1737,7 @@ public final class _Runtime {
                     items[index].row = (items[index].row ?? _RowMark()).merged(with: _RowMark(delete: { delete(position) }))
                 }
             }
-            if child.key == nil, let group = child.view as? any _GroupView, group._keys != nil {
+            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))
@@ -1144,7 +1812,7 @@ public final class _Runtime {
         func walk(_ node: _MountedNode) {
             for (index, box) in node.boxes.enumerated() {
                 if let json = _primitiveJSON(box._anyValue) {
-                    values["\(node.path)#\(index)"] = json
+                    values["\(node.path?.text ?? "")#\(index)"] = json
                 }
             }
             node.children.forEach(walk)
@@ -1153,10 +1821,11 @@ public final class _Runtime {
         return .object(values)
     }
 
-    private func restoreState(into boxes: [any _AnyStateBox], at path: String) {
-        guard !restoredState.isEmpty else { return }
+    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["\(path)#\(index)"] else { continue }
+            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
@@ -1169,74 +1838,145 @@ public final class _Runtime {
 
     // MARK: Headless replay
 
-    /// Replays events separated by commas: `tap:12`, `text:7:Milk`,
-    /// `toggle:9:true`, `env:dark`, `size:regular`, `step:7:1`, `slide:7:0.35`,
-    /// `date:7:1700000000`, `drag:12:changed:40x-3`, `longpress:12`, `delete:31`,
-    /// `refresh:40`. Each is echoed before its ops.
-    func replay(events: String) {
-        for raw in events.split(separator: ",") {
-            let parts = raw.split(separator: ":", maxSplits: 2).map { String($0).trimmingSpaces() }
-            var event: [String: _JSON] = [:]
-            switch parts.first {
-            case "tap" where parts.count == 2:
-                guard let id = Double(parts[1]) else { break }
-                event = ["type": .string("tap"), "id": .number(id)]
-            case "text" where parts.count == 3:
-                guard let id = Double(parts[1]) else { break }
-                event = ["type": .string("text"), "id": .number(id), "value": .string(parts[2])]
-            case "toggle" where parts.count == 3:
-                guard let id = Double(parts[1]) else { break }
-                event = ["type": .string("toggle"), "id": .number(id), "value": .bool(parts[2] == "true")]
-            case "env" where parts.count == 2:
-                event = ["type": .string("environment"), "colorScheme": .string(parts[1])]
-            case "type" where parts.count == 2:
-                event = ["type": .string("environment"), "dynamicTypeSize": .string(parts[1])]
-            case "size" where parts.count == 2:
-                event = ["type": .string("environment"), "horizontalSizeClass": .string(parts[1])]
-            case "select" where parts.count == 3:
-                guard let id = Double(parts[1]), let index = Double(parts[2]) else { break }
-                event = ["type": .string("select"), "id": .number(id), "value": .number(index)]
-            case "step" where parts.count == 3, "slide" where parts.count == 3, "date" where parts.count == 3:
-                guard let id = Double(parts[1]), let value = Double(parts[2]) else { break }
-                event = ["type": .string(parts[0]), "id": .number(id), "value": .number(value)]
-            case "geometry" where parts.count == 3:
-                let dims = parts[2].split(separator: "x").compactMap { Double($0) }
-                guard let id = Double(parts[1]), dims.count == 2 else { break }
-                event = ["type": .string("geometry"), "id": .number(id), "width": .number(dims[0]), "height": .number(dims[1])]
-            case "drag" where parts.count == 3:
-                // drag:12:changed:40x-3 (phase and translation)
-                let rest = parts[2].split(separator: ":").map { String($0).trimmingSpaces() }
-                guard let id = Double(parts[1]), rest.count == 2 else { break }
-                let dims = rest[1].split(separator: "x").compactMap { Double($0) }
-                guard dims.count == 2 else { break }
-                event = [
-                    "type": .string("drag"), "id": .number(id), "phase": .string(rest[0]),
-                    "translation": .object(["width": .number(dims[0]), "height": .number(dims[1])]),
-                ]
-            case "longpress" where parts.count == 2, "delete" where parts.count == 2, "refresh" where parts.count == 2:
-                guard let id = Double(parts[1]) else { break }
-                event = ["type": .string(parts[0]), "id": .number(id)]
-            default:
-                break
-            }
-            guard !event.isEmpty else {
-                print("{\"message\":\"unrecognized event \(raw)\",\"op\":\"error\"}")
+    /// 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
     }
 }
 
-private extension String {
-    func trimmingSpaces() -> String {
-        String(drop(while: { $0 == " " }).reversed().drop(while: { $0 == " " }).reversed())
+/// 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 {
+protocol _OnAppearing: _TraitBearing {
     var _action: (@MainActor () -> Void)? { get }
 }
 
@@ -1244,6 +1984,15 @@ 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))
@@ -1291,7 +2040,8 @@ private func _dismissing(_ element: _Element, with isPresented: Binding<Bool>) -
 /// the views they contribute, keeping ForEach ids as tags when asked.
 @MainActor
 func _flattenChildren(_ view: any View, keys: Bool) -> [(view: any View, tag: AnyHashable?)] {
-    if let group = view as? any _GroupView,
+    // 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
@@ -1333,7 +2083,9 @@ func _tabLabel(of view: any View) -> (any View)? {
 
 /// 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]) -> _Element {
+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 {
@@ -1341,20 +2093,47 @@ private func _hoistBarItems(from element: _Element, into bar: inout [_Element])
             bar.append(child)
             changed = true
         } else {
-            let hoisted = _hoistBarItems(from: child, into: &bar)
+            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 { return 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?)] {