@bloomengine/engine 0.3.1 → 0.3.3

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/JoltPhysics/Build/Android/PerformanceTest/build.gradle

@@ -0,0 +1,51 @@
+plugins {
+    id 'com.android.application'
+}
+
+android {
+    compileSdk 33
+    ndkVersion "26.1.10909125"
+
+    defaultConfig {
+        applicationId "com.joltphysics.performancetest"
+        minSdk 21
+        targetSdk 33
+        versionCode 1
+        versionName "1.0"
+        ndk.abiFilters 'arm64-v8a', 'armeabi-v7a', 'x86_64', 'x86'
+
+        externalNativeBuild {
+            cmake {
+                cppFlags '-std=c++17 -Wall -Werror -ffp-model=precise -ffp-contract=off -DJPH_PROFILE_ENABLED -DJPH_DEBUG_RENDERER'
+                arguments '-DANDROID_TOOLCHAIN=clang', '-DANDROID_STL=c++_static', '-DCROSS_PLATFORM_DETERMINISTIC=ON'
+            }
+        }
+        signingConfig signingConfigs.debug
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    externalNativeBuild {
+        cmake {
+            path file('src/main/cpp/CMakeLists.txt')
+            version '3.22.1'
+        }
+    }
+
+    buildFeatures {
+        viewBinding true
+    }
+    namespace 'com.joltphysics.performancetest'
+}
+
+dependencies {
+}

package/native/third_party/JoltPhysics/Build/Android/PerformanceTest/src/main/AndroidManifest.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application
+        android:allowBackup="true"
+        android:label="Jolt Physics Performance Test"
+        android:supportsRtl="false"
+        android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
+        <activity
+            android:name="android.app.NativeActivity"
+            android:exported="true">
+            <meta-data android:name="android.app.lib_name" android:value="PerformanceTest"/>
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

package/native/third_party/JoltPhysics/Build/Android/PerformanceTest/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.10.2)
+
+project("JoltPhysicsPerformanceTest")
+
+# Make sure we include the app glue sources
+set(APP_GLUE_DIR ${ANDROID_NDK}/sources/android/native_app_glue)
+include_directories(${APP_GLUE_DIR})
+
+# Set repository root
+set(PHYSICS_REPO_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../")
+
+# Make targets
+include(${PHYSICS_REPO_ROOT}/Jolt/Jolt.cmake)
+include(${PHYSICS_REPO_ROOT}/PerformanceTest/PerformanceTest.cmake)
+
+# Link shared native library
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -u ANativeActivity_onCreate")
+add_library(PerformanceTest SHARED ${PERFORMANCE_TEST_SRC_FILES} ${APP_GLUE_DIR}/android_native_app_glue.c)
+target_include_directories(PerformanceTest PUBLIC Jolt ${JOLT_PHYSICS_ROOT} ${PERFORMANCE_TEST_ROOT})
+target_link_libraries(PerformanceTest Jolt android log)