fix: selection across wrapped rows, hot remount, live scroll wheel and env sync

.changeset/select-across-wrapped-rows.md

@@ -0,0 +1,11 @@
+---
+"@gpuix/native": patch
+---
+
+Cover the first glyph of a wrapped row in the selection wash.
+
+The wash walks the visual rows of a paragraph with `position_for_index`.
+The index at a soft-wrap boundary reports its position on the earlier row,
+so each walk started one glyph into the next row and the wash missed that
+glyph. A continuation row now stretches back to the leading edge of the
+layout.

.changeset/survive-a-hot-remount.md

@@ -0,0 +1,13 @@
+---
+"@gpuix/react": patch
+---
+
+Keep events alive across a `bun --hot` remount.
+
+The map from renderer to container lived in the module, and the native
+event callback keeps the module instance that created it. A hot reload
+evaluates the module again, so the new tree registered its handlers in a
+new map while native events searched the old one, and every click died.
+The map now lives on `globalThis`, so both module instances share it. The
+`onEvent` option also follows the latest `render()` call instead of the
+first one.

.changeset/sync-env-overrides-under-bun.md

@@ -0,0 +1,14 @@
+---
+"@gpuix/native": patch
+"@gpuix/react": patch
+---
+
+Push `process.env` overrides through to the Rust side under Bun.
+
+Rust reads overrides such as `GPUIX_SCROLLBARS` at paint. Node writes a
+`process.env` assignment through to `setenv`, but Bun only updates its JS
+snapshot, so a test that set the variable after start had no effect under
+`bun test`. The native module now exports `syncEnvVar`, and the test
+renderer copies the known overrides across before every frame flush. The
+values land in an override map, not in the real environment, because
+`setenv` races `getenv` on the dedicated UI thread of Windows and Linux.

packages/native/Cargo.toml

@@ -102,6 +102,24 @@ lto = true
 # that with "mis-aligned LINKEDIT string pool", so the addon fails to load.
 strip = "none"
 
+# capture_screenshot encodes a png on every visual test. The encoder is
+# too slow at opt-level 0 and vitest kills the worker, so build the
+# image crates with opt-level 3 in debug builds too.
+[profile.dev.package.png]
+opt-level = 3
+
+[profile.dev.package.image]
+opt-level = 3
+
+[profile.dev.package.fdeflate]
+opt-level = 3
+
+[profile.dev.package.flate2]
+opt-level = 3
+
+[profile.dev.package.miniz_oxide]
+opt-level = 3
+
 # The style parse benchmark. `harness = false` because it prints its own
 # numbers rather than running as a test.
 [[bench]]

packages/native/index.d.ts

@@ -561,6 +561,16 @@ export interface HighlightRect {
   height: number
 }
 
+/**
+ * Records one `process.env` entry for `env_var` readers.
+ *
+ * Rust reads overrides such as `GPUIX_SCROLLBARS` at paint. Node writes a
+ * `process.env` assignment through to `setenv`, but Bun only updates its
+ * JS snapshot. A caller on Bun must push the value across with this
+ * function.
+ */
+export declare function syncEnvVar(key: string, value?: string | undefined | null): void
+
 export interface WindowInsets {
   safeArea: EdgeInsets
   ime: EdgeInsets

packages/native/index.js

@@ -578,3 +578,4 @@ if (!nativeBinding) {
 module.exports = nativeBinding
 module.exports.GpuixRenderer = nativeBinding.GpuixRenderer
 module.exports.TestGpuixRenderer = nativeBinding.TestGpuixRenderer
+module.exports.syncEnvVar = nativeBinding.syncEnvVar

packages/native/src/automation.rs

@@ -110,6 +110,8 @@ pub fn bounds_tracker(
         },
     )
     .absolute()
+    .top_0()
+    .left_0()
     .size_full()
 }
 

packages/native/src/motion.rs

@@ -434,9 +434,9 @@ impl MotionState {
                 (Some(from), Some(target)) if raw < 1.0 => Some((from, target)),
                 _ => None,
             };
-            if let Some((from, target)) = ends.filter(|(from, target)| {
-                from.needs_content() || target.needs_content()
-            }) {
+            if let Some((from, target)) =
+                ends.filter(|(from, target)| from.needs_content() || target.needs_content())
+            {
                 let visible = from.mix(target, progress).resolve(old);
                 let end = target.resolve(new);
                 // The pixels a start needs so that mixing it toward `end` at
@@ -624,7 +624,7 @@ mod tests {
             "animate": { "cornerShape": "square" },
             "transition": { "duration": 1.0, "ease": "linear" }
         });
-        let mut state = MotionState::new(&spec, started).unwrap();
+        let state = MotionState::new(&spec, started).unwrap();
         let frame = state.frame(started + Duration::from_millis(500));
         let mut style = StyleDesc::default();
         frame.style.apply_to(&mut style);
@@ -707,8 +707,14 @@ mod tests {
         let state = MotionState::new(&description, started).unwrap();
 
         assert_eq!(at(state.frame(started)), Some(0.0));
-        assert_eq!(at(state.frame(started + Duration::from_millis(500))), Some(100.0));
-        assert_eq!(at(state.frame(started + Duration::from_secs(1))), Some(200.0));
+        assert_eq!(
+            at(state.frame(started + Duration::from_millis(500))),
+            Some(100.0)
+        );
+        assert_eq!(
+            at(state.frame(started + Duration::from_secs(1))),
+            Some(200.0)
+        );
     }
 
     #[test]
@@ -730,7 +736,10 @@ mod tests {
         state.sync(&closing, settled).unwrap();
 
         assert_eq!(at(state.frame(settled)), Some(200.0));
-        assert_eq!(at(state.frame(settled + Duration::from_millis(500))), Some(100.0));
+        assert_eq!(
+            at(state.frame(settled + Duration::from_millis(500))),
+            Some(100.0)
+        );
         assert_eq!(at(state.frame(settled + Duration::from_secs(1))), Some(0.0));
     }
 
@@ -754,7 +763,10 @@ mod tests {
 
         // Half open when it turned, so the collapse starts at half.
         assert_eq!(at(state.frame(turned)), Some(100.0));
-        assert_eq!(at(state.frame(turned + Duration::from_millis(500))), Some(50.0));
+        assert_eq!(
+            at(state.frame(turned + Duration::from_millis(500))),
+            Some(50.0)
+        );
     }
 
     #[test]

packages/native/src/renderer.rs

@@ -702,6 +702,35 @@ fn panic_message(payload: Box<dyn std::any::Any + Send>) -> String {
         .unwrap_or_else(|| "unknown panic".to_string())
 }
 
+/// JS-side values for environment overrides such as `GPUIX_SCROLLBARS`.
+///
+/// A map instead of `std::env::set_var`, because `setenv` races `getenv`
+/// on another thread, and Windows and Linux paint on a dedicated UI thread.
+fn env_overrides() -> &'static std::sync::Mutex<HashMap<String, Option<String>>> {
+    static OVERRIDES: std::sync::OnceLock<std::sync::Mutex<HashMap<String, Option<String>>>> =
+        std::sync::OnceLock::new();
+    OVERRIDES.get_or_init(|| std::sync::Mutex::new(HashMap::new()))
+}
+
+/// Reads an override, or the real process environment when JS never set one.
+pub(crate) fn env_var(key: &str) -> Option<String> {
+    if let Some(value) = env_overrides().lock().unwrap().get(key) {
+        return value.clone();
+    }
+    std::env::var(key).ok()
+}
+
+/// Records one `process.env` entry for `env_var` readers.
+///
+/// Rust reads overrides such as `GPUIX_SCROLLBARS` at paint. Node writes a
+/// `process.env` assignment through to `setenv`, but Bun only updates its
+/// JS snapshot. A caller on Bun must push the value across with this
+/// function.
+#[napi]
+pub fn sync_env_var(key: String, value: Option<String>) {
+    env_overrides().lock().unwrap().insert(key, value);
+}
+
 /// The main GPUI renderer exposed to Node.js.
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 #[napi]
@@ -3253,7 +3282,6 @@ impl GpuixView {
     }
 }
 
-
 impl GpuixView {
     /// Sync focus handles with the current element tree.
     /// Creates handles for new focusable elements, subscribes on_focus/on_blur,
@@ -3465,7 +3493,6 @@ impl gpui::Render for GpuixView {
     }
 }
 
-
 // ── Event emission ───────────────────────────────────────────────────
 
 /// Helper to convert a GPUI Point<Pixels> to (f64, f64).
@@ -3504,7 +3531,6 @@ pub(crate) fn emit_event_full(
     }
 }
 
-
 // ── Types ────────────────────────────────────────────────────────────
 
 #[derive(Debug, Clone)]

packages/native/src/renderer/frame.rs

@@ -204,13 +204,8 @@ pub(super) fn build_element(
                 highlight_set: ctx.highlight.clone(),
                 cascade: cascade.clone(),
             };
-            ctx.custom_registry.render(
-                custom_type,
-                &element.custom_props,
-                render_ctx,
-                window,
-                cx,
-            )
+            ctx.custom_registry
+                .render(custom_type, &element.custom_props, render_ctx, window, cx)
         }
     };
 

packages/native/src/renderer/scrollbar.rs

@@ -41,9 +41,9 @@ pub(crate) enum Mode {
 impl Mode {
     /// The mode for this window, with the environment override on top.
     pub(crate) fn current(cx: &App) -> Self {
-        match std::env::var("GPUIX_SCROLLBARS").as_deref() {
-            Ok("overlay") => Mode::Overlay,
-            Ok("classic") => Mode::Classic,
+        match crate::renderer::env_var("GPUIX_SCROLLBARS").as_deref() {
+            Some("overlay") => Mode::Overlay,
+            Some("classic") => Mode::Classic,
             _ if cx.should_auto_hide_scrollbars() => Mode::Overlay,
             _ => Mode::Classic,
         }

packages/native/src/style.rs

@@ -675,7 +675,10 @@ mod tests {
         let written = serde_json::to_value(StyleDesc::default()).unwrap();
         let written = written.as_object().unwrap();
         for name in written.keys() {
-            assert!(FIELDS.contains(&name.as_str()), "`{name}` is written but never read");
+            assert!(
+                FIELDS.contains(&name.as_str()),
+                "`{name}` is written but never read"
+            );
         }
         assert_eq!(written.len(), FIELDS.len());
     }
@@ -698,7 +701,10 @@ mod tests {
         assert_eq!(style.gap, Some(Numeric::Text("var(--gap)".to_owned())));
         assert_eq!(style.width, Some(Numeric::Text("100%".to_owned())));
         assert_eq!(style.height, Some(Numeric::Text("auto".to_owned())));
-        assert_eq!(style.font_weight, Some(FontWeightValue::Str("bold".to_owned())));
+        assert_eq!(
+            style.font_weight,
+            Some(FontWeightValue::Str("bold".to_owned()))
+        );
         assert_eq!(style.line_clamp, None);
         assert_eq!(style.hover.unwrap().color.as_deref(), Some("red"));
     }
@@ -724,12 +730,16 @@ mod tests {
         let style: StyleDesc =
             serde_json::from_str(r#"{ "gap": 4, "gap": 8, "--pad": 1, "--pad": 2 }"#).unwrap();
         assert_eq!(style.gap, Some(Numeric::Number(8.0)));
-        assert_eq!(declared_variables(&style), vec![("--pad".to_owned(), "2".to_owned())]);
+        assert_eq!(
+            declared_variables(&style),
+            vec![("--pad".to_owned(), "2".to_owned())]
+        );
     }
 
     #[test]
     fn the_boxed_read_and_the_ordinary_read_agree() {
-        let json = r#"{ "gap": 8, "color": "red", "--pad": "4px", "hover": { "gap": 2 }, "nope": 1 }"#;
+        let json =
+            r#"{ "gap": 8, "color": "red", "--pad": "4px", "hover": { "gap": 2 }, "nope": 1 }"#;
         assert_eq!(
             *StyleDesc::from_json_boxed(json).unwrap(),
             serde_json::from_str::<StyleDesc>(json).unwrap()
@@ -748,7 +758,9 @@ mod tests {
             font_size: Some(Numeric::Number(14.0)),
             max_width: Some(Numeric::Number(320.0)),
             user_select: Some("none".to_owned()),
-            custom: [("--pad".to_owned(), serde_json::json!("8px"))].into_iter().collect(),
+            custom: [("--pad".to_owned(), serde_json::json!("8px"))]
+                .into_iter()
+                .collect(),
             hover: Some(Box::new(StyleDesc {
                 background_color: Some("#fff".to_owned()),
                 ..Default::default()

packages/native/src/style/vars.rs

@@ -46,12 +46,7 @@ pub(crate) struct Scope<'a> {
 }
 
 impl<'a> Scope<'a> {
-    pub fn new(
-        variables: &'a Variables,
-        current_color: Rgba,
-        dark: bool,
-        rem_size: f32,
-    ) -> Self {
+    pub fn new(variables: &'a Variables, current_color: Rgba, dark: bool, rem_size: f32) -> Self {
         Self {
             variables,
             current_color,
@@ -541,7 +536,10 @@ mod tests {
     fn a_bare_number_needs_no_resolving() {
         let variables = scope_of(&[]);
         let scope = Scope::new(&variables, Rgba::BLACK, false, 16.0);
-        assert_eq!(scope.number(&Some(crate::style::Numeric::Number(8.0))), Some(8.0));
+        assert_eq!(
+            scope.number(&Some(crate::style::Numeric::Number(8.0))),
+            Some(8.0)
+        );
         assert!(!scope.used_a_variable());
     }
 
@@ -612,10 +610,22 @@ mod tests {
         use crate::style::{DimensionValue, Numeric};
         let text = |t: &str| Some(Numeric::Text(t.to_string()));
 
-        assert_eq!(dimension(Some(Numeric::Number(200.0)), &[]), Some(DimensionValue::Pixels(200.0)));
-        assert_eq!(dimension(text("200px"), &[]), Some(DimensionValue::Pixels(200.0)));
-        assert_eq!(dimension(text("6rem"), &[]), Some(DimensionValue::Pixels(96.0)));
-        assert_eq!(dimension(text("calc(100px + 2rem)"), &[]), Some(DimensionValue::Pixels(132.0)));
+        assert_eq!(
+            dimension(Some(Numeric::Number(200.0)), &[]),
+            Some(DimensionValue::Pixels(200.0))
+        );
+        assert_eq!(
+            dimension(text("200px"), &[]),
+            Some(DimensionValue::Pixels(200.0))
+        );
+        assert_eq!(
+            dimension(text("6rem"), &[]),
+            Some(DimensionValue::Pixels(96.0))
+        );
+        assert_eq!(
+            dimension(text("calc(100px + 2rem)"), &[]),
+            Some(DimensionValue::Pixels(132.0))
+        );
         assert_eq!(
             dimension(text("calc(var(--spacing) * 30)"), &[("--spacing", "4px")]),
             Some(DimensionValue::Pixels(120.0))
@@ -627,10 +637,16 @@ mod tests {
         use crate::style::{DimensionValue, Numeric};
         let text = |t: &str| Some(Numeric::Text(t.to_string()));
 
-        assert_eq!(dimension(text("50%"), &[]), Some(DimensionValue::Percentage(0.5)));
+        assert_eq!(
+            dimension(text("50%"), &[]),
+            Some(DimensionValue::Percentage(0.5))
+        );
         assert_eq!(dimension(text("auto"), &[]), Some(DimensionValue::Auto));
         assert_eq!(dimension(text("AUTO"), &[]), Some(DimensionValue::Auto));
-        assert_eq!(dimension(text("var(--w)"), &[("--w", "auto")]), Some(DimensionValue::Auto));
+        assert_eq!(
+            dimension(text("var(--w)"), &[("--w", "auto")]),
+            Some(DimensionValue::Auto)
+        );
     }
 
     #[test]
@@ -649,6 +665,9 @@ mod tests {
     #[test]
     fn an_absent_declaration_stays_absent() {
         let variables = scope_of(&[]);
-        assert_eq!(Scope::new(&variables, Rgba::BLACK, false, 16.0).number(&None), None);
+        assert_eq!(
+            Scope::new(&variables, Rgba::BLACK, false, 16.0).number(&None),
+            None
+        );
     }
 }