From 619f731e5e8bf8b1dcc4a304dd4ed98b3a5b76e1 Mon Sep 17 00:00:00 2001
From: Virgil <virgil@lethean.io>
Date: Tue, 31 Mar 2026 05:36:25 +0000
Subject: [PATCH] refactor(ax): align remaining semantic names

Co-Authored-By: Virgil <virgil@lethean.io>
---
 datanode/medium_test.go |  56 +++++++--------
 local/medium_test.go    |  60 ++++++++--------
 medium_test.go          |  58 +++++++--------
 store/medium.go         |   2 +-
 store/medium_test.go    | 156 ++++++++++++++++++++--------------------
 store/store.go          |  26 +++----
 store/store_test.go     |  20 +++---
 7 files changed, 189 insertions(+), 189 deletions(-)

diff --git a/datanode/medium_test.go b/datanode/medium_test.go
index 8d8a5b5..b238e7d 100644
--- a/datanode/medium_test.go
+++ b/datanode/medium_test.go
@@ -13,7 +13,7 @@ import (
 
 var _ coreio.Medium = (*Medium)(nil)
 
-func TestClient_ReadWrite_Good(t *testing.T) {
+func TestDataNode_ReadWrite_Good(t *testing.T) {
 	m := New()
 
 	err := m.Write("hello.txt", "world")
@@ -24,7 +24,7 @@ func TestClient_ReadWrite_Good(t *testing.T) {
 	assert.Equal(t, "world", got)
 }
 
-func TestClient_ReadWrite_Bad(t *testing.T) {
+func TestDataNode_ReadWrite_Bad(t *testing.T) {
 	m := New()
 
 	_, err := m.Read("missing.txt")
@@ -34,7 +34,7 @@ func TestClient_ReadWrite_Bad(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestClient_NestedPaths_Good(t *testing.T) {
+func TestDataNode_NestedPaths_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("a/b/c/deep.txt", "deep"))
@@ -48,7 +48,7 @@ func TestClient_NestedPaths_Good(t *testing.T) {
 	assert.True(t, m.IsDir("a/b/c"))
 }
 
-func TestClient_LeadingSlash_Good(t *testing.T) {
+func TestDataNode_LeadingSlash_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("/leading/file.txt", "stripped"))
@@ -61,7 +61,7 @@ func TestClient_LeadingSlash_Good(t *testing.T) {
 	assert.Equal(t, "stripped", got)
 }
 
-func TestClient_IsFile_Good(t *testing.T) {
+func TestDataNode_IsFile_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("file.go", "package main"))
@@ -71,7 +71,7 @@ func TestClient_IsFile_Good(t *testing.T) {
 	assert.False(t, m.IsFile(""))
 }
 
-func TestClient_EnsureDir_Good(t *testing.T) {
+func TestDataNode_EnsureDir_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.EnsureDir("foo/bar/baz"))
@@ -82,7 +82,7 @@ func TestClient_EnsureDir_Good(t *testing.T) {
 	assert.True(t, m.Exists("foo/bar/baz"))
 }
 
-func TestClient_Delete_Good(t *testing.T) {
+func TestDataNode_Delete_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("delete-me.txt", "bye"))
@@ -92,7 +92,7 @@ func TestClient_Delete_Good(t *testing.T) {
 	assert.False(t, m.Exists("delete-me.txt"))
 }
 
-func TestClient_Delete_Bad(t *testing.T) {
+func TestDataNode_Delete_Bad(t *testing.T) {
 	medium := New()
 
 	assert.Error(t, medium.Delete("ghost.txt"))
@@ -101,7 +101,7 @@ func TestClient_Delete_Bad(t *testing.T) {
 	assert.Error(t, medium.Delete("dir"))
 }
 
-func TestClient_Delete_DirectoryInspectionFailure_Bad(t *testing.T) {
+func TestDataNode_Delete_DirectoryInspectionFailure_Bad(t *testing.T) {
 	m := New()
 	require.NoError(t, m.Write("dir/file.txt", "content"))
 
@@ -118,7 +118,7 @@ func TestClient_Delete_DirectoryInspectionFailure_Bad(t *testing.T) {
 	assert.Contains(t, err.Error(), "failed to inspect directory")
 }
 
-func TestClient_DeleteAll_Good(t *testing.T) {
+func TestDataNode_DeleteAll_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("tree/a.txt", "a"))
@@ -132,7 +132,7 @@ func TestClient_DeleteAll_Good(t *testing.T) {
 	assert.True(t, m.Exists("keep.txt"))
 }
 
-func TestClient_DeleteAll_WalkFailure_Bad(t *testing.T) {
+func TestDataNode_DeleteAll_WalkFailure_Bad(t *testing.T) {
 	m := New()
 	require.NoError(t, m.Write("tree/a.txt", "a"))
 
@@ -149,7 +149,7 @@ func TestClient_DeleteAll_WalkFailure_Bad(t *testing.T) {
 	assert.Contains(t, err.Error(), "failed to inspect tree")
 }
 
-func TestClient_Delete_RemoveFailure_Bad(t *testing.T) {
+func TestDataNode_Delete_RemoveFailure_Bad(t *testing.T) {
 	m := New()
 	require.NoError(t, m.Write("keep.txt", "keep"))
 	require.NoError(t, m.Write("bad.txt", "bad"))
@@ -167,7 +167,7 @@ func TestClient_Delete_RemoveFailure_Bad(t *testing.T) {
 	assert.Contains(t, err.Error(), "failed to delete file")
 }
 
-func TestClient_Rename_Good(t *testing.T) {
+func TestDataNode_Rename_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("old.txt", "content"))
@@ -179,7 +179,7 @@ func TestClient_Rename_Good(t *testing.T) {
 	assert.Equal(t, "content", got)
 }
 
-func TestClient_RenameDir_Good(t *testing.T) {
+func TestDataNode_RenameDir_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("src/a.go", "package a"))
@@ -198,7 +198,7 @@ func TestClient_RenameDir_Good(t *testing.T) {
 	assert.Equal(t, "package b", got)
 }
 
-func TestClient_RenameDir_ReadFailure_Bad(t *testing.T) {
+func TestDataNode_RenameDir_ReadFailure_Bad(t *testing.T) {
 	m := New()
 	require.NoError(t, m.Write("src/a.go", "package a"))
 
@@ -215,7 +215,7 @@ func TestClient_RenameDir_ReadFailure_Bad(t *testing.T) {
 	assert.Contains(t, err.Error(), "failed to read source file")
 }
 
-func TestClient_List_Good(t *testing.T) {
+func TestDataNode_List_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("root.txt", "r"))
@@ -244,7 +244,7 @@ func TestClient_List_Good(t *testing.T) {
 	assert.Contains(t, names, "sub")
 }
 
-func TestClient_Stat_Good(t *testing.T) {
+func TestDataNode_Stat_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("stat.txt", "hello"))
@@ -259,7 +259,7 @@ func TestClient_Stat_Good(t *testing.T) {
 	assert.True(t, info.IsDir())
 }
 
-func TestClient_Open_Good(t *testing.T) {
+func TestDataNode_Open_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("open.txt", "opened"))
@@ -273,7 +273,7 @@ func TestClient_Open_Good(t *testing.T) {
 	assert.Equal(t, "opened", string(data))
 }
 
-func TestClient_CreateAppend_Good(t *testing.T) {
+func TestDataNode_CreateAppend_Good(t *testing.T) {
 	m := New()
 
 	w, err := m.Create("new.txt")
@@ -295,7 +295,7 @@ func TestClient_CreateAppend_Good(t *testing.T) {
 	assert.Equal(t, "hello world", got)
 }
 
-func TestClient_Append_ReadFailure_Bad(t *testing.T) {
+func TestDataNode_Append_ReadFailure_Bad(t *testing.T) {
 	m := New()
 	require.NoError(t, m.Write("new.txt", "hello"))
 
@@ -312,7 +312,7 @@ func TestClient_Append_ReadFailure_Bad(t *testing.T) {
 	assert.Contains(t, err.Error(), "failed to read existing content")
 }
 
-func TestClient_Streams_Good(t *testing.T) {
+func TestDataNode_Streams_Good(t *testing.T) {
 	m := New()
 
 	ws, err := m.WriteStream("stream.txt")
@@ -328,7 +328,7 @@ func TestClient_Streams_Good(t *testing.T) {
 	rs.Close()
 }
 
-func TestClient_FileGetFileSet_Good(t *testing.T) {
+func TestDataNode_FileGetFileSet_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.FileSet("alias.txt", "via set"))
@@ -338,7 +338,7 @@ func TestClient_FileGetFileSet_Good(t *testing.T) {
 	assert.Equal(t, "via set", got)
 }
 
-func TestClient_SnapshotRestore_Good(t *testing.T) {
+func TestDataNode_SnapshotRestore_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("a.txt", "alpha"))
@@ -360,7 +360,7 @@ func TestClient_SnapshotRestore_Good(t *testing.T) {
 	assert.Equal(t, "charlie", got)
 }
 
-func TestClient_Restore_Good(t *testing.T) {
+func TestDataNode_Restore_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("original.txt", "before"))
@@ -380,7 +380,7 @@ func TestClient_Restore_Good(t *testing.T) {
 	assert.False(t, m.Exists("extra.txt"))
 }
 
-func TestClient_DataNode_Good(t *testing.T) {
+func TestDataNode_DataNode_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("test.txt", "borg"))
@@ -397,7 +397,7 @@ func TestClient_DataNode_Good(t *testing.T) {
 	assert.Equal(t, "borg", string(data))
 }
 
-func TestClient_Overwrite_Good(t *testing.T) {
+func TestDataNode_Overwrite_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("file.txt", "v1"))
@@ -408,7 +408,7 @@ func TestClient_Overwrite_Good(t *testing.T) {
 	assert.Equal(t, "v2", got)
 }
 
-func TestClient_Exists_Good(t *testing.T) {
+func TestDataNode_Exists_Good(t *testing.T) {
 	m := New()
 
 	assert.True(t, m.Exists(""))
@@ -418,7 +418,7 @@ func TestClient_Exists_Good(t *testing.T) {
 	assert.True(t, m.Exists("x"))
 }
 
-func TestClient_ReadExistingFile_Good(t *testing.T) {
+func TestDataNode_ReadExistingFile_Good(t *testing.T) {
 	m := New()
 
 	require.NoError(t, m.Write("file.txt", "content"))
diff --git a/local/medium_test.go b/local/medium_test.go
index 9177576..53ddf4d 100644
--- a/local/medium_test.go
+++ b/local/medium_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestClient_New_ResolvesRoot_Good(t *testing.T) {
+func TestLocal_New_ResolvesRoot_Good(t *testing.T) {
 	root := t.TempDir()
 	m, err := New(root)
 	assert.NoError(t, err)
@@ -20,7 +20,7 @@ func TestClient_New_ResolvesRoot_Good(t *testing.T) {
 	assert.Equal(t, resolved, m.filesystemRoot)
 }
 
-func TestClient_Path_Sandboxed_Good(t *testing.T) {
+func TestLocal_Path_Sandboxed_Good(t *testing.T) {
 	m := &Medium{filesystemRoot: "/home/user"}
 
 	assert.Equal(t, "/home/user/file.txt", m.sandboxedPath("file.txt"))
@@ -34,7 +34,7 @@ func TestClient_Path_Sandboxed_Good(t *testing.T) {
 	assert.Equal(t, "/home/user/etc/passwd", m.sandboxedPath("/etc/passwd"))
 }
 
-func TestClient_Path_RootFilesystem_Good(t *testing.T) {
+func TestLocal_Path_RootFilesystem_Good(t *testing.T) {
 	m := &Medium{filesystemRoot: "/"}
 
 	assert.Equal(t, "/etc/passwd", m.sandboxedPath("/etc/passwd"))
@@ -44,7 +44,7 @@ func TestClient_Path_RootFilesystem_Good(t *testing.T) {
 	assert.Equal(t, core.Path(cwd, "file.txt"), m.sandboxedPath("file.txt"))
 }
 
-func TestClient_ReadWrite_Basic_Good(t *testing.T) {
+func TestLocal_ReadWrite_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -66,7 +66,7 @@ func TestClient_ReadWrite_Basic_Good(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestClient_EnsureDir_Basic_Good(t *testing.T) {
+func TestLocal_EnsureDir_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -78,7 +78,7 @@ func TestClient_EnsureDir_Basic_Good(t *testing.T) {
 	assert.True(t, info.IsDir())
 }
 
-func TestClient_IsDir_Basic_Good(t *testing.T) {
+func TestLocal_IsDir_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -91,7 +91,7 @@ func TestClient_IsDir_Basic_Good(t *testing.T) {
 	assert.False(t, m.IsDir(""))
 }
 
-func TestClient_IsFile_Basic_Good(t *testing.T) {
+func TestLocal_IsFile_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -104,7 +104,7 @@ func TestClient_IsFile_Basic_Good(t *testing.T) {
 	assert.False(t, m.IsFile(""))
 }
 
-func TestClient_Exists_Basic_Good(t *testing.T) {
+func TestLocal_Exists_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -114,7 +114,7 @@ func TestClient_Exists_Basic_Good(t *testing.T) {
 	assert.False(t, m.Exists("nope"))
 }
 
-func TestClient_List_Basic_Good(t *testing.T) {
+func TestLocal_List_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -127,7 +127,7 @@ func TestClient_List_Basic_Good(t *testing.T) {
 	assert.Len(t, entries, 3)
 }
 
-func TestClient_Stat_Basic_Good(t *testing.T) {
+func TestLocal_Stat_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -138,7 +138,7 @@ func TestClient_Stat_Basic_Good(t *testing.T) {
 	assert.Equal(t, int64(7), info.Size())
 }
 
-func TestClient_Delete_Basic_Good(t *testing.T) {
+func TestLocal_Delete_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -150,7 +150,7 @@ func TestClient_Delete_Basic_Good(t *testing.T) {
 	assert.False(t, m.Exists("todelete"))
 }
 
-func TestClient_DeleteAll_Basic_Good(t *testing.T) {
+func TestLocal_DeleteAll_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -161,7 +161,7 @@ func TestClient_DeleteAll_Basic_Good(t *testing.T) {
 	assert.False(t, m.Exists("dir"))
 }
 
-func TestClient_Delete_ProtectedHomeViaSymlinkEnv_Bad(t *testing.T) {
+func TestLocal_Delete_ProtectedHomeViaSymlinkEnv_Bad(t *testing.T) {
 	realHome := t.TempDir()
 	linkParent := t.TempDir()
 	homeLink := core.Path(linkParent, "home-link")
@@ -176,7 +176,7 @@ func TestClient_Delete_ProtectedHomeViaSymlinkEnv_Bad(t *testing.T) {
 	assert.DirExists(t, realHome)
 }
 
-func TestClient_DeleteAll_ProtectedHomeViaEnv_Bad(t *testing.T) {
+func TestLocal_DeleteAll_ProtectedHomeViaEnv_Bad(t *testing.T) {
 	tempHome := t.TempDir()
 	t.Setenv("HOME", tempHome)
 
@@ -188,7 +188,7 @@ func TestClient_DeleteAll_ProtectedHomeViaEnv_Bad(t *testing.T) {
 	assert.DirExists(t, tempHome)
 }
 
-func TestClient_Rename_Basic_Good(t *testing.T) {
+func TestLocal_Rename_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -200,7 +200,7 @@ func TestClient_Rename_Basic_Good(t *testing.T) {
 	assert.True(t, m.Exists("new"))
 }
 
-func TestClient_FileGetFileSet_Basic_Good(t *testing.T) {
+func TestLocal_FileGetFileSet_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -212,7 +212,7 @@ func TestClient_FileGetFileSet_Basic_Good(t *testing.T) {
 	assert.Equal(t, "value", val)
 }
 
-func TestClient_Delete_Good(t *testing.T) {
+func TestLocal_Delete_Good(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -233,7 +233,7 @@ func TestClient_Delete_Good(t *testing.T) {
 	assert.False(t, medium.IsDir("emptydir"))
 }
 
-func TestClient_Delete_NotEmpty_Bad(t *testing.T) {
+func TestLocal_Delete_NotEmpty_Bad(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -246,7 +246,7 @@ func TestClient_Delete_NotEmpty_Bad(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestClient_DeleteAll_Good(t *testing.T) {
+func TestLocal_DeleteAll_Good(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -264,7 +264,7 @@ func TestClient_DeleteAll_Good(t *testing.T) {
 	assert.False(t, medium.Exists("mydir/subdir/file2.txt"))
 }
 
-func TestClient_Rename_Good(t *testing.T) {
+func TestLocal_Rename_Good(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -282,7 +282,7 @@ func TestClient_Rename_Good(t *testing.T) {
 	assert.Equal(t, "content", content)
 }
 
-func TestClient_Rename_TraversalSanitised_Good(t *testing.T) {
+func TestLocal_Rename_TraversalSanitised_Good(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -297,7 +297,7 @@ func TestClient_Rename_TraversalSanitised_Good(t *testing.T) {
 	assert.True(t, medium.Exists("escaped.txt"))
 }
 
-func TestClient_List_Good(t *testing.T) {
+func TestLocal_List_Good(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -323,7 +323,7 @@ func TestClient_List_Good(t *testing.T) {
 	assert.True(t, names["subdir"])
 }
 
-func TestClient_Stat_Good(t *testing.T) {
+func TestLocal_Stat_Good(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -345,7 +345,7 @@ func TestClient_Stat_Good(t *testing.T) {
 	assert.True(t, info.IsDir())
 }
 
-func TestClient_Exists_Good(t *testing.T) {
+func TestLocal_Exists_Good(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -362,7 +362,7 @@ func TestClient_Exists_Good(t *testing.T) {
 	assert.True(t, medium.Exists("mydir"))
 }
 
-func TestClient_IsDir_Good(t *testing.T) {
+func TestLocal_IsDir_Good(t *testing.T) {
 	testRoot := t.TempDir()
 
 	medium, err := New(testRoot)
@@ -379,7 +379,7 @@ func TestClient_IsDir_Good(t *testing.T) {
 	assert.False(t, medium.IsDir("nonexistent"))
 }
 
-func TestClient_ReadStream_Basic_Good(t *testing.T) {
+func TestLocal_ReadStream_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -397,7 +397,7 @@ func TestClient_ReadStream_Basic_Good(t *testing.T) {
 	assert.Equal(t, "streaming", string(data))
 }
 
-func TestClient_WriteStream_Basic_Good(t *testing.T) {
+func TestLocal_WriteStream_Basic_Good(t *testing.T) {
 	root := t.TempDir()
 	m, _ := New(root)
 
@@ -414,7 +414,7 @@ func TestClient_WriteStream_Basic_Good(t *testing.T) {
 	assert.Equal(t, "piped data", content)
 }
 
-func TestClient_Path_TraversalSandbox_Good(t *testing.T) {
+func TestLocal_Path_TraversalSandbox_Good(t *testing.T) {
 	m := &Medium{filesystemRoot: "/sandbox"}
 
 	assert.Equal(t, "/sandbox/file.txt", m.sandboxedPath("../../../file.txt"))
@@ -426,7 +426,7 @@ func TestClient_Path_TraversalSandbox_Good(t *testing.T) {
 	assert.Equal(t, "/sandbox/file\x00.txt", m.sandboxedPath("file\x00.txt"))
 }
 
-func TestClient_ValidatePath_SymlinkEscape_Bad(t *testing.T) {
+func TestLocal_ValidatePath_SymlinkEscape_Bad(t *testing.T) {
 	root := t.TempDir()
 	m, err := New(root)
 	assert.NoError(t, err)
@@ -461,7 +461,7 @@ func TestClient_ValidatePath_SymlinkEscape_Bad(t *testing.T) {
 	assert.ErrorIs(t, err, fs.ErrPermission)
 }
 
-func TestClient_EmptyPaths_Good(t *testing.T) {
+func TestLocal_EmptyPaths_Good(t *testing.T) {
 	root := t.TempDir()
 	m, err := New(root)
 	assert.NoError(t, err)
diff --git a/medium_test.go b/medium_test.go
index 9c36152..bb57ed0 100644
--- a/medium_test.go
+++ b/medium_test.go
@@ -44,7 +44,7 @@ func TestMemoryMedium_NewDirEntry_Good(t *testing.T) {
 	assert.Equal(t, int64(8), entryInfo.Size())
 }
 
-func TestClient_MockMedium_Read_Good(t *testing.T) {
+func TestMockMedium_Read_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["test.txt"] = "hello world"
 	content, err := m.Read("test.txt")
@@ -52,13 +52,13 @@ func TestClient_MockMedium_Read_Good(t *testing.T) {
 	assert.Equal(t, "hello world", content)
 }
 
-func TestClient_MockMedium_Read_Bad(t *testing.T) {
+func TestMockMedium_Read_Bad(t *testing.T) {
 	m := NewMockMedium()
 	_, err := m.Read("nonexistent.txt")
 	assert.Error(t, err)
 }
 
-func TestClient_MockMedium_Write_Good(t *testing.T) {
+func TestMockMedium_Write_Good(t *testing.T) {
 	m := NewMockMedium()
 	err := m.Write("test.txt", "content")
 	assert.NoError(t, err)
@@ -69,7 +69,7 @@ func TestClient_MockMedium_Write_Good(t *testing.T) {
 	assert.Equal(t, "new content", m.files["test.txt"])
 }
 
-func TestClient_MockMedium_WriteMode_Good(t *testing.T) {
+func TestMockMedium_WriteMode_Good(t *testing.T) {
 	m := NewMockMedium()
 
 	err := m.WriteMode("secure.txt", "secret", 0600)
@@ -80,14 +80,14 @@ func TestClient_MockMedium_WriteMode_Good(t *testing.T) {
 	assert.Equal(t, "secret", content)
 }
 
-func TestClient_MockMedium_EnsureDir_Good(t *testing.T) {
+func TestMockMedium_EnsureDir_Good(t *testing.T) {
 	m := NewMockMedium()
 	err := m.EnsureDir("/path/to/dir")
 	assert.NoError(t, err)
 	assert.True(t, m.dirs["/path/to/dir"])
 }
 
-func TestClient_MockMedium_IsFile_Good(t *testing.T) {
+func TestMockMedium_IsFile_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["exists.txt"] = "content"
 
@@ -95,7 +95,7 @@ func TestClient_MockMedium_IsFile_Good(t *testing.T) {
 	assert.False(t, m.IsFile("nonexistent.txt"))
 }
 
-func TestClient_MockMedium_FileGet_Good(t *testing.T) {
+func TestMockMedium_FileGet_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["test.txt"] = "content"
 	content, err := m.FileGet("test.txt")
@@ -103,14 +103,14 @@ func TestClient_MockMedium_FileGet_Good(t *testing.T) {
 	assert.Equal(t, "content", content)
 }
 
-func TestClient_MockMedium_FileSet_Good(t *testing.T) {
+func TestMockMedium_FileSet_Good(t *testing.T) {
 	m := NewMockMedium()
 	err := m.FileSet("test.txt", "content")
 	assert.NoError(t, err)
 	assert.Equal(t, "content", m.files["test.txt"])
 }
 
-func TestClient_MockMedium_Delete_Good(t *testing.T) {
+func TestMockMedium_Delete_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["test.txt"] = "content"
 
@@ -119,13 +119,13 @@ func TestClient_MockMedium_Delete_Good(t *testing.T) {
 	assert.False(t, m.IsFile("test.txt"))
 }
 
-func TestClient_MockMedium_Delete_NotFound_Bad(t *testing.T) {
+func TestMockMedium_Delete_NotFound_Bad(t *testing.T) {
 	m := NewMockMedium()
 	err := m.Delete("nonexistent.txt")
 	assert.Error(t, err)
 }
 
-func TestClient_MockMedium_Delete_DirNotEmpty_Bad(t *testing.T) {
+func TestMockMedium_Delete_DirNotEmpty_Bad(t *testing.T) {
 	m := NewMockMedium()
 	m.dirs["mydir"] = true
 	m.files["mydir/file.txt"] = "content"
@@ -134,7 +134,7 @@ func TestClient_MockMedium_Delete_DirNotEmpty_Bad(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestClient_MockMedium_DeleteAll_Good(t *testing.T) {
+func TestMockMedium_DeleteAll_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.dirs["mydir"] = true
 	m.dirs["mydir/subdir"] = true
@@ -147,7 +147,7 @@ func TestClient_MockMedium_DeleteAll_Good(t *testing.T) {
 	assert.Empty(t, m.files)
 }
 
-func TestClient_MockMedium_Rename_Good(t *testing.T) {
+func TestMockMedium_Rename_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["old.txt"] = "content"
 
@@ -158,7 +158,7 @@ func TestClient_MockMedium_Rename_Good(t *testing.T) {
 	assert.Equal(t, "content", m.files["new.txt"])
 }
 
-func TestClient_MockMedium_Rename_Dir_Good(t *testing.T) {
+func TestMockMedium_Rename_Dir_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.dirs["olddir"] = true
 	m.files["olddir/file.txt"] = "content"
@@ -170,7 +170,7 @@ func TestClient_MockMedium_Rename_Dir_Good(t *testing.T) {
 	assert.Equal(t, "content", m.files["newdir/file.txt"])
 }
 
-func TestClient_MockMedium_List_Good(t *testing.T) {
+func TestMockMedium_List_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.dirs["mydir"] = true
 	m.files["mydir/file1.txt"] = "content1"
@@ -190,7 +190,7 @@ func TestClient_MockMedium_List_Good(t *testing.T) {
 	assert.True(t, names["subdir"])
 }
 
-func TestClient_MockMedium_Stat_Good(t *testing.T) {
+func TestMockMedium_Stat_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["test.txt"] = "hello world"
 
@@ -201,7 +201,7 @@ func TestClient_MockMedium_Stat_Good(t *testing.T) {
 	assert.False(t, info.IsDir())
 }
 
-func TestClient_MockMedium_Stat_Dir_Good(t *testing.T) {
+func TestMockMedium_Stat_Dir_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.dirs["mydir"] = true
 
@@ -211,7 +211,7 @@ func TestClient_MockMedium_Stat_Dir_Good(t *testing.T) {
 	assert.True(t, info.IsDir())
 }
 
-func TestClient_MockMedium_Exists_Good(t *testing.T) {
+func TestMockMedium_Exists_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["file.txt"] = "content"
 	m.dirs["mydir"] = true
@@ -221,7 +221,7 @@ func TestClient_MockMedium_Exists_Good(t *testing.T) {
 	assert.False(t, m.Exists("nonexistent"))
 }
 
-func TestClient_MockMedium_IsDir_Good(t *testing.T) {
+func TestMockMedium_IsDir_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["file.txt"] = "content"
 	m.dirs["mydir"] = true
@@ -231,7 +231,7 @@ func TestClient_MockMedium_IsDir_Good(t *testing.T) {
 	assert.False(t, m.IsDir("nonexistent"))
 }
 
-func TestClient_MockMedium_StreamAndFSHelpers_Good(t *testing.T) {
+func TestMockMedium_StreamAndFSHelpers_Good(t *testing.T) {
 	m := NewMockMedium()
 	require.NoError(t, m.EnsureDir("dir"))
 	require.NoError(t, m.Write("dir/file.txt", "alpha"))
@@ -293,7 +293,7 @@ func TestClient_MockMedium_StreamAndFSHelpers_Good(t *testing.T) {
 	assert.Equal(t, "stream output", m.files["streamed.txt"])
 }
 
-func TestClient_Read_Good(t *testing.T) {
+func TestIO_Read_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["test.txt"] = "hello"
 	content, err := Read(m, "test.txt")
@@ -301,21 +301,21 @@ func TestClient_Read_Good(t *testing.T) {
 	assert.Equal(t, "hello", content)
 }
 
-func TestClient_Write_Good(t *testing.T) {
+func TestIO_Write_Good(t *testing.T) {
 	m := NewMockMedium()
 	err := Write(m, "test.txt", "hello")
 	assert.NoError(t, err)
 	assert.Equal(t, "hello", m.files["test.txt"])
 }
 
-func TestClient_EnsureDir_Good(t *testing.T) {
+func TestIO_EnsureDir_Good(t *testing.T) {
 	m := NewMockMedium()
 	err := EnsureDir(m, "/my/dir")
 	assert.NoError(t, err)
 	assert.True(t, m.dirs["/my/dir"])
 }
 
-func TestClient_IsFile_Good(t *testing.T) {
+func TestIO_IsFile_Good(t *testing.T) {
 	m := NewMockMedium()
 	m.files["exists.txt"] = "content"
 
@@ -323,7 +323,7 @@ func TestClient_IsFile_Good(t *testing.T) {
 	assert.False(t, IsFile(m, "nonexistent.txt"))
 }
 
-func TestClient_NewSandboxed_Good(t *testing.T) {
+func TestIO_NewSandboxed_Good(t *testing.T) {
 	root := t.TempDir()
 
 	m, err := NewSandboxed(root)
@@ -337,7 +337,7 @@ func TestClient_NewSandboxed_Good(t *testing.T) {
 	assert.True(t, m.IsDir("config"))
 }
 
-func TestClient_ReadWriteStream_Good(t *testing.T) {
+func TestIO_ReadWriteStream_Good(t *testing.T) {
 	m := NewMockMedium()
 
 	writer, err := WriteStream(m, "logs/run.txt")
@@ -354,7 +354,7 @@ func TestClient_ReadWriteStream_Good(t *testing.T) {
 	require.NoError(t, reader.Close())
 }
 
-func TestClient_Copy_Good(t *testing.T) {
+func TestIO_Copy_Good(t *testing.T) {
 	source := NewMockMedium()
 	dest := NewMockMedium()
 	source.files["test.txt"] = "hello"
@@ -368,14 +368,14 @@ func TestClient_Copy_Good(t *testing.T) {
 	assert.Equal(t, "content", dest.files["copied.txt"])
 }
 
-func TestClient_Copy_Bad(t *testing.T) {
+func TestIO_Copy_Bad(t *testing.T) {
 	source := NewMockMedium()
 	dest := NewMockMedium()
 	err := Copy(source, "nonexistent.txt", dest, "dest.txt")
 	assert.Error(t, err)
 }
 
-func TestClient_LocalGlobal_Good(t *testing.T) {
+func TestIO_LocalGlobal_Good(t *testing.T) {
 	assert.NotNil(t, Local, "io.Local should be initialised")
 
 	var m = Local
diff --git a/store/medium.go b/store/medium.go
index 96c2384..5d492be 100644
--- a/store/medium.go
+++ b/store/medium.go
@@ -151,7 +151,7 @@ func (medium *Medium) List(entryPath string) ([]fs.DirEntry, error) {
 	group, key := splitGroupKeyPath(entryPath)
 
 	if group == "" {
-		rows, err := medium.store.database.Query("SELECT DISTINCT grp FROM kv ORDER BY grp")
+		rows, err := medium.store.database.Query("SELECT DISTINCT group_name FROM entries ORDER BY group_name")
 		if err != nil {
 			return nil, core.E("store.List", "query groups", err)
 		}
diff --git a/store/medium_test.go b/store/medium_test.go
index e5d9410..a82fac0 100644
--- a/store/medium_test.go
+++ b/store/medium_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func newTestMedium(t *testing.T) *Medium {
+func newTestKeyValueMedium(t *testing.T) *Medium {
 	t.Helper()
 	m, err := NewMedium(Options{Path: ":memory:"})
 	require.NoError(t, err)
@@ -17,8 +17,8 @@ func newTestMedium(t *testing.T) *Medium {
 	return m
 }
 
-func TestMedium_Medium_ReadWrite_Good(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_ReadWrite_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 
 	err := m.Write("config/theme", "dark")
 	require.NoError(t, err)
@@ -28,56 +28,56 @@ func TestMedium_Medium_ReadWrite_Good(t *testing.T) {
 	assert.Equal(t, "dark", val)
 }
 
-func TestMedium_Medium_Read_NoKey_Bad(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_Read_NoKey_Bad(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 	_, err := m.Read("config")
 	assert.Error(t, err)
 }
 
-func TestMedium_Medium_Read_NotFound_Bad(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_Read_NotFound_Bad(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 	_, err := m.Read("config/missing")
 	assert.Error(t, err)
 }
 
-func TestMedium_Medium_IsFile_Good(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/key", "val")
+func TestKeyValueMedium_IsFile_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/key", "val")
 
-	assert.True(t, m.IsFile("grp/key"))
-	assert.False(t, m.IsFile("grp/nope"))
-	assert.False(t, m.IsFile("grp"))
+	assert.True(t, m.IsFile("group/key"))
+	assert.False(t, m.IsFile("group/nope"))
+	assert.False(t, m.IsFile("group"))
 }
 
-func TestMedium_Medium_Delete_Good(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/key", "val")
+func TestKeyValueMedium_Delete_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/key", "val")
 
-	err := m.Delete("grp/key")
+	err := m.Delete("group/key")
 	require.NoError(t, err)
-	assert.False(t, m.IsFile("grp/key"))
+	assert.False(t, m.IsFile("group/key"))
 }
 
-func TestMedium_Medium_Delete_NonEmptyGroup_Bad(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/key", "val")
+func TestKeyValueMedium_Delete_NonEmptyGroup_Bad(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/key", "val")
 
-	err := m.Delete("grp")
+	err := m.Delete("group")
 	assert.Error(t, err)
 }
 
-func TestMedium_Medium_DeleteAll_Good(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/a", "1")
-	_ = m.Write("grp/b", "2")
+func TestKeyValueMedium_DeleteAll_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/a", "1")
+	_ = m.Write("group/b", "2")
 
-	err := m.DeleteAll("grp")
+	err := m.DeleteAll("group")
 	require.NoError(t, err)
-	assert.False(t, m.Exists("grp"))
+	assert.False(t, m.Exists("group"))
 }
 
-func TestMedium_Medium_Rename_Good(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_Rename_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 	_ = m.Write("old/key", "val")
 
 	err := m.Rename("old/key", "new/key")
@@ -89,8 +89,8 @@ func TestMedium_Medium_Rename_Good(t *testing.T) {
 	assert.False(t, m.IsFile("old/key"))
 }
 
-func TestMedium_Medium_List_Groups_Good(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_List_Groups_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 	_ = m.Write("alpha/a", "1")
 	_ = m.Write("beta/b", "2")
 
@@ -107,46 +107,46 @@ func TestMedium_Medium_List_Groups_Good(t *testing.T) {
 	assert.True(t, names["beta"])
 }
 
-func TestMedium_Medium_List_Keys_Good(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/a", "1")
-	_ = m.Write("grp/b", "22")
+func TestKeyValueMedium_List_Keys_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/a", "1")
+	_ = m.Write("group/b", "22")
 
-	entries, err := m.List("grp")
+	entries, err := m.List("group")
 	require.NoError(t, err)
 	assert.Len(t, entries, 2)
 }
 
-func TestMedium_Medium_Stat_Good(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/key", "hello")
+func TestKeyValueMedium_Stat_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/key", "hello")
 
-	info, err := m.Stat("grp")
+	info, err := m.Stat("group")
 	require.NoError(t, err)
 	assert.True(t, info.IsDir())
 
-	info, err = m.Stat("grp/key")
+	info, err = m.Stat("group/key")
 	require.NoError(t, err)
 	assert.Equal(t, int64(5), info.Size())
 	assert.False(t, info.IsDir())
 }
 
-func TestMedium_Medium_Exists_IsDir_Good(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/key", "val")
+func TestKeyValueMedium_Exists_IsDir_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/key", "val")
 
-	assert.True(t, m.Exists("grp"))
-	assert.True(t, m.Exists("grp/key"))
-	assert.True(t, m.IsDir("grp"))
-	assert.False(t, m.IsDir("grp/key"))
+	assert.True(t, m.Exists("group"))
+	assert.True(t, m.Exists("group/key"))
+	assert.True(t, m.IsDir("group"))
+	assert.False(t, m.IsDir("group/key"))
 	assert.False(t, m.Exists("nope"))
 }
 
-func TestMedium_Medium_Open_Read_Good(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/key", "hello world")
+func TestKeyValueMedium_Open_Read_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/key", "hello world")
 
-	f, err := m.Open("grp/key")
+	f, err := m.Open("group/key")
 	require.NoError(t, err)
 	defer f.Close()
 
@@ -155,83 +155,83 @@ func TestMedium_Medium_Open_Read_Good(t *testing.T) {
 	assert.Equal(t, "hello world", string(data))
 }
 
-func TestMedium_Medium_CreateClose_Good(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_CreateClose_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 
-	w, err := m.Create("grp/key")
+	w, err := m.Create("group/key")
 	require.NoError(t, err)
 	_, _ = w.Write([]byte("streamed"))
 	require.NoError(t, w.Close())
 
-	val, err := m.Read("grp/key")
+	val, err := m.Read("group/key")
 	require.NoError(t, err)
 	assert.Equal(t, "streamed", val)
 }
 
-func TestMedium_Medium_Append_Good(t *testing.T) {
-	m := newTestMedium(t)
-	_ = m.Write("grp/key", "hello")
+func TestKeyValueMedium_Append_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
+	_ = m.Write("group/key", "hello")
 
-	w, err := m.Append("grp/key")
+	w, err := m.Append("group/key")
 	require.NoError(t, err)
 	_, _ = w.Write([]byte(" world"))
 	require.NoError(t, w.Close())
 
-	val, err := m.Read("grp/key")
+	val, err := m.Read("group/key")
 	require.NoError(t, err)
 	assert.Equal(t, "hello world", val)
 }
 
-func TestMedium_Medium_AsMedium_Good(t *testing.T) {
+func TestKeyValueMedium_AsMedium_Good(t *testing.T) {
 	s := newTestStore(t)
 
 	m := s.AsMedium()
-	require.NoError(t, m.Write("grp/key", "val"))
+	require.NoError(t, m.Write("group/key", "val"))
 
-	val, err := s.Get("grp", "key")
+	val, err := s.Get("group", "key")
 	require.NoError(t, err)
 	assert.Equal(t, "val", val)
 
-	val, err = m.Read("grp/key")
+	val, err = m.Read("group/key")
 	require.NoError(t, err)
 	assert.Equal(t, "val", val)
 }
 
-func TestMedium_Medium_Store_Good(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_Store_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 
 	assert.NotNil(t, m.Store())
 	assert.Same(t, m.Store(), m.Store())
 }
 
-func TestMedium_Medium_EnsureDir_FileHelpers_Good(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_EnsureDir_FileHelpers_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 
 	require.NoError(t, m.EnsureDir("ignored"))
-	require.NoError(t, m.FileSet("grp/key", "value"))
+	require.NoError(t, m.FileSet("group/key", "value"))
 
-	value, err := m.FileGet("grp/key")
+	value, err := m.FileGet("group/key")
 	require.NoError(t, err)
 	assert.Equal(t, "value", value)
 }
 
-func TestMedium_Medium_StreamHelpers_Good(t *testing.T) {
-	m := newTestMedium(t)
+func TestKeyValueMedium_StreamHelpers_Good(t *testing.T) {
+	m := newTestKeyValueMedium(t)
 
-	writer, err := m.WriteStream("grp/key")
+	writer, err := m.WriteStream("group/key")
 	require.NoError(t, err)
 	_, err = writer.Write([]byte("streamed"))
 	require.NoError(t, err)
 	require.NoError(t, writer.Close())
 
-	reader, err := m.ReadStream("grp/key")
+	reader, err := m.ReadStream("group/key")
 	require.NoError(t, err)
 	data, err := io.ReadAll(reader)
 	require.NoError(t, err)
 	assert.Equal(t, "streamed", string(data))
 	require.NoError(t, reader.Close())
 
-	file, err := m.Open("grp/key")
+	file, err := m.Open("group/key")
 	require.NoError(t, err)
 	info, err := file.Stat()
 	require.NoError(t, err)
@@ -243,7 +243,7 @@ func TestMedium_Medium_StreamHelpers_Good(t *testing.T) {
 	assert.Nil(t, info.Sys())
 	require.NoError(t, file.Close())
 
-	entries, err := m.List("grp")
+	entries, err := m.List("group")
 	require.NoError(t, err)
 	require.Len(t, entries, 1)
 	assert.Equal(t, "key", entries[0].Name())
diff --git a/store/store.go b/store/store.go
index 2f15491..65b36a2 100644
--- a/store/store.go
+++ b/store/store.go
@@ -37,11 +37,11 @@ func New(options Options) (*Store, error) {
 		database.Close()
 		return nil, core.E("store.New", "WAL mode", err)
 	}
-	if _, err := database.Exec(`CREATE TABLE IF NOT EXISTS kv (
-		grp   TEXT NOT NULL,
-		key   TEXT NOT NULL,
-		value TEXT NOT NULL,
-		PRIMARY KEY (grp, key)
+	if _, err := database.Exec(`CREATE TABLE IF NOT EXISTS entries (
+		group_name TEXT NOT NULL,
+		entry_key  TEXT NOT NULL,
+		entry_value TEXT NOT NULL,
+		PRIMARY KEY (group_name, entry_key)
 	)`); err != nil {
 		database.Close()
 		return nil, core.E("store.New", "create schema", err)
@@ -57,7 +57,7 @@ func (store *Store) Close() error {
 // Example: theme, _ := keyValueStore.Get("app", "theme")
 func (store *Store) Get(group, key string) (string, error) {
 	var value string
-	err := store.database.QueryRow("SELECT value FROM kv WHERE grp = ? AND key = ?", group, key).Scan(&value)
+	err := store.database.QueryRow("SELECT entry_value FROM entries WHERE group_name = ? AND entry_key = ?", group, key).Scan(&value)
 	if err == sql.ErrNoRows {
 		return "", core.E("store.Get", core.Concat("not found: ", group, "/", key), NotFoundError)
 	}
@@ -70,8 +70,8 @@ func (store *Store) Get(group, key string) (string, error) {
 // Example: _ = keyValueStore.Set("app", "theme", "midnight")
 func (store *Store) Set(group, key, value string) error {
 	_, err := store.database.Exec(
-		`INSERT INTO kv (grp, key, value) VALUES (?, ?, ?)
-		 ON CONFLICT(grp, key) DO UPDATE SET value = excluded.value`,
+		`INSERT INTO entries (group_name, entry_key, entry_value) VALUES (?, ?, ?)
+		 ON CONFLICT(group_name, entry_key) DO UPDATE SET entry_value = excluded.entry_value`,
 		group, key, value,
 	)
 	if err != nil {
@@ -82,7 +82,7 @@ func (store *Store) Set(group, key, value string) error {
 
 // Example: _ = keyValueStore.Delete("app", "theme")
 func (store *Store) Delete(group, key string) error {
-	_, err := store.database.Exec("DELETE FROM kv WHERE grp = ? AND key = ?", group, key)
+	_, err := store.database.Exec("DELETE FROM entries WHERE group_name = ? AND entry_key = ?", group, key)
 	if err != nil {
 		return core.E("store.Delete", "exec", err)
 	}
@@ -92,7 +92,7 @@ func (store *Store) Delete(group, key string) error {
 // Example: count, _ := keyValueStore.Count("app")
 func (store *Store) Count(group string) (int, error) {
 	var count int
-	err := store.database.QueryRow("SELECT COUNT(*) FROM kv WHERE grp = ?", group).Scan(&count)
+	err := store.database.QueryRow("SELECT COUNT(*) FROM entries WHERE group_name = ?", group).Scan(&count)
 	if err != nil {
 		return 0, core.E("store.Count", "query", err)
 	}
@@ -101,7 +101,7 @@ func (store *Store) Count(group string) (int, error) {
 
 // Example: _ = keyValueStore.DeleteGroup("app")
 func (store *Store) DeleteGroup(group string) error {
-	_, err := store.database.Exec("DELETE FROM kv WHERE grp = ?", group)
+	_, err := store.database.Exec("DELETE FROM entries WHERE group_name = ?", group)
 	if err != nil {
 		return core.E("store.DeleteGroup", "exec", err)
 	}
@@ -110,7 +110,7 @@ func (store *Store) DeleteGroup(group string) error {
 
 // Example: values, _ := keyValueStore.GetAll("app")
 func (store *Store) GetAll(group string) (map[string]string, error) {
-	rows, err := store.database.Query("SELECT key, value FROM kv WHERE grp = ?", group)
+	rows, err := store.database.Query("SELECT entry_key, entry_value FROM entries WHERE group_name = ?", group)
 	if err != nil {
 		return nil, core.E("store.GetAll", "query", err)
 	}
@@ -134,7 +134,7 @@ func (store *Store) GetAll(group string) (map[string]string, error) {
 // Example: _ = keyValueStore.Set("user", "name", "alice")
 // Example: out, _ := keyValueStore.Render("hello {{ .name }}", "user")
 func (store *Store) Render(templateText, group string) (string, error) {
-	rows, err := store.database.Query("SELECT key, value FROM kv WHERE grp = ?", group)
+	rows, err := store.database.Query("SELECT entry_key, entry_value FROM entries WHERE group_name = ?", group)
 	if err != nil {
 		return "", core.E("store.Render", "query", err)
 	}
diff --git a/store/store_test.go b/store/store_test.go
index f30af61..74df399 100644
--- a/store/store_test.go
+++ b/store/store_test.go
@@ -60,11 +60,11 @@ func TestStore_Delete_Good(t *testing.T) {
 func TestStore_Count_Good(t *testing.T) {
 	s := newTestStore(t)
 
-	_ = s.Set("grp", "a", "1")
-	_ = s.Set("grp", "b", "2")
+	_ = s.Set("group", "a", "1")
+	_ = s.Set("group", "b", "2")
 	_ = s.Set("other", "c", "3")
 
-	n, err := s.Count("grp")
+	n, err := s.Count("group")
 	require.NoError(t, err)
 	assert.Equal(t, 2, n)
 }
@@ -72,23 +72,23 @@ func TestStore_Count_Good(t *testing.T) {
 func TestStore_DeleteGroup_Good(t *testing.T) {
 	s := newTestStore(t)
 
-	_ = s.Set("grp", "a", "1")
-	_ = s.Set("grp", "b", "2")
-	err := s.DeleteGroup("grp")
+	_ = s.Set("group", "a", "1")
+	_ = s.Set("group", "b", "2")
+	err := s.DeleteGroup("group")
 	require.NoError(t, err)
 
-	n, _ := s.Count("grp")
+	n, _ := s.Count("group")
 	assert.Equal(t, 0, n)
 }
 
 func TestStore_GetAll_Good(t *testing.T) {
 	s := newTestStore(t)
 
-	_ = s.Set("grp", "a", "1")
-	_ = s.Set("grp", "b", "2")
+	_ = s.Set("group", "a", "1")
+	_ = s.Set("group", "b", "2")
 	_ = s.Set("other", "c", "3")
 
-	all, err := s.GetAll("grp")
+	all, err := s.GetAll("group")
 	require.NoError(t, err)
 	assert.Equal(t, map[string]string{"a": "1", "b": "2"}, all)
 }