esc

Externally Scriptable Editor

git clone git://mccd.space/esc

editor.c (32508B)

 #include "editor.h"
 #include "strbuf.h"
 #include <SDL3/SDL_stdinc.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 /* Forward declarations for file slot helpers (defined after lifecycle code) */
 static void slots_on_insert(Editor *ed, int pos, int len);
 static void slots_on_delete(Editor *ed, int pos, int len);
 
 /* ---------- undo helpers (called with lock held) ----------------------- */
 
 static void push_undo_delta(Editor *ed, UndoDelta d) {
 	/* Any new edit clears the redo stack. */
 	for (int i = 0; i < ed->redo_len; i++)
 		free(ed->redo_stack[i].reinsert);
 	ed->redo_len = 0;
 
 	/* Drop oldest entry if full. */
 	if (ed->undo_len == UNDO_MAX) {
 		free(ed->undo_stack[0].reinsert);
 		memmove(ed->undo_stack, ed->undo_stack + 1,
 			(UNDO_MAX - 1) * sizeof(UndoDelta));
 		ed->undo_len--;
 	}
 	ed->undo_stack[ed->undo_len++] = d;
 }
 
 /* Raw delete: no delta recorded, no lock acquired. */
 static void delete_range_raw(Editor *ed, int start, int end) {
 	if (start == end)
 		return;
 	if (start > end) {
 		int tmp = start;
 		start = end;
 		end = tmp;
 	}
 	int len = end - start;
 	size_t new_count = 0;
 	for (size_t i = 0; i < ed->ranges_count; i++) {
 		EditorRange r = ed->ranges[i];
 		if (r.start_byte >= start && r.end_byte <= end)
 			continue;
 		if (r.start_byte >= end) {
 			r.start_byte -= len;
 			r.end_byte -= len;
 		} else {
 			if (r.start_byte > start && r.start_byte < end)
 				r.start_byte = start;
 			if (r.end_byte > start && r.end_byte < end)
 				r.end_byte = start;
 			if (start > r.start_byte && end < r.end_byte)
 				r.end_byte -= len;
 		}
 		if (r.end_byte > r.start_byte)
 			ed->ranges[new_count++] = r;
 	}
 	ed->ranges_count = new_count;
 	slots_on_delete(ed, start, len);
 	strbuf_delete(&ed->text, start, len);
 	ed->cursor_idx = start;
 	ed->selection_anchor = start;
 }
 
 /*
  * Apply a delta: delete [pos, pos+delete_len) then insert reinsert at pos.
  * Populate *rev with the inverse delta (for pushing onto the opposite stack).
  * Called with lock held; does not record new undo entries.
  */
 static void apply_delta(Editor *ed, const UndoDelta *d, UndoDelta *rev) {
 	/* Capture bytes that will be deleted, for the reverse. */
 	char *captured = NULL;
 	if (d->delete_len > 0) {
 		captured = malloc(d->delete_len + 1);
 		if (captured) {
 			memcpy(captured, ed->text.data + d->pos, d->delete_len);
 			captured[d->delete_len] = '\0';
 		}
 	}
 
 	rev->pos = d->pos;
 	rev->reinsert = captured;
 	rev->reinsert_len = d->delete_len;
 	rev->delete_len = d->reinsert_len;
 	rev->cursor_before = ed->cursor_idx;
 	rev->anchor_before = ed->selection_anchor;
 
 	/* Apply: delete first, then insert. */
 	if (d->delete_len > 0)
 		delete_range_raw(ed, d->pos, d->pos + (int)d->delete_len);
 
 	if (d->reinsert_len > 0) {
 		/* Shift ranges for the insertion. */
 		for (size_t i = 0; i < ed->ranges_count; i++) {
 			if (ed->ranges[i].start_byte >= d->pos) {
 				ed->ranges[i].start_byte += (int)d->reinsert_len;
 				ed->ranges[i].end_byte += (int)d->reinsert_len;
 			} else if (d->pos > ed->ranges[i].start_byte &&
 				   d->pos < ed->ranges[i].end_byte) {
 				ed->ranges[i].end_byte += (int)d->reinsert_len;
 			}
 		}
 		strbuf_insert(&ed->text, d->pos, d->reinsert, d->reinsert_len);
 	}
 
 	/* Restore cursor, clamped to buffer size. */
 	int tlen = (int)ed->text.len;
 	ed->cursor_idx = d->cursor_before > tlen ? tlen : d->cursor_before;
 	ed->selection_anchor =
 	    d->anchor_before > tlen ? tlen : d->anchor_before;
 }
 
 /* ---------- lifecycle -------------------------------------------------- */
 
 Editor *editor_create(int char_width, float line_height) {
 	Editor *ed = malloc(sizeof(Editor));
 	if (!ed)
 		return NULL;
 
 	strbuf_init(&ed->text, 1024);
 	ed->cursor_idx = 0;
 	ed->selection_anchor = 0;
 
 	ed->mutex = SDL_CreateMutex();
 	if (!ed->mutex) {
 		free(ed);
 		return NULL;
 	}
 
 	// Initialize ranges to zero/NULL
 	ed->ranges = NULL;
 	ed->ranges_count = 0;
 	ed->ranges_capacity = 0;
 
 	ed->files = NULL;
 	ed->files_count = 0;
 	ed->files_cap = 0;
 
 	ed->undo_stack = malloc(UNDO_MAX * sizeof(UndoDelta));
 	ed->undo_len = 0;
 	ed->redo_stack = malloc(UNDO_MAX * sizeof(UndoDelta));
 	ed->redo_len = 0;
 
 	ed->char_width = char_width;
 	ed->line_height = line_height;
 	return ed;
 }
 
 void editor_destroy(Editor *ed) {
 	for (int i = 0; i < ed->files_count; i++)
 		free(ed->files[i].path);
 	free(ed->files);
 	strbuf_free(&ed->text);
 	if (ed->mutex)
 		SDL_DestroyMutex(ed->mutex);
 	for (int i = 0; i < ed->undo_len; i++)
 		free(ed->undo_stack[i].reinsert);
 	free(ed->undo_stack);
 	for (int i = 0; i < ed->redo_len; i++)
 		free(ed->redo_stack[i].reinsert);
 	free(ed->redo_stack);
 	free(ed->ranges);
 	free(ed);
 }
 
 void editor_lock(Editor *ed) {
 	if (ed && ed->mutex)
 		SDL_LockMutex(ed->mutex);
 }
 
 void editor_unlock(Editor *ed) {
 	if (ed && ed->mutex)
 		SDL_UnlockMutex(ed->mutex);
 }
 
 void editor_clear_ranges(Editor *ed) {
 	editor_lock(ed);
 	ed->ranges_count = 0;
 	editor_unlock(ed);
 }
 
 /* ---------- file slot helpers ------------------------------------------ */
 
 static void files_grow(Editor *ed) {
 	if (ed->files_count >= ed->files_cap) {
 		int new_cap = ed->files_cap == 0 ? 4 : ed->files_cap * 2;
 		ed->files = realloc(ed->files, new_cap * sizeof(FileSlot));
 		ed->files_cap = new_cap;
 	}
 }
 
 /* Shift all slot boundaries after a text insertion at pos. */
 static void slots_on_insert(Editor *ed, int pos, int len) {
 	for (int i = 0; i < ed->files_count; i++) {
 		FileSlot *s = &ed->files[i];
 		if (s->buf_start <= pos && pos <= s->buf_end) {
 			/* Cursor is inside this slot */
 			s->buf_end += len;
 			if (s->has_range)
 				s->range_end += len;
 			s->dirty = true;
 		} else if (s->buf_start > pos) {
 			s->buf_start += len;
 			s->buf_end   += len;
 		}
 	}
 }
 
 /* Shift all slot boundaries after a text deletion of [pos, pos+len). */
 static void slots_on_delete(Editor *ed, int pos, int len) {
 	int del_end = pos + len;
 	for (int i = 0; i < ed->files_count; i++) {
 		FileSlot *s = &ed->files[i];
 		if (s->buf_end <= pos) {
 			/* slot entirely before deletion: no change */
 		} else if (s->buf_start >= del_end) {
 			/* slot entirely after deletion */
 			s->buf_start -= len;
 			s->buf_end   -= len;
 		} else {
 			/* overlapping */
 			int overlap_start = s->buf_start > pos ? s->buf_start : pos;
 			int overlap_end   = s->buf_end < del_end ? s->buf_end : del_end;
 			int removed = overlap_end - overlap_start;
 			s->buf_end -= removed;
 			if (s->has_range)
 				s->range_end -= removed;
 			if (s->buf_start > pos)
 				s->buf_start = pos;
 			s->dirty = true;
 		}
 	}
 }
 
 int editor_file_slot_at(Editor *ed, int byte_pos) {
 	for (int i = 0; i < ed->files_count; i++) {
 		if (byte_pos >= ed->files[i].buf_start &&
 		    byte_pos <= ed->files[i].buf_end)
 			return i;
 	}
 	return ed->files_count - 1;
 }
 
 bool editor_open_file(Editor *ed, const char *filename) {
 	editor_lock(ed);
 
 	/* Read file into a temporary strbuf */
 	StrBuf tmp;
 	strbuf_init(&tmp, 1024);
 	if (!strbuf_read_file(&tmp, filename)) {
 		strbuf_free(&tmp);
 		editor_unlock(ed);
 		return false;
 	}
 
 	int insert_pos = (int)ed->text.len;
 	/* Append a newline separator between slots (except for the first) */
 	if (ed->files_count > 0 && insert_pos > 0 &&
 	    ed->text.data[insert_pos - 1] != '\n') {
 		strbuf_insert(&ed->text, insert_pos, "\n", 1);
 		slots_on_insert(ed, insert_pos, 1);
 		insert_pos++;
 	}
 
 	files_grow(ed);
 	FileSlot *s = &ed->files[ed->files_count];
 	s->path        = filename ? strdup(filename) : NULL;
 	s->buf_start   = insert_pos;
 	s->dirty       = false;
 	s->has_range   = false;
 	s->range_start = 0;
 	s->range_end   = 0;
 
 	strbuf_insert(&ed->text, insert_pos, tmp.data, tmp.len);
 	s->buf_end = insert_pos + (int)tmp.len;
 	ed->files_count++;
 
 	strbuf_free(&tmp);
 	editor_unlock(ed);
 	return true;
 }
 
 bool editor_add_file_slot(Editor *ed, const char *path, const char *data, int len) {
 	editor_lock(ed);
 
 	int insert_pos = (int)ed->text.len;
 	if (ed->files_count > 0 && insert_pos > 0 &&
 	    ed->text.data[insert_pos - 1] != '\n') {
 		strbuf_insert(&ed->text, insert_pos, "\n", 1);
 		slots_on_insert(ed, insert_pos, 1);
 		insert_pos++;
 	}
 
 	files_grow(ed);
 	FileSlot *s = &ed->files[ed->files_count];
 	s->path        = path ? strdup(path) : NULL;
 	s->buf_start   = insert_pos;
 	s->dirty       = false;
 	s->has_range   = false;
 	s->range_start = 0;
 	s->range_end   = 0;
 
 	if (data && len > 0)
 		strbuf_insert(&ed->text, insert_pos, data, len);
 	s->buf_end = insert_pos + (len > 0 ? len : 0);
 	ed->files_count++;
 
 	editor_unlock(ed);
 	return true;
 }
 
 void editor_set_file_slot_range(Editor *ed, int idx, int start, int end) {
 	editor_lock(ed);
 	if (idx >= 0 && idx < ed->files_count) {
 		ed->files[idx].has_range   = true;
 		ed->files[idx].range_start = start;
 		ed->files[idx].range_end   = end;
 	}
 	editor_unlock(ed);
 }
 
 bool editor_write_file(Editor *ed, const char *filename) {
 	editor_lock(ed);
 
 	bool any = false;
 	if (filename) {
 		/* Write full buffer to explicit path (legacy / single-file) */
 		bool res = strbuf_write_file(&ed->text, filename);
 		editor_unlock(ed);
 		return res;
 	}
 
 	/* Save all dirty slots */
 	for (int i = 0; i < ed->files_count; i++) {
 		FileSlot *s = &ed->files[i];
 		if (!s->dirty || !s->path)
 			continue;
 		int slot_len = s->buf_end - s->buf_start;
 		/* Write only the slot's bytes */
 		StrBuf tmp;
 		strbuf_init(&tmp, slot_len + 1);
 		strbuf_insert(&tmp, 0, ed->text.data + s->buf_start, slot_len);
 		if (strbuf_write_file(&tmp, s->path)) {
 			s->dirty = false;
 			any = true;
 		}
 		strbuf_free(&tmp);
 	}
 
 	editor_unlock(ed);
 	return any;
 }
 static int utf8_char_to_byte_idx(const char *text, int char_idx) {
 
 	int byte_pos = 0;
 	int current_char = 0;
 	while (text[byte_pos] != '\0' && current_char < char_idx) {
 		// In UTF-8, leading bytes are not of the form 10xxxxxx (0x80)
 		if ((text[byte_pos] & 0xC0) != 0x80) {
 			current_char++;
 		}
 		byte_pos++;
 		// Skip over the rest of the multi-byte character
 		while (text[byte_pos] != '\0' &&
 		       (text[byte_pos] & 0xC0) == 0x80) {
 			byte_pos++;
 		}
 	}
 	return byte_pos;
 }
 void editor_add_formatting_range(Editor *ed, int start_char, int end_char,
 				 RangeFormat data) {
 
 	editor_lock(ed);
 
 	int start = utf8_char_to_byte_idx(ed->text.data, start_char);
 	int end = utf8_char_to_byte_idx(ed->text.data, end_char);
 
 	if (ed->ranges_count >= ed->ranges_capacity) {
 		ed->ranges_capacity =
 		    ed->ranges_capacity == 0 ? 16 : ed->ranges_capacity * 2;
 		ed->ranges = realloc(ed->ranges,
 				     ed->ranges_capacity * sizeof(EditorRange));
 	}
 
 	EditorRange r = {
 	    .start_byte = start, .end_byte = end, .type = RANGE_FORMAT};
 	r.data.format = data;
 
 	// Insert in sorted order
 	size_t i = ed->ranges_count;
 	while (i > 0 && ed->ranges[i - 1].start_byte > start) {
 		ed->ranges[i] = ed->ranges[i - 1];
 		i--;
 	}
 	ed->ranges[i] = r;
 	ed->ranges_count++;
 
 	editor_unlock(ed);
 }
 
 void editor_add_replace_range(Editor *ed, int start_char, int end_char,
 			      int visual_cols) {
 
 	editor_lock(ed);
 	int start = utf8_char_to_byte_idx(ed->text.data, start_char);
 	int end = utf8_char_to_byte_idx(ed->text.data, end_char);
 
 	if (ed->ranges_count >= ed->ranges_capacity) {
 		ed->ranges_capacity =
 		    ed->ranges_capacity == 0 ? 16 : ed->ranges_capacity * 2;
 		ed->ranges = realloc(ed->ranges,
 				     ed->ranges_capacity * sizeof(EditorRange));
 	}
 	EditorRange r = {start, end, RANGE_REPLACEMENT,
 			 .data.replacement = visual_cols};
 	// Insert in sorted order to allow binary search
 	size_t i = ed->ranges_count;
 	while (i > 0 && ed->ranges[i - 1].start_byte > start) {
 		ed->ranges[i] = ed->ranges[i - 1];
 		i--;
 	}
 	ed->ranges[i] = r;
 	ed->ranges_count++;
 
 	editor_unlock(ed);
 }
 
 EditorRange *editor_get_range_at(Editor *ed, int byte_idx) {
 	int left = 0;
 	int right = (int)ed->ranges_count - 1;
 
 	while (left <= right) {
 		int mid = left + (right - left) / 2;
 		EditorRange *r = &ed->ranges[mid];
 
 		if (byte_idx >= r->start_byte && byte_idx < r->end_byte) {
 			return r;
 		}
 
 		if (byte_idx < r->start_byte) {
 			right = mid - 1;
 		} else {
 			left = mid + 1;
 		}
 	}
 	return NULL;
 }
 
 EditorRange *editor_get_range_ending_at(Editor *ed, int byte_idx) {
 	int left = 0;
 	int right = (int)ed->ranges_count - 1;
 
 	while (left <= right) {
 		int mid = left + (right - left) / 2;
 		EditorRange *r = &ed->ranges[mid];
 
 		if (byte_idx == r->end_byte) {
 			return r;
 		}
 
 		if (byte_idx <= r->start_byte) {
 			right = mid - 1;
 		} else {
 			left = mid + 1;
 		}
 	}
 	return NULL;
 }
 
 void editor_goto_pos(Editor *ed, int pos) {
 
 	editor_lock(ed);
 	if (pos > ed->text.len) {
 		ed->cursor_idx = (int)ed->text.len;
 	} else {
 		ed->cursor_idx = pos;
 	}
 	editor_unlock(ed);
 }
 
 void editor_select_all(Editor *ed) {
 
 	editor_lock(ed);
 	ed->selection_anchor = 0;
 	editor_goto_pos(ed, ed->text.len);
 
 	editor_unlock(ed);
 }
 
 void editor_insert_text(Editor *ed, const char *text, bool replace) {
 
 	editor_lock(ed);
 
 	/* Capture pre-edit cursor state for the undo delta. */
 	int cursor_before = ed->cursor_idx;
 	int anchor_before = ed->selection_anchor;
 
 	/* If replacing a selection, compute the insertion point and save the
 	 * displaced bytes so the combined undo delta can restore them. */
 	int ins_pos = ed->cursor_idx;
 	char *saved = NULL;
 	size_t saved_len = 0;
 
 	if (replace && ed->cursor_idx != ed->selection_anchor) {
 		int sel_start = ed->cursor_idx < ed->selection_anchor
 				    ? ed->cursor_idx
 				    : ed->selection_anchor;
 		int sel_end = ed->cursor_idx > ed->selection_anchor
 				  ? ed->cursor_idx
 				  : ed->selection_anchor;
 		ins_pos = sel_start;
 		saved_len = (size_t)(sel_end - sel_start);
 		saved = malloc(saved_len + 1);
 		if (saved) {
 			memcpy(saved, ed->text.data + sel_start, saved_len);
 			saved[saved_len] = '\0';
 		}
 		delete_range_raw(ed, sel_start, sel_end);
 		/* delete_range_raw sets cursor_idx = ins_pos. */
 	}
 
 	size_t input_len = strlen(text);
 
 	/* One combined undo delta for the whole replace-and-insert. */
 	UndoDelta d = {
 	    .pos = ins_pos,
 	    .reinsert = saved,
 	    .reinsert_len = saved_len,
 	    .delete_len = input_len,
 	    .cursor_before = cursor_before,
 	    .anchor_before = anchor_before,
 	};
 	push_undo_delta(ed, d);
 
 	// Shift ranges affected by insertion
 	for (size_t i = 0; i < ed->ranges_count; i++) {
 		if (ed->ranges[i].start_byte >= ed->cursor_idx) {
 			ed->ranges[i].start_byte += input_len;
 			ed->ranges[i].end_byte += input_len;
 		} else if (ed->cursor_idx > ed->ranges[i].start_byte &&
 			   ed->cursor_idx < ed->ranges[i].end_byte) {
 			ed->ranges[i].end_byte += input_len;
 		}
 	}
 
 	// Shift file slot boundaries
 	slots_on_insert(ed, ed->cursor_idx, (int)input_len);
 
 	editor_unlock(ed);
 
 	strbuf_insert(&ed->text, ed->cursor_idx, text, input_len);
 	ed->cursor_idx += (int)input_len;
 	ed->selection_anchor = ed->cursor_idx;
 }
 
 void editor_newline(Editor *ed) { editor_insert_text(ed, "\n", true); }
 
 void editor_delete_range(Editor *ed, int start, int end) {
 
 	editor_lock(ed);
 	if (start == end) {
 		editor_unlock(ed);
 		return;
 	}
 	if (start > end) {
 		int tmp = start;
 		start = end;
 		end = tmp;
 	}
 
 	/* Capture displaced bytes and cursor state for undo. */
 	int len = end - start;
 	char *saved = malloc(len + 1);
 	if (saved) {
 		memcpy(saved, ed->text.data + start, len);
 		saved[len] = '\0';
 	}
 	UndoDelta d = {
 	    .pos = start,
 	    .reinsert = saved,
 	    .reinsert_len = (size_t)len,
 	    .delete_len = 0,
 	    .cursor_before = ed->cursor_idx,
 	    .anchor_before = ed->selection_anchor,
 	};
 	push_undo_delta(ed, d);
 
 	delete_range_raw(ed, start, end);
 
 	editor_unlock(ed);
 }
 
 void editor_delete_back(Editor *ed) {
 
 	editor_lock(ed);
 	if (ed->cursor_idx != ed->selection_anchor) {
 		editor_delete_range(ed, ed->selection_anchor, ed->cursor_idx);
 	} else if (ed->cursor_idx > 0) {
 		/* Hard boundary: cannot backspace across a file slot boundary */
 		for (int i = 1; i < ed->files_count; i++) {
 			if (ed->cursor_idx == ed->files[i].buf_start) {
 				editor_unlock(ed);
 				return;
 			}
 		}
 		int prev = ed->cursor_idx;
 		do {
 			prev--;
 		} while (prev > 0 && (ed->text.data[prev] & 0xC0) == 0x80);
 		editor_delete_range(ed, prev, ed->cursor_idx);
 	}
 
 	editor_unlock(ed);
 }
 
 void editor_delete_forward(Editor *ed) {
 
 	editor_lock(ed);
 	if (ed->cursor_idx != ed->selection_anchor) {
 		editor_delete_range(ed, ed->selection_anchor, ed->cursor_idx);
 	} else if (ed->cursor_idx < (int)ed->text.len) {
 		/* Hard boundary: cannot delete-forward across a file slot boundary */
 		for (int i = 0; i < ed->files_count - 1; i++) {
 			if (ed->cursor_idx == ed->files[i].buf_end) {
 				editor_unlock(ed);
 				return;
 			}
 		}
 		const char *ptr = ed->text.data + ed->cursor_idx;
 		const char *next = ptr;
 		SDL_StepUTF8(&next, NULL);
 		editor_delete_range(ed, ed->cursor_idx,
 				    (int)(next - ed->text.data));
 	}
 
 	editor_unlock(ed);
 }
 
 EditorRange *editor_get_replacement_at(Editor *ed, int byte_idx) {
 
 	for (size_t i = 0; i < ed->ranges_count; i++) {
 		EditorRange *r = &ed->ranges[i];
 		if (r->type == RANGE_REPLACEMENT && byte_idx >= r->start_byte &&
 		    byte_idx < r->end_byte) {
 			return r;
 		}
 	}
 	return NULL;
 }
 
 RangeFormat editor_get_format_at(Editor *ed, int byte_idx) {
 	RangeFormat fmt = {.bold = false, .italic = false};
 	for (size_t i = 0; i < ed->ranges_count; i++) {
 		EditorRange *r = &ed->ranges[i];
 		if (r->type == RANGE_FORMAT && byte_idx >= r->start_byte &&
 		    byte_idx < r->end_byte) {
 			if (r->data.format.bold)
 				fmt.bold = true;
 			if (r->data.format.italic)
 				fmt.italic = true;
 		}
 	}
 	return fmt;
 }
 
 void editor_cursor_left(Editor *ed) {
 
 	editor_lock(ed);
 	if (ed->cursor_idx > 0) {
 		// Are we standing at the end of a replacement?
 		// We need to look backwards to see if the previous byte is
 		// inside a replacement.
 		EditorRange *r =
 		    editor_get_replacement_at(ed, ed->cursor_idx - 1);
 		if (r && ed->cursor_idx == r->end_byte) {
 			ed->cursor_idx = r->start_byte; // Jump back over it
 		} else {
 			const char *ptr = ed->text.data;
 			const char *cur = ptr + ed->cursor_idx;
 			SDL_StepBackUTF8(ptr, &cur);
 			ed->cursor_idx = (int)(cur - ptr);
 		}
 	}
 
 	editor_unlock(ed);
 }
 
 void editor_cursor_right(Editor *ed) {
 
 	editor_lock(ed);
 	if (ed->cursor_idx < (int)ed->text.len) {
 		// Are we standing at the start of a replacement?
 		EditorRange *r = editor_get_replacement_at(ed, ed->cursor_idx);
 		if (r && ed->cursor_idx == r->start_byte) {
 			ed->cursor_idx = r->end_byte; // Jump over it
 		} else {
 			const char *ptr = ed->text.data + ed->cursor_idx;
 			SDL_StepUTF8(&ptr, NULL);
 			ed->cursor_idx = (int)(ptr - ed->text.data);
 		}
 	}
 	editor_unlock(ed);
 }
 
 void editor_clear_selection(Editor *ed) {
 
 	editor_lock(ed);
 	ed->selection_anchor = ed->cursor_idx;
 
 	editor_unlock(ed);
 }
 
 void editor_set_selection(Editor *ed, int anchor, int cursor) {
 	editor_lock(ed);
 	int tlen = (int)ed->text.len;
 	ed->selection_anchor = anchor > tlen ? tlen : anchor;
 	ed->cursor_idx       = cursor > tlen ? tlen : cursor;
 	editor_unlock(ed);
 }
 
 /* Return start of line containing pos (byte offset). */
 static int find_sol(const char *data, int pos) {
 	while (pos > 0 && data[pos - 1] != '\n')
 		pos--;
 	return pos;
 }
 
 /* True if the line at byte pos is blank (whitespace-only or just \n). */
 static bool line_is_blank(const char *data, int len, int pos) {
 	pos = find_sol(data, pos);
 	while (pos < len && data[pos] != '\n') {
 		if (data[pos] != ' ' && data[pos] != '\t' && data[pos] != '\r')
 			return false;
 		pos++;
 	}
 	return true;
 }
 
 void editor_expand_selection(Editor *ed, int level) {
 	if (level == 0) {
 		editor_select_word(ed);
 		return;
 	}
 	editor_lock(ed);
 	const char *data = ed->text.data;
 	int len = (int)ed->text.len;
 	int lo = ed->selection_anchor < ed->cursor_idx
 	             ? ed->selection_anchor : ed->cursor_idx;
 	int hi = ed->selection_anchor > ed->cursor_idx
 	             ? ed->selection_anchor : ed->cursor_idx;
 
 	if (level == 1) {
 		/* Backward to paragraph start */
 		{
 			int p = find_sol(data, lo);
 			while (p > 0) {
 				int prev_start = find_sol(data, p - 1);
 				if (line_is_blank(data, len, prev_start))
 					break;
 				p = prev_start;
 			}
 			lo = p;
 		}
 		/* Forward: to [.?!] + space/\n, or paragraph boundary */
 		bool found = false;
 		for (int p = hi; p < len; p++) {
 			if (data[p] == '\n') {
 				int next = p + 1;
 				if (next >= len || line_is_blank(data, len, next)) {
 					hi = p;
 					found = true;
 					break;
 				}
 			}
 			if ((data[p] == '.' || data[p] == '?' || data[p] == '!') &&
 			    (p + 1 >= len || data[p + 1] == ' ' || data[p + 1] == '\n')) {
 				hi = p + 1;
 				found = true;
 				break;
 			}
 		}
 		if (!found)
 			hi = len;
 	} else {
 		/* level >= 2: paragraph — blank-line boundaries */
 
 		/* Backward: walk lines upward until blank line or start */
 		{
 			int p = find_sol(data, lo);
 			while (p > 0) {
 				int prev_start = find_sol(data, p - 1);
 				if (line_is_blank(data, len, prev_start))
 					break;
 				p = prev_start;
 			}
 			lo = p;
 		}
 
 		/* Forward: walk lines downward until blank line or end */
 		{
 			int p = hi;
 			while (p < len) {
 				while (p < len && data[p] != '\n')
 					p++;
 				if (p >= len) {
 					hi = len;
 					break;
 				}
 				int next = p + 1;
 				if (next >= len) {
 					hi = len;
 					break;
 				}
 				if (line_is_blank(data, len, next)) {
 					hi = next; /* blank line's \n */
 					break;
 				}
 				p = next;
 			}
 			if (p >= len)
 				hi = len;
 		}
 
 		/* level >= 3: extend by one more paragraph per extra level */
 		for (int extra = 0; extra < level - 2; extra++) {
 			/* Extend lo backward past blank separator + prev paragraph */
 			if (lo > 0) {
 				int q = find_sol(data, lo - 1);
 				/* skip blank lines above */
 				while (q > 0 && line_is_blank(data, len, q))
 					q = find_sol(data, q - 1);
 				/* walk back through the non-blank paragraph above */
 				while (q > 0) {
 					int prev = find_sol(data, q - 1);
 					if (line_is_blank(data, len, prev))
 						break;
 					q = prev;
 				}
 				lo = q;
 			}
 			/* Extend hi forward past blank separator + next paragraph */
 			if (hi < len) {
 				int q = hi + 1;
 				/* skip blank lines below */
 				while (q < len && line_is_blank(data, len, q)) {
 					while (q < len && data[q] != '\n')
 						q++;
 					if (q < len) q++;
 				}
 				/* walk forward through the non-blank paragraph below */
 				while (q < len) {
 					while (q < len && data[q] != '\n')
 						q++;
 					if (q >= len) {
 						hi = len;
 						break;
 					}
 					int next = q + 1;
 					if (next >= len) {
 						hi = len;
 						break;
 					}
 					if (line_is_blank(data, len, next)) {
 						hi = next;
 						break;
 					}
 					q = next;
 				}
 				if (q >= len)
 					hi = len;
 			}
 		}
 	}
 
 	ed->selection_anchor = lo;
 	ed->cursor_idx = hi;
 	editor_unlock(ed);
 }
 
 void editor_cursor_up(Editor *ed) {
 
 	editor_lock(ed);
 	int line_start = ed->cursor_idx;
 	while (line_start > 0 && ed->text.data[line_start - 1] != '\n')
 		line_start--;
 
 	int visual_col = 0;
 	const char *p = ed->text.data + line_start;
 
 	while (p < ed->text.data + ed->cursor_idx) {
 		if (*p == '\t') {
 			visual_col += TAB_SIZE - (visual_col % TAB_SIZE);
 			SDL_StepUTF8(&p, NULL);
 		} else {
 			visual_col++;
 			SDL_StepUTF8(&p, NULL);
 		}
 	}
 
 	if (line_start > 0) {
 		int prev_line_end = line_start - 1;
 		int prev_line_start = prev_line_end;
 		while (prev_line_start > 0 &&
 		       ed->text.data[prev_line_start - 1] != '\n')
 			prev_line_start--;
 
 		const char *ptr = ed->text.data + prev_line_start;
 		for (int i = 0; i < visual_col && *ptr != '\n' && *ptr != '\0';
 		     i++)
 			SDL_StepUTF8(&ptr, NULL);
 		ed->cursor_idx = (int)(ptr - ed->text.data);
 	}
 
 	editor_unlock(ed);
 }
 
 void editor_cursor_down(Editor *ed) {
 
 	editor_lock(ed);
 	int line_start = ed->cursor_idx;
 	while (line_start > 0 && ed->text.data[line_start - 1] != '\n')
 		line_start--;
 
 	int visual_col = 0;
 	const char *p = ed->text.data + line_start;
 	while (p < ed->text.data + ed->cursor_idx) {
 		if (*p == '\t') {
 			visual_col += TAB_SIZE - (visual_col % TAB_SIZE);
 			SDL_StepUTF8(&p, NULL);
 		} else {
 			SDL_StepUTF8(&p, NULL);
 			visual_col++;
 		}
 	}
 
 	const char *next_line = strchr(ed->text.data + ed->cursor_idx, '\n');
 	if (next_line) {
 		int target_idx = (int)(next_line - ed->text.data) + 1;
 		const char *ptr = ed->text.data + target_idx;
 		for (int i = 0; i < visual_col; i++) {
 			if (*ptr == '\n' || *ptr == '\0')
 				break;
 			SDL_StepUTF8(&ptr, NULL);
 		}
 		ed->cursor_idx = (int)(ptr - ed->text.data);
 	}
 
 	editor_unlock(ed);
 }
 
 void editor_set_cursor_from_coords(Editor *ed, float mx, float my,
 				   float scroll_x, float scroll_y) {
 
 	editor_lock(ed);
 	int target_col =
 	    (int)((mx - 20.0f + scroll_x + (ed->char_width / 2.0f)) /
 		  ed->char_width);
 	int target_row = (int)((my - 20.0f + scroll_y) / ed->line_height);
 
 	int cur_r = 0, cur_c = 0;
 	const char *ptr = ed->text.data;
 	const char *last_ptr = ed->text.data;
 
 	while (*ptr != '\0') {
 		int current_idx = (int)(ptr - ed->text.data);
 		if (cur_r == target_row && cur_c >= target_col)
 			break;
 
 		last_ptr = ptr;
 
 		EditorRange *r = editor_get_range_at(ed, current_idx);
 		if (r && r->type == RANGE_REPLACEMENT) {
 			cur_c += r->data.replacement.visual_cols;
 			ptr = ed->text.data + r->end_byte; // Skip pointer ahead
 			continue;
 		}
 
 		// --- Standard UTF-8 / Tab logic ---
 		Uint32 cp = SDL_StepUTF8(&ptr, NULL);
 		if (cp == '\t') {
 			cur_c += TAB_SIZE - (cur_c % TAB_SIZE);
 		} else if (cp == '\n') {
 			if (cur_r == target_row) {
 				ptr = last_ptr;
 				break;
 			}
 			cur_r++;
 			cur_c = 0;
 		} else {
 			cur_c++;
 		}
 
 		if (cur_r > target_row) {
 			ptr = last_ptr;
 			break;
 		}
 	}
 	ed->cursor_idx = (int)(ptr - ed->text.data);
 
 	editor_unlock(ed);
 }
 
 static bool is_word_char(char c) {
 	if (c == '\0')
 		return false;
 	// For plumbing, we select everything except standard whitespace
 	return !isspace((unsigned char)c);
 }
 
 void editor_goto_word_start(Editor *ed) {
 
 	editor_lock(ed);
 	if (ed->text.len == 0)
 		return;
 
 	int start = ed->cursor_idx;
 	if (start > 0 && !is_word_char(ed->text.data[start])) {
 		if (is_word_char(ed->text.data[start - 1])) {
 			start--;
 		}
 	}
 	while (start > 0 && is_word_char(ed->text.data[start - 1])) {
 		start--;
 	}
 	ed->cursor_idx = start;
 
 	editor_unlock(ed);
 }
 
 void editor_select_word(Editor *ed) {
 
 	editor_lock(ed);
 	if (ed->text.len == 0)
 		return;
 
 	int start = ed->cursor_idx;
 	int end = ed->cursor_idx;
 
 	if (start > 0 && !is_word_char(ed->text.data[start])) {
 		if (is_word_char(ed->text.data[start - 1])) {
 			start--;
 			end--;
 		}
 	}
 
 	// Only proceed if we are actually on a word character
 	if (!is_word_char(ed->text.data[start]))
 		return;
 
 	// Expand left
 	while (start > 0 && is_word_char(ed->text.data[start - 1])) {
 		start--;
 	}
 
 	// Expand right
 	while (end < (int)ed->text.len && is_word_char(ed->text.data[end])) {
 		end++;
 	}
 
 	ed->selection_anchor = start;
 	ed->cursor_idx = end;
 
 	editor_unlock(ed);
 }
 
 bool editor_has_selection(Editor *ed) {
 	return ed->selection_anchor != ed->cursor_idx;
 }
 
 VisualPos editor_byte_to_visual_pos(const Editor *ed, int byte_idx) {
 	VisualPos pos = {0, 0};
 	const char *ptr = ed->text.data;
 	while (ptr < ed->text.data + byte_idx) {
 		int current_idx = (int)(ptr - ed->text.data);
 		EditorRange *r =
 		    editor_get_replacement_at((Editor *)ed, current_idx);
 		if (r) {
 			pos.col += r->data.replacement.visual_cols;
 			ptr = ed->text.data + r->end_byte;
 			continue;
 		}
 		Uint32 cp = SDL_StepUTF8(&ptr, NULL);
 		if (cp == '\t') {
 			pos.col += TAB_SIZE - (pos.col % TAB_SIZE);
 		} else if (cp == '\n') {
 			pos.row++;
 			pos.col = 0;
 		} else {
 			pos.col++;
 		}
 	}
 	return pos;
 }
 
 int editor_visual_pos_to_byte(const Editor *ed, VisualPos target) {
 	int row = 0, col = 0;
 	const char *ptr = ed->text.data;
 	const char *end = ed->text.data + ed->text.len;
 
 	while (ptr < end) {
 		if (row == target.row && col >= target.col)
 			return (int)(ptr - ed->text.data);
 
 		int current_idx = (int)(ptr - ed->text.data);
 		EditorRange *r =
 		    editor_get_replacement_at((Editor *)ed, current_idx);
 		if (r) {
 			col += r->data.replacement.visual_cols;
 			ptr = ed->text.data + r->end_byte;
 			continue;
 		}
 
 		const char *prev = ptr;
 		Uint32 cp = SDL_StepUTF8(&ptr, NULL);
 		if (cp == '\n') {
 			if (row == target.row)
 				return (int)(prev - ed->text.data);
 			row++;
 			col = 0;
 		} else if (cp == '\t') {
 			col += TAB_SIZE - (col % TAB_SIZE);
 		} else {
 			col++;
 		}
 	}
 	return (int)(end - ed->text.data);
 }
 
 char *editor_get_selection(Editor *ed) {
 	if (ed->cursor_idx == ed->selection_anchor)
 		return NULL;
 
 	int start = (ed->cursor_idx < ed->selection_anchor)
 			? ed->cursor_idx
 			: ed->selection_anchor;
 	int end = (ed->cursor_idx > ed->selection_anchor)
 		      ? ed->cursor_idx
 		      : ed->selection_anchor;
 	int len = end - start;
 
 	char *result = malloc(len + 1);
 	if (!result)
 		return NULL;
 
 	memcpy(result, &ed->text.data[start], len);
 	result[len] = '\0';
 	return result;
 }
 
 static int byte_to_utf8_char_idx(const char *text, int byte_limit) {
 	int char_idx = 0;
 	for (int i = 0; i < byte_limit && text[i] != '\0'; i++) {
 		if ((text[i] & 0xC0) != 0x80)
 			char_idx++;
 	}
 	return char_idx;
 }
 
 void editor_undo(Editor *ed) {
 	editor_lock(ed);
 	if (ed->undo_len == 0) {
 		editor_unlock(ed);
 		return;
 	}
 	UndoDelta d = ed->undo_stack[--ed->undo_len];
 	UndoDelta rev = {0};
 	apply_delta(ed, &d, &rev);
 	free(d.reinsert);
 	if (ed->redo_len < UNDO_MAX)
 		ed->redo_stack[ed->redo_len++] = rev;
 	else
 		free(rev.reinsert);
 	editor_unlock(ed);
 }
 
 void editor_redo(Editor *ed) {
 	editor_lock(ed);
 	if (ed->redo_len == 0) {
 		editor_unlock(ed);
 		return;
 	}
 	UndoDelta d = ed->redo_stack[--ed->redo_len];
 	UndoDelta rev = {0};
 	apply_delta(ed, &d, &rev);
 	free(d.reinsert);
 	if (ed->undo_len < UNDO_MAX)
 		ed->undo_stack[ed->undo_len++] = rev;
 	else
 		free(rev.reinsert);
 	editor_unlock(ed);
 }
 
 void editor_replace_body(Editor *ed, const char *data, size_t len) {
 	editor_lock(ed);
 
 	size_t old_len = ed->text.len;
 	char *saved = malloc(old_len + 1);
 	if (saved) {
 		memcpy(saved, ed->text.data, old_len);
 		saved[old_len] = '\0';
 	}
 	UndoDelta d = {
 	    .pos = 0,
 	    .reinsert = saved,
 	    .reinsert_len = old_len,
 	    .delete_len = len,
 	    .cursor_before = ed->cursor_idx,
 	    .anchor_before = ed->selection_anchor,
 	};
 	push_undo_delta(ed, d);
 
 	ed->ranges_count = 0;
 	strbuf_delete(&ed->text, 0, ed->text.len);
 	strbuf_insert(&ed->text, 0, data ? data : "", len);
 	ed->cursor_idx = 0;
 	ed->selection_anchor = 0;
 
 	editor_unlock(ed);
 	editor_parse_ansi_codes(ed);
 }
 
 void editor_parse_ansi_codes(Editor *ed) {
 	editor_lock(ed);
 	ed->ranges_count = 0;
 
 	const char *data = ed->text.data;
 	size_t len = ed->text.len;
 
 	RangeFormat current_fmt = {.bold = false, .italic = false};
 	int last_segment_start_byte = 0;
 
 	for (int i = 0; i < (int)len; i++) {
 		if (data[i] == '\x1b' && i + 1 < len && data[i + 1] == '[') {
 
 			if (i > last_segment_start_byte) {
 				if (current_fmt.bold || current_fmt.italic) {
 					// We temporarily unlock because
 					// editor_add_formatting_range locks
 					editor_unlock(ed);
 					editor_add_formatting_range(
 					    ed,
 					    byte_to_utf8_char_idx(
 						data, last_segment_start_byte),
 					    byte_to_utf8_char_idx(data, i),
 					    current_fmt);
 					editor_lock(ed);
 					// Re-evaluate data ptr in case buffer
 					// moved (unlikely here but good
 					// practice)
 					data = ed->text.data;
 				}
 			}
 
 			int seq_start = i;
 			int seq_end = i + 2;
 			while (seq_end < len && data[seq_end] != 'm')
 				seq_end++;
 
 			if (seq_end < len && data[seq_end] == 'm') {
 				for (int p = seq_start + 2; p < seq_end;) {
 					int val = atoi(&data[p]);
 					if (val == 0) {
 						current_fmt.bold = false;
 						current_fmt.italic = false;
 					} else if (val == 1) {
 						current_fmt.bold = true;
 					} else if (val == 3) {
 						current_fmt.italic = true;
 					} else if (val == 22) {
 						current_fmt.bold = false;
 					} else if (val == 23) {
 						current_fmt.italic = false;
 					}
 
 					while (p < seq_end && (data[p] >= '0' &&
 							       data[p] <= '9'))
 						p++;
 					if (p < seq_end && data[p] == ';')
 						p++;
 				}
 
 				editor_unlock(ed);
 				editor_add_replace_range(
 				    ed, byte_to_utf8_char_idx(data, seq_start),
 				    byte_to_utf8_char_idx(data, seq_end + 1),
 				    0);
 				editor_lock(ed);
 				data = ed->text.data;
 
 				i = seq_end;
 				last_segment_start_byte = i + 1;
 			}
 		}
 	}
 
 	if (last_segment_start_byte < len) {
 		if (current_fmt.bold || current_fmt.italic) {
 			editor_unlock(ed);
 			editor_add_formatting_range(
 			    ed,
 			    byte_to_utf8_char_idx(data,
 						  last_segment_start_byte),
 			    byte_to_utf8_char_idx(data, len), current_fmt);
 			editor_lock(ed);
 		}
 	}
 	editor_unlock(ed);
 }