fix: support optimized Bazel builds for Tauri desktop app (#38)

akesling · web-flow · commit 697c322ffbf7 · 2026-04-01T14:06:36.000-04:00
Tauri's generate_context!() proc macro generates struct literals whose
shape depends on cfg(debug_assertions) in the host config, but the code
compiles in the target config. With -c opt the target loses
debug_assertions while the host (fastbuild from .bazelrc) keeps them,
causing missing type/field errors.

Add --config=opt to .bazelrc that sets both compilation_mode and
host_compilation_mode to opt. Gate devtools menu item and handler behind
#[cfg(debug_assertions)] since those APIs are unavailable in release.
diff --git a/.bazelrc b/.bazelrc
@@ -18,13 +18,8 @@ build:clippy --@rules_rust//:clippy_flags=-Dwarnings
 # Running them locally prevents sandbox-path leakage into downstream actions.
 build --strategy=CargoBuildScriptRun=local
 
-# Tauri proc-macro cfg consistency
-# Tauri's ResolvedCommand has #[cfg(debug_assertions)] fields. Proc macros
-# run in the exec config (default: opt → no debug_assertions), but the target
-# uses fastbuild (debug_assertions ON). This mismatch causes the proc macro to
-# generate struct literals missing fields the target compilation expects.
-# Compiling exec tools in fastbuild mode keeps cfg(debug_assertions) consistent.
-build --host_compilation_mode=fastbuild
+# Optimized builds
+build:opt --compilation_mode=opt
 
 # Coverage
 # Filter to only instrument our source code, not external crates or test harnesses
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -41,7 +41,8 @@ All Rust code uses edition 2024. Cargo defaults to edition 2021 for `cargo check
 - `cargo check -p crab_city_desktop` — quick compile check
 - `cargo test -p crab_city_desktop` — run unit tests
 - `cd packages/crab_city_desktop && cargo tauri dev --config tauri.dev.conf.json` — launch desktop app with embedded server (auto-starts Vite dev server)
-- `bazel build //packages/crab_city_desktop:macos_app` — build macOS `.app` bundle with embedded server
+- `bazel build //packages/crab_city_desktop:macos_app` — build macOS `.app` bundle (debug)
+- `bazel build --config=opt //packages/crab_city_desktop:macos_app` — build optimized `.app` bundle
 
 **Dev workflow** (single terminal): `cd packages/crab_city_desktop && cargo tauri dev --config tauri.dev.conf.json` — the Tauri app starts an embedded server in-process, and Vite's dev proxy discovers it automatically via the `daemon.port` file. The `--config` flag merges `tauri.dev.conf.json` (devUrl + beforeDevCommand) into the base config. The base `tauri.conf.json` has no dev URL — production builds never reference external dev servers.
 
diff --git a/packages/crab_city_desktop/BUILD.bazel b/packages/crab_city_desktop/BUILD.bazel
@@ -1,6 +1,7 @@
 load("@rules_rust//cargo:defs.bzl", "cargo_build_script")
 load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_test")
 load(":macos_app.bzl", "macos_app")
+load(":tauri_transition.bzl", "tauri_binary", "tauri_test")
 
 package(default_visibility = ["//visibility:public"])
 
@@ -45,7 +46,7 @@ cargo_build_script(
 )
 
 rust_binary(
-    name = "crab_city_desktop",
+    name = "_crab_city_desktop_raw",
     srcs = glob(["src/**/*.rs"]),
     compile_data = _TAURI_DATA,
     edition = "2024",
@@ -54,8 +55,13 @@ rust_binary(
         "CARGO_MANIFEST_DIR": "packages/crab_city_desktop",
     },
     # no-sandbox: tauri proc macros read config and icon files from disk
-    tags = ["no-sandbox"],
+    # manual: must be built via tauri_binary (which applies cfg transition)
+    tags = [
+        "manual",
+        "no-sandbox",
+    ],
     target_compatible_with = ["@platforms//os:macos"],
+    visibility = ["//visibility:private"],
     deps = [
         ":build_script",
         "//packages/crab_city:crab_city_lib_embedded",
@@ -71,16 +77,33 @@ rust_binary(
     ],
 )
 
+tauri_binary(
+    name = "crab_city_desktop",
+    binary = ":_crab_city_desktop_raw",
+    target_compatible_with = ["@platforms//os:macos"],
+)
+
 rust_test(
-    name = "crab_city_desktop_test",
+    name = "_crab_city_desktop_test_raw",
     compile_data = _TAURI_DATA,
-    crate = ":crab_city_desktop",
+    crate = ":_crab_city_desktop_raw",
     edition = "2024",
     rustc_env = {
         "CARGO_MANIFEST_DIR": "packages/crab_city_desktop",
     },
-    tags = ["no-sandbox"],
+    # manual: must be built via tauri_test (which applies cfg transition)
+    tags = [
+        "manual",
+        "no-sandbox",
+    ],
+    target_compatible_with = ["@platforms//os:macos"],
+    visibility = ["//visibility:private"],
+)
+
+tauri_test(
+    name = "crab_city_desktop_test",
     target_compatible_with = ["@platforms//os:macos"],
+    test = ":_crab_city_desktop_test_raw",
 )
 
 macos_app(
diff --git a/packages/crab_city_desktop/CLAUDE.md b/packages/crab_city_desktop/CLAUDE.md
@@ -41,7 +41,9 @@ Tauri's `generate_context!()` proc macro writes cache files to `OUT_DIR` during
 
 Frontend assets (`frontendDist`) are brotli-compressed into `$OUT_DIR/tauri-codegen-assets/{blake3_hash}.{ext}`. The `precreate_frontend_cache()` function in `build.rs` replicates this exactly so the proc macro's write is a no-op in Bazel.
 
-Additionally, `ResolvedCommand` has `#[cfg(debug_assertions)]` fields. Bazel compiles proc macros in exec config (default: `opt`, no debug_assertions) but targets in `fastbuild` (with debug_assertions). This mismatch is fixed by `--host_compilation_mode=fastbuild` in `.bazelrc`.
+Additionally, `ResolvedCommand` has `#[cfg(debug_assertions)]` fields. Bazel compiles proc macros in exec config (default: `opt`, no debug_assertions) but targets in `fastbuild` (with debug_assertions). This mismatch is fixed by a Starlark transition in `tauri_transition.bzl` that forces `host_compilation_mode` to match `compilation_mode`. The `tauri_binary` and `tauri_test` wrapper rules apply this transition — the raw `rust_binary` and `rust_test` targets are tagged `manual` and should not be built directly.
+
+DevTools APIs (`is_devtools_open()`, `open_devtools()`, `close_devtools()`) are only available with `debug_assertions`. The devtools menu item and handler are gated behind `#[cfg(debug_assertions)]`.
 
 ## Dev Workflow
 
@@ -80,7 +82,10 @@ When the external server dies, the health monitor navigates back to `tauri://loc
 ## Release Build (macOS .app bundle)
 
 ```sh
-bazel build //packages/crab_city_desktop:macos_app
+bazel build //packages/crab_city_desktop:macos_app          # debug
+bazel build --config=opt //packages/crab_city_desktop:macos_app  # optimized
 ```
 
+The `tauri_binary` wrapper rule applies a Starlark transition that keeps `host_compilation_mode` in sync with `compilation_mode`, so both `-c opt` and `--config=opt` work correctly.
+
 Produces `CrabCity.app` with the Tauri binary (which includes the embedded server) in `Contents/MacOS/`. No sidecar binary needed. The `macos_app` rule in `macos_app.bzl` uses a tree artifact (directory output) to assemble the bundle structure. Code signing and notarization are deferred to when public distribution is needed.
diff --git a/packages/crab_city_desktop/src/main.rs b/packages/crab_city_desktop/src/main.rs
@@ -286,6 +286,7 @@ fn setup_menu(app: &tauri::App) -> tauri::Result<()> {
         .accelerator("CmdOrCtrl+R")
         .build(app)?;
 
+    #[cfg(debug_assertions)]
     let devtools_item = MenuItemBuilder::new("Toggle Developer Tools")
         .id("devtools")
         .accelerator("CmdOrCtrl+Alt+I")
@@ -320,12 +321,10 @@ fn setup_menu(app: &tauri::App) -> tauri::Result<()> {
         .select_all()
         .build()?;
 
-    let view_submenu = SubmenuBuilder::new(app, "View")
-        .item(&reload_item)
-        .item(&devtools_item)
-        .separator()
-        .fullscreen()
-        .build()?;
+    let view_submenu_builder = SubmenuBuilder::new(app, "View").item(&reload_item);
+    #[cfg(debug_assertions)]
+    let view_submenu_builder = view_submenu_builder.item(&devtools_item);
+    let view_submenu = view_submenu_builder.separator().fullscreen().build()?;
 
     let window_submenu = SubmenuBuilder::new(app, "Window")
         .minimize()
@@ -356,7 +355,9 @@ fn setup_menu(app: &tauri::App) -> tauri::Result<()> {
                 }
             }
         }
-        "devtools" => {
+        "devtools" =>
+        {
+            #[cfg(debug_assertions)]
             if let Some(window) = app_handle.get_webview_window("main") {
                 if window.is_devtools_open() {
                     window.close_devtools();
diff --git a/packages/crab_city_desktop/tauri_transition.bzl b/packages/crab_city_desktop/tauri_transition.bzl
@@ -0,0 +1,79 @@
+"""Bazel transition that forces host_compilation_mode to match compilation_mode.
+
+Tauri's proc macros use #[cfg(debug_assertions)] on struct fields shared between
+codegen output and runtime (e.g. ResolvedCommand). The proc macro runs in the
+host/exec configuration while the generated code compiles in the target
+configuration. If those disagree on debug_assertions the build breaks. This
+transition keeps them in sync, scoped to Tauri targets only.
+"""
+
+def _match_host_compilation_mode_impl(settings, _attr):
+    return {"//command_line_option:host_compilation_mode": settings["//command_line_option:compilation_mode"]}
+
+_match_host_compilation_mode = transition(
+    implementation = _match_host_compilation_mode_impl,
+    inputs = ["//command_line_option:compilation_mode"],
+    outputs = ["//command_line_option:host_compilation_mode"],
+)
+
+_TRANSITION_ATTRS = {
+    "_allowlist_function_transition": attr.label(
+        default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
+    ),
+}
+
+# --- tauri_binary ---------------------------------------------------------
+
+def _tauri_binary_impl(ctx):
+    bin_info = ctx.attr.binary[0][DefaultInfo]
+    real_executable = bin_info.files_to_run.executable
+
+    # Executable rules require the executable to be created by the rule itself.
+    out = ctx.actions.declare_file(ctx.label.name)
+    ctx.actions.symlink(output = out, target_file = real_executable)
+
+    return [DefaultInfo(
+        files = depset([out]),
+        runfiles = ctx.runfiles(files = [real_executable]).merge(bin_info.default_runfiles),
+        executable = out,
+    )]
+
+tauri_binary = rule(
+    implementation = _tauri_binary_impl,
+    executable = True,
+    attrs = dict({
+        "binary": attr.label(
+            mandatory = True,
+            executable = True,
+            cfg = _match_host_compilation_mode,
+        ),
+    }, **_TRANSITION_ATTRS),
+)
+
+# --- tauri_test -----------------------------------------------------------
+
+def _tauri_test_impl(ctx):
+    test_info = ctx.attr.test[0][DefaultInfo]
+    real_executable = test_info.files_to_run.executable
+
+    # Symlink so the test executable is owned by this rule.
+    out = ctx.actions.declare_file(ctx.label.name)
+    ctx.actions.symlink(output = out, target_file = real_executable)
+
+    return [DefaultInfo(
+        files = depset([out]),
+        runfiles = ctx.runfiles(files = [real_executable]).merge(test_info.default_runfiles),
+        executable = out,
+    )]
+
+tauri_test = rule(
+    implementation = _tauri_test_impl,
+    test = True,
+    attrs = dict({
+        "test": attr.label(
+            mandatory = True,
+            executable = True,
+            cfg = _match_host_compilation_mode,
+        ),
+    }, **_TRANSITION_ATTRS),
+)
