@bloomengine/engine 0.3.3 → 0.4.0

package/native/shared/build.rs

@@ -39,6 +39,28 @@ fn build_jolt() {
         .join("third_party")
         .join("bloom_jolt");
 
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
+
+    println!("cargo:rerun-if-env-changed=BLOOM_JOLT_PREBUILT_DIR");
+    println!("cargo:rerun-if-env-changed=BLOOM_JOLT_FROM_SOURCE");
+
+    // Prebuilt fast path — if `@bloomengine/jolt-prebuilt` is available
+    // (via env var or a node_modules sibling), link its archives and
+    // skip the multi-minute cmake build of JoltPhysics entirely. The
+    // env var BLOOM_JOLT_FROM_SOURCE=1 forces the cmake fallback even
+    // when prebuilts are present, useful for hacking on the C++ shim.
+    let from_source = std::env::var_os("BLOOM_JOLT_FROM_SOURCE").is_some();
+    if !from_source {
+        if let Some(prebuilt_dir) =
+            find_prebuilt_dir(&manifest_dir, &target_os, &target_arch)
+        {
+            link_prebuilt(&prebuilt_dir, &target_os);
+            emit_cxx_runtime_link(&target_os);
+            return;
+        }
+    }
+
     if !shim_dir.join("CMakeLists.txt").exists() {
         panic!(
             "bloom_jolt shim not found at {}; did the third_party submodules init?",
@@ -60,8 +82,6 @@ fn build_jolt() {
     //   2. The Jolt build is expensive and identical across every cargo target
     //      hash — caching it once per profile lets `cargo clean` not nuke a
     //      multi-minute compile.
-    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
-    let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
     let dst = shim_dir
         .join("build")
         .join(format!("{}-{}", target_os, target_arch));
@@ -87,10 +107,121 @@ fn build_jolt() {
     println!("cargo:rustc-link-lib=static=bloom_jolt");
     println!("cargo:rustc-link-lib=static=Jolt");
 
-    // C++ standard library — required because we're linking static archives
-    // that pull in libc++ / libstdc++ symbols.
-    let target = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
-    match target.as_str() {
+    emit_cxx_runtime_link(&target_os);
+}
+
+/// Locate the `@bloomengine/jolt-prebuilt` package's lib dir for the
+/// active build target. Returns `Some(dir)` only when both expected
+/// archives are present — a half-shipped package falls through to the
+/// cmake build instead of producing a confusing linker error.
+///
+/// Resolution order:
+///   1. `BLOOM_JOLT_PREBUILT_DIR` env var — points at a directory
+///      containing per-target subdirs (`<dir>/<os>-<arch>/lib*.a`).
+///      Used for local spike testing and for CI matrix jobs that
+///      stage archives outside `node_modules`.
+///   2. Walk up from `CARGO_MANIFEST_DIR` looking for any
+///      `node_modules/@bloomengine/jolt-prebuilt/lib/<os>-<arch>/`.
+///      Matches what npm's resolver does when `@bloomengine/engine`
+///      depends on `@bloomengine/jolt-prebuilt` — the consumer's
+///      install creates this directory next to the engine package.
+#[cfg(feature = "jolt")]
+fn find_prebuilt_dir(
+    manifest_dir: &std::path::Path,
+    target_os: &str,
+    target_arch: &str,
+) -> Option<std::path::PathBuf> {
+    // Map Rust's target_arch to the npm/Node convention used in this
+    // package's directory layout. Keep this in sync with the matrix in
+    // npm/jolt-prebuilt/README.md.
+    let arch_token = match target_arch {
+        "aarch64" => "arm64",
+        "x86_64" => "x64",
+        "arm" => "armv7",
+        other => other,
+    };
+    let target_token = format!("{}-{}", target_os, arch_token);
+
+    let candidates = std::iter::empty::<std::path::PathBuf>()
+        .chain(
+            std::env::var_os("BLOOM_JOLT_PREBUILT_DIR")
+                .map(|v| std::path::PathBuf::from(v).join(&target_token)),
+        )
+        .chain(walk_up_for_node_modules(manifest_dir).map(|nm| {
+            nm.join("@bloomengine")
+                .join("jolt-prebuilt")
+                .join("lib")
+                .join(&target_token)
+        }));
+
+    let (lib_prefix, lib_ext) = if target_os == "windows" {
+        ("", "lib")
+    } else {
+        ("lib", "a")
+    };
+
+    for dir in candidates {
+        let bloom_jolt = dir.join(format!("{}bloom_jolt.{}", lib_prefix, lib_ext));
+        let jolt = dir.join(format!("{}Jolt.{}", lib_prefix, lib_ext));
+        if bloom_jolt.exists() && jolt.exists() {
+            return Some(dir);
+        }
+    }
+    None
+}
+
+/// Iterator over every ancestor `node_modules/` reachable from
+/// `start`. Yields each directory once, parent-first, so a closer
+/// prebuilt installation wins over a higher one (matching node's
+/// resolution algorithm).
+#[cfg(feature = "jolt")]
+fn walk_up_for_node_modules(
+    start: &std::path::Path,
+) -> impl Iterator<Item = std::path::PathBuf> + '_ {
+    let mut next: Option<&std::path::Path> = Some(start);
+    std::iter::from_fn(move || {
+        while let Some(cur) = next {
+            next = cur.parent();
+            let candidate = cur.join("node_modules");
+            if candidate.is_dir() {
+                return Some(candidate);
+            }
+        }
+        None
+    })
+}
+
+#[cfg(feature = "jolt")]
+fn link_prebuilt(dir: &std::path::Path, target_os: &str) {
+    // Rerun if any archive in the prebuilt dir changes — covers the
+    // case where a new release of jolt-prebuilt drops in new bytes.
+    let (lib_prefix, lib_ext) = if target_os == "windows" {
+        ("", "lib")
+    } else {
+        ("lib", "a")
+    };
+    println!(
+        "cargo:rerun-if-changed={}",
+        dir.join(format!("{}bloom_jolt.{}", lib_prefix, lib_ext))
+            .display()
+    );
+    println!(
+        "cargo:rerun-if-changed={}",
+        dir.join(format!("{}Jolt.{}", lib_prefix, lib_ext)).display()
+    );
+
+    println!("cargo:rustc-link-search=native={}", dir.display());
+    println!("cargo:rustc-link-lib=static=bloom_jolt");
+    println!("cargo:rustc-link-lib=static=Jolt");
+}
+
+/// Emit the C++ standard library link directive that matches the
+/// archives we just linked. Required because the static archives pull
+/// in libc++ / libstdc++ symbols that the Rust toolchain doesn't
+/// resolve on its own.
+#[cfg(feature = "jolt")]
+fn emit_cxx_runtime_link(target_os: &str) {
+    match target_os {
         "macos" | "ios" | "tvos" | "watchos" => {
             println!("cargo:rustc-link-lib=dylib=c++");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloomengine/engine",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Bloom Engine: native TypeScript game engine compiled by Perry",
   "main": "src/index.ts",
   "types": "src/index.ts",