swiftui-native 0.0.1

//! Views.
//!
//! * Modifiers

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

// ── Views ──

/// `LocalizedStringKey.init(stringLiteral:)`.
///
/// LocalizedStringKey is 32 bytes, so it comes back in x0-x3 — all four. x3 is
/// the `arguments` array (normally `_swiftEmptyArrayStorage`). Dropping it
/// leaves a null array inside the Text's storage, which survives construction
/// and only faults much later, when SwiftUI diffs the view and compares the two
/// argument arrays.
pub(crate) unsafe fn localized_string_key(s0: u64, s1: u64) -> (u64, u64, u64, u64) {
    let (k0, k1, k2, k3): (u64, u64, u64, u64);
    unsafe {
        core::arch::asm!("blr {f}", f = in(reg) resolve::lsk_init(),
            inout("x0") s0 => k0, inout("x1") s1 => k1,
            lateout("x2") k2, lateout("x3") k3,
            in("x20") resolve::lsk_meta(),
            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") _, clobber_abi("C"),
        );
    }
    (k0, k1, k2, k3)
}

/// Create a `Text` view.
pub fn text(s: &str) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(s);
        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);

        // Text.init(_:tableName:bundle:comment:)
        //   x0-x3 = LocalizedStringKey
        //   x4,x5 = tableName: String?   (nil)
        //   x6    = bundle: Bundle?      (nil)
        //   x7 +2 stack words = comment: StaticString?  (nil)
        //
        // `comment` spills past x7, so zero 32 bytes of stack before the call —
        // otherwise the callee reads whatever Rust happened to leave there.
        let (t0, t1, t2, t3): (u64, u64, u64, u64);
        core::arch::asm!(
            "sub sp, sp, #32",
            "stp xzr, xzr, [sp]",
            "stp xzr, xzr, [sp, #16]",
            "blr {f}",
            "add sp, sp, #32",
            f = in(reg) resolve::text_lsk_init(),
            inout("x0") k0 => t0, inout("x1") k1 => t1,
            inout("x2") k2 => t2, inout("x3") k3 => t3,
            in("x4") 0u64, in("x5") 0u64, in("x6") 0u64, in("x7") 0u64,
            in("x20") resolve::text_meta(),
            lateout("x8") _, lateout("x9") _, lateout("x10") _, lateout("x11") _,
            lateout("x12") _, lateout("x13") _, lateout("x14") _, lateout("x15") _,
            lateout("x16") _, lateout("x17") _, lateout("lr") _, clobber_abi("C"),
        );

        let mut buf = [0u8; 32];
        buf[..8].copy_from_slice(&t0.to_le_bytes());
        buf[8..16].copy_from_slice(&t1.to_le_bytes());
        buf[16..24].copy_from_slice(&t2.to_le_bytes());
        buf[24..32].copy_from_slice(&t3.to_le_bytes());
        wrap_buf(&buf, resolve::text_meta(), resolve::text_wt())
    }
}

/// Create a `Text` with font size, weight and colour applied.
pub fn styled_text(s: &str, size: f64, weight: i32, r: f64, g: f64, b: f64, a: f64) -> ViewHandle {
    let t = font(&text(s), size, weight > 0);
    foreground_style_color(&t, r, g, b, a)
}

/// Create a bold `Text` at `size` points (`size <= 0` keeps the default size).
pub fn bold_text(s: &str, size: f64) -> ViewHandle {
    let t = text(s);
    if size > 0.0 { font(&t, size, true) } else { bold(&t) }
}

/// Build a raw `SwiftUI.Color` value (8 bytes), not wrapped in `AnyView`.
///
/// Modifiers that take a `ShapeStyle` want the `Color` itself. Handing them the
/// `AnyView` wrapper instead type-checks at the ABI level — both are a single
/// class reference — and then misbehaves inside SwiftUI.
pub(crate) unsafe fn color_value(r: f64, g: f64, b: f64, a: f64) -> u64 {
    let mut cs: u8 = 0; // RGBColorSpace.sRGB
    let result: u64;
    unsafe {
        core::arch::asm!("blr {f}", f = in(reg) resolve::color_init(),
            in("x0") &mut cs as *mut u8, in("d0") r, in("d1") g, in("d2") b, in("d3") a,
            in("x20") resolve::color_meta(),
            lateout("x0") result,
            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") _, clobber_abi("C"),
        );
    }
    result
}

/// The `Color` value behind a set of components.
///
/// What [`Shape::fill`] and the other style-taking calls want: a `Color` is one
/// word once built, and building it is a call into SwiftUI rather than a
/// packing of the four numbers.
pub fn color_value_of(c: crate::Color) -> u64 {
    unsafe { color_value(c.r, c.g, c.b, c.a) }
}

/// `Color.opacity(_:)` — a `Color` with its alpha scaled.
///
/// Not the `.opacity(_:)` view modifier. That one composites the layer a view
/// drew; this one changes the colour before anything is drawn, and the two
/// differ wherever the result is clipped or blended — the antialiased edge of a
/// `clipShape` picks up a visibly different value.
pub fn color_opacity(color: u64, opacity: f64) -> u64 {
    unsafe {
        let out: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::color_opacity(),
            in("d0") opacity,
            in("x0") color,
            lateout("x0") out,
            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"),
        );
        out
    }
}

/// `Color.mix(with:by:)` — blend two colours, perceptually.
///
/// `(@guaranteed Color, Double, @in_guaranteed Gradient.ColorSpace,
/// @guaranteed Color) -> @owned Color`: the *other* colour in x0, the fraction
/// in d0, the colour space by address in x1, and the receiver in x2. Swift's
/// default for the space is `.perceptual`, from a default-argument thunk.
pub fn color_mix(color: u64, with: u64, by: f64) -> u64 {
    color_mix_in(color, with, by, super::GradientColorSpace::Perceptual)
}

/// `Color.mix(with:by:in:)` — the same blend in whichever space is named.
pub fn color_mix_in(
    color: u64,
    with: u64,
    by: f64,
    in_space: super::GradientColorSpace,
) -> u64 {
    unsafe {
        let space_meta = abi::metadata0(resolve::gradient_color_space_ma());
        assert!(!space_meta.is_null(), "Gradient.ColorSpace metadata");
        let mut space = super::static_getter_indirect(
            in_space.resolved(),
            space_meta,
            abi::type_bytes(space_meta),
        );
        let out: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::color_mix(),
            in("x0") with,
            in("d0") by,
            in("x1") space.as_mut_ptr(),
            in("x2") color,
            lateout("x0") out,
            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"),
        );
        out
    }
}

/// `Color.exposureAdjust(_:)` — brighten or darken by stops.
///
/// There is no `exposureAdjust` symbol: it is `@inlinable`, and its whole body
/// is `_linearScale(Float(exp2(ev)))` — a truncation to `Float`, a `exp2`, and
/// one call to a function that *is* exported. So this does what the inlined
/// body does, which is what `selectionDisabled` and `task` needed too.
///
/// The `Float` goes in s0, the 32-bit view of d0, and the colour in x0.
pub fn color_exposure_adjust(color: u64, stops: f64) -> u64 {
    unsafe {
        let scale = f64::exp2(stops) as f32;
        let out: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::color_linear_scale(),
            in("s0") scale,
            in("x0") color,
            lateout("x0") out,
            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"),
        );
        out
    }
}

/// `Color.headroom(_:)` — the colour's allowed brightness past white.
///
/// The `Double?` is payload then tag in x0/x1, and the colour follows in x2
/// rather than arriving in x20: like `Color.opacity`, this is an extension
/// method whose receiver is an ordinary argument.
pub fn color_headroom(color: u64, headroom: Option<f64>) -> u64 {
    unsafe {
        let (bits, tag) = match headroom {
            Some(v) => (v.to_bits(), 0u64),
            None => (0, 1),
        };
        let out: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::color_headroom(),
            in("x0") bits, in("x1") tag, in("x2") color,
            lateout("x0") out,
            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"),
        );
        out
    }
}

/// `Color.gradient` — the colour as a gentle vertical gradient.
///
/// An `AnyGradient`, not a `Color`: it is a `ShapeStyle` of its own, so it goes
/// to [`Shape::fill_style`] with its own metadata and witness table rather than
/// through the `Color` overloads. Eight bytes, so it travels in a register both
/// ways, and the receiving colour goes in x0 rather than x20.
pub fn color_gradient(color: u64) -> (Vec<u8>, *const c_void, *const c_void) {
    unsafe {
        let out: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::color_gradient(),
            in("x0") color,
            lateout("x0") out,
            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"),
        );
        (out.to_le_bytes().to_vec(), resolve::any_gradient_meta(), resolve::any_gradient_wt())
    }
}

/// Create a view of a `Color` value that is already built.
pub fn color_view(color: u64) -> ViewHandle {
    unsafe {
        let buf = color.to_le_bytes();
        wrap_buf(&buf, resolve::color_meta(), resolve::color_wt())
    }
}

/// Create a `Color` view.
pub fn color(r: f64, g: f64, b: f64, a: f64) -> ViewHandle {
    unsafe {
        let buf = color_value(r, g, b, a).to_le_bytes();
        wrap_buf(&buf, resolve::color_meta(), resolve::color_wt())
    }
}

/// Create a `Spacer`.
pub fn spacer() -> ViewHandle {
    unsafe {
        let r0: u64; let r1: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::spacer_init(),
            // `Optional<CGFloat>` is a Double plus a tag byte, both loadable:
            // payload in x0, tag in x1. Tag 0 is `.some`, so `.none` needs 1 —
            // with 0 the spacer is built with an explicit `minLength` of zero,
            // which lays out identically and is a different value.
            in("x0") 0u64, in("x1") 1u64, // Optional<CGFloat>.none
            in("x20") resolve::spacer_meta(),
            lateout("x0") r0, lateout("x1") r1,
            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") _, clobber_abi("C"),
        );
        let mut buf = [0u8; 16];
        buf[..8].copy_from_slice(&r0.to_le_bytes());
        buf[8..16].copy_from_slice(&r1.to_le_bytes());
        wrap_buf(&buf, resolve::spacer_meta(), resolve::spacer_wt())
    }
}

/// `Edge.Set.all` — one bit per edge.
///
/// The raw value is an `Int8`, and only the low four bits are edges. Setting
/// the rest (`0xFF`) still reads as "every edge" everywhere it is used, so it
/// lays out identically; it just is not the value Swift writes, and prints as
/// `rawValue: -1` instead of `15`.
pub(crate) const EDGE_SET_ALL: u64 = 0b1111;

/// Create an `EmptyView`.
pub fn empty_view() -> ViewHandle {
    unsafe { ViewHandle::wrap(core::ptr::null(), resolve::empty_meta(), resolve::empty_wt()) }
}

/// Create a `Divider`.
pub fn divider() -> ViewHandle {
    unsafe { ViewHandle::wrap(core::ptr::null(), resolve::divider_meta(), resolve::divider_wt()) }
}

/// Create an `Image` from an SF Symbol name.
pub fn system_image(name: &str) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(name);
        let s0 = u64::from_le_bytes(ss[..8].try_into().unwrap());
        let s1 = u64::from_le_bytes(ss[8..].try_into().unwrap());
        let result: u64;
        core::arch::asm!("blr {f}", f = in(reg) resolve::image_sysname_init(),
            in("x0") s0, in("x1") s1, in("x20") resolve::image_meta(),
            lateout("x0") result,
            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") _, clobber_abi("C"),
        );
        let buf = result.to_le_bytes();
        wrap_buf(&buf, resolve::image_meta(), resolve::image_wt())
    }
}

mangle::result_types! {
    /// `SwiftUI.ProgressView<SwiftUI.EmptyView, SwiftUI.EmptyView>`
    /// `ProgressView<EmptyView, EmptyView>`
    pub(crate) PROGRESS_T = ty("ProgressView").of(vec![ty("EmptyView"), ty("EmptyView")]);
    /// `SwiftUI.Toggle<SwiftUI.Text>`
    /// `Toggle<Text>`
    pub(crate) TOGGLE_T = ty("Toggle").of(vec![ty("Text")]);
    /// `Toggle<AnyView>` — a toggle whose label is any view.
    pub(crate) TOGGLE_ANY_T = ty("Toggle").of(vec![ty("AnyView")]);
    /// `SwiftUI.TextField<SwiftUI.Text>`
    /// `TextField<Text>`
    pub(crate) TEXTFIELD_T = ty("TextField").of(vec![ty("Text")]);
    /// `SwiftUI.SecureField<SwiftUI.Text>`
    /// `SecureField<Text>`
    pub(crate) SECUREFIELD_T = ty("SecureField").of(vec![ty("Text")]);
    /// `SwiftUI.Slider<SwiftUI.EmptyView, SwiftUI.EmptyView>`
    /// `Slider<EmptyView, EmptyView>`
    pub(crate) SLIDER_T = ty("Slider").of(vec![ty("EmptyView"), ty("EmptyView")]);
}

/// Create an indeterminate `ProgressView` — the spinner, with no value.
///
/// `ProgressView()` is not `progress(0, 1)`: it is a different initialiser
/// whose `Label` and `CurrentValueLabel` are both `EmptyView`, and it is the
/// one every `ProgressView()` in the documentation means.
pub fn progress_indeterminate() -> ViewHandle {
    unsafe {
        let ty = mangle::ty("ProgressView")
            .of(vec![mangle::ty("EmptyView"), mangle::ty("EmptyView")])
            .mangle();
        let meta = abi::resolve_type_by_mangled_name(ty.as_bytes());
        assert!(!meta.is_null(), "ProgressView<EmptyView, EmptyView> metadata");
        let mut value = vec![0u8; abi::type_bytes(meta)];
        core::arch::asm!("blr {f}", f = in(reg) resolve::progress_indeterminate_init(),
            in("x8") value.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"),
        );
        let wt = abi::get_view_wt(meta);
        assert!(!wt.is_null(), "ProgressView !: View");
        wrap_buf(&value, meta, wt)
    }
}

/// Create a determinate `ProgressView`.
pub fn progress(value: f64, total: f64) -> ViewHandle {
    unsafe {
        // The initialiser is generic over `V: BinaryFloatingPoint`, so both
        // arguments are passed *indirectly* even though Double is loadable.
        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 opt_meta = abi::resolve_type_by_mangled_name(mangle::optional(mangle::DOUBLE).as_bytes());
        assert!(!opt_meta.is_null(), "Optional<Double> metadata");
        let mut value_buf = vec![0u8; abi::type_bytes(opt_meta)];
        value_buf[..8].copy_from_slice(&value.to_le_bytes());
        abi::store_optional_tag(&mut value_buf, double_meta, true);

        let mut total_buf = total.to_le_bytes();

        let (meta, wt, size) = result_type(&PROGRESS_T);
        let mut result = vec![0u8; size];
        // ProgressView.init(value:total:)
        //   x0 = @in Optional<V>, x1 = @in V,
        //   x2 = V.Type, x3 = V: BinaryFloatingPoint WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::progress_init(),
            in("x0") value_buf.as_mut_ptr(),
            in("x1") total_buf.as_mut_ptr(),
            in("x2") double_meta,
            in("x3") bfp_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)
    }
}



/// Build `Binding.constant(_:)` for a value of the given type.
///
/// A constant binding is enough to render: the displayed state is whatever the
/// getter returns right now, and Rust drives changes by rebuilding the tree and
/// calling [`crate::HostingView::set_root`].
pub(crate) unsafe fn constant_binding(
    value: &[u8],
    value_meta: *const c_void,
    binding_mangled: &[u8],
) -> Vec<u8> {
    unsafe {
        let binding_meta = abi::resolve_type_by_mangled_name(binding_mangled);
        assert!(!binding_meta.is_null(), "Binding metadata");
        let mut val = value.to_vec();
        let mut out = vec![0u8; abi::type_bytes(binding_meta)];
        // static Binding.constant(_: Value) -> Binding<Value>
        //   x0 = @in Value, x1 = Value.Type, x8 = @out Binding
        //
        // `Value` arrives as an ordinary generic argument in x1 — not through
        // the self register, even though this is a static method.
        core::arch::asm!("blr {f}", f = in(reg) resolve::binding_constant(),
            in("x0") val.as_mut_ptr(),
            in("x1") value_meta,
            in("x8") out.as_mut_ptr(),
            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"),
        );
        let _ = binding_meta;
        out
    }
}

/// Create a `Toggle` with a text label.
pub fn toggle(label: &str, is_on: bool) -> 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 binding = constant_binding(&[u8::from(is_on)], resolve::sym(c"$sSbN"), mangle::bound(&swift_type!(SwiftUI.Binding), &[mangle::BOOL]).as_bytes());
        // Binding<Bool> is 17 bytes, so it occupies three registers.
        let b0 = u64::from_le_bytes(binding[0..8].try_into().unwrap());
        let b1 = u64::from_le_bytes(binding[8..16].try_into().unwrap());
        let b2 = binding[16] as u64;

        let (meta, wt, size) = result_type(&TOGGLE_T);
        let mut result = vec![0u8; size];
        // Toggle<Text>.init(_: LocalizedStringKey, isOn: Binding<Bool>)
        //   x0-x3 = key, x4-x6 = binding, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::toggle_init(),
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") b0, in("x5") b1, in("x6") b2,
            in("x8") result.as_mut_ptr(),
            in("x20") meta,
            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)
    }
}





/// A closure that does nothing, for callbacks the Rust API does not expose.
/// Paired with a null context, which Swift retains and releases harmlessly.
pub(crate) unsafe extern "C" fn noop_closure() {}

/// Build `Binding<String>.constant(_:)` and return its four words.
pub(crate) unsafe fn string_binding(value: &str) -> [u64; 4] {
    unsafe {
        let ss = abi::swift_string(value);
        let b = constant_binding(&ss, resolve::string_meta_sym(), mangle::bound(&swift_type!(SwiftUI.Binding), &[mangle::STRING]).as_bytes());
        binding_words(&b)
    }
}

/// The four words of a `Binding<String>` built by [`super::text_binding`].
///
/// `Binding` caches its value inline, so `Binding<String>` is 32 bytes and
/// travels in x4–x7 rather than indirectly.
pub(crate) fn binding_words(b: &[u8]) -> [u64; 4] {
    let mut w = [0u64; 4];
    for (i, slot) in w.iter_mut().enumerate() {
        *slot = u64::from_le_bytes(b[i * 8..i * 8 + 8].try_into().expect("binding word"));
    }
    w
}

/// Create a `TextField` showing a fixed string, which the user cannot edit.
///
/// The string becomes a `Binding.constant` and SwiftUI treats that as
/// read-only: keystrokes have nowhere to be written, so the field ignores them.
/// [`textfield_bound`] is the one that can be typed into.
pub fn textfield(placeholder: &str, value: &str) -> ViewHandle {
    unsafe { textfield_with_binding(placeholder, &string_binding(value)) }
}

/// Create a `TextField` wired to Rust state — typing writes into `state`.
pub fn textfield_bound(placeholder: &str, state: &super::BoundState<String>) -> ViewHandle {
    unsafe { textfield_with_binding(placeholder, &binding_words(&super::text_binding(state))) }
}

/// Shared tail of [`textfield`] and [`textfield_bound`].
unsafe fn textfield_with_binding(placeholder: &str, b: &[u64; 4]) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(placeholder);
        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 (meta, wt, size) = result_type(&TEXTFIELD_T);
        let mut result = vec![0u8; size];
        let noop = noop_closure as *const c_void;
        // TextField.init(_:text:onEditingChanged:onCommit:)
        //   x0-x3 = key, x4-x7 = Binding<String>,
        //   [sp] = onEditingChanged (fn, ctx), [sp+16] = onCommit (fn, ctx)
        core::arch::asm!(
            "sub sp, sp, #32",
            "stp {n}, xzr, [sp]",
            "stp {n}, xzr, [sp, #16]",
            "blr {f}",
            "add sp, sp, #32",
            f = in(reg) resolve::textfield_init(),
            n = in(reg) noop,
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") b[0], in("x5") b[1], in("x6") b[2], in("x7") b[3],
            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 `TextField` that grows along `axis` as it is typed into.
///
/// `.vertical` is the multi-line field — the one that starts a line high and
/// adds rows as text wraps, which is what a comment box or a note is. Only the
/// deprecated `onEditingChanged:onCommit:` initialiser was bound, so every
/// field was one line whatever went in it.
pub fn textfield_axis(
    placeholder: &str,
    state: &super::BoundState<String>,
    axis: super::Axis,
) -> ViewHandle {
    unsafe {
        let b = binding_words(&super::text_binding(state));
        let ss = abi::swift_string(placeholder);
        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 (meta, wt, size) = result_type(&TEXTFIELD_T);
        let mut result = vec![0u8; size];
        // TextField.init(_:text:axis:)
        //   x0-x3 = key, x4-x7 = Binding<String>, and `Axis` — a frozen
        //   two-case enum, so one byte — has no register left and goes on the
        //   stack.
        core::arch::asm!(
            "sub sp, sp, #16",
            "str {a}, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::textfield_axis_init(),
            a = in(reg) axis as u64,
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") b[0], in("x5") b[1], in("x6") b[2], in("x7") b[3],
            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 `SecureField` showing a fixed string, which the user cannot edit.
/// See [`securefield_bound`].
pub fn securefield(placeholder: &str, value: &str) -> ViewHandle {
    unsafe { securefield_with_binding(placeholder, &string_binding(value)) }
}

/// Create a `SecureField` wired to Rust state — typing writes into `state`.
pub fn securefield_bound(placeholder: &str, state: &super::BoundState<String>) -> ViewHandle {
    unsafe { securefield_with_binding(placeholder, &binding_words(&super::text_binding(state))) }
}

/// Shared tail of [`securefield`] and [`securefield_bound`].
unsafe fn securefield_with_binding(placeholder: &str, b: &[u64; 4]) -> ViewHandle {
    unsafe {
        let ss = abi::swift_string(placeholder);
        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 (meta, wt, size) = result_type(&SECUREFIELD_T);
        let mut result = vec![0u8; size];
        let noop = noop_closure as *const c_void;
        // SecureField.init(_:text:onCommit:) — one trailing closure on the stack
        core::arch::asm!(
            "sub sp, sp, #16",
            "stp {n}, xzr, [sp]",
            "blr {f}",
            "add sp, sp, #16",
            f = in(reg) resolve::securefield_init(),
            n = in(reg) noop,
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") b[0], in("x5") b[1], in("x6") b[2], in("x7") b[3],
            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 `Slider` over a closed range.
pub fn slider(value: f64, lower: f64, upper: 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(),
        );
        slider_with_binding(&mut binding, lower, upper)
    }
}

/// Shared tail of [`slider`] and `slider_bound`.
///
/// # Safety
/// `binding` must be a `Binding<Double>`.
pub(crate) unsafe fn slider_with_binding(
    binding: &mut [u8],
    lower: f64,
    upper: f64,
) -> 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 range = [0u8; 16];
        range[..8].copy_from_slice(&lower.to_le_bytes());
        range[8..].copy_from_slice(&upper.to_le_bytes());

        let (meta, wt, size) = result_type(&SLIDER_T);
        let mut result = vec![0u8; size];
        // Slider.init(value:in:onEditingChanged:)
        //   x0 = @in Binding<V>, x1 = @in ClosedRange<V>,
        //   x2 = closure fn, x3 = closure ctx,
        //   x4 = V.Type, x5 = V: BinaryFloatingPoint WT,
        //   x6 = V.Stride: BinaryFloatingPoint WT, x8 = @out
        //
        // `V` is generic, so both the binding and the range arrive by pointer
        // even though Double is loadable.
        core::arch::asm!("blr {f}", f = in(reg) resolve::slider_init(),
            in("x0") binding.as_mut_ptr(),
            in("x1") range.as_mut_ptr(),
            in("x2") noop_closure as *const c_void,
            in("x3") 0u64,
            in("x4") double_meta,
            in("x5") bfp_wt,
            in("x6") bfp_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)
    }
}

/// The same, snapping to multiples of `step`.
///
/// A slider that moves continuously is the right control for a volume; one that
/// picks a rating out of five is not, and there was no way to ask for the
/// second. `step` is `V.Stride` — an *associated* type, so it travels by
/// address like the binding and the range, even though it is a `Double` by the
/// time it gets there.
///
/// # Safety
/// `binding` must be a live `Binding<Double>`.
pub(crate) unsafe fn slider_step_with_binding(
    binding: &mut [u8],
    lower: f64,
    upper: f64,
    step: f64,
) -> 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 range = [0u8; 16];
        range[..8].copy_from_slice(&lower.to_le_bytes());
        range[8..].copy_from_slice(&upper.to_le_bytes());
        let mut step_bytes = step.to_le_bytes();

        let (meta, wt, size) = result_type(&SLIDER_T);
        let mut result = vec![0u8; size];
        // Slider.init(value:in:step:onEditingChanged:)
        //   x0 = @in Binding<V>, x1 = @in ClosedRange<V>, x2 = @in V.Stride,
        //   x3 = closure fn, x4 = closure ctx, x5 = V.Type,
        //   x6 = V: BinaryFloatingPoint WT,
        //   x7 = V.Stride: BinaryFloatingPoint WT, x8 = @out
        core::arch::asm!("blr {f}", f = in(reg) resolve::slider_step_init(),
            in("x0") binding.as_mut_ptr(),
            in("x1") range.as_mut_ptr(),
            in("x2") step_bytes.as_mut_ptr(),
            in("x3") noop_closure as *const c_void,
            in("x4") 0u64,
            in("x5") double_meta,
            in("x6") bfp_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)
    }
}

// ── Modifiers ──

/// Apply `.padding(_:)`.
pub fn padding(view: &ViewHandle, amount: f64) -> ViewHandle {
    unsafe {
        // Sized from the composed result type, not a constant. While every
        // receiver was a one-word `AnyView` a fixed 64 was always big enough;
        // against a concrete receiver the result grows with it.
        let (_, _, size) = PADDING_T.applied_to(view.meta);
        let result = abi::call_modifier_d0(
            resolve::padding_fn(), view.value_ptr(), view.meta, view.wt, amount, size);
        wrap_modified(result, &PADDING_T, view)
    }
}

/// Apply `.opacity(_:)`.
pub fn opacity(view: &ViewHandle, value: f64) -> ViewHandle {
    unsafe {
        let (_, _, size) = OPACITY_T.applied_to(view.meta);
        let result = abi::call_modifier_d0(
            resolve::opacity_fn(), view.value_ptr(), view.meta, view.wt, value, size);
        wrap_modified(result, &OPACITY_T, view)
    }
}

/// Apply `.frame(width:height:)`, centred.
pub fn frame(view: &ViewHandle, width: f64, height: f64) -> ViewHandle {
    frame_aligned(view, width, height, super::Alignment::Center)
}

/// Apply `.frame(width:height:alignment:)`.
pub fn frame_aligned(
    view: &ViewHandle,
    width: f64,
    height: f64,
    alignment: super::Alignment,
) -> ViewHandle {
    frame_optional(view, Some(width), Some(height), alignment)
}

/// Apply `.frame(width:height:alignment:)` with either dimension left out.
///
/// `frame(height: 100)` is not `frame(width: 0, height: 100)` — an omitted
/// dimension means "take what the parent offers", and the `Optional<CGFloat>`
/// carries that in its tag: payload then tag, 0 for `.some` and 1 for `.none`.
pub fn frame_optional(
    view: &ViewHandle,
    width: Option<f64>,
    height: Option<f64>,
    alignment: super::Alignment,
) -> ViewHandle {
    unsafe {
        let self_storage = view.value_ptr();
        let (_, _, size) = FRAME_T.applied_to(view.meta);
        let mut result = vec![0u8; size];

        // Alignment is 16 bytes — `.center` is (horizontal, vertical) = (2, 5).
        // Passing only the first word leaves vertical alignment as 0, which is
        // not a valid AlignmentID and traps inside FrameLayoutCommon at layout
        // time rather than here.
        let [align_h, align_v] = alignment.words();

        // frame(width:height:alignment:)
        //   x0 = width payload,  x1 = width tag  (0 = some)
        //   x2 = height payload, x3 = height tag (0 = some)
        //   x4, x5 = alignment
        //   x6 = Self.Type, x7 = Self: View WT, x8 = @out, x20 = self
        core::arch::asm!("blr {func}",
            func = in(reg) resolve::frame_fn(),
            in("x0") width.map_or(0, f64::to_bits),
            in("x1") u64::from(width.is_none()),
            in("x2") height.map_or(0, f64::to_bits),
            in("x3") u64::from(height.is_none()),
            in("x4") align_h,
            in("x5") align_v,
            in("x6") view.meta,
            in("x7") view.wt,
            in("x8") result.as_mut_ptr(),
            in("x20") self_storage,
            lateout("x9") _, lateout("x10") _, lateout("x11") _,
            lateout("x12") _, lateout("x13") _, lateout("x14") _, lateout("x15") _,
            lateout("x16") _, lateout("x17") _, lateout("lr") _,
            clobber_abi("C"),
        );
        wrap_modified(result, &FRAME_T, view)
    }
}

/// Apply `.background(_:)` with a Color.
pub fn background(view: &ViewHandle, r: f64, g: f64, b: f64, a: f64) -> ViewHandle {
    unsafe {
        let func = resolve::bg_fn();
        let self_storage = view.value_ptr();
        let mut color_storage: u64 = color_value(r, g, b, a);
        let (_, _, size) = BG_T.applied_to(view.meta);
        let mut result = vec![0u8; size];
        // ASM: x0=@in style, x1=Edge.Set, x2=Self.Type, x3=S.Type, x4=Self:View WT, x5=S:ShapeStyle WT
        //      x8=result, x20=self
        core::arch::asm!("blr {func}",
            func = in(reg) func,
            in("x0") &mut color_storage as *mut u64, // @in Color
            in("x1") EDGE_SET_ALL,                   // ignoresSafeAreaEdges: .all
            in("x2") view.meta,                       // Self.Type
            in("x3") resolve::color_meta(),           // S.Type (Color)
            in("x4") view.wt,                         // Self:View WT
            in("x5") resolve::color_shapestyle_wt(),  // S:ShapeStyle WT
            in("x8") result.as_mut_ptr(),
            in("x20") self_storage,
            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") _, clobber_abi("C"),
        );
        wrap_modified(result, &BG_T, view)
    }
}

/// Apply `.cornerRadius(_:)`.
pub fn corner_radius(view: &ViewHandle, radius: f64) -> ViewHandle {
    unsafe {
        let (_, _, size) = CORNER_T.applied_to(view.meta);
        let mut result = vec![0u8; size];
        let self_storage = view.value_ptr();
        // cornerRadius(_:antialiased:)
        //   d0 = radius, x0 = antialiased, x1 = Self.Type, x2 = Self: View WT,
        //   x8 = @out, x20 = self
        core::arch::asm!("blr {f}", f = in(reg) resolve::corner_radius_fn(),
            in("d0") radius,
            in("x0") 1u64,
            in("x1") view.meta,
            in("x2") view.wt,
            in("x8") result.as_mut_ptr(),
            in("x20") self_storage,
            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"),
        );
        wrap_modified(result, &CORNER_T, view)
    }
}

/// Apply `.border(_:width:)`.
/// Apply `.border(_:width:)` with colour components.
///
/// **Opaque.** There is no alpha parameter and the colour is built at 1.0, so a
/// translucent border is not expressible here — use [`border_value`] with a
/// colour that carries its own alpha. The chainable `View::border` does.
pub fn border(view: &ViewHandle, r: f64, g: f64, b: f64, width: f64) -> ViewHandle {
    unsafe { border_value(view, color_value(r, g, b, 1.0), width) }
}

/// Apply `.border(_:width:)` with a `Color` that is already built.
///
/// For one of SwiftUI's named colours: `Color.gray` is semantic and no set of
/// components spells it. See [`system_color`].
pub fn border_value(view: &ViewHandle, color: u64, width: f64) -> ViewHandle {
    unsafe {
        let c = color;
        let (_, _, size) = BORDER_T.applied_to(view.meta);
        let mut result = vec![0u8; size];
        let self_storage = view.value_ptr();
        let mut style: u64 = c;
        // border<S: ShapeStyle>(_:width:)
        //   x0 = @in style, d0 = width, x1 = Self.Type, x2 = S.Type,
        //   x3 = Self: View WT, x4 = S: ShapeStyle WT, x8 = @out, x20 = self
        core::arch::asm!("blr {f}", f = in(reg) resolve::border_fn(),
            in("x0") &mut style as *mut u64,
            in("d0") width,
            in("x1") view.meta,
            in("x2") resolve::color_meta(),
            in("x3") view.wt,
            in("x4") resolve::color_shapestyle_wt(),
            in("x8") result.as_mut_ptr(),
            in("x20") self_storage,
            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_modified(result, &BORDER_T, view)
    }
}

swift_statics! {
    /// One of SwiftUI's own named colours.
    ///
    /// These are not RGB triples, which is the trap. `Color.blue` is a semantic
    /// system colour that resolves through the current appearance; under aqua
    /// it is around `(0, 0.48, 1)`, nowhere near the literal `(0, 0, 1)` a
    /// constant in this crate spells. Building a colour from components and
    /// calling it blue renders a visibly different blue — close enough to look
    /// right on its own and wrong beside the real thing.
    pub enum SystemColor {
        Red = c"$s7SwiftUI5ColorV3redACvgZ",
        Orange = c"$s7SwiftUI5ColorV6orangeACvgZ",
        Yellow = c"$s7SwiftUI5ColorV6yellowACvgZ",
        Green = c"$s7SwiftUI5ColorV5greenACvgZ",
        Mint = c"$s7SwiftUI5ColorV4mintACvgZ",
        Teal = c"$s7SwiftUI5ColorV4tealACvgZ",
        Cyan = c"$s7SwiftUI5ColorV4cyanACvgZ",
        Blue = c"$s7SwiftUI5ColorV4blueACvgZ",
        Indigo = c"$s7SwiftUI5ColorV6indigoACvgZ",
        // `accentColor` mangles `06accentC0` — the `C` substitutes `Color` from
        // earlier in the symbol, so the name never appears spelled out.
        Accent = c"$s7SwiftUI5ColorV06accentC0ACvgZ",
        Purple = c"$s7SwiftUI5ColorV6purpleACvgZ",
        Pink = c"$s7SwiftUI5ColorV4pinkACvgZ",
        Brown = c"$s7SwiftUI5ColorV5brownACvgZ",
        White = c"$s7SwiftUI5ColorV5whiteACvgZ",
        Gray = c"$s7SwiftUI5ColorV4grayACvgZ",
        Black = c"$s7SwiftUI5ColorV5blackACvgZ",
        Clear = c"$s7SwiftUI5ColorV5clearACvgZ",
        Primary = c"$s7SwiftUI5ColorV7primaryACvgZ",
        Secondary = c"$s7SwiftUI5ColorV9secondaryACvgZ",
    }
}

/// The value behind one of SwiftUI's named colours.
///
/// A `Color` is one word, so the static getter returns it in x0 with the
/// metatype in x20 — no indirect result and no copy.
pub fn system_color_value(c: SystemColor) -> u64 {
    unsafe { abi::static_regs(resolve::sym(c.getter()), resolve::color_meta())[0] }
}

/// Create a view of one of SwiftUI's named colours.
pub fn system_color(c: SystemColor) -> ViewHandle {
    unsafe {
        let buf = system_color_value(c).to_le_bytes();
        wrap_buf(&buf, resolve::color_meta(), resolve::color_wt())
    }
}

/// Apply `.frame(maxWidth:maxHeight:alignment:)` with `.infinity` for both.
///
/// Six `Optional<CGFloat>`s — min, ideal and max for each axis — then an
/// `Alignment`, then the two generic words. Each optional is payload and tag,
/// so that is sixteen words in all: x0 through x7 carry the first four
/// optionals and the remaining eight go on the stack. The generic arguments
/// come *after* every formal parameter, which is what makes them spill; putting
/// them in x6 and x7 builds a frame out of the metadata pointers.
pub fn frame_max_infinity(view: &ViewHandle, alignment: super::Alignment) -> ViewHandle {
    unsafe {
        let (meta, wt, size) = super::opaque_result_type(
            resolve::frame_flexible_oret(),
            &[view.meta, view.wt],
        );
        let mut result = vec![0u8; size];
        let this = view.value_ptr();
        let [ah, av] = alignment.words();
        let inf = f64::INFINITY.to_bits();
        // Eight words on the stack, stored from registers rather than copied
        // from an array: `sub sp` moves the stack pointer out from under any
        // operand Rust might have materialised relative to it, and the crate's
        // other spilling call sites all do it this way.
        core::arch::asm!(
            "sub sp, sp, #64",
            "stp {a}, {b}, [sp]",
            "stp {c}, {d}, [sp, #16]",
            "stp {e}, {g}, [sp, #32]",
            "stp {h}, {i}, [sp, #48]",
            "blr {f}",
            "add sp, sp, #64",
            f = in(reg) resolve::frame_flexible_fn(),
            a = in(reg) 0u64,  b = in(reg) 1u64,   // idealHeight = nil
            c = in(reg) inf,   d = in(reg) 0u64,   // maxHeight = .infinity
            e = in(reg) ah,    g = in(reg) av,     // alignment
            h = in(reg) view.meta,
            i = in(reg) view.wt,
            in("x0") 0u64, in("x1") 1u64,      // minWidth = nil
            in("x2") 0u64, in("x3") 1u64,      // idealWidth = nil
            in("x4") inf,  in("x5") 0u64,      // maxWidth = .infinity
            in("x6") 0u64, in("x7") 1u64,      // minHeight = nil
            in("x8") result.as_mut_ptr(),
            in("x20") this,
            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)
    }
}

/// Apply `.frame(maxWidth: .infinity)` — the *width* only.
///
/// Not [`frame_max_infinity`], which sets both axes. Swift's
/// `.frame(maxWidth: .infinity)` leaves `maxHeight` nil, so the view keeps its
/// content's height; setting both stretched a card to fill its canvas and moved
/// everything in it.
///
/// Six `Optional<CGFloat>`s — min, ideal and max for each axis — then an
/// `Alignment`, then the two generic words. Each optional is payload and tag,
/// so that is sixteen words in all: x0 through x7 carry the first four
/// optionals and the remaining eight go on the stack. The generic arguments
/// come *after* every formal parameter, which is what makes them spill; putting
/// them in x6 and x7 builds a frame out of the metadata pointers.
pub fn frame_max_width(view: &ViewHandle, alignment: super::Alignment) -> ViewHandle {
    unsafe {
        let (meta, wt, size) = super::opaque_result_type(
            resolve::frame_flexible_oret(),
            &[view.meta, view.wt],
        );
        let mut result = vec![0u8; size];
        let this = view.value_ptr();
        let [ah, av] = alignment.words();
        let inf = f64::INFINITY.to_bits();
        // Eight words on the stack, stored from registers rather than copied
        // from an array: `sub sp` moves the stack pointer out from under any
        // operand Rust might have materialised relative to it, and the crate's
        // other spilling call sites all do it this way.
        core::arch::asm!(
            "sub sp, sp, #64",
            "stp {a}, {b}, [sp]",
            "stp {c}, {d}, [sp, #16]",
            "stp {e}, {g}, [sp, #32]",
            "stp {h}, {i}, [sp, #48]",
            "blr {f}",
            "add sp, sp, #64",
            f = in(reg) resolve::frame_flexible_fn(),
            a = in(reg) 0u64,  b = in(reg) 1u64,   // idealHeight = nil
            c = in(reg) 0u64,  d = in(reg) 1u64,   // maxHeight = nil
            e = in(reg) ah,    g = in(reg) av,     // alignment
            h = in(reg) view.meta,
            i = in(reg) view.wt,
            in("x0") 0u64, in("x1") 1u64,      // minWidth = nil
            in("x2") 0u64, in("x3") 1u64,      // idealWidth = nil
            in("x4") inf,  in("x5") 0u64,      // maxWidth = .infinity
            in("x6") 0u64, in("x7") 1u64,      // minHeight = nil
            in("x8") result.as_mut_ptr(),
            in("x20") this,
            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)
    }
}

/// `TextEditor(text:)` — a multi-line editable field.
///
/// The whole argument list is one `Binding<String>`, which is four words and
/// travels in x0 through x3.
pub fn text_editor(value: &str) -> ViewHandle {
    unsafe {
        let b = string_binding(value);
        let (meta, wt, size) = result_type(&TEXT_EDITOR_T);
        let mut result = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) resolve::text_editor_init(),
            in("x0") b[0], in("x1") b[1], in("x2") b[2], in("x3") b[3],
            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)
    }
}

/// `Link(_:destination:)` — a label that opens a URL.
///
/// A `LocalizedStringKey` in x0 through x3, then the `URL` by address. The
/// crate builds URLs as `Optional<URL>` because that is what `init?(string:)`
/// returns; a `.some` keeps its payload at offset zero, so the same buffer
/// serves where a bare `URL` is wanted.
pub fn link(title: &str, destination: &str) -> 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) = localized_string_key(s0, s1);
        let mut url = super::optional_url(Some(destination));

        let (meta, wt, size) = result_type(&LINK_T);
        let mut result = vec![0u8; size];
        core::arch::asm!("blr {f}", f = in(reg) resolve::link_init(),
            in("x0") k0, in("x1") k1, in("x2") k2, in("x3") k3,
            in("x4") url.as_mut_ptr(),
            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)
    }
}

/// `.opacity(_:)`, taking `Color`'s own overload when the receiver is a `Color`.
///
/// `Color.opacity(_:)` returns `Color` — the same shape as `Text.bold()` and
/// `Image.resizable()`, and the reason Apple's `Color.primary.opacity(0.1)`
/// types as a plain `Color` where the `View` extension gives
/// `ModifiedContent<Color, _OpacityEffect>`. Both render identically; only one
/// is the type the listing has.
pub fn view_opacity(view: &ViewHandle, value: f64) -> ViewHandle {
    if crate::diag::type_name(view.meta) != "SwiftUI.Color" {
        return opacity(view, value);
    }
    unsafe {
        // A `Color` is one reference, so its value is one word.
        let word = (view.value_ptr() as *const u64).read_unaligned();
        let faded = color_opacity(word, value);
        wrap_buf(&faded.to_le_bytes(), view.meta, view.wt)
    }
}

/// One piece of an interpolated `Text`.
#[derive(Clone, Copy, Debug)]
pub enum TextPart<'a> {
    /// Literal text, kept as a literal segment of the key.
    Literal(&'a str),
    /// A value interpolated with `%lld`, the specifier Swift uses for `Int`.
    Int(i64),
    /// A value interpolated with `%lf`, Swift's specifier for `Double`.
    Double(f64),
    /// A string, through the overload that takes one whole.
    ///
    /// Not a specifier: `appendInterpolation(_ string: String)` is its own
    /// method, and the value goes in as text rather than as a placeholder a
    /// translation could reorder.
    Str(&'a str),
}

/// Anything that can be interpolated into a [`text_interpolated`].
///
/// So a caller writes the value and not the variant — and so [`crate::ltext!`]
/// can accept whatever the format string was given.
pub trait Interpolatable {
    /// This value as a part.
    fn as_part(&self) -> TextPart<'_>;
}

impl Interpolatable for i64 {
    fn as_part(&self) -> TextPart<'_> {
        TextPart::Int(*self)
    }
}

impl Interpolatable for i32 {
    fn as_part(&self) -> TextPart<'_> {
        TextPart::Int(i64::from(*self))
    }
}

impl Interpolatable for usize {
    fn as_part(&self) -> TextPart<'_> {
        TextPart::Int(*self as i64)
    }
}

impl Interpolatable for f64 {
    fn as_part(&self) -> TextPart<'_> {
        TextPart::Double(*self)
    }
}

impl Interpolatable for str {
    fn as_part(&self) -> TextPart<'_> {
        TextPart::Str(self)
    }
}

impl Interpolatable for String {
    fn as_part(&self) -> TextPart<'_> {
        TextPart::Str(self)
    }
}

impl<T: Interpolatable + ?Sized> Interpolatable for &T {
    fn as_part(&self) -> TextPart<'_> {
        (**self).as_part()
    }
}

/// `Text("Item \(i)")` — a `Text` built through SwiftUI's own interpolation.
///
/// [`text()`] takes a Rust `String` and hands SwiftUI a *literal* key. That draws
/// the same pixels, and it is a different value: an interpolated
/// `LocalizedStringKey` keeps its literal segments and its arguments apart,
/// with a format specifier for each, which is what lets a translation reorder
/// them. Formatting in Rust throws that structure away before SwiftUI sees it.
///
/// ```no_run
/// # use swiftui_native::views::{self, TextPart};
/// // The same value `Text("Item \(i)")` builds.
/// views::text_interpolated(&[TextPart::Literal("Item "), TextPart::Int(3)]);
/// ```
pub fn text_interpolated(parts: &[TextPart<'_>]) -> ViewHandle {
    unsafe {
        let meta = abi::resolve_type_by_mangled_name(b"7SwiftUI18LocalizedStringKeyV0D13InterpolationV");
        assert!(!meta.is_null(), "LocalizedStringKey.StringInterpolation metadata");

        // The two hints Swift passes. Only the literal segments count towards
        // the capacity; everything interpolated is an argument, whatever its
        // type, and counts towards the other number.
        let literal_capacity: i64 = parts
            .iter()
            .map(|p| match p {
                TextPart::Literal(s) => s.len() as i64,
                _ => 0,
            })
            .sum();
        let interpolation_count = parts
            .iter()
            .filter(|p| !matches!(p, TextPart::Literal(_)))
            .count() as i64;

        let mut interp = vec![0u8; abi::type_bytes(meta)];
        // `init(literalCapacity:interpolationCount:)` — the two numbers are a
        // hint for the buffer, not a constraint, but Swift passes the real
        // ones and a value comparison notices the difference.
        core::arch::asm!("blr {f}", f = in(reg) resolve::lsk_interp_init(),
            in("x0") literal_capacity,
            in("x1") interpolation_count,
            in("x8") interp.as_mut_ptr(),
            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"),
        );

        for part in parts {
            match *part {
                TextPart::Literal(s) => {
                    let ss = abi::swift_string(s);
                    let w0 = u64::from_le_bytes(ss[..8].try_into().expect("lo"));
                    let w1 = u64::from_le_bytes(ss[8..].try_into().expect("hi"));
                    // `appendLiteral(_: String)`: the string in x0/x1 and the
                    // interpolation as `inout self` in x20.
                    core::arch::asm!("blr {f}", f = in(reg) resolve::lsk_append_literal(),
                        in("x0") w0, in("x1") w1,
                        in("x20") interp.as_mut_ptr(),
                        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"),
                    );
                }
                TextPart::Str(text) => {
                    let ss = abi::swift_string(text);
                    let w0 = u64::from_le_bytes(ss[..8].try_into().expect("lo"));
                    let w1 = u64::from_le_bytes(ss[8..].try_into().expect("hi"));
                    // `appendInterpolation(_ string: String)` — no specifier,
                    // no metatype: a `String` goes in whole.
                    core::arch::asm!("blr {f}", f = in(reg) resolve::lsk_append_string(),
                        in("x0") w0, in("x1") w1,
                        in("x20") interp.as_mut_ptr(),
                        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"),
                    );
                }
                TextPart::Double(v) => {
                    append_specified(
                        &mut interp,
                        &v.to_le_bytes(),
                        "%lf",
                        resolve::double_meta(),
                        resolve::double_format_specifiable_wt(),
                    );
                }
                TextPart::Int(v) => {
                    append_specified(
                        &mut interp,
                        &v.to_le_bytes(),
                        "%lld",
                        resolve::int_meta(),
                        resolve::int_format_specifiable_wt(),
                    );
                }
            }
        }

        // `LocalizedStringKey.init(stringInterpolation:)` — the interpolation
        // by address, the key back in x0–x3.
        let (k0, k1, k2, k3): (u64, u64, u64, u64);
        core::arch::asm!("blr {f}", f = in(reg) resolve::lsk_from_interp(),
            in("x0") interp.as_mut_ptr(),
            lateout("x0") k0, lateout("x1") k1, lateout("x2") k2, lateout("x3") k3,
            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"),
        );

        text_from_key(k0, k1, k2, k3)
    }
}

/// `appendInterpolation(_:specifier:)` for one `_FormatSpecifiable` value.
///
/// `SwiftUI.formatSpecifier(T.self)` is `@inlinable` and exports no symbol, so
/// the specifier string is passed in — `"%lld"` for `Int`, `"%lf"` for
/// `Double`, which is what the inlined body returns and what the compiler's
/// own IR has as a constant.
///
/// # Safety
/// `bytes` must be a live value of `meta`, conforming through `wt`.
unsafe fn append_specified(
    interp: &mut [u8],
    bytes: &[u8],
    specifier: &str,
    meta: *const c_void,
    wt: *const c_void,
) {
    unsafe {
        let spec = abi::swift_string(specifier);
        let sp0 = u64::from_le_bytes(spec[..8].try_into().expect("lo"));
        let sp1 = u64::from_le_bytes(spec[8..].try_into().expect("hi"));
        let mut value = bytes.to_vec();
        // The value by address, because the parameter is generic; then the
        // specifier, then `T.Type` and `T: _FormatSpecifiable`.
        core::arch::asm!("blr {f}", f = in(reg) resolve::lsk_append_interp(),
            in("x0") value.as_mut_ptr(),
            in("x1") sp0, in("x2") sp1,
            in("x3") meta,
            in("x4") wt,
            in("x20") interp.as_mut_ptr(),
            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"),
        );
    }
}

/// `Text.init(_:tableName:bundle:comment:)` over a built key.
///
/// # Safety
/// The four words must be a `+1` `LocalizedStringKey`.
pub(crate) unsafe fn text_from_key(k0: u64, k1: u64, k2: u64, k3: u64) -> ViewHandle {
    unsafe {
        let (t0, t1, t2, t3): (u64, u64, u64, u64);
        core::arch::asm!(
            "sub sp, sp, #32",
            "stp xzr, xzr, [sp]",
            "stp xzr, xzr, [sp, #16]",
            "blr {f}",
            "add sp, sp, #32",
            f = in(reg) resolve::text_lsk_init(),
            inout("x0") k0 => t0, inout("x1") k1 => t1,
            inout("x2") k2 => t2, inout("x3") k3 => t3,
            in("x4") 0u64, in("x5") 0u64, in("x6") 0u64, in("x7") 0u64,
            in("x20") resolve::text_meta(),
            lateout("x8") _, lateout("x9") _, lateout("x10") _, lateout("x11") _,
            lateout("x12") _, lateout("x13") _, lateout("x14") _, lateout("x15") _,
            lateout("x16") _, lateout("x17") _, lateout("lr") _, clobber_abi("C"),
        );
        let mut buf = [0u8; 32];
        buf[..8].copy_from_slice(&t0.to_le_bytes());
        buf[8..16].copy_from_slice(&t1.to_le_bytes());
        buf[16..24].copy_from_slice(&t2.to_le_bytes());
        buf[24..32].copy_from_slice(&t3.to_le_bytes());
        wrap_buf(&buf, resolve::text_meta(), resolve::text_wt())
    }
}