Implement branching undo system with tests and updates.

- Added branching model for undo/redo, enabling multiple redo paths and branch selection.
- Updated `UndoNode` to include `parent` and refined hierarchical navigation.
- Extended `UndoSystem` with branching logic for redo operations, supporting sibling branch selection.
- Overhauled tests to validate branching behavior and tree invariants.
- Refined editor command logic for undo/redo with repeat counts and branch selection.
- Enabled test-only introspection hooks for undo tree validation.
- Updated CMake to include test definitions (`KTE_TESTS` flag).

Buffer.cc

@@ -412,6 +412,7 @@ Buffer::GetLineView(std::size_t row) const
 void
 Buffer::ensure_rows_cache() const
 {
+	std::lock_guard<std::mutex> lock(buffer_mutex_);
 	if (!rows_cache_dirty_)
 		return;
 	rows_.clear();

Buffer.h

@@ -14,6 +14,7 @@
 #include <cstdint>
 #include "syntax/HighlighterEngine.h"
 #include "Highlight.h"
+#include <mutex>
 
 // Forward declaration for swap journal integration
 namespace kte {
@@ -369,6 +370,54 @@ public:
 	}
 
 
+	// Visual-line selection support (multicursor/visual mode)
+	void VisualLineClear()
+	{
+		visual_line_active_ = false;
+	}
+
+
+	void VisualLineStart()
+	{
+		visual_line_active_   = true;
+		visual_line_anchor_y_ = cury_;
+		visual_line_active_y_ = cury_;
+	}
+
+
+	void VisualLineToggle()
+	{
+		if (visual_line_active_)
+			VisualLineClear();
+		else
+			VisualLineStart();
+	}
+
+
+	[[nodiscard]] bool VisualLineActive() const
+	{
+		return visual_line_active_;
+	}
+
+
+	void VisualLineSetActiveY(std::size_t y)
+	{
+		visual_line_active_y_ = y;
+	}
+
+
+	[[nodiscard]] std::size_t VisualLineStartY() const
+	{
+		return visual_line_anchor_y_ < visual_line_active_y_ ? visual_line_anchor_y_ : visual_line_active_y_;
+	}
+
+
+	[[nodiscard]] std::size_t VisualLineEndY() const
+	{
+		return visual_line_anchor_y_ < visual_line_active_y_ ? visual_line_active_y_ : visual_line_anchor_y_;
+	}
+
+
 	[[nodiscard]] std::string AsString() const;
 
 	// Syntax highlighting integration (per-buffer)
@@ -470,6 +519,9 @@ private:
 	bool read_only_                   = false;
 	bool mark_set_                    = false;
 	std::size_t mark_curx_            = 0, mark_cury_ = 0;
+	bool visual_line_active_          = false;
+	std::size_t visual_line_anchor_y_ = 0;
+	std::size_t visual_line_active_y_ = 0;
 
 	// Per-buffer undo state
 	std::unique_ptr<struct UndoTree> undo_tree_;
@@ -482,4 +534,6 @@ private:
 	std::unique_ptr<kte::HighlighterEngine> highlighter_;
 	// Non-owning pointer to swap recorder managed by Editor/SwapManager
 	kte::SwapRecorder *swap_rec_ = nullptr;
+
+	mutable std::mutex buffer_mutex_;
 };

CMakeLists.txt

@@ -4,7 +4,7 @@ project(kte)
 include(GNUInstallDirs)
 
 set(CMAKE_CXX_STANDARD 20)
-set(KTE_VERSION "1.5.6")
+set(KTE_VERSION "1.6.0")
 
 # Default to terminal-only build to avoid SDL/OpenGL dependency by default.
 # Enable with -DBUILD_GUI=ON when SDL2/OpenGL/Freetype are available.
@@ -301,10 +301,17 @@ if (BUILD_TESTS)
             tests/test_buffer_io.cc
             tests/test_piece_table.cc
             tests/test_search.cc
+            tests/test_reflow_paragraph.cc
+            tests/test_undo.cc
+            tests/test_visual_line_mode.cc
 
             # minimal engine sources required by Buffer
             PieceTable.cc
             Buffer.cc
+            Editor.cc
+            Command.cc
+            HelpText.cc
+            Swap.cc
             OptimizedSearch.cc
             UndoNode.cc
             UndoTree.cc
@@ -312,6 +319,9 @@ if (BUILD_TESTS)
             ${SYNTAX_SOURCES}
     )
 
+    # Allow test-only introspection hooks (guarded in headers) without affecting production builds.
+    target_compile_definitions(kte_tests PRIVATE KTE_TESTS=1)
+
     # Allow tests to include project headers like "Buffer.h"
     target_include_directories(kte_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 

Command.cc

@@ -761,6 +761,15 @@ cmd_quit_now(CommandContext &ctx)
 static bool
 cmd_refresh(CommandContext &ctx)
 {
+	// C-g is mapped to Refresh and acts as a general cancel key.
+	// Cancel visual-line (multicursor) mode if active.
+	if (Buffer *buf = ctx.editor.CurrentBuffer()) {
+		if (buf->VisualLineActive()) {
+			buf->VisualLineClear();
+			ctx.editor.SetStatus("Visual line: OFF");
+			return true;
+		}
+	}
 	// If a generic prompt is active, cancel it
 	if (ctx.editor.PromptActive()) {
 		// If also in search mode, restore state
@@ -1970,28 +1979,52 @@ cmd_insert_text(CommandContext &ctx)
 	ensure_at_least_one_line(*buf);
 	std::size_t y  = buf->Cury();
 	std::size_t x  = buf->Curx();
-	std::size_t ins_y = y;
-	std::size_t ins_x = x; // remember insertion start for undo positioning
 	int repeat     = ctx.count > 0 ? ctx.count : 1;
+	std::size_t cx = x;
+	std::size_t cy = y;
 
+	// Visual-line mode: broadcast inserts to each selected line at the same column.
+	if (buf->VisualLineActive()) {
+		const std::size_t sy = buf->VisualLineStartY();
+		const std::size_t ey = buf->VisualLineEndY();
+		const auto &rows     = buf->Rows();
+		for (std::size_t yy = sy; yy <= ey; ++yy) {
+			if (yy >= rows.size())
+				break;
+			std::size_t xx = x;
+			if (xx > rows[yy].size())
+				xx = rows[yy].size();
+			for (int i = 0; i < repeat; ++i) {
+				buf->insert_text(static_cast<int>(yy), static_cast<int>(xx), std::string_view(ctx.arg));
+				xx += ctx.arg.size();
+			}
+			if (yy == y) {
+				cx = xx;
+				cy = yy;
+			}
+		}
+		buf->SetDirty(true);
+		buf->SetCursor(cx, cy);
+		ensure_cursor_visible(ctx.editor, *buf);
+		return true;
+	}
+
+	UndoSystem *u = buf->Undo();
+	if (u) {
+		// Start/extend a typed-run batch. Do NOT commit here; commit happens on boundaries
+		// (cursor movement, prompts, undo/redo, etc.) so consecutive InsertText commands coalesce.
+		buf->SetCursor(x, y);
+		u->Begin(UndoType::Insert);
+	}
 	// Apply edits to the underlying PieceTable through Buffer::insert_text,
 	// not directly to the legacy rows_ cache. This ensures Save() persists text.
 	for (int i = 0; i < repeat; ++i) {
 		buf->insert_text(static_cast<int>(y), static_cast<int>(x), std::string_view(ctx.arg));
+		if (u)
+			u->Append(std::string_view(ctx.arg));
 		x += ctx.arg.size();
 	}
 	buf->SetDirty(true);
-	// Record undo for this contiguous insert at the original insertion point
-	if (auto *u = buf->Undo()) {
-		// Position cursor at insertion start for the undo record
-		buf->SetCursor(ins_x, ins_y);
-		u->Begin(UndoType::Insert);
-		for (int i = 0; i < repeat; ++i) {
-			u->Append(std::string_view(ctx.arg));
-		}
-		// Finalize this contiguous insert as a single undoable action
-		u->commit();
-	}
 	buf->SetCursor(x, y);
 	ensure_cursor_visible(ctx.editor, *buf);
 	return true;
@@ -2784,6 +2817,41 @@ cmd_newline(CommandContext &ctx)
 	std::size_t y = buf->Cury();
 	std::size_t x = buf->Curx();
 	int repeat    = ctx.count > 0 ? ctx.count : 1;
+
+	// Visual-line mode: broadcast newline splits across selected lines.
+	if (buf->VisualLineActive()) {
+		const std::size_t sy = buf->VisualLineStartY();
+		const std::size_t ey = buf->VisualLineEndY();
+		const auto &rows     = buf->Rows();
+		if (rows.empty())
+			return true;
+		std::size_t splits_above = 0;
+		if (sy < y)
+			splits_above = std::min(ey, y - 1) - sy + 1;
+
+		// Iterate bottom-up to keep row indices stable while splitting.
+		for (std::size_t yy = ey + 1; yy-- > sy;) {
+			const auto &rows_view = buf->Rows();
+			if (yy >= rows_view.size())
+				continue;
+			std::size_t xx = x;
+			if (xx > rows_view[yy].size())
+				xx = rows_view[yy].size();
+			// First split at the cursor column; subsequent splits create blank lines.
+			buf->split_line(static_cast<int>(yy), static_cast<int>(xx));
+			for (int i = 1; i < repeat; ++i) {
+				buf->split_line(static_cast<int>(yy + i), 0);
+			}
+		}
+
+		buf->SetDirty(true);
+		// Cursor: end up on the final inserted line for the original cursor line.
+		std::size_t new_y = y + static_cast<std::size_t>(repeat);
+		new_y             += splits_above;
+		buf->SetCursor(0, new_y);
+		ensure_cursor_visible(ctx.editor, *buf);
+		return true;
+	}
 	for (int i = 0; i < repeat; ++i) {
 		buf->split_line(static_cast<int>(y), static_cast<int>(x));
 		// Move to start of next line
@@ -2858,6 +2926,35 @@ cmd_backspace(CommandContext &ctx)
 	std::size_t x = buf->Curx();
 	UndoSystem *u = buf->Undo();
 	int repeat    = ctx.count > 0 ? ctx.count : 1;
+
+	// Visual-line mode: broadcast backspace deletes within each selected line.
+	// For now, we do NOT join lines when at column 0 (too ambiguous across multiple lines).
+	if (buf->VisualLineActive()) {
+		const std::size_t sy = buf->VisualLineStartY();
+		const std::size_t ey = buf->VisualLineEndY();
+		const auto &rows     = buf->Rows();
+		std::size_t cx       = x;
+		for (std::size_t yy = sy; yy <= ey; ++yy) {
+			if (yy >= rows.size())
+				break;
+			std::size_t xx = x;
+			if (xx > rows[yy].size())
+				xx = rows[yy].size();
+			for (int i = 0; i < repeat; ++i) {
+				if (xx == 0)
+					break;
+				buf->delete_text(static_cast<int>(yy), static_cast<int>(xx - 1), 1);
+				--xx;
+			}
+			if (yy == y)
+				cx = xx;
+		}
+		buf->SetDirty(true);
+		buf->SetCursor(cx, y);
+		ensure_cursor_visible(ctx.editor, *buf);
+		(void) u;
+		return true;
+	}
 	for (int i = 0; i < repeat; ++i) {
 		// Refresh a read-only view of lines for char capture/lengths
 		const auto &rows_view = buf->Rows();
@@ -2910,6 +3007,30 @@ cmd_delete_char(CommandContext &ctx)
 	std::size_t x = buf->Curx();
 	UndoSystem *u = buf->Undo();
 	int repeat    = ctx.count > 0 ? ctx.count : 1;
+
+	// Visual-line mode: broadcast delete-char within each selected line.
+	// For now, we do NOT join lines when at end-of-line.
+	if (buf->VisualLineActive()) {
+		const std::size_t sy = buf->VisualLineStartY();
+		const std::size_t ey = buf->VisualLineEndY();
+		const auto &rows     = buf->Rows();
+		for (std::size_t yy = sy; yy <= ey; ++yy) {
+			if (yy >= rows.size())
+				break;
+			std::size_t xx = x;
+			if (xx > rows[yy].size())
+				xx = rows[yy].size();
+			for (int i = 0; i < repeat; ++i) {
+				if (xx >= buf->Rows()[yy].size())
+					break;
+				buf->delete_text(static_cast<int>(yy), static_cast<int>(xx), 1);
+			}
+		}
+		buf->SetDirty(true);
+		ensure_cursor_visible(ctx.editor, *buf);
+		(void) u;
+		return true;
+	}
 	for (int i = 0; i < repeat; ++i) {
 		const auto &rows_view = buf->Rows();
 		if (y >= rows_view.size())
@@ -2947,6 +3068,8 @@ cmd_undo(CommandContext &ctx)
 	if (auto *u = buf->Undo()) {
 		// Ensure pending batch is finalized so it can be undone
 		u->commit();
+		int repeat = ctx.count > 0 ? ctx.count : 1;
+		for (int i = 0; i < repeat; ++i)
 			u->undo();
 		// Keep cursor within buffer bounds
 		ensure_cursor_visible(ctx.editor, *buf);
@@ -2966,7 +3089,14 @@ cmd_redo(CommandContext &ctx)
 	if (auto *u = buf->Undo()) {
 		// Finalize any pending batch before redoing
 		u->commit();
+		// With branching undo, a universal-argument count selects an alternate redo branch:
+		//  - no count (or 1): redo the active branch
+		//  - n>1: redo the (n-1)th sibling branch from this point and make it active
+		if (ctx.count > 1) {
+			u->redo(ctx.count - 1);
+		} else {
 			u->redo();
+		}
 		ensure_cursor_visible(ctx.editor, *buf);
 		ctx.editor.SetStatus("Redone");
 		return true;
@@ -3091,6 +3221,10 @@ cmd_yank(CommandContext &ctx)
 	for (int i = 0; i < repeat; ++i) {
 		insert_text_at_cursor(*buf, text);
 	}
+	// Yank is a paste operation; it should clear the mark/region and any selection highlighting.
+	buf->ClearMark();
+	if (buf->VisualLineActive())
+		buf->VisualLineClear();
 	ensure_cursor_visible(ctx.editor, *buf);
 	// Start a new kill chain only from kill commands; yanking should break it
 	ctx.editor.SetKillChain(false);
@@ -3107,6 +3241,8 @@ cmd_move_file_start(CommandContext &ctx)
 		return false;
 	ensure_at_least_one_line(*buf);
 	buf->SetCursor(0, 0);
+	if (buf->VisualLineActive())
+		buf->VisualLineSetActiveY(buf->Cury());
 	ensure_cursor_visible(ctx.editor, *buf);
 	return true;
 }
@@ -3123,6 +3259,8 @@ cmd_move_file_end(CommandContext &ctx)
 	std::size_t y    = rows.empty() ? 0 : rows.size() - 1;
 	std::size_t x    = rows.empty() ? 0 : rows[y].size();
 	buf->SetCursor(x, y);
+	if (buf->VisualLineActive())
+		buf->VisualLineSetActiveY(buf->Cury());
 	ensure_cursor_visible(ctx.editor, *buf);
 	return true;
 }
@@ -3145,6 +3283,18 @@ cmd_toggle_mark(CommandContext &ctx)
 }
 
 
+static bool
+cmd_visual_line_mode_toggle(CommandContext &ctx)
+{
+	Buffer *buf = ctx.editor.CurrentBuffer();
+	if (!buf)
+		return false;
+	buf->VisualLineToggle();
+	ctx.editor.SetStatus(std::string("Visual line: ") + (buf->VisualLineActive() ? "ON" : "OFF"));
+	return true;
+}
+
+
 static bool
 cmd_jump_to_mark(CommandContext &ctx)
 {
@@ -3306,6 +3456,8 @@ cmd_move_left(CommandContext &ctx)
 		}
 	}
 	buf->SetCursor(x, y);
+	if (buf->VisualLineActive())
+		buf->VisualLineSetActiveY(buf->Cury());
 	ensure_cursor_visible(ctx.editor, *buf);
 	return true;
 }
@@ -3383,6 +3535,8 @@ cmd_move_right(CommandContext &ctx)
 		}
 	}
 	buf->SetCursor(x, y);
+	if (buf->VisualLineActive())
+		buf->VisualLineSetActiveY(buf->Cury());
 	ensure_cursor_visible(ctx.editor, *buf);
 	return true;
 }
@@ -3423,6 +3577,8 @@ cmd_move_up(CommandContext &ctx)
 	if (x > rows[y].size())
 		x = rows[y].size();
 	buf->SetCursor(x, y);
+	if (buf->VisualLineActive())
+		buf->VisualLineSetActiveY(buf->Cury());
 	ensure_cursor_visible(ctx.editor, *buf);
 	return true;
 }
@@ -3464,6 +3620,8 @@ cmd_move_down(CommandContext &ctx)
 	if (x > rows[y].size())
 		x = rows[y].size();
 	buf->SetCursor(x, y);
+	if (buf->VisualLineActive())
+		buf->VisualLineSetActiveY(buf->Cury());
 	ensure_cursor_visible(ctx.editor, *buf);
 	return true;
 }
@@ -4026,6 +4184,29 @@ cmd_reflow_paragraph(CommandContext &ctx)
 		return false;
 	};
 
+	auto is_numbered_line = [&](const std::string &s,
+	                            std::string &indent_out,
+	                            std::string &marker_out,
+	                            std::size_t &after_prefix_idx) -> bool {
+		indent_out    = leading_ws(s);
+		std::size_t i = indent_out.size();
+		if (i >= s.size() || !std::isdigit(static_cast<unsigned char>(s[i])))
+			return false;
+		std::size_t j = i;
+		while (j < s.size() && std::isdigit(static_cast<unsigned char>(s[j])))
+			++j;
+		if (j >= s.size())
+			return false;
+		char delim = s[j];
+		if (!(delim == '.' || delim == ')'))
+			return false;
+		if (j + 1 >= s.size() || s[j + 1] != ' ')
+			return false;
+		marker_out       = s.substr(i, (j - i) + 1); // e.g. "1." or "10)"
+		after_prefix_idx = j + 2; // after delimiter + space
+		return true;
+	};
+
 	auto normalize_spaces = [](const std::string &in) {
 		std::string out;
 		out.reserve(in.size());
@@ -4107,20 +4288,25 @@ cmd_reflow_paragraph(CommandContext &ctx)
 
 	std::vector<std::string> new_lines;
 
-	// Determine if this region looks like a list: any line starting with bullet
-	bool region_has_bullet = false;
+	// Determine if this region looks like a list: any line starting with bullet or number
+	bool region_has_list = false;
 	for (std::size_t i = para_start; i <= para_end; ++i) {
 		std::string s = static_cast<std::string>(rows[i]);
 		std::string indent;
 		char marker;
 		std::size_t idx;
 		if (is_bullet_line(s, indent, marker, idx)) {
-			region_has_bullet = true;
+			region_has_list = true;
+			break;
+		}
+		std::string nmarker;
+		if (is_numbered_line(s, indent, nmarker, idx)) {
+			region_has_list = true;
 			break;
 		}
 	}
 
-	if (region_has_bullet) {
+	if (region_has_list) {
 		// Parse as list items; support hanging indent continuations
 		for (std::size_t i = para_start; i <= para_end; ++i) {
 			std::string s = static_cast<std::string>(rows[i]);
@@ -4148,12 +4334,46 @@ cmd_reflow_paragraph(CommandContext &ctx)
 					if (is_bullet_line(ns, nindent, nmarker, nidx)) {
 						break; // next item
 					}
+					std::string nnmarker;
+					if (is_numbered_line(ns, nindent, nnmarker, nidx)) {
+						break; // next item
+					}
 					// Not a continuation and not a bullet: stop (treat as separate paragraph chunk)
 					break;
 				}
 				content = normalize_spaces(content);
 				wrap_with_prefixes(content, first_prefix, cont_prefix, width, new_lines);
 				i = j - 1; // advance
+			} else {
+				std::string nmarker;
+				if (is_numbered_line(s, indent, nmarker, after_idx)) {
+					std::string first_prefix = indent + nmarker + " ";
+					std::string cont_prefix  = indent + std::string(nmarker.size() + 1, ' ');
+					std::string content      = s.substr(after_idx);
+					// consume continuation lines that are part of this numbered item
+					std::size_t j = i + 1;
+					while (j <= para_end) {
+						std::string ns = static_cast<std::string>(rows[j]);
+						if (starts_with(ns, cont_prefix)) {
+							content += ' ';
+							content += ns.substr(cont_prefix.size());
+							++j;
+							continue;
+						}
+						// stop if next item
+						std::string nindent2;
+						char bmarker;
+						std::size_t nidx;
+						if (is_bullet_line(ns, nindent2, bmarker, nidx))
+							break;
+						std::string nnmarker;
+						if (is_numbered_line(ns, nindent2, nnmarker, nidx))
+							break;
+						break;
+					}
+					content = normalize_spaces(content);
+					wrap_with_prefixes(content, first_prefix, cont_prefix, width, new_lines);
+					i = j - 1;
 				} else {
 					// A non-bullet line within a list region; treat as its own wrapped paragraph preserving its indent
 					std::string base_indent = leading_ws(s);
@@ -4168,6 +4388,10 @@ cmd_reflow_paragraph(CommandContext &ctx)
 						if (is_bullet_line(ns, tmp_indent, tmp_marker, tmp_idx)) {
 							break; // next bullet starts
 						}
+						std::string tmp_nmarker;
+						if (is_numbered_line(ns, tmp_indent, tmp_nmarker, tmp_idx)) {
+							break; // next numbered starts
+						}
 						if (nindent.size() >= base_indent.size()) {
 							content += ' ';
 							content += ns.substr(base_indent.size());
@@ -4181,6 +4405,7 @@ cmd_reflow_paragraph(CommandContext &ctx)
 					i = j - 1;
 				}
 			}
+		}
 	} else {
 		// Normal paragraph: preserve indentation of first line
 		std::string s0  = static_cast<std::string>(rows[para_start]);
@@ -4396,6 +4621,10 @@ InstallDefaultCommands()
 	});
 	CommandRegistry::Register({CommandId::MoveFileEnd, "file-end", "Move to end of file", cmd_move_file_end});
 	CommandRegistry::Register({CommandId::ToggleMark, "toggle-mark", "Toggle mark at cursor", cmd_toggle_mark});
+	CommandRegistry::Register({
+		CommandId::VisualLineModeToggle, "visual-line-toggle", "Toggle visual-line (multicursor) mode",
+		cmd_visual_line_mode_toggle, false, false
+	});
 	CommandRegistry::Register({
 		CommandId::JumpToMark, "jump-to-mark", "Jump to mark (swap mark)", cmd_jump_to_mark
 	});

Command.h

@@ -47,6 +47,7 @@ enum class CommandId {
 	MoveFileStart, // move to beginning of file
 	MoveFileEnd, // move to end of file
 	ToggleMark, // toggle mark at cursor
+	VisualLineModeToggle, // toggle visual-line (multicursor) mode (C-k /)
 	JumpToMark, // jump to mark, set mark to previous cursor
 	KillRegion, // kill region between mark and cursor (to kill ring)
 	CopyRegion, // copy region to kill ring (Alt-w)

Frontend.h

@@ -12,7 +12,7 @@ public:
 	virtual ~Frontend() = default;
 
 	// Initialize the frontend (create window/terminal, etc.)
-	virtual bool Init(Editor &ed) = 0;
+	virtual bool Init(int &argc, char **argv, Editor &ed) = 0;
 
 	// Execute one iteration (poll input, dispatch, draw). Set running=false to exit.
 	virtual void Step(Editor &ed, bool &running) = 0;

ImGuiFrontend.cc

@@ -18,6 +18,7 @@
 #include "GUITheme.h"
 #include "fonts/Font.h" // embedded default font (DefaultFont)
 #include "fonts/FontRegistry.h"
+#include "fonts/IosevkaExtended.h"
 #include "syntax/HighlighterRegistry.h"
 #include "syntax/NullHighlighter.h"
 
@@ -29,8 +30,10 @@
 static auto kGlslVersion = "#version 150"; // GL 3.2 core (macOS compatible)
 
 bool
-GUIFrontend::Init(Editor &ed)
+GUIFrontend::Init(int &argc, char **argv, Editor &ed)
 {
+	(void) argc;
+	(void) argv;
 	// Attach editor to input handler for editor-owned features (e.g., universal argument)
 	input_.Attach(&ed);
 	// editor dimensions will be initialized during the first Step() frame
@@ -262,10 +265,10 @@ GUIFrontend::Step(Editor &ed, bool &running)
 	// Update editor logical rows/cols using current ImGui metrics and display size
 	{
 		ImGuiIO &io = ImGui::GetIO();
-		float line_h = ImGui::GetTextLineHeightWithSpacing();
+		float row_h = ImGui::GetTextLineHeightWithSpacing();
 		float ch_w  = ImGui::CalcTextSize("M").x;
-		if (line_h <= 0.0f)
-			line_h = 16.0f;
+		if (row_h <= 0.0f)
+			row_h = 16.0f;
 		if (ch_w <= 0.0f)
 			ch_w = 8.0f;
 		// Prefer ImGui IO display size; fall back to cached SDL window size
@@ -273,20 +276,20 @@ GUIFrontend::Step(Editor &ed, bool &running)
 		float disp_h = io.DisplaySize.y > 0 ? io.DisplaySize.y : static_cast<float>(height_);
 
 		// Account for the GUI window padding and the status bar height used in ImGuiRenderer.
-		// ImGuiRenderer pushes WindowPadding = (6,6) every frame, so use the same constants here
-		// to avoid mismatches that would cause premature scrolling.
 		const float pad_x = 6.0f;
 		const float pad_y = 6.0f;
-		// Status bar reserves one frame height (with spacing) inside the window
-		float status_h = ImGui::GetFrameHeightWithSpacing();
 
-		float avail_w = std::max(0.0f, disp_w - 2.0f * pad_x);
-		float avail_h = std::max(0.0f, disp_h - 2.0f * pad_y - status_h);
+		// Use the same logic as ImGuiRenderer for available height and status bar reservation.
+		float wanted_bar_h   = ImGui::GetFrameHeight();
+		float total_avail_h  = std::max(0.0f, disp_h - 2.0f * pad_y);
+		float actual_avail_h = std::floor((total_avail_h - wanted_bar_h) / row_h) * row_h;
 
 		// Visible content rows inside the scroll child
-		auto content_rows = static_cast<std::size_t>(std::floor(avail_h / line_h));
+		auto content_rows = static_cast<std::size_t>(std::max(0.0f, std::floor(actual_avail_h / row_h)));
 		// Editor::Rows includes the status line; add 1 back for it.
-		std::size_t rows = std::max<std::size_t>(1, content_rows + 1);
+		std::size_t rows = content_rows + 1;
+
+		float avail_w    = std::max(0.0f, disp_w - 2.0f * pad_x);
 		std::size_t cols = static_cast<std::size_t>(std::max(1.0f, std::floor(avail_w / ch_w)));
 
 		// Only update if changed to avoid churn
@@ -357,14 +360,32 @@ GUIFrontend::LoadGuiFont_(const char * /*path*/, const float size_px)
 {
 	const ImGuiIO &io = ImGui::GetIO();
 	io.Fonts->Clear();
-	const ImFont *font = io.Fonts->AddFontFromMemoryCompressedTTF(
+
+	ImFontConfig config;
+	config.MergeMode = false;
+
+	// Load Basic Latin + Latin Supplement
+	io.Fonts->AddFontFromMemoryCompressedTTF(
 		kte::Fonts::DefaultFontData,
 		kte::Fonts::DefaultFontSize,
-		size_px);
-	if (!font) {
-		font = io.Fonts->AddFontDefault();
-	}
-	(void) font;
+		size_px,
+		&config,
+		io.Fonts->GetGlyphRangesDefault());
+
+	// Merge Greek and Mathematical symbols from IosevkaExtended
+	config.MergeMode                       = true;
+	static const ImWchar extended_ranges[] = {
+		0x0370, 0x03FF, // Greek and Coptic
+		0x2200, 0x22FF, // Mathematical Operators
+		0,
+	};
+	io.Fonts->AddFontFromMemoryCompressedTTF(
+		kte::Fonts::IosevkaExtended::DefaultFontRegularCompressedData,
+		kte::Fonts::IosevkaExtended::DefaultFontRegularCompressedSize,
+		size_px,
+		&config,
+		extended_ranges);
+
 	io.Fonts->Build();
 	return true;
 }

ImGuiFrontend.h

@@ -17,7 +17,7 @@ public:
 
 	~GUIFrontend() override = default;
 
-	bool Init(Editor &ed) override;
+	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 

ImGuiRenderer.cc

@@ -94,8 +94,17 @@ ImGuiRenderer::Draw(Editor &ed)
 			ImGui::SetNextWindowScroll(ImVec2(target_x, target_y));
 		}
 
-		// Reserve space for status bar at bottom
-		ImGui::BeginChild("scroll", ImVec2(0, -ImGui::GetFrameHeightWithSpacing()), false,
+		// Reserve space for status bar at bottom.
+		// We calculate a height that is an exact multiple of the line height
+		// to avoid partial lines and "scroll past end" jitter.
+		float total_avail_h = ImGui::GetContentRegionAvail().y;
+		float wanted_bar_h  = ImGui::GetFrameHeight();
+		float child_h_plan  = std::max(0.0f, std::floor((total_avail_h - wanted_bar_h) / row_h) * row_h);
+		float real_bar_h    = total_avail_h - child_h_plan;
+
+		ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
+		ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
+		ImGui::BeginChild("scroll", ImVec2(0, child_h_plan), false,
 		                  ImGuiWindowFlags_HorizontalScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
 
 		// Get child window position and scroll for click handling
@@ -138,160 +147,87 @@ ImGuiRenderer::Draw(Editor &ed)
 		}
 		prev_buf_rowoffs = buf_rowoffs;
 		prev_buf_coloffs = buf_coloffs;
-
-		// Synchronize cursor and scrolling.
-		// Ensure the cursor is visible, but avoid aggressive centering so that
-		// the same lines remain visible until the cursor actually goes off-screen.
-		{
-			// Compute visible row range using the child window height
-			float child_h  = ImGui::GetWindowHeight();
-			long first_row = static_cast<long>(scroll_y / row_h);
-			long vis_rows  = static_cast<long>(child_h / row_h);
-			if (vis_rows < 1)
-				vis_rows = 1;
-			long last_row = first_row + vis_rows - 1;
-
-			long cyr = static_cast<long>(cy);
-			if (cyr < first_row) {
-				// Scroll just enough to bring the cursor line to the top
-				float target = static_cast<float>(cyr) * row_h;
-				if (target < 0.f)
-					target = 0.f;
-				float max_y = ImGui::GetScrollMaxY();
-				if (max_y >= 0.f && target > max_y)
-					target = max_y;
-				ImGui::SetScrollY(target);
-				scroll_y  = ImGui::GetScrollY();
-				first_row = static_cast<long>(scroll_y / row_h);
-				last_row  = first_row + vis_rows - 1;
-			} else if (cyr > last_row) {
-				// Scroll just enough to bring the cursor line to the bottom
-				long new_first = cyr - vis_rows + 1;
-				if (new_first < 0)
-					new_first = 0;
-				float target = static_cast<float>(new_first) * row_h;
-				float max_y  = ImGui::GetScrollMaxY();
-				if (target < 0.f)
-					target = 0.f;
-				if (max_y >= 0.f && target > max_y)
-					target = max_y;
-				ImGui::SetScrollY(target);
-				scroll_y  = ImGui::GetScrollY();
-				first_row = static_cast<long>(scroll_y / row_h);
-				last_row  = first_row + vis_rows - 1;
-			}
-
-			// Horizontal scroll: ensure cursor column is visible
-			float child_w = ImGui::GetWindowWidth();
-			long vis_cols = static_cast<long>(child_w / space_w);
-			if (vis_cols < 1)
-				vis_cols = 1;
-			long first_col = static_cast<long>(scroll_x / space_w);
-			long last_col  = first_col + vis_cols - 1;
-
-			// Compute cursor's rendered X position (accounting for tabs)
-			std::size_t cursor_rx = 0;
-			if (cy < lines.size()) {
-				std::string cur_line   = static_cast<std::string>(lines[cy]);
-				const std::size_t tabw = 8;
-				for (std::size_t i = 0; i < cx && i < cur_line.size(); ++i) {
-					if (cur_line[i] == '\t') {
-						cursor_rx += tabw - (cursor_rx % tabw);
-					} else {
-						cursor_rx += 1;
-					}
-				}
-			}
-			long cxr = static_cast<long>(cursor_rx);
-			if (cxr < first_col || cxr > last_col) {
-				float target_x = static_cast<float>(cxr) * space_w;
-				// Center horizontally if possible
-				target_x -= (child_w / 2.0f);
-				if (target_x < 0.f)
-					target_x = 0.f;
-				float max_x = ImGui::GetScrollMaxX();
-				if (max_x >= 0.f && target_x > max_x)
-					target_x = max_x;
-				ImGui::SetScrollX(target_x);
-				scroll_x = ImGui::GetScrollX();
-			}
-			// Phase 3: prefetch visible viewport highlights and warm around in background
-			if (buf->SyntaxEnabled() && buf->Highlighter() && buf->Highlighter()->HasHighlighter()) {
-				int fr = static_cast<int>(std::max(0L, first_row));
-				int rc = static_cast<int>(std::max(1L, vis_rows));
-				buf->Highlighter()->PrefetchViewport(*buf, fr, rc, buf->Version());
-			}
-		}
 		// Cache current horizontal offset in rendered columns for click handling
 		const std::size_t coloffs_now = buf->Coloffs();
 
-		// Handle mouse click before rendering to avoid dependent on drawn items
-		if (ImGui::IsWindowHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
+		// Mark selection state (mark -> cursor), in source coordinates
+		bool sel_active    = false;
+		std::size_t sel_sy = 0, sel_sx = 0, sel_ey = 0, sel_ex = 0;
+		if (buf->MarkSet()) {
+			sel_sy = buf->MarkCury();
+			sel_sx = buf->MarkCurx();
+			sel_ey = buf->Cury();
+			sel_ex = buf->Curx();
+			if (sel_sy > sel_ey || (sel_sy == sel_ey && sel_sx > sel_ex)) {
+				std::swap(sel_sy, sel_ey);
+				std::swap(sel_sx, sel_ex);
+			}
+			sel_active = !(sel_sy == sel_ey && sel_sx == sel_ex);
+		}
+		// Visual-line selection: full-line highlight range
+		const bool vsel_active    = buf->VisualLineActive();
+		const std::size_t vsel_sy = vsel_active ? buf->VisualLineStartY() : 0;
+		const std::size_t vsel_ey = vsel_active ? buf->VisualLineEndY() : 0;
+
+		static bool mouse_selecting = false;
+		auto mouse_pos_to_buf       = [&]() -> std::pair<std::size_t, std::size_t> {
 			ImVec2 mp = ImGui::GetIO().MousePos;
-			// Compute content-relative position accounting for scroll
-			// mp.y - child_window_pos.y gives us pixels from top of child window
-			// Adding scroll_y gives us pixels from top of content (buffer row 0)
+			// Convert mouse pos to buffer row
 			float content_y = (mp.y - child_window_pos.y) + scroll_y;
 			long by_l       = static_cast<long>(content_y / row_h);
 			if (by_l < 0)
 				by_l = 0;
-
-			// Convert to buffer row
 			std::size_t by = static_cast<std::size_t>(by_l);
-			if (by >= lines.size()) {
-				if (!lines.empty())
-					by = lines.size() - 1;
-				else
-					by = 0;
-			}
+			if (by >= lines.size())
+				by = lines.empty() ? 0 : (lines.size() - 1);
 
-			// Compute click X position relative to left edge of child window (in pixels)
-			// This gives us the visual offset from the start of displayed content
+			// Convert mouse pos to rendered x
 			float visual_x = mp.x - child_window_pos.x;
 			if (visual_x < 0.0f)
 				visual_x = 0.0f;
-
-			// Convert visual pixel offset to rendered column, then add coloffs_now
-			// to get the absolute rendered column in the buffer
 			std::size_t clicked_rx = static_cast<std::size_t>(visual_x / space_w) + coloffs_now;
 
-			// Empty buffer guard: if there are no lines yet, just move to 0:0
-			if (lines.empty()) {
-				Execute(ed, CommandId::MoveCursorTo, std::string("0:0"));
-			} else {
-				// Convert rendered column (clicked_rx) to source column accounting for tabs
+			// Convert rendered column to source column
+			if (lines.empty())
+				return {0, 0};
 			std::string line_clicked = static_cast<std::string>(lines[by]);
 			const std::size_t tabw   = 8;
-
-				// Iterate through source columns, computing rendered position, to find closest match
-				std::size_t rx       = 0; // rendered column position
+			std::size_t rx           = 0;
 			std::size_t best_col     = 0;
 			float best_dist          = std::numeric_limits<float>::infinity();
 			float clicked_rx_f       = static_cast<float>(clicked_rx);
-
 			for (std::size_t i = 0; i <= line_clicked.size(); ++i) {
-					// Check current position
 				float dist = std::fabs(clicked_rx_f - static_cast<float>(rx));
 				if (dist < best_dist) {
 					best_dist = dist;
 					best_col  = i;
 				}
-
-					// Advance to next position if not at end
 				if (i < line_clicked.size()) {
-						if (line_clicked[i] == '\t') {
-							rx += (tabw - (rx % tabw));
-						} else {
-							rx += 1;
-						}
+					rx += (line_clicked[i] == '\t') ? (tabw - (rx % tabw)) : 1;
 				}
 			}
+			return {by, best_col};
+		};
 
-				// Dispatch absolute buffer coordinates (row:col)
+		// Mouse-driven selection: set mark on press, update cursor on drag
+		if (ImGui::IsWindowHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
+			mouse_selecting = true;
+			auto [by, bx]   = mouse_pos_to_buf();
 			char tmp[64];
-				std::snprintf(tmp, sizeof(tmp), "%zu:%zu", by, best_col);
+			std::snprintf(tmp, sizeof(tmp), "%zu:%zu", by, bx);
+			Execute(ed, CommandId::MoveCursorTo, std::string(tmp));
+			if (Buffer *mbuf = const_cast<Buffer *>(buf)) {
+				mbuf->SetMark(bx, by);
+			}
+		}
+		if (mouse_selecting && ImGui::IsWindowHovered() && ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
+			auto [by, bx] = mouse_pos_to_buf();
+			char tmp[64];
+			std::snprintf(tmp, sizeof(tmp), "%zu:%zu", by, bx);
 			Execute(ed, CommandId::MoveCursorTo, std::string(tmp));
 		}
+		if (mouse_selecting && ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
+			mouse_selecting = false;
 		}
 		for (std::size_t i = rowoffs; i < lines.size(); ++i) {
 			// Capture the screen position before drawing the line
@@ -370,6 +306,51 @@ ImGuiRenderer::Draw(Editor &ed)
 					ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, col);
 				}
 			}
+
+			// Draw selection background (over search highlight; under text)
+			if (sel_active || vsel_active) {
+				bool line_has  = false;
+				std::size_t sx = 0, ex = 0;
+				if (vsel_active && i >= vsel_sy && i <= vsel_ey) {
+					sx       = 0;
+					ex       = line.size();
+					line_has = ex > sx;
+				} else if (i < sel_sy || i > sel_ey) {
+					line_has = false;
+				} else if (sel_sy == sel_ey) {
+					sx       = sel_sx;
+					ex       = sel_ex;
+					line_has = ex > sx;
+				} else if (i == sel_sy) {
+					sx       = sel_sx;
+					ex       = line.size();
+					line_has = ex > sx;
+				} else if (i == sel_ey) {
+					sx       = 0;
+					ex       = std::min(sel_ex, line.size());
+					line_has = ex > sx;
+				} else {
+					sx       = 0;
+					ex       = line.size();
+					line_has = ex > sx;
+				}
+				if (line_has) {
+					std::size_t rx_start = src_to_rx(sx);
+					std::size_t rx_end   = src_to_rx(ex);
+					if (rx_end > coloffs_now) {
+						std::size_t vx0 = (rx_start > coloffs_now)
+							                  ? (rx_start - coloffs_now)
+							                  : 0;
+						std::size_t vx1 = rx_end - coloffs_now;
+						ImVec2 p0       = ImVec2(line_pos.x + static_cast<float>(vx0) * space_w,
+						                         line_pos.y);
+						ImVec2 p1 = ImVec2(line_pos.x + static_cast<float>(vx1) * space_w,
+						                   line_pos.y + line_h);
+						ImU32 col = ImGui::GetColorU32(ImGuiCol_TextSelectedBg);
+						ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, col);
+					}
+				}
+			}
 			// Emit entire line to an expanded buffer (tabs -> spaces)
 			for (std::size_t src = 0; src < line.size(); ++src) {
 				char c = line[src];
@@ -489,23 +470,98 @@ ImGuiRenderer::Draw(Editor &ed)
 				ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, col);
 			}
 		}
+		// Synchronize cursor and scrolling after rendering all lines so content size is known.
+		{
+			float child_h_actual = ImGui::GetWindowHeight();
+			float child_w_actual = ImGui::GetWindowWidth();
+			float scroll_y_now   = ImGui::GetScrollY();
+			float scroll_x_now   = ImGui::GetScrollX();
+
+			long first_row = static_cast<long>(scroll_y_now / row_h);
+			long vis_rows  = static_cast<long>(std::round(child_h_actual / row_h));
+			if (vis_rows < 1)
+				vis_rows = 1;
+			long last_row = first_row + vis_rows - 1;
+
+			long cyr = static_cast<long>(cy);
+			if (cyr < first_row) {
+				float target = static_cast<float>(cyr) * row_h;
+				if (target < 0.f)
+					target = 0.f;
+				float max_y = ImGui::GetScrollMaxY();
+				if (max_y >= 0.f && target > max_y)
+					target = max_y;
+				ImGui::SetScrollY(target);
+				first_row = static_cast<long>(target / row_h);
+				last_row  = first_row + vis_rows - 1;
+			} else if (cyr > last_row) {
+				long new_first = cyr - vis_rows + 1;
+				if (new_first < 0)
+					new_first = 0;
+				float target = static_cast<float>(new_first) * row_h;
+				float max_y  = ImGui::GetScrollMaxY();
+				if (target < 0.f)
+					target = 0.f;
+				if (max_y >= 0.f && target > max_y)
+					target = max_y;
+				ImGui::SetScrollY(target);
+				first_row = static_cast<long>(target / row_h);
+				last_row  = first_row + vis_rows - 1;
+			}
+
+			// Horizontal scroll: ensure cursor column is visible
+			long vis_cols = static_cast<long>(std::round(child_w_actual / space_w));
+			if (vis_cols < 1)
+				vis_cols = 1;
+			long first_col = static_cast<long>(scroll_x_now / space_w);
+			long last_col  = first_col + vis_cols - 1;
+
+			std::size_t cursor_rx = 0;
+			if (cy < lines.size()) {
+				std::string cur_line   = static_cast<std::string>(lines[cy]);
+				const std::size_t tabw = 8;
+				for (std::size_t i = 0; i < cx && i < cur_line.size(); ++i) {
+					if (cur_line[i] == '\t') {
+						cursor_rx += tabw - (cursor_rx % tabw);
+					} else {
+						cursor_rx += 1;
+					}
+				}
+			}
+			long cxr = static_cast<long>(cursor_rx);
+			if (cxr < first_col || cxr > last_col) {
+				float target_x = static_cast<float>(cxr) * space_w;
+				target_x       -= (child_w_actual / 2.0f);
+				if (target_x < 0.f)
+					target_x = 0.f;
+				float max_x = ImGui::GetScrollMaxX();
+				if (max_x >= 0.f && target_x > max_x)
+					target_x = max_x;
+				ImGui::SetScrollX(target_x);
+			}
+
+			if (buf->SyntaxEnabled() && buf->Highlighter() && buf->Highlighter()->HasHighlighter()) {
+				int fr = static_cast<int>(std::max(0L, first_row));
+				int rc = static_cast<int>(std::max(1L, vis_rows));
+				buf->Highlighter()->PrefetchViewport(*buf, fr, rc, buf->Version());
+			}
+		}
 		ImGui::EndChild();
+		ImGui::PopStyleVar(2); // WindowPadding, ItemSpacing
 
-		// Status bar spanning full width
-		ImGui::Separator();
-
-		// Compute full content width and draw a filled background rectangle
+		// Status bar area starting right after the scroll child
 		ImVec2 win_pos = ImGui::GetWindowPos();
-		ImVec2 cr_min  = ImGui::GetWindowContentRegionMin();
-		ImVec2 cr_max  = ImGui::GetWindowContentRegionMax();
-		float x0       = win_pos.x + cr_min.x;
-		float x1       = win_pos.x + cr_max.x;
-		ImVec2 cursor  = ImGui::GetCursorScreenPos();
-		float bar_h    = ImGui::GetFrameHeight();
-		ImVec2 p0(x0, cursor.y);
-		ImVec2 p1(x1, cursor.y + bar_h);
+		ImVec2 win_sz  = ImGui::GetWindowSize();
+		float x0       = win_pos.x;
+		float x1       = win_pos.x + win_sz.x;
+		float y0       = ImGui::GetCursorScreenPos().y;
+		float bar_h    = real_bar_h;
+
+		ImVec2 p0(x0, y0);
+		ImVec2 p1(x1, y0 + bar_h);
 		ImU32 bg_col = ImGui::GetColorU32(ImGuiCol_HeaderActive);
 		ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, bg_col);
+
 		// If a prompt is active, replace the entire status bar with the prompt text
 		if (ed.PromptActive()) {
 			std::string label = ed.PromptLabel();
@@ -591,11 +647,9 @@ ImGuiRenderer::Draw(Editor &ed)
 
 			ImVec2 msg_sz = ImGui::CalcTextSize(final_msg.c_str());
 			ImGui::PushClipRect(ImVec2(p0.x, p0.y), ImVec2(p1.x, p1.y), true);
-			ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - msg_sz.y) * 0.5f));
+			ImGui::SetCursorScreenPos(ImVec2(left_x, y0 + (bar_h - msg_sz.y) * 0.5f));
 			ImGui::TextUnformatted(final_msg.c_str());
 			ImGui::PopClipRect();
-			// Advance cursor to after the bar to keep layout consistent
-			ImGui::Dummy(ImVec2(x1 - x0, bar_h));
 		} else {
 			// Build left text
 			std::string left;
@@ -671,20 +725,21 @@ ImGuiRenderer::Draw(Editor &ed)
 				float max_left = std::max(0.0f, right_x - left_x - pad);
 				if (max_left < left_sz.x && max_left > 10.0f) {
 					// Render a clipped left using a child region
-					ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
-					ImGui::PushClipRect(ImVec2(left_x, p0.y), ImVec2(right_x - pad, p1.y), true);
+					ImGui::SetCursorScreenPos(ImVec2(left_x, y0 + (bar_h - left_sz.y) * 0.5f));
+					ImGui::PushClipRect(ImVec2(left_x, y0), ImVec2(right_x - pad, y0 + bar_h),
+					                    true);
 					ImGui::TextUnformatted(left.c_str());
 					ImGui::PopClipRect();
 				}
 			} else {
 				// Draw left normally
-				ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
+				ImGui::SetCursorScreenPos(ImVec2(left_x, y0 + (bar_h - left_sz.y) * 0.5f));
 				ImGui::TextUnformatted(left.c_str());
 			}
 
 			// Draw right
 			ImGui::SetCursorScreenPos(ImVec2(std::max(right_x, left_x),
-			                                 p0.y + (bar_h - right_sz.y) * 0.5f));
+			                                 y0 + (bar_h - right_sz.y) * 0.5f));
 			ImGui::TextUnformatted(right.c_str());
 
 			// Draw middle message centered in remaining space
@@ -696,14 +751,12 @@ ImGuiRenderer::Draw(Editor &ed)
 					ImVec2 msg_sz = ImGui::CalcTextSize(msg.c_str());
 					float msg_x   = mid_left + std::max(0.0f, (mid_w - msg_sz.x) * 0.5f);
 					// Clip to middle region
-					ImGui::PushClipRect(ImVec2(mid_left, p0.y), ImVec2(mid_right, p1.y), true);
-					ImGui::SetCursorScreenPos(ImVec2(msg_x, p0.y + (bar_h - msg_sz.y) * 0.5f));
+					ImGui::PushClipRect(ImVec2(mid_left, y0), ImVec2(mid_right, y0 + bar_h), true);
+					ImGui::SetCursorScreenPos(ImVec2(msg_x, y0 + (bar_h - msg_sz.y) * 0.5f));
 					ImGui::TextUnformatted(msg.c_str());
 					ImGui::PopClipRect();
 				}
 			}
-			// Advance cursor to after the bar to keep layout consistent
-			ImGui::Dummy(ImVec2(x1 - x0, bar_h));
 		}
 	}
 

KKeymap.cc

@@ -114,6 +114,9 @@ KLookupKCommand(const int ascii_key, const bool ctrl, CommandId &out) -> bool
 	case '=':
 		out = CommandId::IndentRegion;
 		return true;
+	case '/':
+		out = CommandId::VisualLineModeToggle;
+		return true;
 	case ';':
 		out = CommandId::CommandPromptStart; // C-k ; : generic command prompt
 		return true;

PieceTable.cc

@@ -273,6 +273,7 @@ PieceTable::addPieceFront(Source src, std::size_t start, std::size_t len)
 void
 PieceTable::materialize() const
 {
+	std::lock_guard<std::mutex> lock(mutex_);
 	if (!dirty_) {
 		return;
 	}
@@ -348,6 +349,7 @@ PieceTable::coalesceNeighbors(std::size_t index)
 void
 PieceTable::InvalidateLineIndex() const
 {
+	std::lock_guard<std::mutex> lock(mutex_);
 	line_index_dirty_ = true;
 }
 
@@ -355,22 +357,29 @@ PieceTable::InvalidateLineIndex() const
 void
 PieceTable::RebuildLineIndex() const
 {
-	if (!line_index_dirty_)
+	std::lock_guard<std::mutex> lock(mutex_);
+
+	if (!line_index_dirty_) {
 		return;
+	}
 	line_index_.clear();
 	line_index_.push_back(0);
+
 	std::size_t pos = 0;
 	for (const auto &pc: pieces_) {
 		const std::string &src = pc.src == Source::Original ? original_ : add_;
 		const char *base       = src.data() + static_cast<std::ptrdiff_t>(pc.start);
+
 		for (std::size_t j = 0; j < pc.len; ++j) {
 			if (base[j] == '\n') {
 				// next line starts after the newline
 				line_index_.push_back(pos + j + 1);
 			}
 		}
+
 		pos += pc.len;
 	}
+
 	line_index_dirty_ = false;
 }
 
@@ -692,14 +701,18 @@ PieceTable::GetRange(std::size_t byte_offset, std::size_t len) const
 		len = total_size_ - byte_offset;
 
 	// Fast path: return cached value if version/offset/len match
+	{
+		std::lock_guard<std::mutex> lock(mutex_);
 		if (range_cache_.valid && range_cache_.version == version_ &&
 		    range_cache_.off == byte_offset && range_cache_.len == len) {
 			return range_cache_.data;
 		}
+	}
 
 	std::string out;
 	out.reserve(len);
 	if (!dirty_) {
+		std::lock_guard<std::mutex> lock(mutex_);
 		// Already materialized; slice directly
 		out.assign(materialized_.data() + static_cast<std::ptrdiff_t>(byte_offset), len);
 	} else {
@@ -723,11 +736,14 @@ PieceTable::GetRange(std::size_t byte_offset, std::size_t len) const
 	}
 
 	// Update cache
+	{
+		std::lock_guard<std::mutex> lock(mutex_);
 		range_cache_.valid   = true;
 		range_cache_.version = version_;
 		range_cache_.off     = byte_offset;
 		range_cache_.len     = len;
 		range_cache_.data    = out;
+	}
 	return out;
 }
 
@@ -739,15 +755,21 @@ PieceTable::Find(const std::string &needle, std::size_t start) const
 		return start <= total_size_ ? start : std::numeric_limits<std::size_t>::max();
 	if (start > total_size_)
 		return std::numeric_limits<std::size_t>::max();
+	{
+		std::lock_guard<std::mutex> lock(mutex_);
 		if (find_cache_.valid &&
 		    find_cache_.version == version_ &&
 		    find_cache_.needle == needle &&
 		    find_cache_.start == start) {
 			return find_cache_.result;
 		}
+	}
 
 	materialize();
-	auto pos = materialized_.find(needle, start);
+	std::size_t pos;
+	{
+		std::lock_guard<std::mutex> lock(mutex_);
+		pos = materialized_.find(needle, start);
 		if (pos == std::string::npos)
 			pos = std::numeric_limits<std::size_t>::max();
 		// Update cache
@@ -756,6 +778,7 @@ PieceTable::Find(const std::string &needle, std::size_t start) const
 		find_cache_.needle  = needle;
 		find_cache_.start   = start;
 		find_cache_.result  = pos;
+	}
 	return pos;
 }
 
@@ -764,6 +787,9 @@ void
 PieceTable::WriteToStream(std::ostream &out) const
 {
 	// Stream the content piece-by-piece without forcing full materialization
+	// No lock needed for original_ and add_ if they are not being modified.
+	// Since this is a const method and kte's piece table isn't modified by multiple threads
+	// (only queried), we just iterate pieces_.
 	for (const auto &p: pieces_) {
 		if (p.len == 0)
 			continue;

PieceTable.h

@@ -8,6 +8,7 @@
 #include <ostream>
 #include <vector>
 #include <limits>
+#include <mutex>
 
 
 class PieceTable {
@@ -181,4 +182,6 @@ private:
 
 	mutable RangeCache range_cache_;
 	mutable FindCache find_cache_;
+
+	mutable std::mutex mutex_;
 };

QtFrontend.cc

@@ -658,10 +658,8 @@ private:
 } // namespace
 
 bool
-GUIFrontend::Init(Editor &ed)
+GUIFrontend::Init(int &argc, char **argv, Editor &ed)
 {
-	int argc    = 0;
-	char **argv = nullptr;
 	app_ = new QApplication(argc, argv);
 
 	window_ = new MainWindow(input_);

QtFrontend.h

@@ -18,7 +18,7 @@ public:
 
 	~GUIFrontend() override = default;
 
-	bool Init(Editor &ed) override;
+	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 

TerminalFrontend.cc

@@ -8,8 +8,10 @@
 
 
 bool
-TerminalFrontend::Init(Editor &ed)
+TerminalFrontend::Init(int &argc, char **argv, Editor &ed)
 {
+	(void) argc;
+	(void) argv;
 	// Ensure Control keys reach the app: disable XON/XOFF and dsusp/susp bindings (e.g., ^S/^Q, ^Y on macOS)
 	{
 		struct termios tio{};

TerminalFrontend.h

@@ -21,7 +21,7 @@ public:
 	// Adjust if your terminal needs a different threshold.
 	static constexpr int kEscDelayMs = 50;
 
-	bool Init(Editor &ed) override;
+	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 

TerminalInputHandler.cc

@@ -3,6 +3,7 @@
 
 #include "TerminalInputHandler.h"
 #include "KKeymap.h"
+#include "Command.h"
 #include "Editor.h"
 
 namespace {
@@ -23,6 +24,7 @@ map_key_to_command(const int ch,
                    bool &k_prefix,
                    bool &esc_meta,
                    bool &k_ctrl_pending,
+                   bool &mouse_selecting,
                    Editor *ed,
                    MappedInput &out)
 {
@@ -54,13 +56,34 @@ map_key_to_command(const int ch,
 			}
 #endif
 			// React to left button click/press
-			if (ev.bstate & (BUTTON1_CLICKED | BUTTON1_PRESSED | BUTTON1_RELEASED)) {
+			if (ed && (ev.bstate & (BUTTON1_CLICKED | BUTTON1_PRESSED | BUTTON1_RELEASED |
+			                        REPORT_MOUSE_POSITION))) {
 				char buf[64];
 				// Use screen coordinates; command handler will translate via offsets
 				std::snprintf(buf, sizeof(buf), "@%d:%d", ev.y, ev.x);
-				out = {true, CommandId::MoveCursorTo, std::string(buf), 0};
+				const bool pressed  = (ev.bstate & (BUTTON1_PRESSED | BUTTON1_CLICKED)) != 0;
+				const bool released = (ev.bstate & BUTTON1_RELEASED) != 0;
+				const bool moved    = (ev.bstate & REPORT_MOUSE_POSITION) != 0;
+				if (pressed) {
+					mouse_selecting = true;
+					Execute(*ed, CommandId::MoveCursorTo, std::string(buf));
+					if (Buffer *b = ed->CurrentBuffer()) {
+						b->SetMark(b->Curx(), b->Cury());
+					}
+					out.hasCommand = false;
 					return true;
 				}
+				if (mouse_selecting && moved) {
+					Execute(*ed, CommandId::MoveCursorTo, std::string(buf));
+					out.hasCommand = false;
+					return true;
+				}
+				if (released) {
+					mouse_selecting = false;
+					out.hasCommand  = false;
+					return true;
+				}
+			}
 		}
 		// No actionable mouse event
 		out.hasCommand = false;
@@ -292,6 +315,7 @@ TerminalInputHandler::decode_(MappedInput &out)
 		ch,
 		k_prefix_, esc_meta_,
 		k_ctrl_pending_,
+		mouse_selecting_,
 		ed_,
 		out);
 	if (!consumed)

TerminalInputHandler.h

@@ -30,5 +30,8 @@ private:
 	// Simple meta (ESC) state for ESC sequences like ESC b/f
 	bool esc_meta_ = false;
 
+	// Mouse drag selection state
+	bool mouse_selecting_ = false;
+
 	Editor *ed_ = nullptr; // attached editor for uarg handling
 };

TerminalRenderer.cc

@@ -1,3 +1,6 @@
+#include <clocale>
+#define _XOPEN_SOURCE_EXTENDED 1
+#include <cwchar>
 #include <algorithm>
 #include <cstdio>
 #include <filesystem>
@@ -104,8 +107,43 @@ TerminalRenderer::Draw(Editor &ed)
 			const std::size_t cur_mx   = has_current ? ed.SearchMatchX() : 0;
 			const std::size_t cur_my   = has_current ? ed.SearchMatchY() : 0;
 			const std::size_t cur_mend = has_current ? (ed.SearchMatchX() + ed.SearchMatchLen()) : 0;
-			bool hl_on                 = false;
-			bool cur_on                = false;
+
+			// Mark selection (mark -> cursor), in source coordinates
+			bool sel_active    = false;
+			std::size_t sel_sy = 0, sel_sx = 0, sel_ey = 0, sel_ex = 0;
+			if (buf->MarkSet()) {
+				sel_sy = buf->MarkCury();
+				sel_sx = buf->MarkCurx();
+				sel_ey = buf->Cury();
+				sel_ex = buf->Curx();
+				if (sel_sy > sel_ey || (sel_sy == sel_ey && sel_sx > sel_ex)) {
+					std::swap(sel_sy, sel_ey);
+					std::swap(sel_sx, sel_ex);
+				}
+				sel_active = !(sel_sy == sel_ey && sel_sx == sel_ex);
+			}
+			// Visual-line selection: full-line selection range
+			const bool vsel_active    = buf->VisualLineActive();
+			const std::size_t vsel_sy = vsel_active ? buf->VisualLineStartY() : 0;
+			const std::size_t vsel_ey = vsel_active ? buf->VisualLineEndY() : 0;
+			auto is_src_in_sel        = [&](std::size_t y, std::size_t sx) -> bool {
+				(void) sx;
+				if (vsel_active) {
+					if (y >= vsel_sy && y <= vsel_ey)
+						return true;
+				}
+				if (!sel_active)
+					return false;
+				if (y < sel_sy || y > sel_ey)
+					return false;
+				if (sel_sy == sel_ey)
+					return sx >= sel_sx && sx < sel_ex;
+				if (y == sel_sy)
+					return sx >= sel_sx;
+				if (y == sel_ey)
+					return sx < sel_ex;
+				return true;
+			};
 			int written = 0;
 			if (li < lines.size()) {
 				std::string line = static_cast<std::string>(lines[li]);
@@ -153,39 +191,50 @@ TerminalRenderer::Draw(Editor &ed)
 					}
 					return kte::TokenKind::Default;
 				};
-				auto apply_token_attr = [&](kte::TokenKind k) {
-					// Map to simple attributes; search highlight uses A_STANDOUT which takes precedence below
-					attrset(A_NORMAL);
+				auto token_attr = [&](kte::TokenKind k) -> attr_t {
 					switch (k) {
 					case kte::TokenKind::Keyword:
 					case kte::TokenKind::Type:
 					case kte::TokenKind::Constant:
 					case kte::TokenKind::Function:
-							attron(A_BOLD);
-							break;
+						return A_BOLD;
 					case kte::TokenKind::Comment:
-							attron(A_DIM);
-							break;
+						return A_DIM;
 					case kte::TokenKind::String:
 					case kte::TokenKind::Char:
 					case kte::TokenKind::Number:
-							// standout a bit using A_UNDERLINE if available
-							attron(A_UNDERLINE);
-							break;
+						return A_UNDERLINE;
 					default:
-							break;
+						return 0;
 					}
 				};
 				while (written < cols) {
-					char ch       = ' ';
 					bool from_src = false;
+					wchar_t wch   = L' ';
+					int wch_len   = 1;
+					int disp_w    = 1;
+
 					if (src_i < line.size()) {
-						unsigned char c = static_cast<unsigned char>(line[src_i]);
-						if (c == '\t') {
+						// Decode UTF-8
+						std::mbstate_t state = std::mbstate_t();
+						size_t res           = std::mbrtowc(
+							&wch, &line[src_i], line.size() - src_i, &state);
+						if (res == (size_t) -1 || res == (size_t) -2) {
+							// Invalid or incomplete; treat as single byte
+							wch     = static_cast<unsigned char>(line[src_i]);
+							wch_len = 1;
+						} else if (res == 0) {
+							wch     = L'\0';
+							wch_len = 1;
+						} else {
+							wch_len = static_cast<int>(res);
+						}
+
+						if (wch == L'\t') {
 							std::size_t next_tab = tabw - (render_col % tabw);
 							if (render_col + next_tab <= coloffs) {
 								render_col += next_tab;
-								++src_i;
+								src_i      += wch_len;
 								continue;
 							}
 							// Emit spaces for tab
@@ -198,98 +247,90 @@ TerminalRenderer::Draw(Editor &ed)
 							}
 							// Now render visible spaces
 							while (next_tab > 0 && written < cols) {
+								bool in_sel = is_src_in_sel(li, src_i);
 								bool in_hl  = search_mode && is_src_in_hl(src_i);
 								bool in_cur =
 									has_current && li == cur_my && src_i >= cur_mx
-									&& src_i < cur_mend;
-								// Toggle highlight attributes
-								int attr = 0;
+									&&
+									src_i < cur_mend;
+								attr_t a = A_NORMAL;
+								a        |= token_attr(token_at(src_i));
+								if (in_sel) {
+									a |= A_REVERSE;
+								} else {
 									if (in_hl)
-									attr |= A_STANDOUT;
+										a |= A_STANDOUT;
 									if (in_cur)
-									attr |= A_BOLD;
-								if ((attr & A_STANDOUT) && !hl_on) {
-									attron(A_STANDOUT);
-									hl_on = true;
-								}
-								if (!(attr & A_STANDOUT) && hl_on) {
-									attroff(A_STANDOUT);
-									hl_on = false;
-								}
-								if ((attr & A_BOLD) && !cur_on) {
-									attron(A_BOLD);
-									cur_on = true;
-								}
-								if (!(attr & A_BOLD) && cur_on) {
-									attroff(A_BOLD);
-									cur_on = false;
-								}
-								// Apply syntax attribute only if not in search highlight
-								if (!in_hl) {
-									apply_token_attr(token_at(src_i));
+										a |= A_BOLD;
 								}
+								attrset(a);
 								addch(' ');
 								++written;
 								++render_col;
 								--next_tab;
 							}
-							++src_i;
+							src_i += wch_len;
 							continue;
 						} else {
 							// normal char
+							disp_w = wcwidth(wch);
+							if (disp_w < 0)
+								disp_w = 1; // non-printable or similar
+
 							if (render_col < coloffs) {
-								++render_col;
-								++src_i;
+								render_col += disp_w;
+								src_i      += wch_len;
 								continue;
 							}
-							ch       = static_cast<char>(c);
 							from_src = true;
 						}
 					} else {
 						// beyond EOL, fill spaces
-						ch       = ' ';
+						wch      = L' ';
+						wch_len  = 1;
+						disp_w   = 1;
 						from_src = false;
 					}
+
+					if (written + disp_w > cols) {
+						// would overflow, just break
+						break;
+					}
+
+					bool in_sel = from_src && is_src_in_sel(li, src_i);
 					bool in_hl  = search_mode && from_src && is_src_in_hl(src_i);
-					bool in_cur =
-						has_current && li == cur_my && from_src && src_i >= cur_mx && src_i <
-						cur_mend;
-					if (in_hl && !hl_on) {
-						attron(A_STANDOUT);
-						hl_on = true;
-					}
-					if (!in_hl && hl_on) {
-						attroff(A_STANDOUT);
-						hl_on = false;
-					}
-					if (in_cur && !cur_on) {
-						attron(A_BOLD);
-						cur_on = true;
-					}
-					if (!in_cur && cur_on) {
-						attroff(A_BOLD);
-						cur_on = false;
-					}
-					if (!in_hl && from_src) {
-						apply_token_attr(token_at(src_i));
-					}
-					addch(static_cast<unsigned char>(ch));
-					++written;
-					++render_col;
+					bool in_cur = has_current && li == cur_my && from_src && src_i >= cur_mx &&
+					              src_i < cur_mend;
+					attr_t a = A_NORMAL;
 					if (from_src)
-						++src_i;
+						a |= token_attr(token_at(src_i));
+					if (in_sel) {
+						a |= A_REVERSE;
+					} else {
+						if (in_hl)
+							a |= A_STANDOUT;
+						if (in_cur)
+							a |= A_BOLD;
+					}
+					attrset(a);
+
+					if (from_src) {
+						cchar_t cch;
+						wchar_t warr[2] = {wch, L'\0'};
+						setcchar(&cch, warr, 0, 0, nullptr);
+						add_wch(&cch);
+					} else {
+						addch(' ');
+					}
+
+					written    += disp_w;
+					render_col += disp_w;
+					if (from_src)
+						src_i += wch_len;
 					if (src_i >= line.size() && written >= cols)
 						break;
 				}
 			}
-			if (hl_on) {
-				attroff(A_STANDOUT);
-				hl_on = false;
-			}
-			if (cur_on) {
-				attroff(A_BOLD);
-				cur_on = false;
-			}
 			attrset(A_NORMAL);
 			clrtoeol();
 		}
@@ -306,14 +347,26 @@ TerminalRenderer::Draw(Editor &ed)
 			std::size_t src_i_cur             = 0;
 			std::size_t render_col_cur        = 0;
 			while (src_i_cur < line_for_cursor.size() && src_i_cur < cx) {
-				unsigned char ccur = static_cast<unsigned char>(line_for_cursor[src_i_cur]);
-				if (ccur == '\t') {
+				std::mbstate_t state = std::mbstate_t();
+				wchar_t wch;
+				size_t res = std::mbrtowc(
+					&wch, &line_for_cursor[src_i_cur], line_for_cursor.size() - src_i_cur,
+					&state);
+
+				if (res == (size_t) -1 || res == (size_t) -2) {
+					render_col_cur += 1;
+					src_i_cur      += 1;
+				} else if (res == 0) {
+					src_i_cur += 1;
+				} else {
+					if (wch == L'\t') {
 						std::size_t next_tab = tabw - (render_col_cur % tabw);
 						render_col_cur       += next_tab;
-					++src_i_cur;
 					} else {
-					++render_col_cur;
-					++src_i_cur;
+						int dw         = wcwidth(wch);
+						render_col_cur += (dw < 0) ? 1 : dw;
+					}
+					src_i_cur += res;
 				}
 			}
 			rx_recomputed = render_col_cur;

TestFrontend.cc

@@ -4,8 +4,10 @@
 
 
 bool
-TestFrontend::Init(Editor &ed)
+TestFrontend::Init(int &argc, char **argv, Editor &ed)
 {
+	(void) argc;
+	(void) argv;
 	ed.SetDimensions(24, 80);
 	return true;
 }

TestFrontend.h

@@ -13,7 +13,7 @@ public:
 
 	~TestFrontend() override = default;
 
-	bool Init(Editor &ed) override;
+	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 

UndoNode.h

@@ -16,6 +16,7 @@ struct UndoNode {
 	int row{};
 	int col{};
 	std::string text;
+	UndoNode *parent = nullptr; // previous state; null means pre-first-edit
 	UndoNode *child  = nullptr; // next in current timeline
 	UndoNode *next   = nullptr; // redo branch
 };

UndoNodePool.h

@@ -20,6 +20,7 @@ public:
 		available_.pop();
 		// Node comes zeroed; ensure links are reset
 		node->text.clear();
+		node->parent = nullptr;
 		node->child  = nullptr;
 		node->next   = nullptr;
 		node->row    = node->col = 0;
@@ -34,6 +35,7 @@ public:
 			return;
 		// Clear heavy fields to free memory held by strings
 		node->text.clear();
+		node->parent = nullptr;
 		node->child  = nullptr;
 		node->next   = nullptr;
 		node->row    = node->col = 0;

UndoSystem.cc

@@ -11,66 +11,225 @@ UndoSystem::UndoSystem(Buffer &owner, UndoTree &tree)
 void
 UndoSystem::Begin(UndoType type)
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
-	(void) type;
+	if (!buf_)
+		return;
+	const int row = static_cast<int>(buf_->Cury());
+	const int col = static_cast<int>(buf_->Curx());
+
+	// Some operations should always be standalone undo steps.
+	const bool always_standalone = (type == UndoType::Newline || type == UndoType::DeleteRow);
+	if (always_standalone) {
+		commit();
+	}
+
+	if (tree_.pending) {
+		if (tree_.pending->type == type) {
+			// Typed-run coalescing rules.
+			switch (type) {
+			case UndoType::Insert:
+			case UndoType::Paste: {
+				// Cursor must be at the end of the pending insert.
+				if (tree_.pending->row == row
+				    && col == tree_.pending->col + static_cast<int>(tree_.pending->text.size())) {
+					pending_mode_ = PendingAppendMode::Append;
+					return;
+				}
+				break;
+			}
+			case UndoType::Delete: {
+				if (tree_.pending->row == row) {
+					// Two common delete shapes:
+					// 1) backspace-run: cursor moves left each time (so new col is pending.col - 1)
+					// 2) delete-run: cursor stays, always deleting at the same col
+					if (col == tree_.pending->col) {
+						pending_mode_ = PendingAppendMode::Append;
+						return;
+					}
+					if (col + 1 == tree_.pending->col) {
+						// Extend a backspace run to the left; update the start column now.
+						tree_.pending->col = col;
+						pending_mode_      = PendingAppendMode::Prepend;
+						return;
+					}
+				}
+				break;
+			}
+			case UndoType::Newline:
+			case UndoType::DeleteRow:
+				break;
+			}
+		}
+		// Can't coalesce: seal the previous pending step.
+		commit();
+	}
+
+	// Start a new pending node.
+	tree_.pending       = new UndoNode{};
+	tree_.pending->type = type;
+	tree_.pending->row  = row;
+	tree_.pending->col  = col;
+	tree_.pending->text.clear();
+	tree_.pending->parent = nullptr;
+	tree_.pending->child  = nullptr;
+	tree_.pending->next   = nullptr;
+	pending_mode_         = PendingAppendMode::Append;
 }
 
 
 void
 UndoSystem::Append(char ch)
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
-	(void) ch;
+	if (!tree_.pending)
+		return;
+	if (pending_mode_ == PendingAppendMode::Prepend) {
+		tree_.pending->text.insert(tree_.pending->text.begin(), ch);
+	} else {
+		tree_.pending->text.push_back(ch);
+	}
 }
 
 
 void
 UndoSystem::Append(std::string_view text)
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
-	(void) text;
+	if (!tree_.pending)
+		return;
+	if (text.empty())
+		return;
+	if (pending_mode_ == PendingAppendMode::Prepend) {
+		tree_.pending->text.insert(0, text.data(), text.size());
+	} else {
+		tree_.pending->text.append(text.data(), text.size());
+	}
 }
 
 
 void
 UndoSystem::commit()
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
+	if (!tree_.pending)
+		return;
+
+	// Drop empty text batches for text-based operations.
+	if ((tree_.pending->type == UndoType::Insert || tree_.pending->type == UndoType::Delete
+	     || tree_.pending->type == UndoType::Paste)
+	    && tree_.pending->text.empty()) {
+		delete tree_.pending;
+		tree_.pending = nullptr;
+		pending_mode_ = PendingAppendMode::Append;
+		return;
+	}
+
+	if (!tree_.root) {
+		tree_.root            = tree_.pending;
+		tree_.pending->parent = nullptr;
+		tree_.current         = tree_.pending;
+	} else if (!tree_.current) {
+		// We are at the "pre-first-edit" state (undo past the first node).
+		// In branching history, preserve the existing root chain as an alternate branch.
+		tree_.pending->parent = nullptr;
+		tree_.pending->next   = tree_.root;
+		tree_.root            = tree_.pending;
+		tree_.current         = tree_.pending;
+	} else {
+		// Branching semantics: attach as a new redo branch under current.
+		// Make the new edit the active child by inserting it at the head.
+		tree_.pending->parent = tree_.current;
+		if (!tree_.current->child) {
+			tree_.current->child = tree_.pending;
+		} else {
+			tree_.pending->next  = tree_.current->child;
+			tree_.current->child = tree_.pending;
+		}
+		tree_.current = tree_.pending;
+	}
+
+	tree_.pending = nullptr;
+	pending_mode_ = PendingAppendMode::Append;
+	update_dirty_flag();
 }
 
 
 void
 UndoSystem::undo()
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
+	// Seal any in-progress typed run before undo.
+	commit();
+	if (!tree_.current)
+		return;
+	debug_log("undo");
+	apply(tree_.current, -1);
+	tree_.current = tree_.current->parent;
+	update_dirty_flag();
 }
 
 
 void
-UndoSystem::redo()
+UndoSystem::redo(int branch_index)
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
+	commit();
+	UndoNode **head = nullptr;
+	if (!tree_.current) {
+		head = &tree_.root;
+	} else {
+		head = &tree_.current->child;
+	}
+	if (!head || !*head)
+		return;
+	if (branch_index < 0)
+		branch_index = 0;
+
+	// Select the Nth sibling from the branch list and make it the active head.
+	UndoNode *prev = nullptr;
+	UndoNode *sel  = *head;
+	for (int i = 0; i < branch_index && sel; ++i) {
+		prev = sel;
+		sel  = sel->next;
+	}
+	if (!sel)
+		return;
+	if (prev) {
+		prev->next = sel->next;
+		sel->next  = *head;
+		*head      = sel;
+	}
+
+	debug_log("redo");
+	apply(*head, +1);
+	tree_.current = *head;
+	update_dirty_flag();
 }
 
 
 void
 UndoSystem::mark_saved()
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
+	commit();
+	tree_.saved = tree_.current;
+	update_dirty_flag();
 }
 
 
 void
 UndoSystem::discard_pending()
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
+	if (tree_.pending) {
+		delete tree_.pending;
+		tree_.pending = nullptr;
+	}
+	pending_mode_ = PendingAppendMode::Append;
 }
 
 
 void
 UndoSystem::clear()
 {
-	// STUB: Undo system incomplete - disabled until it can be properly implemented
+	discard_pending();
+	free_node(tree_.root);
+	tree_.root    = nullptr;
+	tree_.current = nullptr;
+	tree_.saved   = nullptr;
+	update_dirty_flag();
 }
 
 
@@ -79,34 +238,46 @@ UndoSystem::apply(const UndoNode *node, int direction)
 {
 	if (!node)
 		return;
+	// Cursor positioning: keep the point at a sensible location after undo/redo.
+	// Low-level Buffer edit primitives do not move the cursor.
 	switch (node->type) {
 	case UndoType::Insert:
 	case UndoType::Paste:
 		if (direction > 0) {
 			buf_->insert_text(node->row, node->col, node->text);
+			buf_->SetCursor(static_cast<std::size_t>(node->col + node->text.size()),
+			                static_cast<std::size_t>(node->row));
 		} else {
 			buf_->delete_text(node->row, node->col, node->text.size());
+			buf_->SetCursor(static_cast<std::size_t>(node->col), static_cast<std::size_t>(node->row));
 		}
 		break;
 	case UndoType::Delete:
 		if (direction > 0) {
 			buf_->delete_text(node->row, node->col, node->text.size());
+			buf_->SetCursor(static_cast<std::size_t>(node->col), static_cast<std::size_t>(node->row));
 		} else {
 			buf_->insert_text(node->row, node->col, node->text);
+			buf_->SetCursor(static_cast<std::size_t>(node->col + node->text.size()),
+			                static_cast<std::size_t>(node->row));
 		}
 		break;
 	case UndoType::Newline:
 		if (direction > 0) {
 			buf_->split_line(node->row, node->col);
+			buf_->SetCursor(0, static_cast<std::size_t>(node->row + 1));
 		} else {
 			buf_->join_lines(node->row);
+			buf_->SetCursor(static_cast<std::size_t>(node->col), static_cast<std::size_t>(node->row));
 		}
 		break;
 	case UndoType::DeleteRow:
 		if (direction > 0) {
 			buf_->delete_row(node->row);
+			buf_->SetCursor(0, static_cast<std::size_t>(node->row));
 		} else {
 			buf_->insert_row(node->row, node->text);
+			buf_->SetCursor(0, static_cast<std::size_t>(node->row));
 		}
 		break;
 	}

UndoSystem.h

@@ -22,7 +22,10 @@ public:
 
 	void undo();
 
-	void redo();
+	// Redo the current node's active child branch.
+	// If `branch_index` > 0, selects that redo sibling (0-based) and makes it active.
+	// When current is null (pre-first-edit), branches are selected among `tree_.root` siblings.
+	void redo(int branch_index = 0);
 
 	void mark_saved();
 
@@ -32,7 +35,20 @@ public:
 
 	void UpdateBufferReference(Buffer &new_buf);
 
+#if defined(KTE_TESTS)
+	// Test-only introspection hook.
+	const UndoTree &TreeForTests() const
+	{
+		return tree_;
+	}
+#endif
+
 private:
+	enum class PendingAppendMode : std::uint8_t {
+		Append,
+		Prepend,
+	};
+
 	void apply(const UndoNode *node, int direction); // +1 redo, -1 undo
 	void free_node(UndoNode *node);
 
@@ -48,6 +64,8 @@ private:
 
 	void update_dirty_flag();
 
+	PendingAppendMode pending_mode_ = PendingAppendMode::Append;
+
 	Buffer *buf_;
 	UndoTree &tree_;
 };

cmake/fix_bundle.cmake

@@ -0,0 +1,78 @@
+cmake_minimum_required(VERSION 3.15)
+
+# Fix up a macOS .app bundle by copying non-Qt dylibs into
+# Contents/Frameworks and rewriting install names to use @rpath/@loader_path.
+#
+# Usage:
+#   cmake -DAPP_BUNDLE=/path/to/kge.app -P cmake/fix_bundle.cmake
+
+if (NOT APP_BUNDLE)
+    message(FATAL_ERROR "APP_BUNDLE not set. Invoke with -DAPP_BUNDLE=/path/to/App.app")
+endif ()
+
+get_filename_component(APP_DIR "${APP_BUNDLE}" ABSOLUTE)
+set(EXECUTABLE "${APP_DIR}/Contents/MacOS/kge")
+
+if (NOT EXISTS "${EXECUTABLE}")
+    message(FATAL_ERROR "Executable not found at: ${EXECUTABLE}")
+endif ()
+
+include(BundleUtilities)
+
+# Directories to search when resolving prerequisites. We include Homebrew so that
+# if any deps are currently resolved from there, fixup_bundle will copy them into
+# the bundle and rewrite install names to be self-contained.
+set(DIRS
+        "/usr/local/lib"
+        "/opt/homebrew/lib"
+        "/opt/homebrew/opt"
+)
+
+# Note: We pass empty plugin list so fixup_bundle scans the executable and all
+# libs it references recursively. Qt frameworks already live in the bundle after
+# macdeployqt; this step is primarily for non-Qt dylibs (glib, icu, pcre2, zstd,
+# dbus, etc.).
+# fixup_bundle often fails if copied libraries are read-only.
+# We also try to use the system install_name_tool and otool to avoid issues with Anaconda's version.
+# Note: BundleUtilities uses find_program(gp_otool "otool") internally, so we might need to set it differently.
+set(gp_otool "/usr/bin/otool")
+set(CMAKE_INSTALL_NAME_TOOL "/usr/bin/install_name_tool")
+set(CMAKE_OTOOL "/usr/bin/otool")
+set(ENV{PATH} "/usr/bin:/bin:/usr/sbin:/sbin")
+
+execute_process(COMMAND chmod -R u+w "${APP_DIR}/Contents/Frameworks")
+
+fixup_bundle("${APP_DIR}" "" "${DIRS}")
+
+# On Apple Silicon (and modern macOS in general), modifications by fixup_bundle
+# invalidate code signatures. We must re-sign the bundle (at least ad-hoc)
+# for it to be allowed to run.
+# We sign deep, but sometimes explicit signing of components is more reliable.
+message(STATUS "Re-signing ${APP_DIR} after fixup...")
+
+# 1. Sign dylibs in Frameworks
+file(GLOB_RECURSE DYLIBS "${APP_DIR}/Contents/Frameworks/*.dylib")
+foreach (DYLIB ${DYLIBS})
+    message(STATUS "Signing ${DYLIB}...")
+    execute_process(COMMAND /usr/bin/codesign --force --sign - "${DYLIB}")
+endforeach ()
+
+# 2. Sign nested executables
+message(STATUS "Signing nested kte...")
+execute_process(COMMAND /usr/bin/codesign --force --sign - "${APP_DIR}/Contents/MacOS/kte")
+
+# 3. Sign the main executable explicitly
+message(STATUS "Signing main kge...")
+execute_process(COMMAND /usr/bin/codesign --force --sign - "${APP_DIR}/Contents/MacOS/kge")
+
+# 4. Sign the main bundle
+execute_process(
+        COMMAND /usr/bin/codesign --force --deep --sign - "${APP_DIR}"
+        RESULT_VARIABLE CODESIGN_RESULT
+)
+
+if (NOT CODESIGN_RESULT EQUAL 0)
+    message(FATAL_ERROR "Codesign failed with error: ${CODESIGN_RESULT}")
+endif ()
+
+message(STATUS "fix_bundle.cmake completed for ${APP_DIR}")

fonts/Font.cc

@@ -1,4 +1,5 @@
 #include "Font.h"
+#include "IosevkaExtended.h"
 
 #include "imgui.h"
 
@@ -8,16 +9,32 @@ Font::Load(const float size) const
 {
 	const ImGuiIO &io = ImGui::GetIO();
 	io.Fonts->Clear();
-	const ImFont *font = io.Fonts->AddFontFromMemoryCompressedTTF(
+
+	ImFontConfig config;
+	config.MergeMode = false;
+
+	// Load Basic Latin + Latin Supplement
+	io.Fonts->AddFontFromMemoryCompressedTTF(
 		this->data_,
 		this->size_,
-		size);
+		size,
+		&config,
+		io.Fonts->GetGlyphRangesDefault());
 
-	if (!font) {
-		font = io.Fonts->AddFontDefault();
-	}
+	// Merge Greek and Mathematical symbols from IosevkaExtended as fallback
+	config.MergeMode                       = true;
+	static const ImWchar extended_ranges[] = {
+		0x0370, 0x03FF, // Greek and Coptic
+		0x2200, 0x22FF, // Mathematical Operators
+		0,
+	};
+	io.Fonts->AddFontFromMemoryCompressedTTF(
+		kte::Fonts::IosevkaExtended::DefaultFontRegularCompressedData,
+		kte::Fonts::IosevkaExtended::DefaultFontRegularCompressedSize,
+		size,
+		&config,
+		extended_ranges);
 
-	(void) font;
 	io.Fonts->Build();
 }
 } // namespace kte::Fonts

main.cc

@@ -1,3 +1,4 @@
+#include <clocale>
 #include <cctype>
 #include <cerrno>
 #include <cstdio>
@@ -111,8 +112,10 @@ RunStressHighlighter(unsigned seconds)
 
 
 int
-main(int argc, const char *argv[])
+main(int argc, char *argv[])
 {
+	std::setlocale(LC_ALL, "");
+
 	Editor editor;
 
 	// CLI parsing using getopt_long
@@ -133,7 +136,7 @@ main(int argc, const char *argv[])
 	int opt;
 	int long_index          = 0;
 	unsigned stress_seconds = 0;
-	while ((opt = getopt_long(argc, const_cast<char *const *>(argv), "gthV", long_opts, &long_index)) != -1) {
+	while ((opt = getopt_long(argc, argv, "gthV", long_opts, &long_index)) != -1) {
 		switch (opt) {
 		case 'g':
 			req_gui = true;
@@ -300,7 +303,7 @@ main(int argc, const char *argv[])
 	}
 #endif
 
-	if (!fe->Init(editor)) {
+	if (!fe->Init(argc, argv, editor)) {
 		std::cerr << "kte: failed to initialize frontend" << std::endl;
 		return 1;
 	}

tests/test_reflow_paragraph.cc

@@ -0,0 +1,102 @@
+#include "Test.h"
+
+#include "Buffer.h"
+#include "Command.h"
+#include "Editor.h"
+
+#include <iostream>
+#include <string>
+
+
+static std::string
+to_string_rows(const Buffer &buf)
+{
+	std::string out;
+	for (const auto &r: buf.Rows()) {
+		out += static_cast<std::string>(r);
+		out.push_back('\n');
+	}
+	return out;
+}
+
+
+TEST (ReflowParagraph_NumberedList_HangingIndent)
+{
+	InstallDefaultCommands();
+
+	Editor ed;
+	ed.SetDimensions(24, 80);
+
+	Buffer b;
+	// Two list items in one paragraph (no blank lines).
+	// Second line of each item already uses a hanging indent.
+	const std::string initial =
+		"1. one two three four five six seven eight nine ten eleven\n"
+		"   twelve thirteen fourteen\n"
+		"10. alpha beta gamma delta epsilon zeta eta theta iota kappa lambda\n"
+		"    mu nu xi omicron\n";
+	b.insert_text(0, 0, initial);
+	// Put cursor on first item
+	b.SetCursor(0, 0);
+	ed.AddBuffer(std::move(b));
+
+	Buffer *buf = ed.CurrentBuffer();
+	ASSERT_TRUE(buf != nullptr);
+
+	const int width = 25;
+	ASSERT_TRUE(Execute(ed, std::string("reflow-paragraph"), std::string(), width));
+
+	const auto &rows = buf->Rows();
+	ASSERT_TRUE(!rows.empty());
+	const std::string dump = to_string_rows(*buf);
+
+	// Find the start of the second item.
+	bool any_too_long  = false;
+	std::size_t idx_10 = rows.size();
+	for (std::size_t i = 0; i < rows.size(); ++i) {
+		const std::string line = static_cast<std::string>(rows[i]);
+		if (static_cast<int>(line.size()) > width)
+			any_too_long = true;
+		if (line.rfind("10. ", 0) == 0) {
+			idx_10 = i;
+			break;
+		}
+	}
+	ASSERT_TRUE(idx_10 < rows.size());
+	if (any_too_long) {
+		std::cerr << "Reflow produced a line longer than width=" << width << "\n";
+		std::cerr << to_string_rows(*buf) << "\n";
+	}
+	EXPECT_TRUE(!any_too_long);
+
+	// Item 1: first line has "1. ", continuation lines have 3 spaces.
+	for (std::size_t i = 0; i < idx_10; ++i) {
+		const std::string line = static_cast<std::string>(rows[i]);
+		if (i == 0) {
+			ASSERT_TRUE(line.rfind("1. ", 0) == 0);
+		} else {
+			ASSERT_TRUE(line.rfind("   ", 0) == 0);
+			ASSERT_TRUE(line.rfind("1. ", 0) != 0);
+		}
+	}
+
+	// Item 10: first line has "10. ", continuation lines have 4 spaces.
+	ASSERT_TRUE(static_cast<std::string>(rows[idx_10]).rfind("10. ", 0) == 0);
+	bool bad_10 = false;
+	for (std::size_t i = idx_10 + 1; i < rows.size(); ++i) {
+		const std::string line = static_cast<std::string>(rows[i]);
+		if (line.empty())
+			break; // paragraph terminator / trailing empty line
+		if (line.rfind("    ", 0) != 0)
+			bad_10 = true;
+		if (line.rfind("10. ", 0) == 0)
+			bad_10 = true;
+	}
+	if (bad_10) {
+		std::cerr << "Unexpected prefix in reflow output:\n" << dump << "\n";
+	}
+	ASSERT_TRUE(!bad_10);
+
+	// Debug helper if something goes wrong (kept as a string for easy inspection).
+	EXPECT_TRUE(!to_string_rows(*buf).empty());
+}

tests/test_undo.cc

@@ -0,0 +1,940 @@
+#include "Test.h"
+#include "Buffer.h"
+
+#include "Command.h"
+#include "Editor.h"
+
+#include <cstddef>
+#include <random>
+
+#if defined(KTE_TESTS)
+#include <unordered_set>
+
+static void
+validate_undo_subtree(const UndoNode *node, const UndoNode *expected_parent,
+                      std::unordered_set<const UndoNode *> &seen)
+{
+	ASSERT_TRUE(node != nullptr);
+	ASSERT_TRUE(seen.find(node) == seen.end());
+	seen.insert(node);
+	ASSERT_TRUE(node->parent == expected_parent);
+
+	// Validate each redo branch under this node.
+	for (const UndoNode *ch = node->child; ch != nullptr; ch = ch->next) {
+		validate_undo_subtree(ch, node, seen);
+	}
+}
+
+
+static void
+validate_undo_tree(const UndoSystem &u)
+{
+	const UndoTree &t = u.TreeForTests();
+
+	std::unordered_set<const UndoNode *> seen;
+	for (const UndoNode *root = t.root; root != nullptr; root = root->next) {
+		validate_undo_subtree(root, nullptr, seen);
+	}
+
+	// current/saved must either be null or be reachable from some root.
+	if (t.current)
+		ASSERT_TRUE(seen.find(t.current) != seen.end());
+	if (t.saved)
+		ASSERT_TRUE(seen.find(t.saved) != seen.end());
+
+	// pending is detached (not part of the committed tree).
+	if (t.pending) {
+		ASSERT_TRUE(seen.find(t.pending) == seen.end());
+		ASSERT_TRUE(t.pending->parent == nullptr);
+		ASSERT_TRUE(t.pending->child == nullptr);
+		ASSERT_TRUE(t.pending->next == nullptr);
+	}
+}
+#endif
+
+
+TEST (Undo_InsertRun_Coalesces)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Simulate two separate "typed" insert commands without committing in between.
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("h"));
+	u->Append('h');
+	b.SetCursor(1, 0);
+
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("i"));
+	u->Append('i');
+	b.SetCursor(2, 0);
+
+	u->commit();
+	ASSERT_EQ(b.Rows().size(), (std::size_t) 1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("hi"));
+
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string(""));
+}
+
+
+TEST (Undo_BackspaceRun_Coalesces)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Seed content.
+	b.insert_text(0, 0, std::string_view("abc"));
+	b.SetCursor(3, 0);
+	u->mark_saved();
+
+	// Simulate two backspaces: delete 'c' then 'b'.
+	{
+		const auto &rows = b.Rows();
+		char deleted     = rows[0][2];
+		b.delete_text(0, 2, 1);
+		b.SetCursor(2, 0);
+		u->Begin(UndoType::Delete);
+		u->Append(deleted);
+	}
+	{
+		const auto &rows = b.Rows();
+		char deleted     = rows[0][1];
+		b.delete_text(0, 1, 1);
+		b.SetCursor(1, 0);
+		u->Begin(UndoType::Delete);
+		u->Append(deleted);
+	}
+
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// One undo should restore both characters.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("abc"));
+}
+
+
+TEST (Undo_Branching_RedoPreservedAfterNewEdit)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+	u->commit();
+
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+	u->commit();
+
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// New edit after undo creates a new branch; the old redo should remain as an alternate branch.
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("c"));
+	u->Append('c');
+	b.SetCursor(2, 0);
+	u->commit();
+
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+
+	// No further redo from the tip.
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+
+	// Undo back to the branch point and redo the original branch.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	u->redo(1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+}
+
+
+TEST (Undo_DirtyFlag_MarkSavedAndUndoRedo)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	u->mark_saved();
+	ASSERT_TRUE(!b.Dirty());
+
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("x"));
+	u->Append('x');
+	b.SetCursor(1, 0);
+	u->commit();
+
+	ASSERT_TRUE(b.Dirty());
+	u->undo();
+	ASSERT_TRUE(!b.Dirty());
+	u->redo();
+	ASSERT_TRUE(b.Dirty());
+}
+
+
+TEST (Undo_Newline_UndoRedo_SplitJoin)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Seed a single line and split it.
+	b.insert_text(0, 0, std::string_view("hello"));
+	b.SetCursor(2, 0); // split after "he"
+	u->Begin(UndoType::Newline);
+	b.split_line(0, 2);
+	u->commit();
+
+	ASSERT_EQ(b.Rows().size(), (std::size_t) 2);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("he"));
+	ASSERT_EQ(std::string(b.Rows()[1]), std::string("llo"));
+
+	// Undo should join the lines back.
+	u->undo();
+	ASSERT_EQ(b.Rows().size(), (std::size_t) 1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("hello"));
+
+	// Redo should split again at the same point.
+	u->redo();
+	ASSERT_EQ(b.Rows().size(), (std::size_t) 2);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("he"));
+	ASSERT_EQ(std::string(b.Rows()[1]), std::string("llo"));
+}
+
+
+TEST (Undo_DeleteKeyRun_Coalesces)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Seed content: delete-key semantics keep cursor at the same column.
+	b.insert_text(0, 0, std::string_view("abcd"));
+	b.SetCursor(1, 0); // on 'b'
+
+	// Delete 'b'
+	{
+		const auto &rows = b.Rows();
+		char deleted     = rows[0][1];
+		u->Begin(UndoType::Delete);
+		b.delete_text(0, 1, 1);
+		u->Append(deleted);
+		b.SetCursor(1, 0);
+	}
+	// Delete next char (was 'c', now at same col=1)
+	{
+		const auto &rows = b.Rows();
+		char deleted     = rows[0][1];
+		u->Begin(UndoType::Delete);
+		b.delete_text(0, 1, 1);
+		u->Append(deleted);
+		b.SetCursor(1, 0);
+	}
+
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ad"));
+
+	// One undo should restore both deleted characters.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("abcd"));
+}
+
+
+TEST (Undo_UndoPastFirstEdit_RedoFromPreFirstEdit)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Commit two separate insert edits.
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+	u->commit();
+
+	b.SetCursor(1, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+	u->commit();
+
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	// Undo twice: we should reach the pre-first-edit state.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string(""));
+
+	// Redo twice should restore both edits.
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+}
+
+
+TEST (Undo_NewEditFromPreFirstEdit_PreservesOldHistoryAsAlternateRootBranch)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Build up two edits.
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+	u->commit();
+
+	b.SetCursor(1, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+	u->commit();
+
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	// Undo past first edit so current becomes null.
+	u->undo();
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string(""));
+
+	// Commit a new edit from the pre-first-edit state.
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("x"));
+	u->Append('x');
+	b.SetCursor(1, 0);
+	u->commit();
+
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("x"));
+
+	// From the tip, no further redo.
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("x"));
+
+	// Undo back to pre-first-edit and select the older root branch.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string(""));
+	u->redo(1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+}
+
+
+TEST (Undo_MultiLineDelete_ConsumesNewline_UndoRestores)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Create two lines. PieceTable treats '\n' between logical lines.
+	b.insert_text(0, 0, std::string_view("ab\ncd"));
+	ASSERT_EQ(b.Rows().size(), (std::size_t) 2);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+	ASSERT_EQ(std::string(b.Rows()[1]), std::string("cd"));
+
+	// Delete spanning the newline: delete "b\n" starting at (0,1).
+	b.SetCursor(1, 0);
+	u->Begin(UndoType::Delete);
+	b.delete_text(0, 1, 2);
+	u->Append(std::string_view("b\n"));
+	u->commit();
+
+	ASSERT_EQ(b.Rows().size(), (std::size_t) 1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("acd"));
+
+	// Undo should restore exact original text/line structure.
+	u->undo();
+	ASSERT_EQ(b.Rows().size(), (std::size_t) 2);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+	ASSERT_EQ(std::string(b.Rows()[1]), std::string("cd"));
+}
+
+
+TEST (Undo_DeleteIndent_UndoRestoresCursorAtText)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Seed 3-line content with indentation on the middle line.
+	b.insert_text(0, 0,
+	              std::string_view("I did a thing\n  and then I edited a thing\nbut there were gaps"));
+	ASSERT_EQ(b.Rows().size(), (std::size_t) 3);
+
+	// Cursor at start of the line (before spaces), then C-d C-d deletes two spaces.
+	b.SetCursor(0, 1);
+	for (int i = 0; i < 2; ++i) {
+		const auto &rows = b.Rows();
+		char deleted     = rows[1][0];
+		ASSERT_EQ(deleted, ' ');
+		u->Begin(UndoType::Delete);
+		b.delete_text(1, 0, 1);
+		u->Append(deleted);
+		b.SetCursor(0, 1); // delete-key keeps col the same
+	}
+	u->commit();
+
+	ASSERT_EQ(std::string(b.Rows()[1]), std::string("and then I edited a thing"));
+	ASSERT_EQ(b.Cury(), (std::size_t) 1);
+	ASSERT_EQ(b.Curx(), (std::size_t) 0);
+
+	// Undo should restore indentation, and keep cursor on the text (at 'a'), not at EOL.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[1]), std::string("  and then I edited a thing"));
+	ASSERT_EQ(b.Cury(), (std::size_t) 1);
+	ASSERT_EQ(b.Curx(), (std::size_t) 2);
+}
+
+
+TEST (Undo_StructuralInvariants_BranchingAndRoots)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Build history: a -> b
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+	u->commit();
+
+	b.SetCursor(1, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	// Undo past first edit; now create a new root-level branch x.
+	u->undo();
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string(""));
+
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("x"));
+	u->Append('x');
+	b.SetCursor(1, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("x"));
+
+	// Return to the older root branch.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string(""));
+	u->redo(1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Create a normal branch under 'a'.
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("c"));
+	u->Append('c');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_BranchSelection_ThreeSiblingsAndHeadPersists)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Root: a
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Branch 1: a->b
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	// Back to branch point.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Branch 2: a->c
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("c"));
+	u->Append('c');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Branch 3: a->d
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("d"));
+	u->Append('d');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ad"));
+
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Under 'a', the sibling list should now contain 3 branches.
+	validate_undo_tree(*u);
+
+	// Select the 3rd sibling (branch_index=2) which should be the oldest ("b"), and make it active.
+	u->redo(2);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Since we selected "b", redo with default should now follow "b" again.
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Select another branch by index and ensure it becomes the new default.
+	u->redo(1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ad"));
+	u->undo();
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ad"));
+	u->undo();
+
+	// Out-of-range selection should be a no-op.
+	u->redo(99);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_Branching_SwitchBetweenTwoRedoBranches_TextAndCursor)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Build A->B.
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	ASSERT_EQ(b.Cury(), (std::size_t) 0);
+	ASSERT_EQ(b.Curx(), (std::size_t) 1);
+
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+	ASSERT_EQ(b.Curx(), (std::size_t) 2);
+
+	// Undo to A.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	ASSERT_EQ(b.Curx(), (std::size_t) 1);
+
+	// Create sibling branch A->C.
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("c"));
+	u->Append('c');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+	ASSERT_EQ(b.Curx(), (std::size_t) 2);
+
+	// Back to A.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	ASSERT_EQ(b.Curx(), (std::size_t) 1);
+
+	// Redo into B as the alternate branch (older sibling), and confirm cursor is consistent.
+	u->redo(1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+	ASSERT_EQ(b.Curx(), (std::size_t) 2);
+
+	// Both branches remain reachable: undo to A, redo defaults to B (head reordered).
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	// And the other branch C should still be selectable.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	u->redo(1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+	ASSERT_EQ(b.Curx(), (std::size_t) 2);
+
+	// After selecting C, default redo from A should now follow C.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_Randomized_Deterministic_EditUndoRedoBranchSelect)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	std::mt19937 rng(0xC0FFEEu);
+	std::uniform_int_distribution<int> op(0, 99);
+	std::uniform_int_distribution<int> ch(0, 25);
+
+	const int steps      = 300;
+	const int max_len    = 40;
+	const int max_branch = 4;
+
+	for (int i = 0; i < steps; ++i) {
+		ASSERT_TRUE(!b.Rows().empty());
+		ASSERT_EQ(b.Cury(), (std::size_t) 0);
+		ASSERT_EQ(b.Rows().size(), (std::size_t) 1);
+		ASSERT_TRUE(b.Curx() <= b.Rows()[0].size());
+
+		validate_undo_tree(*u);
+
+		int r           = op(rng);
+		std::string cur = std::string(b.Rows()[0]);
+		int len         = static_cast<int>(cur.size());
+
+		if (r < 40 && len < max_len) {
+			// Insert one char at end as a standalone committed node.
+			char c = static_cast<char>('a' + ch(rng));
+			b.SetCursor(static_cast<std::size_t>(len), 0);
+			u->Begin(UndoType::Insert);
+			b.insert_text(0, len, std::string_view(&c, 1));
+			u->Append(c);
+			b.SetCursor(static_cast<std::size_t>(len + 1), 0);
+			u->commit();
+		} else if (r < 60 && len > 0) {
+			// Backspace at end as a standalone committed node.
+			char deleted = cur[static_cast<std::size_t>(len - 1)];
+			b.delete_text(0, len - 1, 1);
+			b.SetCursor(static_cast<std::size_t>(len - 1), 0);
+			u->Begin(UndoType::Delete);
+			u->Append(deleted);
+			u->commit();
+		} else if (r < 80) {
+			// Undo then redo should round-trip to the exact same node/text/cursor when possible.
+			const UndoNode *before_node = u->TreeForTests().current;
+			const std::string before_text(std::string(b.Rows()[0]));
+			const std::size_t before_x = b.Curx();
+
+			if (before_node) {
+				u->undo();
+				u->redo();
+				ASSERT_TRUE(u->TreeForTests().current == before_node);
+				ASSERT_EQ(std::string(b.Rows()[0]), before_text);
+				ASSERT_EQ(b.Curx(), before_x);
+			} else {
+				// Nothing to undo; just exercise redo/branch-select paths.
+				u->redo();
+			}
+		} else if (r < 90) {
+			u->undo();
+		} else {
+			int idx = static_cast<int>(rng() % static_cast<std::uint32_t>(max_branch));
+			if ((rng() % 8u) == 0u)
+				idx = 99; // intentionally out of range sometimes
+			u->redo(idx);
+		}
+	}
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_PendingCoalescedRun_UndoCommitsThenUndoes)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Create a coalesced insert run without an explicit commit.
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	// undo() should implicitly commit pending and then undo it as one step.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string(""));
+
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_PendingRunAtBranchPoint_UndoThenBranchSelectionStillWorks)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Build a->b.
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+	u->commit();
+
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	// Undo to the branch point.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Start a pending insert "c" at the branch point, but don't commit.
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("c"));
+	u->Append('c');
+	b.SetCursor(2, 0);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+
+	// Undo should seal the pending "c" as a new branch, then undo it, leaving us at "a".
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// The active redo should now be "c".
+	u->redo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	// Select the older "b" branch.
+	u->redo(1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_SavedNodeOnOtherBranch_DirtyClearsWhenReturning)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Build a->b and mark saved at the tip.
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	b.SetCursor(1, 0);
+	u->commit();
+
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	b.SetCursor(2, 0);
+	u->commit();
+	u->mark_saved();
+	ASSERT_TRUE(!b.Dirty());
+
+	// Move to a different branch.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("c"));
+	u->Append('c');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ac"));
+	ASSERT_TRUE(b.Dirty());
+
+	// Return to the saved node by selecting the older branch.
+	u->undo();
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("a"));
+	u->redo(1);
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("ab"));
+	ASSERT_TRUE(!b.Dirty());
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_Clear_AfterSaved_ResetsStateSafely)
+{
+	Buffer b;
+	UndoSystem *u = b.Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	b.SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 0, std::string_view("x"));
+	u->Append('x');
+	b.SetCursor(1, 0);
+	u->commit();
+	u->mark_saved();
+	ASSERT_TRUE(!b.Dirty());
+
+	u->Begin(UndoType::Insert);
+	b.insert_text(0, 1, std::string_view("y"));
+	u->Append('y');
+	b.SetCursor(2, 0);
+	u->commit();
+	ASSERT_TRUE(b.Dirty());
+
+	u->clear();
+	ASSERT_TRUE(!b.Dirty());
+	// clear() resets undo history, but does not mutate buffer contents.
+	ASSERT_EQ(std::string(b.Rows()[0]), std::string("xy"));
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_Command_UndoHonorsRepeatCount)
+{
+	InstallDefaultCommands();
+
+	Editor ed;
+	ed.SetDimensions(24, 80);
+
+	Buffer b;
+	ed.AddBuffer(std::move(b));
+	Buffer *buf = ed.CurrentBuffer();
+	ASSERT_TRUE(buf != nullptr);
+	UndoSystem *u = buf->Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Create two committed steps using the undo system directly.
+	buf->SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	buf->insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	buf->SetCursor(1, 0);
+	u->commit();
+
+	u->Begin(UndoType::Insert);
+	buf->insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	buf->SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string("ab"));
+
+	// Undo twice via command repeat count.
+	ed.SetUniversalArg(1, 2);
+	ASSERT_TRUE(Execute(ed, CommandId::Undo));
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string(""));
+
+	validate_undo_tree(*u);
+}
+
+
+TEST (Undo_Command_RedoCountSelectsBranch)
+{
+	InstallDefaultCommands();
+
+	Editor ed;
+	ed.SetDimensions(24, 80);
+
+	Buffer b;
+	ed.AddBuffer(std::move(b));
+	Buffer *buf = ed.CurrentBuffer();
+	ASSERT_TRUE(buf != nullptr);
+	UndoSystem *u = buf->Undo();
+	ASSERT_TRUE(u != nullptr);
+
+	// Build a->b.
+	buf->SetCursor(0, 0);
+	u->Begin(UndoType::Insert);
+	buf->insert_text(0, 0, std::string_view("a"));
+	u->Append('a');
+	buf->SetCursor(1, 0);
+	u->commit();
+
+	u->Begin(UndoType::Insert);
+	buf->insert_text(0, 1, std::string_view("b"));
+	u->Append('b');
+	buf->SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string("ab"));
+
+	// Undo to the branch point and create a sibling branch "c".
+	u->undo();
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string("a"));
+
+	u->Begin(UndoType::Insert);
+	buf->insert_text(0, 1, std::string_view("c"));
+	u->Append('c');
+	buf->SetCursor(2, 0);
+	u->commit();
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string("ac"));
+
+	// Back to branch point.
+	ASSERT_TRUE(Execute(ed, CommandId::Undo));
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string("a"));
+
+	// Command redo with count=2 should select branch_index=1 (the older "b" branch).
+	ed.SetUniversalArg(1, 2);
+	ASSERT_TRUE(Execute(ed, CommandId::Redo));
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string("ab"));
+
+	// After selection, "b" should be the default redo from the branch point.
+	ASSERT_TRUE(Execute(ed, CommandId::Undo));
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string("a"));
+	ASSERT_TRUE(Execute(ed, CommandId::Redo));
+	ASSERT_EQ(std::string(buf->Rows()[0]), std::string("ab"));
+
+	validate_undo_tree(*u);
+}

tests/test_visual_line_mode.cc

@@ -0,0 +1,158 @@
+#include "Test.h"
+
+#include "Buffer.h"
+#include "Command.h"
+#include "Editor.h"
+
+#include <string>
+
+
+static std::string
+dump_buf(const Buffer &buf)
+{
+	std::string out;
+	for (const auto &r: buf.Rows()) {
+		out += static_cast<std::string>(r);
+		out.push_back('\n');
+	}
+	return out;
+}
+
+
+static std::string
+dump_bytes(const std::string &s)
+{
+	static const char *hex = "0123456789abcdef";
+	std::string out;
+	for (unsigned char c: s) {
+		out.push_back(hex[(c >> 4) & 0xF]);
+		out.push_back(hex[c & 0xF]);
+		out.push_back(' ');
+	}
+	return out;
+}
+
+
+TEST (VisualLineMode_BroadcastInsert)
+{
+	InstallDefaultCommands();
+
+	Editor ed;
+	ed.SetDimensions(24, 80);
+
+	Buffer b;
+	b.insert_text(0, 0, "foo\nfoo\nfoo\n");
+	b.SetCursor(1, 0); // fo|o
+	ed.AddBuffer(std::move(b));
+
+	ASSERT_TRUE(ed.CurrentBuffer() != nullptr);
+
+	// Enter visual-line mode and extend selection to 3 lines
+	ASSERT_TRUE(Execute(ed, std::string("visual-line-toggle")));
+	ASSERT_TRUE(Execute(ed, std::string("down"), std::string(), 2));
+
+	// Broadcast insert to all selected lines
+	ASSERT_TRUE(Execute(ed, std::string("insert"), std::string("X")));
+
+	const std::string got = dump_buf(*ed.CurrentBuffer());
+	// Note: buffers that end with a trailing '\n' have an extra empty row.
+	const std::string exp = "fXoo\nfXoo\nfXoo\n\n";
+	if (got != exp) {
+		std::cerr << "Expected (len=" << exp.size() << ") bytes: " << dump_bytes(exp) << "\n";
+		std::cerr << "Got      (len=" << got.size() << ") bytes: " << dump_bytes(got) << "\n";
+	}
+	ASSERT_TRUE(got == exp);
+}
+
+
+TEST (VisualLineMode_BroadcastBackspace)
+{
+	InstallDefaultCommands();
+
+	Editor ed;
+	ed.SetDimensions(24, 80);
+
+	Buffer b;
+	b.insert_text(0, 0, "abcd\nabcd\nabcd\n");
+	b.SetCursor(2, 0); // ab|cd
+	ed.AddBuffer(std::move(b));
+
+	ASSERT_TRUE(Execute(ed, std::string("visual-line-toggle")));
+	ASSERT_TRUE(Execute(ed, std::string("down"), std::string(), 2));
+
+	ASSERT_TRUE(Execute(ed, std::string("backspace")));
+	const std::string got = dump_buf(*ed.CurrentBuffer());
+	// Note: buffers that end with a trailing '\n' have an extra empty row.
+	const std::string exp = "acd\nacd\nacd\n\n";
+	if (got != exp) {
+		std::cerr << "Expected (len=" << exp.size() << ") bytes: " << dump_bytes(exp) << "\n";
+		std::cerr << "Got      (len=" << got.size() << ") bytes: " << dump_bytes(got) << "\n";
+	}
+	ASSERT_TRUE(got == exp);
+}
+
+
+TEST (VisualLineMode_CancelWithCtrlG)
+{
+	InstallDefaultCommands();
+
+	Editor ed;
+	ed.SetDimensions(24, 80);
+
+	Buffer b;
+	b.insert_text(0, 0, "foo\nfoo\nfoo\n");
+	b.SetCursor(1, 0);
+	ed.AddBuffer(std::move(b));
+
+	ASSERT_TRUE(Execute(ed, std::string("visual-line-toggle")));
+	ASSERT_TRUE(Execute(ed, std::string("down"), std::string(), 2));
+
+	// C-g is mapped to "refresh" and should cancel visual-line mode.
+	ASSERT_TRUE(Execute(ed, std::string("refresh")));
+	ASSERT_TRUE(ed.CurrentBuffer() != nullptr);
+	ASSERT_TRUE(!ed.CurrentBuffer()->VisualLineActive());
+
+	// After cancel, edits should only affect the primary cursor line.
+	ASSERT_TRUE(Execute(ed, std::string("insert"), std::string("X")));
+	const std::string got = dump_buf(*ed.CurrentBuffer());
+	// Cursor is still on the last line we moved to (down, down).
+	const std::string exp = "foo\nfoo\nfXoo\n\n";
+	if (got != exp) {
+		std::cerr << "Expected (len=" << exp.size() << ") bytes: " << dump_bytes(exp) << "\n";
+		std::cerr << "Got      (len=" << got.size() << ") bytes: " << dump_bytes(got) << "\n";
+	}
+	ASSERT_TRUE(got == exp);
+}
+
+
+TEST (Yank_ClearsMarkAndVisualLine)
+{
+	InstallDefaultCommands();
+
+	Editor ed;
+	ed.SetDimensions(24, 80);
+
+	Buffer b;
+	b.insert_text(0, 0, "foo\nbar\n");
+	b.SetCursor(1, 0);
+	ed.AddBuffer(std::move(b));
+
+	ASSERT_TRUE(ed.CurrentBuffer() != nullptr);
+	Buffer *buf = ed.CurrentBuffer();
+
+	// Seed mark + visual-line highlighting.
+	buf->SetMark(buf->Curx(), buf->Cury());
+	ASSERT_TRUE(buf->MarkSet());
+
+	ASSERT_TRUE(Execute(ed, std::string("visual-line-toggle")));
+	ASSERT_TRUE(Execute(ed, std::string("down"), std::string(), 1));
+	ASSERT_TRUE(buf->VisualLineActive());
+
+	// Yank should clear mark and any highlighting.
+	ed.KillRingClear();
+	ed.KillRingPush("X");
+	ASSERT_TRUE(Execute(ed, std::string("yank")));
+
+	ASSERT_TRUE(!buf->MarkSet());
+	ASSERT_TRUE(!buf->VisualLineActive());
+}