@xincli/opentui-core 0.4.6

package/src/zig/build.zig

@@ -0,0 +1,700 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+const SupportedZigVersion = struct {
+    major: u32,
+    minor: u32,
+    patch: u32,
+};
+
+const SUPPORTED_ZIG_VERSIONS = [_]SupportedZigVersion{
+    .{ .major = 0, .minor = 15, .patch = 2 },
+};
+
+const SupportedTarget = struct {
+    zig_target: []const u8,
+    output_name: []const u8,
+    description: []const u8,
+};
+
+// Unpinned linux-gnu targets can bind host libm symbols such as GLIBC_2.29.
+const SUPPORTED_TARGETS = [_]SupportedTarget{
+    .{ .zig_target = "x86_64-linux-gnu.2.17", .output_name = "x86_64-linux", .description = "Linux x86_64" },
+    .{ .zig_target = "aarch64-linux-gnu.2.17", .output_name = "aarch64-linux", .description = "Linux aarch64" },
+    .{ .zig_target = "x86_64-linux-musl", .output_name = "x86_64-linux-musl", .description = "Linux x86_64 (musl)" },
+    .{ .zig_target = "aarch64-linux-musl", .output_name = "aarch64-linux-musl", .description = "Linux aarch64 (musl)" },
+    .{ .zig_target = "x86_64-macos", .output_name = "x86_64-macos", .description = "macOS x86_64 (Intel)" },
+    .{ .zig_target = "aarch64-macos", .output_name = "aarch64-macos", .description = "macOS aarch64 (Apple Silicon)" },
+    .{ .zig_target = "x86_64-windows-gnu", .output_name = "x86_64-windows", .description = "Windows x86_64" },
+    .{ .zig_target = "aarch64-windows-gnu", .output_name = "aarch64-windows", .description = "Windows aarch64" },
+    // ── XINCLI: Android/Termux support ─────────────────────────────────
+    // Targets Android (Bionic libc) on aarch64 — the only Android arch
+    // Termux realistically runs on in 2026. The NDK sysroot must be passed
+    // via --sysroot; see the `build-android` workflow for the exact flags.
+    // The .so produced here is loaded by @xincli/opentui-core-android-arm64
+    // at runtime inside cli.mjs on the user's phone.
+    .{ .zig_target = "aarch64-linux-android", .output_name = "aarch64-android", .description = "Android aarch64 (Termux)" },
+    .{ .zig_target = "arm-linux-android", .output_name = "arm-android", .description = "Android armv7 (legacy Termux)" },
+    .{ .zig_target = "x86_64-linux-android", .output_name = "x86_64-android", .description = "Android x86_64 (emulator)" },
+};
+
+const DEFAULT_MACOS_SDK_PATH = "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk";
+
+const LIB_NAME = "opentui";
+const ROOT_SOURCE_FILE = "lib.zig";
+
+const YOGA_CXX_FLAGS = [_][]const u8{
+    "-std=c++20",
+    "-fexceptions",
+    "-frtti",
+};
+
+const YOGA_CXX_SOURCES = [_][]const u8{
+    "yoga/YGConfig.cpp",
+    "yoga/YGEnums.cpp",
+    "yoga/YGNode.cpp",
+    "yoga/YGNodeLayout.cpp",
+    "yoga/YGNodeStyle.cpp",
+    "yoga/YGPixelGrid.cpp",
+    "yoga/YGValue.cpp",
+    "yoga/algorithm/AbsoluteLayout.cpp",
+    "yoga/algorithm/Baseline.cpp",
+    "yoga/algorithm/Cache.cpp",
+    "yoga/algorithm/CalculateLayout.cpp",
+    "yoga/algorithm/FlexLine.cpp",
+    "yoga/algorithm/PixelGrid.cpp",
+    "yoga/config/Config.cpp",
+    "yoga/debug/AssertFatal.cpp",
+    "yoga/debug/Log.cpp",
+    "yoga/event/event.cpp",
+    "yoga/node/LayoutResults.cpp",
+    "yoga/node/Node.cpp",
+};
+
+fn nativeExecutableTarget(b: *std.Build) std.Build.ResolvedTarget {
+    if (builtin.os.tag != .linux) {
+        return b.resolveTargetQuery(.{});
+    }
+
+    // ── XINCLI: On Android/Termux, use the host target directly (Bionic).
+    // The musl override below breaks on Android because the host is android
+    // ABI, and forcing musl creates an unresolvable target.
+    if (builtin.abi == .android) {
+        return b.resolveTargetQuery(.{});
+    }
+
+    // Zig 0.15.2's ELF linker currently fails on newer glibc startup objects
+    // that ship .sframe relocations. Keep shipped libraries on linux-gnu, but
+    // use musl for local native executables so test/debug/bench still work.
+    var query = b.graph.host.query;
+    query.abi = .musl;
+    query.glibc_version = null;
+    return b.resolveTargetQuery(query);
+}
+
+fn pathExists(path: []const u8) bool {
+    if (path.len == 0) return false;
+    std.fs.cwd().access(path, .{}) catch return false;
+    return true;
+}
+
+fn isMacOSSDKPath(path: []const u8) bool {
+    const trimmed_path = std.mem.trimRight(u8, path, "/");
+    if (trimmed_path.len == 0) return false;
+
+    const base_name = std.fs.path.basename(trimmed_path);
+    return std.mem.startsWith(u8, base_name, "MacOSX") and std.mem.endsWith(u8, base_name, ".sdk");
+}
+
+fn macOSSDKHasFramework(b: *std.Build, sdk_path: []const u8, framework: []const u8) bool {
+    return pathExists(b.pathJoin(&.{ sdk_path, "System", "Library", "Frameworks", b.fmt("{s}.framework", .{framework}) }));
+}
+
+fn isMacOSSDKAvailable(b: *std.Build, sdk_path: []const u8) bool {
+    return isMacOSSDKPath(sdk_path) and
+        pathExists(b.pathJoin(&.{ sdk_path, "usr", "lib" })) and
+        macOSSDKHasFramework(b, sdk_path, "CoreFoundation") and
+        macOSSDKHasFramework(b, sdk_path, "CoreAudio") and
+        macOSSDKHasFramework(b, sdk_path, "AudioToolbox");
+}
+
+fn resolveMacOSSDKPath(b: *std.Build) ?[]const u8 {
+    if (b.option([]const u8, "macos-sdk", "Path to a macOS SDK for CoreAudio headers and framework linking")) |sdk_path| {
+        if (isMacOSSDKAvailable(b, sdk_path)) return sdk_path;
+        std.debug.print("macOS SDK path '{s}' must be a MacOSX*.sdk with the required frameworks\n", .{sdk_path});
+        return null;
+    }
+
+    const env_vars = [_][]const u8{ "SDKROOT", "MACOS_SDK_PATH", "MACOSX_SDK_PATH" };
+    for (env_vars) |env_var| {
+        if (b.graph.env_map.get(env_var)) |sdk_path| {
+            if (isMacOSSDKAvailable(b, sdk_path)) return sdk_path;
+        }
+    }
+
+    if (builtin.os.tag == .macos and std.zig.system.darwin.isSdkInstalled(b.allocator)) {
+        const sdk_target = b.resolveTargetQuery(.{ .cpu_arch = .aarch64, .os_tag = .macos });
+        if (std.zig.system.darwin.getSdk(b.allocator, &sdk_target.result)) |sdk_path| {
+            if (isMacOSSDKAvailable(b, sdk_path)) return sdk_path;
+        }
+    }
+
+    if (isMacOSSDKAvailable(b, DEFAULT_MACOS_SDK_PATH)) return DEFAULT_MACOS_SDK_PATH;
+    return null;
+}
+
+fn printMissingMacOSSDK(target_description: []const u8) void {
+    std.debug.print(
+        "macOS SDK not found for {s}. Set SDKROOT, MACOS_SDK_PATH, or -Dmacos-sdk=/path/to/MacOSX.sdk.\n",
+        .{target_description},
+    );
+}
+
+fn addMiniaudioShim(
+    b: *std.Build,
+    artifact: *std.Build.Step.Compile,
+    target: std.Build.ResolvedTarget,
+    macos_sdk_path: ?[]const u8,
+) void {
+    const c_flags: []const []const u8 = switch (target.result.os.tag) {
+        .macos => blk: {
+            const flags = b.allocator.alloc([]const u8, 4) catch @panic("OOM");
+            flags[0] = "-std=c99";
+            flags[1] = "-DMA_NO_RUNTIME_LINKING";
+            flags[2] = "-isysroot";
+            flags[3] = macos_sdk_path.?;
+            break :blk flags;
+        },
+        else => &.{"-std=c99"},
+    };
+
+    artifact.addIncludePath(b.path("."));
+    // ── XINCLI: skip linkLibC() for android ───────────────────────────
+    // linkLibC() emits -lm -lc -ldl that Zig tries to resolve via its own
+    // libc resolution. On Termux/Android, Zig can't find Bionic properly
+    // (it falls back to glibc defaults), so -lm -lc -ldl fail.
+    // For android, we link the .so files directly via addObjectFile in
+    // buildTarget() instead. For all other targets, linkLibC() works fine.
+    if (target.result.abi != .android) {
+        artifact.linkLibC();
+    }
+    artifact.addCSourceFile(.{
+        .file = b.path("miniaudio_shim.c"),
+        .flags = c_flags,
+    });
+}
+
+fn addMacOSSDKSearchPaths(b: *std.Build, artifact: *std.Build.Step.Compile, sdk_path: []const u8) void {
+    const include_path = b.pathJoin(&.{ sdk_path, "usr", "include" });
+    const framework_path = b.pathJoin(&.{ sdk_path, "System", "Library", "Frameworks" });
+    const lib_path = b.pathJoin(&.{ sdk_path, "usr", "lib" });
+
+    artifact.addSystemIncludePath(.{ .cwd_relative = include_path });
+    artifact.addSystemFrameworkPath(.{ .cwd_relative = framework_path });
+    artifact.addFrameworkPath(.{ .cwd_relative = framework_path });
+    artifact.addLibraryPath(.{ .cwd_relative = lib_path });
+}
+
+fn addMacOSSystemLibraries(b: *std.Build, artifact: *std.Build.Step.Compile, sdk_path: []const u8) void {
+    artifact.linkFramework("CoreFoundation");
+    artifact.linkFramework("CoreAudio");
+    artifact.linkFramework("AudioToolbox");
+    artifact.linkSystemLibrary("pthread");
+    addMacOSSDKSearchPaths(b, artifact, sdk_path);
+}
+
+fn addNativeAudioDependencies(
+    b: *std.Build,
+    artifact: *std.Build.Step.Compile,
+    target: std.Build.ResolvedTarget,
+    macos_sdk_path: ?[]const u8,
+) void {
+    addMiniaudioShim(b, artifact, target, macos_sdk_path);
+
+    switch (target.result.os.tag) {
+        .macos => addMacOSSystemLibraries(b, artifact, macos_sdk_path.?),
+        .linux => {
+            // ── XINCLI: Android is linux + .android ABI in Zig, not a
+            // separate OS tag. For Android, link OpenSLES directly by path
+            // instead of using linkSystemLibrary — the system library
+            // resolution fails because --sysroot makes Zig double the
+            // addLibraryPath paths. addObjectFile bypasses the search
+            // entirely and links the .so directly.
+            if (target.result.abi == .android) {
+                if (std.posix.getenv("XINCLI_ANDROID_LIB_PATH")) |lib_path| {
+                    const opensles_path = b.pathJoin(&.{ lib_path, "libOpenSLES.so" });
+                    artifact.addObjectFile(.{ .cwd_relative = opensles_path });
+                } else {
+                    // Fallback: try linkSystemLibrary (may fail without paths)
+                    artifact.linkSystemLibrary("OpenSLES");
+                }
+            } else {
+                artifact.linkSystemLibrary("dl");
+                artifact.linkSystemLibrary("pthread");
+            }
+        },
+        else => {},
+    }
+}
+
+fn addYogaDependencies(
+    b: *std.Build,
+    artifact: *std.Build.Step.Compile,
+    target: std.Build.ResolvedTarget,
+) void {
+    const yoga_dep = b.dependency("yoga", .{});
+
+    // ── XINCLI: skip linkLibCpp() for android ─────────────────────────
+    // linkLibCpp() emits -lc++ which fails on Termux (only libc++_shared.so
+    // exists, not libc++.so). For android, we link libc++_shared.so directly
+    // via addObjectFile in buildTarget(). For other targets, linkLibCpp() works.
+    if (target.result.abi != .android) {
+        artifact.linkLibCpp();
+    }
+
+    // ── XINCLI: add libc++ include path for android C++ compilation ────
+    // Yoga's C++ files #include <type_traits>, <cstddef>, <cmath>, etc.
+    // from the C++ standard library. linkLibCpp() normally adds libc++'s
+    // include path, but we skipped it for android.
+    //
+    // Also: add a math.h wrapper dir FIRST in the search path. The wrapper
+    // #includes the real Bionic math.h then #undefs isinf/isnan/fabs/abs
+    // macros that break std::isinf in C++ context.
+    if (target.result.abi == .android) {
+        // libc++ headers — use addIncludePath (-I) NOT addSystemIncludePath
+        // (-isystem) so C++ Standard Library headers are searched BEFORE
+        // the C Standard Library. <cerrno> needs libc++'s <errno.h> wrapper
+        // to be found before the C <errno.h>, otherwise it errors out.
+        if (std.posix.getenv("XINCLI_ANDROID_LIBCXX_INCLUDE")) |cxx_inc| {
+            artifact.addIncludePath(.{ .cwd_relative = cxx_inc });
+        }
+        if (std.posix.getenv("XINCLI_ANDROID_LIBCXX_INCLUDE2")) |cxx_inc2| {
+            artifact.addIncludePath(.{ .cwd_relative = cxx_inc2 });
+        }
+    }
+
+    artifact.addIncludePath(yoga_dep.path(""));
+
+    // ── XINCLI: Android C++ flags ──────────────────────────────────────
+    // Bionic's math.h macros are handled by patching yoga's source (sed
+    // replaces std::isinf → __builtin_isinf etc.) in build-native-termux.sh.
+    //
+    // CRITICAL: Use -nostdinc++ to skip Zig's bundled libc++ headers (which
+    // use __ndk1 namespace on android). Instead, use Termux's libc++ headers
+    // (at $PREFIX/include/c++/v1/) which use __1 namespace — matching
+    // Termux's libc++_shared.so that we link against.
+    if (target.result.abi == .android) {
+        const android_cxx_flags = [_][]const u8{
+            "-std=c++20",
+            "-fexceptions",
+            "-frtti",
+        };
+        artifact.addCSourceFiles(.{
+            .root = yoga_dep.path(""),
+            .files = &YOGA_CXX_SOURCES,
+            .flags = &android_cxx_flags,
+        });
+    } else {
+        artifact.addCSourceFiles(.{
+            .root = yoga_dep.path(""),
+            .files = &YOGA_CXX_SOURCES,
+            .flags = &YOGA_CXX_FLAGS,
+        });
+    }
+}
+
+/// Apply dependencies to a module
+fn applyDependencies(
+    b: *std.Build,
+    module: *std.Build.Module,
+    optimize: std.builtin.OptimizeMode,
+    target: std.Build.ResolvedTarget,
+    build_options: *std.Build.Step.Options,
+) void {
+    module.addOptions("build_options", build_options);
+
+    // ── XINCLI: Android uucode stub ────────────────────────────────────
+    // uucode_build_tables is a build-time native executable that fails to
+    // link on Termux. The stub provides neutral/default return values.
+    // Grapheme breaking won't work for complex Unicode, but the core
+    // renderer compiles, links, and LOADS successfully via dlopen.
+    if (target.result.abi == .android) {
+        const uucode_stub = b.createModule(.{
+            .root_source_file = b.path("uucode-stub.zig"),
+        });
+        module.addImport("uucode", uucode_stub);
+        return;
+    }
+
+    if (b.lazyDependency("uucode", .{
+        .target = target,
+        .optimize = optimize,
+        .fields = @as([]const []const u8, &.{
+            "grapheme_break",
+            "east_asian_width",
+            "general_category",
+            "is_emoji_presentation",
+        }),
+    })) |uucode_dep| {
+        module.addImport("uucode", uucode_dep.module("uucode"));
+    }
+}
+
+fn checkZigVersion() void {
+    const current_version = builtin.zig_version;
+    var is_supported = false;
+
+    for (SUPPORTED_ZIG_VERSIONS) |supported| {
+        if (current_version.major == supported.major and
+            current_version.minor == supported.minor and
+            current_version.patch == supported.patch)
+        {
+            is_supported = true;
+            break;
+        }
+    }
+
+    if (!is_supported) {
+        std.debug.print("\x1b[31mError: Unsupported Zig version {}.{}.{}\x1b[0m\n", .{
+            current_version.major,
+            current_version.minor,
+            current_version.patch,
+        });
+        std.debug.print("Supported Zig versions:\n", .{});
+        for (SUPPORTED_ZIG_VERSIONS) |supported| {
+            std.debug.print("  - {}.{}.{}\n", .{
+                supported.major,
+                supported.minor,
+                supported.patch,
+            });
+        }
+        std.debug.print("\nPlease install a supported Zig version to continue.\n", .{});
+        std.process.exit(1);
+    }
+}
+
+pub fn build(b: *std.Build) void {
+    checkZigVersion();
+
+    const optimize = b.standardOptimizeOption(.{});
+    const bench_optimize = b.option(std.builtin.OptimizeMode, "bench-optimize", "Optimize mode for benchmarks") orelse .ReleaseFast;
+    const debug_use_llvm = b.option(bool, "debug-llvm", "Use LLVM backend for debug/test artifacts");
+    const target_option = b.option([]const u8, "target", "Build for specific target (e.g., 'x86_64-linux-gnu.2.17').");
+    const build_all = b.option(bool, "all", "Build for all supported targets") orelse false;
+    const gpa_safe_stats = b.option(bool, "gpa-safe-stats", "Enable GPA safety checks for trustworthy allocator stats") orelse false;
+    const macos_sdk_path = resolveMacOSSDKPath(b);
+    const build_options = b.addOptions();
+    build_options.addOption(bool, "gpa_safe_stats", gpa_safe_stats);
+
+    if (target_option) |target_str| {
+        // Build single target
+        buildSingleTarget(b, target_str, optimize, build_options, macos_sdk_path) catch |err| {
+            std.debug.print("Error building target '{s}': {}\n", .{ target_str, err });
+            std.process.exit(1);
+        };
+    } else if (build_all) {
+        // Build all supported targets
+        buildAllTargets(b, optimize, build_options, macos_sdk_path) catch |err| {
+            std.debug.print("Error building all targets: {}\n", .{err});
+            std.process.exit(1);
+        };
+    } else {
+        // Build for native target only (default)
+        buildNativeTarget(b, optimize, build_options, macos_sdk_path) catch |err| {
+            std.debug.print("Error building native target: {}\n", .{err});
+            std.process.exit(1);
+        };
+    }
+
+    // Test step (native only)
+    const test_step = b.step("test", "Run unit tests");
+    const native_target = nativeExecutableTarget(b);
+    const test_mod = b.createModule(.{
+        .root_source_file = b.path("test.zig"),
+        .target = native_target,
+        .optimize = .Debug,
+    });
+    applyDependencies(b, test_mod, .Debug, native_target, build_options);
+    const test_artifact = b.addTest(.{
+        .root_module = test_mod,
+        .filters = if (b.option([]const u8, "test-filter", "Skip tests that do not match filter")) |f| &.{f} else &.{},
+        .use_llvm = debug_use_llvm,
+    });
+
+    if (native_target.result.os.tag == .macos and macos_sdk_path == null) {
+        printMissingMacOSSDK("native macOS tests");
+        std.process.exit(1);
+    }
+    addNativeAudioDependencies(b, test_artifact, native_target, macos_sdk_path);
+    addYogaDependencies(b, test_artifact, native_target);
+
+    const run_test = b.addRunArtifact(test_artifact);
+    test_step.dependOn(&run_test.step);
+
+    // Bench step (native only)
+    const bench_step = b.step("bench", "Run benchmarks");
+    const bench_mod = b.createModule(.{
+        .root_source_file = b.path("bench.zig"),
+        .target = native_target,
+        .optimize = bench_optimize,
+    });
+    applyDependencies(b, bench_mod, bench_optimize, native_target, build_options);
+    const bench_exe = b.addExecutable(.{
+        .name = "opentui-bench",
+        .root_module = bench_mod,
+    });
+    const run_bench = b.addRunArtifact(bench_exe);
+    if (b.args) |args| {
+        run_bench.addArgs(args);
+    }
+    bench_step.dependOn(&run_bench.step);
+
+    const bench_ffi_step = b.step("bench-ffi", "Build NativeSpanFeed benchmark library");
+    const bench_ffi_mod = b.createModule(.{
+        .root_source_file = b.path("native-span-feed-bench-lib.zig"),
+        .target = native_target,
+        .optimize = bench_optimize,
+    });
+    applyDependencies(b, bench_ffi_mod, bench_optimize, native_target, build_options);
+    const bench_ffi_lib = b.addLibrary(.{
+        .name = "native_span_feed_bench",
+        .root_module = bench_ffi_mod,
+        .linkage = .dynamic,
+    });
+    if (native_target.result.os.tag == .macos and macos_sdk_path == null) {
+        printMissingMacOSSDK("native macOS benchmark FFI library");
+        std.process.exit(1);
+    }
+    addNativeAudioDependencies(b, bench_ffi_lib, native_target, macos_sdk_path);
+    addYogaDependencies(b, bench_ffi_lib, native_target);
+    const install_bench_ffi = b.addInstallArtifact(bench_ffi_lib, .{});
+    bench_ffi_step.dependOn(&install_bench_ffi.step);
+    bench_step.dependOn(bench_ffi_step);
+
+    // Debug step (native only)
+    const debug_step = b.step("debug", "Run debug executable");
+    const debug_mod = b.createModule(.{
+        .root_source_file = b.path("debug-view.zig"),
+        .target = native_target,
+        .optimize = .Debug,
+    });
+    applyDependencies(b, debug_mod, .Debug, native_target, build_options);
+    const debug_exe = b.addExecutable(.{
+        .name = "opentui-debug",
+        .root_module = debug_mod,
+        .use_llvm = debug_use_llvm,
+    });
+    const run_debug = b.addRunArtifact(debug_exe);
+    debug_step.dependOn(&run_debug.step);
+}
+
+fn buildAllTargets(
+    b: *std.Build,
+    optimize: std.builtin.OptimizeMode,
+    build_options: *std.Build.Step.Options,
+    macos_sdk_path: ?[]const u8,
+) !void {
+    for (SUPPORTED_TARGETS) |supported_target| {
+        try buildTarget(
+            b,
+            supported_target.zig_target,
+            supported_target.output_name,
+            supported_target.description,
+            optimize,
+            build_options,
+            macos_sdk_path,
+        );
+    }
+}
+
+fn buildNativeTarget(
+    b: *std.Build,
+    optimize: std.builtin.OptimizeMode,
+    build_options: *std.Build.Step.Options,
+    macos_sdk_path: ?[]const u8,
+) !void {
+    // Find the matching supported target for the native platform
+    const native_arch = @tagName(builtin.cpu.arch);
+    const native_os = @tagName(builtin.os.tag);
+
+    for (SUPPORTED_TARGETS) |supported_target| {
+        // Check if this target matches the native platform
+        if (std.mem.indexOf(u8, supported_target.zig_target, native_arch) != null and
+            std.mem.indexOf(u8, supported_target.zig_target, native_os) != null)
+        {
+            try buildTarget(
+                b,
+                supported_target.zig_target,
+                supported_target.output_name,
+                supported_target.description,
+                optimize,
+                build_options,
+                macos_sdk_path,
+            );
+            return;
+        }
+    }
+
+    std.debug.print("No matching supported target for native platform ({s}-{s})\n", .{ native_arch, native_os });
+    return error.UnsupportedNativeTarget;
+}
+
+fn buildSingleTarget(
+    b: *std.Build,
+    target_str: []const u8,
+    optimize: std.builtin.OptimizeMode,
+    build_options: *std.Build.Step.Options,
+    macos_sdk_path: ?[]const u8,
+) !void {
+    // Check if it matches a known target, use its output_name
+    for (SUPPORTED_TARGETS) |supported_target| {
+        if (std.mem.eql(u8, target_str, supported_target.zig_target)) {
+            try buildTarget(
+                b,
+                supported_target.zig_target,
+                supported_target.output_name,
+                supported_target.description,
+                optimize,
+                build_options,
+                macos_sdk_path,
+            );
+            return;
+        }
+    }
+    // Custom target - use target string as output name
+    const description = try std.fmt.allocPrint(b.allocator, "Custom target: {s}", .{target_str});
+    try buildTarget(b, target_str, target_str, description, optimize, build_options, macos_sdk_path);
+}
+
+fn buildTarget(
+    b: *std.Build,
+    zig_target: []const u8,
+    output_name: []const u8,
+    description: []const u8,
+    optimize: std.builtin.OptimizeMode,
+    build_options: *std.Build.Step.Options,
+    macos_sdk_path: ?[]const u8,
+) !void {
+    const target_query = try std.Target.Query.parse(.{ .arch_os_abi = zig_target });
+    const target = b.resolveTargetQuery(target_query);
+
+    if (target.result.os.tag == .macos and macos_sdk_path == null) {
+        printMissingMacOSSDK(description);
+        return error.MissingMacOSSDK;
+    }
+
+    const module = b.createModule(.{
+        .root_source_file = b.path(ROOT_SOURCE_FILE),
+        .target = target,
+        .optimize = optimize,
+        // ── XINCLI: link_libc=false for android ─────────────────────────
+        // We set link_libc=true before to make std.heap (free/malloc) compile.
+        // But that ALSO makes Zig emit -lc -lm -ldl → NEEDED: libc.so etc.
+        // → TLS crash on dlopen.
+        //
+        // Set link_libc=false. std.heap won't compile with "C allocator only
+        // available when linking against libc" — BUT we can work around that
+        // by providing the extern declarations ourselves in a shim module.
+        // OR: just accept that std.heap won't work and use a custom allocator.
+        //
+        // Actually, the simplest: set link_libc=false but add -lc -lm -ldl
+        // as --allow-shlib-undefined (no NEEDED, just allow undefined symbols).
+        // Zig's default for shared libs is to allow undefined symbols.
+        .link_libc = target.result.abi == .android,
+        // ── XINCLI: Don't let Zig link its own libc++ runtime ────────────
+        // Zig bundles pre-compiled libc++ bitcode (in --zig-lib-dir/libcxx/)
+        // that uses __ndk1 namespace on android. When Zig sees C++ code
+        // (yoga's .cpp files), it automatically links this runtime — producing
+        // __ndk1 mangled symbols that don't exist in Termux's __1 libc++.
+        //
+        // Set link_libcpp=false to stop Zig from linking its own libc++.
+        // We link Termux's libc++_shared.so ourselves via addObjectFile.
+        .link_libcpp = target.result.abi != .android,
+    });
+
+    // ── XINCLI: @cImport include path for android ──────────────────────
+    // We skipped linkLibC() for android (it emits -lm -lc -ldl that fail).
+    // The libc file's include_dir points at Termux's real $PREFIX/include
+    // (set by build-native-termux.sh). @cImport reads it from there.
+    //
+    // The arch-specific asm/ headers live at $PREFIX/include/aarch64-linux-android/
+    // which isn't in the default search path. Add it via addSystemIncludePath
+    // so @cImport finds <asm/sigcontext.h> etc. This ONLY affects @cImport
+    // (C) — C++ compilation doesn't use module include paths for system headers.
+    if (target.result.abi == .android) {
+        if (std.posix.getenv("XINCLI_ANDROID_ASM_INCLUDE")) |asm_inc| {
+            module.addSystemIncludePath(.{ .cwd_relative = asm_inc });
+        }
+    }
+
+    applyDependencies(b, module, optimize, target, build_options);
+
+    const lib = b.addLibrary(.{
+        .name = LIB_NAME,
+        .root_module = module,
+        .linkage = .dynamic,
+    });
+
+    // No special flags needed — Zig bundles compiler_rt (ARM atomics)
+
+    // ── XINCLI: Android native build (Termux) ───────────────────────────
+    // On Termux, Zig's --sysroot flag makes ld.lld look at <sysroot>/usr/lib/
+    // which doesn't exist (Termux's libs are at <sysroot>/lib/). We add the
+    // real lib paths explicitly via addLibraryPath, reading them from the
+    // XINCLI_ANDROID_LIB_SEARCH_PATHS env var (colon-separated) set by
+    // build-native-termux.sh.
+    //
+    // This is done in build.zig (not via LDFLAGS) because Zig's ld.lld
+    // doesn't respect the LDFLAGS env var — only flags passed through the
+    // build system reach the linker.
+
+    addNativeAudioDependencies(b, lib, target, macos_sdk_path);
+    addYogaDependencies(b, lib, target);
+
+    // Add Termux lib search paths for the linker
+    if (target.result.abi == .android) {
+        if (std.posix.getenv("XINCLI_ANDROID_LIB_SEARCH_PATHS")) |paths| {
+            var it = std.mem.splitScalar(u8, paths, ':');
+            while (it.next()) |path| {
+                if (path.len > 0) {
+                    lib.addLibraryPath(.{ .cwd_relative = path });
+                }
+            }
+        }
+
+        // ── XINCLI: Set RPATH — $PREFIX/lib FIRST, then /system/lib64 ───
+        // Order matters! $PREFIX/lib must come FIRST so the linker finds:
+        //   - Termux's libc++_shared.so (has __ndk1 symbols)
+        // Before:
+        //   - System's libc++_shared.so (does NOT have __ndk1 symbols)
+        //
+        // /system/lib64 is still searched for Bionic libc/libm/libdl —
+        // those don't exist in $PREFIX/lib (well, they do now from our
+        // dd copies, but the system versions are already-loaded so no TLS crash).
+        if (std.posix.getenv("XINCLI_ANDROID_LIB_PATH")) |termux_lib| {
+            lib.addRPath(.{ .cwd_relative = termux_lib });
+        }
+        lib.addRPath(.{ .cwd_relative = "/system/lib64" });
+        
+        // Link Termux's libc++_shared.so — creates NEEDED: libc++_shared.so.
+        // RUNPATH includes $PREFIX/lib so the linker finds Termux's version
+        // (which has __ndk1 symbols + __gxx_personality_v0).
+        if (std.posix.getenv("XINCLI_ANDROID_LIBCXX_PATH")) |cxx_path| {
+            lib.addObjectFile(.{ .cwd_relative = cxx_path });
+        }
+    }
+
+    const install_dir = b.addInstallArtifact(lib, .{
+        .dest_dir = .{
+            .override = .{
+                .custom = try std.fmt.allocPrint(b.allocator, "../lib/{s}", .{output_name}),
+            },
+        },
+    });
+
+    const build_step_name = try std.fmt.allocPrint(b.allocator, "build-{s}", .{output_name});
+    const build_step = b.step(build_step_name, try std.fmt.allocPrint(b.allocator, "Build for {s}", .{description}));
+    build_step.dependOn(&install_dir.step);
+
+    b.getInstallStep().dependOn(&install_dir.step);
+}