diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index 1e1944d..094804d 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -87,7 +87,7 @@ jobs:
       - name: Unit + integration tests with coverage
         shell: bash
         run: |
-          go test ./test/unit/... ./test/integration/... -race \
+          go test ./internal/app/ ./test/unit/... ./test/integration/... -race \
             -coverpkg=./internal/... -coverprofile=cover.out
 
       # e2e builds a real binary and drives it under Xvfb -- Linux-only by
@@ -105,9 +105,7 @@ jobs:
         if: runner.os == 'Linux'
         shell: bash
         env:
-          # TODO: ratchet this to 80 (the target in doc/ci-cd-setup.md) once
-          # the suite gets there. Measured at 77.8% when this gate was added.
-          MIN_COVERAGE: '75'
+          MIN_COVERAGE: '80'
         run: |
           pct=$(go tool cover -func=cover.out | tail -1 | grep -oE '[0-9]+\.[0-9]+' | head -1)
           echo "Total line coverage: ${pct}% (minimum: ${MIN_COVERAGE}%)"
diff --git a/doc/developer.md b/doc/developer.md
index 3831471..f8453b6 100644
--- a/doc/developer.md
+++ b/doc/developer.md
@@ -282,7 +282,7 @@ rationale (and the not-yet-implemented publishing channels) is in
 ### Coverage gate
 
 `pr.yml` fails if total line coverage over `internal/...` drops below
-**75%** (`MIN_COVERAGE` in the workflow). Coverage comes from the unit +
+**80%** (`MIN_COVERAGE` in the workflow). Coverage comes from the unit +
 integration tiers only — e2e drives a separately-compiled binary, so its
 execution isn't visible to `-coverpkg` (see §6).
 
diff --git a/src/internal/app/icon_test.go b/src/internal/app/icon_test.go
new file mode 100644
index 0000000..fd509ef
--- /dev/null
+++ b/src/internal/app/icon_test.go
@@ -0,0 +1,74 @@
+package editorapp
+
+import (
+	"image"
+	"testing"
+
+	"gioui.org/io/key"
+	"gioui.org/io/pointer"
+
+	"github.com/kgfly/SimpleNvimEditor/internal/config"
+)
+
+func TestAppIcon(t *testing.T) {
+	img := appIcon()
+	if img == nil {
+		t.Fatal("appIcon returned nil")
+	}
+	b := img.Bounds()
+	if b.Dx() == 0 || b.Dy() == 0 {
+		t.Fatalf("appIcon returned empty image: %v", b)
+	}
+}
+
+func TestNewApp(t *testing.T) {
+	cfg := config.Default()
+	a := New(cfg, []string{"file1.go", "file2.go"})
+	if a == nil {
+		t.Fatal("New returned nil")
+	}
+	if a.state == nil {
+		t.Fatal("New should initialize state")
+	}
+	if len(a.files) != 2 {
+		t.Fatalf("files = %v, want 2 entries", a.files)
+	}
+}
+
+func TestQuitWithNilProc(t *testing.T) {
+	a := New(config.Default(), nil)
+	// Should not panic.
+	a.quit()
+}
+
+func TestOnKeyWithNilProc(t *testing.T) {
+	a := New(config.Default(), nil)
+	a.onKey(key.Event{Name: "A", State: key.Press})
+}
+
+func TestOnEditWithNilProc(t *testing.T) {
+	a := New(config.Default(), nil)
+	a.onEdit(key.EditEvent{Text: "hello"})
+}
+
+func TestOnPointerWithNilProc(t *testing.T) {
+	a := New(config.Default(), nil)
+	a.onPointer(pointer.Event{Kind: pointer.Press, Buttons: pointer.ButtonPrimary})
+}
+
+func TestCaretWithZeroMetrics(t *testing.T) {
+	a := New(config.Default(), nil)
+	c := a.caret()
+	if c.Ascent != 0 || c.Descent != 0 {
+		t.Fatalf("caret with zero metrics should be zero, got %+v", c)
+	}
+}
+
+func TestSyncSizeWithZeroCellDims(t *testing.T) {
+	a := New(config.Default(), nil)
+	// CellWidth and CellHeight are 0, should return early.
+	a.syncSize(image.Pt(800, 600))
+	if a.proc != nil {
+		t.Fatal("syncSize should not start nvim with zero cell dims")
+	}
+}
diff --git a/src/internal/app/ime_test.go b/src/internal/app/ime_test.go
new file mode 100644
index 0000000..bf04b1f
--- /dev/null
+++ b/src/internal/app/ime_test.go
@@ -0,0 +1,173 @@
+package editorapp
+
+import (
+	"testing"
+
+	"gioui.org/io/key"
+)
+
+func TestNewIMEShadow(t *testing.T) {
+	s := newIMEShadow()
+	if s.composing() {
+		t.Fatal("new shadow should not be composing")
+	}
+	if got := s.snippet(); got.Text != "" {
+		t.Fatalf("new shadow snippet = %q, want empty", got.Text)
+	}
+	if got := s.composingText(); got != "" {
+		t.Fatalf("new shadow composingText = %q, want empty", got)
+	}
+}
+
+func TestIMEReset(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "hello")
+	s.setComposing(key.Range{Start: 0, End: 5})
+	s.reset()
+	if s.composing() {
+		t.Fatal("composing should be false after reset")
+	}
+	if len(s.text) != 0 {
+		t.Fatalf("text should be empty after reset, got %d runes", len(s.text))
+	}
+}
+
+func TestIMEReplaceInsert(t *testing.T) {
+	s := newIMEShadow()
+	displaced := s.replace(key.Range{}, "hello")
+	if displaced != 0 {
+		t.Fatalf("insert displaced %d, want 0", displaced)
+	}
+	if got := s.snippet().Text; got != "hello" {
+		t.Fatalf("text = %q, want %q", got, "hello")
+	}
+	if s.sel.Start != 5 || s.sel.End != 5 {
+		t.Fatalf("sel = %+v, want {5,5}", s.sel)
+	}
+}
+
+func TestIMEReplaceOverwrite(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "hello world")
+	displaced := s.replace(key.Range{Start: 0, End: 5}, "hi")
+	if displaced != 5 {
+		t.Fatalf("displaced = %d, want 5", displaced)
+	}
+	if got := s.snippet().Text; got != "hi world" {
+		t.Fatalf("text = %q, want %q", got, "hi world")
+	}
+}
+
+func TestIMESetComposingAndComposingText(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "hello")
+	s.setComposing(key.Range{Start: 0, End: 5})
+	if !s.composing() {
+		t.Fatal("should be composing")
+	}
+	if got := s.composingText(); got != "hello" {
+		t.Fatalf("composingText = %q, want %q", got, "hello")
+	}
+}
+
+func TestIMESetComposingNegativeClears(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "hello")
+	s.setComposing(key.Range{Start: 0, End: 5})
+	s.setComposing(key.Range{Start: -1, End: -1})
+	if s.composing() {
+		t.Fatal("negative start should clear composing")
+	}
+}
+
+func TestIMESetSelection(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "hello")
+	s.setSelection(key.Range{Start: 2, End: 4})
+	if s.sel.Start != 2 || s.sel.End != 4 {
+		t.Fatalf("sel = %+v, want {2,4}", s.sel)
+	}
+}
+
+func TestIMEClampReversedRange(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "ab")
+	r := s.clamp(key.Range{Start: 2, End: 0})
+	if r.Start != 0 || r.End != 2 {
+		t.Fatalf("clamp reversed = %+v, want {0,2}", r)
+	}
+}
+
+func TestIMEClampOutOfBounds(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "ab")
+	r := s.clamp(key.Range{Start: -5, End: 100})
+	if r.Start != 0 || r.End != 2 {
+		t.Fatalf("clamp oob = %+v, want {0,2}", r)
+	}
+}
+
+func TestIMESnippet(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "test")
+	snip := s.snippet()
+	if snip.Range.Start != 0 || snip.Range.End != 4 {
+		t.Fatalf("snippet range = %+v, want {0,4}", snip.Range)
+	}
+	if snip.Text != "test" {
+		t.Fatalf("snippet text = %q, want %q", snip.Text, "test")
+	}
+}
+
+func TestIMETrimIfIdle(t *testing.T) {
+	s := newIMEShadow()
+	// Fill buffer beyond maxShadowRunes.
+	big := make([]rune, maxShadowRunes+1)
+	for i := range big {
+		big[i] = 'x'
+	}
+	s.text = big
+	s.trimIfIdle()
+	if len(s.text) != 0 {
+		t.Fatalf("trimIfIdle should empty oversized idle buffer, got %d", len(s.text))
+	}
+}
+
+func TestIMETrimIfIdleSkipsComposing(t *testing.T) {
+	s := newIMEShadow()
+	big := make([]rune, maxShadowRunes+1)
+	for i := range big {
+		big[i] = 'x'
+	}
+	s.text = big
+	s.setComposing(key.Range{Start: 0, End: 10})
+	s.trimIfIdle()
+	if len(s.text) == 0 {
+		t.Fatal("trimIfIdle should not empty buffer while composing")
+	}
+}
+
+func TestIMETrimIfIdleSmallBuffer(t *testing.T) {
+	s := newIMEShadow()
+	s.replace(key.Range{}, "small")
+	s.trimIfIdle()
+	if s.snippet().Text != "small" {
+		t.Fatal("trimIfIdle should not touch small buffers")
+	}
+}
+
+func TestClampInt(t *testing.T) {
+	cases := []struct {
+		v, lo, hi, want int
+	}{
+		{5, 0, 10, 5},
+		{-1, 0, 10, 0},
+		{15, 0, 10, 10},
+		{0, 0, 0, 0},
+	}
+	for _, c := range cases {
+		if got := clampInt(c.v, c.lo, c.hi); got != c.want {
+			t.Errorf("clampInt(%d, %d, %d) = %d, want %d", c.v, c.lo, c.hi, got, c.want)
+		}
+	}
+}
diff --git a/src/test/unit/config_test.go b/src/test/unit/config_test.go
index 704c3f4..93f8509 100644
--- a/src/test/unit/config_test.go
+++ b/src/test/unit/config_test.go
@@ -189,3 +189,113 @@ func TestDefaultFontFamilyForOSNeverEmpty(t *testing.T) {
 		t.Fatalf("DefaultFontFamilyForOS() returned empty string")
 	}
 }
+
+func TestLoadExplicitZeroFontSizeAndEmptyCommand(t *testing.T) {
+	withIsolatedConfigDir(t)
+
+	path, err := config.FilePath()
+	if err != nil {
+		t.Fatalf("FilePath() error = %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatalf("MkdirAll: %v", err)
+	}
+	toml := `
+[editor]
+font_size = 0
+
+[nvim]
+command = ""
+`
+	if err := os.WriteFile(path, []byte(toml), 0o644); err != nil {
+		t.Fatalf("WriteFile: %v", err)
+	}
+
+	cfg, err := config.Load()
+	if err != nil {
+		t.Fatalf("Load() error = %v", err)
+	}
+	if cfg.Editor.FontSize != config.Default().Editor.FontSize {
+		t.Errorf("zero FontSize should fall back to default, got %v", cfg.Editor.FontSize)
+	}
+	if cfg.Nvim.Command != config.Default().Nvim.Command {
+		t.Errorf("empty Command should fall back to default, got %q", cfg.Nvim.Command)
+	}
+}
+
+func TestLoadNegativeFontSize(t *testing.T) {
+	withIsolatedConfigDir(t)
+
+	path, err := config.FilePath()
+	if err != nil {
+		t.Fatalf("FilePath() error = %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatalf("MkdirAll: %v", err)
+	}
+	if err := os.WriteFile(path, []byte("[editor]\nfont_size = -5\n"), 0o644); err != nil {
+		t.Fatalf("WriteFile: %v", err)
+	}
+
+	cfg, err := config.Load()
+	if err != nil {
+		t.Fatalf("Load() error = %v", err)
+	}
+	if cfg.Editor.FontSize != config.Default().Editor.FontSize {
+		t.Errorf("negative FontSize should fall back to default, got %v", cfg.Editor.FontSize)
+	}
+}
+
+func TestLoadUnreadableFile(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("chmod does not restrict reads on Windows")
+	}
+	withIsolatedConfigDir(t)
+
+	path, err := config.FilePath()
+	if err != nil {
+		t.Fatalf("FilePath() error = %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatalf("MkdirAll: %v", err)
+	}
+	if err := os.WriteFile(path, []byte("[editor]\n"), 0o644); err != nil {
+		t.Fatalf("WriteFile: %v", err)
+	}
+	if err := os.Chmod(path, 0o000); err != nil {
+		t.Skipf("cannot chmod on this platform: %v", err)
+	}
+	t.Cleanup(func() { os.Chmod(path, 0o644) })
+
+	_, err = config.Load()
+	if err == nil {
+		t.Fatal("Load() with unreadable file should return an error")
+	}
+}
+
+func TestLoadSameFontFamilyAsDefault(t *testing.T) {
+	withIsolatedConfigDir(t)
+
+	path, err := config.FilePath()
+	if err != nil {
+		t.Fatalf("FilePath() error = %v", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatalf("MkdirAll: %v", err)
+	}
+	// Set font_family to the same as default — UseSystemFonts should NOT be set.
+	toml := `[editor]
+font_family = "monospace"
+`
+	if err := os.WriteFile(path, []byte(toml), 0o644); err != nil {
+		t.Fatalf("WriteFile: %v", err)
+	}
+
+	cfg, err := config.Load()
+	if err != nil {
+		t.Fatalf("Load() error = %v", err)
+	}
+	if cfg.Editor.UseSystemFonts {
+		t.Error("UseSystemFonts should not be set when font_family == default")
+	}
+}
diff --git a/src/test/unit/coverage_test.go b/src/test/unit/coverage_test.go
new file mode 100644
index 0000000..ed86d7f
--- /dev/null
+++ b/src/test/unit/coverage_test.go
@@ -0,0 +1,602 @@
+package unit_test
+
+import (
+	"image/color"
+	"testing"
+
+	"github.com/kgfly/SimpleNvimEditor/internal/config"
+	"github.com/kgfly/SimpleNvimEditor/internal/uistate"
+)
+
+func nrgba(r, g, b uint8) color.NRGBA {
+	return color.NRGBA{R: r, G: g, B: b, A: 0xff}
+}
+
+// Exercise the len(t)<N guard paths and uncommon branches.
+
+func TestApplyGridResizeTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	// Only 2 elements instead of 3; should be silently ignored.
+	s.Apply(batch(ev("grid_resize", args(1, 10))))
+	if len(s.Snapshot().Grids) != 0 {
+		t.Fatal("malformed grid_resize should not create a grid")
+	}
+}
+
+func TestApplyGridLineTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("grid_resize", args(1, 5, 1)),
+		ev("grid_line", args(1, 0, 0)), // missing cells array
+	))
+	// Should not panic; row stays blank.
+	for _, cell := range s.Snapshot().Grids[1].Data[0] {
+		if cell.Text != " " {
+			t.Fatalf("cell = %q, want blank", cell.Text)
+		}
+	}
+}
+
+func TestApplyGridClearTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	// Empty tuple for grid_clear; should not panic.
+	s.Apply(batch(ev("grid_clear")))
+}
+
+func TestApplyGridDestroyTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("grid_destroy")))
+}
+
+func TestApplyGridScrollTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("grid_resize", args(1, 5, 5)),
+		ev("grid_scroll", args(1, 0, 5, 0)), // only 4 args, need 7
+	))
+}
+
+func TestGridScrollWithRegion(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("grid_resize", args(1, 4, 4))))
+	for r := 0; r < 4; r++ {
+		for c := 0; c < 4; c++ {
+			marker := string(rune('a' + r*4 + c))
+			s.Apply(batch(ev("grid_line", args(1, r, c, []interface{}{[]interface{}{marker}}))))
+		}
+	}
+
+	// Scroll only columns [1,3) of rows [1,3) up by 1.
+	s.Apply(batch(ev("grid_scroll", args(1, 1, 3, 1, 3, 1, 0))))
+
+	g := s.Snapshot().Grids[1]
+	// Row 1 cols 1-2 should have content from row 2 cols 1-2.
+	if got := g.Data[1][1].Text; got != "j" {
+		t.Fatalf("data[1][1] = %q, want %q", got, "j")
+	}
+	// Row 2 cols 1-2 should be blanked.
+	if got := g.Data[2][1].Text; got != " " {
+		t.Fatalf("data[2][1] = %q, want blank", got)
+	}
+	// Row 1 col 0 (outside scroll region) should be unchanged.
+	if got := g.Data[1][0].Text; got != "e" {
+		t.Fatalf("data[1][0] = %q, want %q (untouched by scroll)", got, "e")
+	}
+}
+
+func TestGridScrollNegativeWithRegion(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("grid_resize", args(1, 3, 4))))
+	for r := 0; r < 4; r++ {
+		marker := string(rune('a' + r))
+		s.Apply(batch(ev("grid_line", args(1, r, 0, []interface{}{[]interface{}{marker}}))))
+	}
+
+	// Scroll rows [1,3) down by 1 (negative rowsBy).
+	s.Apply(batch(ev("grid_scroll", args(1, 1, 3, 0, 3, -1, 0))))
+
+	g := s.Snapshot().Grids[1]
+	// Row 1 should be blanked (newly exposed).
+	if got := g.Data[1][0].Text; got != " " {
+		t.Fatalf("data[1][0] = %q, want blank", got)
+	}
+	// Row 2 should have what was in row 1.
+	if got := g.Data[2][0].Text; got != "b" {
+		t.Fatalf("data[2][0] = %q, want %q", got, "b")
+	}
+	// Row 0 should be untouched (outside region).
+	if got := g.Data[0][0].Text; got != "a" {
+		t.Fatalf("data[0][0] = %q, want %q", got, "a")
+	}
+}
+
+func TestGridLineEmptyTuple(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("grid_resize", args(1, 5, 1)),
+		ev("grid_line", args(1, 0, 0, []interface{}{
+			[]interface{}{}, // empty cell tuple
+			[]interface{}{"a"},
+		})),
+	))
+	// Empty tuple should be skipped; "a" goes at col 0 (since empty was skipped).
+	if got := s.Snapshot().Grids[1].Data[0][0].Text; got != "a" {
+		t.Fatalf("cell[0][0] = %q, want %q", got, "a")
+	}
+}
+
+func TestGridLineColBeyondWidth(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("grid_resize", args(1, 2, 1)),
+		ev("grid_line", args(1, 0, 0, []interface{}{
+			[]interface{}{"x", 0, 5}, // repeat 5 into a 2-wide grid
+		})),
+	))
+	g := s.Snapshot().Grids[1]
+	if g.Data[0][0].Text != "x" || g.Data[0][1].Text != "x" {
+		t.Fatalf("visible cells wrong: %+v", g.Data[0])
+	}
+}
+
+func TestApplyWinPosTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("win_pos", args(2, 0, 1)))) // need 6 args
+	if len(s.Snapshot().Windows) != 0 {
+		t.Fatal("malformed win_pos should not create a placement")
+	}
+}
+
+func TestApplyWinFloatPosTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("win_float_pos", args(2, 0)))) // need 6 args
+	if len(s.Snapshot().Windows) != 0 {
+		t.Fatal("malformed win_float_pos should not create a placement")
+	}
+}
+
+func TestApplyWinFloatPosDerivesSize(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("grid_resize", args(5, 20, 10)),
+		ev("win_float_pos", args(5, 0, "NW", 1, 2, 3, true)),
+	))
+	snap := s.Snapshot()
+	found := false
+	for _, w := range snap.Windows {
+		if w.GridID == 5 {
+			found = true
+			if w.Width != 20 || w.Height != 10 {
+				t.Fatalf("float size = %dx%d, want 20x10", w.Width, w.Height)
+			}
+			if !w.Float {
+				t.Fatal("expected Float=true")
+			}
+		}
+	}
+	if !found {
+		t.Fatal("float window placement not found")
+	}
+}
+
+func TestApplyWinFloatPosNoGrid(t *testing.T) {
+	s := uistate.New()
+	// Float pos for grid that doesn't exist yet — width/height should be 0.
+	s.Apply(batch(ev("win_float_pos", args(99, 0, "NW", 1, 0, 0, true))))
+	for _, w := range s.Snapshot().Windows {
+		if w.GridID == 99 {
+			if w.Width != 0 || w.Height != 0 {
+				t.Fatalf("expected 0x0 for unknown grid, got %dx%d", w.Width, w.Height)
+			}
+			return
+		}
+	}
+	t.Fatal("placement for grid 99 not found")
+}
+
+func TestApplyWinHideTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("win_hide"))) // no args
+}
+
+func TestApplyWinCloseTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("win_close"))) // no args
+}
+
+func TestApplyWinCloseEmptyInvocation(t *testing.T) {
+	s := uistate.New()
+	// Invocation with empty tuple — len < 1 guard.
+	s.Apply(batch([]interface{}{"win_close", []interface{}{}}))
+}
+
+func TestApplyWinCloseNonexistentGrid(t *testing.T) {
+	s := uistate.New()
+	// Close a grid that was never placed.
+	s.Apply(batch(ev("win_close", args(999))))
+}
+
+func TestApplyMsgSetPosTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("msg_set_pos", args(1)))) // need 2 args
+}
+
+func TestApplyGridCursorGotoTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("grid_cursor_goto", args(1, 0)))) // need 3
+}
+
+func TestApplyModeInfoSetTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("mode_info_set", args(true)))) // need 2
+}
+
+func TestApplyModeChangeTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("mode_change", args("normal")))) // need 2
+}
+
+func TestApplySetTitleEmptyArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("set_title"))) // no args
+	if s.Snapshot().Title != "" {
+		t.Fatal("empty set_title should not change title")
+	}
+}
+
+func TestApplySetTitleNonSliceRow(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("set_title", args(42)))) // non-[]interface{} row
+	if s.Snapshot().Title != "" {
+		t.Fatal("non-slice set_title should not change title")
+	}
+}
+
+func TestApplySetTitleEmptySliceRow(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("set_title", []interface{}{})))
+	if s.Snapshot().Title != "" {
+		t.Fatal("empty row should not change title")
+	}
+}
+
+func TestApplyHlAttrDefineTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("hl_attr_define", args(1)))) // need 2 (id + map)
+}
+
+func TestApplyDefaultColorsSetTooFewArgs(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("default_colors_set", args(0xFF0000, 0x000000)))) // need 3
+}
+
+func TestCurrentModeInfoOutOfBounds(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("mode_info_set", args(true, []interface{}{
+			map[string]interface{}{"cursor_shape": "vertical", "cell_percentage": int64(25)},
+		})),
+		ev("mode_change", args("normal", int64(99))), // index out of bounds
+	))
+	info := s.Snapshot().CurrentModeInfo()
+	// Out-of-bounds falls back to the default block cursor.
+	if info.CursorShape != "block" || info.CellPercentage != 100 {
+		t.Fatalf("out-of-bounds mode index should return default block, got %+v", info)
+	}
+}
+
+func TestCurrentModeInfoDefaultFallback(t *testing.T) {
+	s := uistate.New()
+	// No mode_info_set or mode_change sent.
+	info := s.Snapshot().CurrentModeInfo()
+	// Defaults to a block cursor per the function's doc.
+	if info.CursorShape != "block" || info.CellPercentage != 100 {
+		t.Fatalf("default ModeInfo should be block/100, got %+v", info)
+	}
+}
+
+func TestApplyBusyStartStopToggle(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("busy_start")))
+	if !s.Snapshot().Busy {
+		t.Fatal("expected Busy=true after busy_start")
+	}
+	s.Apply(batch(ev("busy_stop")))
+	if s.Snapshot().Busy {
+		t.Fatal("expected Busy=false after busy_stop")
+	}
+}
+
+func TestApplySetTitleColonStrip(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("set_title", args("Dir:sub myfile.go"))))
+	got := s.Snapshot().Title
+	if got != "myfile.go" {
+		t.Fatalf("title = %q, want %q", got, "myfile.go")
+	}
+}
+
+func TestApplySetTitleNoColon(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("set_title", args("myfile.go"))))
+	got := s.Snapshot().Title
+	if got != "myfile.go" {
+		t.Fatalf("title = %q, want %q", got, "myfile.go")
+	}
+}
+
+func TestApplySetTitleColonNoSpace(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("set_title", args("file:nospace"))))
+	got := s.Snapshot().Title
+	if got == "" {
+		t.Fatal("title should not be empty")
+	}
+}
+
+func TestGridScrollClampsNegativeRegion(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("grid_resize", args(1, 3, 3))))
+	for r := 0; r < 3; r++ {
+		s.Apply(batch(ev("grid_line", args(1, r, 0, []interface{}{[]interface{}{string(rune('a' + r))}}))))
+	}
+	// Negative top/left, oversized bot/right — should be clamped.
+	s.Apply(batch(ev("grid_scroll", args(1, -5, 99, -5, 99, 1, 0))))
+	g := s.Snapshot().Grids[1]
+	// Effectively scrolls the full grid up by 1.
+	if g.Data[0][0].Text != "b" {
+		t.Fatalf("data[0][0] = %q, want %q", g.Data[0][0].Text, "b")
+	}
+	if g.Data[2][0].Text != " " {
+		t.Fatalf("data[2][0] = %q, want blank", g.Data[2][0].Text)
+	}
+}
+
+func TestGridScrollLargeRowsByClamps(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("grid_resize", args(1, 1, 3))))
+	for r := 0; r < 3; r++ {
+		s.Apply(batch(ev("grid_line", args(1, r, 0, []interface{}{[]interface{}{string(rune('x' + r))}}))))
+	}
+	// rowsBy larger than region — should blank everything.
+	s.Apply(batch(ev("grid_scroll", args(1, 0, 3, 0, 1, 100, 0))))
+	g := s.Snapshot().Grids[1]
+	for r := 0; r < 3; r++ {
+		if g.Data[r][0].Text != " " {
+			t.Fatalf("data[%d][0] = %q, want blank", r, g.Data[r][0].Text)
+		}
+	}
+}
+
+func TestApplyWinHideNonexistentGrid(t *testing.T) {
+	s := uistate.New()
+	// Hide a grid that was never placed — should not panic.
+	s.Apply(batch(ev("win_hide", args(999))))
+}
+
+func TestApplyWinHideEmptyInvocation(t *testing.T) {
+	s := uistate.New()
+	// Invocation with empty tuple — len < 1 guard.
+	s.Apply(batch([]interface{}{"win_hide", []interface{}{}}))
+}
+
+func TestApplyGridDestroyEmptyInvocation(t *testing.T) {
+	s := uistate.New()
+	// Invocation with empty tuple — len < 1 guard.
+	s.Apply(batch([]interface{}{"grid_destroy", []interface{}{}}))
+}
+
+func TestApplyGridClearEmptyInvocation(t *testing.T) {
+	s := uistate.New()
+	// grid_clear with empty invocation tuple.
+	s.Apply(batch([]interface{}{"grid_clear", []interface{}{}}))
+}
+
+func TestApplyGridDestroyNonexistentGrid(t *testing.T) {
+	s := uistate.New()
+	// Destroy a grid that doesn't exist — should not panic.
+	s.Apply(batch(ev("grid_destroy", args(999))))
+}
+
+func TestGridLineNegativeColStart(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("grid_resize", args(1, 5, 1)),
+		// Negative col start: first cells should be skipped, then write at valid cols.
+		ev("grid_line", args(1, 0, -2, []interface{}{
+			[]interface{}{"a"},
+			[]interface{}{"b"},
+			[]interface{}{"c"},
+			[]interface{}{"d"},
+		})),
+	))
+	g := s.Snapshot().Grids[1]
+	// col -2 and -1 are out of bounds (skipped), col 0 gets "c", col 1 gets "d".
+	if g.Data[0][0].Text != "c" {
+		t.Fatalf("data[0][0] = %q, want %q", g.Data[0][0].Text, "c")
+	}
+	if g.Data[0][1].Text != "d" {
+		t.Fatalf("data[0][1] = %q, want %q", g.Data[0][1].Text, "d")
+	}
+}
+
+func TestApplyMsgSetPosWithNegativeRow(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("grid_resize", args(5, 10, 2)),
+		ev("msg_set_pos", args(5, -1, false, "~")),
+	))
+	snap := s.Snapshot()
+	// With row=-1, the placement is hidden, so it shouldn't appear in Windows.
+	for _, w := range snap.Windows {
+		if w.GridID == 5 {
+			t.Fatal("msg_set_pos with row=-1 should be hidden (not in Windows)")
+		}
+	}
+}
+
+func TestApplyMsgSetPosWithPositiveRow(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("grid_resize", args(5, 10, 2)),
+		ev("msg_set_pos", args(5, 3, false, "~")),
+	))
+	snap := s.Snapshot()
+	found := false
+	for _, w := range snap.Windows {
+		if w.GridID == 5 {
+			found = true
+			if w.Row != 3 {
+				t.Fatalf("row = %d, want 3", w.Row)
+			}
+			if !w.Float {
+				t.Fatal("msg_set_pos placements should be Float=true")
+			}
+		}
+	}
+	if !found {
+		t.Fatal("msg_set_pos should produce a visible placement")
+	}
+}
+
+func TestToIntAllTypes(t *testing.T) {
+	s := uistate.New()
+	// Use different integer encodings that exercise toInt branches.
+	// int64 (standard msgpack)
+	s.Apply(batch(ev("grid_resize", args(int64(1), int64(5), int64(3)))))
+	g := s.Snapshot().Grids[1]
+	if g.Cols != 5 || g.Rows != 3 {
+		t.Fatalf("int64: cols=%d rows=%d, want 5x3", g.Cols, g.Rows)
+	}
+	// uint64
+	s.Apply(batch(ev("grid_resize", args(uint64(2), uint64(4), uint64(2)))))
+	g2 := s.Snapshot().Grids[2]
+	if g2.Cols != 4 || g2.Rows != 2 {
+		t.Fatalf("uint64: cols=%d rows=%d, want 4x2", g2.Cols, g2.Rows)
+	}
+	// int
+	s.Apply(batch(ev("grid_resize", args(3, 6, 1))))
+	g3 := s.Snapshot().Grids[3]
+	if g3.Cols != 6 || g3.Rows != 1 {
+		t.Fatalf("int: cols=%d rows=%d, want 6x1", g3.Cols, g3.Rows)
+	}
+	// Non-numeric (default branch → 0): use a string for grid_id.
+	// This should create grid 0 with 0x0 size (all convert to 0).
+	s.Apply(batch(ev("grid_resize", args("not_a_number", "foo", "bar"))))
+	g0 := s.Snapshot().Grids[0]
+	if g0.Cols != 0 || g0.Rows != 0 {
+		t.Fatalf("default: cols=%d rows=%d, want 0x0", g0.Cols, g0.Rows)
+	}
+}
+
+func TestDefaultFontFamilyForOS(t *testing.T) {
+	// Just verify it returns a non-empty string on any platform.
+	f := config.DefaultFontFamilyForOS()
+	if f == "" {
+		t.Fatal("DefaultFontFamilyForOS returned empty string")
+	}
+}
+
+func TestHighlightResolveReverseSwapsColors(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("default_colors_set", args(int64(0xffffff), int64(0x000000), int64(0))),
+		ev("hl_attr_define", args(int64(1), map[string]interface{}{
+			"foreground": int64(0xff0000),
+			"background": int64(0x00ff00),
+			"reverse":    true,
+		})),
+	))
+	snap := s.Snapshot()
+	fg, bg := snap.Highlight.Resolve(1)
+	// Reverse swaps fg and bg.
+	if fg.R != 0x00 || fg.G != 0xff {
+		t.Fatalf("reversed fg = %+v, want green", fg)
+	}
+	if bg.R != 0xff || bg.G != 0x00 {
+		t.Fatalf("reversed bg = %+v, want red", bg)
+	}
+}
+
+func TestHighlightDefaultColors(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("default_colors_set", args(int64(0xaabbcc), int64(0x112233), int64(0))),
+	))
+	snap := s.Snapshot()
+	fg, bg := snap.Highlight.DefaultColors()
+	if fg.R != 0xaa || fg.G != 0xbb || fg.B != 0xcc {
+		t.Fatalf("default fg = %+v, want 0xaabbcc", fg)
+	}
+	if bg.R != 0x11 || bg.G != 0x22 || bg.B != 0x33 {
+		t.Fatalf("default bg = %+v, want 0x112233", bg)
+	}
+}
+
+func TestHighlightAttrBoolFlags(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("hl_attr_define", args(int64(2), map[string]interface{}{
+			"bold":          true,
+			"italic":        true,
+			"underline":     true,
+			"undercurl":     true,
+			"strikethrough": true,
+		})),
+	))
+	attr := s.Snapshot().Highlight.Attr(2)
+	if !attr.Bold || !attr.Italic || !attr.Underline || !attr.Undercurl || !attr.Strike {
+		t.Fatalf("attr flags = %+v, expected all true", attr)
+	}
+}
+
+func TestHighlightResolveUnknownIDReturnsDefaults(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("default_colors_set", args(int64(0xffffff), int64(0x000000), int64(0))),
+	))
+	fg, bg := s.Snapshot().Highlight.Resolve(999)
+	if fg.R != 0xff || fg.G != 0xff || fg.B != 0xff {
+		t.Fatalf("unknown hlID fg = %+v, want white", fg)
+	}
+	if bg.R != 0x00 || bg.G != 0x00 || bg.B != 0x00 {
+		t.Fatalf("unknown hlID bg = %+v, want black", bg)
+	}
+}
+
+func TestHighlightSpecialColor(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(
+		ev("hl_attr_define", args(int64(3), map[string]interface{}{
+			"special": int64(0x0000ff),
+		})),
+	))
+	// Just verify the attr was stored without panicking; Special is
+	// an internal field used by undercurl rendering.
+	_ = s.Snapshot().Highlight.Attr(3)
+}
+
+func TestGridScrollPartialRegionDown(t *testing.T) {
+	s := uistate.New()
+	s.Apply(batch(ev("grid_resize", args(1, 4, 5))))
+	for r := 0; r < 5; r++ {
+		for c := 0; c < 4; c++ {
+			m := string(rune('A' + r*4 + c))
+			s.Apply(batch(ev("grid_line", args(1, r, c, []interface{}{[]interface{}{m}}))))
+		}
+	}
+	// Scroll columns [2,4) of rows [1,4) down by 2.
+	s.Apply(batch(ev("grid_scroll", args(1, 1, 4, 2, 4, -2, 0))))
+	g := s.Snapshot().Grids[1]
+	// Rows 1-2 cols 2-3 should be blanked (newly exposed).
+	if g.Data[1][2].Text != " " {
+		t.Fatalf("data[1][2] = %q, want blank", g.Data[1][2].Text)
+	}
+	if g.Data[2][2].Text != " " {
+		t.Fatalf("data[2][2] = %q, want blank", g.Data[2][2].Text)
+	}
+	// Row 3 cols 2-3 should have old row 1 cols 2-3 content.
+	if g.Data[3][2].Text != "G" {
+		t.Fatalf("data[3][2] = %q, want %q", g.Data[3][2].Text, "G")
+	}
+}
diff --git a/src/test/unit/render_test.go b/src/test/unit/render_test.go
index ad4fc2c..57751b7 100644
--- a/src/test/unit/render_test.go
+++ b/src/test/unit/render_test.go
@@ -245,3 +245,82 @@ func TestFrameWithPlacedSplitWindow(t *testing.T) {
 	})
 	runFrame(t, s.Snapshot())
 }
+
+func TestGridOriginBaseGrid(t *testing.T) {
+	snap := uistate.New().Snapshot()
+	pt, ok := render.GridOrigin(snap, 1, render.Metrics{CellWidth: 8, CellHeight: 16})
+	if !ok {
+		t.Fatal("GridOrigin for grid 1 should always return true")
+	}
+	if pt.X != 0 || pt.Y != 0 {
+		t.Fatalf("GridOrigin(1) = %v, want (0,0)", pt)
+	}
+}
+
+func TestGridOriginPlacedGrid(t *testing.T) {
+	s := uistate.New()
+	s.Apply([][]interface{}{
+		{"grid_resize", []interface{}{1, 80, 24}},
+		{"grid_resize", []interface{}{2, 40, 12}},
+		{"win_pos", []interface{}{2, 0, 3, 5, 40, 12}},
+	})
+	m := render.Metrics{CellWidth: 8, CellHeight: 16}
+	pt, ok := render.GridOrigin(s.Snapshot(), 2, m)
+	if !ok {
+		t.Fatal("GridOrigin should find placed grid")
+	}
+	if pt.X != 5*8 || pt.Y != 3*16 {
+		t.Fatalf("GridOrigin(2) = %v, want (%d,%d)", pt, 5*8, 3*16)
+	}
+}
+
+func TestGridOriginUnplacedGrid(t *testing.T) {
+	snap := uistate.New().Snapshot()
+	_, ok := render.GridOrigin(snap, 99, render.Metrics{CellWidth: 8, CellHeight: 16})
+	if ok {
+		t.Fatal("GridOrigin should return false for unplaced grid")
+	}
+}
+
+func TestFontFaceWeightSuffixes(t *testing.T) {
+	cases := []struct {
+		family   string
+		wantFace string
+	}{
+		{"Hack Thin", "Hack"},
+		{"Hack ExtraLight", "Hack"},
+		{"Hack Light", "Hack"},
+		{"Hack Medium", "Hack"},
+		{"Hack SemiBold", "Hack"},
+		{"Hack Bold", "Hack"},
+		{"Hack ExtraBold", "Hack"},
+		{"Hack Black", "Hack"},
+		{"Hack", "Hack"},
+	}
+	for _, c := range cases {
+		f := render.FontFace(config.EditorConfig{UseSystemFonts: true, FontFamily: c.family})
+		if string(f.Typeface) != c.wantFace {
+			t.Errorf("FontFace(%q).Typeface = %q, want %q", c.family, f.Typeface, c.wantFace)
+		}
+	}
+}
+
+func TestFrameWindowWithMissingGrid(t *testing.T) {
+	// A placement references a grid that was never resized/created. The
+	// "if !ok { continue }" branch in Frame should handle this gracefully.
+	s := uistate.New()
+	s.Apply([][]interface{}{
+		{"grid_resize", []interface{}{1, 40, 20}},
+		// Place grid 7 which doesn't exist — exercises the continue branch.
+		{"win_pos", []interface{}{7, 0, 0, 0, 10, 5}},
+	})
+	runFrame(t, s.Snapshot())
+}
+
+func TestFrameNoBaseGrid(t *testing.T) {
+	// State with no grid 1 at all — the "if base, ok" branch is false.
+	snap := uistate.Snapshot{
+		Highlight: uistate.New().Snapshot().Highlight,
+	}
+	runFrame(t, snap)
+}
diff --git a/src/test/unit/text_test.go b/src/test/unit/text_test.go
new file mode 100644
index 0000000..445f2a4
--- /dev/null
+++ b/src/test/unit/text_test.go
@@ -0,0 +1,117 @@
+package unit_test
+
+import (
+	"testing"
+
+	"gioui.org/io/key"
+
+	"github.com/kgfly/SimpleNvimEditor/internal/input"
+)
+
+func TestIsTextKeyPressOnly(t *testing.T) {
+	e := key.Event{Name: "A", State: key.Release}
+	if input.IsTextKey(e) {
+		t.Fatal("release events should not be text keys")
+	}
+}
+
+func TestIsTextKeyCtrlSuppresses(t *testing.T) {
+	for _, mod := range []key.Modifiers{key.ModCtrl, key.ModCommand, key.ModSuper} {
+		e := key.Event{Name: "A", State: key.Press, Modifiers: mod}
+		if input.IsTextKey(e) {
+			t.Fatalf("modifier %v should suppress text key", mod)
+		}
+	}
+}
+
+func TestIsTextKeySpaceIsText(t *testing.T) {
+	e := key.Event{Name: key.NameSpace, State: key.Press}
+	if !input.IsTextKey(e) {
+		t.Fatal("Space should be a text key")
+	}
+}
+
+func TestIsTextKeyNamedKeysNotText(t *testing.T) {
+	names := []key.Name{
+		key.NameEscape, key.NameReturn, key.NameTab,
+		key.NameLeftArrow, key.NameHome, key.NameF1,
+		key.NameDeleteBackward, key.NameDeleteForward,
+	}
+	for _, n := range names {
+		e := key.Event{Name: n, State: key.Press}
+		if input.IsTextKey(e) {
+			t.Fatalf("%v should not be a text key", n)
+		}
+	}
+}
+
+func TestIsTextKeyPrintableRune(t *testing.T) {
+	cases := []struct {
+		name key.Name
+		want bool
+	}{
+		{"A", true},
+		{"1", true},
+		{"≈", true},
+		{"!", true},
+	}
+	for _, c := range cases {
+		e := key.Event{Name: c.name, State: key.Press}
+		if got := input.IsTextKey(e); got != c.want {
+			t.Errorf("IsTextKey(%q) = %v, want %v", c.name, got, c.want)
+		}
+	}
+}
+
+func TestIsTextKeyShiftAndAltAllowed(t *testing.T) {
+	e := key.Event{Name: "A", State: key.Press, Modifiers: key.ModShift}
+	if !input.IsTextKey(e) {
+		t.Fatal("Shift+letter should be a text key")
+	}
+	e = key.Event{Name: "≈", State: key.Press, Modifiers: key.ModAlt}
+	if !input.IsTextKey(e) {
+		t.Fatal("Alt+rune should be a text key")
+	}
+}
+
+func TestIsTextKeyEmptyName(t *testing.T) {
+	e := key.Event{Name: "", State: key.Press}
+	if input.IsTextKey(e) {
+		t.Fatal("empty name should not be a text key")
+	}
+}
+
+func TestEncodeText(t *testing.T) {
+	cases := []struct {
+		in, want string
+	}{
+		{"hello", "hello"},
+		{"<", "<lt>"},
+		{"a<b", "a<lt>b"},
+		{"<<", "<lt><lt>"},
+		{"no special", "no special"},
+		{"", ""},
+	}
+	for _, c := range cases {
+		if got := input.EncodeText(c.in); got != c.want {
+			t.Errorf("EncodeText(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}
+
+func TestBackspaces(t *testing.T) {
+	cases := []struct {
+		n    int
+		want string
+	}{
+		{0, ""},
+		{-1, ""},
+		{1, "<BS>"},
+		{3, "<BS><BS><BS>"},
+	}
+	for _, c := range cases {
+		if got := input.Backspaces(c.n); got != c.want {
+			t.Errorf("Backspaces(%d) = %q, want %q", c.n, got, c.want)
+		}
+	}
+}