swiftui-native 0.0.1

//! ForEach and the container family.

use super::*;
use crate::abi;
use crate::resolve;
use core::ffi::c_void;
use crate::mangle::{self, swift_type};

// ── ForEach and the container family ──

mangle::result_types! {
    /// `ForEach<Range<Int>, Int, AnyView>`
    /// `ForEach<Range<Int>, Int, AnyView>`
    pub(crate) FOREACH_T = ty("ForEach").of(vec![Type::Verbatim("Sn".into()).of(vec![Type::Verbatim("Si".into())]), Type::Verbatim("Si".into()), ty("AnyView")]);
    /// `List<Never, AnyView>`
    /// `List<Never, AnyView>`
    pub(crate) LIST_T = ty("List").of(vec![Type::Verbatim("s5NeverO".into()), ty("AnyView")]);
    /// `List<Never, ForEach<[Int], Int, HStack<AnyView>>>` — what
    /// `List(_:id:rowContent:)` builds. The rows are wrapped in an `HStack` by
    /// the initialiser itself, not by anything here.
    pub(crate) LIST_ID_T = ty("List").of(vec![
        Type::Verbatim("s5NeverO".into()),
        ty("ForEach").of(vec![
            Type::Verbatim("Sa".into()).of(vec![Type::Verbatim("Si".into())]),
            Type::Verbatim("Si".into()),
            ty("HStack").of(vec![ty("AnyView")]),
        ]),
    ]);
    /// The same over `String` identifiers.
    pub(crate) LIST_ID_STR_T = ty("List").of(vec![
        Type::Verbatim("s5NeverO".into()),
        ty("ForEach").of(vec![
            Type::Verbatim("Sa".into()).of(vec![Type::Verbatim("SS".into())]),
            Type::Verbatim("SS".into()),
            ty("HStack").of(vec![ty("AnyView")]),
        ]),
    ]);
    /// `TabView<Int, AnyView>`
    /// `TabView<Int, AnyView>`
    pub(crate) TABVIEW_T = ty("TabView").of(vec![Type::Verbatim("Si".into()), ty("AnyView")]);
    /// `NavigationStack<NavigationPath, AnyView>`
    /// `NavigationStack<NavigationPath, AnyView>`
    pub(crate) NAVSTACK_T = ty("NavigationStack").of(vec![ty("NavigationPath"), ty("AnyView")]);
    /// `GroupBox<EmptyView, AnyView>`
    /// `GroupBox<EmptyView, AnyView>`
    pub(crate) GROUPBOX_T = ty("GroupBox").of(vec![ty("EmptyView"), ty("AnyView")]);
    /// `GridRow<AnyView>`
    /// `GridRow<AnyView>`
    pub(crate) GRIDROW_T = ty("GridRow").of(vec![ty("AnyView")]);
    /// `Form<AnyView>`
    /// `Form<AnyView>`
    pub(crate) FORM_T = ty("Form").of(vec![ty("AnyView")]);
    /// `DisclosureGroup<Text, AnyView>`
    /// `DisclosureGroup<Text, AnyView>`
    pub(crate) DISCLOSURE_T = ty("DisclosureGroup").of(vec![ty("Text"), ty("AnyView")]);
    /// `SwiftUI.Stepper<SwiftUI.Text>`
    /// `Stepper<Text>`
    pub(crate) STEPPER_T = ty("Stepper").of(vec![ty("Text")]);
    /// `Grid<AnyView>` — the content closure hands back an `AnyView`, so that, not
    /// the row type, is `Grid`'s `Content`.
    /// `Grid<AnyView>`
    pub(crate) GRID_T = ty("Grid").of(vec![ty("AnyView")]);
    /// `Menu<Text, AnyView>`
    /// `Menu<Text, AnyView>`
    pub(crate) MENU_T = ty("Menu").of(vec![ty("Text"), ty("AnyView")]);
    /// `Gauge<AnyView, EmptyView, EmptyView, EmptyView>`
    /// `Gauge<AnyView, EmptyView, EmptyView, EmptyView>`
    pub(crate) GAUGE_T = ty("Gauge").of(vec![ty("AnyView"), ty("EmptyView"), ty("EmptyView"), ty("EmptyView")]);
}






/// The Rust side of a `ForEach` content closure.
pub(crate) type IndexBuilder = Box<dyn Fn(i64) -> ViewHandle>;

/// `ForEach`'s `(Int) -> Content` body: build the view for this index and hand
/// SwiftUI a `+1` reference to it.
pub(crate) unsafe extern "C" fn emit_index_view(out: *mut u8, index: i64, payload: *mut c_void) {
    let typed = unsafe { &*(payload as *const TypedIndexBuilder) };
    let view = (typed.builder)(index);
    unsafe {
        if typed.meta.is_null() {
            *(out as *mut u64) = view.into_anyview_word();
            return;
        }
        // SwiftUI sized each row for the type the probe produced; writing a
        // different one would scribble past it. Swift enforces the same rule at
        // compile time by making the closure's result `some View`, i.e. one type.
        assert_eq!(
            view.meta, typed.meta,
            "a ForEach builder returned {} after returning {} — every row has to \
             be one type. Use `view_if!` for a branch, which builds a \
             `_ConditionalContent` and so stays one.",
            crate::diag::type_name(view.meta),
            crate::diag::type_name(typed.meta),
        );
        let vwt = &*swift_runtime_sys::SwiftABI::get_value_witness_table(view.meta);
        if vwt.size > 0 {
            (vwt.initialize_with_copy)(out as *mut c_void, view.value_ptr() as *mut c_void, view.meta);
        }
    }
}

/// An index builder together with the row type it was found to produce.
pub(crate) struct TypedIndexBuilder {
    pub(crate) builder: IndexBuilder,
    pub(crate) meta: *const c_void,
}

/// `ForEach(0..<count) { index in … }`.
///
/// SwiftUI calls the closure whenever it rebuilds the body, not just once at
/// construction, so the builder is leaked deliberately — it has to outlive the
/// `ForEach` value.
/// A range `ForEach` can run over.
///
/// Swift has two: `ForEach(0..<n)`, which is special-cased and identifies rows
/// by position, and `ForEach(a...b, id: \.self)`, which identifies them by
/// value. Rust spells those `0..n` and `a..=b`, and they reach different
/// SwiftUI initialisers and build different types — so which one a caller
/// wrote is worth keeping rather than normalising away.
pub trait ForEachRange {
    /// Run `builder` over this range.
    fn for_each_rows(self, builder: impl Fn(i64) -> ViewHandle + 'static) -> ViewHandle;
}

impl ForEachRange for std::ops::Range<i64> {
    fn for_each_rows(self, builder: impl Fn(i64) -> ViewHandle + 'static) -> ViewHandle {
        for_each_half_open(self, builder)
    }
}

impl ForEachRange for std::ops::RangeInclusive<i64> {
    fn for_each_rows(self, builder: impl Fn(i64) -> ViewHandle + 'static) -> ViewHandle {
        for_each_closed(*self.start(), *self.end(), builder)
    }
}

/// `ForEach` over a range of indices.
///
/// `0..n` is `ForEach(0..<n)` — positional identity, which is what Swift's
/// special-cased overload gives. `a..=b` is `ForEach(a...b, id: \.self)` —
/// identity by value, so a row that moves animates as a move and its state
/// follows it.
pub fn for_each<R: ForEachRange>(
    range: R,
    builder: impl Fn(i64) -> ViewHandle + 'static,
) -> ViewHandle {
    range.for_each_rows(builder)
}

fn for_each_half_open(range: std::ops::Range<i64>, builder: impl Fn(i64) -> ViewHandle + 'static) -> ViewHandle {
    unsafe {
        let boxed: IndexBuilder = Box::new(builder);
        // Ask the builder what a row is. The first index is one it will be asked
        // for anyway — but it is an extra call, and a builder with side effects
        // will notice.
        let probe = boxed(range.start);
        let (known_meta, known_wt, known_size) = result_type(&FOREACH_T);
        // `ForEach<Data, ID, Content>`: three parameters, then their
        // conformances, so the content is at 2 and its `View` witness at 5.
        let typed = super::substitute_content(known_meta, 6, 2, 5, probe.meta, probe.wt);
        let promised = if typed.is_some() { probe.meta } else { core::ptr::null() };
        let (content_meta, content_wt) = match typed {
            Some(_) => (probe.meta, probe.wt),
            None => (resolve::anyview_meta(), resolve::anyview_wt()),
        };
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        drop(probe);

        let payload = Box::into_raw(Box::new(TypedIndexBuilder { builder: boxed, meta: promised }))
            as *mut c_void;
        let ctx = Box::leak(Box::new(abi::IndexClosureCtx::new(emit_index_view, payload)))
            as *mut abi::IndexClosureCtx;

        let mut result = vec![0u8; size];
        // ForEach.init(_: Range<Int>, content: (Int) -> C)
        //   x0/x1 = range bounds, x2 = closure fn, x3 = closure ctx,
        //   x4 = C.Type, x5 = C: View WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::foreach_range_init(),
            in("x0") range.start,
            in("x1") range.end,
            in("x2") abi::index_closure_thunk as *const c_void,
            in("x3") ctx,
            in("x4") content_meta,
            in("x5") content_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `ForEach` over any Rust collection.
///
/// Identity note: this is built on `ForEach(0..<count)`, so SwiftUI identifies
/// rows *positionally*. Inserting in the middle of `items` makes SwiftUI treat
/// every later row as changed rather than moved. That is the same semantics as
/// writing `ForEach(0..<n)` in Swift.
///
/// For rows SwiftUI identifies *by value* — so a move animates as a move and
/// per-row state follows the row — use [`list_identified`] or
/// [`list_identified_str`], which pass a real `\Int.self` / `\String.self` key
/// path. They are list constructors rather than a general
/// `for_each_identified` because the plain `ForEach(_:id:content:)` over `View`
/// content is inlinable and exports no symbol; `List(_:id:rowContent:)` does
/// export one and builds the identified `ForEach` itself.
pub fn for_each_items<T: Clone + 'static>(
    items: &[T],
    builder: impl Fn(&T) -> ViewHandle + 'static,
) -> ViewHandle {
    let owned: Vec<T> = items.to_vec();
    for_each(0..owned.len() as i64, move |i| builder(&owned[i as usize]))
}

/// A container whose only argument is a `() -> Content` closure.
///
///   x0 = closure fn, x1 = closure ctx,
///   x2 = Content.Type, x3 = Content: View WT, x8 = @out
pub(crate) unsafe fn content_container(
    child: &ViewHandle,
    init: *const c_void,
    mangled: &[u8],
) -> ViewHandle {
    unsafe {
        let kid_handles = Child::new(child, Content::Erased);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let (meta, wt, size) = result_type(mangled);
        let mut result = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) init,
            in("x0") abi::swift_closure_thunk as *const c_void,
            in("x1") &mut ctx as *mut abi::ClosureCtx,
            in("x2") resolve::anyview_meta(),
            in("x3") resolve::anyview_wt(),
            in("x8") result.as_mut_ptr(),
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `List { … }` with static content.
pub fn list(child: &ViewHandle) -> ViewHandle {
    // `List<SelectionValue, Content>` — one leading parameter, the selection,
    // which stays whatever `LIST_T` was declared with (`Never`).
    unsafe { content_container_typed(child, resolve::list_init(), &LIST_T,
        ContentShape { args: 3, meta_at: 1, wt_at: 2 }) }
}

/// `TabView { … }`.
pub fn tab_view(child: &ViewHandle) -> ViewHandle {
    unsafe { content_container_typed(child, resolve::tabview_init(), &TABVIEW_T,
        ContentShape { args: 3, meta_at: 1, wt_at: 2 }) }
}

/// `NavigationStack { … }`.
pub fn navigation_stack(child: &ViewHandle) -> ViewHandle {
    unsafe { content_container_typed(child, resolve::navstack_init(), &NAVSTACK_T,
        ContentShape { args: 3, meta_at: 1, wt_at: 2 }) }
}

/// `GroupBox { … }`.
pub fn group_box(child: &ViewHandle) -> ViewHandle {
    unsafe { content_container_typed(child, resolve::groupbox_init(), &GROUPBOX_T,
        ContentShape { args: 3, meta_at: 1, wt_at: 2 }) }
}

/// `GridRow { … }` over N children.
pub fn grid_row(children: &[ViewHandle]) -> ViewHandle {
    unsafe { grid_row_impl(children, None) }
}

/// `GridRow(alignment:) { … }` — how this row's cells sit against each other
/// vertically, overriding the grid's own `alignment` for this row only.
pub fn grid_row_aligned(
    children: &[ViewHandle],
    alignment: super::VerticalAlignment,
) -> ViewHandle {
    unsafe { grid_row_impl(children, Some(alignment)) }
}

unsafe fn grid_row_impl(
    children: &[ViewHandle],
    alignment: Option<super::VerticalAlignment>,
) -> ViewHandle {
    unsafe {
        // The cells are the row's `@ViewBuilder` body, at their own types.
        //
        // This used to wrap them in an `HStack` and box that, which was not a
        // spelling difference: a `GridRow`'s cells are what the *grid* aligns
        // into columns, and an `HStack` between them takes that job away. Two
        // rows whose first cells differed in width had their second columns
        // start at different x — 1.9% of the pixels, against a Swift reference
        // that had been written with the same `HStack` in it and so agreed.
        // `grid_columns` in `examples/parity` is that case.
        let (content_meta, content_wt, offsets) = super::tuple_content(children);
        let kids = super::tuple_children(children, &offsets);
        let payload = TuplePayload { children: kids.as_ptr(), count: kids.len() };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let (known_meta, _, _) = result_type(&GRIDROW_T);
        let meta = abi::generic_metadata_from(known_meta, &[content_meta, content_wt]);
        assert!(!meta.is_null(), "GridRow metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "{} !: View", crate::diag::type_name(meta));
        let size = abi::type_bytes(meta);
        let mut result = vec![0u8; size];
        // GridRow.init(alignment: VerticalAlignment?, content: () -> C)
        //   x0 = alignment payload, x1 = alignment tag (1 = nil),
        //   x2 = closure fn, x3 = closure ctx,
        //   x4 = C.Type, x5 = C: View WT, x8 = @out
        // `Optional<VerticalAlignment>`: the word in x0, the tag in x1.
        // `VerticalAlignment` has no spare bits the optional could use, so the
        // tag is a separate argument rather than folded into the payload.
        let (align, tag) = match alignment {
            Some(a) => (super::static_getter(a.resolved(), resolve::valign_meta()).0, 0u64),
            None => (0u64, 1u64),
        };
        core::arch::asm!("blr {f}", f = in(reg) resolve::gridrow_init(),
            in("x0") align,
            in("x1") tag,
            in("x2") abi::swift_closure_thunk as *const c_void,
            in("x3") &mut ctx as *mut abi::ClosureCtx,
            in("x4") content_meta,
            in("x5") content_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}




/// `Form { … }`.
///
/// `Form.init(content:)` is `@inlinable`, so there is no symbol to call. The
/// struct is exactly the size of its content, though — it stores nothing else —
/// so the value is built directly.
pub fn form(child: &ViewHandle) -> ViewHandle {
    unsafe {
        // `Form<Content>` stores nothing but its content, so there is no
        // initialiser to call — the value *is* the child. Building
        // `Form<Text>` rather than `Form<AnyView>` is then a matter of naming
        // the type and copying the child in through its own value witness,
        // which is what keeps a refcounted field retained; a raw byte copy of
        // an `AnyView` word happened to work only because the word was the
        // reference.
        let (known_meta, known_wt, known_size) = result_type(&FORM_T);
        let meta = abi::generic_metadata_from(known_meta, &[child.meta, child.wt]);
        let wt = if meta.is_null() { core::ptr::null() } else { abi::get_view_wt(meta) };
        if !wt.is_null() {
            let vwt = &*swift_runtime_sys::SwiftABI::get_value_witness_table(child.meta);
            let mut out = vec![0u8; abi::type_bytes(meta)];
            if vwt.size > 0 {
                (vwt.initialize_with_copy)(
                    out.as_mut_ptr() as *mut c_void,
                    child.value_ptr() as *mut c_void,
                    child.meta,
                );
            }
            return wrap_owned(out, meta, wt);
        }
        assert_eq!(known_size, 8, "Form<AnyView> is expected to hold only its content");
        let owned = child.clone();
        let buf = owned.to_anyview_word().to_le_bytes();
        wrap_buf(&buf, known_meta, known_wt)
    }
}

/// `DisclosureGroup(_:content:)`.
pub fn disclosure_group(label: &str, child: &ViewHandle) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(label);
        let s0 = u64::from_le_bytes(ss[..8].try_into().unwrap());
        let s1 = u64::from_le_bytes(ss[8..].try_into().unwrap());
        let (k0, k1, k2, k3) = localized_string_key(s0, s1);

        let (known_meta, known_wt, known_size) = result_type(&DISCLOSURE_T);
        // Two parameters, then their `View` conformances.
        let typed = super::substitute_content(known_meta, 4, 1, 3, child.meta, child.wt);
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let (content_meta, content_wt) = match typed {
            Some(_) => (child.meta, child.wt),
            None => (resolve::anyview_meta(), resolve::anyview_wt()),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };

        let kid_handles = Child::new(child, kind);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        // init(_: LocalizedStringKey, content: () -> C)
        //   x0-x3 = key, x4 = closure fn, x5 = closure ctx,
        //   x6 = C.Type, x7 = C: View WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::disclosure_init(),
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") abi::swift_closure_thunk as *const c_void,
            in("x5") &mut ctx as *mut abi::ClosureCtx,
            in("x6") content_meta,
            in("x7") content_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}



/// Create a `Stepper` over a closed range.
pub fn stepper(label: &str, value: f64, lower: f64, upper: f64, step: f64) -> ViewHandle {
    unsafe {
        let mut binding = constant_binding(
            &value.to_le_bytes(),
            resolve::double_meta(),
            mangle::bound(&swift_type!(SwiftUI.Binding), &[mangle::DOUBLE]).as_bytes(),
        );
        stepper_with_binding(label, &mut binding, lower, upper, step)
    }
}

/// Shared tail of [`stepper`] and `stepper_bound`.
///
/// # Safety
/// `binding` must be a `Binding<Double>`.
pub(crate) unsafe fn stepper_with_binding(
    label: &str,
    binding: &mut [u8],
    lower: f64,
    upper: f64,
    step: f64,
) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(label);
        let s0 = u64::from_le_bytes(ss[..8].try_into().unwrap());
        let s1 = u64::from_le_bytes(ss[8..].try_into().unwrap());
        let (k0, k1, k2, k3) = localized_string_key(s0, s1);

        let double_meta = resolve::double_meta();
        let stride_wt = abi::get_view_wt_for_proto(double_meta, resolve::strideable_proto());
        assert!(!stride_wt.is_null(), "Double: Strideable");

        let mut range = [0u8; 16];
        range[..8].copy_from_slice(&lower.to_le_bytes());
        range[8..].copy_from_slice(&upper.to_le_bytes());
        let mut step_buf = step.to_le_bytes();

        let (meta, wt, size) = result_type(&STEPPER_T);
        let mut result = vec![0u8; size];
        let noop = noop_closure as *const c_void;
        // Stepper.init(_:value:in:step:onEditingChanged:)
        //   x0-x3 = key, x4 = @in Binding<V>, x5 = @in ClosedRange<V>,
        //   x6 = @in V.Stride, x7 = closure fn,
        //   [sp] = closure ctx, [sp+8] = V.Type, [sp+16] = V: Strideable WT,
        //   [sp+24] = V.Stride.Type
        core::arch::asm!(
            "sub sp, sp, #32",
            "stp xzr, {dm}, [sp]",
            "stp {sw}, {dm}, [sp, #16]",
            "blr {f}",
            "add sp, sp, #32",
            f = in(reg) resolve::stepper_init(),
            dm = in(reg) double_meta,
            sw = in(reg) stride_wt,
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") binding.as_mut_ptr(),
            in("x5") range.as_mut_ptr(),
            in("x6") step_buf.as_mut_ptr(),
            in("x7") noop,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}





/// `Grid { … }` over `GridRow` children.
///
/// The rows are the grid's `@ViewBuilder` body at their own types, so this is a
/// `Grid<GridRow<…>>` for one row and a `Grid<TupleView<(GridRow<…>, …)>>` for
/// several — the same types Swift builds from the same source.
pub fn grid(rows: &[ViewHandle]) -> ViewHandle {
    unsafe {
        // Several rows are a `TupleView`, not a `VStack`. Wrapping them in a
        // stack built `Grid<AnyView>` where Swift builds
        // `Grid<TupleView<(GridRow<…>, GridRow<…>)>>` — it rendered the same, and
        // it was a different type, with a `VStack.init` in the trace that the
        // compiler's IR has no call to.
        let (content_meta, content_wt, offsets) = super::tuple_content(rows);
        let handles = super::tuple_children(rows, &offsets);
        let payload = TuplePayload { children: handles.as_ptr(), count: handles.len() };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let (ah, av) = static_getter(resolve::alignment_center(), resolve::alignment_meta());
        let (known_meta, _, _) = result_type(&GRID_T);
        let meta = abi::generic_metadata_from(known_meta, &[content_meta, content_wt]);
        assert!(!meta.is_null(), "Grid metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "Grid !: View");
        let size = abi::type_bytes(meta);
        let mut result = vec![0u8; size];
        // Grid.init(alignment:horizontalSpacing:verticalSpacing:content:)
        //   x0/x1 = Alignment, x2/x3 = hSpacing (payload, tag 1 = nil),
        //   x4/x5 = vSpacing, x6 = closure fn, x7 = closure ctx,
        //   [sp] = Content.Type, [sp+8] = Content: View WT, x8 = @out
        //
        // Eight registers are already spoken for, so the generic arguments spill.
        core::arch::asm!(
            "sub sp, sp, #16",
            "stp {cm}, {cw}, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::grid_init(),
            cm = in(reg) content_meta,
            cw = in(reg) content_wt,
            in("x0") ah, in("x1") av,
            in("x2") 0u64, in("x3") 1u64,
            in("x4") 0u64, in("x5") 1u64,
            in("x6") abi::swift_closure_thunk as *const c_void,
            in("x7") &mut ctx as *mut abi::ClosureCtx,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `Menu(_:content:)`.
pub fn menu(label: &str, child: &ViewHandle) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(label);
        let s0 = u64::from_le_bytes(ss[..8].try_into().unwrap());
        let s1 = u64::from_le_bytes(ss[8..].try_into().unwrap());
        let (k0, k1, k2, k3) = localized_string_key(s0, s1);

        let (known_meta, known_wt, known_size) = result_type(&MENU_T);
        // Two parameters, then their `View` conformances.
        let typed = super::substitute_content(known_meta, 4, 1, 3, child.meta, child.wt);
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let (content_meta, content_wt) = match typed {
            Some(_) => (child.meta, child.wt),
            None => (resolve::anyview_meta(), resolve::anyview_wt()),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };

        let kid_handles = Child::new(child, kind);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        // Menu.init(_: LocalizedStringKey, content: () -> C)
        //   x0-x3 = key, x4 = closure fn, x5 = closure ctx,
        //   x6 = C.Type, x7 = C: View WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::menu_init(),
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") abi::swift_closure_thunk as *const c_void,
            in("x5") &mut ctx as *mut abi::ClosureCtx,
            in("x6") content_meta,
            in("x7") content_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `Gauge(value:in:label:)`.
pub fn gauge(value: f64, lower: f64, upper: f64, label: &ViewHandle) -> ViewHandle {
    unsafe {
        let double_meta = resolve::double_meta();
        let bfp_wt =
            abi::get_view_wt_for_proto(double_meta, resolve::binary_floating_point_proto());
        assert!(!bfp_wt.is_null(), "Double: BinaryFloatingPoint");

        let mut value_buf = value.to_le_bytes();
        let mut range = [0u8; 16];
        range[..8].copy_from_slice(&lower.to_le_bytes());
        range[8..].copy_from_slice(&upper.to_le_bytes());

        // `Gauge<Label, CurrentValueLabel, MinimumValueLabel, MaximumValueLabel>`
        // — four parameters, so `Label`'s witness is at 4. `V` belongs to the
        // initialiser, not the type, which is why it is not among them.
        let (known_meta, known_wt, known_size) = result_type(&GAUGE_T);
        let typed = super::substitute_args(known_meta, 8, &[(0, label.meta)], &[(4, label.wt)]);
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let (label_meta, label_wt) = match typed {
            Some(_) => (label.meta, label.wt),
            None => (resolve::anyview_meta(), resolve::anyview_wt()),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };

        let kid_handles = Child::new(label, kind);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        // Gauge.init(value:in:label:)
        //   x0 = @in V, x1 = @in ClosedRange<V>, x2 = closure fn, x3 = closure ctx,
        //   x4 = Label.Type, x5 = V.Type, x6 = Label: View WT,
        //   x7 = V: BinaryFloatingPoint WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::gauge_init(),
            in("x0") value_buf.as_mut_ptr(),
            in("x1") range.as_mut_ptr(),
            in("x2") abi::swift_closure_thunk as *const c_void,
            in("x3") &mut ctx as *mut abi::ClosureCtx,
            in("x4") label_meta,
            in("x5") double_meta,
            in("x6") label_wt,
            in("x7") bfp_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `Group { … }` — a container that groups without laying out.
///
/// Its initialiser has the same shape as `GroupBox`'s: a content closure and
/// the two generic words, nothing else.
pub fn group(child: &ViewHandle) -> ViewHandle {
    unsafe { content_container_typed(child, resolve::group_init(), &GROUP_T,
        ContentShape { args: 2, meta_at: 0, wt_at: 1 }) }
}

/// `ControlGroup { … }`
pub fn control_group(child: &ViewHandle) -> ViewHandle {
    unsafe { content_container_typed(child, resolve::control_group_init(), &CONTROL_GROUP_T,
        ContentShape { args: 2, meta_at: 0, wt_at: 1 }) }
}

/// `ViewThatFits(in:) { … }` — the first child that fits.
///
/// One argument ahead of the closure: an `Axis.Set`, which is a one-byte option
/// set, so the closure and the generic words all shift one register right.
pub fn view_that_fits(child: &ViewHandle, axes: &[super::AxisSet]) -> ViewHandle {
    unsafe {
        // `ViewThatFits<Content>` — one parameter, so its witness is at 1.
        let (known_meta, known_wt, known_size) = result_type(&VIEW_THAT_FITS_T);
        let typed = super::substitute_args(known_meta, 2, &[(0, child.meta)], &[(1, child.wt)]);
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let (content_meta, content_wt) = match typed {
            Some(_) => (child.meta, child.wt),
            None => (resolve::anyview_meta(), resolve::anyview_wt()),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };

        let kid_handles = Child::new(child, kind);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);
        let g: Vec<&core::ffi::CStr> = axes.iter().map(|a| a.getter()).collect();
        let set = super::option_set_word(resolve::axis_set_ma(), &g);

        let mut result = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) resolve::view_that_fits_init(),
            in("x0") set,
            in("x1") abi::swift_closure_thunk as *const c_void,
            in("x2") &mut ctx as *mut abi::ClosureCtx,
            in("x3") content_meta,
            in("x4") content_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x5") _, lateout("x6") _, lateout("x7") _, lateout("x9") _,
            lateout("x10") _, lateout("x11") _, lateout("x12") _, lateout("x13") _,
            lateout("x14") _, lateout("x15") _, lateout("x16") _, lateout("x17") _,
            lateout("lr") _, lateout("x20") _, lateout("x21") _, clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

// ── Section, NavigationSplitView, Canvas, EditButton ──

mangle::result_types! {
    /// `Section<AnyView, AnyView, EmptyView>`
    /// `Section<AnyView, AnyView, EmptyView>`
    pub(crate) SECTION_T = ty("Section").of(vec![ty("AnyView"), ty("AnyView"), ty("EmptyView")]);
    /// `Section<EmptyView, AnyView, EmptyView>`
    /// `Section<EmptyView, AnyView, EmptyView>`
    pub(crate) SECTION_CONTENT_T = ty("Section").of(vec![ty("EmptyView"), ty("AnyView"), ty("EmptyView")]);
    /// `Section<AnyView, AnyView, AnyView>` — header *and* footer.
    pub(crate) SECTION_HF_T = ty("Section").of(vec![ty("AnyView"), ty("AnyView"), ty("AnyView")]);
    /// `NavigationSplitView<AnyView, AnyView, AnyView>` — all three columns.
    pub(crate) NAV_SPLIT3_T = ty("NavigationSplitView")
        .of(vec![ty("AnyView"), ty("AnyView"), ty("AnyView")]);
    /// `Section<EmptyView, AnyView, AnyView>` — footer, no header.
    pub(crate) SECTION_FOOTER_T = ty("Section").of(vec![ty("EmptyView"), ty("AnyView"), ty("AnyView")]);
    /// `NavigationSplitView<AnyView, EmptyView, AnyView>`
    /// `NavigationSplitView<AnyView, EmptyView, AnyView>`
    pub(crate) NAV_SPLIT_T = ty("NavigationSplitView").of(vec![ty("AnyView"), ty("EmptyView"), ty("AnyView")]);
    /// `Canvas<EmptyView>`
    /// `Canvas<EmptyView>`
    pub(crate) CANVAS_T = ty("Canvas").of(vec![ty("EmptyView")]);
    /// `EditButton` — gated like `edit_button`, whose macOS implementation is
    /// a trap stub rather than a missing symbol.
    #[cfg(not(target_os = "macos"))]
    pub(crate) EDIT_BUTTON_T = ty("EditButton");
}

/// `Section { … }` — no header, no footer.
pub fn section_content(content: &ViewHandle) -> ViewHandle {
    // `Section<Parent, Content, Footer>` — the content is the *middle*
    // parameter, so this is the case the `shape` generalisation exists for.
    // Three parameters and three `View` conformances, so the witness vector
    // starts at 3 and the content's is at 4.
    unsafe {
        content_container_typed(
            content,
            resolve::section_content_init(),
            &SECTION_CONTENT_T,
            ContentShape { args: 6, meta_at: 1, wt_at: 4 },
        )
    }
}

/// A `+1` copy of a view's value, for an `@in` parameter the callee consumes.
///
/// For an erased parameter the copy is the `AnyView` word; for a typed one it is
/// the value itself, at its own stride. Either way the callee *destroys* what it
/// is handed, so this must be a copy and never the handle's own bytes — the
/// handle is still holding them.
unsafe fn in_value(view: &ViewHandle, typed: bool) -> Vec<u8> {
    unsafe {
        if typed {
            let mut buf = vec![0u8; abi::type_bytes(view.meta)];
            abi::copy_value(buf.as_mut_ptr(), view.value_ptr() as *const u8, view.meta);
            buf
        } else {
            view.to_anyview_word().to_le_bytes().to_vec()
        }
    }
}

/// `Section(header:) { … }`.
///
/// The header is a *value* parameter of generic type, so it travels indirectly —
/// x0 holds the address of the `AnyView` word, not the word. It is `@in`, i.e.
/// consumed, so the handle is retained and forgotten rather than dropped here.
///
/// Generic order is `Section<Parent, Content, Footer>`; this overload pins
/// `Footer == EmptyView`, leaving two metadata words and two witness tables.
pub fn section(header: &ViewHandle, content: &ViewHandle) -> ViewHandle {
    unsafe {
        // `Section<Parent, Content, Footer>` — three parameters, so the witnesses
        // are at 3, 4 and 5. This overload pins `Footer`, which is left as the
        // known instantiation's `EmptyView`.
        let (known_meta, known_wt, known_size) = result_type(&SECTION_T);
        let typed = super::substitute_args(
            known_meta,
            6,
            &[(0, header.meta), (1, content.meta)],
            &[(3, header.wt), (4, content.wt)],
        );
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let (parent_meta, parent_wt, content_meta, content_wt) = match typed {
            Some(_) => (header.meta, header.wt, content.meta, content.wt),
            None => (
                resolve::anyview_meta(),
                resolve::anyview_wt(),
                resolve::anyview_meta(),
                resolve::anyview_wt(),
            ),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };
        let mut header_in = in_value(header, typed.is_some());

        let kid_handles = Child::new(content, kind);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        // Section.init(header: Parent, content: () -> Content)
        //   x0 = &header, x1 = closure fn, x2 = closure ctx,
        //   x3 = Parent.Type, x4 = Content.Type,
        //   x5 = Parent: View WT, x6 = Content: View WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::section_init(),
            in("x0") header_in.as_mut_ptr(),
            in("x1") abi::swift_closure_thunk as *const c_void,
            in("x2") &mut ctx as *mut abi::ClosureCtx,
            in("x3") parent_meta,
            in("x4") content_meta,
            in("x5") parent_wt,
            in("x6") content_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `Section(header:footer:) { … }`.
///
/// A footer is where a settings group's explanatory line goes, and there was no
/// way to put one there: only the no-header and header-only initialisers were
/// bound. Both of these are exported.
///
/// Both the header and the footer are `@in` value parameters of generic type,
/// so each travels as the *address* of its `AnyView` word and is consumed —
/// retained and forgotten here rather than dropped.
pub fn section_header_footer(
    header: &ViewHandle,
    footer: &ViewHandle,
    content: &ViewHandle,
) -> ViewHandle {
    unsafe {
        let (known_meta, known_wt, known_size) = result_type(&SECTION_HF_T);
        let typed = super::substitute_args(
            known_meta,
            6,
            &[(0, header.meta), (1, content.meta), (2, footer.meta)],
            &[(3, header.wt), (4, content.wt), (5, footer.wt)],
        );
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let any = resolve::anyview_meta();
        let any_wt = resolve::anyview_wt();
        let [parent_meta, content_meta, footer_meta] = match typed {
            Some(_) => [header.meta, content.meta, footer.meta],
            None => [any; 3],
        };
        let [parent_wt, content_wt, footer_wt] = match typed {
            Some(_) => [header.wt, content.wt, footer.wt],
            None => [any_wt; 3],
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };
        let mut header_in = in_value(header, typed.is_some());
        let mut footer_in = in_value(footer, typed.is_some());

        let kid_handles = Child::new(content, kind);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        // Section.init(header: Parent, footer: Footer, content: () -> Content)
        //   x0 = &header, x1 = &footer, x2 = closure fn, x3 = closure ctx,
        //   x4 = Parent.Type, x5 = Content.Type, x6 = Footer.Type,
        //   x7 = Parent: View WT, [sp] = Content: View WT,
        //   [sp+8] = Footer: View WT, x8 = @out
        //
        // The metadata follows the *generic signature's* order — Parent,
        // Content, Footer — not the argument order, which puts the footer
        // second.
        core::arch::asm!(
            "sub sp, sp, #16",
            "stp {cw}, {fw}, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::section_hf_init(),
            cw = in(reg) content_wt,
            fw = in(reg) footer_wt,
            in("x0") header_in.as_mut_ptr(),
            in("x1") footer_in.as_mut_ptr(),
            in("x2") abi::swift_closure_thunk as *const c_void,
            in("x3") &mut ctx as *mut abi::ClosureCtx,
            in("x4") parent_meta,
            in("x5") content_meta,
            in("x6") footer_meta,
            in("x7") parent_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `Section(footer:) { … }` — a footer with no header.
///
/// `Parent` is pinned to `EmptyView` by the extension, so only `Content` and
/// `Footer` need metadata.
pub fn section_footer(footer: &ViewHandle, content: &ViewHandle) -> ViewHandle {
    unsafe {
        // `Parent` is pinned to `EmptyView` here, so only `Content` (1) and
        // `Footer` (2) move, with their witnesses at 4 and 5.
        let (known_meta, known_wt, known_size) = result_type(&SECTION_FOOTER_T);
        let typed = super::substitute_args(
            known_meta,
            6,
            &[(1, content.meta), (2, footer.meta)],
            &[(4, content.wt), (5, footer.wt)],
        );
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let any = resolve::anyview_meta();
        let any_wt = resolve::anyview_wt();
        let (content_meta, footer_meta, content_wt, footer_wt) = match typed {
            Some(_) => (content.meta, footer.meta, content.wt, footer.wt),
            None => (any, any, any_wt, any_wt),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };
        let mut footer_in = in_value(footer, typed.is_some());

        let kid_handles = Child::new(content, kind);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        // Section.init(footer: Footer, content: () -> Content)
        //   x0 = &footer, x1 = closure fn, x2 = closure ctx,
        //   x3 = Content.Type, x4 = Footer.Type,
        //   x5 = Content: View WT, x6 = Footer: View WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::section_footer_init(),
            in("x0") footer_in.as_mut_ptr(),
            in("x1") abi::swift_closure_thunk as *const c_void,
            in("x2") &mut ctx as *mut abi::ClosureCtx,
            in("x3") content_meta,
            in("x4") footer_meta,
            in("x5") content_wt,
            in("x6") footer_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `Section(isExpanded:) { … } header: { … }` — a section that collapses.
///
/// The disclosure state is a `Binding<Bool>` over Rust state, so the section
/// opens and closes by itself *and* whatever is bound sees it — which is the
/// point of taking a binding rather than an initial value.
///
/// Unlike [`section`](fn@section), the header here is a **closure**, not a
/// value: this
/// initialiser takes `content:` and `header:` as two `() -> some View`, so both
/// travel as a function-and-context pair rather than as an `@in` address.
pub fn section_expanded(
    is_expanded: &crate::views::BoundState<bool>,
    header: &ViewHandle,
    content: &ViewHandle,
) -> ViewHandle {
    unsafe {
        let binding = crate::views::bool_binding(is_expanded);
        let b = binding_words(&mut binding.clone());

        let (known_meta, known_wt, known_size) = result_type(&SECTION_T);
        let typed = super::substitute_args(
            known_meta,
            6,
            &[(0, header.meta), (1, content.meta)],
            &[(3, header.wt), (4, content.wt)],
        );
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let any = resolve::anyview_meta();
        let any_wt = resolve::anyview_wt();
        let (parent_meta, content_meta, parent_wt, content_wt) = match typed {
            Some(_) => (header.meta, content.meta, header.wt, content.wt),
            None => (any, any, any_wt, any_wt),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };

        let head_kids = Child::new(header, kind);
        let head_handles = head_kids.element();
        let head_payload = TuplePayload { children: head_handles.as_ptr(), count: 1 };
        let mut head_ctx =
            abi::ClosureCtx::new(emit_tuple, &head_payload as *const TuplePayload as *mut c_void);

        let body_kids = Child::new(content, kind);
        let body_handles = body_kids.element();
        let body_payload = TuplePayload { children: body_handles.as_ptr(), count: 1 };
        let mut body_ctx =
            abi::ClosureCtx::new(emit_tuple, &body_payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        // Section.init(isExpanded: Binding<Bool>, content: () -> B, header: () -> A)
        //   x0..x2 = the binding, x3/x4 = content closure,
        //   x5/x6 = header closure, x7 = Parent.Type,
        //   [sp] = Content.Type, [sp+8] = Parent: View WT,
        //   [sp+16] = Content: View WT, x8 = @out
        core::arch::asm!(
            "sub sp, sp, #32",
            "stp {cm}, {pw}, [sp]",
            "str {cw}, [sp, #16]",
            "blr {f}",
            "add sp, sp, #32",
            f = in(reg) resolve::section_expanded_init(),
            cm = in(reg) content_meta,
            pw = in(reg) parent_wt,
            cw = in(reg) content_wt,
            in("x0") b[0],
            in("x1") b[1],
            in("x2") b[2],
            in("x3") abi::swift_closure_thunk as *const c_void,
            in("x4") &mut body_ctx as *mut abi::ClosureCtx,
            in("x5") abi::swift_closure_thunk as *const c_void,
            in("x6") &mut head_ctx as *mut abi::ClosureCtx,
            in("x7") parent_meta,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `NavigationSplitView { sidebar } detail: { detail }`.
///
/// Two content closures, so two (fn, ctx) pairs fill x0–x3 and the four generic
/// words land in x4–x7 with nothing spilled. `Content == EmptyView` is pinned by
/// this overload, so only `Sidebar` and `Detail` are passed.
pub fn navigation_split_view(sidebar: &ViewHandle, detail: &ViewHandle) -> ViewHandle {
    unsafe {
        // `NavigationSplitView<Sidebar, Content, Detail>` — `Content` is pinned
        // to `EmptyView` by this overload, so the sidebar is 0 and the detail 2,
        // with their witnesses at 3 and 5.
        let (known_meta, known_wt, known_size) = result_type(&NAV_SPLIT_T);
        let typed = super::substitute_args(
            known_meta,
            6,
            &[(0, sidebar.meta), (2, detail.meta)],
            &[(3, sidebar.wt), (5, detail.wt)],
        );
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let (side_meta, detail_meta, side_wt, detail_wt) = match typed {
            Some(_) => (sidebar.meta, detail.meta, sidebar.wt, detail.wt),
            None => (
                resolve::anyview_meta(),
                resolve::anyview_meta(),
                resolve::anyview_wt(),
                resolve::anyview_wt(),
            ),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };

        let kid_side_handles = Child::new(sidebar, kind);
        let side_handles = kid_side_handles.element();
        let side_payload = TuplePayload { children: side_handles.as_ptr(), count: 1 };
        let mut side_ctx =
            abi::ClosureCtx::new(emit_tuple, &side_payload as *const TuplePayload as *mut c_void);
        let kid_detail_handles = Child::new(detail, kind);
        let detail_handles = kid_detail_handles.element();
        let detail_payload = TuplePayload { children: detail_handles.as_ptr(), count: 1 };
        let mut detail_ctx =
            abi::ClosureCtx::new(emit_tuple, &detail_payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) resolve::nav_split_init(),
            in("x0") abi::swift_closure_thunk as *const c_void,
            in("x1") &mut side_ctx as *mut abi::ClosureCtx,
            in("x2") abi::swift_closure_thunk as *const c_void,
            in("x3") &mut detail_ctx as *mut abi::ClosureCtx,
            in("x4") side_meta,
            in("x5") detail_meta,
            in("x6") side_wt,
            in("x7") detail_wt,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// The renderer Canvas stores: `(inout GraphicsContext, CGSize) -> Void`.
///
/// The empty body ignores every argument, which is safe at any signature — the
/// context is `inout` so nothing is consumed, and `CGSize` arrives in d0/d1.
unsafe extern "C" fn empty_renderer() {}

/// `Canvas { context, size in … }` with an empty renderer.
///
/// `colorMode` is a `ColorRenderingMode`, a *resilient* enum, so it is passed by
/// address rather than in a register — case 0 (`.nonLinear`) is the default the
/// trailing-closure spelling produces.
pub fn canvas() -> ViewHandle {
    unsafe {
        let mode_meta = abi::resolve_type_by_mangled_name(b"7SwiftUI18ColorRenderingModeO");
        assert!(!mode_meta.is_null(), "ColorRenderingMode metadata");
        let mut mode = vec![0u8; abi::type_bytes(mode_meta)];
        abi::inject_enum_tag(&mut mode, mode_meta, 0);

        let (meta, wt, size) = result_type(&CANVAS_T);
        let mut result = vec![0u8; size];
        // Canvas.init(opaque:colorMode:rendersAsynchronously:renderer:)
        //   x0 = opaque, x1 = &colorMode, x2 = rendersAsynchronously,
        //   x3 = renderer fn, x4 = renderer ctx, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::canvas_init(),
            in("x0") 0u64,
            in("x1") mode.as_ptr(),
            in("x2") 0u64,
            in("x3") empty_renderer as *const c_void,
            in("x4") 0u64,
            in("x8") result.as_mut_ptr(),
            lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `EditButton()`.
///
/// `EditButton` is `@available(macOS, unavailable)`. Availability is a *source*
/// restriction and not a linkage one, so `$s7SwiftUI10EditButtonVACycfC` is in
/// the macOS export table and binds cleanly — but here the symbol is not the
/// whole story either. Calling it on macOS reaches `Fatal error: Unavailable
/// code reached` and traps: what Apple shipped at that address is a stub, not an
/// initialiser. So this is gated rather than merely bound, and the trap is the
/// evidence for the gate.
///
/// That is the other half of the `defaultHoverEffect` lesson. An exported symbol
/// proves the name resolves; only calling it proves there is an implementation.
#[cfg(not(target_os = "macos"))]
pub fn edit_button() -> ViewHandle {
    unsafe {
        let (meta, wt, size) = result_type(&EDIT_BUTTON_T);
        let mut result = vec![0u8; size.max(1)];
        core::arch::asm!("blr {f}", f = in(reg) resolve::edit_button_init(),
            in("x8") result.as_mut_ptr(),
            lateout("x0") _, lateout("x1") _, lateout("x2") _, lateout("x3") _,
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

// ── ColorPicker and DatePicker ──

mangle::result_types! {
    /// `ColorPicker<Text>`
    /// `ColorPicker<Text>`
    pub(crate) COLOR_PICKER_T = ty("ColorPicker").of(vec![ty("Text")]);
    /// `DatePicker<Text>`
    /// `DatePicker<Text>`
    pub(crate) DATE_PICKER_T = ty("DatePicker").of(vec![ty("Text")]);
}

/// `ColorPicker(_:selection:supportsOpacity:)`.
///
/// `Color` is one word, so `Binding<Color>` is 24 bytes — three registers, loaded
/// rather than passed by address. That puts the `LocalizedStringKey` in x0–x3,
/// the binding in x4–x6 and `supportsOpacity` in x7, with nothing spilled.
/// Shared tail of `color_picker` and `color_picker_bound`.
///
/// # Safety
/// `b` must be a `Binding<Color>`.
pub(crate) unsafe fn color_picker_with_binding(
    title: &str,
    supports_opacity: bool,
    b: &[u8],
) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(title);
        let s0 = u64::from_le_bytes(ss[..8].try_into().expect("lo"));
        let s1 = u64::from_le_bytes(ss[8..].try_into().expect("hi"));
        let (k0, k1, k2, k3) = super::localized_string_key(s0, s1);
        let w = |i: usize| u64::from_le_bytes(b[i * 8..i * 8 + 8].try_into().expect("word"));

        let (meta, wt, size) = result_type(&COLOR_PICKER_T);
        let mut result = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) resolve::color_picker_init(),
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") w(0), in("x5") w(1), in("x6") w(2),
            in("x7") u64::from(supports_opacity),
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `Date(timeIntervalSinceReferenceDate:)`, in a buffer ready to pass by address.
///
/// Foundation's `Date` is resilient, so its size comes from the metadata rather
/// than being assumed to be the one `Double` it holds.
pub(crate) unsafe fn date_bytes(interval: f64) -> Vec<u8> {
    unsafe {
        let meta = abi::metadata0(resolve::date_ma());
        let mut buf = vec![0u8; abi::type_bytes(meta)];
        core::arch::asm!("blr {f}", f = in(reg) resolve::date_tisrd_init(),
            in("d0") interval,
            in("x8") buf.as_mut_ptr(),
            lateout("x0") _, lateout("x1") _, lateout("x2") _, lateout("x3") _,
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        buf
    }
}

/// `DatePicker(_:selection:displayedComponents:)` showing the date components.
///
/// Both the binding and the components travel by address: `Date` is resilient,
/// so `Binding<Date>` is address-only, and `DatePickerComponents` returns its
/// statics through x8 rather than in a register — unlike `Axis.Set` and the
/// other nested `.Set` types this crate binds.
///
/// Swift spells the argument `[.date]`, which goes through
/// `SetAlgebra.init(arrayLiteral:)`. For a single member that is a union of one,
/// so the member's own bytes are passed directly; the parity case's value
/// comparison is what confirms the two agree.
/// Shared tail of `date_picker` and `date_picker_bound`.
///
/// # Safety
/// `binding` must be a `Binding<Date>`.
pub(crate) unsafe fn date_picker_with_binding_components(
    title: &str,
    binding: &[u8],
    components: &[DatePickerComponent],
) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(title);
        let s0 = u64::from_le_bytes(ss[..8].try_into().expect("lo"));
        let s1 = u64::from_le_bytes(ss[8..].try_into().expect("hi"));
        let (k0, k1, k2, k3) = super::localized_string_key(s0, s1);
        let components = date_picker_components(components);

        let (meta, wt, size) = result_type(&DATE_PICKER_T);
        let mut result = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) resolve::date_picker_init(),
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") binding.as_ptr(),
            in("x5") components.as_ptr(),
            in("x8") result.as_mut_ptr(),
            lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `DatePicker(_:selection:in:displayedComponents:)` — a date picker with
/// bounds.
///
/// "Pick a date after today" is a constraint a date picker exists to express,
/// and only the unbounded initialiser was bound — so every picker offered every
/// date and the check had to happen afterwards.
///
/// `lower` and `upper` are seconds from Apple's reference date, the same scale
/// [`date_picker_bound`] takes, so a range is two of whatever that function is
/// already being given.
pub fn date_picker_range(
    title: &str,
    state: &super::BoundState<f64>,
    lower: f64,
    upper: f64,
) -> ViewHandle {
    date_picker_range_components(title, state, lower, upper, &[DatePickerComponent::Date])
}

/// As [`date_picker_range`], showing the named components.
///
/// `&[DatePickerComponent::Date, DatePickerComponent::HourAndMinute]` is
/// Swift's `[.date, .hourAndMinute]` — a date *and* time picker, which is what
/// most uses of this control actually want.
pub fn date_picker_range_components(
    title: &str,
    state: &super::BoundState<f64>,
    lower: f64,
    upper: f64,
    components: &[DatePickerComponent],
) -> ViewHandle {
    unsafe {
        // `Date` is one `Double`, so the same eight bytes a slider would write.
        let binding = super::scalar_binding::<f64, 8>(
            state,
            abi::metadata0(resolve::date_ma()),
            mangle::bound(&swift_type!(SwiftUI.Binding), &[mangle::DATE]).as_bytes(),
            |v| v.to_le_bytes(),
            f64::from_le_bytes,
        );
        let ss = abi::swift_string(title);
        let s0 = u64::from_le_bytes(ss[..8].try_into().expect("title lo"));
        let s1 = u64::from_le_bytes(ss[8..].try_into().expect("title hi"));
        let (k0, k1, k2, k3) = super::localized_string_key(s0, s1);
        let components = date_picker_components(components);

        // `ClosedRange<Date>` travels by *address*, not in registers. `Date`
        // is resilient — which is why the binding beside it goes by address
        // too — so a range of them is address-only however small it measures.
        let lo = date_bytes(lower);
        let hi = date_bytes(upper);
        let n = lo.len();
        let mut range = vec![0u8; n * 2];
        range[..n].copy_from_slice(&lo);
        range[n..].copy_from_slice(&hi);

        let (meta, wt, size) = result_type(&DATE_PICKER_T);
        let mut result = vec![0u8; size];
        // DatePicker.init(_:selection:in:displayedComponents:)
        //   x0-x3 = key, x4 = @in Binding<Date>, x5/x6 = the range,
        //   x7 = @in DatePickerComponents, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::date_picker_range_init(),
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") binding.as_ptr(),
            in("x5") range.as_ptr(),
            in("x6") components.as_ptr(),
            lateout("x7") _,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

mangle::result_types! {
    /// `Picker<Text, Int, AnyView>`
    /// `Picker<Text, Int, AnyView>`
    pub(crate) PICKER_T = ty("Picker").of(vec![ty("Text"), Type::Verbatim("Si".into()), ty("AnyView")]);
}

/// `Picker(_:selection:) { … }` over an `Int` selection.
///
/// Four generic words for two parameters — `Picker<Label, SelectionValue, Content>`
/// needs `SelectionValue: Hashable` as well as `Content: View`, and the
/// declaration order is *selection before content*, which is not the order the
/// type name reads in. Only x7 is left by the time they start, so three spill.
///
/// The spilled words are stored *from registers*. Building them in a local array
/// and copying would read through `sp`, and `sub sp, sp, #32` has already moved
/// it out from under anything the compiler materialised sp-relative.
///
/// `Binding<SelectionValue>` travels by address here even though `Binding<Int>`
/// is three loadable words: the initialiser is generic over `SelectionValue`, so
/// from the callee's side the binding is address-only.
/// Shared tail of `picker` and `picker_bound`.
///
/// # Safety
/// `binding` must be a binding of the type this control edits.
pub(crate) unsafe fn picker_with_binding(title: &str, content: &ViewHandle, binding: &[u8]) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(title);
        let s0 = u64::from_le_bytes(ss[..8].try_into().expect("lo"));
        let s1 = u64::from_le_bytes(ss[8..].try_into().expect("hi"));
        let (k0, k1, k2, k3) = super::localized_string_key(s0, s1);


        // `Picker<Label, SelectionValue, Content>` — three parameters, so
        // `Content`'s witness is at 5. `SelectionValue`'s conformance is
        // `Hashable` rather than `View`, and is left as the known one.
        let (known_meta, known_wt, known_size) = result_type(&PICKER_T);
        let typed = super::substitute_args(known_meta, 6, &[(2, content.meta)], &[(5, content.wt)]);
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let (content_meta, content_wt) = match typed {
            Some(_) => (content.meta, content.wt),
            None => (resolve::anyview_meta(), resolve::anyview_wt()),
        };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };

        let kid_handles = Child::new(content, kind);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        // Picker.init(_:selection:content:)
        //   x0-x3 = key, x4 = &Binding<SelectionValue>,
        //   x5 = content fn, x6 = content ctx, x7 = SelectionValue.Type,
        //   [sp] = Content.Type, [sp+8] = SelectionValue: Hashable WT,
        //   [sp+16] = Content: View WT, x8 = @out
        core::arch::asm!(
            "sub sp, sp, #32",
            "stp {cm}, {hw}, [sp]",
            "str {vw}, [sp, #16]",
            "blr {f}",
            "add sp, sp, #32",
            f = in(reg) resolve::picker_init(),
            cm = in(reg) content_meta,
            hw = in(reg) resolve::int_hashable_wt(),
            vw = in(reg) content_wt,
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") binding.as_ptr(),
            in("x5") abi::swift_closure_thunk as *const c_void,
            in("x6") &mut ctx as *mut abi::ClosureCtx,
            in("x7") resolve::int_meta(),
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

// ── Table and TableColumn ──

// These three names are the compiler's own, copied from `-emit-ir`, rather than
// rebuilt by `result_types!`. `TableColumn<…, Text, Text>` repeats a type inside
// one argument list, and the crate's substitution numbering resolved the second
// `Text` to `TableColumn` — the runtime then refused the name. A name Swift
// emitted is by construction the one the runtime accepts.

/// `SwiftUI.TableColumn<SwiftUI.InterfaceOrientation, Swift.Never, SwiftUI.Text, SwiftUI.Text>`
pub(crate) const TABLE_COLUMN_T: &[u8] =
    b"7SwiftUI11TableColumnVyAA20InterfaceOrientationVs5NeverOAA4TextVAIG";
/// `[SwiftUI.InterfaceOrientation]`
pub(crate) const IO_ARRAY_T: &[u8] = b"Say7SwiftUI20InterfaceOrientationVG";
/// `SwiftUI.Table<SwiftUI.InterfaceOrientation, SwiftUI.TableForEachContent<[SwiftUI.InterfaceOrientation]>, SwiftUI.TableColumn<SwiftUI.InterfaceOrientation, Swift.Never, SwiftUI.Text, SwiftUI.Text>>`
pub(crate) const TABLE_T: &[u8] =
    b"7SwiftUI5TableVyAA20InterfaceOrientationVAA0C14ForEachContentVySayAEGGAA0C6ColumnVyAEs5NeverOAA4TextVAOGG";

/// A protocol witness table, looked up at run time rather than linked.
///
/// SwiftUI exports conformance *descriptors* but no `…WP` symbols for these —
/// the compiler emits a lazy accessor per client instead. Since the conformance
/// is registered in the process's conformance table, asking the runtime for it
/// gives the same table the accessor would have cached.
pub(crate) unsafe fn conformance_wt(meta: *const c_void, proto: *const c_void) -> *const c_void {
    unsafe {
        assert!(!meta.is_null() && !proto.is_null(), "conformance lookup needs both operands");
        type Conforms = unsafe extern "C" fn(*const c_void, *const c_void) -> *const c_void;
        let f: Conforms = core::mem::transmute(resolve::conforms_to_protocol());
        let wt = f(meta, proto);
        assert!(!wt.is_null(), "no registered conformance");
        wt
    }
}

/// What a table column's cell closure needs to build one `Text`.
struct ColumnCell {
    text: String,
}

/// `TableColumn`'s `(RowValue) -> Text` body.
///
/// The row arrives by address in x0 because `RowValue` is generic, and the
/// `Text` goes back through x8 — which is what [`abi::index_closure_thunk`]
/// already shuffles into place. The row is ignored here; each call builds a
/// fresh `+1` `Text`, so ownership transfers correctly however often SwiftUI
/// re-renders.
unsafe extern "C" fn emit_cell_text(out: *mut u8, _row: i64, payload: *mut c_void) {
    unsafe {
        let cell = &*(payload as *const ColumnCell);
        let words = super::text_verbatim_words(&cell.text);
        core::ptr::copy_nonoverlapping(words.as_ptr() as *const u8, out, 32);
    }
}

/// What the `columns:` closure needs to rebuild its column.
struct ColumnsPayload {
    title: String,
    cell: *mut c_void,
}

/// `Table`'s `columns:` body — one `TableColumn`, rebuilt per call.
unsafe extern "C" fn emit_columns(out: *mut u8, payload: *mut c_void) {
    unsafe {
        let p = &*(payload as *const ColumnsPayload);
        let io_meta = abi::metadata0(resolve::interface_orientation_ma());
        let ss = abi::swift_string(&p.title);
        let s0 = u64::from_le_bytes(ss[..8].try_into().expect("lo"));
        let s1 = u64::from_le_bytes(ss[8..].try_into().expect("hi"));
        let (k0, k1, k2, k3) = super::localized_string_key(s0, s1);
        // TableColumn.init(_:content:)
        //   x0-x3 = key, x4 = content fn, x5 = content ctx,
        //   x6 = RowValue.Type, x7 = Content.Type,
        //   [sp] = RowValue: Identifiable WT, [sp+8] = Content: View WT, x8 = @out
        core::arch::asm!(
            "sub sp, sp, #16",
            "stp {iw}, {vw}, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::table_column_init(),
            iw = in(reg) conformance_wt(io_meta, resolve::identifiable_proto()),
            vw = in(reg) resolve::text_wt(),
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") abi::index_closure_thunk as *const c_void,
            in("x5") p.cell,
            in("x6") io_meta,
            in("x7") resolve::text_meta(),
            in("x8") out,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
    }
}

/// `Table(rows) { TableColumn(title) { row in Text(cell) } }`.
///
/// Rows are `InterfaceOrientation` values because `Table` needs
/// `Value: Identifiable`, and a Rust type cannot be made to conform without
/// synthesising a nominal Swift type — a different problem from binding an ABI.
/// `InterfaceOrientation` is one of the few SwiftUI types that already conforms
/// and can be built from its statics, so the whole call is reachable, and the
/// same expression compiles in Swift for the reference.
///
/// `Value: Identifiable` is not among the witness tables passed: the runtime
/// derives it from `Columns.TableRowValue`, whose associated conformance the
/// `TableColumnContent` table already carries. So five generic words, not six,
/// and nothing spills.
pub fn table(rows: &[Orientation], title: &str, cell: &str) -> ViewHandle {
    unsafe {
        let io_meta = abi::metadata0(resolve::interface_orientation_ma());
        let stride = abi::type_stride(io_meta);
        let mut bytes = vec![0u8; stride * rows.len()];
        for (i, o) in rows.iter().enumerate() {
            let v = super::resilient_static(io_meta, o.getter());
            bytes[i * stride..i * stride + v.len()].copy_from_slice(&v);
        }
        let array = abi::swift_array(io_meta, rows.len(), &bytes);

        let cell_payload = Box::into_raw(Box::new(ColumnCell { text: cell.to_string() })) as *mut c_void;
        let cell_ctx = Box::leak(Box::new(abi::IndexClosureCtx::new(emit_cell_text, cell_payload)))
            as *mut abi::IndexClosureCtx as *mut c_void;
        let cols_payload = Box::into_raw(Box::new(ColumnsPayload {
            title: title.to_string(),
            cell: cell_ctx,
        })) as *mut c_void;
        let mut cols_ctx = abi::ClosureCtx::new(emit_columns, cols_payload);

        let column_meta = abi::resolve_type_by_mangled_name(TABLE_COLUMN_T);
        assert!(!column_meta.is_null(), "TableColumn metadata");
        let array_meta = abi::resolve_type_by_mangled_name(IO_ARRAY_T);
        assert!(!array_meta.is_null(), "Array<InterfaceOrientation> metadata");

        let (meta, wt, size) = result_type(TABLE_T);
        let mut result = vec![0u8; size];
        // Table.init(_:columns:)
        //   x0 = &data, x1 = columns fn, x2 = columns ctx,
        //   x3 = Value.Type, x4 = Columns.Type, x5 = Data.Type,
        //   x6 = Columns: TableColumnContent WT,
        //   x7 = Data: RandomAccessCollection WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::table_init(),
            in("x0") &array as *const u64,
            in("x1") abi::swift_closure_thunk as *const c_void,
            in("x2") &mut cols_ctx as *mut abi::ClosureCtx,
            in("x3") io_meta,
            in("x4") column_meta,
            in("x5") array_meta,
            in("x6") conformance_wt(column_meta, resolve::table_column_content_proto()),
            in("x7") conformance_wt(array_meta, resolve::random_access_proto()),
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

swift_statics! {
    /// A member of `SwiftUI.InterfaceOrientation` — [`table`]'s row type.
    ///
    /// Not a natural thing to tabulate, but `Table` needs `Value: Identifiable`,
    /// and this is one of the few SwiftUI types that both conforms and can be
    /// built from its own statics. See [`table`].
    pub enum Orientation {
        Portrait = c"$s7SwiftUI20InterfaceOrientationV8portraitACvgZ",
        PortraitUpsideDown = c"$s7SwiftUI20InterfaceOrientationV18portraitUpsideDownACvgZ",
        LandscapeLeft = c"$s7SwiftUI20InterfaceOrientationV13landscapeLeftACvgZ",
        LandscapeRight = c"$s7SwiftUI20InterfaceOrientationV14landscapeRightACvgZ",
    }
}

// ── OutlineGroup ──

/// `SwiftUI.OutlineGroup<[Swift.Int], Swift.Int, SwiftUI.AnyView, SwiftUI.AnyView, SwiftUI.DisclosureGroup<SwiftUI.AnyView, SwiftUI.OutlineSubgroupChildren>>`
pub(crate) const OUTLINE_GROUP_T: &[u8] =
    b"7SwiftUI12OutlineGroupVySaySiGSiAA7AnyViewVAfA010DisclosureD0VyAfA0C16SubgroupChildrenVGG";

/// The two key path patterns `OutlineGroup` needs, one slot each.
///
/// `static mut` rather than boxed for the reason [`crate::keypath`] documents:
/// every reference inside a pattern is a 32-bit offset, and the thunks it points
/// at are in this image's text segment.
static mut OUTLINE_ID_SLOT: crate::keypath::IdentitySlot = crate::keypath::IdentitySlot::new();
static mut OUTLINE_CHILDREN_SLOT: crate::keypath::ComputedSlot = crate::keypath::ComputedSlot::new();

/// `OutlineGroup`'s `(Element) -> Leaf` body.
///
/// The element arrives by address because it is generic; this leaf ignores it,
/// so what the pointer addresses never matters. Each call hands back a `+1`
/// `AnyView`.
unsafe extern "C" fn emit_leaf_view(out: *mut u8, _element: i64, payload: *mut c_void) {
    unsafe {
        let leaf = &*(payload as *const ViewHandle);
        let copy = leaf.clone();
        *(out as *mut u64) = copy.into_anyview_word();
    }
}

/// `OutlineGroup(root, id:children:content:)` over `Int` nodes with no children.
///
/// The row type is `Int` because the two key paths are *synthesised*: no Swift
/// type has to exist for a get-only computed key path, only a getter, so the
/// root can be any type whose metadata is nameable. `Int` is the plainest.
///
/// Only four generic words, and only one of them metadata — `Leaf`. `Data`, `ID`
/// and `Element` are not passed at all; the runtime takes them from the
/// `KeyPath<Root, Value>` class metadata of the two key paths, which is why
/// their mangled names have to be right rather than merely plausible.
pub fn outline_group(root: i64, leaf: &ViewHandle) -> ViewHandle {
    unsafe {
        // Built once, not per call: rebuilding one per render handed SwiftUI a
        // fresh object every time and never got it back — 45 KB a frame.
        //
        // `OutlineGroup.init` *consumes* its key paths; the compiled reference
        // never releases what `swift_getKeyPath` returned. So the cached object
        // is retained at each use, which is what the per-call build was
        // accidentally paying for. Reusing it without the retain over-releases
        // and traps on the third render.
        static ID_KP: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
        static CHILDREN_KP: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
        // `\Int.self`, not a computed key path that happens to return the root.
        // Both are correct, but only the identity one reflects the same as the
        // reference's — a computed component is described by whatever symbol
        // `dladdr` finds at its getter, and a getter written in Rust has no
        // Swift property name to find.
        let id_kp = *ID_KP.get_or_init(|| {
            crate::keypath::build_identity(crate::static_mut(&raw mut OUTLINE_ID_SLOT), b"Si", b"Si")
        });
        let children_kp = *CHILDREN_KP.get_or_init(|| {
            crate::keypath::build_computed(
                crate::static_mut(&raw mut OUTLINE_CHILDREN_SLOT),
                b"Si",
                b"SaySiGSg",
                crate::keypath::kp_nil_children_get as *const c_void,
            )
        });
        swift_runtime_sys::RuntimeRaw::swift_retain(id_kp as *mut c_void);
        swift_runtime_sys::RuntimeRaw::swift_retain(children_kp as *mut c_void);

        let leaf_payload = Box::into_raw(Box::new(leaf.clone())) as *mut c_void;
        let ctx = Box::leak(Box::new(abi::IndexClosureCtx::new(emit_leaf_view, leaf_payload)))
            as *mut abi::IndexClosureCtx;

        // Cached, like every other case's `result_type` call. Resolving a type
        // from a mangled *string* is a demangle plus a metadata-cache probe, and
        // asking for the conformance is a second scan — per render that is the
        // difference between bounded and growing.
        static ARRAY_SK_WT: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
        let array_sk_wt = *ARRAY_SK_WT.get_or_init(|| {
            let array_meta = abi::resolve_type_by_mangled_name(b"SaySiG");
            assert!(!array_meta.is_null(), "Array<Int> metadata");
            conformance_wt(array_meta, resolve::random_access_proto()) as usize
        }) as *const c_void;

        let (meta, wt, size) = result_type(OUTLINE_GROUP_T);
        let mut result = vec![0u8; size];
        let root_value = root;
        // OutlineGroup.init(_:id:children:content:)
        //   x0 = &root, x1 = id KeyPath, x2 = children KeyPath,
        //   x3 = content fn, x4 = content ctx, x5 = Leaf.Type,
        //   x6 = Data: RandomAccessCollection WT, x7 = ID: Hashable WT,
        //   [sp] = Leaf: View WT, x8 = @out
        core::arch::asm!(
            "sub sp, sp, #16",
            "str {lw}, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::outline_group_init(),
            lw = in(reg) resolve::anyview_wt(),
            in("x0") &root_value as *const i64,
            in("x1") id_kp,
            in("x2") children_kp,
            in("x3") abi::index_closure_thunk as *const c_void,
            in("x4") ctx,
            in("x5") resolve::anyview_meta(),
            in("x6") array_sk_wt,
            in("x7") resolve::int_hashable_wt(),
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

// ── The nine modifiers the coverage parser used to hide ──

/// A `View` modifier taking a style value built by a zero-argument initialiser.
///
/// Exactly the shape `progressViewStyle` has: the style goes in x0 by address,
/// then `Self.Type`, `S.Type`, `Self: View` and `S: SomeStyle` fill x1–x4, with
/// the receiver in x20 and the opaque result through x8.
pub(crate) unsafe fn zero_arg_style_modifier(
    view: &ViewHandle,
    style_ma: *const c_void,
    style_init: *const c_void,
    style_wt: *const c_void,
    func: *const c_void,
    oret: *const c_void,
) -> ViewHandle {
    unsafe {
        let style_meta = abi::metadata0(style_ma);
        assert!(!style_meta.is_null(), "style metadata");
        let mut style = vec![0u8; abi::type_bytes(style_meta)];
        core::arch::asm!("blr {f}", f = in(reg) style_init,
            in("x8") style.as_mut_ptr(),
            in("x20") style_meta,
            lateout("x0") _, lateout("x1") _, lateout("x2") _, lateout("x3") _,
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );

        let subst = [view.meta, style_meta, view.wt, style_wt];
        let (meta, wt, size) = super::opaque_result_type(oret, &subst);
        let mut result = vec![0u8; size];
        let this = view.value_ptr();
        core::arch::asm!("blr {f}", f = in(reg) func,
            in("x0") style.as_mut_ptr(),
            in("x1") subst[0], in("x2") subst[1], in("x3") subst[2], in("x4") subst[3],
            in("x8") result.as_mut_ptr(),
            in("x20") this,
            lateout("x5") _, lateout("x6") _, lateout("x7") _, lateout("x9") _,
            lateout("x10") _, lateout("x11") _, lateout("x12") _, lateout("x13") _,
            lateout("x14") _, lateout("x15") _, lateout("x16") _, lateout("x17") _,
            lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `.navigationSplitViewStyle(.automatic)`
/// `NavigationSplitView { sidebar } content: { content } detail: { detail }`.
///
/// The three-column shape — a sidebar, a list, and the selected item — which is
/// what a Mail or Notes window is. Only the two-column initialiser was bound,
/// pinning the middle column to `EmptyView`, so the middle one could not be
/// filled at all.
///
/// All three are `() -> some View` closures, so each is a function-and-context
/// pair; the metadata and witnesses follow in generic order behind them.
pub fn navigation_split_view3(
    sidebar: &ViewHandle,
    content: &ViewHandle,
    detail: &ViewHandle,
) -> ViewHandle {
    unsafe {
        // All three columns move here, so every parameter and every witness is
        // substituted.
        let (known_meta, known_wt, known_size) = result_type(&NAV_SPLIT3_T);
        let typed = super::substitute_args(
            known_meta,
            6,
            &[(0, sidebar.meta), (1, content.meta), (2, detail.meta)],
            &[(3, sidebar.wt), (4, content.wt), (5, detail.wt)],
        );
        let (meta, wt) = typed.unwrap_or((known_meta, known_wt));
        let size = if typed.is_some() { abi::type_bytes(meta) } else { known_size };
        let kind = if typed.is_some() { Content::Concrete } else { Content::Erased };

        // One leaked child list and closure context per column.
        let side_kids = Child::new(sidebar, kind);
        let side_handles = side_kids.element();
        let side_payload = TuplePayload { children: side_handles.as_ptr(), count: 1 };
        let mut side_ctx =
            abi::ClosureCtx::new(emit_tuple, &side_payload as *const TuplePayload as *mut c_void);

        let mid_kids = Child::new(content, kind);
        let mid_handles = mid_kids.element();
        let mid_payload = TuplePayload { children: mid_handles.as_ptr(), count: 1 };
        let mut mid_ctx =
            abi::ClosureCtx::new(emit_tuple, &mid_payload as *const TuplePayload as *mut c_void);

        let detail_kids = Child::new(detail, kind);
        let detail_handles = detail_kids.element();
        let detail_payload = TuplePayload { children: detail_handles.as_ptr(), count: 1 };
        let mut detail_ctx =
            abi::ClosureCtx::new(emit_tuple, &detail_payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; size];
        let any = resolve::anyview_meta();
        let any_wt = resolve::anyview_wt();
        let [side_meta, mid_meta, detail_meta] = match typed {
            Some(_) => [sidebar.meta, content.meta, detail.meta],
            None => [any; 3],
        };
        let [side_wt, mid_wt, detail_wt] = match typed {
            Some(_) => [sidebar.wt, content.wt, detail.wt],
            None => [any_wt; 3],
        };
        // NavigationSplitView.init(sidebar:content:detail:)
        //   x0/x1, x2/x3, x4/x5 = the three closures in that order,
        //   x6 = Sidebar.Type, x7 = Content.Type,
        //   [sp] = Detail.Type, [sp+8..] = the three View witnesses,
        //   x8 = @out
        core::arch::asm!(
            "sub sp, sp, #32",
            "stp {dm}, {sw}, [sp]",
            "stp {cw}, {dw}, [sp, #16]",
            "blr {f}",
            "add sp, sp, #32",
            f = in(reg) resolve::nav_split3_init(),
            dm = in(reg) detail_meta,
            sw = in(reg) side_wt,
            cw = in(reg) mid_wt,
            dw = in(reg) detail_wt,
            in("x0") abi::swift_closure_thunk as *const c_void,
            in("x1") &mut side_ctx as *mut abi::ClosureCtx,
            in("x2") abi::swift_closure_thunk as *const c_void,
            in("x3") &mut mid_ctx as *mut abi::ClosureCtx,
            in("x4") abi::swift_closure_thunk as *const c_void,
            in("x5") &mut detail_ctx as *mut abi::ClosureCtx,
            in("x6") side_meta,
            in("x7") mid_meta,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

pub fn navigation_split_view_style_automatic(view: &ViewHandle) -> ViewHandle {
    navigation_split_view_style(view, SplitViewStyle::Automatic)
}

/// Which `NavigationSplitViewStyle` to apply.
///
/// Each is a distinct Swift type with its own conformance, which is why the
/// modifier is generic in Swift and takes a value here.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SplitViewStyle {
    /// `.automatic`.
    Automatic,
    /// `.balanced` — the detail column shares space with the others.
    Balanced,
    /// `.prominentDetail` — the detail column keeps its size.
    ProminentDetail,
}

impl SplitViewStyle {
    fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::Automatic => (
                resolve::auto_nav_split_style_ma(),
                resolve::auto_nav_split_style_init(),
                resolve::auto_nav_split_style_wt(),
            ),
            Self::Balanced => (
                resolve::balanced_nav_split_style_ma(),
                resolve::balanced_nav_split_style_init(),
                resolve::balanced_nav_split_style_wt(),
            ),
            Self::ProminentDetail => (
                resolve::prominent_nav_split_style_ma(),
                resolve::prominent_nav_split_style_init(),
                resolve::prominent_nav_split_style_wt(),
            ),
        }
    }
}

/// Apply `.navigationSplitViewStyle(_:)`.
pub fn navigation_split_view_style(view: &ViewHandle, style: SplitViewStyle) -> ViewHandle {
    unsafe {
        let (ma, init, wt) = style.parts();
        zero_arg_style_modifier(view, ma, init, wt,
            resolve::nav_split_style_fn(), resolve::nav_split_style_oret())
    }
}

/// `.navigationViewStyle(.automatic)`
pub fn navigation_view_style_automatic(view: &ViewHandle) -> ViewHandle {
    unsafe {
        zero_arg_style_modifier(view, resolve::default_nav_view_style_ma(),
            resolve::default_nav_view_style_init(), resolve::default_nav_view_style_wt(),
            resolve::nav_view_style_fn(), resolve::nav_view_style_oret())
    }
}

/// `.navigationViewStyle(.columns)` — the two-column split.
///
/// The witness is looked up at run time rather than named: a
/// `NavigationViewStyle` conformance mangles its substitutions against the
/// words in its *own* type name, so `ColumnNavigationViewStyle`'s is not
/// `DefaultNavigationViewStyle`'s with a letter changed. Copying one has
/// produced a witness for the wrong protocol in this crate before.
pub fn navigation_view_style_columns(view: &ViewHandle) -> ViewHandle {
    unsafe {
        let meta = abi::metadata0(resolve::column_nav_view_style_ma());
        let wt = abi::get_view_wt_for_proto(meta, resolve::nav_view_style_proto());
        assert!(!wt.is_null(), "ColumnNavigationViewStyle: NavigationViewStyle");
        zero_arg_style_modifier(view, resolve::column_nav_view_style_ma(),
            resolve::column_nav_view_style_init(), wt,
            resolve::nav_view_style_fn(), resolve::nav_view_style_oret())
    }
}

/// `.navigationViewStyle(.doubleColumn)` — sidebar plus detail.
pub fn navigation_view_style_double_column(view: &ViewHandle) -> ViewHandle {
    unsafe {
        let meta = abi::metadata0(resolve::double_column_nav_view_style_ma());
        let wt = abi::get_view_wt_for_proto(meta, resolve::nav_view_style_proto());
        assert!(!wt.is_null(), "DoubleColumnNavigationViewStyle: NavigationViewStyle");
        zero_arg_style_modifier(view, resolve::double_column_nav_view_style_ma(),
            resolve::double_column_nav_view_style_init(), wt,
            resolve::nav_view_style_fn(), resolve::nav_view_style_oret())
    }
}

/// `.navigationViewStyle(.stack)` — one view at a time, pushed and popped.
///
/// `@available(macOS, unavailable)`, so iOS only.
#[cfg(not(target_os = "macos"))]
pub fn navigation_view_style_stack(view: &ViewHandle) -> ViewHandle {
    unsafe {
        let meta = abi::metadata0(resolve::stack_nav_view_style_ma());
        let wt = abi::get_view_wt_for_proto(meta, resolve::nav_view_style_proto());
        assert!(!wt.is_null(), "StackNavigationViewStyle: NavigationViewStyle");
        zero_arg_style_modifier(view, resolve::stack_nav_view_style_ma(),
            resolve::stack_nav_view_style_init(), wt,
            resolve::nav_view_style_fn(), resolve::nav_view_style_oret())
    }
}

/// `.tabViewStyle(.automatic)`
pub fn tab_view_style_automatic(view: &ViewHandle) -> ViewHandle {
    tab_view_style(view, TabStyle::Automatic)
}

/// Which `TabViewStyle` to apply.
///
/// Each is a distinct Swift type with its own conformance, which is why the
/// modifier is generic in Swift and takes a value here.
///
/// The cases are the ones a platform can actually use, so a style that does
/// not exist here is a compile error rather than a trap at run time:
/// `.grouped` is macOS-only and absent on iOS. `.page` is iOS-only and is not
/// offered at all — its initialiser takes an `indexDisplayMode`, and nothing
/// on this machine could check it.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TabStyle {
    /// `.automatic` — `DefaultTabViewStyle`.
    Automatic,
    /// `.sidebarAdaptable` — a sidebar where there is room, tabs where not.
    SidebarAdaptable,
    /// `.tabBarOnly` — the tab bar without the adaptive sidebar.
    TabBarOnly,
    /// `.grouped` — macOS only.
    #[cfg(target_os = "macos")]
    Grouped,
}

impl TabStyle {
    fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::Automatic => (
                resolve::default_tab_view_style_ma(),
                resolve::default_tab_view_style_init(),
                resolve::default_tab_view_style_wt(),
            ),
            Self::SidebarAdaptable => (
                resolve::sidebar_tab_view_style_ma(),
                resolve::sidebar_tab_view_style_init(),
                resolve::sidebar_tab_view_style_wt(),
            ),
            Self::TabBarOnly => (
                resolve::tabbar_only_tab_view_style_ma(),
                resolve::tabbar_only_tab_view_style_init(),
                resolve::tabbar_only_tab_view_style_wt(),
            ),
            #[cfg(target_os = "macos")]
            Self::Grouped => (
                resolve::grouped_tab_view_style_ma(),
                resolve::grouped_tab_view_style_init(),
                resolve::grouped_tab_view_style_wt(),
            ),
        }
    }
}

/// Apply `.tabViewStyle(_:)`.
pub fn tab_view_style(view: &ViewHandle, style: TabStyle) -> ViewHandle {
    unsafe {
        let (ma, init, wt) = style.parts();
        zero_arg_style_modifier(view, ma, init, wt,
            resolve::tab_view_style_fn(), resolve::tab_view_style_oret())
    }
}

/// `.navigationSplitViewColumnWidth(_:)` — one `CGFloat`, so d0 and nothing else.
pub fn navigation_split_view_column_width(view: &ViewHandle, width: f64) -> ViewHandle {
    unsafe {
        super::modifier_f64(resolve::nav_split_column_width_fn(),
            resolve::nav_split_column_width_oret(), view, width)
    }
}

/// `.tabViewSearchActivation(.automatic)` — a resilient struct, so by address.
pub fn tab_view_search_activation_automatic(view: &ViewHandle) -> ViewHandle {
    tab_view_search_activation(view, TabSearchActivation::Automatic)
}

/// Which of `TabSearchActivation`'s cases a tab view's search uses.
///
/// Two, not three: `onSearchPresentation` is in the documentation but exports
/// no getter, so there is nothing to call. The export table is the list here.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TabSearchActivation {
    /// Let the system decide.
    Automatic,
    /// Activate when the search tab itself is selected.
    SearchTabSelection,
}

/// `.tabViewSearchActivation(_:)`.
pub fn tab_view_search_activation(
    view: &ViewHandle,
    activation: TabSearchActivation,
) -> ViewHandle {
    unsafe {
        let meta = abi::metadata0(resolve::tab_search_activation_ma());
        let value = super::resilient_static(
            meta,
            match activation {
                TabSearchActivation::Automatic =>
                    c"$s7SwiftUI19TabSearchActivationV9automaticACvgZ",
                // `searchTabSelection` compresses `search` against the type's
                // own `Search`, so the mangling is `06searchC9Selection`, not
                // the `18searchTabSelection` a fresh encoding would give.
                TabSearchActivation::SearchTabSelection =>
                    c"$s7SwiftUI19TabSearchActivationV06searchC9SelectionACvgZ",
            },
        );
        super::modifier_indirect(resolve::tab_search_activation_fn(),
            resolve::tab_search_activation_oret(), view, &value)
    }
}

/// `.tabViewCustomization(nil)`.
///
/// The argument is `Binding<TabViewCustomization>?`. A non-nil one would need a
/// binding into customization state a reference binary would have to declare for
/// itself, so `nil` is both the reachable spelling and the comparable one.
pub fn tab_view_customization_none(view: &ViewHandle) -> ViewHandle {
    unsafe {
        let payload = abi::resolve_type_by_mangled_name(b"7SwiftUI7BindingVyAA20TabViewCustomizationVG");
        assert!(!payload.is_null(), "Binding<TabViewCustomization> metadata");
        let bytes = super::opt_resilient_bytes(
            payload,
            b"7SwiftUI7BindingVyAA20TabViewCustomizationVGSg",
            None,
        );
        super::modifier_indirect(resolve::tab_customization_fn(),
            resolve::tab_customization_oret(), view, &bytes)
    }
}

/// `.tabViewCustomization(_:)` with a live customization, not `nil`.
///
/// [`tab_view_customization_none`] passes `nil`, which is the "do not persist
/// anything" case and the only one that needed no value. This builds a real
/// `TabViewCustomization` and hands SwiftUI a binding to it, so the user's
/// reordering and hiding of tabs is kept — the whole point of the modifier.
///
/// The value lives in the binding's closures for the life of the process: a
/// customization SwiftUI can write back to has to outlive the call that made
/// it, and there is nowhere else to put it.
pub fn tab_view_customization(view: &ViewHandle) -> ViewHandle {
    unsafe {
        let meta = abi::metadata0(resolve::tab_customization_ma());
        assert!(!meta.is_null(), "TabViewCustomization metadata");
        let size = abi::type_bytes(meta);
        let mut initial = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) resolve::tab_customization_init(),
            in("x8") initial.as_mut_ptr(),
            in("x20") meta,
            lateout("x0") _, lateout("x1") _, lateout("x2") _, lateout("x3") _,
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );

        // Shared between the getter and the setter, and leaked: SwiftUI holds
        // the binding, so the storage has to last as long as the view does.
        let cell: &'static std::sync::Mutex<Vec<u8>> =
            Box::leak(Box::new(std::sync::Mutex::new(initial)));
        let get_cell = cell;
        let binding = super::binding_get_set(
            meta,
            b"7SwiftUI7BindingVyAA20TabViewCustomizationVG",
            Box::new(move |out| {
                let v = get_cell.lock().expect("customization");
                core::ptr::copy_nonoverlapping(v.as_ptr(), out, v.len());
            }),
            Box::new(move |inp| {
                let mut v = cell.lock().expect("customization");
                let n = v.len();
                core::ptr::copy_nonoverlapping(inp, v.as_mut_ptr(), n);
            }),
        );

        let payload =
            abi::resolve_type_by_mangled_name(b"7SwiftUI7BindingVyAA20TabViewCustomizationVG");
        assert!(!payload.is_null(), "Binding<TabViewCustomization> metadata");
        let bytes = super::opt_resilient_bytes(
            payload,
            b"7SwiftUI7BindingVyAA20TabViewCustomizationVGSg",
            Some(&binding),
        );
        super::modifier_indirect(resolve::tab_customization_fn(),
            resolve::tab_customization_oret(), view, &bytes)
    }
}

/// A `View` modifier taking one `@ViewBuilder` content closure.
///
/// x0/x1 are the closure, then `Self.Type`, `V.Type`, `Self: View`, `V: View`.
/// The closure is `@noescape` — SwiftUI resolves the content during the call —
/// so the context can live on this stack frame.
pub(crate) unsafe fn content_closure_modifier(
    view: &ViewHandle,
    content: &ViewHandle,
    func: *const c_void,
    oret: *const c_void,
) -> ViewHandle {
    unsafe {
        let kid_handles = Child::new(content, Content::Concrete);
        let handles = kid_handles.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let subst = [view.meta, content.meta,
                     view.wt, content.wt];
        let (meta, wt, size) = super::opaque_result_type(oret, &subst);
        let mut result = vec![0u8; size];
        let this = view.value_ptr();
        core::arch::asm!("blr {f}", f = in(reg) func,
            in("x0") abi::swift_closure_thunk as *const c_void,
            in("x1") &mut ctx as *mut abi::ClosureCtx,
            in("x2") subst[0], in("x3") subst[1], in("x4") subst[2], in("x5") subst[3],
            in("x8") result.as_mut_ptr(),
            in("x20") this,
            lateout("x6") _, lateout("x7") _, lateout("x9") _,
            lateout("x10") _, lateout("x11") _, lateout("x12") _, lateout("x13") _,
            lateout("x14") _, lateout("x15") _, lateout("x16") _, lateout("x17") _,
            lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `.tabViewSidebarHeader { … }`
pub fn tab_view_sidebar_header(view: &ViewHandle, content: &ViewHandle) -> ViewHandle {
    unsafe {
        content_closure_modifier(view, content,
            resolve::tab_sidebar_header_fn(), resolve::tab_sidebar_header_oret())
    }
}

/// `.tabViewSidebarFooter { … }`
pub fn tab_view_sidebar_footer(view: &ViewHandle, content: &ViewHandle) -> ViewHandle {
    unsafe {
        content_closure_modifier(view, content,
            resolve::tab_sidebar_footer_fn(), resolve::tab_sidebar_footer_oret())
    }
}

/// `.tabViewSidebarBottomBar { … }`
pub fn tab_view_sidebar_bottom_bar(view: &ViewHandle, content: &ViewHandle) -> ViewHandle {
    unsafe {
        content_closure_modifier(view, content,
            resolve::tab_sidebar_bottom_bar_fn(), resolve::tab_sidebar_bottom_bar_oret())
    }
}

// ── Modifiers Apple declares `@_alwaysEmitIntoClient` ──
//
// The framework exports no entry point for these, so each one builds the value
// its inlined body builds and goes through the exported `View.modifier(_:)` or
// `View.environment(_:_:)`. What the body builds is read out of the deserialised
// SIL of the inlinable function — `swiftc -emit-sil` carries it — rather than
// guessed from the signature.

/// `.geometryGroup()` — inlines to `modifier(_GeometryGroupEffect())`.
///
/// `_GeometryGroupEffect` has no stored properties, so the value is zero bytes
/// and all the work is naming the type.
pub fn geometry_group(view: &ViewHandle) -> ViewHandle {
    unsafe {
        let meta = abi::metadata0(resolve::geometry_group_effect_ma());
        assert!(!meta.is_null(), "_GeometryGroupEffect metadata");
        let bytes = vec![0u8; abi::type_bytes(meta)];
        super::apply_modifier(view, meta, &bytes)
    }
}

/// `.symbolEffectsRemoved(_:)` — inlines to
/// `modifier(_SymbolEffectsRemovedModifier(isEnabled:))`, one `Bool`.
pub fn symbol_effects_removed(view: &ViewHandle, removed: bool) -> ViewHandle {
    unsafe {
        let meta = abi::metadata0(resolve::symbol_effects_removed_ma());
        assert!(!meta.is_null(), "_SymbolEffectsRemovedModifier metadata");
        let mut bytes = vec![0u8; abi::type_bytes(meta).max(1)];
        bytes[0] = u8::from(removed);
        super::apply_modifier(view, meta, &bytes)
    }
}

/// `.safeAreaPadding(_:)` — inlines to
/// `modifier(SafeAreaPaddingModifier(edges: .all, insets: EdgeInsets(_all:)))`.
///
/// Unlike the two above, both of `SafeAreaPaddingModifier`'s pieces are exported
/// initialisers, so the value is built by calling them rather than by writing
/// its fields.
pub fn safe_area_padding(view: &ViewHandle, length: f64) -> ViewHandle {
    unsafe {
        let insets_meta = abi::metadata0(resolve::edge_insets_ma());
        // `EdgeInsets` is four `CGFloat`s and nothing else, so it comes back in
        // d0-d3 rather than through x8 — and it is concrete, so there is no
        // metadata in x20 either. Passing x8 instead left the buffer zeroed,
        // which rendered identically and only the value comparison caught.
        let (top, leading, bottom, trailing): (f64, f64, f64, f64);
        core::arch::asm!("blr {f}", f = in(reg) resolve::edge_insets_all_init(),
            inout("d0") length => top,
            lateout("d1") leading, lateout("d2") bottom, lateout("d3") trailing,
            lateout("x0") _, lateout("x1") _, lateout("x2") _, lateout("x3") _,
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x8") _, lateout("x9") _, lateout("x10") _, lateout("x11") _,
            lateout("x12") _, lateout("x13") _, lateout("x14") _, lateout("x15") _,
            lateout("x16") _, lateout("x17") _, lateout("lr") _, lateout("x20") _,
            lateout("x21") _, clobber_abi("C"),
        );
        let mut insets = vec![0u8; abi::type_bytes(insets_meta)];
        for (i, v) in [top, leading, bottom, trailing].iter().enumerate() {
            insets[i * 8..i * 8 + 8].copy_from_slice(&v.to_le_bytes());
        }
        // `insets:` is `EdgeInsets?`, and `EdgeInsets` is four CGFloats with no
        // spare bit pattern, so the Optional carries a separate tag byte.
        let opt_insets = super::opt_resilient_bytes(
            insets_meta,
            b"7SwiftUI10EdgeInsetsVSg",
            Some(&insets),
        );
        let edges = super::static_getter(
            resolve::edge_set_all(),
            abi::metadata0(resolve::edge_set_ma()),
        ).0;

        let meta = abi::metadata0(resolve::safe_area_padding_ma());
        let mut value = vec![0u8; abi::type_bytes(meta)];
        core::arch::asm!("blr {f}", f = in(reg) resolve::safe_area_padding_init(),
            in("x0") edges,
            in("x1") opt_insets.as_ptr(),
            in("x8") value.as_mut_ptr(),
            in("x20") meta,
            lateout("x2") _, lateout("x3") _, lateout("x4") _, lateout("x5") _,
            lateout("x6") _, lateout("x7") _, lateout("x9") _, lateout("x10") _,
            lateout("x11") _, lateout("x12") _, lateout("x13") _, lateout("x14") _,
            lateout("x15") _, lateout("x16") _, lateout("x17") _, lateout("lr") _,
            lateout("x21") _, clobber_abi("C"),
        );
        super::apply_modifier(view, meta, &value)
    }
}

/// `.symbolColorRenderingMode(.flat)` — inlines to
/// `environment(\.symbolColorRenderingMode, mode)`.
pub fn symbol_color_rendering_mode_flat(view: &ViewHandle) -> ViewHandle {
    symbol_color_rendering_mode(view, SymbolColorRendering::Flat)
}

/// How a multicolour symbol's colours are rendered.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SymbolColorRendering {
    /// `.flat` — each layer one colour.
    Flat,
    /// `.gradient` — each layer shaded.
    Gradient,
}

/// Apply `.symbolColorRenderingMode(_:)`.
pub fn symbol_color_rendering_mode(view: &ViewHandle, mode: SymbolColorRendering) -> ViewHandle {
    unsafe {
        let getter = match mode {
            SymbolColorRendering::Flat => c"$s7SwiftUI24SymbolColorRenderingModeV4flatACvgZ",
            SymbolColorRendering::Gradient => {
                c"$s7SwiftUI24SymbolColorRenderingModeV8gradientACvgZ"
            }
        };
        symbol_environment_modifier(
            view,
            resolve::symbol_color_rendering_mode_ma(),
            getter,
            b"7SwiftUI24SymbolColorRenderingModeVSg",
            symbol_color_rendering_key_path(),
        )
    }
}

/// `.symbolVariableValueMode(.color)` — inlines to
/// `environment(\.symbolVariableValueMode, mode)`.
pub fn symbol_variable_value_mode_color(view: &ViewHandle) -> ViewHandle {
    symbol_variable_value_mode(view, SymbolVariableValue::Color)
}

/// How a symbol shows a variable value.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SymbolVariableValue {
    /// `.color` — layers change colour.
    Color,
    /// `.draw` — layers are drawn in progressively.
    Draw,
}

/// Apply `.symbolVariableValueMode(_:)`.
pub fn symbol_variable_value_mode(view: &ViewHandle, mode: SymbolVariableValue) -> ViewHandle {
    unsafe {
        let getter = match mode {
            SymbolVariableValue::Color => c"$s7SwiftUI23SymbolVariableValueModeV5colorACvgZ",
            SymbolVariableValue::Draw => c"$s7SwiftUI23SymbolVariableValueModeV4drawACvgZ",
        };
        symbol_environment_modifier(
            view,
            resolve::symbol_variable_value_mode_ma(),
            getter,
            b"7SwiftUI23SymbolVariableValueModeVSg",
            symbol_variable_value_key_path(),
        )
    }
}

/// The shape both symbol environment modifiers share: a resilient struct's
/// static, wrapped in an `Optional`, written through a key path.
unsafe fn symbol_environment_modifier(
    view: &ViewHandle,
    value_ma: *const c_void,
    static_getter_sym: &'static core::ffi::CStr,
    optional_mangled: &[u8],
    key_path: u64,
) -> ViewHandle {
    unsafe {
        let payload = abi::metadata0(value_ma);
        let value = super::resilient_static(payload, static_getter_sym);
        let boxed = super::opt_resilient_bytes(payload, optional_mangled, Some(&value));
        let opt_meta = abi::resolve_type_by_mangled_name(optional_mangled);
        assert!(!opt_meta.is_null(), "{}", crate::diag::demangle_type(optional_mangled));
        super::generic1_modifier_ints(
            resolve::environment_fn(),
            resolve::environment_oret(),
            view,
            opt_meta,
            core::ptr::null(),
            &[key_path, boxed.as_ptr() as u64],
            [0.0; 4],
        )
    }
}

/// `\EnvironmentValues.symbolColorRenderingMode`, built once.
fn symbol_color_rendering_key_path() -> u64 {
    use std::sync::atomic::{AtomicU64, Ordering};
    static CACHE: AtomicU64 = AtomicU64::new(0);
    static mut SLOT: crate::keypath::Slot = crate::keypath::Slot::new();
    let hit = CACHE.load(Ordering::Relaxed);
    if hit != 0 {
        return hit;
    }
    unsafe {
        let kp = crate::keypath::build(
            crate::static_mut(&raw mut SLOT),
            crate::keypath::Property {
                getter: resolve::env_symbol_color_rendering_getter(),
                setter: resolve::env_symbol_color_rendering_setter(),
                descriptor: resolve::env_symbol_color_rendering_descriptor(),
                root: b"7SwiftUI17EnvironmentValuesV",
                value: b"7SwiftUI24SymbolColorRenderingModeVSg",
            },
            crate::keypath::next_thunks(),
        );
        CACHE.store(kp, Ordering::Relaxed);
        kp
    }
}

/// `\EnvironmentValues.symbolVariableValueMode`, built once.
fn symbol_variable_value_key_path() -> u64 {
    use std::sync::atomic::{AtomicU64, Ordering};
    static CACHE: AtomicU64 = AtomicU64::new(0);
    static mut SLOT: crate::keypath::Slot = crate::keypath::Slot::new();
    let hit = CACHE.load(Ordering::Relaxed);
    if hit != 0 {
        return hit;
    }
    unsafe {
        let kp = crate::keypath::build(
            crate::static_mut(&raw mut SLOT),
            crate::keypath::Property {
                getter: resolve::env_symbol_variable_value_getter(),
                setter: resolve::env_symbol_variable_value_setter(),
                descriptor: resolve::env_symbol_variable_value_descriptor(),
                root: b"7SwiftUI17EnvironmentValuesV",
                value: b"7SwiftUI23SymbolVariableValueModeVSg",
            },
            crate::keypath::next_thunks(),
        );
        CACHE.store(kp, Ordering::Relaxed);
        kp
    }
}

/// `.allowedDynamicRange(.high)` on any `View` — inlines to
/// `environment(\.allowedDynamicRange, range)`.
///
/// Not the same modifier as `Image.allowedDynamicRange(_:)`, which is exported
/// and already bound: that one is a method on `Image` and produces an `Image`.
/// This is the `View` spelling, and it writes the environment instead.
pub fn allowed_dynamic_range_high(view: &ViewHandle) -> ViewHandle {
    allowed_dynamic_range(view, DynamicRange::High)
}

/// How much dynamic range an image in this view may use.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DynamicRange {
    /// `.standard` — no more than the display's usual range.
    Standard,
    /// `.constrainedHigh` — some headroom, bounded.
    ConstrainedHigh,
    /// `.high` — the display's full range.
    High,
}

/// Apply `.allowedDynamicRange(_:)`.
pub fn allowed_dynamic_range(view: &ViewHandle, range: DynamicRange) -> ViewHandle {
    unsafe {
        let getter = match range {
            DynamicRange::Standard => c"$s7SwiftUI5ImageV12DynamicRangeV8standardAEvgZ",
            DynamicRange::ConstrainedHigh => {
                c"$s7SwiftUI5ImageV12DynamicRangeV15constrainedHighAEvgZ"
            }
            DynamicRange::High => c"$s7SwiftUI5ImageV12DynamicRangeV4highAEvgZ",
        };
        symbol_environment_modifier(
            view,
            resolve::image_dynamic_range_ma(),
            getter,
            b"7SwiftUI5ImageV12DynamicRangeVSg",
            allowed_dynamic_range_key_path(),
        )
    }
}

/// `\EnvironmentValues.allowedDynamicRange`, built once.
fn allowed_dynamic_range_key_path() -> u64 {
    use std::sync::atomic::{AtomicU64, Ordering};
    static CACHE: AtomicU64 = AtomicU64::new(0);
    static mut SLOT: crate::keypath::Slot = crate::keypath::Slot::new();
    let hit = CACHE.load(Ordering::Relaxed);
    if hit != 0 {
        return hit;
    }
    unsafe {
        let kp = crate::keypath::build(
            crate::static_mut(&raw mut SLOT),
            crate::keypath::Property {
                getter: resolve::env_allowed_dynamic_range_getter(),
                setter: resolve::env_allowed_dynamic_range_setter(),
                descriptor: resolve::env_allowed_dynamic_range_descriptor(),
                root: b"7SwiftUI17EnvironmentValuesV",
                value: b"7SwiftUI5ImageV12DynamicRangeVSg",
            },
            crate::keypath::next_thunks(),
        );
        CACHE.store(kp, Ordering::Relaxed);
        kp
    }
}

/// `Text(verbatim:).equatable()` — an `EquatableView<Text>`.
///
/// `equatable()` is `@_alwaysEmitIntoClient` and its whole body is
/// `EquatableView(content: self)`; `EquatableView` has one stored property, so
/// there is nothing to call — the `Text` is the value.
///
/// It takes a `Text` rather than a `ViewHandle` because the constraint is
/// `Self: Equatable`, and `AnyView` — which every handle in this crate is — does
/// not conform. A view erased into `AnyView` genuinely cannot be made equatable;
/// that is a property of `AnyView`, not a gap in the binding.
pub fn equatable_text(text: &str) -> ViewHandle {
    unsafe {
        let meta = abi::resolve_type_by_mangled_name(b"7SwiftUI13EquatableViewVyAA4TextVG");
        assert!(!meta.is_null(), "EquatableView<Text> metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "EquatableView<Text>: View");
        let words = super::text_verbatim_words(text);
        let mut bytes = vec![0u8; abi::type_bytes(meta)];
        core::ptr::copy_nonoverlapping(words.as_ptr() as *const u8, bytes.as_mut_ptr(), 32);
        ViewHandle::wrap(bytes.as_ptr() as *const c_void, meta, wt)
    }
}

/// `.equatable()` — wrap a view in `EquatableView`, whatever its type.
///
/// [`equatable_text`] does this for a `Text` and nothing else, because the
/// mangled name it resolves names `Text`. The constraint is
/// `Content: Equatable & View`, and whether a given type satisfies it is a
/// question the runtime can answer — so this asks, instead of the binding
/// deciding in advance which one type is allowed.
///
/// The bound is genuine, not a limitation here: a view erased into `AnyView`
/// is not `Equatable` and cannot be made so. That is what the panic says, and
/// it is the same thing Swift's type checker would say at the call site.
///
/// Wrapping is the whole of it — `equatable()` is `@inlinable` with the body
/// `EquatableView(content: self)`, and `EquatableView` stores only its
/// content, so the value is the content's own bytes copied through its value
/// witness. A raw `memcpy` would work for a `Text` and leak a reference for
/// anything holding one.
pub fn equatable(view: &ViewHandle) -> ViewHandle {
    unsafe {
        let eq_wt = {
            type Conforms = unsafe extern "C" fn(*const c_void, *const c_void) -> *const c_void;
            let f: Conforms = core::mem::transmute(resolve::conforms_to_protocol());
            f(view.meta, resolve::equatable_proto())
        };
        assert!(
            !eq_wt.is_null(),
            "{} is not Equatable, so it has no .equatable(); an AnyView never \
             is, so build the leaf type directly",
            crate::diag::type_name(view.meta)
        );
        // `EquatableView<Content> where Content: Equatable, Content: View`:
        // one parameter then its two witnesses, in the order the requirements
        // are declared.
        let meta = abi::generic_metadata_from_descriptor(
            resolve::equatable_view_desc(),
            &[view.meta, eq_wt, view.wt],
        );
        assert!(!meta.is_null(), "EquatableView metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "EquatableView<_>: View");

        let vwt = &*swift_runtime_sys::SwiftABI::get_value_witness_table(view.meta);
        let mut out = vec![0u8; abi::type_bytes(meta)];
        if vwt.size > 0 {
            (vwt.initialize_with_copy)(
                out.as_mut_ptr() as *mut c_void,
                view.value_ptr() as *mut c_void,
                view.meta,
            );
        }
        wrap_owned(out, meta, wt)
    }
}

/// `.sectionIndexLabel(_:)` — inlines through `_trait` to
/// `modifier(_TraitWritingModifier<SectionIndexLabelKey>(value:))`.
///
/// `SectionIndexLabel` is a resilient enum with a payload, so its `.text` case
/// is built the way the crate builds every resilient case: write the payload,
/// then inject the tag through the value witness. The whole thing is then an
/// `Optional`, because the trait's value type is one.
pub fn section_index_label(view: &ViewHandle, label: &str) -> ViewHandle {
    unsafe {
        let label_meta = abi::metadata0(resolve::section_index_label_ma());
        assert!(!label_meta.is_null(), "SectionIndexLabel metadata");
        let mut payload = vec![0u8; abi::type_bytes(label_meta)];
        let words = super::text_verbatim_words(label);
        core::ptr::copy_nonoverlapping(words.as_ptr() as *const u8, payload.as_mut_ptr(), 32);
        // `.text(Text)` is the first payload case, and payload cases take the
        // low tags.
        abi::inject_enum_tag(&mut payload, label_meta, 0);
        let value = super::opt_resilient_bytes(
            label_meta,
            b"7SwiftUI17SectionIndexLabelOSg",
            Some(&payload),
        );

        let meta = abi::resolve_type_by_mangled_name(
            b"7SwiftUI21_TraitWritingModifierVyAA20SectionIndexLabelKeyVG",
        );
        assert!(!meta.is_null(), "_TraitWritingModifier<SectionIndexLabelKey> metadata");
        super::apply_modifier(view, meta, &value)
    }
}

/// `.symbolEffect(.pulse)` — inlines to
/// `modifier(_IndefiniteSymbolEffectModifier(effect:options:isActive:))`.
///
/// Three stored properties and no exported initialiser, so the value is
/// assembled field by field. `.pulse` is `PulseSymbolEffect()`, whose zero-argument
/// initialiser *is* exported — in the `Symbols` framework rather than SwiftUI,
/// which `resolve::sym` reaches because it searches every loaded image.
///
/// `_IndefiniteSymbolEffectModifier` is *not* generic, despite its
/// `init<T>(effect:options:isActive:)` — the initialiser folds `T` into a
/// `SymbolEffectConfiguration.Effect` case. So the stored fields are
/// `{ config, options, isActive }`, which is what the reference's own `dump`
/// says and what this assembles.
pub fn symbol_effect_pulse(view: &ViewHandle) -> ViewHandle {
    symbol_effect(view, SymbolEffect::Pulse)
}

/// One of the indefinite symbol effects — the ones `.symbolEffect(_:)` takes
/// with no `value:`, which run until the view goes away.
///
/// The discrete and transition effects (`.appear`, `.replace`, `.drawOn` …)
/// are a different modifier and are not these.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SymbolEffect {
    /// Fade the layers in and out in turn.
    Pulse,
    /// A single upward nudge, repeating.
    Bounce,
    /// Light the layers up one at a time.
    VariableColor,
    /// Shake side to side.
    Wiggle,
    /// Spin.
    Rotate,
    /// Swell and settle, like breathing.
    Breathe,
}

impl SymbolEffect {
    /// The effect type's metadata accessor, its initialiser, and the name of
    /// the `SymbolEffectConfiguration.Effect` case that wraps it.
    fn parts(self) -> (*const c_void, *const c_void, &'static str) {
        match self {
            Self::Pulse => (
                resolve::pulse_symbol_effect_ma(),
                resolve::pulse_symbol_effect_init(),
                "pulse",
            ),
            Self::Bounce => (
                resolve::bounce_symbol_effect_ma(),
                resolve::bounce_symbol_effect_init(),
                "bounce",
            ),
            Self::VariableColor => (
                resolve::variable_color_symbol_effect_ma(),
                resolve::variable_color_symbol_effect_init(),
                "variableColor",
            ),
            Self::Wiggle => (
                resolve::wiggle_symbol_effect_ma(),
                resolve::wiggle_symbol_effect_init(),
                "wiggle",
            ),
            Self::Rotate => (
                resolve::rotate_symbol_effect_ma(),
                resolve::rotate_symbol_effect_init(),
                "rotate",
            ),
            Self::Breathe => (
                resolve::breathe_symbol_effect_ma(),
                resolve::breathe_symbol_effect_init(),
                "breathe",
            ),
        }
    }
}

/// `.symbolEffect(_:)` with any of the indefinite effects.
///
/// The case tag is *read* from the enum's reflection rather than written down:
/// `SymbolEffectConfiguration.Effect` numbers its cases in declaration order,
/// which is not the order the documentation lists them — `.variableColor` is 2
/// and `.scale` is 3, where reading down the page would say otherwise. A wrong
/// tag builds a valid value of the wrong case, which renders, and renders
/// wrongly. See [`abi::enum_case_index`].
pub fn symbol_effect(view: &ViewHandle, effect: SymbolEffect) -> ViewHandle {
    unsafe {
        let (effect_ma, effect_init, case) = effect.parts();
        let effect_meta = abi::metadata0(effect_ma);
        assert!(!effect_meta.is_null(), "{case} effect metadata");
        let mut effect = vec![0u8; abi::type_bytes(effect_meta)];
        core::arch::asm!("blr {f}", f = in(reg) effect_init,
            in("x8") effect.as_mut_ptr(),
            in("x20") effect_meta,
            lateout("x0") _, lateout("x1") _, lateout("x2") _, lateout("x3") _,
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
        );
        let options_meta = abi::metadata0(resolve::symbol_effect_options_ma());
        let options = super::static_getter_indirect(
            resolve::symbol_effect_options_default(),
            options_meta,
            abi::type_bytes(options_meta),
        );

        // `SymbolEffectConfiguration.Effect` is a resilient enum; `.pulse` is its
        // first payload case, so the payload goes in at offset zero and the tag
        // follows through the value witness.
        let effect_enum_meta = abi::metadata0(resolve::symbol_effect_config_effect_ma());
        let mut config = vec![0u8; abi::type_bytes(effect_enum_meta)];
        config[..abi::type_size(effect_meta)]
            .copy_from_slice(&effect[..abi::type_size(effect_meta)]);
        let tag = abi::enum_case_index(effect_enum_meta, case)
            .unwrap_or_else(|| panic!("SymbolEffectConfiguration.Effect has no case .{case}"));
        abi::inject_enum_tag(&mut config, effect_enum_meta, tag as u32);

        let meta = abi::resolve_type_by_mangled_name(b"7SwiftUI31_IndefiniteSymbolEffectModifierV");
        assert!(!meta.is_null(), "_IndefiniteSymbolEffectModifier metadata");
        let config_meta = abi::metadata0(resolve::symbol_effect_config_ma());
        let config_size = abi::type_size(config_meta);
        let options_size = abi::type_size(options_meta);
        let mut bytes = vec![0u8; abi::type_bytes(meta)];
        // Read rather than computed. The arithmetic that used to stand in here
        // — pad each field to eight — does give the right answers for this
        // type, but it is arithmetic agreeing with a layout rather than the
        // layout itself: `SymbolEffectConfiguration` is eleven bytes and
        // `options` holds a `Double`, so it starts eight-aligned at sixteen,
        // and writing it at eleven produced a plausible `SymbolEffectOptions`
        // whose speed read 2.07e-317. Only the value comparison caught that.
        let offsets = abi::struct_field_offsets(meta).expect("three stored fields");
        let &[config_at, options_at, active_at] = offsets.as_slice() else {
            panic!("_IndefiniteSymbolEffectModifier is {} fields, not 3", offsets.len());
        };
        bytes[config_at..config_at + config_size].copy_from_slice(&config[..config_size]);
        bytes[options_at..options_at + options_size]
            .copy_from_slice(&options[..options_size]);
        // `isActive` defaults to true at the call site.
        bytes[active_at] = 1;
        super::apply_modifier(view, meta, &bytes)
    }
}


/// A `Picker` whose selection cannot change: `Binding.constant` is read-only.
/// Use [`picker_bound()`] for one the user can actually pick from.
pub fn picker(title: &str, selection: i64, content: &ViewHandle) -> ViewHandle {
    unsafe {
        let binding = super::constant_binding(
            &selection.to_le_bytes(),
            resolve::int_meta(),
            mangle::bound(&swift_type!(SwiftUI.Binding), &[mangle::INT]).as_bytes(),
        );
        picker_with_binding(title, content, &binding)
    }
}

/// A `Picker` bound to Rust state: choosing writes the new index back.
pub fn picker_bound(
    title: &str,
    state: &super::BoundState<i64>,
    content: &ViewHandle,
) -> ViewHandle {
    unsafe { picker_with_binding(title, content, &super::i64_binding_of(state)) }
}


/// A member of `SwiftUI.DatePickerComponents`.
///
/// `HourMinuteAndSecond` exists in the framework but is `@available(macOS,
/// unavailable)` and `@available(iOS, unavailable)`, so it is not here.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DatePickerComponent {
    /// The calendar date — month, day and year.
    Date,
    /// The time of day, to the minute.
    HourAndMinute,
}

impl DatePickerComponent {
    fn getter(self) -> &'static core::ffi::CStr {
        match self {
            Self::Date => c"$s7SwiftUI20DatePickerComponentsV4dateACvgZ",
            Self::HourAndMinute => c"$s7SwiftUI20DatePickerComponentsV13hourAndMinuteACvgZ",
        }
    }
}

/// The `DatePickerComponents` value for a set of members.
///
/// # Safety
/// Calls into SwiftUI.
pub(crate) unsafe fn date_picker_components(members: &[DatePickerComponent]) -> Vec<u8> {
    unsafe {
        let meta = abi::metadata0(resolve::dp_components_ma());
        assert!(!meta.is_null(), "DatePickerComponents metadata");
        let size = abi::type_bytes(meta);

        // `rawValue` takes `self` by address in x20 and returns one word;
        // `init(rawValue:)` takes the word in x0 and returns through x8.
        // Neither is given a metatype — the IR declares them
        // `(ptr noalias swiftself) -> i64` and `(sret, i64)`.
        let mut raw = 0u64;
        for m in members {
            let mut one = super::resilient_static(meta, m.getter());
            let bits: u64;
            core::arch::asm!("blr {f}", f = in(reg) resolve::dp_components_raw(),
                in("x20") one.as_mut_ptr(),
                lateout("x0") bits,
                lateout("x1") _, lateout("x2") _, lateout("x3") _, lateout("x4") _,
                lateout("x5") _, lateout("x6") _, lateout("x7") _, lateout("x8") _,
                lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
                lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
                lateout("x17") _, lateout("lr") _, lateout("x21") _, clobber_abi("C"),
            );
            raw |= bits;
        }

        let mut out = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) resolve::dp_components_init_raw(),
            in("x0") raw,
            in("x8") out.as_mut_ptr(),
            lateout("x1") _, lateout("x2") _, lateout("x3") _, lateout("x4") _,
            lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        out
    }
}

/// A `DatePicker` showing a fixed date, which the user cannot change.
/// See [`date_picker_bound`].
pub fn date_picker(title: &str, interval: f64) -> ViewHandle {
    date_picker_components_shown(title, interval, &[DatePickerComponent::Date])
}

/// As [`date_picker`], showing the named components.
pub fn date_picker_components_shown(
    title: &str,
    interval: f64,
    components: &[DatePickerComponent],
) -> ViewHandle {
    unsafe {
        let date = date_bytes(interval);
        let binding = super::constant_binding(
            &date,
            abi::metadata0(resolve::date_ma()),
            mangle::bound(&swift_type!(SwiftUI.Binding), &[mangle::DATE]).as_bytes(),
        );
        date_picker_with_binding_components(title, &binding, components)
    }
}

/// A `DatePicker` bound to Rust state, held as a `Date`'s seconds-since-2001.
pub fn date_picker_bound(title: &str, state: &super::BoundState<f64>) -> ViewHandle {
    date_picker_bound_components(title, state, &[DatePickerComponent::Date])
}

/// As [`date_picker_bound`], showing the named components.
pub fn date_picker_bound_components(
    title: &str,
    state: &super::BoundState<f64>,
    components: &[DatePickerComponent],
) -> ViewHandle {
    unsafe {
        // `Date` is one `Double`, so the same eight bytes a slider would write.
        let binding = super::scalar_binding::<f64, 8>(
            state,
            abi::metadata0(resolve::date_ma()),
            mangle::bound(&swift_type!(SwiftUI.Binding), &[mangle::DATE]).as_bytes(),
            |v| v.to_le_bytes(),
            f64::from_le_bytes,
        );
        date_picker_with_binding_components(title, &binding, components)
    }
}


/// A `ColorPicker` showing a fixed colour, which the user cannot change.
/// See [`color_picker_bound`].
pub fn color_picker(title: &str, color: crate::Color, supports_opacity: bool) -> ViewHandle {
    unsafe {
        let value = super::color_value_of(color).to_le_bytes();
        let b = super::constant_binding(
            &value,
            resolve::color_meta(),
            mangle::bound(&swift_type!(SwiftUI.Binding), &["7SwiftUI5ColorV"]).as_bytes(),
        );
        color_picker_with_binding(title, supports_opacity, &b)
    }
}

/// A `ColorPicker` bound to Rust state.
///
/// The state holds the `Color` as the one reference `Color` is — what
/// [`super::color_value_of`] returns — because that is what the binding reads
/// and writes. `Color` is a class instance, not a struct of components.
pub fn color_picker_bound(
    title: &str,
    state: &super::BoundState<u64>,
    supports_opacity: bool,
) -> ViewHandle {
    unsafe {
        let b = super::scalar_binding::<u64, 8>(
            state,
            resolve::color_meta(),
            mangle::bound(&swift_type!(SwiftUI.Binding), &["7SwiftUI5ColorV"]).as_bytes(),
            |v| v.to_le_bytes(),
            u64::from_le_bytes,
        );
        color_picker_with_binding(title, supports_opacity, &b)
    }
}

/// Where a container keeps its content in its generic argument vector.
#[derive(Clone, Copy)]
pub(crate) struct ContentShape {
    /// How many words the argument vector has: parameters, then conformances.
    pub(crate) args: usize,
    /// Index of the content's metadata.
    pub(crate) meta_at: usize,
    /// Index of the content's `View` witness table.
    pub(crate) wt_at: usize,
}

/// A container whose only argument is a `() -> Content` closure, keeping the
/// content's own type instead of boxing it into an `AnyView`.
///
/// [`content_container`] names its result by a fixed mangled string, and that
/// string has to spell some concrete `Content` — so it spells `AnyView`, and the
/// child is boxed to match. The name still gives an *instantiation*, though, and
/// every metadata record points at the nominal descriptor it came from: read
/// that off and the runtime will build `List<Never, Text>` as readily as
/// `List<Never, AnyView>`.
///
/// The other generic arguments — `Never` for `List`'s selection, `EmptyView` for
/// a `Section`'s header — are read off the known instantiation, so they are
/// whatever that type was declared with rather than something guessed here.
///
/// `shape` says where the content sits: how many arguments the vector has, and
/// the index of the content's metadata and of its `View` witness. Those cannot
/// be derived from each other — a `List` has two type parameters but only one
/// conformance, so its witness is at 2 and not at 4 — and a wrong guess would
/// build some *other* instantiation rather than fail. So the result is checked
/// against what was asked for, and anything unexpected falls back to boxing,
/// which is what this always did.
///
/// # Safety
/// `init` must be the container's `init(content:)` and `known` an instantiation
/// of it over `AnyView`.
pub(crate) unsafe fn content_container_typed(
    child: &ViewHandle,
    init: *const c_void,
    known: &'static CachedType,
    shape: ContentShape,
) -> ViewHandle {
    unsafe {
        let (known_meta, _, _) = result_type(known);
        // Generic arguments sit after the metadata header.
        let args_base = (known_meta as *const *const c_void).add(2);
        let mut args: Vec<*const c_void> = (0..shape.args).map(|i| *args_base.add(i)).collect();
        args[shape.meta_at] = child.meta;
        args[shape.wt_at] = child.wt;
        let meta = abi::generic_metadata_from(known_meta, &args);
        if meta.is_null() {
            return content_container(child, init, known);
        }
        // Did we build what we meant to? The content's metadata has to be where
        // we put it, or `shape` describes a different type than this one.
        let built = (meta as *const *const c_void).add(2);
        if *built.add(shape.meta_at) != child.meta {
            return content_container(child, init, known);
        }
        let wt = abi::get_view_wt(meta);
        if wt.is_null() {
            return content_container(child, init, known);
        }

        let kid = Child::new(child, Content::Concrete);
        let handles = kid.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        let mut result = vec![0u8; abi::type_bytes(meta)];
        core::arch::asm!("blr {f}", f = in(reg) init,
            in("x0") abi::swift_closure_thunk as *const c_void,
            in("x1") &mut ctx as *mut abi::ClosureCtx,
            in("x2") child.meta,
            in("x3") child.wt,
            in("x8") result.as_mut_ptr(),
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

// ── Lists with identity ─────────────────────────────────────────────────────

/// `(Data.Element) -> Content`, where `Element` is *generic*.
///
/// [`emit_index_view`] reads x0 as the index itself, which is right for
/// `ForEach(0..<n)` — there `Element` is concretely `Int` and arrives in a
/// register. Here `Element` is an associated type of a generic `Data`, so it is
/// `@in_guaranteed`: x0 is the *address* of the `Int`. Reading it as the value
/// gave every row the same number, which was the pointer — caught by the
/// rendered pixels, since the type and the value were both already identical to
/// Swift's.
pub(crate) unsafe extern "C" fn emit_element_view(out: *mut u8, element: i64, payload: *mut c_void) {
    unsafe { emit_index_view(out, *(element as *const i64), payload) };
}

/// The `\Int.self` this list's `id:` is.
static mut LIST_ID_SLOT: crate::keypath::IdentitySlot = crate::keypath::IdentitySlot::new();
/// And `\String.self`, for the string-keyed one. One slot per key path.
static mut LIST_ID_STR_SLOT: crate::keypath::IdentitySlot = crate::keypath::IdentitySlot::new();


/// `List(ids, id: \.self) { id in … }` — rows SwiftUI identifies by value.
///
/// [`for_each`] and everything built on it identify rows *positionally*:
/// inserting at the front makes SwiftUI treat every later row as changed rather
/// than moved, so nothing animates as a move and per-row state follows the
/// index instead of the row. That is the same semantics as writing
/// `ForEach(0..<n)` in Swift, and it is the wrong semantics for a list of
/// things.
///
/// This takes the identifiers themselves. `ids` are the rows' identities, and
/// `builder` is asked for the row belonging to each — so moving an id moves its
/// row, and removing one removes that row rather than the last.
///
/// The plain `ForEach(_:id:content:)` over `View` content is not reachable:
/// it is inlinable and exports no symbol, and the only exported `ForEach`
/// `id:` initialisers are the `TabContent`, `PickerContent`, `ToolbarContent`,
/// `TableRowContent` and `AccessibilityRotorContent` flavours. `List`'s does
/// export one, and builds the identified `ForEach` internally — which is why
/// this is a list constructor and not a general `for_each_identified`.
pub fn list_identified(ids: &[i64], builder: impl Fn(i64) -> ViewHandle + 'static) -> ViewHandle {
    unsafe {
        static ID_KP: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
        let id_kp = *ID_KP.get_or_init(|| {
            crate::keypath::build_identity(crate::static_mut(&raw mut LIST_ID_SLOT), b"Si", b"Si")
        });

        let int_meta = resolve::int_meta();
        let stride = abi::type_bytes(int_meta);
        let mut bytes = vec![0u8; stride * ids.len()];
        for (i, id) in ids.iter().enumerate() {
            bytes[i * stride..i * stride + 8].copy_from_slice(&id.to_le_bytes());
        }
        let array = abi::swift_array(int_meta, ids.len(), &bytes);

        let boxed: IndexBuilder = Box::new(builder);
        identified_list(array, b"SaySiG", int_meta, id_kp, &LIST_ID_T, emit_element_view, boxed)
    }
}

/// `List(names, id: \.self) { name in … }` — the same, keyed by `String`.
///
/// Which is what most lists key on: an identifier is usually a name or a UUID
/// string, and turning one into an `Int` to get identity back would defeat the
/// point. `String` is `Hashable`, which is all `ForEach`'s `ID` has to be.
pub fn list_identified_str(
    ids: &[&str],
    builder: impl Fn(&str) -> ViewHandle + 'static,
) -> ViewHandle {
    unsafe {
        static ID_KP: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
        let id_kp = *ID_KP.get_or_init(|| {
            crate::keypath::build_identity(crate::static_mut(&raw mut LIST_ID_STR_SLOT), b"SS", b"SS")
        });
        let array = swift_string_array(ids);
        let string_meta = resolve::string_meta();
        let boxed: StringBuilder = Box::new(builder);
        let payload = Box::into_raw(Box::new(boxed)) as *mut c_void;
        identified_list_raw(
            array,
            b"SaySSG",
            string_meta,
            id_kp,
            &LIST_ID_STR_T,
            emit_string_element_view,
            payload,
        )
    }
}

/// The Rust side of a string-keyed row builder.
pub(crate) type StringBuilder = Box<dyn Fn(&str) -> ViewHandle>;

/// `(String) -> Content` — the element arrives by address, as [`emit_element_view`]
/// explains, and a `String` is sixteen bytes there rather than one word.
pub(crate) unsafe extern "C" fn emit_string_element_view(
    out: *mut u8,
    element: i64,
    payload: *mut c_void,
) {
    unsafe {
        let builder = &*(payload as *const StringBuilder);
        let mut raw = [0u8; 16];
        core::ptr::copy_nonoverlapping(element as *const u8, raw.as_mut_ptr(), 16);
        let view = builder(&abi::read_swift_string(raw));
        *(out as *mut u64) = view.into_anyview_word();
    }
}

/// Build the `List` once the element type's pieces are in hand.
///
/// # Safety
/// `array` must be a live Swift array of `element_meta`, `array_mangled` its
/// type's mangled name, and `payload` what `body` expects.
unsafe fn identified_list_raw(
    array: u64,
    array_mangled: &[u8],
    element_meta: *const c_void,
    id_kp: u64,
    result: &'static crate::views::types::CachedType,
    body: unsafe extern "C" fn(*mut u8, i64, *mut c_void),
    payload: *mut c_void,
) -> ViewHandle {
    unsafe {
        // The initialiser *consumes* the key path, so the cached object is
        // retained per use — the same balance [`outline_group`] documents.
        swift_runtime_sys::RuntimeRaw::swift_retain(id_kp as *mut c_void);
        let array_meta = abi::resolve_type_by_mangled_name(array_mangled);
        assert!(!array_meta.is_null(), "array metadata");

        let ctx = Box::leak(Box::new(abi::IndexClosureCtx::new(body, payload)))
            as *mut abi::IndexClosureCtx;

        let (meta, wt, size) = result_type(result);
        let mut out = vec![0u8; size];
        // List.init(_:id:rowContent:)
        //   x0 = @in Data, x1 = id KeyPath, x2 = rowContent fn,
        //   x3 = rowContent ctx, x4 = Data.Type, x5 = ID.Type,
        //   x6 = RowContent.Type, x7 = Data: RandomAccessCollection WT,
        //   [sp] = ID: Hashable WT, [sp+8] = RowContent: View WT, x8 = @out
        core::arch::asm!(
            "sub sp, sp, #16",
            "stp {hw}, {vw}, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::list_id_init(),
            hw = in(reg) conformance_wt(element_meta, resolve::hashable_proto()),
            vw = in(reg) resolve::anyview_wt(),
            in("x0") &array as *const u64,
            in("x1") id_kp,
            in("x2") abi::index_closure_thunk as *const c_void,
            in("x3") ctx,
            in("x4") array_meta,
            in("x5") element_meta,
            in("x6") resolve::anyview_meta(),
            in("x7") conformance_wt(array_meta, resolve::random_access_proto()),
            in("x8") out.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(out, meta, wt)
    }
}

/// The `Int`-keyed shape, which carries a typed builder rather than a raw one.
///
/// # Safety
/// As [`identified_list_raw`].
unsafe fn identified_list(
    array: u64,
    array_mangled: &[u8],
    element_meta: *const c_void,
    id_kp: u64,
    result: &'static crate::views::types::CachedType,
    body: unsafe extern "C" fn(*mut u8, i64, *mut c_void),
    builder: IndexBuilder,
) -> ViewHandle {
    unsafe {
        let payload = Box::into_raw(Box::new(TypedIndexBuilder {
            builder,
            // No type is promised: the rows go in as `AnyView`, which is what
            // the result type names.
            meta: core::ptr::null(),
        })) as *mut c_void;
        identified_list_raw(array, array_mangled, element_meta, id_kp, result, body, payload)
    }
}








// ── Tabs ────────────────────────────────────────────────────────────────────

/// `Tab<Never, AnyView, DefaultTabLabel>`, spelled without substitutions so it
/// can be pasted into a larger name — which the compressed form the runtime
/// hands back cannot be.
const TAB_MANGLED: &str =
    "7SwiftUI3TabVys5NeverO7SwiftUI7AnyViewV7SwiftUI15DefaultTabLabelVG";

/// `Tab<Never, AnyView, DefaultTabLabel>`'s metadata, resolved once.
fn tab_meta() -> *const c_void {
    static CACHE: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
    *CACHE.get_or_init(|| unsafe {
        let name = mangle::ty("Tab")
            .of(vec![
                mangle::Type::Verbatim("s5NeverO".into()),
                mangle::ty("AnyView"),
                mangle::ty("DefaultTabLabel"),
            ])
            .mangle();
        let m = abi::resolve_type_by_mangled_name(name.as_bytes());
        assert!(!m.is_null(), "{}", mangle::demangle(&name));
        m as usize
    }) as *const c_void
}

/// `Tab("Home", systemImage: "house") { … }` — one tab of a modern `TabView`.
///
/// The older way to build a tab is `.tabItem { Label(…) }` on the page itself,
/// which is what [`tab_item`](super::tab_item) binds. `Tab` is the replacement:
/// the tab and its label are one value rather than a modifier on the content,
/// which is what lets a `TabView` know its tabs without rendering them.
///
/// `Tab` is not a `View` — it is a `TabContent`, and only a `TabView` accepts
/// one.
pub fn tab(title: &str, system_image: &str, content: &ViewHandle) -> ViewHandle {
    unsafe {
        let t = abi::swift_string(title);
        let t0 = u64::from_le_bytes(t[..8].try_into().expect("title lo"));
        let t1 = u64::from_le_bytes(t[8..].try_into().expect("title hi"));
        let (k0, k1, k2, k3) = super::primitives::localized_string_key(t0, t1);

        let img = abi::swift_string(system_image);
        let i0 = u64::from_le_bytes(img[..8].try_into().expect("image lo"));
        let i1 = u64::from_le_bytes(img[8..].try_into().expect("image hi"));

        let kids = Child::new(content, Content::Erased);
        let handles = kids.element();
        let payload = TuplePayload { children: handles.as_ptr(), count: 1 };
        let mut ctx =
            abi::ClosureCtx::new(emit_tuple, &payload as *const TuplePayload as *mut c_void);

        // Not `result_type`: that asserts the type conforms to `View`, and a
        // `Tab` conforms to `TabContent` instead — which is the whole point of
        // it. Resolving the name directly skips the witness it does not have.
        //
        // The content stays boxed, and this is the one container in this file
        // where that is not just history. `Tab` is a `TabContent`, so what holds
        // it is a `TabView<…, Content: TabContent>` rather than a view, and every
        // `TabContent` in the tree — the tab itself, the `TupleTabContent` over
        // several, the `TabView` around them — names `Tab<Never, AnyView,
        // DefaultTabLabel>` in its own type. Typing one of them and not the rest
        // describes a value of one layout to code expecting another: building
        // `Tab<Never, Text, …>` here left `tab_view` reading it as the `AnyView`
        // form, and `tab_view_one` faulted. Moving them all is a `TabContent`
        // composition of its own, not this one-line change.
        let meta = tab_meta();
        let (content_meta, content_wt) = (resolve::anyview_meta(), resolve::anyview_wt());

        let mut result = vec![0u8; abi::type_bytes(meta)];
        // Tab.init(_:systemImage:content:)
        //   x0-x3 = LocalizedStringKey (thirty-two bytes), x4/x5 = systemImage,
        //   x6/x7 = the content closure, [sp] = Content.Type,
        //   [sp+8] = Content: View WT, x8 = @out
        //
        // The `role:` overload next to this one takes a `TabRole?` in between,
        // which leaves one register for a two-word closure — AAPCS64 does not
        // split an argument, so the closure and everything after it would go to
        // the stack. This overload is both what `Tab(_:systemImage:)` compiles
        // to and the one that fits.
        core::arch::asm!(
            "sub sp, sp, #16",
            "stp {cm}, {cw}, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::tab_init(),
            cm = in(reg) content_meta,
            cw = in(reg) content_wt,
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") i0, in("x5") i1,
            in("x6") abi::swift_closure_thunk as *const c_void,
            in("x7") &mut ctx as *mut abi::ClosureCtx,
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        // A `Tab` is a `TabContent`, not a `View`. The handle carries that
        // witness in the slot a view's `View` witness would use, which is what
        // `tab_view_of` reads — and is also why a `Tab` cannot be put anywhere
        // a view goes.
        wrap_owned(result, meta, conformance_wt(meta, resolve::tab_content_proto()))
    }
}


/// `(…) -> TabContent` — hand back the tab this closure was built with.
///
/// Unlike [`emit_tuple`], which writes an `AnyView` word, a `TabContent` is a
/// value of whatever concrete type it is — fifty-seven bytes for a `Tab` — so
/// the whole thing is copied through the result address.
unsafe extern "C" fn emit_tab(out: *mut u8, payload: *mut c_void) {
    unsafe {
        let tab = &*(payload as *const ViewHandle);
        let vwt = &*swift_runtime_sys::SwiftABI::get_value_witness_table(tab.meta);
        (vwt.initialize_with_copy)(
            out as *mut c_void,
            tab.value_ptr() as *mut c_void,
            tab.meta,
        );
    }
}

/// `TabView { Tab(…) }` — the modern tab view, over **one** tab.
///
/// [`tab_view`](fn@tab_view) takes a `View` and relies on each page carrying a
/// `.tabItem`
/// modifier; this takes a [`tab`] directly, which is the API that replaced it.
///
/// The result type is `TabView<Never, TabContentBuilder<Never>.Content<T>>` —
/// a generic nested inside a generic, whose mangling puts *both* argument lists
/// in one group separated by `_` rather than closing the parent's first. That
/// distinction is the difference between resolving and not.
///
pub fn tab_view_of(tab: &ViewHandle) -> ViewHandle {
    unsafe {
        assert!(
            !tab.wt.is_null(),
            "tab_view_of needs a Tab, which carries a TabContent witness",
        );
        tab_view_from(tab, TAB_MANGLED)
    }
}

/// Wrap any `TabContent` in a `TabView`.
///
/// `verbose` is the content's mangled name **without substitutions**. It is a
/// parameter rather than something to look up because
/// `abi::mangled_type_name` hands back the compressed form, whose `AA`
/// back-references are numbered against the name they came from — pasting one
/// into a larger name shifts every later reference and produces a string that
/// resolves to a different type, or to nothing. Here it resolved
/// `_TupleTabContent<Never, (Tab, Tab, Tab)>` to
/// `_TupleTabContent<Never, (View<…>, Never, Never)>`, which is what caught it.
///
/// # Safety
/// `content` must be a `TabContent` whose witness the handle carries, and
/// `verbose` must name its type.
unsafe fn tab_view_from(content: &ViewHandle, verbose: &str) -> ViewHandle {
    unsafe {
        let payload = Box::into_raw(Box::new(content.clone())) as *mut c_void;
        let mut ctx = abi::ClosureCtx::new(emit_tab, payload);

        // Resolved by name. Every metadata-accessor route to
        // `TabContentBuilder<Never>.Content<C>` faulted — its `Ma` with the two
        // arguments in registers, `swift_getGenericMetadata` with its `Mn`
        // descriptor, and the same with a descriptor taken from a known
        // instance — so whatever shape a nested generic's arguments take, it is
        // not the flat parent-then-child array a top-level one uses.
        let inner = format!("7SwiftUI17TabContentBuilderV7ContentVys5NeverO_{verbose}G");
        let full = format!("7SwiftUI7TabViewVys5NeverO{inner}G");
        let meta = abi::resolve_type_by_mangled_name(full.as_bytes());
        assert!(!meta.is_null(), "{}", crate::diag::demangle_type(full.as_bytes()));
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "TabView !: View");

        let mut result = vec![0u8; abi::type_bytes(meta)];
        // TabView.init(content: () -> C)
        //   x0/x1 = the closure, x2 = C.Type, x3 = C: TabContent WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::tabview_content_init(),
            in("x0") abi::swift_closure_thunk as *const c_void,
            in("x1") &mut ctx as *mut abi::ClosureCtx,
            in("x2") content.meta,
            in("x3") content.wt,
            in("x8") result.as_mut_ptr(),
            lateout("x4") _, lateout("x5") _, lateout("x6") _, lateout("x7") _,
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}











// ── Composing several tabs ──────────────────────────────────────────────────
//
// `@TabContentBuilder` does more than gather: each `Tab` becomes
// `ModifiedContent<Tab.TabIdentifiedView, _TraitWritingModifier<TagValueTraitKey<Never>>>`,
// which is what carries its identity, and the block becomes a
// `_TupleTabContent` over a tuple of those. `buildBlock` is inlinable and
// exports nothing, so both halves are built here instead.
//
// Every type below is spelled *without substitutions*. The runtime will hand
// back a name for any metadata, but only the compressed form, whose `AA`
// back-references are numbered against the name they came from — pasting one
// into a larger name silently resolves to a different type. Composing from
// verbose pieces has nothing to misnumber, and each piece is checked against
// the metadata the opaque-result descriptor gives.

/// `Tab<Never, AnyView, DefaultTabLabel>.TabIdentifiedView`.
///
/// Nested in an *extension*, so the module appears twice — once for `Tab` and
/// once for the extension — and the generic arguments are the parent's
/// followed by the child's (none), separated by `_`.
const TAB_IDENTIFIED: &str = "7SwiftUI3TabV7SwiftUIE17TabIdentifiedViewVys5NeverO\
7SwiftUI7AnyViewV7SwiftUI15DefaultTabLabelV_G";

/// `_TraitWritingModifier<TagValueTraitKey<Never>>` — one byte, the tag.
const TAB_TRAIT: &str =
    "7SwiftUI21_TraitWritingModifierVy7SwiftUI16TagValueTraitKeyVys5NeverOGG";

/// One element of the builder's tuple.
fn tab_element_name() -> String {
    format!("7SwiftUI15ModifiedContentVy{TAB_IDENTIFIED}{TAB_TRAIT}G")
}

/// A `Tab` as the element `@TabContentBuilder` collects.
///
/// The type is reached two ways and they are checked against each other: the
/// composed name above, and `Tab._identifiedView`'s opaque-result descriptor.
/// The value is *built* rather than fetched — the exported `_identifiedView`
/// getter faults under every argument layout tried — which is sound because the
/// type turns out to be two plain fields: a `TabIdentifiedView` whose single
/// field *is* the `Tab`, and a one-byte modifier.
///
/// # Safety
/// `tab` must be a `Tab<Never, AnyView, DefaultTabLabel>`.
unsafe fn identified_element(tab: &ViewHandle) -> (Vec<u8>, *const c_void) {
    unsafe {
        let name = tab_element_name();
        let meta = abi::resolve_type_by_mangled_name(name.as_bytes());
        assert!(!meta.is_null(), "{}", crate::diag::demangle_type(name.as_bytes()));
        debug_assert_eq!(meta, identified_element_from_descriptor(), "composed name is a different type");

        let offsets = abi::struct_field_offsets(meta).expect("two stored fields");
        let &[content_at, modifier_at] = offsets.as_slice() else {
            panic!("the identified view is {} fields, not 2", offsets.len());
        };
        // The wrapper's one field is the `Tab` itself, at offset zero and the
        // same size — checked, since a wrapper that added anything would make
        // the copy below silent nonsense.
        let wrapper = abi::field_type_metadata(meta, 0);
        assert_eq!(abi::field_type_metadata(wrapper, 0), tab.meta, "TabIdentifiedView wraps something else");
        assert_eq!(abi::struct_field_offsets(wrapper).as_deref(), Some(&[0][..]));

        let mut bytes = vec![0u8; abi::type_bytes(meta)];
        let vwt = &*swift_runtime_sys::SwiftABI::get_value_witness_table(tab.meta);
        (vwt.initialize_with_copy)(
            bytes.as_mut_ptr().add(content_at) as *mut c_void,
            tab.value_ptr() as *mut c_void,
            tab.meta,
        );
        // The modifier holds a `Never?`, which is one byte and can only be
        // `nil` — `Never` is uninhabited, so there is no other value. Written
        // through `Never`'s own witness rather than as a literal, which is the
        // rule `store_optional_tag` documents.
        abi::store_optional_tag(&mut bytes[modifier_at..], resolve::never_meta(), false);
        (bytes, meta)
    }
}

/// The same type by the other route, for the crosscheck in
/// [`identified_element`].
fn identified_element_from_descriptor() -> *const c_void {
    unsafe {
        let label = abi::resolve_type_by_mangled_name(b"7SwiftUI15DefaultTabLabelV");
        let subst = [
            resolve::never_meta(),
            resolve::anyview_meta(),
            label,
            resolve::never_hashable_wt(),
            resolve::anyview_wt(),
            abi::get_view_wt(label),
        ];
        super::opaque_result_type(resolve::tab_identified_oret(), &subst).0
    }
}

/// `TabView { Tab(…); Tab(…); … }` — the modern tab view over any number of
/// tabs.
///
/// ```no_run
/// # use swiftui_native::views;
/// let tabs = [
///     views::tab("Home", "house", &views::text("home")),
///     views::tab("Settings", "gear", &views::text("settings")),
/// ];
/// let view = views::tab_view_tabs(&tabs);
/// ```
pub fn tab_view_tabs(tabs: &[ViewHandle]) -> ViewHandle {
    assert!(!tabs.is_empty(), "a TabView needs at least one tab");
    unsafe {
        let mut elements = Vec::with_capacity(tabs.len());
        let mut element_meta = core::ptr::null();
        for tab in tabs {
            assert!(!tab.wt.is_null(), "tab_view_tabs takes Tabs, which carry a TabContent witness");
            let (bytes, meta) = identified_element(tab);
            element_meta = meta;
            elements.push(bytes);
        }

        // `(A, B, C, …)` is `A_BC…t`: the `_` appears once, after the *first*
        // element, and the rest follow unseparated. Measured — `Si_Sit`
        // resolves to a two-element tuple, `Si_Si_Sit` to nothing, and
        // `Si_SiSit` is the three-element one.
        let one = tab_element_name();
        let content_name = if tabs.len() == 1 {
            format!("7SwiftUI16_TupleTabContentVys5NeverO{one}G")
        } else {
            let rest = one.repeat(tabs.len() - 1);
            format!("7SwiftUI16_TupleTabContentVys5NeverO{one}_{rest}tG")
        };
        let content_meta = abi::resolve_type_by_mangled_name(content_name.as_bytes());
        assert!(
            !content_meta.is_null(),
            "{}",
            crate::diag::demangle_type(content_name.as_bytes())
        );

        // The tuple itself, whose element offsets come from tuple metadata —
        // not struct metadata: it has no descriptor and no field-offset vector,
        // just a count and one `{ type, offset }` pair per element.
        let tuple_meta = if tabs.len() == 1 {
            element_meta
        } else {
            abi::tuple_metadata(&vec![element_meta; tabs.len()])
        };
        let offsets = if tabs.len() == 1 {
            vec![0]
        } else {
            abi::tuple_element_offsets(tuple_meta, tabs.len())
        };
        let mut tuple = vec![0u8; abi::type_bytes(tuple_meta)];
        for (bytes, at) in elements.iter().zip(&offsets) {
            tuple[*at..*at + bytes.len()].copy_from_slice(bytes);
        }

        let mut content = vec![0u8; abi::type_bytes(content_meta)];
        // _TupleTabContent.init(_: B)
        //   x0 = @in B — generic, so by address — x1 = SelectionValue.Type,
        //   x2 = B.Type, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::tuple_tab_init(),
            in("x0") tuple.as_mut_ptr(),
            in("x1") resolve::never_meta(),
            in("x2") tuple_meta,
            in("x8") content.as_mut_ptr(),
            lateout("x3") _, lateout("x4") _, lateout("x5") _, lateout("x6") _,
            lateout("x7") _, lateout("x9") _, lateout("x10") _, lateout("x11") _,
            lateout("x12") _, lateout("x13") _, lateout("x14") _, lateout("x15") _,
            lateout("x16") _, lateout("x17") _, lateout("lr") _, lateout("x20") _,
            lateout("x21") _, clobber_abi("C"),
        );
        // The initialiser consumed the tuple and the elements it holds.
        core::mem::forget(tuple);
        for bytes in elements {
            core::mem::forget(bytes);
        }

        let wt = conformance_wt(content_meta, resolve::tab_content_proto());
        assert!(!wt.is_null(), "_TupleTabContent !: TabContent");
        tab_view_from(&wrap_owned(content, content_meta, wt), &content_name)
    }
}


/// `Stepper(_:onIncrement:onDecrement:)` — a stepper driven by callbacks.
///
/// [`stepper_bound`](super::stepper_bound) binds a number and a range, which is
/// right when there is a number to bind. A stepper that adds and removes rows,
/// or nudges something the Rust side computes, has no such number — and there
/// was no way to ask for one.
///
/// Both callbacks are `(() -> ())?`, which is two words with `nil` as both
/// null. Passing `None` for either greys out that half of the control, which is
/// how SwiftUI says "you cannot go further this way".
pub fn stepper_actions(
    label: &str,
    on_increment: Option<Box<dyn Fn()>>,
    on_decrement: Option<Box<dyn Fn()>>,
) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(label);
        let s0 = u64::from_le_bytes(ss[..8].try_into().expect("label lo"));
        let s1 = u64::from_le_bytes(ss[8..].try_into().expect("label hi"));
        let (k0, k1, k2, k3) = super::primitives::localized_string_key(s0, s1);

        let words = |f: Option<Box<dyn Fn()>>| match f {
            Some(f) => super::closures::boxed_action_words(f),
            None => [0, 0],
        };
        let inc = words(on_increment);
        let dec = words(on_decrement);

        let (meta, wt, size) = result_type(&STEPPER_T);
        let mut result = vec![0u8; size];
        // Stepper.init(_:onIncrement:onDecrement:onEditingChanged:)
        //   x0-x3 = LocalizedStringKey, x4/x5 = onIncrement,
        //   x6/x7 = onDecrement, [sp] = onEditingChanged fn,
        //   [sp+8] = its context, x8 = @out
        core::arch::asm!(
            "sub sp, sp, #16",
            "stp {ef}, xzr, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::stepper_actions_init(),
            ef = in(reg) super::noop_closure as *const c_void,
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") inc[0], in("x5") inc[1],
            in("x6") dec[0], in("x7") dec[1],
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}

/// `ForEach(a...b, id: \.self) { … }` — a closed range, identified by value.
///
/// [`for_each`] takes a Rust `Range` and reaches the `Range<Int>` overload,
/// which builds `ForEach<Range<Int>, Int, Content>`. Apple's documentation
/// writes `ForEach(1...10, id: \.self)`, which is a *`ClosedRange`* and a
/// different `Data` type argument — so a view transcribed from it could not be
/// reproduced until this existed.
///
/// The `id:` is a real `\Int.self` key path, built at run time, so SwiftUI
/// identifies rows by value: a row that moves animates as a move, and its
/// state follows it. `for_each`'s positional identity does not.
pub fn for_each_closed(
    start: i64,
    end: i64,
    builder: impl Fn(i64) -> ViewHandle + 'static,
) -> ViewHandle {
    unsafe {
        let boxed: IndexBuilder = Box::new(builder);
        let probe = boxed(start);
        let (content_meta, content_wt) = (probe.meta, probe.wt);

        let data_meta = abi::resolve_type_by_mangled_name(b"SNySiG");
        assert!(!data_meta.is_null(), "ClosedRange<Int> metadata");
        let data_wt = super::conformance_wt(data_meta, resolve::random_access_collection_proto());
        let int_meta = resolve::int_meta();

        // `ForEach<Data, ID, Content>` — three parameters then three
        // conformances, in declaration order.
        let (known_meta, _, _) = result_type(&FOREACH_T);
        let meta = abi::generic_metadata_from(
            known_meta,
            &[
                data_meta,
                int_meta,
                content_meta,
                data_wt,
                resolve::int_hashable_wt(),
                content_wt,
            ],
        );
        assert!(!meta.is_null(), "ForEach<ClosedRange<Int>, Int, _> metadata");
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "ForEach !: View");
        drop(probe);

        // `\Int.self`, built once and *retained per call*.
        //
        // `ForEach.init(_:id:content:)` consumes the key path — Swift's own
        // call site pairs it with a fresh `swift_getKeyPath`, which returns
        // `+1`, and never releases afterwards. A cached one handed over
        // without a retain is a reference this code does not own, and the
        // object is freed a few calls later; the crash lands nowhere near the
        // cause. `Environment.init` next door has exactly this note.
        static KP: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
        let keypath = *KP.get_or_init(|| {
            static mut SLOT: crate::keypath::IdentitySlot = crate::keypath::IdentitySlot::new();
            crate::keypath::build_identity(crate::static_mut(&raw mut SLOT), b"Si\0", b"Si\0")
        });
        swift_runtime_sys::RuntimeRaw::swift_retain(keypath as *mut c_void);

        let payload =
            Box::into_raw(Box::new(TypedIndexBuilder { builder: boxed, meta: content_meta }))
                as *mut c_void;
        let ctx = Box::leak(Box::new(abi::IndexClosureCtx::new(emit_element_view, payload)))
            as *mut abi::IndexClosureCtx;

        // `ClosedRange<Int>` is two words: lower then upper, both inclusive.
        let mut data = [start, end];
        let mut result = vec![0u8; abi::type_bytes(meta)];
        // `(sret, @in data, keypath, content fn, content ctx, Data.Type,
        //   Content.Type, Data: RandomAccessCollection WT, ID: Hashable WT,
        //   [sp] = Content: View WT)` — nine after the result, so one spills.
        core::arch::asm!(
            "sub sp, sp, #16",
            "str {cw}, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::foreach_id_init(),
            cw = in(reg) content_wt,
            in("x0") data.as_mut_ptr(),
            in("x1") keypath,
            in("x2") abi::index_closure_thunk as *const c_void,
            in("x3") ctx,
            in("x4") data_meta,
            in("x5") content_meta,
            in("x6") data_wt,
            in("x7") resolve::int_hashable_wt(),
            in("x8") result.as_mut_ptr(),
            lateout("x9") _, lateout("x10") _, lateout("x11") _, lateout("x12") _,
            lateout("x13") _, lateout("x14") _, lateout("x15") _, lateout("x16") _,
            lateout("x17") _, lateout("lr") _, lateout("x20") _, lateout("x21") _,
            clobber_abi("C"),
        );
        wrap_owned(result, meta, wt)
    }
}