@bloomengine/engine 0.3.1 → 0.3.2

package/native/macos/src/lib.rs

@@ -8,7 +8,7 @@
 
 use bloom_shared::engine::EngineState;
 use bloom_shared::renderer::Renderer;
-use bloom_shared::string_header::str_from_header;
+use bloom_shared::string_header::{str_from_header, alloc_perry_string};
 use bloom_shared::audio::{parse_wav, parse_ogg, parse_mp3};
 
 use objc2::rc::Retained;
@@ -753,38 +753,32 @@ pub extern "C" fn bloom_is_mouse_button_released(btn: f64) -> f64 {
 // ============================================================
 
 #[no_mangle]
-pub extern "C" fn bloom_is_gamepad_available(gamepad: f64) -> f64 {
-    let _ = gamepad;
+pub extern "C" fn bloom_is_gamepad_available() -> f64 {
     if engine().input.is_gamepad_available() { 1.0 } else { 0.0 }
 }
 
 #[no_mangle]
-pub extern "C" fn bloom_get_gamepad_axis(gamepad: f64, axis: f64) -> f64 {
-    let _ = gamepad;
+pub extern "C" fn bloom_get_gamepad_axis(axis: f64) -> f64 {
     engine().input.get_gamepad_axis(axis as usize) as f64
 }
 
 #[no_mangle]
-pub extern "C" fn bloom_is_gamepad_button_pressed(gamepad: f64, button: f64) -> f64 {
-    let _ = gamepad;
-    if engine().input.is_gamepad_button_pressed(button as usize) { 1.0 } else { 0.0 }
+pub extern "C" fn bloom_is_gamepad_button_pressed(btn: f64) -> f64 {
+    if engine().input.is_gamepad_button_pressed(btn as usize) { 1.0 } else { 0.0 }
 }
 
 #[no_mangle]
-pub extern "C" fn bloom_is_gamepad_button_down(gamepad: f64, button: f64) -> f64 {
-    let _ = gamepad;
-    if engine().input.is_gamepad_button_down(button as usize) { 1.0 } else { 0.0 }
+pub extern "C" fn bloom_is_gamepad_button_down(btn: f64) -> f64 {
+    if engine().input.is_gamepad_button_down(btn as usize) { 1.0 } else { 0.0 }
 }
 
 #[no_mangle]
-pub extern "C" fn bloom_is_gamepad_button_released(gamepad: f64, button: f64) -> f64 {
-    let _ = gamepad;
-    if engine().input.is_gamepad_button_released(button as usize) { 1.0 } else { 0.0 }
+pub extern "C" fn bloom_is_gamepad_button_released(btn: f64) -> f64 {
+    if engine().input.is_gamepad_button_released(btn as usize) { 1.0 } else { 0.0 }
 }
 
 #[no_mangle]
-pub extern "C" fn bloom_get_gamepad_axis_count(gamepad: f64) -> f64 {
-    let _ = gamepad;
+pub extern "C" fn bloom_get_gamepad_axis_count() -> f64 {
     engine().input.get_gamepad_axis_count() as f64
 }
 
@@ -793,13 +787,13 @@ pub extern "C" fn bloom_get_gamepad_axis_count(gamepad: f64) -> f64 {
 // ============================================================
 
 #[no_mangle]
-pub extern "C" fn bloom_get_touch_x() -> f64 {
-    engine().input.get_touch_x(0)
+pub extern "C" fn bloom_get_touch_x(index: f64) -> f64 {
+    engine().input.get_touch_x(index as usize)
 }
 
 #[no_mangle]
-pub extern "C" fn bloom_get_touch_y() -> f64 {
-    engine().input.get_touch_y(0)
+pub extern "C" fn bloom_get_touch_y(index: f64) -> f64 {
+    engine().input.get_touch_y(index as usize)
 }
 
 #[no_mangle]
@@ -1411,19 +1405,7 @@ pub extern "C" fn bloom_profiler_frame_history() -> *const u8 {
     for (cpu, gpu) in &hist {
         s.push_str(&format!("{:.2}|{:.2}\n", cpu, gpu));
     }
-    let bytes = s.as_bytes();
-    let len = bytes.len();
-    let total = 12 + len;
-    let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
-    unsafe {
-        let ptr = std::alloc::alloc(layout);
-        if ptr.is_null() { return std::ptr::null(); }
-        *(ptr as *mut u32) = len as u32;
-        *(ptr.add(4) as *mut u32) = len as u32;
-        *(ptr.add(8) as *mut u32) = 1;
-        std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(12), len);
-        ptr
-    }
+    alloc_perry_string(&s)
 }
 
 #[no_mangle]
@@ -1441,19 +1423,7 @@ pub extern "C" fn bloom_profiler_overlay_text() -> *const u8 {
         }
         s.push('\n');
     }
-    let bytes = s.as_bytes();
-    let len = bytes.len();
-    let total = 12 + len;
-    let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
-    unsafe {
-        let ptr = std::alloc::alloc(layout);
-        if ptr.is_null() { return std::ptr::null(); }
-        *(ptr as *mut u32) = len as u32;
-        *(ptr.add(4) as *mut u32) = len as u32;
-        *(ptr.add(8) as *mut u32) = 1;
-        std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(12), len);
-        ptr
-    }
+    alloc_perry_string(&s)
 }
 
 // ============================================================
@@ -2327,27 +2297,11 @@ pub extern "C" fn bloom_set_clipboard_text(text_ptr: *const u8) {
 #[no_mangle]
 pub extern "C" fn bloom_get_clipboard_text() -> *const u8 {
     match arboard::Clipboard::new() {
-        Ok(mut clipboard) => {
-            match clipboard.get_text() {
-                Ok(text) => {
-                    let bytes = text.as_bytes();
-                    let len = bytes.len();
-                    let total = 12 + len;
-                    let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
-                    unsafe {
-                        let ptr = std::alloc::alloc(layout);
-                        if ptr.is_null() { return std::ptr::null(); }
-                        *(ptr as *mut u32) = len as u32;
-                        *(ptr.add(4) as *mut u32) = len as u32;
-                        *(ptr.add(8) as *mut u32) = 1;
-                        std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(12), len);
-                        ptr
-                    }
-                }
-                Err(_) => std::ptr::null(),
-            }
-        }
-        Err(_) => std::ptr::null(),
+        Ok(mut clipboard) => match clipboard.get_text() {
+            Ok(text) => alloc_perry_string(&text),
+            Err(_) => alloc_perry_string(""),
+        },
+        Err(_) => alloc_perry_string(""),
     }
 }
 
@@ -2361,23 +2315,8 @@ pub extern "C" fn bloom_open_file_dialog(filter_ptr: *const u8, title_ptr: *cons
         dialog = dialog.add_filter("Files", &[filter]);
     }
     match dialog.pick_file() {
-        Some(path) => {
-            let s = path.to_string_lossy();
-            let bytes = s.as_bytes();
-            let len = bytes.len();
-            let total = 12 + len;
-            let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
-            unsafe {
-                let ptr = std::alloc::alloc(layout);
-                if ptr.is_null() { return std::ptr::null(); }
-                *(ptr as *mut u32) = len as u32;
-                *(ptr.add(4) as *mut u32) = len as u32;
-                *(ptr.add(8) as *mut u32) = 1;
-                std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(12), len);
-                ptr
-            }
-        }
-        None => std::ptr::null(),
+        Some(path) => alloc_perry_string(&path.to_string_lossy()),
+        None => alloc_perry_string(""),
     }
 }
 
@@ -2389,23 +2328,8 @@ pub extern "C" fn bloom_save_file_dialog(default_name_ptr: *const u8, title_ptr:
         .set_title(title)
         .set_file_name(default_name);
     match dialog.save_file() {
-        Some(path) => {
-            let s = path.to_string_lossy();
-            let bytes = s.as_bytes();
-            let len = bytes.len();
-            let total = 12 + len;
-            let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
-            unsafe {
-                let ptr = std::alloc::alloc(layout);
-                if ptr.is_null() { return std::ptr::null(); }
-                *(ptr as *mut u32) = len as u32;
-                *(ptr.add(4) as *mut u32) = len as u32;
-                *(ptr.add(8) as *mut u32) = 1;
-                std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(12), len);
-                ptr
-            }
-        }
-        None => std::ptr::null(),
+        Some(path) => alloc_perry_string(&path.to_string_lossy()),
+        None => alloc_perry_string(""),
     }
 }
 
@@ -2456,24 +2380,12 @@ pub extern "C" fn bloom_file_exists(path_ptr: *const u8) -> f64 {
 #[no_mangle]
 pub extern "C" fn bloom_read_file(path_ptr: *const u8) -> *const u8 {
     let path = str_from_header(path_ptr);
+    // Always return a valid Perry string. A null pointer would NaN-box into a
+    // string-typed JS value pointing at address 0; `.length` / `.charCodeAt`
+    // would then segfault. Callers detect "missing file" via `data.length === 0`.
     match std::fs::read_to_string(path) {
-        Ok(contents) => {
-            // Return Perry-format string: StringHeader (length u32 + capacity u32 + refcount u32) followed by UTF-8 data
-            let bytes = contents.as_bytes();
-            let len = bytes.len();
-            let total = 12 + len; // 12 bytes header (3 × u32) + data
-            let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
-            unsafe {
-                let ptr = std::alloc::alloc(layout);
-                if ptr.is_null() { return std::ptr::null(); }
-                *(ptr as *mut u32) = len as u32;           // length
-                *(ptr.add(4) as *mut u32) = len as u32;    // capacity
-                *(ptr.add(8) as *mut u32) = 1;             // refcount (unique)
-                std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(12), len);
-                ptr
-            }
-        }
-        Err(_) => std::ptr::null(),
+        Ok(contents) => alloc_perry_string(&contents),
+        Err(_)       => alloc_perry_string(""),
     }
 }
 

package/native/shared/build.rs

@@ -50,10 +50,38 @@ fn build_jolt() {
     println!("cargo:rerun-if-changed={}", shim_dir.join("include/bloom_jolt.h").display());
     println!("cargo:rerun-if-changed={}", shim_dir.join("src/bloom_jolt.cpp").display());
 
-    let dst = cmake::Config::new(&shim_dir)
-        .profile("Release")
-        .define("CMAKE_BUILD_TYPE", "Release")
-        .build();
+    // Build into a stable, short path next to the shim itself rather than the
+    // per-build OUT_DIR. Two reasons:
+    //   1. Cargo wraps OUT_DIR with the `\\?\` long-path prefix on Windows
+    //      whenever the absolute path approaches MAX_PATH; MSBuild and cl.exe
+    //      both choke on `\\?\`-prefixed paths in subtle ways (echo'd build
+    //      events fail with MSB3073, cl.exe rewrites the file to `\\testfile`
+    //      and reports C1083).
+    //   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));
+
+    let lib_ext = if target_os == "windows" { "lib" } else { "a" };
+    let lib_prefix = if target_os == "windows" { "" } else { "lib" };
+    let bloom_jolt_lib = dst
+        .join("lib")
+        .join(format!("{}bloom_jolt.{}", lib_prefix, lib_ext));
+    let jolt_lib = dst
+        .join("lib")
+        .join(format!("{}Jolt.{}", lib_prefix, lib_ext));
+
+    if !(bloom_jolt_lib.exists() && jolt_lib.exists()) {
+        let _ = cmake::Config::new(&shim_dir)
+            .out_dir(&dst)
+            .profile("Release")
+            .define("CMAKE_BUILD_TYPE", "Release")
+            .build();
+    }
 
     println!("cargo:rustc-link-search=native={}", dst.join("lib").display());
     println!("cargo:rustc-link-lib=static=bloom_jolt");

package/native/shared/src/postfx.rs

@@ -43,26 +43,30 @@ struct OutlineParams {
 @group(0) @binding(2) var tex_sampler: sampler;
 @group(0) @binding(3) var<uniform> params: OutlineParams;
 
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-};
+// VertexOutput is defined in FULLSCREEN_VERT — this string is concatenated
+// after it, so redefining here would be a WGSL parser error.
 
 @fragment
 fn fs_outline(in: VertexOutput) -> @location(0) vec4<f32> {
     let color = textureSample(scene_color, tex_sampler, in.uv);
-    let center_id = textureSample(object_id_tex, tex_sampler, in.uv).r;
 
-    let pixel = vec2<f32>(1.0 / params.screen_size.x, 1.0 / params.screen_size.y);
-    let t = params.thickness.x;
+    // Object IDs must not be filtered — interpolating IDs produces nonsense
+    // values at edges. Use textureLoad with integer coords; this also avoids
+    // requiring the FLOAT32_FILTERABLE wgpu feature (not advertised on Apple GPUs).
+    let dim = vec2<i32>(textureDimensions(object_id_tex));
+    let max_xy = dim - vec2<i32>(1, 1);
+    let center_pix = clamp(vec2<i32>(in.uv * vec2<f32>(dim)), vec2<i32>(0, 0), max_xy);
+    let center_id = textureLoad(object_id_tex, center_pix, 0).r;
+
+    let t = max(1, i32(round(params.thickness.x)));
 
     // Sample neighbors for edge detection
     var edge = 0.0;
     for (var dy = -1; dy <= 1; dy++) {
         for (var dx = -1; dx <= 1; dx++) {
             if (dx == 0 && dy == 0) { continue; }
-            let offset = vec2<f32>(f32(dx), f32(dy)) * pixel * t;
-            let neighbor_id = textureSample(object_id_tex, tex_sampler, in.uv + offset).r;
+            let neighbor_pix = clamp(center_pix + vec2<i32>(dx, dy) * t, vec2<i32>(0, 0), max_xy);
+            let neighbor_id = textureLoad(object_id_tex, neighbor_pix, 0).r;
             if (abs(neighbor_id - center_id) > 0.001) {
                 edge += 1.0;
             }
@@ -169,7 +173,9 @@ impl PostFxPipeline {
             label: Some("outline_bg_layout"),
             entries: &[
                 bgl_texture(0, wgpu::TextureSampleType::Float { filterable: true }),
-                bgl_texture(1, wgpu::TextureSampleType::Float { filterable: true }),
+                // R32Float — non-filterable on adapters without FLOAT32_FILTERABLE
+                // (e.g. Apple GPUs). Sampled via textureLoad in OUTLINE_FRAG.
+                bgl_texture(1, wgpu::TextureSampleType::Float { filterable: false }),
                 bgl_sampler(2),
                 bgl_uniform(3),
             ],

package/native/shared/src/renderer/formats.rs

@@ -430,15 +430,9 @@ pub(super) fn create_mesh_sdf_texture(
         sample_count: 1,
         dimension: wgpu::TextureDimension::D3,
         format: wgpu::TextureFormat::R32Float,
-        // COPY_DST is needed by ticket 022's disk cache so a cached
-        // SDF can be uploaded via queue.write_texture instead of
-        // re-baked. COPY_SRC is needed by the same ticket's readback
-        // path on cache miss. Both have zero runtime cost when the
-        // cache isn't used (just usage-flag bits at allocation).
         usage: wgpu::TextureUsages::STORAGE_BINDING
              | wgpu::TextureUsages::TEXTURE_BINDING
-             | wgpu::TextureUsages::COPY_SRC
-             | wgpu::TextureUsages::COPY_DST,
+             | wgpu::TextureUsages::COPY_SRC,
         view_formats: &[],
     });
     let view = texture.create_view(&wgpu::TextureViewDescriptor::default());

package/native/shared/src/renderer/impulse_field.rs

@@ -150,7 +150,8 @@ impl ImpulseField {
                 dimension: wgpu::TextureDimension::D2,
                 format: wgpu::TextureFormat::R32Float,
                 usage: wgpu::TextureUsages::TEXTURE_BINDING
-                     | wgpu::TextureUsages::STORAGE_BINDING,
+                     | wgpu::TextureUsages::STORAGE_BINDING
+                     | wgpu::TextureUsages::COPY_SRC,
                 view_formats: &[],
             });
             let view = tex.create_view(&Default::default());

package/native/shared/src/renderer/material_system.rs

@@ -1775,11 +1775,21 @@ mod tests {
             compatible_surface: None,
             force_fallback_adapter: true,
         })).ok()?;
+        // The material ABI uses 5 bind groups (PerFrame, PerView,
+        // PerMaterial, PerDraw, SceneInputs). downlevel_defaults caps
+        // max_bind_groups at 4, which is fine on Metal (it silently
+        // accepts more) but DX12 enforces it strictly — bump to 5 so
+        // the user-material pipeline validates on every backend.
+        // Also bump max_uniform_buffer_binding_size from 16KB to 64KB
+        // for the JointMatrices UBO (1024 × mat4x4 = 64KB).
+        let mut required_limits = wgpu::Limits::downlevel_defaults();
+        required_limits.max_bind_groups = 5;
+        required_limits.max_uniform_buffer_binding_size = 64 << 10;
         let (device, queue) = pollster::block_on(adapter.request_device(
             &wgpu::DeviceDescriptor {
                 label: Some("material-test-device"),
                 required_features: wgpu::Features::empty(),
-                required_limits: wgpu::Limits::downlevel_defaults(),
+                required_limits,
                 ..Default::default()
             },
         )).ok()?;
@@ -1832,7 +1842,7 @@ fn fs_main(_in: VsOut) -> TranslucentOut {
     /// at (-1,-1), (3,-1), (-1,3). The pipeline's MVP starts as
     /// identity (we override it below) so the triangle covers the
     /// whole viewport.
-    fn make_fullscreen_tri(device: &wgpu::Device) -> (wgpu::Buffer, wgpu::Buffer, u32) {
+    fn make_fullscreen_tri(device: &wgpu::Device, queue: &wgpu::Queue) -> (wgpu::Buffer, wgpu::Buffer, u32) {
         let mut verts: [Vertex3D; 3] = [Vertex3D::default(); 3];
         verts[0].position = [-1.0, -1.0, 0.5];
         verts[1].position = [ 3.0, -1.0, 0.5];
@@ -1847,6 +1857,7 @@ fn fs_main(_in: VsOut) -> TranslucentOut {
             usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
+        queue.write_buffer(&vb, 0, bytemuck::cast_slice(&verts));
         let indices: [u32; 3] = [0, 1, 2];
         let ib = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("test_tri_ib"),
@@ -1854,6 +1865,7 @@ fn fs_main(_in: VsOut) -> TranslucentOut {
             usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
+        queue.write_buffer(&ib, 0, bytemuck::cast_slice(&indices));
         (vb, ib, 3)
     }
 
@@ -1919,7 +1931,7 @@ fn fs_main(_in: VsOut) -> TranslucentOut {
             [0.0, 0.0, 1.0, 0.0],
             [0.0, 0.0, 0.0, 1.0],
         ];
-        let (vb, ib, icount) = make_fullscreen_tri(&device);
+        let (vb, ib, icount) = make_fullscreen_tri(&device, &queue);
 
         sys.submit_draw(
             &device, &queue, &joint_buf,

package/native/shared/src/renderer/shaders.rs

@@ -4337,6 +4337,12 @@ fn fs_main(in: VsOut) -> @location(0) vec4<f32> {
     var hit_uv = vec2<f32>(-1.0);
     var hit_found = false;
     var prev_t = 0.0;
+    // FXC (the legacy HLSL compiler used by D3D11 + DX12 fallback in wgpu) refuses
+    // to unroll a loop that contains an implicit-gradient texture sample when the
+    // iteration count is uniform-driven, and refuses to *not* unroll because the
+    // body has the gradient op — the only escape is to take the gradient out of
+    // the loop. textureSampleLevel forces explicit LOD and removes the gradient
+    // op, which is also what we want here (depth has no mips).
     for (var i = 0u; i < n_steps; i = i + 1u) {
         let ray_view = view_pos + r * t;
         let ray_clip = u.proj * vec4<f32>(ray_view, 1.0);
@@ -4347,7 +4353,7 @@ fn fs_main(in: VsOut) -> @location(0) vec4<f32> {
             break;
         }
         let ray_uv = vec2<f32>(ray_ndc.x * 0.5 + 0.5, 1.0 - (ray_ndc.y * 0.5 + 0.5));
-        let scene_depth = textureSample(depth_tex, depth_samp, ray_uv);
+        let scene_depth = textureSampleLevel(depth_tex, depth_samp, ray_uv, 0i);
 
         if (ray_ndc.z >= scene_depth) {
             let hit_view = view_pos_from_depth(ray_uv, scene_depth);

package/native/shared/src/renderer/transient.rs

@@ -86,6 +86,9 @@ pub struct TransientId(pub u32);
 
 /// Internal record per live allocation.
 struct Slot {
+    /// Stable handle id — survives `Vec` reordering when invalidation
+    /// drops other slots, so `TransientId` lookups stay valid.
+    id:       u32,
     desc:     TransientDesc,
     /// Physical extent at allocation time — used for resize detection.
     extent:   (u32, u32),
@@ -173,13 +176,13 @@ impl TransientPool {
         let target_extent = desc.size.extent(self.swap_size.0, self.swap_size.1);
 
         // Look for an existing free slot with identical desc + extent.
-        for (i, slot) in self.slots.iter_mut().enumerate() {
+        for slot in self.slots.iter_mut() {
             if !slot.in_use
                 && slot.desc == desc
                 && slot.extent == target_extent
             {
                 slot.in_use = true;
-                return TransientId(i as u32);
+                return TransientId(slot.id);
             }
         }
 
@@ -201,13 +204,10 @@ impl TransientPool {
         let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
         let id = self.next_id;
         self.next_id += 1;
-        // Slot index equals the id in this simple implementation —
-        // once we add alias-based reuse the mapping becomes indirect,
-        // but for now that's overkill.
-        let slot_index = self.slots.len() as u32;
-        assert_eq!(id, slot_index,
-            "TransientPool invariant: slot ids are contiguous until Phase 3b adds aliasing");
-        self.slots.push(Slot { desc, extent: target_extent, texture, view, in_use: true });
+        // Ids are stable — surviving slots keep theirs across resizes
+        // (which can drop swapchain-relative slots and shrink the Vec),
+        // so handle lookups stay valid even when the slot index shifts.
+        self.slots.push(Slot { id, desc, extent: target_extent, texture, view, in_use: true });
         TransientId(id)
     }
 
@@ -215,7 +215,7 @@ impl TransientPool {
     /// reuse pool and can be handed back to a subsequent `acquire`
     /// with a matching desc.
     pub fn release(&mut self, id: TransientId) {
-        if let Some(slot) = self.slots.get_mut(id.0 as usize) {
+        if let Some(slot) = self.slots.iter_mut().find(|s| s.id == id.0) {
             slot.in_use = false;
         }
     }
@@ -223,12 +223,12 @@ impl TransientPool {
     /// Get the underlying texture for a transient. Borrowed for the
     /// pool's lifetime — callers hold the borrow only while encoding.
     pub fn texture(&self, id: TransientId) -> Option<&wgpu::Texture> {
-        self.slots.get(id.0 as usize).map(|s| &s.texture)
+        self.slots.iter().find(|s| s.id == id.0).map(|s| &s.texture)
     }
 
     /// Get the default view for a transient.
     pub fn view(&self, id: TransientId) -> Option<&wgpu::TextureView> {
-        self.slots.get(id.0 as usize).map(|s| &s.view)
+        self.slots.iter().find(|s| s.id == id.0).map(|s| &s.view)
     }
 
     /// Frame-end book-keeping. Currently does nothing because

package/native/shared/src/string_header.rs

@@ -33,3 +33,35 @@ pub fn str_from_header(ptr: *const u8) -> &'static str {
         std::str::from_utf8_unchecked(std::slice::from_raw_parts(data, len))
     }
 }
+
+/// Allocate a Perry 0.5.x heap string suitable for returning across the
+/// FFI boundary (declared as `returns: "string"` in package.json). Layout
+/// matches `StringHeader` above: 5×u32 header (utf16_len, byte_len,
+/// capacity, refcount, flags) followed by UTF-8 data.
+///
+/// Older engine code allocated 12 bytes (Perry 0.4.x layout) and Perry's
+/// 0.5.x runtime read 8 bytes into the payload — strings came back with a
+/// garbage prefix and read past the end. Always go through this helper.
+pub fn alloc_perry_string(s: &str) -> *const u8 {
+    let bytes = s.as_bytes();
+    let byte_len = bytes.len();
+    // ASCII fast path: utf16_len == byte_len when every byte is < 0x80.
+    let utf16_len = if bytes.iter().all(|&b| b < 0x80) {
+        byte_len
+    } else {
+        s.encode_utf16().count()
+    };
+    let total = std::mem::size_of::<StringHeader>() + byte_len;
+    let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
+    unsafe {
+        let ptr = std::alloc::alloc(layout);
+        if ptr.is_null() { return std::ptr::null(); }
+        *(ptr as *mut u32)         = utf16_len as u32;
+        *(ptr.add(4)  as *mut u32) = byte_len  as u32;
+        *(ptr.add(8)  as *mut u32) = byte_len  as u32; // capacity
+        *(ptr.add(12) as *mut u32) = 1;                // refcount=unique
+        *(ptr.add(16) as *mut u32) = 0;                // flags
+        std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(20), byte_len);
+        ptr
+    }
+}

package/native/third_party/bloom_jolt/CMakeLists.txt

@@ -8,11 +8,18 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 # ---------------------------------------------------------------------------
 # JoltPhysics build options.
-# Matches the "Distribution" flavour: no asserts, no profile, no debug renderer,
-# interprocedural optimisation on. We keep object stream off — we don't use
-# Jolt's scene serialisation (Bloom handles save/load itself).
+# Matches the "Distribution" flavour: no asserts, no profile, no debug renderer.
+# We keep object stream off — we don't use Jolt's scene serialisation (Bloom
+# handles save/load itself).
+#
+# IPO is OFF because Rust's link step on Linux/GCC routes through rust-lld,
+# which doesn't load gcc's lto-wrapper plugin. With IPO on, libJolt.a's archive
+# members are GIMPLE bitcode and rust-lld leaves their implementations
+# unresolved (undefined-symbol errors on JPH::Free, BodyManager locks, vtables,
+# etc — see issue #44). Jolt is heavily inlined via its precompiled header
+# already, so the perf delta from skipping LTO on the static archive is small.
 # ---------------------------------------------------------------------------
-set(INTERPROCEDURAL_OPTIMIZATION        ON  CACHE BOOL "" FORCE)
+set(INTERPROCEDURAL_OPTIMIZATION        OFF CACHE BOOL "" FORCE)
 set(USE_STATIC_MSVC_RUNTIME_LIBRARY     OFF CACHE BOOL "" FORCE)
 set(TARGET_UNIT_TESTS                   OFF CACHE BOOL "" FORCE)
 set(TARGET_HELLO_WORLD                  OFF CACHE BOOL "" FORCE)
@@ -21,8 +28,10 @@ set(TARGET_SAMPLES                      OFF CACHE BOOL "" FORCE)
 set(TARGET_VIEWER                       OFF CACHE BOOL "" FORCE)
 set(OBJECT_LAYER_BITS                   16  CACHE STRING "" FORCE)
 set(USE_ASSERTS                         OFF CACHE BOOL "" FORCE)
-set(PROFILE_ENABLED                     OFF CACHE BOOL "" FORCE)
+set(PROFILER_IN_DEBUG_AND_RELEASE       OFF CACHE BOOL "" FORCE)
+set(PROFILER_IN_DISTRIBUTION            OFF CACHE BOOL "" FORCE)
 set(DEBUG_RENDERER_IN_DEBUG_AND_RELEASE OFF CACHE BOOL "" FORCE)
+set(DEBUG_RENDERER_IN_DISTRIBUTION      OFF CACHE BOOL "" FORCE)
 set(CROSS_PLATFORM_DETERMINISTIC        OFF CACHE BOOL "" FORCE)
 set(FLOATING_POINT_EXCEPTIONS_ENABLED   OFF CACHE BOOL "" FORCE)
 set(DOUBLE_PRECISION                    OFF CACHE BOOL "" FORCE)

package/native/windows/Cargo.lock

@@ -110,6 +110,7 @@ name = "bloom-windows"
 version = "0.1.0"
 dependencies = [
  "bloom-shared",
+ "image",
  "raw-window-handle",
  "wgpu",
  "windows 0.58.0",

package/native/windows/Cargo.toml

@@ -8,11 +8,20 @@ name = "bloom_windows"
 crate-type = ["staticlib"]
 
 [features]
-default = ["jolt"]
+# Jolt is opt-in on Windows because Perry's native-library build pipeline
+# does not forward cargo `--features` to nativeLibrary crates, and bundling
+# Jolt's static archives into bloom_windows.lib leaves the final lld-link
+# step unable to resolve `JPH::*` symbols (the staticlib has no embedded
+# search path and the C++ library lives off cargo's normal lib search).
+# Games that need bloom/physics on Windows must opt in explicitly until the
+# perry side gains a way to thread `cargo:rustc-link-search` through to the
+# final link line.
+default = []
 jolt = ["bloom-shared/jolt"]
 
 [dependencies]
 bloom-shared = { path = "../shared", default-features = false, features = ["mp3"] }
+image = { version = "0.25", default-features = false, features = ["hdr"] }
 raw-window-handle = "0.6"
 wgpu = "29"