const std = @import("std");
const llvm = @import("llvm_api.zig");
const c = llvm.c;

/// One `#jni_main #jni_class("...")` declaration's Java-source emission.
/// Populated by lowering and surfaced to the sx Android bundler in
/// `library/modules/platform/bundle.sx` via `BuildConfig.jni_main_*`,
/// which writes a `.java` file under `<stage>/java/<pkg>/<Cls>.java`,
/// compiles via `javac`, dexes via `d8`, and bundles the resulting
/// `classes.dex` into the APK.
pub const JniMainEmission = struct {
    /// foreign_path of the source decl (e.g. "co/swipelab/sxmain/SxApp").
    /// Splits into package + class name for `<stage>/java/<pkg>/<Class>.java`.
    foreign_path: []const u8,
    /// Pre-rendered Java source bytes (from `jni_java_emit.emitJavaSource`).
    java_source: []const u8,
};

pub const TargetConfig = struct {
    /// Target triple (e.g. "aarch64-apple-darwin"). Null = host default.
    triple: ?[*:0]const u8 = null,
    /// CPU name (e.g. "generic", "apple-m1"). Null = "generic".
    cpu: ?[*:0]const u8 = null,
    /// CPU features string (e.g. "+avx2"). Null = "".
    features: ?[*:0]const u8 = null,
    /// Optimization level.
    opt_level: OptLevel = .default,
    /// Library search paths (-L flags).
    lib_paths: []const []const u8 = &.{},
    /// Framework search paths (-F flags). Apple-only.
    framework_paths: []const []const u8 = &.{},
    /// Output path override.
    output_path: ?[]const u8 = null,
    /// Linker command (null = "cc" on Unix, "link.exe" on Windows).
    linker: ?[]const u8 = null,
    /// Sysroot for cross-compilation (passed as --sysroot to linker).
    sysroot: ?[]const u8 = null,
    /// Extra flags passed through to the linker (e.g. Emscripten -s flags).
    extra_link_flags: []const []const u8 = &.{},
    /// Custom WASM shell template path (overrides the built-in template).
    wasm_shell_path: ?[]const u8 = null,
    /// Path to a `.app` bundle directory to produce (iOS/macOS). When set, the
    /// linker output is moved into the bundle alongside a generated Info.plist
    /// and ad-hoc signed for simulator runs.
    bundle_path: ?[]const u8 = null,
    /// CFBundleIdentifier for the bundle (e.g. "co.swipelab.sxhello").
    /// Required when `bundle_path` is set. On Android, doubles as the
    /// AndroidManifest package="..." attribute.
    bundle_id: ?[]const u8 = null,
    /// Path to a `.apk` file to produce (Android). When set, the linked
    /// `.so` is wrapped into a debug-signed APK ready for `adb install`.
    apk_path: ?[]const u8 = null,
    /// Custom AndroidManifest.xml path. When null, a minimal NativeActivity
    /// manifest is generated from `bundle_id`.
    manifest_path: ?[]const u8 = null,
    /// Debug keystore for APK signing. Defaults to `~/.android/debug.keystore`.
    keystore_path: ?[]const u8 = null,
    /// Codesigning identity (e.g. `"Apple Development: Alex (TEAMID)"` or a
    /// SHA-1 fingerprint from `security find-identity -p codesigning`).
    /// When null, ad-hoc signs with `-` (sufficient for simulator, not device).
    codesign_identity: ?[]const u8 = null,
    /// Path to a `.mobileprovision` to embed as `embedded.mobileprovision`.
    /// Required for real-device builds.
    provisioning_profile: ?[]const u8 = null,
    /// Path to an entitlements plist. When null and `provisioning_profile`
    /// is set, the entitlements are auto-extracted from the profile.
    entitlements_path: ?[]const u8 = null,
    /// True when emitting an ahead-of-time binary (`sx build`), false for
    /// in-process JIT (`sx run`). Used by emit_llvm to gate code that only
    /// makes sense for a standalone executable — e.g. the macOS bundle
    /// `chdir` shouldn't run in JIT mode because it would mutate the host
    /// sx process's CWD.
    is_aot: bool = false,

    pub const OptLevel = enum {
        none,
        less,
        default,
        aggressive,

        pub fn toLLVM(self: OptLevel) c.LLVMCodeGenOptLevel {
            return switch (self) {
                .none => c.LLVMCodeGenLevelNone,
                .less => c.LLVMCodeGenLevelLess,
                .default => c.LLVMCodeGenLevelDefault,
                .aggressive => c.LLVMCodeGenLevelAggressive,
            };
        }
    };

    /// Check if target triple indicates aarch64/arm64 (runtime check, not comptime).
    pub fn isAarch64(self: TargetConfig) bool {
        return self.tripleHasPrefix("aarch64", "arm64");
    }

    /// Check if target triple indicates x86_64/x86-64.
    pub fn isX86_64(self: TargetConfig) bool {
        return self.tripleHasPrefix("x86_64", "x86-64");
    }

    /// Check if target triple indicates Windows (contains "windows" or "win32").
    pub fn isWindows(self: TargetConfig) bool {
        return self.tripleContains("windows") or self.tripleContains("win32");
    }

    /// Check if target triple indicates WebAssembly (wasm32 or wasm64).
    pub fn isWasm(self: TargetConfig) bool {
        return self.tripleHasPrefix("wasm32", "wasm64");
    }

    /// Check if target triple indicates wasm32 specifically (4-byte pointers, i32 size_t).
    pub fn isWasm32(self: TargetConfig) bool {
        return self.tripleHasPrefix("wasm32", "wasm32");
    }

    /// Check if target triple indicates wasm64 specifically (8-byte pointers, i64 size_t).
    pub fn isWasm64(self: TargetConfig) bool {
        return self.tripleHasPrefix("wasm64", "wasm64");
    }

    /// Check if target triple indicates macOS/Darwin (does not match iOS).
    pub fn isMacOS(self: TargetConfig) bool {
        if (self.isIOS()) return false;
        return self.tripleContains("darwin") or self.tripleContains("macos");
    }

    /// Check if target triple indicates iOS (device or simulator).
    pub fn isIOS(self: TargetConfig) bool {
        return self.tripleContains("-apple-ios");
    }

    /// Check if target triple indicates the iOS Simulator.
    pub fn isIOSSimulator(self: TargetConfig) bool {
        return self.isIOS() and self.tripleContains("simulator");
    }

    /// Check if target triple indicates a real iOS device (not Simulator).
    pub fn isIOSDevice(self: TargetConfig) bool {
        return self.isIOS() and !self.tripleContains("simulator");
    }

    /// Check if target triple indicates Linux (NOT Android — Android uses
    /// "linux-android" too but isAndroid() must take precedence).
    pub fn isLinux(self: TargetConfig) bool {
        if (self.isAndroid()) return false;
        return self.tripleContains("linux");
    }

    /// Check if target triple indicates Android (e.g. aarch64-linux-android21).
    pub fn isAndroid(self: TargetConfig) bool {
        return self.tripleContains("android");
    }

    /// Check if target triple indicates Emscripten (contains "emscripten").
    pub fn isEmscripten(self: TargetConfig) bool {
        return self.tripleContains("emscripten");
    }

    fn tripleHasPrefix(self: TargetConfig, prefix1: []const u8, prefix2: []const u8) bool {
        if (self.triple) |t| {
            const span = std.mem.span(t);
            return std.mem.startsWith(u8, span, prefix1) or std.mem.startsWith(u8, span, prefix2);
        }
        const dt = c.LLVMGetDefaultTargetTriple();
        defer c.LLVMDisposeMessage(dt);
        const span = std.mem.span(dt);
        return std.mem.startsWith(u8, span, prefix1) or std.mem.startsWith(u8, span, prefix2);
    }

    fn tripleContains(self: TargetConfig, needle: []const u8) bool {
        if (self.triple) |t| {
            return std.mem.indexOf(u8, std.mem.span(t), needle) != null;
        }
        const dt = c.LLVMGetDefaultTargetTriple();
        defer c.LLVMDisposeMessage(dt);
        return std.mem.indexOf(u8, std.mem.span(dt), needle) != null;
    }

    pub fn getCpu(self: TargetConfig) [*:0]const u8 {
        return self.cpu orelse "generic";
    }

    pub fn getFeatures(self: TargetConfig) [*:0]const u8 {
        return self.features orelse "";
    }

    pub fn getLinker(self: TargetConfig) []const u8 {
        return self.linker orelse "cc";
    }
};

/// Execute a precompiled object file in-process using LLVM's ORC JIT.
/// Takes ownership of obj_buf. Returns the exit code from main().
pub fn runJITFromObject(obj_buf: c.LLVMMemoryBufferRef) !u8 {
    // Create LLJIT with default builder (no custom TM needed — .o is precompiled)
    var jit: c.LLVMOrcLLJITRef = null;
    var err = c.LLVMOrcCreateLLJIT(&jit, null);
    if (err != null) {
        const msg = c.LLVMGetErrorMessage(err);
        defer c.LLVMDisposeErrorMessage(msg);
        std.debug.print("JIT error: {s}\n", .{std.mem.span(msg)});
        return error.CompileError;
    }
    defer _ = c.LLVMOrcDisposeLLJIT(jit);

    // Add process symbols so JIT can find libc (printf, etc.)
    const jd = c.LLVMOrcLLJITGetMainJITDylib(jit);
    const prefix = c.LLVMOrcLLJITGetGlobalPrefix(jit);
    var gen: c.LLVMOrcDefinitionGeneratorRef = null;
    err = c.LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(&gen, prefix, null, null);
    if (err != null) {
        const msg = c.LLVMGetErrorMessage(err);
        defer c.LLVMDisposeErrorMessage(msg);
        std.debug.print("JIT symbol gen error: {s}\n", .{std.mem.span(msg)});
        return error.CompileError;
    }
    c.LLVMOrcJITDylibAddGenerator(jd, gen);

    // Add precompiled object file (transfers ownership of obj_buf)
    err = c.LLVMOrcLLJITAddObjectFile(jit, jd, obj_buf);
    if (err != null) {
        const msg = c.LLVMGetErrorMessage(err);
        defer c.LLVMDisposeErrorMessage(msg);
        std.debug.print("JIT add object error: {s}\n", .{std.mem.span(msg)});
        return error.CompileError;
    }

    // Look up the "main" function
    var main_addr: c.LLVMOrcExecutorAddress = 0;
    err = c.LLVMOrcLLJITLookup(jit, &main_addr, "main");
    if (err != null) {
        const msg = c.LLVMGetErrorMessage(err);
        defer c.LLVMDisposeErrorMessage(msg);
        std.debug.print("JIT lookup error: {s}\n", .{std.mem.span(msg)});
        return error.CompileError;
    }

    // Cast to function pointer and call
    const main_fn: *const fn () callconv(.c) i32 = @ptrFromInt(main_addr);
    const result = main_fn();
    return if (result >= 0 and result <= 255) @intCast(result) else 1;
}

// Android APK bundling (createApk, compileJniMainSources,
// buildAndroidManifest, buildJniMainManifest, ensureDebugKeystore,
// libNameFromSoBasename + helpers) has moved to
// `library/modules/platform/bundle.sx`. `src/main.zig` invokes it
// post-link via the BuildOptions callback registered from sx code.
// `--apk <path>` on the CLI is a transitional alias that feeds
// `bundle_path` so the auto-fallback to `platform.bundle.bundle_main`
// fires; programs that opt in via `set_post_link_callback` reach the
// sx bundler directly.


/// Discover the Android NDK root. Honors $ANDROID_NDK_HOME / $ANDROID_NDK_ROOT,
/// otherwise picks the highest-versioned NDK under $HOME/Library/Android/sdk/ndk
/// (the SDK Manager default install location on macOS). Caller owns the slice.
pub fn discoverAndroidNdk(allocator: std.mem.Allocator, io: std.Io) ![]const u8 {
    if (std.c.getenv("ANDROID_NDK_HOME")) |env| {
        return try allocator.dupe(u8, std.mem.span(env));
    }
    if (std.c.getenv("ANDROID_NDK_ROOT")) |env| {
        return try allocator.dupe(u8, std.mem.span(env));
    }
    const home_env = std.c.getenv("HOME") orelse {
        std.debug.print("error: cannot locate Android NDK \u{2014} set $ANDROID_NDK_HOME\n", .{});
        return error.NdkNotFound;
    };
    const home = std.mem.span(home_env);
    const ndk_root = try std.fmt.allocPrint(allocator, "{s}/Library/Android/sdk/ndk", .{home});
    var dir = std.Io.Dir.openDir(.cwd(), io, ndk_root, .{ .iterate = true }) catch {
        std.debug.print("error: no NDK at {s} \u{2014} install via Android Studio or set $ANDROID_NDK_HOME\n", .{ndk_root});
        return error.NdkNotFound;
    };
    defer dir.close(io);
    var best: ?[]const u8 = null;
    var it = dir.iterate();
    while (it.next(io) catch null) |entry| {
        if (entry.kind != .directory) continue;
        if (best == null or std.mem.order(u8, entry.name, best.?) == .gt) {
            best = try allocator.dupe(u8, entry.name);
        }
    }
    const version = best orelse {
        std.debug.print("error: no NDK versions under {s}\n", .{ndk_root});
        return error.NdkNotFound;
    };
    return try std.fmt.allocPrint(allocator, "{s}/{s}", .{ ndk_root, version });
}

/// Run `xcrun --sdk <sdk_name> --show-sdk-path` and return the trimmed path.
/// Caller owns the returned slice.
pub fn discoverAppleSdk(allocator: std.mem.Allocator, io: std.Io, sdk_name: []const u8) ![]const u8 {
    const r = std.process.run(allocator, io, .{
        .argv = &.{ "xcrun", "--sdk", sdk_name, "--show-sdk-path" },
    }) catch |e| {
        std.debug.print("error: failed to run xcrun: {} \u{2014} install Xcode Command Line Tools (xcode-select --install)\n", .{e});
        return error.SdkNotFound;
    };
    defer allocator.free(r.stderr);
    errdefer allocator.free(r.stdout);
    if (r.term != .exited or r.term.exited != 0) {
        std.debug.print("error: xcrun --sdk {s} --show-sdk-path failed\n", .{sdk_name});
        allocator.free(r.stdout);
        return error.SdkNotFound;
    }
    const trimmed = std.mem.trimEnd(u8, r.stdout, " \t\r\n");
    const out = try allocator.dupe(u8, trimmed);
    allocator.free(r.stdout);
    return out;
}

pub fn link(allocator: std.mem.Allocator, io: std.Io, output_obj: []const u8, extra_objects: []const []const u8, output_bin: []const u8, libraries: []const []const u8, frameworks: []const []const u8, target_config: TargetConfig, has_jni_main: bool) !void {
    var argv = std.ArrayList([]const u8).empty;

    if (target_config.isIOS()) {
        // iOS: clang driver with -isysroot pointing at the iOS SDK.
        // -l libraries are generally wrong for iOS (Apple ships system code
        // as frameworks); user-declared #library still pass through.
        const linker = target_config.linker orelse "clang";
        try argv.append(allocator, linker);
        if (target_config.triple) |t| {
            try argv.append(allocator, "-target");
            try argv.append(allocator, std.mem.span(t));
        }
        const sdk_path = if (target_config.sysroot) |sr|
            try allocator.dupe(u8, sr)
        else blk: {
            const sdk_name: []const u8 = if (target_config.isIOSSimulator()) "iphonesimulator" else "iphoneos";
            break :blk try discoverAppleSdk(allocator, io, sdk_name);
        };
        try argv.append(allocator, "-isysroot");
        try argv.append(allocator, sdk_path);
        const min_flag: []const u8 = if (target_config.isIOSSimulator()) "-mios-simulator-version-min=14.0" else "-mios-version-min=14.0";
        try argv.append(allocator, min_flag);
        // Embedded framework load path: bundle/Frameworks at runtime.
        try argv.append(allocator, "-Wl,-rpath,@executable_path/Frameworks");
        try argv.append(allocator, output_obj);
        try argv.append(allocator, "-o");
        try argv.append(allocator, output_bin);
        for (extra_objects) |eo| try argv.append(allocator, eo);
        for (target_config.lib_paths) |lp| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "-L{s}", .{lp}));
        }
        for (target_config.framework_paths) |fp| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "-F{s}", .{fp}));
        }
        for (libraries) |lib| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "-l{s}", .{lib}));
        }
        for (frameworks) |fw| {
            try argv.append(allocator, "-framework");
            try argv.append(allocator, fw);
        }
        for (target_config.extra_link_flags) |flag| {
            var it = std.mem.tokenizeScalar(u8, flag, ' ');
            while (it.next()) |part| try argv.append(allocator, part);
        }
    } else if (target_config.isAndroid()) {
        // Android: NDK clang. Produces a shared library (.so).
        //
        // Two entry shapes:
        //
        //   - **#jni_main path (`has_jni_main = true`)** — the Java side
        //     drives lifecycle (the bundled classes.dex declares an
        //     Activity that overrides `onCreate` etc.). The .so just
        //     provides JNI implementations bound at load time via the
        //     `JNI_OnLoad` synthesized in slice R.3. No native_app_glue
        //     is needed: there's no `ANativeActivity_onCreate` to host,
        //     no `android_main` event loop to run.
        //
        //   - **Legacy NativeActivity path (`has_jni_main = false`)** —
        //     native_app_glue.c is compiled and linked alongside the sx
        //     code; the glue owns `ANativeActivity_onCreate` and forwards
        //     into the user's `android_main` on a worker thread. The
        //     `-u ANativeActivity_onCreate` keeps the glue's symbol from
        //     being stripped (nothing in our .o references it).
        //
        // The `libraries` parameter (collected from `#library` directives)
        // and `frameworks` parameter (Apple-only by definition) are
        // intentionally ignored here. On Android, users opt into specific
        // libs via `opts.add_link_flag("-l<name>")` in their build.sx —
        // the platform-specific link surface should be expressed in build
        // options rather than auto-inherited from every imported module
        // (most of which assume Apple targets).
        const ndk_root = if (target_config.sysroot) |sr|
            try allocator.dupe(u8, sr)
        else
            try discoverAndroidNdk(allocator, io);
        const host_tag: []const u8 = if (@import("builtin").os.tag == .macos) "darwin-x86_64" else "linux-x86_64";
        const clang = try std.fmt.allocPrint(allocator, "{s}/toolchains/llvm/prebuilt/{s}/bin/clang", .{ ndk_root, host_tag });

        const glue_obj_opt: ?[]const u8 = if (has_jni_main) null else blk: {
            const glue_src = try std.fmt.allocPrint(allocator, "{s}/sources/android/native_app_glue/android_native_app_glue.c", .{ndk_root});
            const glue_obj = try std.fmt.allocPrint(allocator, "{s}.glue.o", .{output_obj});
            var glue_argv = std.ArrayList([]const u8).empty;
            try glue_argv.appendSlice(allocator, &.{ clang, "-c", "-fPIC" });
            if (target_config.triple) |t| {
                try glue_argv.append(allocator, "-target");
                try glue_argv.append(allocator, std.mem.span(t));
            }
            try glue_argv.appendSlice(allocator, &.{ glue_src, "-o", glue_obj });
            const glue_slice = try glue_argv.toOwnedSlice(allocator);
            var glue_child = std.process.spawn(io, .{ .argv = glue_slice }) catch return error.LinkError;
            const glue_term = glue_child.wait(io) catch return error.LinkError;
            if (glue_term != .exited or glue_term.exited != 0) return error.LinkError;
            break :blk glue_obj;
        };

        try argv.append(allocator, clang);
        if (target_config.triple) |t| {
            try argv.append(allocator, "-target");
            try argv.append(allocator, std.mem.span(t));
        }
        try argv.append(allocator, "-shared");
        try argv.append(allocator, "-fPIC");
        if (!has_jni_main) {
            try argv.appendSlice(allocator, &.{ "-u", "ANativeActivity_onCreate" });
        }
        try argv.append(allocator, output_obj);
        if (glue_obj_opt) |go| try argv.append(allocator, go);
        for (extra_objects) |eo| try argv.append(allocator, eo);
        try argv.append(allocator, "-o");
        try argv.append(allocator, output_bin);
        for (target_config.lib_paths) |lp| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "-L{s}", .{lp}));
        }
        // Default libs available on every Android runtime; linker drops
        // unreferenced ones automatically. `#library` directives are
        // intentionally NOT auto-emitted here (most assume Apple targets);
        // users opt in per-target via `opts.add_link_flag("-l...")` in
        // their build.sx.
        try argv.appendSlice(allocator, &.{ "-llog", "-landroid", "-lEGL", "-lGLESv3", "-lm", "-ldl" });
        for (target_config.extra_link_flags) |flag| {
            var it = std.mem.tokenizeScalar(u8, flag, ' ');
            while (it.next()) |part| try argv.append(allocator, part);
        }
    } else if (target_config.isEmscripten()) {
        // Emscripten: use emcc as the linker/driver
        const linker = target_config.linker orelse "emcc";
        try argv.appendSlice(allocator, &.{ linker, output_obj, "-o", output_bin });
        for (extra_objects) |eo| try argv.append(allocator, eo);

        if (target_config.sysroot) |sr| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "--sysroot={s}", .{sr}));
        }

        for (target_config.lib_paths) |lp| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "-L{s}", .{lp}));
        }
        // Skip -l flags for Emscripten: libraries like SDL3 are provided via
        // -sUSE_SDL=3, not -lSDL3. User provides everything via --lflags.

        // wasm64: automatically add -sMEMORY64 for the linker
        if (target_config.isWasm64()) {
            try argv.append(allocator, "-sMEMORY64");
        }

        // HTML shell template: use custom path if set, otherwise write built-in template to temp file
        if (std.mem.endsWith(u8, output_bin, ".html")) {
            if (target_config.wasm_shell_path) |custom_shell| {
                try argv.appendSlice(allocator, &.{ "--shell-file", custom_shell });
            } else {
                const shell_html = @embedFile("wasm_shell.html");
                const shell_path = try std.fmt.allocPrint(allocator, "{s}.shell.html", .{output_obj});
                std.Io.Dir.writeFile(.cwd(), io, .{ .sub_path = shell_path, .data = shell_html }) catch {};
                try argv.appendSlice(allocator, &.{ "--shell-file", shell_path });
            }
        }

        // Extra linker flags (e.g. -sUSE_SDL=3, -sUSE_WEBGL2=1, --preload-file assets)
        // Split space-separated flags into individual argv entries.
        for (target_config.extra_link_flags) |flag| {
            var it = std.mem.tokenizeScalar(u8, flag, ' ');
            while (it.next()) |part| {
                try argv.append(allocator, part);
            }
        }
    } else if (target_config.isWindows()) {
        // Windows: MSVC-style linker flags
        const linker = target_config.linker orelse "link.exe";
        try argv.appendSlice(allocator, &.{ linker, output_obj });
        for (extra_objects) |eo| try argv.append(allocator, eo);
        try argv.append(allocator, try std.fmt.allocPrint(allocator, "/OUT:{s}", .{output_bin}));

        for (target_config.lib_paths) |lp| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "/LIBPATH:{s}", .{lp}));
        }
        for (libraries) |lib| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "{s}.lib", .{lib}));
        }
    } else {
        // Unix: cc-style linker flags
        try argv.appendSlice(allocator, &.{ target_config.getLinker(), output_obj, "-o", output_bin });
        for (extra_objects) |eo| try argv.append(allocator, eo);

        if (target_config.sysroot) |sr| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "--sysroot={s}", .{sr}));
        }

        // User-supplied library paths first
        for (target_config.lib_paths) |lp| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "-L{s}", .{lp}));
        }

        // Auto-detect host OS library paths when linking foreign libraries
        if (libraries.len > 0 and target_config.triple == null) {
            for (host_lib_paths) |path| {
                try argv.append(allocator, try std.fmt.allocPrint(allocator, "-L{s}", .{path}));
            }
        }

        for (libraries) |lib| {
            try argv.append(allocator, try std.fmt.allocPrint(allocator, "-l{s}", .{lib}));
        }

        // Frameworks: only meaningful on Apple targets; silently ignored elsewhere.
        if (target_config.isMacOS()) {
            for (frameworks) |fw| {
                try argv.append(allocator, "-framework");
                try argv.append(allocator, fw);
            }
        }

        // Extra linker flags — split space-separated flags into individual argv entries.
        for (target_config.extra_link_flags) |flag| {
            var it = std.mem.tokenizeScalar(u8, flag, ' ');
            while (it.next()) |part| {
                try argv.append(allocator, part);
            }
        }
    }

    const argv_slice = try argv.toOwnedSlice(allocator);
    if (std.c.getenv("SX_DEBUG_LINK") != null) {
        std.debug.print("[sx] link argv:", .{});
        for (argv_slice) |a| std.debug.print(" {s}", .{a});
        std.debug.print("\n", .{});
    }
    var child = std.process.spawn(io, .{
        .argv = argv_slice,
    }) catch return error.LinkError;
    const result = child.wait(io) catch return error.LinkError;
    if (result != .exited) return error.LinkError;
    if (result.exited != 0) return error.LinkError;
}

// Apple .app bundling (createBundle, embedFramework, extractEntitlements,
// buildInfoPlist, codesign) has moved to
// `library/modules/platform/bundle.sx`. `src/main.zig` invokes it
// post-link via the BuildOptions callback registered from sx code.

/// After emcc produces HTML output, inject cache-busting hashes into the
/// generated <script> tag and add Module.locateFile for .wasm/.data files.
pub fn postProcessWasmHtml(allocator: std.mem.Allocator, io: std.Io, html_path: []const u8) void {
    const base = if (std.mem.endsWith(u8, html_path, ".html"))
        html_path[0 .. html_path.len - 5]
    else
        return;

    // Hash build output contents (.js + .wasm + optional .data)
    var hash: u64 = 0;
    const exts = [_][]const u8{ ".js", ".wasm", ".data" };
    for (exts) |ext| {
        const path = std.fmt.allocPrint(allocator, "{s}{s}", .{ base, ext }) catch continue;
        if (std.Io.Dir.readFileAlloc(.cwd(), io, path, allocator, .limited(64 * 1024 * 1024))) |data| {
            hash = std.hash.Wyhash.hash(hash, data);
        } else |_| {}
    }

    const hash_hex = std.fmt.allocPrint(allocator, "{x:0>8}", .{@as(u32, @truncate(hash))}) catch return;

    // Read the final HTML produced by emcc
    const html = std.Io.Dir.readFileAlloc(.cwd(), io, html_path, allocator, .limited(10 * 1024 * 1024)) catch return;

    var out = std.ArrayList(u8).empty;
    var pos: usize = 0;
    var injected_locateFile = false;

    // Find emcc's generated script tag: <script ...src="*.js"></script>
    // Inject ?v=HASH into the src and prepend a Module.locateFile script.
    while (std.mem.indexOfPos(u8, html, pos, "src=\"")) |src_start| {
        const val_start = src_start + 5; // past src="
        const val_end = std.mem.indexOfPos(u8, html, val_start, "\"") orelse break;
        const src_val = html[val_start..val_end];

        if (!std.mem.endsWith(u8, src_val, ".js")) {
            // Not a .js src — skip past this attribute and keep searching
            pos = val_end + 1;
            continue;
        }

        // Find the opening < of this tag to inject locateFile before it
        const tag_start = if (std.mem.lastIndexOf(u8, html[pos..src_start], "<")) |off| pos + off else src_start;

        // Copy everything up to the tag start
        out.appendSlice(allocator, html[pos..tag_start]) catch return;

        // Inject Module.locateFile once, before the first .js script tag
        if (!injected_locateFile) {
            out.appendSlice(allocator, "<script>Module.locateFile=function(p){return p+'?v=") catch return;
            out.appendSlice(allocator, hash_hex) catch return;
            out.appendSlice(allocator, "'}</script>\n") catch return;
            injected_locateFile = true;
        }

        // Copy tag up to the closing quote of src, inserting ?v=HASH
        out.appendSlice(allocator, html[tag_start..val_end]) catch return;
        out.appendSlice(allocator, "?v=") catch return;
        out.appendSlice(allocator, hash_hex) catch return;

        pos = val_end;
    }
    // Copy remaining HTML
    out.appendSlice(allocator, html[pos..]) catch return;

    const final = out.toOwnedSlice(allocator) catch return;
    std.Io.Dir.writeFile(.cwd(), io, .{ .sub_path = html_path, .data = final }) catch {};
}

/// Common library paths for the host OS, computed at comptime.
pub const host_lib_paths = blk: {
    const builtin = @import("builtin");
    var paths: []const []const u8 = &.{};
    if (builtin.os.tag == .macos) {
        if (builtin.cpu.arch == .aarch64) {
            // Apple Silicon Homebrew
            paths = &.{ "/opt/homebrew/lib", "/usr/local/lib" };
        } else {
            // Intel Mac Homebrew
            paths = &.{"/usr/local/lib"};
        }
    } else if (builtin.os.tag == .linux) {
        paths = &.{ "/usr/local/lib", "/usr/lib" };
    }
    break :blk paths;
};