diff --git a/README.md b/README.md
index bb30410..4c5a8f3 100644
--- a/README.md
+++ b/README.md
@@ -6,12 +6,6 @@ A TUI IDE.
 
 # TODO
 
-- [ ] FIX: bug where `move_line_up/down` dont honor folding.
-    - idk .. wyyy but it is soo hard. somehow handle \n seperately without interfering with folding.
-
-- [ ] Do this thing where folds are properly shifted on newline addition / deletion.
-- [ ] Add support for brackets/quotes to auto-close. (also for backspace)
-    - it also doesnt actually add a closer if it exists and is matched.
 - [ ] Add feature where doing enter uses tree-sitter to add newline with indentation.
     - it should also put stuff like `}` on the next line.
 - [ ] Add the highlight of block edges when cursor is on a bracket (or in).
@@ -29,3 +23,4 @@ A TUI IDE.
 - [ ] Add git stuff.
 - [ ] Fix bug where alt+up at eof adds extra line.
 - [ ] Think about how i would keep fold states sensical if i added code prettying.
+- [ ] Redo folding system and its relation to move_line_* functions.
diff --git a/include/editor.h b/include/editor.h
index b70cc6b..85cc349 100644
--- a/include/editor.h
+++ b/include/editor.h
@@ -137,13 +137,12 @@ inline const Fold *fold_for_line(const std::vector<Fold> &folds,
 }
 
 inline Fold *fold_for_line(std::vector<Fold> &folds, uint32_t line) {
-  const auto *fold = fold_for_line(static_cast<const std::vector<Fold> &>(folds),
-                                   line);
+  const auto *fold =
+      fold_for_line(static_cast<const std::vector<Fold> &>(folds), line);
   return const_cast<Fold *>(fold);
 }
 
-inline bool line_is_fold_start(const std::vector<Fold> &folds,
-                               uint32_t line) {
+inline bool line_is_fold_start(const std::vector<Fold> &folds, uint32_t line) {
   const Fold *fold = fold_for_line(folds, line);
   return fold && fold->start == line;
 }
@@ -203,5 +202,11 @@ void word_boundaries(Editor *editor, Coord coord, uint32_t *prev_col,
                      uint32_t *next_clusters);
 void word_boundaries_exclusive(Editor *editor, Coord coord, uint32_t *prev_col,
                                uint32_t *next_col);
+std::vector<Fold>::iterator find_fold_iter(Editor *editor, uint32_t line);
+bool add_fold(Editor *editor, uint32_t start, uint32_t end);
+bool remove_fold(Editor *editor, uint32_t line);
+void apply_line_insertion(Editor *editor, uint32_t line, uint32_t rows);
+void apply_line_deletion(Editor *editor, uint32_t removal_start,
+                         uint32_t removal_end);
 
 #endif
diff --git a/include/knot.h b/include/knot.h
index d9303e6..13f7103 100644
--- a/include/knot.h
+++ b/include/knot.h
@@ -117,6 +117,12 @@ LineIterator *begin_l_iter(Knot *root, uint32_t start_line);
 // freed by the caller
 char *next_line(LineIterator *it, uint32_t *out_len);
 
+// Returns the previous line as a null terminated string
+// `it` is the iterator returned from begin_l_iter
+// it can be used to iterate backwards
+// and can be used along with next_line
+// doing prev_line then next_line or vice versa will return the same line
+// `out_len` is set to the length of the returned string
 char *prev_line(LineIterator *it, uint32_t *out_len);
 
 // Used to start an iterator over leaf data
diff --git a/src/editor.cc b/src/editor.cc
index 03683d9..3fbae81 100644
--- a/src/editor.cc
+++ b/src/editor.cc
@@ -117,43 +117,43 @@ void render_editor(Editor *editor) {
   span_cursor.sync(global_byte_offset);
   def_span_cursor.sync(global_byte_offset);
   while (rendered_rows < editor->size.row) {
-      const Fold *fold = fold_for_line(editor->folds, line_index);
-      if (fold) {
-        update(editor->position.row + rendered_rows, editor->position.col, "",
-               0xAAAAAA, 0, 0);
-        char buf[16];
-        int len = snprintf(buf, sizeof(buf), "%*u", numlen - 3,
-                           fold->start + 1);
-        uint32_t num_color =
-            editor->cursor.row == fold->start ? 0xFFFFFF : 0x555555;
-        for (int i = 0; i < len; i++)
-          update(editor->position.row + rendered_rows,
-                 editor->position.col + i + 2, (char[2]){buf[i], 0}, num_color,
-                 0, 0);
-        const char marker[15] = "... folded ...";
-        uint32_t i = 0;
-        for (; i < 14 && i < render_width; i++)
-          update(rendered_rows, i + render_x, (char[2]){marker[i], 0}, 0xc6c6c6,
-                 0, 0);
-        for (; i < render_width; i++)
-          update(rendered_rows, i + render_x, " ", 0xc6c6c6, 0, 0);
-        rendered_rows++;
+    const Fold *fold = fold_for_line(editor->folds, line_index);
+    if (fold) {
+      update(editor->position.row + rendered_rows, editor->position.col, "",
+             0xAAAAAA, 0, 0);
+      char buf[16];
+      int len = snprintf(buf, sizeof(buf), "%*u", numlen - 3, fold->start + 1);
+      uint32_t num_color =
+          editor->cursor.row == fold->start ? 0xFFFFFF : 0x555555;
+      for (int i = 0; i < len; i++)
+        update(editor->position.row + rendered_rows,
+               editor->position.col + i + 2, (char[2]){buf[i], 0}, num_color, 0,
+               0);
+      const char marker[15] = "... folded ...";
+      uint32_t i = 0;
+      for (; i < 14 && i < render_width; i++)
+        update(rendered_rows, i + render_x, (char[2]){marker[i], 0}, 0xc6c6c6,
+               0, 0);
+      for (; i < render_width; i++)
+        update(rendered_rows, i + render_x, " ", 0xc6c6c6, 0, 0);
+      rendered_rows++;
 
-        uint32_t skip_until = fold->end;
-        while (line_index <= skip_until) {
-          uint32_t line_len;
-          char *line = next_line(it, &line_len);
-          if (!line)
-            break;
-          global_byte_offset += line_len;
-          if (line_len > 0 && line[line_len - 1] == '\n')
-            global_byte_offset--;
-          global_byte_offset++;
-          free(line);
-          line_index++;
-        }
-        continue;
+      uint32_t skip_until = fold->end;
+      while (line_index <= skip_until) {
+        uint32_t line_len;
+        char *line = next_line(it, &line_len);
+        if (!line)
+          break;
+        global_byte_offset += line_len;
+        if (line_len > 0 && line[line_len - 1] == '\n')
+          global_byte_offset--;
+        global_byte_offset++;
+        free(line);
+        line_index++;
       }
+      continue;
+    }
+    uint32_t line_len;
     char *line = next_line(it, &line_len);
     if (!line)
       break;
diff --git a/src/editor_ctrl.cc b/src/editor_ctrl.cc
index 5a734e9..db9391b 100644
--- a/src/editor_ctrl.cc
+++ b/src/editor_ctrl.cc
@@ -3,589 +3,9 @@ extern "C" {
 }
 #include "../include/editor.h"
 #include "../include/main.h"
-#include "../include/ts.h"
 #include "../include/utils.h"
 #include <cmath>
 
-static Highlight HL_UNDERLINE = {0, 0, 1 << 2, 100};
-
-static std::vector<Fold>::iterator find_fold_iter(Editor *editor,
-                                                  uint32_t line) {
-  auto &folds = editor->folds;
-  auto it = std::lower_bound(
-      folds.begin(), folds.end(), line,
-      [](const Fold &fold, uint32_t value) { return fold.start < value; });
-  if (it != folds.end() && it->start == line)
-    return it;
-  if (it != folds.begin()) {
-    --it;
-    if (it->contains(line))
-      return it;
-  }
-  return folds.end();
-}
-
-static bool add_fold(Editor *editor, uint32_t start, uint32_t end) {
-  if (!editor || !editor->root)
-    return false;
-  if (start > end)
-    std::swap(start, end);
-  if (start >= editor->root->line_count)
-    return false;
-  end = std::min(end, editor->root->line_count - 1);
-  if (start == end)
-    return false;
-
-  Fold new_fold{start, end};
-  auto &folds = editor->folds;
-  auto it = std::lower_bound(
-      folds.begin(), folds.end(), new_fold.start,
-      [](const Fold &fold, uint32_t value) { return fold.start < value; });
-
-  if (it != folds.begin()) {
-    auto prev = std::prev(it);
-    if (prev->end + 1 >= new_fold.start) {
-      new_fold.start = std::min(new_fold.start, prev->start);
-      new_fold.end = std::max(new_fold.end, prev->end);
-      it = folds.erase(prev);
-    }
-  }
-  while (it != folds.end() && it->start <= new_fold.end + 1) {
-    new_fold.end = std::max(new_fold.end, it->end);
-    it = folds.erase(it);
-  }
-  folds.insert(it, new_fold);
-  return true;
-}
-
-static bool remove_fold(Editor *editor, uint32_t line) {
-  auto it = find_fold_iter(editor, line);
-  if (it == editor->folds.end())
-    return false;
-  editor->folds.erase(it);
-  return true;
-}
-
-static void apply_line_insertion(Editor *editor, uint32_t line,
-                                 uint32_t rows) {
-  if (rows == 0)
-    return;
-  for (auto &fold : editor->folds) {
-    if (line <= fold.start) {
-      fold.start += rows;
-      fold.end += rows;
-    } else if (line <= fold.end) {
-      fold.end += rows;
-    }
-  }
-}
-
-static void apply_line_deletion(Editor *editor, uint32_t removal_start,
-                                uint32_t removal_end) {
-  if (removal_start > removal_end)
-    return;
-  uint32_t rows_removed = removal_end - removal_start + 1;
-  std::vector<Fold> updated;
-  updated.reserve(editor->folds.size());
-  for (auto fold : editor->folds) {
-    if (fold.end < removal_start) {
-      updated.push_back(fold);
-      continue;
-    }
-    if (fold.start > removal_end) {
-      fold.start -= rows_removed;
-      fold.end -= rows_removed;
-      updated.push_back(fold);
-      continue;
-    }
-    if (fold.start >= removal_start)
-      continue;
-    if (fold.end > removal_end)
-      fold.end -= rows_removed;
-    else
-      fold.end = removal_start - 1;
-    if (fold.end >= fold.start)
-      updated.push_back(fold);
-  }
-  editor->folds.swap(updated);
-}
-
-void handle_editor_event(Editor *editor, KeyEvent event) {
-  static std::chrono::steady_clock::time_point last_click_time =
-      std::chrono::steady_clock::now();
-  static uint32_t click_count = 0;
-  static Coord last_click_pos = {UINT32_MAX, UINT32_MAX};
-  if (event.key_type == KEY_MOUSE) {
-    auto now = std::chrono::steady_clock::now();
-    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
-                        now - last_click_time)
-                        .count();
-    switch (event.mouse_state) {
-    case SCROLL:
-      switch (event.mouse_direction) {
-      case SCROLL_UP:
-        scroll_up(editor, 10);
-        ensure_cursor(editor);
-        break;
-      case SCROLL_DOWN:
-        scroll_down(editor, 10);
-        ensure_cursor(editor);
-        break;
-      case SCROLL_LEFT:
-        cursor_left(editor, 10);
-        break;
-      case SCROLL_RIGHT:
-        cursor_right(editor, 10);
-        break;
-      }
-      break;
-    case PRESS:
-      if (event.mouse_button == LEFT_BTN) {
-        Coord cur_pos = {event.mouse_x, event.mouse_y};
-        if (duration < 250 && last_click_pos == cur_pos)
-          click_count++;
-        else
-          click_count = 1;
-        last_click_time = now;
-        last_click_pos = cur_pos;
-        Coord p = editor_hit_test(editor, event.mouse_x, event.mouse_y);
-        if (p.row == UINT32_MAX && p.col == UINT32_MAX)
-          return;
-        editor->cursor_preffered = UINT32_MAX;
-        if (click_count == 1) {
-          editor->cursor = p;
-          editor->selection = p;
-          if (mode == SELECT) {
-            mode = NORMAL;
-            editor->selection_active = false;
-          }
-        } else if (click_count == 2) {
-          uint32_t prev_col, next_col;
-          word_boundaries(editor, editor->cursor, &prev_col, &next_col, nullptr,
-                          nullptr);
-          if (editor->cursor < editor->selection)
-            editor->cursor = {editor->cursor.row, prev_col};
-          else
-            editor->cursor = {editor->cursor.row, next_col};
-          editor->cursor_preffered = UINT32_MAX;
-          editor->selection_type = WORD;
-          mode = SELECT;
-          editor->selection_active = true;
-        } else if (click_count >= 3) {
-          if (editor->cursor < editor->selection) {
-            editor->cursor = {p.row, 0};
-          } else {
-            uint32_t line_len;
-            LineIterator *it = begin_l_iter(editor->root, p.row);
-            char *line = next_line(it, &line_len);
-            free(it);
-            if (!line)
-              return;
-            if (line_len > 0 && line[line_len - 1] == '\n')
-              line_len--;
-            free(line);
-            editor->cursor = {p.row, line_len};
-          }
-          editor->cursor_preffered = UINT32_MAX;
-          editor->selection_type = LINE;
-          mode = SELECT;
-          editor->selection_active = true;
-          click_count = 3;
-        }
-      }
-      break;
-    case DRAG:
-      if (event.mouse_button == LEFT_BTN) {
-        Coord p = editor_hit_test(editor, event.mouse_x, event.mouse_y);
-        if (p.row == UINT32_MAX && p.col == UINT32_MAX)
-          return;
-        editor->cursor_preffered = UINT32_MAX;
-        mode = SELECT;
-        if (!editor->selection_active) {
-          editor->selection_active = true;
-          editor->selection_type = CHAR;
-        }
-        uint32_t prev_col, next_col, line_len;
-        switch (editor->selection_type) {
-        case CHAR:
-          editor->cursor = p;
-          break;
-        case WORD:
-          word_boundaries(editor, p, &prev_col, &next_col, nullptr, nullptr);
-          if (editor->cursor < editor->selection)
-            editor->cursor = {p.row, prev_col};
-          else
-            editor->cursor = {p.row, next_col};
-          break;
-        case LINE:
-          if (editor->cursor < editor->selection) {
-            editor->cursor = {p.row, 0};
-          } else {
-            LineIterator *it = begin_l_iter(editor->root, p.row);
-            char *line = next_line(it, &line_len);
-            free(it);
-            if (!line)
-              return;
-            if (line_len > 0 && line[line_len - 1] == '\n')
-              line_len--;
-            free(line);
-            editor->cursor = {p.row, line_len};
-          }
-          break;
-        }
-      }
-      break;
-    case RELEASE:
-      if (event.mouse_button == LEFT_BTN)
-        if (editor->cursor.row == editor->selection.row &&
-            editor->cursor.col == editor->selection.col) {
-          mode = NORMAL;
-          editor->selection_active = false;
-        }
-      break;
-    }
-  }
-  if (event.key_type == KEY_SPECIAL) {
-    switch (event.special_modifier) {
-    case 0:
-      switch (event.special_key) {
-      case KEY_DOWN:
-        cursor_down(editor, 1);
-        break;
-      case KEY_UP:
-        cursor_up(editor, 1);
-        break;
-      case KEY_LEFT:
-        cursor_left(editor, 1);
-        break;
-      case KEY_RIGHT:
-        cursor_right(editor, 1);
-        break;
-      }
-      break;
-    case CNTRL:
-      uint32_t prev_col, next_col;
-      word_boundaries(editor, editor->cursor, &prev_col, &next_col, nullptr,
-                      nullptr);
-      switch (event.special_key) {
-      case KEY_DOWN:
-        cursor_down(editor, 5);
-        break;
-      case KEY_UP:
-        cursor_up(editor, 5);
-        break;
-      case KEY_LEFT:
-        editor->cursor_preffered = UINT32_MAX;
-        if (prev_col == editor->cursor.col)
-          cursor_left(editor, 1);
-        else
-          editor->cursor = {editor->cursor.row, prev_col};
-        break;
-      case KEY_RIGHT:
-        editor->cursor_preffered = UINT32_MAX;
-        if (next_col == editor->cursor.col)
-          cursor_right(editor, 1);
-        else
-          editor->cursor = {editor->cursor.row, next_col};
-        break;
-      }
-      break;
-    case ALT:
-      switch (event.special_key) {
-      case KEY_DOWN:
-        move_line_down(editor);
-        break;
-      case KEY_UP:
-        move_line_up(editor);
-        break;
-      case KEY_LEFT:
-        cursor_left(editor, 8);
-        break;
-      case KEY_RIGHT:
-        cursor_right(editor, 8);
-        break;
-      }
-      break;
-    }
-  }
-  switch (mode) {
-  case NORMAL:
-    if (event.key_type == KEY_CHAR && event.len == 1) {
-      switch (event.c[0]) {
-      case 'u':
-        if (editor->root->line_count > 0) {
-          editor->cursor.row = editor->root->line_count - 1;
-          LineIterator *it = begin_l_iter(editor->root, editor->cursor.row);
-          if (!it)
-            break;
-          uint32_t line_len;
-          char *line = next_line(it, &line_len);
-          if (!line)
-            break;
-          if (line_len > 0 && line[line_len - 1] == '\n')
-            line_len--;
-          free(line);
-          free(it);
-          line_len = count_clusters(line, line_len, 0, line_len);
-          editor->cursor.col = line_len;
-          editor->cursor_preffered = UINT32_MAX;
-          mode = SELECT;
-          editor->selection_active = true;
-          editor->selection = {0, 0};
-          editor->selection_type = LINE;
-        }
-        break;
-      case 'a':
-        mode = INSERT;
-        cursor_right(editor, 1);
-        break;
-      case 'i':
-        mode = INSERT;
-        break;
-      case 'n':
-        mode = JUMPER;
-        editor->jumper_set = true;
-        break;
-      case 'm':
-        mode = JUMPER;
-        editor->jumper_set = false;
-        break;
-      case 'N':
-        for (uint8_t i = 0; i < 94; i++)
-          if (editor->hooks[i] == editor->cursor.row + 1) {
-            editor->hooks[i] = 0;
-            break;
-          }
-        break;
-      case 's':
-      case 'v':
-        mode = SELECT;
-        editor->selection_active = true;
-        editor->selection = editor->cursor;
-        editor->selection_type = CHAR;
-        break;
-      case ';':
-      case ':':
-        mode = RUNNER;
-        break;
-      case 0x7F:
-        cursor_left(editor, 1);
-        break;
-      case ' ':
-        cursor_right(editor, 1);
-        break;
-      case '\r':
-      case '\n':
-        cursor_down(editor, 1);
-        break;
-      case '\\':
-      case '|':
-        cursor_up(editor, 1);
-        break;
-      case CTRL('d'):
-        scroll_down(editor, 1);
-        ensure_cursor(editor);
-        break;
-      case CTRL('u'):
-        scroll_up(editor, 1);
-        ensure_cursor(editor);
-        break;
-      case 'p':
-        uint32_t len;
-        char *text = get_from_clipboard(&len);
-        if (text) {
-          edit_insert(editor, editor->cursor, text, len);
-          uint32_t grapheme_len = count_clusters(text, len, 0, len);
-          cursor_right(editor, grapheme_len);
-          free(text);
-        }
-        break;
-      }
-    }
-    break;
-  case INSERT:
-    if (event.key_type == KEY_CHAR) {
-      if (event.len == 1) {
-        if (event.c[0] == '\t') {
-          edit_insert(editor, editor->cursor, (char *)"  ", 1);
-          cursor_right(editor, 2);
-        } else if (event.c[0] == '\n' || event.c[0] == '\r') {
-          edit_insert(editor, editor->cursor, (char *)"\n", 1);
-          cursor_right(editor, 1);
-        } else if (event.c[0] == 0x7F) {
-          edit_erase(editor, editor->cursor, -1);
-        } else if (event.c[0] == CTRL('W')) {
-          uint32_t prev_col_byte, prev_col_cluster;
-          word_boundaries(editor, editor->cursor, &prev_col_byte, nullptr,
-                          &prev_col_cluster, nullptr);
-          if (prev_col_byte == editor->cursor.col)
-            edit_erase(editor, editor->cursor, -1);
-          else
-            edit_erase(editor, editor->cursor, -(int64_t)prev_col_cluster);
-        } else if (isprint((unsigned char)(event.c[0]))) {
-          edit_insert(editor, editor->cursor, event.c, 1);
-          cursor_right(editor, 1);
-        } else if (event.c[0] == 0x1B) {
-          mode = NORMAL;
-          cursor_left(editor, 1);
-        }
-      } else if (event.len > 1) {
-        edit_insert(editor, editor->cursor, event.c, event.len);
-        cursor_right(editor, 1);
-      }
-    } else if (event.key_type == KEY_SPECIAL &&
-               event.special_key == KEY_DELETE) {
-      switch (event.special_modifier) {
-      case 0:
-        edit_erase(editor, editor->cursor, 1);
-        break;
-      case CNTRL:
-        uint32_t next_col_byte, next_col_cluster;
-        word_boundaries(editor, editor->cursor, nullptr, &next_col_byte,
-                        nullptr, &next_col_cluster);
-        if (next_col_byte == editor->cursor.col)
-          edit_erase(editor, editor->cursor, 1);
-        else
-          edit_erase(editor, editor->cursor, next_col_cluster);
-        break;
-      }
-    }
-    break;
-  case SELECT:
-    if (event.key_type == KEY_CHAR && event.len == 1) {
-      uint32_t len;
-      char *text;
-      switch (event.c[0]) {
-      case 'f':
-        if (editor->cursor.row != editor->selection.row) {
-          uint32_t start = MIN(editor->cursor.row, editor->selection.row);
-          uint32_t end = MAX(editor->cursor.row, editor->selection.row);
-          add_fold(editor, start, end);
-        }
-        cursor_left(editor, 1);
-        cursor_down(editor, 1);
-        editor->selection_active = false;
-        mode = NORMAL;
-        break;
-      case 0x1B:
-      case 's':
-      case 'v':
-        editor->selection_active = false;
-        mode = NORMAL;
-        break;
-      case 'y':
-        text = get_selection(editor, &len);
-        copy_to_clipboard(text, len);
-        free(text);
-        editor->selection_active = false;
-        mode = NORMAL;
-        break;
-      case 'x':
-        text = get_selection(editor, &len);
-        copy_to_clipboard(text, len);
-        edit_erase(editor, MIN(editor->cursor, editor->selection), len);
-        free(text);
-        editor->selection_active = false;
-        mode = NORMAL;
-        break;
-      case 'p':
-        text = get_from_clipboard(&len);
-        if (text) {
-          Coord start, end;
-          if (editor->cursor >= editor->selection) {
-            start = editor->selection;
-            end = move_right(editor, editor->cursor, 1);
-          } else {
-            start = editor->cursor;
-            end = move_right(editor, editor->selection, 1);
-          }
-          uint32_t start_byte =
-              line_to_byte(editor->root, start.row, nullptr) + start.col;
-          uint32_t end_byte =
-              line_to_byte(editor->root, end.row, nullptr) + end.col;
-          edit_erase(editor, start, end_byte - start_byte);
-          edit_insert(editor, editor->cursor, text, len);
-          free(text);
-        }
-        editor->selection_active = false;
-        mode = NORMAL;
-        break;
-      }
-    }
-    break;
-  case JUMPER:
-    if (event.key_type == KEY_CHAR && event.len == 1 &&
-        (event.c[0] >= '!' && event.c[0] <= '~')) {
-      if (editor->jumper_set) {
-        for (uint8_t i = 0; i < 94; i++)
-          if (editor->hooks[i] == editor->cursor.row + 1) {
-            editor->hooks[i] = 0;
-            break;
-          }
-        editor->hooks[event.c[0] - '!'] = editor->cursor.row + 1;
-      } else {
-        uint32_t line = editor->hooks[event.c[0] - '!'];
-        if (line > 0) {
-          if (line_is_folded(editor->folds, --line))
-            break;
-          editor->cursor = {line, 0};
-          editor->cursor_preffered = UINT32_MAX;
-        }
-      }
-    }
-    mode = NORMAL;
-    break;
-  case RUNNER:
-    if (event.key_type == KEY_CHAR && event.len == 1) {
-      switch (event.c[0]) {
-      case 0x1B:
-        mode = NORMAL;
-        break;
-      }
-    }
-    break;
-  }
-  ensure_scroll(editor);
-  if (event.key_type == KEY_CHAR && event.c)
-    free(event.c);
-}
-
-void editor_worker(Editor *editor) {
-  if (!editor || !editor->root)
-    return;
-  if (editor->parser && editor->query)
-    ts_collect_spans(editor);
-  uint32_t prev_col, next_col;
-  word_boundaries_exclusive(editor, editor->cursor, &prev_col, &next_col);
-  if (next_col - prev_col > 0 && next_col - prev_col < 256 - 4) {
-    std::shared_lock lock(editor->knot_mtx);
-    uint32_t offset = line_to_byte(editor->root, editor->cursor.row, nullptr);
-    char *word = read(editor->root, offset + prev_col, next_col - prev_col);
-    if (word) {
-      char buf[256];
-      snprintf(buf, sizeof(buf), "\\b%s\\b", word);
-      std::vector<std::pair<size_t, size_t>> results =
-          search_rope(editor->root, buf);
-      std::unique_lock lock(editor->def_spans.mtx);
-      editor->def_spans.spans.clear();
-      for (const auto &match : results) {
-        Span s;
-        s.start = match.first;
-        s.end = match.first + match.second;
-        s.hl = &HL_UNDERLINE;
-        editor->def_spans.spans.push_back(s);
-      }
-      std::sort(editor->def_spans.spans.begin(), editor->def_spans.spans.end());
-      lock.unlock();
-      free(word);
-    }
-  } else {
-    std::unique_lock lock(editor->def_spans.mtx);
-    editor->def_spans.spans.clear();
-    lock.unlock();
-  }
-}
-
 uint32_t scan_left(const char *line, uint32_t len, uint32_t off) {
   if (off > len)
     off = len;
@@ -791,42 +211,32 @@ Coord move_right_pure(Editor *editor, Coord cursor, uint32_t number) {
   Coord result = cursor;
   if (!editor || !editor->root || number == 0)
     return result;
-
   uint32_t row = result.row;
   uint32_t col = result.col;
   uint32_t line_len = 0;
-
   LineIterator *it = begin_l_iter(editor->root, row);
   char *line = next_line(it, &line_len);
   free(it);
-
   if (!line)
     return result;
-
   if (line_len > 0 && line[line_len - 1] == '\n')
     --line_len;
-
   while (number > 0) {
     if (col >= line_len) {
       free(line);
       line = nullptr;
-
       uint32_t next_row = row + 1;
       if (next_row >= editor->root->line_count) {
         col = line_len;
         break;
       }
-
       row = next_row;
       col = 0;
-
       it = begin_l_iter(editor->root, row);
       line = next_line(it, &line_len);
       free(it);
-
       if (!line)
         break;
-
       if (line_len > 0 && line[line_len - 1] == '\n')
         --line_len;
     } else {
@@ -838,10 +248,8 @@ Coord move_right_pure(Editor *editor, Coord cursor, uint32_t number) {
     }
     number--;
   }
-
   if (line)
     free(line);
-
   result.row = row;
   result.col = col;
   return result;
@@ -1035,7 +443,6 @@ void cursor_down(Editor *editor, uint32_t number) {
         get_visual_col_from_bytes(line_content, len, editor->cursor.col);
   uint32_t visual_col = editor->cursor_preffered;
   free(line_content);
-
   uint32_t target_row = editor->cursor.row;
   while (number > 0 && target_row < editor->root->line_count - 1) {
     target_row = next_unfolded_row(editor, target_row + 1);
@@ -1045,7 +452,6 @@ void cursor_down(Editor *editor, uint32_t number) {
     }
     number--;
   }
-
   it = begin_l_iter(editor->root, target_row);
   line_content = next_line(it, &len);
   free(it);
@@ -1072,7 +478,6 @@ void cursor_up(Editor *editor, uint32_t number) {
         get_visual_col_from_bytes(line_content, len, editor->cursor.col);
   uint32_t visual_col = editor->cursor_preffered;
   free(line_content);
-
   uint32_t target_row = editor->cursor.row;
   while (number > 0 && target_row > 0) {
     target_row = prev_unfolded_row(editor, target_row - 1);
@@ -1082,7 +487,6 @@ void cursor_up(Editor *editor, uint32_t number) {
     }
     number--;
   }
-
   it = begin_l_iter(editor->root, target_row);
   line_content = next_line(it, &len);
   free(it);
@@ -1131,6 +535,8 @@ void move_line_up(Editor *editor) {
     line_cluster_len = count_clusters(line, line_len, 0, line_len);
     uint32_t target_row = prev_unfolded_row(editor, editor->cursor.row - 1);
     uint32_t up_by = editor->cursor.row - target_row;
+    if (up_by > 1)
+      up_by--;
     lock.unlock();
     Coord cursor = editor->cursor;
     edit_erase(editor, {cursor.row, 0}, line_cluster_len);
@@ -1178,14 +584,15 @@ void move_line_down(Editor *editor) {
     if (line_len && line[line_len - 1] == '\n')
       line_len--;
     line_cluster_len = count_clusters(line, line_len, 0, line_len);
-    uint32_t target_row =
-        next_unfolded_row(editor, editor->cursor.row + 1);
+    uint32_t target_row = next_unfolded_row(editor, editor->cursor.row + 1);
     if (target_row >= editor->root->line_count) {
       free(line);
       lock.unlock();
       return;
     }
     uint32_t down_by = target_row - editor->cursor.row;
+    if (down_by > 1)
+      down_by--;
     uint32_t ln;
     line_to_byte(editor->root, editor->cursor.row + down_by - 1, &ln);
     lock.unlock();
@@ -1200,11 +607,19 @@ void move_line_down(Editor *editor) {
     if (editor->cursor.row >= editor->root->line_count - 1 ||
         editor->selection.row >= editor->root->line_count - 1)
       return;
+    std::shared_lock lock(editor->knot_mtx);
     uint32_t start_row = MIN(editor->cursor.row, editor->selection.row);
     uint32_t end_row = MAX(editor->cursor.row, editor->selection.row);
+    uint32_t target_row = next_unfolded_row(editor, end_row + 1);
+    if (target_row >= editor->root->line_count)
+      return;
+    uint32_t down_by = target_row - end_row;
+    if (down_by > 1)
+      down_by--;
     uint32_t start_byte = line_to_byte(editor->root, start_row, nullptr);
     uint32_t end_byte = line_to_byte(editor->root, end_row + 1, nullptr);
     char *selected_text = read(editor->root, start_byte, end_byte - start_byte);
+    lock.unlock();
     if (!selected_text)
       return;
     uint32_t selected_len = count_clusters(selected_text, end_byte - start_byte,
@@ -1212,11 +627,11 @@ void move_line_down(Editor *editor) {
     Coord cursor = editor->cursor;
     Coord selection = editor->selection;
     edit_erase(editor, {start_row, 0}, selected_len);
-    edit_insert(editor, {start_row + 1, 0}, selected_text,
+    edit_insert(editor, {start_row + down_by, 0}, selected_text,
                 end_byte - start_byte);
     free(selected_text);
-    editor->cursor = {cursor.row + 1, cursor.col};
-    editor->selection = {selection.row + 1, selection.col};
+    editor->cursor = {cursor.row + down_by, cursor.col};
+    editor->selection = {selection.row + down_by, selection.col};
   }
 }
 
@@ -1245,8 +660,7 @@ void edit_erase(Editor *editor, Coord pos, int64_t len) {
     lock_1.unlock();
     uint32_t start_row = point.row;
     uint32_t end_row = pos.row;
-    if (end_row > start_row)
-      apply_line_deletion(editor, start_row + 1, end_row);
+    apply_line_deletion(editor, start_row + 1, end_row);
     std::unique_lock lock_2(editor->knot_mtx);
     editor->root = erase(editor->root, start, byte_pos - start);
     lock_2.unlock();
@@ -1289,8 +703,7 @@ void edit_erase(Editor *editor, Coord pos, int64_t len) {
     lock_1.unlock();
     uint32_t start_row = pos.row;
     uint32_t end_row = point.row;
-    if (end_row > start_row)
-      apply_line_deletion(editor, start_row + 1, end_row);
+    apply_line_deletion(editor, start_row + 1, end_row);
     std::unique_lock lock_2(editor->knot_mtx);
     editor->root = erase(editor->root, byte_pos, end - byte_pos);
     lock_2.unlock();
@@ -1341,8 +754,7 @@ void edit_insert(Editor *editor, Coord pos, char *data, uint32_t len) {
       cols++;
     }
   }
-  if (rows > 0)
-    apply_line_insertion(editor, pos.row, rows);
+  apply_line_insertion(editor, pos.row, rows);
   if (editor->tree) {
     TSInputEdit edit = {
         .start_byte = byte_pos,
@@ -1439,3 +851,95 @@ void apply_edit(std::vector<Span> &spans, uint32_t x, int64_t y) {
       ++i;
   }
 }
+
+std::vector<Fold>::iterator find_fold_iter(Editor *editor, uint32_t line) {
+  auto &folds = editor->folds;
+  auto it = std::lower_bound(
+      folds.begin(), folds.end(), line,
+      [](const Fold &fold, uint32_t value) { return fold.start < value; });
+  if (it != folds.end() && it->start == line)
+    return it;
+  if (it != folds.begin()) {
+    --it;
+    if (it->contains(line))
+      return it;
+  }
+  return folds.end();
+}
+
+bool add_fold(Editor *editor, uint32_t start, uint32_t end) {
+  if (!editor || !editor->root)
+    return false;
+  if (start > end)
+    std::swap(start, end);
+  if (start >= editor->root->line_count)
+    return false;
+  end = std::min(end, editor->root->line_count - 1);
+  if (start == end)
+    return false;
+
+  Fold new_fold{start, end};
+  auto &folds = editor->folds;
+  auto it = std::lower_bound(
+      folds.begin(), folds.end(), new_fold.start,
+      [](const Fold &fold, uint32_t value) { return fold.start < value; });
+
+  if (it != folds.begin()) {
+    auto prev = std::prev(it);
+    if (prev->end + 1 >= new_fold.start) {
+      new_fold.start = std::min(new_fold.start, prev->start);
+      new_fold.end = std::max(new_fold.end, prev->end);
+      it = folds.erase(prev);
+    }
+  }
+  while (it != folds.end() && it->start <= new_fold.end + 1) {
+    new_fold.end = std::max(new_fold.end, it->end);
+    it = folds.erase(it);
+  }
+  folds.insert(it, new_fold);
+  return true;
+}
+
+bool remove_fold(Editor *editor, uint32_t line) {
+  auto it = find_fold_iter(editor, line);
+  if (it == editor->folds.end())
+    return false;
+  editor->folds.erase(it);
+  return true;
+}
+
+void apply_line_insertion(Editor *editor, uint32_t line, uint32_t rows) {
+  for (auto it = editor->folds.begin(); it != editor->folds.end();) {
+    if (line <= it->start) {
+      it->start += rows;
+      it->end += rows;
+      ++it;
+    } else if (line <= it->end) {
+      it = editor->folds.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+void apply_line_deletion(Editor *editor, uint32_t removal_start,
+                         uint32_t removal_end) {
+  if (removal_start > removal_end)
+    return;
+  uint32_t rows_removed = removal_end - removal_start + 1;
+  std::vector<Fold> updated;
+  updated.reserve(editor->folds.size());
+  for (auto fold : editor->folds) {
+    if (removal_end < fold.start) {
+      fold.start -= rows_removed;
+      fold.end -= rows_removed;
+      updated.push_back(fold);
+      continue;
+    }
+    if (removal_start > fold.end) {
+      updated.push_back(fold);
+      continue;
+    }
+  }
+  editor->folds.swap(updated);
+}
diff --git a/src/editor_events.cc b/src/editor_events.cc
new file mode 100644
index 0000000..2cf3c7e
--- /dev/null
+++ b/src/editor_events.cc
@@ -0,0 +1,520 @@
+#include "../include/editor.h"
+#include "../include/main.h"
+#include "../include/ts.h"
+
+void handle_editor_event(Editor *editor, KeyEvent event) {
+  static std::chrono::steady_clock::time_point last_click_time =
+      std::chrono::steady_clock::now();
+  static uint32_t click_count = 0;
+  static Coord last_click_pos = {UINT32_MAX, UINT32_MAX};
+  if (event.key_type == KEY_MOUSE) {
+    auto now = std::chrono::steady_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
+                        now - last_click_time)
+                        .count();
+    switch (event.mouse_state) {
+    case SCROLL:
+      switch (event.mouse_direction) {
+      case SCROLL_UP:
+        scroll_up(editor, 10);
+        ensure_cursor(editor);
+        break;
+      case SCROLL_DOWN:
+        scroll_down(editor, 10);
+        ensure_cursor(editor);
+        break;
+      case SCROLL_LEFT:
+        cursor_left(editor, 10);
+        break;
+      case SCROLL_RIGHT:
+        cursor_right(editor, 10);
+        break;
+      }
+      break;
+    case PRESS:
+      if (event.mouse_button == LEFT_BTN) {
+        Coord cur_pos = {event.mouse_x, event.mouse_y};
+        if (duration < 250 && last_click_pos == cur_pos)
+          click_count++;
+        else
+          click_count = 1;
+        last_click_time = now;
+        last_click_pos = cur_pos;
+        Coord p = editor_hit_test(editor, event.mouse_x, event.mouse_y);
+        if (p.row == UINT32_MAX && p.col == UINT32_MAX)
+          return;
+        editor->cursor_preffered = UINT32_MAX;
+        if (click_count == 1) {
+          editor->cursor = p;
+          editor->selection = p;
+          if (mode == SELECT) {
+            mode = NORMAL;
+            editor->selection_active = false;
+          }
+        } else if (click_count == 2) {
+          uint32_t prev_col, next_col;
+          word_boundaries(editor, editor->cursor, &prev_col, &next_col, nullptr,
+                          nullptr);
+          if (editor->cursor < editor->selection)
+            editor->cursor = {editor->cursor.row, prev_col};
+          else
+            editor->cursor = {editor->cursor.row, next_col};
+          editor->cursor_preffered = UINT32_MAX;
+          editor->selection_type = WORD;
+          mode = SELECT;
+          editor->selection_active = true;
+        } else if (click_count >= 3) {
+          if (editor->cursor < editor->selection) {
+            editor->cursor = {p.row, 0};
+          } else {
+            uint32_t line_len;
+            LineIterator *it = begin_l_iter(editor->root, p.row);
+            char *line = next_line(it, &line_len);
+            free(it);
+            if (!line)
+              return;
+            if (line_len > 0 && line[line_len - 1] == '\n')
+              line_len--;
+            free(line);
+            editor->cursor = {p.row, line_len};
+          }
+          editor->cursor_preffered = UINT32_MAX;
+          editor->selection_type = LINE;
+          mode = SELECT;
+          editor->selection_active = true;
+          click_count = 3;
+        }
+      }
+      break;
+    case DRAG:
+      if (event.mouse_button == LEFT_BTN) {
+        Coord p = editor_hit_test(editor, event.mouse_x, event.mouse_y);
+        if (p.row == UINT32_MAX && p.col == UINT32_MAX)
+          return;
+        editor->cursor_preffered = UINT32_MAX;
+        mode = SELECT;
+        if (!editor->selection_active) {
+          editor->selection_active = true;
+          editor->selection_type = CHAR;
+        }
+        uint32_t prev_col, next_col, line_len;
+        switch (editor->selection_type) {
+        case CHAR:
+          editor->cursor = p;
+          break;
+        case WORD:
+          word_boundaries(editor, p, &prev_col, &next_col, nullptr, nullptr);
+          if (editor->cursor < editor->selection)
+            editor->cursor = {p.row, prev_col};
+          else
+            editor->cursor = {p.row, next_col};
+          break;
+        case LINE:
+          if (editor->cursor < editor->selection) {
+            editor->cursor = {p.row, 0};
+          } else {
+            LineIterator *it = begin_l_iter(editor->root, p.row);
+            char *line = next_line(it, &line_len);
+            free(it);
+            if (!line)
+              return;
+            if (line_len > 0 && line[line_len - 1] == '\n')
+              line_len--;
+            free(line);
+            editor->cursor = {p.row, line_len};
+          }
+          break;
+        }
+      }
+      break;
+    case RELEASE:
+      if (event.mouse_button == LEFT_BTN)
+        if (editor->cursor.row == editor->selection.row &&
+            editor->cursor.col == editor->selection.col) {
+          mode = NORMAL;
+          editor->selection_active = false;
+        }
+      break;
+    }
+  }
+  if (event.key_type == KEY_SPECIAL) {
+    switch (event.special_modifier) {
+    case 0:
+      switch (event.special_key) {
+      case KEY_DOWN:
+        cursor_down(editor, 1);
+        break;
+      case KEY_UP:
+        cursor_up(editor, 1);
+        break;
+      case KEY_LEFT:
+        cursor_left(editor, 1);
+        break;
+      case KEY_RIGHT:
+        cursor_right(editor, 1);
+        break;
+      }
+      break;
+    case CNTRL:
+      uint32_t prev_col, next_col;
+      word_boundaries(editor, editor->cursor, &prev_col, &next_col, nullptr,
+                      nullptr);
+      switch (event.special_key) {
+      case KEY_DOWN:
+        cursor_down(editor, 5);
+        break;
+      case KEY_UP:
+        cursor_up(editor, 5);
+        break;
+      case KEY_LEFT:
+        editor->cursor_preffered = UINT32_MAX;
+        if (prev_col == editor->cursor.col)
+          cursor_left(editor, 1);
+        else
+          editor->cursor = {editor->cursor.row, prev_col};
+        break;
+      case KEY_RIGHT:
+        editor->cursor_preffered = UINT32_MAX;
+        if (next_col == editor->cursor.col)
+          cursor_right(editor, 1);
+        else
+          editor->cursor = {editor->cursor.row, next_col};
+        break;
+      }
+      break;
+    case ALT:
+      switch (event.special_key) {
+      case KEY_DOWN:
+        move_line_down(editor);
+        break;
+      case KEY_UP:
+        move_line_up(editor);
+        break;
+      case KEY_LEFT:
+        cursor_left(editor, 8);
+        break;
+      case KEY_RIGHT:
+        cursor_right(editor, 8);
+        break;
+      }
+      break;
+    }
+  }
+  switch (mode) {
+  case NORMAL:
+    if (event.key_type == KEY_CHAR && event.len == 1) {
+      switch (event.c[0]) {
+      case 'u':
+        if (editor->root->line_count > 0) {
+          editor->cursor.row = editor->root->line_count - 1;
+          LineIterator *it = begin_l_iter(editor->root, editor->cursor.row);
+          if (!it)
+            break;
+          uint32_t line_len;
+          char *line = next_line(it, &line_len);
+          if (!line)
+            break;
+          if (line_len > 0 && line[line_len - 1] == '\n')
+            line_len--;
+          free(it);
+          line_len = count_clusters(line, line_len, 0, line_len);
+          free(line);
+          editor->cursor.col = line_len;
+          editor->cursor_preffered = UINT32_MAX;
+          mode = SELECT;
+          editor->selection_active = true;
+          editor->selection = {0, 0};
+          editor->selection_type = LINE;
+        }
+        break;
+      case 'a':
+        mode = INSERT;
+        cursor_right(editor, 1);
+        break;
+      case 'i':
+        mode = INSERT;
+        break;
+      case 'n':
+        mode = JUMPER;
+        editor->jumper_set = true;
+        break;
+      case 'm':
+        mode = JUMPER;
+        editor->jumper_set = false;
+        break;
+      case 'N':
+        for (uint8_t i = 0; i < 94; i++)
+          if (editor->hooks[i] == editor->cursor.row + 1) {
+            editor->hooks[i] = 0;
+            break;
+          }
+        break;
+      case 's':
+      case 'v':
+        mode = SELECT;
+        editor->selection_active = true;
+        editor->selection = editor->cursor;
+        editor->selection_type = CHAR;
+        break;
+      case ';':
+      case ':':
+        mode = RUNNER;
+        break;
+      case 0x7F:
+        cursor_left(editor, 1);
+        break;
+      case ' ':
+        cursor_right(editor, 1);
+        break;
+      case '\r':
+      case '\n':
+        cursor_down(editor, 1);
+        break;
+      case '\\':
+      case '|':
+        cursor_up(editor, 1);
+        break;
+      case CTRL('d'):
+        scroll_down(editor, 1);
+        ensure_cursor(editor);
+        break;
+      case CTRL('u'):
+        scroll_up(editor, 1);
+        ensure_cursor(editor);
+        break;
+      case 'p':
+        uint32_t len;
+        char *text = get_from_clipboard(&len);
+        if (text) {
+          edit_insert(editor, editor->cursor, text, len);
+          uint32_t grapheme_len = count_clusters(text, len, 0, len);
+          cursor_right(editor, grapheme_len);
+          free(text);
+        }
+        break;
+      }
+    }
+    break;
+  case INSERT:
+    if (event.key_type == KEY_CHAR) {
+      if (event.len == 1) {
+        if (event.c[0] == '\t') {
+          edit_insert(editor, editor->cursor, (char *)"  ", 2);
+          cursor_right(editor, 2);
+        } else if (event.c[0] == '\n' || event.c[0] == '\r') {
+          edit_insert(editor, editor->cursor, (char *)"\n", 1);
+          cursor_right(editor, 1);
+        } else if (event.c[0] == CTRL('W')) {
+          uint32_t prev_col_byte, prev_col_cluster;
+          word_boundaries(editor, editor->cursor, &prev_col_byte, nullptr,
+                          &prev_col_cluster, nullptr);
+          if (prev_col_byte == editor->cursor.col)
+            edit_erase(editor, editor->cursor, -1);
+          else
+            edit_erase(editor, editor->cursor, -(int64_t)prev_col_cluster);
+        } else if (isprint((unsigned char)(event.c[0]))) {
+          char c = event.c[0];
+          char closing = 0;
+          if (c == '{')
+            closing = '}';
+          else if (c == '(')
+            closing = ')';
+          else if (c == '[')
+            closing = ']';
+          else if (c == '"')
+            closing = '"';
+          else if (c == '\'')
+            closing = '\'';
+          if (closing) {
+            char pair[2] = {c, closing};
+            edit_insert(editor, editor->cursor, pair, 2);
+            cursor_right(editor, 1);
+          } else {
+            edit_insert(editor, editor->cursor, event.c, 1);
+            cursor_right(editor, 1);
+          }
+        } else if (event.c[0] == 0x7F || event.c[0] == 0x08) {
+          Coord prev_pos = editor->cursor;
+          if (prev_pos.col > 0)
+            prev_pos.col--;
+          LineIterator *it = begin_l_iter(editor->root, editor->cursor.row);
+          if (!it)
+            return;
+          char *line = next_line(it, nullptr);
+          free(it);
+          char prev_char = line[prev_pos.col];
+          char next_char = line[editor->cursor.col];
+          free(line);
+          bool is_pair = (prev_char == '{' && next_char == '}') ||
+                         (prev_char == '(' && next_char == ')') ||
+                         (prev_char == '[' && next_char == ']') ||
+                         (prev_char == '"' && next_char == '"') ||
+                         (prev_char == '\'' && next_char == '\'');
+          if (is_pair) {
+            edit_erase(editor, editor->cursor, 1);
+            edit_erase(editor, prev_pos, 1);
+          } else {
+            edit_erase(editor, editor->cursor, -1);
+          }
+        } else if (event.c[0] == 0x1B) {
+          mode = NORMAL;
+          cursor_left(editor, 1);
+        }
+      } else if (event.len > 1) {
+        edit_insert(editor, editor->cursor, event.c, event.len);
+        cursor_right(editor, 1);
+      }
+    } else if (event.key_type == KEY_SPECIAL &&
+               event.special_key == KEY_DELETE) {
+      switch (event.special_modifier) {
+      case 0:
+        edit_erase(editor, editor->cursor, 1);
+        break;
+      case CNTRL:
+        uint32_t next_col_byte, next_col_cluster;
+        word_boundaries(editor, editor->cursor, nullptr, &next_col_byte,
+                        nullptr, &next_col_cluster);
+        if (next_col_byte == editor->cursor.col)
+          edit_erase(editor, editor->cursor, 1);
+        else
+          edit_erase(editor, editor->cursor, next_col_cluster);
+        break;
+      }
+    }
+    break;
+  case SELECT:
+    if (event.key_type == KEY_CHAR && event.len == 1) {
+      uint32_t len;
+      char *text;
+      switch (event.c[0]) {
+      case 'f':
+        if (editor->cursor.row != editor->selection.row) {
+          uint32_t start = MIN(editor->cursor.row, editor->selection.row);
+          uint32_t end = MAX(editor->cursor.row, editor->selection.row);
+          add_fold(editor, start, end);
+        }
+        cursor_left(editor, 1);
+        cursor_down(editor, 1);
+        editor->selection_active = false;
+        mode = NORMAL;
+        break;
+      case 0x1B:
+      case 's':
+      case 'v':
+        editor->selection_active = false;
+        mode = NORMAL;
+        break;
+      case 'y':
+        text = get_selection(editor, &len);
+        copy_to_clipboard(text, len);
+        free(text);
+        editor->selection_active = false;
+        mode = NORMAL;
+        break;
+      case 'x':
+        text = get_selection(editor, &len);
+        copy_to_clipboard(text, len);
+        edit_erase(editor, MIN(editor->cursor, editor->selection), len);
+        free(text);
+        editor->selection_active = false;
+        mode = NORMAL;
+        break;
+      case 'p':
+        text = get_from_clipboard(&len);
+        if (text) {
+          Coord start, end;
+          if (editor->cursor >= editor->selection) {
+            start = editor->selection;
+            end = move_right(editor, editor->cursor, 1);
+          } else {
+            start = editor->cursor;
+            end = move_right(editor, editor->selection, 1);
+          }
+          uint32_t start_byte =
+              line_to_byte(editor->root, start.row, nullptr) + start.col;
+          uint32_t end_byte =
+              line_to_byte(editor->root, end.row, nullptr) + end.col;
+          edit_erase(editor, start, end_byte - start_byte);
+          edit_insert(editor, editor->cursor, text, len);
+          free(text);
+        }
+        editor->selection_active = false;
+        mode = NORMAL;
+        break;
+      }
+    }
+    break;
+  case JUMPER:
+    if (event.key_type == KEY_CHAR && event.len == 1 &&
+        (event.c[0] >= '!' && event.c[0] <= '~')) {
+      if (editor->jumper_set) {
+        for (uint8_t i = 0; i < 94; i++)
+          if (editor->hooks[i] == editor->cursor.row + 1) {
+            editor->hooks[i] = 0;
+            break;
+          }
+        editor->hooks[event.c[0] - '!'] = editor->cursor.row + 1;
+      } else {
+        uint32_t line = editor->hooks[event.c[0] - '!'];
+        if (line > 0) {
+          if (line_is_folded(editor->folds, --line))
+            break;
+          editor->cursor = {line, 0};
+          editor->cursor_preffered = UINT32_MAX;
+        }
+      }
+    }
+    mode = NORMAL;
+    break;
+  case RUNNER:
+    if (event.key_type == KEY_CHAR && event.len == 1) {
+      switch (event.c[0]) {
+      case 0x1B:
+        mode = NORMAL;
+        break;
+      }
+    }
+    break;
+  }
+  ensure_scroll(editor);
+  if (event.key_type == KEY_CHAR && event.c)
+    free(event.c);
+}
+
+static Highlight HL_UNDERLINE = {0, 0, 1 << 2, 100};
+
+void editor_worker(Editor *editor) {
+  if (!editor || !editor->root)
+    return;
+  if (editor->parser && editor->query)
+    ts_collect_spans(editor);
+  uint32_t prev_col, next_col;
+  word_boundaries_exclusive(editor, editor->cursor, &prev_col, &next_col);
+  if (next_col - prev_col > 0 && next_col - prev_col < 256 - 4) {
+    std::shared_lock lock(editor->knot_mtx);
+    uint32_t offset = line_to_byte(editor->root, editor->cursor.row, nullptr);
+    char *word = read(editor->root, offset + prev_col, next_col - prev_col);
+    if (word) {
+      char buf[256];
+      snprintf(buf, sizeof(buf), "\\b%s\\b", word);
+      std::vector<std::pair<size_t, size_t>> results =
+          search_rope(editor->root, buf);
+      std::unique_lock lock(editor->def_spans.mtx);
+      editor->def_spans.spans.clear();
+      for (const auto &match : results) {
+        Span s;
+        s.start = match.first;
+        s.end = match.first + match.second;
+        s.hl = &HL_UNDERLINE;
+        editor->def_spans.spans.push_back(s);
+      }
+      std::sort(editor->def_spans.spans.begin(), editor->def_spans.spans.end());
+      lock.unlock();
+      free(word);
+    }
+  } else {
+    std::unique_lock lock(editor->def_spans.mtx);
+    editor->def_spans.spans.clear();
+    lock.unlock();
+  }
+}