const std = @import("std"); const builtin = @import("builtin"); const mupdf_build = @import("mupdf.zig"); const snap_build = @import("build/snap.zig"); const grammar_manifest = @import("src/grammar_manifest.zig"); /// The package manifest, imported UNTYPED on purpose — see the `version` /// option in `shellOptions` for why that word is load-bearing. const zon = @import("build.zig.zon"); /// Releases are numbered 0.N; the zon holds "0.N.0" because it must be semver, /// and what a user sees drops that ".0". const display_version = if (std.mem.endsWith(u8, zon.version, ".0") and std.mem.count(u8, zon.version, ".") == 2) zon.version[0 .. zon.version.len - 2] else zon.version; /// Every dependency the manifest pins, by its content hash: a grammar, /// ghostty or the Unicode tables steps a core differently, so they are part /// of a replica's semantics hash (src/wire.zig `semantics`). const deps_text = blk: { var text: []const u8 = ""; for (@typeInfo(@TypeOf(zon.dependencies)).@"struct".field_names) |name| { const dep = @field(zon.dependencies, name); text = text ++ name ++ " " ++ (if (@hasField(@TypeOf(dep), "hash")) dep.hash else "path") ++ "\n"; } break :blk text; }; pub const Platform = enum { tui, gui, macos }; const PerfBuild = struct { compiler: []const u8, target: []const u8, cpu: []const u8, driver_optimize: []const u8, core_optimize: []const u8, c_optimize: []const u8, terminal_optimize: []const u8, platform: []const u8, grammars: []const u8, mupdf: bool, jpx: bool, tracy: bool, terminal_simd: bool, prebuilt_shaders: bool, }; pub const macos_min_version: std.SemanticVersion = .{ .major = 13, .minor = 0, .patch = 0 }; pub const TreeSitterGrammars = enum { disabled, zig, minimal, full }; const gui_shaders = [_][]const u8{ "ui.vert", "ui.frag", "decor.frag", "overlay.vert", "overlay.frag", "image.vert", "image.frag", }; pub fn build(b: *std.Build) void { const requested_platform = b.option(Platform, "platform", "which shell to build (tui, gui, macos); absent builds the tui cli and the SDL gui together"); const platform = requested_platform orelse .tui; const also_gui = requested_platform == null; // A bare `zig build` also copies the binaries into ~/.local/bin. Zig // 0.17 keeps the prefix in the maker process, out of this script's // reach, so `--prefix` no longer turns it off: -Dhome-install=false does. const home_bin: ?[]const u8 = if (also_gui and (b.option(bool, "home-install", "a bare `zig build` also copies the binaries into ~/.local/bin (default: true)") orelse true)) if (b.graph.environ_map.get("HOME")) |home| b.pathJoin(&.{ home, ".local", "bin" }) else null else null; const home_install = home_bin != null; const target = b.standardTargetOptions(.{ .default_target = switch (platform) { .macos => if (builtin.os.tag.isDarwin()) .{ .cpu_arch = builtin.target.cpu.arch, .os_tag = .macos, .os_version_min = .{ .semver = macos_min_version }, } else .{}, .tui, .gui => .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .gnu, .glibc_version = .{ .major = 2, .minor = 38, .patch = 0 }, }, }, }); const optimize = b.standardOptimizeOption(.{}); const static = b.option(bool, "static", "statically link") orelse false; // one substring, because that is what a dev loop needs: see the unit-test // step for why the whole-binary run is worth narrowing const test_filters: []const []const u8 = if (b.option([]const u8, "test-filter", "run only tests whose name contains this")) |f| &.{f} else &.{}; const enable_mupdf = b.option(bool, "mupdf", "build the pdf addon, PDF panes over MuPDF (AGPL/commercial; default on; -Dmupdf=false leaves it out)") orelse true; const enable_jpx = b.option(bool, "jpx", "JPEG 2000 in PDFs, for scanned documents (default on; -Djpx=false drops openjpeg)") orelse true; const embed_sources = b.option(bool, "embed-sources", "serve the editor's own sources under /src of its 9P tree (default off)") orelse false; const test_build = b.step("test-build", "compile unit-test programs without running them"); const doc_typ_opts = b.addOptions(); doc_typ_opts.addOptionPathUntracked("dir", b.path("docs/typ")); // The words the shipped addons bring (PdfFit...), which the docs name too. doc_typ_opts.addOptionPathUntracked("addons", b.path("addons")); // The docs (docs/typ, docs/site): each output is one typst run, and each // reads docs/typ/builtins-*.json; `builtins-json` refreshes this build's from the // registry first (the tool is wired below, once the core module is). const typst_bin: ?[]const u8 = b.findProgram(.{ .names = &.{"typst"} }); var doc_renders: [3]?*std.Build.Step.Run = @splat(null); const cheatsheet_step = b.step("cheatsheet", "render docs/typ/cheatsheet-a4.typ to /share/doc/pardes/cheatsheet.pdf (needs typst)"); const book_step = b.step("book", "render docs/typ/book.typ to /share/doc/pardes/pardes.pdf (needs typst)"); // The website: one Typst bundle run writes every page, the stylesheet, // the fonts and the media (docs/site/site.typ). const site_step = b.step("site", "render the docs website to /share/doc/pardes/site (needs typst)"); if (typst_bin) |typst| { // They read all of docs/typ, docs/site and the tutor, so they always // run rather than track every file. const sheet = b.addSystemCommand(&.{ typst, "compile", "--ignore-system-fonts" }); sheet.addFileArg(b.path("docs/typ/cheatsheet-a4.typ")); sheet.has_side_effects = true; cheatsheet_step.dependOn(&b.addInstallFile(sheet.addOutputFileArg("cheatsheet.pdf"), "share/doc/pardes/cheatsheet.pdf").step); const book = b.addSystemCommand(&.{ typst, "compile", "--ignore-system-fonts", "--root", "." }); book.setCwd(b.path(".")); book.addFileArg(b.path("docs/typ/book.typ")); book.has_side_effects = true; book_step.dependOn(&b.addInstallFile(book.addOutputFileArg("pardes.pdf"), "share/doc/pardes/pardes.pdf").step); const site = b.addSystemCommand(&.{ typst, "compile", "--format", "bundle", "--features", "bundle,html", "--root", "." }); site.setCwd(b.path(".")); site.addFileArg(b.path("docs/site/site.typ")); const site_dir = site.addOutputDirectoryArg("site"); site.has_side_effects = true; site_step.dependOn(&b.addInstallDirectory(.{ .source_dir = site_dir, .install_dir = .prefix, .install_subdir = "share/doc/pardes/site" }).step); doc_renders = .{ sheet, book, site }; } else { cheatsheet_step.dependOn(&b.addFail("zig build cheatsheet needs typst on PATH").step); book_step.dependOn(&b.addFail("zig build book needs typst on PATH").step); site_step.dependOn(&b.addFail("zig build site needs typst on PATH").step); } const test_nonce: ?*std.Build.Module = if (b.option(bool, "test-rebuild", "force fresh Zig test compilation while retaining cached C dependencies") orelse false) blk: { const files = b.addTempFiles(); const source = files.add("test_nonce.zig", b.fmt("pub const nonce = {d};\n", .{std.Io.Clock.awake.now(b.graph.io).nanoseconds})); break :blk b.createModule(.{ .root_source_file = source, .target = target, .optimize = optimize }); } else null; const unit_profile = b.addExecutable(.{ .name = "pardes-unit-profile", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/unit_profile.zig"), }), }); const c_optimize: std.lang.Optimize = if (optimize == .debug) .fast else optimize; const tree_sitter_grammars = b.option(TreeSitterGrammars, "tree-sitter", "tree-sitter grammar set: disabled, zig, minimal (c/c++/zig), full") orelse .full; const tracy = b.option([]const u8, "tracy", "enable Tracy profiling; supply the path to a Tracy source checkout"); const macos_identity = b.option([]const u8, "macos-identity", "codesigning identity for pardes.app (default: ad-hoc)") orelse "-"; const prebuilt_shaders = b.option(bool, "prebuilt-shaders", "embed the committed shaders/prebuilt/*.spv instead of running glslc (default: on for a bare `zig build`, off when -Dplatform names a shell)") orelse also_gui; const mupdf_check = b.step("mupdf-check", "the pdf addon's check: MuPDF compiles, links, renders and searches docs/design.pdf, and its script runs"); const pdf_pointer_bench_step = b.step("pdf-pointer-bench", "time PDF hover and selection gestures and prove their pixels (-Doptimize=ReleaseFast -- [--label L] [--reps N] [--path FILE] [--cell WxH])"); const pdf_scroll_bench_step = b.step("pdf-scroll-bench", "benchmark fast continuous-strip PDF scrolling in ReleaseFast (-Doptimize=ReleaseFast -- [--json] [--reps N] [--warmup N] [--path FILE])"); if (!enable_mupdf) mupdf_check.dependOn(&b.addFail("mupdf-check is unavailable with -Dmupdf=false").step); if (!enable_mupdf) pdf_scroll_bench_step.dependOn(&b.addFail("pdf-scroll-bench is unavailable with -Dmupdf=false").step); if (!enable_mupdf) pdf_pointer_bench_step.dependOn(&b.addFail("pdf-pointer-bench is unavailable with -Dmupdf=false").step); const shaders_step = b.step("shaders", "refresh the committed shaders/prebuilt/*.spv (glslc)"); const update_shaders = b.addUpdateSourceFiles(); for (gui_shaders) |name| { update_shaders.addCopyFileToSource(compileGlsl(b, name), b.fmt("shaders/prebuilt/{s}.spv", .{name})); } shaders_step.dependOn(&update_shaders.step); // build-time IO: slurps the grammars' highlights.scm queries, and reads // vendor/themes to find the theme sources var threaded: std.Io.Threaded = .init(b.allocator, .{}); defer threaded.deinit(); const io = threaded.io(); const root_mod = b.createModule(.{ .target = target, .optimize = optimize, // The macOS shell is a library whose host owns main(): it roots at // its own flat C ABI instead of src/main.zig. .root_source_file = b.path(switch (platform) { .macos => "src/macos.zig", .tui, .gui => "src/main.zig", }), .link_libc = true, }); const core_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("src/pardes.zig"), .link_libc = true, }); const isolated_mod: ?*std.Build.Module = if (platform == .tui) b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("src/main.zig"), .link_libc = true, }) else null; const gui_mod: ?*std.Build.Module = if (also_gui) b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("src/main.zig"), .link_libc = true, }) else null; const CoreMod = struct { mod: ?*std.Build.Module, shell: Platform }; var core_mods_buf: [4]*std.Build.Module = undefined; var core_shells_buf: [4]Platform = undefined; var core_mods_len: usize = 0; // root_mod FIRST: the module map below is folded out of its import table. for ([_]CoreMod{ .{ .mod = root_mod, .shell = platform }, // hxdiff's headless core and pardes-isolate are the primary shell's // configuration compiled two more ways, not two more frontends. .{ .mod = core_module, .shell = platform }, .{ .mod = isolated_mod, .shell = platform }, .{ .mod = gui_mod, .shell = .gui }, }) |entry| if (entry.mod) |m| { core_mods_buf[core_mods_len] = m; core_shells_buf[core_mods_len] = entry.shell; core_mods_len += 1; }; const core_mods = core_mods_buf[0..core_mods_len]; const cloud9 = b.dependency("cloud9", .{ .target = target, .optimize = optimize }).module("cloud9"); for (core_mods) |mod| mod.addImport("cloud9", cloud9); const core_shells = core_shells_buf[0..core_mods_len]; // The conditional dependencies, hoisted so one `wireCore` call at the end // can name them all. The unconditional ones are ordinary consts below. var ts_mod: ?*std.Build.Module = null; var ts_queries_opts: ?*std.Build.Step.Options = null; var ghostty_core_vt: ?*std.Build.Module = null; var ts_libs: std.ArrayList(*std.Build.Step.Compile) = .empty; const theme_gen = b.addExecutable(.{ .name = "pardes-gen-themes", .root_module = b.createModule(.{ .target = b.graph.host, .optimize = .debug, .root_source_file = b.path("tools/gen_themes.zig"), }), }); const run_theme_gen = b.addRunArtifact(theme_gen); const themes_out = run_theme_gen.addOutputDirectoryArg("themes"); for (vendoredThemes(b, io)) |name| run_theme_gen.addFileArg(b.path(b.fmt("vendor/themes/{s}", .{name}))); const themes_mod = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = themes_out.path(b, "list.zig"), }); // forkpty: in libc proper on glibc>=2.34 and darwin; the BSDs keep it in libutil if (target.result.os.tag == .freebsd or target.result.os.tag == .netbsd or target.result.os.tag == .openbsd) root_mod.linkSystemLibrary("util", .{}); // The macOS shell carries the workspace tag row's commands in its native // menu bar; the row itself goes away. `-Dworkspace-tag=true` puts it back. const workspace_tag = b.option(bool, "workspace-tag", "draw the workspace tag row (default: on except on macOS, whose menu bar carries its commands)"); // The commit is a build input: every `jj new` or `jj commit` moves HEAD, // changes the options module and so recompiles every binary that imports // it, which is all of them (~0.6 GB of fresh test objects per move). Only // builds someone keeps are stamped: release builds and the bare // `zig build` that installs into ~/.local. Every other Debug build (any // -Dplatform or --prefix, so every test and snapshot run) prints // `pardes ` alone, like a tarball build; -Dstamp-commit=true // stamps one anyway. const stamp_commit = b.option(bool, "stamp-commit", "embed the git commit in --version and crash records (default: release builds and the ~/.local install)") orelse (optimize != .debug or home_install); const shell_cfg: ShellConfig = .{ .tree_sitter_grammars = tree_sitter_grammars, .tracy = tracy != null, .workspace_tag = workspace_tag, .prebuilt_shaders = prebuilt_shaders, .embed_sources = embed_sources, .commit = if (stamp_commit) gitCommit(b) else null, }; const opts = shellOptions(b, shell_cfg, platform); const gui_opts: ?*std.Build.Step.Options = if (also_gui) shellOptions(b, shell_cfg, .gui) else null; if (tracy) |tracy_path| { for ([_]*std.Build.Module{ root_mod, core_module }) |mod| { mod.addIncludePath(.{ .cwd_relative = tracy_path }); mod.addCSourceFile(.{ .file = .{ .cwd_relative = b.pathJoin(&.{ tracy_path, "public", "TracyClient.cpp" }) }, .flags = &.{ "-DTRACY_ENABLE=1", "-DTRACY_NO_SAMPLING", "-DTRACY_NO_CALLSTACK", "-DTRACY_NO_SYSTEM_TRACING", "-DTRACY_NO_CRASH_HANDLER", "-DTRACY_NO_CODE_TRANSFER", "-fno-sanitize=undefined", }, }); mod.link_libcpp = true; } } if (tree_sitter_grammars != .disabled) { const tree_sitter_mod = b.dependency("tree_sitter", .{ .target = target, .optimize = c_optimize }).module("tree_sitter"); ts_mod = tree_sitter_mod; const ts_queries = b.addOptions(); inline for (grammar_manifest.all) |g| { if (tree_sitter_grammars == .full or (tree_sitter_grammars == .minimal and g.tier != .full) or (tree_sitter_grammars == .zig and g.tier == .zig)) { const dep = b.dependency(g.dep, .{}); const query = configureRead(b, io, dep.builder.root, g.query, 0x100000) catch @panic("read " ++ g.name ++ " highlights"); ts_queries.addOption([]const u8, g.name ++ "_highlights", query); // helix's textobject queries, vendored (vendor/queries); a // grammar without one gets none const objects = configureRead(b, io, b.root, "vendor/queries/" ++ g.name ++ "/textobjects.scm", 0x100000) catch ""; ts_queries.addOption([]const u8, g.name ++ "_textobjects", objects); const lib = b.addLibrary(.{ .name = "tree-sitter-" ++ g.name, .root_module = b.createModule(.{ .target = target, .optimize = c_optimize, .link_libc = true }), .linkage = .static, }); // Every allocation a grammar's external scanner makes goes to the // runtime's allocator, which syntax.zig points at a Zig one: // TREE_SITTER_REUSE_ALLOCATOR for the scanners that use // ts_malloc, and src/tree_sitter_heap.h for the ones that call // malloc themselves. const ts_cflags = [_][]const u8{ "-fno-sanitize=function", "-DTREE_SITTER_REUSE_ALLOCATOR", // Relative to the build root, the compiler's working directory. "-include", "src/tree_sitter_heap.h", }; lib.root_module.addCSourceFile(.{ .file = dep.path(g.src ++ "/parser.c"), .flags = &ts_cflags }); if (g.scanner) lib.root_module.addCSourceFile(.{ .file = dep.path(g.src ++ "/scanner.c"), .flags = &ts_cflags }); lib.root_module.addIncludePath(dep.path(g.src)); ts_libs.append(b.allocator, lib) catch @panic("OOM"); } } ts_queries_opts = ts_queries; } const zstbi_dep = b.dependency("zstbi", .{ .target = target, .optimize = c_optimize }); const zstbi_mod = zstbi_dep.module("root"); // The image addon (addons/image/image.c over stb_image), installed where // the start scan finds it (/lib/pardes/addons) and handed by // path to every test that opens a picture. const image_addon = b.addLibrary(.{ .name = "image", .linkage = .dynamic, .root_module = b.createModule(.{ .target = target, .optimize = c_optimize, .link_libc = true }) }); image_addon.root_module.addIncludePath(b.path("src/kinds")); image_addon.root_module.addIncludePath(zstbi_dep.path("libs/stbi")); image_addon.root_module.addCSourceFile(.{ .file = b.path("addons/image/image.c"), .flags = &.{ "-std=c11", "-Wall", "-Wextra", "-Werror" } }); // mvzr backtracks with no bound on its work (its own test "do not make // this test any longer": `a?` n times is 2^n steps), and pardes searches // with it holding the editor. Its matcher gets a step budget, patched into // the fetched source here at build time so that a fresh fetch keeps it: // each entry to matchPattern, which its backtracking recurses through, // spends a step, and with none left the match fails and says so // (src/regexp.zig). A bump that moves the anchor stops the build. const mvzr_mod = mvzr: { const dep = b.dependency("mvzr", .{ .target = target, .optimize = optimize }); const src = configureRead(b, io, dep.builder.root, "src/mvzr.zig", 1 << 20) catch @panic("read mvzr"); const anchor = "fn matchPattern(patt: []const RegOp, sets: []const CharSet, haystack: []const u8, i_in: usize) ?OpMatch {\n"; const at = (std.mem.indexOf(u8, src, anchor) orelse @panic("mvzr's matchPattern changed: redo its step budget in build.zig")) + anchor.len; const spend = \\ if (steps_left == 0) { \\ exhausted = true; \\ return null; \\ } \\ steps_left -= 1; \\ ; const budget = \\ \\/// pardes's patch (its build.zig): matchPattern entries left before a \\/// match gives up, and whether one did. Set by the caller per search. \\pub threadlocal var steps_left: u64 = std.math.maxInt(u64); \\pub threadlocal var exhausted: bool = false; \\ ; const budgeted = b.fmt("{s}{s}{s}{s}", .{ src[0..at], spend, src[at..], budget }); // A group's greedy match never gave back to what follows the group: // on `aab`, `(a+)ab` missed where `a+ab` matched. hasAlt counts the // group's own `)` as an alternative, so every group with pattern // after it takes matchGroup's alternatives branch, which tries each // alternative's one (greedy) match and gives up. When the rest fails // after it, try that alternative's shorter matches, longest first // (docs/mvzr-group-backtrack.md is the report for upstream). const group_anchor = \\ const next_match = matchPattern(next_patt, sets, haystack, m1.i); \\ if (next_match) |m2| { \\ // Whole group matches, and we can use m2.j \\ return m2; \\ } else { // Try our next pattern, if any. \\ ; const group_backoff = \\ const next_match = matchPattern(next_patt, sets, haystack, m1.i); \\ if (next_match) |m2| { \\ // Whole group matches, and we can use m2.j \\ return m2; \\ } else { // Try our next pattern, if any. \\ // pardes's patch (its build.zig): back the group off. \\ var e = m1.i; \\ while (e > i) { \\ e -= 1; \\ const shorter = matchAlt(remaining_patt, sets, haystack[0..e], i) orelse continue; \\ if (shorter.i != e) continue; \\ if (matchPattern(next_patt, sets, haystack, e)) |whole| return whole; \\ } \\ ; if (std.mem.count(u8, budgeted, group_anchor) != 1) @panic("mvzr's matchGroup changed: redo its group backtracking in build.zig"); const backed = std.mem.replaceOwned(u8, b.allocator, budgeted, group_anchor, group_backoff) catch @panic("OOM"); // `$` is refused anywhere but last, so `h$|zz` was a bad pattern // while `zz|h$` was fine. An alternative or a group ends at `|` and // `)`, and the matcher's `.end` ends the alternative it is in, so // `$` may stand before either (docs/mvzr-group-backtrack.md). const end_anchor = \\ '$' => { \\ if (i + 1 < in.len) { \\ ; const end_before_alt = \\ '$' => { \\ // pardes's patch (its build.zig): `$` may end an alternative. \\ if (i + 1 < in.len and in[i + 1] != '|' and in[i + 1] != ')') { \\ ; if (std.mem.count(u8, backed, end_anchor) != 1) @panic("mvzr's parser changed: redo its `$` before `|` in build.zig"); var patched = std.mem.replaceOwned(u8, b.allocator, backed, end_anchor, end_before_alt) catch @panic("OOM"); // Zig 0.17 removed `**`; mvzr still has it (its PR #16 replaces it upstream). for ([_][3][]const u8{ .{ "[1]RegOp{.{ .unused = {} }} ** ops", "@splat(.{ .unused = {} })", "1" }, .{ "[1]CharSet{.{ .low = 0, .hi = 0 }} ** char_sets", "@splat(.{ .low = 0, .hi = 0 })", "1" }, .{ "\"a\" ** 2048", "&@as([2048]u8, @splat('a'))", "2" }, .{ "\"12345,\" ** 255", "std.mem.asBytes(&@as([255][6]u8, @splat(\"12345,\".*)))", "1" }, }) |edit| { if (std.mem.count(u8, patched, edit[0]) != std.fmt.parseInt(usize, edit[2], 10) catch unreachable) std.debug.panic("mvzr changed at `{s}`: redo its `**` patch in build.zig", .{edit[0]}); patched = std.mem.replaceOwned(u8, b.allocator, patched, edit[0], edit[1]) catch @panic("OOM"); } break :mvzr b.createModule(.{ .root_source_file = b.addWriteFiles().add("mvzr.zig", patched), .target = target, .optimize = optimize }); }; // The C heap every C library with an allocator hook is handed: the core's // tree-sitter and fonts, and pdf.zig's MuPDF, which is a module of its own. const c_heap_mod = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("src/c_heap.zig"), }); // One FreeType in a binary: the gui's glyph atlas links it and MuPDF is // built against it (see mupdf.zig). At c_optimize with the rest of the // vendored C, since MuPDF rasterizes a PDF's text through it. const freetype_dep = b.dependency("freetype", .{ .target = target, .optimize = c_optimize, .@"enable-libpng" = false, }); const freetype = freetype_dep.artifact("freetype"); // ...and one zlib, the one FreeType links for its gzip module. Asked of // FreeType's build with the options it asks with, the dependency cache // hands back that same artifact rather than a second copy. const zlib = freetype_dep.builder.dependency("zlib", .{ .target = target, .optimize = c_optimize }).artifact("z"); // The PDF addon (addons/pdf/pdf.c over MuPDF and pdf_bridge.c), built // and installed as the image addon is. MuPDF is compiled against the // build's FreeType and zlib and links them into the library, which holds // its own copy of each beside a window's FreeType (docs/shared-libs.md); // so all three are position-independent, and the library exports its // `pardes_addon` alone. var pdf_addon: ?*std.Build.Step.Compile = null; if (enable_mupdf) { if (b.lazyDependency("mupdf", .{})) |mupdf_dep| { freetype.root_module.pic = true; zlib.root_module.pic = true; const mupdf = mupdf_build.add(b, io, mupdf_dep, .{ .target = target, .optimize = c_optimize, .jpx = enable_jpx, .freetype = freetype, .zlib = zlib, .pic = true, }); const lib = b.addLibrary(.{ .name = "pdf", .linkage = .dynamic, .root_module = b.createModule(.{ .target = target, .optimize = c_optimize, .link_libc = true }) }); mupdf.linkTo(lib.root_module); lib.root_module.addIncludePath(b.path("src/kinds")); lib.root_module.addIncludePath(b.path("addons/pdf")); lib.root_module.addCSourceFile(.{ .file = b.path("addons/pdf/pdf.c"), .flags = &.{ "-std=gnu11", "-Wall", "-Wextra", "-Werror" } }); lib.root_module.addCSourceFile(.{ .file = b.path("addons/pdf/pdf_bridge.c"), .flags = &.{"-std=gnu11"} }); lib.setVersionScript(b.addWriteFiles().add("pdf.map", "{ global: pardes_addon; local: *; };\n")); pdf_addon = lib; mupdf_check.dependOn(mupdf_build.addProbe(b, mupdf, .{ .target = target, .pdf = b.path("docs/design.pdf"), })); // The PDF benches: the core over the addon, a pane of it. const config = b.addOptions(); config.addOption(bool, "release_fast_core", optimize == .fast); config.addOption([]const u8, "core_optimize", @tagName(optimize)); config.addOptionPath("pdf_addon", lib.getEmittedBin()); for ([_]struct { step: *std.Build.Step, exe: []const u8, file: []const u8, optimize: std.lang.Optimize }{ .{ .step = pdf_pointer_bench_step, .exe = "pardes-pdf-pointer-bench", .file = "test/pdf_pointer_bench.zig", .optimize = .fast }, .{ .step = pdf_scroll_bench_step, .exe = "pardes-pdf-scroll-bench", .file = "test/pdf_scroll_bench.zig", .optimize = optimize }, }) |bench| { const exe = b.addExecutable(.{ .name = bench.exe, .root_module = b.createModule(.{ .target = target, .optimize = bench.optimize, .root_source_file = b.path(bench.file), .link_libc = true }) }); exe.root_module.addImport("pardes", core_module); exe.root_module.addOptions("pdf_bench_config", config); const run = b.addRunArtifact(exe); run.addPassthruArgs(); run.setCwd(b.path(".")); bench.step.dependOn(&run.step); } } } const uucode_config = b.path("uucode_config.zig"); const uucode_tables = b.dependency("uucode", .{ .target = target, .optimize = optimize, .build_config_path = uucode_config, }).namedLazyPath("tables.zig"); const uucode_mod = b.dependency("uucode", .{ .target = target, .optimize = optimize, .build_config_path = uucode_config, .tables_path = uucode_tables, }).module("uucode"); const vaxis_dep = b.dependency("vaxis", .{ .target = target, .optimize = optimize, .external_uucode = true, }); const vaxis_mod = vaxis_dep.module("vaxis"); // vaxis's input parser, patched here at build time like mvzr so that a // fresh fetch keeps it: no reply, split read or malformed sequence may // reach the editor as typed text, and none may panic or end input. // - A cursor position report that no F3 could have sent is no key: the // startup width queries' `CSI 1;1R` arrived as two F3s, which a shell // pane took for text. // - ESC before a CSI or SS3 key (rxvt's Alt+arrow) is Alt on that key, // not Alt+Escape followed by `[A` as text. // - An X10 mouse report and a kitty graphics reply cut short by a read // wait for their rest: the first became three bytes of text, the // second sliced past its input. // - A byte no UTF-8 starts with is dropped instead of failing the parse, // which stopped input. (vaxis itself now drops a malformed color or // clipboard reply and ends an OSC at its first terminator.) // - A device report's fields are sought in the sequence, not past it. // A bump that moves an anchor stops the build. { var src = configureRead(b, io, vaxis_dep.builder.root, "src/Parser.zig", 1 << 20) catch @panic("read vaxis Parser.zig"); const edits = [_]struct { anchor: []const u8, with: []const u8, count: usize = 1 }{ .{ .anchor = \\ 0x5F => return parseApc(input), \\ else => { , .with = \\ 0x5F => return parseApc(input), \\ // pardes's patch (its build.zig): ESC before a key's sequence is Alt on the key. \\ 0x1B => if (input.len > 2 and (input[2] == '[' or input[2] == 'O')) { \\ var inner = if (input[2] == '[') parseCsi(input[1..], &self.buf, self.cursor_position_requests) else parseSs3(input[1..]); \\ if (inner.n == 0) return inner; \\ if (inner.event) |*event| switch (event.*) { \\ .key_press, .key_release => |*key| key.mods.alt = true, \\ else => {}, \\ }; \\ inner.n += 1; \\ return inner; \\ } else return .{ .event = .{ .key_press = .{ .codepoint = Key.escape, .mods = .{ .alt = true } } }, .n = 2 }, \\ else => { , }, .{ .anchor = " const first_cp = iter.next() orelse return error.InvalidUTF8;\n", .with = " const first_cp = iter.next() orelse return .{ .event = null, .n = 1 }; // pardes's patch (its build.zig)\n", }, .{ .anchor = " n = std.unicode.utf8CodepointSequenceLength(first_cp) catch return error.InvalidUTF8;\n", .with = " n = std.unicode.utf8CodepointSequenceLength(first_cp) catch return .{ .event = null, .n = 1 }; // pardes's patch (its build.zig)\n", }, .{ .anchor = \\ const sequence = input[0 .. end + 1 + 1]; \\ \\ switch (input[2]) { , .with = \\ // pardes's patch (its build.zig): an ESC that ends the input is half an ST. \\ if (input.len < end + 2) return .{ .event = null, .n = 0 }; \\ const sequence = input[0 .. end + 1 + 1]; \\ \\ switch (input[2]) { , }, .{ .anchor = \\ 'A', 'B', 'C', 'D', 'E', 'F', 'H', 'P', 'Q', 'R', 'S' => { \\ // Legacy keys \\ , .with = \\ 'A', 'B', 'C', 'D', 'E', 'F', 'H', 'P', 'Q', 'R', 'S' => { \\ // pardes's patch (its build.zig): a cursor position report is no key. \\ if (final == 'R' and cursorReport(sequence)) return null_event; \\ // Legacy keys \\ , }, .{ .anchor = " std.debug.assert(sequence.len >= 4); // ESC [ ? c == 4 bytes\n", .with = " if (sequence.len < 4) return null_event; // pardes's patch (its build.zig)\n", }, .{ .anchor = "const delim_idx = std.mem.indexOfScalarPos(u8, input, 3, ';')", .with = "const delim_idx = std.mem.indexOfScalarPos(u8, sequence, 3, ';')", .count = 2, }, .{ .anchor = "input[delim_idx + 1 .. sequence.len - 2]", .with = "sequence[@min(delim_idx + 1, sequence.len - 2) .. sequence.len - 2]", }, .{ .anchor = " if (input.len == 3 and (input[2] == 'M') and full_input.len >= 6) {\n", .with = \\ // pardes's patch (its build.zig): an X10 report still arriving is incomplete, not text. \\ if (input.len == 3 and input[2] == 'M' and full_input.len < 6) return .{ .event = null, .n = 0 }; \\ if (input.len == 3 and (input[2] == 'M') and full_input.len >= 6) { \\ , }, }; for (edits) |edit| { if (std.mem.count(u8, src, edit.anchor) != edit.count) std.debug.panic("vaxis's Parser.zig changed at `{s}`: redo its patch in build.zig", .{edit.anchor}); src = std.mem.replaceOwned(u8, b.allocator, src, edit.anchor, edit.with) catch @panic("OOM"); } const cursor_report = \\ \\/// pardes's patch (its build.zig): whether `CSI ... R` answers a cursor \\/// position query. Only `CSI 1 ; mods R` with mods past 1 is a modified F3 \\/// (a bare F3 is `SS3 R`); a report has another row, or col 1 (mods 1). \\fn cursorReport(sequence: []const u8) bool { \\ const params = sequence[2 .. sequence.len - 1]; \\ if (params.len > 0 and params[0] == '?') return true; \\ var fields = std.mem.splitScalar(u8, params, ';'); \\ const row = fields.first(); \\ const col = fields.next() orelse return false; \\ if (fields.next() != null or row.len == 0 or col.len == 0) return false; \\ for (params) |c| if (c != ';' and !std.ascii.isDigit(c)) return false; \\ return !std.mem.eql(u8, row, "1") or std.mem.eql(u8, col, "1"); \\} \\ ; // vaxis's render, patched the same way: a blank whose ink alone // changed is not sent, since a blank's ink shows nowhere. A fade // (InactiveDim on a focus change) sent every blank of every pane it // touched again: 7 KB a click for three shell panes. The terminal // keeps the old ink there, and so does vaxis's last frame. var render_src = configureRead(b, io, vaxis_dep.builder.root, "src/Vaxis.zig", 1 << 20) catch @panic("read vaxis Vaxis.zig"); const render_anchor = \\ if ((!self.refresh and \\ last.eql(cell) and ; if (std.mem.count(u8, render_src, render_anchor) != 1) std.debug.panic("vaxis's Vaxis.zig changed at `{s}`: redo its patch in build.zig", .{render_anchor}); render_src = std.mem.replaceOwned(u8, b.allocator, render_src, render_anchor, \\ if ((!self.refresh and \\ (last.eql(cell) or blankInkOnly(&last, &cell)) and // pardes's patch (its build.zig) \\ ) catch @panic("OOM"); // And the secondary cursors count as changed when they differ, not // when they are the same: read the other way round, every render // started a frame, ~40 bytes to the terminal with nothing changed. const secondary_anchor = " std.meta.eql(self.screen.cursor_secondary, self.state.cursor_secondary);\n"; if (std.mem.count(u8, render_src, secondary_anchor) != 1) std.debug.panic("vaxis's Vaxis.zig changed at `{s}`: redo its patch in build.zig", .{secondary_anchor}); render_src = std.mem.replaceOwned(u8, b.allocator, render_src, secondary_anchor, " !std.meta.eql(self.screen.cursor_secondary, self.state.cursor_secondary); // pardes's patch (its build.zig)\n") catch @panic("OOM"); const blank_ink = \\ \\/// pardes's patch (its build.zig): a blank cell (a space, no underline, \\/// strike or reverse) that differs from the last frame's blank in its \\/// ink alone, which shows nowhere. \\inline fn blankInkOnly(last: *const InternalScreen.InternalCell, cell: *const Cell) bool { \\ if (!(cell.char.grapheme.len == 1 and cell.char.grapheme[0] == ' ')) return false; \\ if (last.default or cell.default) return false; \\ if (!(last.char.items.len == 1 and last.char.items[0] == ' ')) return false; \\ const s = cell.style; \\ if (s.reverse or s.strikethrough or s.ul_style != .off) return false; \\ if (!std.mem.eql(u8, last.uri.items, cell.link.uri)) return false; \\ // Field by field: Style.eql is slow, and this runs for every blank \\ // a scrolling shell moves. \\ const l = last.style; \\ return sameColor(l.bg, s.bg) and sameColor(l.ul, s.ul) and l.ul_style == s.ul_style and \\ l.bold == s.bold and l.dim == s.dim and l.italic == s.italic and l.blink == s.blink and \\ !l.reverse and !l.strikethrough and l.invisible == s.invisible; \\} \\ \\inline fn sameColor(a: Cell.Color, b: Cell.Color) bool { \\ return switch (a) { \\ .default => b == .default, \\ .index => |i| b == .index and b.index == i, \\ .rgb => |rgb| b == .rgb and rgb[0] == b.rgb[0] and rgb[1] == b.rgb[1] and rgb[2] == b.rgb[2], \\ }; \\} \\ ; // And its event queue: a pop that makes room woke one blocked // writer, and only on the pop from full. The tui has two writers // (a pane's pty reader, and the input reader posting the frame // ack's wake), so when the loop emptied a full queue in one batch // the writer not woken waited on for good: under `yes` the pane // stopped being read, its program blocked on the pty, while keys // went on working. Every blocked writer is woken now. var queue_src = configureRead(b, io, vaxis_dep.builder.root, "src/queue.zig", 1 << 20) catch @panic("read vaxis queue.zig"); const wake_one = "self.not_full.signal(self.io);"; if (std.mem.count(u8, queue_src, wake_one) != 2) std.debug.panic("vaxis's queue.zig changed at `{s}`: redo its patch in build.zig", .{wake_one}); queue_src = std.mem.replaceOwned(u8, b.allocator, queue_src, wake_one, "self.not_full.broadcast(self.io); // pardes's patch (its build.zig)") catch @panic("OOM"); const files = b.addWriteFiles(); _ = files.add("Parser.zig", b.fmt("{s}{s}", .{ src, cursor_report })); _ = files.add("Vaxis.zig", b.fmt("{s}{s}", .{ render_src, blank_ink })); _ = files.add("queue.zig", queue_src); _ = files.addCopyFile(vaxis_dep.path("src/widgets/terminal/Parser.zig"), "widgets/terminal/Parser.zig"); // Suffixes: this leaves out both Parser.zig files, Vaxis.zig and // queue.zig, written above. _ = files.addCopyDirectory(vaxis_dep.path("src"), "", .{ .exclude_extensions = &.{ "Parser.zig", "Vaxis.zig", "queue.zig" } }); vaxis_mod.root_source_file = files.getDirectory().path(b, "main.zig"); } var ghostty_vt_for_snap: ?*std.Build.Module = null; const ghostty_simd = !target.result.os.tag.isDarwin() or b.graph.host.result.os.tag.isDarwin(); const ghostty_optimize: std.lang.Optimize = if (optimize == .debug) .safe else optimize; const ghostty_dep = b.lazyDependency("ghostty", .{ .target = target, .optimize = ghostty_optimize, .simd = ghostty_simd, .@"app-runtime" = .none, .@"emit-xcframework" = false }); if (ghostty_dep) |dep| { const ghostty_vt = dep.module("ghostty-vt"); ghostty_vt_for_snap = ghostty_vt; ghostty_vt.addImport("uucode", uucode_mod); patchGhosttyKitty(b, io, dep, ghostty_vt); ghostty_core_vt = ghostty_vt; } // override uucode on vaxis LAST so it wins over ghostty's build() wiring. vaxis_mod.addImport("uucode", uucode_mod); // One PNG decoder (docs/shared-libs.md): ghostty's, wuffs, which // ghostty-vt links for kitty graphics whatever pardes does; a terminal's // PNG is decoded through it (TerminalImages.zig), and of zstbi only its // resize is left, for the PNG's downscale: stb_image and its writer // (with the deflate it carries) are patched out, here at build time so // a fresh fetch keeps it. The image addon has its own (addons/image). const wuffs_mod: ?*std.Build.Module = if (ghostty_core_vt) |vt| vt.import_table.get("wuffs") else null; { var sources: usize = 0; for (zstbi_mod.link_objects.items) |obj| switch (obj) { .c_source_file => |csf| { sources += 1; var src = configureRead(b, io, zstbi_dep.builder.root, "src/zstbi.c", 1 << 20) catch @panic("read zstbi.c"); // zstbi.deinit still resets the reader's and the writer's // flip flags, and Image.deinit frees the resize's output. for ([_][2][]const u8{ .{ "#define STB_IMAGE_IMPLEMENTATION\n#include \"stb_image.h\"\n", "void stbi_set_flip_vertically_on_load(int flag) { (void)flag; }\nvoid stbi_image_free(void *p) { zstbiFreePtr(p); }\n" }, .{ "#define STB_IMAGE_WRITE_IMPLEMENTATION\n#include \"stb_image_write.h\"\n", "void stbi_flip_vertically_on_write(int flag) { (void)flag; }\n" }, }) |cut| { if (std.mem.count(u8, src, cut[0]) != 1) std.debug.panic("zstbi.c changed at `{s}`: redo its patch in build.zig", .{cut[0]}); src = std.mem.replaceOwned(u8, b.allocator, src, cut[0], cut[1]) catch @panic("OOM"); } csf.file = b.addWriteFiles().add("zstbi.c", src); }, else => {}, }; if (sources != 1) @panic("zstbi's build no longer compiles one C file: redo its patch in build.zig"); } // One zstd (docs/shared-libs.md): a far replica's stream, compressed by // its session and read by its client (src/replica.zig). The library's // compressor and decompressor alone, single-threaded and without its // x86 assembly, each context made with ZSTD_customMem over c_heap; of // its block compressors only those of levels 3 (dfast) and 6 (lazy), // the two replica.zig asks for, and its unused functions dropped at // link. Zig's std has a decompressor, but no compressor. { const dep = b.dependency("zstd", .{}); const zstd = b.addLibrary(.{ .name = "zstd", .root_module = b.createModule(.{ .target = target, .optimize = c_optimize, .link_libc = true }), .linkage = .static, }); zstd.root_module.addCSourceFiles(.{ .root = dep.path("lib"), .files = &.{ "common/debug.c", "common/entropy_common.c", "common/error_private.c", "common/fse_decompress.c", "common/pool.c", "common/threading.c", "common/xxhash.c", "common/zstd_common.c", "compress/fse_compress.c", "compress/hist.c", "compress/huf_compress.c", "compress/zstd_compress.c", "compress/zstd_compress_literals.c", "compress/zstd_compress_sequences.c", "compress/zstd_compress_superblock.c", "compress/zstd_double_fast.c", "compress/zstd_fast.c", "compress/zstd_lazy.c", "compress/zstd_ldm.c", "compress/zstd_opt.c", "compress/zstd_preSplit.c", "decompress/huf_decompress.c", "decompress/zstd_ddict.c", "decompress/zstd_decompress.c", "decompress/zstd_decompress_block.c", }, .flags = &.{ "-DXXH_NAMESPACE=ZSTD_", "-DZSTD_DISABLE_ASM", "-DZSTD_LEGACY_SUPPORT=0", "-DDEBUGLEVEL=0", "-DZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR", "-DZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR", "-DZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR", "-DZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR", "-DZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR", }, }); zstd.link_function_sections = true; zstd.link_data_sections = true; for (core_mods) |m| m.linkLibrary(zstd); } // xitdb keeps what pardes writes to disk (src/Db.zig): pure Zig, no C // library and no allocator hook of its own (it takes Zig allocators). const xitdb_mod = b.dependency("xitdb", .{ .target = target, .optimize = optimize }).module("xitdb"); // One call per module instead of one line per module per dependency, and // BEFORE the fold below, which reads what these imports put in the table. // The kinds' C ABI (src/kinds/pardes_addon.h), translated once: the core's // records are the header's, never a mirror of it. const kind_mod = b.addTranslateC(.{ .root_source_file = b.path("src/kinds/pardes_addon.h"), .target = target, .optimize = optimize }).createModule(); for (core_mods) |m| wireCore(m, .{ .kind = kind_mod, .themes = themes_mod, .tree_sitter = ts_mod, .ts_libs = ts_libs.items, .ts_queries = ts_queries_opts, .zstbi = zstbi_mod, .mvzr = mvzr_mod, .c_heap = c_heap_mod, .ghostty_vt = ghostty_core_vt, .vaxis = vaxis_mod, .uucode = uucode_mod, .wuffs = wuffs_mod, .xitdb = xitdb_mod, }); const iso_off = b.addOptions(); iso_off.addOption(bool, "isolated", false); const iso_on = b.addOptions(); iso_on.addOption(bool, "isolated", true); for (core_mods, core_shells) |mod, shell| { // config.zig's test checks the words and keys docs/typ names exist. mod.addOptions("doc_typ", doc_typ_opts); mod.addOptions("pardes_config", if (also_gui and shell == .gui) gui_opts.? else opts); mod.addOptions("pardes_isolation", if (isolated_mod == mod) iso_on else iso_off); } // docs/typ/builtins-.json: every builtin, from the registry and the Help // rows (src/builtins_json.zig), rewritten in the source tree so a plain // `typst compile` reads it too; a unit test fails when it is stale. // A terminal build writes builtins-tui.json and a window build // builtins-gui.json; style.typ merges the two into one glossary. const builtins_json_step = b.step("builtins-json", "rewrite docs/typ/builtins-.json from the builtin registry (-Dplatform=tui or gui)"); if (requested_platform == .tui or requested_platform == .gui) { const gen = b.addExecutable(.{ .name = "pardes-gen-builtins-json", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("tools/gen_builtins_json.zig"), .imports = &.{.{ .name = "pardes", .module = core_module }}, }) }); const run_gen = b.addRunArtifact(gen); const json = run_gen.addOutputFileArg("builtins.json"); const update = b.addUpdateSourceFiles(); update.addCopyFileToSource(json, b.fmt("docs/typ/builtins-{s}.json", .{@tagName(platform)})); builtins_json_step.dependOn(&update.step); for (doc_renders) |r| if (r) |run| run.step.dependOn(&update.step); } else builtins_json_step.dependOn(&b.addFail("builtins-json writes one build's list: pass -Dplatform=tui or -Dplatform=gui").step); const gui_shell_mod: ?*std.Build.Module = gui_mod orelse if (platform == .gui) root_mod else null; if (gui_shell_mod) |gm| { const sdl_dep = b.lazyDependency("sdl", .{ .target = target, .optimize = optimize, .sanitize_c = .off, .preferred_linkage = .static }); if (sdl_dep) |dep| { const sdl_lib = dep.artifact("SDL3"); // SDL's own stb_image (SDL_stb.c, for SDL_LoadPNG and a camera's // MJPEG, neither of which pardes calls) is a second PNG and JPEG // decoder beside the build's: off (docs/shared-libs.md). sdl_lib.root_module.addCMacro("SDL_DISABLE_STB", "1"); gm.linkLibrary(sdl_lib); gm.addIncludePath(dep.path("include")); // gui.zig's `c`: SDL and the font shim, which @cImport gave it before Zig 0.17. const header = b.addWriteFiles().add("gui_c.h", \\#define SDL_DISABLE_OLD_NAMES 1 \\#include \\#include "font.h" \\ ); const gui_c = b.addTranslateC(.{ .root_source_file = header, .target = target, .optimize = optimize }); gui_c.addIncludePath(dep.path("include")); gui_c.addIncludePath(b.path("src/gui")); gm.addImport("gui_c", gui_c.createModule()); } gm.linkLibrary(freetype); // HarfBuzz from source, like FreeType: its FreeType integration // (HAVE_FREETYPE, hb-ft) links the freetype artifact above, so the two // share one FreeType. The flags are the ones Ghostty builds it with, // plus its allocator: gui.zig's ui_malloc and friends, over a Zig // allocator, as FreeType's is. if (b.lazyDependency("harfbuzz", .{})) |upstream| { const harfbuzz = b.addLibrary(.{ .name = "harfbuzz", .linkage = .static, .root_module = b.createModule(.{ .target = target, .optimize = optimize, .link_libc = true, .link_libcpp = true, }), }); harfbuzz.root_module.linkLibrary(freetype); harfbuzz.root_module.addIncludePath(upstream.path("src")); harfbuzz.root_module.addCSourceFile(.{ .file = upstream.path("src/harfbuzz.cc"), .flags = &.{ "-DHAVE_STDBOOL_H", "-DHAVE_UNISTD_H", "-DHAVE_SYS_MMAN_H", "-DHAVE_PTHREAD=1", "-DHAVE_FREETYPE=1", "-DHAVE_FT_GET_VAR_BLEND_COORDINATES=1", "-DHAVE_FT_SET_VAR_BLEND_COORDINATES=1", "-DHAVE_FT_DONE_MM_VAR=1", "-DHAVE_FT_GET_TRANSFORM=1", "-Dhb_malloc_impl=ui_malloc", "-Dhb_calloc_impl=ui_calloc", "-Dhb_realloc_impl=ui_realloc", "-Dhb_free_impl=ui_free", }, }); gm.linkLibrary(harfbuzz); gm.addIncludePath(upstream.path("src")); } if (target.result.os.tag.isDarwin()) gm.addRPath(.{ .cwd_relative = "/usr/local/lib" }); gm.addIncludePath(b.path("src/gui")); gm.addCSourceFile(.{ .file = b.path("src/gui/font.c") }); // the embedded UI font: provided as a build import since assets/ lives // outside the src/ module root (@embedFile can't escape it) gm.addAnonymousImport("AdwaitaMono-Regular.ttf", .{ .root_source_file = b.path("assets/AdwaitaMono-Regular.ttf"), }); for (gui_shaders) |name| gm.addAnonymousImport(b.fmt("{s}.spv", .{name}), .{ .root_source_file = if (prebuilt_shaders) b.path(b.fmt("shaders/prebuilt/{s}.spv", .{name})) else compileGlsl(b, name), }); } if (platform == .macos) { const header = b.addTranslateC(.{ .root_source_file = b.path("src/macos/pardes.h"), .target = target, .optimize = optimize, }); root_mod.addImport("pardes.h", header.createModule()); const lib = b.addLibrary(.{ .name = "pardes", .linkage = .static, .root_module = root_mod, }); lib.bundle_compiler_rt = true; lib.bundle_ubsan_rt = true; const archive: ?std.Build.LazyPath = if (builtin.os.tag.isDarwin() and target.result.os.tag.isDarwin()) fatArchive(b, lib) else null; const install_lib: *std.Build.Step = if (archive) |a| &b.addInstallLibFile(a, "libpardes.a").step else &b.addInstallArtifact(lib, .{}).step; b.getInstallStep().dependOn(install_lib); b.installFile("src/macos/pardes.h", "include/pardes.h"); const app_step = b.step("macos-app", "assemble zig-out/pardes.app (needs macOS + swiftc)"); const dmg_step = b.step("macos-dmg", "package zig-out/pardes.dmg for distribution (needs macOS + swiftc)"); if (archive) |lib_archive| { const apple_arch: []const u8 = if (target.result.cpu.arch == .aarch64) "arm64" else @tagName(target.result.cpu.arch); const triple = b.fmt("{s}-apple-macos{d}.{d}", .{ apple_arch, macos_min_version.major, macos_min_version.minor, }); const min_version = b.fmt("{d}.{d}", .{ macos_min_version.major, macos_min_version.minor }); const swift_mode: []const u8 = switch (optimize) { .debug => "-Onone", .small => "-Osize", .fast, .safe => "-O", }; const link = b.addSystemCommand(&.{ "swiftc", swift_mode, "-target", triple, "-import-objc-header" }); link.addFileArg(b.path("src/macos/pardes.h")); link.addArg("-o"); const app_bin = link.addOutputFileArg("pardes"); for ([_][]const u8{ "main.swift", "AppDelegate.swift", "PardesView.swift", "ScenePostprocessor.swift", "FileWatcher.swift", }) |src| link.addFileArg(b.path(b.fmt("src/macos/Sources/{s}", .{src}))); link.addFileArg(lib_archive); link.addArgs(&.{ "-lc++", "-framework", "AppKit", "-framework", "CoreText", "-framework", "CoreGraphics", "-framework", "CoreImage", "-framework", "Metal", }); const icon_build = b.addSystemCommand(&.{ "swiftc", "-O", "-target", triple, "-o" }); const icon_bin = icon_build.addOutputFileArg("pardes-icon"); icon_build.addFileArg(b.path("src/macos/icon.swift")); const icon_run = std.Build.Step.Run.create(b, "pardes-icon"); icon_run.addFileArg(icon_bin); icon_run.addFileArg(b.path("src/macos/icon.png")); const icon_dir = icon_run.addOutputDirectoryArg("Resources"); const plist = b.addSystemCommand(&.{ "plutil", "-replace", "LSMinimumSystemVersion", "-string", min_version, "-o", }); const plist_out = plist.addOutputFileArg("Info.plist"); plist.addFileArg(b.path("src/macos/Info.plist")); const version_plist = b.addSystemCommand(&.{ "plutil", "-replace", "CFBundleShortVersionString", "-string", display_version, "-o", }); const version_plist_out = version_plist.addOutputFileArg("Info.plist"); version_plist.addFileArg(plist_out); const install_app_bin = b.addInstallFileWithDir(app_bin, .{ .custom = "pardes.app/Contents/MacOS" }, "pardes"); const install_plist = b.addInstallFileWithDir(version_plist_out, .{ .custom = "pardes.app/Contents" }, "Info.plist"); const install_scene_kernel = b.addInstallFileWithDir( b.path("shaders/crt.ci.metal"), .{ .custom = "pardes.app/Contents/Resources" }, "crt.ci.metal", ); // CFBundleIconFile names this without its extension; without both // halves the Dock shows the generic blank page. const install_icon = b.addInstallFileWithDir(icon_dir.path(b, "pardes.icns"), .{ .custom = "pardes.app/Contents/Resources" }, "pardes.icns"); const sign = b.addSystemCommand(&.{ "codesign", "--force", "--sign", macos_identity }); if (!std.mem.eql(u8, macos_identity, "-")) sign.addArgs(&.{ "--options", "runtime", "--timestamp" }); sign.setCwd(installed("")); sign.addArg("pardes.app"); sign.has_side_effects = true; sign.step.dependOn(&install_app_bin.step); sign.step.dependOn(&install_plist.step); sign.step.dependOn(&install_icon.step); sign.step.dependOn(&install_scene_kernel.step); app_step.dependOn(&sign.step); const dmg = b.addSystemCommand(&.{ "hdiutil", "create", "-volname", "pardes", "-ov", "-format", "UDZO", "-srcfolder" }); dmg.setCwd(installed("")); dmg.addArgs(&.{ "pardes.app", "pardes.dmg" }); dmg.has_side_effects = true; dmg.step.dependOn(&sign.step); dmg_step.dependOn(&dmg.step); b.getInstallStep().dependOn(&sign.step); } else { const why = b.addFail("pardes.app needs a Darwin host and target; drop -Dtarget= or pass -Dtarget=native"); app_step.dependOn(&why.step); dmg_step.dependOn(&why.step); } const e2e_step = b.step("macos-e2e", "run the offscreen AppKit snapshot suite (needs macOS + swiftc)"); if (archive) |lib_archive| { const arch = if (target.result.cpu.arch == .aarch64) "arm64" else @tagName(target.result.cpu.arch); const triple = b.fmt("{s}-apple-macos{d}.{d}", .{ arch, macos_min_version.major, macos_min_version.minor }); const e2e = b.addSystemCommand(&.{ "swiftc", "-O", "-target", triple, "-import-objc-header" }); e2e.addFileArg(b.path("src/macos/pardes.h")); e2e.addArg("-o"); const e2e_bin = e2e.addOutputFileArg("pardes-macos-e2e"); for ([_][]const u8{ "src/macos/Sources/PardesView.swift", "src/macos/Sources/ScenePostprocessor.swift", "src/macos/Sources/FileWatcher.swift", "src/macos/Sources/AppDelegate.swift", "test/macos_e2e.swift", }) |source| e2e.addFileArg(b.path(source)); e2e.addFileArg(lib_archive); e2e.addArgs(&.{ "-lc++", "-framework", "AppKit", "-framework", "CoreText", "-framework", "CoreGraphics", "-framework", "CoreImage", "-framework", "Metal" }); const files = b.addWriteFiles(); const runnable = files.addCopyFile(e2e_bin, "pardes-macos-e2e"); _ = files.addCopyFile(b.path("shaders/crt.ci.metal"), "crt.ci.metal"); const run_e2e = std.Build.Step.Run.create(b, "run macos-e2e"); run_e2e.addFileArg(runnable); run_e2e.setCwd(b.path(".")); run_e2e.addPassthruArgs(); run_e2e.has_side_effects = true; e2e_step.dependOn(&run_e2e.step); } else e2e_step.dependOn(&b.addFail("macos-e2e needs a Darwin host and target").step); const unit_step = b.step("unit-test", "run the C-ABI guard and core unit tests"); const unit_tests = b.addTest(.{ .root_module = root_mod, .filters = test_filters }); if (test_nonce) |nonce| unit_tests.root_module.addImport("test_rebuild_nonce", nonce); test_build.dependOn(&unit_tests.step); const run_unit = b.addRunArtifact(unit_tests); run_unit.has_side_effects = true; unit_step.dependOn(&run_unit.step); if (testMatch(b, unit_profile, test_filters, unit_step)) |check| check.addArtifactArg(unit_tests); } else { var exe_name: []const u8 = if (platform == .gui) "pardes-gui" else "pardes"; if (target.result.os.tag != .linux or target.result.cpu.arch != .x86_64) exe_name = b.fmt("{s}-{s}-{s}", .{ exe_name, @tagName(target.result.os.tag), @tagName(target.result.cpu.arch) }); const exe = b.addExecutable(.{ .name = exe_name, .linkage = if (static) .static else null, .root_module = root_mod, }); installHome(b, exe, home_bin); if (target.result.os.tag == .linux and !static) { for ([_]?*std.Build.Step.Compile{ image_addon, pdf_addon }, [_][]const u8{ "image.so", "pdf.so" }) |lib, name| if (lib) |l| { b.getInstallStep().dependOn(&b.addInstallFileWithDir(l.getEmittedBin(), .lib, b.fmt("pardes/addons/{s}", .{name})).step); if (home_bin) |dir| { const copy = b.addSystemCommand(&.{ "install", "-Dm755" }); copy.addFileArg(l.getEmittedBin()); copy.addArg(b.pathJoin(&.{ dir, "..", "lib", "pardes", "addons", name })); copy.has_side_effects = true; b.getInstallStep().dependOn(©.step); } }; } if (gui_mod) |gm| { var gui_name: []const u8 = "pardes-gui"; if (target.result.os.tag != .linux or target.result.cpu.arch != .x86_64) gui_name = b.fmt("{s}-{s}-{s}", .{ gui_name, @tagName(target.result.os.tag), @tagName(target.result.cpu.arch) }); const gui_exe = b.addExecutable(.{ .name = gui_name, .linkage = if (static) .static else null, .root_module = gm, }); installHome(b, gui_exe, home_bin); } const run = b.addRunArtifact(exe); b.step("run", "descend to the pardes").dependOn(&run.step); if (isolated_mod) |iso| { const iso_exe = b.addExecutable(.{ .name = "pardes-isolate", .linkage = if (static) .static else null, .root_module = iso, }); const run_iso = b.addRunArtifact(iso_exe); // Something to look at on arrival, read out of the binary itself. run_iso.addPassthruArgs(); const iso_step = b.step("run-isolated", "descend to a pardes with no host but the terminal"); iso_step.dependOn(&run_iso.step); } const addons: []const *std.Build.Step.Compile = if (pdf_addon) |pdf| b.allocator.dupe(*std.Build.Step.Compile, &.{ image_addon, pdf }) catch @panic("OOM") else &.{image_addon}; snap_build.addTty(b, .{ .exe = exe, .addons = addons, .target = target, .optimize = optimize, .ghostty_vt = ghostty_vt_for_snap, .cloud9 = cloud9, .gui = platform == .gui, }); const image_harness = b.addExecutable(.{ .name = "pardes-image-harness", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/image_harness.zig"), .link_libc = true, }), }); if (ghostty_vt_for_snap) |vt| image_harness.root_module.addImport("ghostty-vt", vt); switch (target.result.os.tag) { .freebsd, .netbsd, .openbsd => image_harness.root_module.linkSystemLibrary("util", .{}), else => {}, } const run_image_harness = b.addRunArtifact(image_harness); run_image_harness.addArtifactArg(exe); run_image_harness.addArtifactArg(image_addon); run_image_harness.addArg(if (platform == .gui) "gui" else "tui"); run_image_harness.has_side_effects = true; b.step("image-harness", "exercise native Kitty/SDL image rendering end to end").dependOn(&run_image_harness.step); // Kitty graphics through a terminal pane, end to end: a client in // the pane's bash (and kitten icat, chafa when installed), a kitty // terminal outside (tui) or the GPU capture (gui). test/kitty.zig // is the same protocol at the core. const kitty_client = b.addExecutable(.{ .name = "pardes-kitty-client", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/kitty_client.zig"), .link_libc = true, }), }); const kitty_harness = b.addExecutable(.{ .name = "pardes-kitty-harness", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/kitty_harness.zig"), .link_libc = true, }), }); if (ghostty_vt_for_snap) |vt| kitty_harness.root_module.addImport("ghostty-vt", vt); switch (target.result.os.tag) { .freebsd, .netbsd, .openbsd => kitty_harness.root_module.linkSystemLibrary("util", .{}), else => {}, } const run_kitty_harness = b.addRunArtifact(kitty_harness); run_kitty_harness.addArtifactArg(exe); run_kitty_harness.addArtifactArg(kitty_client); run_kitty_harness.addArg(if (platform == .gui) "gui" else "tui"); run_kitty_harness.has_side_effects = true; b.step("kitty-harness", "kitty graphics through a terminal pane end to end (a client inside, a kitty terminal or the GPU capture outside)").dependOn(&run_kitty_harness.step); const pdf_harness_step = b.step("pdf-harness", "exercise continuous PDF rendering, search, and sections navigation end to end"); if (pdf_addon != null) { const run_pdf_harness = b.addRunArtifact(image_harness); run_pdf_harness.addArtifactArg(exe); run_pdf_harness.addArtifactArg(image_addon); run_pdf_harness.addArg(if (platform == .gui) "gui" else "tui"); run_pdf_harness.addArg("pdf"); run_pdf_harness.addArtifactArg(pdf_addon.?); run_pdf_harness.has_side_effects = true; pdf_harness_step.dependOn(&run_pdf_harness.step); } else { pdf_harness_step.dependOn(&b.addFail("pdf-harness is unavailable with -Dmupdf=false").step); } const hxdiff = b.addExecutable(.{ .name = "pardes-hxdiff", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/hxdiff.zig"), .link_libc = true, }), }); hxdiff.root_module.addImport("pardes", core_module); const run_hxdiff = b.addRunArtifact(hxdiff); run_hxdiff.has_side_effects = true; // Bare, it runs the checked-in suite (test/hxdiff.zig). run_hxdiff.addPassthruArgs(); run_hxdiff.setCwd(b.path(".")); const hxdiff_step = b.step("hxdiff", "compare Helix results (-- --strict cases reference [waivers]; cases alone emits)"); hxdiff_step.dependOn(&run_hxdiff.step); const helix_harness = b.option([]const u8, "helix-harness", "path to the reference hx-harness executable") orelse b.graph.environ_map.get("HX_HARNESS") orelse "hx-harness"; const reference = b.addSystemCommand(&.{helix_harness}); reference.addFileArg(b.path("test/hxcases/cases.jsonl")); reference.has_side_effects = true; const reference_results = reference.captureStdOut(.{}); const live_diff = b.addRunArtifact(hxdiff); live_diff.addArg("--strict"); live_diff.addFileArg(b.path("test/hxcases/cases.jsonl")); live_diff.addFileArg(reference_results); live_diff.addFileArg(b.path("test/hxcases/waivers.jsonl")); live_diff.has_side_effects = true; b.step("hxdiff-live", "compare the editor against a freshly run Helix reference").dependOn(&live_diff.step); const update_reference = b.addUpdateSourceFiles(); update_reference.addCopyFileToSource(reference_results, "test/hxcases/goldens.jsonl"); update_reference.step.dependOn(&live_diff.step); b.step("hxdiff-update", "replace checked-in Helix goldens after the live comparison passes").dependOn(&update_reference.step); const run_hxparity = b.addRunArtifact(hxdiff); run_hxparity.has_side_effects = true; run_hxparity.addArg("--parity"); run_hxparity.addPassthruArgs(); run_hxparity.setCwd(b.path(".")); const hxparity_step = b.step("hxparity", "run the file-vs-pty editing parity suite (-- [--waivers w.jsonl] ...)"); hxparity_step.dependOn(&run_hxparity.step); // every helix-golf example, one case per step of its walkthrough const run_hxgolf = b.addRunArtifact(hxdiff); run_hxgolf.has_side_effects = true; run_hxgolf.addArgs(&.{ "--strict", "test/hxcases/golf.jsonl", "test/hxcases/golf-goldens.jsonl", "test/hxcases/golf-waivers.jsonl" }); run_hxgolf.setCwd(b.path(".")); b.step("hxgolf", "compare the helix-golf examples against their Helix results").dependOn(&run_hxgolf.step); const lspbench = b.addExecutable(.{ .name = "pardes-lspbench", .root_module = b.createModule(.{ .target = target, .optimize = .fast, .root_source_file = b.path("test/lspbench.zig"), .link_libc = true, }), }); lspbench.root_module.addImport("pardes", core_module); const run_lspbench = b.addRunArtifact(lspbench); run_lspbench.addPassthruArgs(); run_lspbench.setCwd(b.path(".")); run_lspbench.has_side_effects = true; const lspbench_step = b.step("lspbench", "language-backend latency + feature matrix (-- [--json] [--check] [repo-root]), or one query (-- probe : [arg] [--reps N])"); lspbench_step.dependOn(&run_lspbench.step); const rollback_bench = b.addExecutable(.{ .name = "pardes-rollback-bench", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/rollback_bench.zig"), .link_libc = true }), }); rollback_bench.root_module.addImport("pardes", core_module); const run_rollback_bench = b.addRunArtifact(rollback_bench); run_rollback_bench.has_side_effects = true; b.step("rollback-bench", "a replica's rollback copy (walked state, pinned blobs, walk time) for a typical and a big session, and a fork of the big one (-Doptimize=ReleaseFast)").dependOn(&run_rollback_bench.step); const replicas = b.addExecutable(.{ .name = "pardes-replicas", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/replicas.zig"), .link_libc = true }), }); replicas.root_module.addImport("pardes", core_module); const run_replicas = b.addRunArtifact(replicas); run_replicas.addPassthruArgs(); run_replicas.has_side_effects = true; b.step("replicas", "one authority and several replicas in process, each client typing over a delayed link: digests at quiescence, rollback rate and costs per RTT (-- [--seeds N] [--steps M] [--clients C] [--rtt 30,80,207])").dependOn(&run_replicas.step); const locations_bench_step = b.step("locations-bench", "measure cold/warm result formatting (-Doptimize=ReleaseFast; CSV on stderr)"); if (optimize != .fast) { locations_bench_step.dependOn(&b.addFail("locations-bench requires -Doptimize=ReleaseFast").step); } else { const locations_bench_module = b.createModule(.{ .target = target, .optimize = .fast, .root_source_file = b.path("test/locations_bench.zig"), .link_libc = true, }); locations_bench_module.addImport("pardes", core_module); const locations_bench = b.addTest(.{ .root_module = locations_bench_module, .filters = &.{"locations benchmark cold and warm formatting"} }); const run_locations_bench = b.addRunArtifact(locations_bench); run_locations_bench.has_side_effects = true; locations_bench_step.dependOn(&run_locations_bench.step); } const perf_optimize: std.lang.Optimize = .fast; const perf_options = b.addOptions(); const perf_target = std.Target.Query.fromTarget(&target.result); perf_options.addOption(PerfBuild, "identity", .{ .compiler = builtin.zig_version_string, .target = perf_target.zigTriple(b.allocator) catch @panic("out of memory"), .cpu = perf_target.serializeCpuAlloc(b.allocator) catch @panic("out of memory"), .driver_optimize = @tagName(perf_optimize), .core_optimize = @tagName(optimize), .c_optimize = @tagName(c_optimize), .terminal_optimize = @tagName(ghostty_optimize), .platform = @tagName(platform), .grammars = @tagName(tree_sitter_grammars), .mupdf = enable_mupdf, .jpx = enable_mupdf and enable_jpx, .tracy = tracy != null, .terminal_simd = ghostty_simd, .prebuilt_shaders = platform == .gui and prebuilt_shaders, }); perf_options.addOptionPath("image_addon", image_addon.getEmittedBin()); perf_options.addOption(bool, "has_pdf_addon", pdf_addon != null); if (pdf_addon) |l| perf_options.addOptionPath("pdf_addon", l.getEmittedBin()); const perf = b.addExecutable(.{ .name = "pardes-perf", .root_module = b.createModule(.{ .target = target, .optimize = perf_optimize, .root_source_file = b.path("test/perf.zig"), .link_libc = true, }), }); perf.root_module.addImport("pardes", core_module); // --live drives the real binary through a pty (test/e2e_harness.zig). if (ghostty_vt_for_snap) |vt| perf.root_module.addImport("ghostty-vt", vt); perf.root_module.addOptions("perf_options", perf_options); const run_perf = b.addRunArtifact(perf); run_perf.has_side_effects = true; run_perf.addPassthruArgs(); run_perf.setCwd(b.path(".")); const perf_step = b.step("perf", "gesture latency or bounded terminal stress (-- [--json] [--reps N] [--base old.json] [--terminal-mib N])"); perf_step.dependOn(&run_perf.step); // The gate: the 50k-line file's gestures against the baseline this // build shape recorded, each within 3x of its best. Record one with // `zig build perf -Dplatform=P [-Doptimize=O] -- --only medium // --reps 10 --json > test/perf-baseline-P-O.json` (a build that is // known good). ponytail: the numbers are this machine's; another // machine records its own. const perf_gate = b.addRunArtifact(perf); perf_gate.has_side_effects = true; perf_gate.setCwd(b.path(".")); perf_gate.addArgs(&.{ "--only", "medium", "--reps", "10", "--base", b.fmt("test/perf-baseline-{t}-{t}.json", .{ platform, optimize }), "--max-ratio", "3" }); const perf_gate_step = b.step("perf-gate", "fail when a gesture on the 50k-line file takes over 3x its recorded baseline (test/perf-baseline--.json)"); perf_gate_step.dependOn(&perf_gate.step); const perf_tests = b.addTest(.{ .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/perf.zig"), .link_libc = true, }), .filters = test_filters, }); perf_tests.root_module.addOptions("perf_options", perf_options); const fs_bench = b.addExecutable(.{ .name = "pardes-fs-bench", .root_module = b.createModule(.{ .target = target, .optimize = .fast, .root_source_file = b.path("test/fs_bench.zig"), .link_libc = true, }), }); fs_bench.root_module.addImport("pardes", core_module); const run_fs_bench = b.addRunArtifact(fs_bench); run_fs_bench.has_side_effects = true; run_fs_bench.addPassthruArgs(); run_fs_bench.setCwd(b.path(".")); const fs_bench_step = b.step("fs-bench", "9P filesystem request cost and allocation count (-- [--json] [--reps N])"); fs_bench_step.dependOn(&run_fs_bench.step); const fs_bench_test = b.addTest(.{ .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/fs_bench.zig"), }), .filters = test_filters, }); const syntax_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("src/syntax.zig"), .link_libc = true, }); syntax_module.addOptions("pardes_config", opts); wireCore(syntax_module, .{ .tree_sitter = ts_mod, .ts_libs = ts_libs.items, .ts_queries = ts_queries_opts, .c_heap = c_heap_mod }); const syntax_runner = b.addExecutable(.{ .name = "pardes-syntax", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/syntax.zig"), .link_libc = true, }), }); syntax_runner.root_module.addImport("syntax", syntax_module); const run_syntax = b.addRunArtifact(syntax_runner); run_syntax.addPassthruArgs(); run_syntax.has_side_effects = true; b.step("syntax", "emit deterministic syntax snapshots (-- --bench: highlighting latency and allocations)").dependOn(&run_syntax.step); const syntax_test = b.addTest(.{ .root_module = syntax_module, .filters = if (test_filters.len == 0) &.{"syntax "} else test_filters, }); const run_syntax_test = b.addRunArtifact(syntax_test); run_syntax_test.has_side_effects = true; const syntax_test_step = b.step("syntax-test", "test syntax correctness without building the editor"); syntax_test_step.dependOn(&run_syntax_test.step); if (testMatch(b, unit_profile, test_filters, syntax_test_step)) |check| check.addArtifactArg(syntax_test); const history = b.addExecutable(.{ .name = "pardes-history", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/history.zig"), }), }); const run_history = b.addRunArtifact(history); run_history.addPassthruArgs(); run_history.has_side_effects = true; b.step("history", "compare command output and test/build runtime across jj revisions").dependOn(&run_history.step); const unit_step = b.step("unit-test", "run native shell and module unit tests"); // One copy of each codec in the binary (docs/shared-libs.md): the // linked symbol table, read for the families the build chose against. // ELF only; it runs with every unit-test, like the perf gate. if (target.result.ofmt == .elf) { const libs_check = b.addExecutable(.{ .name = "pardes-shared-libs-check", .root_module = b.createModule(.{ .target = b.graph.host, .optimize = .debug, .root_source_file = b.path("tools/shared_libs_check.zig"), .link_libc = true, }), }); const run_libs_check = b.addRunArtifact(libs_check); run_libs_check.addArtifactArg(exe); const libs_check_step = b.step("shared-libs-check", "fail when the binary links a second copy of a codec the build chose one of (docs/shared-libs.md)"); libs_check_step.dependOn(&run_libs_check.step); unit_step.dependOn(&run_libs_check.step); } // The perf gate runs with every unit-test (a regression like a // contrast search per grapheme costs 100x, far past the gate). unit_step.dependOn(perf_gate_step); const units: Units = .{ .nonce = test_nonce, .build = test_build, .unit = unit_step, .match = testMatch(b, unit_profile, test_filters, unit_step), .profiler = unit_profile, .filters = test_filters }; // The perf and fs bench programs' own tests: they compile no editor. _ = units.add(b, perf_tests, null); _ = units.add(b, fs_bench_test, null); const core_test = b.addTest(.{ .root_module = core_module, .filters = test_filters }); const run_core_test = b.addRunArtifact(core_test); run_core_test.has_side_effects = true; const core_test_step = b.step("core-test", "run core tests without native shell tests"); core_test_step.dependOn(&run_core_test.step); if (testMatch(b, unit_profile, test_filters, core_test_step)) |check| check.addArtifactArg(core_test); const pane_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/panes.zig"), .link_libc = true, }); pane_module.addImport("pardes", core_module); pane_module.addImport("pardes_config", core_module.import_table.get("pardes_config").?); const test_addons = b.addOptions(); test_addons.addOptionPath("image", image_addon.getEmittedBin()); test_addons.addOption(bool, "has_pdf", pdf_addon != null); if (pdf_addon) |l| test_addons.addOptionPath("pdf", l.getEmittedBin()); pane_module.addOptions("test_addons", test_addons); const pane_tests = b.addTest(.{ .root_module = pane_module, .filters = test_filters }); _ = units.add(b, pane_tests, b.step("pane-test", "run pane, output and namespace integration tests")); // The behavioural tests (docs/next-tests.md): their module has the // session alone, so none can reach past what a 9P client sees. const session_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/session.zig"), .link_libc = true, }); session_module.addImport("pardes", core_module); // The scripted language server its language words ask // (Session.initLanguage), as the snapshot scripts' do. const session_options = b.addOptions(); session_options.addOptionPath("lspmock", b.addExecutable(.{ .name = "pardes-lspmock", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/lspmock.zig"), .link_libc = true, }), }).getEmittedBin()); var fake_addon_lib: ?*std.Build.Step.Compile = null; // The fake addon (addons/fake/fake.c) and three copies of it built // wrong, which the loader must refuse (test/behaviour/addons.zig). for ([_]struct { []const u8, []const u8 }{ .{ "fake_addon", "-DFAKE_PLAIN" }, .{ "fake_addon_abi", "-DFAKE_ABI=0x30000" }, .{ "fake_addon_no_export", "-DFAKE_NO_EXPORT" }, .{ "fake_addon_core_word", "-DFAKE_WORD=\"Save\"" }, .{ "fake_addon_no_dump", "-DFAKE_NO_DUMP" }, }) |variant| { const lib = b.addLibrary(.{ .name = variant[0], .linkage = .dynamic, .root_module = b.createModule(.{ .target = target, .optimize = optimize, .link_libc = true }) }); lib.root_module.addIncludePath(b.path("src/kinds")); const name_flag = if (std.mem.eql(u8, variant[0], "fake_addon_abi")) "-DFAKE_NAME=\"fakeabi\"" else if (std.mem.eql(u8, variant[0], "fake_addon_core_word")) "-DFAKE_NAME=\"fakeword\"" else "-DFAKE_PLAIN"; // The header is the whole contract: it compiles clean under every warning. lib.root_module.addCSourceFile(.{ .file = b.path("addons/fake/fake.c"), .flags = &.{ "-std=c11", "-Wall", "-Wextra", "-Werror", "-Wno-override-init", variant[1], name_flag } }); session_options.addOptionPath(variant[0], lib.getEmittedBin()); if (std.mem.eql(u8, variant[0], "fake_addon")) fake_addon_lib = lib; } session_options.addOptionPath("image_addon", image_addon.getEmittedBin()); session_options.addOption(bool, "has_pdf_addon", pdf_addon != null); if (pdf_addon) |l| session_options.addOptionPath("pdf_addon", l.getEmittedBin()); session_module.addOptions("session_options", session_options); const behaviour_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/behaviour.zig"), .link_libc = true, }); behaviour_module.addImport("session", session_module); // The build's options alone (platform), never the core: a test of a // window's word knows which build it runs in. behaviour_module.addImport("pardes_config", core_module.import_table.get("pardes_config").?); const behaviour_tests = b.addTest(.{ .root_module = behaviour_module, .filters = test_filters }); const behaviour_test_step = b.step("behaviour-test", "run the behavioural tests, through the 9P tree alone (test/behaviour/)"); _ = units.add(b, behaviour_tests, behaviour_test_step); // An addon's own test: `--addon-test` over the fake (the template) // and the snake (a shipped example, built but not installed), each // with its script, compared with what it printed when written. const addon_test_step = b.step("addon-test", "pardes --addon-test over the fake, snake and pdf addons, against addons/*/*.out"); const snake_lib = b.addLibrary(.{ .name = "snake", .linkage = .dynamic, .root_module = b.createModule(.{ .target = target, .optimize = optimize, .link_libc = true }) }); snake_lib.root_module.addIncludePath(b.path("src/kinds")); snake_lib.root_module.addCSourceFile(.{ .file = b.path("addons/snake/snake.c"), .flags = &.{ "-std=c11", "-Wall", "-Wextra", "-Werror" } }); // ...and the pdf addon's, which mupdf-check runs too (its script // opens docs/design.pdf, from the build root). const libs = [_]struct { ?*std.Build.Step.Compile, []const u8 }{ .{ fake_addon_lib.?, "addons/fake/fake" }, .{ snake_lib, "addons/snake/snake" }, .{ pdf_addon, "addons/pdf/pdf" } }; for (libs) |t| if (t[0]) |lib| { const run_addon_test = b.addRunArtifact(exe); run_addon_test.setCwd(b.path(".")); run_addon_test.addArg("--addon-test"); run_addon_test.addArtifactArg(lib); run_addon_test.addFileArg(b.path(b.fmt("{s}.script", .{t[1]}))); const compare = b.addSystemCommand(&.{ "diff", "-u" }); compare.addFileArg(b.path(b.fmt("{s}.out", .{t[1]}))); compare.addFileArg(run_addon_test.captureStdOut(.{})); behaviour_test_step.dependOn(&compare.step); addon_test_step.dependOn(&compare.step); if (lib == pdf_addon) mupdf_check.dependOn(&compare.step); }; // The 9P monkey at T1 (test/monkey9p.zig): random requests against // an in-process session, the documented rules checked after each. // Its fixed-seed smoke run is part of behaviour-test. const monkey_session = b.addExecutable(.{ .name = "pardes-monkey-session", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/monkey9p.zig"), .link_libc = true, }), }); monkey_session.root_module.addImport("session", session_module); const run_monkey_session = b.addRunArtifact(monkey_session); run_monkey_session.addPassthruArgs(); run_monkey_session.has_side_effects = true; b.step("monkey-session", "random 9P requests against an in-process session, checking the documented rules (-- [--seed N]... [--steps M] [--only i,j,k] [--no-shrink] [-v])").dependOn(&run_monkey_session.step); const run_monkey_session_smoke = b.addRunArtifact(monkey_session); run_monkey_session_smoke.addArg("--smoke"); run_monkey_session_smoke.has_side_effects = true; const monkey_session_smoke_step = b.step("monkey-session-smoke", "a short fixed-seed run of monkey-session (part of behaviour-test)"); monkey_session_smoke_step.dependOn(&run_monkey_session_smoke.step); if (test_filters.len == 0) behaviour_test_step.dependOn(&run_monkey_session_smoke.step); // Kitty graphics conformance at the core: what a terminal pane's // program sends, what it reads back, what ghostty stores and what a // frame draws (test/kitty.zig). The end-to-end arm, through a real // pty and the shell's output, is the kitty-harness step. const kitty_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/kitty.zig"), .link_libc = true, }); kitty_module.addImport("pardes", core_module); const kitty_tests = b.addTest(.{ .root_module = kitty_module, .filters = test_filters }); _ = units.add(b, kitty_tests, b.step("kitty-test", "run the kitty graphics conformance cases for terminal panes")); // 9p_io.zig's and fs.zig's tests as roots of their own, on the // core's imports and C libraries: native transport integration // stays reachable even when Zig's filter leaves the core's // anonymous test-import block out. for ([_]struct { path: []const u8, step: []const u8, about: []const u8, filters: []const []const u8 }{ .{ .path = "src/9p_io.zig", .step = "9p-io-test", .about = "run native 9P transport and client integration tests", .filters = &.{ "Unix and TCP", "one fetch", "expired sessions", "posts itself" } }, .{ .path = "src/fs.zig", .step = "fs-unit-test", .about = "run filesystem unit tests", .filters = test_filters }, }) |t| { const m = b.createModule(.{ .root_source_file = b.path(t.path), .target = target, .optimize = optimize, .link_libc = true }); m.link_objects.appendSlice(b.allocator, core_module.link_objects.items) catch @panic("OOM"); var imports = core_module.import_table.iterator(); while (imports.next()) |entry| m.addImport(entry.key_ptr.*, entry.value_ptr.*); b.step(t.step, t.about).dependOn(&b.addRunArtifact(b.addTest(.{ .root_module = m, .filters = t.filters })).step); } const protocol_step = b.step("9p-test", "run freestanding 9P protocol tests"); const protocol_match = testMatch(b, unit_profile, test_filters, protocol_step); for ([_]struct { path: []const u8, libc: bool, optimize: ?std.builtin.OptimizeMode = null }{ .{ .path = "test/history.zig", .libc = false }, .{ .path = "src/9p.zig", .libc = false }, .{ .path = "src/fonts.zig", .libc = true }, .{ .path = "src/c_heap.zig", .libc = false }, // Its lookup goes wrong only where the optimizer folds it. .{ .path = "src/c_heap.zig", .libc = false, .optimize = .ReleaseSafe }, }) |entry| { const tests = b.addTest(.{ .root_module = b.createModule(.{ .target = target, .optimize = entry.optimize orelse optimize, .root_source_file = b.path(entry.path), .link_libc = entry.libc, }), .filters = test_filters, }); tests.root_module.addImport("cloud9", cloud9); const run_tests = units.add(b, tests, null); if (std.mem.eql(u8, entry.path, "src/9p.zig")) { protocol_step.dependOn(&run_tests.step); if (protocol_match) |check| check.addArtifactArg(tests); } } const deck_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/deck/replay.zig"), }); deck_module.addImport("deck", b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("src/gui/deck.zig"), })); _ = units.add(b, b.addTest(.{ .root_module = deck_module, .filters = test_filters }), null); if (platform == .tui or platform == .gui) { const run_shell_test = units.add(b, b.addTest(.{ .root_module = root_mod, .filters = test_filters }), null); // The native shell's tests alone, without the perf gate's // ReleaseFast build: what a -Dtest-filter iteration wants. b.step("shell-test", "run the native shell's unit tests (src/main.zig's)").dependOn(&run_shell_test.step); const profile_test = b.addExecutable(.{ .name = "pardes-unit-profile-test", .root_module = b.createModule(.{ .target = target, .optimize = optimize, .root_source_file = b.path("test/unit_profile_test.zig"), }), }); const run_profile_test = b.addRunArtifact(profile_test); run_profile_test.addArtifactArg(unit_profile); run_profile_test.has_side_effects = true; b.step("unit-profile-test", "test profiler timing, failures and deadlines").dependOn(&run_profile_test.step); if (test_filters.len == 0) { unit_step.dependOn(&run_profile_test.step); test_build.dependOn(&unit_profile.step); test_build.dependOn(&profile_test.step); } } } // The test-build programs installed rather than run, for a machine the // build cannot run them on (`-Dtarget=x86_64-freebsd.15.0`): each into // /test, named for its root file. const test_install = b.step("test-install", "install the test-build programs into /test, to run elsewhere"); for (test_build.dependencies.items) |dep| { const t = dep.cast(std.Build.Step.Compile) orelse continue; const name = switch (t.root_module.root_source_file orelse continue) { .src_path => |p| std.fs.path.stem(p.sub_path), else => t.name, }; test_install.dependOn(&b.addInstallArtifact(t, .{ .dest_dir = .{ .override = .{ .custom = "test" } }, .dest_sub_path = name }).step); } } /// What every unit-test program is wired into: test-build, unit-test, and /// unit-test's one filter check (`match`: a filter need match in one only). const Units = struct { nonce: ?*std.Build.Module, build: *std.Build.Step, unit: *std.Build.Step, match: ?*std.Build.Step.Run, profiler: *std.Build.Step.Compile, filters: []const []const u8, /// `t` wired in, and run by `own` too, with a filter check of its own, /// when it has a step of its own. fn add(u: Units, b: *std.Build, t: *std.Build.Step.Compile, own: ?*std.Build.Step) *std.Build.Step.Run { if (u.nonce) |nonce| t.root_module.addImport("test_rebuild_nonce", nonce); u.build.dependOn(&t.step); const run = b.addRunArtifact(t); run.has_side_effects = true; u.unit.dependOn(&run.step); if (u.match) |check| check.addArtifactArg(t); const step = own orelse return run; step.dependOn(&run.step); if (testMatch(b, u.profiler, u.filters, step)) |check| check.addArtifactArg(t); return run; } }; fn testMatch(b: *std.Build, profiler: *std.Build.Step.Compile, filters: []const []const u8, step: *std.Build.Step) ?*std.Build.Step.Run { if (filters.len == 0) return null; const check = b.addRunArtifact(profiler); check.addArgs(&.{ "--check-filter", filters[0] }); check.has_side_effects = true; step.dependOn(&check.step); return check; } /// Installs `artifact` in the prefix and, given `home_bin`, copies it there /// too (`install` unlinks first, so a running binary is replaced). fn installHome(b: *std.Build, artifact: *std.Build.Step.Compile, home_bin: ?[]const u8) void { b.installArtifact(artifact); const dir = home_bin orelse return; const copy = b.addSystemCommand(&.{ "install", "-Dm755" }); copy.addArtifactArg(artifact); copy.addArg(b.pathJoin(&.{ dir, artifact.name })); copy.has_side_effects = true; b.getInstallStep().dependOn(©.step); } /// ghostty's kitty graphics loader (src/terminal/kitty/graphics_image.zig), /// patched at build time so a fresh fetch keeps it, for what a program in a /// pane may name with t=f, t=t and t=s (test/kitty.zig): /// - a path is opened for reading only once it is known to be a regular /// file: ghostty opens first and checks after, and the open of a FIFO /// waits for a writer (pardes hung) while a device's open may do /// something. On Linux an O_PATH probe looks, which opens nothing, and /// the same inode is reopened through /proc/self/fd; elsewhere a stat by /// path looks first. /// - shared memory is opened non-blocking and must be a regular file, so /// a FIFO in /dev/shm (or a symlink there to one) neither hangs nor maps. /// - an image may be no larger than a screen's storage /// (TerminalImages.storage_limit) rather than ghostty's 400 MB, which a /// program could make pardes read and hold before refusing it. fn patchGhosttyKitty(b: *std.Build, io: std.Io, dep: *std.Build.Dependency, vt: *std.Build.Module) void { const rel = "src/terminal/kitty/graphics_image.zig"; var src = configureRead(b, io, dep.builder.root, rel, 1 << 22) catch @panic("read ghostty's graphics_image.zig"); const edits = [_][2][]const u8{ .{ "const max_size = 400 * 1024 * 1024; // 400MB", "const max_size = 64 * 1024 * 1024; // pardes (build.zig): a screen's storage, TerminalImages.storage_limit", }, .{ \\ var file = std.Io.Dir.cwd().openFile( \\ io, \\ path, \\ .{}, \\ ) catch |err| { , \\ var file = pardesOpenRegular(io, path) catch |err| { }, .{ " const fd = std.c.shm_open(pathz, @as(c_int, @bitCast(std.c.O{ .ACCMODE = .RDONLY })), @as(u16, 0));", \\ // pardes (build.zig): a FIFO there must not hang the open, and \\ // on Linux nothing but a regular file is opened at all. FreeBSD's \\ // names are no files, and its shm_open refuses O_NONBLOCK. \\ if (comptime builtin.target.os.tag == .linux) if (path.len > 0 and path[0] == '/') { \\ var dev: [std.Io.Dir.max_path_bytes]u8 = undefined; \\ const full = std.fmt.bufPrint(&dev, "/dev/shm{s}", .{path}) catch return error.InvalidData; \\ const shm_stat = std.Io.Dir.cwd().statFile(io, full, .{}) catch return error.InvalidData; \\ if (shm_stat.kind != .file) return error.InvalidData; \\ }; \\ const fd = std.c.shm_open(pathz, @as(c_int, @bitCast(std.c.O{ .ACCMODE = .RDONLY, .NONBLOCK = builtin.target.os.tag != .freebsd })), @as(u16, 0)); }, .{ " if (stat.size <= 0) return error.InvalidData;", " if (stat.kind != .file) return error.InvalidData; // pardes (build.zig)\n if (stat.size <= 0) return error.InvalidData;", }, }; for (edits) |edit| { if (std.mem.count(u8, src, edit[0]) != 1) std.debug.panic("ghostty's {s} changed at `{s}`: redo its patch in build.zig", .{ rel, edit[0] }); src = std.mem.replaceOwned(u8, b.allocator, src, edit[0], edit[1]) catch @panic("OOM"); } const helper = \\ \\/// pardes (build.zig): `path`, opened for reading only once it is known \\/// to be a regular file. Elsewhere than Linux, a stat by path first. \\fn pardesOpenRegular(io: std.Io, path: []const u8) !std.Io.File { \\ if (comptime builtin.target.os.tag != .linux) { \\ if ((try std.Io.Dir.cwd().statFile(io, path, .{})).kind != .file) return error.NotRegularFile; \\ return std.Io.Dir.cwd().openFile(io, path, .{}); \\ } \\ const probe = try std.Io.Dir.cwd().openFile(io, path, .{ .path_only = true }); \\ defer probe.close(io); \\ const stat = try probe.stat(io); \\ if (stat.kind != .file) return error.NotRegularFile; \\ var buf: [32]u8 = undefined; \\ const same = std.fmt.bufPrint(&buf, "/proc/self/fd/{d}", .{probe.handle}) catch unreachable; \\ return std.Io.Dir.cwd().openFile(io, same, .{}); \\} \\ ; const files = b.addWriteFiles(); // The rest of src as it is; fonts are the app's, not the library's. _ = files.addCopyDirectory(dep.path("src"), "", .{ .exclude_extensions = &.{ "graphics_image.zig", ".ttf", ".otf" } }); _ = files.add("terminal/kitty/graphics_image.zig", b.fmt("{s}{s}", .{ src, helper })); vt.root_source_file = files.getDirectory().path(b, "lib_vt.zig"); } /// A file read while configuring, under a package's root. A dependency's is /// hash-addressed and never changes under the same pin; this repo's are not /// tracked one by one, since the configure runs again on every build anyway /// (findProgram and gitCommit poison its cache). // ponytail: untracked repo reads; b.dependOnFileContents each one if the configure cache ever stays pure. fn configureRead(b: *std.Build, io: std.Io, root: std.Build.Cache.Path, sub: []const u8, limit: usize) ![]u8 { return root.root_dir.handle.readFileAlloc(io, b.pathJoin(&.{ root.subPathOrDot(), sub }), b.allocator, .limited(limit)); } /// `sub` under the install prefix, known only when the build runs. fn installed(sub: []const u8) std.Build.LazyPath { return .{ .relative = .{ .base = .install_prefix, .sub_path = sub } }; } fn gitCommit(b: *std.Build) ?[]const u8 { // HEAD is not a file the configure cache can track. b.graph.poisonCache(); var code: u8 = 0; const out = b.runAllowFail( &.{ "git", "rev-parse", "--short=12", "HEAD" }, &code, .ignore, ) catch return null; const trimmed = std.mem.trim(u8, out, " \t\r\n"); return if (trimmed.len == 0) null else trimmed; } const ShellConfig = struct { tree_sitter_grammars: TreeSitterGrammars, tracy: bool, /// null = "the platform's own default": the macOS shell hands the row to /// its native menu bar, every other shell keeps the acme topbar. workspace_tag: ?bool, prebuilt_shaders: bool, embed_sources: bool, commit: ?[]const u8, }; fn shellOptions(b: *std.Build, cfg: ShellConfig, platform: Platform) *std.Build.Step.Options { const o = b.addOptions(); o.addOption(Platform, "platform", platform); o.addOption(bool, "syntax_highlighting", cfg.tree_sitter_grammars != .disabled); o.addOption(bool, "syntax_zig_grammar", cfg.tree_sitter_grammars != .disabled); o.addOption(bool, "syntax_minimal_grammars", cfg.tree_sitter_grammars == .minimal or cfg.tree_sitter_grammars == .full); o.addOption(bool, "syntax_full_grammars", cfg.tree_sitter_grammars == .full); o.addOption(bool, "enable_tracy", cfg.tracy); o.addOption(bool, "workspace_tag", cfg.workspace_tag orelse (platform != .macos)); o.addOption(bool, "embed_sources", cfg.embed_sources); o.addOption([]const u8, "version", display_version); // ...and the commit it was built from, when there is one and the build // is stamped at all (see `stamp_commit`). Read at configure time. o.addOption(?[]const u8, "commit", cfg.commit); o.addOption([]const u8, "deps", deps_text); return o; } fn fatArchive(b: *std.Build, lib: *std.Build.Step.Compile) std.Build.LazyPath { const run = std.Build.Step.Run.create(b, "libtool libpardes.a"); run.addArgs(&.{ "libtool", "-static", "-o" }); const output = run.addOutputFileArg("libpardes.a"); for (lib.getCompileDependencies(false), 0..) |dep, i| { if (dep.kind != .lib) continue; run.addFileArg(reindexed(b, dep.getEmittedBin(), i)); } return output; } fn reindexed(b: *std.Build, archive: std.Build.LazyPath, index: usize) std.Build.LazyPath { const run = std.Build.Step.Run.create(b, b.fmt("ranlib #{d}", .{index})); run.addArgs(&.{ "/bin/sh", "-c", "/bin/cp \"$1\" \"$2\" && /usr/bin/ranlib \"$2\"", "_" }); run.addFileArg(archive); return run.addOutputFileArg(b.fmt("{d}.a", .{index})); } /// glslc shaders/.glsl -fshader-stage= -o .spv, /// returned as a LazyPath for @embedFile. The stage is the name's own suffix. fn compileGlsl(b: *std.Build, name: []const u8) std.Build.LazyPath { const stage = if (std.mem.endsWith(u8, name, ".vert")) "vertex" else "fragment"; const cmd = b.addSystemCommand(&.{ "glslc", b.fmt("-fshader-stage={s}", .{stage}) }); cmd.addFileArg(b.path(b.fmt("shaders/{s}.glsl", .{name}))); cmd.addArg("-o"); return cmd.addOutputFileArg(b.fmt("{s}.spv", .{name})); } fn vendoredThemes(b: *std.Build, io: std.Io) []const []const u8 { var names: std.ArrayList([]const u8) = .empty; var dir = b.root.root_dir.handle.openDir(io, "vendor/themes", .{ .iterate = true }) catch @panic("open vendor/themes"); defer dir.close(io); var it = dir.iterate(); while (it.next(io) catch @panic("read vendor/themes")) |e| { if (!std.mem.endsWith(u8, e.name, ".toml") and !std.mem.endsWith(u8, e.name, ".json")) continue; names.append(b.allocator, b.dupe(e.name)) catch @panic("OOM"); } std.mem.sort([]const u8, names.items, {}, struct { fn lt(_: void, a: []const u8, c: []const u8) bool { return std.mem.order(u8, a, c) == .lt; } }.lt); return names.items; } fn wireCore(m: *std.Build.Module, d: struct { kind: ?*std.Build.Module = null, themes: ?*std.Build.Module = null, tree_sitter: ?*std.Build.Module = null, ts_libs: []const *std.Build.Step.Compile = &.{}, ts_queries: ?*std.Build.Step.Options = null, zstbi: ?*std.Build.Module = null, mvzr: ?*std.Build.Module = null, c_heap: ?*std.Build.Module = null, ghostty_vt: ?*std.Build.Module = null, vaxis: ?*std.Build.Module = null, uucode: ?*std.Build.Module = null, wuffs: ?*std.Build.Module = null, xitdb: ?*std.Build.Module = null, }) void { if (d.kind) |x| m.addImport("pardes_addon", x); if (d.themes) |x| m.addImport("generated_themes", x); if (d.tree_sitter) |x| m.addImport("tree-sitter", x); for (d.ts_libs) |lib| m.linkLibrary(lib); if (d.ts_queries) |x| m.addOptions("ts_queries", x); if (d.zstbi) |x| m.addImport("zstbi", x); if (d.mvzr) |x| m.addImport("mvzr", x); if (d.c_heap) |x| m.addImport("c_heap", x); if (d.ghostty_vt) |x| m.addImport("ghostty-vt", x); if (d.vaxis) |x| m.addImport("vaxis", x); if (d.uucode) |x| m.addImport("uucode", x); if (d.wuffs) |x| m.addImport("wuffs", x); if (d.xitdb) |x| m.addImport("xitdb", x); }