refactor(editor): address indentation-guide review findings

Follow-up cleanup on the indentation-guides feature from code review:

- Reuse indent-based folding (find_fold_range_at_byte) for active-mode
  block detection instead of hand-coded {([:/} delimiter heuristics, so a
  guide spans exactly the rows the matching fold would hide. Probe with the
  cursor's line-start byte so a cursor past a block's last-line indent still
  resolves its enclosing block.
- Compute all-mode guide columns with a monotonic indentation-staircase
  scanner walked once over the viewport: O(n) instead of O(n^2), and two
  depth-bounded reused buffers instead of a per-frame Vec<Vec<usize>>. The
  scan is skipped entirely unless mode is `all`.
- Draw guides continuously through whitespace-only lines (matching active
  mode) rather than leaving a one-row gap.
- Reuse indent_folding::slice_indent for indent measurement, deleting the
  two bespoke indent helpers.
- Drop the two hardcoded settings-ordering functions; settings sort
  alphabetically like the rest.
- Drop the unrelated humanizeSchemaName refactor from theme_editor.ts.
- Rename the config key indentation_guides -> indentation_guide and
  regenerate config-schema.json.

Give CellPassInput/CellPass a second lifetime so the per-row guide-column
slice can borrow the reused buffer independently of the render-wide
lifetime. Active-mode tests rewritten for the new pure-indent model; adds
unit + e2e coverage for guides through blank lines.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: sinelaw

crates/fresh-editor/plugins/config-schema.json

@@ -79,7 +79,7 @@
         "terminal_auto_title": true,
         "cursor_style": "default",
         "rulers": [],
-        "indentation_guides": "none",
+        "indentation_guide": "none",
         "indentation_guide_glyph": "▏",
         "whitespace_show": true,
         "whitespace_spaces_leading": false,
@@ -581,7 +581,7 @@
           "default": [],
           "x-section": "Display"
         },
-        "indentation_guides": {
+        "indentation_guide": {
           "description": "Vertical indentation guide rendering mode.\nGuides are drawn at indentation levels derived from the active buffer's\ntab size. They replace existing leading whitespace cells visually only;\nbuffer text, cursor positions, and mouse mappings are unchanged.\nModes:\n- `none`: disable indentation guides.\n- `all`: draw every indentation level in leading whitespace.\n- `active`: draw only the innermost guide for the cursor's current\n  indentation block.\nDefault: none",
           "$ref": "#/$defs/IndentationGuideMode",
           "default": "none",

crates/fresh-editor/plugins/theme_editor.ts

@@ -249,25 +249,6 @@ function fieldRefersToColorDef(fieldObj: Record<string, unknown>): boolean {
   return false;
 }
 
-function humanizeSchemaName(name: string): string {
-  return name
-    .split("_")
-    .filter(part => part.length > 0)
-    .map(part => {
-      if (part === "fg") return "Foreground";
-      if (part === "bg") return "Background";
-      if (part === "ui") return "UI";
-      if (part === "lsp") return "LSP";
-      return part.charAt(0).toUpperCase() + part.slice(1);
-    })
-    .join(" ");
-}
-
-function translateOrFallback(key: string, fallback: string): string {
-  const translated = editor.t(key);
-  return translated && translated !== key ? translated : fallback;
-}
-
 /**
  * Load theme sections from the Rust API.
  * Parses the raw JSON Schema and resolves $ref references.
@@ -338,8 +319,8 @@ function loadThemeSections(): ThemeSection[] {
 
       fields.push({
         key: fieldName,
-        displayName: translateOrFallback(i18nName, humanizeSchemaName(fieldName)),
-        description: translateOrFallback(i18nDesc, fieldDesc),
+        displayName: editor.t(i18nName) || fieldDesc || fieldName,
+        description: editor.t(i18nDesc) || fieldDesc,
         section: sectionName,
       });
     }
@@ -353,8 +334,8 @@ function loadThemeSections(): ThemeSection[] {
 
     sections.push({
       name: sectionName,
-      displayName: translateOrFallback(sectionI18nName, humanizeSchemaName(sectionName)),
-      description: translateOrFallback(sectionI18nDesc, sectionDesc),
+      displayName: editor.t(sectionI18nName) || sectionDesc || sectionName,
+      description: editor.t(sectionI18nDesc) || sectionDesc,
       fields,
     });
   }

crates/fresh-editor/src/app/render.rs

@@ -719,7 +719,7 @@ impl Editor {
                     self.config.editor.diagnostics_inline_text,
                     self.config.editor.show_tilde,
                     self.config.editor.highlight_current_column,
-                    self.config.editor.indentation_guides,
+                    self.config.editor.indentation_guide,
                     &self.config.editor.indentation_guide_glyph,
                     self.config.editor.hide_current_line_on_selection,
                     __cell_theme_map_mut,
@@ -2356,7 +2356,7 @@ impl Editor {
                     self.config.editor.diagnostics_inline_text,
                     false, // hide tilde markers in the preview
                     self.config.editor.highlight_current_column,
-                    self.config.editor.indentation_guides,
+                    self.config.editor.indentation_guide,
                     &self.config.editor.indentation_guide_glyph,
                     self.config.editor.hide_current_line_on_selection,
                     &mut scratch_cell_theme_map,
@@ -3382,7 +3382,7 @@ impl Editor {
                 let diagnostics_inline_text = self.config.editor.diagnostics_inline_text;
                 let show_tilde = false; // preview hides tilde markers
                 let highlight_current_column = self.config.editor.highlight_current_column;
-                let indentation_guides = self.config.editor.indentation_guides;
+                let indentation_guide = self.config.editor.indentation_guide;
                 let indentation_guide_glyph = self.config.editor.indentation_guide_glyph.clone();
                 let screen_width = frame.area().width;
 
@@ -3454,7 +3454,7 @@ impl Editor {
                         diagnostics_inline_text,
                         show_tilde,
                         highlight_current_column,
-                        indentation_guides,
+                        indentation_guide,
                         &indentation_guide_glyph,
                         cell_theme_map,
                         screen_width,

crates/fresh-editor/src/config.rs

@@ -1208,7 +1208,7 @@ pub struct EditorConfig {
     /// Default: none
     #[serde(default)]
     #[schemars(extend("x-section" = "Display"))]
-    pub indentation_guides: IndentationGuideMode,
+    pub indentation_guide: IndentationGuideMode,
 
     /// Glyph used to draw indentation guides. The default is a left-aligned
     /// vertical guide character. Leading/trailing whitespace is ignored, and
@@ -1799,7 +1799,7 @@ impl Default for EditorConfig {
             set_window_title: true,
             terminal_auto_title: true,
             rulers: Vec::new(),
-            indentation_guides: IndentationGuideMode::None,
+            indentation_guide: IndentationGuideMode::None,
             indentation_guide_glyph: default_indentation_guide_glyph(),
             whitespace_show: true,
             whitespace_spaces_leading: false,
@@ -7727,10 +7727,10 @@ mod tests {
     #[test]
     fn test_indentation_guide_mode_rejects_booleans() {
         assert!(
-            serde_json::from_str::<Config>(r#"{"editor":{"indentation_guides":false}}"#).is_err()
+            serde_json::from_str::<Config>(r#"{"editor":{"indentation_guide":false}}"#).is_err()
         );
         assert!(
-            serde_json::from_str::<Config>(r#"{"editor":{"indentation_guides":true}}"#).is_err()
+            serde_json::from_str::<Config>(r#"{"editor":{"indentation_guide":true}}"#).is_err()
         );
     }
 
@@ -7741,9 +7741,9 @@ mod tests {
             ("all", IndentationGuideMode::All),
             ("active", IndentationGuideMode::Active),
         ] {
-            let json = format!(r#"{{"editor":{{"indentation_guides":"{}"}}}}"#, value);
+            let json = format!(r#"{{"editor":{{"indentation_guide":"{}"}}}}"#, value);
             let cfg: Config = serde_json::from_str(&json).unwrap();
-            assert_eq!(cfg.editor.indentation_guides, expected);
+            assert_eq!(cfg.editor.indentation_guide, expected);
         }
     }
 
@@ -7752,10 +7752,10 @@ mod tests {
         assert_eq!(Config::default().editor.indentation_guide_glyph, "▏");
 
         let cfg: Config = serde_json::from_str(
-            r#"{"editor":{"indentation_guides":"all","indentation_guide_glyph":"┊"}}"#,
+            r#"{"editor":{"indentation_guide":"all","indentation_guide_glyph":"┊"}}"#,
         )
         .unwrap();
-        assert_eq!(cfg.editor.indentation_guides, IndentationGuideMode::All);
+        assert_eq!(cfg.editor.indentation_guide, IndentationGuideMode::All);
         assert_eq!(cfg.editor.indentation_guide_glyph, "┊");
     }
 

crates/fresh-editor/src/partial_config.rs

@@ -218,7 +218,7 @@ pub struct PartialEditorConfig {
     pub set_window_title: Option<bool>,
     pub terminal_auto_title: Option<bool>,
     pub rulers: Option<Vec<usize>>,
-    pub indentation_guides: Option<IndentationGuideMode>,
+    pub indentation_guide: Option<IndentationGuideMode>,
     pub indentation_guide_glyph: Option<String>,
     pub whitespace_show: Option<bool>,
     pub whitespace_spaces_leading: Option<bool>,
@@ -338,8 +338,7 @@ impl Merge for PartialEditorConfig {
         self.terminal_auto_title
             .merge_from(&other.terminal_auto_title);
         self.rulers.merge_from(&other.rulers);
-        self.indentation_guides
-            .merge_from(&other.indentation_guides);
+        self.indentation_guide.merge_from(&other.indentation_guide);
         self.indentation_guide_glyph
             .merge_from(&other.indentation_guide_glyph);
         self.whitespace_show.merge_from(&other.whitespace_show);
@@ -656,7 +655,7 @@ impl From<&crate::config::EditorConfig> for PartialEditorConfig {
             set_window_title: Some(cfg.set_window_title),
             terminal_auto_title: Some(cfg.terminal_auto_title),
             rulers: Some(cfg.rulers.clone()),
-            indentation_guides: Some(cfg.indentation_guides),
+            indentation_guide: Some(cfg.indentation_guide),
             indentation_guide_glyph: Some(cfg.indentation_guide_glyph.clone()),
             whitespace_show: Some(cfg.whitespace_show),
             whitespace_spaces_leading: Some(cfg.whitespace_spaces_leading),
@@ -829,9 +828,7 @@ impl PartialEditorConfig {
                 .terminal_auto_title
                 .unwrap_or(defaults.terminal_auto_title),
             rulers: self.rulers.unwrap_or_else(|| defaults.rulers.clone()),
-            indentation_guides: self
-                .indentation_guides
-                .unwrap_or(defaults.indentation_guides),
+            indentation_guide: self.indentation_guide.unwrap_or(defaults.indentation_guide),
             indentation_guide_glyph: self
                 .indentation_guide_glyph
                 .map(|glyph| crate::config::normalize_indentation_guide_glyph(&glyph))

crates/fresh-editor/src/view/folding.rs

@@ -436,7 +436,9 @@ pub mod indent_folding {
     }
 
     /// Measure leading indent of a line given as a byte slice (no trailing `\n`).
-    fn slice_indent(line: &[u8], tab_size: usize) -> (usize, bool) {
+    /// Returns `(indent_width, all_blank)` where `all_blank` is true when the
+    /// line has no non-whitespace character. Tabs expand against `tab_size`.
+    pub fn slice_indent(line: &[u8], tab_size: usize) -> (usize, bool) {
         let mut indent = 0;
         let mut all_blank = true;
         for &b in line {

crates/fresh-editor/src/view/settings/items.rs

@@ -896,13 +896,11 @@ fn build_page(category: &SettingCategory, ctx: &BuildContext) -> SettingsPage {
         .collect();
 
     // Sort items: by section first (None comes last), then alphabetically by name
-    items.sort_by(|a, b| {
-        indentation_guide_items_order(a, b).unwrap_or_else(|| match (&a.section, &b.section) {
-            (Some(sec_a), Some(sec_b)) => sec_a.cmp(sec_b).then_with(|| a.name.cmp(&b.name)),
-            (Some(_), None) => std::cmp::Ordering::Less,
-            (None, Some(_)) => std::cmp::Ordering::Greater,
-            (None, None) => a.name.cmp(&b.name),
-        })
+    items.sort_by(|a, b| match (&a.section, &b.section) {
+        (Some(sec_a), Some(sec_b)) => sec_a.cmp(sec_b).then_with(|| a.name.cmp(&b.name)),
+        (Some(_), None) => std::cmp::Ordering::Less,
+        (None, Some(_)) => std::cmp::Ordering::Greater,
+        (None, None) => a.name.cmp(&b.name),
     });
 
     // Mark items that start a new section, and capture the section list
@@ -945,17 +943,6 @@ fn build_page(category: &SettingCategory, ctx: &BuildContext) -> SettingsPage {
     }
 }
 
-fn indentation_guide_items_order(a: &SettingItem, b: &SettingItem) -> Option<std::cmp::Ordering> {
-    const MODE_PATH: &str = "/editor/indentation_guides";
-    const GLYPH_PATH: &str = "/editor/indentation_guide_glyph";
-
-    match (a.path.as_str(), b.path.as_str()) {
-        (MODE_PATH, GLYPH_PATH) => Some(std::cmp::Ordering::Less),
-        (GLYPH_PATH, MODE_PATH) => Some(std::cmp::Ordering::Greater),
-        _ => None,
-    }
-}
-
 /// Expand an Object schema into its children when every child has a native
 /// (non-JSON) control, otherwise build it as a single item. This lets compound
 /// config structs like `StatusBarConfig` surface their children as individual
@@ -1720,44 +1707,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_indentation_guide_glyph_follows_mode_in_built_page() {
-        let categories = crate::view::settings::schema::parse_schema(include_str!(
-            "../../../plugins/config-schema.json"
-        ))
-        .unwrap();
-        let config = serde_json::json!({
-            "editor": {
-                "indentation_guides": "none",
-                "indentation_guide_glyph": "▏"
-            }
-        });
-        let pages = build_pages(
-            &categories,
-            &config,
-            &HashMap::new(),
-            ConfigLayer::User,
-            &HashMap::new(),
-        );
-        let editor = pages
-            .iter()
-            .find(|page| page.path == "/editor")
-            .expect("editor page should exist");
-
-        let guide_mode_idx = editor
-            .items
-            .iter()
-            .position(|item| item.path == "/editor/indentation_guides")
-            .expect("indentation_guides item should exist");
-        let guide_glyph_idx = editor
-            .items
-            .iter()
-            .position(|item| item.path == "/editor/indentation_guide_glyph")
-            .expect("indentation_guide_glyph item should exist");
-
-        assert_eq!(guide_glyph_idx, guide_mode_idx + 1);
-    }
-
     #[test]
     fn test_build_text_item() {
         let schema = SettingSchema {

crates/fresh-editor/src/view/settings/schema.rs

@@ -498,32 +498,16 @@ fn parse_properties(
 
     // Sort settings: by x-order (if set) first, then alphabetically by name.
     // Settings with x-order come before those without.
-    settings.sort_by(|a, b| {
-        indentation_guide_settings_order(a, b).unwrap_or_else(|| match (a.order, b.order) {
-            (Some(a_ord), Some(b_ord)) => a_ord.cmp(&b_ord).then_with(|| a.name.cmp(&b.name)),
-            (Some(_), None) => std::cmp::Ordering::Less,
-            (None, Some(_)) => std::cmp::Ordering::Greater,
-            (None, None) => a.name.cmp(&b.name),
-        })
+    settings.sort_by(|a, b| match (a.order, b.order) {
+        (Some(a_ord), Some(b_ord)) => a_ord.cmp(&b_ord).then_with(|| a.name.cmp(&b.name)),
+        (Some(_), None) => std::cmp::Ordering::Less,
+        (None, Some(_)) => std::cmp::Ordering::Greater,
+        (None, None) => a.name.cmp(&b.name),
     });
 
     settings
 }
 
-fn indentation_guide_settings_order(
-    a: &SettingSchema,
-    b: &SettingSchema,
-) -> Option<std::cmp::Ordering> {
-    const MODE_PATH: &str = "/editor/indentation_guides";
-    const GLYPH_PATH: &str = "/editor/indentation_guide_glyph";
-
-    match (a.path.as_str(), b.path.as_str()) {
-        (MODE_PATH, GLYPH_PATH) => Some(std::cmp::Ordering::Less),
-        (GLYPH_PATH, MODE_PATH) => Some(std::cmp::Ordering::Greater),
-        _ => None,
-    }
-}
-
 /// Parse a single setting from its schema
 fn parse_setting(
     name: &str,
@@ -979,53 +963,31 @@ mod tests {
     }
 
     #[test]
-    fn test_indentation_guides_generated_schema_renders_as_enum() {
+    fn test_indentation_guide_generated_schema_renders_as_enum() {
         let categories = parse_schema(include_str!("../../../plugins/config-schema.json")).unwrap();
         let editor = categories
             .iter()
             .find(|c| c.path == "/editor")
             .expect("editor category should exist");
-        let indentation_guides = editor
+        let indentation_guide = editor
             .settings
             .iter()
-            .find(|s| s.path == "/editor/indentation_guides")
-            .expect("indentation_guides setting should exist");
+            .find(|s| s.path == "/editor/indentation_guide")
+            .expect("indentation_guide setting should exist");
 
-        match &indentation_guides.setting_type {
+        match &indentation_guide.setting_type {
             SettingType::Enum { options } => {
                 let values: Vec<&str> =
                     options.iter().map(|option| option.value.as_str()).collect();
                 assert_eq!(values, vec!["none", "all", "active"]);
             }
             other => panic!(
-                "expected indentation_guides to render as enum, got {:?}",
+                "expected indentation_guide to render as enum, got {:?}",
                 other
             ),
         }
     }
 
-    #[test]
-    fn test_indentation_guide_glyph_follows_mode_setting() {
-        let categories = parse_schema(include_str!("../../../plugins/config-schema.json")).unwrap();
-        let editor = categories
-            .iter()
-            .find(|c| c.path == "/editor")
-            .expect("editor category should exist");
-
-        let guide_mode_idx = editor
-            .settings
-            .iter()
-            .position(|s| s.path == "/editor/indentation_guides")
-            .expect("indentation_guides setting should exist");
-        let guide_glyph_idx = editor
-            .settings
-            .iter()
-            .position(|s| s.path == "/editor/indentation_guide_glyph")
-            .expect("indentation_guide_glyph setting should exist");
-
-        assert_eq!(guide_glyph_idx, guide_mode_idx + 1);
-    }
-
     #[test]
     fn test_humanize_name() {
         assert_eq!(humanize_name("tab_size"), "Tab Size");