Enable LSP debug logging, expand language feature support, and fix GUI rendering issues.

- Added `--debug` CLI flag to control LSP debug logging and corresponding environment setting.
- Extended LSP capabilities with basic hover, completion, and definition feature support.
- Removed redundant `NoScrollWithMouse` flag, resolving inconsistencies in GUI scrolling behavior.
- Refined variable usage and type consistency across LSP and rendering modules.
- Updated `LspManager` for improved buffer handling and server diagnostics integration.

.gitignore

@@ -1,5 +1,6 @@
 !.idea
 cmake-build*
 build
+build-*
 /imgui.ini
 result

.idea/codeStyles/Project.xml

@@ -141,8 +141,12 @@
         <pair source="c++m" header="" fileNamingConvention="NONE" />
       </extensions>
     </files>
-    <codeStyleSettings language="Markdown">
+    <codeStyleSettings language="CMake">
-      <option name="RIGHT_MARGIN" value="72" />
+      <indentOptions>
+        <option name="INDENT_SIZE" value="8" />
+        <option name="TAB_SIZE" value="8" />
+        <option name="USE_TAB_CHARACTER" value="true" />
+      </indentOptions>
     </codeStyleSettings>
     <codeStyleSettings language="ObjectiveC">
       <indentOptions>

.idea/codeStyles/codeStyleConfig.xml

@@ -1,6 +1,5 @@
 <component name="ProjectCodeStyleConfiguration">
   <state>
     <option name="USE_PER_PROJECT_SETTINGS" value="true" />
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="sccl" />
   </state>
 </component>

.idea/editor.xml

@@ -19,7 +19,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppBoostFormatTooManyArgs/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCStyleCast/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCVQualifierCanNotBeAppliedToReference/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassIsIncomplete/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassNeedsConstructorBecauseOfUninitializedMember/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
@@ -58,7 +58,6 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDefaultInitializationWithNoUserConstructor/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDefaultIsUsedAsIdentifier/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDefaultedSpecialMemberFunctionIsImplicitlyDeleted/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDefinitionsOrder/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDeletingVoidPointer/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDependentTemplateWithoutTemplateKeyword/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppDependentTypeWithoutTypenameKeyword/@EntryIndexedValue" value="WARNING" type="string" />

.idea/kte.iml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CIDR" type="CPP_MODULE" version="4">
+<module classpath="CMake" type="CPP_MODULE" version="4">
   <component name="FacetManager">
     <facet type="Python" name="Python facet">
       <configuration sdkName="" />

.junie/guidelines.md

@@ -1,35 +1,28 @@
 # Project Guidelines
 
-kte is Kyle's Text Editor — a simple, fast text editor written in C++20.
+kte is Kyle's Text Editor — a simple, fast text editor written in C++17. It
-It
+replaces the earlier C implementation, ke (see the ke manual in `docs/ke.md`). The
-replaces the earlier C implementation, ke (see the ke manual in
+design draws inspiration from Antirez' kilo, with keybindings rooted in the
-`docs/ke.md`). The
-design draws inspiration from Antirez' kilo, with keybindings rooted in
-the
 WordStar/VDE family and emacs. The spiritual parent is `mg(1)`.
 
-These guidelines summarize the goals, interfaces, key operations, and
+These guidelines summarize the goals, interfaces, key operations, and current
-current
 development practices for kte.
 
 ## Goals
 
 - Keep the core small, fast, and understandable.
-- Provide an ncurses-based terminal-first editing experience, with an
+- Provide an ncurses-based terminal-first editing experience, with an additional ImGui GUI.
-  additional ImGui GUI.
 - Preserve familiar keybindings from ke while modernizing the internals.
-- Favor simple data structures (e.g., piece table) and incremental
+- Favor simple data structures (e.g., piece table) and incremental evolution.
-  evolution.
 
 Project entry point: `main.cpp`
 
 ## Core Components (current codebase)
 
 - Buffer: editing model and file I/O (`Buffer.h/.cpp`).
-- PieceTable: editable in-memory text representation (
+- GapBuffer: editable in-memory text representation (`GapBuffer.h/.cpp`).
-  `PieceTable.h/.cpp`).
+- PieceTable: experimental/alternative representation (`PieceTable.h/.cpp`).
-- InputHandler: interface for handling text input (`InputHandler.h/`),
+- InputHandler: interface for handling text input (`InputHandler.h/`), along
-  along
   with `TerminalInputHandler` (ncurses-based) and `GUIInputHandler`.
 - Renderer: interface for rendering text (`Renderer.h`), along with
   `TerminalRenderer` (ncurses-based) and `GUIRenderer`.
@@ -43,16 +36,13 @@ The file `docs/ke.md` contains the canonical reference for keybindings.
 
 ## Contributing/Development Notes
 
-- C++ standard: C++20.
+- C++ standard: C++17.
 - Keep dependencies minimal.
-- Prefer small, focused changes that preserve ke’s UX unless explicitly
+- Prefer small, focused changes that preserve ke’s UX unless explicitly changing
-  changing
   behavior.
 
 ## References
 
-- Previous editor manual: `ke.md` (canonical keybinding/spec reference
+- Previous editor manual: `ke.md` (canonical keybinding/spec reference for now).
-  for now).
 - Inspiration: kilo, WordStar/VDE, emacs, `mg(1)`.
 
-

AppendBuffer.h

@@ -0,0 +1,15 @@
+/*
+ * AppendBuffer.h - selector header to choose GapBuffer or PieceTable
+ */
+#ifndef KTE_APPENDBUFFER_H
+#define KTE_APPENDBUFFER_H
+
+#ifdef KTE_USE_PIECE_TABLE
+#include "PieceTable.h"
+using AppendBuffer = PieceTable;
+#else
+#include "GapBuffer.h"
+using AppendBuffer = GapBuffer;
+#endif
+
+#endif // KTE_APPENDBUFFER_H

Buffer.cc

@@ -2,28 +2,14 @@
 #include <sstream>
 #include <filesystem>
 #include <cstdlib>
-#include <limits>
-#include <cerrno>
-#include <cstring>
-#include <string_view>
-
-#include <vector>
-
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/types.h>
 
 #include "Buffer.h"
-#include "SwapRecorder.h"
 #include "UndoSystem.h"
 #include "UndoTree.h"
-#include "ErrorHandler.h"
-#include "SyscallWrappers.h"
-#include "ErrorRecovery.h"
 // For reconstructing highlighter state on copies
 #include "syntax/HighlighterRegistry.h"
 #include "syntax/NullHighlighter.h"
+#include "lsp/BufferChangeTracker.h"
 
 
 Buffer::Buffer()
@@ -34,175 +20,7 @@ Buffer::Buffer()
 }
 
 
-bool
+Buffer::~Buffer() = default;
-Buffer::stat_identity(const std::string &path, FileIdentity &out)
-{
-	struct stat st{};
-	if (::stat(path.c_str(), &st) != 0) {
-		out.valid = false;
-		return false;
-	}
-	out.valid = true;
-	// Use nanosecond timestamp when available.
-	std::uint64_t ns = 0;
-#if defined(__APPLE__)
-	ns = static_cast<std::uint64_t>(st.st_mtimespec.tv_sec) * 1000000000ull
-	     + static_cast<std::uint64_t>(st.st_mtimespec.tv_nsec);
-#else
-	ns = static_cast<std::uint64_t>(st.st_mtim.tv_sec) * 1000000000ull
-	     + static_cast<std::uint64_t>(st.st_mtim.tv_nsec);
-#endif
-	out.mtime_ns = ns;
-	out.size     = static_cast<std::uint64_t>(st.st_size);
-	out.dev      = static_cast<std::uint64_t>(st.st_dev);
-	out.ino      = static_cast<std::uint64_t>(st.st_ino);
-	return true;
-}
-
-
-bool
-Buffer::current_disk_identity(FileIdentity &out) const
-{
-	if (!is_file_backed_ || filename_.empty()) {
-		out.valid = false;
-		return false;
-	}
-	return stat_identity(filename_, out);
-}
-
-
-bool
-Buffer::ExternallyModifiedOnDisk() const
-{
-	if (!is_file_backed_ || filename_.empty())
-		return false;
-	FileIdentity now{};
-	if (!current_disk_identity(now)) {
-		// If the file vanished, treat as modified when we previously had an identity.
-		return on_disk_identity_.valid;
-	}
-	if (!on_disk_identity_.valid)
-		return false;
-	return now.mtime_ns != on_disk_identity_.mtime_ns
-	       || now.size != on_disk_identity_.size
-	       || now.dev != on_disk_identity_.dev
-	       || now.ino != on_disk_identity_.ino;
-}
-
-
-void
-Buffer::RefreshOnDiskIdentity()
-{
-	FileIdentity id{};
-	if (current_disk_identity(id))
-		on_disk_identity_ = id;
-}
-
-
-static bool
-write_all_fd(int fd, const char *data, std::size_t len, std::string &err)
-{
-	std::size_t off = 0;
-	while (off < len) {
-		ssize_t n = ::write(fd, data + off, len - off);
-		if (n < 0) {
-			if (errno == EINTR)
-				continue;
-			err = std::string("Write failed: ") + std::strerror(errno);
-			return false;
-		}
-		off += static_cast<std::size_t>(n);
-	}
-	return true;
-}
-
-
-static void
-best_effort_fsync_dir(const std::string &path)
-{
-	try {
-		std::filesystem::path p(path);
-		std::filesystem::path dir = p.parent_path();
-		if (dir.empty())
-			return;
-		int dfd = kte::syscall::Open(dir.c_str(), O_RDONLY);
-		if (dfd < 0)
-			return;
-		(void) kte::syscall::Fsync(dfd);
-		(void) kte::syscall::Close(dfd);
-	} catch (...) {
-		// best-effort
-	}
-}
-
-
-static bool
-atomic_write_file(const std::string &path, const char *data, std::size_t len, std::string &err)
-{
-	// Create a temp file in the same directory so rename() is atomic.
-	std::filesystem::path p(path);
-	std::filesystem::path dir  = p.parent_path();
-	std::string base           = p.filename().string();
-	std::filesystem::path tmpl = dir / ("." + base + ".kte.tmp.XXXXXX");
-	std::string tmpl_s         = tmpl.string();
-
-	// mkstemp requires a mutable buffer.
-	std::vector<char> buf(tmpl_s.begin(), tmpl_s.end());
-	buf.push_back('\0');
-
-	// Retry on transient errors for temp file creation
-	int fd          = -1;
-	auto mkstemp_fn = [&]() -> bool {
-		// Reset buffer for each retry attempt
-		buf.assign(tmpl_s.begin(), tmpl_s.end());
-		buf.push_back('\0');
-		fd = kte::syscall::Mkstemp(buf.data());
-		return fd >= 0;
-	};
-
-	if (!kte::RetryOnTransientError(mkstemp_fn, kte::RetryPolicy::Aggressive(), err)) {
-		if (fd < 0) {
-			err = std::string("Failed to create temp file for save: ") + std::strerror(errno) + err;
-		}
-		return false;
-	}
-	std::string tmp_path(buf.data());
-
-	// If the destination exists, carry over its permissions.
-	struct stat dst_st{};
-	if (::stat(path.c_str(), &dst_st) == 0) {
-		(void) kte::syscall::Fchmod(fd, dst_st.st_mode);
-	}
-
-	bool ok = write_all_fd(fd, data, len, err);
-	if (ok) {
-		// Retry fsync on transient errors
-		auto fsync_fn = [&]() -> bool {
-			return kte::syscall::Fsync(fd) == 0;
-		};
-
-		std::string fsync_err;
-		if (!kte::RetryOnTransientError(fsync_fn, kte::RetryPolicy::Aggressive(), fsync_err)) {
-			err = std::string("fsync failed: ") + std::strerror(errno) + fsync_err;
-			ok  = false;
-		}
-	}
-	(void) kte::syscall::Close(fd);
-
-	if (ok) {
-		if (::rename(tmp_path.c_str(), path.c_str()) != 0) {
-			err = std::string("rename failed: ") + std::strerror(errno);
-			ok  = false;
-		}
-	}
-
-	if (!ok) {
-		(void) ::unlink(tmp_path.c_str());
-		return false;
-	}
-	best_effort_fsync_dir(path);
-	return true;
-}
 
 
 Buffer::Buffer(const std::string &path)
@@ -215,22 +33,20 @@ Buffer::Buffer(const std::string &path)
 // Copy constructor/assignment: perform a deep copy of core fields; reinitialize undo for the new buffer.
 Buffer::Buffer(const Buffer &other)
 {
-	curx_             = other.curx_;
+	curx_           = other.curx_;
-	cury_             = other.cury_;
+	cury_           = other.cury_;
-	rx_               = other.rx_;
+	rx_             = other.rx_;
-	nrows_            = other.nrows_;
+	nrows_          = other.nrows_;
-	rowoffs_          = other.rowoffs_;
+	rowoffs_        = other.rowoffs_;
-	coloffs_          = other.coloffs_;
+	coloffs_        = other.coloffs_;
-	rows_             = other.rows_;
+	rows_           = other.rows_;
-	content_          = other.content_;
+	filename_       = other.filename_;
-	rows_cache_dirty_ = other.rows_cache_dirty_;
+	is_file_backed_ = other.is_file_backed_;
-	filename_         = other.filename_;
+	dirty_          = other.dirty_;
-	is_file_backed_   = other.is_file_backed_;
+	read_only_      = other.read_only_;
-	dirty_            = other.dirty_;
+	mark_set_       = other.mark_set_;
-	read_only_        = other.read_only_;
+	mark_curx_      = other.mark_curx_;
-	mark_set_         = other.mark_set_;
+	mark_cury_      = other.mark_cury_;
-	mark_curx_        = other.mark_curx_;
-	mark_cury_        = other.mark_cury_;
 	// Copy syntax/highlighting flags
 	version_        = other.version_;
 	syntax_enabled_ = other.syntax_enabled_;
@@ -265,25 +81,23 @@ Buffer::operator=(const Buffer &other)
 {
 	if (this == &other)
 		return *this;
-	curx_             = other.curx_;
+	curx_           = other.curx_;
-	cury_             = other.cury_;
+	cury_           = other.cury_;
-	rx_               = other.rx_;
+	rx_             = other.rx_;
-	nrows_            = other.nrows_;
+	nrows_          = other.nrows_;
-	rowoffs_          = other.rowoffs_;
+	rowoffs_        = other.rowoffs_;
-	coloffs_          = other.coloffs_;
+	coloffs_        = other.coloffs_;
-	rows_             = other.rows_;
+	rows_           = other.rows_;
-	content_          = other.content_;
+	filename_       = other.filename_;
-	rows_cache_dirty_ = other.rows_cache_dirty_;
+	is_file_backed_ = other.is_file_backed_;
-	filename_         = other.filename_;
+	dirty_          = other.dirty_;
-	is_file_backed_   = other.is_file_backed_;
+	read_only_      = other.read_only_;
-	dirty_            = other.dirty_;
+	mark_set_       = other.mark_set_;
-	read_only_        = other.read_only_;
+	mark_curx_      = other.mark_curx_;
-	mark_set_         = other.mark_set_;
+	mark_cury_      = other.mark_cury_;
-	mark_curx_        = other.mark_curx_;
+	version_        = other.version_;
-	mark_cury_        = other.mark_cury_;
+	syntax_enabled_ = other.syntax_enabled_;
-	version_          = other.version_;
+	filetype_       = other.filetype_;
-	syntax_enabled_   = other.syntax_enabled_;
-	filetype_         = other.filetype_;
 	// Recreate undo system for this instance
 	undo_tree_ = std::make_unique<UndoTree>();
 	undo_sys_  = std::make_unique<UndoSystem>(*this, *undo_tree_);
@@ -327,12 +141,10 @@ Buffer::Buffer(Buffer &&other) noexcept
 	  undo_sys_(std::move(other.undo_sys_))
 {
 	// Move syntax/highlighting state
-	version_          = other.version_;
+	version_        = other.version_;
-	syntax_enabled_   = other.syntax_enabled_;
+	syntax_enabled_ = other.syntax_enabled_;
-	filetype_         = std::move(other.filetype_);
+	filetype_       = std::move(other.filetype_);
-	highlighter_      = std::move(other.highlighter_);
+	highlighter_    = std::move(other.highlighter_);
-	content_          = std::move(other.content_);
-	rows_cache_dirty_ = other.rows_cache_dirty_;
 	// Update UndoSystem's buffer reference to point to this object
 	if (undo_sys_) {
 		undo_sys_->UpdateBufferReference(*this);
@@ -365,12 +177,11 @@ Buffer::operator=(Buffer &&other) noexcept
 	undo_sys_       = std::move(other.undo_sys_);
 
 	// Move syntax/highlighting state
-	version_          = other.version_;
+	version_        = other.version_;
-	syntax_enabled_   = other.syntax_enabled_;
+	syntax_enabled_ = other.syntax_enabled_;
-	filetype_         = std::move(other.filetype_);
+	filetype_       = std::move(other.filetype_);
-	highlighter_      = std::move(other.highlighter_);
+	highlighter_    = std::move(other.highlighter_);
-	content_          = std::move(other.content_);
+
-	rows_cache_dirty_ = other.rows_cache_dirty_;
 	// Update UndoSystem's buffer reference to point to this object
 	if (undo_sys_) {
 		undo_sys_->UpdateBufferReference(*this);
@@ -422,66 +233,59 @@ Buffer::OpenFromFile(const std::string &path, std::string &err)
 		mark_set_  = false;
 		mark_curx_ = mark_cury_ = 0;
 
-		// Empty PieceTable
-		content_.Clear();
-		rows_cache_dirty_ = true;
-
 		return true;
 	}
 
 	std::ifstream in(norm, std::ios::in | std::ios::binary);
 	if (!in) {
 		err = "Failed to open file: " + norm;
-		kte::ErrorHandler::Instance().Error("Buffer", err, norm);
 		return false;
 	}
 
-	// Read entire file into PieceTable as-is
+	// Detect if file ends with a newline so we can preserve a final empty line
-	std::string data;
+	// in our in-memory representation (mg-style semantics).
-	in.seekg(0, std::ios::end);
+	bool ends_with_nl = false;
-	if (!in) {
+	{
-		err = "Failed to seek to end of file: " + norm;
+		in.seekg(0, std::ios::end);
-		kte::ErrorHandler::Instance().Error("Buffer", err, norm);
+		std::streamoff sz = in.tellg();
-		return false;
+		if (sz > 0) {
-	}
+			in.seekg(-1, std::ios::end);
-	auto sz = in.tellg();
+			char last = 0;
-	if (sz < 0) {
+			in.read(&last, 1);
-		err = "Failed to get file size: " + norm;
+			ends_with_nl = (last == '\n');
-		kte::ErrorHandler::Instance().Error("Buffer", err, norm);
+		} else {
-		return false;
+			in.clear();
-	}
+		}
-	if (sz > 0) {
+		// Rewind to start for line-by-line read
-		data.resize(static_cast<std::size_t>(sz));
+		in.clear();
 		in.seekg(0, std::ios::beg);
-		if (!in) {
+	}
-			err = "Failed to seek to beginning of file: " + norm;
+
-			kte::ErrorHandler::Instance().Error("Buffer", err, norm);
+	rows_.clear();
-			return false;
+	std::string line;
+	while (std::getline(in, line)) {
+		// std::getline strips the '\n', keep raw line content only
+		// Handle potential Windows CRLF: strip trailing '\r'
+		if (!line.empty() && line.back() == '\r') {
+			line.pop_back();
 		}
-		in.read(data.data(), static_cast<std::streamsize>(data.size()));
+		rows_.emplace_back(line);
-		if (!in && !in.eof()) {
+	}
-			err = "Failed to read file: " + norm;
+
-			kte::ErrorHandler::Instance().Error("Buffer", err, norm);
+	// If the file ended with a newline and we didn't already get an
-			return false;
+	// empty final row from getline (e.g., when the last textual line
-		}
+	// had content followed by '\n'), append an empty row to represent
-		// Validate we read the expected number of bytes
+	// the cursor position past the last newline.
-		const std::streamsize bytes_read = in.gcount();
+	if (ends_with_nl) {
-		if (bytes_read != static_cast<std::streamsize>(data.size())) {
+		if (rows_.empty() || !rows_.back().empty()) {
-			err = "Partial read of file (expected " + std::to_string(data.size()) +
+			rows_.emplace_back(std::string());
-			      " bytes, got " + std::to_string(bytes_read) + "): " + norm;
-			kte::ErrorHandler::Instance().Error("Buffer", err, norm);
-			return false;
 		}
 	}
-	content_.Clear();
+
-	if (!data.empty())
+	nrows_          = rows_.size();
-		content_.Append(data.data(), data.size());
+	filename_       = norm;
-	rows_cache_dirty_ = true;
+	is_file_backed_ = true;
-	nrows_            = 0; // not used under PieceTable
+	dirty_          = false;
-	filename_         = norm;
-	is_file_backed_   = true;
-	dirty_            = false;
-	RefreshOnDiskIdentity();
 
 	// Reset/initialize undo system for this loaded file
 	if (!undo_tree_)
@@ -508,18 +312,24 @@ Buffer::Save(std::string &err) const
 		err = "Buffer is not file-backed; use SaveAs()";
 		return false;
 	}
-	const std::size_t sz = content_.Size();
+	std::ofstream out(filename_, std::ios::out | std::ios::binary | std::ios::trunc);
-	const char *data     = sz ? content_.Data() : nullptr;
+	if (!out) {
-	if (sz && !data) {
+		err = "Failed to open for write: " + filename_;
-		err = "Internal error: buffer materialization failed";
 		return false;
 	}
-	if (!atomic_write_file(filename_, data ? data : "", sz, err)) {
+	for (std::size_t i = 0; i < rows_.size(); ++i) {
-		kte::ErrorHandler::Instance().Error("Buffer", err, filename_);
+		const char *d = rows_[i].Data();
+		std::size_t n = rows_[i].Size();
+		if (d && n)
+			out.write(d, static_cast<std::streamsize>(n));
+		if (i + 1 < rows_.size()) {
+			out.put('\n');
+		}
+	}
+	if (!out.good()) {
+		err = "Write error";
 		return false;
 	}
-	// Update observed on-disk identity after a successful save.
-	const_cast<Buffer *>(this)->RefreshOnDiskIdentity();
 	// Note: const method cannot change dirty_. Intentionally const to allow UI code
 	// to decide when to flip dirty flag after successful save.
 	return true;
@@ -548,21 +358,29 @@ Buffer::SaveAs(const std::string &path, std::string &err)
 		out_path = path;
 	}
 
-	const std::size_t sz = content_.Size();
+	// Write to the given path
-	const char *data     = sz ? content_.Data() : nullptr;
+	std::ofstream out(out_path, std::ios::out | std::ios::binary | std::ios::trunc);
-	if (sz && !data) {
+	if (!out) {
-		err = "Internal error: buffer materialization failed";
+		err = "Failed to open for write: " + out_path;
 		return false;
 	}
-	if (!atomic_write_file(out_path, data ? data : "", sz, err)) {
+	for (std::size_t i = 0; i < rows_.size(); ++i) {
-		kte::ErrorHandler::Instance().Error("Buffer", err, out_path);
+		const char *d = rows_[i].Data();
+		std::size_t n = rows_[i].Size();
+		if (d && n)
+			out.write(d, static_cast<std::streamsize>(n));
+		if (i + 1 < rows_.size()) {
+			out.put('\n');
+		}
+	}
+	if (!out.good()) {
+		err = "Write error";
 		return false;
 	}
 
 	filename_       = out_path;
 	is_file_backed_ = true;
 	dirty_          = false;
-	RefreshOnDiskIdentity();
 	return true;
 }
 
@@ -575,139 +393,116 @@ Buffer::AsString() const
 	if (this->Dirty()) {
 		ss << "*";
 	}
-	ss << ">: " << content_.LineCount() << " lines";
+	ss << ">: " << rows_.size() << " lines";
 	return ss.str();
 }
 
 
+std::string
+Buffer::FullText() const
+{
+	std::string out;
+	// Precompute size for fewer reallocations
+	std::size_t total = 0;
+	for (std::size_t i = 0; i < rows_.size(); ++i) {
+		total += rows_[i].Size();
+		if (i + 1 < rows_.size())
+			total += 1; // for '\n'
+	}
+	out.reserve(total);
+	for (std::size_t i = 0; i < rows_.size(); ++i) {
+		const char *d = rows_[i].Data();
+		std::size_t n = rows_[i].Size();
+		if (d && n)
+			out.append(d, n);
+		if (i + 1 < rows_.size())
+			out.push_back('\n');
+	}
+	return out;
+}
+
+
 // --- Raw editing APIs (no undo recording, cursor untouched) ---
 void
 Buffer::insert_text(int row, int col, std::string_view text)
 {
 	if (row < 0)
 		row = 0;
-	if (col < 0)
+	if (static_cast<std::size_t>(row) > rows_.size())
-		col = 0;
+		row = static_cast<int>(rows_.size());
-	const std::size_t off = content_.LineColToByteOffset(static_cast<std::size_t>(row),
+	if (rows_.empty())
-	                                                     static_cast<std::size_t>(col));
+		rows_.emplace_back("");
-	if (!text.empty()) {
+	if (static_cast<std::size_t>(row) >= rows_.size())
-		content_.Insert(off, text.data(), text.size());
+		rows_.emplace_back("");
-		rows_cache_dirty_ = true;
+
-		if (swap_rec_)
+	auto y = static_cast<std::size_t>(row);
-			swap_rec_->OnInsert(row, col, text);
+	auto x = static_cast<std::size_t>(col);
+	if (x > rows_[y].size())
+		x = rows_[y].size();
+
+	std::string remain(text);
+	while (true) {
+		auto pos = remain.find('\n');
+		if (pos == std::string::npos) {
+			rows_[y].insert(x, remain);
+			break;
+		}
+		// Insert up to newline
+		std::string seg = remain.substr(0, pos);
+		rows_[y].insert(x, seg);
+		x += seg.size();
+		// Split line at x
+		std::string tail = rows_[y].substr(x);
+		rows_[y].erase(x);
+		rows_.insert(rows_.begin() + static_cast<std::ptrdiff_t>(y + 1), Line(tail));
+		y += 1;
+		x = 0;
+		remain.erase(0, pos + 1);
+	}
+	// Do not set dirty here; UndoSystem will manage state/dirty externally
+	if (change_tracker_) {
+		change_tracker_->recordInsertion(row, col, std::string(text));
 	}
 }
 
 
-// ===== Adapter helpers for PieceTable-backed Buffer =====
-std::string_view
-Buffer::GetLineView(std::size_t row) const
-{
-	// Get byte range for the logical line and return a view into materialized data
-	auto range       = content_.GetLineRange(row); // [start,end) in bytes
-	const char *base = content_.Data(); // materializes if needed
-	if (!base)
-		return std::string_view();
-	const std::size_t start = range.first;
-	const std::size_t len   = (range.second > range.first) ? (range.second - range.first) : 0;
-	return std::string_view(base + start, len);
-}
-
-
-void
-Buffer::ensure_rows_cache() const
-{
-	std::lock_guard<std::mutex> lock(buffer_mutex_);
-	if (!rows_cache_dirty_)
-		return;
-	rows_.clear();
-	const std::size_t lc = content_.LineCount();
-	rows_.reserve(lc);
-	for (std::size_t i = 0; i < lc; ++i) {
-		rows_.emplace_back(content_.GetLine(i));
-	}
-	// Keep nrows_ in sync for any legacy code that still reads it
-	const_cast<Buffer *>(this)->nrows_ = rows_.size();
-	rows_cache_dirty_                  = false;
-}
-
-
-std::size_t
-Buffer::content_LineCount_() const
-{
-	return content_.LineCount();
-}
-
-
-#if defined(KTE_TESTS)
-std::string
-Buffer::BytesForTests() const
-{
-	const std::size_t sz = content_.Size();
-	if (sz == 0)
-		return std::string();
-	const char *data = content_.Data();
-	if (!data)
-		return std::string();
-	return std::string(data, data + sz);
-}
-#endif
-
-
 void
 Buffer::delete_text(int row, int col, std::size_t len)
 {
-	if (len == 0)
+	if (rows_.empty() || len == 0)
 		return;
 	if (row < 0)
 		row = 0;
-	if (col < 0)
+	if (static_cast<std::size_t>(row) >= rows_.size())
-		col = 0;
+		return;
+	const auto y = static_cast<std::size_t>(row);
+	const auto x = std::min<std::size_t>(static_cast<std::size_t>(col), rows_[y].size());
 
-	const std::size_t start = content_.LineColToByteOffset(static_cast<std::size_t>(row),
-	                                                       static_cast<std::size_t>(col));
-	std::size_t r         = static_cast<std::size_t>(row);
-	std::size_t c         = static_cast<std::size_t>(col);
 	std::size_t remaining = len;
-	const std::size_t lc  = content_.LineCount();
+	while (remaining > 0 && y < rows_.size()) {
-
+		auto &line                = rows_[y];
-	while (remaining > 0 && r < lc) {
+		const std::size_t in_line = std::min<std::size_t>(remaining, line.size() - std::min(x, line.size()));
-		const std::string line = content_.GetLine(r); // logical line (without trailing '\n')
+		if (x < line.size() && in_line > 0) {
-		const std::size_t L    = line.size();
+			line.erase(x, in_line);
-		if (c < L) {
+			remaining -= in_line;
-			const std::size_t take = std::min(remaining, L - c);
-			c                      += take;
-			remaining              -= take;
 		}
 		if (remaining == 0)
 			break;
-		// Consume newline between lines as one char, if there is a next line
+		// If at or beyond end of line and there is a next line, join it (deleting the implied '\n')
-		if (r + 1 < lc) {
+		if (y + 1 < rows_.size()) {
-			remaining -= 1; // the newline
+			line += rows_[y + 1];
-			r         += 1;
+			rows_.erase(rows_.begin() + static_cast<std::ptrdiff_t>(y + 1));
-			c         = 0;
+			// deleting the newline consumes one virtual character
+			if (remaining > 0) {
+				// Treat the newline as one deletion unit if len spans it
+				// We already joined, so nothing else to do here.
+			}
 		} else {
-			// At last line and still remaining: delete to EOF
+			break;
-			const std::size_t total  = content_.Size();
-			const std::size_t actual = (total > start) ? (total - start) : 0;
-			if (actual == 0)
-				return;
-			content_.Delete(start, actual);
-			rows_cache_dirty_ = true;
-			if (swap_rec_)
-				swap_rec_->OnDelete(row, col, actual);
-			return;
 		}
 	}
-
+	if (change_tracker_) {
-	// Compute end offset at (r,c)
+		change_tracker_->recordDeletion(row, col, len);
-	std::size_t end = content_.LineColToByteOffset(r, c);
-	if (end > start) {
-		const std::size_t actual = end - start;
-		content_.Delete(start, actual);
-		rows_cache_dirty_ = true;
-		if (swap_rec_)
-			swap_rec_->OnDelete(row, col, actual);
 	}
 }
 
@@ -715,37 +510,35 @@ Buffer::delete_text(int row, int col, std::size_t len)
 void
 Buffer::split_line(int row, const int col)
 {
-	int c = col;
+	if (row < 0) {
-	if (row < 0)
 		row = 0;
-	if (c < 0)
+	}
-		c = 0;
+
-	const std::size_t off = content_.LineColToByteOffset(static_cast<std::size_t>(row),
+	if (static_cast<std::size_t>(row) >= rows_.size()) {
-	                                                     static_cast<std::size_t>(c));
+		rows_.resize(static_cast<std::size_t>(row) + 1);
-	const char nl = '\n';
+	}
-	content_.Insert(off, &nl, 1);
+	const auto y    = static_cast<std::size_t>(row);
-	rows_cache_dirty_ = true;
+	const auto x    = std::min<std::size_t>(static_cast<std::size_t>(col), rows_[y].size());
-	if (swap_rec_)
+	const auto tail = rows_[y].substr(x);
-		swap_rec_->OnInsert(row, c, std::string_view("\n", 1));
+	rows_[y].erase(x);
+	rows_.insert(rows_.begin() + static_cast<std::ptrdiff_t>(y + 1), Line(tail));
 }
 
 
 void
 Buffer::join_lines(int row)
 {
-	if (row < 0)
+	if (row < 0) {
 		row = 0;
-	std::size_t r = static_cast<std::size_t>(row);
+	}
-	if (r + 1 >= content_.LineCount())
+
+	const auto y = static_cast<std::size_t>(row);
+	if (y + 1 >= rows_.size()) {
 		return;
-	const int col = static_cast<int>(content_.GetLine(r).size());
+	}
-	// Delete the newline between line r and r+1
+
-	std::size_t end_of_line = content_.LineColToByteOffset(r, std::numeric_limits<std::size_t>::max());
+	rows_[y] += rows_[y + 1];
-	// end_of_line now equals line end (clamped before newline). The newline should be exactly at this position.
+	rows_.erase(rows_.begin() + static_cast<std::ptrdiff_t>(y + 1));
-	content_.Delete(end_of_line, 1);
-	rows_cache_dirty_ = true;
-	if (swap_rec_)
-		swap_rec_->OnDelete(row, col, 1);
 }
 
 
@@ -754,18 +547,9 @@ Buffer::insert_row(int row, const std::string_view text)
 {
 	if (row < 0)
 		row = 0;
-	std::size_t off = content_.LineColToByteOffset(static_cast<std::size_t>(row), 0);
+	if (static_cast<std::size_t>(row) > rows_.size())
-	if (!text.empty())
+		row = static_cast<int>(rows_.size());
-		content_.Insert(off, text.data(), text.size());
+	rows_.insert(rows_.begin() + row, Line(std::string(text)));
-	const char nl = '\n';
-	content_.Insert(off + text.size(), &nl, 1);
-	rows_cache_dirty_ = true;
-	if (swap_rec_) {
-		// Avoid allocation: emit the row text insertion (if any) and the newline insertion.
-		if (!text.empty())
-			swap_rec_->OnInsert(row, 0, text);
-		swap_rec_->OnInsert(row, static_cast<int>(text.size()), std::string_view("\n", 1));
-	}
 }
 
 
@@ -774,31 +558,9 @@ Buffer::delete_row(int row)
 {
 	if (row < 0)
 		row = 0;
-	std::size_t r = static_cast<std::size_t>(row);
+	if (static_cast<std::size_t>(row) >= rows_.size())
-	if (r >= content_.LineCount())
 		return;
-	auto range = content_.GetLineRange(r); // [start,end)
+	rows_.erase(rows_.begin() + row);
-	// If not last line, ensure we include the separating newline by using end as-is (which points to next line start)
-	// If last line, end may equal total_size_. We still delete [start,end) which removes the last line content.
-	const std::size_t start  = range.first;
-	const std::size_t end    = range.second;
-	const std::size_t actual = (end > start) ? (end - start) : 0;
-	if (actual == 0)
-		return;
-	content_.Delete(start, actual);
-	rows_cache_dirty_ = true;
-	if (swap_rec_)
-		swap_rec_->OnDelete(row, 0, actual);
-}
-
-
-void
-Buffer::replace_all_bytes(const std::string_view bytes)
-{
-	content_.Clear();
-	if (!bytes.empty())
-		content_.Append(bytes.data(), bytes.size());
-	rows_cache_dirty_ = true;
 }
 
 
@@ -815,3 +577,17 @@ Buffer::Undo() const
 {
 	return undo_sys_.get();
 }
+
+
+void
+Buffer::SetChangeTracker(std::unique_ptr<kte::lsp::BufferChangeTracker> tracker)
+{
+	change_tracker_ = std::move(tracker);
+}
+
+
+kte::lsp::BufferChangeTracker *
+Buffer::GetChangeTracker()
+{
+	return change_tracker_.get();
+}

Buffer.h

@@ -1,39 +1,8 @@
 /*
  * Buffer.h - editor buffer representing an open document
- *
- * Buffer is the central document model in kte. Each Buffer represents one open file
- * or scratch document and manages:
- *
- * - Content storage: Uses PieceTable for efficient text operations
- * - Cursor state: Current position (curx_, cury_), rendered column (rx_)
- * - Viewport: Scroll offsets (rowoffs_, coloffs_) for display
- * - File backing: Optional association with a file on disk
- * - Undo/Redo: Integrated UndoSystem for operation history
- * - Syntax highlighting: Optional HighlighterEngine for language-aware coloring
- * - Swap/crash recovery: Integration with SwapRecorder for journaling
- * - Dirty tracking: Modification state for save prompts
- *
- * Key concepts:
- *
- * 1. Cursor coordinates:
- *    - (curx_, cury_): Logical character position in the document
- *    - rx_: Rendered column accounting for tab expansion
- *
- * 2. File backing:
- *    - Buffers can be file-backed (associated with a path) or scratch (unnamed)
- *    - File identity tracking detects external modifications
- *
- * 3. Legacy Line wrapper:
- *    - Buffer::Line provides a string-like interface for legacy command code
- *    - New code should prefer direct PieceTable operations
- *    - See DEVELOPER_GUIDE.md for migration guidance
- *
- * 4. Content access:
- *    - Rows(): Materialized line cache (legacy, being phased out)
- *    - GetLineView(): Zero-copy line access via string_view (preferred)
- *    - Direct PieceTable access for new editing operations
  */
-#pragma once
+#ifndef KTE_BUFFER_H
+#define KTE_BUFFER_H
 
 #include <cstddef>
 #include <memory>
@@ -41,16 +10,18 @@
 #include <vector>
 #include <string_view>
 
-#include "PieceTable.h"
+#include "AppendBuffer.h"
 #include "UndoSystem.h"
 #include <cstdint>
+#include <memory>
 #include "syntax/HighlighterEngine.h"
 #include "Highlight.h"
-#include <mutex>
 
-// Forward declaration for swap journal integration
+// Forward declarations to avoid heavy includes
 namespace kte {
-class SwapRecorder;
+namespace lsp {
+class BufferChangeTracker;
+}
 }
 
 
@@ -58,6 +29,8 @@ class Buffer {
 public:
 	Buffer();
 
+	~Buffer();
+
 	Buffer(const Buffer &other);
 
 	Buffer &operator=(const Buffer &other);
@@ -74,14 +47,6 @@ public:
 	bool Save(std::string &err) const; // saves to existing filename; returns false if not file-backed
 	bool SaveAs(const std::string &path, std::string &err); // saves to path and makes buffer file-backed
 
-	// External modification detection.
-	// Returns true if the file on disk differs from the last observed identity recorded
-	// on open/save.
-	[[nodiscard]] bool ExternallyModifiedOnDisk() const;
-
-	// Refresh the stored on-disk identity to match current stat (used after open/save).
-	void RefreshOnDiskIdentity();
-
 	// Accessors
 	[[nodiscard]] std::size_t Curx() const
 	{
@@ -103,7 +68,7 @@ public:
 
 	[[nodiscard]] std::size_t Nrows() const
 	{
-		return content_LineCount_();
+		return nrows_;
 	}
 
 
@@ -119,8 +84,7 @@ public:
 	}
 
 
-	// Line wrapper used by legacy command paths.
+	// Line wrapper backed by AppendBuffer (GapBuffer/PieceTable)
-	// Keep this lightweight: store materialized bytes only for that line.
 	class Line {
 	public:
 		Line() = default;
@@ -149,102 +113,119 @@ public:
 		// capacity helpers
 		void Clear()
 		{
-			s_.clear();
+			buf_.Clear();
 		}
 
 
 		// size/access
 		[[nodiscard]] std::size_t size() const
 		{
-			return s_.size();
+			return buf_.Size();
 		}
 
 
 		[[nodiscard]] bool empty() const
 		{
-			return s_.empty();
+			return size() == 0;
 		}
 
 
 		// read-only raw view
 		[[nodiscard]] const char *Data() const
 		{
-			return s_.data();
+			return buf_.Data();
 		}
 
 
 		[[nodiscard]] std::size_t Size() const
 		{
-			return s_.size();
+			return buf_.Size();
 		}
 
 
 		// element access (read-only)
 		[[nodiscard]] char operator[](std::size_t i) const
 		{
-			return (i < s_.size()) ? s_[i] : '\0';
+			const char *d = buf_.Data();
+			return (i < buf_.Size() && d) ? d[i] : '\0';
 		}
 
 
 		// conversions
 		explicit operator std::string() const
 		{
-			return s_;
+			return {buf_.Data() ? buf_.Data() : "", buf_.Size()};
 		}
 
 
 		// string-like API used by command/renderer layers (implemented via materialization for now)
 		[[nodiscard]] std::string substr(std::size_t pos) const
 		{
-			return pos < s_.size() ? s_.substr(pos) : std::string();
+			const std::size_t n = buf_.Size();
+			if (pos >= n)
+				return {};
+			return {buf_.Data() + pos, n - pos};
 		}
 
 
 		[[nodiscard]] std::string substr(std::size_t pos, std::size_t len) const
 		{
-			return pos < s_.size() ? s_.substr(pos, len) : std::string();
+			const std::size_t n = buf_.Size();
+			if (pos >= n)
+				return {};
+			const std::size_t take = (pos + len > n) ? (n - pos) : len;
+			return {buf_.Data() + pos, take};
 		}
 
 
 		// minimal find() to support search within a line
 		[[nodiscard]] std::size_t find(const std::string &needle, const std::size_t pos = 0) const
 		{
-			return s_.find(needle, pos);
+			// Materialize to std::string for now; Line is backed by AppendBuffer
+			const auto s = static_cast<std::string>(*this);
+			return s.find(needle, pos);
 		}
 
 
 		void erase(std::size_t pos)
 		{
-			if (pos < s_.size())
+			// erase to end
-				s_.erase(pos);
+			material_edit([&](std::string &s) {
+				if (pos < s.size())
+					s.erase(pos);
+			});
 		}
 
 
 		void erase(std::size_t pos, std::size_t len)
 		{
-			if (pos < s_.size())
+			material_edit([&](std::string &s) {
-				s_.erase(pos, len);
+				if (pos < s.size())
+					s.erase(pos, len);
+			});
 		}
 
 
 		void insert(std::size_t pos, const std::string &seg)
 		{
-			if (pos > s_.size())
+			material_edit([&](std::string &s) {
-				pos = s_.size();
+				if (pos > s.size())
-			s_.insert(pos, seg);
+					pos = s.size();
+				s.insert(pos, seg);
+			});
 		}
 
 
 		Line &operator+=(const Line &other)
 		{
-			s_ += other.s_;
+			buf_.Append(other.buf_.Data(), other.buf_.Size());
 			return *this;
 		}
 
 
 		Line &operator+=(const std::string &s)
 		{
-			s_ += s;
+			buf_.Append(s.data(), s.size());
 			return *this;
 		}
 
@@ -258,47 +239,37 @@ public:
 	private:
 		void assign_from(const std::string &s)
 		{
-			s_ = s;
+			buf_.Clear();
+			if (!s.empty())
+				buf_.Append(s.data(), s.size());
 		}
 
 
-		std::string s_;
+		template<typename F>
+		void material_edit(F fn)
+		{
+			std::string tmp = static_cast<std::string>(*this);
+			fn(tmp);
+			assign_from(tmp);
+		}
+
+
+		AppendBuffer buf_;
 	};
 
 
 	[[nodiscard]] const std::vector<Line> &Rows() const
 	{
-		ensure_rows_cache();
 		return rows_;
 	}
 
 
 	[[nodiscard]] std::vector<Line> &Rows()
 	{
-		ensure_rows_cache();
 		return rows_;
 	}
 
 
-	// Lightweight, lazy per-line accessors that avoid materializing all rows.
-	// Prefer these over Rows() in hot paths to reduce memory overhead on large files.
-	[[nodiscard]] std::string GetLineString(std::size_t row) const
-	{
-		return content_.GetLine(row);
-	}
-
-
-	[[nodiscard]] std::pair<std::size_t, std::size_t> GetLineRange(std::size_t row) const
-	{
-		return content_.GetLineRange(row);
-	}
-
-
-	// Zero-copy view of a line. Points into the materialized backing store; becomes
-	// invalid after subsequent edits. Use immediately.
-	[[nodiscard]] std::string_view GetLineView(std::size_t row) const;
-
-
 	[[nodiscard]] const std::string &Filename() const
 	{
 		return filename_;
@@ -410,73 +381,11 @@ 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_;
-	}
-
-
-	// In visual-line (multi-cursor) mode, the UI should highlight only the per-line
-	// cursor "spot" (Curx clamped to each line length), not the entire line.
-	[[nodiscard]] bool VisualLineSpotSelected(std::size_t y, std::size_t sx) const
-	{
-		if (!visual_line_active_)
-			return false;
-		if (y < VisualLineStartY() || y > VisualLineEndY())
-			return false;
-		std::string_view ln = GetLineView(y);
-		// `GetLineView()` returns the raw range, which may include a trailing '\n'.
-		if (!ln.empty() && ln.back() == '\n')
-			ln.remove_suffix(1);
-		const std::size_t spot = std::min(Curx(), ln.size());
-		return sx == spot;
-	}
-
-
 	[[nodiscard]] std::string AsString() const;
 
+	// Compose full text of this buffer with newlines between rows
+	[[nodiscard]] std::string FullText() const;
+
 	// Syntax highlighting integration (per-buffer)
 	[[nodiscard]] std::uint64_t Version() const
 	{
@@ -508,13 +417,13 @@ public:
 	}
 
 
-	[[nodiscard]] kte::HighlighterEngine *Highlighter()
+	kte::HighlighterEngine *Highlighter()
 	{
 		return highlighter_.get();
 	}
 
 
-	[[nodiscard]] const kte::HighlighterEngine *Highlighter() const
+	const kte::HighlighterEngine *Highlighter() const
 	{
 		return highlighter_.get();
 	}
@@ -527,19 +436,6 @@ public:
 	}
 
 
-	// Swap journal integration (set by Editor)
-	void SetSwapRecorder(kte::SwapRecorder *rec)
-	{
-		swap_rec_ = rec;
-	}
-
-
-	[[nodiscard]] kte::SwapRecorder *SwapRecorder() const
-	{
-		return swap_rec_;
-	}
-
-
 	// Raw, low-level editing APIs used by UndoSystem apply().
 	// These must NOT trigger undo recording. They also do not move the cursor.
 	void insert_text(int row, int col, std::string_view text);
@@ -554,61 +450,29 @@ public:
 
 	void delete_row(int row);
 
-	// Replace the entire buffer content with raw bytes.
-	// Intended for crash recovery (swap replay) and test harnesses.
-	// This does not trigger swap or undo recording.
-	void replace_all_bytes(std::string_view bytes);
-
 	// Undo system accessors (created per-buffer)
-	[[nodiscard]] UndoSystem *Undo();
+	UndoSystem *Undo();
 
 	[[nodiscard]] const UndoSystem *Undo() const;
 
-#if defined(KTE_TESTS)
+	// LSP integration: optional change tracker
-	// Test-only: return the raw buffer bytes (including newlines) as a string.
+	void SetChangeTracker(std::unique_ptr<kte::lsp::BufferChangeTracker> tracker);
-	[[nodiscard]] std::string BytesForTests() const;
+
-#endif
+	kte::lsp::BufferChangeTracker *GetChangeTracker();
 
 private:
-	struct FileIdentity {
-		bool valid             = false;
-		std::uint64_t mtime_ns = 0;
-		std::uint64_t size     = 0;
-		std::uint64_t dev      = 0;
-		std::uint64_t ino      = 0;
-	};
-
-	[[nodiscard]] static bool stat_identity(const std::string &path, FileIdentity &out);
-
-	[[nodiscard]] bool current_disk_identity(FileIdentity &out) const;
-
-	mutable FileIdentity on_disk_identity_{};
-
 	// State mirroring original C struct (without undo_tree)
 	std::size_t curx_    = 0, cury_ = 0; // cursor position in characters
 	std::size_t rx_      = 0; // render x (tabs expanded)
 	std::size_t nrows_   = 0; // number of rows
 	std::size_t rowoffs_ = 0, coloffs_ = 0; // viewport offsets
-	mutable std::vector<Line> rows_; // materialized cache of rows (without trailing newlines)
+	std::vector<Line> rows_; // buffer rows (without trailing newlines)
-	// PieceTable is the source of truth.
-	PieceTable content_{};
-	mutable bool rows_cache_dirty_ = true; // invalidate on edits / I/O
-
-	// Helper to rebuild rows_ from content_
-	void ensure_rows_cache() const;
-
-	// Helper to query content_.LineCount() while keeping header minimal
-	std::size_t content_LineCount_() const;
-
 	std::string filename_;
-	bool is_file_backed_              = false;
+	bool is_file_backed_   = false;
-	bool dirty_                       = false;
+	bool dirty_            = false;
-	bool read_only_                   = false;
+	bool read_only_        = false;
-	bool mark_set_                    = false;
+	bool mark_set_         = false;
-	std::size_t mark_curx_            = 0, mark_cury_ = 0;
+	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_;
@@ -619,8 +483,9 @@ private:
 	bool syntax_enabled_   = true;
 	std::string filetype_;
 	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_;
+	// Optional LSP change tracker (absent by default)
+	std::unique_ptr<kte::lsp::BufferChangeTracker> change_tracker_;
 };
+
+#endif // KTE_BUFFER_H

CMakeLists.txt

@@ -3,490 +3,419 @@ project(kte)
 
 include(GNUInstallDirs)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 17)
-set(KTE_VERSION "1.7.0")
+set(KTE_VERSION "1.2.0")
 
 # Default to terminal-only build to avoid SDL/OpenGL dependency by default.
 # Enable with -DBUILD_GUI=ON when SDL2/OpenGL/Freetype are available.
 set(BUILD_GUI ON CACHE BOOL "Enable building the graphical version.")
-set(KTE_USE_QT OFF CACHE BOOL "Build the QT frontend instead of ImGui.")
+set(BUILD_TESTS OFF CACHE BOOL "Enable building test programs.")
-set(BUILD_TESTS ON CACHE BOOL "Enable building test programs.")
+option(KTE_USE_PIECE_TABLE "Use PieceTable instead of GapBuffer implementation" ON)
 set(KTE_FONT_SIZE "18.0" CACHE STRING "Default font size for GUI")
 option(KTE_UNDO_DEBUG "Enable undo instrumentation logs" OFF)
 option(KTE_ENABLE_TREESITTER "Enable optional Tree-sitter highlighter adapter" OFF)
 
-# Optionally enable AddressSanitizer (ASan)
-option(ENABLE_ASAN "Enable AddressSanitizer for builds" OFF)
-
-if (ENABLE_ASAN)
-    message(STATUS "ASan enabled")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
-    # Ensure the sanitizer is linked too (especially important on some platforms)
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
-endif ()
-
 if (CMAKE_HOST_UNIX)
-    message(STATUS "Build system is POSIX.")
+	message(STATUS "Build system is POSIX.")
 else ()
-    message(STATUS "Build system is NOT POSIX.")
+	message(STATUS "Build system is NOT POSIX.")
 endif ()
 
-add_compile_options(
-
-)
-
 if (MSVC)
-    add_compile_options("/W4" "$<$<CONFIG:RELEASE>:/O2>")
+	add_compile_options("/W4" "$<$<CONFIG:RELEASE>:/O2>")
 else ()
-    add_compile_options(
+	add_compile_options(
-            "-Wall"
+		"-Wall"
-            "-Wextra"
+		"-Wextra"
-            "-Werror"
+		"-Werror"
-            "-pedantic"
+		"$<$<CONFIG:DEBUG>:-g>"
-            "-Wno-unused-function"
+		"$<$<CONFIG:RELEASE>:-O2>")
-            "-Wno-unused-parameter"
+	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-            "$<$<CONFIG:RELEASE>:-O2>"
+		add_compile_options("-stdlib=libc++")
-            "$<$<CONFIG:DEBUG>:-g>"
+	else ()
-    )
+		# nothing special for gcc at the moment
-    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	endif ()
-        add_compile_options("-stdlib=libc++")
-    else ()
-        # nothing special for gcc at the moment
-    endif ()
 endif ()
 add_compile_definitions(KGE_PLATFORM=${CMAKE_HOST_SYSTEM_NAME})
 add_compile_definitions(KTE_VERSION_STR="v${KTE_VERSION}")
 if (KTE_ENABLE_TREESITTER)
-    add_compile_definitions(KTE_ENABLE_TREESITTER)
+	add_compile_definitions(KTE_ENABLE_TREESITTER)
 endif ()
 
 message(STATUS "Build system: ${CMAKE_HOST_SYSTEM_NAME}")
 
-if (BUILD_GUI)
+if (${BUILD_GUI})
-    include(cmake/imgui.cmake)
+	include(cmake/imgui.cmake)
 endif ()
 
 # NCurses for terminal mode
-set(CURSES_NEED_NCURSES TRUE)
+set(CURSES_NEED_NCURSES)
-set(CURSES_NEED_WIDE TRUE)
+set(CURSES_NEED_WIDE)
 find_package(Curses REQUIRED)
 include_directories(${CURSES_INCLUDE_DIR})
 
-# On Alpine Linux, CMake's FindCurses looks in wrong paths
+# Detect availability of get_wch (wide-char input) in the curses headers
-# Manually find the correct ncurses library
+include(CheckSymbolExists)
-if (EXISTS "/etc/alpine-release")
+set(CMAKE_REQUIRED_INCLUDES ${CURSES_INCLUDE_DIR})
-    find_library(NCURSESW_LIB NAMES ncursesw PATHS /usr/lib /lib REQUIRED)
+check_symbol_exists(get_wch "ncurses.h" KTE_HAVE_GET_WCH_IN_NCURSES)
-    set(CURSES_LIBRARIES ${NCURSESW_LIB})
+if (NOT KTE_HAVE_GET_WCH_IN_NCURSES)
-    message(STATUS "Alpine Linux detected, using ncurses at: ${NCURSESW_LIB}")
+	# Some systems expose curses headers as <curses.h>
+	check_symbol_exists(get_wch "curses.h" KTE_HAVE_GET_WCH_IN_CURSES)
+endif ()
+if (KTE_HAVE_GET_WCH_IN_NCURSES OR KTE_HAVE_GET_WCH_IN_CURSES)
+	add_compile_definitions(KTE_HAVE_GET_WCH)
 endif ()
 
 set(SYNTAX_SOURCES
-        syntax/GoHighlighter.cc
+	syntax/HighlighterEngine.cc
-        syntax/CppHighlighter.cc
+	syntax/CppHighlighter.cc
-        syntax/JsonHighlighter.cc
+	syntax/HighlighterRegistry.cc
-        syntax/ErlangHighlighter.cc
+	syntax/NullHighlighter.cc
-        syntax/MarkdownHighlighter.cc
+	syntax/JsonHighlighter.cc
-        syntax/TreeSitterHighlighter.cc
+	syntax/MarkdownHighlighter.cc
-        syntax/LispHighlighter.cc
+	syntax/ShellHighlighter.cc
-        syntax/HighlighterEngine.cc
+	syntax/GoHighlighter.cc
-        syntax/RustHighlighter.cc
+	syntax/PythonHighlighter.cc
-        syntax/HighlighterRegistry.cc
+	syntax/RustHighlighter.cc
-        syntax/SqlHighlighter.cc
+	syntax/LispHighlighter.cc
-        syntax/NullHighlighter.cc
+	syntax/SqlHighlighter.cc
-        syntax/ForthHighlighter.cc
+	syntax/ErlangHighlighter.cc
-        syntax/PythonHighlighter.cc
+	syntax/ForthHighlighter.cc
-        syntax/ShellHighlighter.cc
 )
 
-if (KTE_ENABLE_TREESITTER)
-    list(APPEND SYNTAX_SOURCES
-            TreeSitterHighlighter.cc)
-endif ()
-
-set(FONT_SOURCES
-        fonts/Font.cc
-        fonts/FontRegistry.cc
-)
-
-if (BUILD_GUI)
-    set(GUI_SOURCES
-            GUIConfig.cc
-    )
-    if (KTE_USE_QT)
-        find_package(Qt6 COMPONENTS Widgets REQUIRED)
-        set(GUI_SOURCES
-                ${GUI_SOURCES}
-                QtFrontend.cc
-                QtInputHandler.cc
-                QtRenderer.cc
-        )
-        # Expose preprocessor switch so sources can exclude ImGui-specific code
-        add_compile_definitions(KTE_USE_QT)
-    else ()
-        set(GUI_SOURCES
-                ${GUI_SOURCES}
-                ${FONT_SOURCES}
-                ImGuiFrontend.cc
-                ImGuiInputHandler.cc
-                ImGuiRenderer.cc
-        )
-    endif ()
-endif ()
-
 set(COMMON_SOURCES
-        PieceTable.cc
+	GapBuffer.cc
-        Buffer.cc
+	PieceTable.cc
-        Editor.cc
+	Buffer.cc
-        Command.cc
+	Editor.cc
-        HelpText.cc
+	Command.cc
-        KKeymap.cc
+	HelpText.cc
-        Swap.cc
+	KKeymap.cc
-        ErrorHandler.cc
+	TerminalInputHandler.cc
-        SyscallWrappers.cc
+	TerminalRenderer.cc
-        ErrorRecovery.cc
+	TerminalFrontend.cc
-        TerminalInputHandler.cc
+	TestInputHandler.cc
-        TerminalRenderer.cc
+	TestRenderer.cc
-        TerminalFrontend.cc
+	TestFrontend.cc
-        TestInputHandler.cc
+	UndoNode.cc
-        TestRenderer.cc
+	UndoTree.cc
-        TestFrontend.cc
+	UndoSystem.cc
-        UndoNode.cc
+	lsp/UtfCodec.cc
-        UndoTree.cc
+	lsp/BufferChangeTracker.cc
-        UndoSystem.cc
+	lsp/JsonRpcTransport.cc
+	lsp/LspProcessClient.cc
+	lsp/DiagnosticStore.cc
+	lsp/TerminalDiagnosticDisplay.cc
+	lsp/LspManager.cc
 
-        ${SYNTAX_SOURCES}
+	${SYNTAX_SOURCES}
-)
-
-set(SYNTAX_HEADERS
-        syntax/GoHighlighter.h
-        syntax/HighlighterEngine.h
-        syntax/ShellHighlighter.h
-        syntax/MarkdownHighlighter.h
-        syntax/LispHighlighter.h
-        syntax/SqlHighlighter.h
-        syntax/ForthHighlighter.h
-        syntax/JsonHighlighter.h
-        syntax/TreeSitterHighlighter.h
-        syntax/NullHighlighter.h
-        syntax/CppHighlighter.h
-        syntax/ErlangHighlighter.h
-        syntax/LanguageHighlighter.h
-        syntax/RustHighlighter.h
-        syntax/PythonHighlighter.h
 )
 
 if (KTE_ENABLE_TREESITTER)
-    list(APPEND THEME_HEADERS
+	list(APPEND SYNTAX_SOURCES
-            TreeSitterHighlighter.h)
+		syntax/TreeSitterHighlighter.cc)
 endif ()
 
 set(THEME_HEADERS
-        themes/ThemeHelpers.h
+	themes/EInk.h
-        themes/EInk.h
+	themes/Gruvbox.h
-        themes/Gruvbox.h
+	themes/Nord.h
-        themes/Solarized.h
+	themes/Plan9.h
-        themes/Plan9.h
+	themes/Solarized.h
-        themes/Nord.h
+	themes/ThemeHelpers.h
-        themes/Everforest.h
-        themes/KanagawaPaper.h
-        themes/LCARS.h
-        themes/OldBook.h
-        themes/Amber.h
-        themes/Orbital.h
-        themes/WeylandYutani.h
-        themes/Zenburn.h
 )
 
-set(FONT_HEADERS
+set(SYNTAX_HEADERS
-        fonts/Font.h
+	syntax/LanguageHighlighter.h
-        fonts/FontRegistry.h
+	syntax/HighlighterEngine.h
-        fonts/FontRegistry.h
+	syntax/CppHighlighter.h
-        fonts/FontList.h
+	syntax/HighlighterRegistry.h
-        fonts/B612Mono.h
+	syntax/NullHighlighter.h
-        fonts/BrassMono.h
+	syntax/JsonHighlighter.h
-        fonts/BrassMonoCode.h
+	syntax/MarkdownHighlighter.h
-        fonts/FiraCode.h
+	syntax/ShellHighlighter.h
-        fonts/Go.h
+	syntax/GoHighlighter.h
-        fonts/IBMPlexMono.h
+	syntax/PythonHighlighter.h
-        fonts/Idealist.h
+	syntax/RustHighlighter.h
-        fonts/Inconsolata.h
+	syntax/LispHighlighter.h
-        fonts/InconsolataExpanded.h
-        fonts/Iosevka.h
-        fonts/IosevkaExtended.h
-        fonts/ShareTech.h
-        fonts/SpaceMono.h
-        fonts/Syne.h
-        fonts/Triplicate.h
-        fonts/Unispace.h
-        fonts/BerkeleyMono.h
 )
 
+if (KTE_ENABLE_TREESITTER)
+	list(APPEND SYNTAX_HEADERS
+		syntax/TreeSitterHighlighter.h)
+endif ()
+
 set(COMMON_HEADERS
-        PieceTable.h
+	GapBuffer.h
-        Buffer.h
+	PieceTable.h
-        Editor.h
+	Buffer.h
-        Command.h
+	Editor.h
-        HelpText.h
+	AppendBuffer.h
-        KKeymap.h
+	Command.h
-        Swap.h
+	HelpText.h
-        InputHandler.h
+	KKeymap.h
-        TerminalInputHandler.h
+	InputHandler.h
-        Renderer.h
+	TerminalInputHandler.h
-        TerminalRenderer.h
+	Renderer.h
-        Frontend.h
+	TerminalRenderer.h
-        TerminalFrontend.h
+	Frontend.h
-        TestInputHandler.h
+	TerminalFrontend.h
-        TestRenderer.h
+	TestInputHandler.h
-        TestFrontend.h
+	TestRenderer.h
-        UndoNode.h
+	TestFrontend.h
-        UndoTree.h
+	UndoNode.h
-        UndoSystem.h
+	UndoTree.h
-        Highlight.h
+	UndoSystem.h
+	Highlight.h
+	lsp/UtfCodec.h
+	lsp/LspTypes.h
+	lsp/BufferChangeTracker.h
+	lsp/JsonRpcTransport.h
+	lsp/LspClient.h
+	lsp/LspProcessClient.h
+	lsp/Diagnostic.h
+	lsp/DiagnosticStore.h
+	lsp/DiagnosticDisplay.h
+	lsp/TerminalDiagnosticDisplay.h
+	lsp/LspManager.h
+	lsp/LspServerConfig.h
+	ext/json.h
+	ext/json_fwd.h
 
-        ${SYNTAX_HEADERS}
+	${THEME_HEADERS}
+	${SYNTAX_HEADERS}
 )
 
-if (BUILD_GUI)
-    set(GUI_HEADERS
-            GUIConfig.h
-    )
-
-    if (KTE_USE_QT)
-        set(GUI_HEADERS
-                ${GUI_HEADERS}
-                QtFrontend.h
-                QtInputHandler.h
-                QtRenderer.h
-        )
-    else ()
-        set(GUI_HEADERS
-                ${GUI_HEADERS}
-                ${THEME_HEADERS}
-                ${FONT_HEADERS}
-                ImGuiFrontend.h
-                ImGuiInputHandler.h
-                ImGuiRenderer.h
-                fonts/BerkeleyMono.h
-        )
-    endif ()
-endif ()
-
 # kte (terminal-first) executable
 add_executable(kte
-        main.cc
+	main.cc
-        ${COMMON_SOURCES}
+	${COMMON_SOURCES}
-        ${COMMON_HEADERS}
+	${COMMON_HEADERS}
 )
 
+if (KTE_USE_PIECE_TABLE)
+	target_compile_definitions(kte PRIVATE KTE_USE_PIECE_TABLE=1)
+endif ()
 if (KTE_UNDO_DEBUG)
-    target_compile_definitions(kte PRIVATE KTE_UNDO_DEBUG=1)
+	target_compile_definitions(kte PRIVATE KTE_UNDO_DEBUG=1)
 endif ()
 
 target_link_libraries(kte ${CURSES_LIBRARIES})
-
+# Ensure vendored headers (e.g., ext/json.h) are on the include path
-# Static linking on Linux only (macOS does not support static linking of system libraries)
+target_include_directories(kte PRIVATE ${CMAKE_SOURCE_DIR}/ext)
-if (NOT APPLE)
-    target_link_options(kte PRIVATE -static)
-endif ()
 
 if (KTE_ENABLE_TREESITTER)
-    # Users can provide their own tree-sitter include/lib via cache variables
+	# Users can provide their own tree-sitter include/lib via cache variables
-    set(TREESITTER_INCLUDE_DIR "" CACHE PATH "Path to tree-sitter include directory")
+	set(TREESITTER_INCLUDE_DIR "" CACHE PATH "Path to tree-sitter include directory")
-    set(TREESITTER_LIBRARY "" CACHE FILEPATH "Path to tree-sitter library (.a/.dylib)")
+	set(TREESITTER_LIBRARY "" CACHE FILEPATH "Path to tree-sitter library (.a/.dylib)")
-    if (TREESITTER_INCLUDE_DIR)
+	if (TREESITTER_INCLUDE_DIR)
-        target_include_directories(kte PRIVATE ${TREESITTER_INCLUDE_DIR})
+		target_include_directories(kte PRIVATE ${TREESITTER_INCLUDE_DIR})
-    endif ()
+	endif ()
-    if (TREESITTER_LIBRARY)
+	if (TREESITTER_LIBRARY)
-        target_link_libraries(kte ${TREESITTER_LIBRARY})
+		target_link_libraries(kte ${TREESITTER_LIBRARY})
-    endif ()
+	endif ()
 endif ()
 
 install(TARGETS kte
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 )
 
 # Man pages
 install(FILES docs/kte.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
 
 if (BUILD_TESTS)
-    # Unified unit test runner
+	# test_undo executable for testing undo/redo system
-    add_executable(kte_tests
+	add_executable(test_undo
-            tests/TestRunner.cc
+		test_undo.cc
-            tests/Test.h
+		${COMMON_SOURCES}
-            tests/TestHarness.h
+		${COMMON_HEADERS}
-            tests/test_daily_driver_harness.cc
+	)
-            tests/test_daily_workflows.cc
-            tests/test_buffer_io.cc
-            tests/test_buffer_rows.cc
-            tests/test_command_semantics.cc
-            tests/test_kkeymap.cc
-            tests/test_swap_recorder.cc
-            tests/test_swap_writer.cc
-            tests/test_swap_replay.cc
-            tests/test_swap_edge_cases.cc
-            tests/test_swap_recovery_prompt.cc
-            tests/test_swap_cleanup.cc
-            tests/test_swap_git_editor.cc
-            tests/test_piece_table.cc
-            tests/test_search.cc
-            tests/test_search_replace_flow.cc
-            tests/test_reflow_paragraph.cc
-            tests/test_reflow_indented_bullets.cc
-            tests/test_undo.cc
-            tests/test_visual_line_mode.cc
-            tests/test_benchmarks.cc
-            tests/test_migration_coverage.cc
 
-            # minimal engine sources required by Buffer
+	if (KTE_USE_PIECE_TABLE)
-            PieceTable.cc
+		target_compile_definitions(test_undo PRIVATE KTE_USE_PIECE_TABLE=1)
-            Buffer.cc
+	endif ()
-            Editor.cc
-            Command.cc
-            HelpText.cc
-            Swap.cc
-            ErrorHandler.cc
-            SyscallWrappers.cc
-            ErrorRecovery.cc
-            KKeymap.cc
-            SwapRecorder.h
-            OptimizedSearch.cc
-            UndoNode.cc
-            UndoTree.cc
-            UndoSystem.cc
-            ${SYNTAX_SOURCES}
-    )
 
-    # Allow test-only introspection hooks (guarded in headers) without affecting production builds.
+	if (KTE_UNDO_DEBUG)
-    target_compile_definitions(kte_tests PRIVATE KTE_TESTS=1)
+		target_compile_definitions(test_undo PRIVATE KTE_UNDO_DEBUG=1)
+	endif ()
 
-    # Allow tests to include project headers like "Buffer.h"
-    target_include_directories(kte_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
-    # Keep tests free of ncurses/GUI deps
+	target_link_libraries(test_undo ${CURSES_LIBRARIES})
-    if (KTE_ENABLE_TREESITTER)
+	# Ensure vendored headers (e.g., ext/json.h) are on the include path for tests as well
-        if (TREESITTER_INCLUDE_DIR)
+	target_include_directories(test_undo PRIVATE ${CMAKE_SOURCE_DIR}/ext)
-            target_include_directories(kte_tests PRIVATE ${TREESITTER_INCLUDE_DIR})
+	if (KTE_ENABLE_TREESITTER)
-        endif ()
+		if (TREESITTER_INCLUDE_DIR)
-        if (TREESITTER_LIBRARY)
+			target_include_directories(test_undo PRIVATE ${TREESITTER_INCLUDE_DIR})
-            target_link_libraries(kte_tests ${TREESITTER_LIBRARY})
+		endif ()
-        endif ()
+		if (TREESITTER_LIBRARY)
-    endif ()
+			target_link_libraries(test_undo ${TREESITTER_LIBRARY})
+		endif ()
+	endif ()
 
-    # Static linking on Linux only (macOS does not support static linking of system libraries)
+	# test_utfcodec executable for UTF conversion helpers
-    if (NOT APPLE)
+	add_executable(test_utfcodec
-        target_link_options(kte_tests PRIVATE -static)
+		test_utfcodec.cc
-    endif ()
+		${COMMON_SOURCES}
+		${COMMON_HEADERS}
+	)
+
+	if (KTE_USE_PIECE_TABLE)
+		target_compile_definitions(test_utfcodec PRIVATE KTE_USE_PIECE_TABLE=1)
+	endif ()
+
+	if (KTE_UNDO_DEBUG)
+		target_compile_definitions(test_utfcodec PRIVATE KTE_UNDO_DEBUG=1)
+	endif ()
+
+
+	target_link_libraries(test_utfcodec ${CURSES_LIBRARIES})
+	# Ensure vendored headers (e.g., ext/json.h) are on the include path for tests as well
+	target_include_directories(test_utfcodec PRIVATE ${CMAKE_SOURCE_DIR}/ext)
+	if (KTE_ENABLE_TREESITTER)
+		if (TREESITTER_INCLUDE_DIR)
+			target_include_directories(test_utfcodec PRIVATE ${TREESITTER_INCLUDE_DIR})
+		endif ()
+		if (TREESITTER_LIBRARY)
+			target_link_libraries(test_utfcodec ${TREESITTER_LIBRARY})
+		endif ()
+	endif ()
+
+	# test_transport executable for JSON-RPC framing
+	add_executable(test_transport
+		test_transport.cc
+		${COMMON_SOURCES}
+		${COMMON_HEADERS}
+	)
+
+	if (KTE_USE_PIECE_TABLE)
+		target_compile_definitions(test_transport PRIVATE KTE_USE_PIECE_TABLE=1)
+	endif ()
+
+	if (KTE_UNDO_DEBUG)
+		target_compile_definitions(test_transport PRIVATE KTE_UNDO_DEBUG=1)
+	endif ()
+
+
+	target_link_libraries(test_transport ${CURSES_LIBRARIES})
+	# Ensure vendored headers (e.g., ext/json.h) are on the include path for tests as well
+	target_include_directories(test_transport PRIVATE ${CMAKE_SOURCE_DIR}/ext)
+	if (KTE_ENABLE_TREESITTER)
+		if (TREESITTER_INCLUDE_DIR)
+			target_include_directories(test_transport PRIVATE ${TREESITTER_INCLUDE_DIR})
+		endif ()
+		if (TREESITTER_LIBRARY)
+			target_link_libraries(test_transport ${TREESITTER_LIBRARY})
+		endif ()
+	endif ()
+
+	# test_lsp_decode executable for dispatcher decoding
+	add_executable(test_lsp_decode
+		test_lsp_decode.cc
+		${COMMON_SOURCES}
+		${COMMON_HEADERS}
+	)
+
+	if (KTE_USE_PIECE_TABLE)
+		target_compile_definitions(test_lsp_decode PRIVATE KTE_USE_PIECE_TABLE=1)
+	endif ()
+
+	if (KTE_UNDO_DEBUG)
+		target_compile_definitions(test_lsp_decode PRIVATE KTE_UNDO_DEBUG=1)
+	endif ()
+
+
+	target_link_libraries(test_lsp_decode ${CURSES_LIBRARIES})
+	# Ensure vendored headers (e.g., ext/json.h) are on the include path for tests as well
+	target_include_directories(test_lsp_decode PRIVATE ${CMAKE_SOURCE_DIR}/ext)
+	if (KTE_ENABLE_TREESITTER)
+		if (TREESITTER_INCLUDE_DIR)
+			target_include_directories(test_lsp_decode PRIVATE ${TREESITTER_INCLUDE_DIR})
+		endif ()
+		if (TREESITTER_LIBRARY)
+			target_link_libraries(test_lsp_decode ${TREESITTER_LIBRARY})
+		endif ()
+	endif ()
 endif ()
 
-if (BUILD_GUI)
+if (${BUILD_GUI})
-    # ImGui::CreateContext();
+	target_sources(kte PRIVATE
-    # ImGuiIO& io = ImGui::GetIO();
+		Font.h
+		GUIConfig.cc
+		GUIConfig.h
+		GUIRenderer.cc
+		GUIRenderer.h
+		GUIInputHandler.cc
+		GUIInputHandler.h
+		GUIFrontend.cc
+		GUIFrontend.h)
+	target_compile_definitions(kte PRIVATE KTE_BUILD_GUI=1)
+	target_link_libraries(kte imgui)
 
-    # // Set custom ini filename path to ~/.config/kte/imgui.ini
+	# kge (GUI-first) executable
-    # if (const char* home = std::getenv("HOME")) {
+	add_executable(kge
-    #     static std::string ini_path = std::string(home) + "/.config/kte/imgui.ini";
+		main.cc
-    #     io.IniFilename = ini_path.c_str();
+		${COMMON_SOURCES}
-    # }
+		${COMMON_HEADERS}
+		GUIConfig.cc
+		GUIConfig.h
+		GUIRenderer.cc
+		GUIRenderer.h
+		GUIInputHandler.cc
+		GUIInputHandler.h
+		GUIFrontend.cc
+		GUIFrontend.h)
+	target_compile_definitions(kge PRIVATE KTE_BUILD_GUI=1 KTE_DEFAULT_GUI=1 KTE_FONT_SIZE=${KTE_FONT_SIZE})
+	if (KTE_UNDO_DEBUG)
+		target_compile_definitions(kge PRIVATE KTE_UNDO_DEBUG=1)
+	endif ()
+	target_link_libraries(kge ${CURSES_LIBRARIES} imgui)
+	target_include_directories(kge PRIVATE ${CMAKE_SOURCE_DIR}/ext)
 
-    # io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+	# On macOS, build kge as a proper .app bundle
-    # io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+	if (APPLE)
-    # Do not enable GUI in the terminal-first 'kte' binary; GUI is built as separate 'kge'.
+		# Define the icon file
-    # This avoids referencing GUI classes from kte and keeps dependencies minimal.
+		set(MACOSX_BUNDLE_ICON_FILE kge.icns)
+		set(kge_ICON "${CMAKE_CURRENT_SOURCE_DIR}/${MACOSX_BUNDLE_ICON_FILE}")
 
-    # kge (GUI-first) executable
+		# Add icon to the target sources and mark it as a resource
-    add_executable(kge
+		target_sources(kge PRIVATE ${kge_ICON})
-            main.cc
+		set_source_files_properties(${kge_ICON} PROPERTIES
-            ${COMMON_SOURCES}
+			MACOSX_PACKAGE_LOCATION Resources)
-            ${GUI_SOURCES}
-            ${COMMON_HEADERS}
-            ${GUI_HEADERS}
 
-    )
+		# Configure Info.plist with version and identifiers
-    target_compile_definitions(kge PRIVATE KTE_BUILD_GUI=1 KTE_DEFAULT_GUI=1 KTE_FONT_SIZE=${KTE_FONT_SIZE})
+		set(KGE_BUNDLE_ID "dev.wntrmute.kge")
-    if (KTE_USE_QT)
+		configure_file(
-        target_compile_definitions(kge PRIVATE KTE_USE_QT=1)
+			${CMAKE_CURRENT_LIST_DIR}/cmake/Info.plist.in
-    endif ()
+			${CMAKE_CURRENT_BINARY_DIR}/kge-Info.plist
-    if (KTE_UNDO_DEBUG)
+			@ONLY)
-        target_compile_definitions(kge PRIVATE KTE_UNDO_DEBUG=1)
-    endif ()
-    if (KTE_USE_QT)
-        target_link_libraries(kge ${CURSES_LIBRARIES} Qt6::Widgets)
-    else ()
-        target_link_libraries(kge ${CURSES_LIBRARIES} imgui)
-    endif ()
 
-    # Static linking on Linux only (macOS does not support static linking of system libraries)
+		set_target_properties(kge PROPERTIES
-    if (NOT APPLE)
+			MACOSX_BUNDLE TRUE
-        target_link_options(kge PRIVATE -static)
+			MACOSX_BUNDLE_GUI_IDENTIFIER ${KGE_BUNDLE_ID}
-    endif ()
+			MACOSX_BUNDLE_BUNDLE_NAME "kge"
+			MACOSX_BUNDLE_ICON_FILE ${MACOSX_BUNDLE_ICON_FILE}
+			MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_BINARY_DIR}/kge-Info.plist")
 
-    # On macOS, build kge as a proper .app bundle
+		add_dependencies(kge kte)
-    if (APPLE)
+		add_custom_command(TARGET kge POST_BUILD
-        # Define the icon file
+			COMMAND ${CMAKE_COMMAND} -E copy
-        set(MACOSX_BUNDLE_ICON_FILE kge.icns)
+			$<TARGET_FILE:kte>
-        set(kge_ICON "${CMAKE_CURRENT_SOURCE_DIR}/${MACOSX_BUNDLE_ICON_FILE}")
+			$<TARGET_FILE_DIR:kge>/kte
+			COMMENT "Copying kte binary into kge.app bundle")
 
-        # Add icon to the target sources and mark it as a resource
+		install(TARGETS kge
-        target_sources(kge PRIVATE ${kge_ICON})
+			BUNDLE DESTINATION .
-        set_source_files_properties(${kge_ICON} PROPERTIES
+		)
-                MACOSX_PACKAGE_LOCATION Resources)
 
-        # Configure Info.plist with version and identifiers
+		install(TARGETS kte
-        set(KGE_BUNDLE_ID "dev.wntrmute.kge")
+			RUNTIME DESTINATION kge.app/Contents/MacOS
-        configure_file(
+		)
-                ${CMAKE_CURRENT_LIST_DIR}/cmake/Info.plist.in
+	else ()
-                ${CMAKE_CURRENT_BINARY_DIR}/kge-Info.plist
+		install(TARGETS kge
-                @ONLY)
+			RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-
+		)
-        # Ensure proper macOS bundle properties and RPATH so our bundled
+	endif ()
-        # frameworks are preferred over system/Homebrew ones.
+	# Install kge man page only when GUI is built
-        set_target_properties(kge PROPERTIES
+	install(FILES docs/kge.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
-                MACOSX_BUNDLE TRUE
+	install(FILES kge.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/icons)
-                MACOSX_BUNDLE_GUI_IDENTIFIER ${KGE_BUNDLE_ID}
-                MACOSX_BUNDLE_BUNDLE_NAME "kge"
-                MACOSX_BUNDLE_ICON_FILE ${MACOSX_BUNDLE_ICON_FILE}
-                MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_BINARY_DIR}/kge-Info.plist"
-                # Prefer the app's bundled frameworks at runtime
-                INSTALL_RPATH "@executable_path/../Frameworks"
-                BUILD_WITH_INSTALL_RPATH TRUE
-        )
-
-        add_dependencies(kge kte)
-        add_custom_command(TARGET kge POST_BUILD
-                COMMAND ${CMAKE_COMMAND} -E copy
-                $<TARGET_FILE:kte>
-                $<TARGET_FILE_DIR:kge>/kte
-                COMMENT "Copying kte binary into kge.app bundle")
-
-        install(TARGETS kge
-                BUNDLE DESTINATION .
-        )
-
-        install(TARGETS kte
-                RUNTIME DESTINATION kge.app/Contents/MacOS
-        )
-    else ()
-        install(TARGETS kge
-                RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-        )
-    endif ()
-    # Install kge man page only when GUI is built
-    install(FILES docs/kge.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
-    install(FILES kge.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/icons)
-
-    # Optional post-build bundle fixup (can also be run from scripts).
-    # This provides a CMake target to run BundleUtilities' fixup_bundle on the
-    # built app, useful after macdeployqt to ensure non-Qt dylibs are internalized.
-    if (APPLE AND TARGET kge)
-        get_target_property(IS_BUNDLE kge MACOSX_BUNDLE)
-        if (IS_BUNDLE)
-            add_custom_target(kge_fixup_bundle ALL
-                    COMMAND ${CMAKE_COMMAND}
-                    -DAPP_BUNDLE=${CMAKE_CURRENT_BINARY_DIR}/$<TARGET_PROPERTY:kge,MACOSX_BUNDLE_BUNDLE_NAME>.app
-                    -P ${CMAKE_CURRENT_LIST_DIR}/cmake/fix_bundle.cmake
-                    COMMENT "Running fixup_bundle on kge.app to internalize non-Qt dylibs"
-                    VERBATIM)
-            add_dependencies(kge_fixup_bundle kge)
-        endif ()
-    endif ()
 endif ()

Command.h

@@ -1,7 +1,8 @@
 /*
  * Command.h - command model and registry for editor actions
  */
-#pragma once
+#ifndef KTE_COMMAND_H
+#define KTE_COMMAND_H
 
 #include <functional>
 #include <string>
@@ -27,11 +28,8 @@ enum class CommandId {
 	SearchReplace, // begin search & replace (two-step prompt)
 	OpenFileStart, // begin open-file prompt
 	VisualFilePickerToggle,
-	// GUI-only: toggle/show a visual font selector dialog
-	VisualFontPickerToggle,
 	// Buffers
 	BufferSwitchStart, // begin buffer switch prompt
-	BufferNew, // create a new empty, unnamed buffer (C-k i)
 	BufferClose,
 	BufferNext,
 	BufferPrev,
@@ -47,7 +45,6 @@ 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)
@@ -61,8 +58,6 @@ enum class CommandId {
 	MoveEnd,
 	PageUp,
 	PageDown,
-	ScrollUp, // scroll viewport up (towards beginning) without moving cursor
-	ScrollDown, // scroll viewport down (towards end) without moving cursor
 	WordPrev,
 	WordNext,
 	DeleteWordPrev, // delete previous word (ESC BACKSPACE)
@@ -94,22 +89,18 @@ enum class CommandId {
 	ShowHelp, // open +HELP+ buffer with manual text (C-k h)
 	// Meta
 	UnknownKCommand, // arg: single character that was not recognized after C-k
-	UnknownEscCommand, // invalid ESC (meta) command; show status and exit escape mode
 	// Generic command prompt
 	CommandPromptStart, // begin generic command prompt (C-k ;)
 	// Theme by name
 	ThemeSetByName,
-	// Font by name (GUI)
-	FontSetByName,
-	// Font size (GUI)
-	FontSetSize,
 	// Background mode (GUI)
 	BackgroundSet,
 	// Syntax highlighting
 	Syntax, // ":syntax on|off|reload"
 	SetOption, // generic ":set key=value" (v1: filetype=<lang>)
-	// Viewport control
+	// LSP
-	CenterOnCursor, // center the viewport on the current cursor line (C-k k)
+	LspHover,
+	LspGotoDefinition,
 };
 
 
@@ -135,9 +126,6 @@ struct Command {
 	CommandHandler handler;
 	// Public commands are exposed in the ": " prompt (C-k ;)
 	bool isPublic = false;
-	// Whether this command should consume and honor a universal argument repeat count.
-	// Default true per issue request; authors can turn off per-command.
-	bool repeatable = true;
 };
 
 
@@ -165,3 +153,5 @@ void InstallDefaultCommands();
 bool Execute(Editor &ed, CommandId id, const std::string &arg = std::string(), int count = 0);
 
 bool Execute(Editor &ed, const std::string &name, const std::string &arg = std::string(), int count = 0);
+
+#endif // KTE_COMMAND_H

Dockerfile

@@ -1,23 +0,0 @@
-# Minimal Dockerfile for building and testing kte on Linux
-# This container provides a build environment with all dependencies.
-# Mount the source tree at /kte when running the container.
-FROM alpine:3.19
-
-# Install build dependencies
-RUN apk add --no-cache \
-    g++ \
-    cmake \
-    make \
-    ncurses-dev \
-    sdl2-dev \
-    mesa-dev \
-    freetype-dev \
-    libx11-dev \
-    libxext-dev
-
-# Set working directory where source will be mounted
-WORKDIR /kte
-
-# Default command: build and run tests
-# Add DirectFB include path for SDL2 compatibility on Alpine
-CMD ["sh", "-c", "cmake -B build -DBUILD_GUI=ON -DBUILD_TESTS=ON -DCMAKE_CXX_FLAGS='-I/usr/include/directfb' && cmake --build build --target kte && cmake --build build --target kge && cmake --build build --target kte_tests && ./build/kte_tests"]

Editor.cc

@@ -1,53 +1,17 @@
 #include <algorithm>
-#include <cstdio>
-#include <filesystem>
 #include <utility>
+#include <filesystem>
+#include "syntax/HighlighterRegistry.h"
+#include "syntax/NullHighlighter.h"
 
 #include "Editor.h"
+#include "lsp/LspManager.h"
 #include "syntax/HighlighterRegistry.h"
 #include "syntax/CppHighlighter.h"
 #include "syntax/NullHighlighter.h"
 
 
-namespace {
+Editor::Editor() = default;
-static std::string
-buffer_bytes_via_views(const Buffer &b)
-{
-	const std::size_t nrows = b.Nrows();
-	std::string out;
-	for (std::size_t i = 0; i < nrows; i++) {
-		auto v = b.GetLineView(i);
-		out.append(v.data(), v.size());
-	}
-	return out;
-}
-
-
-static void
-apply_pending_line(Editor &ed, const std::size_t line1)
-{
-	if (line1 == 0)
-		return;
-	Buffer *b = ed.CurrentBuffer();
-	if (!b)
-		return;
-	const std::size_t nrows = b->Nrows();
-	std::size_t line        = line1 > 0 ? line1 - 1 : 0; // 1-based to 0-based
-	if (nrows > 0) {
-		if (line >= nrows)
-			line = nrows - 1;
-	} else {
-		line = 0;
-	}
-	b->SetCursor(0, line);
-}
-} // namespace
-
-
-Editor::Editor()
-{
-	swap_ = std::make_unique<kte::SwapManager>();
-}
 
 
 void
@@ -66,6 +30,15 @@ Editor::SetStatus(const std::string &message)
 }
 
 
+void
+Editor::NotifyBufferSaved(Buffer *buf)
+{
+	if (lsp_manager_ && buf) {
+		lsp_manager_->onBufferSaved(buf);
+	}
+}
+
+
 Buffer *
 Editor::CurrentBuffer()
 {
@@ -162,11 +135,6 @@ std::size_t
 Editor::AddBuffer(const Buffer &buf)
 {
 	buffers_.push_back(buf);
-	// Attach swap recorder
-	if (swap_) {
-		swap_->Attach(&buffers_.back());
-		buffers_.back().SetSwapRecorder(swap_->RecorderFor(&buffers_.back()));
-	}
 	if (buffers_.size() == 1) {
 		curbuf_ = 0;
 	}
@@ -178,10 +146,6 @@ std::size_t
 Editor::AddBuffer(Buffer &&buf)
 {
 	buffers_.push_back(std::move(buf));
-	if (swap_) {
-		swap_->Attach(&buffers_.back());
-		buffers_.back().SetSwapRecorder(swap_->RecorderFor(&buffers_.back()));
-	}
 	if (buffers_.size() == 1) {
 		curbuf_ = 0;
 	}
@@ -198,24 +162,19 @@ Editor::OpenFile(const std::string &path, std::string &err)
 		Buffer &cur                  = buffers_[curbuf_];
 		const bool unnamed           = cur.Filename().empty() && !cur.IsFileBacked();
 		const bool clean             = !cur.Dirty();
-		const std::size_t nrows      = cur.Nrows();
+		const auto &rows             = cur.Rows();
-		const bool rows_empty        = (nrows == 0);
+		const bool rows_empty        = rows.empty();
-		const bool single_empty_line = (nrows == 1 && cur.GetLineView(0).size() == 0);
+		const bool single_empty_line = (!rows.empty() && rows.size() == 1 && rows[0].size() == 0);
 		if (unnamed && clean && (rows_empty || single_empty_line)) {
 			bool ok = cur.OpenFromFile(path, err);
 			if (!ok)
 				return false;
-			// Ensure swap recorder is attached for this buffer
-			if (swap_) {
-				swap_->Attach(&cur);
-				cur.SetSwapRecorder(swap_->RecorderFor(&cur));
-				swap_->NotifyFilenameChanged(cur);
-			}
 			// Setup highlighting using registry (extension + shebang)
 			cur.EnsureHighlighter();
 			std::string first = "";
-			if (cur.Nrows() > 0)
+			const auto &rows  = cur.Rows();
-				first = cur.GetLineString(0);
+			if (!rows.empty())
+				first = static_cast<std::string>(rows[0]);
 			std::string ft = kte::HighlighterRegistry::DetectForPath(path, first);
 			if (!ft.empty()) {
 				cur.SetFiletype(ft);
@@ -232,8 +191,10 @@ Editor::OpenFile(const std::string &path, std::string &err)
 					eng->InvalidateFrom(0);
 				}
 			}
-			// Defensive: ensure any active prompt is closed after a successful open
+			// Notify LSP (if wired) for current buffer open
-			CancelPrompt();
+			if (lsp_manager_) {
+				lsp_manager_->onBufferOpened(&cur);
+			}
 			return true;
 		}
 	}
@@ -242,13 +203,14 @@ Editor::OpenFile(const std::string &path, std::string &err)
 	if (!b.OpenFromFile(path, err)) {
 		return false;
 	}
-	// NOTE: swap recorder/attach must happen after the buffer is stored in its
-	// final location (vector) because swap manager keys off Buffer*.
 	// Initialize syntax highlighting by extension + shebang via registry (v2)
 	b.EnsureHighlighter();
 	std::string first = "";
-	if (b.Nrows() > 0)
+	{
-		first = b.GetLineString(0);
+		const auto &rows = b.Rows();
+		if (!rows.empty())
+			first = static_cast<std::string>(rows[0]);
+	}
 	std::string ft = kte::HighlighterRegistry::DetectForPath(path, first);
 	if (!ft.empty()) {
 		b.SetFiletype(ft);
@@ -267,182 +229,15 @@ Editor::OpenFile(const std::string &path, std::string &err)
 	}
 	// Add as a new buffer and switch to it
 	std::size_t idx = AddBuffer(std::move(b));
-	if (swap_) {
-		swap_->NotifyFilenameChanged(buffers_[idx]);
-	}
 	SwitchTo(idx);
-	// Defensive: ensure any active prompt is closed after a successful open
+	// Notify LSP (if wired) for current buffer open
-	CancelPrompt();
+	if (lsp_manager_) {
+		lsp_manager_->onBufferOpened(&buffers_[curbuf_]);
+	}
 	return true;
 }
 
 
-void
-Editor::RequestOpenFile(const std::string &path, const std::size_t line1)
-{
-	PendingOpen p;
-	p.path  = path;
-	p.line1 = line1;
-	pending_open_.push_back(std::move(p));
-}
-
-
-bool
-Editor::HasPendingOpens() const
-{
-	return !pending_open_.empty();
-}
-
-
-Editor::RecoveryPromptKind
-Editor::PendingRecoveryPrompt() const
-{
-	return pending_recovery_prompt_;
-}
-
-
-void
-Editor::CancelRecoveryPrompt()
-{
-	pending_recovery_prompt_ = RecoveryPromptKind::None;
-	pending_recovery_open_   = PendingOpen{};
-	pending_recovery_swap_path_.clear();
-	pending_recovery_replay_err_.clear();
-}
-
-
-bool
-Editor::ResolveRecoveryPrompt(const bool yes)
-{
-	const RecoveryPromptKind kind = pending_recovery_prompt_;
-	if (kind == RecoveryPromptKind::None)
-		return false;
-	const PendingOpen req    = pending_recovery_open_;
-	const std::string swp    = pending_recovery_swap_path_;
-	const std::string rerr_s = pending_recovery_replay_err_;
-	CancelRecoveryPrompt();
-
-	std::string err;
-	if (kind == RecoveryPromptKind::RecoverOrDiscard) {
-		if (yes) {
-			if (!OpenFile(req.path, err)) {
-				SetStatus(err);
-				return false;
-			}
-			Buffer *b = CurrentBuffer();
-			if (!b) {
-				SetStatus("Recovery failed: no buffer");
-				return false;
-			}
-			std::string rerr;
-			if (!kte::SwapManager::ReplayFile(*b, swp, rerr)) {
-				SetStatus("Swap recovery failed: " + rerr);
-				return false;
-			}
-			b->SetDirty(true);
-			apply_pending_line(*this, req.line1);
-			SetStatus("Recovered " + req.path);
-			return true;
-		}
-		// Discard: best-effort delete swap, then open clean.
-		(void) std::remove(swp.c_str());
-		if (!OpenFile(req.path, err)) {
-			SetStatus(err);
-			return false;
-		}
-		apply_pending_line(*this, req.line1);
-		SetStatus("Opened " + req.path);
-		return true;
-	}
-	if (kind == RecoveryPromptKind::DeleteCorruptSwap) {
-		if (yes) {
-			(void) std::remove(swp.c_str());
-		}
-		if (!OpenFile(req.path, err)) {
-			SetStatus(err);
-			return false;
-		}
-		apply_pending_line(*this, req.line1);
-		// Include a short hint that the swap was corrupt.
-		if (!rerr_s.empty()) {
-			SetStatus("Opened " + req.path + " (swap unreadable)");
-		} else {
-			SetStatus("Opened " + req.path);
-		}
-		return true;
-	}
-	return false;
-}
-
-
-bool
-Editor::ProcessPendingOpens()
-{
-	if (PromptActive())
-		return false;
-	if (pending_recovery_prompt_ != RecoveryPromptKind::None)
-		return false;
-
-	bool opened_any = false;
-	while (!pending_open_.empty()) {
-		PendingOpen req = std::move(pending_open_.front());
-		pending_open_.pop_front();
-		if (req.path.empty())
-			continue;
-
-		std::string swp = kte::SwapManager::ComputeSwapPathForFilename(req.path);
-		bool swp_exists = false;
-		try {
-			swp_exists = !swp.empty() && std::filesystem::exists(std::filesystem::path(swp));
-		} catch (...) {
-			swp_exists = false;
-		}
-		if (swp_exists) {
-			Buffer tmp;
-			std::string oerr;
-			if (tmp.OpenFromFile(req.path, oerr)) {
-				const std::string orig = buffer_bytes_via_views(tmp);
-				std::string rerr;
-				if (kte::SwapManager::ReplayFile(tmp, swp, rerr)) {
-					const std::string rec = buffer_bytes_via_views(tmp);
-					if (rec != orig) {
-						pending_recovery_prompt_    = RecoveryPromptKind::RecoverOrDiscard;
-						pending_recovery_open_      = req;
-						pending_recovery_swap_path_ = swp;
-						StartPrompt(PromptKind::Confirm, "Recover", "");
-						SetStatus("Recover swap edits for " + req.path + "? (y/N, C-g cancel)");
-						return opened_any;
-					}
-				} else {
-					pending_recovery_prompt_     = RecoveryPromptKind::DeleteCorruptSwap;
-					pending_recovery_open_       = req;
-					pending_recovery_swap_path_  = swp;
-					pending_recovery_replay_err_ = rerr;
-					StartPrompt(PromptKind::Confirm, "Swap", "");
-					SetStatus(
-						"Swap file unreadable for " + req.path +
-						". Delete it? (y/N, C-g cancel)");
-					return opened_any;
-				}
-			}
-		}
-
-		std::string err;
-		if (!OpenFile(req.path, err)) {
-			SetStatus(err);
-			opened_any = false;
-			continue;
-		}
-		apply_pending_line(*this, req.line1);
-		SetStatus("Opened " + req.path);
-		opened_any = true;
-		// Open at most one per call; frontends can call us again next frame.
-		break;
-	}
-	return opened_any;
-}
-
-
 bool
 Editor::SwitchTo(std::size_t index)
 {
@@ -481,13 +276,6 @@ Editor::CloseBuffer(std::size_t index)
 	if (index >= buffers_.size()) {
 		return false;
 	}
-	if (swap_) {
-		// Always remove swap file when closing a buffer on normal exit.
-		// Swap files are for crash recovery; on clean close, we don't need them.
-		// This prevents stale swap files from accumulating (e.g., when used as git editor).
-		swap_->Detach(&buffers_[index], true);
-		buffers_[index].SetSwapRecorder(nullptr);
-	}
 	buffers_.erase(buffers_.begin() + static_cast<std::ptrdiff_t>(index));
 	if (buffers_.empty()) {
 		curbuf_ = 0;
@@ -510,67 +298,8 @@ Editor::Reset()
 	msgtm_                = 0;
 	uarg_                 = 0;
 	ucount_               = 0;
-	repeatable_           = false;
 	quit_requested_       = false;
 	quit_confirm_pending_ = false;
-	// Reset close-confirm/save state
-	close_confirm_pending_ = false;
-	close_after_save_      = false;
 	buffers_.clear();
 	curbuf_ = 0;
 }
-
-
-// --- Universal argument helpers ---
-void
-Editor::UArgStart()
-{
-	// If not active, start fresh; else multiply by 4 per ke semantics
-	if (uarg_ == 0) {
-		ucount_ = 0;
-	} else {
-		if (ucount_ == 0) {
-			ucount_ = 1;
-		}
-		ucount_ *= 4;
-	}
-	uarg_ = 1;
-	char buf[64];
-	std::snprintf(buf, sizeof(buf), "C-u %d", ucount_);
-	SetStatus(buf);
-}
-
-
-void
-Editor::UArgDigit(int d)
-{
-	if (d < 0)
-		d = 0;
-	if (d > 9)
-		d = 9;
-	if (uarg_ == 0) {
-		uarg_   = 1;
-		ucount_ = 0;
-	}
-	ucount_ = ucount_ * 10 + d;
-	char buf[64];
-	std::snprintf(buf, sizeof(buf), "C-u %d", ucount_);
-	SetStatus(buf);
-}
-
-
-void
-Editor::UArgClear()
-{
-	uarg_   = 0;
-	ucount_ = 0;
-}
-
-
-int
-Editor::UArgGet()
-{
-	int n = (ucount_ > 0) ? ucount_ : 1;
-	UArgClear();
-	return n;
-}

Editor.h

@@ -1,52 +1,22 @@
 /*
  * Editor.h - top-level editor state and buffer management
- *
- * Editor is the top-level coordinator in kte. It manages:
- *
- * - Buffer collection: Multiple open documents (buffers_), current buffer selection
- * - UI state: Dimensions, status messages, prompts, search state
- * - Kill ring: Shared clipboard for cut/copy/paste operations across buffers
- * - Universal argument: Repeat count mechanism (C-u)
- * - Mode flags: Editor modes (normal, k-command, search, prompt, etc.)
- * - Swap/crash recovery: SwapManager integration for journaling
- * - File operations: Opening files, managing pending opens, recovery prompts
- *
- * Key responsibilities:
- *
- * 1. Buffer lifecycle:
- *    - AddBuffer(): Add new buffers to the collection
- *    - OpenFile(): Load files into buffers
- *    - SwitchTo(): Change active buffer
- *    - CloseBuffer(): Remove buffers with dirty checks
- *
- * 2. UI coordination:
- *    - SetDimensions(): Terminal/window size for viewport calculations
- *    - SetStatus(): Status line messages with timestamps
- *    - Prompt system: Multi-step prompts for file open, buffer switch, etc.
- *    - Search state: Active search, query, match position, origin tracking
- *
- * 3. Shared editor state:
- *    - Kill ring: Circular buffer of killed text (max 60 entries)
- *    - Universal argument: C-u digit collection for command repetition
- *    - Mode tracking: Current input mode (normal, k-command, ESC, prompt)
- *
- * 4. Integration points:
- *    - Commands operate on Editor and current Buffer
- *    - Frontend (Terminal/GUI) queries Editor for rendering
- *    - SwapManager journals all buffer modifications
- *
- * Design note: Editor owns the buffer collection but doesn't directly edit content.
- * Commands modify buffers through Buffer's API, and Editor coordinates the UI state.
  */
-#pragma once
+#ifndef KTE_EDITOR_H
+#define KTE_EDITOR_H
+
 #include <cstddef>
 #include <ctime>
-#include <deque>
 #include <string>
 #include <vector>
 
 #include "Buffer.h"
-#include "Swap.h"
+
+// fwd decl for LSP wiring
+namespace kte {
+namespace lsp {
+class LspManager;
+}
+}
 
 
 class Editor {
@@ -69,16 +39,6 @@ public:
 	}
 
 
-	[[nodiscard]] std::size_t ContentRows() const
-	{
-		// Always compute from current rows_ to avoid stale values.
-		// Reserve 1 row for status line.
-		if (rows_ == 0)
-			return 1;
-		return std::max<std::size_t>(1, rows_ - 1);
-	}
-
-
 	// Mode and flags (mirroring legacy fields)
 	void SetMode(int m)
 	{
@@ -195,33 +155,6 @@ public:
 	}
 
 
-	// --- Universal argument control (C-u) ---
-	// Begin or extend a universal argument (like ke's uarg_start)
-	void UArgStart();
-
-	// Add a digit 0..9 to the current universal argument (like ke's uarg_digit)
-	void UArgDigit(int d);
-
-	// Clear universal-argument state (like ke's uarg_clear)
-	void UArgClear();
-
-	// Consume the current universal argument, returning count >= 1.
-	// If no universal argument active, returns 1.
-	int UArgGet();
-
-	// Repeatable command flag: input layer can mark the next command as repeatable
-	void SetRepeatable(bool on)
-	{
-		repeatable_ = on;
-	}
-
-
-	[[nodiscard]] bool Repeatable() const
-	{
-		return repeatable_;
-	}
-
-
 	// Status message storage. Rendering is renderer-dependent; the editor
 	// merely stores the current message and its timestamp.
 	void SetStatus(const std::string &message);
@@ -258,31 +191,6 @@ public:
 	}
 
 
-	// --- Buffer close/save confirmation state ---
-	void SetCloseConfirmPending(bool on)
-	{
-		close_confirm_pending_ = on;
-	}
-
-
-	[[nodiscard]] bool CloseConfirmPending() const
-	{
-		return close_confirm_pending_;
-	}
-
-
-	void SetCloseAfterSave(bool on)
-	{
-		close_after_save_ = on;
-	}
-
-
-	[[nodiscard]] bool CloseAfterSave() const
-	{
-		return close_after_save_;
-	}
-
-
 	[[nodiscard]] std::time_t StatusTime() const
 	{
 		return msgtm_;
@@ -535,29 +443,21 @@ public:
 
 	bool OpenFile(const std::string &path, std::string &err);
 
-	// Request that a file be opened. The request is processed by calling
+	// LSP: attach/detach manager
-	// ProcessPendingOpens() (typically once per frontend frame).
+	void SetLspManager(kte::lsp::LspManager *mgr)
-	void RequestOpenFile(const std::string &path, std::size_t line1 = 0);
+	{
+		lsp_manager_ = mgr;
+	}
 
-	// If no modal prompt is active, process queued open requests.
-	// Returns true if a file was opened during this call.
-	bool ProcessPendingOpens();
 
-	[[nodiscard]] bool HasPendingOpens() const;
+	// LSP helpers: trigger hover/definition at current cursor in current buffer
+	bool LspHoverAtCursor();
 
-	// Swap recovery confirmation state. When non-None, a `PromptKind::Confirm`
+	bool LspGotoDefinitionAtCursor();
-	// prompt is active and the user's answer should be routed to ResolveRecoveryPrompt().
-	enum class RecoveryPromptKind {
-		None = 0,
-		RecoverOrDiscard, // y = recover swap, else discard swap and open clean
-		DeleteCorruptSwap // y = delete corrupt swap, else keep it
-	};
 
-	[[nodiscard]] RecoveryPromptKind PendingRecoveryPrompt() const;
 
-	bool ResolveRecoveryPrompt(bool yes);
+	// LSP: notify buffer saved (used by commands)
-
+	void NotifyBufferSaved(Buffer *buf);
-	void CancelRecoveryPrompt();
 
 	// Buffer switching/closing
 	bool SwitchTo(std::size_t index);
@@ -580,13 +480,6 @@ public:
 	}
 
 
-	// Swap manager access (for advanced integrations/tests)
-	[[nodiscard]] kte::SwapManager *Swap()
-	{
-		return swap_.get();
-	}
-
-
 	// --- GUI: Visual File Picker state ---
 	void SetFilePickerVisible(bool on)
 	{
@@ -612,11 +505,6 @@ public:
 	}
 
 private:
-	struct PendingOpen {
-		std::string path;
-		std::size_t line1{0}; // 1-based; 0 = none
-	};
-
 	std::size_t rows_ = 0, cols_ = 0;
 	int mode_         = 0;
 	int kill_         = 0; // KILL CHAIN
@@ -625,23 +513,17 @@ private:
 	std::string msg_;
 	std::time_t msgtm_ = 0;
 	int uarg_          = 0, ucount_ = 0; // C-u support
-	bool repeatable_   = false; // whether the next command is repeatable
 
 	std::vector<Buffer> buffers_;
 	std::size_t curbuf_ = 0; // index into buffers_
 
-	// Swap journaling manager (lifetime = editor)
-	std::unique_ptr<kte::SwapManager> swap_;
-
 	// Kill ring (Emacs-like)
 	std::vector<std::string> kill_ring_;
 	std::size_t kill_ring_max_ = 60;
 
 	// Quit state
-	bool quit_requested_        = false;
+	bool quit_requested_       = false;
-	bool quit_confirm_pending_  = false;
+	bool quit_confirm_pending_ = false;
-	bool close_confirm_pending_ = false; // awaiting y/N to save-before-close
-	bool close_after_save_      = false; // if true, close buffer after successful Save/SaveAs
 
 	// Search state
 	bool search_active_ = false;
@@ -660,13 +542,6 @@ private:
 	std::string prompt_text_;
 	std::string pending_overwrite_path_;
 
-	// Deferred open + swap recovery prompt state
-	std::deque<PendingOpen> pending_open_;
-	RecoveryPromptKind pending_recovery_prompt_ = RecoveryPromptKind::None;
-	PendingOpen pending_recovery_open_{};
-	std::string pending_recovery_swap_path_;
-	std::string pending_recovery_replay_err_;
-
 	// GUI-only state (safe no-op in terminal builds)
 	bool file_picker_visible_ = false;
 	std::string file_picker_dir_;
@@ -699,4 +574,9 @@ public:
 private:
 	std::string replace_find_tmp_;
 	std::string replace_with_tmp_;
+
+	// Non-owning pointer to LSP manager (if provided)
+	kte::lsp::LspManager *lsp_manager_ = nullptr;
 };
+
+#endif // KTE_EDITOR_H

ErrorHandler.cc

@@ -1,318 +0,0 @@
-#include "ErrorHandler.h"
-#include <chrono>
-#include <ctime>
-#include <iomanip>
-#include <sstream>
-#include <filesystem>
-#include <cstdlib>
-
-namespace fs = std::filesystem;
-
-namespace kte {
-ErrorHandler::ErrorHandler()
-{
-	// Determine log file path: ~/.local/state/kte/error.log
-	const char *home = std::getenv("HOME");
-	if (home) {
-		fs::path log_dir = fs::path(home) / ".local" / "state" / "kte";
-		try {
-			if (!fs::exists(log_dir)) {
-				fs::create_directories(log_dir);
-			}
-			log_file_path_ = (log_dir / "error.log").string();
-		} catch (...) {
-			// If we can't create the directory, disable file logging
-			file_logging_enabled_ = false;
-		}
-	} else {
-		// No HOME, disable file logging
-		file_logging_enabled_ = false;
-	}
-}
-
-
-ErrorHandler::~ErrorHandler()
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	if (log_file_ &&log_file_
-	->
-	is_open()
-	)
-	{
-		log_file_->flush();
-		log_file_->close();
-	}
-}
-
-
-ErrorHandler &
-ErrorHandler::Instance()
-{
-	static ErrorHandler instance;
-	return instance;
-}
-
-
-void
-ErrorHandler::Report(ErrorSeverity severity, const std::string &component,
-                     const std::string &message, const std::string &context)
-{
-	ErrorRecord record;
-	record.timestamp_ns = now_ns();
-	record.severity     = severity;
-	record.component    = component;
-	record.message      = message;
-	record.context      = context;
-
-	{
-		std::lock_guard<std::mutex> lg(mtx_);
-
-		// Add to in-memory queue
-		errors_.push_back(record);
-		while (errors_.size() > 100) {
-			errors_.pop_front();
-		}
-
-		++total_error_count_;
-		if (severity == ErrorSeverity::Critical) {
-			++critical_error_count_;
-		}
-
-		// Write to log file if enabled
-		if (file_logging_enabled_) {
-			write_to_log(record);
-		}
-	}
-}
-
-
-void
-ErrorHandler::Info(const std::string &component, const std::string &message,
-                   const std::string &context)
-{
-	Report(ErrorSeverity::Info, component, message, context);
-}
-
-
-void
-ErrorHandler::Warning(const std::string &component, const std::string &message,
-                      const std::string &context)
-{
-	Report(ErrorSeverity::Warning, component, message, context);
-}
-
-
-void
-ErrorHandler::Error(const std::string &component, const std::string &message,
-                    const std::string &context)
-{
-	Report(ErrorSeverity::Error, component, message, context);
-}
-
-
-void
-ErrorHandler::Critical(const std::string &component, const std::string &message,
-                       const std::string &context)
-{
-	Report(ErrorSeverity::Critical, component, message, context);
-}
-
-
-bool
-ErrorHandler::HasErrors() const
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	return !errors_.empty();
-}
-
-
-bool
-ErrorHandler::HasCriticalErrors() const
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	return critical_error_count_ > 0;
-}
-
-
-std::string
-ErrorHandler::GetLastError() const
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	if (errors_.empty())
-		return "";
-
-	const ErrorRecord &e = errors_.back();
-	std::string result   = "[" + severity_to_string(e.severity) + "] ";
-	result               += e.component;
-	if (!e.context.empty()) {
-		result += " (" + e.context + ")";
-	}
-	result += ": " + e.message;
-	return result;
-}
-
-
-std::size_t
-ErrorHandler::GetErrorCount() const
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	return total_error_count_;
-}
-
-
-std::size_t
-ErrorHandler::GetErrorCount(ErrorSeverity severity) const
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	std::size_t count = 0;
-	for (const auto &e: errors_) {
-		if (e.severity == severity) {
-			++count;
-		}
-	}
-	return count;
-}
-
-
-std::vector<ErrorHandler::ErrorRecord>
-ErrorHandler::GetRecentErrors(std::size_t max_count) const
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	std::vector<ErrorRecord> result;
-	result.reserve(std::min(max_count, errors_.size()));
-
-	// Return most recent first
-	auto it = errors_.rbegin();
-	for (std::size_t i = 0; i < max_count && it != errors_.rend(); ++i, ++it) {
-		result.push_back(*it);
-	}
-	return result;
-}
-
-
-void
-ErrorHandler::ClearErrors()
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	errors_.clear();
-	total_error_count_    = 0;
-	critical_error_count_ = 0;
-}
-
-
-void
-ErrorHandler::SetFileLoggingEnabled(bool enabled)
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	file_logging_enabled_ = enabled;
-	if (!enabled && log_file_ && log_file_->is_open()) {
-		log_file_->flush();
-		log_file_->close();
-		log_file_.reset();
-	}
-}
-
-
-std::string
-ErrorHandler::GetLogFilePath() const
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	return log_file_path_;
-}
-
-
-void
-ErrorHandler::write_to_log(const ErrorRecord &record)
-{
-	// Must be called with mtx_ held
-	if (log_file_path_.empty())
-		return;
-
-	ensure_log_file();
-	if (!log_file_ || !log_file_->is_open())
-		return;
-
-	// Format: [timestamp] [SEVERITY] component (context): message
-	std::string timestamp = format_timestamp(record.timestamp_ns);
-	std::string severity  = severity_to_string(record.severity);
-
-	*log_file_ << "[" << timestamp << "] [" << severity << "] " << record.component;
-	if (!record.context.empty()) {
-		*log_file_ << " (" << record.context << ")";
-	}
-	*log_file_ << ": " << record.message << "\n";
-	log_file_->flush();
-}
-
-
-void
-ErrorHandler::ensure_log_file()
-{
-	// Must be called with mtx_ held
-	if (log_file_ &&log_file_
-	->
-	is_open()
-	)
-	return;
-
-	if (log_file_path_.empty())
-		return;
-
-	try {
-		log_file_ = std::make_unique<std::ofstream>(log_file_path_,
-		                                            std::ios::app | std::ios::out);
-		if (!log_file_->is_open()) {
-			log_file_.reset();
-		}
-	} catch (...) {
-		log_file_.reset();
-	}
-}
-
-
-std::string
-ErrorHandler::format_timestamp(std::uint64_t timestamp_ns) const
-{
-	// Convert nanoseconds to time_t (seconds)
-	std::time_t seconds = static_cast<std::time_t>(timestamp_ns / 1000000000ULL);
-	std::uint64_t nanos = timestamp_ns % 1000000000ULL;
-
-	std::tm tm_buf{};
-#if defined(_WIN32)
-	localtime_s(&tm_buf, &seconds);
-#else
-	localtime_r(&seconds, &tm_buf);
-#endif
-
-	std::ostringstream oss;
-	oss << std::put_time(&tm_buf, "%Y-%m-%d %H:%M:%S");
-	oss << "." << std::setfill('0') << std::setw(3) << (nanos / 1000000ULL);
-	return oss.str();
-}
-
-
-std::string
-ErrorHandler::severity_to_string(ErrorSeverity severity) const
-{
-	switch (severity) {
-	case ErrorSeverity::Info:
-		return "INFO";
-	case ErrorSeverity::Warning:
-		return "WARNING";
-	case ErrorSeverity::Error:
-		return "ERROR";
-	case ErrorSeverity::Critical:
-		return "CRITICAL";
-	default:
-		return "UNKNOWN";
-	}
-}
-
-
-std::uint64_t
-ErrorHandler::now_ns()
-{
-	using namespace std::chrono;
-	return duration_cast<nanoseconds>(steady_clock::now().time_since_epoch()).count();
-}
-} // namespace kte

ErrorHandler.h

@@ -1,106 +0,0 @@
-// ErrorHandler.h - Centralized error handling and logging for kte
-#pragma once
-
-#include <string>
-#include <vector>
-#include <deque>
-#include <mutex>
-#include <cstdint>
-#include <memory>
-#include <fstream>
-
-namespace kte {
-enum class ErrorSeverity {
-	Info, // Informational messages
-	Warning, // Non-critical issues
-	Error, // Errors that affect functionality but allow continuation
-	Critical // Critical errors that may cause data loss or crashes
-};
-
-// Centralized error handler with logging and in-memory error tracking
-class ErrorHandler {
-public:
-	struct ErrorRecord {
-		std::uint64_t timestamp_ns{0};
-		ErrorSeverity severity{ErrorSeverity::Error};
-		std::string component; // e.g., "SwapManager", "Buffer", "main"
-		std::string message;
-		std::string context; // e.g., filename, buffer name, operation
-	};
-
-	// Get the global ErrorHandler instance
-	static ErrorHandler &Instance();
-
-	// Report an error with severity, component, message, and optional context
-	void Report(ErrorSeverity severity, const std::string &component,
-	            const std::string &message, const std::string &context = "");
-
-	// Convenience methods for common severity levels
-	void Info(const std::string &component, const std::string &message,
-	          const std::string &context = "");
-
-	void Warning(const std::string &component, const std::string &message,
-	             const std::string &context = "");
-
-	void Error(const std::string &component, const std::string &message,
-	           const std::string &context = "");
-
-	void Critical(const std::string &component, const std::string &message,
-	              const std::string &context = "");
-
-	// Query error state (thread-safe)
-	bool HasErrors() const;
-
-	bool HasCriticalErrors() const;
-
-	std::string GetLastError() const;
-
-	std::size_t GetErrorCount() const;
-
-	std::size_t GetErrorCount(ErrorSeverity severity) const;
-
-	// Get recent errors (up to max_count, most recent first)
-	std::vector<ErrorRecord> GetRecentErrors(std::size_t max_count = 10) const;
-
-	// Clear in-memory error history (does not affect log file)
-	void ClearErrors();
-
-	// Enable/disable file logging (enabled by default)
-	void SetFileLoggingEnabled(bool enabled);
-
-	// Get the path to the error log file
-	std::string GetLogFilePath() const;
-
-private:
-	ErrorHandler();
-
-	~ErrorHandler();
-
-	// Non-copyable, non-movable
-	ErrorHandler(const ErrorHandler &) = delete;
-
-	ErrorHandler &operator=(const ErrorHandler &) = delete;
-
-	ErrorHandler(ErrorHandler &&) = delete;
-
-	ErrorHandler &operator=(ErrorHandler &&) = delete;
-
-	void write_to_log(const ErrorRecord &record);
-
-	void ensure_log_file();
-
-	std::string format_timestamp(std::uint64_t timestamp_ns) const;
-
-	std::string severity_to_string(ErrorSeverity severity) const;
-
-	static std::uint64_t now_ns();
-
-	mutable std::mutex mtx_;
-	std::deque<ErrorRecord> errors_; // bounded to max 100 entries
-	std::size_t total_error_count_{0};
-	std::size_t critical_error_count_{0};
-	bool file_logging_enabled_{true};
-	std::string log_file_path_;
-	std::unique_ptr<std::ofstream> log_file_;
-};
-} // namespace kte

ErrorRecovery.cc

@@ -1,157 +0,0 @@
-// ErrorRecovery.cc - Error recovery mechanisms implementation
-#include "ErrorRecovery.h"
-#include <mutex>
-
-namespace kte {
-CircuitBreaker::CircuitBreaker(const Config &cfg)
-	: config_(cfg), state_(State::Closed), failure_count_(0), success_count_(0),
-	  last_failure_time_(std::chrono::steady_clock::time_point::min()),
-	  state_change_time_(std::chrono::steady_clock::now()) {}
-
-
-bool
-CircuitBreaker::AllowRequest()
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-
-	const auto now = std::chrono::steady_clock::now();
-
-	switch (state_) {
-	case State::Closed:
-		// Normal operation, allow all requests
-		return true;
-
-	case State::Open: {
-		// Check if timeout has elapsed to transition to HalfOpen
-		const auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
-			now - state_change_time_
-		);
-		if (elapsed >= config_.open_timeout) {
-			TransitionTo(State::HalfOpen);
-			return true; // Allow one request to test recovery
-		}
-		return false; // Circuit is open, reject request
-	}
-
-	case State::HalfOpen:
-		// Allow limited requests to test recovery
-		return true;
-	}
-
-	return false;
-}
-
-
-void
-CircuitBreaker::RecordSuccess()
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-
-	switch (state_) {
-	case State::Closed:
-		// Reset failure count on success in normal operation
-		failure_count_ = 0;
-		break;
-
-	case State::HalfOpen:
-		++success_count_;
-		if (success_count_ >= config_.success_threshold) {
-			// Enough successes, close the circuit
-			TransitionTo(State::Closed);
-		}
-		break;
-
-	case State::Open:
-		// Shouldn't happen (requests rejected), but handle gracefully
-		break;
-	}
-}
-
-
-void
-CircuitBreaker::RecordFailure()
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-
-	const auto now     = std::chrono::steady_clock::now();
-	last_failure_time_ = now;
-
-	switch (state_) {
-	case State::Closed:
-		// Check if we need to reset the failure count (window expired)
-		if (IsWindowExpired()) {
-			failure_count_ = 0;
-		}
-
-		++failure_count_;
-		if (failure_count_ >= config_.failure_threshold) {
-			// Too many failures, open the circuit
-			TransitionTo(State::Open);
-		}
-		break;
-
-	case State::HalfOpen:
-		// Failure during recovery test, reopen the circuit
-		TransitionTo(State::Open);
-		break;
-
-	case State::Open:
-		// Already open, just track the failure
-		++failure_count_;
-		break;
-	}
-}
-
-
-void
-CircuitBreaker::Reset()
-{
-	std::lock_guard<std::mutex> lg(mtx_);
-	TransitionTo(State::Closed);
-}
-
-
-void
-CircuitBreaker::TransitionTo(State new_state)
-{
-	if (state_ == new_state) {
-		return;
-	}
-
-	state_             = new_state;
-	state_change_time_ = std::chrono::steady_clock::now();
-
-	switch (new_state) {
-	case State::Closed:
-		failure_count_ = 0;
-		success_count_ = 0;
-		break;
-
-	case State::Open:
-		success_count_ = 0;
-		// Keep failure_count_ for diagnostics
-		break;
-
-	case State::HalfOpen:
-		success_count_ = 0;
-		// Keep failure_count_ for diagnostics
-		break;
-	}
-}
-
-
-bool
-CircuitBreaker::IsWindowExpired() const
-{
-	if (failure_count_ == 0) {
-		return false;
-	}
-
-	const auto now     = std::chrono::steady_clock::now();
-	const auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(
-		now - last_failure_time_
-	);
-
-	return elapsed >= config_.window;
-}
-} // namespace kte

ErrorRecovery.h

@@ -1,170 +0,0 @@
-// ErrorRecovery.h - Error recovery mechanisms for kte
-#pragma once
-
-#include <chrono>
-#include <cstddef>
-#include <functional>
-#include <string>
-#include <thread>
-#include <mutex>
-#include <cerrno>
-
-namespace kte {
-// Classify errno values as transient (retryable) or permanent
-inline bool
-IsTransientError(int err)
-{
-	switch (err) {
-	case EAGAIN:
-#if EAGAIN != EWOULDBLOCK
-	case EWOULDBLOCK: 
-#endif
-	case EBUSY:
-	case EIO: // I/O error (may be transient on network filesystems)
-	case ETIMEDOUT:
-	case ENOSPC: // Disk full (may become available)
-	case EDQUOT: // Quota exceeded (may become available)
-		return true;
-	default:
-		return false;
-	}
-}
-
-
-// RetryPolicy defines retry behavior for transient failures
-struct RetryPolicy {
-	std::size_t max_attempts{3}; // Maximum retry attempts
-	std::chrono::milliseconds initial_delay{100}; // Initial delay before first retry
-	double backoff_multiplier{2.0}; // Exponential backoff multiplier
-	std::chrono::milliseconds max_delay{5000}; // Maximum delay between retries
-
-	// Default policy: 3 attempts, 100ms initial, 2x backoff, 5s max
-	static RetryPolicy Default()
-	{
-		return RetryPolicy{};
-	}
-
-
-	// Aggressive policy for critical operations: more attempts, faster retries
-	static RetryPolicy Aggressive()
-	{
-		return RetryPolicy{5, std::chrono::milliseconds(50), 1.5, std::chrono::milliseconds(2000)};
-	}
-
-
-	// Conservative policy for non-critical operations: fewer attempts, slower retries
-	static RetryPolicy Conservative()
-	{
-		return RetryPolicy{2, std::chrono::milliseconds(200), 2.5, std::chrono::milliseconds(10000)};
-	}
-};
-
-// Retry a function with exponential backoff for transient errors
-// Returns true on success, false on permanent failure or exhausted retries
-// The function `fn` should return true on success, false on failure, and set errno on failure
-template<typename Func>
-bool
-RetryOnTransientError(Func fn, const RetryPolicy &policy, std::string &err)
-{
-	std::size_t attempt             = 0;
-	std::chrono::milliseconds delay = policy.initial_delay;
-
-	while (attempt < policy.max_attempts) {
-		++attempt;
-		errno = 0;
-		if (fn()) {
-			return true; // Success
-		}
-
-		int saved_errno = errno;
-		if (!IsTransientError(saved_errno)) {
-			// Permanent error, don't retry
-			return false;
-		}
-
-		if (attempt >= policy.max_attempts) {
-			// Exhausted retries
-			err += " (exhausted " + std::to_string(policy.max_attempts) + " retry attempts)";
-			return false;
-		}
-
-		// Sleep before retry
-		std::this_thread::sleep_for(delay);
-
-		// Exponential backoff
-		delay = std::chrono::milliseconds(
-			static_cast<long long>(delay.count() * policy.backoff_multiplier)
-		);
-		if (delay > policy.max_delay) {
-			delay = policy.max_delay;
-		}
-	}
-
-	return false;
-}
-
-
-// CircuitBreaker prevents repeated attempts to failing operations
-// States: Closed (normal), Open (failing, reject immediately), HalfOpen (testing recovery)
-class CircuitBreaker {
-public:
-	enum class State {
-		Closed, // Normal operation, allow all requests
-		Open, // Failing, reject requests immediately
-		HalfOpen // Testing recovery, allow limited requests
-	};
-
-	struct Config {
-		std::size_t failure_threshold; // Failures before opening circuit
-		std::chrono::seconds open_timeout; // Time before attempting recovery (Open → HalfOpen)
-		std::size_t success_threshold; // Successes in HalfOpen before closing
-		std::chrono::seconds window; // Time window for counting failures
-
-		Config()
-			: failure_threshold(5), open_timeout(30), success_threshold(2), window(60) {}
-	};
-
-
-	explicit CircuitBreaker(const Config &cfg = Config());
-
-
-	// Check if operation is allowed (returns false if circuit is Open)
-	bool AllowRequest();
-
-	// Record successful operation
-	void RecordSuccess();
-
-	// Record failed operation
-	void RecordFailure();
-
-	// Get current state
-	State GetState() const
-	{
-		return state_;
-	}
-
-
-	// Get failure count in current window
-	std::size_t GetFailureCount() const
-	{
-		return failure_count_;
-	}
-
-
-	// Reset circuit to Closed state (for testing or manual intervention)
-	void Reset();
-
-private:
-	void TransitionTo(State new_state);
-
-	bool IsWindowExpired() const;
-
-	Config config_;
-	State state_;
-	std::size_t failure_count_;
-	std::size_t success_count_;
-	std::chrono::steady_clock::time_point last_failure_time_;
-	std::chrono::steady_clock::time_point state_change_time_;
-	mutable std::mutex mtx_;
-};
-} // namespace kte

Frontend.h

@@ -1,7 +1,9 @@
 /*
  * Frontend.h - top-level container that couples Input + Renderer and runs the loop
  */
-#pragma once
+#ifndef KTE_FRONTEND_H
+#define KTE_FRONTEND_H
+
 
 class Editor;
 class InputHandler;
@@ -12,7 +14,7 @@ public:
 	virtual ~Frontend() = default;
 
 	// Initialize the frontend (create window/terminal, etc.)
-	virtual bool Init(int &argc, char **argv, Editor &ed) = 0;
+	virtual bool Init(Editor &ed) = 0;
 
 	// Execute one iteration (poll input, dispatch, draw). Set running=false to exit.
 	virtual void Step(Editor &ed, bool &running) = 0;
@@ -20,3 +22,5 @@ public:
 	// Shutdown/cleanup
 	virtual void Shutdown() = 0;
 };
+
+#endif // KTE_FRONTEND_H

GUIConfig.cc

@@ -102,8 +102,6 @@ GUIConfig::LoadFromFile(const std::string &path)
 			if (v > 0.0f) {
 				font_size = v;
 			}
-		} else if (key == "font") {
-			font = val;
 		} else if (key == "theme") {
 			theme = val;
 		} else if (key == "background" || key == "bg") {

GUIConfig.h

@@ -1,7 +1,8 @@
 /*
  * GUIConfig - loads simple GUI configuration from $HOME/.config/kte/kge.ini
  */
-#pragma once
+#ifndef KTE_GUI_CONFIG_H
+#define KTE_GUI_CONFIG_H
 
 #include <string>
 
@@ -15,7 +16,6 @@ public:
 	int columns       = 80;
 	int rows          = 42;
 	float font_size   = (float) KTE_FONT_SIZE;
-	std::string font  = "default";
 	std::string theme = "nord";
 	// Background mode for themes that support light/dark variants
 	// Values: "dark" (default), "light"
@@ -31,3 +31,5 @@ public:
 	// Load from explicit path. Returns true if file existed and was parsed.
 	bool LoadFromFile(const std::string &path);
 };
+
+#endif // KTE_GUI_CONFIG_H

GUIFrontend.cc

@@ -1,24 +1,21 @@
-#include <algorithm>
 #include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <filesystem>
 #include <string>
+#include <cstring>
+#include <cstdlib>
+#include <algorithm>
 
-#include <imgui.h>
 #include <SDL.h>
 #include <SDL_opengl.h>
-#include <backends/imgui_impl_opengl3.h>
+#include <imgui.h>
 #include <backends/imgui_impl_sdl2.h>
+#include <backends/imgui_impl_opengl3.h>
 
-#include "ImGuiFrontend.h"
-#include "Command.h"
 #include "Editor.h"
+#include "Command.h"
+#include "GUIFrontend.h"
+#include "Font.h" // embedded default font (DefaultFontRegular)
 #include "GUIConfig.h"
 #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"
 
@@ -27,16 +24,12 @@
 #define KTE_FONT_SIZE 16.0f
 #endif
 
-static auto kGlslVersion = "#version 150"; // GL 3.2 core (macOS compatible)
+static const char *kGlslVersion = "#version 150"; // GL 3.2 core (macOS compatible)
 
 bool
-GUIFrontend::Init(int &argc, char **argv, Editor &ed)
+GUIFrontend::Init(Editor &ed)
 {
-	(void) argc;
+	(void) ed; // editor dimensions will be initialized during the first Step() frame
-	(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
 	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0) {
 		return false;
 	}
@@ -83,17 +76,13 @@ GUIFrontend::Init(int &argc, char **argv, Editor &ed)
 		height_ = std::max(200, h);
 	}
 
-	SDL_SetHint(SDL_HINT_VIDEO_ALLOW_SCREENSAVER, "1");
 	window_ = SDL_CreateWindow(
 		"kge - kyle's graphical editor " KTE_VERSION_STR,
 		SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
 		width_, height_,
 		win_flags);
-	if (!window_) {
+	if (!window_)
 		return false;
-	}
-
-	SDL_EnableScreenSaver();
 
 #if defined(__APPLE__)
 	// macOS: when "fullscreen" is requested, position the window at the
@@ -116,25 +105,7 @@ GUIFrontend::Init(int &argc, char **argv, Editor &ed)
 	IMGUI_CHECKVERSION();
 	ImGui::CreateContext();
 	ImGuiIO &io = ImGui::GetIO();
-
+	(void) io;
-	// Set custom ini filename path to ~/.config/kte/imgui.ini
-	if (const char *home = std::getenv("HOME")) {
-		namespace fs = std::filesystem;
-		fs::path config_dir = fs::path(home) / ".config" / "kte";
-
-		std::error_code ec;
-		if (!fs::exists(config_dir)) {
-			fs::create_directories(config_dir, ec);
-		}
-
-		if (fs::exists(config_dir)) {
-			static std::string ini_path = (config_dir / "imgui.ini").string();
-			io.IniFilename              = ini_path.c_str();
-		}
-	}
-
-	io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
-	io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
 	ImGui::StyleColorsDark();
 
 	// Apply background mode and selected theme (default: Nord). Can be changed at runtime via commands.
@@ -202,19 +173,8 @@ GUIFrontend::Init(int &argc, char **argv, Editor &ed)
 	}
 #endif
 
-	// Install embedded fonts into registry and load configured font
+	// Initialize GUI font from embedded default (use configured size or compiled default)
-	kte::Fonts::InstallDefaultFonts();
+	LoadGuiFont_(nullptr, (float) cfg.font_size);
-	// Initialize font atlas using configured font name and size; fallback to embedded default helper
-	if (!kte::Fonts::FontRegistry::Instance().LoadFont(cfg.font, (float) cfg.font_size)) {
-		LoadGuiFont_(nullptr, (float) cfg.font_size);
-		// Record defaults in registry so subsequent size changes have a base
-		kte::Fonts::FontRegistry::Instance().RequestLoadFont("default", (float) cfg.font_size);
-		std::string n;
-		float s = 0.0f;
-		if (kte::Fonts::FontRegistry::Instance().ConsumePendingFontRequest(n, s)) {
-			kte::Fonts::FontRegistry::Instance().LoadFont(n, s);
-		}
-	}
 
 	return true;
 }
@@ -243,65 +203,7 @@ GUIFrontend::Step(Editor &ed, bool &running)
 		input_.ProcessSDLEvent(e);
 	}
 
-	// Apply pending font change before starting a new frame
+	// Execute pending mapped inputs (drain queue)
-	{
-		std::string fname;
-		float fsize = 0.0f;
-		if (kte::Fonts::FontRegistry::Instance().ConsumePendingFontRequest(fname, fsize)) {
-			if (!fname.empty() && fsize > 0.0f) {
-				kte::Fonts::FontRegistry::Instance().LoadFont(fname, fsize);
-				// Recreate backend font texture
-				ImGui_ImplOpenGL3_DestroyFontsTexture();
-				ImGui_ImplOpenGL3_CreateFontsTexture();
-			}
-		}
-	}
-
-	// Start a new ImGui frame BEFORE processing commands so dimensions are correct
-	ImGui_ImplOpenGL3_NewFrame();
-	ImGui_ImplSDL2_NewFrame(window_);
-	ImGui::NewFrame();
-
-	// Update editor logical rows/cols using current ImGui metrics and display size
-	{
-		ImGuiIO &io = ImGui::GetIO();
-		float row_h = ImGui::GetTextLineHeightWithSpacing();
-		float ch_w  = ImGui::CalcTextSize("M").x;
-		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
-		float disp_w = io.DisplaySize.x > 0 ? io.DisplaySize.x : static_cast<float>(width_);
-		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.
-		const float pad_x = 6.0f;
-		const float pad_y = 6.0f;
-
-		// 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::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 = 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
-		if (rows != ed.Rows() || cols != ed.Cols()) {
-			ed.SetDimensions(rows, cols);
-		}
-	}
-
-	// Allow deferred opens (including swap recovery prompts) to run.
-	ed.ProcessPendingOpens();
-
-	// Execute pending mapped inputs (drain queue) AFTER dimensions are updated
 	for (;;) {
 		MappedInput mi;
 		if (!input_.Poll(mi))
@@ -322,6 +224,46 @@ GUIFrontend::Step(Editor &ed, bool &running)
 		running = false;
 	}
 
+	// Start a new ImGui frame
+	ImGui_ImplOpenGL3_NewFrame();
+	ImGui_ImplSDL2_NewFrame(window_);
+	ImGui::NewFrame();
+
+	// Update editor logical rows/cols using current ImGui metrics and display size
+	{
+		ImGuiIO &io  = ImGui::GetIO();
+		float line_h = ImGui::GetTextLineHeightWithSpacing();
+		float ch_w   = ImGui::CalcTextSize("M").x;
+		if (line_h <= 0.0f)
+			line_h = 16.0f;
+		if (ch_w <= 0.0f)
+			ch_w = 8.0f;
+		// Prefer ImGui IO display size; fall back to cached SDL window size
+		float disp_w = io.DisplaySize.x > 0 ? io.DisplaySize.x : static_cast<float>(width_);
+		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 GUIRenderer
+		const ImGuiStyle &style = ImGui::GetStyle();
+		float pad_x             = style.WindowPadding.x;
+		float pad_y             = style.WindowPadding.y;
+		// 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);
+
+		// Visible content rows inside the scroll child
+		auto content_rows = static_cast<std::size_t>(std::floor(avail_h / line_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 cols = static_cast<std::size_t>(std::max(1.0f, std::floor(avail_w / ch_w)));
+
+		// Only update if changed to avoid churn
+		if (rows != ed.Rows() || cols != ed.Cols()) {
+			ed.SetDimensions(rows, cols);
+		}
+	}
+
 	// No runtime font UI; always use embedded font.
 
 	// Draw editor UI
@@ -359,36 +301,21 @@ GUIFrontend::Shutdown()
 
 
 bool
-GUIFrontend::LoadGuiFont_(const char * /*path*/, const float size_px)
+GUIFrontend::LoadGuiFont_(const char * /*path*/, float size_px)
 {
 	const ImGuiIO &io = ImGui::GetIO();
 	io.Fonts->Clear();
-
+	const ImFont *font = io.Fonts->AddFontFromMemoryCompressedTTF(
-	ImFontConfig config;
+		DefaultFontBoldCompressedData,
-	config.MergeMode = false;
+		DefaultFontBoldCompressedSize,
-
+		size_px);
-	// Load Basic Latin + Latin Supplement
+	if (!font) {
-	io.Fonts->AddFontFromMemoryCompressedTTF(
+		font = io.Fonts->AddFontDefault();
-		kte::Fonts::DefaultFontData,
+	}
-		kte::Fonts::DefaultFontSize,
+	(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;
 }
+
+
+// No runtime font reload or system font resolution in this simplified build.

GUIFrontend.h

@@ -1,11 +1,12 @@
 /*
- * GUIFrontend - couples ImGuiInputHandler + GUIRenderer and owns SDL2/ImGui lifecycle
+ * GUIFrontend - couples GUIInputHandler + GUIRenderer and owns SDL2/ImGui lifecycle
  */
-#pragma once
+#ifndef KTE_GUI_FRONTEND_H
+#define KTE_GUI_FRONTEND_H
+
 #include "Frontend.h"
-#include "GUIConfig.h"
+#include "GUIInputHandler.h"
-#include "ImGuiInputHandler.h"
+#include "GUIRenderer.h"
-#include "ImGuiRenderer.h"
 
 
 struct SDL_Window;
@@ -17,7 +18,7 @@ public:
 
 	~GUIFrontend() override = default;
 
-	bool Init(int &argc, char **argv, Editor &ed) override;
+	bool Init(Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 
@@ -26,11 +27,12 @@ public:
 private:
 	static bool LoadGuiFont_(const char *path, float size_px);
 
-	GUIConfig config_{};
+	GUIInputHandler input_{};
-	ImGuiInputHandler input_{};
+	GUIRenderer renderer_{};
-	ImGuiRenderer renderer_{};
 	SDL_Window *window_   = nullptr;
 	SDL_GLContext gl_ctx_ = nullptr;
 	int width_            = 1280;
 	int height_           = 800;
 };
+
+#endif // KTE_GUI_FRONTEND_H

GUIInputHandler.cc

@@ -5,9 +5,8 @@
 #include <SDL.h>
 #include <imgui.h>
 
-#include "ImGuiInputHandler.h"
+#include "GUIInputHandler.h"
 #include "KKeymap.h"
-#include "Editor.h"
 
 
 static bool
@@ -15,17 +14,20 @@ map_key(const SDL_Keycode key,
         const SDL_Keymod mod,
         bool &k_prefix,
         bool &esc_meta,
-        bool &k_ctrl_pending,
+        // universal-argument state (by ref)
-        Editor *ed,
+        bool &uarg_active,
-        MappedInput &out,
+        bool &uarg_collecting,
-        bool &suppress_textinput_once)
+        bool &uarg_negative,
+        bool &uarg_had_digits,
+        int &uarg_value,
+        std::string &uarg_text,
+        MappedInput &out)
 {
 	// Ctrl handling
 	const bool is_ctrl = (mod & KMOD_CTRL) != 0;
 	const bool is_alt  = (mod & (KMOD_ALT | KMOD_LALT | KMOD_RALT)) != 0;
 
-	// If previous key was ESC, interpret this as Meta via ESC keymap.
+	// If previous key was ESC, interpret this as Meta via ESC keymap
-	// Prefer KEYDOWN when we can derive a printable ASCII; otherwise defer to TEXTINPUT.
 	if (esc_meta) {
 		int ascii_key = 0;
 		if (key == SDLK_BACKSPACE) {
@@ -43,74 +45,52 @@ map_key(const SDL_Keycode key,
 			ascii_key = '>';
 		}
 		if (ascii_key != 0) {
-			esc_meta  = false; // consume if we can decide on KEYDOWN
 			ascii_key = KLowerAscii(ascii_key);
 			CommandId id;
 			if (KLookupEscCommand(ascii_key, id)) {
-				out = {true, id, "", 0};
+				// Only consume the ESC-meta prefix if we actually mapped a command
+				esc_meta = false;
+				out      = {true, id, "", 0};
 				return true;
 			}
-			// Known printable but unmapped ESC sequence: report invalid
-			out = {true, CommandId::UnknownEscCommand, "", 0};
-			return true;
 		}
-		// No usable ASCII from KEYDOWN → keep esc_meta set and let TEXTINPUT handle it
+		// Unhandled meta chord at KEYDOWN: do not clear esc_meta here.
+		// Leave it set so SDL_TEXTINPUT fallback can translate and suppress insertion.
 		out.hasCommand = false;
 		return true;
 	}
 
 	// Movement and basic keys
-	// These keys exit k-prefix mode if active (user pressed C-k then a special key).
 	switch (key) {
 	case SDLK_LEFT:
-		k_prefix = false;
+		out = {true, CommandId::MoveLeft, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveLeft, "", 0};
 		return true;
 	case SDLK_RIGHT:
-		k_prefix = false;
+		out = {true, CommandId::MoveRight, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveRight, "", 0};
 		return true;
 	case SDLK_UP:
-		k_prefix = false;
+		out = {true, CommandId::MoveUp, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveUp, "", 0};
 		return true;
 	case SDLK_DOWN:
-		k_prefix = false;
+		out = {true, CommandId::MoveDown, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveDown, "", 0};
 		return true;
 	case SDLK_HOME:
-		k_prefix = false;
+		out = {true, CommandId::MoveHome, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveHome, "", 0};
 		return true;
 	case SDLK_END:
-		k_prefix = false;
+		out = {true, CommandId::MoveEnd, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveEnd, "", 0};
 		return true;
 	case SDLK_PAGEUP:
-		k_prefix = false;
+		out = {true, CommandId::PageUp, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::PageUp, "", 0};
 		return true;
 	case SDLK_PAGEDOWN:
-		k_prefix = false;
+		out = {true, CommandId::PageDown, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::PageDown, "", 0};
 		return true;
 	case SDLK_DELETE:
-		k_prefix = false;
+		out = {true, CommandId::DeleteChar, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::DeleteChar, "", 0};
 		return true;
 	case SDLK_BACKSPACE:
-		k_prefix = false;
+		out = {true, CommandId::Backspace, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::Backspace, "", 0};
 		return true;
 	case SDLK_TAB:
 		// Insert a literal tab character when not interpreting a k-prefix suffix.
@@ -123,13 +103,10 @@ map_key(const SDL_Keycode key,
 		break; // fall through so k-prefix handler can process
 	case SDLK_RETURN:
 	case SDLK_KP_ENTER:
-		k_prefix = false;
+		out = {true, CommandId::Newline, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::Newline, "", 0};
 		return true;
 	case SDLK_ESCAPE:
 		k_prefix = false;
-		k_ctrl_pending = false;
 		esc_meta       = true; // next key will be treated as Meta
 		out.hasCommand = false; // no immediate command for bare ESC in GUI
 		return true;
@@ -139,6 +116,7 @@ map_key(const SDL_Keycode key,
 
 	// If we are in k-prefix, interpret the very next key via the C-k keymap immediately.
 	if (k_prefix) {
+		k_prefix = false;
 		esc_meta = false;
 		// Normalize to ASCII; preserve case for letters using Shift
 		int ascii_key = 0;
@@ -158,24 +136,10 @@ map_key(const SDL_Keycode key,
 			ascii_key = static_cast<int>(key);
 		}
 		bool ctrl2 = (mod & KMOD_CTRL) != 0;
-		// If user typed a literal 'C' (uppercase) or '^' as a control qualifier, keep k-prefix active
-		// Do NOT treat lowercase 'c' as a qualifier; 'c' is a valid k-command (BufferClose).
-		if (ascii_key == 'C' || ascii_key == '^') {
-			k_ctrl_pending = true;
-			// Keep waiting for the next suffix; show status and suppress ensuing TEXTINPUT
-			if (ed)
-				ed->SetStatus("C-k C _");
-			suppress_textinput_once = true;
-			out.hasCommand          = false;
-			return true;
-		}
-		// Otherwise, consume the k-prefix now for the actual suffix
-		k_prefix = false;
 		if (ascii_key != 0) {
 			int lower                  = KLowerAscii(ascii_key);
 			bool ctrl_suffix_supported = (lower == 'd' || lower == 'x' || lower == 'q');
-			bool pass_ctrl             = (ctrl2 || k_ctrl_pending) && ctrl_suffix_supported;
+			bool pass_ctrl             = ctrl2 && ctrl_suffix_supported;
-			k_ctrl_pending             = false;
 			CommandId id;
 			bool mapped = KLookupKCommand(ascii_key, pass_ctrl, id);
 			// Diagnostics for u/U
@@ -192,40 +156,54 @@ map_key(const SDL_Keycode key,
 			}
 			if (mapped) {
 				out = {true, id, "", 0};
-				if (ed)
-					ed->SetStatus(""); // clear "C-k _" hint after suffix
 				return true;
 			}
 			int shown = KLowerAscii(ascii_key);
 			char c    = (shown >= 0x20 && shown <= 0x7e) ? static_cast<char>(shown) : '?';
 			std::string arg(1, c);
 			out = {true, CommandId::UnknownKCommand, arg, 0};
-			if (ed)
-				ed->SetStatus(""); // clear hint; handler will set unknown status
 			return true;
 		}
-		// Non-printable/unmappable key as k-suffix (e.g., F-keys): report unknown and exit k-mode
+		out.hasCommand = false;
-		out = {true, CommandId::UnknownKCommand, std::string("?"), 0};
-		if (ed)
-			ed->SetStatus("");
 		return true;
 	}
 
 	if (is_ctrl) {
 		// Universal argument: C-u
 		if (key == SDLK_u) {
-			if (ed)
+			if (!uarg_active) {
-				ed->UArgStart();
+				uarg_active     = true;
+				uarg_collecting = true;
+				uarg_negative   = false;
+				uarg_had_digits = false;
+				uarg_value      = 4; // default
+				uarg_text.clear();
+				out = {true, CommandId::UArgStatus, uarg_text, 0};
+				return true;
+			} else if (uarg_collecting && !uarg_had_digits && !uarg_negative) {
+				if (uarg_value <= 0)
+					uarg_value = 4;
+				else
+					uarg_value *= 4; // repeated C-u multiplies by 4
+				out = {true, CommandId::UArgStatus, uarg_text, 0};
+				return true;
+			} else {
+				// End collection if already started with digits or '-'
+				uarg_collecting = false;
+				if (!uarg_had_digits && !uarg_negative && uarg_value <= 0)
+					uarg_value = 4;
+			}
 			out.hasCommand = false;
 			return true;
 		}
 		// Cancel universal arg on C-g as well (it maps to Refresh via ctrl map)
 		if (key == SDLK_g) {
-			if (ed)
+			uarg_active     = false;
-				ed->UArgClear();
+			uarg_collecting = false;
-			// Also cancel any pending k-prefix qualifier
+			uarg_negative   = false;
-			k_ctrl_pending = false;
+			uarg_had_digits = false;
-			k_prefix       = false; // treat as cancel of prefix
+			uarg_value      = 0;
+			uarg_text.clear();
 		}
 		if (key == SDLK_k || key == SDLK_KP_EQUALS) {
 			k_prefix = true;
@@ -269,17 +247,29 @@ map_key(const SDL_Keycode key,
 		}
 	}
 
-	// If collecting universal argument, allow digits on KEYDOWN path too
+	// If collecting universal argument, allow digits/minus on KEYDOWN path too
-	if (ed && ed->UArg() != 0) {
+	if (uarg_active && uarg_collecting) {
 		if ((key >= SDLK_0 && key <= SDLK_9) && !(mod & KMOD_SHIFT)) {
 			int d = static_cast<int>(key - SDLK_0);
-			ed->UArgDigit(d);
+			if (!uarg_had_digits) {
-			out.hasCommand = false;
+				uarg_value      = 0;
-			// We consumed a digit on KEYDOWN; SDL will often also emit TEXTINPUT for it.
+				uarg_had_digits = true;
-			// Request suppression of the very next TEXTINPUT to avoid double-counting.
+			}
-			suppress_textinput_once = true;
+			if (uarg_value < 100000000) {
+				uarg_value = uarg_value * 10 + d;
+			}
+			uarg_text.push_back(static_cast<char>('0' + d));
+			out = {true, CommandId::UArgStatus, uarg_text, 0};
 			return true;
 		}
+		if (key == SDLK_MINUS && !uarg_had_digits && !uarg_negative) {
+			uarg_negative = true;
+			uarg_text     = "-";
+			out           = {true, CommandId::UArgStatus, uarg_text, 0};
+			return true;
+		}
+		// Any other key will end collection; process it normally
+		uarg_collecting = false;
 	}
 
 	// k_prefix handled earlier
@@ -289,40 +279,34 @@ map_key(const SDL_Keycode key,
 
 
 bool
-ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
+GUIInputHandler::ProcessSDLEvent(const SDL_Event &e)
 {
 	MappedInput mi;
 	bool produced = false;
 	switch (e.type) {
 	case SDL_MOUSEWHEEL: {
-		// High-resolution trackpads can deliver fractional wheel deltas. Accumulate
+		// If ImGui wants to capture the mouse (e.g., hovering the File Picker list),
-		// precise values and emit one scroll step per whole unit.
+		// don't translate wheel events into editor scrolling.
-		float dy = 0.0f;
+		// This prevents background buffer scroll while using GUI widgets.
-#if SDL_VERSION_ATLEAST(2, 0, 18)
+		ImGuiIO &io = ImGui::GetIO();
-		dy = e.wheel.preciseY;
+		if (io.WantCaptureMouse) {
-#else
+			return true; // consumed by GUI
-		dy = static_cast<float>(e.wheel.y);
+		}
-#endif
+
+		// Map vertical wheel to line-wise cursor movement (MoveUp/MoveDown)
+		int dy = e.wheel.y;
 #ifdef SDL_MOUSEWHEEL_FLIPPED
 		if (e.wheel.direction == SDL_MOUSEWHEEL_FLIPPED)
 			dy = -dy;
 #endif
-		if (dy != 0.0f) {
+		if (dy != 0) {
-			wheel_accum_y_  += dy;
+			int repeat   = dy > 0 ? dy : -dy;
-			float abs_accum = wheel_accum_y_ >= 0.0f ? wheel_accum_y_ : -wheel_accum_y_;
+			CommandId id = dy > 0 ? CommandId::MoveUp : CommandId::MoveDown;
-			int steps       = static_cast<int>(abs_accum);
+			std::lock_guard<std::mutex> lk(mu_);
-			if (steps > 0) {
+			for (int i = 0; i < repeat; ++i) {
-				CommandId id = (wheel_accum_y_ > 0.0f) ? CommandId::ScrollUp : CommandId::ScrollDown;
+				q_.push(MappedInput{true, id, std::string(), 0});
-				std::lock_guard<std::mutex> lk(mu_);
-				for (int i = 0; i < steps; ++i) {
-					q_.push(MappedInput{true, id, std::string(), 0});
-				}
-				// remove the whole steps, keep fractional remainder
-				wheel_accum_y_ += (wheel_accum_y_ > 0.0f)
-					                  ? -static_cast<float>(steps)
-					                  : static_cast<float>(steps);
-				return true; // consumed
 			}
+			return true; // consumed
 		}
 		return false;
 	}
@@ -353,9 +337,7 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 						segment = std::string_view(text).substr(start);
 					}
 					if (!segment.empty()) {
-						MappedInput ins{
+						MappedInput ins{true, CommandId::InsertText, std::string(segment), 0};
-							true, CommandId::InsertText, std::string(segment), 0
-						};
 						q_.push(ins);
 					}
 					if (has_nl) {
@@ -372,27 +354,28 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 			}
 		}
 
-		{
+		produced = map_key(key, mods,
-			bool suppress_req = false;
+		                   k_prefix_, esc_meta_,
-			produced          = map_key(key, mods,
+		                   uarg_active_, uarg_collecting_, uarg_negative_, uarg_had_digits_, uarg_value_,
-			                   k_prefix_, esc_meta_,
+		                   uarg_text_,
-			                   k_ctrl_pending_,
+		                   mi);
-			                   ed_,
-			                   mi,
-			                   suppress_req);
-			if (suppress_req) {
-				// Prevent the corresponding TEXTINPUT from delivering the same digit again
-				suppress_text_input_once_ = true;
-			}
-		}
 
-		// Note: Do NOT suppress SDL_TEXTINPUT after inserting a TAB. Most platforms
+		// If we inserted a TAB on KEYDOWN, suppress any subsequent SDL_TEXTINPUT
-		// do not emit TEXTINPUT for Tab, and suppressing here would incorrectly
+		// for this keystroke to avoid double insertion on platforms that emit it.
-		// eat the next character typed if no TEXTINPUT follows the Tab press.
+		if (produced && mi.hasCommand && mi.id == CommandId::InsertText && mi.arg == "\t") {
+			suppress_text_input_once_ = true;
+		}
 
 		// If we just consumed a universal-argument digit or '-' on KEYDOWN and emitted UArgStatus,
 		// suppress the subsequent SDL_TEXTINPUT for this keystroke to avoid duplicating the digit in status.
-		// Additional suppression handled above when KEYDOWN consumed a uarg digit
+		if (produced && mi.hasCommand && mi.id == CommandId::UArgStatus) {
+			// Digits without shift, or a plain '-'
+			const bool is_digit_key = (key >= SDLK_0 && key <= SDLK_9) && !(mods & KMOD_SHIFT);
+			const bool is_minus_key = (key == SDLK_MINUS);
+			if (uarg_active_ && uarg_collecting_ && (is_digit_key || is_minus_key)) {
+				suppress_text_input_once_ = true;
+			}
+		}
 
 		// Suppress the immediate following SDL_TEXTINPUT when a printable KEYDOWN was used as a
 		// k-prefix suffix or Meta (Alt/ESC) chord, regardless of whether a command was produced.
@@ -413,8 +396,7 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 			}
 			// Alt/Meta + letter can also generate TEXTINPUT on some platforms
 			const bool is_meta_symbol = (
-				key == SDLK_COMMA || key == SDLK_PERIOD || key == SDLK_LESS || key ==
+				key == SDLK_COMMA || key == SDLK_PERIOD || key == SDLK_LESS || key == SDLK_GREATER);
-				SDLK_GREATER);
 			if (is_alt && ((key >= SDLK_a && key <= SDLK_z) || is_meta_symbol)) {
 				should_suppress = true;
 			}
@@ -438,24 +420,35 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 			break;
 		}
 
-		// If editor universal argument is active, consume digit TEXTINPUT
+		// If universal argument collection is active, consume digit/minus TEXTINPUT
-		if (ed_ && ed_
+		if (uarg_active_ && uarg_collecting_) {
-
-
-		    ->
-		    UArg() != 0
-		) {
 			const char *txt = e.text.text;
 			if (txt && *txt) {
 				unsigned char c0 = static_cast<unsigned char>(txt[0]);
 				if (c0 >= '0' && c0 <= '9') {
 					int d = c0 - '0';
-					ed_->UArgDigit(d);
+					if (!uarg_had_digits_) {
-					produced = true; // consumed to update status
+						uarg_value_      = 0;
+						uarg_had_digits_ = true;
+					}
+					if (uarg_value_ < 100000000) {
+						uarg_value_ = uarg_value_ * 10 + d;
+					}
+					uarg_text_.push_back(static_cast<char>(c0));
+					mi       = {true, CommandId::UArgStatus, uarg_text_, 0};
+					produced = true; // consumed and enqueued status update
+					break;
+				}
+				if (c0 == '-' && !uarg_had_digits_ && !uarg_negative_) {
+					uarg_negative_ = true;
+					uarg_text_     = "-";
+					mi             = {true, CommandId::UArgStatus, uarg_text_, 0};
+					produced       = true;
 					break;
 				}
 			}
-			// Non-digit ends collection; allow processing normally below
+			// End collection and allow this TEXTINPUT to be processed normally below
+			uarg_collecting_ = false;
 		}
 
 		// If we are still in k-prefix and KEYDOWN path didn't handle the suffix,
@@ -471,21 +464,9 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 					ascii_key = static_cast<int>(c0);
 				}
 				if (ascii_key != 0) {
-					// Qualifier via TEXTINPUT: uppercase 'C' or '^' only
-					if (ascii_key == 'C' || ascii_key == '^') {
-						k_ctrl_pending_ = true;
-						if (ed_)
-							ed_->SetStatus("C-k C _");
-						// Keep k-prefix active; do not emit a command
-						k_prefix_ = true;
-						produced  = true;
-						break;
-					}
 					// Map via k-prefix table; do not pass Ctrl for TEXTINPUT case
 					CommandId id;
-					bool pass_ctrl  = k_ctrl_pending_;
+					bool mapped = KLookupKCommand(ascii_key, false, id);
-					k_ctrl_pending_ = false;
-					bool mapped     = KLookupKCommand(ascii_key, pass_ctrl, id);
 					// Diagnostics: log any k-prefix TEXTINPUT suffix mapping
 					char disp = (ascii_key >= 0x20 && ascii_key <= 0x7e)
 						            ? static_cast<char>(ascii_key)
@@ -496,9 +477,7 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 					             mapped ? static_cast<int>(id) : -1);
 					std::fflush(stderr);
 					if (mapped) {
-						mi = {true, id, "", 0};
+						mi       = {true, id, "", 0};
-						if (ed_)
-							ed_->SetStatus(""); // clear "C-k _" hint after suffix
 						produced = true;
 						break; // handled; do not insert text
 					} else {
@@ -508,18 +487,13 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 							         ? static_cast<char>(shown)
 							         : '?';
 						std::string arg(1, c);
-						mi = {true, CommandId::UnknownKCommand, arg, 0};
+						mi       = {true, CommandId::UnknownKCommand, arg, 0};
-						if (ed_)
-							ed_->SetStatus("");
 						produced = true;
 						break;
 					}
 				}
 			}
-			// If no usable ASCII was found, still report an unknown k-command and exit k-mode
+			// Consume even if no usable ascii was found
-			mi = {true, CommandId::UnknownKCommand, std::string("?"), 0};
-			if (ed_)
-				ed_->SetStatus("");
 			produced = true;
 			break;
 		}
@@ -559,8 +533,7 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 					}
 				}
 			}
-			// If we get here, unmapped ESC sequence via TEXTINPUT: report invalid
+			// If we get here, swallow the TEXTINPUT (do not insert stray char)
-			mi       = {true, CommandId::UnknownEscCommand, "", 0};
 			produced = true;
 			break;
 		}
@@ -590,6 +563,24 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 	}
 
 	if (produced && mi.hasCommand) {
+		// Attach universal-argument count if present, then clear the state
+		if (uarg_active_ && mi.id != CommandId::UArgStatus) {
+			int count = 0;
+			if (!uarg_had_digits_ && !uarg_negative_) {
+				count = (uarg_value_ > 0) ? uarg_value_ : 4;
+			} else {
+				count = uarg_value_;
+				if (uarg_negative_)
+					count = -count;
+			}
+			mi.count         = count;
+			uarg_active_     = false;
+			uarg_collecting_ = false;
+			uarg_negative_   = false;
+			uarg_had_digits_ = false;
+			uarg_value_      = 0;
+			uarg_text_.clear();
+		}
 		std::lock_guard<std::mutex> lk(mu_);
 		q_.push(mi);
 	}
@@ -598,7 +589,7 @@ ImGuiInputHandler::ProcessSDLEvent(const SDL_Event &e)
 
 
 bool
-ImGuiInputHandler::Poll(MappedInput &out)
+GUIInputHandler::Poll(MappedInput &out)
 {
 	std::lock_guard<std::mutex> lk(mu_);
 	if (q_.empty())

GUIInputHandler.h

@@ -1,7 +1,9 @@
 /*
- * ImGuiInputHandler - ImGui/SDL2-based input mapping for GUI mode
+ * GUIInputHandler - ImGui/SDL2-based input mapping for GUI mode
  */
-#pragma once
+#ifndef KTE_GUI_INPUT_HANDLER_H
+#define KTE_GUI_INPUT_HANDLER_H
+
 #include <mutex>
 #include <queue>
 
@@ -10,18 +12,11 @@
 
 union SDL_Event; // fwd decl to avoid including SDL here (SDL defines SDL_Event as a union)
 
-class ImGuiInputHandler final : public InputHandler {
+class GUIInputHandler final : public InputHandler {
 public:
-	ImGuiInputHandler() = default;
+	GUIInputHandler() = default;
-
-	~ImGuiInputHandler() override = default;
-
-
-	void Attach(Editor *ed) override
-	{
-		ed_ = ed;
-	}
 
+	~GUIInputHandler() override = default;
 
 	// Translate an SDL event to editor command and enqueue if applicable.
 	// Returns true if it produced a mapped command or consumed input.
@@ -32,18 +27,20 @@ public:
 private:
 	std::mutex mu_;
 	std::queue<MappedInput> q_;
-	bool k_prefix_       = false;
+	bool k_prefix_ = false;
-	bool k_ctrl_pending_ = false; // if true, next k-suffix is treated as Ctrl- (qualifier via literal 'C' or '^')
 	// Treat ESC as a Meta prefix: next key is looked up via ESC keymap
 	bool esc_meta_ = false;
 	// When a printable keydown generated a non-text command, suppress the very next SDL_TEXTINPUT
 	// event produced by SDL for the same keystroke to avoid inserting stray characters.
 	bool suppress_text_input_once_ = false;
 
-	Editor *ed_ = nullptr; // attached editor for editor-owned uarg handling
+	// Universal argument (C-u) state for GUI
-
+	bool uarg_active_     = false; // an argument is pending for the next command
-	// Accumulators for high-resolution (trackpad) scrolling. We emit one scroll
+	bool uarg_collecting_ = false; // collecting digits / '-' right now
-	// command per whole step and keep the fractional remainder.
+	bool uarg_negative_   = false; // whether a leading '-' was supplied
-	float wheel_accum_y_ = 0.0f;
+	bool uarg_had_digits_ = false; // whether any digits were supplied
-	float wheel_accum_x_ = 0.0f; // reserved for future horizontal scrolling
+	int uarg_value_       = 0; // current absolute value (>=0)
+	std::string uarg_text_; // raw digits/minus typed for status display
 };
+
+#endif // KTE_GUI_INPUT_HANDLER_H

GUIRenderer.cc

@@ -9,7 +9,7 @@
 #include <imgui.h>
 #include <regex>
 
-#include "ImGuiRenderer.h"
+#include "GUIRenderer.h"
 #include "Highlight.h"
 #include "GUITheme.h"
 #include "Buffer.h"
@@ -30,7 +30,7 @@
 
 
 void
-ImGuiRenderer::Draw(Editor &ed)
+GUIRenderer::Draw(Editor &ed)
 {
 	// Make the editor window occupy the entire GUI container/viewport
 	ImGuiViewport *vp = ImGui::GetMainViewport();
@@ -47,7 +47,6 @@ ImGuiRenderer::Draw(Editor &ed)
 
 	ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar
 	                         | ImGuiWindowFlags_NoScrollbar
-	                         | ImGuiWindowFlags_NoScrollWithMouse
 	                         | ImGuiWindowFlags_NoResize
 	                         | ImGuiWindowFlags_NoMove
 	                         | ImGuiWindowFlags_NoCollapse
@@ -60,182 +59,208 @@ ImGuiRenderer::Draw(Editor &ed)
 	ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
 	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(6.f, 6.f));
 
-	ImGui::Begin("kte", nullptr, flags);
+	ImGui::Begin("kte", nullptr, flags | ImGuiWindowFlags_NoScrollWithMouse);
 
 	const Buffer *buf = ed.CurrentBuffer();
 	if (!buf) {
 		ImGui::TextUnformatted("[no buffer]");
 	} else {
-		const auto &lines   = buf->Rows();
+		const auto &lines = buf->Rows();
+		// Reserve space for status bar at bottom
+		ImGui::BeginChild("scroll", ImVec2(0, -ImGui::GetFrameHeightWithSpacing()), false,
+		                  ImGuiWindowFlags_HorizontalScrollbar);
+		// Detect click-to-move inside this scroll region
+		ImVec2 list_origin  = ImGui::GetCursorScreenPos();
+		float scroll_y      = ImGui::GetScrollY();
+		float scroll_x      = ImGui::GetScrollX();
+		std::size_t rowoffs = 0; // we render from the first line; scrolling is handled by ImGui
 		std::size_t cy      = buf->Cury();
 		std::size_t cx      = buf->Curx();
 		const float line_h  = ImGui::GetTextLineHeight();
 		const float row_h   = ImGui::GetTextLineHeightWithSpacing();
 		const float space_w = ImGui::CalcTextSize(" ").x;
-
 		// Two-way sync between Buffer::Rowoffs and ImGui scroll position:
 		// - If command layer changed Buffer::Rowoffs since last frame, drive ImGui scroll from it.
 		// - Otherwise, propagate ImGui scroll to Buffer::Rowoffs so command layer has an up-to-date view.
-		static long prev_buf_rowoffs = -1; // previous frame's Buffer::Rowoffs
+		// This prevents clicks/wheel from being immediately overridden by stale offsets.
-		static long prev_buf_coloffs = -1; // previous frame's Buffer::Coloffs
-
-		const long buf_rowoffs = static_cast<long>(buf->Rowoffs());
-		const long buf_coloffs = static_cast<long>(buf->Coloffs());
-
-		// Detect programmatic change (e.g., page_down command changed rowoffs)
-		// Use SetNextWindowScroll BEFORE BeginChild to set initial scroll position
-		if (prev_buf_rowoffs >= 0 && buf_rowoffs != prev_buf_rowoffs) {
-			float target_y = static_cast<float>(buf_rowoffs) * row_h;
-			ImGui::SetNextWindowScroll(ImVec2(-1.0f, target_y));
-		}
-		if (prev_buf_coloffs >= 0 && buf_coloffs != prev_buf_coloffs) {
-			float target_x = static_cast<float>(buf_coloffs) * space_w;
-			float target_y = static_cast<float>(buf_rowoffs) * row_h;
-			ImGui::SetNextWindowScroll(ImVec2(target_x, target_y));
-		}
-
-		// 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
-		ImVec2 child_window_pos = ImGui::GetWindowPos();
-		float scroll_y          = ImGui::GetScrollY();
-		float scroll_x          = ImGui::GetScrollX();
-		std::size_t rowoffs     = 0; // we render from the first line; scrolling is handled by ImGui
-
-		// Synchronize buffer offsets from ImGui scroll if user scrolled manually
 		bool forced_scroll = false;
 		{
-			static float prev_scroll_y = -1.0f; // previous frame's ImGui scroll Y in pixels
+			static long prev_buf_rowoffs = -1; // previous frame's Buffer::Rowoffs
-			static float prev_scroll_x = -1.0f; // previous frame's ImGui scroll X in pixels
+			static long prev_buf_coloffs = -1; // previous frame's Buffer::Coloffs
+			static float prev_scroll_y   = -1.0f; // previous frame's ImGui scroll Y in pixels
+			static float prev_scroll_x   = -1.0f; // previous frame's ImGui scroll X in pixels
 
+			const long buf_rowoffs = static_cast<long>(buf->Rowoffs());
+			const long buf_coloffs = static_cast<long>(buf->Coloffs());
 			const long scroll_top  = static_cast<long>(scroll_y / row_h);
 			const long scroll_left = static_cast<long>(scroll_x / space_w);
 
-			// Check if rowoffs was programmatically changed this frame
+			// Detect programmatic change (e.g., keyboard navigation ensured visibility)
 			if (prev_buf_rowoffs >= 0 && buf_rowoffs != prev_buf_rowoffs) {
+				ImGui::SetScrollY(static_cast<float>(buf_rowoffs) * row_h);
+				scroll_y      = ImGui::GetScrollY();
 				forced_scroll = true;
 			}
-
+			if (prev_buf_coloffs >= 0 && buf_coloffs != prev_buf_coloffs) {
-			// If user scrolled (not programmatic), update buffer offsets accordingly
+				ImGui::SetScrollX(static_cast<float>(buf_coloffs) * space_w);
-			if (prev_scroll_y >= 0.0f && scroll_y != prev_scroll_y && !forced_scroll) {
+				scroll_x      = ImGui::GetScrollX();
-				if (Buffer *mbuf = const_cast<Buffer *>(buf)) {
+				forced_scroll = true;
+			}
+			// If user scrolled, update buffer offsets accordingly
+			if (prev_scroll_y >= 0.0f && scroll_y != prev_scroll_y) {
+				if (auto mbuf = const_cast<Buffer *>(buf)) {
 					mbuf->SetOffsets(static_cast<std::size_t>(std::max(0L, scroll_top)),
 					                 mbuf->Coloffs());
 				}
 			}
-			if (prev_scroll_x >= 0.0f && scroll_x != prev_scroll_x && !forced_scroll) {
+			if (prev_scroll_x >= 0.0f && scroll_x != prev_scroll_x) {
-				if (Buffer *mbuf = const_cast<Buffer *>(buf)) {
+				if (auto mbuf = const_cast<Buffer *>(buf)) {
 					mbuf->SetOffsets(mbuf->Rowoffs(),
 					                 static_cast<std::size_t>(std::max(0L, scroll_left)));
 				}
 			}
 
 			// Update trackers for next frame
-			prev_scroll_y = scroll_y;
+			prev_buf_rowoffs = static_cast<long>(buf->Rowoffs());
-			prev_scroll_x = scroll_x;
+			prev_buf_coloffs = static_cast<long>(buf->Coloffs());
+			prev_scroll_y    = ImGui::GetScrollY();
+			prev_scroll_x    = ImGui::GetScrollX();
 		}
-		prev_buf_rowoffs = buf_rowoffs;
+		// Synchronize cursor and scrolling.
-		prev_buf_coloffs = buf_coloffs;
+		// Ensure the cursor is visible even on the first frame or when it didn't move,
-		// Cache current horizontal offset in rendered columns for click handling
+		// unless we already forced scrolling from Buffer::Rowoffs this frame.
-		const std::size_t coloffs_now = buf->Coloffs();
+		{
+			// 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;
 
-		// Mark selection state (mark -> cursor), in source coordinates
+			if (!forced_scroll) {
-		bool sel_active    = false;
+				long cyr = static_cast<long>(cy);
-		std::size_t sel_sy = 0, sel_sx = 0, sel_ey = 0, sel_ex = 0;
+				if (cyr < first_row || cyr > last_row) {
-		if (buf->MarkSet()) {
+					float target = (static_cast<float>(cyr) - std::max(0L, vis_rows / 2)) * row_h;
-			sel_sy = buf->MarkCury();
+					float max_y  = ImGui::GetScrollMaxY();
-			sel_sx = buf->MarkCurx();
+					if (target < 0.f)
-			sel_ey = buf->Cury();
+						target = 0.f;
-			sel_ex = buf->Curx();
+					if (max_y >= 0.f && target > max_y)
-			if (sel_sy > sel_ey || (sel_sy == sel_ey && sel_sx > sel_ex)) {
+						target = max_y;
-				std::swap(sel_sy, sel_ey);
+					ImGui::SetScrollY(target);
-				std::swap(sel_sx, sel_ex);
+					// refresh local variables
-			}
+					scroll_y  = ImGui::GetScrollY();
-			sel_active = !(sel_sy == sel_ey && sel_sx == sel_ex);
+					first_row = static_cast<long>(scroll_y / row_h);
-		}
+					last_row  = first_row + vis_rows - 1;
-		// 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;
-			// 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;
-			std::size_t by = static_cast<std::size_t>(by_l);
-			if (by >= lines.size())
-				by = lines.empty() ? 0 : (lines.size() - 1);
-
-			// Convert mouse pos to rendered x
-			float visual_x = mp.x - child_window_pos.x;
-			if (visual_x < 0.0f)
-				visual_x = 0.0f;
-			std::size_t clicked_rx = static_cast<std::size_t>(visual_x / space_w) + coloffs_now;
-
-			// 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;
-			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) {
-				float dist = std::fabs(clicked_rx_f - static_cast<float>(rx));
-				if (dist < best_dist) {
-					best_dist = dist;
-					best_col  = i;
-				}
-				if (i < line_clicked.size()) {
-					rx += (line_clicked[i] == '\t') ? (tabw - (rx % tabw)) : 1;
 				}
 			}
-			return {by, best_col};
+			// 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));
-		// Mouse-driven selection: set mark on press, update cursor on drag
+				int rc = static_cast<int>(std::max(1L, vis_rows));
+				buf->Highlighter()->PrefetchViewport(*buf, fr, rc, buf->Version());
+			}
+		}
+		// Handle mouse click before rendering to avoid dependency on drawn items
 		if (ImGui::IsWindowHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
-			mouse_selecting = true;
+			ImVec2 mp = ImGui::GetIO().MousePos;
-			auto [by, bx]   = mouse_pos_to_buf();
+			// Compute viewport-relative row so (0) is top row of the visible area
-			char tmp[64];
+			// Note: list_origin is already in the scrolled space of the child window,
-			std::snprintf(tmp, sizeof(tmp), "%zu:%zu", by, bx);
+			// so we must NOT subtract scroll_y again (would double-apply).
-			Execute(ed, CommandId::MoveCursorTo, std::string(tmp));
+			float vy_f = (mp.y - list_origin.y) / row_h;
-			if (Buffer *mbuf = const_cast<Buffer *>(buf)) {
+			long vy    = static_cast<long>(vy_f);
-				mbuf->SetMark(bx, by);
+			if (vy < 0)
+				vy = 0;
+
+			// Clamp vy within visible content height to avoid huge jumps
+			ImVec2 cr_min = ImGui::GetWindowContentRegionMin();
+			ImVec2 cr_max = ImGui::GetWindowContentRegionMax();
+			float child_h = (cr_max.y - cr_min.y);
+			long vis_rows = static_cast<long>(child_h / row_h);
+			if (vis_rows < 1)
+				vis_rows = 1;
+			if (vy >= vis_rows)
+				vy = vis_rows - 1;
+
+			// Translate viewport row to buffer row using Buffer::Rowoffs
+			std::size_t by = buf->Rowoffs() + static_cast<std::size_t>(vy);
+			if (by >= lines.size()) {
+				if (!lines.empty())
+					by = lines.size() - 1;
+				else
+					by = 0;
+			}
+
+			// Compute desired pixel X inside the viewport content.
+			// list_origin is already scrolled; do not subtract scroll_x here.
+			float px = (mp.x - list_origin.x);
+			if (px < 0.0f)
+				px = 0.0f;
+
+			// 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 pixel X to a render-column target including horizontal col offset
+				// Use our own tab expansion of width 8 to match command layer logic.
+				std::string line_clicked = static_cast<std::string>(lines[by]);
+				const std::size_t tabw   = 8;
+				// We iterate source columns computing absolute rendered column (rx_abs) from 0,
+				// then translate to viewport-space by subtracting Coloffs.
+				std::size_t coloffs = buf->Coloffs();
+				std::size_t rx_abs  = 0; // absolute rendered column
+				std::size_t i       = 0; // source column iterator
+
+				// Fast-forward i until rx_abs >= coloffs to align with leftmost visible column
+				if (!line_clicked.empty() && coloffs > 0) {
+					while (i < line_clicked.size() && rx_abs < coloffs) {
+						if (line_clicked[i] == '\t') {
+							rx_abs += (tabw - (rx_abs % tabw));
+						} else {
+							rx_abs += 1;
+						}
+						++i;
+					}
+				}
+
+				// Now search for closest source column to clicked px within/after viewport
+				std::size_t best_col = i; // default to first visible column
+				float best_dist      = std::numeric_limits<float>::infinity();
+				while (true) {
+					// For i in [current..size], evaluate candidate including the implicit end position
+					std::size_t rx_view = (rx_abs >= coloffs) ? (rx_abs - coloffs) : 0;
+					float rx_px         = static_cast<float>(rx_view) * space_w;
+					float dist          = std::fabs(px - rx_px);
+					if (dist <= best_dist) {
+						best_dist = dist;
+						best_col  = i;
+					}
+					if (i == line_clicked.size())
+						break;
+					// advance to next source column
+					if (line_clicked[i] == '\t') {
+						rx_abs += (tabw - (rx_abs % tabw));
+					} else {
+						rx_abs += 1;
+					}
+					++i;
+				}
+
+				// Dispatch absolute buffer coordinates (row:col)
+				char tmp[64];
+				std::snprintf(tmp, sizeof(tmp), "%zu:%zu", by, best_col);
+				Execute(ed, CommandId::MoveCursorTo, std::string(tmp));
 			}
 		}
-		if (mouse_selecting && ImGui::IsWindowHovered() && ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
+		// Cache current horizontal offset in rendered columns
-			auto [by, bx] = mouse_pos_to_buf();
+		const std::size_t coloffs_now = buf->Coloffs();
-			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
-			ImVec2 line_pos  = ImGui::GetCursorScreenPos();
+			ImVec2 line_pos = ImGui::GetCursorScreenPos();
-			std::string line = static_cast<std::string>(lines[i]);
+			auto line       = static_cast<std::string>(lines[i]);
 
 			// Expand tabs to spaces with width=8 and apply horizontal scroll offset
-			const std::size_t tabw = 8;
+			constexpr std::size_t tabw = 8;
 			std::string expanded;
 			expanded.reserve(line.size() + 16);
 			std::size_t rx_abs_draw = 0; // rendered column for drawing
@@ -252,7 +277,7 @@ ImGuiRenderer::Draw(Editor &ed)
 						for (auto it = std::sregex_iterator(line.begin(), line.end(), rx);
 						     it != std::sregex_iterator(); ++it) {
 							const auto &m  = *it;
-							std::size_t sx = static_cast<std::size_t>(m.position());
+							auto sx        = static_cast<std::size_t>(m.position());
 							std::size_t ex = sx + static_cast<std::size_t>(m.length());
 							hl_src_ranges.emplace_back(sx, ex);
 						}
@@ -295,9 +320,9 @@ ImGuiRenderer::Draw(Editor &ed)
 						continue; // fully left of view
 					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);
+					auto 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,
+					auto p1 = ImVec2(line_pos.x + static_cast<float>(vx1) * space_w,
-					                   line_pos.y + line_h);
+					                 line_pos.y + line_h);
 					// Choose color: current match stronger
 					bool is_current = has_current && sx == cur_x && ex == cur_end;
 					ImU32 col       = is_current
@@ -306,71 +331,6 @@ ImGuiRenderer::Draw(Editor &ed)
 					ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, col);
 				}
 			}
-
-			// Draw selection background (over search highlight; under text)
-			if (sel_active) {
-				bool line_has  = false;
-				std::size_t sx = 0, ex = 0;
-				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);
-					}
-				}
-			}
-			if (vsel_active && i >= vsel_sy && i <= vsel_ey) {
-				// Visual-line (multi-cursor) mode: highlight only the per-line cursor spot.
-				const std::size_t spot_sx  = std::min(buf->Curx(), line.size());
-				const std::size_t rx_start = src_to_rx(spot_sx);
-				std::size_t rx_end         = rx_start;
-				if (spot_sx < line.size()) {
-					rx_end = src_to_rx(spot_sx + 1);
-				} else {
-					// EOL spot: draw a 1-cell highlight just past the last character.
-					rx_end = rx_start + 1;
-				}
-				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];
@@ -386,78 +346,42 @@ ImGuiRenderer::Draw(Editor &ed)
 
 			// Draw syntax-colored runs (text above background highlights)
 			if (buf->SyntaxEnabled() && buf->Highlighter() && buf->Highlighter()->HasHighlighter()) {
-				kte::LineHighlight lh = buf->Highlighter()->GetLine(
+				const kte::LineHighlight &lh = buf->Highlighter()->GetLine(
 					*buf, static_cast<int>(i), buf->Version());
-				// Sanitize spans defensively: clamp to [0, line.size()], ensure end>=start, drop empties
-				struct SSpan {
-					std::size_t s;
-					std::size_t e;
-					kte::TokenKind k;
-				};
-				std::vector<SSpan> spans;
-				spans.reserve(lh.spans.size());
-				const std::size_t line_len = line.size();
-				for (const auto &sp: lh.spans) {
-					int s_raw = sp.col_start;
-					int e_raw = sp.col_end;
-					if (e_raw < s_raw)
-						std::swap(e_raw, s_raw);
-					std::size_t s = static_cast<std::size_t>(std::max(
-						0, std::min(s_raw, static_cast<int>(line_len))));
-					std::size_t e = static_cast<std::size_t>(std::max(
-						static_cast<int>(s), std::min(e_raw, static_cast<int>(line_len))));
-					if (e <= s)
-						continue;
-					spans.push_back(SSpan{s, e, sp.kind});
-				}
-				std::sort(spans.begin(), spans.end(), [](const SSpan &a, const SSpan &b) {
-					return a.s < b.s;
-				});
-
 				// Helper to convert a src column to expanded rx position
-				auto src_to_rx_full = [&](std::size_t sidx) -> std::size_t {
+				auto src_to_rx_full = [&](const std::size_t sidx) -> std::size_t {
 					std::size_t rx = 0;
 					for (std::size_t k = 0; k < sidx && k < line.size(); ++k) {
 						rx += (line[k] == '\t') ? (tabw - (rx % tabw)) : 1;
 					}
 					return rx;
 				};
-
+				for (const auto &sp: lh.spans) {
-				for (const auto &sp: spans) {
+					std::size_t rx_s = src_to_rx_full(
-					std::size_t rx_s = src_to_rx_full(sp.s);
+						static_cast<std::size_t>(std::max(0, sp.col_start)));
-					std::size_t rx_e = src_to_rx_full(sp.e);
+					std::size_t rx_e = src_to_rx_full(
+						static_cast<std::size_t>(std::max(sp.col_start, sp.col_end)));
 					if (rx_e <= coloffs_now)
-						continue; // fully left of viewport
-					// Clamp to visible portion and expanded length
-					std::size_t draw_start = (rx_s > coloffs_now) ? rx_s : coloffs_now;
-					if (draw_start >= expanded.size())
-						continue; // fully right of expanded text
-					std::size_t draw_end = std::min<std::size_t>(rx_e, expanded.size());
-					if (draw_end <= draw_start)
 						continue;
-					// Screen position is relative to coloffs_now
+					std::size_t vx0 = (rx_s > coloffs_now) ? (rx_s - coloffs_now) : 0;
-					std::size_t screen_x = draw_start - coloffs_now;
+					std::size_t vx1 = (rx_e > coloffs_now) ? (rx_e - coloffs_now) : 0;
-					ImU32 col = ImGui::GetColorU32(kte::SyntaxInk(sp.k));
+					if (vx0 >= expanded.size())
-					ImVec2 p = ImVec2(line_pos.x + static_cast<float>(screen_x) * space_w,
+						continue;
-					                  line_pos.y);
+					vx1 = std::min<std::size_t>(vx1, expanded.size());
+					if (vx1 <= vx0)
+						continue;
+					ImU32 col = ImGui::GetColorU32(kte::SyntaxInk(sp.kind));
+					auto p    = ImVec2(line_pos.x + static_cast<float>(vx0) * space_w, line_pos.y);
 					ImGui::GetWindowDrawList()->AddText(
-						p, col, expanded.c_str() + draw_start, expanded.c_str() + draw_end);
+						p, col, expanded.c_str() + vx0, expanded.c_str() + vx1);
 				}
-				// We drew text via draw list (no layout advance). Manually advance the cursor to the next line.
+				// We drew text via draw list (no layout advance). Advance by the same amount
-				// Use row_h (with spacing) to match click calculation and ensure consistent line positions.
+				// ImGui uses between lines (line height + spacing) so hit-testing (which
+				// divides by row_h) aligns with drawing.
 				ImGui::SetCursorScreenPos(ImVec2(line_pos.x, line_pos.y + row_h));
 			} else {
-				// No syntax: draw as one run, accounting for horizontal scroll offset
+				// No syntax: draw as one run
-				if (coloffs_now < expanded.size()) {
+				ImGui::TextUnformatted(expanded.c_str());
-					ImVec2 p = ImVec2(line_pos.x, line_pos.y);
-					ImGui::GetWindowDrawList()->AddText(
-						p, ImGui::GetColorU32(ImGuiCol_Text),
-						expanded.c_str() + coloffs_now);
-					ImGui::SetCursorScreenPos(ImVec2(line_pos.x, line_pos.y + row_h));
-				} else {
-					// Line is fully scrolled out of view horizontally
-					ImGui::SetCursorScreenPos(ImVec2(line_pos.x, line_pos.y + row_h));
-				}
 			}
 
 			// Draw a visible cursor indicator on the current line
@@ -472,121 +396,34 @@ ImGuiRenderer::Draw(Editor &ed)
 				}
 				// Convert to viewport x by subtracting horizontal col offset
 				std::size_t rx_viewport = (rx_abs > coloffs_now) ? (rx_abs - coloffs_now) : 0;
-				// For proportional fonts (Linux GUI), avoid accumulating drift by computing
+				ImVec2 p0 = ImVec2(line_pos.x + static_cast<float>(rx_viewport) * space_w, line_pos.y);
-				// the exact pixel width of the expanded substring up to the cursor.
-				// expanded contains the line with tabs expanded to spaces and is what we draw.
-				float cursor_px = 0.0f;
-				if (rx_viewport > 0 && coloffs_now < expanded.size()) {
-					std::size_t start = coloffs_now;
-					std::size_t end   = std::min(expanded.size(), start + rx_viewport);
-					// Measure substring width in pixels
-					ImVec2 sz = ImGui::CalcTextSize(expanded.c_str() + start,
-					                                expanded.c_str() + end);
-					cursor_px = sz.x;
-				}
-				ImVec2 p0 = ImVec2(line_pos.x + cursor_px, line_pos.y);
 				ImVec2 p1 = ImVec2(p0.x + space_w, p0.y + line_h);
 				ImU32 col = IM_COL32(200, 200, 255, 128); // soft highlight
 				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 area starting right after the scroll child
+		// Status bar spanning full width
+		ImGui::Separator();
+
+		// Compute full content width and draw a filled background rectangle
 		ImVec2 win_pos = ImGui::GetWindowPos();
-		ImVec2 win_sz  = ImGui::GetWindowSize();
+		ImVec2 cr_min  = ImGui::GetWindowContentRegionMin();
-		float x0       = win_pos.x;
+		ImVec2 cr_max  = ImGui::GetWindowContentRegionMax();
-		float x1       = win_pos.x + win_sz.x;
+		float x0       = win_pos.x + cr_min.x;
-		float y0       = ImGui::GetCursorScreenPos().y;
+		float x1       = win_pos.x + cr_max.x;
-		float bar_h    = real_bar_h;
+		ImVec2 cursor  = ImGui::GetCursorScreenPos();
-
+		float bar_h    = ImGui::GetFrameHeight();
-		ImVec2 p0(x0, y0);
+		ImVec2 p0(x0, cursor.y);
-		ImVec2 p1(x1, y0 + bar_h);
+		ImVec2 p1(x1, cursor.y + 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();
+			const std::string &label = ed.PromptLabel();
-			std::string ptext = ed.PromptText();
+			std::string ptext        = ed.PromptText();
-			auto kind         = ed.CurrentPromptKind();
+			auto kind                = ed.CurrentPromptKind();
 			if (kind == Editor::PromptKind::OpenFile || kind == Editor::PromptKind::SaveAs ||
 			    kind == Editor::PromptKind::Chdir) {
 				const char *home_c = std::getenv("HOME");
@@ -633,10 +470,10 @@ ImGuiRenderer::Draw(Editor &ed)
 						float ratio = tail_sz.x / avail_px;
 						size_t skip = ratio > 1.5f
 							              ? std::min(tail.size() - start,
-								              (size_t) std::max<size_t>(
+								              static_cast<size_t>(std::max<size_t>(
-									              1, (size_t) (tail.size() / 4)))
+									              1, tail.size() / 4)))
 							              : 1;
-						start                 += skip;
+						start += skip;
 						std::string candidate = tail.substr(start);
 						ImVec2 cand_sz        = ImGui::CalcTextSize(candidate.c_str());
 						if (cand_sz.x <= avail_px) {
@@ -667,9 +504,11 @@ 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, y0 + (bar_h - msg_sz.y) * 0.5f));
+			ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (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;
@@ -689,14 +528,13 @@ ImGuiRenderer::Draw(Editor &ed)
 			left += "  ";
 			// Insert buffer position prefix "[x/N] " before filename
 			{
-				std::size_t total = ed.BufferCount();
+				if (std::size_t total = ed.BufferCount(); total > 0) {
-				if (total > 0) {
 					std::size_t idx1 = ed.CurrentBufferIndex() + 1; // 1-based for display
-					left             += "[";
+					left += "[";
-					left             += std::to_string(static_cast<unsigned long long>(idx1));
+					left += std::to_string(static_cast<unsigned long long>(idx1));
-					left             += "/";
+					left += "/";
-					left             += std::to_string(static_cast<unsigned long long>(total));
+					left += std::to_string(static_cast<unsigned long long>(total));
-					left             += "] ";
+					left += "] ";
 				}
 			}
 			left += fname;
@@ -704,10 +542,10 @@ ImGuiRenderer::Draw(Editor &ed)
 				left += " *";
 			// Append total line count as "<n>L"
 			{
-				unsigned long lcount = static_cast<unsigned long>(buf->Rows().size());
+				auto lcount = buf->Rows().size();
-				left                 += " ";
+				left += " ";
-				left                 += std::to_string(lcount);
+				left += std::to_string(lcount);
-				left                 += "L";
+				left += "L";
 			}
 
 			// Build right text (cursor/mark)
@@ -745,21 +583,20 @@ 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, y0 + (bar_h - left_sz.y) * 0.5f));
+					ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
-					ImGui::PushClipRect(ImVec2(left_x, y0), ImVec2(right_x - pad, y0 + bar_h),
+					ImGui::PushClipRect(ImVec2(left_x, p0.y), ImVec2(right_x - pad, p1.y), true);
-					                    true);
 					ImGui::TextUnformatted(left.c_str());
 					ImGui::PopClipRect();
 				}
 			} else {
 				// Draw left normally
-				ImGui::SetCursorScreenPos(ImVec2(left_x, y0 + (bar_h - left_sz.y) * 0.5f));
+				ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
 				ImGui::TextUnformatted(left.c_str());
 			}
 
 			// Draw right
 			ImGui::SetCursorScreenPos(ImVec2(std::max(right_x, left_x),
-			                                 y0 + (bar_h - right_sz.y) * 0.5f));
+			                                 p0.y + (bar_h - right_sz.y) * 0.5f));
 			ImGui::TextUnformatted(right.c_str());
 
 			// Draw middle message centered in remaining space
@@ -771,12 +608,14 @@ 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, y0), ImVec2(mid_right, y0 + bar_h), true);
+					ImGui::PushClipRect(ImVec2(mid_left, p0.y), ImVec2(mid_right, p1.y), true);
-					ImGui::SetCursorScreenPos(ImVec2(msg_x, y0 + (bar_h - msg_sz.y) * 0.5f));
+					ImGui::SetCursorScreenPos(ImVec2(msg_x, p0.y + (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));
 		}
 	}
 
@@ -789,9 +628,9 @@ ImGuiRenderer::Draw(Editor &ed)
 		ImGuiViewport *vp2 = ImGui::GetMainViewport();
 
 		// Desired size, min size, and margins
-		const ImVec2 want(800.0f, 500.0f);
+		constexpr ImVec2 want(800.0f, 500.0f);
-		const ImVec2 min_sz(240.0f, 160.0f);
+		constexpr ImVec2 min_sz(240.0f, 160.0f);
-		const float margin = 20.0f; // space from viewport edges
+		constexpr float margin = 20.0f; // space from viewport edges
 
 		// Compute the maximum allowed size (viewport minus margins) and make sure it's not negative
 		ImVec2 max_sz(std::max(32.0f, vp2->Size.x - 2.0f * margin),
@@ -912,8 +751,12 @@ ImGuiRenderer::Draw(Editor &ed)
 						ed.SetFilePickerDir(e.path.string());
 					} else if (!e.is_dir && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
 						// Open file on single click
-						ed.RequestOpenFile(e.path.string());
+						std::string err;
-						(void) ed.ProcessPendingOpens();
+						if (!ed.OpenFile(e.path.string(), err)) {
+							ed.SetStatus(std::string("open: ") + err);
+						} else {
+							ed.SetStatus(std::string("Opened: ") + e.name);
+						}
 						ed.SetFilePickerVisible(false);
 					}
 				}

GUIRenderer.h

@@ -0,0 +1,18 @@
+/*
+ * GUIRenderer - ImGui-based renderer for GUI mode
+ */
+#ifndef KTE_GUI_RENDERER_H
+#define KTE_GUI_RENDERER_H
+
+#include "Renderer.h"
+
+class GUIRenderer final : public Renderer {
+public:
+	GUIRenderer() = default;
+
+	~GUIRenderer() override = default;
+
+	void Draw(Editor &ed) override;
+};
+
+#endif // KTE_GUI_RENDERER_H

GUITheme.h

@@ -1,307 +1,11 @@
-// GUITheme.h — theming helpers and background mode
+// GUITheme.h — ImGui theming helpers and background mode
 #pragma once
 
-#include <cstddef>
-#include <string>
-#include <algorithm>
-#include <cctype>
-
-#include "Highlight.h"
-
-// Cross-frontend theme change request hook: declared here, defined in Command.cc
-namespace kte {
-extern bool gThemeChangePending;
-extern std::string gThemeChangeRequest; // raw user-provided name
-// Qt GUI: cross-frontend font change hooks and current font state
-extern bool gFontChangePending;
-extern std::string gFontFamilyRequest; // requested family (case-insensitive)
-extern float gFontSizeRequest; // <= 0 means keep size
-extern std::string gCurrentFontFamily; // last applied family (Qt)
-extern float gCurrentFontSize; // last applied size (Qt)
-// Qt GUI: request to show a visual font dialog (set by command handler)
-extern bool gFontDialogRequested;
-}
-
-#if defined(KTE_USE_QT)
-// Qt build: avoid hard dependency on ImGui headers/types.
-// Provide a lightweight color vector matching ImVec4 fields used by renderers.
-struct KteColor {
-	float x{0}, y{0}, z{0}, w{1};
-};
-
-static inline KteColor
-RGBA(unsigned int rgb, float a = 1.0f)
-{
-	const float r = static_cast<float>((rgb >> 16) & 0xFF) / 255.0f;
-	const float g = static_cast<float>((rgb >> 8) & 0xFF) / 255.0f;
-	const float b = static_cast<float>(rgb & 0xFF) / 255.0f;
-	return {r, g, b, a};
-}
-
-namespace kte {
-// Background mode selection for light/dark palettes
-enum class BackgroundMode { Light, Dark };
-
-// Global background mode; default to Dark to match prior defaults
-static inline auto gBackgroundMode = BackgroundMode::Dark;
-
-
-static inline void
-SetBackgroundMode(const BackgroundMode m)
-{
-	gBackgroundMode = m;
-}
-
-
-static inline BackgroundMode
-GetBackgroundMode()
-{
-	return gBackgroundMode;
-}
-
-
-// Minimal GUI palette for Qt builds. This mirrors the defaults used in the ImGui
-// frontend (Nord-ish) and switches for light/dark background mode.
-struct Palette {
-	KteColor bg; // editor background
-	KteColor fg; // default foreground text
-	KteColor sel_bg; // selection background
-	KteColor cur_bg; // cursor cell background
-	KteColor status_bg; // status bar background
-	KteColor status_fg; // status bar foreground
-};
-
-// Optional theme override (Qt): when set, GetPalette() will return this instead
-// of the generic light/dark defaults. This allows honoring theme names in kge.ini.
-static inline bool gPaletteOverride = false;
-static inline Palette gOverridePalette{};
-static inline std::string gOverrideThemeName = ""; // lowercased name
-
-static inline Palette
-GetPalette()
-{
-	const bool dark = (GetBackgroundMode() == BackgroundMode::Dark);
-	if (gPaletteOverride) {
-		return gOverridePalette;
-	}
-	if (dark) {
-		return Palette{
-			/*bg*/ RGBA(0x1C1C1E),
-			/*fg*/ RGBA(0xDCDCDC),
-			/*sel_bg*/ RGBA(0xC8C800, 0.35f),
-			/*cur_bg*/ RGBA(0xC8C8FF, 0.50f),
-			/*status_bg*/ RGBA(0x28282C),
-			/*status_fg*/ RGBA(0xB4B48C)
-		};
-	} else {
-		// Light palette tuned for readability
-		return Palette{
-			/*bg*/ RGBA(0xFBFBFC),
-			/*fg*/ RGBA(0x30343A),
-			/*sel_bg*/ RGBA(0x268BD2, 0.22f),
-			/*cur_bg*/ RGBA(0x000000, 0.15f),
-			/*status_bg*/ RGBA(0xE6E8EA),
-			/*status_fg*/ RGBA(0x50555A)
-		};
-	}
-}
-
-
-// A few named palettes to provide visible differences between themes in Qt.
-// These are approximate and palette-based (no widget style changes like ImGuiStyle).
-static inline Palette
-NordDark()
-{
-	return {
-		/*bg*/RGBA(0x2E3440), /*fg*/RGBA(0xD8DEE9), /*sel_bg*/RGBA(0x88C0D0, 0.25f),
-		/*cur_bg*/RGBA(0x81A1C1, 0.35f), /*status_bg*/RGBA(0x3B4252), /*status_fg*/RGBA(0xE5E9F0)
-	};
-}
-
-
-static inline Palette
-NordLight()
-{
-	return {
-		/*bg*/RGBA(0xECEFF4), /*fg*/RGBA(0x2E3440), /*sel_bg*/RGBA(0x5E81AC, 0.22f),
-		/*cur_bg*/RGBA(0x000000, 0.12f), /*status_bg*/RGBA(0xE5E9F0), /*status_fg*/RGBA(0x4C566A)
-	};
-}
-
-
-static inline Palette
-SolarizedDark()
-{
-	return {
-		/*bg*/RGBA(0x002b36), /*fg*/RGBA(0x93a1a1), /*sel_bg*/RGBA(0x586e75, 0.40f),
-		/*cur_bg*/RGBA(0x657b83, 0.35f), /*status_bg*/RGBA(0x073642), /*status_fg*/RGBA(0xeee8d5)
-	};
-}
-
-
-static inline Palette
-SolarizedLight()
-{
-	return {
-		/*bg*/RGBA(0xfdf6e3), /*fg*/RGBA(0x586e75), /*sel_bg*/RGBA(0x268bd2, 0.25f),
-		/*cur_bg*/RGBA(0x000000, 0.10f), /*status_bg*/RGBA(0xeee8d5), /*status_fg*/RGBA(0x657b83)
-	};
-}
-
-
-static inline Palette
-GruvboxDark()
-{
-	return {
-		/*bg*/RGBA(0x282828), /*fg*/RGBA(0xebdbb2), /*sel_bg*/RGBA(0xd79921, 0.35f),
-		/*cur_bg*/RGBA(0x458588, 0.40f), /*status_bg*/RGBA(0x3c3836), /*status_fg*/RGBA(0xd5c4a1)
-	};
-}
-
-
-static inline Palette
-GruvboxLight()
-{
-	return {
-		/*bg*/RGBA(0xfbf1c7), /*fg*/RGBA(0x3c3836), /*sel_bg*/RGBA(0x076678, 0.22f),
-		/*cur_bg*/RGBA(0x000000, 0.10f), /*status_bg*/RGBA(0xebdbb2), /*status_fg*/RGBA(0x504945)
-	};
-}
-
-
-static inline Palette
-EInk()
-{
-	return {
-		/*bg*/RGBA(0xffffff), /*fg*/RGBA(0x000000), /*sel_bg*/RGBA(0x000000, 0.10f),
-		/*cur_bg*/RGBA(0x000000, 0.12f), /*status_bg*/RGBA(0x000000), /*status_fg*/RGBA(0xffffff)
-	};
-}
-
-
-// Apply a Qt theme by name. Returns true on success. Name matching is case-insensitive and
-// supports common aliases (e.g., "solarized-light" or "solarized light"). If the name conveys
-// a background (light/dark), BackgroundMode is updated to keep SyntaxInk consistent.
-static inline bool
-ApplyQtThemeByName(std::string name)
-{
-	// normalize
-	std::transform(name.begin(), name.end(), name.begin(), [](unsigned char c) {
-		return (char) std::tolower(c);
-	});
-	auto has = [&](const std::string &s) {
-		return name.find(s) != std::string::npos;
-	};
-
-	if (name.empty() || name == "default" || name == "nord") {
-		// Choose variant by current background mode
-		if (GetBackgroundMode() == BackgroundMode::Dark) {
-			gOverridePalette = NordDark();
-		} else {
-			gOverridePalette = NordLight();
-		}
-		gPaletteOverride   = true;
-		gOverrideThemeName = "nord";
-		return true;
-	}
-
-	if (has("solarized")) {
-		if (has("light")) {
-			SetBackgroundMode(BackgroundMode::Light);
-			gOverridePalette = SolarizedLight();
-		} else if (has("dark")) {
-			SetBackgroundMode(BackgroundMode::Dark);
-			gOverridePalette = SolarizedDark();
-		} else {
-			// pick from current background
-			gOverridePalette = (GetBackgroundMode() == BackgroundMode::Dark)
-				                   ? SolarizedDark()
-				                   : SolarizedLight();
-		}
-		gPaletteOverride   = true;
-		gOverrideThemeName = "solarized";
-		return true;
-	}
-
-	if (has("gruvbox")) {
-		if (has("light")) {
-			SetBackgroundMode(BackgroundMode::Light);
-			gOverridePalette = GruvboxLight();
-		} else if (has("dark")) {
-			SetBackgroundMode(BackgroundMode::Dark);
-			gOverridePalette = GruvboxDark();
-		} else {
-			gOverridePalette = (GetBackgroundMode() == BackgroundMode::Dark)
-				                   ? GruvboxDark()
-				                   : GruvboxLight();
-		}
-		gPaletteOverride   = true;
-		gOverrideThemeName = "gruvbox";
-		return true;
-	}
-
-	if (has("eink") || has("e-ink") || has("paper")) {
-		SetBackgroundMode(BackgroundMode::Light);
-		gOverridePalette   = EInk();
-		gPaletteOverride   = true;
-		gOverrideThemeName = "eink";
-		return true;
-	}
-
-	// Unknown -> clear override so default light/dark applies; return false.
-	gPaletteOverride = false;
-	gOverrideThemeName.clear();
-	return false;
-}
-
-
-// Minimal SyntaxInk mapping for Qt builds, returning KteColor
-[[maybe_unused]] static KteColor
-SyntaxInk(const TokenKind k)
-{
-	const bool dark    = (GetBackgroundMode() == BackgroundMode::Dark);
-	const KteColor def = dark ? RGBA(0xD8DEE9) : RGBA(0x2E3440);
-	switch (k) {
-	case TokenKind::Keyword:
-		return dark ? RGBA(0x81A1C1) : RGBA(0x5E81AC);
-	case TokenKind::Type:
-		return dark ? RGBA(0x8FBCBB) : RGBA(0x4C566A);
-	case TokenKind::String:
-		return dark ? RGBA(0xA3BE8C) : RGBA(0x6C8E5E);
-	case TokenKind::Char:
-		return dark ? RGBA(0xA3BE8C) : RGBA(0x6C8E5E);
-	case TokenKind::Comment:
-		return dark ? RGBA(0x616E88) : RGBA(0x7A869A);
-	case TokenKind::Number:
-		return dark ? RGBA(0xEBCB8B) : RGBA(0xB58900);
-	case TokenKind::Preproc:
-		return dark ? RGBA(0xD08770) : RGBA(0xAF3A03);
-	case TokenKind::Constant:
-		return dark ? RGBA(0xB48EAD) : RGBA(0x7B4B7F);
-	case TokenKind::Function:
-		return dark ? RGBA(0x88C0D0) : RGBA(0x3465A4);
-	case TokenKind::Operator:
-		return dark ? RGBA(0x2E3440) : RGBA(0x2E3440);
-	case TokenKind::Punctuation:
-		return dark ? RGBA(0xECEFF4) : RGBA(0x2E3440);
-	case TokenKind::Identifier:
-		return def;
-	case TokenKind::Whitespace:
-		return def;
-	case TokenKind::Error:
-		return dark ? RGBA(0xBF616A) : RGBA(0xCC0000);
-	case TokenKind::Default: default:
-		return def;
-	}
-}
-} // namespace kte
-
-#else
-
 #include <imgui.h>
 #include <vector>
 #include <memory>
 #include <string>
+#include <cstddef>
 #include <algorithm>
 #include <cctype>
 
@@ -322,19 +26,11 @@ enum class ThemeId {
 	Nord = 2,
 	Plan9 = 3,
 	Solarized = 4,
-	Everforest = 5,
-	KanagawaPaper = 6,
-	LCARS = 7,
-	OldBook = 8,
-	Zenburn = 9,
-	Amber = 10,
-	WeylandYutani = 11,
-	Orbital = 12,
 };
 
 // Current theme tracking
 static inline auto gCurrentTheme             = ThemeId::Nord;
-static inline std::size_t gCurrentThemeIndex = 6; // Nord index
+static inline std::size_t gCurrentThemeIndex = 0;
 
 // Forward declarations for helpers used below
 static size_t ThemeIndexFromId(ThemeId id);
@@ -369,14 +65,6 @@ BackgroundModeName()
 #include "themes/Solarized.h"
 #include "themes/Gruvbox.h"
 #include "themes/EInk.h"
-#include "themes/Everforest.h"
-#include "themes/KanagawaPaper.h"
-#include "themes/LCARS.h"
-#include "themes/OldBook.h"
-#include "themes/Amber.h"
-#include "themes/WeylandYutani.h"
-#include "themes/Zenburn.h"
-#include "themes/Orbital.h"
 
 
 // Theme abstraction and registry (generalized theme system)
@@ -390,123 +78,6 @@ public:
 };
 
 namespace detail {
-struct LCARSTheme final : Theme {
-	[[nodiscard]] const char *Name() const override
-	{
-		return "lcars";
-	}
-
-
-	void Apply() const override
-	{
-		ApplyLcarsTheme();
-	}
-
-
-	ThemeId Id() override
-	{
-		return ThemeId::LCARS;
-	}
-};
-
-struct EverforestTheme final : Theme {
-	[[nodiscard]] const char *Name() const override
-	{
-		return "everforest";
-	}
-
-
-	void Apply() const override
-	{
-		ApplyEverforestTheme();
-	}
-
-
-	ThemeId Id() override
-	{
-		return ThemeId::Everforest;
-	}
-};
-
-struct KanagawaPaperTheme final : Theme {
-	[[nodiscard]] const char *Name() const override
-	{
-		return "kanagawa-paper";
-	}
-
-
-	void Apply() const override
-	{
-		ApplyKanagawaPaperTheme();
-	}
-
-
-	ThemeId Id() override
-	{
-		return ThemeId::KanagawaPaper;
-	}
-};
-
-struct OldBookTheme final : Theme {
-	[[nodiscard]] const char *Name() const override
-	{
-		return "old-book";
-	}
-
-
-	void Apply() const override
-	{
-		if (gBackgroundMode == BackgroundMode::Dark)
-			ApplyOldBookDarkTheme();
-		else
-			ApplyOldBookLightTheme();
-	}
-
-
-	ThemeId Id() override
-	{
-		return ThemeId::OldBook;
-	}
-};
-
-struct OrbitalTheme final : Theme {
-	[[nodiscard]] const char *Name() const override
-	{
-		return "orbital";
-	}
-
-
-	void Apply() const override
-	{
-		ApplyOrbitalTheme();
-	}
-
-
-	ThemeId Id() override
-	{
-		return ThemeId::Orbital;
-	}
-};
-
-struct ZenburnTheme final : Theme {
-	[[nodiscard]] const char *Name() const override
-	{
-		return "zenburn";
-	}
-
-
-	void Apply() const override
-	{
-		ApplyZenburnTheme();
-	}
-
-
-	ThemeId Id() override
-	{
-		return ThemeId::Zenburn;
-	}
-};
-
 struct NordTheme final : Theme {
 	[[nodiscard]] const char *Name() const override
 	{
@@ -526,44 +97,6 @@ struct NordTheme final : Theme {
 	}
 };
 
-struct AmberTheme final : Theme {
-	[[nodiscard]] const char *Name() const override
-	{
-		return "amber";
-	}
-
-
-	void Apply() const override
-	{
-		ApplyAmberTheme();
-	}
-
-
-	ThemeId Id() override
-	{
-		return ThemeId::Amber;
-	}
-};
-
-struct WeylandYutaniTheme final : Theme {
-	[[nodiscard]] const char *Name() const override
-	{
-		return "weyland-yutani";
-	}
-
-
-	void Apply() const override
-	{
-		ApplyWeylandYutaniTheme();
-	}
-
-
-	ThemeId Id() override
-	{
-		return ThemeId::WeylandYutani;
-	}
-};
-
 struct GruvboxTheme final : Theme {
 	[[nodiscard]] const char *Name() const override
 	{
@@ -656,21 +189,12 @@ ThemeRegistry()
 {
 	static std::vector<std::unique_ptr<Theme> > reg;
 	if (reg.empty()) {
-		// Alphabetical by canonical name:
+		// Alphabetical by canonical name: eink, gruvbox, nord, plan9, solarized
-		// amber, eink, everforest, gruvbox, kanagawa-paper, lcars, nord, old-book, orbital, plan9, solarized, weyland-yutani, zenburn
-		reg.emplace_back(std::make_unique<detail::AmberTheme>());
 		reg.emplace_back(std::make_unique<detail::EInkTheme>());
-		reg.emplace_back(std::make_unique<detail::EverforestTheme>());
 		reg.emplace_back(std::make_unique<detail::GruvboxTheme>());
-		reg.emplace_back(std::make_unique<detail::KanagawaPaperTheme>());
-		reg.emplace_back(std::make_unique<detail::LCARSTheme>());
 		reg.emplace_back(std::make_unique<detail::NordTheme>());
-		reg.emplace_back(std::make_unique<detail::OldBookTheme>());
-		reg.emplace_back(std::make_unique<detail::OrbitalTheme>());
 		reg.emplace_back(std::make_unique<detail::Plan9Theme>());
 		reg.emplace_back(std::make_unique<detail::SolarizedTheme>());
-		reg.emplace_back(std::make_unique<detail::WeylandYutaniTheme>());
-		reg.emplace_back(std::make_unique<detail::ZenburnTheme>());
 	}
 	return reg;
 }
@@ -780,26 +304,6 @@ ApplyThemeByName(const std::string &name)
 	} else if (n == "eink-light") {
 		SetBackgroundMode(BackgroundMode::Light);
 		n = "eink";
-	} else if (n == "everforest-hard") {
-		// Request asks for everforest hard; map to canonical name
-		n = "everforest";
-	} else if (n == "oldbook") {
-		// alias to old-book
-		n = "old-book";
-	} else if (n == "old-book-dark" || n == "oldbook-dark") {
-		SetBackgroundMode(BackgroundMode::Dark);
-		n = "old-book";
-	} else if (n == "old-book-light" || n == "oldbook-light") {
-		SetBackgroundMode(BackgroundMode::Light);
-		n = "old-book";
-	} else if (n == "kanagawa" || n == "kanagawa-paper-light" || n == "kanagawa-light"
-	           || n == "kanagawa-dark" || n == "kanagawa-paper-dark") {
-		// map to canonical kanagawa-paper; background controls light/dark
-		n = "kanagawa-paper";
-	} else if (n == "vim-amber") {
-		n = "amber";
-	} else if (n == "weyland") {
-		n = "weyland-yutani";
 	}
 
 	const auto &reg = ThemeRegistry();
@@ -833,32 +337,16 @@ static size_t
 ThemeIndexFromId(const ThemeId id)
 {
 	switch (id) {
-	case ThemeId::Amber:
-		return 0;
 	case ThemeId::EInk:
-		return 1;
+		return 0;
-	case ThemeId::Everforest:
-		return 2;
 	case ThemeId::GruvboxDarkMedium:
-		return 3;
+		return 1;
-	case ThemeId::KanagawaPaper:
-		return 4;
-	case ThemeId::LCARS:
-		return 5;
 	case ThemeId::Nord:
-		return 6;
+		return 2;
-	case ThemeId::OldBook:
-		return 7;
-	case ThemeId::Orbital:
-		return 8;
 	case ThemeId::Plan9:
-		return 9;
+		return 3;
 	case ThemeId::Solarized:
-		return 10;
+		return 4;
-	case ThemeId::WeylandYutani:
-		return 11;
-	case ThemeId::Zenburn:
-		return 12;
 	}
 	return 0;
 }
@@ -870,31 +358,15 @@ ThemeIdFromIndex(const size_t idx)
 	switch (idx) {
 	default:
 	case 0:
-		return ThemeId::Amber;
-	case 1:
 		return ThemeId::EInk;
-	case 2:
+	case 1:
-		return ThemeId::Everforest;
-	case 3:
 		return ThemeId::GruvboxDarkMedium; // unified gruvbox
-	case 4:
+	case 2:
-		return ThemeId::KanagawaPaper;
-	case 5:
-		return ThemeId::LCARS;
-	case 6:
 		return ThemeId::Nord;
-	case 7:
+	case 3:
-		return ThemeId::OldBook;
-	case 8:
-		return ThemeId::Orbital;
-	case 9:
 		return ThemeId::Plan9;
-	case 10:
+	case 4:
 		return ThemeId::Solarized;
-	case 11:
-		return ThemeId::WeylandYutani;
-	case 12:
-		return ThemeId::Zenburn;
 	}
 }
 
@@ -941,5 +413,3 @@ SyntaxInk(const TokenKind k)
 	}
 }
 } // namespace kte
-
-#endif // KTE_USE_QT

GapBuffer.cc

@@ -0,0 +1,204 @@
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+
+#include "GapBuffer.h"
+
+
+GapBuffer::GapBuffer() = default;
+
+
+GapBuffer::GapBuffer(std::size_t initialCapacity)
+	: buffer_(nullptr), size_(0), capacity_(0)
+{
+	if (initialCapacity > 0) {
+		Reserve(initialCapacity);
+	}
+}
+
+
+GapBuffer::GapBuffer(const GapBuffer &other)
+	: buffer_(nullptr), size_(0), capacity_(0)
+{
+	if (other.capacity_ > 0) {
+		Reserve(other.capacity_);
+		if (other.size_ > 0) {
+			std::memcpy(buffer_, other.buffer_, other.size_);
+			size_ = other.size_;
+		}
+		setTerminator();
+	}
+}
+
+
+GapBuffer &
+GapBuffer::operator=(const GapBuffer &other)
+{
+	if (this == &other)
+		return *this;
+	if (other.capacity_ > capacity_) {
+		Reserve(other.capacity_);
+	}
+	if (other.size_ > 0) {
+		std::memcpy(buffer_, other.buffer_, other.size_);
+	}
+	size_ = other.size_;
+	setTerminator();
+	return *this;
+}
+
+
+GapBuffer::GapBuffer(GapBuffer &&other) noexcept
+	: buffer_(other.buffer_), size_(other.size_), capacity_(other.capacity_)
+{
+	other.buffer_   = nullptr;
+	other.size_     = 0;
+	other.capacity_ = 0;
+}
+
+
+GapBuffer &
+GapBuffer::operator=(GapBuffer &&other) noexcept
+{
+	if (this == &other)
+		return *this;
+	delete[] buffer_;
+	buffer_         = other.buffer_;
+	size_           = other.size_;
+	capacity_       = other.capacity_;
+	other.buffer_   = nullptr;
+	other.size_     = 0;
+	other.capacity_ = 0;
+	return *this;
+}
+
+
+GapBuffer::~GapBuffer()
+{
+	delete[] buffer_;
+}
+
+
+void
+GapBuffer::Reserve(const std::size_t newCapacity)
+{
+	if (newCapacity <= capacity_)
+		return;
+	// Allocate space for terminator as well
+	char *nb = new char[newCapacity + 1];
+	if (size_ > 0 && buffer_) {
+		std::memcpy(nb, buffer_, size_);
+	}
+	delete[] buffer_;
+	buffer_   = nb;
+	capacity_ = newCapacity;
+	setTerminator();
+}
+
+
+void
+GapBuffer::AppendChar(const char c)
+{
+	ensureCapacityFor(1);
+	buffer_[size_++] = c;
+	setTerminator();
+}
+
+
+void
+GapBuffer::Append(const char *s, const std::size_t len)
+{
+	if (!s || len == 0)
+		return;
+	ensureCapacityFor(len);
+	std::memcpy(buffer_ + size_, s, len);
+	size_ += len;
+	setTerminator();
+}
+
+
+void
+GapBuffer::Append(const GapBuffer &other)
+{
+	if (other.size_ == 0)
+		return;
+	Append(other.buffer_, other.size_);
+}
+
+
+void
+GapBuffer::PrependChar(char c)
+{
+	ensureCapacityFor(1);
+	// shift right by 1
+	if (size_ > 0) {
+		std::memmove(buffer_ + 1, buffer_, size_);
+	}
+	buffer_[0] = c;
+	++size_;
+	setTerminator();
+}
+
+
+void
+GapBuffer::Prepend(const char *s, std::size_t len)
+{
+	if (!s || len == 0)
+		return;
+	ensureCapacityFor(len);
+	if (size_ > 0) {
+		std::memmove(buffer_ + len, buffer_, size_);
+	}
+	std::memcpy(buffer_, s, len);
+	size_ += len;
+	setTerminator();
+}
+
+
+void
+GapBuffer::Prepend(const GapBuffer &other)
+{
+	if (other.size_ == 0)
+		return;
+	Prepend(other.buffer_, other.size_);
+}
+
+
+void
+GapBuffer::Clear()
+{
+	size_ = 0;
+	setTerminator();
+}
+
+
+void
+GapBuffer::ensureCapacityFor(std::size_t delta)
+{
+	if (capacity_ - size_ >= delta)
+		return;
+	auto required = size_ + delta;
+	Reserve(growCapacity(capacity_, required));
+}
+
+
+std::size_t
+GapBuffer::growCapacity(std::size_t current, std::size_t required)
+{
+	// geometric growth, at least required
+	std::size_t newCap = current ? current : 8;
+	while (newCap < required)
+		newCap = newCap + (newCap >> 1); // 1.5x growth
+	return newCap;
+}
+
+
+void
+GapBuffer::setTerminator() const
+{
+	if (!buffer_) {
+		return;
+	}
+
+	buffer_[size_] = '\0';
+}

GapBuffer.h

@@ -0,0 +1,80 @@
+/*
+ * GapBuffer.h - C++ replacement for abuf append/prepend buffer utilities
+ */
+#ifndef KTE_GAPBUFFER_H
+#define KTE_GAPBUFFER_H
+
+#include <cstddef>
+
+
+class GapBuffer {
+public:
+	GapBuffer();
+
+	explicit GapBuffer(std::size_t initialCapacity);
+
+	GapBuffer(const GapBuffer &other);
+
+	GapBuffer &operator=(const GapBuffer &other);
+
+	GapBuffer(GapBuffer &&other) noexcept;
+
+	GapBuffer &operator=(GapBuffer &&other) noexcept;
+
+	~GapBuffer();
+
+	void Reserve(std::size_t newCapacity);
+
+
+	void AppendChar(char c);
+
+	void Append(const char *s, std::size_t len);
+
+	void Append(const GapBuffer &other);
+
+	void PrependChar(char c);
+
+	void Prepend(const char *s, std::size_t len);
+
+	void Prepend(const GapBuffer &other);
+
+	// Content management
+	void Clear();
+
+	// Accessors
+	char *Data()
+	{
+		return buffer_;
+	}
+
+
+	[[nodiscard]] const char *Data() const
+	{
+		return buffer_;
+	}
+
+
+	[[nodiscard]] std::size_t Size() const
+	{
+		return size_;
+	}
+
+
+	[[nodiscard]] std::size_t Capacity() const
+	{
+		return capacity_;
+	}
+
+private:
+	void ensureCapacityFor(std::size_t delta);
+
+	static std::size_t growCapacity(std::size_t current, std::size_t required);
+
+	void setTerminator() const;
+
+	char *buffer_         = nullptr;
+	std::size_t size_     = 0; // number of valid bytes (excluding terminator)
+	std::size_t capacity_ = 0; // capacity of buffer_ excluding space for terminator
+};
+
+#endif // KTE_GAPBUFFER_H

HelpText.cc

@@ -22,9 +22,7 @@ HelpText::Text()
 		"  C-k '        Toggle read-only\n"
 		"  C-k -        Unindent region (mark required)\n"
 		"  C-k =        Indent region (mark required)\n"
-		"  C-k /        Toggle visual line mode\n"
 		"  C-k ;        Command prompt (:\\ )\n"
-		"  C-k SPACE    Toggle mark\n"
 		"  C-k C-d      Kill entire line\n"
 		"  C-k C-q      Quit now (no confirm)\n"
 		"  C-k C-x      Save and quit\n"
@@ -36,9 +34,7 @@ HelpText::Text()
 		"  C-k f        Flush kill ring\n"
 		"  C-k g        Jump to line\n"
 		"  C-k h        Show this help\n"
-		"  C-k i        New empty buffer\n"
 		"  C-k j        Jump to mark\n"
-		"  C-k k        Center viewport on cursor\n"
 		"  C-k l        Reload buffer from disk\n"
 		"  C-k n        Previous buffer\n"
 		"  C-k o        Change working directory (prompt)\n"
@@ -79,7 +75,7 @@ HelpText::Text()
 		"Buffers:\n  +HELP+ is read-only. Press C-k ' to toggle; C-k h restores it.\n"
 		"\n"
 		"GUI appearance (command prompt):\n"
-		"  : theme NAME         Set GUI theme (amber, eink, everforest, gruvbox, kanagawa-paper, lcars, nord, old-book, plan9, solarized, weyland-yutani, zenburn)\n"
+		"  : theme NAME         Set GUI theme (eink, gruvbox, nord, plan9, solarized)\n"
-		"  : background MODE    Set background: light | dark (affects eink, gruvbox, old-book, solarized)\n"
+		"  : background MODE    Set background: light | dark (affects eink, gruvbox, solarized)\n"
 	);
 }

HelpText.h

@@ -1,7 +1,9 @@
 /*
  * HelpText.h - embedded/customizable help content
  */
-#pragma once
+#ifndef KTE_HELPTEXT_H
+#define KTE_HELPTEXT_H
+
 #include <string>
 
 class HelpText {
@@ -11,3 +13,5 @@ public:
 	// (in HelpText.cc) without touching the help command logic.
 	static std::string Text();
 };
+
+#endif // KTE_HELPTEXT_H

ImGuiRenderer.h

@@ -1,14 +0,0 @@
-/*
- * ImGuiRenderer - ImGui-based renderer for GUI mode
- */
-#pragma once
-#include "Renderer.h"
-
-class ImGuiRenderer final : public Renderer {
-public:
-	ImGuiRenderer() = default;
-
-	~ImGuiRenderer() override = default;
-
-	void Draw(Editor &ed) override;
-};

InputHandler.h

@@ -1,13 +1,13 @@
 /*
  * InputHandler.h - input abstraction and mapping to commands
  */
-#pragma once
+#ifndef KTE_INPUT_HANDLER_H
+#define KTE_INPUT_HANDLER_H
+
 #include <string>
 
 #include "Command.h"
 
-class Editor; // fwd decl
-
 
 // Result of translating raw input into an editor command.
 struct MappedInput {
@@ -21,11 +21,9 @@ class InputHandler {
 public:
 	virtual ~InputHandler() = default;
 
-	// Optional: attach current Editor so handlers can consult editor state (e.g., universal argument)
-	// Default implementation does nothing.
-	virtual void Attach(Editor *) {}
-
 	// Poll for input and translate it to a command. Non-blocking.
 	// Returns true if a command is available in 'out'. Returns false if no input.
 	virtual bool Poll(MappedInput &out) = 0;
 };
+
+#endif // KTE_INPUT_HANDLER_H

KKeymap.cc

@@ -17,9 +17,6 @@ KLookupKCommand(const int ascii_key, const bool ctrl, CommandId &out) -> bool
 		case 'd':
 			out = CommandId::KillLine;
 			return true;
-		case 's':
-			out = CommandId::Save;
-			return true;
 		case 'q':
 			out = CommandId::QuitNow;
 			return true;
@@ -45,15 +42,6 @@ KLookupKCommand(const int ascii_key, const bool ctrl, CommandId &out) -> bool
 	case 'a':
 		out = CommandId::MarkAllAndJumpEnd;
 		return true;
-	case ' ': // C-k SPACE
-		out = CommandId::ToggleMark;
-		return true;
-	case 'i':
-		out = CommandId::BufferNew; // C-k i new empty buffer
-		return true;
-	case 'k':
-		out = CommandId::CenterOnCursor; // C-k k center current line
-		return true;
 	case 'b':
 		out = CommandId::BufferSwitchStart;
 		return true;
@@ -120,9 +108,6 @@ 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;

KKeymap.h

@@ -1,7 +1,9 @@
 /*
  * KKeymap.h - mapping for k-command (C-k prefix) keys to CommandId
  */
-#pragma once
+#ifndef KTE_KKEYMAP_H
+#define KTE_KKEYMAP_H
+
 #include "Command.h"
 
 
@@ -28,3 +30,5 @@ KLowerAscii(const int key)
 		return key + ('a' - 'A');
 	return key;
 }
+
+#endif // KTE_KKEYMAP_H

OptimizedSearch.cc

@@ -1,79 +0,0 @@
-#include "OptimizedSearch.h"
-
-#include <algorithm>
-
-
-void
-OptimizedSearch::build_bad_char(const std::string &pattern)
-{
-	if (pattern == last_pat_)
-		return;
-	last_pat_ = pattern;
-	std::fill(bad_char_.begin(), bad_char_.end(), -1);
-	for (std::size_t i = 0; i < pattern.size(); ++i) {
-		bad_char_[static_cast<unsigned char>(pattern[i])] = static_cast<int>(i);
-	}
-}
-
-
-std::size_t
-OptimizedSearch::find_first(const std::string &text, const std::string &pattern, std::size_t start)
-{
-	const std::size_t n = text.size();
-	const std::size_t m = pattern.size();
-	if (m == 0)
-		return start <= n ? start : std::string::npos;
-	if (m > n || start >= n)
-		return std::string::npos;
-	build_bad_char(pattern);
-	std::size_t s = start;
-	while (s <= n - m) {
-		std::size_t j = m;
-		while (j > 0 && pattern[j - 1] == text[s + j - 1]) {
-			--j;
-		}
-		if (j == 0) {
-			return s; // match found
-		}
-		unsigned char badc = static_cast<unsigned char>(text[s + j - 1]);
-		int bcidx          = bad_char_[badc];
-		std::size_t shift  = (j - 1 > static_cast<std::size_t>(bcidx))
-			                    ? (j - 1 - static_cast<std::size_t>(bcidx))
-			                    : 1;
-		s += shift;
-	}
-	return std::string::npos;
-}
-
-
-std::vector<std::size_t>
-OptimizedSearch::find_all(const std::string &text, const std::string &pattern, std::size_t start)
-{
-	std::vector<std::size_t> res;
-	const std::size_t n = text.size();
-	const std::size_t m = pattern.size();
-	if (m == 0)
-		return res;
-	if (m > n || start >= n)
-		return res;
-	build_bad_char(pattern);
-	std::size_t s = start;
-	while (s <= n - m) {
-		std::size_t j = m;
-		while (j > 0 && pattern[j - 1] == text[s + j - 1]) {
-			--j;
-		}
-		if (j == 0) {
-			res.push_back(s);
-			s += m; // non-overlapping
-			continue;
-		}
-		unsigned char badc = static_cast<unsigned char>(text[s + j - 1]);
-		int bcidx          = bad_char_[badc];
-		std::size_t shift  = (j - 1 > static_cast<std::size_t>(bcidx))
-			                    ? (j - 1 - static_cast<std::size_t>(bcidx))
-			                    : 1;
-		s += shift;
-	}
-	return res;
-}

OptimizedSearch.h

@@ -1,23 +0,0 @@
-// OptimizedSearch.h - Boyer–Moore (bad character) based substring search
-#pragma once
-#include <array>
-#include <cstddef>
-#include <string>
-#include <vector>
-
-class OptimizedSearch {
-public:
-	OptimizedSearch() = default;
-
-	// Find first occurrence at or after start. Returns npos if not found.
-	std::size_t find_first(const std::string &text, const std::string &pattern, std::size_t start = 0);
-
-	// Find all non-overlapping matches at or after start. Returns starting indices.
-	std::vector<std::size_t> find_all(const std::string &text, const std::string &pattern, std::size_t start = 0);
-
-private:
-	std::array<int, 256> bad_char_{};
-	std::string last_pat_;
-
-	void build_bad_char(const std::string &pattern);
-};

PieceTable.cc

@@ -1,7 +1,5 @@
 #include <algorithm>
 #include <utility>
-#include <limits>
-#include <ostream>
 
 #include "PieceTable.h"
 
@@ -16,32 +14,13 @@ PieceTable::PieceTable(const std::size_t initialCapacity)
 }
 
 
-PieceTable::PieceTable(const std::size_t initialCapacity,
-                       const std::size_t piece_limit,
-                       const std::size_t small_piece_threshold,
-                       const std::size_t max_consolidation_bytes)
-{
-	add_.reserve(initialCapacity);
-	materialized_.reserve(initialCapacity);
-	piece_limit_             = piece_limit;
-	small_piece_threshold_   = small_piece_threshold;
-	max_consolidation_bytes_ = max_consolidation_bytes;
-}
-
-
 PieceTable::PieceTable(const PieceTable &other)
 	: original_(other.original_),
 	  add_(other.add_),
 	  pieces_(other.pieces_),
 	  materialized_(other.materialized_),
 	  dirty_(other.dirty_),
-	  total_size_(other.total_size_)
+	  total_size_(other.total_size_) {}
-{
-	version_ = other.version_;
-	// caches are per-instance, mark invalid
-	range_cache_ = {};
-	find_cache_  = {};
-}
 
 
 PieceTable &
@@ -55,9 +34,6 @@ PieceTable::operator=(const PieceTable &other)
 	materialized_ = other.materialized_;
 	dirty_        = other.dirty_;
 	total_size_   = other.total_size_;
-	version_      = other.version_;
-	range_cache_  = {};
-	find_cache_   = {};
 	return *this;
 }
 
@@ -72,9 +48,6 @@ PieceTable::PieceTable(PieceTable &&other) noexcept
 {
 	other.dirty_      = true;
 	other.total_size_ = 0;
-	version_          = other.version_;
-	range_cache_      = {};
-	find_cache_       = {};
 }
 
 
@@ -91,9 +64,6 @@ PieceTable::operator=(PieceTable &&other) noexcept
 	total_size_       = other.total_size_;
 	other.dirty_      = true;
 	other.total_size_ = 0;
-	version_          = other.version_;
-	range_cache_      = {};
-	find_cache_       = {};
 	return *this;
 }
 
@@ -109,21 +79,6 @@ PieceTable::Reserve(const std::size_t newCapacity)
 }
 
 
-// Setter to allow tuning consolidation heuristics
-void
-PieceTable::SetConsolidationParams(const std::size_t piece_limit,
-                                   const std::size_t small_piece_threshold,
-                                   const std::size_t max_consolidation_bytes)
-{
-	piece_limit_             = piece_limit;
-	small_piece_threshold_   = small_piece_threshold;
-	max_consolidation_bytes_ = max_consolidation_bytes;
-}
-
-
-// (removed helper) — we'll invalidate caches inline inside mutating methods
-
-
 void
 PieceTable::AppendChar(char c)
 {
@@ -196,11 +151,6 @@ PieceTable::Clear()
 	materialized_.clear();
 	total_size_ = 0;
 	dirty_      = true;
-	line_index_.clear();
-	line_index_dirty_ = true;
-	version_++;
-	range_cache_ = {};
-	find_cache_  = {};
 }
 
 
@@ -218,12 +168,9 @@ PieceTable::addPieceBack(const Source src, const std::size_t start, const std::s
 			std::size_t expectStart = last.start + last.len;
 
 			if (expectStart == start) {
-				last.len    += len;
+				last.len += len;
 				total_size_ += len;
-				dirty_      = true;
+				dirty_ = true;
-				version_++;
-				range_cache_ = {};
-				find_cache_  = {};
 				return;
 			}
 		}
@@ -231,11 +178,7 @@ PieceTable::addPieceBack(const Source src, const std::size_t start, const std::s
 
 	pieces_.push_back(Piece{src, start, len});
 	total_size_ += len;
-	dirty_      = true;
+	dirty_ = true;
-	InvalidateLineIndex();
-	version_++;
-	range_cache_ = {};
-	find_cache_  = {};
 }
 
 
@@ -251,29 +194,21 @@ PieceTable::addPieceFront(Source src, std::size_t start, std::size_t len)
 		Piece &first = pieces_.front();
 		if (first.src == src && start + len == first.start) {
 			first.start = start;
-			first.len   += len;
+			first.len += len;
 			total_size_ += len;
-			dirty_      = true;
+			dirty_ = true;
-			version_++;
-			range_cache_ = {};
-			find_cache_  = {};
 			return;
 		}
 	}
 	pieces_.insert(pieces_.begin(), Piece{src, start, len});
 	total_size_ += len;
-	dirty_      = true;
+	dirty_ = true;
-	InvalidateLineIndex();
-	version_++;
-	range_cache_ = {};
-	find_cache_  = {};
 }
 
 
 void
 PieceTable::materialize() const
 {
-	std::lock_guard<std::mutex> lock(mutex_);
 	if (!dirty_) {
 		return;
 	}
@@ -290,511 +225,3 @@ PieceTable::materialize() const
 	// Ensure there is a null terminator present via std::string invariants
 	dirty_ = false;
 }
-
-
-// ===== New Phase 1 implementation =====
-
-std::pair<std::size_t, std::size_t>
-PieceTable::locate(const std::size_t byte_offset) const
-{
-	if (byte_offset >= total_size_) {
-		return {pieces_.size(), 0};
-	}
-	std::size_t off = byte_offset;
-	for (std::size_t i = 0; i < pieces_.size(); ++i) {
-		const auto &p = pieces_[i];
-		if (off < p.len) {
-			return {i, off};
-		}
-		off -= p.len;
-	}
-	// Should not reach here unless inconsistency; return end
-	return {pieces_.size(), 0};
-}
-
-
-void
-PieceTable::coalesceNeighbors(std::size_t index)
-{
-	if (pieces_.empty())
-		return;
-	if (index >= pieces_.size())
-		index = pieces_.size() - 1;
-	// Merge repeatedly with previous while contiguous and same source
-	while (index > 0) {
-		auto &prev = pieces_[index - 1];
-		auto &curr = pieces_[index];
-		if (prev.src == curr.src && prev.start + prev.len == curr.start) {
-			prev.len += curr.len;
-			pieces_.erase(pieces_.begin() + static_cast<std::ptrdiff_t>(index));
-			index -= 1;
-		} else {
-			break;
-		}
-	}
-	// Merge repeatedly with next while contiguous and same source
-	while (index + 1 < pieces_.size()) {
-		auto &curr = pieces_[index];
-		auto &next = pieces_[index + 1];
-		if (curr.src == next.src && curr.start + curr.len == next.start) {
-			curr.len += next.len;
-			pieces_.erase(pieces_.begin() + static_cast<std::ptrdiff_t>(index + 1));
-		} else {
-			break;
-		}
-	}
-}
-
-
-void
-PieceTable::InvalidateLineIndex() const
-{
-	std::lock_guard<std::mutex> lock(mutex_);
-	line_index_dirty_ = true;
-}
-
-
-void
-PieceTable::RebuildLineIndex() const
-{
-	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;
-}
-
-
-void
-PieceTable::Insert(std::size_t byte_offset, const char *text, std::size_t len)
-{
-	if (len == 0) {
-		return;
-	}
-	if (byte_offset > total_size_) {
-		byte_offset = total_size_;
-	}
-
-	const std::size_t add_start = add_.size();
-	add_.append(text, len);
-
-	if (pieces_.empty()) {
-		pieces_.push_back(Piece{Source::Add, add_start, len});
-		total_size_ += len;
-		dirty_      = true;
-		InvalidateLineIndex();
-		maybeConsolidate();
-		version_++;
-		range_cache_ = {};
-		find_cache_  = {};
-		return;
-	}
-
-	auto [idx, inner] = locate(byte_offset);
-	if (idx == pieces_.size()) {
-		// insert at end
-		pieces_.push_back(Piece{Source::Add, add_start, len});
-		total_size_ += len;
-		dirty_      = true;
-		InvalidateLineIndex();
-		coalesceNeighbors(pieces_.size() - 1);
-		maybeConsolidate();
-		version_++;
-		range_cache_ = {};
-		find_cache_  = {};
-		return;
-	}
-
-	Piece target = pieces_[idx];
-	// Build replacement sequence: left, inserted, right
-	std::vector<Piece> repl;
-	repl.reserve(3);
-	if (inner > 0) {
-		repl.push_back(Piece{target.src, target.start, inner});
-	}
-	repl.push_back(Piece{Source::Add, add_start, len});
-	const std::size_t right_len = target.len - inner;
-	if (right_len > 0) {
-		repl.push_back(Piece{target.src, target.start + inner, right_len});
-	}
-
-	// Replace target with repl
-	pieces_.erase(pieces_.begin() + static_cast<std::ptrdiff_t>(idx));
-	pieces_.insert(pieces_.begin() + static_cast<std::ptrdiff_t>(idx), repl.begin(), repl.end());
-
-	total_size_ += len;
-	dirty_      = true;
-	InvalidateLineIndex();
-	// Try coalescing around the inserted position (the inserted piece is at idx + (inner>0 ? 1 : 0))
-	std::size_t ins_index = idx + (inner > 0 ? 1 : 0);
-	coalesceNeighbors(ins_index);
-	maybeConsolidate();
-	version_++;
-	range_cache_ = {};
-	find_cache_  = {};
-}
-
-
-void
-PieceTable::Delete(std::size_t byte_offset, std::size_t len)
-{
-	if (len == 0) {
-		return;
-	}
-	if (byte_offset >= total_size_) {
-		return;
-	}
-	if (byte_offset + len > total_size_) {
-		len = total_size_ - byte_offset;
-	}
-
-	auto [idx, inner]     = locate(byte_offset);
-	std::size_t remaining = len;
-
-	while (remaining > 0 && idx < pieces_.size()) {
-		Piece &pc             = pieces_[idx];
-		std::size_t available = pc.len - inner; // bytes we can remove from this piece starting at inner
-		std::size_t take      = std::min(available, remaining);
-
-		// Compute lengths for left and right remnants
-		std::size_t left_len  = inner;
-		std::size_t right_len = pc.len - inner - take;
-		Source src            = pc.src;
-		std::size_t start     = pc.start;
-
-		// Replace current piece with up to two remnants
-		if (left_len > 0 && right_len > 0) {
-			pc.len = left_len; // keep left in place
-			Piece right{src, start + inner + take, right_len};
-			pieces_.insert(pieces_.begin() + static_cast<std::ptrdiff_t>(idx + 1), right);
-			idx += 1; // move to right for next iteration decision
-		} else if (left_len > 0) {
-			pc.len = left_len;
-			// no insertion; idx now points to left; move to next piece
-		} else if (right_len > 0) {
-			pc.start = start + inner + take;
-			pc.len   = right_len;
-		} else {
-			// entire piece removed
-			pieces_.erase(pieces_.begin() + static_cast<std::ptrdiff_t>(idx));
-			// stay at same idx for next piece
-			inner     = 0;
-			remaining -= take;
-			continue;
-		}
-
-		// After modifying current idx, next deletion continues at beginning of the next logical region
-		inner     = 0;
-		remaining -= take;
-		if (remaining == 0)
-			break;
-		// Move to next piece
-		idx += 1;
-	}
-
-	total_size_ -= len;
-	dirty_      = true;
-	InvalidateLineIndex();
-	if (idx < pieces_.size())
-		coalesceNeighbors(idx);
-	if (idx > 0)
-		coalesceNeighbors(idx - 1);
-	maybeConsolidate();
-	version_++;
-	range_cache_ = {};
-	find_cache_  = {};
-}
-
-
-// ===== Consolidation implementation =====
-
-void
-PieceTable::appendPieceDataTo(std::string &out, const Piece &p) const
-{
-	if (p.len == 0)
-		return;
-	const std::string &src = p.src == Source::Original ? original_ : add_;
-	out.append(src.data() + static_cast<std::ptrdiff_t>(p.start), p.len);
-}
-
-
-void
-PieceTable::consolidateRange(std::size_t start_idx, std::size_t end_idx)
-{
-	if (start_idx >= end_idx || start_idx >= pieces_.size())
-		return;
-	end_idx           = std::min(end_idx, pieces_.size());
-	std::size_t total = 0;
-	for (std::size_t i = start_idx; i < end_idx; ++i)
-		total += pieces_[i].len;
-	if (total == 0)
-		return;
-
-	const std::size_t add_start = add_.size();
-	std::string tmp;
-	tmp.reserve(std::min<std::size_t>(total, max_consolidation_bytes_));
-	for (std::size_t i = start_idx; i < end_idx; ++i)
-		appendPieceDataTo(tmp, pieces_[i]);
-	add_.append(tmp);
-
-	// Replace [start_idx, end_idx) with single Add piece
-	Piece consolidated{Source::Add, add_start, tmp.size()};
-	pieces_.erase(pieces_.begin() + static_cast<std::ptrdiff_t>(start_idx),
-	              pieces_.begin() + static_cast<std::ptrdiff_t>(end_idx));
-	pieces_.insert(pieces_.begin() + static_cast<std::ptrdiff_t>(start_idx), consolidated);
-
-	// total_size_ unchanged
-	dirty_ = true;
-	InvalidateLineIndex();
-	coalesceNeighbors(start_idx);
-	// Layout changed; invalidate caches/version
-	version_++;
-	range_cache_ = {};
-	find_cache_  = {};
-}
-
-
-void
-PieceTable::maybeConsolidate()
-{
-	if (pieces_.size() <= piece_limit_)
-		return;
-
-	// Find the first run of small pieces to consolidate
-	std::size_t n          = pieces_.size();
-	std::size_t best_start = n, best_end = n;
-	std::size_t i          = 0;
-	while (i < n) {
-		// Skip large pieces quickly
-		if (pieces_[i].len > small_piece_threshold_) {
-			i++;
-			continue;
-		}
-		std::size_t j     = i;
-		std::size_t bytes = 0;
-		while (j < n) {
-			const auto &p = pieces_[j];
-			if (p.len > small_piece_threshold_)
-				break;
-			if (bytes + p.len > max_consolidation_bytes_)
-				break;
-			bytes += p.len;
-			j++;
-		}
-		if (j - i >= 2 && bytes > 0) {
-			// consolidate runs of at least 2 pieces
-			best_start = i;
-			best_end   = j;
-			break; // do one run per call; subsequent ops can repeat if still over limit
-		}
-		i = j + 1;
-	}
-
-	if (best_start < best_end) {
-		consolidateRange(best_start, best_end);
-	}
-}
-
-
-std::size_t
-PieceTable::LineCount() const
-{
-	RebuildLineIndex();
-	return line_index_.empty() ? 0 : line_index_.size();
-}
-
-
-std::pair<std::size_t, std::size_t>
-PieceTable::GetLineRange(std::size_t line_num) const
-{
-	RebuildLineIndex();
-	if (line_index_.empty())
-		return {0, 0};
-	if (line_num >= line_index_.size())
-		return {0, 0};
-	std::size_t start = line_index_[line_num];
-	std::size_t end   = (line_num + 1 < line_index_.size()) ? line_index_[line_num + 1] : total_size_;
-	return {start, end};
-}
-
-
-std::string
-PieceTable::GetLine(std::size_t line_num) const
-{
-	auto [start, end] = GetLineRange(line_num);
-	if (end < start)
-		return std::string();
-	// Trim trailing '\n'
-	if (end > start) {
-		// To check last char, we can get it via GetRange of len 1 at end-1 without materializing whole
-		std::string last = GetRange(end - 1, 1);
-		if (!last.empty() && last[0] == '\n') {
-			end -= 1;
-		}
-	}
-	return GetRange(start, end - start);
-}
-
-
-std::pair<std::size_t, std::size_t>
-PieceTable::ByteOffsetToLineCol(std::size_t byte_offset) const
-{
-	if (byte_offset > total_size_)
-		byte_offset = total_size_;
-	RebuildLineIndex();
-	if (line_index_.empty())
-		return {0, 0};
-	auto it         = std::upper_bound(line_index_.begin(), line_index_.end(), byte_offset);
-	std::size_t row = (it == line_index_.begin()) ? 0 : static_cast<std::size_t>((it - line_index_.begin()) - 1);
-	std::size_t col = byte_offset - line_index_[row];
-	return {row, col};
-}
-
-
-std::size_t
-PieceTable::LineColToByteOffset(std::size_t row, std::size_t col) const
-{
-	RebuildLineIndex();
-	if (line_index_.empty())
-		return 0;
-	if (row >= line_index_.size())
-		return total_size_;
-	std::size_t start = line_index_[row];
-	std::size_t end   = (row + 1 < line_index_.size()) ? line_index_[row + 1] : total_size_;
-	// Clamp col to line length excluding trailing newline
-	if (end > start) {
-		std::string last = GetRange(end - 1, 1);
-		if (!last.empty() && last[0] == '\n') {
-			end -= 1;
-		}
-	}
-	std::size_t target = start + std::min(col, end - start);
-	return target;
-}
-
-
-std::string
-PieceTable::GetRange(std::size_t byte_offset, std::size_t len) const
-{
-	if (byte_offset >= total_size_ || len == 0)
-		return std::string();
-	if (byte_offset + len > total_size_)
-		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 {
-		// Assemble substring directly from pieces without full materialization
-		auto [idx, inner]     = locate(byte_offset);
-		std::size_t remaining = len;
-		while (remaining > 0 && idx < pieces_.size()) {
-			const auto &p          = pieces_[idx];
-			const std::string &src = (p.src == Source::Original) ? original_ : add_;
-			std::size_t take       = std::min<std::size_t>(p.len - inner, remaining);
-			if (take > 0) {
-				const char *base = src.data() + static_cast<std::ptrdiff_t>(p.start + inner);
-				out.append(base, take);
-				remaining -= take;
-				inner     = 0;
-				idx       += 1;
-			} else {
-				break;
-			}
-		}
-	}
-
-	// 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;
-}
-
-
-std::size_t
-PieceTable::Find(const std::string &needle, std::size_t start) const
-{
-	if (needle.empty())
-		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();
-	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
-		find_cache_.valid   = true;
-		find_cache_.version = version_;
-		find_cache_.needle  = needle;
-		find_cache_.start   = start;
-		find_cache_.result  = pos;
-	}
-	return pos;
-}
-
-
-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;
-		const std::string &src = (p.src == Source::Original) ? original_ : add_;
-		const char *base       = src.data() + static_cast<std::ptrdiff_t>(p.start);
-		out.write(base, static_cast<std::streamsize>(p.len));
-	}
-}

PieceTable.h

@@ -1,48 +1,12 @@
 /*
  * PieceTable.h - Alternative to GapBuffer using a piece table representation
- *
- * PieceTable is kte's core text storage data structure. It provides efficient
- * insert/delete operations without copying the entire buffer by maintaining a
- * sequence of "pieces" that reference ranges in two underlying buffers:
- * - original_: Initial file content (currently unused, reserved for future)
- * - add_: All text added during editing
- *
- * Key advantages:
- * - O(1) append/prepend operations (common case)
- * - O(n) insert/delete at arbitrary positions (n = number of pieces, not bytes)
- * - Efficient undo: just restore the piece list
- * - Memory efficient: no gap buffer waste
- *
- * Performance characteristics:
- * - Piece count grows with edit operations; automatic consolidation prevents unbounded growth
- * - Materialization (Data() call) is O(total_size) but cached until next edit
- * - Line index is lazily rebuilt on first line-based query after edits
- * - Range and Find operations use lightweight caches for repeated queries
- *
- * API evolution:
- * 1. Legacy API (GapBuffer compatibility):
- *    - Append/Prepend: Build content sequentially
- *    - Data(): Materialize entire buffer
- *
- * 2. New buffer-wide API (Phase 1):
- *    - Insert/Delete: Edit at arbitrary byte offsets
- *    - Line-based queries: LineCount, GetLine, GetLineRange
- *    - Position conversion: ByteOffsetToLineCol, LineColToByteOffset
- *    - Efficient extraction: GetRange, Find, WriteToStream
- *
- * Implementation notes:
- * - Consolidation heuristics prevent piece fragmentation (configurable via SetConsolidationParams)
- * - Thread-safe for concurrent reads (mutex protects caches and lazy rebuilds)
- * - Version tracking invalidates caches on mutations
  */
-#pragma once
+#ifndef KTE_PIECETABLE_H
+#define KTE_PIECETABLE_H
+
 #include <cstddef>
-#include <cstdint>
 #include <string>
-#include <ostream>
 #include <vector>
-#include <limits>
-#include <mutex>
 
 
 class PieceTable {
@@ -51,12 +15,6 @@ public:
 
 	explicit PieceTable(std::size_t initialCapacity);
 
-	// Advanced constructor allowing configuration of consolidation heuristics
-	PieceTable(std::size_t initialCapacity,
-	           std::size_t piece_limit,
-	           std::size_t small_piece_threshold,
-	           std::size_t max_consolidation_bytes);
-
 	PieceTable(const PieceTable &other);
 
 	PieceTable &operator=(const PieceTable &other);
@@ -112,38 +70,6 @@ public:
 		return materialized_.capacity();
 	}
 
-
-	// ===== New buffer-wide API (Phase 1) =====
-	// Byte-based editing operations
-	void Insert(std::size_t byte_offset, const char *text, std::size_t len);
-
-	void Delete(std::size_t byte_offset, std::size_t len);
-
-	// Line-based queries
-	[[nodiscard]] std::size_t LineCount() const; // number of logical lines
-	[[nodiscard]] std::string GetLine(std::size_t line_num) const;
-
-	[[nodiscard]] std::pair<std::size_t, std::size_t> GetLineRange(std::size_t line_num) const; // [start,end)
-
-	// Position conversion
-	[[nodiscard]] std::pair<std::size_t, std::size_t> ByteOffsetToLineCol(std::size_t byte_offset) const;
-
-	[[nodiscard]] std::size_t LineColToByteOffset(std::size_t row, std::size_t col) const;
-
-	// Substring extraction
-	[[nodiscard]] std::string GetRange(std::size_t byte_offset, std::size_t len) const;
-
-	// Simple search utility; returns byte offset or npos
-	[[nodiscard]] std::size_t Find(const std::string &needle, std::size_t start = 0) const;
-
-	// Stream out content without materializing the entire buffer
-	void WriteToStream(std::ostream &out) const;
-
-	// Heuristic configuration
-	void SetConsolidationParams(std::size_t piece_limit,
-	                            std::size_t small_piece_threshold,
-	                            std::size_t max_consolidation_bytes);
-
 private:
 	enum class Source : unsigned char { Original, Add };
 
@@ -159,63 +85,14 @@ private:
 
 	void materialize() const;
 
-	// Helper: locate piece index and inner offset for a global byte offset
-	[[nodiscard]] std::pair<std::size_t, std::size_t> locate(std::size_t byte_offset) const;
-
-	// Helper: try to coalesce neighboring pieces around index
-	void coalesceNeighbors(std::size_t index);
-
-	// Consolidation helpers and heuristics
-	void maybeConsolidate();
-
-	void consolidateRange(std::size_t start_idx, std::size_t end_idx);
-
-	void appendPieceDataTo(std::string &out, const Piece &p) const;
-
-	// Line index support (rebuilt lazily on demand)
-	void InvalidateLineIndex() const;
-
-	void RebuildLineIndex() const;
-
 	// Underlying storages
 	std::string original_; // unused for builder use-case, but kept for API symmetry
 	std::string add_;
 	std::vector<Piece> pieces_;
 
 	mutable std::string materialized_;
-	mutable bool dirty_ = true;
+	mutable bool dirty_     = true;
-	// Monotonic content version. Increment on any mutation that affects content layout
+	std::size_t total_size_ = 0;
-	mutable std::uint64_t version_ = 0;
-	std::size_t total_size_        = 0;
-
-	// Cached line index: starting byte offset of each line (always contains at least 1 entry: 0)
-	mutable std::vector<std::size_t> line_index_;
-	mutable bool line_index_dirty_ = true;
-
-	// Heuristic knobs
-	std::size_t piece_limit_             = 4096; // trigger consolidation when exceeded
-	std::size_t small_piece_threshold_   = 64; // bytes
-	std::size_t max_consolidation_bytes_ = 4096; // cap per consolidation run
-
-	// Lightweight caches to avoid redundant work when callers query the same range repeatedly
-	struct RangeCache {
-		bool valid            = false;
-		std::uint64_t version = 0;
-		std::size_t off       = 0;
-		std::size_t len       = 0;
-		std::string data;
-	};
-
-	struct FindCache {
-		bool valid            = false;
-		std::uint64_t version = 0;
-		std::string needle;
-		std::size_t start  = 0;
-		std::size_t result = std::numeric_limits<std::size_t>::max();
-	};
-
-	mutable RangeCache range_cache_;
-	mutable FindCache find_cache_;
-
-	mutable std::mutex mutex_;
 };
+
+#endif // KTE_PIECETABLE_H

QtFrontend.cc

@@ -1,983 +0,0 @@
-#include "QtFrontend.h"
-
-#include <QApplication>
-#include <QWidget>
-#include <QKeyEvent>
-#include <QTimer>
-#include <QScreen>
-#include <QFont>
-#include <QFontMetrics>
-#include <QFontDatabase>
-#include <QFileDialog>
-#include <QFontDialog>
-#include <QPainter>
-#include <QPaintEvent>
-#include <QWheelEvent>
-#include <regex>
-
-#include "Editor.h"
-#include "Command.h"
-#include "Buffer.h"
-#include "GUITheme.h"
-#include "Highlight.h"
-
-namespace {
-class MainWindow : public QWidget {
-public:
-	explicit MainWindow(class QtInputHandler &ih, QWidget *parent = nullptr)
-		: QWidget(parent), input_(ih)
-	{
-		// Match ImGui window title format
-		setWindowTitle(QStringLiteral("kge - kyle's graphical editor ")
-		               + QStringLiteral(KTE_VERSION_STR));
-		resize(1280, 800);
-		setFocusPolicy(Qt::StrongFocus);
-	}
-
-
-	bool WasClosed() const
-	{
-		return closed_;
-	}
-
-
-	void SetEditor(Editor *ed)
-	{
-		ed_ = ed;
-	}
-
-
-	void SetFontFamilyAndSize(QString family, int px)
-	{
-		if (family.isEmpty())
-			family = QStringLiteral("Brass Mono");
-		if (px <= 0)
-			px = 18;
-		font_family_ = std::move(family);
-		font_px_     = px;
-		update();
-	}
-
-protected:
-	void keyPressEvent(QKeyEvent *event) override
-	{
-		// Route to editor keymap; if handled, accept and stop propagation so
-		// Qt doesn't trigger any default widget shortcuts.
-		if (input_.ProcessKeyEvent(*event)) {
-			event->accept();
-			return;
-		}
-		QWidget::keyPressEvent(event);
-	}
-
-
-	void paintEvent(QPaintEvent *event) override
-	{
-		Q_UNUSED(event);
-		QPainter p(this);
-		p.setRenderHint(QPainter::TextAntialiasing, true);
-
-		// Colors from GUITheme palette (Qt branch)
-		auto to_qcolor = [](const KteColor &c) -> QColor {
-			int r = int(std::round(c.x * 255.0f));
-			int g = int(std::round(c.y * 255.0f));
-			int b = int(std::round(c.z * 255.0f));
-			int a = int(std::round(c.w * 255.0f));
-			return QColor(r, g, b, a);
-		};
-		const auto pal         = kte::GetPalette();
-		const QColor bg        = to_qcolor(pal.bg);
-		const QColor fg        = to_qcolor(pal.fg);
-		const QColor sel_bg    = to_qcolor(pal.sel_bg);
-		const QColor cur_bg    = to_qcolor(pal.cur_bg);
-		const QColor status_bg = to_qcolor(pal.status_bg);
-		const QColor status_fg = to_qcolor(pal.status_fg);
-
-		// Background
-		p.fillRect(rect(), bg);
-
-		// Font/metrics (configured or defaults)
-		QFont f(font_family_, font_px_);
-		p.setFont(f);
-		QFontMetrics fm(f);
-		const int line_h = fm.height();
-		const int ch_w   = std::max(1, fm.horizontalAdvance(QStringLiteral(" ")));
-
-		// Layout metrics
-		const int pad_l    = 8;
-		const int pad_t    = 6;
-		const int pad_r    = 8;
-		const int pad_b    = 6;
-		const int status_h = line_h + 6; // status bar height
-
-		// Content area (text viewport)
-		const QRect content_rect(pad_l,
-		                         pad_t,
-		                         width() - pad_l - pad_r,
-		                         height() - pad_t - pad_b - status_h);
-
-		// Text viewport occupies all content area (no extra title row)
-		QRect viewport(content_rect.x(), content_rect.y(), content_rect.width(), content_rect.height());
-
-		// Draw buffer contents
-		if (ed_ && viewport.height() > 0 && viewport.width() > 0) {
-			const Buffer *buf = ed_->CurrentBuffer();
-			if (buf) {
-				const std::size_t nrows   = buf->Nrows();
-				const std::size_t rowoffs = buf->Rowoffs();
-				const std::size_t coloffs = buf->Coloffs();
-				const std::size_t cy      = buf->Cury();
-				const std::size_t cx      = buf->Curx();
-
-				// Visible line count
-				const int max_lines        = (line_h > 0) ? (viewport.height() / line_h) : 0;
-				const std::size_t last_row = std::min<std::size_t>(
-					nrows, rowoffs + std::max(0, max_lines));
-
-				// Tab width: follow ImGuiRenderer default of 4
-				const std::size_t tabw = 4;
-
-				// Prepare painter clip to viewport
-				p.save();
-				p.setClipRect(viewport);
-
-				// Iterate visible lines
-				for (std::size_t i = rowoffs, vis_idx = 0; i < last_row; ++i, ++vis_idx) {
-					// Get line as string for regex/iterator usage and general string ops.
-					const std::string line = buf->GetLineString(i);
-					const int y            = viewport.y() + static_cast<int>(vis_idx) * line_h;
-					const int baseline     = y + fm.ascent();
-
-					// Helper: convert src col -> rx with tab expansion
-					auto src_to_rx_line = [&](std::size_t src_col) -> std::size_t {
-						std::size_t rx = 0;
-						for (std::size_t k = 0; k < src_col && k < line.size(); ++k) {
-							rx += (line[k] == '\t') ? (tabw - (rx % tabw)) : 1;
-						}
-						return rx;
-					};
-
-					// Search-match background highlights first (under text)
-					if (ed_->SearchActive() && !ed_->SearchQuery().empty()) {
-						std::vector<std::pair<std::size_t, std::size_t> > hl_src_ranges;
-						// Compute ranges per line (source indices)
-						if (ed_->PromptActive() &&
-						    (ed_->CurrentPromptKind() == Editor::PromptKind::RegexSearch ||
-						     ed_->CurrentPromptKind() ==
-						     Editor::PromptKind::RegexReplaceFind)) {
-							try {
-								std::regex rx(ed_->SearchQuery());
-								for (auto it = std::sregex_iterator(
-									     line.begin(), line.end(), rx);
-								     it != std::sregex_iterator(); ++it) {
-									const auto &m  = *it;
-									std::size_t sx = static_cast<std::size_t>(m.
-										position());
-									std::size_t ex =
-										sx + static_cast<std::size_t>(m.
-											length());
-									hl_src_ranges.emplace_back(sx, ex);
-								}
-							} catch (const std::regex_error &) {
-								// Invalid regex: ignore, status line already shows errors
-							}
-						} else {
-							const std::string &q = ed_->SearchQuery();
-							if (!q.empty()) {
-								std::size_t pos = 0;
-								while ((pos = line.find(q, pos)) != std::string::npos) {
-									hl_src_ranges.emplace_back(pos, pos + q.size());
-									pos += q.size();
-								}
-							}
-						}
-
-						if (!hl_src_ranges.empty()) {
-							const bool has_current =
-								ed_->SearchMatchLen() > 0 && ed_->SearchMatchY() == i;
-							const std::size_t cur_x = has_current ? ed_->SearchMatchX() : 0;
-							const std::size_t cur_end = has_current
-								? (ed_->SearchMatchX() + ed_->SearchMatchLen())
-								: 0;
-							for (const auto &rg: hl_src_ranges) {
-								std::size_t sx   = rg.first, ex = rg.second;
-								std::size_t rx_s = src_to_rx_line(sx);
-								std::size_t rx_e = src_to_rx_line(ex);
-								if (rx_e <= coloffs)
-									continue; // fully left of view
-								int vx0 = viewport.x() + static_cast<int>((
-									          (rx_s > coloffs ? rx_s - coloffs : 0)
-									          * ch_w));
-								int vx1 = viewport.x() + static_cast<int>((
-									          (rx_e - coloffs) * ch_w));
-								QRect r(vx0, y, std::max(0, vx1 - vx0), line_h);
-								if (r.width() <= 0)
-									continue;
-								bool is_current =
-									has_current && sx == cur_x && ex == cur_end;
-								QColor col = is_current
-									             ? QColor(255, 220, 120, 140)
-									             : QColor(200, 200, 0, 90);
-								p.fillRect(r, col);
-							}
-						}
-					}
-
-					// Selection background (if active on this line)
-					if (buf->MarkSet() && (
-						    i == buf->MarkCury() || i == cy || (
-							    i > std::min(buf->MarkCury(), cy) && i < std::max(
-								    buf->MarkCury(), cy)))) {
-						std::size_t sx = 0, ex = 0;
-						if (buf->MarkCury() == i && cy == i) {
-							sx = std::min(buf->MarkCurx(), cx);
-							ex = std::max(buf->MarkCurx(), cx);
-						} else if (i == buf->MarkCury()) {
-							sx = buf->MarkCurx();
-							ex = line.size();
-						} else if (i == cy) {
-							sx = 0;
-							ex = cx;
-						} else {
-							sx = 0;
-							ex = line.size();
-						}
-						std::size_t rx_s = src_to_rx_line(sx);
-						std::size_t rx_e = src_to_rx_line(ex);
-						if (rx_e > coloffs) {
-							int vx0 = viewport.x() + static_cast<int>((rx_s > coloffs
-								          ? rx_s - coloffs
-								          : 0) * ch_w);
-							int vx1 = viewport.x() + static_cast<int>(
-								          (rx_e - coloffs) * ch_w);
-							QRect sel_r(vx0, y, std::max(0, vx1 - vx0), line_h);
-							if (sel_r.width() > 0)
-								p.fillRect(sel_r, sel_bg);
-						}
-					}
-
-					// Build expanded line (tabs -> spaces) for drawing
-					std::string expanded;
-					expanded.reserve(line.size() + 8);
-					std::size_t rx_acc = 0;
-					for (char c: line) {
-						if (c == '\t') {
-							std::size_t adv = (tabw - (rx_acc % tabw));
-							expanded.append(adv, ' ');
-							rx_acc += adv;
-						} else {
-							expanded.push_back(c);
-							rx_acc += 1;
-						}
-					}
-
-					// Syntax highlighting spans or plain text
-					if (buf->SyntaxEnabled() && buf->Highlighter() && buf->Highlighter()->
-					    HasHighlighter()) {
-						kte::LineHighlight lh = buf->Highlighter()->GetLine(
-							*buf, static_cast<int>(i), buf->Version());
-						struct SSpan {
-							std::size_t s;
-							std::size_t e;
-							kte::TokenKind k;
-						};
-						std::vector<SSpan> spans;
-						spans.reserve(lh.spans.size());
-						const std::size_t line_len = line.size();
-						for (const auto &sp: lh.spans) {
-							int s_raw = sp.col_start;
-							int e_raw = sp.col_end;
-							if (e_raw < s_raw)
-								std::swap(e_raw, s_raw);
-							std::size_t s = static_cast<std::size_t>(std::max(
-								0, std::min(s_raw, (int) line_len)));
-							std::size_t e = static_cast<std::size_t>(std::max(
-								(int) s, std::min(e_raw, (int) line_len)));
-							if (s < e)
-								spans.push_back({s, e, sp.kind});
-						}
-						std::sort(spans.begin(), spans.end(),
-						          [](const SSpan &a, const SSpan &b) {
-							          return a.s < b.s;
-						          });
-
-						auto colorFor = [](kte::TokenKind k) -> QColor {
-							// GUITheme provides colors via ImGui vector; avoid direct dependency types
-							const auto v = kte::SyntaxInk(k);
-							return QColor(int(v.x * 255.0f), int(v.y * 255.0f),
-							              int(v.z * 255.0f), int(v.w * 255.0f));
-						};
-
-						// Helper to convert src col to expanded rx
-						auto src_to_rx_full = [&](std::size_t sidx) -> std::size_t {
-							std::size_t rx = 0;
-							for (std::size_t k = 0; k < sidx && k < line.size(); ++k) {
-								rx += (line[k] == '\t') ? (tabw - (rx % tabw)) : 1;
-							}
-							return rx;
-						};
-
-						if (spans.empty()) {
-							// No highlight spans: draw the whole (visible) expanded line in default fg
-							if (coloffs < expanded.size()) {
-								const char *start =
-									expanded.c_str() + static_cast<int>(coloffs);
-								p.setPen(fg);
-								p.drawText(viewport.x(), baseline,
-								           QString::fromUtf8(start));
-							}
-						} else {
-							// Draw colored spans
-							for (const auto &sp: spans) {
-								std::size_t rx_s = src_to_rx_full(sp.s);
-								std::size_t rx_e = src_to_rx_full(sp.e);
-								if (rx_e <= coloffs)
-									continue; // left of viewport
-								std::size_t draw_start = (rx_s > coloffs)
-									? rx_s
-									: coloffs;
-								std::size_t draw_end = std::min<std::size_t>(
-									rx_e, expanded.size());
-								if (draw_end <= draw_start)
-									continue;
-								std::size_t screen_x = draw_start - coloffs;
-								int px = viewport.x() + int(screen_x * ch_w);
-								int len = int(draw_end - draw_start);
-								p.setPen(colorFor(sp.k));
-								p.drawText(px, baseline,
-								           QString::fromUtf8(
-									           expanded.c_str() + draw_start, len));
-							}
-						}
-					} else {
-						// Draw expanded text clipped by coloffs
-						if (static_cast<std::size_t>(coloffs) < expanded.size()) {
-							const char *start =
-								expanded.c_str() + static_cast<int>(coloffs);
-							p.setPen(fg);
-							p.drawText(viewport.x(), baseline, QString::fromUtf8(start));
-						}
-					}
-
-					// Cursor indicator on current line
-					if (i == cy) {
-						std::size_t rx_cur = src_to_rx_line(cx);
-						if (rx_cur >= coloffs) {
-							// Compute exact pixel x by measuring expanded substring [coloffs, rx_cur)
-							std::size_t start = std::min<std::size_t>(
-								coloffs, expanded.size());
-							std::size_t end = std::min<
-								std::size_t>(rx_cur, expanded.size());
-							int px_advance = 0;
-							if (end > start) {
-								const QString sub = QString::fromUtf8(
-									expanded.c_str() + start,
-									static_cast<int>(end - start));
-								px_advance = fm.horizontalAdvance(sub);
-							}
-							int x0 = viewport.x() + px_advance;
-							QRect r(x0, y, ch_w, line_h);
-							p.fillRect(r, cur_bg);
-						}
-					}
-				}
-
-				p.restore();
-			}
-		}
-
-		// Status bar
-		const int bar_y = height() - status_h;
-		QRect status_rect(0, bar_y, width(), status_h);
-		p.fillRect(status_rect, status_bg);
-		p.setPen(status_fg);
-		if (ed_) {
-			const int pad         = 6;
-			const int left_x      = status_rect.x() + pad;
-			const int right_x_max = status_rect.x() + status_rect.width() - pad;
-			const int baseline_y  = bar_y + (status_h + fm.ascent() - fm.descent()) / 2;
-
-			// If a prompt is active, mirror ImGui/TUI: show only the prompt across the bar
-			if (ed_->PromptActive()) {
-				std::string label = ed_->PromptLabel();
-				std::string text  = ed_->PromptText();
-
-				// Map $HOME to ~ for path prompts (Open/Save/Chdir)
-				auto kind = ed_->CurrentPromptKind();
-				if (kind == Editor::PromptKind::OpenFile ||
-				    kind == Editor::PromptKind::SaveAs ||
-				    kind == Editor::PromptKind::Chdir) {
-					const char *home_c = std::getenv("HOME");
-					if (home_c && *home_c) {
-						std::string home(home_c);
-						if (text.rfind(home, 0) == 0) {
-							std::string rest = text.substr(home.size());
-							if (rest.empty())
-								text = "~";
-							else if (!rest.empty() && (rest[0] == '/' || rest[0] == '\\'))
-								text = std::string("~") + rest;
-						}
-					}
-				}
-
-				std::string prefix;
-				if (kind == Editor::PromptKind::Command)
-					prefix = ": ";
-				else if (!label.empty())
-					prefix = label + ": ";
-
-				// Compose text and elide per behavior:
-				const int max_w        = status_rect.width() - 2 * pad;
-				QString qprefix        = QString::fromStdString(prefix);
-				QString qtext          = QString::fromStdString(text);
-				int avail_w            = std::max(0, max_w - fm.horizontalAdvance(qprefix));
-				Qt::TextElideMode mode = Qt::ElideRight;
-				if (kind == Editor::PromptKind::OpenFile ||
-				    kind == Editor::PromptKind::SaveAs ||
-				    kind == Editor::PromptKind::Chdir) {
-					mode = Qt::ElideLeft;
-				}
-				QString shown = fm.elidedText(qtext, mode, avail_w);
-				p.drawText(left_x, baseline_y, qprefix + shown);
-			} else {
-				// Build left segment: app/version, buffer idx/total, filename [+dirty], line count
-				QString left;
-				left += QStringLiteral("kge ");
-				left += QStringLiteral(KTE_VERSION_STR);
-
-				const Buffer *buf = ed_->CurrentBuffer();
-				if (buf) {
-					// buffer index/total
-					std::size_t total = ed_->BufferCount();
-					if (total > 0) {
-						std::size_t idx1 = ed_->CurrentBufferIndex() + 1; // 1-based
-						left             += QStringLiteral("  [");
-						left             += QString::number(static_cast<qlonglong>(idx1));
-						left             += QStringLiteral("/");
-						left             += QString::number(static_cast<qlonglong>(total));
-						left             += QStringLiteral("] ");
-					} else {
-						left += QStringLiteral("  ");
-					}
-
-					// buffer display name
-					std::string disp;
-					try {
-						disp = ed_->DisplayNameFor(*buf);
-					} catch (...) {
-						disp = buf->Filename();
-					}
-					if (disp.empty())
-						disp = "[No Name]";
-					left += QString::fromStdString(disp);
-					if (buf->Dirty())
-						left += QStringLiteral(" *");
-
-					// total lines suffix " <n>L"
-					unsigned long lcount = static_cast<unsigned long>(buf->Rows().size());
-					left                 += QStringLiteral(" ");
-					left                 += QString::number(static_cast<qlonglong>(lcount));
-					left                 += QStringLiteral("L");
-				}
-
-				// Build right segment: cursor and mark
-				QString right;
-				if (buf) {
-					int row1       = static_cast<int>(buf->Cury()) + 1;
-					int col1       = static_cast<int>(buf->Curx()) + 1;
-					bool have_mark = buf->MarkSet();
-					int mrow1      = have_mark ? static_cast<int>(buf->MarkCury()) + 1 : 0;
-					int mcol1      = have_mark ? static_cast<int>(buf->MarkCurx()) + 1 : 0;
-					if (have_mark)
-						right = QString("%1,%2 | M: %3,%4").arg(row1).arg(col1).arg(mrow1).arg(
-							mcol1);
-					else
-						right = QString("%1,%2 | M: not set").arg(row1).arg(col1);
-				}
-
-				// Middle message: status text
-				QString mid = QString::fromStdString(ed_->Status());
-
-				// Measure and layout
-				int left_w  = fm.horizontalAdvance(left);
-				int right_w = fm.horizontalAdvance(right);
-				int lx      = left_x;
-				int rx      = std::max(left_x, right_x_max - right_w);
-
-				// If overlap, elide left to make space for right
-				if (lx + left_w + pad > rx) {
-					int max_left_w = std::max(0, rx - lx - pad);
-					left           = fm.elidedText(left, Qt::ElideRight, max_left_w);
-					left_w         = fm.horizontalAdvance(left);
-				}
-
-				// Draw left and right
-				p.drawText(lx, baseline_y, left);
-				if (!right.isEmpty())
-					p.drawText(rx, baseline_y, right);
-
-				// Middle message clipped between end of left and start of right
-				int mid_left  = lx + left_w + pad;
-				int mid_right = std::max(mid_left, rx - pad);
-				int mid_w     = std::max(0, mid_right - mid_left);
-				if (mid_w > 0 && !mid.isEmpty()) {
-					QString mid_show = fm.elidedText(mid, Qt::ElideRight, mid_w);
-					p.save();
-					p.setClipRect(QRect(mid_left, bar_y, mid_w, status_h));
-					p.drawText(mid_left, baseline_y, mid_show);
-					p.restore();
-				}
-			}
-		}
-	}
-
-
-	void resizeEvent(QResizeEvent *event) override
-	{
-		QWidget::resizeEvent(event);
-		if (!ed_)
-			return;
-		// Update editor dimensions based on new size
-		QFont f(font_family_, font_px_);
-		QFontMetrics fm(f);
-		const int line_h   = std::max(12, fm.height());
-		const int ch_w     = std::max(6, fm.horizontalAdvance(QStringLiteral(" ")));
-		const int pad_l    = 8, pad_r = 8, pad_t = 6, pad_b = 6;
-		const int status_h = line_h + 6;
-		const int avail_w  = std::max(0, width() - pad_l - pad_r);
-		const int avail_h  = std::max(0, height() - pad_t - pad_b - status_h);
-		std::size_t rows   = std::max<std::size_t>(1, (avail_h / line_h));
-		std::size_t cols   = std::max<std::size_t>(1, (avail_w / ch_w));
-		ed_->SetDimensions(rows, cols);
-	}
-
-
-	void wheelEvent(QWheelEvent *event) override
-	{
-		if (!ed_) {
-			QWidget::wheelEvent(event);
-			return;
-		}
-		Buffer *buf = ed_->CurrentBuffer();
-		if (!buf) {
-			QWidget::wheelEvent(event);
-			return;
-		}
-
-		// Recompute metrics to map pixel deltas to rows/cols
-		QFont f(font_family_, font_px_);
-		QFontMetrics fm(f);
-		const int line_h = std::max(12, fm.height());
-		const int ch_w   = std::max(6, fm.horizontalAdvance(QStringLiteral(" ")));
-
-		// Determine scroll intent: use pixelDelta when available (trackpads), otherwise angleDelta
-		QPoint pixel = event->pixelDelta();
-		QPoint angle = event->angleDelta();
-
-		double v_lines_delta = 0.0;
-		double h_cols_delta  = 0.0;
-
-		// Horizontal scroll with Shift or explicit horizontal delta
-		bool horiz_mode = (event->modifiers() & Qt::ShiftModifier) || (!pixel.isNull() && pixel.x() != 0) || (
-			                  !angle.isNull() && angle.x() != 0);
-
-		if (!pixel.isNull()) {
-			// Trackpad smooth scrolling (pixels)
-			v_lines_delta = -static_cast<double>(pixel.y()) / std::max(1, line_h);
-			h_cols_delta  = -static_cast<double>(pixel.x()) / std::max(1, ch_w);
-		} else if (!angle.isNull()) {
-			// Mouse wheel: 120 units per notch; map one notch to 3 lines similar to ImGui UX
-			v_lines_delta = -static_cast<double>(angle.y()) / 120.0 * 3.0;
-			// For horizontal wheels, each notch scrolls 8 columns
-			h_cols_delta = -static_cast<double>(angle.x()) / 120.0 * 8.0;
-		}
-
-		// Accumulate fractional deltas across events
-		v_scroll_accum_ += v_lines_delta;
-		h_scroll_accum_ += h_cols_delta;
-
-		int d_rows = 0;
-		int d_cols = 0;
-		if (std::fabs(v_scroll_accum_) >= 1.0 && (!horiz_mode || std::fabs(v_scroll_accum_) > std::fabs(
-			                                          h_scroll_accum_))) {
-			d_rows          = static_cast<int>(v_scroll_accum_);
-			v_scroll_accum_ -= d_rows;
-		}
-		if (std::fabs(h_scroll_accum_) >= 1.0 && (horiz_mode || std::fabs(h_scroll_accum_) >= std::fabs(
-			                                          v_scroll_accum_))) {
-			d_cols          = static_cast<int>(h_scroll_accum_);
-			h_scroll_accum_ -= d_cols;
-		}
-
-		if (d_rows != 0 || d_cols != 0) {
-			std::size_t new_rowoffs = buf->Rowoffs();
-			std::size_t new_coloffs = buf->Coloffs();
-			// Clamp vertical between 0 and last row (leaving at least one visible line)
-			if (d_rows != 0) {
-				long nr = static_cast<long>(new_rowoffs) + d_rows;
-				if (nr < 0)
-					nr = 0;
-				const auto nrows = static_cast<long>(buf->Rows().size());
-				if (nr > std::max(0L, nrows - 1))
-					nr = std::max(0L, nrows - 1);
-				new_rowoffs = static_cast<std::size_t>(nr);
-			}
-			if (d_cols != 0) {
-				long nc = static_cast<long>(new_coloffs) + d_cols;
-				if (nc < 0)
-					nc = 0;
-				new_coloffs = static_cast<std::size_t>(nc);
-			}
-			buf->SetOffsets(new_rowoffs, new_coloffs);
-			update();
-			event->accept();
-			return;
-		}
-
-		QWidget::wheelEvent(event);
-	}
-
-
-	void closeEvent(QCloseEvent *event) override
-	{
-		closed_ = true;
-		QWidget::closeEvent(event);
-	}
-
-private:
-	QtInputHandler &input_;
-	bool closed_           = false;
-	Editor *ed_            = nullptr;
-	double v_scroll_accum_ = 0.0;
-	double h_scroll_accum_ = 0.0;
-	QString font_family_   = QStringLiteral("Brass Mono");
-	int font_px_           = 18;
-};
-} // namespace
-
-bool
-GUIFrontend::Init(int &argc, char **argv, Editor &ed)
-{
-	app_ = new QApplication(argc, argv);
-
-	window_ = new MainWindow(input_);
-	window_->show();
-	// Ensure the window becomes the active, focused window so it receives key events
-	window_->activateWindow();
-	window_->raise();
-	window_->setFocus(Qt::OtherFocusReason);
-
-	renderer_.Attach(window_);
-	input_.Attach(&ed);
-	if (auto *mw = dynamic_cast<MainWindow *>(window_))
-		mw->SetEditor(&ed);
-
-	// Load GUI configuration (kge.ini) and configure font for Qt
-	config_ = GUIConfig::Load();
-
-	// Apply background mode from config to match ImGui frontend behavior
-	if (config_.background == "light")
-		kte::SetBackgroundMode(kte::BackgroundMode::Light);
-	else
-		kte::SetBackgroundMode(kte::BackgroundMode::Dark);
-
-	// Apply theme by name for Qt palette-based theming (maps to named palettes).
-	// If unknown, falls back to the generic light/dark palette.
-	(void) kte::ApplyQtThemeByName(config_.theme);
-	if (window_)
-		window_->update();
-
-	// Map GUIConfig font name to a system family (Qt uses installed fonts)
-	auto choose_family = [](const std::string &name) -> QString {
-		QString fam;
-		std::string n = name;
-		std::transform(n.begin(), n.end(), n.begin(), [](unsigned char c) {
-			return (char) std::tolower(c);
-		});
-		if (n.empty() || n == "default" || n == "brassmono" || n == "brassmonocode") {
-			fam = QStringLiteral("Brass Mono");
-		} else if (n == "jetbrains" || n == "jetbrains mono" || n == "jetbrains-mono") {
-			fam = QStringLiteral("JetBrains Mono");
-		} else if (n == "iosevka") {
-			fam = QStringLiteral("Iosevka");
-		} else if (n == "inconsolata" || n == "inconsolataex") {
-			fam = QStringLiteral("Inconsolata");
-		} else if (n == "space" || n == "spacemono" || n == "space mono") {
-			fam = QStringLiteral("Space Mono");
-		} else if (n == "go") {
-			fam = QStringLiteral("Go Mono");
-		} else if (n == "ibm" || n == "ibm plex mono" || n == "ibm-plex-mono") {
-			fam = QStringLiteral("IBM Plex Mono");
-		} else if (n == "fira" || n == "fira code" || n == "fira-code") {
-			fam = QStringLiteral("Fira Code");
-		} else if (!name.empty()) {
-			fam = QString::fromStdString(name);
-		}
-
-		// Validate availability; choose a fallback if needed
-		const auto families = QFontDatabase::families();
-		if (!fam.isEmpty() && families.contains(fam)) {
-			return fam;
-		}
-		// Preferred fallback chain on macOS; otherwise, try common monospace families
-		const QStringList fallbacks = {
-			QStringLiteral("Brass Mono"),
-			QStringLiteral("JetBrains Mono"),
-			QStringLiteral("SF Mono"),
-			QStringLiteral("Menlo"),
-			QStringLiteral("Monaco"),
-			QStringLiteral("Courier New"),
-			QStringLiteral("Courier"),
-			QStringLiteral("Monospace")
-		};
-		for (const auto &fb: fallbacks) {
-			if (families.contains(fb))
-				return fb;
-		}
-		// As a last resort, return the request (Qt will substitute)
-		return fam.isEmpty() ? QStringLiteral("Monospace") : fam;
-	};
-
-	QString family = choose_family(config_.font);
-	int px_size    = (config_.font_size > 0.0f) ? (int) std::lround(config_.font_size) : 18;
-	if (auto *mw = dynamic_cast<MainWindow *>(window_)) {
-		mw->SetFontFamilyAndSize(family, px_size);
-	}
-	// Track current font in globals for command/status queries
-	kte::gCurrentFontFamily = family.toStdString();
-	kte::gCurrentFontSize   = static_cast<float>(px_size);
-
-	// Set initial dimensions based on font metrics
-	QFont f(family, px_size);
-	QFontMetrics fm(f);
-	const int line_h   = std::max(12, fm.height());
-	const int ch_w     = std::max(6, fm.horizontalAdvance(QStringLiteral("M")));
-	const int w        = window_->width();
-	const int h        = window_->height();
-	const int pad      = 16;
-	const int status_h = line_h + 4;
-	const int avail_w  = std::max(0, w - 2 * pad);
-	const int avail_h  = std::max(0, h - 2 * pad - status_h);
-	std::size_t rows   = std::max<std::size_t>(1, (avail_h / line_h) + 1); // + status
-	std::size_t cols   = std::max<std::size_t>(1, (avail_w / ch_w));
-	ed.SetDimensions(rows, cols);
-
-	return true;
-}
-
-
-void
-GUIFrontend::Step(Editor &ed, bool &running)
-{
-	// Pump Qt events
-	if (app_)
-		app_->processEvents();
-
-	// Allow deferred opens (including swap recovery prompts) to run.
-	ed.ProcessPendingOpens();
-
-	// Drain input queue
-	for (;;) {
-		MappedInput mi;
-		if (!input_.Poll(mi))
-			break;
-		if (mi.hasCommand) {
-			Execute(ed, mi.id, mi.arg, mi.count);
-		}
-	}
-
-	if (ed.QuitRequested()) {
-		running = false;
-	}
-
-	// --- Visual File Picker (Qt): invoked via CommandId::VisualFilePickerToggle ---
-	if (ed.FilePickerVisible()) {
-		QString startDir;
-		if (!ed.FilePickerDir().empty()) {
-			startDir = QString::fromStdString(ed.FilePickerDir());
-		}
-		QFileDialog dlg(window_, QStringLiteral("Open File"), startDir);
-		dlg.setFileMode(QFileDialog::ExistingFile);
-		if (dlg.exec() == QDialog::Accepted) {
-			const QStringList files = dlg.selectedFiles();
-			if (!files.isEmpty()) {
-				const QString fp = files.front();
-				ed.RequestOpenFile(fp.toStdString());
-				(void) ed.ProcessPendingOpens();
-				// Update picker dir for next time
-				QFileInfo info(fp);
-				ed.SetFilePickerDir(info.dir().absolutePath().toStdString());
-			}
-		}
-		// Close picker overlay regardless of outcome
-		ed.SetFilePickerVisible(false);
-		if (window_)
-			window_->update();
-	}
-
-	// Apply any queued theme change requests (from command handler)
-	if (kte::gThemeChangePending) {
-		if (!kte::gThemeChangeRequest.empty()) {
-			// Apply Qt palette theme by name; if unknown, keep current palette
-			(void) kte::ApplyQtThemeByName(kte::gThemeChangeRequest);
-		}
-		kte::gThemeChangePending = false;
-		kte::gThemeChangeRequest.clear();
-		if (window_)
-			window_->update();
-	}
-
-	// Visual font picker request (Qt only)
-	if (kte::gFontDialogRequested) {
-		// Seed initial font from current or default
-		QFont seed;
-		if (!kte::gCurrentFontFamily.empty()) {
-			seed = QFont(QString::fromStdString(kte::gCurrentFontFamily),
-			             (int) std::lround(kte::gCurrentFontSize > 0 ? kte::gCurrentFontSize : 18));
-		} else {
-			seed = window_ ? window_->font() : QFont();
-		}
-		bool ok            = false;
-		const QFont chosen = QFontDialog::getFont(&ok, seed, window_, QStringLiteral("Choose Editor Font"));
-		if (ok) {
-			// Queue font change via existing hooks
-			kte::gFontFamilyRequest = chosen.family().toStdString();
-			// Use pixel size if available, otherwise convert from point size approximately
-			int px = chosen.pixelSize();
-			if (px <= 0) {
-				// Approximate points to pixels (96 DPI assumption); Qt will rasterize appropriately
-				px = (int) std::lround(chosen.pointSizeF() * 96.0 / 72.0);
-				if (px <= 0)
-					px = 18;
-			}
-			kte::gFontSizeRequest   = static_cast<float>(px);
-			kte::gFontChangePending = true;
-		}
-		kte::gFontDialogRequested = false;
-		if (window_)
-			window_->update();
-	}
-
-	// Apply any queued font change requests (Qt)
-	if (kte::gFontChangePending) {
-		// Derive target family
-		auto map_family = [](const std::string &name) -> QString {
-			std::string n = name;
-			std::transform(n.begin(), n.end(), n.begin(), [](unsigned char c) {
-				return (char) std::tolower(c);
-			});
-			QString fam;
-			if (n == "brass" || n == "brassmono" || n == "brass mono") {
-				fam = QStringLiteral("Brass Mono");
-			} else if (n == "jetbrains" || n == "jetbrains mono" || n == "jetbrains-mono") {
-				fam = QStringLiteral("JetBrains Mono");
-			} else if (n == "iosevka") {
-				fam = QStringLiteral("Iosevka");
-			} else if (n == "inconsolata" || n == "inconsolataex") {
-				fam = QStringLiteral("Inconsolata");
-			} else if (n == "space" || n == "spacemono" || n == "space mono") {
-				fam = QStringLiteral("Space Mono");
-			} else if (n == "go") {
-				fam = QStringLiteral("Go Mono");
-			} else if (n == "ibm" || n == "ibm plex mono" || n == "ibm-plex-mono") {
-				fam = QStringLiteral("IBM Plex Mono");
-			} else if (n == "fira" || n == "fira code" || n == "fira-code") {
-				fam = QStringLiteral("Fira Code");
-			} else if (!name.empty()) {
-				fam = QString::fromStdString(name);
-			}
-			// Validate availability; choose fallback if needed
-			const auto families = QFontDatabase::families();
-			if (!fam.isEmpty() && families.contains(fam)) {
-				return fam;
-			}
-			// Fallback chain
-			const QStringList fallbacks = {
-				QStringLiteral("Brass Mono"),
-				QStringLiteral("JetBrains Mono"),
-				QStringLiteral("SF Mono"),
-				QStringLiteral("Menlo"),
-				QStringLiteral("Monaco"),
-				QStringLiteral("Courier New"),
-				QStringLiteral("Courier"),
-				QStringLiteral("Monospace")
-			};
-			for (const auto &fb: fallbacks) {
-				if (families.contains(fb))
-					return fb;
-			}
-			return fam.isEmpty() ? QStringLiteral("Monospace") : fam;
-		};
-
-		QString target_family;
-		if (!kte::gFontFamilyRequest.empty()) {
-			target_family = map_family(kte::gFontFamilyRequest);
-		} else if (!kte::gCurrentFontFamily.empty()) {
-			target_family = QString::fromStdString(kte::gCurrentFontFamily);
-		}
-		int target_px = 0;
-		if (kte::gFontSizeRequest > 0.0f) {
-			target_px = (int) std::lround(kte::gFontSizeRequest);
-		} else if (kte::gCurrentFontSize > 0.0f) {
-			target_px = (int) std::lround(kte::gCurrentFontSize);
-		}
-		if (target_px <= 0)
-			target_px = 18;
-		if (target_family.isEmpty())
-			target_family = QStringLiteral("Monospace");
-
-		if (auto *mw = dynamic_cast<MainWindow *>(window_)) {
-			mw->SetFontFamilyAndSize(target_family, target_px);
-		}
-		// Update globals
-		kte::gCurrentFontFamily = target_family.toStdString();
-		kte::gCurrentFontSize   = static_cast<float>(target_px);
-		// Reset requests
-		kte::gFontChangePending = false;
-		kte::gFontFamilyRequest.clear();
-		kte::gFontSizeRequest = 0.0f;
-
-		// Recompute editor dimensions to match new metrics
-		QFont f(target_family, target_px);
-		QFontMetrics fm(f);
-		const int line_h   = std::max(12, fm.height());
-		const int ch_w     = std::max(6, fm.horizontalAdvance(QStringLiteral("M")));
-		const int w        = window_ ? window_->width() : 0;
-		const int h        = window_ ? window_->height() : 0;
-		const int pad      = 16;
-		const int status_h = line_h + 4;
-		const int avail_w  = std::max(0, w - 2 * pad);
-		const int avail_h  = std::max(0, h - 2 * pad - status_h);
-		std::size_t rows   = std::max<std::size_t>(1, (avail_h / line_h) + 1); // + status
-		std::size_t cols   = std::max<std::size_t>(1, (avail_w / ch_w));
-		ed.SetDimensions(rows, cols);
-
-		if (window_)
-			window_->update();
-	}
-
-	// Draw current frame (request repaint)
-	renderer_.Draw(ed);
-
-	// Detect window close
-	if (auto *mw = dynamic_cast<MainWindow *>(window_)) {
-		if (mw->WasClosed()) {
-			running = false;
-		}
-	}
-}
-
-
-void
-GUIFrontend::Shutdown()
-{
-	if (window_) {
-		window_->close();
-		delete window_;
-		window_ = nullptr;
-	}
-	if (app_) {
-		delete app_;
-		app_ = nullptr;
-	}
-}

QtFrontend.h

@@ -1,36 +0,0 @@
-/*
- * QtFrontend - couples QtInputHandler + QtRenderer and owns Qt lifecycle
- */
-#pragma once
-
-#include "Frontend.h"
-#include "GUIConfig.h"
-#include "QtInputHandler.h"
-#include "QtRenderer.h"
-
-class QApplication;
-class QWidget;
-
-// Keep the public class name GUIFrontend to match main.cc selection logic.
-class GUIFrontend final : public Frontend {
-public:
-	GUIFrontend() = default;
-
-	~GUIFrontend() override = default;
-
-	bool Init(int &argc, char **argv, Editor &ed) override;
-
-	void Step(Editor &ed, bool &running) override;
-
-	void Shutdown() override;
-
-private:
-	GUIConfig config_{};
-	QtInputHandler input_{};
-	QtRenderer renderer_{};
-
-	QApplication *app_ = nullptr; // owned
-	QWidget *window_   = nullptr; // owned
-	int width_         = 1280;
-	int height_        = 800;
-};

QtInputHandler.cc

@@ -1,536 +0,0 @@
-// Refactor: route all key processing through command subsystem, mirroring ImGuiInputHandler
-
-#include "QtInputHandler.h"
-
-#include <QKeyEvent>
-
-#include <ncurses.h>
-
-#include "Editor.h"
-#include "KKeymap.h"
-
-// Temporary verbose logging to debug macOS Qt key translation issues
-// Default to off; enable by defining QT_IH_DEBUG=1 at compile time when needed.
-#ifndef QT_IH_DEBUG
-#define QT_IH_DEBUG 0
-#endif
-
-#if QT_IH_DEBUG
-#include <cstdio>
-static const char *
-mods_str(Qt::KeyboardModifiers m)
-{
-	static thread_local char buf[64];
-	buf[0]     = '\0';
-	bool first = true;
-	auto add   = [&](const char *s) {
-		if (!first)
-			std::snprintf(buf + std::strlen(buf), sizeof(buf) - std::strlen(buf), "|");
-		std::snprintf(buf + std::strlen(buf), sizeof(buf) - std::strlen(buf), "%s", s);
-		first = false;
-	};
-	if (m & Qt::ShiftModifier)
-		add("Shift");
-	if (m & Qt::ControlModifier)
-		add("Ctrl");
-	if (m & Qt::AltModifier)
-		add("Alt");
-	if (m & Qt::MetaModifier)
-		add("Meta");
-	if (first)
-		std::snprintf(buf, sizeof(buf), "none");
-	return buf;
-}
-#define LOGF(...) std::fprintf(stderr, __VA_ARGS__)
-#else
-#define LOGF(...) ((void)0)
-#endif
-
-static bool
-IsPrintableQt(const QKeyEvent &e)
-{
-	// Printable if it yields non-empty text and no Ctrl/Meta modifier
-	if (e.modifiers() & (Qt::ControlModifier | Qt::MetaModifier))
-		return false;
-	const QString t = e.text();
-	return !t.isEmpty() && !t.at(0).isNull();
-}
-
-
-static int
-ToAsciiKey(const QKeyEvent &e)
-{
-	const QString t = e.text();
-	if (!t.isEmpty()) {
-		const QChar c = t.at(0);
-		if (!c.isNull())
-			return KLowerAscii(c.unicode());
-	}
-	// When modifiers (like Control) are held, Qt::text() can be empty on macOS.
-	// Fall back to mapping common virtual keys to ASCII.
-	switch (e.key()) {
-	case Qt::Key_A:
-		return 'a';
-	case Qt::Key_B:
-		return 'b';
-	case Qt::Key_C:
-		return 'c';
-	case Qt::Key_D:
-		return 'd';
-	case Qt::Key_E:
-		return 'e';
-	case Qt::Key_F:
-		return 'f';
-	case Qt::Key_G:
-		return 'g';
-	case Qt::Key_H:
-		return 'h';
-	case Qt::Key_I:
-		return 'i';
-	case Qt::Key_J:
-		return 'j';
-	case Qt::Key_K:
-		return 'k';
-	case Qt::Key_L:
-		return 'l';
-	case Qt::Key_M:
-		return 'm';
-	case Qt::Key_N:
-		return 'n';
-	case Qt::Key_O:
-		return 'o';
-	case Qt::Key_P:
-		return 'p';
-	case Qt::Key_Q:
-		return 'q';
-	case Qt::Key_R:
-		return 'r';
-	case Qt::Key_S:
-		return 's';
-	case Qt::Key_T:
-		return 't';
-	case Qt::Key_U:
-		return 'u';
-	case Qt::Key_V:
-		return 'v';
-	case Qt::Key_W:
-		return 'w';
-	case Qt::Key_X:
-		return 'x';
-	case Qt::Key_Y:
-		return 'y';
-	case Qt::Key_Z:
-		return 'z';
-	case Qt::Key_0:
-		return '0';
-	case Qt::Key_1:
-		return '1';
-	case Qt::Key_2:
-		return '2';
-	case Qt::Key_3:
-		return '3';
-	case Qt::Key_4:
-		return '4';
-	case Qt::Key_5:
-		return '5';
-	case Qt::Key_6:
-		return '6';
-	case Qt::Key_7:
-		return '7';
-	case Qt::Key_8:
-		return '8';
-	case Qt::Key_9:
-		return '9';
-	case Qt::Key_Comma:
-		return ',';
-	case Qt::Key_Period:
-		return '.';
-	case Qt::Key_Semicolon:
-		return ';';
-	case Qt::Key_Apostrophe:
-		return '\'';
-	case Qt::Key_Minus:
-		return '-';
-	case Qt::Key_Equal:
-		return '=';
-	case Qt::Key_Slash:
-		return '/';
-	case Qt::Key_Backslash:
-		return '\\';
-	case Qt::Key_BracketLeft:
-		return '[';
-	case Qt::Key_BracketRight:
-		return ']';
-	case Qt::Key_QuoteLeft:
-		return '`';
-	case Qt::Key_Space:
-		return ' ';
-	default:
-		break;
-	}
-	return 0;
-}
-
-
-// Case-preserving ASCII derivation for k-prefix handling where we need to
-// distinguish between 'C' and 'c'. Falls back to virtual-key mapping if
-// event text is unavailable (common when Control/Meta held on macOS).
-static int
-ToAsciiKeyPreserveCase(const QKeyEvent &e)
-{
-	const QString t = e.text();
-	if (!t.isEmpty()) {
-		const QChar c = t.at(0);
-		if (!c.isNull())
-			return c.unicode();
-	}
-	// Fall back to virtual key mapping (letters as uppercase A..Z)
-	switch (e.key()) {
-	case Qt::Key_A:
-		return 'A';
-	case Qt::Key_B:
-		return 'B';
-	case Qt::Key_C:
-		return 'C';
-	case Qt::Key_D:
-		return 'D';
-	case Qt::Key_E:
-		return 'E';
-	case Qt::Key_F:
-		return 'F';
-	case Qt::Key_G:
-		return 'G';
-	case Qt::Key_H:
-		return 'H';
-	case Qt::Key_I:
-		return 'I';
-	case Qt::Key_J:
-		return 'J';
-	case Qt::Key_K:
-		return 'K';
-	case Qt::Key_L:
-		return 'L';
-	case Qt::Key_M:
-		return 'M';
-	case Qt::Key_N:
-		return 'N';
-	case Qt::Key_O:
-		return 'O';
-	case Qt::Key_P:
-		return 'P';
-	case Qt::Key_Q:
-		return 'Q';
-	case Qt::Key_R:
-		return 'R';
-	case Qt::Key_S:
-		return 'S';
-	case Qt::Key_T:
-		return 'T';
-	case Qt::Key_U:
-		return 'U';
-	case Qt::Key_V:
-		return 'V';
-	case Qt::Key_W:
-		return 'W';
-	case Qt::Key_X:
-		return 'X';
-	case Qt::Key_Y:
-		return 'Y';
-	case Qt::Key_Z:
-		return 'Z';
-	case Qt::Key_Comma:
-		return ',';
-	case Qt::Key_Period:
-		return '.';
-	case Qt::Key_Semicolon:
-		return ';';
-	case Qt::Key_Apostrophe:
-		return '\'';
-	case Qt::Key_Minus:
-		return '-';
-	case Qt::Key_Equal:
-		return '=';
-	case Qt::Key_Slash:
-		return '/';
-	case Qt::Key_Backslash:
-		return '\\';
-	case Qt::Key_BracketLeft:
-		return '[';
-	case Qt::Key_BracketRight:
-		return ']';
-	case Qt::Key_QuoteLeft:
-		return '`';
-	case Qt::Key_Space:
-		return ' ';
-	default:
-		break;
-	}
-	return 0;
-}
-
-
-bool
-QtInputHandler::ProcessKeyEvent(const QKeyEvent &e)
-{
-	const Qt::KeyboardModifiers mods = e.modifiers();
-	LOGF("[QtIH] keyPress key=0x%X mods=%s text='%s' k_prefix=%d k_ctrl_pending=%d esc_meta=%d\n",
-	     e.key(), mods_str(mods), e.text().toUtf8().constData(), (int)k_prefix_, (int)k_ctrl_pending_,
-	     (int)esc_meta_);
-
-	// Control-chord detection: only treat the physical Control key as control-like.
-	// Do NOT include Meta (Command) here so that ⌘-letter shortcuts do not fall into
-	// the Ctrl map (prevents ⌘-T being mistaken for C-t).
-	const bool ctrl_like = (mods & Qt::ControlModifier);
-
-	// 1) Universal argument digits (when active), consume digits without enqueuing commands
-	if (ed_ && ed_
-
-	    ->
-	    UArg() != 0
-	) {
-		if (!(mods & (Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier))) {
-			if (e.key() >= Qt::Key_0 && e.key() <= Qt::Key_9) {
-				int d = e.key() - Qt::Key_0;
-				ed_->UArgDigit(d);
-				// request status refresh
-				std::lock_guard<std::mutex> lk(mu_);
-				q_.push(MappedInput{true, CommandId::UArgStatus, std::string(), 0});
-				LOGF("[QtIH] UArg digit %d -> enqueue UArgStatus\n", d);
-				return true;
-			}
-		}
-	}
-
-	// 2) Enter k-prefix on C-k
-	if (ctrl_like && (e.key() == Qt::Key_K)) {
-		k_prefix_       = true;
-		k_ctrl_pending_ = false;
-		LOGF("[QtIH] Enter KPrefix\n");
-		std::lock_guard<std::mutex> lk(mu_);
-		q_.push(MappedInput{true, CommandId::KPrefix, std::string(), 0});
-		return true;
-	}
-
-	// 3) If currently in k-prefix, resolve next key via KLookupKCommand
-	if (k_prefix_) {
-		// ESC/meta prefix should not interfere with k-suffix resolution
-		esc_meta_ = false;
-		// Support literal 'C' (uppercase) or '^' to indicate the next key is Ctrl-qualified.
-		// Use case-preserving derivation so that 'c' (lowercase) can still be a valid suffix
-		// like C-k c (BufferClose).
-		int ascii_raw = ToAsciiKeyPreserveCase(e);
-		if (ascii_raw == 'C' || ascii_raw == '^') {
-			k_ctrl_pending_ = true;
-			if (ed_)
-				ed_->SetStatus("C-k C _");
-			LOGF("[QtIH] KPrefix: set k_ctrl_pending via '%c'\n", (ascii_raw == 'C') ? 'C' : '^');
-			return true; // consume, wait for next key
-		}
-		int ascii_key = (ascii_raw != 0) ? ascii_raw : ToAsciiKey(e);
-		int lower     = KLowerAscii(ascii_key);
-		// Only pass a control suffix for specific supported keys (d/x/q),
-		// matching ImGui behavior so that holding Ctrl during the suffix
-		// doesn't break other mappings like C-k c (BufferClose).
-		bool ctrl_suffix_supported = (lower == 'd' || lower == 'x' || lower == 'q');
-		bool pass_ctrl             = (ctrl_like || k_ctrl_pending_) && ctrl_suffix_supported;
-		k_ctrl_pending_            = false; // consume pending qualifier on any suffix
-		LOGF("[QtIH] KPrefix: ascii_key=%d lower=%d pass_ctrl=%d\n", ascii_key, lower, (int)pass_ctrl);
-		if (ascii_key != 0) {
-			CommandId id;
-			if (KLookupKCommand(ascii_key, pass_ctrl, id)) {
-				LOGF("[QtIH] KPrefix: mapped to command id=%d\n", (int)id);
-				std::lock_guard<std::mutex> lk(mu_);
-				q_.push(MappedInput{true, id, std::string(), 0});
-			} else {
-				// Unknown k-command: notify
-				std::string a;
-				a.push_back(static_cast<char>(ascii_key));
-				LOGF("[QtIH] KPrefix: unknown command for '%c'\n", (char)ascii_key);
-				std::lock_guard<std::mutex> lk(mu_);
-				q_.push(MappedInput{true, CommandId::UnknownKCommand, a, 0});
-			}
-			k_prefix_ = false;
-			return true;
-		}
-		// If not resolvable, consume and exit k-prefix
-		k_prefix_ = false;
-		LOGF("[QtIH] KPrefix: unresolved key; exiting prefix\n");
-		return true;
-	}
-
-	// 3.5) GUI shortcut: Command/Meta + T opens the visual font picker (Qt only).
-	// Require Meta present and Control NOT present so Ctrl-T never triggers this.
-	if ((mods & Qt::MetaModifier) && !(mods & Qt::ControlModifier) && e.key() == Qt::Key_T) {
-		LOGF("[QtIH] Meta/Super-T -> VisualFontPickerToggle\n");
-		std::lock_guard<std::mutex> lk(mu_);
-		q_.push(MappedInput{true, CommandId::VisualFontPickerToggle, std::string(), 0});
-		return true;
-	}
-
-	// 4) ESC as Meta prefix (set state). Alt/Meta chord handled below directly.
-	if (e.key() == Qt::Key_Escape) {
-		esc_meta_ = true;
-		LOGF("[QtIH] ESC: set esc_meta\n");
-		return true; // consumed
-	}
-
-	// 5) Alt/Meta bindings (ESC f/b equivalent). Handle either Alt/Meta or pending esc_meta_
-	// ESC/meta chords: on macOS, do NOT treat Meta as ESC; only Alt (Option) should trigger.
-#if defined(__APPLE__)
-	if (esc_meta_ || (mods & Qt::AltModifier)) {
-#else
-		if (esc_meta_ || (mods & (Qt::AltModifier | Qt::MetaModifier))) {
-
-#endif
-		int ascii_key = 0;
-		if (e.key() == Qt::Key_Backspace) {
-			ascii_key = KEY_BACKSPACE;
-		} else if (e.key() >= Qt::Key_A && e.key() <= Qt::Key_Z) {
-			ascii_key = 'a' + (e.key() - Qt::Key_A);
-		} else if (e.key() == Qt::Key_Comma) {
-			ascii_key = '<';
-		} else if (e.key() == Qt::Key_Period) {
-			ascii_key = '>';
-		}
-		// If still unknown, try deriving from text (covers digits, punctuation, locale)
-		if (ascii_key == 0) {
-			ascii_key = ToAsciiKey(e);
-		}
-		esc_meta_ = false; // one-shot regardless
-		if (ascii_key != 0) {
-			ascii_key = KLowerAscii(ascii_key);
-			CommandId id;
-			if (KLookupEscCommand(ascii_key, id)) {
-				LOGF("[QtIH] ESC/Meta: mapped '%d' -> id=%d\n", ascii_key, (int)id);
-				std::lock_guard<std::mutex> lk(mu_);
-				q_.push(MappedInput{true, id, std::string(), 0});
-				return true;
-			} else {
-				// Report invalid ESC sequence just like ImGui path
-				LOGF("[QtIH] ESC/Meta: unknown command for ascii=%d\n", ascii_key);
-				std::lock_guard<std::mutex> lk(mu_);
-				q_.push(MappedInput{true, CommandId::UnknownEscCommand, std::string(), 0});
-				return true;
-			}
-		}
-		// Nothing derivable: consume (ESC prefix cleared) and do not insert text
-		return true;
-	}
-
-	// 6) Control-chord direct mappings (e.g., C-n/C-p/C-f/C-b...)
-	if (ctrl_like) {
-		// Universal argument handling: C-u starts collection; C-g cancels
-		if (e.key() == Qt::Key_U) {
-			if (ed_)
-				ed_->UArgStart();
-			LOGF("[QtIH] Ctrl-chord: start universal argument\n");
-			return true;
-		}
-		if (e.key() == Qt::Key_G) {
-			if (ed_)
-				ed_->UArgClear();
-			k_ctrl_pending_ = false;
-			k_prefix_       = false;
-			LOGF("[QtIH] Ctrl-chord: cancel universal argument and k-prefix via C-g\n");
-			// Fall through to map C-g to Refresh via ctrl map
-		}
-		if (e.key() >= Qt::Key_A && e.key() <= Qt::Key_Z) {
-			int ascii_key = 'a' + (e.key() - Qt::Key_A);
-			CommandId id;
-			if (KLookupCtrlCommand(ascii_key, id)) {
-				LOGF("[QtIH] Ctrl-chord: 'C-%c' -> id=%d\n", (char)ascii_key, (int)id);
-				std::lock_guard<std::mutex> lk(mu_);
-				q_.push(MappedInput{true, id, std::string(), 0});
-				return true;
-			}
-		}
-		// If no mapping, continue to allow other keys below
-	}
-
-	// 7) Special navigation/edit keys (match ImGui behavior)
-	{
-		CommandId id;
-		bool has = false;
-		switch (e.key()) {
-		case Qt::Key_Return:
-		case Qt::Key_Enter:
-			id = CommandId::Newline;
-			has = true;
-			break;
-		case Qt::Key_Backspace:
-			id = CommandId::Backspace;
-			has = true;
-			break;
-		case Qt::Key_Delete:
-			id = CommandId::DeleteChar;
-			has = true;
-			break;
-		case Qt::Key_Left:
-			id = CommandId::MoveLeft;
-			has = true;
-			break;
-		case Qt::Key_Right:
-			id = CommandId::MoveRight;
-			has = true;
-			break;
-		case Qt::Key_Up:
-			id = CommandId::MoveUp;
-			has = true;
-			break;
-		case Qt::Key_Down:
-			id = CommandId::MoveDown;
-			has = true;
-			break;
-		case Qt::Key_Home:
-			id = CommandId::MoveHome;
-			has = true;
-			break;
-		case Qt::Key_End:
-			id = CommandId::MoveEnd;
-			has = true;
-			break;
-		case Qt::Key_PageUp:
-			id = CommandId::PageUp;
-			has = true;
-			break;
-		case Qt::Key_PageDown:
-			id = CommandId::PageDown;
-			has = true;
-			break;
-		default:
-			break;
-		}
-		if (has) {
-			LOGF("[QtIH] Special key -> id=%d\n", (int)id);
-			std::lock_guard<std::mutex> lk(mu_);
-			q_.push(MappedInput{true, id, std::string(), 0});
-			return true;
-		}
-	}
-
-	// 8) Insert printable text
-	if (IsPrintableQt(e)) {
-		std::string s = e.text().toStdString();
-		if (!s.empty()) {
-			LOGF("[QtIH] InsertText '%s'\n", s.c_str());
-			std::lock_guard<std::mutex> lk(mu_);
-			q_.push(MappedInput{true, CommandId::InsertText, s, 0});
-			return true;
-		}
-	}
-
-	LOGF("[QtIH] Unhandled key\n");
-	return false;
-}
-
-
-bool
-QtInputHandler::Poll(MappedInput &out)
-{
-	std::lock_guard<std::mutex> lock(mu_);
-	if (q_.empty())
-		return false;
-	out = q_.front();
-	q_.pop();
-	return true;
-}

QtInputHandler.h

@@ -1,40 +0,0 @@
-/*
- * QtInputHandler - Qt-based input mapping for GUI mode
- */
-#pragma once
-
-#include <mutex>
-#include <queue>
-
-#include "InputHandler.h"
-
-class QKeyEvent;
-
-class QtInputHandler final : public InputHandler {
-public:
-	QtInputHandler() = default;
-
-	~QtInputHandler() override = default;
-
-
-	void Attach(Editor *ed) override
-	{
-		ed_ = ed;
-	}
-
-
-	// Translate a Qt key event to editor command and enqueue if applicable.
-	// Returns true if it produced a mapped command or consumed input.
-	bool ProcessKeyEvent(const QKeyEvent &e);
-
-	bool Poll(MappedInput &out) override;
-
-private:
-	std::mutex mu_;
-	std::queue<MappedInput> q_;
-	bool k_prefix_                 = false;
-	bool k_ctrl_pending_           = false; // C-k C-… qualifier
-	bool esc_meta_                 = false; // ESC-prefix for next key
-	bool suppress_text_input_once_ = false; // reserved (Qt sends text in keyPressEvent)
-	Editor *ed_                    = nullptr;
-};

QtRenderer.cc

@@ -1,76 +0,0 @@
-#include "QtRenderer.h"
-
-#include <QWidget>
-#include <QPainter>
-#include <QPaintEvent>
-#include <QFont>
-#include <QFontMetrics>
-
-#include "Editor.h"
-
-namespace {
-class EditorWidget : public QWidget {
-public:
-	explicit EditorWidget(QWidget *parent = nullptr) : QWidget(parent)
-	{
-		setAttribute(Qt::WA_OpaquePaintEvent);
-		setFocusPolicy(Qt::StrongFocus);
-	}
-
-
-	void SetEditor(Editor *ed)
-	{
-		ed_ = ed;
-	}
-
-protected:
-	void paintEvent(QPaintEvent *event) override
-	{
-		Q_UNUSED(event);
-		QPainter p(this);
-		// Background
-		const QColor bg(28, 28, 30);
-		p.fillRect(rect(), bg);
-
-		// Font and metrics
-		QFont f("JetBrains Mono", 13);
-		p.setFont(f);
-		QFontMetrics fm(f);
-		const int line_h = fm.height();
-
-		// Title
-		p.setPen(QColor(220, 220, 220));
-		p.drawText(8, fm.ascent() + 4, QStringLiteral("kte (Qt frontend)"));
-
-		// Status bar at bottom
-		const int bar_h = line_h + 6; // padding
-		const int bar_y = height() - bar_h;
-		QRect status_rect(0, bar_y, width(), bar_h);
-		p.fillRect(status_rect, QColor(40, 40, 44));
-		p.setPen(QColor(180, 180, 140));
-		if (ed_) {
-			const QString status = QString::fromStdString(ed_->Status());
-			// draw at baseline within the bar
-			const int baseline = bar_y + 3 + fm.ascent();
-			p.drawText(8, baseline, status);
-		}
-	}
-
-private:
-	Editor *ed_ = nullptr;
-};
-} // namespace
-
-void
-QtRenderer::Draw(Editor &ed)
-{
-	if (!widget_)
-		return;
-
-	// If our widget is an EditorWidget, pass the editor pointer for painting
-	if (auto *ew = dynamic_cast<EditorWidget *>(widget_)) {
-		ew->SetEditor(&ed);
-	}
-	// Request a repaint
-	widget_->update();
-}

QtRenderer.h

@@ -1,27 +0,0 @@
-/*
- * QtRenderer - minimal Qt-based renderer
- */
-#pragma once
-
-#include "Renderer.h"
-
-class QWidget;
-
-class QtRenderer final : public Renderer {
-public:
-	QtRenderer() = default;
-
-	~QtRenderer() override = default;
-
-
-	void Attach(QWidget *widget)
-	{
-		widget_ = widget;
-	}
-
-
-	void Draw(Editor &ed) override;
-
-private:
-	QWidget *widget_ = nullptr; // not owned
-};

README.md

@@ -32,27 +32,27 @@ Project Goals
 
 Keybindings
 -----------
-kte maintains ke’s command model while internals evolve. Highlights (
+kte maintains ke’s command model while internals evolve. Highlights (subject to refinement):
-subject to refinement):
 
 - K‑command prefix: `C-k` enters k‑command mode; exit with `ESC` or
   `C-g`.
 - Save/Exit: `C-k s` (save), `C-k x` or `C-k C-x` (save and exit),
   `C-k q` (quit with confirm), `C-k C-q` (quit immediately).
-- Editing: `C-k d` (kill to EOL), `C-k C-d` (kill line), `C-w` (kill
+- Editing: `C-k d` (kill to EOL), `C-k C-d` (kill line), `C-k
-  region), `C-y` (yank), `C-u` (universal argument).
+  BACKSPACE` (kill to BOL), `C-w` (kill region), `C-y` ( yank), `C-u`
+  (universal argument).
 - Navigation/Search: `C-s` (incremental find), `C-r` (regex search),
   `ESC f/b` (word next/prev), `ESC BACKSPACE` (delete previous word).
 - Buffers/Files: `C-k e` (open), `C-k b`/`C-k p` (switch), `C-k c`
-  (close), `C-k l` (reload).
+  (close), `C-k C-r` (reload).
-- Misc: `C-l` (refresh), `C-g` (cancel), `C-k g` (goto line).
+- Misc: `C-l` (refresh), `C-g` (cancel), `C-k m` (run make), `C-k g`
+  (goto line).
 
 See `ke.md` for the canonical ke reference retained for now.
 
 Build and Run
 -------------
-Prerequisites: C++20 compiler, CMake, and ncurses development
+Prerequisites: C++17 compiler, CMake, and ncurses development headers/libs.
-headers/libs.
 
 Dependencies by platform
 ------------------------
@@ -62,38 +62,30 @@ Dependencies by platform
         - `brew install ncurses`
     - Optional GUI (enable with `-DBUILD_GUI=ON`):
         - `brew install sdl2 freetype`
-        - OpenGL is provided by the system framework on macOS; no
+        - OpenGL is provided by the system framework on macOS; no package needed.
-          package needed.
 
 - Debian/Ubuntu
     - Terminal (default):
         - `sudo apt-get install -y libncurses5-dev libncursesw5-dev`
     - Optional GUI (enable with `-DBUILD_GUI=ON`):
-      -
+        - `sudo apt-get install -y libsdl2-dev libfreetype6-dev mesa-common-dev`
-      `sudo apt-get install -y libsdl2-dev libfreetype6-dev mesa-common-dev`
+        - The `mesa-common-dev` package provides OpenGL headers/libs (`libGL`).
-        - The `mesa-common-dev` package provides OpenGL headers/libs (
-          `libGL`).
 
 - NixOS/Nix
     - Terminal (default):
         - Ad-hoc shell: `nix-shell -p cmake gcc ncurses`
     - Optional GUI (enable with `-DBUILD_GUI=ON`):
-        - Ad-hoc shell:
+        - Ad-hoc shell: `nix-shell -p cmake gcc ncurses SDL2 freetype libGL`
-          `nix-shell -p cmake gcc ncurses SDL2 freetype libGL`
+    - With flakes/devshell (example `flake.nix` inputs not provided): include
-    - With flakes/devshell (example `flake.nix` inputs not provided):
+      `ncurses` for TUI, and `SDL2`, `freetype`, `libGL` for GUI in your devShell.
-      include
-      `ncurses` for TUI, and `SDL2`, `freetype`, `libGL` for GUI in your
-      devShell.
 
 Notes
 -----
 
-- The GUI is OFF by default to keep SDL/OpenGL/Freetype optional. Enable
+- The GUI is OFF by default to keep SDL/OpenGL/Freetype optional. Enable it by
-  it by
   configuring with `-DBUILD_GUI=ON` and ensuring the GUI deps above are
   installed for your platform.
-- If you previously configured with GUI ON and want to disable it,
+- If you previously configured with GUI ON and want to disable it, reconfigure
-  reconfigure
   the build directory with `-DBUILD_GUI=OFF`.
 
 Example build:
@@ -121,8 +113,7 @@ built as `kge`) or request the GUI from `kte`:
 GUI build example
 -----------------
 
-To build with the optional GUI (after installing the GUI dependencies
+To build with the optional GUI (after installing the GUI dependencies listed above):
-listed above):
 
 ```
 cmake -S . -B cmake-build-debug -DCMAKE_BUILD_TYPE=Debug -DBUILD_GUI=ON

ROADMAP.md

@@ -2,12 +2,9 @@ ROADMAP / TODO:
 
 - [x] Search + Replace
 - [x] Regex search + replace
+- [ ] The undo system should actually work
 - [x] Able to mark buffers as read-only
 - [x] Built-in help text
 - [x] Shorten paths in the homedir with ~
 - [x] When the filename is longer than the message window, scoot left to
   keep it in view
-- [x] Syntax highlighting
-- [ ] Swap files (crash recovery). See `docs/plans/swap-files.md`
-- [ ] The undo system should actually work
-- [ ] LSP integration

Renderer.h

@@ -1,7 +1,9 @@
 /*
  * Renderer.h - rendering abstraction
  */
-#pragma once
+#ifndef KTE_RENDERER_H
+#define KTE_RENDERER_H
+
 
 class Editor;
 
@@ -11,3 +13,5 @@ public:
 
 	virtual void Draw(Editor &ed) = 0;
 };
+
+#endif // KTE_RENDERER_H

Swap.h

@@ -1,253 +0,0 @@
-// Swap.h - swap journal (crash recovery) writer/manager for kte
-#pragma once
-
-#include <cstdint>
-#include <cstddef>
-#include <string>
-#include <string_view>
-#include <vector>
-#include <unordered_map>
-#include <memory>
-#include <mutex>
-#include <condition_variable>
-#include <deque>
-#include <thread>
-#include <atomic>
-
-#include "SwapRecorder.h"
-#include "ErrorRecovery.h"
-
-class Buffer;
-
-namespace kte {
-// Minimal record types for stage 1
-enum class SwapRecType : std::uint8_t {
-	INS = 1,
-	DEL = 2,
-	SPLIT = 3,
-	JOIN = 4,
-	META = 0xF0,
-	CHKPT = 0xFE,
-};
-
-struct SwapConfig {
-	// Grouping and durability knobs (stage 1 defaults)
-	unsigned flush_interval_ms{200}; // group small writes
-	unsigned fsync_interval_ms{1000}; // at most once per second
-
-	// Checkpoint/compaction knobs (stage 2 defaults)
-	// A checkpoint is a full snapshot of the buffer content written as a CHKPT record.
-	// Compaction rewrites the swap file to contain just the latest checkpoint.
-	std::size_t checkpoint_bytes{1024 * 1024}; // request checkpoint after this many queued edit-bytes
-	unsigned checkpoint_interval_ms{60000}; // request checkpoint at least this often while editing
-	std::size_t compact_bytes{8 * 1024 * 1024}; // compact on checkpoint once journal grows beyond this
-
-	// Cleanup / retention (best-effort)
-	bool prune_on_startup{true};
-	unsigned prune_max_age_days{30};
-	std::size_t prune_max_files{2048};
-};
-
-// SwapManager manages sidecar swap files and a single background writer thread.
-class SwapManager final {
-public:
-	SwapManager();
-
-	~SwapManager();
-
-	// Attach a buffer to begin journaling. Safe to call multiple times; idempotent.
-	void Attach(Buffer *buf);
-
-	// Detach and close journal.
-	// If remove_file is true, the swap file is deleted after closing.
-	// Intended for clean shutdown/close flows.
-	void Detach(Buffer *buf, bool remove_file = false);
-
-	// Reset (truncate-by-delete) the journal for a buffer after a clean save.
-	// Best-effort: closes the current fd, deletes the swap file, and resumes recording.
-	void ResetJournal(Buffer &buf);
-
-	// Best-effort pruning of old swap files under the swap directory.
-	// Never touches non-`.swp` files.
-	void PruneSwapDir();
-
-	// Block until all currently queued records have been written.
-	// If buf is non-null, flushes all records (stage 1) but is primarily intended
-	// for tests and shutdown.
-	void Flush(Buffer *buf = nullptr);
-
-	// Request a full-content checkpoint record for one buffer (or all buffers if buf is null).
-	// This is best-effort and asynchronous; call Flush() if you need it written before continuing.
-	void Checkpoint(Buffer *buf = nullptr);
-
-
-	void SetConfig(const SwapConfig &cfg)
-	{
-		std::lock_guard<std::mutex> lg(mtx_);
-		cfg_ = cfg;
-		cv_.notify_one();
-	}
-
-
-	// Obtain a per-buffer recorder adapter that emits records for that buffer.
-	// The returned pointer is owned by the SwapManager and remains valid until
-	// Detach(buf) or SwapManager destruction.
-	SwapRecorder *RecorderFor(Buffer *buf);
-
-	// Notify that the buffer's filename changed (e.g., SaveAs)
-	void NotifyFilenameChanged(Buffer &buf);
-
-	// Replay a swap journal into an already-open buffer.
-	// On success, the buffer content reflects all valid journal records.
-	// On failure (corrupt/truncated/invalid), the buffer is left in whatever
-	// state results from applying records up to the failure point; callers should
-	// treat this as a recovery failure and surface `err`.
-	static bool ReplayFile(Buffer &buf, const std::string &swap_path, std::string &err);
-
-	// Compute the swap path for a file-backed buffer by filename.
-	// Returns empty string if filename is empty.
-	static std::string ComputeSwapPathForFilename(const std::string &filename);
-
-	// Test-only hook to keep swap path logic centralized.
-	// (Avoid duplicating naming rules in unit tests.)
-#ifdef KTE_TESTS
-	static std::string ComputeSwapPathForTests(const Buffer &buf)
-	{
-		return ComputeSidecarPath(buf);
-	}
-#endif
-
-	// RAII guard to suspend recording for internal operations
-	class SuspendGuard {
-	public:
-		SuspendGuard(SwapManager &m, Buffer *b);
-
-		~SuspendGuard();
-
-	private:
-		SwapManager &m_;
-		Buffer *buf_;
-		bool prev_;
-	};
-
-	// Per-buffer toggle
-	void SetSuspended(Buffer &buf, bool on);
-
-	// Error reporting for background thread
-	struct SwapError {
-		std::uint64_t timestamp_ns{0};
-		std::string message;
-		std::string buffer_name; // filename or "<unnamed>"
-	};
-
-	// Query error state (thread-safe)
-	bool HasErrors() const;
-
-	std::string GetLastError() const;
-
-	std::size_t GetErrorCount() const;
-
-private:
-	class BufferRecorder final : public SwapRecorder {
-	public:
-		BufferRecorder(SwapManager &m, Buffer &b) : m_(m), buf_(b) {}
-
-		void OnInsert(int row, int col, std::string_view bytes) override;
-
-		void OnDelete(int row, int col, std::size_t len) override;
-
-	private:
-		SwapManager &m_;
-		Buffer &buf_;
-	};
-
-	void RecordInsert(Buffer &buf, int row, int col, std::string_view text);
-
-	void RecordDelete(Buffer &buf, int row, int col, std::size_t len);
-
-	void RecordSplit(Buffer &buf, int row, int col);
-
-	void RecordJoin(Buffer &buf, int row);
-
-	void RecordCheckpoint(Buffer &buf, bool urgent_flush);
-
-	void maybe_request_checkpoint(Buffer &buf, std::size_t approx_edit_bytes);
-
-	struct JournalCtx {
-		std::string path;
-		int fd{-1};
-		bool header_ok{false};
-		bool suspended{false};
-		std::uint64_t last_flush_ns{0};
-		std::uint64_t last_fsync_ns{0};
-		std::uint64_t last_chkpt_ns{0};
-		std::uint64_t edit_bytes_since_chkpt{0};
-		std::uint64_t approx_size_bytes{0};
-	};
-
-	struct Pending {
-		Buffer *buf{nullptr};
-		SwapRecType type{SwapRecType::INS};
-		std::vector<std::uint8_t> payload; // framed payload only
-		bool urgent_flush{false};
-		std::uint64_t seq{0};
-	};
-
-	// Helpers
-	static std::string ComputeSidecarPath(const Buffer &buf);
-
-	static std::string ComputeSidecarPathForFilename(const std::string &filename);
-
-	static std::uint64_t now_ns();
-
-	static bool ensure_parent_dir(const std::string &path);
-
-	static std::string SwapDirRoot();
-
-	static bool write_header(int fd);
-
-	static bool open_ctx(JournalCtx &ctx, const std::string &path, std::string &err);
-
-	static void close_ctx(JournalCtx &ctx);
-
-	static bool compact_to_checkpoint(JournalCtx &ctx, const std::vector<std::uint8_t> &chkpt_record,
-	                                  std::string &err);
-
-	static std::uint32_t crc32(const std::uint8_t *data, std::size_t len, std::uint32_t seed = 0);
-
-	static void put_le32(std::vector<std::uint8_t> &out, std::uint32_t v);
-
-	static void put_le64(std::uint8_t dst[8], std::uint64_t v);
-
-	static void put_u24_le(std::uint8_t dst[3], std::uint32_t v);
-
-	void enqueue(Pending &&p);
-
-	void writer_loop();
-
-	void process_one(const Pending &p);
-
-	// Error reporting helper (called from writer thread)
-	void report_error(const std::string &message, Buffer *buf = nullptr);
-
-	// State
-	SwapConfig cfg_{};
-	std::unordered_map<Buffer *, JournalCtx> journals_;
-	std::unordered_map<Buffer *, std::unique_ptr<BufferRecorder> > recorders_;
-	mutable std::mutex mtx_;
-	std::condition_variable cv_;
-	std::vector<Pending> queue_;
-	std::uint64_t next_seq_{0};
-	std::uint64_t last_processed_{0};
-	std::uint64_t inflight_{0};
-	std::atomic<bool> running_{false};
-	std::thread worker_;
-
-	// Error tracking (protected by mtx_)
-	std::deque<SwapError> errors_; // bounded to max 100 entries
-	std::size_t total_error_count_{0};
-
-	// Circuit breaker for swap operations (protected by mtx_)
-	CircuitBreaker circuit_breaker_;
-};
-} // namespace kte

SwapRecorder.h

@@ -1,19 +0,0 @@
-// SwapRecorder.h - minimal swap journal recording interface for Buffer mutations
-#pragma once
-
-#include <cstddef>
-#include <string_view>
-
-namespace kte {
-// SwapRecorder is a tiny, non-blocking callback interface.
-// Implementations must return quickly; Buffer calls these hooks after a
-// mutation succeeds.
-class SwapRecorder {
-public:
-	virtual ~SwapRecorder() = default;
-
-	virtual void OnInsert(int row, int col, std::string_view bytes) = 0;
-
-	virtual void OnDelete(int row, int col, std::size_t len) = 0;
-};
-} // namespace kte

SyscallWrappers.cc

@@ -1,76 +0,0 @@
-#include "SyscallWrappers.h"
-
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <cerrno>
-#include <cstdlib>
-
-namespace kte {
-namespace syscall {
-int
-Open(const char *path, int flags, mode_t mode)
-{
-	int fd;
-	do {
-		fd = ::open(path, flags, mode);
-	} while (fd == -1 && errno == EINTR);
-	return fd;
-}
-
-
-int
-Close(int fd)
-{
-	int ret;
-	do {
-		ret = ::close(fd);
-	} while (ret == -1 && errno == EINTR);
-	return ret;
-}
-
-
-int
-Fsync(int fd)
-{
-	int ret;
-	do {
-		ret = ::fsync(fd);
-	} while (ret == -1 && errno == EINTR);
-	return ret;
-}
-
-
-int
-Fstat(int fd, struct stat *buf)
-{
-	int ret;
-	do {
-		ret = ::fstat(fd, buf);
-	} while (ret == -1 && errno == EINTR);
-	return ret;
-}
-
-
-int
-Fchmod(int fd, mode_t mode)
-{
-	int ret;
-	do {
-		ret = ::fchmod(fd, mode);
-	} while (ret == -1 && errno == EINTR);
-	return ret;
-}
-
-
-int
-Mkstemp(char *template_str)
-{
-	int fd;
-	do {
-		fd = ::mkstemp(template_str);
-	} while (fd == -1 && errno == EINTR);
-	return fd;
-}
-} // namespace syscall
-} // namespace kte

SyscallWrappers.h

@@ -1,47 +0,0 @@
-// SyscallWrappers.h - EINTR-safe syscall wrappers for kte
-#pragma once
-
-#include <string>
-#include <cstddef>
-#include <sys/stat.h>
-
-namespace kte {
-namespace syscall {
-// EINTR-safe wrapper for open(2).
-// Returns file descriptor on success, -1 on failure (errno set).
-// Automatically retries on EINTR.
-int Open(const char *path, int flags, mode_t mode = 0);
-
-// EINTR-safe wrapper for close(2).
-// Returns 0 on success, -1 on failure (errno set).
-// Automatically retries on EINTR.
-// Note: Some systems may not restart close() on EINTR, but we retry anyway
-// as recommended by POSIX.1-2008.
-int Close(int fd);
-
-// EINTR-safe wrapper for fsync(2).
-// Returns 0 on success, -1 on failure (errno set).
-// Automatically retries on EINTR.
-int Fsync(int fd);
-
-// EINTR-safe wrapper for fstat(2).
-// Returns 0 on success, -1 on failure (errno set).
-// Automatically retries on EINTR.
-int Fstat(int fd, struct stat *buf);
-
-// EINTR-safe wrapper for fchmod(2).
-// Returns 0 on success, -1 on failure (errno set).
-// Automatically retries on EINTR.
-int Fchmod(int fd, mode_t mode);
-
-// EINTR-safe wrapper for mkstemp(3).
-// Returns file descriptor on success, -1 on failure (errno set).
-// Automatically retries on EINTR.
-// Note: template_str must be a mutable buffer ending in "XXXXXX".
-int Mkstemp(char *template_str);
-
-// Note: rename(2) and unlink(2) are not wrapped because they operate on
-// filesystem metadata and typically complete atomically without EINTR.
-// If interrupted, they either succeed or fail without partial state.
-} // namespace syscall
-} // namespace kte

TerminalFrontend.cc

@@ -1,6 +1,12 @@
 #include <ncurses.h>
+#include <clocale>
 #include <termios.h>
 #include <unistd.h>
+#ifdef __APPLE__
+#include <xlocale.h>
+#endif
+#include <langinfo.h>
+#include <cctype>
 
 #include "TerminalFrontend.h"
 #include "Command.h"
@@ -8,10 +14,37 @@
 
 
 bool
-TerminalFrontend::Init(int &argc, char **argv, Editor &ed)
+TerminalFrontend::Init(Editor &ed)
 {
-	(void) argc;
+	// Enable UTF-8 locale so ncurses and the terminal handle multibyte correctly
-	(void) argv;
+	// This relies on the user's environment (e.g., LANG/LC_ALL) being set to a UTF-8 locale.
+	// If not set, try a couple of common UTF-8 fallbacks.
+	const char *loc      = std::setlocale(LC_ALL, "");
+	auto is_utf8_codeset = []() -> bool {
+		const char *cs = nl_langinfo(CODESET);
+		if (!cs)
+			return false;
+		std::string s(cs);
+		for (auto &ch: s)
+			ch = static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
+		return (s.find("UTF-8") != std::string::npos) || (s.find("UTF8") != std::string::npos);
+	};
+	bool utf8_ok = (MB_CUR_MAX > 1) && is_utf8_codeset();
+	if (!utf8_ok) {
+		// Try common UTF-8 locales
+		loc     = std::setlocale(LC_CTYPE, "C.UTF-8");
+		utf8_ok = (loc != nullptr) && (MB_CUR_MAX > 1) && is_utf8_codeset();
+		if (!utf8_ok) {
+			loc     = std::setlocale(LC_CTYPE, "en_US.UTF-8");
+			utf8_ok = (loc != nullptr) && (MB_CUR_MAX > 1) && is_utf8_codeset();
+		}
+		if (!utf8_ok) {
+			// macOS often uses plain "UTF-8" locale identifier
+			loc     = std::setlocale(LC_CTYPE, "UTF-8");
+			utf8_ok = (loc != nullptr) && (MB_CUR_MAX > 1) && is_utf8_codeset();
+		}
+	}
+
 	// Ensure Control keys reach the app: disable XON/XOFF and dsusp/susp bindings (e.g., ^S/^Q, ^Y on macOS)
 	{
 		struct termios tio{};
@@ -44,38 +77,22 @@ TerminalFrontend::Init(int &argc, char **argv, Editor &ed)
 	meta(stdscr, TRUE);
 	// Make ESC key sequences resolve quickly so ESC+<key> works as meta
 #ifdef set_escdelay
-	set_escdelay(TerminalFrontend::kEscDelayMs);
+	set_escdelay(50);
 #endif
-	// Make getch() block briefly instead of busy-looping; reduces CPU when idle
+	nodelay(stdscr, TRUE);
-	// Equivalent to nodelay(FALSE) with a small timeout.
-	timeout(16); // ~16ms (about 60Hz)
 	curs_set(1);
 	// Enable mouse support if available
 	mouseinterval(0);
-	mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION, nullptr);
+	mousemask(ALL_MOUSE_EVENTS, nullptr);
 
 	int r = 0, c = 0;
 	getmaxyx(stdscr, r, c);
 	prev_r_ = r;
 	prev_c_ = c;
 	ed.SetDimensions(static_cast<std::size_t>(r), static_cast<std::size_t>(c));
-	// Attach editor to input handler for editor-owned features (e.g., universal argument)
+	// Inform renderer of UTF-8 capability so it can choose proper output path
-	input_.Attach(&ed);
+	renderer_.SetUtf8Enabled(utf8_ok);
-
+	input_.SetUtf8Enabled(utf8_ok);
-	// Ignore SIGINT (Ctrl-C) so it doesn't terminate the TUI.
-	// We'll restore the previous handler on Shutdown().
-	{
-		struct sigaction sa{};
-		sa.sa_handler = SIG_IGN;
-		sigemptyset(&sa.sa_mask);
-		sa.sa_flags = 0;
-		struct sigaction old{};
-		if (sigaction(SIGINT, &sa, &old) == 0) {
-			old_sigint_      = old;
-			have_old_sigint_ = true;
-		}
-	}
-
 	return true;
 }
 
@@ -94,14 +111,14 @@ TerminalFrontend::Step(Editor &ed, bool &running)
 	}
 	ed.SetDimensions(static_cast<std::size_t>(r), static_cast<std::size_t>(c));
 
-	// Allow deferred opens (including swap recovery prompts) to run.
-	ed.ProcessPendingOpens();
-
 	MappedInput mi;
 	if (input_.Poll(mi)) {
 		if (mi.hasCommand) {
 			Execute(ed, mi.id, mi.arg, mi.count);
 		}
+	} else {
+		// Avoid busy loop
+		usleep(1000);
 	}
 
 	if (ed.QuitRequested()) {
@@ -120,10 +137,5 @@ TerminalFrontend::Shutdown()
 		(void) tcsetattr(STDIN_FILENO, TCSANOW, &orig_tio_);
 		have_orig_tio_ = false;
 	}
-	// Restore previous SIGINT handler
-	if (have_old_sigint_) {
-		(void) sigaction(SIGINT, &old_sigint_, nullptr);
-		have_old_sigint_ = false;
-	}
 	endwin();
 }

TerminalFrontend.h

@@ -1,9 +1,10 @@
 /*
  * TerminalFrontend - couples TerminalInputHandler + TerminalRenderer and owns ncurses lifecycle
  */
-#pragma once
+#ifndef KTE_TERMINAL_FRONTEND_H
+#define KTE_TERMINAL_FRONTEND_H
+
 #include <termios.h>
-#include <signal.h>
 
 #include "Frontend.h"
 #include "TerminalInputHandler.h"
@@ -16,12 +17,7 @@ public:
 
 	~TerminalFrontend() override = default;
 
-	// Configurable ESC key delay (ms) for ncurses' set_escdelay().
+	bool Init(Editor &ed) override;
-	// Controls how long ncurses waits to distinguish ESC vs. meta sequences.
-	// Adjust if your terminal needs a different threshold.
-	static constexpr int kEscDelayMs = 50;
-
-	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 
@@ -35,7 +31,6 @@ private:
 	// Saved terminal attributes to restore on shutdown
 	bool have_orig_tio_ = false;
 	struct termios orig_tio_{};
-	// Saved SIGINT handler to restore on shutdown
-	bool have_old_sigint_ = false;
-	struct sigaction old_sigint_{};
 };
+
+#endif // KTE_TERMINAL_FRONTEND_H

TerminalInputHandler.cc

@@ -1,10 +1,10 @@
 #include <cstdio>
+#include <cwchar>
+#include <climits>
 #include <ncurses.h>
 
 #include "TerminalInputHandler.h"
 #include "KKeymap.h"
-#include "Command.h"
-#include "Editor.h"
 
 namespace {
 constexpr int
@@ -23,66 +23,70 @@ static bool
 map_key_to_command(const int ch,
                    bool &k_prefix,
                    bool &esc_meta,
-                   bool &k_ctrl_pending,
+                   // universal-argument state (by ref)
-                   bool &mouse_selecting,
+                   bool &uarg_active,
-                   Editor *ed,
+                   bool &uarg_collecting,
+                   bool &uarg_negative,
+                   bool &uarg_had_digits,
+                   int &uarg_value,
+                   std::string &uarg_text,
                    MappedInput &out)
 {
 	// Handle special keys from ncurses
-	// These keys exit k-prefix mode if active (user pressed C-k then a special key).
 	switch (ch) {
-	case KEY_ENTER:
-		// Some terminals send KEY_ENTER distinct from '\n'/'\r'
-		k_prefix = false;
-		k_ctrl_pending = false;
-		out            = {true, CommandId::Newline, "", 0};
-		return true;
 	case KEY_MOUSE: {
-		k_prefix       = false;
-		k_ctrl_pending = false;
 		MEVENT ev{};
 		if (getmouse(&ev) == OK) {
-			// Mouse wheel → scroll viewport without moving cursor
+			// Mouse wheel → map to MoveUp/MoveDown one line per wheel notch
+			unsigned long wheel_up_mask = 0;
+			unsigned long wheel_dn_mask = 0;
 #ifdef BUTTON4_PRESSED
-			if (ev.bstate & (BUTTON4_PRESSED | BUTTON4_RELEASED | BUTTON4_CLICKED)) {
+			wheel_up_mask |= BUTTON4_PRESSED;
-				out = {true, CommandId::ScrollUp, "", 0};
+#endif
-				return true;
+#ifdef BUTTON4_RELEASED
-			}
+			wheel_up_mask |= BUTTON4_RELEASED;
+#endif
+#ifdef BUTTON4_CLICKED
+			wheel_up_mask |= BUTTON4_CLICKED;
+#endif
+#ifdef BUTTON4_DOUBLE_CLICKED
+			wheel_up_mask |= BUTTON4_DOUBLE_CLICKED;
+#endif
+#ifdef BUTTON4_TRIPLE_CLICKED
+			wheel_up_mask |= BUTTON4_TRIPLE_CLICKED;
 #endif
 #ifdef BUTTON5_PRESSED
-			if (ev.bstate & (BUTTON5_PRESSED | BUTTON5_RELEASED | BUTTON5_CLICKED)) {
+			wheel_dn_mask |= BUTTON5_PRESSED;
-				out = {true, CommandId::ScrollDown, "", 0};
+#endif
+#ifdef BUTTON5_RELEASED
+			wheel_dn_mask |= BUTTON5_RELEASED;
+#endif
+#ifdef BUTTON5_CLICKED
+			wheel_dn_mask |= BUTTON5_CLICKED;
+#endif
+#ifdef BUTTON5_DOUBLE_CLICKED
+			wheel_dn_mask |= BUTTON5_DOUBLE_CLICKED;
+#endif
+#ifdef BUTTON5_TRIPLE_CLICKED
+			wheel_dn_mask |= BUTTON5_TRIPLE_CLICKED;
+#endif
+			if (wheel_up_mask && (ev.bstate & wheel_up_mask)) {
+				// Prefer viewport scrolling for wheel: page up
+				out = {true, CommandId::PageUp, "", 0};
+				return true;
+			}
+			if (wheel_dn_mask && (ev.bstate & wheel_dn_mask)) {
+				// Prefer viewport scrolling for wheel: page down
+				out = {true, CommandId::PageDown, "", 0};
 				return true;
 			}
-#endif
 			// React to left button click/press
-			if (ed && (ev.bstate & (BUTTON1_CLICKED | BUTTON1_PRESSED | BUTTON1_RELEASED |
+			if (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);
-				const bool pressed  = (ev.bstate & (BUTTON1_PRESSED | BUTTON1_CLICKED)) != 0;
+				out = {true, CommandId::MoveCursorTo, std::string(buf), 0};
-				const bool released = (ev.bstate & BUTTON1_RELEASED) != 0;
+				return true;
-				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
@@ -90,54 +94,34 @@ map_key_to_command(const int ch,
 		return true;
 	}
 	case KEY_LEFT:
-		k_prefix = false;
+		out = {true, CommandId::MoveLeft, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveLeft, "", 0};
 		return true;
 	case KEY_RIGHT:
-		k_prefix = false;
+		out = {true, CommandId::MoveRight, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveRight, "", 0};
 		return true;
 	case KEY_UP:
-		k_prefix = false;
+		out = {true, CommandId::MoveUp, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveUp, "", 0};
 		return true;
 	case KEY_DOWN:
-		k_prefix = false;
+		out = {true, CommandId::MoveDown, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveDown, "", 0};
 		return true;
 	case KEY_HOME:
-		k_prefix = false;
+		out = {true, CommandId::MoveHome, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveHome, "", 0};
 		return true;
 	case KEY_END:
-		k_prefix = false;
+		out = {true, CommandId::MoveEnd, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::MoveEnd, "", 0};
 		return true;
 	case KEY_PPAGE:
-		k_prefix = false;
+		out = {true, CommandId::PageUp, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::PageUp, "", 0};
 		return true;
 	case KEY_NPAGE:
-		k_prefix = false;
+		out = {true, CommandId::PageDown, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::PageDown, "", 0};
 		return true;
 	case KEY_DC:
-		k_prefix = false;
+		out = {true, CommandId::DeleteChar, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::DeleteChar, "", 0};
 		return true;
 	case KEY_RESIZE:
-		k_prefix = false;
+		out = {true, CommandId::Refresh, "", 0};
-		k_ctrl_pending = false;
-		out            = {true, CommandId::Refresh, "", 0};
 		return true;
 	default:
 		break;
@@ -147,7 +131,6 @@ map_key_to_command(const int ch,
 	if (ch == 27) {
 		// ESC
 		k_prefix       = false;
-		k_ctrl_pending = false;
 		esc_meta       = true; // next key will be considered meta-modified
 		out.hasCommand = false; // no command yet
 		return true;
@@ -156,33 +139,59 @@ map_key_to_command(const int ch,
 	// Control keys
 	if (ch == CTRL('K')) {
 		// C-k prefix
-		k_prefix       = true;
+		k_prefix = true;
-		k_ctrl_pending = false;
+		out      = {true, CommandId::KPrefix, "", 0};
-		out            = {true, CommandId::KPrefix, "", 0};
 		return true;
 	}
 	if (ch == CTRL('G')) {
 		// cancel
-		k_prefix       = false;
+		k_prefix = false;
-		k_ctrl_pending = false;
+		esc_meta = false;
-		esc_meta       = false;
 		// cancel universal argument as well
-		if (ed)
+		uarg_active     = false;
-			ed->UArgClear();
+		uarg_collecting = false;
+		uarg_negative   = false;
+		uarg_had_digits = false;
+		uarg_value      = 0;
+		uarg_text.clear();
 		out = {true, CommandId::Refresh, "", 0};
 		return true;
 	}
 	// Universal argument: C-u
 	if (ch == CTRL('U')) {
-		if (ed)
+		// Start or extend universal argument
-			ed->UArgStart();
+		if (!uarg_active) {
-		out.hasCommand = false; // C-u itself doesn't issue a command
+			uarg_active     = true;
+			uarg_collecting = true;
+			uarg_negative   = false;
+			uarg_had_digits = false;
+			uarg_value      = 4; // default
+			// Reset collected text and emit status update
+			uarg_text.clear();
+			out = {true, CommandId::UArgStatus, uarg_text, 0};
+			return true;
+		} else if (uarg_collecting && !uarg_had_digits && !uarg_negative) {
+			// Bare repeated C-u multiplies by 4
+			if (uarg_value <= 0)
+				uarg_value = 4;
+			else
+				uarg_value *= 4;
+			// Keep showing status (no digits yet)
+			out = {true, CommandId::UArgStatus, uarg_text, 0};
+			return true;
+		} else {
+			// If digits or '-' have been entered, C-u ends the argument (ready for next command)
+			uarg_collecting = false;
+			if (!uarg_had_digits && !uarg_negative && uarg_value <= 0)
+				uarg_value = 4;
+		}
+		// No command produced by C-u itself
+		out.hasCommand = false;
 		return true;
 	}
 	// Tab (note: terminals encode Tab and C-i as the same code 9)
 	if (ch == '\t') {
 		k_prefix       = false;
-		k_ctrl_pending = false;
 		out.hasCommand = true;
 		out.id         = CommandId::InsertText;
 		out.arg        = "\t";
@@ -193,40 +202,22 @@ map_key_to_command(const int ch,
 	// IMPORTANT: if we're in k-prefix, the very next key must be interpreted
 	// via the C-k keymap first, even if it's a Control chord like C-d.
 	if (k_prefix) {
-		// In k-prefix: allow a control qualifier via literal 'C' or '^'
+		k_prefix      = false; // consume the prefix for this one key
-		// Detect Control keycodes first
 		bool ctrl     = false;
 		int ascii_key = ch;
 		if (ch >= 1 && ch <= 26) {
 			ctrl      = true;
 			ascii_key = 'a' + (ch - 1);
 		}
-		// If user typed literal 'C' or '^' as a qualifier, keep k-prefix and set pending
-		// Note: Do NOT treat lowercase 'c' as a qualifier, since 'c' is a valid C-k command (BufferClose).
-		if (ascii_key == 'C' || ascii_key == '^') {
-			k_ctrl_pending = true;
-			if (ed)
-				ed->SetStatus("C-k C _");
-			out.hasCommand = false;
-			return true;
-		}
-		// For actual suffix, consume the k-prefix
-		k_prefix = false;
 		// Do NOT lowercase here; KLookupKCommand handles case-sensitive bindings
 		CommandId id;
-		bool pass_ctrl = (ctrl || k_ctrl_pending);
+		if (KLookupKCommand(ascii_key, ctrl, id)) {
-		k_ctrl_pending = false;
-		if (KLookupKCommand(ascii_key, pass_ctrl, id)) {
 			out = {true, id, "", 0};
-			if (ed)
-				ed->SetStatus(""); // clear "C-k _" hint after suffix
 		} else {
 			int shown = KLowerAscii(ascii_key);
 			char c    = (shown >= 0x20 && shown <= 0x7e) ? static_cast<char>(shown) : '?';
 			std::string arg(1, c);
 			out = {true, CommandId::UnknownKCommand, arg, 0};
-			if (ed)
-				ed->SetStatus(""); // clear hint; handler will set unknown status
 		}
 		return true;
 	}
@@ -242,9 +233,8 @@ map_key_to_command(const int ch,
 
 	// Enter
 	if (ch == '\n' || ch == '\r') {
-		k_prefix       = false;
+		k_prefix = false;
-		k_ctrl_pending = false;
+		out      = {true, CommandId::Newline, "", 0};
-		out            = {true, CommandId::Newline, "", 0};
 		return true;
 	}
 	// If previous key was ESC, interpret as meta and use ESC keymap
@@ -254,12 +244,6 @@ map_key_to_command(const int ch,
 		// Handle ESC + BACKSPACE (meta-backspace, Alt-Backspace)
 		if (ch == KEY_BACKSPACE || ch == 127 || ch == CTRL('H')) {
 			ascii_key = KEY_BACKSPACE; // normalized value for lookup
-		} else if (ch == ',') {
-			// Some terminals emit ',' when Shift state is lost after ESC; treat as '<'
-			ascii_key = '<';
-		} else if (ch == '.') {
-			// Likewise, map '.' to '>'
-			ascii_key = '>';
 		} else if (ascii_key >= 'A' && ascii_key <= 'Z') {
 			ascii_key = ascii_key - 'A' + 'a';
 		}
@@ -268,26 +252,48 @@ map_key_to_command(const int ch,
 			out = {true, id, "", 0};
 			return true;
 		}
-		// Unhandled ESC sequence: exit escape mode and show status
+		// Unhandled meta key: no command
-		out = {true, CommandId::UnknownEscCommand, "", 0};
+		out.hasCommand = false;
 		return true;
 	}
 
 	// Backspace in ncurses can be KEY_BACKSPACE or 127
 	if (ch == KEY_BACKSPACE || ch == 127 || ch == CTRL('H')) {
-		k_prefix       = false;
+		k_prefix = false;
-		k_ctrl_pending = false;
+		out      = {true, CommandId::Backspace, "", 0};
-		out            = {true, CommandId::Backspace, "", 0};
 		return true;
 	}
 
 	// k_prefix handled earlier
 
-	// If universal argument is active at editor level and we get a digit, feed it
+	// If collecting universal arg, handle digits and optional leading '-'
-	if (ed && ed->UArg() != 0 && ch >= '0' && ch <= '9') {
+	if (uarg_active && uarg_collecting) {
-		ed->UArgDigit(ch - '0');
+		if (ch >= '0' && ch <= '9') {
-		out.hasCommand = false; // keep collecting, no command yet
+			int d = ch - '0';
-		return true;
+			if (!uarg_had_digits) {
+				// First digit overrides any 4^n default
+				uarg_value      = 0;
+				uarg_had_digits = true;
+			}
+			if (uarg_value < 100000000) {
+				// avoid overflow
+				uarg_value = uarg_value * 10 + d;
+			}
+			// Update raw text and status to reflect collected digits
+			uarg_text.push_back(static_cast<char>(ch));
+			out = {true, CommandId::UArgStatus, uarg_text, 0};
+			return true;
+		}
+		if (ch == '-' && !uarg_had_digits && !uarg_negative) {
+			uarg_negative = true;
+			// Show leading minus in status
+			uarg_text = "-";
+			out       = {true, CommandId::UArgStatus, uarg_text, 0};
+			return true;
+		}
+		// Any other key will be processed as a command; fall through to mapping below
+		// but mark collection finished so we apply the argument to that command
+		uarg_collecting = false;
 	}
 
 	// Printable ASCII
@@ -307,6 +313,77 @@ map_key_to_command(const int ch,
 bool
 TerminalInputHandler::decode_(MappedInput &out)
 {
+#if defined(KTE_HAVE_GET_WCH)
+	if (utf8_enabled_) {
+		// Prefer wide-character input so we can capture Unicode code points
+		wint_t wch = 0;
+		int rc     = get_wch(&wch);
+		if (rc == ERR) {
+			return false;
+		}
+		if (rc == KEY_CODE_YES) {
+			// Function/special key; pass through existing mapper
+			int sk        = static_cast<int>(wch);
+			bool consumed = map_key_to_command(
+				sk,
+				k_prefix_, esc_meta_,
+				uarg_active_, uarg_collecting_, uarg_negative_, uarg_had_digits_, uarg_value_,
+				uarg_text_,
+				out);
+			if (!consumed)
+				return false;
+		} else {
+			// Regular character
+			if (wch <= 0x7F) {
+				// ASCII path -> reuse existing mapping (handles control, ESC, etc.)
+				int ch        = static_cast<int>(wch);
+				bool consumed = map_key_to_command(
+					ch,
+					k_prefix_, esc_meta_,
+					uarg_active_, uarg_collecting_, uarg_negative_, uarg_had_digits_, uarg_value_,
+					uarg_text_,
+					out);
+				if (!consumed)
+					return false;
+			} else {
+				// Non-ASCII printable -> insert UTF-8 text directly
+				if (iswcntrl(static_cast<wint_t>(wch))) {
+					out.hasCommand = false;
+					return true;
+				}
+				char mb[MB_LEN_MAX];
+				mbstate_t st{};
+				std::size_t n = wcrtomb(mb, static_cast<wchar_t>(wch), &st);
+				if (n == static_cast<std::size_t>(-1)) {
+					// Fallback placeholder if encoding failed
+					out.hasCommand = true;
+					out.id         = CommandId::InsertText;
+					out.arg        = "?";
+					out.count      = 0;
+				} else {
+					out.hasCommand = true;
+					out.id         = CommandId::InsertText;
+					out.arg.assign(mb, mb + n);
+					out.count = 0;
+				}
+			}
+		}
+	} else {
+		int ch = getch();
+		if (ch == ERR) {
+			return false; // no input
+		}
+		bool consumed = map_key_to_command(
+			ch,
+			k_prefix_, esc_meta_,
+			uarg_active_, uarg_collecting_, uarg_negative_, uarg_had_digits_, uarg_value_, uarg_text_,
+			out);
+		if (!consumed)
+			return false;
+	}
+#else
+	// Wide-character input not available in this curses; fall back to byte-wise getch
+	(void) utf8_enabled_;
 	int ch = getch();
 	if (ch == ERR) {
 		return false; // no input
@@ -314,12 +391,30 @@ TerminalInputHandler::decode_(MappedInput &out)
 	bool consumed = map_key_to_command(
 		ch,
 		k_prefix_, esc_meta_,
-		k_ctrl_pending_,
+		uarg_active_, uarg_collecting_, uarg_negative_, uarg_had_digits_, uarg_value_, uarg_text_,
-		mouse_selecting_,
-		ed_,
 		out);
 	if (!consumed)
 		return false;
+#endif
+	// If a command was produced and a universal argument is active, attach it and clear state
+	if (out.hasCommand && uarg_active_ && out.id != CommandId::UArgStatus) {
+		int count = 0;
+		if (!uarg_had_digits_ && !uarg_negative_) {
+			// No explicit digits: use current value (default 4 or 4^n)
+			count = (uarg_value_ > 0) ? uarg_value_ : 4;
+		} else {
+			count = uarg_value_;
+			if (uarg_negative_)
+				count = -count;
+		}
+		out.count = count;
+		// Clear state
+		uarg_active_     = false;
+		uarg_collecting_ = false;
+		uarg_negative_   = false;
+		uarg_had_digits_ = false;
+		uarg_value_      = 0;
+	}
 	return true;
 }
 

TerminalInputHandler.h

@@ -1,7 +1,9 @@
 /*
  * TerminalInputHandler - ncurses-based input handling for terminal mode
  */
-#pragma once
+#ifndef KTE_TERMINAL_INPUT_HANDLER_H
+#define KTE_TERMINAL_INPUT_HANDLER_H
+
 #include "InputHandler.h"
 
 
@@ -11,27 +13,31 @@ public:
 
 	~TerminalInputHandler() override;
 
-
-	void Attach(Editor *ed) override
-	{
-		ed_ = ed;
-	}
-
-
 	bool Poll(MappedInput &out) override;
 
+
+	void SetUtf8Enabled(bool on)
+	{
+		utf8_enabled_ = on;
+	}
+
 private:
 	bool decode_(MappedInput &out);
 
 	// ke-style prefix state
 	bool k_prefix_ = false; // true after C-k until next key or ESC
-	// Optional control qualifier inside k-prefix (e.g., user typed literal 'C' or '^')
-	bool k_ctrl_pending_ = false;
 	// Simple meta (ESC) state for ESC sequences like ESC b/f
 	bool esc_meta_ = false;
 
-	// Mouse drag selection state
+	// Universal argument (C-u) state
-	bool mouse_selecting_ = false;
+	bool uarg_active_     = false; // an argument is pending for the next command
+	bool uarg_collecting_ = false; // collecting digits / '-' right now
+	bool uarg_negative_   = false; // whether a leading '-' was supplied
+	bool uarg_had_digits_ = false; // whether any digits were supplied
+	int uarg_value_       = 0; // current absolute value (>=0)
+	std::string uarg_text_; // raw digits/minus typed for status display
 
-	Editor *ed_ = nullptr; // attached editor for uarg handling
+	bool utf8_enabled_ = true;
 };
+
+#endif // KTE_TERMINAL_INPUT_HANDLER_H

TerminalRenderer.cc

@@ -1,12 +1,10 @@
-#include <clocale>
-#define _XOPEN_SOURCE_EXTENDED 1
-#include <cwchar>
 #include <algorithm>
 #include <cstdio>
 #include <filesystem>
 #include <cstdlib>
 #include <ncurses.h>
 #include <regex>
+#include <cwchar>
 #include <string>
 
 #include "TerminalRenderer.h"
@@ -37,8 +35,6 @@ TerminalRenderer::Draw(Editor &ed)
 
 	const Buffer *buf = ed.CurrentBuffer();
 	int content_rows  = rows - 1; // last line is status
-	if (content_rows < 1)
-		content_rows = 1;
 
 	int saved_cur_y = -1, saved_cur_x = -1; // logical cursor position within content area
 	if (buf) {
@@ -107,168 +103,65 @@ 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;
-			// Mark selection (mark -> cursor), in source coordinates
+			bool cur_on                = false;
-			bool sel_active    = false;
+			int written                = 0;
-			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_mark_sel   = [&](std::size_t y, std::size_t sx) -> bool {
-				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]);
+				std::string line = static_cast<std::string>(lines[li]);
-				const bool vsel_on_line         = vsel_active && li >= vsel_sy && li <= vsel_ey;
+				src_i            = 0;
-				const std::size_t vsel_spot_src = vsel_on_line
+				render_col       = 0;
-					                                  ? std::min(buf->Curx(), line.size())
+				// Syntax highlighting: fetch per-line spans
-					                                  : 0;
+				const kte::LineHighlight *lh_ptr = nullptr;
-				const bool vsel_spot_is_eol = vsel_on_line && vsel_spot_src == line.size();
-				std::size_t vsel_line_rx    = 0;
-				if (vsel_spot_is_eol) {
-					// Compute the rendered (column) width of the line so we can highlight a
-					// single cell at EOL when the spot falls beyond the last character.
-					std::size_t rc = 0;
-					std::size_t si = 0;
-					while (si < line.size()) {
-						wchar_t wch = L' ';
-						int wch_len = 1;
-						std::mbstate_t state = std::mbstate_t();
-						size_t res = std::mbrtowc(&wch, &line[si], line.size() - si, &state);
-						if (res == (size_t) -1 || res == (size_t) -2) {
-							wch     = static_cast<unsigned char>(line[si]);
-							wch_len = 1;
-						} else if (res == 0) {
-							wch     = L'\0';
-							wch_len = 1;
-						} else {
-							wch_len = static_cast<int>(res);
-						}
-						if (wch == L'\t') {
-							constexpr std::size_t tab_width = 8;
-							const std::size_t next_tab      = tab_width - (rc % tab_width);
-							rc                              += next_tab;
-						} else {
-							int w = wcwidth(wch);
-							if (w < 0)
-								w = 1;
-							rc += static_cast<std::size_t>(w);
-						}
-						si += static_cast<std::size_t>(wch_len);
-					}
-					vsel_line_rx = rc;
-				}
-				src_i      = 0;
-				render_col = 0;
-				// Syntax highlighting: fetch per-line spans (sanitized copy)
-				std::vector<kte::HighlightSpan> sane_spans;
 				if (buf->SyntaxEnabled() && buf->Highlighter() && buf->Highlighter()->
 				    HasHighlighter()) {
-					kte::LineHighlight lh_val = buf->Highlighter()->GetLine(
+					lh_ptr = &buf->Highlighter()->GetLine(
 						*buf, static_cast<int>(li), buf->Version());
-					// Sanitize defensively: clamp to [0, line.size()], ensure end>=start, drop empties
-					const std::size_t line_len = line.size();
-					sane_spans.reserve(lh_val.spans.size());
-					for (const auto &sp: lh_val.spans) {
-						int s_raw = sp.col_start;
-						int e_raw = sp.col_end;
-						if (e_raw < s_raw)
-							std::swap(e_raw, s_raw);
-						std::size_t s = static_cast<std::size_t>(std::max(
-							0, std::min(s_raw, static_cast<int>(line_len))));
-						std::size_t e = static_cast<std::size_t>(std::max(
-							static_cast<int>(s),
-							std::min(e_raw, static_cast<int>(line_len))));
-						if (e <= s)
-							continue;
-						sane_spans.push_back(kte::HighlightSpan{
-							static_cast<int>(s), static_cast<int>(e), sp.kind
-						});
-					}
-					std::sort(sane_spans.begin(), sane_spans.end(),
-					          [](const kte::HighlightSpan &a, const kte::HighlightSpan &b) {
-						          return a.col_start < b.col_start;
-					          });
 				}
 				auto token_at = [&](std::size_t src_index) -> kte::TokenKind {
-					if (sane_spans.empty())
+					if (!lh_ptr)
 						return kte::TokenKind::Default;
-					int si = static_cast<int>(src_index);
+					for (const auto &sp: lh_ptr->spans) {
-					for (const auto &sp: sane_spans) {
+						if (static_cast<int>(src_index) >= sp.col_start && static_cast<int>(
-						if (si < sp.col_start)
+							    src_index) < sp.col_end)
-							break;
-						if (si >= sp.col_start && si < sp.col_end)
 							return sp.kind;
 					}
 					return kte::TokenKind::Default;
 				};
-				auto token_attr = [&](kte::TokenKind k) -> attr_t {
+				auto apply_token_attr = [&](kte::TokenKind k) {
+					// Map to simple attributes; search highlight uses A_STANDOUT which takes precedence below
+					attrset(A_NORMAL);
 					switch (k) {
 					case kte::TokenKind::Keyword:
 					case kte::TokenKind::Type:
 					case kte::TokenKind::Constant:
 					case kte::TokenKind::Function:
-						return A_BOLD;
+						attron(A_BOLD);
+						break;
 					case kte::TokenKind::Comment:
-						return A_DIM;
+						attron(A_DIM);
+						break;
 					case kte::TokenKind::String:
 					case kte::TokenKind::Char:
 					case kte::TokenKind::Number:
-						return A_UNDERLINE;
+						// standout a bit using A_UNDERLINE if available
+						attron(A_UNDERLINE);
+						break;
 					default:
-						return 0;
+						break;
 					}
 				};
 				while (written < cols) {
-					bool from_src = false;
+					// Default to space when beyond EOL
-					wchar_t wch   = L' ';
+					bool from_src             = false;
-					int wch_len   = 1;
+					int wcw                   = 1; // display width
-					int disp_w    = 1;
+					std::size_t advance_bytes = 0;
-
 					if (src_i < line.size()) {
-						// Decode UTF-8
+						unsigned char c = static_cast<unsigned char>(line[src_i]);
-						std::mbstate_t state = std::mbstate_t();
+						if (c == '\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      += wch_len;
+								++src_i;
 								continue;
 							}
 							// Emit spaces for tab
@@ -277,148 +170,148 @@ TerminalRenderer::Draw(Editor &ed)
 								std::size_t to_skip = std::min<std::size_t>(
 									next_tab, coloffs - render_col);
 								render_col += to_skip;
-								next_tab   -= to_skip;
+								next_tab -= to_skip;
 							}
 							// Now render visible spaces
 							while (next_tab > 0 && written < cols) {
-								bool in_mark = is_src_in_mark_sel(li, src_i);
-								bool in_vsel =
-									vsel_on_line && !vsel_spot_is_eol && src_i ==
-									vsel_spot_src;
-								bool in_sel = in_mark || in_vsel;
 								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;
-									src_i < cur_mend;
+								// Toggle highlight attributes
-								attr_t a = A_NORMAL;
+								int attr = 0;
-								a        |= token_attr(token_at(src_i));
+								if (in_hl)
-								if (in_sel) {
+									attr |= A_STANDOUT;
-									a |= A_REVERSE;
+								if (in_cur)
-								} else {
+									attr |= A_BOLD;
-									if (in_hl)
+								if ((attr & A_STANDOUT) && !hl_on) {
-										a |= A_STANDOUT;
+									attron(A_STANDOUT);
-									if (in_cur)
+									hl_on = true;
-										a |= A_BOLD;
+								}
+								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));
 								}
-								attrset(a);
 								addch(' ');
 								++written;
 								++render_col;
 								--next_tab;
 							}
-							src_i += wch_len;
+							++src_i;
 							continue;
 						} else {
-							// normal char
+							if (!Utf8Enabled()) {
-							disp_w = wcwidth(wch);
+								// ASCII fallback: treat each byte as single width
-							if (disp_w < 0)
+								if (render_col + 1 <= coloffs) {
-								disp_w = 1; // non-printable or similar
+									++render_col;
-
+									++src_i;
-							if (render_col < coloffs) {
+									continue;
-								render_col += disp_w;
+								}
-								src_i      += wch_len;
+								wcw           = 1;
-								continue;
+								advance_bytes = 1;
+								from_src      = true;
+							} else {
+								// Decode one UTF-8 codepoint
+								mbstate_t st{};
+								const char *p   = line.data() + src_i;
+								std::size_t rem = line.size() - src_i;
+								wchar_t tmp_wc  = 0;
+								std::size_t n   = mbrtowc(&tmp_wc, p, rem, &st);
+								if (n == static_cast<std::size_t>(-1) || n ==
+								    static_cast<std::size_t>(-2) || n == 0) {
+									// Invalid/incomplete -> treat as single-byte placeholder
+									tmp_wc = L'?';
+									n      = 1;
+								}
+								int w = wcwidth(tmp_wc);
+								if (w < 0)
+									w = 1;
+								// If this codepoint is scrolled off to the left, skip it
+								if (render_col + static_cast<std::size_t>(w) <=
+								    coloffs) {
+									render_col += static_cast<std::size_t>(w);
+									src_i += n;
+									continue;
+								}
+								wcw           = w;
+								advance_bytes = n;
+								from_src      = true;
 							}
-							from_src = true;
 						}
 					} else {
 						// beyond EOL, fill spaces
-						wch      = L' ';
-						wch_len  = 1;
-						disp_w   = 1;
 						from_src = false;
 					}
-
+					bool in_hl  = search_mode && from_src && is_src_in_hl(src_i);
-					if (written + disp_w > cols) {
+					bool in_cur =
-						// would overflow, just break
+						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));
+					}
+					if (written + wcw > cols) {
 						break;
 					}
-
-					bool in_mark = from_src && is_src_in_mark_sel(li, src_i);
-					bool in_vsel = false;
-					if (vsel_on_line) {
-						if (from_src) {
-							in_vsel = !vsel_spot_is_eol && src_i == vsel_spot_src;
-						} else {
-							in_vsel = vsel_spot_is_eol && render_col == vsel_line_rx;
-						}
-					}
-					bool in_sel = in_mark || in_vsel;
-					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;
-					attr_t a = A_NORMAL;
-					if (from_src)
-						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;
+						// Output original bytes for this unit (UTF-8 codepoint or ASCII byte)
-						wchar_t warr[2] = {wch, L'\0'};
+						const char *cp = line.data() + (src_i);
-						setcchar(&cch, warr, 0, 0, nullptr);
+						int out_n      = Utf8Enabled() ? static_cast<int>(advance_bytes) : 1;
-						add_wch(&cch);
+						addnstr(cp, out_n);
+						src_i += static_cast<std::size_t>(out_n);
 					} else {
 						addch(' ');
 					}
-
+					written += wcw;
-					written    += disp_w;
+					render_col += wcw;
-					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();
 		}
 
-		// Place terminal cursor at logical position accounting for tabs and coloffs.
+		// Place terminal cursor at logical position accounting for tabs and coloffs
-		// Recompute the rendered X using the same logic as the drawing loop to avoid
+		std::size_t cy = buf->Cury();
-		// any drift between the command-layer computation and the terminal renderer.
+		std::size_t rx = buf->Rx(); // render x computed by command layer
-		std::size_t cy            = buf->Cury();
+		int cur_y      = static_cast<int>(cy) - static_cast<int>(buf->Rowoffs());
-		std::size_t cx            = buf->Curx();
+		int cur_x      = static_cast<int>(rx) - static_cast<int>(buf->Coloffs());
-		int cur_y                 = static_cast<int>(cy) - static_cast<int>(buf->Rowoffs());
-		std::size_t rx_recomputed = 0;
-		if (cy < lines.size()) {
-			const std::string line_for_cursor = static_cast<std::string>(lines[cy]);
-			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) {
-				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;
-					} else {
-						int dw         = wcwidth(wch);
-						render_col_cur += (dw < 0) ? 1 : dw;
-					}
-					src_i_cur += res;
-				}
-			}
-			rx_recomputed = render_col_cur;
-		}
-		int cur_x = static_cast<int>(rx_recomputed) - static_cast<int>(buf->Coloffs());
 		if (cur_y >= 0 && cur_y < content_rows && cur_x >= 0 && cur_x < cols) {
 			// remember where to leave the terminal cursor after status is drawn
 			saved_cur_y = cur_y;
@@ -503,9 +396,9 @@ TerminalRenderer::Draw(Editor &ed)
 	{
 		const char *app = "kte";
 		left.reserve(256);
-		left            += app;
+		left += app;
-		left            += " ";
+		left += " ";
-		left            += KTE_VERSION_STR; // already includes leading 'v'
+		left += KTE_VERSION_STR; // already includes leading 'v'
 		const Buffer *b = buf;
 		std::string fname;
 		if (b) {
@@ -526,11 +419,11 @@ TerminalRenderer::Draw(Editor &ed)
 			std::size_t total = ed.BufferCount();
 			if (total > 0) {
 				std::size_t idx1 = ed.CurrentBufferIndex() + 1; // human-friendly 1-based
-				left             += "[";
+				left += "[";
-				left             += std::to_string(static_cast<unsigned long long>(idx1));
+				left += std::to_string(static_cast<unsigned long long>(idx1));
-				left             += "/";
+				left += "/";
-				left             += std::to_string(static_cast<unsigned long long>(total));
+				left += std::to_string(static_cast<unsigned long long>(total));
-				left             += "] ";
+				left += "] ";
 			}
 		}
 		left += fname;
@@ -542,9 +435,9 @@ TerminalRenderer::Draw(Editor &ed)
 		// Append total line count as "<n>L"
 		if (b) {
 			unsigned long lcount = static_cast<unsigned long>(b->Rows().size());
-			left                 += " ";
+			left += " ";
-			left                 += std::to_string(lcount);
+			left += std::to_string(lcount);
-			left                 += "L";
+			left += "L";
 		}
 	}
 
@@ -569,6 +462,10 @@ TerminalRenderer::Draw(Editor &ed)
 		else
 			std::snprintf(rbuf, sizeof(rbuf), "%d,%d | M: not set", row1, col1);
 		right = rbuf;
+		// If UTF-8 is not enabled (ASCII fallback), append a short hint
+		if (!Utf8Enabled()) {
+			right += " | ASCII";
+		}
 	}
 
 	// Compute placements with truncation rules: prioritize left and right; middle gets remaining

TerminalRenderer.h

@@ -1,7 +1,9 @@
 /*
  * TerminalRenderer - ncurses-based renderer for terminal mode
  */
-#pragma once
+#ifndef KTE_TERMINAL_RENDERER_H
+#define KTE_TERMINAL_RENDERER_H
+
 #include "Renderer.h"
 
 
@@ -12,4 +14,21 @@ public:
 	~TerminalRenderer() override;
 
 	void Draw(Editor &ed) override;
+
+	// Enable/disable UTF-8 aware rendering (set by TerminalFrontend after locale init)
+	void SetUtf8Enabled(bool on)
+	{
+		utf8_enabled_ = on;
+	}
+
+
+	[[nodiscard]] bool Utf8Enabled() const
+	{
+		return utf8_enabled_;
+	}
+
+private:
+	bool utf8_enabled_ = true;
 };
+
+#endif // KTE_TERMINAL_RENDERER_H

TestFrontend.cc

@@ -4,10 +4,8 @@
 
 
 bool
-TestFrontend::Init(int &argc, char **argv, Editor &ed)
+TestFrontend::Init(Editor &ed)
 {
-	(void) argc;
-	(void) argv;
 	ed.SetDimensions(24, 80);
 	return true;
 }
@@ -16,9 +14,6 @@ TestFrontend::Init(int &argc, char **argv, Editor &ed)
 void
 TestFrontend::Step(Editor &ed, bool &running)
 {
-	// Allow deferred opens (including swap recovery prompts) to run.
-	ed.ProcessPendingOpens();
-
 	MappedInput mi;
 	if (input_.Poll(mi)) {
 		if (mi.hasCommand) {

TestFrontend.h

@@ -1,7 +1,9 @@
 /*
  * TestFrontend.h - headless frontend for testing with programmable input
  */
-#pragma once
+#ifndef KTE_TEST_FRONTEND_H
+#define KTE_TEST_FRONTEND_H
+
 #include "Frontend.h"
 #include "TestInputHandler.h"
 #include "TestRenderer.h"
@@ -13,7 +15,7 @@ public:
 
 	~TestFrontend() override = default;
 
-	bool Init(int &argc, char **argv, Editor &ed) override;
+	bool Init(Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 
@@ -35,3 +37,5 @@ private:
 	TestInputHandler input_{};
 	TestRenderer renderer_{};
 };
+
+#endif // KTE_TEST_FRONTEND_H

TestInputHandler.h

@@ -1,7 +1,9 @@
 /*
  * TestInputHandler.h - programmable input handler for testing
  */
-#pragma once
+#ifndef KTE_TEST_INPUT_HANDLER_H
+#define KTE_TEST_INPUT_HANDLER_H
+
 #include <queue>
 
 #include "InputHandler.h"
@@ -28,3 +30,5 @@ public:
 private:
 	std::queue<MappedInput> queue_;
 };
+
+#endif // KTE_TEST_INPUT_HANDLER_H

TestRenderer.h

@@ -1,7 +1,9 @@
 /*
  * TestRenderer.h - minimal renderer for testing (no actual display)
  */
-#pragma once
+#ifndef KTE_TEST_RENDERER_H
+#define KTE_TEST_RENDERER_H
+
 #include <cstddef>
 
 #include "Renderer.h"
@@ -30,3 +32,5 @@ public:
 private:
 	std::size_t draw_count_ = 0;
 };
+
+#endif // KTE_TEST_RENDERER_H

UndoNode.h

@@ -1,4 +1,6 @@
-#pragma once
+#ifndef KTE_UNDONODE_H
+#define KTE_UNDONODE_H
+
 #include <cstdint>
 #include <string>
 
@@ -15,9 +17,10 @@ struct UndoNode {
 	UndoType type{};
 	int row{};
 	int col{};
-	std::uint64_t group_id = 0; // 0 means ungrouped; non-zero means undo/redo as an atomic group
 	std::string text;
-	UndoNode *parent = nullptr; // previous state; null means pre-first-edit
+	UndoNode *child = nullptr; // next in current timeline
-	UndoNode *child  = nullptr; // next in current timeline
+	UndoNode *next  = nullptr; // redo branch
-	UndoNode *next   = nullptr; // redo branch
 };
+
+
+#endif // KTE_UNDONODE_H

UndoNodePool.h

@@ -1,63 +0,0 @@
-#pragma once
-#include <stack>
-#include <vector>
-#include <memory>
-#include "UndoNode.h"
-
-// Pool allocator for UndoNode to eliminate frequent malloc/free.
-// Uses fixed-size blocks to keep node addresses stable.
-class UndoNodePool {
-public:
-	explicit UndoNodePool(std::size_t block_size = 64)
-		: block_size_(block_size) {}
-
-
-	UndoNode *acquire()
-	{
-		if (available_.empty())
-			allocate_block();
-		auto *node = available_.top();
-		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;
-		node->type   = UndoType{};
-		return node;
-	}
-
-
-	void release(UndoNode *node)
-	{
-		if (!node)
-			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;
-		node->type   = UndoType{};
-		available_.push(node);
-	}
-
-private:
-	void allocate_block()
-	{
-		// allocate a new block; keep ownership so memory stays valid
-		std::unique_ptr<UndoNode[]> block(new UndoNode[block_size_]);
-		UndoNode *base = block.get();
-		blocks_.push_back(std::move(block));
-		for (std::size_t i = 0; i < block_size_; ++i) {
-			// ensure the node is reset; rely on default constructor/zero init
-			available_.push(&base[i]);
-		}
-	}
-
-
-	std::size_t block_size_;
-	std::vector<std::unique_ptr<UndoNode[]> > blocks_;
-	std::stack<UndoNode *> available_;
-};

UndoSystem.cc

@@ -8,91 +8,60 @@ UndoSystem::UndoSystem(Buffer &owner, UndoTree &tree)
 	: buf_(&owner), tree_(tree) {}
 
 
-std::uint64_t
-UndoSystem::BeginGroup()
-{
-	// Ensure any pending typed run is sealed so the group is a distinct undo step.
-	commit();
-	if (active_group_id_ == 0)
-		active_group_id_ = next_group_id_++;
-	return active_group_id_;
-}
-
-
-void
-UndoSystem::EndGroup()
-{
-	commit();
-	active_group_id_ = 0;
-}
-
-
 void
 UndoSystem::Begin(UndoType type)
 {
-	if (!buf_)
+#ifdef KTE_UNDO_DEBUG
-		return;
+	debug_log("Begin");
+#endif
+	// Reuse pending if batching conditions are met
 	const int row = static_cast<int>(buf_->Cury());
 	const int col = static_cast<int>(buf_->Curx());
-
+	if (tree_.pending && tree_.pending->type == type && tree_.pending->row == row) {
-	// Some operations should always be standalone undo steps.
+		if (type == UndoType::Delete) {
-	const bool always_standalone = (type == UndoType::Newline || type == UndoType::DeleteRow);
+			// Support batching both forward deletes (DeleteChar) and backspace (prepend case)
-	if (always_standalone) {
+			// Forward delete: cursor stays at anchor col; keep batching when col == anchor
-		commit();
+			const auto anchor = static_cast<std::size_t>(tree_.pending->col);
-	}
+			if (anchor == static_cast<std::size_t>(col)) {
-
+				pending_prepend_ = false;
-	if (tree_.pending) {
+				return; // keep batching forward delete
-		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: {
+			// Backspace: cursor moved left by exactly one position relative to current anchor.
-				if (tree_.pending->row == row) {
+			// Extend batch by shifting anchor left and prepending the deleted byte.
-					// Two common delete shapes:
+			if (static_cast<std::size_t>(col) + 1 == anchor) {
-					// 1) backspace-run: cursor moves left each time (so new col is pending.col - 1)
+				tree_.pending->col = col;
-					// 2) delete-run: cursor stays, always deleting at the same col
+				pending_prepend_   = true;
-					if (col == tree_.pending->col) {
+				return;
-						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:
+		} else {
-			case UndoType::DeleteRow:
+			std::size_t expected = static_cast<std::size_t>(tree_.pending->col) + tree_.pending->text.
-				break;
+			                       size();
+			if (expected == static_cast<std::size_t>(col)) {
+				pending_prepend_ = false;
+				return; // keep batching
 			}
 		}
-		// Can't coalesce: seal the previous pending step.
-		commit();
 	}
+	// Otherwise commit any existing batch and start a new node
+	commit();
+	auto *node       = new UndoNode();
+	node->type       = type;
+	node->row        = row;
+	node->col        = col;
+	node->child      = nullptr;
+	node->next       = nullptr;
+	tree_.pending    = node;
+	pending_prepend_ = false;
 
-	// Start a new pending node.
+#ifdef KTE_UNDO_DEBUG
-	tree_.pending           = new UndoNode{};
+	debug_log("Begin:new");
-	tree_.pending->type     = type;
+#endif
-	tree_.pending->row      = row;
+	// Assert pending is detached from the tree
-	tree_.pending->col      = col;
+	assert(tree_.pending && "pending must exist after Begin");
-	tree_.pending->group_id = active_group_id_;
+	assert(tree_.pending != tree_.root);
-	tree_.pending->text.clear();
+	assert(tree_.pending != tree_.current);
-	tree_.pending->parent = nullptr;
+	assert(tree_.pending != tree_.saved);
-	tree_.pending->child  = nullptr;
+	assert(!is_descendant(tree_.root, tree_.pending));
-	tree_.pending->next   = nullptr;
-	pending_mode_         = PendingAppendMode::Append;
 }
 
 
@@ -101,11 +70,15 @@ UndoSystem::Append(char ch)
 {
 	if (!tree_.pending)
 		return;
-	if (pending_mode_ == PendingAppendMode::Prepend) {
+	if (pending_prepend_ && tree_.pending->type == UndoType::Delete) {
+		// Prepend for backspace so that text is in increasing column order
 		tree_.pending->text.insert(tree_.pending->text.begin(), ch);
 	} else {
 		tree_.pending->text.push_back(ch);
 	}
+#ifdef KTE_UNDO_DEBUG
+	debug_log("Append:ch");
+#endif
 }
 
 
@@ -114,131 +87,108 @@ UndoSystem::Append(std::string_view text)
 {
 	if (!tree_.pending)
 		return;
-	if (text.empty())
+	tree_.pending->text.append(text.data(), text.size());
-		return;
+#ifdef KTE_UNDO_DEBUG
-	if (pending_mode_ == PendingAppendMode::Prepend) {
+	debug_log("Append:sv");
-		tree_.pending->text.insert(0, text.data(), text.size());
+#endif
-	} else {
-		tree_.pending->text.append(text.data(), text.size());
-	}
 }
 
 
 void
 UndoSystem::commit()
 {
+#ifdef KTE_UNDO_DEBUG
+	debug_log("commit:enter");
+#endif
 	if (!tree_.pending)
 		return;
 
-	// Drop empty text batches for text-based operations.
+	// If we have redo branches from current, discard them (non-linear behavior)
-	if ((tree_.pending->type == UndoType::Insert || tree_.pending->type == UndoType::Delete
+	if (tree_.current && tree_.current->child) {
-	     || tree_.pending->type == UndoType::Paste)
+		free_node(tree_.current->child);
-	    && tree_.pending->text.empty()) {
+		tree_.current->child = nullptr;
-		delete tree_.pending;
+		// We diverged; saved snapshot cannot be on discarded branch anymore
-		tree_.pending = nullptr;
+		if (tree_.saved) {
-		pending_mode_ = PendingAppendMode::Append;
+			// If saved is not equal to current, keep it; if it was on discarded branch we cannot easily detect now.
-		return;
+			// For simplicity, leave saved as-is; dirty flag uses pointer equality.
-	}
-
-	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;
 	}
 
+	// Attach pending as next state
+	if (!tree_.root) {
+		tree_.root    = tree_.pending;
+		tree_.current = tree_.pending;
+	} else if (!tree_.current) {
+		// Should not happen if root exists, but handle gracefully
+		tree_.current = tree_.pending;
+	} else {
+		// Attach as primary child (head of redo list)
+		tree_.pending->next  = nullptr;
+		tree_.current->child = tree_.pending;
+		tree_.current        = tree_.pending;
+	}
 	tree_.pending = nullptr;
-	pending_mode_ = PendingAppendMode::Append;
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("commit:done");
+#endif
+	// post-conditions
+	assert(tree_.pending == nullptr && "pending must be cleared after commit");
 }
 
 
 void
 UndoSystem::undo()
 {
-	// Seal any in-progress typed run before undo.
+	// Close any pending batch
 	commit();
 	if (!tree_.current)
 		return;
-	debug_log("undo");
+	UndoNode *parent = find_parent(tree_.root, tree_.current);
-	const std::uint64_t gid = tree_.current->group_id;
+	UndoNode *node   = tree_.current;
-	do {
+	// Apply inverse of current node
-		UndoNode *node = tree_.current;
+	apply(node, -1);
-		apply(node, -1);
+	tree_.current = parent;
-		tree_.current = node->parent;
-	} while (gid != 0 && tree_.current && tree_.current->group_id == gid);
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("undo");
+#endif
 }
 
 
 void
-UndoSystem::redo(int branch_index)
+UndoSystem::redo()
 {
-	commit();
+	// Redo next child along current timeline
-	UndoNode **head = nullptr;
+	if (tree_.pending) {
+		// If app added pending edits, finalize them before redo chain
+		commit();
+	}
+	UndoNode *next = nullptr;
 	if (!tree_.current) {
-		head = &tree_.root;
+		next = tree_.root; // if nothing yet, try applying first node
 	} else {
-		head = &tree_.current->child;
+		next = tree_.current->child;
 	}
-	if (!head || !*head)
+	if (!next)
 		return;
-	if (branch_index < 0)
+	apply(next, +1);
-		branch_index = 0;
+	tree_.current = next;
-
-	// 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");
-	UndoNode *node          = *head;
-	const std::uint64_t gid = node->group_id;
-	apply(node, +1);
-	tree_.current = node;
-	while (gid != 0 && tree_.current && tree_.current->child
-	       && tree_.current->child->group_id == gid) {
-		UndoNode *child = tree_.current->child;
-		apply(child, +1);
-		tree_.current = child;
-	}
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("redo");
+#endif
 }
 
 
 void
 UndoSystem::mark_saved()
 {
-	commit();
 	tree_.saved = tree_.current;
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("mark_saved");
+#endif
 }
 
 
@@ -249,21 +199,26 @@ UndoSystem::discard_pending()
 		delete tree_.pending;
 		tree_.pending = nullptr;
 	}
-	pending_mode_ = PendingAppendMode::Append;
+#ifdef KTE_UNDO_DEBUG
+	debug_log("discard_pending");
+#endif
 }
 
 
 void
 UndoSystem::clear()
 {
-	discard_pending();
+	if (tree_.root) {
-	free_node(tree_.root);
+		free_node(tree_.root);
-	tree_.root       = nullptr;
+	}
-	tree_.current    = nullptr;
+	if (tree_.pending) {
-	tree_.saved      = nullptr;
+		delete tree_.pending;
-	active_group_id_ = 0;
+	}
-	next_group_id_   = 1;
+	tree_.root = tree_.current = tree_.saved = tree_.pending = nullptr;
 	update_dirty_flag();
+#ifdef KTE_UNDO_DEBUG
+	debug_log("clear");
+#endif
 }
 
 
@@ -272,46 +227,34 @@ 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

@@ -1,45 +1,6 @@
-/*
+#ifndef KTE_UNDOSYSTEM_H
- * UndoSystem.h - undo/redo system with tree-based branching
+#define KTE_UNDOSYSTEM_H
- *
+
- * UndoSystem manages the undo/redo history for a Buffer. It provides:
- *
- * - Tree-based undo: Multiple redo branches at each node (not just linear history)
- * - Atomic grouping: Multiple operations can be undone/redone as a single step
- * - Dirty tracking: Marks when buffer matches last saved state
- * - Efficient storage: Nodes stored in UndoTree, operations applied to Buffer
- *
- * Key concepts:
- *
- * 1. Undo tree structure:
- *    - Each edit creates a node in the tree
- *    - Undo moves up the tree (toward root)
- *    - Redo moves down the tree (toward leaves)
- *    - Multiple redo branches preserved (not lost on new edits after undo)
- *
- * 2. Operation lifecycle:
- *    - Begin(type): Start recording an operation (insert/delete)
- *    - Append(text): Add content to the pending operation
- *    - commit(): Finalize and add to undo tree
- *    - discard_pending(): Cancel without recording
- *
- * 3. Atomic grouping:
- *    - BeginGroup()/EndGroup(): Bracket multiple operations
- *    - All operations in a group share the same group_id
- *    - Undo/redo treats the entire group as one step
- *
- * 4. Integration with Buffer:
- *    - UndoSystem holds a reference to its owning Buffer
- *    - apply() executes undo/redo by calling Buffer's editing methods
- *    - Buffer's dirty flag updated automatically
- *
- * Usage pattern:
- *   undo_system.Begin(UndoType::Insert);
- *   undo_system.Append("text");
- *   undo_system.commit();  // Now undoable
- *
- * See also: UndoTree.h (storage), UndoNode.h (node structure)
- */
-#pragma once
 #include <string_view>
 #include <cstddef>
 #include <cstdint>
@@ -53,12 +14,6 @@ class UndoSystem {
 public:
 	explicit UndoSystem(Buffer &owner, UndoTree &tree);
 
-	// Begin an atomic group: subsequent committed nodes with the same group_id will be
-	// undone/redone as a single step. Returns the active group id.
-	std::uint64_t BeginGroup();
-
-	void EndGroup();
-
 	void Begin(UndoType type);
 
 	void Append(char ch);
@@ -69,10 +24,7 @@ public:
 
 	void undo();
 
-	// Redo the current node's active child branch.
+	void redo();
-	// 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();
 
@@ -82,20 +34,7 @@ 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);
 
@@ -111,11 +50,10 @@ private:
 
 	void update_dirty_flag();
 
-	PendingAppendMode pending_mode_ = PendingAppendMode::Append;
-
-	std::uint64_t active_group_id_ = 0;
-	std::uint64_t next_group_id_   = 1;
-
 	Buffer *buf_;
 	UndoTree &tree_;
+	// Internal hint for Delete batching: whether next Append() should prepend
+	bool pending_prepend_ = false;
 };
+
+#endif // KTE_UNDOSYSTEM_H

UndoTree.h

@@ -1,4 +1,6 @@
-#pragma once
+#ifndef KTE_UNDOTREE_H
+#define KTE_UNDOTREE_H
+
 #include "UndoNode.h"
 
 
@@ -8,3 +10,6 @@ struct UndoTree {
 	UndoNode *saved   = nullptr; // points to node matching last save (for dirty flag)
 	UndoNode *pending = nullptr; // in-progress batch (detached)
 };
+
+
+#endif // KTE_UNDOTREE_H

cmake/Info.plist.in

@@ -24,8 +24,5 @@
     <string>10.13</string>
     <key>NSHighResolutionCapable</key>
     <true/>
-    <!-- Allow running multiple instances of the app -->
-    <key>LSMultipleInstancesProhibited</key>
-    <false/>
 </dict>
 </plist>

cmake/fix_bundle.cmake

@@ -1,78 +0,0 @@
-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}")

default.nix

@@ -1,17 +1,14 @@
 {
-  pkgs ? import <nixpkgs> {},
+  lib,
-  lib ? pkgs.lib,
   stdenv,
   cmake,
   ncurses,
   SDL2,
   libGL,
   xorg,
-  kdePackages,
-  qt6Packages ? kdePackages.qt6Packages,
   installShellFiles,
+
   graphical ? false,
-  graphical-qt ? false,
   ...
 }:
 let
@@ -37,16 +34,10 @@ stdenv.mkDerivation {
     SDL2
     libGL
     xorg.libX11
-  ]
-  ++ lib.optionals graphical-qt [
-    kdePackages.qt6ct
-    qt6Packages.qtbase
-    qt6Packages.wrapQtAppsHook
   ];
 
   cmakeFlags = [
     "-DBUILD_GUI=${if graphical then "ON" else "OFF"}"
-    "-DKTE_USE_QT=${if graphical-qt then "ON" else "OFF"}"
     "-DCMAKE_BUILD_TYPE=Debug"
   ];
 
@@ -55,23 +46,17 @@ stdenv.mkDerivation {
 
     mkdir -p $out/bin
     cp kte $out/bin/
+
     installManPage ../docs/kte.1
 
-    ${lib.optionalString graphical ''
+  ''
-      mkdir -p $out/bin
+  + lib.optionalString graphical ''
-  
+    cp kge $out/bin/
-    ${if graphical-qt then ''
+    installManPage ../docs/kge.1
-        cp kge $out/bin/kge-qt
+    mkdir -p $out/share/icons
-      '' else ''
+    cp ../kge.png $out/share/icons/
-        cp kge $out/bin/kge
+  ''
-      ''}
+  + ''
-
-      installManPage ../docs/kge.1
-
-      mkdir -p $out/share/icons/hicolor/256x256/apps
-      cp ../kge.png $out/share/icons/hicolor/256x256/apps/kge.png
-    ''}
-
     runHook postInstall
   '';
 }

docker-build.sh

@@ -1,28 +0,0 @@
-#!/bin/bash
-# Helper script to test Linux builds using Docker/Podman
-# This script mounts the current source tree into a Linux container,
-# builds kte in terminal-only mode, and runs the test suite.
-
-set -e
-
-# Detect whether to use docker or podman
-if command -v docker &> /dev/null; then
-    CONTAINER_CMD="docker"
-elif command -v podman &> /dev/null; then
-    CONTAINER_CMD="podman"
-else
-    echo "Error: Neither docker nor podman found in PATH"
-    exit 1
-fi
-
-IMAGE_NAME="kte-linux"
-
-# Check if image exists, if not, build it
-if ! $CONTAINER_CMD image inspect "$IMAGE_NAME" &> /dev/null; then
-    echo "Building $IMAGE_NAME image..."
-    $CONTAINER_CMD build -t "$IMAGE_NAME" .
-fi
-
-# Run the container with the current directory mounted
-echo "Running Linux build and tests..."
-$CONTAINER_CMD run --rm -v "$(pwd):/kte" "$IMAGE_NAME"

docs/BENCHMARKS.md

@@ -1,245 +0,0 @@
-# kte Benchmarking and Testing Guide
-
-This document describes the benchmarking infrastructure and testing
-improvements added to ensure high performance and correctness of core
-operations.
-
-## Overview
-
-The kte test suite now includes comprehensive benchmarks and migration
-coverage tests to:
-
-- Measure performance of core operations (PieceTable, Buffer, syntax
-  highlighting)
-- Ensure no performance regressions from refactorings
-- Validate correctness of API migrations (Buffer::Rows() →
-  GetLineString/GetLineView)
-- Provide performance baselines for future optimizations
-
-## Running Tests
-
-### All Tests (including benchmarks)
-
-```bash
-cmake --build cmake-build-debug --target kte_tests && ./cmake-build-debug/kte_tests
-```
-
-### Test Organization
-
-- **58 existing tests**: Core functionality, undo/redo, swap recovery,
-  search, etc.
-- **15 benchmark tests**: Performance measurements for critical
-  operations
-- **30 migration coverage tests**: Edge cases and correctness validation
-
-Total: **98 tests**
-
-## Benchmark Results
-
-### Buffer Iteration Patterns (5,000 lines)
-
-| Pattern                                 | Time    | Speedup vs Rows() |
-|-----------------------------------------|---------|-------------------|
-| `Rows()` + iteration                    | 3.1 ms  | 1.0x (baseline)   |
-| `Nrows()` + `GetLineString()`           | 1.9 ms  | **1.7x faster**   |
-| `Nrows()` + `GetLineView()` (zero-copy) | 0.28 ms | **11x faster**    |
-
-**Key Insight**: `GetLineView()` provides zero-copy access and is
-dramatically faster than materializing the entire rows cache.
-
-### PieceTable Operations (10,000 lines)
-
-| Operation                   | Time    |
-|-----------------------------|---------|
-| Sequential inserts (10K)    | 2.1 ms  |
-| Random inserts (5K)         | 32.9 ms |
-| `GetLine()` sequential      | 4.7 ms  |
-| `GetLineRange()` sequential | 1.3 ms  |
-
-### Buffer Operations
-
-| Operation                            | Time    |
-|--------------------------------------|---------|
-| `Nrows()` (1M calls)                 | 13.0 ms |
-| `GetLineString()` (10K lines)        | 4.8 ms  |
-| `GetLineView()` (10K lines)          | 1.6 ms  |
-| `Rows()` materialization (10K lines) | 6.2 ms  |
-
-### Syntax Highlighting
-
-| Operation                          | Time    | Notes          |
-|------------------------------------|---------|----------------|
-| C++ highlighting (~1000 lines)     | 2.0 ms  | First pass     |
-| HighlighterEngine cache population | 19.9 ms |                |
-| HighlighterEngine cache hits       | 0.52 ms | **38x faster** |
-
-### Large File Performance
-
-| Operation                       | Time    |
-|---------------------------------|---------|
-| Insert 50K lines                | 0.53 ms |
-| Iterate 50K lines (GetLineView) | 2.7 ms  |
-| Random access (10K accesses)    | 1.8 ms  |
-
-## API Differences: GetLineString vs GetLineView
-
-Understanding the difference between these APIs is critical:
-
-### `GetLineString(row)`
-
-- Returns: `std::string` (copy)
-- Content: Line text **without** trailing newline
-- Use case: When you need to modify the string or store it
-- Example: `"hello"` for line `"hello\n"`
-
-### `GetLineView(row)`
-
-- Returns: `std::string_view` (zero-copy)
-- Content: Raw line range **including** trailing newline
-- Use case: Read-only access, maximum performance
-- Example: `"hello\n"` for line `"hello\n"`
-- **Warning**: View becomes invalid after buffer modifications
-
-### `Rows()`
-
-- Returns: `std::vector<Buffer::Line>&` (materialized cache)
-- Content: Lines **without** trailing newlines
-- Use case: Legacy code, being phased out
-- Performance: Slower due to materialization overhead
-
-## Migration Coverage Tests
-
-The `test_migration_coverage.cc` file provides 30 tests covering:
-
-### Edge Cases
-
-- Empty buffers
-- Single lines (with/without newlines)
-- Very long lines (10,000 characters)
-- Many empty lines (1,000 newlines)
-
-### Consistency
-
-- `GetLineString()` vs `GetLineView()` vs `Rows()`
-- Consistency after edits (insert, delete, split, join)
-
-### Boundary Conditions
-
-- First line access
-- Last line access
-- Line range boundaries
-
-### Special Characters
-
-- Tabs, carriage returns, null bytes
-- Unicode (UTF-8 multibyte characters)
-
-### Stress Tests
-
-- Large files (10,000 lines)
-- Many small operations (100+ inserts)
-- Alternating insert/delete patterns
-
-### Regression Tests
-
-- Shebang detection pattern (Editor.cc)
-- Empty buffer check pattern (Editor.cc)
-- Syntax highlighter pattern (all highlighters)
-- Swap snapshot pattern (Swap.cc)
-
-## Performance Recommendations
-
-Based on benchmark results:
-
-1. **Prefer `GetLineView()` for read-only access**
-    - 11x faster than `Rows()` for iteration
-    - Zero-copy, minimal overhead
-    - Use immediately (view invalidates on edit)
-
-2. **Use `GetLineString()` when you need a copy**
-    - Still 1.7x faster than `Rows()`
-    - Safe to store and modify
-    - Strips trailing newlines automatically
-
-3. **Avoid `Rows()` in hot paths**
-    - Materializes entire line cache
-    - Slower for large files
-    - Being phased out (legacy API)
-
-4. **Cache `Nrows()` in tight loops**
-    - Very fast (13ms for 1M calls)
-    - But still worth caching in inner loops
-
-5. **Leverage HighlighterEngine caching**
-    - 38x speedup on cache hits
-    - Automatically invalidates on edits
-    - Prefetch viewport for smooth scrolling
-
-## Adding New Benchmarks
-
-To add a new benchmark:
-
-1. Add a `TEST(Benchmark_YourName)` in `tests/test_benchmarks.cc`
-2. Use `BenchmarkTimer` to measure critical sections:
-   ```cpp
-   {
-       BenchmarkTimer timer("Operation description");
-       // ... code to benchmark ...
-   }
-   ```
-3. Print section headers with `std::cout` for clarity
-4. Use `ASSERT_EQ` or `EXPECT_TRUE` to validate results
-
-Example:
-
-```cpp
-TEST(Benchmark_MyOperation) {
-    std::cout << "\n=== My Operation Benchmark ===\n";
-    
-    // Setup
-    Buffer buf;
-    std::string data = generate_test_data();
-    buf.insert_text(0, 0, data);
-    
-    std::size_t result = 0;
-    {
-        BenchmarkTimer timer("My operation on 10K lines");
-        for (std::size_t i = 0; i < buf.Nrows(); ++i) {
-            result += my_operation(buf, i);
-        }
-    }
-    
-    EXPECT_TRUE(result > 0);
-}
-```
-
-## Continuous Performance Monitoring
-
-Run benchmarks regularly to detect regressions:
-
-```bash
-# Run tests and save output
-./cmake-build-debug/kte_tests > benchmark_results.txt
-
-# Compare with baseline
-diff benchmark_baseline.txt benchmark_results.txt
-```
-
-Look for:
-
-- Significant time increases (>20%) in any benchmark
-- New operations that are slower than expected
-- Cache effectiveness degradation
-
-## Conclusion
-
-The benchmark suite provides:
-
-- **Performance validation**: Ensures migrations don't regress
-  performance
-- **Optimization guidance**: Identifies fastest APIs for each use case
-- **Regression detection**: Catches performance issues early
-- **Documentation**: Demonstrates correct API usage patterns
-
-All 98 tests pass with 0 failures, confirming both correctness and
-performance of the migrated codebase.

docs/TestFrontend.md

@@ -2,43 +2,27 @@
 
 ## Overview
 
-`TestFrontend` is a headless implementation of the `Frontend` interface
+`TestFrontend` is a headless implementation of the `Frontend` interface designed to facilitate programmatic testing of editor features. It allows you to queue commands and text input manually, execute them step-by-step, and inspect the editor/buffer state.
-designed to facilitate programmatic testing of editor features. It
-allows you to queue commands and text input manually, execute them
-step-by-step, and inspect the editor/buffer state.
 
 ## Components
 
 ### TestInputHandler
-
 A programmable input handler that uses a queue-based system:
-
+- `QueueCommand(CommandId id, const std::string &arg = "", int count = 0)` - Queue a specific command
--
+- `QueueText(const std::string &text)` - Queue text for insertion (character by character)
-`QueueCommand(CommandId id, const std::string &arg = "", int count = 0)` -
-Queue a specific command
-- `QueueText(const std::string &text)` - Queue text for insertion (
-  character by character)
 - `Poll(MappedInput &out)` - Returns queued commands one at a time
 - `IsEmpty()` - Check if the input queue is empty
 
 ### TestRenderer
-
 A minimal no-op renderer for testing:
-
+- `Draw(Editor &ed)` - No-op implementation, just increments draw counter
-- `Draw(Editor &ed)` - No-op implementation, just increments draw
-  counter
 - `GetDrawCount()` - Returns the number of times Draw() was called
 - `ResetDrawCount()` - Resets the draw counter
 
 ### TestFrontend
-
+The main frontend class that integrates TestInputHandler and TestRenderer:
-The main frontend class that integrates TestInputHandler and
+- `Init(Editor &ed)` - Initializes the frontend (sets editor dimensions to 24x80)
-TestRenderer:
+- `Step(Editor &ed, bool &running)` - Processes one command from the queue and renders
-
-- `Init(Editor &ed)` - Initializes the frontend (sets editor dimensions
-  to 24x80)
-- `Step(Editor &ed, bool &running)` - Processes one command from the
-  queue and renders
 - `Shutdown()` - Cleanup (no-op for TestFrontend)
 - `Input()` - Access the TestInputHandler
 - `Renderer()` - Access the TestRenderer
@@ -91,55 +75,31 @@ int main() {
 
 ## Key Features
 
-1. **Programmable Input**: Queue any sequence of commands or text
+1. **Programmable Input**: Queue any sequence of commands or text programmatically
-   programmatically
 2. **Step-by-Step Execution**: Run the editor one command at a time
-3. **State Inspection**: Access and verify editor/buffer state between
+3. **State Inspection**: Access and verify editor/buffer state between commands
-   commands
+4. **No UI Dependencies**: Headless operation, no terminal or GUI required
-4. **No UI Dependencies**: Headless operation, no terminal or GUI
+5. **Integration Testing**: Test command sequences, undo/redo, multi-line editing, etc.
-   required
-5. **Integration Testing**: Test command sequences, undo/redo,
-   multi-line editing, etc.
 
 ## Available Commands
 
 All commands from `CommandId` enum can be queued, including:
-
 - `CommandId::InsertText` - Insert text (use `QueueText()` helper)
 - `CommandId::Newline` - Insert newline
 - `CommandId::Backspace` - Delete character before cursor  
 - `CommandId::DeleteChar` - Delete character at cursor
-- `CommandId::MoveLeft`, `MoveRight`, `MoveUp`, `MoveDown` - Cursor
+- `CommandId::MoveLeft`, `MoveRight`, `MoveUp`, `MoveDown` - Cursor movement
-  movement
 - `CommandId::Undo`, `CommandId::Redo` - Undo/redo operations
 - `CommandId::Save`, `CommandId::Quit` - File operations
 - And many more (see Command.h)
 
 ## Integration
 
-TestFrontend is built into both `kte` and `kge` executables as part of
+TestFrontend is built into both `kte` and `kge` executables as part of the common source files. You can create standalone test programs by linking against the same source files and ncurses.
-the common source files. You can create standalone test programs by
-linking against the same source files and ncurses.
 
 ## Notes
 
 - Always call `InstallDefaultCommands()` before using any commands
-- Buffer must be initialized (via `OpenFile()` or `AddBuffer()`) before
+- Buffer must be initialized (via `OpenFile()` or `AddBuffer()`) before queuing edit commands
-  queuing edit commands
 - Undo/redo requires the buffer to have an UndoSystem attached
 - The test frontend sets editor dimensions to 24x80 by default
-
-## Highlighter stress harness
-
-For renderer/highlighter race testing without a UI, `kte` provides a
-lightweight stress mode:
-
-```
-kte --stress-highlighter=5
-```
-
-This runs a short synthetic workload (5 seconds by default) that edits
-and scrolls a buffer while
-exercising `HighlighterEngine::PrefetchViewport` and `GetLine`
-concurrently. Use Debug builds with
-AddressSanitizer enabled for best effect.

docs/audits/error-propagation-standardization.md

@@ -1,549 +0,0 @@
-# Error Propagation Standardization Report
-
-**Project:** kte (Kyle's Text Editor)  
-**Date:** 2026-02-17  
-**Auditor:** Error Propagation Standardization Review  
-**Language:** C++20
-
----
-
-## Executive Summary
-
-This report documents the standardization of error propagation patterns
-across the kte codebase. Following the implementation of centralized
-error handling (ErrorHandler), this audit identifies inconsistencies in
-error propagation and provides concrete remediation recommendations.
-
-**Key Findings:**
-
-- **Dominant Pattern**: `bool + std::string &err` is used consistently
-  in Buffer and SwapManager for I/O operations
-- **Inconsistencies**: PieceTable has no error reporting mechanism; some
-  internal helpers lack error propagation
-- **Standard Chosen**: `bool + std::string &err` pattern (C++20 project,
-  std::expected not available)
-- **Documentation**: Comprehensive error handling conventions added to
-  DEVELOPER_GUIDE.md
-
-**Overall Assessment**: The codebase has a **solid foundation** with the
-`bool + err` pattern used consistently in critical I/O paths. Primary
-gaps are in PieceTable memory allocation error handling and some
-internal helper functions.
-
----
-
-## 1. CURRENT STATE ANALYSIS
-
-### 1.1 Error Propagation Patterns Found
-
-#### Pattern 1: `bool + std::string &err` (Dominant)
-
-**Usage**: File I/O, swap operations, resource allocation
-
-**Examples**:
-
-- `Buffer::OpenFromFile(const std::string &path, std::string &err)` (
-  Buffer.h:72)
-- `Buffer::Save(std::string &err)` (Buffer.h:74)
-- `Buffer::SaveAs(const std::string &path, std::string &err)` (Buffer.h:
-  75)
-- `Editor::OpenFile(const std::string &path, std::string &err)` (
-  Editor.h:536)
--
-`SwapManager::ReplayFile(Buffer &buf, const std::string &swap_path, std::string &err)` (
-Swap.h:104)
--
-`SwapManager::open_ctx(JournalCtx &ctx, const std::string &path, std::string &err)` (
-Swap.h:208)
--
-`SwapManager::compact_to_checkpoint(JournalCtx &ctx, const std::vector<std::uint8_t> &chkpt_record, std::string &err)` (
-Swap.h:212-213)
-
-**Assessment**: ✅ **Excellent** - Consistent, well-implemented,
-integrated with ErrorHandler
-
-#### Pattern 2: `void` (State Changes)
-
-**Usage**: Setters, cursor movement, flag toggles, internal state
-modifications
-
-**Examples**:
-
-- `Buffer::SetCursor(std::size_t x, std::size_t y)` (Buffer.h:348)
-- `Buffer::SetDirty(bool d)` (Buffer.h:368)
-- `Buffer::SetMark(std::size_t x, std::size_t y)` (Buffer.h:387)
-- `Buffer::insert_text(int row, int col, std::string_view text)` (
-  Buffer.h:545)
-- `Buffer::delete_text(int row, int col, std::size_t len)` (Buffer.h:
-  547)
-- `Editor::SetStatus(const std::string &msg)` (Editor.h:various)
-
-**Assessment**: ✅ **Appropriate** - These operations are infallible
-state changes
-
-#### Pattern 3: `bool` without error parameter (Control Flow)
-
-**Usage**: Validation checks, control flow decisions
-
-**Examples**:
-
-- `Editor::ProcessPendingOpens()` (Editor.h:544)
-- `Editor::ResolveRecoveryPrompt(bool yes)` (Editor.h:558)
-- `Editor::SwitchTo(std::size_t index)` (Editor.h:563)
-- `Editor::CloseBuffer(std::size_t index)` (Editor.h:565)
-
-**Assessment**: ✅ **Appropriate** - Success/failure is sufficient for
-control flow
-
-#### Pattern 4: No Error Reporting (PieceTable)
-
-**Usage**: Memory allocation, text manipulation
-
-**Examples**:
-
-- `void PieceTable::Reserve(std::size_t newCapacity)` (PieceTable.h:71)
-- `void PieceTable::Append(const char *s, std::size_t len)` (
-  PieceTable.h:75)
--
-`void PieceTable::Insert(std::size_t byte_offset, const char *text, std::size_t len)` (
-PieceTable.h:118)
-- `char *PieceTable::Data()` (PieceTable.h:89-93) - returns nullptr on
-  allocation failure
-
-**Assessment**: ⚠️ **Gap** - Memory allocation failures are not reported
-
----
-
-## 2. STANDARDIZATION DECISION
-
-### 2.1 Chosen Pattern: `bool + std::string &err`
-
-**Rationale**:
-
-1. **C++20 Project**: `std::expected` (C++23) is not available
-2. **Existing Adoption**: Already used consistently in Buffer,
-   SwapManager, Editor for I/O operations
-3. **Clear Semantics**: `bool` return indicates success/failure, `err`
-   provides details
-4. **ErrorHandler Integration**: Works seamlessly with centralized error
-   logging
-5. **Zero Overhead**: No exceptions, no dynamic allocation for error
-   paths
-6. **Testability**: Easy to verify error messages in unit tests
-
-**Alternative Considered**: `std::expected<T, std::string>` (C++23)
-
-- **Rejected**: Requires C++23, would require major refactoring, not
-  available in current toolchain
-
-### 2.2 Pattern Selection Guidelines
-
-| Operation Type      | Pattern                   | Example                                                                           |
-|---------------------|---------------------------|-----------------------------------------------------------------------------------|
-| File I/O            | `bool + std::string &err` | `Buffer::Save(std::string &err)`                                                  |
-| Syscalls            | `bool + std::string &err` | `open_ctx(JournalCtx &ctx, const std::string &path, std::string &err)`            |
-| Resource Allocation | `bool + std::string &err` | Future: `PieceTable::Reserve(std::size_t cap, std::string &err)`                  |
-| Parsing/Validation  | `bool + std::string &err` | `SwapManager::ReplayFile(Buffer &buf, const std::string &path, std::string &err)` |
-| State Changes       | `void`                    | `Buffer::SetCursor(std::size_t x, std::size_t y)`                                 |
-| Control Flow        | `bool` (no err)           | `Editor::SwitchTo(std::size_t index)`                                             |
-
----
-
-## 3. INCONSISTENCIES AND GAPS
-
-### 3.1 PieceTable Memory Allocation (Severity: 6/10)
-
-**Finding**: PieceTable methods that allocate memory (`Reserve`,
-`Append`, `Insert`, `Data`) do not report allocation failures.
-
-**Impact**:
-
-- Memory allocation failures are silent
-- `Data()` returns `nullptr` on failure, but callers may not check
-- Large file operations could fail without user notification
-
-**Evidence**:
-
-```cpp
-// PieceTable.h:71
-void Reserve(std::size_t newCapacity);  // No error reporting
-
-// PieceTable.h:89-93
-char *Data();  // Returns nullptr on allocation failure
-```
-
-**Remediation Priority**: **Medium** - Memory allocation failures are
-rare on modern systems, but should be handled for robustness
-
-**Recommended Fix**:
-
-**Option 1: Add error parameter to fallible operations** (Preferred)
-
-```cpp
-// PieceTable.h
-bool Reserve(std::size_t newCapacity, std::string &err);
-bool Append(const char *s, std::size_t len, std::string &err);
-bool Insert(std::size_t byte_offset, const char *text, std::size_t len, std::string &err);
-
-// Returns nullptr on failure; check with HasMaterializationError()
-char *Data();
-bool HasMaterializationError() const;
-std::string GetMaterializationError() const;
-```
-
-**Option 2: Use exceptions for allocation failures** (Not recommended)
-
-PieceTable could throw `std::bad_alloc` on allocation failures, but this
-conflicts with the project's error handling philosophy and would require
-exception handling throughout the codebase.
-
-**Option 3: Status quo with improved documentation** (Minimal change)
-
-Document that `Data()` can return `nullptr` and callers must check. Add
-assertions in debug builds.
-
-```cpp
-// PieceTable.h
-// Returns pointer to materialized buffer, or nullptr if materialization fails.
-// Callers MUST check for nullptr before dereferencing.
-char *Data();
-```
-
-**Recommendation**: **Option 3** for now (document + assertions), *
-*Option 1** if memory allocation errors become a concern in production.
-
-### 3.2 Internal Helper Functions (Severity: 4/10)
-
-**Finding**: Some internal helper functions in Swap.cc and Buffer.cc use
-`bool` returns without error parameters.
-
-**Examples**:
-
-```cpp
-// Swap.cc:562
-static bool ensure_parent_dir(const std::string &path);  // No error details
-
-// Swap.cc:579
-static bool write_header(int fd);  // No error details
-
-// Buffer.cc:101
-static bool write_all_fd(int fd, const char *data, std::size_t len, std::string &err);  // ✅ Good
-```
-
-**Impact**: Limited - These are internal helpers called by functions
-that do report errors
-
-**Remediation Priority**: **Low** - Callers already provide error
-context
-
-**Recommended Fix**: Add error parameters to internal helpers for
-consistency
-
-```cpp
-// Swap.cc
-static bool ensure_parent_dir(const std::string &path, std::string &err);
-static bool write_header(int fd, std::string &err);
-```
-
-**Status**: **Deferred** - Low priority, callers already provide
-adequate error context
-
-### 3.3 Editor Control Flow Methods (Severity: 2/10)
-
-**Finding**: Editor methods like `SwitchTo()`, `CloseBuffer()` return
-`bool` without error details.
-
-**Assessment**: ✅ **Appropriate** - These are control flow decisions
-where success/failure is sufficient
-
-**Remediation**: **None needed** - Current pattern is correct for this
-use case
-
----
-
-## 4. ERRORHANDLER INTEGRATION STATUS
-
-### 4.1 Components with ErrorHandler Integration
-
-✅ **Buffer** (Buffer.cc)
-
-- `OpenFromFile()` - Reports file open, seek, read errors
-- `Save()` - Reports write errors
-- `SaveAs()` - Reports write errors
-
-✅ **SwapManager** (Swap.cc)
-
-- `report_error()` - All swap file errors reported
-- Background thread errors captured and logged
-- Errno captured for all syscalls
-
-✅ **main** (main.cc)
-
-- Top-level exception handler reports Critical errors
-- Both `std::exception` and unknown exceptions captured
-
-### 4.2 Components Without ErrorHandler Integration
-
-⚠️ **PieceTable** (PieceTable.cc)
-
-- No error reporting mechanism
-- Memory allocation failures are silent
-
-⚠️ **Editor** (Editor.cc)
-
-- File operations delegate to Buffer (✅ covered)
-- Control flow methods don't need error reporting (✅ appropriate)
-
-⚠️ **Command** (Command.cc)
-
-- Commands use `Editor::SetStatus()` for user-facing messages
-- No ErrorHandler integration for command failures
-- **Assessment**: Commands are user-initiated actions; status messages
-  are appropriate
-
----
-
-## 5. DOCUMENTATION STATUS
-
-### 5.1 Error Handling Conventions (DEVELOPER_GUIDE.md)
-
-✅ **Added comprehensive section** covering:
-
-- Three standard error propagation patterns
-- Pattern selection guidelines with decision tree
-- ErrorHandler integration requirements
-- Code examples for file I/O, syscalls, background threads, top-level
-  handlers
-- Anti-patterns and best practices
-- Error log location and format
-- Migration guide for updating existing code
-
-**Location**: `docs/DEVELOPER_GUIDE.md` section 7
-
-### 5.2 API Documentation
-
-⚠️ **Gap**: Individual function documentation in headers could be
-improved
-
-**Recommendation**: Add brief comments to public APIs documenting error
-behavior
-
-```cpp
-// Buffer.h
-// Opens a file and loads its content into the buffer.
-// Returns false on failure; err contains detailed error message.
-// Errors are logged to ErrorHandler.
-bool OpenFromFile(const std::string &path, std::string &err);
-```
-
----
-
-## 6. REMEDIATION RECOMMENDATIONS
-
-### 6.1 High Priority (Severity 7-10)
-
-**None identified** - Critical error handling gaps were addressed in
-previous sessions:
-
-- ✅ Top-level exception handler added (Severity 9/10)
-- ✅ Background thread error reporting added (Severity 9/10)
-- ✅ File I/O error checking added (Severity 8/10)
-- ✅ Errno capture added to swap operations (Severity 7/10)
-- ✅ Centralized error handling implemented (Severity 7/10)
-
-### 6.2 Medium Priority (Severity 4-6)
-
-#### 6.2.1 PieceTable Memory Allocation Error Handling (Severity: 6/10)
-
-**Action**: Document that `Data()` can return `nullptr` and add debug
-assertions
-
-**Implementation**:
-
-```cpp
-// PieceTable.h
-// Returns pointer to materialized buffer, or nullptr if materialization fails
-// due to memory allocation error. Callers MUST check for nullptr.
-char *Data();
-
-// PieceTable.cc
-char *PieceTable::Data() {
-    materialize();
-    assert(materialized_ != nullptr && "PieceTable materialization failed");
-    return materialized_;
-}
-```
-
-**Effort**: Low (documentation + assertions)  
-**Risk**: Low (no API changes)  
-**Timeline**: Next maintenance cycle
-
-#### 6.2.2 Add Error Parameters to Internal Helpers (Severity: 4/10)
-
-**Action**: Add `std::string &err` parameters to `ensure_parent_dir()`
-and `write_header()`
-
-**Implementation**:
-
-```cpp
-// Swap.cc
-static bool ensure_parent_dir(const std::string &path, std::string &err) {
-    try {
-        fs::path p(path);
-        fs::path dir = p.parent_path();
-        if (dir.empty())
-            return true;
-        if (!fs::exists(dir))
-            fs::create_directories(dir);
-        return true;
-    } catch (const std::exception &e) {
-        err = std::string("Failed to create directory: ") + e.what();
-        return false;
-    } catch (...) {
-        err = "Failed to create directory: unknown error";
-        return false;
-    }
-}
-```
-
-**Effort**: Low (update 2 functions + call sites)  
-**Risk**: Low (internal helpers only)  
-**Timeline**: Next maintenance cycle
-
-### 6.3 Low Priority (Severity 1-3)
-
-#### 6.3.1 Add Function-Level Error Documentation (Severity: 3/10)
-
-**Action**: Add brief comments to public APIs documenting error behavior
-
-**Effort**: Medium (many functions to document)  
-**Risk**: None (documentation only)  
-**Timeline**: Ongoing as code is touched
-
-#### 6.3.2 Add ErrorHandler Integration to Commands (Severity: 2/10)
-
-**Action**: Consider logging command failures to ErrorHandler for
-diagnostics
-
-**Assessment**: **Not recommended** - Commands are user-initiated
-actions; status messages are more appropriate than error logs
-
----
-
-## 7. TESTING RECOMMENDATIONS
-
-### 7.1 Error Handling Test Coverage
-
-**Current State**:
-
-- ✅ Swap file error handling tested (test_swap_edge_cases.cc)
-- ✅ Buffer I/O error handling tested (test_buffer_io.cc)
-- ⚠️ PieceTable allocation failure testing missing
-
-**Recommendations**:
-
-1. **Add PieceTable allocation failure tests** (if Option 1 from 3.1 is
-   implemented)
-2. **Add ErrorHandler query tests** - Verify error logging and retrieval
-3. **Add errno capture tests** - Verify errno is captured correctly in
-   syscall failures
-
-### 7.2 Test Examples
-
-```cpp
-// test_error_handler.cc
-TEST(ErrorHandler, LogsErrorsWithContext) {
-    ErrorHandler::Instance().Error("TestComponent", "Test error", "test.txt");
-    EXPECT_TRUE(ErrorHandler::Instance().HasErrors());
-    EXPECT_EQ(ErrorHandler::Instance().GetErrorCount(), 1);
-    std::string last = ErrorHandler::Instance().GetLastError();
-    EXPECT_TRUE(last.find("Test error") != std::string::npos);
-    EXPECT_TRUE(last.find("test.txt") != std::string::npos);
-}
-
-// test_piece_table.cc (if Option 1 implemented)
-TEST(PieceTable, ReportsAllocationFailure) {
-    PieceTable pt;
-    std::string err;
-    // Attempt to allocate huge buffer
-    bool ok = pt.Reserve(SIZE_MAX, err);
-    EXPECT_FALSE(ok);
-    EXPECT_FALSE(err.empty());
-}
-```
-
----
-
-## 8. MIGRATION CHECKLIST
-
-For developers updating existing code to follow error handling
-conventions:
-
-- [ ] Identify all error-prone operations (file I/O, syscalls,
-  allocations)
-- [ ] Add `std::string &err` parameter if not present
-- [ ] Clear `err` at function start: `err.clear();`
-- [ ] Capture `errno` immediately after syscall failures:
-  `int saved_errno = errno;`
-- [ ] Build detailed error messages with context (paths, operation
-  details)
-- [ ] Call `ErrorHandler::Instance().Error()` at all error sites
-- [ ] Return `false` on failure, `true` on success
-- [ ] Update all call sites to handle the error parameter
-- [ ] Write unit tests that verify error handling
-- [ ] Update function documentation to describe error behavior
-
----
-
-## 9. SUMMARY AND NEXT STEPS
-
-### 9.1 Achievements
-
-✅ **Standardized on `bool + std::string &err` pattern** for error-prone
-operations  
-✅ **Documented comprehensive error handling conventions** in
-DEVELOPER_GUIDE.md  
-✅ **Identified and prioritized remaining gaps** (PieceTable, internal
-helpers)  
-✅ **Integrated ErrorHandler** into Buffer, SwapManager, and main  
-✅ **Established clear pattern selection guidelines** for future
-development
-
-### 9.2 Remaining Work
-
-**Medium Priority**:
-
-1. Document PieceTable `Data()` nullptr behavior and add assertions
-2. Add error parameters to internal helper functions
-
-**Low Priority**:
-
-3. Add function-level error documentation to public APIs
-4. Add ErrorHandler query tests
-
-### 9.3 Conclusion
-
-The kte codebase has achieved **strong error handling consistency** with
-the `bool + std::string &err` pattern used uniformly across critical I/O
-paths. The centralized ErrorHandler provides comprehensive logging and
-UI integration. Remaining gaps are minor and primarily affect edge
-cases (memory allocation failures) that are rare in practice.
-
-**Overall Grade**: **B+ (8.5/10)**
-
-**Strengths**:
-
-- Consistent error propagation in Buffer and SwapManager
-- Comprehensive ErrorHandler integration
-- Excellent documentation in DEVELOPER_GUIDE.md
-- Errno capture for all syscalls
-- Top-level exception handling
-
-**Areas for Improvement**:
-
-- PieceTable memory allocation error handling
-- Internal helper function error propagation
-- Function-level API documentation
-
-The error handling infrastructure is **production-ready** and provides a
-solid foundation for reliable operation and debugging.

docs/ke.md

@@ -77,4 +77,5 @@ k-command mode can be exited with ESC or C-g.
 
 The find operation is an incremental search. The up or left arrow
 keys will go to the previous result, while the down or right arrow keys
-will go to the next result.
+will go to the next result. Unfortunately, the search starts from the
+top of the file each time. This is a known bug.

docs/kge.1

@@ -252,6 +252,9 @@ Open using the terminal frontend from kge:
 (project keybinding manual)
 .br
 Project homepage: https://github.com/wntrmute/kte
+.SH BUGS
+Report issues on the project tracker. Some behaviors are inherited from
+ke and may evolve over time; see the manual for notes.
 .SH AUTHORS
 Kyle (wntrmute) and contributors.
 .SH COPYRIGHT

docs/kte.1

@@ -146,16 +146,14 @@ When running the GUI frontend, you can control appearance via the generic
 command prompt (type "C-k ;" then enter commands):
 .TP
 .B : theme NAME
-Set the GUI theme. Available names: "amber", "eink", "everforest", "gruvbox", "kanagawa-paper", "lcars", "nord", "old-book", "orbital", "plan9", "solarized", "weyland-yutani", "zenburn".
+Set the GUI theme. Available names: "nord", "gruvbox", "plan9", "solarized", "eink".
 Compatibility aliases are also accepted: "gruvbox-dark", "gruvbox-light",
-"solarized-dark", "solarized-light", "eink-dark", "eink-light",
+"solarized-dark", "solarized-light", "eink-dark", "eink-light".
-"everforest-hard", "oldbook", "old-book-dark", "old-book-light",
-"kanagawa", "kanagawa-light", "kanagawa-paper-light", "vim-amber", "weyland".
 .TP
 .B : background MODE
 Set background mode for supported themes. MODE is either "light" or "dark".
-Themes that respond to background: eink, gruvbox, kanagawa-paper, old-book, solarized. The
+Themes that respond to background: eink, gruvbox, solarized. The
-"lcars", "nord" and "plan9" themes do not vary with background.
+"nord" and "plan9" themes do not vary with background.
 
 .SH CONFIGURATION
 The GUI reads a simple configuration file at
@@ -279,6 +277,9 @@ Force GUI frontend (if available):
 (project keybinding manual)
 .br
 Project homepage: https://github.com/wntrmute/kte
+.SH BUGS
+Incremental search currently restarts from the top on each invocation; see
+\(lqKnown behavior\(rq in the ke manual. Report issues on the project tracker.
 .SH AUTHORS
 Kyle (wntrmute) and contributors.
 .SH COPYRIGHT

docs/plans/piece-table-migration.md

@@ -1,601 +0,0 @@
-# PieceTable Migration Plan
-
-## Executive Summary
-
-This document outlines the plan to remove GapBuffer support from kte and
-migrate to using a **single PieceTable per Buffer**, rather than the
-current vector-of-Lines architecture where each Line contains either a
-GapBuffer or PieceTable.
-
-## Current Architecture Analysis
-
-### Text Storage
-
-**Current Implementation:**
-
-- `Buffer` contains `std::vector<Line> rows_`
-- Each `Line` wraps an `AppendBuffer` (type alias)
-- `AppendBuffer` is either `GapBuffer` (default) or `PieceTable` (via
-  `KTE_USE_PIECE_TABLE`)
-- Each line is independently managed with its own buffer
-- Operations are line-based with coordinate pairs (row, col)
-
-**Key Files:**
-
-- `Buffer.h/cc` - Buffer class with vector of Lines
-- `AppendBuffer.h` - Type selector (GapBuffer vs PieceTable)
-- `GapBuffer.h/cc` - Per-line gap buffer implementation
-- `PieceTable.h/cc` - Per-line piece table implementation
-- `UndoSystem.h/cc` - Records operations with (row, col, text)
-- `UndoNode.h` - Undo operation types (Insert, Delete, Paste, Newline,
-  DeleteRow)
-- `Command.cc` - High-level editing commands
-
-### Current Buffer API
-
-**Low-level editing operations (used by UndoSystem):**
-
-```cpp
-void insert_text(int row, int col, std::string_view text);
-void delete_text(int row, int col, std::size_t len);
-void split_line(int row, int col);
-void join_lines(int row);
-void insert_row(int row, std::string_view text);
-void delete_row(int row);
-```
-
-**Line access:**
-
-```cpp
-std::vector<Line> &Rows();
-const std::vector<Line> &Rows() const;
-```
-
-**Line API (Buffer::Line):**
-
-```cpp
-std::size_t size() const;
-const char *Data() const;
-char operator[](std::size_t i) const;
-std::string substr(std::size_t pos, std::size_t len) const;
-std::size_t find(const std::string &needle, std::size_t pos) const;
-void erase(std::size_t pos, std::size_t len);
-void insert(std::size_t pos, const std::string &seg);
-Line &operator+=(const Line &other);
-Line &operator+=(const std::string &s);
-```
-
-### Current PieceTable Limitations
-
-The existing `PieceTable` class only supports:
-
-- `Append(char/string)` - add to end
-- `Prepend(char/string)` - add to beginning
-- `Clear()` - empty the buffer
-- `Data()` / `Size()` - access content (materializes on demand)
-
-**Missing capabilities needed for buffer-wide storage:**
-
-- Insert at arbitrary byte position
-- Delete at arbitrary byte position
-- Line indexing and line-based queries
-- Position conversion (byte offset ↔ line/col)
-- Efficient line boundary tracking
-
-## Target Architecture
-
-### Design Overview
-
-**Single PieceTable per Buffer:**
-
-- `Buffer` contains one `PieceTable content_` (replaces
-  `std::vector<Line> rows_`)
-- Text stored as continuous byte sequence with `\n` as line separators
-- Line index cached for efficient line-based operations
-- All operations work on byte offsets internally
-- Buffer provides line/column API as convenience layer
-
-### Enhanced PieceTable Design
-
-```cpp
-class PieceTable {
-public:
-    // Existing API (keep for compatibility if needed)
-    void Append(const char *s, std::size_t len);
-    void Prepend(const char *s, std::size_t len);
-    void Clear();
-    const char *Data() const;
-    std::size_t Size() const;
-    
-    // NEW: Core byte-based editing operations
-    void Insert(std::size_t byte_offset, const char *text, std::size_t len);
-    void Delete(std::size_t byte_offset, std::size_t len);
-    
-    // NEW: Line-based queries
-    std::size_t LineCount() const;
-    std::string GetLine(std::size_t line_num) const;
-    std::pair<std::size_t, std::size_t> GetLineRange(std::size_t line_num) const; // (start, end) byte offsets
-    
-    // NEW: Position conversion
-    std::pair<std::size_t, std::size_t> ByteOffsetToLineCol(std::size_t byte_offset) const;
-    std::size_t LineColToByteOffset(std::size_t row, std::size_t col) const;
-    
-    // NEW: Substring extraction
-    std::string GetRange(std::size_t byte_offset, std::size_t len) const;
-    
-    // NEW: Search support
-    std::size_t Find(const std::string &needle, std::size_t start_offset) const;
-
-private:
-    // Existing members
-    std::string original_;
-    std::string add_;
-    std::vector<Piece> pieces_;
-    mutable std::string materialized_;
-    mutable bool dirty_;
-    std::size_t total_size_;
-    
-    // NEW: Line index for efficient line operations
-    struct LineInfo {
-        std::size_t byte_offset;      // absolute byte offset from buffer start
-        std::size_t piece_idx;        // which piece contains line start
-        std::size_t offset_in_piece;  // byte offset within that piece
-    };
-    mutable std::vector<LineInfo> line_index_;
-    mutable bool line_index_dirty_;
-    
-    // NEW: Line index management
-    void RebuildLineIndex() const;
-    void InvalidateLineIndex();
-};
-```
-
-### Buffer API Changes
-
-```cpp
-class Buffer {
-public:
-    // NEW: Direct content access
-    PieceTable &Content() { return content_; }
-    const PieceTable &Content() const { return content_; }
-    
-    // MODIFIED: Keep existing API but implement via PieceTable
-    void insert_text(int row, int col, std::string_view text);
-    void delete_text(int row, int col, std::size_t len);
-    void split_line(int row, int col);
-    void join_lines(int row);
-    void insert_row(int row, std::string_view text);
-    void delete_row(int row);
-    
-    // MODIFIED: Line access - return line from PieceTable
-    std::size_t Nrows() const { return content_.LineCount(); }
-    std::string GetLine(std::size_t row) const { return content_.GetLine(row); }
-    
-    // REMOVED: Rows() - no longer have vector of Lines
-    // std::vector<Line> &Rows();  // REMOVE
-    
-private:
-    // REMOVED: std::vector<Line> rows_;
-    // NEW: Single piece table for all content
-    PieceTable content_;
-    
-    // Keep existing members
-    std::size_t curx_, cury_, rx_;
-    std::size_t nrows_;  // cached from content_.LineCount()
-    std::size_t rowoffs_, coloffs_;
-    std::string filename_;
-    bool is_file_backed_;
-    bool dirty_;
-    bool read_only_;
-    bool mark_set_;
-    std::size_t mark_curx_, mark_cury_;
-    std::unique_ptr<UndoTree> undo_tree_;
-    std::unique_ptr<UndoSystem> undo_sys_;
-    std::uint64_t version_;
-    bool syntax_enabled_;
-    std::string filetype_;
-    std::unique_ptr<kte::HighlighterEngine> highlighter_;
-    kte::SwapRecorder *swap_rec_;
-};
-```
-
-## Migration Phases
-
-### Phase 1: Extend PieceTable (Foundation)
-
-**Goal:** Add buffer-wide capabilities to PieceTable without breaking
-existing per-line usage.
-
-**Tasks:**
-
-1. Add line indexing infrastructure to PieceTable
-    - Add `LineInfo` struct and `line_index_` member
-    - Implement `RebuildLineIndex()` that scans pieces for '\n'
-      characters
-    - Implement `InvalidateLineIndex()` called by Insert/Delete
-
-2. Implement core byte-based operations
-    - `Insert(byte_offset, text, len)` - split piece at offset, insert
-      new piece
-    - `Delete(byte_offset, len)` - split pieces, remove/truncate as
-      needed
-
-3. Implement line-based query methods
-    - `LineCount()` - return line_index_.size()
-    - `GetLine(line_num)` - extract text between line boundaries
-    - `GetLineRange(line_num)` - return (start, end) byte offsets
-
-4. Implement position conversion
-    - `ByteOffsetToLineCol(offset)` - binary search in line_index_
-    - `LineColToByteOffset(row, col)` - lookup line start, add col
-
-5. Implement utility methods
-    - `GetRange(offset, len)` - extract substring
-    - `Find(needle, start)` - search across pieces
-
-**Testing:**
-
-- Write unit tests for new PieceTable methods
-- Test with multi-line content
-- Verify line index correctness after edits
-- Benchmark performance vs current line-based approach
-
-**Estimated Effort:** 3-5 days
-
-### Phase 2: Create Buffer Adapter Layer (Compatibility)
-
-**Goal:** Create compatibility layer in Buffer to use PieceTable while
-maintaining existing API.
-
-**Tasks:**
-
-1. Add `PieceTable content_` member to Buffer (alongside existing
-   `rows_`)
-2. Add compilation flag `KTE_USE_BUFFER_PIECE_TABLE` (like existing
-   `KTE_USE_PIECE_TABLE`)
-3. Implement Buffer methods to delegate to content_:
-   ```cpp
-   #ifdef KTE_USE_BUFFER_PIECE_TABLE
-       void insert_text(int row, int col, std::string_view text) {
-           std::size_t offset = content_.LineColToByteOffset(row, col);
-           content_.Insert(offset, text.data(), text.size());
-       }
-       // ... similar for other methods
-   #else
-       // Existing line-based implementation
-   #endif
-   ```
-4. Update file I/O to work with PieceTable
-    - `OpenFromFile()` - load into content_ instead of rows_
-    - `Save()` - serialize content_ instead of rows_
-5. Update `AsString()` to materialize from content_
-
-**Testing:**
-
-- Run existing buffer correctness tests with new flag
-- Verify undo/redo still works
-- Test file I/O round-tripping
-- Test with existing command operations
-
-**Estimated Effort:** 3-4 days
-
-### Phase 3: Migrate Command Layer (High-level Operations)
-
-**Goal:** Update commands that directly access Rows() to use new API.
-
-**Tasks:**
-
-1. Audit all usages of `buf.Rows()` in Command.cc
-2. Refactor helper functions:
-    - `extract_region_text()` - use content_.GetRange()
-    - `delete_region()` - convert to byte offsets, use content_.Delete()
-    - `insert_text_at_cursor()` - convert position, use content_
-      .Insert()
-3. Update commands that iterate over lines:
-    - Use `buf.GetLine(i)` instead of `buf.Rows()[i]`
-    - Update line count queries to use `buf.Nrows()`
-4. Update search/replace operations:
-    - Modify `search_compute_matches()` to work with GetLine()
-    - Update regex matching to work line-by-line or use content directly
-
-**Testing:**
-
-- Test all editing commands (insert, delete, newline, backspace)
-- Test region operations (mark, copy, kill)
-- Test search and replace
-- Test word navigation and deletion
-- Run through common editing workflows
-
-**Estimated Effort:** 4-6 days
-
-### Phase 4: Update Renderer and Frontend (Display)
-
-**Goal:** Ensure all renderers work with new Buffer structure.
-
-**Tasks:**
-
-1. Audit renderer implementations:
-    - `TerminalRenderer.cc`
-    - `ImGuiRenderer.cc`
-    - `QtRenderer.cc`
-    - `TestRenderer.cc`
-2. Update line access patterns:
-    - Replace `buf.Rows()[y]` with `buf.GetLine(y)`
-    - Handle string return instead of Line object
-3. Update syntax highlighting integration:
-    - Ensure HighlighterEngine works with GetLine()
-    - Update any line-based caching
-
-**Testing:**
-
-- Test rendering in terminal
-- Test ImGui frontend (if enabled)
-- Test Qt frontend (if enabled)
-- Verify syntax highlighting displays correctly
-- Test scrolling and viewport updates
-
-**Estimated Effort:** 2-3 days
-
-### Phase 5: Remove Old Infrastructure (Cleanup) ✅ COMPLETED
-
-**Goal:** Remove GapBuffer, AppendBuffer, and Line class completely.
-
-**Status:** Completed on 2025-12-05
-
-**Tasks:**
-
-1. ✅ Remove conditional compilation:
-    - Removed `#ifdef KTE_USE_BUFFER_PIECE_TABLE` (PieceTable is now the
-      only way)
-    - Removed `#ifdef KTE_USE_PIECE_TABLE`
-    - Removed `AppendBuffer.h`
-2. ✅ Delete obsolete code:
-    - Deleted `GapBuffer.h/cc`
-    - Line class now uses PieceTable internally (kept for API
-      compatibility)
-    - `rows_` kept as mutable cache rebuilt from `content_` PieceTable
-3. ✅ Update CMakeLists.txt:
-    - Removed GapBuffer from sources
-    - Removed AppendBuffer.h from headers
-    - Removed KTE_USE_PIECE_TABLE and KTE_USE_BUFFER_PIECE_TABLE options
-4. ✅ Clean up includes and dependencies
-5. ✅ Update documentation
-
-**Testing:**
-
-- Full regression test suite
-- Verify clean compilation
-- Check for any lingering references
-
-**Estimated Effort:** 1-2 days
-
-### Phase 6: Performance Optimization (Polish)
-
-**Goal:** Optimize the new implementation for real-world usage.
-
-**Tasks:**
-
-1. Profile common operations:
-    - Measure line access patterns
-    - Identify hot paths in editing
-    - Benchmark against old implementation
-2. Optimize line index:
-    - Consider incremental updates instead of full rebuild
-    - Tune rebuild threshold
-    - Cache frequently accessed lines
-3. Optimize piece table:
-    - Tune piece coalescing heuristics
-    - Consider piece count limits and consolidation
-4. Memory optimization:
-    - Review materialization frequency
-    - Consider lazy materialization strategies
-    - Profile memory usage on large files
-
-**Testing:**
-
-- Benchmark suite with various file sizes
-- Memory profiling
-- Real-world usage testing
-
-**Estimated Effort:** 3-5 days
-
-## Files Requiring Modification
-
-### Core Files (Must Change)
-
-- `PieceTable.h/cc` - Add new methods (Phase 1)
-- `Buffer.h/cc` - Replace rows_ with content_ (Phase 2)
-- `Command.cc` - Update line access (Phase 3)
-- `UndoSystem.cc` - May need updates for new Buffer API
-
-### Renderer Files (Will Change)
-
-- `TerminalRenderer.cc` - Update line access (Phase 4)
-- `ImGuiRenderer.cc` - Update line access (Phase 4)
-- `QtRenderer.cc` - Update line access (Phase 4)
-- `TestRenderer.cc` - Update line access (Phase 4)
-
-### Files Removed (Phase 5 - Completed)
-
-- `GapBuffer.h/cc` - ✅ Deleted
-- `AppendBuffer.h` - ✅ Deleted
-- `test_buffer_correctness.cc` - ✅ Deleted (obsolete GapBuffer
-  comparison test)
-- `bench/BufferBench.cc` - ✅ Deleted (obsolete GapBuffer benchmarks)
-- `bench/PerformanceSuite.cc` - ✅ Deleted (obsolete GapBuffer
-  benchmarks)
-- `Buffer::Line` class - ✅ Updated to use PieceTable internally (kept
-  for API compatibility)
-
-### Build Files
-
-- `CMakeLists.txt` - Update sources (Phase 5)
-
-### Documentation
-
-- `README.md` - Update architecture notes
-- `docs/` - Update any architectural documentation
-- `REWRITE.md` - Note C++ now matches Rust design
-
-## Testing Strategy
-
-### Unit Tests
-
-- **PieceTable Tests:** New file `test_piece_table.cc`
-    - Test Insert/Delete at various positions
-    - Test line indexing correctness
-    - Test position conversion
-    - Test with edge cases (empty, single line, large files)
-
-- **Buffer Tests:** Extend `test_buffer_correctness.cc`
-    - Test new Buffer API with PieceTable backend
-    - Test file I/O round-tripping
-    - Test multi-line operations
-
-### Integration Tests
-
-- **Undo Tests:** `test_undo.cc` should still pass
-    - Verify undo/redo across all operation types
-    - Test undo tree navigation
-
-- **Search Tests:** `test_search_correctness.cc` should still pass
-    - Verify search across multiple lines
-    - Test regex search
-
-### Manual Testing
-
-- Load and edit large files (>10MB)
-- Perform complex editing sequences
-- Test all keybindings and commands
-- Verify syntax highlighting
-- Test crash recovery (swap files)
-
-### Regression Testing
-
-- All existing tests must pass with new implementation
-- No observable behavior changes for users
-- Performance should be comparable or better
-
-## Risk Assessment
-
-### High Risk
-
-- **Undo System Integration:** Undo records operations with
-  row/col/text. Need to ensure compatibility or refactor.
-    - *Mitigation:* Carefully preserve undo semantics, extensive testing
-
-- **Performance Regression:** Line index rebuilding could be expensive
-  on large files.
-    - *Mitigation:* Profile early, optimize incrementally, consider
-      caching strategies
-
-### Medium Risk
-
-- **Syntax Highlighting:** Highlighters may depend on line-based access
-  patterns.
-    - *Mitigation:* Review highlighter integration, test thoroughly
-
-- **Renderer Updates:** Multiple renderers need updating, risk of
-  inconsistency.
-    - *Mitigation:* Update all renderers in same phase, test each
-
-### Low Risk
-
-- **Search/Replace:** Should work naturally with new GetLine() API.
-    - *Mitigation:* Test thoroughly with existing test suite
-
-## Success Criteria
-
-### Functional Requirements
-
-- ✓ All existing tests pass
-- ✓ All commands work identically to before
-- ✓ File I/O works correctly
-- ✓ Undo/redo functionality preserved
-- ✓ Syntax highlighting works
-- ✓ All frontends (terminal, ImGui, Qt) work
-
-### Code Quality
-
-- ✓ GapBuffer completely removed
-- ✓ No conditional compilation for buffer type
-- ✓ Clean, maintainable code
-- ✓ Good test coverage for new PieceTable methods
-
-### Performance
-
-- ✓ Editing operations at least as fast as current
-- ✓ Line access within 2x of current performance
-- ✓ Memory usage reasonable (no excessive materialization)
-- ✓ Large file handling acceptable (tested up to 100MB)
-
-## Timeline Estimate
-
-| Phase                      | Duration       | Dependencies |
-|----------------------------|----------------|--------------|
-| Phase 1: Extend PieceTable | 3-5 days       | None         |
-| Phase 2: Buffer Adapter    | 3-4 days       | Phase 1      |
-| Phase 3: Command Layer     | 4-6 days       | Phase 2      |
-| Phase 4: Renderer Updates  | 2-3 days       | Phase 3      |
-| Phase 5: Cleanup           | 1-2 days       | Phase 4      |
-| Phase 6: Optimization      | 3-5 days       | Phase 5      |
-| **Total**                  | **16-25 days** |              |
-
-**Note:** Timeline assumes one developer working full-time. Actual
-duration may vary based on:
-
-- Unforeseen integration issues
-- Performance optimization needs
-- Testing thoroughness
-- Code review iterations
-
-## Alternatives Considered
-
-### Alternative 1: Keep Line-based but unify GapBuffer/PieceTable
-
-- Keep vector of Lines, but make each Line always use PieceTable
-- Remove GapBuffer, remove AppendBuffer selector
-- **Pros:** Smaller change, less risk
-- **Cons:** Doesn't achieve architectural goal, still have per-line
-  overhead
-
-### Alternative 2: Hybrid approach
-
-- Use PieceTable for buffer, but maintain materialized Line objects as
-  cache
-- **Pros:** Easier migration, maintains some compatibility
-- **Cons:** Complex dual representation, cache invalidation issues
-
-### Alternative 3: Complete rewrite
-
-- Follow REWRITE.md exactly, implement in Rust
-- **Pros:** Modern language, better architecture
-- **Cons:** Much larger effort, different project
-
-## Recommendation
-
-**Proceed with planned migration** (single PieceTable per Buffer)
-because:
-
-1. Aligns with long-term architecture vision (REWRITE.md)
-2. Removes unnecessary per-line buffer overhead
-3. Simplifies codebase (one text representation)
-4. Enables future optimizations (better undo, swap files, etc.)
-5. Reasonable effort (16-25 days) for significant improvement
-
-**Suggested Approach:**
-
-- Start with Phase 1 (extend PieceTable) in isolated branch
-- Thoroughly test new PieceTable functionality
-- Proceed incrementally through phases
-- Maintain working editor at end of each phase
-- Merge to main after Phase 4 (before cleanup) to get testing
-- Complete Phase 5-6 based on feedback
-
-## References
-
-- `REWRITE.md` - Rust architecture specification (lines 54-157)
-- Current buffer implementation: `Buffer.h/cc`
-- Current piece table: `PieceTable.h/cc`
-- Undo system: `UndoSystem.h/cc`, `UndoNode.h`
-- Commands: `Command.cc`

docs/plans/qt-frontend.md

@@ -1,124 +0,0 @@
-Based on the project structure and the presence of files like
-`imgui.ini`, `GUIFrontend.h`, and `TerminalFrontend.h`, here is an
-analysis of the difficulty and challenges involved in adding a GTK or Qt
-version of the GUI.
-
-### **Executive Summary: Difficulty Level - Moderate**
-
-The project is well-architected for this task. It already supports
-multiple frontends (Terminal vs. GUI), meaning the "Core Logic" (
-Buffers, Syntax, Commands) is successfully decoupled from the "View" (
-Rendering/Input). However, the specific move from an **Immediate Mode**
-GUI (likely Dear ImGui, implied by `imgui.ini` and standard naming
-patterns) to a **Retained Mode** GUI (Qt/GTK) introduces specific
-architectural frictions regarding the event loop and state management.
-
----
-
-### **1. Architectural Analysis**
-
-The existence of abstract interfaces—likely `Frontend`, `Renderer`, and
-`InputHandler`—is the biggest asset here.
-
-* **Current State:**
-    * **Abstract Layer:** `Frontend.h`, `Renderer.h`, `InputHandler.h`
-      likely define the contract.
-    * **Implementations:**
-        * `Terminal*` files implement the TUI (likely ncurses or VT100).
-        * `GUI*` files (currently ImGui) implement the graphical
-          version.
-* **The Path Forward:**
-    * You would create `QtFrontend`, `QtRenderer`, `QtInputHandler` (or
-      GTK equivalents).
-    * Because the core logic (`Editor.cc`, `Buffer.cc`) calls these
-      interfaces, you theoretically don't need to touch the core text
-      manipulation code.
-
-### **2. Key Challenges**
-
-#### **A. The Event Loop Inversion (Main Challenge)**
-
-* **Current (ImGui):** Typically, the application owns the loop:
-  `while (running) { HandleInput(); Update(); Render(); }`. The
-  application explicitly tells the GUI to draw every frame.
-* **Target (Qt/GTK):** The framework owns the loop: `app.exec()` or
-  `gtk_main()`. The framework calls *you* when events happen.
-* **Difficulty:** You will need to refactor `main.cc` or the entry point
-  to hand over control to the Qt/GTK application object. The Editor's "
-  tick" function might need to be connected to a timer or an idle event
-  in the new framework to ensure logic updates happen.
-
-#### **B. Rendering Paradigm: Canvas vs. Widgets**
-
-* **The "Easy" Way (Custom Canvas):**
-    * Implement the `QtRenderer` by subclassing `QWidget` and overriding
-      `paintEvent`.
-    * Use `QPainter` (or Cairo in GTK) to draw text, cursors, and
-      selections exactly where the `Renderer` interface says to.
-    * **Pros:** Keeps the code similar to the current ImGui/Terminal
-      renderers.
-    * **Cons:** You lose native accessibility and some native "feel" (
-      scrolling physics, native text context menus).
-* **The "Hard" Way (Native Widgets):**
-    * Trying to map an internal `Buffer` directly to a `QTextEdit` or
-      `GtkTextView`.
-    * **Difficulty:** This is usually very hard because the Editor core
-      likely manages its own cursor, selection, and syntax highlighting.
-      Syncing that internal state with a complex native widget often
-      leads to conflicts.
-    * **Recommendation:** Stick to the "Custom Canvas" approach (drawing
-      text manually on a surface) to preserve the custom editor
-      behavior (vim-like modes, specific syntax highlighting).
-
-#### **C. Input Handling**
-
-* **Challenge:** Mapping Qt/GTK key events to the internal `Keymap`.
-* **Detail:** ImGui and Terminal libraries often provide raw scancodes
-  or simple chars. Qt/GTK provide complex Event objects. You will need a
-  translation layer in `QtInputHandler::keyPressEvent` that converts
-  `Qt::Key_Escape` -> `KKey::Escape` (or your internal equivalent).
-
-### **3. Portability of Assets**
-
-#### **Themes (Colors)**
-
-* **Feasibility:** High.
-* **Approach:** `GUITheme.h` likely contains structs with RGB/Hex
-  values. Qt supports stylesheets (QSS) and GTK uses CSS. You can write
-  a converter that reads your current theme configuration and generates
-  a CSS string to apply to your window, or simply use the RGB values
-  directly in your custom `QPainter`/Cairo drawing logic.
-
-#### **Fonts**
-
-* **Feasibility:** Moderate.
-* **Approach:**
-    * **ImGui:** Usually loads a TTF into a texture atlas.
-    * **Qt/GTK:** Uses the system font engine (Freetype/Pango).
-    * **Challenge:** You won't use the texture atlas anymore. You will
-      simply request a font family and size (e.g.,
-      `QFont("JetBrains Mono", 12)`). You may need to ensure your custom
-      renderer calculates character width/height metrics correctly using
-      `QFontMetrics` (Qt) or `PangoLayout` (GTK) to align the grid
-      correctly.
-
-### **4. Summary Recommendation**
-
-If you proceed, **Qt** is generally considered easier to integrate with
-C++ projects than GTK (which is C-based, though `gtkmm` exists).
-
-1. **Create a `QtFrontend`** class inheriting from `Frontend`.
-2. **Create a `QtWindow`** class inheriting from `QWidget`.
-3. **Implement `QtRenderer`** that holds a pointer to the `QtWindow`.
-   When the core calls `DrawText()`, `QtRenderer` should queue that
-   command or draw directly to the widget's paint buffer.
-4. **Refactor `main.cc`** to instantiate `QApplication` instead of the
-   current manual loop.
-
----
-
-Note (2025-12): The Qt frontend defers all key processing to the
-existing command subsystem and keymaps, mirroring the ImGui path. There
-are no Qt-only keybindings; `QtInputHandler` translates Qt key events
-into the shared keymap flow (C-k prefix, Ctrl chords, ESC/Meta,
-universal-argument digits, printable insertion).

docs/plans/swap-files.md

@@ -1,147 +0,0 @@
-Swap files for kte — design plan
-================================
-
-Goals
------
-
-- Preserve user work across crashes, power failures, and OS kills.
-- Keep the editor responsive; avoid blocking the UI on disk I/O.
-- Bound recovery time and swap size.
-- Favor simple, robust primitives that work well on POSIX and macOS;
-  keep Windows feasibility in mind.
-
-Model overview
---------------
-Per open buffer, maintain a swap journal in a per-user state directory:
-
-- Path: `$XDG_STATE_HOME/kte/swap/<encoded-path>.swp` (or
-  `~/.local/state/kte/swap/...`)
-  where `<encoded-path>` is the file path with separators replaced (e.g.
-  `/home/kyle/tmp/test.txt` → `home!kyle!tmp!test.txt.swp`).
-  Unnamed/unsaved
-  buffers use a unique `unnamed-<pid>-<counter>.swp` name.
-- Format: append‑only journal of editing operations with periodic
-  checkpoints.
-- Crash safety: only append, fsync as per policy; checkpoint via
-  write‑to‑temp + fsync + atomic rename.
-
-File format (v1)
-----------------
-Header (fixed 64 bytes):
-
-- Magic: `KTE_SWP\0` (8 bytes)
-- Version: 1 (u32)
-- Flags: bitset (u32) — e.g., compression, checksums, endian.
-- Created time (u64)
-- Host info hash (u64) — optional, for telemetry/debug.
-- File identity: hash of canonical path (u64) and original file
-  size+mtime (u64+u64) at start.
-- Reserved/padding.
-
-Records (stream after header):
-
-- Each record: [type u8][len u24][payload][crc32 u32]
-- Types:
-    - `CHKPT` — full snapshot checkpoint of entire buffer content and
-      minimal metadata (cursor pos, filetype). Payload optionally
-      compressed. Written occasionally to cap replay time.
-    - `INS` — insert at (row, col) text bytes (text may contain
-      newlines). Encoded with varints.
-    - `DEL` — delete length at (row, col). If spanning lines, semantics
-      defined as in Buffer::delete_text.
-    - `SPLIT`, `JOIN` — explicit structural ops (optional; can be
-      expressed via INS/DEL).
-    - `META` — update metadata (e.g., filetype, encoding hints).
-
-Durability policy
------------------
-Configurable knobs (sane defaults in parentheses):
-
-- Time‑based flush: group edits and flush every 150–300 ms (200 ms).
-- Operation count flush: after N ops (200).
-- Idle flush: on 500 ms idle lull, flush immediately.
-- Checkpoint cadence: after M KB of journal (512–2048 KB) or T seconds (
-  30–120 s), whichever first.
-- fsync policy:
-    - `always`: fsync every flush (safest, slowest).
-    - `grouped` (default): fsync at most every 1–2 s or on
-      idle/blur/quit.
-    - `never`: rely on OS flush (fastest, riskier).
-    - On POSIX, prefer `fdatasync` when available; fall back to `fsync`.
-
-Performance & threading
------------------------
-
-- Background writer thread per editor instance (shared) with a bounded
-  MPSC queue of per‑buffer records.
-- Each Buffer has a small in‑memory journal buffer; UI thread enqueues
-  ops (non‑blocking) and may coalesce adjacent inserts/deletes.
-- Writer batch‑writes records to the swap file, computes CRCs, and
-  decides checkpoint boundaries.
-- Backpressure: if the queue grows beyond a high watermark, signal the
-  UI to start coalescing more aggressively and slow enqueue (never block
-  hard editing path; at worst drop optional `META`).
-
-Recovery flow
--------------
-
-On opening a file:
-
-1. Detect swap journal `$XDG_STATE_HOME/kte/swap/<encoded-path>.swp`.
-2. Validate header, iterate records verifying CRCs.
-3. Compare recorded original file identity against actual file; if
-   mismatch, warn user but allow recovery (content wins).
-4. Reconstruct buffer: start from the last good `CHKPT` (if any), then
-   replay subsequent ops. If trailing partial record encountered (EOF
-   mid‑record), truncate at last good offset.
-5. Present a choice: Recover (load recovered buffer; keep the swap file
-   until user saves) or Discard (delete swap file and open clean file).
-
-Stability & corruption mitigation
----------------------------------
-
-- Append‑only with per‑record CRC32 guards against torn writes.
-- Atomic checkpoint rotation: write `<encoded-path>.swp.tmp`, fsync,
-  then rename over old `.swp`.
-- Size caps: rotate or compact when `.swp` exceeds a threshold (e.g.,
-  64–128 MB). Compaction creates a fresh file with a single checkpoint.
-- Low‑disk‑space behavior: on write failures, surface a non‑modal
-  warning and temporarily fall back to in‑memory only; retry
-  opportunistically.
-
-Security considerations
------------------------
-
-- Swap files mirror buffer content, which may be sensitive. Options:
-    - Configurable location (same dir vs. `$XDG_STATE_HOME/kte/swap`).
-    - Optional per‑file encryption (future work) using OS keychain.
-    - Ensure permissions are 0600.
-
-Interoperability & UX
----------------------
-
-- Use a distinctive directory (`$XDG_STATE_HOME/kte/swap`) to avoid
-  conflicts with other editors’ `.swp` conventions.
-- Status bar indicator when swap is active; commands to purge/compact.
-- On save: do not delete swap immediately; keep until the buffer is
-  clean and idle for a short grace period (allows undo of accidental
-  external changes).
-
-Implementation plan (staged)
-----------------------------
-
-1. Minimal journal writer (append‑only INS/DEL) with grouped fsync;
-   single per‑editor writer thread.
-2. Reader/recovery path with CRC validation and replay.
-3. Checkpoints + atomic rotation; compaction path.
-4. Config surface and UI prompts; telemetry counters.
-5. Optional compression and advanced coalescing.
-
-Defaults balancing performance and stability
--------------------------------------------
-
-- Grouped flush with fsync every ~1 s or on idle/quit.
-- Checkpoint every 1 MB or 60 s.
-- Bounded queue and batch writes to minimize syscalls.
-- Immediate flush on critical events (buffer close, app quit, power
-  source change on laptops if detectable).

docs/plans/test-plan.md

@@ -1,163 +0,0 @@
-### Unit testing plan (headless, no interactive frontend)
-
-#### Principles
-- Headless-only: exercise core components directly (`PieceTable`, `Buffer`, `UndoSystem`, `OptimizedSearch`, and minimal `Editor` flows) without starting `kte` or `kge`.
-- Deterministic and fast: avoid timers, GUI, environment-specific behavior; prefer in-memory operations and temporary files.
-- Regression-focused: encode prior failures (save/newline mismatch, legacy `rows_` writes) as explicit tests to prevent recurrences.
-
-#### Harness and execution
-- Single binary: use target `kte_tests` (already present) to compile and run all tests under `tests/` with the minimal in-tree framework (`tests/Test.h`, `tests/TestRunner.cc`).
-- No GUI/ncurses deps: link only engine sources (PieceTable/Buffer/Undo/Search/Undo* and syntax minimal set), not frontends.
-- How to build/run:
-  - Debug profile:
-    ```
-    cmake -S /Users/kyle/src/kte -B /Users/kyle/src/kte/cmake-build-debug -DBUILD_TESTS=ON && \
-    cmake --build /Users/kyle/src/kte/cmake-build-debug --target kte_tests && \
-    /Users/kyle/src/kte/cmake-build-debug/kte_tests
-    ```
-  - Release profile:
-    ```
-    cmake -S /Users/kyle/src/kte -B /Users/kyle/src/kte/cmake-build-release -DBUILD_TESTS=ON && \
-    cmake --build /Users/kyle/src/kte/cmake-build-release --target kte_tests && \
-    /Users/kyle/src/kte/cmake-build-release/kte_tests
-    ```
-
----
-
-### Test catalog (summary table)
-
-The table below catalogs all unit tests defined in this plan. It is headless-only and maps directly to the suites A–H described later. “Implemented” reflects current coverage in `kte_tests`.
-
-| Suite | ID  | Name                                      | Description (1‑line)                                                                 | Headless | Implemented |
-|:-----:|:---:|:------------------------------------------|:-------------------------------------------------------------------------------------|:--------:|:-----------:|
-| A | 1 | SaveAs then Save (append) | New buffer → write two lines → `SaveAs` → append → `Save`; verify exact bytes. | Yes | ✓ |
-| A | 2 | Open existing then Save | Open seeded file, append, `Save`; verify overwrite bytes. | Yes | ✓ |
-| A | 3 | Open non-existent then SaveAs | Start from non-existent path, insert `hello, world\n`, `SaveAs`; verify bytes. | Yes | ✓ |
-| A | 4 | Trailing newline preservation | Verify saving preserves presence/absence of final `\n`. | Yes | Planned |
-| A | 5 | Empty buffer saves | Empty → `SaveAs` → 0 bytes; then insert `\n` → `Save` → 1 byte. | Yes | Planned |
-| A | 6 | Large file streaming | 1–4 MiB with periodic newlines; size and content integrity. | Yes | Planned |
-| A | 7 | Tilde expansion | `SaveAs` with `~/...`; re-open to confirm path/content. | Yes | Planned |
-| A | 8 | Error propagation | Save to unwritable path → expect failure and error message. | Yes | Planned |
-| B | 1 | Insert/Delete LineCount | Basic inserts/deletes and line counting sanity. | Yes | ✓ |
-| B | 2 | Line/Col conversions | `LineColToByteOffset` and reverse around boundaries. | Yes | ✓ |
-| B | 3 | Delete spanning newlines | Delete ranges that cross line breaks; verify bytes/lines. | Yes | Planned |
-| B | 4 | Split/Join equivalence | `split_line` followed by `join_lines` yields original bytes. | Yes | Planned |
-| B | 5 | Stream vs Data equivalence | `WriteToStream` matches `GetRange`/`Data()` after edits. | Yes | Planned |
-| B | 6 | UTF‑8 bytes stability | Multibyte sequences behave correctly (byte-based ops). | Yes | Planned |
-| C | 1 | insert_text/delete_text | Edits at start/middle/end; `Rows()` mirrors PieceTable. | Yes | Planned |
-| C | 2 | split_line/join_lines | Effects and snapshots across multiple positions. | Yes | Planned |
-| C | 3 | insert_row/delete_row | Replace paragraph by row ops; verify bytes/linecount. | Yes | Planned |
-| C | 4 | Cache invalidation | After each mutation, `Rows()` matches `LineCount()`. | Yes | Planned |
-| D | 1 | Grouped insert undo | Contiguous typing undone/redone as a group. | Yes | Planned |
-| D | 2 | Delete/Newline undo/redo | Backspace/Delete and Newline transitions across undo/redo. | Yes | Planned |
-| D | 3 | Mark saved & dirty | Dirty/save markers interact correctly with undo/redo. | Yes | Planned |
-| E | 1 | Search parity basic | `OptimizedSearch::find_all` vs `std::string` reference. | Yes | ✓ |
-| E | 2 | Large text search | ~1 MiB random text/patterns parity. | Yes | Planned |
-| F | 1 | Editor open & reload | Open via `Editor`, modify, reload, verify on-disk bytes. | Yes | Planned |
-| F | 2 | Read-only toggle | Toggle and verify enforcement/behavior of saves. | Yes | Planned |
-| F | 3 | Prompt lifecycle | Start/Accept/Cancel prompt doesn’t corrupt state. | Yes | Planned |
-| G | 1 | Saved only newline regression | Insert text + newline; `Save` includes both bytes. | Yes | Planned |
-| G | 2 | Backspace crash regression | PieceTable-backed delete/join path remains stable. | Yes | Planned |
-| G | 3 | Overwrite-confirm path | Saving over existing path succeeds and is correct. | Yes | Planned |
-| H | 1 | Many small edits | 10k small edits; final bytes correct within time bounds. | Yes | Planned |
-| H | 2 | Consolidation equivalence | After many edits, stream vs data produce identical bytes. | Yes | Planned |
-
-Legend: Implemented = ✓, Planned = to be added per Coverage roadmap.
-
-### Test suites and cases
-
-#### A) Filesystem I/O via Buffer
-1) SaveAs then Save (append)
-   - New buffer → `insert_text` two lines (explicit `\n`) → `SaveAs(tmp)` → insert a third line → `Save()`.
-   - Assert file bytes equal exact expected string.
-2) Open existing then Save
-   - Seed a file on disk; `OpenFromFile(path)` → append line → `Save()`.
-   - Assert file bytes updated exactly.
-3) Open non-existent then SaveAs
-   - `OpenFromFile(nonexistent)` → assert `IsFileBacked()==false` → insert `"hello, world\n"` → `SaveAs(path)`.
-   - Read back exact bytes.
-4) Trailing newline preservation
-   - Case (a) last line without `\n`; (b) last line with `\n` → save and verify bytes unchanged.
-5) Empty buffer saves
-   - `SaveAs(tmp)` on empty buffer → 0-byte file. Then insert `"\n"` and `Save()` → 1-byte file.
-6) Large file streaming
-   - Insert ~1–4 MiB of data with periodic newlines. `SaveAs` then `Save`; verify size matches `content_.Size()` and bytes integrity.
-7) Path normalization and tilde expansion
-   - `SaveAs("~/.../file.txt")` → verify path expands to `$HOME` and file content round-trips with `OpenFromFile`.
-8) Error propagation (guarded)
-   - Attempt save into a non-writable path; expect `Save/SaveAs` returns false with non-empty error. Mark as skipped in environments lacking such path.
-
-#### B) PieceTable semantics
-1) Line counting and deletion across lines
-   - Insert `"abc\n123\nxyz"` → 3 lines; delete middle line range → 2 lines; validate `GetLine` contents.
-2) Position conversions
-   - Validate `LineColToByteOffset` and `ByteOffsetToLineCol` at start/end of lines and EOF, especially around `\n`.
-3) Delete spanning newlines
-   - Remove a range that crosses line boundaries; verify resulting bytes, `LineCount` and line contents.
-4) Split/join equivalence
-   - Split at various columns; then join adjacent lines; verify bytes equal original.
-5) WriteToStream vs materialized `Data()`
-   - After multiple inserts/deletes (without forcing `Data()`), stream to `std::ostringstream`; compare with `GetRange(0, Size())`, then call `Data()` and re-compare.
-6) UTF-8 bytes stability
-   - Insert multibyte sequences (e.g., `"héllo"`, `"中文"`, emoji) as raw bytes; ensure line counting and conversions behave (byte-based API; no crashes/corruption).
-
-#### C) Buffer editing helpers and rows cache correctness
-1) `insert_text`/`delete_text`
-   - Apply at start/middle/end of lines; immediately call `Rows()` and validate contents/lengths mirror PieceTable.
-2) `split_line` and `join_lines`
-   - Verify content effects and `Rows()` snapshots for multiple positions and consecutive operations.
-3) `insert_row`/`delete_row`
-   - Replace a paragraph by deleting N rows then inserting N′ rows; verify bytes and `LineCount`.
-4) Cache invalidation
-   - After each mutation, fetch `Rows()`; assert `Nrows() == content.LineCount()` and no stale data remains.
-
-#### D) UndoSystem semantics
-1) Grouped contiguous insert undo
-   - Emulate typing at a single location via repeated `insert_text`; one `undo()` should remove the whole run; `redo()` restores it.
-2) Delete/newline undo/redo
-   - Simulate backspace/delete (`delete_text` and `join_lines`) and newline (`split_line`); verify content transitions across `undo()`/`redo()`.
-3) Mark saved and dirty flag
-   - After successful save, call `UndoSystem::mark_saved()` (via existing pathways) and ensure dirty state pairing behaves as intended (at least: `SetDirty(false)` plus save does not break undo/redo).
-
-#### E) Search algorithms
-1) Parity with `std::string::find`
-   - Use `OptimizedSearch::find_all` across edge cases (empty needle/text, overlaps like `"aaaaa"` vs `"aa"`, Unicode byte sequences). Compare to reference implementation.
-2) Large text
-   - Random ASCII text ~1 MiB; random patterns; results match reference.
-
-#### F) Editor non-interactive flows (no frontend)
-1) Open and reload
-   - Through `Editor`, open file; modify the underlying `Buffer` directly; invoke reload (`Buffer::OpenFromFile` or `cmd_reload_buffer` if you bring `Command.cc` into the test target). Verify bytes match the on-disk file after reload.
-2) Read-only toggle
-   - Toggle `Buffer::ToggleReadOnly()`; confirm flag value changes and that subsequent saves still execute when not read-only (or, if enforcement exists, that mutations are appropriately restricted).
-3) Prompt lifecycle (headless)
-   - Exercise `StartPrompt` → `AcceptPrompt` → `CancelPrompt`; ensure state resets and does not corrupt buffer/editor state.
-
-#### G) Regression tests for reported bugs
-1) “Saved only newline”
-   - Build buffer content via `insert_text` followed by `split_line` for newline; `Save` then validate bytes include both the text and newline.
-2) Backspace crash path
-   - Mimic backspace behavior using PieceTable-backed helpers (`delete_text`/`join_lines`); ensure no dependency on legacy `rows_` mutation and no memory issues.
-3) Overwrite-confirm path behavior
-   - Start with non-file-backed buffer named to collide with an existing file; perform `SaveAs(existing_path)` and assert success and correctness on disk (unit test bypasses interactive confirm, validating underlying write path).
-
-#### H) Performance/stress sanity
-1) Many small edits
-   - 10k single-char inserts and interleaved deletes; assert final bytes; keep within conservative runtime bounds.
-2) Consolidation heuristics
-   - After many edits, call both `WriteToStream` and `Data()` and verify identical bytes.
-
----
-
-### Coverage roadmap
-- Phase 1 (already implemented and passing):
-  - Buffer I/O basics (A.1–A.3), PieceTable basics (B.1–B.2), Search parity (E.1).
-- Phase 2 (add next):
-  - Buffer I/O edge cases (A.4–A.7), deeper PieceTable ops (B.3–B.6), Buffer helpers and cache (C.1–C.4), Undo semantics (D.1–D.2), Regression set (G.1–G.3).
-- Phase 3:
-  - Editor flows (F.1–F.3), performance/stress (H.1–H.2), and optional integration of `Command.cc` into the test target to exercise non-interactive command execution paths directly.
-
-### Notes
-- Use per-test temp files under the repo root or a unique temp directory; ensure cleanup after assertions.
-- For HOME-dependent tests (tilde expansion), set `HOME` in the test process if not present or skip with a clear message.
-- On macOS Debug, a benign allocator warning may appear; rely on process exit code for pass/fail.

docs/plans/undo.md

@@ -1,215 +0,0 @@
-This is a design for a non-linear undo/redo system for kte. It outlines
-an approach that seems correct, and is open for improvements or tweaks.
-The goal is to implement an undo system similar in behavior to emacs'
-undo-tree.
-
-### Core Requirements
-
-1. Each open buffer has its own completely independent undo tree.
-2. Undo and redo must be non-linear: typing after undo creates a branch;
-   old redo branches are discarded.
-3. Typing, backspacing, and pasting are batched into word-level undo
-   steps.
-4. Undo/redo must never create new undo nodes while applying an
-   undo/redo (silent, low-level apply).
-5. The system must be memory-safe and leak-proof even if the user types
-   and immediately closes the buffer.
-
-### Data Structures
-
-This is a proprosed data design.
-
-```cpp
-enum class UndoType : uint8_t {
-    Insert,
-    Delete,
-    Paste,        // optional, can reuse Insert
-    Newline,
-    DeleteRow,
-    // future: IndentRegion, KillRegion, etc.
-};
-
-struct UndoNode {
-    UndoType type;
-    int row;           // original cursor row
-    int col;           // original cursor column (updated during batch)
-    std::string text;  // the inserted or deleted text (full batch)
-    UndoNode* child = nullptr;   // next in current timeline
-    UndoNode* next  = nullptr;   // redo branch (rarely used)
-    // no parent pointer needed — we walk from root
-};
-
-struct UndoTree {
-    UndoNode* root    = nullptr;  // first edit ever
-    UndoNode* current = nullptr;  // current state of buffer
-    UndoNode* saved   = nullptr;  // points to node matching last save (for dirty flag)
-    UndoNode* pending = nullptr;  // in-progress batch (detached)
-};
-```
-
-Each `Buffer` owns one `std::unique_ptr<UndoTree>`.
-
-### Core API
-
-This is based on the data structures from before.
-
-```cpp
-class UndoSystem {
-public:
-    void Begin(UndoType type);
-    void Append(char ch);
-    void Append(std::string_view text);
-    void commit();                     // called on cursor move, commands, etc.
-
-    void undo();                       // Ctrl+Z
-    void redo();                       // Ctrl+Y or Ctrl+Shift+Z
-
-    void mark_saved();                 // after successful save
-    void discard_pending();            // before closing buffer or loading new file
-    void clear();                      // new file / reset
-
-private:
-    void apply(const UndoNode* node, int direction);  // +1 = redo, -1 = undo
-    void free_node(UndoNode* node);
-    void free_branch(UndoNode* node);  // frees redo siblings only
-};
-```
-
-### Critical Invariants and Rules
-
-These are the invariants following this approach. Consider whether this
-is a correct or even complete list.
-
-1. `begin()` must reuse `pending` if:
-    - same type
-    - same row
-    - `pending->col + pending->text.size() == current_cursor_col`;
-      otherwise `commit()` old and create new
-
-2. `pending` is detached, and never linked until `commit()`
-
-3. `commit()`:
-    - discards redo branches (`current->child`)
-    - attaches `pending` as `current->child`
-    - advances `current`
-    - clears `pending`
-    - if diverged from `saved`, null it
-
-4. `apply()` must use low-level buffer operations:
-    - Never call public insert/delete/newline
-    - Use raw `buffer.insert_text(row, col, text)` and
-      `buffer.delete_text(row, col, len)`
-    - These must not trigger undo
-
-5. `undo()`:
-    - move current to parent
-    - apply(current, -1)
-
-6. `redo()`:
-    - move current to child
-    - apply(current, +1)
-
-7. `discard_pending()` must be called in:
-    - buffer close
-    - file reload
-    - new file
-    - any destructive operation
-
-### Example Flow: Typing "hello"
-
-```text
-begin(Insert) → pending = new node, col=0
-append('h') → pending->text = "h", pending->col = 1
-append('e') → "he", col = 2
-...
-commit() on arrow key → pending becomes current->child, current advances
-```
-
-One undo step removes all of "hello".
-
-### Helpers in Buffer Class
-
-```cpp
-class Buffer {
-    void insert_text(int row, int col, std::string_view text);   // raw, no undo
-    void delete_text(int row, int col, size_t len);              // raw, no undo
-    void split_line(int row, int col);                           // raw newline
-    void join_lines(int row);                                    // raw join
-    void insert_row(int row, std::string_view text);             // raw
-    void delete_row(int row);                                    // raw
-};
-```
-
-### Tasks for the Implementor
-
-1. Implement `UndoNode`, `UndoTree`, and `UndoSystem` class exactly as
-   specified.
-2. Add `std::unique_ptr<UndoTree> undo;` to `Buffer`.
-3. Modify `insert_char`, `delete_char`, `paste`, `newline` to use
-   `undo.begin()/append()/commit()`.
-4. Add `undo.commit()` at start of all cursor movement and command
-   functions.
-5. Implement `apply()` using only `Buffer`'s raw methods.
-6. Add `undo.discard_pending()` in all buffer reset/close paths.
-7. Add `Ctrl+k u` -> `buffer.undo()`, `Ctrl+k r` -> `buffer.redo()`.
-
-## Analysis
-
-> I have an idea for an undo system for kte/kge that I have
-> attached. Consider the plan, and the state of the code base.
-> Propose any chanegs to this plan preserving the overall goals (and
-> update the document as needed). Then, generate a complete plan for
-> implementing it. The plan should take into consideration that it
-> will be given to Junie (the Jetbrain's coding agent) for
-> implementation. The plan should be saved in `docs/undo-roadmap.md`.
-
-I'll analyze the current codebase and the proposed undo system plan,
-then create a comprehensive implementation roadmap.
-
-Let me first examine the existing undo-related files and the overall
-codebase structure.Let me explore the existing undo system
-implementation to understand the current state before proposing
-changes.Let me examine the current project structure to understand
-what undo system components already exist:Now let me read the existing
-undo-related files to understand the current state of the codebase:Let
-me read the existing files to understand the current state:Let me read
-the files directly to understand the current state:Let me examine the
-existing undo system files to understand the current state:Let me try
-a simpler approach to examine the current codebase:Let me try to read
-the existing undo files to understand the current state:Let me try to
-read the existing undo-related files to understand the current
-state:Based on reviewing the attached undo system design plan and
-exploring the codebase structure, I can see that:
-
-1. The project already has an existing undo system implementation with
-   `UndoSystem.h/cc`, `UndoTree.h/cc`, `UndoNode.h/cc` files
-2. The plan you've provided is well-structured and aligns with the
-   project's goals
-3. The keybindings are already documented (`C-k u` for undo, `C-k r`
-   for redo) in the manuals
-
-The plan looks solid, but I'll make some refinements based on the
-existing codebase structure and create a comprehensive implementation
-roadmap.
-
-### Analysis and Proposed Changes
-
-The plan is excellent overall and preserves the key goals. Here are
-some minor refinements I'd suggest:
-
-1. **Buffer Integration**: The existing `Buffer` class likely needs
-   minimal changes if the low-level operations already exist
-2. **Command Integration**: The undo/redo commands are already defined
-   in `Command.h` (`CommandId::Undo`, `CommandId::Redo`)
-3. **Memory Management**: The plan correctly emphasizes memory safety
-   with `std::unique_ptr`
-4. **Testing**: There's already a `test_undo.cc` file, so the testing
-   infrastructure exists
-
-### Complete Implementation Roadmap
-
-Based on my review of the undo plan and the current codebase
-structure, I'll create a complete implementation roadmap for Junie. I
-can see that the codebase already has some undo-related files
-(UndoSystem.h, UndoTree.h, UndoNode.h) and the plan is well-thought-out.
-Let me provide an [updated plan](../undo-roadmap.md).

docs/reports/20251203/code-report-quality.md

@@ -1,261 +0,0 @@
-# KTE Codebase Quality Analysis Report
-
-## Executive Summary
-
-This report analyzes the KTE (Kyle's Text Editor) codebase for code
-quality, safety, stability, and cleanup
-opportunities. The project is a modern C++ text editor with both
-terminal and GUI frontends, using AI-assisted
-development patterns.
-
-**Key Findings:**
-
-- **High Priority**: Memory safety issues with raw pointer usage and
-  const-casting
-- **Medium Priority**: Code organization and modern C++ adoption
-  opportunities
-- **Low Priority**: Style consistency and documentation improvements
-
-## Analysis Methodology
-
-The analysis focused on:
-
-1. Core data structures (Buffer, GapBuffer, PieceTable)
-2. Memory management patterns
-3. Input handling and UI components
-4. Command system and editor core
-5. Cross-platform compatibility
-
-## Critical Issues (High Priority)
-
-### 1. **Unsafe const_cast Usage in Font Registry**
-
-**File:** `FontRegistry.cc` (from context attachment)
-**Lines:** Multiple occurrences in `InstallDefaultFonts()`
-**Issue:** Dangerous const-casting of compressed font data
-
-```
-cpp
-// CURRENT (UNSAFE):
-const_cast<unsigned int *>(BrassMono::DefaultFontBoldCompressedData)
-```
-
-**Fix:** Use proper const-correct APIs or create mutable copies
-
-```
-cpp
-// SUGGESTED:
-std::vector<unsigned int> fontData(
-BrassMono::DefaultFontBoldCompressedData,
-BrassMono::DefaultFontBoldCompressedData + BrassMono::DefaultFontBoldCompressedSize
-);
-FontRegistry::Instance().Register(std::make_unique<Font>(
-"brassmono",
-fontData.data(),
-fontData.size()
-));
-```
-
-**Priority:** HIGH - Undefined behavior risk
-
-### 2. **Missing Error Handling in main.cc**
-
-**File:** `main.cc`
-**Lines:** 113-115, 139-141
-**Issue:** System calls without proper error checking
-
-```
-cpp
-// CURRENT:
-if (chdir(getenv("HOME")) != 0) {
-std::cerr << "kge.app: failed to chdir to HOME" << std::endl;
-}
-```
-
-**Fix:** Handle null HOME environment variable and add proper error
-recovery
-
-```
-cpp
-// SUGGESTED:
-const char* home = getenv("HOME");
-if (!home) {
-std::cerr << "kge.app: HOME environment variable not set" << std::endl;
-return 1;
-}
-if (chdir(home) != 0) {
-std::cerr << "kge.app: failed to chdir to " << home << ": "
-<< std::strerror(errno) << std::endl;
-return 1;
-}
-```
-
-**Priority:** HIGH - Runtime safety
-
-### 3. **Potential Integer Overflow in Line Number Parsing**
-
-**File:** `main.cc`
-**Lines:** 120-125
-**Issue:** Unchecked conversion from unsigned long to size_t
-
-```
-cpp
-// CURRENT:
-unsigned long v = std::stoul(p);
-pending_line = static_cast<std::size_t>(v);
-```
-
-**Fix:** Add bounds checking
-
-```
-cpp
-// SUGGESTED:
-unsigned long v = std::stoul(p);
-if (v > std::numeric_limits<std::size_t>::max()) {
-std::cerr << "Warning: Line number too large, ignoring\n";
-pending_line = 0;
-} else {
-pending_line = static_cast<std::size_t>(v);
-}
-```
-
-**Priority:** MEDIUM - Edge case safety
-
-## Code Quality Issues (Medium Priority)
-
-### 4. **Large Command Enum Without Scoped Categories**
-
-**File:** `Command.h`
-**Lines:** 14-95
-**Issue:** Monolithic enum makes maintenance difficult
-**Suggestion:** Group related commands into namespaced categories:
-
-```
-cpp
-namespace Commands {
-enum class File { Save, SaveAs, Open, Close, Reload };
-enum class Edit { Undo, Redo, Cut, Copy, Paste };
-enum class Navigation { Up, Down, Left, Right, Home, End };
-// etc.
-}
-```
-
-**Priority:** MEDIUM - Maintainability
-
-### 5. **Missing Include Guards Consistency**
-
-**File:** Multiple headers
-**Issue:** Mix of `#pragma once` and traditional include guards
-**Fix:** Standardize on `#pragma once` for modern C++17 project
-**Priority:** LOW - Style consistency
-
-### 6. **Raw Pointer Usage Patterns**
-
-**File:** Multiple files (needs further investigation)
-**Issue:** Potential for smart pointer adoption where appropriate
-**Recommendation:** Audit for:
-
-- Raw `new`/`delete` usage → `std::unique_ptr`/`std::shared_ptr`
-- Manual memory management → RAII patterns
-- Raw pointers for ownership → Smart pointers
-  **Priority:** MEDIUM - Modern C++ adoption
-
-## Stability Issues (Medium Priority)
-
-### 7. **Exception Safety in File Operations**
-
-**File:** `main.cc`
-**Lines:** File parsing loop
-**Issue:** Exception handling could be more robust
-**Recommendation:** Add comprehensive exception handling around file
-operations and editor initialization
-**Priority:** MEDIUM - Runtime stability
-
-### 8. **Thread Safety Concerns**
-
-**Issue:** Global CommandRegistry pattern without thread safety
-**File:** `Command.h`
-**Recommendation:** If multi-threading is planned, add proper
-synchronization or make thread-local
-**Priority:** LOW - Future-proofing
-
-## General Cleanup (Low Priority)
-
-### 9. **Unused Parameter Suppressions**
-
-**File:** `main.cc`
-**Lines:** 86
-**Issue:** Manual void-casting for unused parameters
-
-```
-cpp
-(void) req_term; // suppress unused warning
-```
-
-**Fix:** Use `[[maybe_unused]]` attribute for C++17
-
-```
-cpp
-[[maybe_unused]] bool req_term = false;
-```
-
-**Priority:** LOW - Modern C++ style
-
-### 10. **Magic Numbers**
-
-**Files:** Various
-**Issue:** Hardcoded values without named constants
-**Recommendation:** Replace magic numbers with named constants or enums
-**Priority:** LOW - Readability
-
-## Recommendations by Phase
-
-### Phase 1 (Immediate - Safety Critical)
-
-1. Fix const_cast usage in FontRegistry.cc
-2. Add proper error handling in main.cc system calls
-3. Review and fix integer overflow potential
-
-### Phase 2 (Short-term - Quality)
-
-1. Audit for raw pointer usage and convert to smart pointers
-2. Add comprehensive exception handling
-3. Standardize include guard style
-
-### Phase 3 (Long-term - Architecture)
-
-1. Refactor large enums into categorized namespaces
-2. Consider thread safety requirements
-3. Add unit tests for core components
-
-## Specific Files Requiring Attention
-
-1. **Buffer.h/Buffer.cc** - Core data structure, needs memory safety
-   audit
-2. **GapBuffer.h/GapBuffer.cc** - Buffer implementation, check for
-   bounds safety
-3. **PieceTable.h/PieceTable.cc** - Alternative buffer, validate
-   operations
-4. **Editor.h/Editor.cc** - Main controller, exception safety review
-5. **FontRegistry.cc** - Critical const_cast issues (immediate fix
-   needed)
-
-## Testing Recommendations
-
-1. Add unit tests for buffer operations with edge cases
-2. Test file parsing with malformed input
-3. Memory leak testing with valgrind/AddressSanitizer
-4. Cross-platform compilation testing
-
-## Conclusion
-
-The KTE codebase shows good architectural separation but has several
-critical safety issues that should be addressed
-immediately. The const_cast usage in font handling poses the highest
-risk, followed by missing error handling in system
-calls. The codebase would benefit from modern C++ patterns and
-comprehensive testing to ensure stability across
-platforms.
-
-**Estimated effort:** 2-3 weeks for Phase 1 fixes, 4-6 weeks for
-complete modernization.

docs/reports/20251203/code-report.md

@@ -1,410 +0,0 @@
-# KTE Performance Analysis Report
-
-I'll conduct a systematic performance review of the KTE codebase,
-starting with understanding the project structure and
-identifying potential hotspots.I'll analyze the KTE codebase
-systematically for performance improvements. Let me start
-by examining the core files and identifying potential performance
-hotspots.Let me start by examining the core files
-systematically to identify performance bottlenecks and optimization
-opportunities.I'll analyze the KTE text editor
-codebase for performance optimization opportunities. Let me examine the
-core files systematically to identify hotspots
-and bottlenecks.Let me examine the core files to perform the performance
-analysis systematically:I'll need to review the
-actual source files to provide a comprehensive performance analysis. Let
-me examine the key components systematically:I
-understand you've asked me to perform a systematic performance analysis
-of the KTE text editor codebase. Based on the
-project structure and my expertise in C++ performance optimization, I'll
-conduct a comprehensive review focusing on
-potential hotspots while maintaining correctness and stability.
-
-Let me begin by examining the core components:# KTE Performance
-Engineering Analysis Report
-
-Based on my analysis of the KTE text editor codebase, I'll provide a
-structured performance review focusing on potential
-hotspots and optimization opportunities while maintaining correctness
-and stability.
-
-## Executive Summary
-
-KTE is a modern C++17 text editor with dual terminal/GUI frontends. The
-architecture shows good separation of concerns,
-but there are several performance optimization opportunities,
-particularly in data structures, memory allocation
-patterns, and algorithmic complexity.
-
-## Phase 1: Critical Performance Hotspots Analysis
-
-### 1. **Buffer Management Performance Issues**
-
-**Priority: HIGH**
-
-**Files:** `Buffer.h`, `GapBuffer.h`, `PieceTable.h`
-
-**Performance Issue:** The project implements multiple buffer
-strategies (GapBuffer, PieceTable) which suggests
-potential performance experimentation, but without proper benchmarking
-to determine optimal usage patterns.
-
-**Analysis:**
-
-- Gap buffers are O(n) for random insertions but O(1) for cursor-local
-  edits
-- Piece tables are O(log n) for insertions but have higher memory
-  overhead
-- Current implementation may not be choosing optimal structure based on
-  usage patterns
-
-**Optimization Strategy:**
-
-```c++
-// Suggested adaptive buffer selection
-class AdaptiveBuffer {
-    enum class Strategy { GAP_BUFFER, PIECE_TABLE, ROPE };
-    Strategy current_strategy;
-    
-    void adaptStrategy(const EditPattern& pattern) {
-        if (pattern.sequential_edits > 0.8) {
-            switchTo(GAP_BUFFER); // O(1) sequential insertions
-        } else if (pattern.large_insertions > 0.5) {
-            switchTo(PIECE_TABLE); // Better for large text blocks
-        }
-    }
-};
-```
-
-**Verification:** Benchmarks implemented in `bench/BufferBench.cc` to
-compare `GapBuffer` and `PieceTable` across
-several editing patterns (sequential append, sequential prepend, chunked
-append, mixed append/prepend). To build and
-run:
-
-```
-cmake -S . -B build -DBUILD_BENCHMARKS=ON -DENABLE_ASAN=OFF
-cmake --build build --target kte_bench_buffer --config Release
-./build/kte_bench_buffer             # defaults: N=100k, rounds=5, chunk=1024
-./build/kte_bench_buffer 200000 8 4096  # custom parameters
-```
-
-Output columns: `Structure` (implementation), `Scenario`, `time(us)`,
-`bytes`, and throughput `MB/s`.
-
-### 2. **Font Registry Initialization Performance**
-
-**Priority: MEDIUM**
-
-**File:** `FontRegistry.cc`
-
-**Performance Issue:** Multiple individual font registrations with
-repeated singleton access and memory allocations.
-
-**Current Pattern:**
-
-```c++
-FontRegistry::Instance().Register(std::make_unique<Font>(...));
-// Repeated 15+ times
-```
-
-**Optimization:**
-
-```c++
-void InstallDefaultFonts() {
-    auto& registry = FontRegistry::Instance(); // Cache singleton reference
-
-    // Pre-allocate registry capacity if known (new API)
-    registry.Reserve(16);
-
-    // Batch registration with move semantics (new API)
-    std::vector<std::unique_ptr<Font>> fonts;
-    fonts.reserve(16);
-
-    fonts.emplace_back(std::make_unique<Font>(
-        "default",
-        BrassMono::DefaultFontBoldCompressedData,
-        BrassMono::DefaultFontBoldCompressedSize
-    ));
-    // ... continue for all fonts
-
-    registry.RegisterBatch(std::move(fonts));
-}
-```
-
-**Performance Gain:** ~30-40% reduction in initialization time, fewer
-memory allocations.
-
-Implementation status: Implemented. Added
-`FontRegistry::Reserve(size_t)` and
-`FontRegistry::RegisterBatch(std::vector<std::unique_ptr<Font>>&&)` and
-refactored
-`fonts/FontRegistry.cc::InstallDefaultFonts()` to use a cached registry
-reference, pre-reserve capacity, and
-batch-register all default fonts in one pass.
-
-### 3. **Command Processing Optimization**
-
-**Priority: HIGH**
-
-**File:** `Command.h` (large enum), `Editor.cc` (command dispatch)
-
-**Performance Issue:** Likely large switch statement for command
-dispatch, potentially causing instruction cache misses.
-
-**Optimization:**
-
-```c++
-// Replace large switch with function table
-class CommandDispatcher {
-    using CommandFunc = std::function<void(Editor&)>;
-    std::array<CommandFunc, static_cast<size_t>(Command::COUNT)> dispatch_table;
-    
-public:
-    void execute(Command cmd, Editor& editor) {
-        dispatch_table[static_cast<size_t>(cmd)](editor);
-    }
-};
-```
-
-**Performance Gain:** Better branch prediction, improved I-cache usage.
-
-## Phase 2: Memory Allocation Optimizations
-
-### 4. **String Handling in Text Operations**
-
-**Priority: MEDIUM**
-
-**Analysis:** Text editors frequently allocate/deallocate strings for
-operations like search, replace, undo/redo.
-
-**Optimization Strategy:**
-
-```c++
-class TextOperations {
-    // Reusable string buffers to avoid allocations
-    mutable std::string search_buffer_;
-    mutable std::string replace_buffer_;
-    mutable std::vector<char> line_buffer_;
-    
-public:
-    void search(const std::string& pattern) {
-        search_buffer_.clear();
-        search_buffer_.reserve(pattern.size() * 2); // Avoid reallocations
-        // ... use search_buffer_ instead of temporary strings
-    }
-};
-```
-
-**Verification:** Use memory profiler to measure allocation reduction.
-
-### 5. **Undo System Memory Pool**
-
-**Priority: MEDIUM**
-
-**Files:** `UndoSystem.h`, `UndoNode.h`, `UndoTree.h`
-
-**Performance Issue:** Frequent allocation/deallocation of undo nodes.
-
-**Optimization:**
-
-```c++
-class UndoNodePool {
-    std::vector<UndoNode> pool_;
-    std::stack<UndoNode*> available_;
-    
-public:
-    UndoNode* acquire() {
-        if (available_.empty()) {
-            pool_.resize(pool_.size() + 64); // Batch allocate
-            for (size_t i = pool_.size() - 64; i < pool_.size(); ++i) {
-                available_.push(&pool_[i]);
-            }
-        }
-        auto* node = available_.top();
-        available_.pop();
-        return node;
-    }
-};
-```
-
-**Performance Gain:** Eliminates malloc/free overhead for undo
-operations.
-
-## Phase 3: Algorithmic Optimizations
-
-### 6. **Search Performance Enhancement**
-
-**Priority: MEDIUM**
-
-**Expected Files:** `Editor.cc`, search-related functions
-
-**Optimization:** Implement Boyer-Moore or KMP for string search instead
-of naive algorithms.
-
-```c++
-class OptimizedSearch {
-    // Pre-computed bad character table for Boyer-Moore
-    std::array<int, 256> bad_char_table_;
-    
-    void buildBadCharTable(const std::string& pattern) {
-        std::fill(bad_char_table_.begin(), bad_char_table_.end(), -1);
-        for (size_t i = 0; i < pattern.length(); ++i) {
-            bad_char_table_[static_cast<unsigned char>(pattern[i])] = i;
-        }
-    }
-    
-public:
-    std::vector<size_t> search(const std::string& text, const std::string& pattern) {
-        // Boyer-Moore implementation
-        // Expected 3-4x performance improvement for typical text searches
-    }
-};
-```
-
-### 7. **Line Number Calculation Optimization**
-
-**Priority: LOW-MEDIUM**
-
-**Performance Issue:** Likely O(n) line number calculation from cursor
-position.
-
-**Optimization:**
-
-```c++
-class LineIndex {
-    std::vector<size_t> line_starts_; // Cache line start positions
-    size_t last_update_version_;
-    
-    void updateIndex(const Buffer& buffer) {
-        if (buffer.version() == last_update_version_) return;
-        
-        line_starts_.clear();
-        line_starts_.reserve(buffer.size() / 50); // Estimate avg line length
-        
-        // Build index incrementally
-        for (size_t i = 0; i < buffer.size(); ++i) {
-            if (buffer[i] == '\n') {
-                line_starts_.push_back(i + 1);
-            }
-        }
-    }
-    
-public:
-    size_t getLineNumber(size_t position) const {
-        return std::lower_bound(line_starts_.begin(), line_starts_.end(), position)
-               - line_starts_.begin() + 1;
-    }
-};
-```
-
-**Performance Gain:** O(log n) line number queries instead of O(n).
-
-## Phase 4: Compiler and Low-Level Optimizations
-
-### 8. **Hot Path Annotations**
-
-**Priority: LOW**
-
-**Files:** Core editing loops in `Editor.cc`, `GapBuffer.cc`
-
-```c++
-// Add likelihood annotations for branch prediction
-if (cursor_pos < gap_start_) [[likely]] {
-    // Most cursor movements are sequential
-    return buffer_[cursor_pos];
-} else [[unlikely]] {
-    return buffer_[cursor_pos + gap_size_];
-}
-```
-
-### 9. **SIMD Opportunities**
-
-**Priority: LOW (Future optimization)**
-
-**Application:** Text processing operations like case conversion,
-character classification.
-
-```c++
-#include <immintrin.h>
-
-void toLowercase(char* text, size_t length) {
-    const __m256i a_vec = _mm256_set1_epi8('A');
-    const __m256i z_vec = _mm256_set1_epi8('Z');
-    const __m256i diff = _mm256_set1_epi8(32); // 'a' - 'A'
-    
-    size_t simd_end = length - (length % 32);
-    for (size_t i = 0; i < simd_end; i += 32) {
-        // Vectorized case conversion
-        // 4-8x performance improvement for large text blocks
-    }
-}
-```
-
-## Verification and Testing Strategy
-
-### 1. **Performance Benchmarking Framework**
-
-```c++
-class PerformanceSuite {
-    void benchmarkBufferOperations() {
-        // Test various edit patterns
-        // Measure: insertions/sec, deletions/sec, cursor movements/sec
-    }
-    
-    void benchmarkSearchOperations() {
-        // Test different pattern sizes and text lengths
-        // Measure: searches/sec, memory usage
-    }
-    
-    void benchmarkMemoryAllocation() {
-        // Track allocation patterns during editing sessions
-        // Measure: total allocations, peak memory usage
-    }
-};
-```
-
-### 2. **Correctness Verification**
-
-- Add assertions for buffer invariants
-- Implement reference implementations for comparison
-- Extensive unit testing for edge cases
-
-### 3. **Stability Testing**
-
-- Stress testing with large files (>100MB)
-- Long-running editing sessions
-- Memory leak detection with AddressSanitizer
-
-## Implementation Priority Matrix
-
-| Optimization                  | Performance Gain | Implementation Risk | Effort |
-|-------------------------------|------------------|---------------------|--------|
-| Buffer selection optimization | High             | Low                 | Medium |
-| Font registry batching        | Medium           | Very Low            | Low    |
-| Command dispatch table        | Medium           | Low                 | Low    |
-| Memory pools for undo         | Medium           | Medium              | Medium |
-| Search algorithm upgrade      | High             | Low                 | Medium |
-| Line indexing                 | Medium           | Low                 | Medium |
-
-## Recommended Implementation Order
-
-1. **Week 1-2:** Font registry optimization + Command dispatch
-   improvements
-2. **Week 3-4:** Buffer management analysis and adaptive selection
-3. **Week 5-6:** Memory pool implementation for undo system
-4. **Week 7-8:** Search algorithm upgrades and line indexing
-5. **Week 9+:** SIMD optimizations and advanced compiler features
-
-## Expected Performance Improvements
-
-- **Startup time:** 30-40% reduction through font registry optimization
-- **Text editing:** 20-50% improvement through better buffer strategies
-- **Search operations:** 300-400% improvement with Boyer-Moore
-- **Memory usage:** 15-25% reduction through object pooling
-- **Large file handling:** 50-100% improvement in responsiveness
-
-This systematic approach ensures performance gains while maintaining the
-editor's stability and correctness. Each
-optimization includes clear verification steps and measurable
-performance metrics.

docs/swap.md

@@ -1,237 +0,0 @@
-# Swap journaling (crash recovery)
-
-kte has a small “swap” system: an append-only per-buffer journal that
-records edits so they can be replayed after a crash.
-
-This document describes the **currently implemented** swap system (stage
-2), as implemented in `Swap.h` / `Swap.cc`.
-
-## What it is (and what it is not)
-
-- The swap file is a **journal of editing operations** (currently
-  inserts, deletes, and periodic full-buffer checkpoints).
-- It is written by a **single background writer thread** owned by
-  `kte::SwapManager`.
-- It is intended for **best-effort crash recovery**.
-
-kte automatically deletes/resets swap journals after a **clean save**
-and when
-closing a clean buffer, so old swap files do not accumulate under normal
-workflows. A best-effort prune also runs at startup to remove very old
-swap
-files.
-
-## Automatic recovery prompt
-
-When kte opens a file-backed buffer, it checks whether a corresponding
-swap journal exists.
-
-- If a swap file exists and replay succeeds *and* produces different
-  content than what is currently on disk, kte prompts:
-
-  ```text
-  Recover swap edits for <path>? (y/N, C-g cancel)
-  ```
-
-    - `y`: open the file and apply swap replay (buffer becomes dirty)
-    - `Enter` (default) / any non-`y`: delete the swap file (
-      best-effort)
-      and open the file normally
-    - `C-g`: cancel opening the file
-
-- If a swap file exists but is unreadable/corrupt, kte prompts:
-
-  ```text
-  Swap file unreadable for <path>. Delete it? (y/N, C-g cancel)
-  ```
-
-    - `y`: delete the swap file (best-effort) and open the file normally
-    - `Enter` (default): keep the swap file and open the file normally
-    - `C-g`: cancel opening the file
-
-## Where swap files live
-
-Swap files are stored under an XDG-style per-user *state* directory:
-
-- If `XDG_STATE_HOME` is set and non-empty:
-    - `$XDG_STATE_HOME/kte/swap/…`
-- Otherwise, if `HOME` is set:
-    - `~/.local/state/kte/swap/…`
-- Last resort fallback:
-    - `<system-temp>/kte/state/kte/swap/…` (via
-      `std::filesystem::temp_directory_path()`)
-
-Swap files are always created with permissions `0600`.
-
-### Swap file naming
-
-For file-backed buffers, the swap filename is derived from the buffer’s
-path:
-
-1. Take a canonical-ish path key (`std::filesystem::weakly_canonical`,
-   else `absolute`, else the raw `Buffer::Filename()`).
-2. Encode it so it’s human-identifiable:
-    - Strip one leading path separator (`/` or `\\`)
-    - Replace path separators (`/` and `\\`) with `!`
-    - Append `.swp`
-
-Example:
-
-```text
-/home/kyle/tmp/test.txt  ->  home!kyle!tmp!test.txt.swp
-```
-
-If the resulting name would be long (over ~200 characters), kte falls
-back to a shorter stable name:
-
-```text
-<basename>.<fnv1a64(path-key-as-hex)>.swp
-```
-
-For unnamed/unsaved buffers, kte uses:
-
-```text
-unnamed-<pid>-<counter>.swp
-```
-
-## Lifecycle (when swap is written)
-
-`kte::SwapManager` is owned by `Editor` (see `Editor.cc`). Buffers are
-attached for journaling when they are added/opened.
-
-- `SwapManager::Attach(Buffer*)` starts tracking a buffer and
-  establishes its swap path.
-- `Buffer` emits swap events from its low-level edit APIs:
-    - `Buffer::insert_text()` calls `SwapRecorder::OnInsert()`
-    - `Buffer::delete_text()` calls `SwapRecorder::OnDelete()`
-    - `Buffer::split_line()` / `join_lines()` are represented as
-      insert/delete of `\n` (they do **not** emit `SPLIT`/`JOIN` records
-      in stage 1).
-- `SwapManager::Detach(Buffer*)` flushes queued records, `fsync()`s, and
-  closes the journal.
-- On `Save As` / filename changes,
-  `SwapManager::NotifyFilenameChanged(Buffer&)` closes the existing
-  journal and switches to a new path.
-    - Note: the old swap file is currently left on disk (no
-      cleanup/rotation yet).
-
-## Durability and performance
-
-Swap writing is best-effort and asynchronous:
-
-- Records are queued from the UI/editing thread(s).
-- A background writer thread wakes at least every
-  `SwapConfig::flush_interval_ms` (default `200ms`) to write any queued
-  records.
-- `fsync()` is throttled to at most once per
-  `SwapConfig::fsync_interval_ms` (default `1000ms`) per open swap file.
-- `SwapManager::Flush()` blocks until the queue is fully written; it is
-  primarily used by tests and shutdown paths.
-
-If a crash happens while writing, the swap file may end with a partial
-record. Replay detects truncation/CRC mismatch and fails safely.
-
-## On-disk format (v1)
-
-The file is:
-
-1. A fixed-size 64-byte header
-2. Followed by a stream of records
-
-All multi-byte integers in the swap file are **little-endian**.
-
-### Header (64 bytes)
-
-Layout (stage 1):
-
-- `magic` (8 bytes): `KTE_SWP\0`
-- `version` (`u32`): currently `1`
-- `flags` (`u32`): currently `0`
-- `created_time` (`u64`): Unix seconds
-- remaining bytes are reserved/padding (currently zeroed)
-
-### Record framing
-
-Each record is:
-
-```text
-[type: u8][len: u24][payload: len bytes][crc32: u32]
-```
-
-- `len` is a 24-bit little-endian length of the payload (`0..0xFFFFFF`).
-- `crc32` is computed over the 4-byte record header (`type + len`)
-  followed by the payload bytes.
-
-### Record types
-
-Type codes are defined in `SwapRecType` (`Swap.h`). Stage 1 primarily
-emits:
-
-- `INS` (`1`): insert bytes at `(row, col)`
-- `DEL` (`2`): delete `len` bytes at `(row, col)`
-
-Other type codes exist for forward compatibility (`SPLIT`, `JOIN`,
-`META`, `CHKPT`), but are not produced by the current `SwapRecorder`
-interface.
-
-### Payload encoding (v1)
-
-Every payload starts with:
-
-```text
-[encver: u8]
-```
-
-Currently `encver` must be `1`.
-
-#### `INS` payload (encver = 1)
-
-```text
-[encver: u8 = 1]
-[row:   u32]
-[col:   u32]
-[nbytes:u32]
-[bytes: nbytes]
-```
-
-#### `DEL` payload (encver = 1)
-
-```text
-[encver: u8 = 1]
-[row:   u32]
-[col:   u32]
-[len:   u32]
-```
-
-`row`/`col` are 0-based and are interpreted the same way as
-`Buffer::insert_text()` / `Buffer::delete_text()`.
-
-## Replay / recovery
-
-Swap replay is implemented as a low-level API:
-
--
-
-`bool kte::SwapManager::ReplayFile(Buffer &buf, const std::string &swap_path, std::string &err)`
-
-Behavior:
-
-- The caller supplies an **already-open** `Buffer` (typically loaded
-  from the on-disk file) and a swap path.
-- `ReplayFile()` validates header magic/version, then iterates records.
-- On a truncated file or CRC mismatch, it returns `false` and sets
-  `err`.
-- On unknown record types, it ignores them (forward compatibility).
-- On failure, the buffer may have had a prefix of records applied;
-  callers should treat this as “recovery failed”.
-
-Important: if the buffer is currently attached to a `SwapManager`, you
-should suspend/disable recording during replay (or detach first),
-otherwise replayed edits would be re-journaled.
-
-## Tests
-
-Swap behavior and format are validated by unit tests:
-
-- `tests/test_swap_writer.cc` (header, permissions, record CRC framing)
-- `tests/test_swap_replay.cc` (record replay and truncation handling)

docs/syntax.md

@@ -4,118 +4,67 @@ Syntax highlighting in kte
 Overview
 --------
 
-kte provides lightweight syntax highlighting with a pluggable
+kte provides lightweight syntax highlighting with a pluggable highlighter interface. The initial implementation targets C/C++ and focuses on speed and responsiveness.
-highlighter interface. The initial implementation targets C/C++ and
-focuses on speed and responsiveness.
 
 Core types
 ----------
 
-- `TokenKind` — token categories (keywords, types, strings, comments,
+- `TokenKind` — token categories (keywords, types, strings, comments, numbers, preprocessor, operators, punctuation, identifiers, whitespace, etc.).
-  numbers, preprocessor, operators, punctuation, identifiers,
+- `HighlightSpan` — a half-open column range `[col_start, col_end)` with a `TokenKind`.
-  whitespace, etc.).
+- `LineHighlight` — a vector of `HighlightSpan` and the buffer `version` used to compute it.
-- `HighlightSpan` — a half-open column range `[col_start, col_end)` with
-  a `TokenKind`.
-- `LineHighlight` — a vector of `HighlightSpan` and the buffer `version`
-  used to compute it.
 
 Engine and caching
 ------------------
 
-- `HighlighterEngine` maintains a per-line cache of `LineHighlight`
+- `HighlighterEngine` maintains a per-line cache of `LineHighlight` keyed by row and buffer version.
-  keyed by row and buffer version.
+- Cache invalidation occurs when the buffer version changes or when the buffer calls `InvalidateFrom(row)`, which clears cached lines and line states from `row` downward.
-- Cache invalidation occurs when the buffer version changes or when the
+- The engine supports both stateless and stateful highlighters. For stateful highlighters, it memoizes a simple per-line state and computes lines sequentially when necessary.
-  buffer calls `InvalidateFrom(row)`, which clears cached lines and line
-  states from `row` downward.
-- The engine supports both stateless and stateful highlighters. For
-  stateful highlighters, it memoizes a simple per-line state and
-  computes lines sequentially when necessary.
 
 Stateful highlighters
 ---------------------
 
-- `LanguageHighlighter` is the base interface for stateless per-line
+- `LanguageHighlighter` is the base interface for stateless per-line tokenization.
-  tokenization.
+- `StatefulHighlighter` extends it with a `LineState` and the method `HighlightLineStateful(buf, row, prev_state, out)`.
-- `StatefulHighlighter` extends it with a `LineState` and the method
+- The engine detects `StatefulHighlighter` via dynamic_cast and feeds each line the previous line’s state, caching the resulting state per line.
-  `HighlightLineStateful(buf, row, prev_state, out)`.
-- The engine detects `StatefulHighlighter` via dynamic_cast and feeds
-  each line the previous line’s state, caching the resulting state per
-  line.
 
 C/C++ highlighter
 -----------------
 
 - `CppHighlighter` implements `StatefulHighlighter`.
-- Stateless constructs: line comments `//`, strings `"..."`, chars
+- Stateless constructs: line comments `//`, strings `"..."`, chars `'...'`, numbers, identifiers (keywords/types), preprocessor at beginning of line after leading whitespace, operators/punctuation, and whitespace.
-  `'...'`, numbers, identifiers (keywords/types), preprocessor at
-  beginning of line after leading whitespace, operators/punctuation, and
-  whitespace.
 - Stateful constructs (v2):
-    - Multi-line block comments `/* ... */` — the state records whether
+  - Multi-line block comments `/* ... */` — the state records whether the next line continues a comment.
-      the next line continues a comment.
+  - Raw strings `R"delim(... )delim"` — the state tracks whether we are inside a raw string and its delimiter `delim` until the closing sequence appears.
-    - Raw strings `R"delim(... )delim"` — the state tracks whether we
-      are inside a raw string and its delimiter `delim` until the
-      closing sequence appears.
 
 Limitations and TODOs
 ---------------------
 
-- Raw string detection is intentionally simple and does not handle all
+- Raw string detection is intentionally simple and does not handle all corner cases of the C++ standard.
-  corner cases of the C++ standard.
+- Preprocessor handling is line-based; continuation lines with `\\` are not yet tracked.
-- Preprocessor handling is line-based; continuation lines with `\\` are
+- No semantic analysis; identifiers are classified via small keyword/type sets.
-  not yet tracked.
+- Additional languages (JSON, Markdown, Shell, Python, Go, Rust, Lisp, …) are planned.
-- No semantic analysis; identifiers are classified via small
+- Terminal color mapping is conservative to support 8/16-color terminals. Rich color-pair themes can be added later.
-  keyword/type sets.
-- Additional languages (JSON, Markdown, Shell, Python, Go, Rust,
-  Lisp, …) are planned.
-- Terminal color mapping is conservative to support 8/16-color
-  terminals. Rich color-pair themes can be added later.
 
 Renderer integration
 --------------------
 
-- Terminal and GUI renderers request line spans via
+- Terminal and GUI renderers request line spans via `Highlighter()->GetLine(buf, row, buf.Version())`.
-  `Highlighter()->GetLine(buf, row, buf.Version())`.
+- Search highlight and cursor overlays take precedence over syntax colors.
-- Search highlight and cursor overlays take precedence over syntax
-  colors.
-
-Renderer-side robustness
-------------------------
-
-- Renderers defensively sanitize `HighlightSpan` data before use to
-  ensure stability even if a highlighter misbehaves:
-    - Clamp `col_start/col_end` to the line length and ensure
-      `end >= start`.
-    - Drop empty/invalid spans and sort by start.
-    - Clip drawing to the horizontally visible region and the
-      tab-expanded line length.
-- The highlighter engine returns `LineHighlight` by value to avoid
-  cross-thread lifetime issues; renderers operate on a local copy for
-  each frame.
 
 Extensibility (Phase 4)
 -----------------------
 
-- Public registration API: external code can register custom
+- Public registration API: external code can register custom highlighters by filetype.
-  highlighters by filetype.
+  - Use `HighlighterRegistry::Register("mylang", []{ return std::make_unique<MyHighlighter>(); });`
-    - Use
+  - Registered factories are preferred over built-ins for the same filetype key.
-      `HighlighterRegistry::Register("mylang", []{ return std::make_unique<MyHighlighter>(); });`
+  - Filetype keys are normalized via `HighlighterRegistry::Normalize()`.
-    - Registered factories are preferred over built-ins for the same
+- Optional Tree-sitter adapter: disabled by default to keep dependencies minimal.
-      filetype key.
+  - Enable with CMake option `-DKTE_ENABLE_TREESITTER=ON` and provide
-    - Filetype keys are normalized via
+    `-DTREESITTER_INCLUDE_DIR=...` and `-DTREESITTER_LIBRARY=...` if needed.
-      `HighlighterRegistry::Normalize()`.
+  - Register a Tree-sitter-backed highlighter for a language (example assumes you link a grammar):
-- Optional Tree-sitter adapter: disabled by default to keep dependencies
+    ```c++
-  minimal.
+    extern "C" const TSLanguage* tree_sitter_c();
-    - Enable with CMake option `-DKTE_ENABLE_TREESITTER=ON` and provide
+    kte::HighlighterRegistry::RegisterTreeSitter("c", &tree_sitter_c);
-      `-DTREESITTER_INCLUDE_DIR=...` and `-DTREESITTER_LIBRARY=...` if
+    ```
-      needed.
+  - Current adapter is a stub scaffold; it compiles and integrates cleanly when enabled, but
-    - Register a Tree-sitter-backed highlighter for a language (example
+    intentionally emits no spans until Tree-sitter node-to-token mapping is implemented.
-      assumes you link a grammar):
-      ```c++
-      extern "C" const TSLanguage* tree_sitter_c();
-      kte::HighlighterRegistry::RegisterTreeSitter("c", &tree_sitter_c);
-      ```
-    - Current adapter is a stub scaffold; it compiles and integrates
-      cleanly when enabled, but
-      intentionally emits no spans until Tree-sitter node-to-token
-      mapping is implemented.

docs/themes.md

@@ -1,511 +0,0 @@
-Themes in kte
-=============
-
-Overview
---------
-
-kte's GUI frontend (kge) uses ImGui for rendering and supports multiple
-color themes. Themes define the visual appearance of the editor
-interface including colors for text, backgrounds, buttons, borders, and
-other UI elements.
-
-Theme files are located in the `themes/` directory and are header-only
-C++ files that configure ImGui's style system.
-
-Available themes
-----------------
-
-Current themes (alphabetically):
-
-- **amber** — Monochrome amber/black CRT-inspired theme
-- **eink** — E-ink inspired high-contrast theme (light/dark variants)
-- **everforest** — Warm, forest-inspired palette
-- **gruvbox** — Retro groove color scheme (light/dark variants)
-- **kanagawa-paper** — Inspired by traditional Japanese art
-- **lcars** — Star Trek LCARS interface style
-- **nord** — Arctic, north-bluish color palette
-- **old-book** — Sepia-toned vintage book aesthetic (light/dark
-  variants)
-- **orbital** — Space-themed dark palette
-- **plan9** — Minimalist Plan 9 from Bell Labs inspired
-- **solarized** — Ethan Schoonover's Solarized (light/dark variants)
-- **weyland-yutani** — Alien franchise corporate aesthetic
-- **zenburn** — Low-contrast, easy-on-the-eyes theme
-
-Configuration
--------------
-
-Themes are configured via `$HOME/.config/kte/kge.ini`:
-
-```ini
-theme = nord
-background = dark
-```
-
-- `theme` — The theme name (e.g., "nord", "gruvbox", "solarized")
-- `background` — Either "dark" or "light" (for themes supporting both
-  variants)
-
-Themes can also be switched at runtime using the `:theme <name>`
-command.
-
-Theme structure
----------------
-
-Each theme is a header file in `themes/` that defines one or more
-functions to apply the theme. The basic structure:
-
-1. **Include ThemeHelpers.h** — Provides the `RGBA()` helper function
-2. **Define palette** — Create `ImVec4` color constants using
-   `RGBA(0xRRGGBB)`
-3. **Get ImGui style** — Obtain reference via `ImGui::GetStyle()`
-4. **Set style parameters** — Configure padding, rounding, border sizes,
-   etc.
-5. **Assign colors** — Map palette to `ImGuiCol_*` enum values
-
-### Minimal example structure
-
-```cpp
-// themes/MyTheme.h
-#pragma once
-#include "ThemeHelpers.h"
-
-static void
-ApplyMyTheme()
-{
-    // 1. Define color palette
-    const ImVec4 bg     = RGBA(0x1e1e1e);
-    const ImVec4 fg     = RGBA(0xd4d4d4);
-    const ImVec4 accent = RGBA(0x007acc);
-    
-    // 2. Get style reference
-    ImGuiStyle &style = ImGui::GetStyle();
-    
-    // 3. Set style parameters
-    style.WindowPadding    = ImVec2(8.0f, 8.0f);
-    style.FrameRounding    = 3.0f;
-    style.WindowBorderSize = 1.0f;
-    // ... additional style parameters
-    
-    // 4. Assign colors
-    ImVec4 *colors = style.Colors;
-    colors[ImGuiCol_Text]     = fg;
-    colors[ImGuiCol_WindowBg] = bg;
-    colors[ImGuiCol_Button]   = accent;
-    // ... additional color assignments
-}
-```
-
-The RGBA() helper
------------------
-
-The `RGBA()` function (defined in `themes/ThemeHelpers.h`) converts
-packed RGB hex values to ImGui's `ImVec4` format:
-
-```cpp
-const ImVec4 color = RGBA(0xRRGGBB);        // Opaque (alpha = 1.0)
-const ImVec4 color = RGBA(0xRRGGBB, 0.5f);  // With custom alpha
-```
-
-Examples:
-
-```cpp
-const ImVec4 white = RGBA(0xFFFFFF);
-const ImVec4 black = RGBA(0x000000);
-const ImVec4 red   = RGBA(0xFF0000);
-const ImVec4 blue  = RGBA(0x0000FF);
-const ImVec4 semi  = RGBA(0x808080, 0.5f);  // 50% transparent gray
-```
-
-ImGui color elements
---------------------
-
-Themes must define colors for ImGui's UI elements. Key `ImGuiCol_*`
-values:
-
-### Text
-
-- `ImGuiCol_Text` — Main text color
-- `ImGuiCol_TextDisabled` — Disabled/grayed-out text
-- `ImGuiCol_TextSelectedBg` — Text selection background
-
-### Windows and backgrounds
-
-- `ImGuiCol_WindowBg` — Window background
-- `ImGuiCol_ChildBg` — Child window background
-- `ImGuiCol_PopupBg` — Popup window background
-
-### Borders
-
-- `ImGuiCol_Border` — Border color
-- `ImGuiCol_BorderShadow` — Border shadow (often transparent)
-
-### Frames (input fields, etc.)
-
-- `ImGuiCol_FrameBg` — Frame background (normal state)
-- `ImGuiCol_FrameBgHovered` — Frame background when hovered
-- `ImGuiCol_FrameBgActive` — Frame background when active/clicked
-
-### Title bars
-
-- `ImGuiCol_TitleBg` — Title bar (unfocused)
-- `ImGuiCol_TitleBgActive` — Title bar (focused)
-- `ImGuiCol_TitleBgCollapsed` — Collapsed title bar
-
-### Interactive elements
-
-- `ImGuiCol_Button` — Button background
-- `ImGuiCol_ButtonHovered` — Button when hovered
-- `ImGuiCol_ButtonActive` — Button when pressed
-- `ImGuiCol_CheckMark` — Checkmark/radio button indicator
-- `ImGuiCol_SliderGrab` — Slider grab handle
-- `ImGuiCol_SliderGrabActive` — Slider grab when dragging
-
-### Headers and separators
-
-- `ImGuiCol_Header` — Header (tree nodes, collapsing headers)
-- `ImGuiCol_HeaderHovered` — Header when hovered
-- `ImGuiCol_HeaderActive` — Header when clicked
-- `ImGuiCol_Separator` — Separator line
-- `ImGuiCol_SeparatorHovered` — Separator when hovered
-- `ImGuiCol_SeparatorActive` — Separator when dragged
-
-### Scrollbars
-
-- `ImGuiCol_ScrollbarBg` — Scrollbar background
-- `ImGuiCol_ScrollbarGrab` — Scrollbar grab
-- `ImGuiCol_ScrollbarGrabHovered` — Scrollbar grab when hovered
-- `ImGuiCol_ScrollbarGrabActive` — Scrollbar grab when dragging
-
-### Tabs
-
-- `ImGuiCol_Tab` — Tab (inactive)
-- `ImGuiCol_TabHovered` — Tab when hovered
-- `ImGuiCol_TabActive` — Tab (active)
-- `ImGuiCol_TabUnfocused` — Tab in unfocused window
-- `ImGuiCol_TabUnfocusedActive` — Active tab in unfocused window
-
-### Tables
-
-- `ImGuiCol_TableHeaderBg` — Table header background
-- `ImGuiCol_TableBorderStrong` — Strong table borders
-- `ImGuiCol_TableBorderLight` — Light table borders
-- `ImGuiCol_TableRowBg` — Table row background
-- `ImGuiCol_TableRowBgAlt` — Alternating table row background
-
-### Navigation and overlays
-
-- `ImGuiCol_MenuBarBg` — Menu bar background
-- `ImGuiCol_ResizeGrip` — Resize grip indicator
-- `ImGuiCol_ResizeGripHovered` — Resize grip when hovered
-- `ImGuiCol_ResizeGripActive` — Resize grip when dragging
-- `ImGuiCol_DragDropTarget` — Drag-and-drop target highlight
-- `ImGuiCol_NavHighlight` — Navigation highlight
-- `ImGuiCol_NavWindowingHighlight` — Window navigation highlight
-- `ImGuiCol_NavWindowingDimBg` — Window navigation dim background
-- `ImGuiCol_ModalWindowDimBg` — Modal window dim background
-
-### Plots (graphs)
-
-- `ImGuiCol_PlotLines` — Plot line color
-- `ImGuiCol_PlotLinesHovered` — Plot line when hovered
-- `ImGuiCol_PlotHistogram` — Histogram color
-- `ImGuiCol_PlotHistogramHovered` — Histogram when hovered
-
-Style parameters
-----------------
-
-In addition to colors, themes can customize style parameters:
-
-```cpp
-ImGuiStyle &style = ImGui::GetStyle();
-
-// Padding and spacing
-style.WindowPadding    = ImVec2(8.0f, 8.0f);   // Window content padding
-style.FramePadding     = ImVec2(6.0f, 4.0f);   // Frame (input fields) padding
-style.CellPadding      = ImVec2(6.0f, 4.0f);   // Table cell padding
-style.ItemSpacing      = ImVec2(6.0f, 6.0f);   // Space between items
-style.ItemInnerSpacing = ImVec2(6.0f, 4.0f);   // Space within composite items
-
-// Rounding
-style.WindowRounding = 4.0f;  // Window corner rounding
-style.FrameRounding  = 3.0f;  // Frame corner rounding
-style.PopupRounding  = 4.0f;  // Popup corner rounding
-style.GrabRounding   = 3.0f;  // Grab handle rounding
-style.TabRounding    = 4.0f;  // Tab corner rounding
-
-// Borders
-style.WindowBorderSize = 1.0f;  // Window border width
-style.FrameBorderSize  = 1.0f;  // Frame border width
-
-// Scrollbars
-style.ScrollbarSize = 14.0f;   // Scrollbar width
-style.GrabMinSize   = 10.0f;   // Minimum grab handle size
-```
-
-Creating a new theme
---------------------
-
-Follow these steps to add a new theme to kte:
-
-### 1. Create the theme file
-
-Create a new header file in `themes/` (e.g., `themes/MyTheme.h`):
-
-```cpp
-// themes/MyTheme.h — Brief description
-#pragma once
-#include "ThemeHelpers.h"
-
-// Expects to be included from GUITheme.h after <imgui.h> and RGBA() helper
-
-static void
-ApplyMyTheme()
-{
-    // Define your color palette
-    const ImVec4 background = RGBA(0x1e1e1e);
-    const ImVec4 foreground = RGBA(0xd4d4d4);
-    const ImVec4 accent     = RGBA(0x007acc);
-    // ... more colors
-    
-    ImGuiStyle &style = ImGui::GetStyle();
-    
-    // Configure style parameters
-    style.WindowPadding = ImVec2(8.0f, 8.0f);
-    // ... more style settings
-    
-    ImVec4 *colors = style.Colors;
-    
-    // Assign all required colors
-    colors[ImGuiCol_Text]     = foreground;
-    colors[ImGuiCol_WindowBg] = background;
-    // ... assign all other ImGuiCol_* values
-}
-```
-
-Refer to existing themes like `Nord.h` for a complete example of all
-required color assignments.
-
-### 2. Add theme to GUITheme.h
-
-Edit `GUITheme.h` to integrate your theme:
-
-**a) Add to ThemeId enum:**
-
-```cpp
-enum class ThemeId {
-    // ... existing themes
-    MyTheme = 13,  // Use next available number
-};
-```
-
-**b) Include your theme header:**
-
-```cpp
-// After other theme includes
-#include "themes/MyTheme.h"
-```
-
-**c) Create wrapper class in detail namespace:**
-
-```cpp
-namespace detail {
-// ... existing theme classes
-
-struct MyThemeWrapper final : Theme {
-    [[nodiscard]] const char *Name() const override
-    {
-        return "mytheme";  // Lowercase canonical name
-    }
-    
-    void Apply() const override
-    {
-        ApplyMyTheme();
-    }
-    
-    ThemeId Id() override
-    {
-        return ThemeId::MyTheme;
-    }
-};
-} // namespace detail
-```
-
-**d) Register in ThemeRegistry():**
-
-```cpp
-static const std::vector<std::unique_ptr<Theme>> &
-ThemeRegistry()
-{
-    static std::vector<std::unique_ptr<Theme>> reg;
-    if (reg.empty()) {
-        // Add in alphabetical order by canonical name
-        reg.emplace_back(std::make_unique<detail::AmberTheme>());
-        // ... existing themes
-        reg.emplace_back(std::make_unique<detail::MyThemeWrapper>());
-        // ... remaining themes
-    }
-    return reg;
-}
-```
-
-### 3. Test your theme
-
-Rebuild kte and test:
-
-```bash
-# Set theme in config
-echo "theme = mytheme" >> ~/.config/kte/kge.ini
-
-# Or switch at runtime
-kge
-:theme mytheme
-```
-
-Light/Dark theme variants
---------------------------
-
-Some themes support both light and dark background modes. To implement
-this:
-
-### 1. Create separate functions for each variant
-
-```cpp
-// themes/MyTheme.h
-#pragma once
-#include "ThemeHelpers.h"
-
-static void
-ApplyMyThemeDark()
-{
-    const ImVec4 bg = RGBA(0x1e1e1e);  // Dark background
-    const ImVec4 fg = RGBA(0xd4d4d4);  // Light text
-    // ... rest of dark theme
-}
-
-static void
-ApplyMyThemeLight()
-{
-    const ImVec4 bg = RGBA(0xffffff);  // Light background
-    const ImVec4 fg = RGBA(0x1e1e1e);  // Dark text
-    // ... rest of light theme
-}
-```
-
-### 2. Check background mode in Apply()
-
-```cpp
-// In GUITheme.h wrapper class
-struct MyThemeWrapper final : Theme {
-    // ... Name() and Id() methods
-    
-    void Apply() const override
-    {
-        if (gBackgroundMode == BackgroundMode::Dark)
-            ApplyMyThemeDark();
-        else
-            ApplyMyThemeLight();
-    }
-};
-```
-
-See `Solarized.h`, `Gruvbox.h`, `EInk.h`, or `OldBook.h` for complete
-examples.
-
-Updating existing themes
-------------------------
-
-To modify an existing theme:
-
-### 1. Locate the theme file
-
-Theme files are in `themes/` directory. For example, Nord theme is in
-`themes/Nord.h`.
-
-### 2. Modify colors or style
-
-Edit the `ApplyXxxTheme()` function:
-
-- Update palette color definitions
-- Change style parameters
-- Reassign `ImGuiCol_*` values
-
-### 3. Rebuild and test
-
-```bash
-# Rebuild kte
-cmake --build build
-
-# Test changes
-./build/kge
-```
-
-Changes take effect immediately on next launch or theme switch.
-
-Best practices
---------------
-
-When creating or updating themes:
-
-1. **Start from an existing theme** — Copy a similar theme as a
-   template (e.g., `Nord.h` for dark themes, `Solarized.h` for
-   light/dark variants)
-
-2. **Define a complete palette first** — Create all color constants at
-   the top before assigning them
-
-3. **Assign all colors** — Ensure every `ImGuiCol_*` value is set to
-   avoid inheriting unexpected colors
-
-4. **Use consistent naming** — Follow existing conventions (e.g.,
-   `nord0`, `base03`, descriptive names)
-
-5. **Test interactivity** — Verify hover, active, and disabled states
-   for buttons, frames, and other interactive elements
-
-6. **Consider contrast** — Ensure text is readable against backgrounds;
-   test with different content
-
-7. **Test transparency** — Use alpha values carefully for overlays, dim
-   backgrounds, and selection highlights
-
-8. **Match style to theme** — Adjust rounding, padding, and borders to
-   suit the theme's aesthetic (e.g., sharp corners for retro themes,
-   rounded for modern)
-
-9. **Document inspiration** — Note the color scheme's origin or
-   inspiration in the file header
-
-10. **Maintain alphabetical order** — When registering in
-    `ThemeRegistry()`, maintain alphabetical order by canonical name
-
-Troubleshooting
----------------
-
-### Theme not appearing
-
-- Check that the theme is registered in `ThemeRegistry()` in
-  alphabetical order
-- Verify the canonical name matches what you're using in config or
-  commands
-- Ensure the theme header is included in `GUITheme.h`
-
-### Colors look wrong
-
-- Verify hex color values are in 0xRRGGBB format (not 0xBBGGRR)
-- Check alpha values for semi-transparent elements
-- Ensure all `ImGuiCol_*` values are assigned
-
-### Style inconsistent
-
-- Make sure style parameters are set before color assignments
-- Check that you're getting `ImGui::GetStyle()` reference correctly
-- Verify no global style changes are overriding theme settings
-
-References
-----------
-
-- ImGui style
-  reference: https://github.com/ocornut/imgui/blob/master/imgui.h
-- Existing themes in `themes/` directory
-- Color palette resources: coolors.co, colorhunt.co

docs/undo-roadmap.md

@@ -1,390 +1,279 @@
-## Updated Undo System Plan for kte/kge
+Undo System Overhaul Roadmap (emacs-style undo-tree)
+
+Context: macOS, C++17 project, ncurses terminal and SDL2/ImGui GUI frontends. Date: 2025-12-01.
+
+Purpose
+
+- Define a clear, incremental plan to implement a robust, non-linear undo system inspired by emacs' undo-tree.
+- Align implementation with docs/undo.md and fix gaps observed in docs/undo-state.md.
+- Provide test cases and acceptance criteria so a junior engineer or agentic coding system can execute the plan safely.
 
-After reviewing the existing codebase and your undo plan, I propose
+References
-the following refined approach that preserves your goals while making
-it more suitable for implementation:
 
-### Refined Data Structures
+- Specification: docs/undo.md (API, invariants, batching rules, raw buffer ops)
-
+- Current snapshot and recent fix: docs/undo-state.md (GUI mapping notes; Begin/Append ordering fix)
-The proposed data structures are sound but need some refinements:
+- Code: UndoSystem.{h,cc}, UndoTree.{h,cc}, UndoNode.{h,cc}, Buffer.{h,cc}, Command.{h,cc}, GUI/Terminal InputHandlers,
+  KKeymap.
+
+Instrumentation (KTE_UNDO_DEBUG)
 
-```c++
+- How to enable
-enum class UndoType : uint8_t {
+  - Build with the CMake option `-DKTE_UNDO_DEBUG=ON` to enable concise instrumentation logs from `UndoSystem`.
-    Insert,
+  - The following targets receive the `KTE_UNDO_DEBUG` compile definition when ON:
-    Delete,
+    - `kte` (terminal), `kge` (GUI), and `test_undo` (tests).
-    Paste,
+  - Examples:
-    Newline,
+    ```sh
-    DeleteRow,
+    # Terminal build with tests and instrumentation ON
-    // Future: IndentRegion, KillRegion, etc.
+    cmake -S . -B cmake-build-term -DBUILD_TESTS=ON -DBUILD_GUI=OFF -DKTE_UNDO_DEBUG=ON
-};
+    cmake --build cmake-build-term --target test_undo -j
-
+    ./cmake-build-term/test_undo 2> undo.log
-struct UndoNode {
+
-    UndoType type;
+    # GUI build (requires SDL2/OpenGL/Freetype toolchain) with instrumentation ON
-    int row;
+    cmake -S . -B cmake-build-gui -DBUILD_GUI=ON -DKTE_UNDO_DEBUG=ON
-    int col;
+    cmake --build cmake-build-gui --target kge -j
-    std::string text;
+    # Run kge and perform actions; logs go to stderr
-    std::unique_ptr<UndoNode> child = nullptr;   // next in timeline
+    ```
-    std::unique_ptr<UndoNode> next  = nullptr;   // redo branch
+
-    UndoNode* parent = nullptr;  // weak pointer for navigation
+- What it logs
-};
+  - Each Begin/Append/commit/undo/redo operation prints a single `[UNDO]` line with:
-
+    - current cursor `(row,col)`, pointer to `pending`, its type/row/col/text-size, and pointers to `current`/`saved`.
-struct UndoTree {
+  - Example fields: `[UNDO] Begin cur=(0,0) pending=0x... t=Insert r=0 c=0 nlen=2 current=0x... saved=0x...`
-    std::unique_ptr<UndoNode> root;
+
-    UndoNode* current = nullptr;
+- Example trace snippets
-    UndoNode* saved   = nullptr;
+  - Typing a contiguous word ("Hello") batches into a single Insert node; one commit occurs before the subsequent undo:
-    std::unique_ptr<UndoNode> pending = nullptr;
+    ```text
-};
+    [UNDO] Begin cur=(0,0) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x0 saved=0x0
-```
+    [UNDO] commit:enter cur=(0,0) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x0 saved=0x0
-
+    [UNDO] Begin:new cur=(0,0) pending=0x... t=Insert r=0 c=0 nlen=0 current=0x0 saved=0x0
-Key changes:
+    [UNDO] Append:sv cur=(0,0) pending=0x... t=Insert r=0 c=0 nlen=1 current=0x0 saved=0x0
-
+    ... (more Append as characters are typed) ...
-- Use `std::unique_ptr` for owned pointers to ensure proper RAII
+    [UNDO] commit:enter cur=(0,5) pending=0x... t=Insert r=0 c=0 nlen=5 current=0x0 saved=0x0
-- Add weak `parent` pointer for easier navigation
+    [UNDO] commit:done cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x... saved=0x0
-- This ensures memory safety without manual management
+    ```
-
+
----
+  - Undo then Redo across that batch:
-
+    ```text
-```markdown
+    [UNDO] commit:enter cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x... saved=0x0
-# Undo System Implementation Roadmap for kte/kge
+    [UNDO] undo cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x0 saved=0x0
-
+    [UNDO] commit:enter cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x0 saved=0x0
-This is the complete implementation plan for the non-linear undo/redo
+    [UNDO] redo cur=(0,5) pending=0x0 t=- r=-1 c=-1 nlen=0 current=0x... saved=0x0
-system for kte. This document serves as a detailed
+    ```
-specification for Junie to implement an undo system similar to emacs'
+
-undo-tree.
+  - Newline and backspace/delete traces follow the same pattern with `t=Newline` or `t=Delete` and immediate commit for newline.
-
+    Capture by running `kge`/`kte` with `KTE_UNDO_DEBUG=ON` and performing the actions; append representative 3–6 line snippets to docs.
-## Overview
+
-
+Notes
-The goal is to implement a robust, memory-safe undo system where:
+
-
+- Pointer values and exact cursor positions in the logs depend on the runtime and actions; this is expected.
-1. Each buffer has its own independent undo tree
+- Keep `KTE_UNDO_DEBUG` OFF by default in CI/release to avoid noisy logs and any performance impact.
-2. Undo and redo are non-linear - typing after undo creates a branch
+
-3. Operations are batched into word-level undo steps
+̄1) Current State Summary (from docs/undo-state.md)
-4. The system is leak-proof and handles buffer closure gracefully
+
-
+- Terminal (kte): Keybindings and UndoSystem integration have been stable.
-## Phase 1: Core Data Structures
+- GUI (kge): Previously, C-k u/U mapping and SDL TEXTINPUT suppression had issues on macOS; these were debugged. The
-
+  core root cause of “status shows Undone but no change” was fixed by moving UndoSystem::Begin/Append/commit to occur
-### 1.1 UndoType enum (UndoNode.h)
+  after buffer modifications/cursor updates so batching conditions see the correct cursor.
-```
+- Undo core exists with tree invariants, saved marker/dirty flag mirroring, batching for Insert/Delete, and Newline as a
-
+  single-step undo.
-cpp enum class UndoType : uint8_t { Insert, Delete, Paste, // can
+
-reuse Insert if preferred Newline, DeleteRow, // Future extensions:
+Gaps/Risks
-IndentRegion, KillRegion };
+
-
+- Event-path unification between KEYDOWN and TEXTINPUT across platforms (macOS specifics).
-```
+- Comprehensive tests for branching, GC/limits, multi-line operations, and UTF-8 text input.
-### 1.2 UndoNode struct (UndoNode.h)
+- Advanced/compound command grouping and future region operations.
-```
+
-
+
-cpp struct UndoNode { UndoType type; int row; // original cursor row
+2) Design Goals (emacs-like undo-tree)
-int col; // original cursor column (updated during batch) std::string
+
-text; // the inserted or deleted text (full batch)
+- Per-buffer, non-linear undo tree: new edits after undo create a branch; existing redo branches are discarded.
-std::unique_ptr<UndoNode> child = nullptr; // next in current timeline
+- Batching: insert/backspace/paste/newline grouped into sensible units to match user expectations.
-std::unique_ptr<UndoNode> next = nullptr; // redo branch (rarely used)
+- Silent apply during undo/redo (no re-recording), using raw Buffer methods only.
-UndoNode* parent = nullptr; // weak pointer for navigation };
+- Correct saved/dirty tracking and robust pending node lifecycle (detached until commit).
-
+- Efficient memory behavior; optional pruning limits similar to emacs (undo-limit, undo-strong-limit).
-```
+- Deterministic behavior across terminal and GUI frontends.
-### 1.3 UndoTree struct (UndoTree.h)
+
-```
+
-
+3) Invariants and API (must align with docs/undo.md)
-cpp struct UndoTree { std::unique_ptr<UndoNode> root; // first edit
+
-ever UndoNode* current = nullptr; // current state of buffer UndoNode*
+- UndoTree holds root/current/saved/pending; pending is detached and only linked on commit.
-saved = nullptr; // points to node matching last save
+- Begin(type) reuses pending only if: same type, same row, and pending->col + pending->text.size() == current cursor
-std::unique_ptr<UndoNode> pending = nullptr; // in-progress batch };
+  col (or prepend rules for backspace sequences); otherwise it commits and starts a new node.
-
+- commit(): frees redo siblings from current, attaches pending as current->child, advances current, clears pending;
-```
+  nullifies saved marker if diverged.
-### 1.4 UndoSystem class (UndoSystem.h)
+- undo()/redo(): move current and apply the node using low-level Buffer APIs that do not trigger undo recording.
-```
+- mark_saved(): updates saved pointer and dirty flag (dirty ⇔ current != saved).
-
+- discard_pending()/clear(): lifecycle for buffer close/reset/new file.
-cpp class UndoSystem { private: std::unique_ptr<UndoTree> tree;
+
-
+
-public: UndoSystem(); ~UndoSystem() = default;
+4) Phased Roadmap
-
+
-    // Core batching API
+Phase 0 — Baseline & Instrumentation (1 day)
-    void begin(UndoType type, int row, int col);
+
-    void append(char ch);
+- Audit UndoSystem against docs/undo.md invariants; ensure apply() uses only raw Buffer ops.
-    void append(std::string_view text);
+- Verify Begin/Append ordering across all edit commands: insert, backspace, delete, newline, paste.
-    void commit();
+- Add a temporary debug toggle (compile-time or editor flag) to log Begin/Append/commit/undo/redo, cursor(row,col), node
-
+  sizes, and pending state. Include assertions for: pending detached, commit clears pending, redo branch freed on new
-    // Undo/Redo operations
+  commit, and correct batching preconditions.
-    void undo(class Buffer& buffer);
+- Deliverables: Short log from typing/undo/redo scenarios; instrumentation behind a macro so it can be removed.
-    void redo(class Buffer& buffer);
+
-
+Phase 1 — Input Path Unification & Batching Rules (1–2 days)
-    // State management
+
-    void mark_saved();
+- Ensure all printable text insertion (terminal and GUI) flows through CommandId::InsertText and reaches UndoSystem
-    void discard_pending();
+  Begin/Append. On SDL, handle KEYDOWN vs TEXTINPUT consistently; always suppress trailing TEXTINPUT after k-prefix
-    void clear();
+  suffix commands.
-
+- Commit boundaries: at k-prefix entry, before Undo/Redo, on cursor movement, on focus/file ops, and before any
-    // Query methods
+  non-editing command that should separate undo units.
-    bool can_undo() const;
+- Batching heuristics:
-    bool can_redo() const;
+    - Insert: same row, contiguous columns; Append(std::string_view) handles multi-character text (pastes, IME).
-    bool is_dirty() const;
+    - Backspace: prepend batching in increasing column order (store deleted text in forward order).
-
+    - Delete (forward): contiguous at same row/col.
-private: void apply_node(Buffer& buffer, const UndoNode* node, int
+    - Newline: record as UndoType::Newline and immediately commit (single-step undo for line splits/joins).
-direction); bool should_batch_with_pending(UndoType type, int row, int
+- Deliverables: Manual tests pass for typing/backspace/delete/newline/paste; GUI C-k u/U work as expected on macOS.
-col) const; void attach_pending_to_current(); void
+
-discard_redo_branches(); };
+Phase 2 — Tree Limits & GC (1 day)
-
+
-```
+- Add configurable memory/size limits for undo data (soft and strong limits like emacs). Implement pruning of oldest
-## Phase 2: Buffer Integration
+  ancestors or deep redo branches while preserving recent edits. Provide stats (node count, bytes in text storage).
-
+- Deliverables: Config hooks, tests demonstrating pruning without violating apply/undo invariants.
-### 2.1 Add undo system to Buffer class (Buffer.h)
+
-Add to Buffer class:
+Phase 3 — Compound Commands & Region Ops (2–3 days)
-```
+
-
+- Introduce an optional RAII-style UndoTransaction to group multi-step commands (indent region, kill region, rectangle
-cpp private: std::unique_ptr<UndoSystem> undo_system; bool
+  ops) into a single undo step. Internally this just sequences Begin/Append and ensures commit even on early returns.
-applying_undo = false; // prevent recursive undo during apply
+- Support row operations (InsertRow/DeleteRow) with proper raw Buffer calls. Ensure join_lines/split_line are handled by
-
+  Newline nodes or dedicated types if necessary.
-public: // Raw operations (don't trigger undo) void
+- Deliverables: Commands updated to use transactions when appropriate; tests for region delete/indent and multi-line
-raw_insert_text(int row, int col, std::string_view text); void
+  paste.
-raw_delete_text(int row, int col, size_t len); void raw_split_line(int
+
-row, int col); void raw_join_lines(int row); void raw_insert_row(int
+Phase 4 — Developer UX & Diagnostics (1 day)
-row, std::string_view text); void raw_delete_row(int row);
+
-
+- Add a dev command to dump the undo tree (preorder) with markers for current/saved and pending (detached). For GUI,
-    // Undo/Redo public API
+  optionally expose a simple ImGui debug window (behind a compile flag) that visualizes the current branch.
-    void undo();
+- Editor status improvements: show short status codes for undo/redo and when a new branch was created or redo discarded.
-    void redo();
+- Deliverables: Tree dump command; example output in docs.
-    bool can_undo() const;
+
-    bool can_redo() const;
+Phase 5 — Comprehensive Tests & Property Checks (2–3 days)
-    void mark_saved();
+
-    bool is_dirty() const;
+- Unit tests (extend test_undo.cc):
-
+    - Insert batching: type "Hello" then one undo removes all; redo restores.
-```
+    - Backspace batching: type "Hello", backspace 3×, undo → restores the 3; redo → re-applies deletion.
-### 2.2 Modify existing Buffer operations (Buffer.cc)
+    - Delete batching (forward delete) with cursor not moving.
-For each user-facing operation (`insert_char`, `delete_char`, etc.):
+    - Newline: split a line and undo to join; join a line (via backspace at col 0) and undo to split.
-
+    - Branching: type "abc", undo twice, type "X" → redo history discarded; ensure redo no longer restores 'b'/'c'.
-1. **Before performing operation**: Call `undo_system->commit()` if cursor moved
+    - Saved/dirty: mark_saved after typing; ensure dirty flag toggles correctly after undo/redo; saved marker tracks the
-2. **Begin batching**: Call `undo_system->begin(type, row, col)`
+      node.
-3. **Record change**: Call `undo_system->append()` with the affected text
+    - discard_pending: create pending by typing, then move cursor or invoke commit boundary; ensure pending is attached;
-4. **Perform operation**: Execute the actual buffer modification
+      also ensure discard on buffer close clears pending.
-5. **Auto-commit conditions**: Commit on cursor movement, command execution
+    - clear(): resets state with no leaks; tree pointers null.
-
+    - UTF-8 input: insert multi-byte characters via InsertText with multi-char std::string; ensure counts/col tracking
-Example pattern:
+      behave (text stored as bytes; editor col policy consistent within kte).
-```
+- Integration tests (TestFrontend):
-
+    - Both TerminalFrontend and GUIFrontend: simulate text input and commands, including k-prefix C-k u/U.
-cpp void Buffer::insert_char(char ch) { if (applying_undo) return; //
+    - Paste scenarios: multi-character insertions batched as one.
-silent during undo application
+- Property tests (optional but recommended):
-
+    - Generate random sequences of edits; record them; then apply undo until root and redo back to the end → buffer
-    // Auto-commit if cursor moved significantly or type changed
+      contents match at each step; no crashes; dirty flag transitions consistent. Seed-based to reproduce failures.
-    if (should_commit_before_insert()) {
+    - Redo-branch discard property: any new edit after undo must eliminate redo path; redoing should be impossible
-        undo_system->commit();
+      afterward.
-    }
+- Deliverables: Tests merged and passing on CI for both frontends; failures block changes to undo core.
-
+
-    undo_system->begin(UndoType::Insert, cursor_row, cursor_col);
+Phase 6 — Performance & Stress (0.5–1 day)
-    undo_system->append(ch);
+
-
+- Stress test with large files and long edit sequences. Target: smooth typing at 10k+ ops/minute on commodity hardware;
-    // Perform actual insertion
+  memory growth bounded when GC limits enabled.
-    raw_insert_text(cursor_row, cursor_col, std::string(1, ch));
+- Deliverables: Basic perf notes; optional lightweight benchmarks.
-    cursor_col++;
+
-
+
-}
+5) Acceptance Criteria
-
+
-```
+- Conformance to docs/undo.md invariants and API surface (including raw Buffer operations for apply()).
-### 2.3 Commit triggers
+- Repro checklist passes:
-Auto-commit `pending` operations when:
+    - Type text; single-step undo/redo works and respects batching.
-- Cursor moves (arrow keys, mouse click)
+    - Backspace/delete batching works.
-- Any command starts executing
+    - Newline split/join are single-step undo/redo.
-- Buffer switching
+    - Branching works: undo, then type → redo path is discarded; no ghost redo.
-- Before undo/redo operations
+    - Saved/dirty flags accurate across undo/redo and diverge/rejoin paths.
-- Before file save/close
+    - No pending nodes leaked on buffer close/reload; no re-recording during undo/redo.
-
+    - Behavior identical across terminal and GUI input paths.
-## Phase 3: UndoSystem Implementation
+- Tests added for all above; CI green.
-
+
-### 3.1 Core batching logic (UndoSystem.cc)
+
-```
+6) Concrete Work Items by File
-
+
-cpp void UndoSystem::begin(UndoType type, int row, int col) { if
+- UndoSystem.h/cc:
-(should_batch_with_pending(type, row, col)) { // Continue existing
+    - Re-verify Begin/Append ordering; enforce batching invariants; prepend logic for backspace; immediate commit for
-batch return; }
+      newline.
-
+    - Implement/verify apply() uses only Buffer raw methods: insert_text/delete_text/split_line/join_lines/row ops.
-    // Commit any existing pending operation
+    - Add limits (configurable) and stats; add discard_pending safety paths.
-    if (pending) {
+- Buffer.h/cc:
-        commit();
+    - Ensure raw methods exist and do not trigger undo; ensure UpdateBufferReference is correctly used when
-    }
+      replacing/renaming the underlying buffer.
-
+    - Call undo.commit() on cursor movement and non-editing commands (via Command layer integration).
-    // Create new pending node
+- Command.cc:
-    pending = std::make_unique<UndoNode>();
+    - Ensure all edit commands drive UndoSystem correctly; commit at k-prefix entry and before Undo/Redo.
-    pending->type = type;
+    - Introduce UndoTransaction for compound commands when needed.
-    pending->row = row;
+- GUIInputHandler.cc / TerminalInputHandler.cc / KKeymap.cc:
-    pending->col = col;
+    - Ensure unified InsertText path; suppress SDL_TEXTINPUT when a k-prefix suffix produced a command; preserve case
-    pending->text.clear();
+      mapping.
-
+- Tests: test_undo.cc (extend) + new tests (e.g., test_undo_branching.cc, test_undo_multiline.cc).
-}
+
-
+
-bool UndoSystem::should_batch_with_pending(UndoType type, int row, int
+7) Example Test Cases (sketches)
-col) const { if (!pending) return false; if (pending->type != type)
+
-return false; if (pending->row != row) return false;
+- Branch discard after undo:
-
+    1) InsertText("abc"); Undo(); Undo(); InsertText("X"); Redo();
-    // For Insert: check if we're continuing at the right position
+       Expected: Redo is a no-op (or status indicates no redo), buffer is "aX".
-    if (type == UndoType::Insert) {
+
-        return (pending->col + pending->text.size()) == col;
+- Newline split/join:
-    }
+    1) InsertText("ab"); Newline(); InsertText("c"); Undo();
-
+       Expected: single undo joins lines → buffer "abc" on one line at original join point; Redo() splits again.
-    // For Delete: check if we're continuing from the same position
+
-    if (type == UndoType::Delete) {
+- Backspace batching:
-        return pending->col == col;
+    1) InsertText("hello"); Backspace×3; Undo();
-    }
+       Expected: restores "hello".
-
+
-    return false;
+- UTF-8 insertion:
-
+    1) InsertText("😀汉"); Undo(); Redo();
-}
+       Expected: content unchanged across cycles; no crashes.
-
+
-```
+- Saved/dirty transitions:
-### 3.2 Commit logic
+    1) InsertText("hi"); mark_saved(); InsertText("!"); Undo(); Redo();
-```
+       Expected: dirty false after mark_saved; dirty true after InsertText("!"); dirty returns to false after Undo();
-
+       true again after Redo().
-cpp void UndoSystem::commit() { if (!pending || pending->text.empty())
+
-{ pending.reset(); return; }
+
-
+8) Risks & Mitigations
-    // Discard any redo branches from current position
+
-    discard_redo_branches();
+- SDL/macOS event ordering (KEYDOWN vs TEXTINPUT, IME): Mitigate by suppressing TEXTINPUT on mapped k-prefix suffixes;
-
+  optionally temporarily disable SDL text input during k-prefix suffix mapping; add targeted diagnostics.
-    // Attach pending as child of current
+- UTF-8 width vs byte-length: Store bytes in UndoNode::text; keep column logic consistent with existing Buffer
-    attach_pending_to_current();
+  semantics.
-
+- Memory growth: Add GC/limits and provide a way to clear/reduce history for huge sessions.
-    // Move current forward
+- Re-entrancy during apply(): Prevent public edit paths from being called; use only raw operations.
-    current = pending.release();
+
-    if (current->parent) {
+
-        current->parent->child.reset(current);
+9) Nice-to-Have (post-MVP)
-    }
+
-
+- Visual undo-tree navigation (emacs-like time travel and branch selection), at least as a debug tool initially.
-    // Update saved pointer if we diverged
+- Persistent undo across saves (opt-in; likely out-of-scope initially).
-    if (saved && saved != current) {
+- Time-based batching threshold (e.g., break batches after >500ms pause in typing).
-        // Check if saved is still reachable from current
+
-        if (!is_ancestor_of(current, saved)) {
+
-            saved = nullptr;
+10) Execution Notes for a Junior Engineer/Agentic System
-        }
+
-    }
+- Start from Phase 0; do not skip instrumentation—assertions will catch subtle batching bugs early.
-
+- Change one surface at a time; when adjusting Begin/Append/commit positions, re-run unit tests immediately.
-}
+- Always ensure commit boundaries before invoking commands that move the cursor/state.
-
+- When unsure about apply(), read docs/undo.md and mirror exactly: only raw Buffer methods, never the public editing
-```
+  APIs.
-### 3.3 Apply operations
+- Keep diffs small and localized; add tests alongside behavior changes.
-```
+
-
+Appendix A — Minimal Developer Checklist
-cpp void UndoSystem::apply_node(Buffer& buffer, const UndoNode* node,
+
-int direction) { if (!node) return;
+- [ ] Begin/Append occur after buffer mutation and cursor updates for all edit commands.
-
+- [ ] Pending detached until commit; freed/cleared on commit/discard/clear.
-    switch (node->type) {
+- [ ] Redo branches freed on new commit after undo.
-        case UndoType::Insert:
+- [ ] mark_saved updates both saved pointer and dirty flag; dirty mirrors current != saved.
-            if (direction > 0) {  // redo
+- [ ] apply() uses only raw Buffer methods; no recording during apply.
-                buffer.raw_insert_text(node->row, node->col, node->text);
+- [ ] Terminal and GUI both route printable input to InsertText; k-prefix mapping suppresses trailing TEXTINPUT.
-            } else {  // undo
+- [ ] Unit and integration tests cover batching, branching, newline, saved/dirty, and UTF-8 cases.
-                buffer.raw_delete_text(node->row, node->col, node->text.size());
-            }
-            break;
-
-        case UndoType::Delete:
-            if (direction > 0) {  // redo
-                buffer.raw_delete_text(node->row, node->col, node->text.size());
-            } else {  // undo
-                buffer.raw_insert_text(node->row, node->col, node->text);
-            }
-            break;
-
-        case UndoType::Newline:
-            if (direction > 0) {  // redo
-                buffer.raw_split_line(node->row, node->col);
-            } else {  // undo
-                buffer.raw_join_lines(node->row);
-            }
-            break;
-
-        // Handle other types...
-    }
-
-}
-
-```
-## Phase 4: Command Integration
-
-### 4.1 Add undo/redo commands (Command.cc)
-Register the undo/redo commands in the command system:
-```
-
-cpp // In InstallDefaultCommands() CommandRegistry::Register({
-CommandId::Undo, "undo", "Undo the last change", [](CommandContext&
-ctx) { auto& editor = ctx.editor; auto* buffer =
-editor.current_buffer(); if (buffer && buffer->can_undo()) {
-buffer->undo(); return true; } return false; }, false // not public
-command });
-
-CommandRegistry::Register({ CommandId::Redo, "redo", "Redo the last
-undone change", [](CommandContext& ctx) { auto& editor = ctx.editor;
-auto* buffer = editor.current_buffer(); if (buffer &&
-buffer->can_redo()) { buffer->redo(); return true; } return false; },
-false // not public command });
-
-```
-### 4.2 Update keybinding handlers
-Ensure the input handlers map `C-k u` to `CommandId::Undo` and `C-k r`
-to `CommandId::Redo`.
-
-## Phase 5: Memory Management and Edge Cases
-
-### 5.1 Buffer lifecycle management
-- **Constructor**: Initialize `undo_system = std::make_unique<UndoSystem>()`
-- **Destructor**: `undo_system.reset()` (automatic)
-- **File reload**: Call `undo_system->clear()` before loading
-- **New file**: Call `undo_system->clear()`
-- **Close buffer**: Call `undo_system->discard_pending()` then let destructor handle cleanup
-
-### 5.2 Save state tracking
-- **After successful save**: Call `buffer->mark_saved()`
-- **For dirty flag**: Use `buffer->is_dirty()`
-
-### 5.3 Edge case handling
-- Prevent undo during undo application (`applying_undo` flag)
-- Handle empty operations gracefully
-- Ensure cursor positioning after undo/redo
-- Test memory leaks with rapid typing + buffer close
-
-## Phase 6: Testing
-
-### 6.1 Unit tests (test_undo.cc)
-Create comprehensive tests covering:
-- Basic typing and undo
-- Word-level batching
-- Non-linear undo (type, undo, type different text)
-- Memory leak testing
-- Save state tracking
-- Edge cases (empty buffers, large operations)
-
-### 6.2 Integration tests
-- Test with all buffer implementations (GapBuffer, PieceTable)
-- Test with GUI and Terminal frontends
-- Test rapid typing + immediate buffer close
-- Test file reload during pending operations
-
-## Implementation Priority
-
-1. **Phase 1**: Implement core data structures
-2. **Phase 2**: Add Buffer integration points
-3. **Phase 3**: Implement UndoSystem methods
-4. **Phase 4**: Wire up commands and keybindings
-5. **Phase 5**: Handle edge cases and memory management
-6. **Phase 6**: Comprehensive testing
-
-## Critical Success Criteria
-
-- ✅ No memory leaks even with rapid typing + buffer close
-- ✅ Batching works correctly (word-level undo steps)
-- ✅ Non-linear undo creates branches correctly
-- ✅ Save state tracking works properly
-- ✅ Silent operations during undo application
-- ✅ Clean integration with existing Buffer operations
-
-This roadmap provides Junie with a complete, step-by-step implementation plan that preserves the original design goals while ensuring robust, memory-safe implementation.
-```
-
-This roadmap refines your original plan by:
-
-1. **Memory Safety**: Uses `std::unique_ptr` for automatic memory
-   management
-2. **Clear Implementation Steps**: Breaks down into logical phases
-3. **Integration Points**: Clearly identifies where to hook into
-   existing code
-4. **Edge Case Handling**: Addresses buffer lifecycle and error
-   conditions
-5. **Testing Strategy**: Ensures robust validation
-
-The core design remains faithful to your emacs-style undo tree vision
-while being practical for implementation by Junie.

docs/undo-state.md

@@ -0,0 +1,139 @@
+### Context recap
+
+- The undo system is now tree‑based with batching rules and `KTE_UNDO_DEBUG` instrumentation hooks already present in
+  `UndoSystem.{h,cc}`.
+- GUI path uses SDL; printable input now flows exclusively via `SDL_TEXTINPUT` to `CommandId::InsertText`, while
+  control/meta/movement (incl. Backspace/Delete/Newline and k‑prefix) come from `SDL_KEYDOWN`.
+- Commit boundaries must be enforced at well‑defined points (movement, non‑editing commands, newline, undo/redo, etc.).
+
+### Status summary (2025‑12‑01)
+
+- Input‑path unification: Completed. `GUIInputHandler.cc` routes all printable characters through `SDL_TEXTINPUT → InsertText`.
+  Newlines originate only from `SDL_KEYDOWN → Newline`. CR/LF are filtered out of `SDL_TEXTINPUT` payloads. Suppression
+  rules prevent stray `TEXTINPUT` after meta/prefix/universal‑argument flows. Terminal input path remains consistent.
+- Tests: `test_undo.cc` expanded to cover branching behavior, UTF‑8 insertion, multi‑line newline/join, and typing batching.
+  All scenarios pass.
+- Instrumentation: `KTE_UNDO_DEBUG` hooks exist in `UndoSystem.{h,cc}`; a CMake toggle has not yet been added.
+- Commit boundaries: Undo/Redo commit boundaries are in place; newline path commits immediately by design. A final audit
+  pass across movement/non‑editing commands is still pending.
+- Docs: This status document updated. Further docs (instrumentation how‑to and example traces) remain pending in
+  `docs/undo.md` / `docs/undo-roadmap.md`.
+
+### Objectives
+
+- Use the existing instrumentation to capture short traces of typing/backspacing/deleting and undo/redo.
+- Unify input paths (SDL `KEYDOWN` vs `TEXTINPUT`) and lock down commit boundaries across commands.
+- Extend tests to cover branching behavior, UTF‑8, and multi‑line operations.
+
+### Plan of action
+
+1. Enable instrumentation and make it easy to toggle
+    - Add a CMake option in `CMakeLists.txt` (root project):
+      `option(KTE_UNDO_DEBUG "Enable undo instrumentation logs" OFF)`.
+    - When ON, add a compile definition `-DKTE_UNDO_DEBUG` to all targets that include the editor core (e.g., `kte`,
+      `kge`, and test binaries).
+    - Keep the default OFF so normal builds are quiet; ensure both modes compile in CI.
+
+2. Capture short traces to validate current behavior
+    - Build with `-DKTE_UNDO_DEBUG=ON` and run the GUI frontend:
+        - Scenario A: type a contiguous word, then move cursor (should show `Begin(Insert)` + multiple `Append`, single
+          `commit` at a movement boundary).
+        - Scenario B: hold backspace to delete a run, including backspace batching (prepend rule); verify
+          `Begin(Delete)` with prepended `Append` behavior, single `commit`.
+        - Scenario C: forward deletes at a fixed column (anchor batching); expected single `Begin(Delete)` with same
+          column.
+        - Scenario D: insert newline (`Newline` node) and immediately commit; type text on the next line; undo/redo
+          across the boundary.
+        - Scenario E: undo chain and redo chain; then type new text and confirm redo branch gets discarded in logs.
+    - Save representative trace snippets and add to `docs/undo.md` or `docs/undo-roadmap.md` for reference.
+
+3. Input‑path unification (SDL `KEYDOWN` vs `TEXTINPUT`) — Completed 2025‑12‑01
+    - In `GUIInputHandler.cc`:
+        - Ensure printable characters are generated exclusively from `SDL_TEXTINPUT` and mapped to
+          `CommandId::InsertText`.
+        - Keep `SDL_KEYDOWN` for control/meta/movement, backspace/delete, newline, and k‑prefix handling.
+        - Maintain suppression of stray `SDL_TEXTINPUT` immediately following meta/prefix or universal‑argument
+          collection so no accidental text is inserted.
+        - Confirm that `InsertText` path never carries `"\n"`; newline must only originate from `KEYDOWN` →
+          `CommandId::Newline`.
+    - If the terminal input path exists, ensure parity: printable insertions go through `InsertText`, control via key
+      events, and the same commit boundaries apply.
+    - Status: Implemented. See `GUIInputHandler.cc` changes; tests confirm parity with terminal path.
+
+4. Enforce and verify commit boundaries in command execution — In progress
+    - Audit `Command.cc` and ensure `u->commit()` is called before executing any non‑editing command that should end a
+      batch:
+        - Movement commands (left/right/up/down/home/end/page).
+        - Prompt accept/cancel transitions and mode switches (search prompts, replace prompts).
+        - Buffer/file operations (open/switch/save/close), and focus changes.
+        - Before running `Undo` or `Redo` (already present).
+    - Ensure immediate commit at the end of atomic edit operations:
+        - `Newline` insertion and line joins (`Delete` of newline when backspacing at column 0) should create
+          `UndoType::Newline` and commit immediately (parts are already implemented; verify all call sites).
+        - Pastes should be a single `Paste`/`Insert` batch per operation (depending on current design).
+
+5. Extend automated tests (or add them if absent) — Phase 1 completed
+    - Branching behavior ✓
+        - Insert `"abc"`, undo twice (back to `"a"`), insert `"X"`, assert redo list is discarded, and new timeline
+          continues with `aX`.
+        - Navigate undo/redo along the new branch to ensure correctness.
+    - UTF‑8 insertion and deletion ✓
+        - Insert `"é漢"` (multi‑byte characters) via `InsertText`; verify buffer content and that a single Insert batch
+          is created.
+        - Undo/redo restores/removes the full insertion batch.
+        - Backspace after typed UTF‑8 should remove the last inserted codepoint from the batch in a single undo step (
+          current semantics are byte‑oriented in buffer ops; test to current behavior and document).
+    - Multi‑line operations ✓
+        - Newline splits a line: verify an `UndoType::Newline` node is created and committed immediately; undo/redo
+          round‑trip.
+        - Backspace at column 0 joins with previous line: record as `Newline` deletion (via `UndoType::Newline`
+          inverse); undo/redo round‑trip.
+    - Typing and deletion batching ✓ (typing) / Pending (delete batching)
+        - Typing a contiguous word (no cursor moves) yields one `Insert` node with accumulated text.
+        - Forward delete at a fixed anchor column yields one `Delete` batch. (Pending test)
+        - Backspace batching uses the prepend rule when the cursor moves left. (Pending test)
+    - Place tests near existing test suite files (e.g., `tests/test_undo.cc`) or create them if not present. Prefer
+      using `Buffer` + `UndoSystem` directly for tight unit tests; add higher‑level integration tests as needed.
+
+6. Documentation updates — In progress
+    - In `docs/undo.md` and `docs/undo-roadmap.md`:
+        - Describe how to enable instrumentation (`KTE_UNDO_DEBUG`) and an example of trace logs.
+        - List batching rules and commit boundaries clearly with examples.
+        - Document current UTF‑8 semantics (byte‑wise vs codepoint‑wise) and any known limitations.
+    - Current status: this `undo-state.md` updated; instrumentation how‑to and example traces pending.
+
+7. CI and build hygiene — Pending
+    - Default builds: `KTE_UNDO_DEBUG` OFF.
+    - Add a CI job that builds and runs tests with `KTE_UNDO_DEBUG=ON` to ensure the instrumentation path remains
+      healthy.
+    - Ensure no performance regressions or excessive logging in release builds.
+
+8. Stretch goals (optional, time‑boxed) — Pending
+    - IME composition: confirm that `SDL_TEXTINPUT` behavior during IME composition does not produce partial/broken
+      insertions; if needed, buffer composition updates into a single commit.
+    - Ensure paste operations (multi‑line/UTF‑8) remain atomic in undo history.
+
+### How to run the tests
+
+- Configure with `-DBUILD_TESTS=ON` and build the `test_undo` target. Run the produced binary (e.g., `./test_undo`).
+  The test prints progress and uses assertions to validate behavior.
+
+### Deliverables
+
+- CMake toggle for instrumentation and verified logs for core scenarios. (Pending)
+- Updated `GUIInputHandler.cc` solidifying `KEYDOWN` vs `TEXTINPUT` separation and suppression rules. (Completed)
+- Verified commit boundaries in `Command.cc` with comments where appropriate. (In progress)
+- New tests for branching, UTF‑8, and multi‑line operations; all passing. (Completed for listed scenarios)
+- Docs updated with how‑to and example traces. (Pending)
+
+### Acceptance criteria
+
+### Current status (2025‑12‑01) vs acceptance criteria
+
+- Short instrumentation traces match expected batching and commit behavior for typing, backspace/delete, newline, and
+  undo/redo. — Pending (instrumentation toggle + capture not done)
+- Printable input comes exclusively from `SDL_TEXTINPUT`; no stray inserts after meta/prefix/universal‑argument flows.
+  — Satisfied (GUI path updated; terminal path consistent)
+- Undo branching behaves correctly; redo is discarded upon new commits after undo. — Satisfied (tested)
+- UTF‑8 and multi‑line scenarios round‑trip via undo/redo according to the documented semantics. — Satisfied (tested)
+- Tests pass with `KTE_UNDO_DEBUG` both OFF and ON. — Pending (no CMake toggle yet; default OFF passes)

docs/undo.md

@@ -0,0 +1,140 @@
+This is a design for a non-linear undo/redo system for kte. The design must be identical in behavior and correctness
+to the proven kte editor undo system.
+
+### Core Requirements
+
+1. Each open buffer has its own completely independent undo tree.
+2. Undo and redo must be non-linear: typing after undo creates a branch; old redo branches are discarded.
+3. Typing, backspacing, and pasting are batched into word-level undo steps.
+4. Undo/redo must never create new undo nodes while applying an undo/redo (silent, low-level apply).
+5. The system must be memory-safe and leak-proof even if the user types and immediately closes the buffer.
+
+### Data Structures
+
+```cpp
+enum class UndoType : uint8_t {
+    Insert,
+    Delete,
+    Paste,        // optional, can reuse Insert
+    Newline,
+    DeleteRow,
+    // future: IndentRegion, KillRegion, etc.
+};
+
+struct UndoNode {
+    UndoType type;
+    int row;           // original cursor row
+    int col;           // original cursor column (updated during batch)
+    std::string text;  // the inserted or deleted text (full batch)
+    UndoNode* child = nullptr;   // next in current timeline
+    UndoNode* next  = nullptr;   // redo branch (rarely used)
+    // no parent pointer needed — we walk from root
+};
+
+struct UndoTree {
+    UndoNode* root    = nullptr;  // first edit ever
+    UndoNode* current = nullptr;  // current state of buffer
+    UndoNode* saved   = nullptr;  // points to node matching last save (for dirty flag)
+    UndoNode* pending = nullptr;  // in-progress batch (detached)
+};
+```
+
+Each `Buffer` owns one `std::unique_ptr<UndoTree>`.
+
+### Core API (must implement exactly)
+
+```cpp
+class UndoSystem {
+public:
+    void Begin(UndoType type);
+    void Append(char ch);
+    void Append(std::string_view text);
+    void commit();                     // called on cursor move, commands, etc.
+
+    void undo();                       // Ctrl+Z
+    void redo();                       // Ctrl+Y or Ctrl+Shift+Z
+
+    void mark_saved();                 // after successful save
+    void discard_pending();            // before closing buffer or loading new file
+    void clear();                      // new file / reset
+
+private:
+    void apply(const UndoNode* node, int direction);  // +1 = redo, -1 = undo
+    void free_node(UndoNode* node);
+    void free_branch(UndoNode* node);  // frees redo siblings only
+};
+```
+
+### Critical Invariants and Rules
+
+1. `begin()` must reuse `pending` if:
+    - same type
+    - same row
+    - `pending->col + pending->text.size() == current_cursor_col`
+      → otherwise `commit()` old and create new
+
+2. `pending` is detached — never linked until `commit()`
+
+3. `commit()`:
+    - discards redo branches (`current->child`)
+    - attaches `pending` as `current->child`
+    - advances `current`
+    - clears `pending`
+    - if diverged from `saved`, null it
+
+4. `apply()` must use low-level buffer operations:
+    - Never call public insert/delete/newline
+    - Use raw `buffer.insert_text(row, col, text)` and `buffer.delete_text(row, col, len)`
+    - These must not trigger undo
+
+5. `undo()`:
+    - move current to parent
+    - apply(current, -1)
+
+6. `redo()`:
+    - move current to child
+    - apply(current, +1)
+
+7. `discard_pending()` must be called in:
+    - buffer close
+    - file reload
+    - new file
+    - any destructive operation
+
+### Example Flow: Typing "hello"
+
+```text
+begin(Insert) → pending = new node, col=0
+append('h') → pending->text = "h", pending->col = 1
+append('e') → "he", col = 2
+...
+commit() on arrow key → pending becomes current->child, current advances
+```
+
+One undo step removes all of "hello".
+
+### Required Helper in Buffer Class
+
+```cpp
+class Buffer {
+    void insert_text(int row, int col, std::string_view text);   // raw, no undo
+    void delete_text(int row, int col, size_t len);              // raw, no undo
+    void split_line(int row, int col);                           // raw newline
+    void join_lines(int row);                                    // raw join
+    void insert_row(int row, std::string_view text);             // raw
+    void delete_row(int row);                                    // raw
+};
+```
+
+### Tasks for Agent
+
+1. Implement `UndoNode`, `UndoTree`, and `UndoSystem` class exactly as specified.
+2. Add `std::unique_ptr<UndoTree> undo;` to `Buffer`.
+3. Modify `insert_char`, `delete_char`, `paste`, `newline` to use `undo.begin()/append()/commit()`.
+4. Add `undo.commit()` at start of all cursor movement and command functions.
+5. Implement `apply()` using only `Buffer`'s raw methods.
+6. Add `undo.discard_pending()` in all buffer reset/close paths.
+7. Add `Ctrl+Z` → `buffer.undo()`, `Ctrl+Y` → `buffer.redo()`.
+
+This design is used in production editors and is considered the gold standard for small, correct, non-linear undo in
+C/C++. Implement it faithfully.

ext/json_fwd.h

@@ -0,0 +1,185 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+// #include <nlohmann/detail/abi_macros.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+#if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+#if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0
+#warning "Already included a different version of the library!"
+#endif
+#endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 12  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 0   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+#define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_DIAGNOSTIC_POSITIONS
+#define JSON_DIAGNOSTIC_POSITIONS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+#define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+#define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+#define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_DIAGNOSTIC_POSITIONS
+#define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp
+#else
+#define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+#define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+#define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
+#endif
+
+// Construct the namespace ABI tags component
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif
+
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+/// a class to store JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/
+template<template<typename U, typename V, typename... Args> class ObjectType =
+	std::map,
+	template<typename U, typename... Args> class ArrayType = std::vector,
+	class StringType = std::string, class BooleanType = bool,
+	class NumberIntegerType = std::int64_t,
+	class NumberUnsignedType = std::uint64_t,
+	class NumberFloatType = double,
+	template<typename U> class AllocatorType = std::allocator,
+	template<typename T, typename SFINAE = void> class JSONSerializer =
+	adl_serializer,
+	class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
+	class CustomBaseClass = void>
+class basic_json;
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer;
+
+/*!
+@brief default specialization
+@sa https://json.nlohmann.me/api/json/
+*/
+using json = basic_json<>;
+
+/// @brief a minimal map-like container that preserves insertion order
+/// @sa https://json.nlohmann.me/api/ordered_map/
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/// @brief specialization that maintains the insertion order of object keys
+/// @sa https://json.nlohmann.me/api/ordered_json/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
+NLOHMANN_JSON_NAMESPACE_END
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_

flake.nix

@@ -13,9 +13,8 @@
       packages = eachSystem (system: rec {
         default = kte;
         full = kge;
-        kte = (pkgsFor system).callPackage ./default.nix { graphical = false; graphical-qt = false; };
+        kte = (pkgsFor system).callPackage ./default.nix { graphical = false; };
-        kge = (pkgsFor system).callPackage ./default.nix { graphical = true;  graphical-qt = false; };
+        kge = (pkgsFor system).callPackage ./default.nix { graphical = true; };
-        qt  = (pkgsFor system).callPackage ./default.nix { graphical = true;  graphical-qt = true;  };
       });
     };
 }