Merge ffi/layout: compile-time + cross-language FFI ABI layout assertions

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 1313

src/ffi/mod.rs

@@ -52,11 +52,67 @@ pub struct FFIApplicationData {
     pub app_name_length: u32,
 }
 
+// MARK: - ABI Layout Assertions
+//
+// The four `#[repr(C)]` structs above are passed by value (or via packed
+// buffers) across the Rust <-> Swift `@_cdecl` FFI boundary. Their Swift
+// counterparts live in `swift-bridge/Sources/ScreenCaptureKitBridge/Core.swift`
+// (`@frozen public struct FFIRect/FFIDisplayData/FFIWindowData/FFIApplicationData`).
+//
+// These compile-time assertions pin the exact ABI shared with Swift: any change
+// to a field type, field order, or padding fails the build immediately instead
+// of silently corrupting marshalled data at runtime. If you change the layout
+// here you MUST mirror it in Core.swift (and vice versa); the cross-language
+// `sc_verify_ffi_layout` check in `tests/ffi_layout_tests.rs` guards that too.
+use core::mem::{align_of, offset_of, size_of};
+
+const _: () = assert!(size_of::<FFIRect>() == 32);
+const _: () = assert!(align_of::<FFIRect>() == 8);
+const _: () = assert!(offset_of!(FFIRect, x) == 0);
+const _: () = assert!(offset_of!(FFIRect, y) == 8);
+const _: () = assert!(offset_of!(FFIRect, width) == 16);
+const _: () = assert!(offset_of!(FFIRect, height) == 24);
+
+const _: () = assert!(size_of::<FFIDisplayData>() == 48);
+const _: () = assert!(align_of::<FFIDisplayData>() == 8);
+const _: () = assert!(offset_of!(FFIDisplayData, display_id) == 0);
+const _: () = assert!(offset_of!(FFIDisplayData, width) == 4);
+const _: () = assert!(offset_of!(FFIDisplayData, height) == 8);
+const _: () = assert!(offset_of!(FFIDisplayData, frame) == 16);
+
+const _: () = assert!(size_of::<FFIWindowData>() == 64);
+const _: () = assert!(align_of::<FFIWindowData>() == 8);
+const _: () = assert!(offset_of!(FFIWindowData, window_id) == 0);
+const _: () = assert!(offset_of!(FFIWindowData, window_layer) == 4);
+const _: () = assert!(offset_of!(FFIWindowData, is_on_screen) == 8);
+const _: () = assert!(offset_of!(FFIWindowData, is_active) == 9);
+const _: () = assert!(offset_of!(FFIWindowData, frame) == 16);
+const _: () = assert!(offset_of!(FFIWindowData, title_offset) == 48);
+const _: () = assert!(offset_of!(FFIWindowData, title_length) == 52);
+const _: () = assert!(offset_of!(FFIWindowData, owning_app_index) == 56);
+const _: () = assert!(offset_of!(FFIWindowData, _padding) == 60);
+
+const _: () = assert!(size_of::<FFIApplicationData>() == 24);
+const _: () = assert!(align_of::<FFIApplicationData>() == 4);
+const _: () = assert!(offset_of!(FFIApplicationData, process_id) == 0);
+const _: () = assert!(offset_of!(FFIApplicationData, _padding) == 4);
+const _: () = assert!(offset_of!(FFIApplicationData, bundle_id_offset) == 8);
+const _: () = assert!(offset_of!(FFIApplicationData, bundle_id_length) == 12);
+const _: () = assert!(offset_of!(FFIApplicationData, app_name_offset) == 16);
+const _: () = assert!(offset_of!(FFIApplicationData, app_name_length) == 20);
+
 // MARK: - CoreGraphics Initialization
 extern "C" {
     /// Force CoreGraphics initialization by calling `CGMainDisplayID`
     /// This prevents `CGS_REQUIRE_INIT` crashes on headless systems
     pub fn sc_initialize_core_graphics();
+
+    /// Cross-language ABI check implemented in the Swift bridge.
+    ///
+    /// Returns `true` only if the Swift `MemoryLayout` (size, stride and
+    /// alignment) of all four FFI structs matches the values pinned on the
+    /// Rust side. Verified by `tests/ffi_layout_tests.rs`.
+    pub fn sc_verify_ffi_layout() -> bool;
 }
 
 // MARK: - SCShareableContent

swift-bridge/Sources/ScreenCaptureKitBridge/Core.swift

@@ -77,6 +77,31 @@ public func initializeCoreGraphics() {
     _ = CGMainDisplayID()
 }
 
+// MARK: - FFI Layout Verification
+
+/// Cross-language ABI check called from Rust's `tests/ffi_layout_tests.rs`.
+///
+/// Returns `true` only if the Swift `MemoryLayout` (size, stride and alignment)
+/// of all four FFI structs matches the values pinned on the Rust side via the
+/// `const _: () = assert!(...)` checks in `src/ffi/mod.rs`. If the layouts ever
+/// drift apart this returns `false` and the Rust test fails, flagging a real
+/// ABI mismatch.
+@_cdecl("sc_verify_ffi_layout")
+public func verifyFFILayout() -> Bool {
+    return MemoryLayout<FFIRect>.size == 32
+        && MemoryLayout<FFIRect>.stride == 32
+        && MemoryLayout<FFIRect>.alignment == 8
+        && MemoryLayout<FFIDisplayData>.size == 48
+        && MemoryLayout<FFIDisplayData>.stride == 48
+        && MemoryLayout<FFIDisplayData>.alignment == 8
+        && MemoryLayout<FFIWindowData>.size == 64
+        && MemoryLayout<FFIWindowData>.stride == 64
+        && MemoryLayout<FFIWindowData>.alignment == 8
+        && MemoryLayout<FFIApplicationData>.size == 24
+        && MemoryLayout<FFIApplicationData>.stride == 24
+        && MemoryLayout<FFIApplicationData>.alignment == 4
+}
+
 // MARK: - Error Types
 
 /// Strongly typed errors for the ScreenCaptureKit bridge

tests/ffi_layout_tests.rs

@@ -8,7 +8,9 @@
 
 use std::mem::{align_of, size_of};
 
-use screencapturekit::ffi::{FFIApplicationData, FFIDisplayData, FFIRect, FFIWindowData};
+use screencapturekit::ffi::{
+    sc_verify_ffi_layout, FFIApplicationData, FFIDisplayData, FFIRect, FFIWindowData,
+};
 
 #[test]
 fn ffi_rect_layout() {
@@ -57,3 +59,18 @@ fn ffi_application_data_layout() {
         "FFIApplicationData alignment drifted"
     );
 }
+
+/// Cross-language ABI check: asks the Swift bridge to verify that *its*
+/// `MemoryLayout` (size/stride/alignment) for all four FFI structs matches the
+/// values pinned on the Rust side. A `false` return means the Rust and Swift
+/// layouts genuinely disagree, which is a real ABI bug.
+#[test]
+fn ffi_layout_matches_swift() {
+    // SAFETY: `sc_verify_ffi_layout` takes no arguments and only reads
+    // compile-time `MemoryLayout` constants in the Swift bridge.
+    let matches = unsafe { sc_verify_ffi_layout() };
+    assert!(
+        matches,
+        "Swift FFI struct layout disagrees with Rust layout (ABI mismatch)"
+    );
+}