Honor SDKROOT for local Apple deps

build.zig.zon

@@ -26,9 +26,7 @@
             .lazy = true,
         },
         .zig_objc = .{
-            // mitchellh/zig-objc
-            .url = "https://deps.files.ghostty.org/zig_objc-f356ed02833f0f1b8e84d50bed9e807bf7cdc0ae.tar.gz",
-            .hash = "zig_objc-0.0.0-Ir_Sp5gTAQCvxxR7oVIrPXxXwsfKgVP7_wqoOQrZjFeK",
+            .path = "./pkg/zig-objc",
             .lazy = true,
         },
         .zig_js = .{

include/ghostty.h

@@ -3,8 +3,9 @@
 // isn't meant to be a general purpose embedding API (yet) so there hasn't
 // been documentation or example work beyond that.
 //
-// The only consumer of this API is the macOS app, but the API is built to
-// be more general purpose.
+// cmux uses this API on both macOS and iOS. The iOS integration depends on
+// manual surface I/O via ghostty_surface_config_s.io_mode, io_write_cb,
+// ghostty_surface_process_output, and ghostty_surface_text_input.
 #ifndef GHOSTTY_H
 #define GHOSTTY_H
 
@@ -1084,6 +1085,7 @@ bool ghostty_surface_needs_confirm_quit(ghostty_surface_t);
 bool ghostty_surface_process_exited(ghostty_surface_t);
 void ghostty_surface_refresh(ghostty_surface_t);
 void ghostty_surface_draw(ghostty_surface_t);
+void ghostty_surface_draw_now(ghostty_surface_t);
 void ghostty_surface_set_content_scale(ghostty_surface_t, double, double);
 void ghostty_surface_set_focus(ghostty_surface_t, bool);
 void ghostty_surface_set_occlusion(ghostty_surface_t, bool);
@@ -1098,6 +1100,7 @@ bool ghostty_surface_key_is_binding(ghostty_surface_t,
                                     ghostty_input_key_s,
                                     ghostty_binding_flags_e*);
 void ghostty_surface_text(ghostty_surface_t, const char*, uintptr_t);
+void ghostty_surface_text_input(ghostty_surface_t, const char*, uintptr_t);
 void ghostty_surface_preedit(ghostty_surface_t, const char*, uintptr_t);
 void ghostty_surface_process_output(ghostty_surface_t, const char*, uintptr_t);
 bool ghostty_surface_mouse_captured(ghostty_surface_t);
@@ -1133,6 +1136,9 @@ bool ghostty_surface_read_selection(ghostty_surface_t, ghostty_text_s*);
 bool ghostty_surface_read_text(ghostty_surface_t,
                                ghostty_selection_s,
                                ghostty_text_s*);
+bool ghostty_surface_read_text_html(ghostty_surface_t,
+                                    ghostty_selection_s,
+                                    ghostty_text_s*);
 void ghostty_surface_free_text(ghostty_surface_t, ghostty_text_s*);
 
 #ifdef __APPLE__

macos/Sources/Ghostty/Ghostty.Surface.swift

@@ -44,7 +44,7 @@ extension Ghostty {
 
             text.withCString { ptr in
                 // len includes the null terminator so we do len - 1
-                ghostty_surface_text(surface, ptr, UInt(len - 1))
+                ghostty_surface_text_input(surface, ptr, UInt(len - 1))
             }
         }
 

pkg/apple-sdk/build.zig

@@ -41,14 +41,28 @@ pub fn addPaths(
     });
 
     if (!gop.found_existing) {
+        const sdkroot_override = std.process.getEnvVarOwned(b.allocator, "SDKROOT") catch |err| switch (err) {
+            error.EnvironmentVariableNotFound => null,
+            else => return err,
+        };
+        defer if (sdkroot_override) |sdkroot| b.allocator.free(sdkroot);
+
         // Detect our SDK using the "findNative" Zig stdlib function.
         // This is really important because it forces using `xcrun` to
         // find the SDK path.
-        const libc = try std.zig.LibCInstallation.findNative(.{
-            .allocator = b.allocator,
-            .target = &step.rootModuleTarget(),
-            .verbose = false,
-        });
+        const libc = libc: {
+            if (sdkroot_override) |sdkroot| {
+                var libc: std.zig.LibCInstallation = .{};
+                libc.include_dir = try std.fs.path.join(b.allocator, &.{ sdkroot, "usr", "include" });
+                libc.sys_include_dir = try std.fs.path.join(b.allocator, &.{ sdkroot, "usr", "include" });
+                break :libc libc;
+            }
+            break :libc try std.zig.LibCInstallation.findNative(.{
+                .allocator = b.allocator,
+                .target = &step.rootModuleTarget(),
+                .verbose = false,
+            });
+        };
 
         // Render the file compatible with the `--libc` Zig flag.
         var stream: std.io.Writer.Allocating = .init(b.allocator);

pkg/macos/iosurface/iosurface.zig

@@ -20,6 +20,10 @@ pub const IOSurface = opaque {
     };
 
     pub fn init(properties: Properties) Allocator.Error!*IOSurface {
+        // Metal requires IOSurface row bytes to be aligned (64-byte is safe).
+        const row_bytes: c_int = @intCast(
+            (@as(usize, @intCast(properties.width)) * @as(usize, @intCast(properties.bytes_per_element)) + 63) & ~@as(usize, 63),
+        );
         var w = try foundation.Number.create(.int, &properties.width);
         defer w.release();
         var h = try foundation.Number.create(.int, &properties.height);
@@ -28,15 +32,18 @@ pub const IOSurface = opaque {
         defer pf.release();
         var bpe = try foundation.Number.create(.int, &properties.bytes_per_element);
         defer bpe.release();
+        var rb = try foundation.Number.create(.int, &row_bytes);
+        defer rb.release();
 
         var properties_dict = try foundation.Dictionary.create(
             &[_]?*const anyopaque{
                 c.kIOSurfaceWidth,
                 c.kIOSurfaceHeight,
                 c.kIOSurfacePixelFormat,
                 c.kIOSurfaceBytesPerElement,
+                c.kIOSurfaceBytesPerRow,
             },
-            &[_]?*const anyopaque{ w, h, pf, bpe },
+            &[_]?*const anyopaque{ w, h, pf, bpe, rb },
         );
         defer properties_dict.release();
 
@@ -84,14 +91,14 @@ pub const IOSurface = opaque {
     }
 
     pub inline fn lock(self: *IOSurface) void {
-        c.IOSurfaceLock(
+        _ = c.IOSurfaceLock(
             @ptrCast(self),
             0,
             null,
         );
     }
     pub inline fn unlock(self: *IOSurface) void {
-        c.IOSurfaceUnlock(
+        _ = c.IOSurfaceUnlock(
             @ptrCast(self),
             0,
             null,

pkg/zig-objc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mitchell Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pkg/zig-objc/README.md

@@ -0,0 +1,101 @@
+# zig-objc - Objective-C Runtime Bindings for Zig
+
+zig-objc allows Zig to call Objective-C using the macOS
+[Objective-C runtime](https://developer.apple.com/documentation/objectivec/objective-c_runtime?language=objc).
+
+**Project Status:** This library does not currently have 100% coverage over the Objective-C
+runtime, but supports enough features to be useful. I use this library in
+shipping code that I run every day.
+
+## Features
+
+  * Classes:
+    - Find classes
+    - Read property metadata
+    - Call methods
+    - Create subclasses
+    - Add methods
+    - Replace methods
+    - Add instance variables
+  * Objects:
+    - Class or class name for object
+    - Read and write properties
+    - Read and write instance variables
+    - Call methods
+    - Call superclass methods
+  * Protocols:
+    - Check conformance
+    - Read property metadata
+  * Blocks:
+    - Define and invoke blocks with captured values
+    - Pass blocks to C APIs which can then invoke your Zig code
+  * Autorelease pools
+
+There is still a bunch of the runtime API that isn't supported. It wouldn't
+be hard work to add it, I just haven't needed it. For example: object
+instance variables, protocols, dynamically registering new classes, etc.
+
+Feel free to open a pull request if you want additional features.
+**Do not open issues to request features (only pull requests).** I'm
+only going to add features I need, _unless_ you open a pull request to
+add it yourself.
+
+## Example
+
+Here is an example that uses `NSProcessInfo` to implement a function
+`macosVersionAtLeast` that returns true if the running macOS versions
+is at least the given arguments.
+
+```zig
+const objc = @import("objc");
+
+pub fn macosVersionAtLeast(major: i64, minor: i64, patch: i64) bool {
+    /// Get the objc class from the runtime
+    const NSProcessInfo = objc.getClass("NSProcessInfo").?;
+
+    /// Call a class method with no arguments that returns another objc object.
+    const info = NSProcessInfo.msgSend(objc.Object, "processInfo", .{});
+
+    /// Call an instance method that returns a boolean and takes a single
+    /// argument.
+    return info.msgSend(bool, "isOperatingSystemAtLeastVersion:", .{
+        NSOperatingSystemVersion{ .major = major, .minor = minor, .patch = patch },
+    });
+}
+
+/// This extern struct matches the Cocoa headers for layout.
+const NSOperatingSystemVersion = extern struct {
+    major: i64,
+    minor: i64,
+    patch: i64,
+};
+```
+
+## Usage
+
+Add this repository to your `build.zig.zon` file. Then:
+
+```zig
+pub fn build(b: *std.build.Builder) !void {
+  // ... other stuff
+
+  exe.root_module.addImport("objc", b.dependency("zig_objc", .{
+    .target = target,
+    .optimize = optimize,
+  }).module("objc"));
+}
+```
+
+Note that `zig-objc` will find and link to headers from the target SDK
+(macOS, iOS, etc.) automatically by finding your Xcode installation. If
+Xcode is not installed, you can add it manually but you must set the
+`-Dadd-paths=false` flag.
+
+**`zig-objc` only works with released versions of Zig.** We don't support
+nightly versions because the Zig compiler is still changing too much.
+
+## Documentation
+
+Read the source code, it is well commented. If something isn't clear, please
+open an issue and I'll enhance the source code. Some familiarity with
+Objective-C concepts is expected for understanding the doc comments.

pkg/zig-objc/build.zig

@@ -0,0 +1,99 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) !void {
+    const optimize = b.standardOptimizeOption(.{});
+    const target = b.standardTargetOptions(.{});
+    const add_paths = b.option(
+        bool,
+        "add-paths",
+        "add apple SDK paths from Xcode installation",
+    ) orelse true;
+
+    const objc = b.addModule("objc", .{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    if (add_paths) try addAppleSDK(b, objc);
+    objc.linkSystemLibrary("objc", .{});
+    objc.linkFramework("Foundation", .{});
+
+    const tests = b.addTest(.{
+        .name = "objc-test",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+    tests.linkSystemLibrary("objc");
+    tests.linkFramework("Foundation");
+    tests.linkFramework("AppKit"); // Required by 'tagged pointer' test.
+    try addAppleSDK(b, tests.root_module);
+    b.installArtifact(tests);
+
+    const test_step = b.step("test", "Run tests");
+    const tests_run = b.addRunArtifact(tests);
+    test_step.dependOn(&tests_run.step);
+}
+
+/// Add the SDK framework, include, and library paths to the given module.
+/// The module target is used to determine the SDK to use so it must have
+/// a resolved target.
+///
+/// The Apple SDK is determined based on the build target and found using
+/// xcrun, so it requires a valid Xcode installation.
+pub fn addAppleSDK(b: *std.Build, m: *std.Build.Module) !void {
+    // The cache. This always uses b.allocator and never frees memory
+    // (which is idiomatic for a Zig build exe).
+    const Cache = struct {
+        const Key = struct {
+            arch: std.Target.Cpu.Arch,
+            os: std.Target.Os.Tag,
+            abi: std.Target.Abi,
+        };
+
+        var map: std.AutoHashMapUnmanaged(Key, ?[]const u8) = .{};
+    };
+
+    const target = m.resolved_target.?.result;
+    const gop = try Cache.map.getOrPut(b.allocator, .{
+        .arch = target.cpu.arch,
+        .os = target.os.tag,
+        .abi = target.abi,
+    });
+
+    // This executes `xcrun` to get the SDK path. We don't want to execute
+    // this multiple times so we cache the value.
+    if (!gop.found_existing) {
+        const sdkroot_override = std.process.getEnvVarOwned(b.allocator, "SDKROOT") catch |err| switch (err) {
+            error.EnvironmentVariableNotFound => null,
+            else => return err,
+        };
+        defer if (sdkroot_override) |sdkroot| b.allocator.free(sdkroot);
+
+        if (sdkroot_override) |sdkroot| {
+            gop.value_ptr.* = try b.allocator.dupe(u8, sdkroot);
+        } else {
+            gop.value_ptr.* = std.zig.system.darwin.getSdk(
+                b.allocator,
+                &m.resolved_target.?.result,
+            );
+        }
+    }
+
+    // The active SDK we want to use
+    const path = gop.value_ptr.* orelse return switch (target.os.tag) {
+        // Return a more descriptive error. Before we just returned the
+        // generic error but this was confusing a lot of community members.
+        // It costs us nothing in the build script to return something better.
+        .macos => error.XcodeMacOSSDKNotFound,
+        .ios => error.XcodeiOSSDKNotFound,
+        .tvos => error.XcodeTVOSSDKNotFound,
+        .watchos => error.XcodeWatchOSSDKNotFound,
+        else => error.XcodeAppleSDKNotFound,
+    };
+    m.addSystemFrameworkPath(.{ .cwd_relative = b.pathJoin(&.{ path, "System/Library/Frameworks" }) });
+    m.addSystemIncludePath(.{ .cwd_relative = b.pathJoin(&.{ path, "usr/include" }) });
+    m.addLibraryPath(.{ .cwd_relative = b.pathJoin(&.{ path, "usr/lib" }) });
+}

pkg/zig-objc/build.zig.zon

@@ -0,0 +1,13 @@
+.{
+    .name = .zig_objc,
+    .version = "0.0.0",
+    .fingerprint = 0x8a91772ba7d2bf22,
+    .paths = .{
+        "src/",
+        "build.zig",
+        "build.zig.zon",
+        "README.md",
+        "LICENSE",
+    },
+    .dependencies = .{},
+}

pkg/zig-objc/src/autorelease.zig

@@ -0,0 +1,17 @@
+const std = @import("std");
+
+pub const AutoreleasePool = opaque {
+    /// Create a new autorelease pool. To clean it up, call deinit.
+    pub inline fn init() *AutoreleasePool {
+        return @ptrCast(objc_autoreleasePoolPush().?);
+    }
+
+    pub inline fn deinit(self: *AutoreleasePool) void {
+        objc_autoreleasePoolPop(self);
+    }
+};
+
+// I'm not sure if these are internal or not... they aren't in any headers,
+// but its how autorelease pools are implemented.
+extern "c" fn objc_autoreleasePoolPush() ?*anyopaque;
+extern "c" fn objc_autoreleasePoolPop(?*anyopaque) void;