@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/Runtime/Measurements.swift

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

package/Sources/SwiftUI/Runtime/Ops.swift

@@ -12,6 +12,17 @@ public enum _Op: Equatable, Sendable {
     /// The app's `UserDefaults`, whole, after a change; the host stores them
     /// and hands them back at the next launch (`SB_DEFAULTS`).
     case defaults(_JSON)
+    /// Phase 13: something only the host can do (`fetch`, an `image` probe);
+    /// the host answers with a `response` event carrying the same id.
+    case request(id: Int, kind: String, params: _JSON)
+    /// Phase 18: one saved batch of a SwiftData store (an object with `store`,
+    /// `put` and `delete`); the host writes it to IndexedDB and hands the
+    /// store back at the next launch (`SB_SWIFTDATA`).
+    case swiftData(_JSON)
+    /// A bitmap's source (an image file, or a generator's pixels) under its
+    /// content key, sent once before the first element that draws it; the
+    /// host keeps it for the run (docs/ops-protocol.md, "Bitmaps and Core Image").
+    case imageData(_JSON)
 
     public var json: _JSON {
         switch self {
@@ -35,6 +46,20 @@ public enum _Op: Equatable, Sendable {
             return .object(["op": .string("event")])
         case .defaults(let values):
             return .object(["op": .string("defaults"), "values": values])
+        case .request(let id, let kind, let params):
+            return .object(["op": .string("request"), "id": .number(Double(id)), "kind": .string(kind), "params": params])
+        case .swiftData(let change):
+            if case .object(var fields) = change {
+                fields["op"] = .string("swiftdata")
+                return .object(fields)
+            }
+            return .object(["op": .string("swiftdata")])
+        case .imageData(let source):
+            if case .object(var fields) = source {
+                fields["op"] = .string("imagedata")
+                return .object(fields)
+            }
+            return .object(["op": .string("imagedata")])
         }
     }
 }
@@ -54,34 +79,55 @@ final class _HeadlessHost: _RenderHost {
     }
 }
 
-/// Keeps pending ops serialized as a JSON array in a stable heap buffer that
-/// the browser reads out of linear memory via the `sb_ops_*` exports.
+/// Keeps pending ops serialized as a JSON array in a heap buffer that the
+/// browser reads out of linear memory via the `sb_ops_*` exports, and their
+/// `.bytes` values beside it (`sb_bytes_*`) once the page has asked for them
+/// (else as base64). The ops are serialized when the page reads them, once
+/// per batch, not on every `apply`.
 @MainActor
 final class _BufferedHost: _RenderHost {
     static let shared = _BufferedHost()
 
     private(set) var pending: [_Op] = []
     private var buffer: UnsafeMutableBufferPointer<UInt8> = .allocate(capacity: 2)
-
-    init() {
-        reserialize()
-    }
+    private let outbox = _BytesOutbox()
+    private var stale = true
+    /// The page reads `.bytes` beside the JSON: it called `sb_bytes_count`.
+    private var bytesBeside = false
 
     func apply(_ ops: [_Op]) {
         pending.append(contentsOf: ops)
-        reserialize()
+        stale = true
     }
 
     func clear() {
         pending.removeAll()
-        reserialize()
+        stale = true
     }
 
-    var pointer: Int32 { Int32(Int(bitPattern: buffer.baseAddress)) }
-    var length: Int32 { Int32(buffer.count) }
+    var pointer: Int32 { serialize(); return Int32(Int(bitPattern: buffer.baseAddress)) }
+    var length: Int32 { serialize(); return Int32(buffer.count) }
+
+    /// The buffer's text (tests: `pointer` is a wasm32 address).
+    var text: String { serialize(); return String(decoding: buffer, as: UTF8.self) }
+
+    /// The `.bytes` values of the pending ops, by the `n` of their `{"$bytes": n}`.
+    /// The first read opts the page in: from then on the ops name them as `{"$bytes": n}`.
+    var bytes: [UnsafeMutableBufferPointer<UInt8>] {
+        if !bytesBeside {
+            bytesBeside = true
+            stale = true
+        }
+        serialize()
+        return outbox.items
+    }
 
-    private func reserialize() {
-        let bytes = Array(_JSON.array(pending.map(\.json)).serialized.utf8)
+    private func serialize() {
+        guard stale else { return }
+        stale = false
+        outbox.removeAll()
+        let json = _JSON.array(pending.map(\.json))
+        let bytes = Array((bytesBeside ? json.serialized(outbox: outbox) : json.serialized).utf8)
         buffer.deallocate()
         buffer = .allocate(capacity: bytes.count)
         _ = buffer.initialize(from: bytes)

package/Sources/SwiftUI/Runtime/Reconciler.swift

@@ -8,6 +8,11 @@ struct _Element {
     var key: AnyHashable?
     /// What makes this element a selectable or deletable `List` row (Phase 8).
     var row: _RowMark?
+    /// `accessibilityLabel` / `accessibilityIdentifier`, for event scripts only.
+    var accessibility: _AccessibilityMark?
+    /// `.layoutValue(key:value:)` above this element, by key type: what a
+    /// custom layout's subview reads (CustomLayout.swift).
+    var layoutValues: [ObjectIdentifier: Any]?
     /// Identity of this element value: a fresh token per produced element,
     /// kept by copies. Two elements with one token are the same subtree (a
     /// clean node's cached output), which the reconciler skips whole.
@@ -59,6 +64,8 @@ final class _Reconciler {
         var key: AnyHashable?
         /// The token of the element this was rendered from.
         var token: Int
+        /// Not sent to the host; headless event scripts match it.
+        var accessibility: _AccessibilityMark?
     }
 
     private(set) var roots: [Rendered] = []
@@ -152,6 +159,7 @@ final class _Reconciler {
         if previous.token == element.token { return previous }
         var rendered = previous
         rendered.token = element.token
+        rendered.accessibility = element.accessibility
         if rendered.props != element.props {
             ops.append(.update(id: rendered.id, props: element.props))
             rendered.props = element.props
@@ -170,7 +178,8 @@ final class _Reconciler {
         let children = element.children.enumerated().map { childIndex, child in
             create(child, parent: id, index: childIndex, ops: &ops)
         }
-        return Rendered(id: id, kind: element.kind, props: element.props, children: children, key: element.key, token: element.token)
+        return Rendered(id: id, kind: element.kind, props: element.props, children: children, key: element.key,
+                        token: element.token, accessibility: element.accessibility)
     }
 
     private func destroy(_ rendered: Rendered, ops: inout [_Op]) {

package/Sources/SwiftUI/Runtime/Replay.swift

@@ -0,0 +1,382 @@
+// Headless event scripts (SB_EVENTS, Examples/*/__snapshots__/events.txt).
+//
+// An event names its target by element id (`tap:12`) or by a selector
+// resolved against what is on screen when the event is replayed:
+//
+//   tap:"Add Samples 2"         the tappable element showing that text
+//   tap:"Edit"#2                the second of several matches
+//   tap:@save                   `.accessibilityIdentifier("save")`
+//   select:[tabview]:"Settings" an element of that kind (here by a tab title)
+//   text:"Name":Paul            a field by its placeholder
+//   back, dismiss               the visible screen's back button, the top sheet or alert
+//
+// A selector that matches nothing, or several elements without `#n`, stops
+// the replay with an error op, so a script never taps the wrong element.
+
+/// A replay target written as a selector.
+struct _Selector: CustomStringConvertible {
+    var kind: String?
+    var text: String?
+    var identifier: String?
+    /// 1-based, from `#n`.
+    var index: Int?
+
+    var description: String {
+        var out = ""
+        if let kind { out += "[\(kind)]" }
+        if let text { out += _quoted(text) }
+        if let identifier { out += "@\(identifier)" }
+        if let index { out += "#\(index)" }
+        return out
+    }
+}
+
+enum _ScriptTarget {
+    case id(Int)
+    case selector(_Selector)
+}
+
+/// One event of a script, parsed but not yet resolved.
+struct _ScriptEvent {
+    var type: String
+    var target: _ScriptTarget?
+    /// What follows the target (`Paul` in `text:"Name":Paul`), unquoted.
+    var value: String?
+    /// Whether `value` was written in quotes (`select:"Sort":"Title"` names an option).
+    var valueQuoted = false
+    var raw: String
+}
+
+struct _ScriptError: Error {
+    let message: String
+}
+
+private func _quoted(_ text: String) -> String {
+    "\"" + text.replacingAll("\\", with: "\\\\").replacingAll("\"", with: "\\\"") + "\""
+}
+
+extension String {
+    func trimmingSpaces() -> String {
+        String(drop(while: { $0 == " " }).reversed().drop(while: { $0 == " " }).reversed())
+    }
+
+    fileprivate func replacingAll(_ target: Character, with replacement: String) -> String {
+        var out = ""
+        for character in self {
+            if character == target { out += replacement } else { out.append(character) }
+        }
+        return out
+    }
+}
+
+/// The event types whose first field is a target.
+private let _targetedEvents: Set<String> = [
+    "tap", "text", "toggle", "select", "step", "slide", "date", "geometry",
+    "drag", "longpress", "delete", "refresh",
+]
+
+/// The element kinds a selector picks for each event type, unless it names
+/// a kind itself (`[navscreen]`). A selector resolves to the nearest element
+/// at or above a match that has a handler and is one of these, as a tap on
+/// a button's text reaches the button.
+private let _targetKinds: [String: Set<String>] = [
+    "tap": ["button", "navlink", "listrow", "tapgesture"],
+    "longpress": ["gesture"],
+    "drag": ["gesture"],
+    "delete": ["listrow"],
+    "text": ["textfield", "searchfield", "texteditor"],
+    "toggle": ["toggle"],
+    "select": ["picker", "tabview"],
+    "step": ["stepper"],
+    "slide": ["slider"],
+    "date": ["datepicker"],
+    "geometry": ["geometry"],
+]
+
+enum _EventScript {
+    /// Splits a script into events at commas and line breaks outside quotes.
+    /// A line whose first non-blank character is `#` is a comment.
+    static func split(_ script: String) -> [String] {
+        var events: [String] = []
+        var current = ""
+        var inQuotes = false
+        var escaped = false
+        var inComment = false
+        func flush() {
+            let trimmed = current.trimmingSpaces()
+            if !trimmed.isEmpty { events.append(trimmed) }
+            current = ""
+        }
+        for character in script {
+            if inComment {
+                if character == "\n" { inComment = false }
+                continue
+            }
+            if inQuotes {
+                current.append(character)
+                if escaped {
+                    escaped = false
+                } else if character == "\\" {
+                    escaped = true
+                } else if character == "\"" {
+                    inQuotes = false
+                }
+                continue
+            }
+            switch character {
+            case "\"":
+                inQuotes = true
+                current.append(character)
+            case ",", "\n", "\r":
+                flush()
+            case "#" where current.trimmingSpaces().isEmpty:
+                inComment = true
+            default:
+                current.append(character)
+            }
+        }
+        flush()
+        return events
+    }
+
+    static func parse(_ raw: String) throws(_ScriptError) -> _ScriptEvent {
+        var scanner = _Scanner(raw)
+        let type = scanner.read(until: ":").trimmingSpaces()
+        var event = _ScriptEvent(type: type, raw: raw)
+        guard scanner.skip(":") else { return event }
+        if _targetedEvents.contains(type) {
+            event.target = try scanner.readTarget(in: raw)
+            guard scanner.skip(":") else {
+                guard scanner.atEnd else { throw _ScriptError(message: "unexpected text after the target in \(raw)") }
+                return event
+            }
+        }
+        if scanner.peek == "\"" {
+            event.value = try scanner.readQuoted(in: raw)
+            event.valueQuoted = true
+            guard scanner.atEnd else { throw _ScriptError(message: "unexpected text after the value in \(raw)") }
+        } else {
+            event.value = scanner.rest.trimmingSpaces()
+        }
+        return event
+    }
+}
+
+private struct _Scanner {
+    let characters: [Character]
+    var position = 0
+
+    init(_ text: String) { characters = Array(text) }
+
+    var atEnd: Bool { position >= characters.count }
+    var peek: Character? { atEnd ? nil : characters[position] }
+    var rest: String { String(characters[position...]) }
+
+    mutating func skip(_ character: Character) -> Bool {
+        guard peek == character else { return false }
+        position += 1
+        return true
+    }
+
+    mutating func read(until stop: Character) -> String {
+        var out = ""
+        while let next = peek, next != stop {
+            out.append(next)
+            position += 1
+        }
+        return out
+    }
+
+    mutating func skipSpaces() {
+        while peek == " " { position += 1 }
+    }
+
+    mutating func readQuoted(in raw: String) throws(_ScriptError) -> String {
+        guard skip("\"") else { throw _ScriptError(message: "expected a quoted string in \(raw)") }
+        var out = ""
+        while let next = peek {
+            position += 1
+            if next == "\"" { return out }
+            if next == "\\", let escaped = peek {
+                position += 1
+                out.append(escaped)
+            } else {
+                out.append(next)
+            }
+        }
+        throw _ScriptError(message: "unterminated string in \(raw)")
+    }
+
+    /// An element id, or a selector: `[kind]`, then `"text"` or `@identifier`, then `#n`.
+    mutating func readTarget(in raw: String) throws(_ScriptError) -> _ScriptTarget {
+        skipSpaces()
+        if let first = peek, first.isNumber || first == "-" {
+            let text = read(until: ":").trimmingSpaces()
+            guard let id = Int(text) else { throw _ScriptError(message: "bad element id \(text) in \(raw)") }
+            return .id(id)
+        }
+        var selector = _Selector()
+        if skip("[") {
+            selector.kind = read(until: "]")
+            guard skip("]"), !(selector.kind ?? "").isEmpty else {
+                throw _ScriptError(message: "expected [kind] in \(raw)")
+            }
+        }
+        if peek == "\"" {
+            selector.text = try readQuoted(in: raw)
+        } else if skip("@") {
+            var identifier = ""
+            while let next = peek, next != ":", next != "#" {
+                identifier.append(next)
+                position += 1
+            }
+            selector.identifier = identifier.trimmingSpaces()
+            guard !(selector.identifier ?? "").isEmpty else { throw _ScriptError(message: "expected an identifier after @ in \(raw)") }
+        }
+        if skip("#") {
+            let digits = read(until: ":").trimmingSpaces()
+            guard let index = Int(digits), index > 0 else { throw _ScriptError(message: "bad match number #\(digits) in \(raw)") }
+            selector.index = index
+        }
+        skipSpaces()
+        guard selector.kind != nil || selector.text != nil || selector.identifier != nil else {
+            throw _ScriptError(message: "expected an element id or a selector in \(raw)")
+        }
+        return .selector(selector)
+    }
+}
+
+// MARK: - Resolving selectors
+
+extension _Reconciler.Rendered {
+    func string(_ key: String) -> String? {
+        if case .object(let fields) = props, case .string(let value)? = fields[key] { return value }
+        return nil
+    }
+
+    func number(_ key: String) -> Double? {
+        if case .object(let fields) = props, case .number(let value)? = fields[key] { return value }
+        return nil
+    }
+
+    /// Whether `text` is what this element shows or is labelled with: a
+    /// `text`, an image's name, a screen title, a control's label or
+    /// placeholder, or its `accessibilityLabel`.
+    func shows(_ text: String) -> Bool {
+        if accessibility?.label == text { return true }
+        switch kind {
+        case "text": return string("text") == text
+        case "image": return string("systemName") == text || string("name") == text
+        default:
+            return string("title") == text || string("label") == text || string("placeholder") == text
+        }
+    }
+}
+
+@MainActor
+extension _Reconciler {
+    /// The elements on screen: the top sheet or alert if one is presented,
+    /// else everything, without the screens a stack has pushed over and
+    /// the unselected tabs.
+    private var visibleRoots: [Rendered] {
+        if let modal = roots.last(where: { $0.kind == "sheet" || $0.kind == "alert" }) { return [modal] }
+        return roots
+    }
+
+    private func visibleChildren(of element: Rendered) -> [Rendered] {
+        switch element.kind {
+        case "navstack":
+            guard let top = element.children.lastIndex(where: { $0.kind == "navscreen" }) else { return element.children }
+            return element.children.enumerated().filter { index, child in
+                child.kind != "navscreen" || index == top
+            }.map(\.1)
+        case "tabview":
+            guard let selected = element.number("selected").map(Int.init),
+                  element.children.indices.contains(selected) else { return element.children }
+            return [element.children[selected]]
+        default:
+            return element.children
+        }
+    }
+
+    /// The element a selector names for an event of this type.
+    func resolve(_ selector: _Selector, for type: String) throws(_ScriptError) -> Rendered {
+        let kinds = selector.kind.map { Set([$0]) } ?? _targetKinds[type]
+        func isTarget(_ element: Rendered) -> Bool {
+            handlers[element.id] != nil && (kinds?.contains(element.kind) ?? true)
+        }
+        func isMatch(_ element: Rendered) -> Bool {
+            if let identifier = selector.identifier { return element.accessibility?.identifier == identifier }
+            if let text = selector.text { return element.shows(text) }
+            return element.kind == selector.kind
+        }
+
+        var found: [Rendered] = []
+        func visit(_ element: Rendered, path: inout [Rendered]) {
+            path.append(element)
+            if isMatch(element), let target = path.last(where: isTarget), !found.contains(where: { $0.id == target.id }) {
+                found.append(target)
+            }
+            for child in visibleChildren(of: element) { visit(child, path: &path) }
+            path.removeLast()
+        }
+        var path: [Rendered] = []
+        for root in visibleRoots { visit(root, path: &path) }
+
+        let event = "\(type):\(selector)"
+        guard !found.isEmpty else { throw _ScriptError(message: "\(event) matches nothing on screen") }
+        if let index = selector.index {
+            guard index <= found.count else {
+                throw _ScriptError(message: "\(event): only \(found.count) element\(found.count == 1 ? "" : "s") match")
+            }
+            return found[index - 1]
+        }
+        guard found.count == 1 else {
+            let ids = found.map { "\($0.kind) \($0.id)" }.joined(separator: ", ")
+            throw _ScriptError(message: "\(event) matches \(found.count) elements (\(ids)); pick one with #1…#\(found.count)")
+        }
+        return found[0]
+    }
+
+    /// The rendered element with this id, if it is on the tree.
+    func element(id: Int) -> Rendered? {
+        func find(in elements: [Rendered]) -> Rendered? {
+            for element in elements {
+                if element.id == id { return element }
+                if let found = find(in: element.children) { return found }
+            }
+            return nil
+        }
+        return find(in: roots)
+    }
+
+    /// `back`: the visible screen's back button.
+    func backTarget() throws(_ScriptError) -> Rendered {
+        try resolve(_Selector(kind: "navscreen"), for: "tap")
+    }
+
+    /// `dismiss`: the top sheet or alert.
+    func dismissTarget() throws(_ScriptError) -> Rendered {
+        guard let modal = roots.last(where: { $0.kind == "sheet" || $0.kind == "alert" }), handlers[modal.id] != nil else {
+            throw _ScriptError(message: "dismiss: no sheet or alert is presented")
+        }
+        return modal
+    }
+
+    /// The index `select:…:"Option"` names: a picker option or a tab title.
+    func optionIndex(_ option: String, of element: Rendered) throws(_ScriptError) -> Int {
+        let names: [String?]
+        if element.kind == "tabview" {
+            names = element.children.map { $0.string("title") }
+        } else if case .object(let fields) = element.props, case .array(let options)? = fields["options"] {
+            names = options.map { if case .string(let name) = $0 { name } else { nil } }
+        } else {
+            names = []
+        }
+        guard let index = names.firstIndex(of: option) else {
+            let known = names.compactMap { $0 }.map(_quoted).joined(separator: ", ")
+            throw _ScriptError(message: "\(element.kind) \(element.id) has no option \(_quoted(option)) (options: \(known))")
+        }
+        return index
+    }
+}